commit fdb4e4cd363323829ebf0fd12172e4e5c6755652
Author: agibert <agibert>
Date:   Wed Nov 12 02:25:22 2008 +0000

    Initial creation.

diff --git a/GNU-FDL.txt b/GNU-FDL.txt
new file mode 100644
index 0000000..b42936b
--- /dev/null
+++ b/GNU-FDL.txt
@@ -0,0 +1,355 @@
+		GNU Free Documentation License
+		   Version 1.1, March 2000
+
+ Copyright (C) 2000  Free Software Foundation, Inc.
+     59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+0. PREAMBLE
+
+The purpose of this License is to make a manual, textbook, or other
+written document "free" in the sense of freedom: to assure everyone
+the effective freedom to copy and redistribute it, with or without
+modifying it, either commercially or noncommercially.  Secondarily,
+this License preserves for the author and publisher a way to get
+credit for their work, while not being considered responsible for
+modifications made by others.
+
+This License is a kind of "copyleft", which means that derivative
+works of the document must themselves be free in the same sense.  It
+complements the GNU General Public License, which is a copyleft
+license designed for free software.
+
+We have designed this License in order to use it for manuals for free
+software, because free software needs free documentation: a free
+program should come with manuals providing the same freedoms that the
+software does.  But this License is not limited to software manuals;
+it can be used for any textual work, regardless of subject matter or
+whether it is published as a printed book.  We recommend this License
+principally for works whose purpose is instruction or reference.
+
+
+1. APPLICABILITY AND DEFINITIONS
+
+This License applies to any manual or other work that contains a
+notice placed by the copyright holder saying it can be distributed
+under the terms of this License.  The "Document", below, refers to any
+such manual or work.  Any member of the public is a licensee, and is
+addressed as "you".
+
+A "Modified Version" of the Document means any work containing the
+Document or a portion of it, either copied verbatim, or with
+modifications and/or translated into another language.
+
+A "Secondary Section" is a named appendix or a front-matter section of
+the Document that deals exclusively with the relationship of the
+publishers or authors of the Document to the Document's overall subject
+(or to related matters) and contains nothing that could fall directly
+within that overall subject.  (For example, if the Document is in part a
+textbook of mathematics, a Secondary Section may not explain any
+mathematics.)  The relationship could be a matter of historical
+connection with the subject or with related matters, or of legal,
+commercial, philosophical, ethical or political position regarding
+them.
+
+The "Invariant Sections" are certain Secondary Sections whose titles
+are designated, as being those of Invariant Sections, in the notice
+that says that the Document is released under this License.
+
+The "Cover Texts" are certain short passages of text that are listed,
+as Front-Cover Texts or Back-Cover Texts, in the notice that says that
+the Document is released under this License.
+
+A "Transparent" copy of the Document means a machine-readable copy,
+represented in a format whose specification is available to the
+general public, whose contents can be viewed and edited directly and
+straightforwardly with generic text editors or (for images composed of
+pixels) generic paint programs or (for drawings) some widely available
+drawing editor, and that is suitable for input to text formatters or
+for automatic translation to a variety of formats suitable for input
+to text formatters.  A copy made in an otherwise Transparent file
+format whose markup has been designed to thwart or discourage
+subsequent modification by readers is not Transparent.  A copy that is
+not "Transparent" is called "Opaque".
+
+Examples of suitable formats for Transparent copies include plain
+ASCII without markup, Texinfo input format, LaTeX input format, SGML
+or XML using a publicly available DTD, and standard-conforming simple
+HTML designed for human modification.  Opaque formats include
+PostScript, PDF, proprietary formats that can be read and edited only
+by proprietary word processors, SGML or XML for which the DTD and/or
+processing tools are not generally available, and the
+machine-generated HTML produced by some word processors for output
+purposes only.
+
+The "Title Page" means, for a printed book, the title page itself,
+plus such following pages as are needed to hold, legibly, the material
+this License requires to appear in the title page.  For works in
+formats which do not have any title page as such, "Title Page" means
+the text near the most prominent appearance of the work's title,
+preceding the beginning of the body of the text.
+
+
+2. VERBATIM COPYING
+
+You may copy and distribute the Document in any medium, either
+commercially or noncommercially, provided that this License, the
+copyright notices, and the license notice saying this License applies
+to the Document are reproduced in all copies, and that you add no other
+conditions whatsoever to those of this License.  You may not use
+technical measures to obstruct or control the reading or further
+copying of the copies you make or distribute.  However, you may accept
+compensation in exchange for copies.  If you distribute a large enough
+number of copies you must also follow the conditions in section 3.
+
+You may also lend copies, under the same conditions stated above, and
+you may publicly display copies.
+
+
+3. COPYING IN QUANTITY
+
+If you publish printed copies of the Document numbering more than 100,
+and the Document's license notice requires Cover Texts, you must enclose
+the copies in covers that carry, clearly and legibly, all these Cover
+Texts: Front-Cover Texts on the front cover, and Back-Cover Texts on
+the back cover.  Both covers must also clearly and legibly identify
+you as the publisher of these copies.  The front cover must present
+the full title with all words of the title equally prominent and
+visible.  You may add other material on the covers in addition.
+Copying with changes limited to the covers, as long as they preserve
+the title of the Document and satisfy these conditions, can be treated
+as verbatim copying in other respects.
+
+If the required texts for either cover are too voluminous to fit
+legibly, you should put the first ones listed (as many as fit
+reasonably) on the actual cover, and continue the rest onto adjacent
+pages.
+
+If you publish or distribute Opaque copies of the Document numbering
+more than 100, you must either include a machine-readable Transparent
+copy along with each Opaque copy, or state in or with each Opaque copy
+a publicly-accessible computer-network location containing a complete
+Transparent copy of the Document, free of added material, which the
+general network-using public has access to download anonymously at no
+charge using public-standard network protocols.  If you use the latter
+option, you must take reasonably prudent steps, when you begin
+distribution of Opaque copies in quantity, to ensure that this
+Transparent copy will remain thus accessible at the stated location
+until at least one year after the last time you distribute an Opaque
+copy (directly or through your agents or retailers) of that edition to
+the public.
+
+It is requested, but not required, that you contact the authors of the
+Document well before redistributing any large number of copies, to give
+them a chance to provide you with an updated version of the Document.
+
+
+4. MODIFICATIONS
+
+You may copy and distribute a Modified Version of the Document under
+the conditions of sections 2 and 3 above, provided that you release
+the Modified Version under precisely this License, with the Modified
+Version filling the role of the Document, thus licensing distribution
+and modification of the Modified Version to whoever possesses a copy
+of it.  In addition, you must do these things in the Modified Version:
+
+A. Use in the Title Page (and on the covers, if any) a title distinct
+   from that of the Document, and from those of previous versions
+   (which should, if there were any, be listed in the History section
+   of the Document).  You may use the same title as a previous version
+   if the original publisher of that version gives permission.
+B. List on the Title Page, as authors, one or more persons or entities
+   responsible for authorship of the modifications in the Modified
+   Version, together with at least five of the principal authors of the
+   Document (all of its principal authors, if it has less than five).
+C. State on the Title page the name of the publisher of the
+   Modified Version, as the publisher.
+D. Preserve all the copyright notices of the Document.
+E. Add an appropriate copyright notice for your modifications
+   adjacent to the other copyright notices.
+F. Include, immediately after the copyright notices, a license notice
+   giving the public permission to use the Modified Version under the
+   terms of this License, in the form shown in the Addendum below.
+G. Preserve in that license notice the full lists of Invariant Sections
+   and required Cover Texts given in the Document's license notice.
+H. Include an unaltered copy of this License.
+I. Preserve the section entitled "History", and its title, and add to
+   it an item stating at least the title, year, new authors, and
+   publisher of the Modified Version as given on the Title Page.  If
+   there is no section entitled "History" in the Document, create one
+   stating the title, year, authors, and publisher of the Document as
+   given on its Title Page, then add an item describing the Modified
+   Version as stated in the previous sentence.
+J. Preserve the network location, if any, given in the Document for
+   public access to a Transparent copy of the Document, and likewise
+   the network locations given in the Document for previous versions
+   it was based on.  These may be placed in the "History" section.
+   You may omit a network location for a work that was published at
+   least four years before the Document itself, or if the original
+   publisher of the version it refers to gives permission.
+K. In any section entitled "Acknowledgements" or "Dedications",
+   preserve the section's title, and preserve in the section all the
+   substance and tone of each of the contributor acknowledgements
+   and/or dedications given therein.
+L. Preserve all the Invariant Sections of the Document,
+   unaltered in their text and in their titles.  Section numbers
+   or the equivalent are not considered part of the section titles.
+M. Delete any section entitled "Endorsements".  Such a section
+   may not be included in the Modified Version.
+N. Do not retitle any existing section as "Endorsements"
+   or to conflict in title with any Invariant Section.
+
+If the Modified Version includes new front-matter sections or
+appendices that qualify as Secondary Sections and contain no material
+copied from the Document, you may at your option designate some or all
+of these sections as invariant.  To do this, add their titles to the
+list of Invariant Sections in the Modified Version's license notice.
+These titles must be distinct from any other section titles.
+
+You may add a section entitled "Endorsements", provided it contains
+nothing but endorsements of your Modified Version by various
+parties--for example, statements of peer review or that the text has
+been approved by an organization as the authoritative definition of a
+standard.
+
+You may add a passage of up to five words as a Front-Cover Text, and a
+passage of up to 25 words as a Back-Cover Text, to the end of the list
+of Cover Texts in the Modified Version.  Only one passage of
+Front-Cover Text and one of Back-Cover Text may be added by (or
+through arrangements made by) any one entity.  If the Document already
+includes a cover text for the same cover, previously added by you or
+by arrangement made by the same entity you are acting on behalf of,
+you may not add another; but you may replace the old one, on explicit
+permission from the previous publisher that added the old one.
+
+The author(s) and publisher(s) of the Document do not by this License
+give permission to use their names for publicity for or to assert or
+imply endorsement of any Modified Version.
+
+
+5. COMBINING DOCUMENTS
+
+You may combine the Document with other documents released under this
+License, under the terms defined in section 4 above for modified
+versions, provided that you include in the combination all of the
+Invariant Sections of all of the original documents, unmodified, and
+list them all as Invariant Sections of your combined work in its
+license notice.
+
+The combined work need only contain one copy of this License, and
+multiple identical Invariant Sections may be replaced with a single
+copy.  If there are multiple Invariant Sections with the same name but
+different contents, make the title of each such section unique by
+adding at the end of it, in parentheses, the name of the original
+author or publisher of that section if known, or else a unique number.
+Make the same adjustment to the section titles in the list of
+Invariant Sections in the license notice of the combined work.
+
+In the combination, you must combine any sections entitled "History"
+in the various original documents, forming one section entitled
+"History"; likewise combine any sections entitled "Acknowledgements",
+and any sections entitled "Dedications".  You must delete all sections
+entitled "Endorsements."
+
+
+6. COLLECTIONS OF DOCUMENTS
+
+You may make a collection consisting of the Document and other documents
+released under this License, and replace the individual copies of this
+License in the various documents with a single copy that is included in
+the collection, provided that you follow the rules of this License for
+verbatim copying of each of the documents in all other respects.
+
+You may extract a single document from such a collection, and distribute
+it individually under this License, provided you insert a copy of this
+License into the extracted document, and follow this License in all
+other respects regarding verbatim copying of that document.
+
+
+7. AGGREGATION WITH INDEPENDENT WORKS
+
+A compilation of the Document or its derivatives with other separate
+and independent documents or works, in or on a volume of a storage or
+distribution medium, does not as a whole count as a Modified Version
+of the Document, provided no compilation copyright is claimed for the
+compilation.  Such a compilation is called an "aggregate", and this
+License does not apply to the other self-contained works thus compiled
+with the Document, on account of their being thus compiled, if they
+are not themselves derivative works of the Document.
+
+If the Cover Text requirement of section 3 is applicable to these
+copies of the Document, then if the Document is less than one quarter
+of the entire aggregate, the Document's Cover Texts may be placed on
+covers that surround only the Document within the aggregate.
+Otherwise they must appear on covers around the whole aggregate.
+
+
+8. TRANSLATION
+
+Translation is considered a kind of modification, so you may
+distribute translations of the Document under the terms of section 4.
+Replacing Invariant Sections with translations requires special
+permission from their copyright holders, but you may include
+translations of some or all Invariant Sections in addition to the
+original versions of these Invariant Sections.  You may include a
+translation of this License provided that you also include the
+original English version of this License.  In case of a disagreement
+between the translation and the original English version of this
+License, the original English version will prevail.
+
+
+9. TERMINATION
+
+You may not copy, modify, sublicense, or distribute the Document except
+as expressly provided for under this License.  Any other attempt to
+copy, modify, sublicense or distribute the Document is void, and will
+automatically terminate your rights under this License.  However,
+parties who have received copies, or rights, from you under this
+License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+
+10. FUTURE REVISIONS OF THIS LICENSE
+
+The Free Software Foundation may publish new, revised versions
+of the GNU Free Documentation License from time to time.  Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.  See
+http://www.gnu.org/copyleft/.
+
+Each version of the License is given a distinguishing version number.
+If the Document specifies that a particular numbered version of this
+License "or any later version" applies to it, you have the option of
+following the terms and conditions either of that specified version or
+of any later version that has been published (not as a draft) by the
+Free Software Foundation.  If the Document does not specify a version
+number of this License, you may choose any version ever published (not
+as a draft) by the Free Software Foundation.
+
+
+ADDENDUM: How to use this License for your documents
+
+To use this License in a document you have written, include a copy of
+the License in the document and put the following copyright and
+license notices just after the title page:
+
+      Copyright (c)  YEAR  YOUR NAME.
+      Permission is granted to copy, distribute and/or modify this document
+      under the terms of the GNU Free Documentation License, Version 1.1
+      or any later version published by the Free Software Foundation;
+      with the Invariant Sections being LIST THEIR TITLES, with the
+      Front-Cover Texts being LIST, and with the Back-Cover Texts being LIST.
+      A copy of the license is included in the section entitled "GNU
+      Free Documentation License".
+
+If you have no Invariant Sections, write "with no Invariant Sections"
+instead of saying which ones are invariant.  If you have no
+Front-Cover Texts, write "no Front-Cover Texts" instead of
+"Front-Cover Texts being LIST"; likewise for Back-Cover Texts.
+
+If your document contains nontrivial examples of program code, we
+recommend releasing these examples in parallel under your choice of
+free software license, such as the GNU General Public License,
+to permit their use in free software.
diff --git a/GNU-GPL.txt b/GNU-GPL.txt
new file mode 100644
index 0000000..5b6e7c6
--- /dev/null
+++ b/GNU-GPL.txt
@@ -0,0 +1,340 @@
+		    GNU GENERAL PUBLIC LICENSE
+		       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.
+                       59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Library General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+		    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+			    NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
+	    How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Library General
+Public License instead of this License.
diff --git a/ReadMe.txt b/ReadMe.txt
new file mode 100644
index 0000000..43659dd
--- /dev/null
+++ b/ReadMe.txt
@@ -0,0 +1,52 @@
+# $RCSfile: ReadMe.txt,v $
+# $Revision: 1.1 $
+# $Name:  $
+# $Date: 2008/11/12 02:25:22 $
+# $Author: agibert $
+
+
+
+
+
+Welcome to IMR (Interlinking Message Router) !
+
+
+
+This program is DIAMIS Cristal message transformer. It can convert XML Cristal messages to old flat message format and vice versa.
+Thanks to its fully configurability, IMR can virtually convert any file format.
+Message are read from and writen to different media: file, MQSeries ans Tuxedo Queues.
+
+This is the initial and origianal release of IMR.
+This version has been in production between April 2005 and February 2008 and no bug has been detected !
+
+
+This release of IMR supports the following OS:
+	- Mandriva Linux 2005 (Developement),
+	- HP UX (Production).
+
+
+
+Authors:
+	- Architecture and team leading :    A. Gibert
+	- Conception, Development and Tests: A. Gibert, H. Moussaid, D. Olivon, E. Renaud (Coignet)
+
+
+
+IMR is now licensed under the GPL GNU Licenses.
+For more information, please read the corresponding source file headers.
+The license details can be found in the GNU-GPL.txt and GNU-FDL.txt files.
+
+IMR depend on:
+    - libnode V2.1.0-1 (http://www.rx3.org/dvp/?dvp=libnode),
+    - libxml2 V2.6.9 (http://www.xmlsoft.org/),
+    - libz V1.1.4 ((C) 1995-2002 Jean-loup Gailly and Mark Adler).
+These libraries are currently distributed with IMR. Please check their corresponding licenses.
+
+
+
+Enjoy it!
+
+Your IMR Team.
+
+arnaud@rx3.net
+http://www.rx3.org/dvp/?dvp=imr
diff --git a/ReleaseNotes.txt b/ReleaseNotes.txt
new file mode 100644
index 0000000..38addd7
--- /dev/null
+++ b/ReleaseNotes.txt
@@ -0,0 +1,17 @@
+# $RCSfile: ReleaseNotes.txt,v $
+# $Revision: 1.1 $
+# $Name:  $
+# $Date: 2008/11/12 02:25:22 $
+# $Author: agibert $
+
+
+
+
+
+------------------------------------------------------------------------------------------------------------------------------------
+IMR V 1.0.0-1 - A. Gibert / H. Moussaid / D. Olivon / E. Renaud (Coignet) - 01/04/05
+------------------------------------------------------------------------------------------------------------------------------------
+
+- Intial Version, released for MICOT/Target project (Banque de France - Paris),
+- This version has been in production between April 2005 and February 2008.
+- GPL Release.
diff --git a/ToDo.txt b/ToDo.txt
new file mode 100644
index 0000000..fb711f7
--- /dev/null
+++ b/ToDo.txt
@@ -0,0 +1,12 @@
+# $RCSfile: ToDo.txt,v $
+# $Revision: 1.1 $
+# $Name:  $
+# $Date: 2008/11/12 02:25:22 $
+# $Author: agibert $
+
+
+
+
+
+- Remove libnode and libxml from source and use them externally,
+- Support the forth comming libnode in order to support C99 standards...
diff --git a/doc/IMR-Architecture_Generale.odp b/doc/IMR-Architecture_Generale.odp
new file mode 100644
index 0000000..983cb0f
Binary files /dev/null and b/doc/IMR-Architecture_Generale.odp differ
diff --git a/doc/IMR-Architecture_Generale.odt b/doc/IMR-Architecture_Generale.odt
new file mode 100644
index 0000000..be5b115
Binary files /dev/null and b/doc/IMR-Architecture_Generale.odt differ
diff --git a/doc/IMR-DCT-Mapping_Manager.odt b/doc/IMR-DCT-Mapping_Manager.odt
new file mode 100644
index 0000000..116e1d1
Binary files /dev/null and b/doc/IMR-DCT-Mapping_Manager.odt differ
diff --git a/doc/IMR-DCT-Static_Data_Manager.odt b/doc/IMR-DCT-Static_Data_Manager.odt
new file mode 100644
index 0000000..b19978b
Binary files /dev/null and b/doc/IMR-DCT-Static_Data_Manager.odt differ
diff --git a/doc/IMR-MCD.pdf b/doc/IMR-MCD.pdf
new file mode 100755
index 0000000..ed30117
Binary files /dev/null and b/doc/IMR-MCD.pdf differ
diff --git a/doc/IMR-MPD.pdf b/doc/IMR-MPD.pdf
new file mode 100755
index 0000000..51c0415
Binary files /dev/null and b/doc/IMR-MPD.pdf differ
diff --git a/src/Makefile b/src/Makefile
new file mode 100644
index 0000000..4a58285
--- /dev/null
+++ b/src/Makefile
@@ -0,0 +1,179 @@
+#------------------------------------------------------------------------------
+# General Makefile
+#------------------------------------------------------------------------------
+# $Author: agibert $
+# $Date: 2008/11/12 02:25:22 $
+# $Revision: 1.1 $
+# $Label:  $
+#------------------------------------------------------------------------------
+# Makefile Target:		clean all install uninstall clean-lib clean-bin
+# 				lib bin install-lib install-bin uninstall-lib
+# 				uninstall-bin
+# Default Makefile Target:	all
+# Makefile Support Switches:	ORACLE_SUPPORT TUX_SUPPORT MQS_SUPPORT
+# Makefile Switches:		VERBOSE WARNING DEBUG OPTIMIZE STATIC DYNAMIC
+# Makefile Switches:		PROFILE STRIP DOTI DOLINT EFENCE DMALLOC PURIFY
+# Default Makefile Switches:	STATIC=1 DEBUG=1
+# Makefile Variables:		CC SUBDIR
+# Default Makefile Variables:	SQLCHECK=FULL
+#------------------------------------------------------------------------------
+
+#------------------------------------------------------------------------------
+# IMR - Interlinking Message Router                                            
+# Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)                
+# mailto:arnaud@rx3.net                                                        
+# http://www.rx3.org/dvp/?dvp=imr                                              
+#------------------------------------------------------------------------------
+# This file is part of IMR                                                     
+#                                                                              
+# This program is free software; you can redistribute it and/or                
+# modify it under the terms of the GNU General Public License                  
+# as published by the Free Software Foundation; either version 2               
+# of the License, or (at your option) any later version.                       
+#                                                                              
+# This program is distributed in the hope that it will be useful,              
+# but WITHOUT ANY WARRANTY; without even the implied warranty of               
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                
+# GNU General Public License for more details.                                 
+#                                                                              
+# You should have received a copy of the GNU General Public License            
+# along with this program; if not, write to the Free Software Foundation,      
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.          
+#------------------------------------------------------------------------------
+
+
+
+
+
+#------------------------------------------------------------------------------
+# Constants
+#------------------------------------------------------------------------------
+
+MAKE		= make
+SHELL		= bash
+
+
+
+
+
+#------------------------------------------------------------------------------
+# Variables
+#------------------------------------------------------------------------------
+
+ifdef VERBOSE
+	QUIET=
+	SILENT=
+else
+	QUIET=@
+	SILENT=-s
+endif
+
+
+
+LIB=		libz							\
+		libnode							\
+		libxml							\
+		liblog_mng						\
+		libstatic_data_mng					\
+		libio_mng						\
+		libmapping_mng						\
+		libmsg_router						\
+		sd_appl_struct						\
+		sd_cnv_struct						\
+		sd_fmtattr_struct					\
+		sd_fmt_struct						\
+		sd_mappath_struct					\
+		sd_msg_struct						\
+		sd_msgmap_struct
+
+BIN=		imrd							\
+#		imrc
+
+SUBDIR=		$(LIB) $(BIN)
+
+
+
+
+
+#------------------------------------------------------------------------------
+# External targets
+#------------------------------------------------------------------------------
+
+all:
+
+
+
+clean all install uninstall:
+	$(QUIET)$(MAKE) $(SILENT) $(MAKEOVERRIDES) make-$@
+
+
+
+lib:
+	$(QUIET)$(MAKE) $(SILENT) SUBDIR="$(LIB)" $(MAKEOVERRIDES) all
+
+bin:
+	$(QUIET)$(MAKE) $(SILENT) SUBDIR="$(BIN)" $(MAKEOVERRIDES) all
+
+clean-lib install-lib uninstall-lib:
+	$(QUIET)$(MAKE) $(SILENT) SUBDIR="$(LIB)" $(MAKEOVERRIDES) $(patsubst %-lib, %, $@)
+
+clean-bin install-bin uninstall-bin:
+	$(QUIET)$(MAKE) $(SILENT) SUBDIR="$(BIN)" $(MAKEOVERRIDES) $(patsubst %-bin, %, $@)
+
+
+
+
+
+#------------------------------------------------------------------------------
+# Internal targets
+#------------------------------------------------------------------------------
+
+make-clean make-all make-install make-uninstall: $(SUBDIR)
+
+
+
+
+
+#------------------------------------------------------------------------------
+# Rules
+#------------------------------------------------------------------------------
+
+$(SUBDIR):	
+	@echo Making $(patsubst make-%, %, $(MAKECMDGOALS)) into $@...
+	$(QUIET)$(MAKE) $(SILENT) -C $@/src ECHO_HEAD="\t$@: " $(MAKEOVERRIDES) $(patsubst make-%, %, $(MAKECMDGOALS))
+	@echo Completed $(patsubst make-%, %, $(MAKECMDGOALS)) into $@ !
+
+
+
+
+
+#------------------------------------------------------------------------------
+# Suffixes
+#------------------------------------------------------------------------------
+
+.PHONY:		clean clean-lib clean-bin make-clean all make-all lib bin install install-lib install-bin make-install uninstall uninstall-lib uninstall-bin make-uninstall $(SUBDIR)
+ifdef PURIFY
+        .NOTPARALLEL:
+endif
+
+
+
+
+
+#------------------------------------------------------------------------------
+# Dependencies
+#------------------------------------------------------------------------------
+
+$(BIN):		$(LIB)
+
+
+
+ifneq (,$(findstring clean,$(MAKECMDGOALS)))
+all:		clean
+install:	clean
+endif
+
+ifneq (,$(findstring uninstall,$(MAKECMDGOALS)))
+all:		uninstall
+install:	uninstall
+endif
diff --git a/src/Makefile_rule.mk b/src/Makefile_rule.mk
new file mode 100644
index 0000000..aa7f68a
--- /dev/null
+++ b/src/Makefile_rule.mk
@@ -0,0 +1,280 @@
+#------------------------------------------------------------------------------
+# Makefile Rule Definitions
+#------------------------------------------------------------------------------
+# $Author: agibert $
+# $Date: 2008/11/12 02:25:22 $
+# $Revision: 1.1 $
+# $Label:  $
+#------------------------------------------------------------------------------
+# Makefile Target:		clean all dep install uninstall
+# Default Makefile Target:	all
+# Makefile Support Switches:	ORACLE_SUPPORT TUX_SUPPORT MQS_SUPPORT
+# Makefile Switches:		VERBOSE WARNING DEBUG OPTIMIZE STATIC DYNAMIC
+# Makefile Switches:		PROFILE STRIP DOTI DOLINT EFENCE DMALLOC PURIFY
+# Default Makefile Switches:	STATIC=1 DEBUG=1
+# Makefile Variables:		CC SQLCHECK
+# Default Makefile Variables:	SQLCHECK=FULL
+# Tuxedo Server Tag:		TXSERVICE_NAME TXSERVICE_TYPE
+# Tuxedo Service Type:		NONE TX_SERVER_OXA TX_CLIENT_ORA
+#------------------------------------------------------------------------------
+
+#------------------------------------------------------------------------------
+# IMR - Interlinking Message Router                                            
+# Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)                
+# mailto:arnaud@rx3.net                                                        
+# http://www.rx3.org/dvp/?dvp=imr                                              
+#------------------------------------------------------------------------------
+# This file is part of IMR                                                     
+#                                                                              
+# This program is free software; you can redistribute it and/or                
+# modify it under the terms of the GNU General Public License                  
+# as published by the Free Software Foundation; either version 2               
+# of the License, or (at your option) any later version.                       
+#                                                                              
+# This program is distributed in the hope that it will be useful,              
+# but WITHOUT ANY WARRANTY; without even the implied warranty of               
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                
+# GNU General Public License for more details.                                 
+#                                                                              
+# You should have received a copy of the GNU General Public License            
+# along with this program; if not, write to the Free Software Foundation,      
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.          
+#------------------------------------------------------------------------------
+
+
+
+
+
+#------------------------------------------------------------------------------
+# Variables
+#------------------------------------------------------------------------------
+
+TARGET_FILES=		$(TARGET)
+INSTALL_FILES=		$(TARGET)
+UNINSTALL_FILES=	$(TARGET)
+
+ifeq ($(suffix $(TARGET)),$(SHLIB_SUFFIX))
+        INSTALL_DIR=		$(GLOBAL_LIB_DIR)
+        TARGET_FILES+=		$(TARGET:$(SHLIB_SUFFIX)=.a)
+        INSTALL_FILES+=		$(TARGET:$(SHLIB_SUFFIX)=.a)
+        UNINSTALL_FILES+=	$(TARGET:$(SHLIB_SUFFIX)=.a) .pure $(TARGET:$(SHLIB_SUFFIX)=_pure_*$(SHLIB_SUFFIX)) $(TARGET:$(SHLIB_SUFFIX)=_pure_*.a)
+
+        ifdef DOLINT
+                LINT_TARGET=		llib-l$(subst lib,,$(basename $(TARGET))).ln
+                LINT_LIB=		$(LINT_TARGET)
+                TARGET_FILES+=		$(LINT_TARGET)
+                INSTALL_FILES+=		$(LINT_TARGET)
+                UNINSTALL_FILES+=	$(LINT_TARGET)
+        endif
+else
+        ifeq ($(suffix $(TARGET)),.xml)
+                INSTALL_DIR=		$(GLOBAL_LIB_DIR)/imr
+        else
+                INSTALL_DIR=		$(GLOBAL_BIN_DIR)
+
+                ifdef DOLINT
+                        LINT_FILE=	$(basename $(TARGET)).lint
+                        LINT_LIB=	
+                        TARGET_FILES+=	$(LINT_FILE)
+                endif
+        endif
+endif
+
+ifdef DOTI
+        TARGET_FILES+=	$(OBJ:.o=.i)
+endif
+
+
+
+
+
+#------------------------------------------------------------------------------
+# External targets
+#------------------------------------------------------------------------------
+
+all: dep
+	$(QUIET)$(MAKE) $(SILENT) $(MAKEOVERRIDES) build
+
+clean:
+	@echo -e '$(ECHO_HEAD)Cleaning up...'
+	$(QUIET)$(RM) -f						\
+		$(shell for file in $(OBJ:.o=);				\
+			do						\
+				if [ -f $$file.pc ];			\
+				then					\
+					echo $$file.c $$file.lis;	\
+				fi;					\
+			done)						\
+		$(OBJ:.o=.dep)						\
+		$(OBJ:.o=.i)						\
+		$(OBJ:.o=.ln)						\
+		$(OBJ:.o=.sublint)					\
+		$(OBJ:.o=_pure_*)					\
+		$(OBJ)							\
+		$(TARGET_FILES)						\
+		llib-l$(subst lib,,$(basename $(TARGET))).ln		\
+		llib-l$(subst lib,,$(basename $(TARGET))).sublint	\
+		BS-*.c BS-*.o						\
+		BS-*_pure_*						\
+		BC-*.c BC-*.o						\
+		BC-*_pure_*						\
+		logfile*						\
+		.pure
+
+install: $(patsubst %,$(INSTALL_DIR)/%,$(INSTALL_FILES))
+
+uninstall:
+	$(QUIET)for file in $(UNINSTALL_FILES);				\
+	do								\
+		echo -e "$(ECHO_HEAD)Uninstalling $$file from $(INSTALL_DIR)..."; \
+		$(RM) -f $(INSTALL_DIR)/$$file;				\
+	done
+
+dep:
+	$(QUIET)$(MAKE) $(SILENT) $(MAKEOVERRIDES) depend
+
+
+
+
+
+#------------------------------------------------------------------------------
+# Internal targets
+#------------------------------------------------------------------------------
+
+depend:	$(OBJ:.o=.dep)
+
+build: $(TARGET_FILES)
+
+
+
+
+
+#------------------------------------------------------------------------------
+# Rules
+#------------------------------------------------------------------------------
+
+%.dep	: %.c
+	@echo -e '$(ECHO_HEAD)Dependencing $<...'
+	$(QUIET)$(MAKEDEP) $(MAKEDEP_FLAGS) -o.o $<  >$@
+	$(QUIET)$(MAKEDEP) $(MAKEDEP_FLAGS) -o.i $< >>$@
+
+%.c	: %.pc
+	@echo -e '$(ECHO_HEAD)Procing $<...'
+	$(QUIET)$(PROC) $(DEVNULL) $(PROC_FLAGS) oname=$@ iname=$< $(PROC_FILTER)
+
+%.i	: %.c
+	@echo -e '$(ECHO_HEAD)Precompilling $<...'
+	$(QUIET)$(CPP) $(CPPFLAGS) $(INCLUDE) -o $@ $<
+
+%.ln	: %.c
+	@echo -e '$(ECHO_HEAD)Linting $<...'
+	$(QUIET)$(LINT) $(LINTFLAGS) $(INCLUDE) -c > $(<:.c=.sublint) $<
+
+%.o	: %.c
+	@echo -e '$(ECHO_HEAD)Compilling $<...'
+	$(QUIET)$(CC) $(CFLAGS) $(INCLUDE)   -o $@ $<
+
+$(LINT_LIB): $(OBJ:.o=.ln)
+	@echo -e '$(ECHO_HEAD)Lib Linting $@...'
+	$(QUIET)$(LINT) $(LINTFLAGS) -o $(subst lib,,$(basename $(TARGET))) > $(@:.ln=.sublint) $(OBJ:.o=.ln)
+
+%$(SHLIB_SUFFIX): %.o
+	@echo -e '$(ECHO_HEAD)Linking $@...'
+	$(QUIET)$(LD) $(LDFLAGS)           -o $@ $(OBJ)
+
+%.a	: %.o
+	@echo -e '$(ECHO_HEAD)Linking $@...'
+	$(QUIET)$(AR) $(ARFLAGS)              $@ $(OBJ)
+
+%.lint	: %.ln
+	@echo -e '$(ECHO_HEAD)Link Linting $@...'
+	$(QUIET)$(LINT) $(LINTFLAGS) $(LINTLIBS) $< >$@
+
+%	: %.o
+ifeq ($(TXSERVICE_TYPE),TX_SERVER_OXA)
+	@echo -e '$(ECHO_HEAD)Building Tuxedo server $@... '
+	$(QUIET)$(PRELINK) $(TXBLDSRV) $(TXBLD_FLAGS)  -o $@ -f "$(OBJ)" $(TXBLD_LIB) -s "$(TXSERVICE_NAME)" $(PRELINK_FILTER)
+else
+        ifeq ($(TXSERVICE_TYPE),TX_CLIENT_ORA)
+		@echo -e '$(ECHO_HEAD)Building Tuxedo client $@...'
+		$(QUIET)$(PRELINK) $(TXBLDCLN) $(TXBLD_FLAGS)  -o $@ -f "$(OBJ)" $(TXBLD_LIB) $(PRELINK_FILTER)
+                ifndef DEBUG
+			$(QUIET)$(RM) BC-*.c
+                endif
+        else
+		@echo -e '$(ECHO_HEAD)Linking $@...'
+                ifdef PURIFY
+			@echo -e '$(ECHO_HEAD)Purifing $@... '
+			$(PURIFIER) $(PURIFIER_FLAGS) $(CC) $(LINK_FLAGS) -o $@ $(OBJ) $(LIB) $(PRELINK_FILTER)
+                else
+			$(QUIET)$(CC) $(LINK_FLAGS) -o $@ $(OBJ) $(LIB)
+                endif
+        endif
+endif
+ifdef DEBUG
+        ifeq ($(OS),HP-UX)
+	        @echo -e '$(ECHO_HEAD)Pxdbing $@...'
+	        $(QUIET)$(PXDB) $(PXDBFLAGS) $@
+        endif
+else
+        ifdef STRIP
+		@echo -e '$(ECHO_HEAD)Striping $@...'
+		$(QUIET)$(STRIPPER) $@
+        endif
+endif
+
+%.xml	: %.xml.m4
+	@echo -e '$(ECHO_HEAD)M4ing $@... '
+	$(QUIET)$(M4) $(M4_FLAGS) > $@ $<
+
+$(INSTALL_DIR)/%: $(INSTALL_DIR) all
+	@echo -e '$(ECHO_HEAD)Installing $(subst $(INSTALL_DIR)/,,$@) into $(INSTALL_DIR)...'
+	$(QUIET)$(CP) $(subst $(INSTALL_DIR)/,,$@) $(INSTALL_DIR)
+
+$(INSTALL_DIR):
+	@echo -e '$(ECHO_HEAD)Creatinging $(INSTALL_DIR)...'
+	$(QUIET)$(MKDIR) $(INSTALL_DIR)
+
+
+
+
+
+#------------------------------------------------------------------------------
+# Suffixes
+#------------------------------------------------------------------------------
+
+.SECONDARY:	$(OBJ:.o=.c) $(OBJ:.o=.dep) $(OBJ:.o=.ln) $(OBJ:.o=.sublint)
+.SUFFIXES:	.pc .c .h .dep .i .ln .sublint .o $(SHLIB_SUFFIX) .a .lint
+.PHONY:		clean all dep install uninstall build depend
+.DELETE_ON_ERROR:
+
+
+
+
+
+#------------------------------------------------------------------------------
+# Dependencies
+#------------------------------------------------------------------------------
+
+$(OBJ): Makefile $(MAKEFILE_GLOB) $(MAKEFILE_PATH)
+$(TARGET_FILES): $(OBJ) $(OBJ_RAW) Makefile $(MAKEFILE_GLOB) $(MAKEFILE_PATH)
+
+ifneq ($(suffix $(TARGET)),$(SHLIB_SUFFIX))
+        ifneq ($(suffix $(TARGET)),.xml)
+                $(TARGET): $(patsubst %,$(GLOBAL_LIB_DIR)/lib%$(SHLIB_SUFFIX),$(LIB_LIST))
+        endif
+endif
+
+ifneq (,$(findstring clean,$(MAKECMDGOALS)))
+dep: clean
+endif
+
+ifneq (,$(findstring uninstall,$(MAKECMDGOALS)))
+dep: uninstall
+endif
+
+ifeq ($(MAKECMDGOALS),build)
+        ifneq (,$(OBJ))
+                -include $(OBJ:.o=.dep)
+        endif
+endif
diff --git a/src/Makefile_template.mk b/src/Makefile_template.mk
new file mode 100644
index 0000000..90c00da
--- /dev/null
+++ b/src/Makefile_template.mk
@@ -0,0 +1,65 @@
+#------------------------------------------------------------------------------
+# Local Makefile
+#------------------------------------------------------------------------------
+# $Author: agibert $
+# $Date: 2008/11/12 02:25:22 $
+# $Revision: 1.1 $
+# $Label:  $
+#------------------------------------------------------------------------------
+
+#------------------------------------------------------------------------------
+# IMR - Interlinking Message Router                                            
+# Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)                
+# mailto:arnaud@rx3.net                                                        
+# http://www.rx3.org/dvp/?dvp=imr                                              
+#------------------------------------------------------------------------------
+# This file is part of IMR                                                     
+#                                                                              
+# This program is free software; you can redistribute it and/or                
+# modify it under the terms of the GNU General Public License                  
+# as published by the Free Software Foundation; either version 2               
+# of the License, or (at your option) any later version.                       
+#                                                                              
+# This program is distributed in the hope that it will be useful,              
+# but WITHOUT ANY WARRANTY; without even the implied warranty of               
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                
+# GNU General Public License for more details.                                 
+#                                                                              
+# You should have received a copy of the GNU General Public License            
+# along with this program; if not, write to the Free Software Foundation,      
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.          
+#------------------------------------------------------------------------------
+
+
+
+
+
+#------------------------------------------------------------------------------
+# Var include
+#------------------------------------------------------------------------------
+
+include ../../Makefile_var.mk
+
+
+
+#------------------------------------------------------------------------------
+# Variables
+#------------------------------------------------------------------------------
+
+TARGET=		lib_xxx$(SHLIB_SUFFIX)
+
+OBJ=		module1.o 						\
+		module2.o 						\
+		lib_xxx.o
+
+EXTRA_INC=	../zzz
+
+EXTRA_LIB=	-lzzz
+
+
+
+#------------------------------------------------------------------------------
+# Rule include
+#------------------------------------------------------------------------------
+
+include ../../Makefile_rule.mk
diff --git a/src/Makefile_var.mk b/src/Makefile_var.mk
new file mode 100644
index 0000000..aead75b
--- /dev/null
+++ b/src/Makefile_var.mk
@@ -0,0 +1,497 @@
+#------------------------------------------------------------------------------
+# Makefile Var Definitions
+#------------------------------------------------------------------------------
+# $Author: agibert $
+# $Date: 2008/11/12 02:25:22 $
+# $Revision: 1.1 $
+# $Label:  $
+#------------------------------------------------------------------------------
+
+#------------------------------------------------------------------------------
+# IMR - Interlinking Message Router                                            
+# Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)                
+# mailto:arnaud@rx3.net                                                        
+# http://www.rx3.org/dvp/?dvp=imr                                              
+#------------------------------------------------------------------------------
+# This file is part of IMR                                                     
+#                                                                              
+# This program is free software; you can redistribute it and/or                
+# modify it under the terms of the GNU General Public License                  
+# as published by the Free Software Foundation; either version 2               
+# of the License, or (at your option) any later version.                       
+#                                                                              
+# This program is distributed in the hope that it will be useful,              
+# but WITHOUT ANY WARRANTY; without even the implied warranty of               
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                
+# GNU General Public License for more details.                                 
+#                                                                              
+# You should have received a copy of the GNU General Public License            
+# along with this program; if not, write to the Free Software Foundation,      
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.          
+#------------------------------------------------------------------------------
+
+
+
+
+
+#------------------------------------------------------------------------------
+# Curent Module Dir
+#------------------------------------------------------------------------------
+
+LOCAL_INC_DIR=		../include
+
+
+
+#------------------------------------------------------------------------------
+# Global Dir
+#------------------------------------------------------------------------------
+
+GLOBAL_INC_DIR=		../../include
+GLOBAL_BIN_DIR=		../../../bin
+GLOBAL_LIB_DIR=		../../../lib
+
+LIB_LIST=		msg_router mapping_mng io_mng static_data_mng log_mng xml node z
+
+
+
+#------------------------------------------------------------------------------
+# Constants
+#------------------------------------------------------------------------------
+
+MAKE		= make
+MAKEDEP		= makedepend
+SHELL		= bash
+RM      	= rm
+MKDIR		= mkdir -p
+CP		= cp
+CAT		= cat
+M4              = m4
+PROC		= proc
+CC		=
+#CC		= cc
+#CC		= gcc
+CPP		= $(CC)
+LD		=
+#LD      	= ld
+#LD      	= $(CC)
+AR      	= ar
+TXBLDSRV	= buildserver
+TXBLDCLN	= buildclient
+TXMKFML		= mkfldhdr
+TXMKVIEW	= viewc
+PXDB		= pxdb
+LINT		= lint
+STRIPPER	= strip
+PURIFIER	= purify
+
+COMMA		= ,
+
+
+
+
+
+#------------------------------------------------------------------------------
+# Variables
+#------------------------------------------------------------------------------
+
+OS		= $(shell uname)
+
+ifndef CC
+        ifeq ($(OS),HP-UX)
+                CC=	cc
+                LD=	ld
+        else
+                CC=	gcc
+                LD=	gcc
+        endif
+endif
+
+ifdef VERBOSE
+	QUIET=
+	SILENT=
+	PROC_FILTER=
+	PRELINK_FILTER=
+	TXBLDSRV+= -v
+	TXBLDCLN+= -v
+else
+	QUIET=@
+	SILENT=-s
+	PROC_FILTER=| grep -v -e '^$$' -e '^Pro' -e '^(c)'		\
+			   -e '^Copyright' -e '^System default option';	\
+		    [[ $${PIPESTATUS[0]} = 0 ]]
+	PRELINK_FILTER=2>&1 | grep -v -e '^Purify'			\
+			   -e '^Instrumenting: ';			\
+		    [[ $${PIPESTATUS[0]} = 0 ]]
+endif
+
+ifdef DYNAMIC
+	STATIC=
+else
+	STATIC=1
+endif
+
+ifdef OPTIMIZE
+	DEBUG=
+else
+	DEBUG=1
+endif
+
+ifdef DEBUG
+	TXBLDSRV+= -k
+endif
+
+ifndef SQLCHECK
+	SQLCHECK=FULL
+endif
+
+ifndef ORACLE_SUPPORT
+        ifndef ORACLE_HOME
+                ORACLE_SUPPORT	= 0
+        else
+                ORACLE_SUPPORT	= 1
+        endif
+endif
+
+ifndef TUX_SUPPORT
+        ifndef TUXDIR
+                TUX_SUPPORT	= 0
+        else
+                TUX_SUPPORT	= 1
+        endif
+endif
+
+ifndef MQS_SUPPORT
+        ifndef MQM_HOME
+                MQS_SUPPORT	= 0
+        else
+                MQS_SUPPORT	= 1
+        endif
+endif
+
+
+
+# Flags Init
+INCLUDE=
+LIB_cc=
+LIB_gcc=
+LIB=
+M4_FLAGS=
+MAKEDEP_FLAGS=
+PROC_FLAGS=
+CPPFLAGS=
+CPPFLAGS_cc=
+CPPFLAGS_gcc=
+CFLAGS=
+CFLAGS_cc=
+CFLAGS_gcc=
+LDFLAGS=
+TXBLD_FLAGS=
+TXBLD_FLAGS_cc=
+TXBLD_FLAGS_gcc=
+LDFLAGS=
+LDFLAGS_cc=
+LDFLAGS_gcc=
+LINK_FLAGS=
+LINK_FLAGS_cc=
+LINK_FLAGS_gcc=
+ARFLAGS=
+
+
+
+
+PURIFIER_FLAGS=	-user-path=$(shell echo "$(patsubst %,lib%/src,$(LIB_LIST)) imrd/src" | sed 's/ /\:/g')
+
+ifdef PURIFY
+	PRELINK=echo -e '$(ECHO_HEAD)Purifing $@... ';	\
+		export CC="$(PURIFIER) $(PURIFIER_FLAGS) $(CC)";
+endif
+
+
+
+ifeq ($(ORACLE_SUPPORT),1)
+        INCLUDE+=	-I$(ORACLE_HOME)/precomp/public
+        LIB+=		-L$(ORACLE_HOME)/lib -lclntsh
+        M4_FLAGS+=	-DORACLE_SUPPORT
+        MAKEDEP_FLAGS+=	-DORACLE_SUPPORT
+        PROC_FLAGS+=	DEFINE=ORACLE_SUPPORT
+        CPPFLAGS+=	-DORACLE_SUPPORT
+        CFLAGS+=	-DORACLE_SUPPORT
+endif
+
+ifeq ($(TUX_SUPPORT),1)
+        INCLUDE+=	-I$(TUXDIR)/include
+        LIB+=		-L$(TUXDIR)/lib -lfml -lfml32 -ltux
+        M4_FLAGS+=	-DTUX_SUPPORT
+        MAKEDEP_FLAGS+=	-DTUX_SUPPORT
+        PROC_FLAGS+=	DEFINE=TUX_SUPPORT
+        CPPFLAGS+=	-DTUX_SUPPORT
+        CFLAGS+=	-DTUX_SUPPORT
+endif
+
+ifeq ($(MQS_SUPPORT),1)
+        INCLUDE+=	-I$(MQM_HOME)/inc
+        LIB+=		-L$(MQM_HOME)/lib64 -lmqic
+        M4_FLAGS+=	-DMQS_SUPPORT
+        MAKEDEP_FLAGS+=	-DMQS_SUPPORT
+        PROC_FLAGS+=	DEFINE=MQS_SUPPORT
+        CPPFLAGS+=	-DMQS_SUPPORT
+        CFLAGS+=	-DMQS_SUPPORT
+endif
+
+
+
+# OS Dependant Flags
+
+ifeq ($(OS),HP-UX)
+        SHLIB_SUFFIX=	.sl
+        M4_FLAGS:=	-B100000 -S100000 $(M4_FLAGS)
+        MAKEDEP_FLAGS+=	-z -D _HPUX_SOURCE -D __hpux
+        PROC_FLAGS+=	DEFINE=_PA_RISC2_0
+        CPPFLAGS+=	-D _HPUX_SOURCE -D __hpux
+        CFLAGS+=	-D _HPUX_SOURCE -D __hpux
+        LDFLAGS+=	-b
+        LDFLAGS+=	
+
+        ifeq ($(ARCH),32BITS)
+                MAKEDEP_FLAGS+=	
+                CPPFLAGS_cc+=	+DD32
+                CPPFLAGS_gcc+= 	
+                CFLAGS_cc+=	+DD32
+                CFLAGS_gcc+= 	
+                TXBLD_FLAGS_cc+= +DD32
+                TXBLD_FLAGS_gcc+=
+                LINK_FLAGS_cc+= +DD32
+                LINK_FLAGS_gcc+=
+                LDFLAGS_cc+=
+                LDFLAGS_gcc+=
+        endif
+
+        ifeq ($(ARCH),64BITS)
+                MAKEDEP_FLAGS+=	-D__LP64__
+                CPPFLAGS_cc+=	+DD64
+                CPPFLAGS_gcc+= 	
+                CFLAGS_cc+=	+DD64
+                CFLAGS_gcc+= 	
+                TXBLD_FLAGS_cc+= +DD64
+                TXBLD_FLAGS_gcc+=
+                LINK_FLAGS_cc+= +DD64
+                LINK_FLAGS_gcc+=
+                LDFLAGS_cc+=
+                LDFLAGS_gcc+=
+        endif
+else
+        SHLIB_SUFFIX=	.so
+        M4_FLAGS+=
+        MAKEDEP_FLAGS+=	
+        PROC_FLAGS+=
+        CPPFLAGS+=
+        CFLAGS+=
+        LDFLAGS+=	-shared
+endif
+
+
+
+# Compiler Dependant Flags
+
+INCLUDE+=	-I.							\
+		$(patsubst %,-I../../lib%/include,$(LIB_LIST))		\
+		-I$(GLOBAL_INC_DIR) 					\
+		$(shell for inc in $(EXTRA_INC);			\
+			do						\
+				echo "-I$$inc ";			\
+			done)
+
+
+
+ifeq ($(SQLCHECK),FULL)
+PROC_FLAGS+=	USERID=$(USR_IMRMGR)/$(PWD_IMRMGR)
+endif
+
+PROC_FLAGS+=	SQLCHECK=$(SQLCHECK)                                    \
+		RELEASE_CURSOR=NO					\
+		HOLD_CURSOR=YES						\
+		MAXOPENCURSOR=100					\
+		DBMS=V7							\
+		MODE=ORACLE						\
+		CODE=ANSI_C						\
+		$(patsubst -I%,INCLUDE=%,$(INCLUDE))
+
+
+
+
+CPPFLAGS_cc+=	-P -C -Ae -w
+CPPFLAGS_gcc+=	-E -C
+
+CFLAGS_cc+=	-c -Ae +z
+CFLAGS_gcc+=	-c -fpic  -pipe
+
+TXBLD_FLAGS_cc+=	-Wl,+s,-Bimmediate
+TXBLD_FLAGS_gcc+=	
+
+LDFLAGS_cc+=
+LDFLAGS_gcc+=
+
+LINK_FLAGS_cc+=
+LINK_FLAGS_gcc+=
+
+
+
+ifdef DEBUG
+        CFLAGS_cc+=	-g
+        CFLAGS_gcc+= 	-g
+        TXBLD_FLAGS_cc+= -g
+        TXBLD_FLAGS_gcc+= -g
+        LDFLAGS_cc+=	
+        LDFLAGS_gcc+=	
+        LINK_FLAGS_cc+=	-g
+        LINK_FLAGS_gcc+= -g
+endif
+
+ifdef OPTIMIZE
+        CFLAGS_cc+=	-O
+        CFLAGS_gcc+= 	-O3
+        TXBLD_FLAGS_cc+= -O
+        TXBLD_FLAGS_gcc+= -O3
+        LDFLAGS_cc+=	
+        LDFLAGS_gcc+=	-O3
+        LINK_FLAGS_cc+=	-O
+        LINK_FLAGS_gcc+= -Wl,-O3
+endif
+
+ifdef PROFILE
+        CFLAGS_cc+=	-pg
+        CFLAGS_gcc+= 	-pg
+        TXBLD_FLAGS_cc+= -pg
+        TXBLD_FLAGS_gcc+= -pg
+endif
+
+
+
+ifdef WARNING
+        CFLAGS_cc+=+w1 +M2
+        CFLAGS_gcc+=-Wformat -Wnonnull -Wimplicit -Wmain -Wmissing-braces \
+		-Wparentheses -Wsequence-point -Wreturn-type -Wswitch	\
+		-Wswitch-default -Wswitch-enum -Wtrigraphs -Wunused 	\
+		-Wuninitialized -Wunknown-pragmas -Wstrict-aliasing -W	\
+		-Wfloat-equal -Wundef -Wendif-labels -Wshadow		\
+		-Wpointer-arith -Wbad-function-cast -Wcast-qual		\
+		-Wcast-align -Wwrite-strings -Wconversion		\
+		-Wsign-compare -Waggregate-return -Wstrict-prototypes	\
+		-Wmissing-prototypes -Wmissing-declarations		\
+		-Wmissing-noreturn -Wmissing-format-attribute -Wpacked	\
+		-Wredundant-decls -Wnested-externs -Wunreachable-code 	\
+		-Winline -Wlong-long -Wdisabled-optimization
+        TXBLD_FLAGS_cc+=+w1 +M2
+        TXBLD_FLAGS_gcc+=-Wformat -Wnonnull -Wimplicit -Wmain -Wmissing-braces \
+		-Wparentheses -Wsequence-point -Wreturn-type -Wswitch	\
+		-Wswitch-default -Wswitch-enum -Wtrigraphs -Wunused 	\
+		-Wuninitialized -Wunknown-pragmas -Wstrict-aliasing -W	\
+		-Wfloat-equal -Wundef -Wendif-labels -Wshadow		\
+		-Wpointer-arith -Wbad-function-cast -Wcast-qual		\
+		-Wcast-align -Wwrite-strings -Wconversion		\
+		-Wsign-compare -Waggregate-return -Wstrict-prototypes	\
+		-Wmissing-prototypes -Wmissing-declarations		\
+		-Wmissing-noreturn -Wmissing-format-attribute -Wpacked	\
+		-Wredundant-decls -Wnested-externs -Wunreachable-code 	\
+		-Winline -Wlong-long -Wdisabled-optimization
+endif
+
+
+
+ifdef EFENCE
+else
+        ifdef DMALLOC
+                CFLAGS+= -DDMALLOC
+        endif
+endif
+
+
+
+ifdef STATIC
+        ifeq ($(CC),cc)
+                LIB+=	-Wl,-a,archive_shared
+
+                ifeq ($(ARCH),64BITS)
+                        LIB+=	-Wl,+forceload
+                else
+                        LIB+=	-Wl,-E
+                endif
+        else
+                LIB+=	-Wl,-export-dynamic,-whole-archive,-Bstatic
+        endif
+endif
+
+LIB+=		-L$(GLOBAL_LIB_DIR)					\
+		$(patsubst %,-l%,$(LIB_LIST))
+
+ifdef STATIC
+        ifeq ($(CC),cc)
+                ifeq ($(ARCH),64BITS)
+	                LIB+=	-Wl,+noforceload
+                endif
+
+                LIB+=	-Wl,-a,shared_archive
+        else
+                LIB+=	-Wl,-no-whole-archive,-Bdynamic
+        endif
+endif
+
+ifdef EFENCE
+        LIB+=	-lefence -lrt
+else
+        ifdef DMALLOC
+                LIB+= -ldmalloc
+        endif
+endif
+
+LIB_cc+=	-lnsl -lm -lpthread
+
+LIB_gcc+=	-lpthread -lm -ldl
+
+
+
+TXBLD_LIB= -f "$(LIB) -ltmib"
+
+
+
+TXSERVICE_NAME=	$(shell if [ -f $(TARGET).c ];				\
+			then						\
+				grep TXSERVICE_NAME $(TARGET).c |	\
+					sed "s/.*: //";			\
+			 fi)
+TXSERVICE_TYPE=	$(shell if [ -f $(TARGET).c ];				\
+			then						\
+				grep TXSERVICE_TYPE $(TARGET).c |	\
+					sed "s/.*: //";			\
+			 fi)
+
+
+
+PXDBFLAGS=	-s on $(EXTRA_PXDBFLAGS)
+
+
+
+LINTFLAGS=	$(EXTRA_LINTFLAGS)
+
+LINTLIBS=	$(GLOBAL_LIB_DIR)/*.ln
+
+
+
+# Flags Merging
+
+MAKEDEP_FLAGS+=	$(INCLUDE) -f- $(EXTRA_MAKEDEP_FLAGS)
+PROC_FLAGS+=	$(EXTRA_PROC_FLAGS)
+CPPFLAGS+=	$(CPPFLAGS_$(CPP)) $(EXTRA_CPPFLAGS)
+CFLAGS+=	$(CFLAGS_$(CC)) $(EXTRA_CFLAGS)
+LINK_FLAGS+=	$(LINK_FLAGS_$(CC)) $(EXTRA_LINK_FLAGS)
+LDFLAGS+=	$(LDFLAGS_$(CC)) $(EXTRA_LDFLAGS)
+LIB+=           $(LIB_$(CC)) $(EXTRA_LIB)
+ARFLAGS+=	-cr $(EXTRA_ARFLAGS)
+TXBLD_FLAGS+=	-f "$(TXBLD_FLAGS_$(CC))" -r $(ORACLE_RM) $(EXTRA_TXBLD_FLAGS)
+
+
+
+ifeq ($(CC),gcc)
+        TXBLDSRV:=CC=cc.gcc; $(TXBLDSRV)
+        TXBLDCLN:=CC=cc.gcc; $(TXBLDCLN)
+endif
diff --git a/src/imrc/src/Makefile b/src/imrc/src/Makefile
new file mode 100644
index 0000000..4c685d0
--- /dev/null
+++ b/src/imrc/src/Makefile
@@ -0,0 +1,59 @@
+#------------------------------------------------------------------------------
+# Local Makefile
+#------------------------------------------------------------------------------
+
+#------------------------------------------------------------------------------
+# IMR - Interlinking Message Router                                            
+# Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)                
+# mailto:arnaud@rx3.net                                                        
+# http://www.rx3.org/dvp/?dvp=imr                                              
+#------------------------------------------------------------------------------
+# This file is part of IMR                                                     
+#                                                                              
+# This program is free software; you can redistribute it and/or                
+# modify it under the terms of the GNU General Public License                  
+# as published by the Free Software Foundation; either version 2               
+# of the License, or (at your option) any later version.                       
+#                                                                              
+# This program is distributed in the hope that it will be useful,              
+# but WITHOUT ANY WARRANTY; without even the implied warranty of               
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                
+# GNU General Public License for more details.                                 
+#                                                                              
+# You should have received a copy of the GNU General Public License            
+# along with this program; if not, write to the Free Software Foundation,      
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.          
+#------------------------------------------------------------------------------
+
+
+
+#------------------------------------------------------------------------------
+# Constants
+#------------------------------------------------------------------------------
+
+MAKEFILE_GLOB=	../../Makefile_glob.mk
+MAKEFILE_PATH=	../../Makefile_path.mk
+
+
+
+#------------------------------------------------------------------------------
+# Variables
+#------------------------------------------------------------------------------
+
+TARGET=		lib_xxx.sl
+
+OBJ=		module1.o 						\
+		module2.o 						\
+		lib_xxx.o
+
+EXTRA_INC=	../zzz
+
+EXTRA_LIB=	-lzzz
+
+
+
+#------------------------------------------------------------------------------
+# Include
+#------------------------------------------------------------------------------
+
+include $(MAKEFILE_GLOB)
diff --git a/src/imrd/src/Makefile b/src/imrd/src/Makefile
new file mode 100644
index 0000000..193f269
--- /dev/null
+++ b/src/imrd/src/Makefile
@@ -0,0 +1,65 @@
+#------------------------------------------------------------------------------
+# Local Makefile
+#------------------------------------------------------------------------------
+# $Workfile:   Makefile  $                                                     
+#------------------------------------------------------------------------------
+# $Author: agibert $                                                        
+# $Date: 2008/11/12 02:25:22 $                                             
+# $Revision: 1.1 $                                                         
+# $Label:  $                                                           
+#------------------------------------------------------------------------------
+
+#------------------------------------------------------------------------------
+# IMR - Interlinking Message Router                                            
+# Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)                
+# mailto:arnaud@rx3.net                                                        
+# http://www.rx3.org/dvp/?dvp=imr                                              
+#------------------------------------------------------------------------------
+# This file is part of IMR                                                     
+#                                                                              
+# This program is free software; you can redistribute it and/or                
+# modify it under the terms of the GNU General Public License                  
+# as published by the Free Software Foundation; either version 2               
+# of the License, or (at your option) any later version.                       
+#                                                                              
+# This program is distributed in the hope that it will be useful,              
+# but WITHOUT ANY WARRANTY; without even the implied warranty of               
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                
+# GNU General Public License for more details.                                 
+#                                                                              
+# You should have received a copy of the GNU General Public License            
+# along with this program; if not, write to the Free Software Foundation,      
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.          
+#------------------------------------------------------------------------------
+
+
+
+
+
+#------------------------------------------------------------------------------
+# Var include
+#------------------------------------------------------------------------------
+
+include ../../Makefile_var.mk
+
+
+
+#------------------------------------------------------------------------------
+# Variables
+#------------------------------------------------------------------------------
+
+TARGET=		imrd
+
+OBJ=		imrd.o
+
+EXTRA_INC=	
+
+EXTRA_LIB=	
+
+
+
+#------------------------------------------------------------------------------
+# Rule include
+#------------------------------------------------------------------------------
+
+include ../../Makefile_rule.mk
diff --git a/src/imrd/src/imrd.c b/src/imrd/src/imrd.c
new file mode 100644
index 0000000..30a2a32
--- /dev/null
+++ b/src/imrd/src/imrd.c
@@ -0,0 +1,1140 @@
+/*----------------------------------------------------------------------------*/
+/* $Workfile:   imrd.c  $                                                     */                                            
+/*----------------------------------------------------------------------------*/
+/* $Author: agibert $                                                      */
+/* $Date: 2008/11/12 02:25:22 $                                           */
+/* $Revision: 1.1 $                                                       */
+/* $Label:  $                                                         */
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#define _IMRD_C_
+
+#include "imrd.h" 
+
+
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Config_Init         			                 	  	      */
+/*----------------------------------------------------------------------------*/
+/* Config_Ptr:   Config structure to initialize                               */
+/* ArgC:         Argument number                                              */
+/* ArgV:         Argument tab                                                 */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  Config_Init( IMRT_Config  *Config_Ptr, int  ArgC, char  **ArgV)
+{
+    struct stat     stat_buf;
+    IMRT_Module_Id  module_id;
+
+
+    /* LM Init */
+
+    strcpy( Config_Ptr->LM.Log_File, "-");
+
+    Config_Ptr->LM.Module_Nb = IMRD_MODULE_NB;
+
+    for( module_id = 0; module_id < IMRD_MODULE_NB; module_id++)
+    {
+	if( module_id == IMRD_MODULE_ID_UNKNOWN)
+	{
+	    Config_Ptr->LM.Level_Tab[ IMRD_LOG_TYPE_ID_TRACE][ module_id]   = IMRD_LOG_LEVEL_UNSET;
+
+	    Config_Ptr->LM.Level_Tab[ IMRD_LOG_TYPE_ID_TRACE][ module_id]   = IMRD_LOG_LEVEL_UNSET;
+	    Config_Ptr->LM.Level_Tab[ IMRD_LOG_TYPE_ID_INFO][ module_id]    = IMRD_LOG_LEVEL_DEFAULT;
+	    Config_Ptr->LM.Level_Tab[ IMRD_LOG_TYPE_ID_WARNING][ module_id] = IMRD_LOG_LEVEL_DEFAULT;
+	    Config_Ptr->LM.Level_Tab[ IMRD_LOG_TYPE_ID_ERROR][ module_id]   = IMRD_LOG_LEVEL_DEFAULT;
+	}
+	else
+	{
+	    Config_Ptr->LM.Level_Tab[ IMRD_LOG_TYPE_ID_TRACE][   module_id] = IMRD_LOG_LEVEL_UNSET;
+	    Config_Ptr->LM.Level_Tab[ IMRD_LOG_TYPE_ID_INFO][    module_id] = IMRD_LOG_LEVEL_UNSET;
+	    Config_Ptr->LM.Level_Tab[ IMRD_LOG_TYPE_ID_WARNING][ module_id] = IMRD_LOG_LEVEL_UNSET;
+	    Config_Ptr->LM.Level_Tab[ IMRD_LOG_TYPE_ID_ERROR][   module_id] = IMRD_LOG_LEVEL_UNSET;
+	}
+    }
+
+
+
+    /* SDM Init */
+
+    Config_Ptr->SDM.Flag = IMRD_SDM_FLAG_XML;
+
+    strncpy( Config_Ptr->SDM.Lib_Path, dirname( ArgV[0]), IMRD_PATH_LEN);
+    strncat( Config_Ptr->SDM.Lib_Path, "/../lib/imr", IMRD_PATH_LEN);
+
+    if( ( stat( Config_Ptr->SDM.Lib_Path, &stat_buf) == -1) || ( ! S_ISDIR( stat_buf.st_mode)))
+    {
+	strcpy( Config_Ptr->SDM.Lib_Path, ".");
+    }
+
+
+
+    /* MM Init */
+
+    Config_Ptr->MM.XML_Format = IMRD_FALSE;
+
+
+
+    /* MR Init */
+
+    Config_Ptr->MR.Mapping_Forced                      = IMRD_FALSE;
+    Config_Ptr->MR.Continue_Forced                     = IMRD_FALSE;
+    Config_Ptr->MR.Read_Mode                           = IMRD_READ_MODE_WAIT;
+    Config_Ptr->MR.Log_Id_Struct_Input.Bit_Nb          = 0;
+    Config_Ptr->MR.Log_Id_Struct_Input.Log_Size        = 0;
+    Config_Ptr->MR.Log_Id_Struct_Input.Log_Id_Bit_Ptr  = NULL;
+    Config_Ptr->MR.Log_Id_Struct_Output.Bit_Nb         = 0;
+    Config_Ptr->MR.Log_Id_Struct_Output.Log_Size       = 0;
+    Config_Ptr->MR.Log_Id_Struct_Output.Log_Id_Bit_Ptr = NULL;
+
+
+
+    /* IMRD Init */
+
+    strcpy( Config_Ptr->IMRD.Medium_URL_Input,  "file://\\nMSG_BREAK\\n@in.txt");
+    strcpy( Config_Ptr->IMRD.Appl_Name_Input,   "bo_raw");
+     Config_Ptr->IMRD.Appl_Id_Input = IMRD_APPL_ID_UNDEFINEDED;
+
+    strcpy( Config_Ptr->IMRD.Medium_URL_Output, "file://\\nMSG_BREAK\\n@out.txt");
+    strcpy( Config_Ptr->IMRD.Appl_Name_Output,  "cristal_raw");
+    Config_Ptr->IMRD.Appl_Id_Output = IMRD_APPL_ID_UNDEFINEDED;
+
+    strcpy( Config_Ptr->IMRD.Medium_URL_Trash,  "file://\\nMSG_BREAK\\n@trash.txt");
+
+    Config_Ptr->IMRD.Version_Mode = IMRD_FALSE;
+    Config_Ptr->IMRD.Help_Mode    = IMRD_FALSE;
+    Config_Ptr->IMRD.Dump_Mode    = IMRD_SDM_FLAG_UNKNOWN;
+    Config_Ptr->IMRD.Core_Dump    = IMRD_FALSE;
+
+
+
+    return( IMRS_OK);
+}
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Config_Deinit      			                 	  	      */
+/*----------------------------------------------------------------------------*/
+/* Config_Ptr:   Config structure to deinitialize                             */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  Config_Deinit( IMRT_Config  *Config_Ptr)
+{
+    if( Config_Ptr->MR.Log_Id_Struct_Input.Log_Id_Bit_Ptr != NULL)
+    {
+	free( Config_Ptr->MR.Log_Id_Struct_Input.Log_Id_Bit_Ptr);
+    }
+
+    if( Config_Ptr->MR.Log_Id_Struct_Output.Log_Id_Bit_Ptr)
+    {
+	free( Config_Ptr->MR.Log_Id_Struct_Output.Log_Id_Bit_Ptr);
+    }
+
+    return( IMRS_OK);
+}
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Args_Parse         			                 	  	      */
+/*----------------------------------------------------------------------------*/
+/* Config_Ptr:   Configuration structure to update                            */
+/* ArgC:         Argument number                                              */
+/* ArgV:         Argument tab                                                 */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  Args_Parse( IMRT_Config  *Config_Ptr, int  ArgC, char  **ArgV)
+{
+    int             arg_cur, i, j;
+    char            value_tmp[ IMRD_ARG_NAME_SIZE];
+    IMRT_Module_Id  module_id;
+
+
+    for( arg_cur = 1; arg_cur < ArgC; arg_cur++)
+    {
+	for( i = 0;
+	     ( i < IMRD_ARG_NB) && ( strcmp( IMRG_Arg_Tab[i].Name_Short, ArgV[arg_cur]) != 0) && ( strcmp( IMRG_Arg_Tab[i].Name_Long, ArgV[arg_cur]) != 0);
+	     i++);
+
+	
+
+	if( ( i > 0) && ( i < IMRD_ARG_NB))
+	{
+
+	    switch( i)
+	    {
+		case IMRD_ARG_VERSION:
+		{
+		    Config_Ptr->IMRD.Version_Mode = IMRD_TRUE;
+
+		    break;
+		}
+
+		case IMRD_ARG_HELP:
+		{
+		    Config_Ptr->IMRD.Help_Mode = IMRD_TRUE;
+
+		    break;
+		}
+
+		case IMRD_ARG_VERBOSE_LEVEL_DEFAULT:
+		{
+		    if( ( arg_cur + 1) < ArgC)
+		    {
+			strncpy( value_tmp, ArgV[ ++arg_cur], IMRD_ARG_NAME_LEN);
+
+			Config_Ptr->LM.Level_Tab[ IMRD_LOG_TYPE_ID_TRACE][   IMRD_MODULE_ID_UNKNOWN] = atoi( value_tmp);
+		    }
+		    else
+		    {
+			IMRD_LM_LOG_ERROR_1( "Missing argument value [%s] !", IMRG_Arg_Tab[ i].Name_Short);
+
+			return( IMRS_KO);
+		    }
+
+		    break;
+		}
+
+		case IMRD_ARG_VERBOSE_LEVEL_MODULE:
+		{
+		    if( ( arg_cur + 2) < ArgC )
+		    {
+			strncpy( value_tmp, ArgV[ ++arg_cur], IMRD_ARG_NAME_LEN);
+			j = atoi( value_tmp);
+
+			strncpy( value_tmp, ArgV[ ++arg_cur], IMRD_ARG_NAME_LEN);
+
+			for( module_id = 1;
+			     ( module_id < IMRD_MODULE_NB) && ( strcmp( value_tmp, IMRG_IMRD_Base.Module_Entry_Tab[ module_id].Module_Ptr->Name) != 0);
+			     module_id++);
+
+			if( module_id == IMRD_MODULE_NB)
+			{
+			    IMRD_LM_LOG_ERROR_1( "Module not found [%s] !", value_tmp);
+
+			    return( IMRS_KO);
+			}
+
+			Config_Ptr->LM.Level_Tab[ IMRD_LOG_TYPE_ID_TRACE][ module_id] = j;
+		    }
+		    else
+		    {
+			IMRD_LM_LOG_ERROR_1( "Missing argument value [%s] !", IMRG_Arg_Tab[ i].Name_Short);
+
+			return( IMRS_KO);
+		    }
+
+		    break;
+		}
+
+		case IMRD_ARG_LOG_FILE:
+		{
+		    if( ( arg_cur + 1) < ArgC)
+		    {
+			strncpy( ( char *) Config_Ptr->LM.Log_File, ArgV[ ++arg_cur], IMRD_PATH_LEN);
+		    }
+		    else
+		    {
+			IMRD_LM_LOG_ERROR_1( "Missing argument value [%s] !", IMRG_Arg_Tab[ i].Name_Short);
+
+			return( IMRS_KO);
+		    }
+
+		    break;
+		}
+
+		case IMRD_ARG_SD_READ_XML:
+		{
+		    Config_Ptr->SDM.Flag = IMRD_SDM_FLAG_XML;
+
+		    break;
+		}
+
+		case IMRD_ARG_SD_READ_SQL:
+		{
+		    Config_Ptr->SDM.Flag = IMRD_SDM_FLAG_SQL;
+
+		    break;
+		}
+
+		case IMRD_ARG_SD_WRITE_XML:
+		{
+		    Config_Ptr->IMRD.Dump_Mode = IMRD_SDM_FLAG_XML;
+
+		    break;
+		}
+
+		case IMRD_ARG_SD_WRITE_SQL:
+		{
+		    Config_Ptr->IMRD.Dump_Mode = IMRD_SDM_FLAG_SQL;
+
+		    break;
+		}
+
+		case IMRD_ARG_LIBRARY_DIR:
+		{
+		    if( ( arg_cur + 1) < ArgC)
+		    {
+			strncpy( ( char *) Config_Ptr->SDM.Lib_Path, ArgV[ ++arg_cur], IMRD_PATH_LEN);
+		    }
+		    else
+		    {
+			IMRD_LM_LOG_ERROR_1( "Missing argument value [%s] !", IMRG_Arg_Tab[ i].Name_Short);
+
+			return( IMRS_KO);
+		    }
+
+		    break;
+		}
+
+		case IMRD_ARG_MEDIUM_URL_INPUT:
+		{
+		    if( ( arg_cur + 1) < ArgC)
+		    {
+			strncpy( ( char *) Config_Ptr->IMRD.Medium_URL_Input, ArgV[ ++arg_cur], IMRD_MEDIUM_URL_LEN);
+		    }
+		    else
+		    {
+			IMRD_LM_LOG_ERROR_1( "Missing argument value [%s] !", IMRG_Arg_Tab[ i].Name_Short);
+
+			return( IMRS_KO);
+		    }
+
+		    break;
+		}
+
+		case IMRD_ARG_APPL_NAME_INPUT:
+		{
+		    if( ( arg_cur + 1) < ArgC)
+		    {
+			strncpy( ( char *) Config_Ptr->IMRD.Appl_Name_Input, ArgV[ ++arg_cur], IMRD_APPL_NAME_LEN);
+		    }
+		    else
+		    {
+			IMRD_LM_LOG_ERROR_1( "Missing argument value [%s] !", IMRG_Arg_Tab[i].Name_Short);
+
+			return( IMRS_KO);
+		    }
+
+		    break;
+		}
+
+		case IMRD_ARG_APPL_ID_INPUT:
+		{
+		    if( ( arg_cur + 1) < ArgC)
+		    {
+			strncpy( value_tmp, ArgV[++arg_cur], IMRD_ARG_NAME_LEN);
+			
+			Config_Ptr->IMRD.Appl_Id_Input = atoi( value_tmp);
+			Config_Ptr->IMRD.Appl_Name_Input[0] = '\0';
+		    }
+		    else
+		    {
+			IMRD_LM_LOG_ERROR_1( "Missing argument value [%s] !", IMRG_Arg_Tab[i].Name_Short);
+
+			return( IMRS_KO);
+		    }
+
+		    break;
+		}
+
+		case IMRD_ARG_MEDIUM_URL_OUTPUT:
+		{
+		    if( ( arg_cur + 1) < ArgC)
+		    {
+			strncpy( ( char *) Config_Ptr->IMRD.Medium_URL_Output, ArgV[ ++arg_cur], IMRD_MEDIUM_URL_LEN);
+		    }
+		    else
+		    {
+			IMRD_LM_LOG_ERROR_1( "Missing argument value [%s] !", IMRG_Arg_Tab[ i].Name_Short);
+
+			return( IMRS_KO);
+		    }
+
+		    break;
+		}
+
+		case IMRD_ARG_APPL_NAME_OUTPUT:
+		{
+		    if( ( arg_cur + 1) < ArgC)
+		    {
+			strncpy( ( char *) Config_Ptr->IMRD.Appl_Name_Output, ArgV[ ++arg_cur], IMRD_APPL_NAME_LEN);
+		    }
+		    else
+		    {
+			IMRD_LM_LOG_ERROR_1( "Missing argument value [%s] !", IMRG_Arg_Tab[i].Name_Short);
+
+			return( IMRS_KO);
+		    }
+
+		    break;
+		}
+
+		case IMRD_ARG_APPL_ID_OUTPUT:
+		{
+		    if( ( arg_cur + 1) < ArgC)
+		    {
+			strncpy( value_tmp, ArgV[ ++arg_cur], IMRD_ARG_NAME_LEN);
+			
+			Config_Ptr->IMRD.Appl_Id_Output = atoi( value_tmp);
+			Config_Ptr->IMRD.Appl_Name_Output[0] = '\0';
+		    }
+		    else
+		    {
+			IMRD_LM_LOG_ERROR_1( "Missing argument value [%s] !", IMRG_Arg_Tab[i].Name_Short);
+
+			return( IMRS_KO);
+		    }
+
+		    break;
+		}
+
+		case IMRD_ARG_MEDIUM_URL_TRASH:
+		{
+		    if( ( arg_cur + 1) < ArgC)
+		    {
+			strncpy( ( char *) Config_Ptr->IMRD.Medium_URL_Trash, ArgV[ ++arg_cur], IMRD_MEDIUM_URL_LEN);
+		    }
+		    else
+		    {
+			IMRD_LM_LOG_ERROR_1( "Missing argument value [%s] !", IMRG_Arg_Tab[ i].Name_Short);
+
+			return( IMRS_KO);
+		    }
+
+		    break;
+		}
+
+		case IMRD_ARG_MAPPING_FORCED:
+		{
+		    Config_Ptr->MR.Mapping_Forced = IMRD_TRUE;
+
+		    break;
+		}
+
+		case IMRD_ARG_CONTINUE_FORCED:
+		{
+		    Config_Ptr->MR.Continue_Forced = IMRD_TRUE;
+
+		    break;
+		}
+
+		case IMRD_ARG_NO_WAIT:
+		{
+		    Config_Ptr->MR.Read_Mode = IMRD_READ_MODE_NO_WAIT;
+
+		    break;
+		}
+
+		case IMRD_ARG_XML_FORMAT:
+		{
+		    Config_Ptr->MM.XML_Format = IMRD_TRUE;
+
+		    break;
+		}
+
+		case IMRD_ARG_CORE_DUMP:
+		{
+		    Config_Ptr->IMRD.Core_Dump = IMRD_TRUE;
+
+		    break;
+		}
+		
+		case IMRD_ARG_LOG_ID_INPUT_MSG :
+		{
+		    if( ( arg_cur + 2) < ArgC)
+		    {
+			if( atoi( ArgV[ arg_cur + 1]) < 0)
+			{
+			    IMRD_LM_LOG_ERROR_1( "Invalid Log_Id_Offset: [%s] !", ArgV[ arg_cur + 1]);
+
+			    return( IMRS_KO);
+			}
+
+			if( atoi( ArgV[ arg_cur + 2]) <= 0)
+			{
+			    IMRD_LM_LOG_ERROR_1( "Invalid Log_Id_Size: [%d] !", ArgV[ arg_cur + 2]);
+
+			    return( IMRS_KO);
+			}
+
+			if( ( Config_Ptr->MR.Log_Id_Struct_Input.Log_Id_Bit_Ptr =
+			      realloc( Config_Ptr->MR.Log_Id_Struct_Input.Log_Id_Bit_Ptr,   
+				       ( ( Config_Ptr->MR.Log_Id_Struct_Input.Bit_Nb + 1)) * sizeof( IMRT_Log_Id_Bit))) == NULL)
+			{
+			    IMRD_LM_LOG_ERROR_1( "Can't allocate Input Log_Id_Bit_Ptr (%d) !", errno);
+
+			    return( IMRS_KO);
+			}
+
+			Config_Ptr->MR.Log_Id_Struct_Input.Log_Id_Bit_Ptr[ Config_Ptr->MR.Log_Id_Struct_Input.Bit_Nb].Offset  = atoi( ArgV[ ++arg_cur]);
+			Config_Ptr->MR.Log_Id_Struct_Input.Log_Id_Bit_Ptr[ Config_Ptr->MR.Log_Id_Struct_Input.Bit_Nb].Size    = atoi( ArgV[ ++arg_cur]);
+			Config_Ptr->MR.Log_Id_Struct_Input.Log_Size                                                          += atoi( ArgV[   arg_cur]);
+			Config_Ptr->MR.Log_Id_Struct_Input.Bit_Nb++;
+		    }
+		    else
+		    {
+			IMRD_LM_LOG_ERROR_1( "Missing argument value [%s] !", IMRG_Arg_Tab[ i].Name_Short);
+			return( IMRS_KO);
+		    }
+
+		    break;
+		}
+
+		case IMRD_ARG_LOG_ID_OUTPUT_MSG :
+		{
+		    if( ( arg_cur + 2) < ArgC)
+		    {
+			if( atoi( ArgV[ arg_cur + 1]) < 0)
+			{
+			    IMRD_LM_LOG_ERROR_1( "Invalid Log_Id_Offset: [%s] !", ArgV[ arg_cur + 1]);
+
+			    return( IMRS_KO);
+			}
+
+			if( atoi( ArgV[ arg_cur + 2]) <= 0)
+			{
+			    IMRD_LM_LOG_ERROR_1( "Invalid Log_Id_Size: [%d] !", ArgV[ arg_cur + 2]);
+
+			    return( IMRS_KO);
+			}
+
+			if( ( Config_Ptr->MR.Log_Id_Struct_Output.Log_Id_Bit_Ptr =
+			      realloc( Config_Ptr->MR.Log_Id_Struct_Output.Log_Id_Bit_Ptr,   
+				       ( ( Config_Ptr->MR.Log_Id_Struct_Output.Bit_Nb + 1)) * sizeof( IMRT_Log_Id_Bit))) == NULL)
+			{
+			    IMRD_LM_LOG_ERROR_1( "Can't allocate Output Log_Id_Bit_Ptr (%d) !", errno);
+
+			    return( IMRS_KO);
+			}
+
+			Config_Ptr->MR.Log_Id_Struct_Output.Log_Id_Bit_Ptr[ Config_Ptr->MR.Log_Id_Struct_Output.Bit_Nb].Offset  = atoi( ArgV[ ++arg_cur]);
+			Config_Ptr->MR.Log_Id_Struct_Output.Log_Id_Bit_Ptr[ Config_Ptr->MR.Log_Id_Struct_Output.Bit_Nb].Size    = atoi( ArgV[ ++arg_cur]);
+			Config_Ptr->MR.Log_Id_Struct_Output.Log_Size                                                           += atoi( ArgV[   arg_cur]);
+			Config_Ptr->MR.Log_Id_Struct_Output.Bit_Nb++;
+		    }
+		    else
+		    {
+			IMRD_LM_LOG_ERROR_1( "Missing argument value [%s] !", IMRG_Arg_Tab[ i].Name_Short);
+			return( IMRS_KO);
+		    }
+		    
+		    break;
+		}
+
+
+		default:
+		{
+		    IMRD_LM_LOG_ERROR_1( "Internal parse error [%d] !", i);
+		    
+		    return( IMRS_KO);
+		}
+	    }
+	}
+	else
+	{
+	    IMRD_LM_LOG_ERROR_1( "Unreconized argument: (%s) !", ArgV[arg_cur]);
+
+	    return( IMRS_KO);
+	}
+    }
+
+    return( IMRS_OK);
+}
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Args_Log      			                 	  	      */
+/*----------------------------------------------------------------------------*/
+/* Config_Ptr:   Configuration structure to dump                              */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  Args_Log( IMRT_Config  *Config_Ptr)
+{
+    IMRT_Module_Id  module_id;
+    int             idx;
+   
+
+    IMRD_LM_LOG_INFO_3( "Lib_Dir: [%s]   Static_Data_Read: [%s]   Static_Data_Write: [%s]",
+			Config_Ptr->SDM.Lib_Path,
+			( ( Config_Ptr->SDM.Flag == IMRD_SDM_FLAG_XML) ? "XML" : ( ( Config_Ptr->SDM.Flag == IMRD_SDM_FLAG_SQL) ? "SQL" : "Unknown")),
+			( ( Config_Ptr->IMRD.Dump_Mode == IMRD_SDM_FLAG_XML) ? "XML" : ( ( Config_Ptr->IMRD.Dump_Mode == IMRD_SDM_FLAG_SQL) ? "SQL" : "Unknown")));
+    IMRD_LM_LOG_INFO_3( "Mapping_Forced: [%s]   Continue_Forced: [%s]   Read_Mode: [%s]",
+			( ( Config_Ptr->MR.Mapping_Forced == IMRD_TRUE) ? "True" : "False"),
+			( ( Config_Ptr->MR.Continue_Forced == IMRD_TRUE) ? "True" : "False"),
+			( ( Config_Ptr->MR.Read_Mode == IMRD_READ_MODE_WAIT) ? "Wait" : ( ( Config_Ptr->MR.Read_Mode == IMRD_READ_MODE_NO_WAIT) ? "No Wait" : "Unknown")));
+    IMRD_LM_LOG_INFO_2( "XML_Format: [%s]   Core_Dump: [%s]", ( ( Config_Ptr->MM.XML_Format == IMRD_TRUE) ? "True" : "False"), ( ( Config_Ptr->IMRD.Core_Dump == IMRD_TRUE) ? "True" : "False"));
+    IMRD_LM_LOG_INFO_1( "Medium_URL_Input:  [%s]", Config_Ptr->IMRD.Medium_URL_Input);
+    IMRD_LM_LOG_INFO_1( "Medium_URL_Output: [%s]", Config_Ptr->IMRD.Medium_URL_Output);
+    IMRD_LM_LOG_INFO_1( "Medium_URL_Trash:  [%s]", Config_Ptr->IMRD.Medium_URL_Trash);
+    IMRD_LM_LOG_INFO_0( "Log Level Tab: Module Id                               Trace   Info   Warning  Error");
+    
+    for( module_id = 0; module_id < IMRD_MODULE_NB; module_id++)
+    {
+	IMRD_LM_LOG_INFO_5( "Log Level tab: [%-34s]:   (%3d)   (%3d)   (%3d)   (%3d)",
+			    ( ( IMRG_IMRD_Base.Module_Entry_Tab[ module_id].Module_Ptr == NULL) ? "Default" : IMRG_IMRD_Base.Module_Entry_Tab[ module_id].Module_Ptr->Name_Long),
+			    Config_Ptr->LM.Level_Tab[ IMRD_LOG_TYPE_ID_TRACE][   module_id],
+			    Config_Ptr->LM.Level_Tab[ IMRD_LOG_TYPE_ID_INFO][    module_id],
+			    Config_Ptr->LM.Level_Tab[ IMRD_LOG_TYPE_ID_WARNING][ module_id],
+			    Config_Ptr->LM.Level_Tab[ IMRD_LOG_TYPE_ID_ERROR][   module_id]);
+    }
+
+    for( idx = 0 ; idx < Config_Ptr->MR.Log_Id_Struct_Input.Bit_Nb; idx++)
+    {
+	IMRD_LM_LOG_INFO_2( "Log_Id_Bit_Input:    Offset: (%5d)   Size: (%5d)",
+			    Config_Ptr->MR.Log_Id_Struct_Input.Log_Id_Bit_Ptr[ idx].Offset,
+			    Config_Ptr->MR.Log_Id_Struct_Input.Log_Id_Bit_Ptr[ idx].Size);
+    }
+
+    for( idx = 0 ; idx < Config_Ptr->MR.Log_Id_Struct_Output.Bit_Nb; idx++)
+    {
+	IMRD_LM_LOG_INFO_2( "Log_Id_Bit_Output:   Offset: (%5d)   Size: (%5d)",
+			    Config_Ptr->MR.Log_Id_Struct_Output.Log_Id_Bit_Ptr[ idx].Offset,
+			    Config_Ptr->MR.Log_Id_Struct_Output.Log_Id_Bit_Ptr[ idx].Size);
+    }
+
+    return( IMRS_OK);
+}
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Version_Log      			                 	  	      */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  Version_Log()
+{
+    IMRT_Module_Id   module_id;
+
+
+    for( module_id = 0; module_id < IMRD_MODULE_NB; module_id++)
+    {
+	if( IMRG_IMRD_Base.Module_Entry_Tab[ module_id].Module_Ptr != NULL)
+	{
+	    IMRD_LM_LOG_INFO_2( "[%-4s]: [%s]", IMRG_IMRD_Base.Module_Entry_Tab[ module_id].Module_Ptr->Name, IMRG_IMRD_Base.Module_Entry_Tab[ module_id].Module_Ptr->Version);
+	}
+    }
+
+    return( IMRS_OK);
+}
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Version_Print     			                 	  	      */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  Version_Print()
+{
+    IMRT_Module_Id   module_id;
+
+
+    for( module_id = 0; module_id < IMRD_MODULE_NB; module_id++)
+    {
+	if( IMRG_IMRD_Base.Module_Entry_Tab[ module_id].Module_Ptr != NULL)
+	{
+	    fprintf( stderr, "[%-4s]: [%s]\n", IMRG_IMRD_Base.Module_Entry_Tab[ module_id].Module_Ptr->Name, IMRG_IMRD_Base.Module_Entry_Tab[ module_id].Module_Ptr->Version);
+	}
+    }
+
+    return( IMRS_OK);
+}
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Help_Print    			                 	  	      */
+/*----------------------------------------------------------------------------*/
+/*                                                                            */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  Help_Print( void)
+{
+    int  i;
+
+
+    for( i = 0; i < IMRD_ARG_NB; i++)
+    {
+	if( IMRG_Arg_Tab[i].Name_Short[0] != '\0')
+	    fprintf( stderr, "%-6s%-25s%s\n", IMRG_Arg_Tab[i].Name_Short, IMRG_Arg_Tab[i].Name_Long, IMRG_Arg_Tab[i].Help);
+    }
+
+    return( IMRS_OK);
+}
+
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Lib_Open                                                                   */
+/*----------------------------------------------------------------------------*/
+/* Module_Entry_Ptr:   Module to open                                         */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  Lib_Open( IMRT_Module_Entry  *Module_Entry_Ptr)
+{
+    IMRT_Status  status;
+
+
+    if( Module_Entry_Ptr->Module_Ptr->Lib.Open_Ptr != NULL)
+    {
+	IMRD_LM_LOG_TRACE_1( IMRD_LOG_LEVEL_VERBOSE_0, "Opening %s library...", Module_Entry_Ptr->Module_Ptr->Name_Long);
+
+	if( ( status = Module_Entry_Ptr->Module_Ptr->Lib.Open_Ptr( Module_Entry_Ptr->Config_Ptr)) != IMRS_OK)
+	{
+	    Module_Entry_Ptr->Status = IMRD_LIB_STATUS_ERROR;
+	
+	    IMRD_LM_LOG_ERROR_1( "Can't open %s library !", Module_Entry_Ptr->Module_Ptr->Name_Long);
+	}
+	else
+	{
+	    Module_Entry_Ptr->Status = IMRD_LIB_STATUS_OPENED;
+	
+	    IMRD_LM_LOG_TRACE_1( IMRD_LOG_LEVEL_VERBOSE_0, "%s library opened !", Module_Entry_Ptr->Module_Ptr->Name_Long);
+	}
+    }
+
+    return( status);
+}
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Libs_Open    			                 	  	      */
+/*----------------------------------------------------------------------------*/
+/* Module_Entry_Tab:   Module tab                                             */
+/* Module_Nb:          Number of module                                       */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  Libs_Open( IMRT_Module_Entry  *Module_Entry_Tab, IMRT_Module_Id  Module_Nb)
+{
+    IMRT_Status     status;
+    IMRT_Module_Id  i;
+
+
+    for( i = 0, status = IMRS_OK; ( i < Module_Nb) && ( status == IMRS_OK); i++)
+    {
+	if( ( Module_Entry_Tab[i].Module_Ptr != NULL)
+	    && ( Module_Entry_Tab[i].Module_Ptr->Type == IMRD_MODULE_TYPE_LIBRARY) 
+	    && ( Module_Entry_Tab[i].Module_Ptr->Lib.Open_Ptr != NULL)
+	    && ( Module_Entry_Tab[i].Status == IMRD_LIB_STATUS_CLOSED))
+	{
+	    status = Lib_Open( &( Module_Entry_Tab[i]));
+	}
+    }
+
+    return( status);
+}
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Lib_Close                                                                  */
+/*----------------------------------------------------------------------------*/
+/* Module_Entry_Ptr:   Module to close                                        */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  Lib_Close( IMRT_Module_Entry  *Module_Entry_Ptr)
+{
+    IMRT_Status  status;
+
+
+    IMRD_LM_LOG_TRACE_1( IMRD_LOG_LEVEL_VERBOSE_0, "Closinging %s library...", Module_Entry_Ptr->Module_Ptr->Name_Long);
+
+    if( ( status = Module_Entry_Ptr->Module_Ptr->Lib.Close_Ptr()) != IMRS_OK)
+    {
+	Module_Entry_Ptr->Status = IMRD_LIB_STATUS_ERROR;
+	
+	IMRD_LM_LOG_ERROR_1( "Can't close %s library !", Module_Entry_Ptr->Module_Ptr->Name_Long);
+    }
+    else
+    {
+	Module_Entry_Ptr->Status = IMRD_LIB_STATUS_CLOSED;
+
+	IMRD_LM_LOG_TRACE_1( IMRD_LOG_LEVEL_VERBOSE_0, "%s library closed !", Module_Entry_Ptr->Module_Ptr->Name_Long);
+    }
+
+    return( status);
+}
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Libs_Close    			                 	  	      */
+/*----------------------------------------------------------------------------*/
+/* Module_Entry_Tab:   Module tab                                             */
+/* Module_Nb:          Number of module                                       */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  Libs_Close( IMRT_Module_Entry  *Module_Entry_Tab, IMRT_Module_Id  Module_Nb)
+{
+    IMRT_Status     status;
+    IMRT_Module_Id  i;
+
+
+    for( i = ( Module_Nb - 1), status = IMRS_OK; ( i > -1) && ( status == IMRS_OK); i--)
+    {
+	if( ( Module_Entry_Tab[i].Module_Ptr != NULL) && ( Module_Entry_Tab[i].Module_Ptr->Lib.Open_Ptr != NULL))
+	{
+	    if( Module_Entry_Tab[i].Status == IMRD_LIB_STATUS_OPENED)
+	    {
+		status = Lib_Close( &( Module_Entry_Tab[i]));
+	    }
+	    else
+	    {
+		IMRD_LM_LOG_TRACE_1( IMRD_LOG_LEVEL_VERBOSE_0, "%s library not opened !", Module_Entry_Tab[i].Module_Ptr->Name_Long);
+	    }
+	}
+    }
+
+    return( status);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Signal_Trap                                                                  */
+/*------------------------------------------------------------------------------*/
+
+void  Signal_Trap( int  Sig_Num)
+{
+	
+    fprintf( stderr, "Signal: (%d) !\n", Sig_Num);
+    
+    switch( Sig_Num)
+    {
+	case SIGBUS:
+	case SIGSEGV:
+	{
+	    if( ( IMRG_Base.Sig_Trapped == SIGBUS) || ( IMRG_Base.Sig_Trapped == SIGSEGV))
+	    {
+		fprintf( stderr, "Imediate exit !!!\n");
+		exit( -1);
+	    }
+	    else
+	    {
+		fprintf( stderr, "Long Jumping...\n");
+		IMRG_Base.Sig_Trapped = Sig_Num;
+		
+		siglongjmp( IMRG_Base.SigLongJmp_Env, 1);
+	    }
+	    
+	    break;
+	}
+	
+	case SIGINT:
+	case SIGQUIT:
+	case SIGTERM:
+	default:
+	{
+	    if( IMRG_Base.Sig_Trapped != 0)
+	    {
+		fprintf( stderr, "Signal rejected: (%d) !\n", Sig_Num);
+	    }
+	    else
+	    {
+		IMRG_Base.Sig_Trapped = Sig_Num;
+	    }
+	    
+	    break;
+	}
+    }
+}
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Signal_Init    			                 	  	      */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  Signal_Init()
+{
+    int               rc;
+    struct sigaction  act = {0};
+
+    act.sa_handler = Signal_Trap;
+
+
+    if( ( rc = sigaction( SIGINT, &act, &( IMRG_IMRD_Base.OAct_Int))) != 0)
+    {
+	IMRD_LM_LOG_ERROR_2( "Can't trap signal (%d)   errno: (%d) !", SIGINT, errno);
+
+	return( IMRS_KO);
+    }
+
+    if( ( rc = sigaction( SIGQUIT, &act, &( IMRG_IMRD_Base.OAct_Quit))) != 0)
+    {
+	IMRD_LM_LOG_ERROR_2( "Can't trap signal (%d)   errno: (%d) !", SIGQUIT, errno);
+
+	return( IMRS_KO);
+    }
+
+    if( ( rc = sigaction( SIGTERM, &act, &( IMRG_IMRD_Base.OAct_Int))) != 0)
+    {
+	IMRD_LM_LOG_ERROR_2( "Can't trap signal (%d)   errno: (%d) !", SIGTERM, errno);
+
+	return( IMRS_KO);
+    }
+
+    if( IMRG_IMRD_Base.Config.IMRD.Core_Dump == IMRD_FALSE)
+    {
+	if( ( rc = sigaction( SIGBUS, &act, &( IMRG_IMRD_Base.OAct_Bus))) != 0)
+	{
+	    IMRD_LM_LOG_ERROR_2( "Can't trap signal (%d)   errno: (%d) !", SIGBUS, errno);
+	    
+	    return( IMRS_KO);
+	}
+
+	if( ( rc = sigaction( SIGSEGV, &act, &( IMRG_IMRD_Base.OAct_SegV))) != 0)
+	{
+	    IMRD_LM_LOG_ERROR_2( "Can't trap signal (%d)   errno: (%d) !", SIGSEGV, errno);
+	    
+	    return( IMRS_KO);
+	}
+    }
+
+    return( IMRS_OK);
+}
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* main         			                 	  	      */
+/*----------------------------------------------------------------------------*/
+/* ArgC:  Argument number                                                     */
+/* ArgV:  Argument tab                                                        */
+/*----------------------------------------------------------------------------*/
+
+int  main( int  ArgC, char  **ArgV)
+{
+    IMRT_Status      status;
+    NDT_Status       nd_status;
+    int              exit_status;
+    IMRT_Config     *config_ptr = &( IMRG_IMRD_Base.Config);
+    IMRT_Module_Id   module_id;
+
+
+    if( sigsetjmp( IMRG_Base.SigLongJmp_Env, 1) != 0 )
+    {
+	IMRD_LM_LOG_TRACE_1( IMRD_LOG_LEVEL_VERBOSE_0, "Exiting on signal (%d)...", IMRG_Base.Sig_Trapped);
+
+	ND_Library_StdErr_Set( NULL);
+	exit_status = 0;
+    }
+    else
+    {
+	if( ( status = Config_Init( config_ptr, ArgC, ArgV)) != IMRS_OK)
+	{
+	    IMRD_LM_LOG_ERROR_0( "Can't init config !");
+
+	    exit( -1);
+	}
+
+	if( ( status = Args_Parse( config_ptr, ArgC, ArgV)) != IMRS_OK)
+	{
+	    IMRD_LM_LOG_ERROR_0( "Can't parse args !");
+
+	    exit( -1);
+	}
+
+	if( ( status = Signal_Init()) != IMRS_OK)
+	{
+	    IMRD_LM_LOG_ERROR_0( "Can't init signals !");
+
+	    exit( -1);
+	}
+
+	if( config_ptr->IMRD.Version_Mode == IMRD_TRUE)
+	{
+	    Version_Print();
+	    exit( 0);
+	}
+
+	if( config_ptr->IMRD.Help_Mode == IMRD_TRUE)
+	{
+	    Help_Print();
+	    exit( 0);
+	}
+
+	if( ( status = Lib_Open( &( IMRG_IMRD_Base.Module_Entry_Tab[1]))) != IMRS_OK)
+	{
+	    exit( -1);
+	}
+
+	if( ( status = Version_Log()) != IMRS_OK)
+	{
+	    IMRD_LM_LOG_ERROR_0( "Can't log versions !");
+
+	    exit( -1);
+	}
+
+	if( ( nd_status = ND_Library_Open( NDD_TRUE)) != NDS_OK)
+	{
+	    IMRD_LM_LOG_ERROR_1( "Can't open node library (%d) !", nd_status);
+
+	    exit( -1);
+	}
+
+	IMRD_LM_LOG_TRACE_0( IMRD_LOG_LEVEL_VERBOSE_0, "Node library opened !");
+    
+	if( ( status = Libs_Open( IMRG_IMRD_Base.Module_Entry_Tab, IMRD_MODULE_NB)) != IMRS_OK)
+	{
+	    exit_status = -1;
+	}
+	else
+	{
+	    if( ( status = Args_Log( config_ptr)) != IMRS_OK)
+	    {
+		exit_status = -1;
+	    }
+	    else
+	    {
+		switch( config_ptr->IMRD.Dump_Mode)
+		{
+		    case IMRD_SDM_FLAG_XML:
+		    {
+			if( IMR_SDM_XML_Dump() != IMRS_OK)
+			{
+			    exit_status = -1;
+			}
+			else
+			{
+			    exit_status = 0;
+			}
+
+			break;
+		    }
+
+		    case IMRD_SDM_FLAG_SQL:
+		    {
+			if( IMR_SDM_SQL_Dump() != IMRS_OK)
+			{
+			    exit_status = -1;
+			}
+			else
+			{
+			    exit_status = 0;
+			}
+
+			break;
+		    }
+
+		    default:
+		    {
+			if( ( config_ptr->IMRD.Appl_Id_Input == IMRD_APPL_ID_UNDEFINEDED) && ( IMR_SDM_Appl_Id_Get( &( config_ptr->IMRD.Appl_Id_Input), config_ptr->IMRD.Appl_Name_Input) != IMRS_OK))
+			{
+			    IMRD_LM_LOG_ERROR_1( "Can't get Appl_Id from [%s] !", config_ptr->IMRD.Appl_Name_Input);
+			    
+			    exit_status = -1;
+			}
+			else
+			{
+			    if( ( config_ptr->IMRD.Appl_Id_Output == IMRD_APPL_ID_UNDEFINEDED) && ( IMR_SDM_Appl_Id_Get( &( config_ptr->IMRD.Appl_Id_Output), config_ptr->IMRD.Appl_Name_Output) != IMRS_OK))
+			    {
+				IMRD_LM_LOG_ERROR_1( "Can't get Appl_Id from [%s] !", config_ptr->IMRD.Appl_Name_Output);
+
+				exit_status = -1;
+			    }
+			    else
+			    {
+				IMRD_LM_LOG_INFO_2( "Appl_Name_Input:  [%s]   Appl_Id_Input:  (%d)", config_ptr->IMRD.Appl_Name_Input, config_ptr->IMRD.Appl_Id_Input);
+				IMRD_LM_LOG_INFO_2( "Appl_Name_Output: [%s]   Appl_Id_Output: (%d)", config_ptr->IMRD.Appl_Name_Output, config_ptr->IMRD.Appl_Id_Output);
+
+				if( ( status = IMR_MR_Proceed( config_ptr->IMRD.Medium_URL_Output, config_ptr->IMRD.Appl_Id_Output, config_ptr->IMRD.Medium_URL_Trash, config_ptr->IMRD.Medium_URL_Input, config_ptr->IMRD.Appl_Id_Input)) != IMRS_OK)
+				{
+				    exit_status = -1;
+				}
+				else
+				{
+				    exit_status = 0;
+				}
+			    }
+			}
+
+			break;
+		    }
+		}
+	    }
+	}
+    }
+    
+    if( ( status = Libs_Close( IMRG_IMRD_Base.Module_Entry_Tab, IMRD_MODULE_NB)) != IMRS_OK)
+    {
+	exit_status = -1;
+    }
+
+    if( ( nd_status = ND_Library_Close()) != NDS_OK)
+    {
+	IMRD_LM_LOG_ERROR_1( "Can't close node library (%d)", nd_status);
+	    
+	exit_status = -1;
+    }
+    else
+    {
+	IMRD_LM_LOG_TRACE_0( IMRD_LOG_LEVEL_VERBOSE_0, "Node library closed !");
+    }
+
+    if( ( status = Config_Deinit( config_ptr)) != IMRS_OK)
+    {
+	IMRD_LM_LOG_ERROR_0( "Can't deinit config !");
+	
+	exit_status = -1;
+    }
+
+    exit( exit_status);
+}
diff --git a/src/imrd/src/imrd.h b/src/imrd/src/imrd.h
new file mode 100644
index 0000000..837cdb4
--- /dev/null
+++ b/src/imrd/src/imrd.h
@@ -0,0 +1,415 @@
+/*----------------------------------------------------------------------------*/
+/* File: imrd.h 				         		      */
+/*----------------------------------------------------------------------------*/
+/*                                                                            */
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#ifndef _IMRD_H_
+#define _IMRD_H_
+
+
+
+#include <imr.h>
+
+
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Local Return Status                                                        */
+/*----------------------------------------------------------------------------*/
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Module Definitions                                                         */
+/*----------------------------------------------------------------------------*/
+
+#define IMRD_IMRD_MODULE_ID                ( IMRT_Module_Id) 6
+#define IMRD_IMRD_MODULE_NAME            ( IMRT_Module_Name) "imrd"
+#define IMRD_IMRD_MODULE_NAME_LONG  ( IMRT_Module_Name_Long) "Interlinking Message Router Daemon"
+#define IMRD_IMRD_MODULE_VERSION      ( IMRT_Module_Version) "@(#) VERSIONIMR: $Label:  $   $Date: 2008/11/12 02:25:22 $   $Workfile:   imrd.h  $"
+
+#define IMRD_MODULE_PTR                                      &IMRG_IMRD_Module
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Local Definitions                                                          */
+/*----------------------------------------------------------------------------*/
+
+typedef struct IMRT_Module_Entry
+{
+	IMRT_Module      *Module_Ptr;
+	IMRT_Lib_Status   Status;
+	IMRT_Lib_Config  *Config_Ptr;
+}  IMRT_Module_Entry;
+
+
+
+typedef struct IMRT_IMRD_Config
+{
+	IMRT_Medium_URL  Medium_URL_Input, Medium_URL_Output, Medium_URL_Trash;
+	IMRT_Appl_Name   Appl_Name_Input,  Appl_Name_Output;
+	IMRT_Appl_Id     Appl_Id_Input,    Appl_Id_Output;
+	IMRT_Boolean     Version_Mode,     Help_Mode;
+	IMRT_SDM_Flag    Dump_Mode;
+	IMRT_Boolean     Core_Dump;
+}  IMRT_IMRD_Config;
+
+
+
+typedef struct IMRT_Config
+{
+	IMRT_LM_Config    LM;
+	IMRT_SDM_Config   SDM;
+	IMRT_IOM_Config   IOM;
+	IMRT_MM_Config    MM;
+	IMRT_MR_Config    MR;
+	IMRT_IMRD_Config  IMRD;
+}  IMRT_Config;
+
+
+
+#define IMRD_MODULE_NB  ( IMRT_Module_Id) 7
+
+
+
+typedef struct IMRT_IMRD_Base
+{
+//	IMRT_Module_Nb     Module_Nb;
+	IMRT_Module_Entry  Module_Entry_Tab[ IMRD_MODULE_NB];
+	IMRT_Config        Config;
+	int                Sig_Trapped;
+	sigjmp_buf         SigLongJmp_Env;
+	struct sigaction   OAct_Int, OAct_Quit, OAct_Term, OAct_Bus, OAct_SegV;
+
+}  IMRT_IMRD_Base;
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Global Variables                                                           */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Module  IMRG_IMRD_Module = 
+{ 
+    IMRD_IMRD_MODULE_ID,
+    IMRD_IMRD_MODULE_NAME,
+    IMRD_IMRD_MODULE_NAME_LONG,
+    IMRD_IMRD_MODULE_VERSION,
+    IMRD_MODULE_TYPE_OBJECT,
+    { 
+	IMRD_LIB_STATUS_UNKNOWN,
+	NULL,
+	NULL
+    }
+};
+
+
+
+IMRT_IMRD_Base  IMRG_IMRD_Base = 
+{
+//    IMRD_LIB_NB,
+    {
+	{ NULL,              IMRD_LIB_STATUS_UNKNOWN,                      NULL},
+	{ &IMRG_LM_Module,   IMRD_LIB_STATUS_CLOSED,  (IMRT_Lib_Config  *) &( IMRG_IMRD_Base.Config.LM)},
+	{ &IMRG_SDM_Module,  IMRD_LIB_STATUS_CLOSED,  (IMRT_Lib_Config  *) &( IMRG_IMRD_Base.Config.SDM)},
+	{ &IMRG_IOM_Module,  IMRD_LIB_STATUS_CLOSED,  (IMRT_Lib_Config  *) &( IMRG_IMRD_Base.Config.IOM)},
+	{ &IMRG_MM_Module,   IMRD_LIB_STATUS_CLOSED,  (IMRT_Lib_Config  *) &( IMRG_IMRD_Base.Config.MM)},
+	{ &IMRG_MR_Module,   IMRD_LIB_STATUS_CLOSED,  (IMRT_Lib_Config  *) &( IMRG_IMRD_Base.Config.MR)},
+	{ &IMRG_IMRD_Module, IMRD_LIB_STATUS_UNKNOWN, (IMRT_Lib_Config  *) &( IMRG_IMRD_Base.Config.IMRD)}
+    },
+    {
+	{ "", 0, { 0 } },
+	{ IMRD_SDM_FLAG_UNKNOWN, ""},
+	{ NULL},
+	{ IMRD_FALSE},
+	{ IMRD_FALSE, IMRD_READ_MODE_WAIT},
+	{ "", "", "", "", "", 0, 0, IMRD_FALSE, IMRD_FALSE, IMRD_SDM_FLAG_UNKNOWN, IMRD_FALSE}
+    }
+};
+
+
+
+IMRT_Base  IMRG_Base = 
+{
+    0,
+    {0}
+};
+
+
+
+#define IMRD_ARG_NAME_LEN   ( short) 63
+#define IMRD_ARG_NAME_SIZE  ( short) (IMRD_ARG_NAME_LEN + 1)
+
+typedef char  IMRT_Arg_Name[ IMRD_ARG_NAME_SIZE];
+
+
+
+#define IMRD_ARG_HELP_LEN   ( short) 128
+#define IMRD_ARG_HELP_SIZE  ( short) 128
+
+typedef char  IMRT_Arg_Help[ IMRD_ARG_HELP_SIZE];
+
+
+
+typedef short  IMRT_ARG_ID;
+
+#define IMRD_ARG_NB  ( IMRT_ARG_ID) 25
+
+#define IMRD_ARG_UNKNOWN                ( IMRT_ARG_ID)  0
+#define IMRD_ARG_VERSION                ( IMRT_ARG_ID)  1
+#define IMRD_ARG_HELP                   ( IMRT_ARG_ID)  2
+#define IMRD_ARG_VERBOSE_LEVEL_DEFAULT  ( IMRT_ARG_ID)  3
+#define IMRD_ARG_VERBOSE_LEVEL_MODULE   ( IMRT_ARG_ID)  4
+#define IMRD_ARG_LOG_FILE               ( IMRT_ARG_ID)  5
+#define IMRD_ARG_SD_READ_XML            ( IMRT_ARG_ID)  6
+#define IMRD_ARG_SD_READ_SQL            ( IMRT_ARG_ID)  7
+#define IMRD_ARG_SD_WRITE_XML           ( IMRT_ARG_ID)  8
+#define IMRD_ARG_SD_WRITE_SQL           ( IMRT_ARG_ID)  9
+#define IMRD_ARG_LIBRARY_DIR            ( IMRT_ARG_ID) 10
+#define IMRD_ARG_MEDIUM_URL_INPUT       ( IMRT_ARG_ID) 11
+#define IMRD_ARG_MEDIUM_URL_OUTPUT      ( IMRT_ARG_ID) 12
+#define IMRD_ARG_MEDIUM_URL_TRASH       ( IMRT_ARG_ID) 13
+#define IMRD_ARG_APPL_NAME_INPUT        ( IMRT_ARG_ID) 14
+#define IMRD_ARG_APPL_NAME_OUTPUT       ( IMRT_ARG_ID) 15
+#define IMRD_ARG_APPL_ID_INPUT          ( IMRT_ARG_ID) 16
+#define IMRD_ARG_APPL_ID_OUTPUT         ( IMRT_ARG_ID) 17
+#define IMRD_ARG_MAPPING_FORCED         ( IMRT_ARG_ID) 18
+#define IMRD_ARG_CONTINUE_FORCED        ( IMRT_ARG_ID) 19
+#define IMRD_ARG_NO_WAIT                ( IMRT_ARG_ID) 20
+#define IMRD_ARG_XML_FORMAT             ( IMRT_ARG_ID) 21
+#define IMRD_ARG_CORE_DUMP              ( IMRT_ARG_ID) 22
+#define IMRD_ARG_LOG_ID_INPUT_MSG       ( IMRT_ARG_ID) 23
+#define IMRD_ARG_LOG_ID_OUTPUT_MSG      ( IMRT_ARG_ID) 24
+
+
+typedef struct IMRT_Arg
+{
+	IMRT_Arg_Name   Name_Short;
+	IMRT_Arg_Name   Name_Long;
+	IMRT_Arg_Help   Help;
+}  IMRT_Arg;
+
+
+
+IMRT_Arg  IMRG_Arg_Tab[ IMRD_ARG_NB] =
+{
+    { "",      "",                        "Unknown"},
+    { "-V",    "--version",               "Print version"},
+    { "-h",    "--help",                  "Print this help"},
+    { "-vld",  "--verbose_level_default", "Set the genral verbose level"},
+    { "-vlm",  "--verbose_level_module",  "Set the module verbose level"},
+    { "-lf",   "--log_file",              "Set log file"},
+#ifdef ORACLE_SUPPORT
+    { "-sdrx", "--static_data_read_xml",  "Read  static data from xml repository"},
+    { "-sdrs", "--static_data_read_sql",  "Read  static data from sql repository"},
+    { "-sdwx", "--static_data_write_xml", "Write static data to   xml repository"},
+    { "-sdws", "--static_data_write_sql", "Write static data to   sql repository"},
+#else
+    { "",      "",                        "None"},
+    { "",      "",                        "None"},
+    { "",      "",                        "None"},
+    { "",      "",                        "None"},
+#endif /* ORACLE_SUPPORT */
+    { "-ld",   "--library_dir",           "Set imr library dir"},
+    { "-mui",  "--medium_url_input",      "Set input  medium url"},
+    { "-muo",  "--medium_url_output",     "Set output medium url"},
+    { "-mut",  "--medium_url_trash",      "Set trash  medium url"},
+    { "-ani",  "--appl_name_input",       "Set input  appl name"},
+    { "-ano",  "--appl_name_output",      "Set output appl name"},
+    { "-aii",  "--appl_id_input",         "Set input  appl id"},
+    { "-aio",  "--appl_id_output",        "Set output appl id"},
+    { "-mf",   "--mapping_forced",        "Output bad mapped buffer"},
+    { "-cf",   "--continue_forced",       "Continue on mapping error"},
+    { "-nw",   "--no_wait",               "Don't wait if nothing to read"},
+    { "-xf",   "--xml_format",            "Format xml output buffer"},
+    { "-cd",   "--core_dump",             "Dump core on SIGSEGV and SIGBUS"},
+    { "-iim",  "--id_input_message",      "Log Id input  message"},
+    { "-iom",  "--id_output_message",     "Log Id output message"}
+};
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Prototypes                                                                 */
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* Config_Init         			                 	  	      */
+/*----------------------------------------------------------------------------*/
+/* Config_Ptr:   Config structure to initialize                               */
+/* ArgC:         Argument number                                              */
+/* ArgV:         Argument tab                                                 */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  Config_Init( IMRT_Config  *, int, char  **);
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Config_Deinit      			                 	  	      */
+/*----------------------------------------------------------------------------*/
+/* Config_Ptr:   Config structure to deinitialize                             */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  Config_Deinit( IMRT_Config  *);
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Args_Parse         			                 	  	      */
+/*----------------------------------------------------------------------------*/
+/* Config_Ptr:   Configuration structure to update                            */
+/* ArgC:         Argument number                                              */
+/* ArgV:         Argument tab                                                 */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  Args_Parse( IMRT_Config  *, int, char  **);
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Args_Log      			                 	  	      */
+/*----------------------------------------------------------------------------*/
+/* Config_Ptr:   Configuration structure to dump                              */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  Args_Log( IMRT_Config  *);
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Version_Log      			                 	  	      */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  Version_Log( void);
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Version_Print      			                 	  	      */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  Version_Print( void);
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Help_Print    			                 	  	      */
+/*----------------------------------------------------------------------------*/
+/*                                                                            */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  Help_Print( void);
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Lib_Open                                                                   */
+/*----------------------------------------------------------------------------*/
+/* Module_Entry_Ptr:   Module to open                                         */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  Lib_Open( IMRT_Module_Entry  *);
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Libs_Open    			                 	  	      */
+/*----------------------------------------------------------------------------*/
+/* Module_Entry_Tab:   Module tab                                             */
+/* Module_Nb:          Number of module                                       */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  Libs_Open( IMRT_Module_Entry  *, IMRT_Module_Id);
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Lib_Close                                                                  */
+/*----------------------------------------------------------------------------*/
+/* Module_Entry_Ptr:   Module to close                                        */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  Lib_Close( IMRT_Module_Entry  *);
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Libs_Close    			                 	  	      */
+/*----------------------------------------------------------------------------*/
+/* Module_Entry_Tab:   Module tab                                             */
+/* Module_Nb:          Number of module                                       */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  Libs_Close( IMRT_Module_Entry  *, IMRT_Module_Id);
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Signal_Trap                                                                  */
+/*------------------------------------------------------------------------------*/
+
+void  Signal_Trap( int);
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Signal_Init    			                 	  	      */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  Signal_Init();
+
+
+
+/*----------------------------------------------------------------------------*/
+/* main                                                                       */
+/*----------------------------------------------------------------------------*/
+/* ArgC:           argument number                                            */
+/* ArgV:           Argument tab                                               */
+/*----------------------------------------------------------------------------*/
+
+int main( int, char  **);
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+
+#endif
diff --git a/src/include/imr.h b/src/include/imr.h
new file mode 100644
index 0000000..d62c6c7
--- /dev/null
+++ b/src/include/imr.h
@@ -0,0 +1,702 @@
+/*----------------------------------------------------------------------------*/
+/* File: imr.h                                                                */
+/*----------------------------------------------------------------------------*/
+/*                                                                            */
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#ifndef _IMR_H_
+#define _IMR_H_
+
+
+
+#include <errno.h>
+#include <stdlib.h>
+#include <dlfcn.h>
+#include <libgen.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <signal.h>
+#include <setjmp.h>
+
+#include <node.h>
+
+
+
+
+
+
+
+#define TRACE 1
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Global definitions                                                         */
+/*----------------------------------------------------------------------------*/
+
+typedef short  IMRT_Boolean;
+
+#define IMRD_FALSE  ( IMRT_Boolean) 0
+#define IMRD_TRUE   ( IMRT_Boolean) 1
+
+#define IMRD_NO     'n'
+#define IMRD_YES    'y'
+
+#define IMRD_MAX(A,B)  (((A) < (B)) ? (B) : (A))
+#define IMRD_MIN(A,B)  (((A) > (B)) ? (B) : (A))
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Status definition                                                          */
+/*----------------------------------------------------------------------------*/
+
+typedef short  IMRT_Status;
+
+#define IMRS_OK          ( IMRT_Status)  0
+
+#define IMRS_KO          ( IMRT_Status)  1
+#define IMRS_NO_IDENT    ( IMRT_Status) -2
+#define IMRS_BAD_FORMAT	 ( IMRT_Status) -3
+#define IMRS_ROLLBACK    ( IMRT_Status) -4
+
+#define IMRS_NO_DATA     ( IMRT_Status)  3
+#define IMRS_SIGNAL      ( IMRT_Status)  4
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Module and Lib definitions                                                 */
+/*----------------------------------------------------------------------------*/
+
+typedef short  IMRT_Module_Id;
+
+#define IMRD_MODULE_ID_UNKNOWN  (IMRT_Module_Id) 0
+
+#define IMRD_MODULE_NB_MAX      (IMRT_Module_Id) 10
+
+
+
+typedef char  *IMRT_Module_Name;
+
+
+typedef char  *IMRT_Module_Name_Long;
+
+
+
+typedef char  *IMRT_Module_Version;
+
+
+
+typedef	short  IMRT_Module_Type;
+
+#define IMRD_MODULE_TYPE_UNKNOWN  ( IMRT_Module_Type) 0
+#define IMRD_MODULE_TYPE_OBJECT   ( IMRT_Module_Type) 1
+#define IMRD_MODULE_TYPE_LIBRARY  ( IMRT_Module_Type) 2
+
+
+
+typedef	short  IMRT_Lib_Status;
+
+#define IMRD_LIB_STATUS_UNKNOWN  ( IMRT_Lib_Status) 0
+#define IMRD_LIB_STATUS_CLOSED   ( IMRT_Lib_Status) 1
+#define IMRD_LIB_STATUS_OPENED   ( IMRT_Lib_Status) 2
+#define IMRD_LIB_STATUS_ERROR    ( IMRT_Lib_Status) 3
+
+
+
+typedef struct IMRT_Lib_Config
+{
+	char  *dummy;
+}  IMRT_Lib_Config;
+
+
+
+typedef	IMRT_Status  ( IMRT_Lib_Open)(  IMRT_Lib_Config  *);
+typedef IMRT_Status  ( IMRT_Lib_Close)( void);
+
+
+
+typedef struct IMRT_Lib
+{
+	IMRT_Lib_Status   Status;
+	IMRT_Lib_Open    *Open_Ptr;
+	IMRT_Lib_Close   *Close_Ptr;
+}  IMRT_Lib;
+
+
+
+typedef struct IMRT_Module
+{
+	IMRT_Module_Id          Id;
+	IMRT_Module_Name        Name;
+	IMRT_Module_Name_Long   Name_Long;
+	IMRT_Module_Version     Version;
+	IMRT_Module_Type        Type;
+	IMRT_Lib                Lib;
+}  IMRT_Module;
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IMRT_Path definition                                                       */
+/*----------------------------------------------------------------------------*/
+
+#define IMRD_PATH_LEN   ( short) 255
+#define IMRD_PATH_SIZE  ( short) ( IMRD_PATH_LEN + 1)
+
+typedef  char  IMRT_Path[ IMRD_PATH_SIZE];
+
+typedef short  IMRT_Lib_Flag;
+#define IRMD_LIB_FLAG_SDM_XML (IMRT_Lib_Flag)0
+#define IRMD_LIB_FLAG_SDM_SQL (IMRT_Lib_Flag)1
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IMRT_Tag definition                                                        */
+/*----------------------------------------------------------------------------*/
+
+#define IMRD_TAG_LEN         ( short) 100
+#define IMRD_TAG_SIZE        ( short) ( IMRD_TAG_LEN  + 1)
+
+typedef char  IMRT_Tag[ IMRD_TAG_SIZE];
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IMRT_Cnv_Id definition                                                     */
+/*----------------------------------------------------------------------------*/
+
+typedef short  IMRT_Cnv_Id;
+
+#define IMRD_CNV_ID_UNKNOWN  ( IMRT_Cnv_Id) 0
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IMRT_Cnv_Name definition                                                   */
+/*----------------------------------------------------------------------------*/
+
+#define IMRD_CNV_NAME_LEN   ( short) 65
+#define IMRD_CNV_NAME_SIZE  ( short) ( IMRD_CNV_NAME_LEN + 1)
+
+typedef char  IMRT_Cnv_Name[ IMRD_CNV_NAME_SIZE];
+
+#define IMRD_CNV_NAME_UNKNOWN   "Unknown"
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IMRT_Cnv_Attr definition                                                   */
+/*----------------------------------------------------------------------------*/
+
+#define IMRD_CNV_ATTR_LEN   ( short) 20
+#define IMRD_CNV_ATTR_SIZE  ( short) ( IMRD_CNV_ATTR_LEN + 1)
+
+typedef char  IMRT_Cnv_Attr[ IMRD_CNV_ATTR_SIZE];
+
+#define IMRD_CNV_ATTR_UNKNOWN   "UNKNOWN"
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IMRT_Cnv definition                                                        */
+/*----------------------------------------------------------------------------*/
+
+typedef struct IMRT_Cnv
+{
+	IMRT_Cnv_Id    Id;
+	IMRT_Cnv_Name  Name;
+} IMRT_Cnv;
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IMRT_Field definition                                                      */
+/*----------------------------------------------------------------------------*/
+
+#define IMRD_FIXED_SIZE_UNKNOWN  ( size_t) -1
+
+
+
+#define IMRD_NAME_LEN         ( short) 255
+#define IMRD_NAME_SIZE        ( short) ( IMRD_NAME_LEN      + 1)
+
+typedef char  IMRT_Field_Name[     IMRD_NAME_SIZE];
+
+
+
+#define IMRD_VALUE_ID_LEN     ( short) 20
+#define IMRD_VALUE_ID_SIZE    ( short) ( IMRD_VALUE_ID_LEN  + 1)
+
+typedef char  IMRT_Field_Value_Id[ IMRD_VALUE_ID_SIZE];
+
+
+#define IMRD_EXIST_LEN     ( short) 1
+#define IMRD_EXIST_SIZE    ( short) ( IMRD_EXIST_LEN  + 1)
+
+typedef char  IMRT_Field_Exist[ IMRD_EXIST_SIZE];
+
+
+#define IMRD_VALUE_LEN       ( short) 150
+#define IMRD_VALUE_SIZE      ( short) ( IMRD_VALUE_LEN  + 1)
+
+typedef char  IMRT_Value[          IMRD_VALUE_SIZE];
+
+
+
+typedef struct IMRT_Field_Fixed
+{
+	size_t         Offset;
+	size_t         Size;
+	IMRT_Value     Def_Val;
+	IMRT_Cnv       *Cnv_Ptr;
+	IMRT_Cnv_Attr  Cnv_Attr;
+} IMRT_Field_Fixed;
+
+
+
+#define IMRD_FML_TAG_LEN      ( short) 50
+#define IMRD_FML_TAG_SIZE     ( short) ( IMRD_FML_TAG_LEN   + 1)
+
+typedef char  IMRT_FML_Tag[  IMRD_FML_TAG_SIZE];
+
+
+#define IMRD_FML_TAG_UNKNOWN  ""
+
+
+
+
+
+typedef struct IMRT_Field_FML
+{
+	IMRT_FML_Tag   Tag;
+	IMRT_Value     Def_Val;
+	IMRT_Cnv      *Cnv_Ptr;
+	IMRT_Cnv_Attr  Cnv_Attr;
+} IMRT_Field_FML;
+
+
+
+#define IMRD_XML_TAG_LEN      ( short) 150
+#define IMRD_XML_TAG_SIZE     ( short) ( IMRD_XML_TAG_LEN   + 1)
+
+typedef char  IMRT_XML_Tag[  IMRD_XML_TAG_SIZE];
+
+#define IMRD_XML_TAG_UNKNOWN  ""
+
+
+
+typedef struct IMRT_Field_XML
+{
+	IMRT_XML_Tag   Tag;
+	IMRT_Value     Def_Val;
+	IMRT_Cnv      *Cnv_Ptr;
+	IMRT_Cnv_Attr  Cnv_Attr;
+} IMRT_Field_XML;
+
+
+
+#define IMRD_TAGGED_TAG_LEN   ( short) 20
+#define IMRD_TAGGED_TAG_SIZE  ( short) ( IMRD_TAGGED_TAG_LEN + 1)
+
+typedef char  IMRT_Tagged_Tag[   IMRD_TAGGED_TAG_SIZE];
+
+#define IMRD_TAGGED_TAG_UNKNOWN  ""
+
+
+
+
+typedef struct IMRT_Field_Tagged
+{
+	IMRT_Tagged_Tag   Tag;
+	IMRT_Value        Def_Val;
+	IMRT_Cnv         *Cnv_Ptr;
+	IMRT_Cnv_Attr     Cnv_Attr;
+} IMRT_Field_Tagged;
+
+
+
+#define IMRD_INTERNAL_TAG_LEN     ( short) 20
+#define IMRD_INTERNAL_TAG_SIZE    ( short) ( IMRD_INTERNAL_TAG_LEN  + 1)
+
+typedef char  IMRT_Internal_Tag[ IMRD_INTERNAL_TAG_SIZE];
+
+#define IMRD_INTERNAL_TAG_UNKNOWN  ""
+
+
+
+
+typedef struct IMRT_Field_Internal
+{
+	IMRT_Internal_Tag  Tag;
+	IMRT_Value         Def_Val;
+	IMRT_Cnv          *Cnv_Ptr;
+	IMRT_Cnv_Attr      Cnv_Attr;
+} IMRT_Field_Internal;
+
+
+
+
+typedef short  IMRT_Delimited_Id;
+
+#define IMRD_DELIMITED_ID_UNKNOWN  ( IMRT_Delimited_Id) -1
+
+
+
+typedef struct IMRT_Field_Delimited
+{
+	IMRT_Delimited_Id Id;
+	IMRT_Value        Def_Val;
+	IMRT_Cnv         *Cnv_Ptr;
+	IMRT_Cnv_Attr     Cnv_Attr;
+} IMRT_Field_Delimited;
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IMRT_Field_Id definition                                                   */
+/*----------------------------------------------------------------------------*/
+
+typedef int  IMRT_Field_Id;
+
+#define IMRD_FIELD_ID_UNKNOWN  ( IMRT_Field_Id) 0
+
+
+
+typedef struct IMRT_Field
+{
+	IMRT_Field_Id        Id;
+	IMRT_Field_Name      Name;
+	IMRT_Field_Value_Id  Value_Id;
+	IMRT_Boolean         Exist;
+	IMRT_Field_Fixed     Fixed;
+	IMRT_Field_FML       FML;
+	IMRT_Field_XML       XML;
+	IMRT_Field_Tagged    Tagged;
+	IMRT_Field_Internal  Internal;
+	IMRT_Field_Delimited Delimited;
+}  IMRT_Field;
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IMRT_FieldMap_Id definition                                                */
+/*----------------------------------------------------------------------------*/
+
+typedef int  IMRT_FieldMap_Id;
+
+#define IMRD_FIELDMAP_ID_UNKNOWN  ( IMRT_FieldMap_Id) 0
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IMRT_FieldMap definition                                                   */
+/*----------------------------------------------------------------------------*/
+
+typedef struct IMRT_FieldMap
+{
+	IMRT_FieldMap_Id    Id;
+	IMRT_Field         *Field_Input_Ptr;
+	IMRT_Field         *Field_Output_Ptr;
+}  IMRT_FieldMap;
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IMRT_Msg definition                                                        */
+/*----------------------------------------------------------------------------*/
+
+typedef short  IMRT_Msg_Id;
+
+#define IMRD_MSG_ID_UNKNOWN  ( IMRT_Msg_Id  ) 0
+
+
+
+typedef char  IMRT_Msg_Name[ IMRD_NAME_SIZE];
+
+#define IMRD_MSG_NAME_UNKNOWN   "UNKNOWN"
+
+
+
+typedef struct IMRT_Msg
+{
+	IMRT_Msg_Id     Id;
+	IMRT_Msg_Name   Name;
+	size_t          Size;
+	NDT_Root       *Field_Struct_Ptr;
+}  IMRT_Msg;
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IMRT_Fmt definition                                                        */
+/*----------------------------------------------------------------------------*/
+
+
+
+/* #define IMRT_LG_MESSAGE_TYPE 60 */
+
+
+
+typedef int  IMRT_Fmt_Id;
+
+#define IMRD_FMT_ID_UNKNOWN  ( IMRT_Fmt_Id) 0
+
+
+
+#define IMRD_FMT_NAME_LEN   ( short) 20
+#define IMRD_FMT_NAME_SIZE  ( short) ( IMRD_FMT_NAME_LEN + 1)
+
+typedef char  IMRT_Fmt_Name[ IMRD_FMT_NAME_SIZE];
+
+#define IMRD_FMT_NAME_UNKNOWN   "Unknown"
+
+
+
+
+typedef short  IMRT_Branche_Id;
+
+#define IMRD_BRANCHE_ID_UNKNOWN  ( IMRT_Branche_Id  ) 0
+
+
+
+typedef short  IMRT_FmtAttr_Id;
+
+#define IMRD_FMTATTR_ID_UNKNOWN  ( IMRT_FmtAttr_Id) 0
+
+
+
+#define IMRD_FMTATTR_NAME_LEN   ( short) 65
+#define IMRD_FMTATTR_NAME_SIZE  ( short) ( IMRD_FMTATTR_NAME_LEN + 1)
+
+typedef char  IMRT_FmtAttr_Name[ IMRD_FMTATTR_NAME_SIZE];
+
+#define IMRD_FMTATTR_NAME_UNKNOWN   "unknown"
+
+
+
+
+#define IMRD_FMTATTR_VALUE_LEN   ( short) 20
+#define IMRD_FMTATTR_VALUE_SIZE  ( short) ( IMRD_FMTATTR_VALUE_LEN + 1)
+
+typedef char  IMRT_FmtAttr_Value[ IMRD_FMTATTR_VALUE_SIZE];
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IMRT_FmtAttr definition                                                    */
+/*----------------------------------------------------------------------------*/
+
+typedef struct IMRT_FmtAttr
+{
+	IMRT_FmtAttr_Id     Id;
+	IMRT_FmtAttr_Name   Name;
+	IMRT_FmtAttr_Value  Value;
+}  IMRT_FmtAttr;
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IMRT_FmtMsg definition                                                     */
+/*----------------------------------------------------------------------------*/
+
+typedef struct IMRT_FmtMsg
+{
+	IMRT_Msg         *Msg_Ptr;
+	IMRT_Branche_Id   Branche_Id;
+	IMRT_FmtAttr     *FmtAttr_Ptr;
+}  IMRT_FmtMsg;
+
+
+
+
+typedef struct IMRT_Fmt
+{
+	IMRT_Fmt_Id     Id;
+	IMRT_Fmt_Name   Name;
+	NDT_Root       *FmtMsg_Struct_Ptr;
+}  IMRT_Fmt;
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IMRT_Appl_Id definition                                                    */
+/*----------------------------------------------------------------------------*/
+
+typedef short  IMRT_Appl_Id;
+
+#define IMRD_APPL_ID_UNKNOWN  ( IMRT_Appl_Id) 0
+
+#define IMRD_APPL_ID_UNDEFINEDED  ( IMRT_Appl_Id) -1
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IMRT_Appl_Name definition                                                  */
+/*----------------------------------------------------------------------------*/
+
+#define IMRD_APPL_NAME_LEN   ( short) 30
+#define IMRD_APPL_NAME_SIZE  ( short) ( IMRD_APPL_NAME_LEN + 1)
+
+typedef char  IMRT_Appl_Name[ IMRD_APPL_NAME_SIZE];
+
+#define IMRD_APPL_NAME_UNKNOWN   "UNKNOWN"
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IMRT_Buffer definition                                                     */
+/*----------------------------------------------------------------------------*/
+
+typedef short IMRT_Dir_Id;
+
+#define IMRD_DIR_ID_UNKNOWN  ( IMRT_Dir_Id) 0
+#define IMRD_DIR_ID_IN       ( IMRT_Dir_Id) 1
+#define IMRD_DIR_ID_OUT      ( IMRT_Dir_Id) 2
+
+
+
+typedef short IMRT_Buffer_Status;
+
+#define IMRD_BUFFER_STATUS_UNKNOWN    ( IMRT_Buffer_Status) 0
+#define IMRD_BUFFER_STATUS_ALLOCATED  ( IMRT_Buffer_Status) 1
+#define IMRD_BUFFER_STATUS_FREED      ( IMRT_Buffer_Status) 2
+
+
+
+typedef short IMRT_Buffer_Flag;
+
+#define IMRD_BUFFER_FLAG_UNKNOWN  ( IMRT_Buffer_Flag) 0
+#define IMRD_BUFFER_FLAG_OPENED   ( IMRT_Buffer_Flag) 1
+#define IMRD_BUFFER_FLAG_CLOSED   ( IMRT_Buffer_Flag) 2
+
+
+
+typedef char IMRT_Buffer_Data;
+
+
+
+typedef struct IMRT_Buffer
+{
+   IMRT_Msg_Id          Msg_Id;
+   IMRT_Appl_Id         Appl_Id_Input;
+   IMRT_Appl_Id         Appl_Id_Output;
+   IMRT_Dir_Id          Dir_Id;
+   IMRT_Fmt_Id          Fmt_Id;
+   IMRT_FmtAttr_Value   FmtAttr_Value;
+   IMRT_Buffer_Status   Status;
+   IMRT_Buffer_Flag     Flag;
+   size_t		Data_Buf_Len;
+   size_t               Data_Buf_Size;
+   IMRT_Buffer_Data    *Data_Buf_Ptr;
+   IMRT_Boolean         Data_Tmp_Changed;
+   IMRT_Buffer_Data    *Data_Tmp_Ptr;
+}  IMRT_Buffer;
+
+
+
+typedef short  IMRT_Buffer_Id;
+
+#define IMRT_BUFFER_ID_MAX_NB  ( IMRT_Buffer_Id) 50
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IMRT_IOM_Read_Mode definition                                              */
+/*----------------------------------------------------------------------------*/
+
+typedef short   IMRT_Read_Mode;
+
+#define IMRD_READ_MODE_UNKNOWN  ( IMRT_Read_Mode) 0
+#define IMRD_READ_MODE_WAIT     ( IMRT_Read_Mode) 1
+#define IMRD_READ_MODE_NO_WAIT  ( IMRT_Read_Mode) 2
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IMRT_Base                                                                  */
+/*----------------------------------------------------------------------------*/
+
+typedef struct IMRT_Base
+{
+	int          Sig_Trapped;
+	sigjmp_buf   SigLongJmp_Env;
+}  IMRT_Base;
+
+
+
+#   ifdef _IMRD_C_
+
+#   else
+
+extern IMRT_Base  IMRG_Base;
+
+#   endif
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IMR libraries                                                              */
+/*----------------------------------------------------------------------------*/
+
+#include <log_mng.h>
+#include <static_data_mng.h>
+#include <io_mng.h>
+#include <mapping_mng.h>
+#include <msg_router.h>
+
+#endif
diff --git a/src/libio_mng/include/io_mng.h b/src/libio_mng/include/io_mng.h
new file mode 100644
index 0000000..8f0441e
--- /dev/null
+++ b/src/libio_mng/include/io_mng.h
@@ -0,0 +1,459 @@
+/*----------------------------------------------------------------------------*/
+/* $Workfile:   io_mng.h  $                                                   */                                            
+/*----------------------------------------------------------------------------*/
+/* $Author: agibert $                                                      */
+/* $Date: 2008/11/12 02:25:22 $                                           */
+/* $Revision: 1.1 $                                                       */
+/* $Label:  $                                                         */
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#ifndef _IO_MNG_H_
+#define _IO_MNG_H_
+
+
+
+#include <imr.h>
+
+#ifdef TUX_SUPPORT
+#   include <atmi.h>
+#   include <fml32.h>
+#   include <tpadm.h>
+#endif
+
+#ifdef MQS_SUPPORT
+#   include <cmqc.h>
+#endif
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IMRD_IOM_API definition                                                    */
+/*----------------------------------------------------------------------------*/
+
+#   ifdef _LIBIO_MNG_
+#       define IMRD_IOM_API  
+#   else
+#       define IMRD_IOM_API  extern
+#   endif
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IOM_Config definition                                                      */
+/*----------------------------------------------------------------------------*/
+
+typedef struct IMRT_IOM_Config
+{
+	char  *dummy;
+
+}  IMRT_IOM_Config;
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IMRT_File_Delim definition                                                 */
+/*----------------------------------------------------------------------------*/
+
+#define IMRD_FILE_DELIM_LEN   (short) 32
+#define IMRD_FILE_DELIM_SIZE  (short) ( IMRD_FILE_DELIM_LEN + 1)
+
+typedef char   IMRT_File_Delim[ IMRD_FILE_DELIM_SIZE];
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IMRT_File_Buffer definition                                                */
+/*----------------------------------------------------------------------------*/
+
+#define IMRD_FILE_BUFFER_LEN   (size_t) 4096
+#define IMRD_FILE_BUFFER_SIZE  (size_t) ( IMRD_FILE_BUFFER_LEN + 1)
+
+typedef char  IMRT_File_Buffer;
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IMRT_Medium_File definition                                                */
+/*----------------------------------------------------------------------------*/
+
+typedef struct IMRT_Medium_File
+{
+	IMRT_File_Delim    Delim;
+	size_t             Delim_Len;
+	size_t             Msg_Len;
+	IMRT_Path          Path;
+	FILE              *Handle_Ptr;
+	IMRT_File_Buffer  *Buffer_Ptr;
+	size_t             Buffer_Len;
+	IMRT_File_Buffer  *Cur_Ptr;
+
+}  IMRT_Medium_File;
+
+
+
+#ifdef TUX_SUPPORT
+/*----------------------------------------------------------------------------*/
+/* IMRT_Tux_Queue_Name definition                                             */
+/*----------------------------------------------------------------------------*/
+
+#define IMRD_TUX_QUEUE_NAME_LEN   ( short) 255
+#define IMRD_TUX_QUEUE_NAME_SIZE  ( short) ( IMRD_TUX_QUEUE_NAME_LEN + 1)
+
+typedef char  IMRT_Tux_Queue_Name[ IMRD_TUX_QUEUE_NAME_SIZE];
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IMRT_Tux_Queue_Space definition                                            */
+/*----------------------------------------------------------------------------*/
+
+#define IMRD_TUX_QUEUE_SPACE_LEN   ( short) 255
+#define IMRD_TUX_QUEUE_SPACE_SIZE  ( short) ( IMRD_TUX_QUEUE_SPACE_LEN + 1)
+
+typedef char  IMRT_Tux_Queue_Space[ IMRD_TUX_QUEUE_SPACE_SIZE];
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IMRT_Tux_Open_Info definition                                              */
+/*----------------------------------------------------------------------------*/
+
+#define IMRD_TUX_OPEN_INFO_LEN   ( short) 255
+#define IMRD_TUX_OPEN_INFO_SIZE  ( short) ( IMRD_TUX_OPEN_INFO_LEN + 1)
+
+typedef char  IMRT_Tux_Open_Info[ IMRD_TUX_OPEN_INFO_SIZE];
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IMRT_Tux_Lmid definition                                                   */
+/*----------------------------------------------------------------------------*/
+
+#define IMRD_TUX_LMID_LEN   ( short) 255
+#define IMRD_TUX_LMID_SIZE  ( short) ( IMRD_TUX_LMID_LEN + 1)
+
+typedef char  IMRT_Tux_Lmid[ IMRD_TUX_LMID_SIZE];
+
+
+
+#define IMRD_TUX_BUFFER_SIZE   ( size_t) 10000
+
+typedef FBFR32  IMRT_Tux_Buffer;
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IMRT_Medium_Tux definition                                                 */
+/*----------------------------------------------------------------------------*/
+
+typedef struct IMRT_Medium_Tux
+{
+	IMRT_Tux_Queue_Space   Queue_Space;
+	IMRT_Tux_Queue_Name    Queue_Name;
+
+}  IMRT_Medium_Tux;
+#endif /* MQS_SUPPORT */
+
+
+
+#ifdef MQS_SUPPORT
+/*----------------------------------------------------------------------------*/
+/* IMRT_MQS_Queue_Manager definition                                          */
+/*----------------------------------------------------------------------------*/
+
+#define IMRD_MQS_QUEUE_MNG_LEN   ( short) 255
+#define IMRD_MQS_QUEUE_MNG_SIZE  ( short) ( IMRD_MQS_QUEUE_MNG_LEN + 1)
+
+typedef  char  IMRT_MQS_Queue_Mng[ IMRD_MQS_QUEUE_MNG_SIZE];
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IMRT_MQS_Queue_Name definition                                             */
+/*----------------------------------------------------------------------------*/
+
+#define IMRD_MQS_QUEUE_NAME_LEN   ( short) 255
+#define IMRD_MQS_QUEUE_NAME_SIZE  ( short) ( IMRD_MQS_QUEUE_NAME_LEN + 1)
+
+typedef  char  IMRT_MQS_Queue_Name[ IMRD_MQS_QUEUE_NAME_SIZE];
+
+
+
+
+#define IMRD_MQS_BUFFER_LEN   (size_t) 4096
+#define IMRD_MQS_BUFFER_SIZE  (size_t) ( IMRD_MQS_BUFFER_LEN + 1)
+
+typedef MQBYTE  IMRT_MQS_Buffer;
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IMRT_Mediul_MQS definition                                                 */
+/*----------------------------------------------------------------------------*/
+
+typedef struct IMRT_Medium_MQS
+{
+	IMRT_MQS_Queue_Mng   Queue_Mng;
+	IMRT_MQS_Queue_Name  Queue_Name;
+	MQHCONN              Conn_Hdl;
+	MQHOBJ               Obj_Hdl;
+
+}  IMRT_Medium_MQS;
+#endif /* MQS_SUPPORT */
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IMRT_Medium definitions                                                    */
+/*----------------------------------------------------------------------------*/
+
+#define IMRD_MEDIUM_NAME_LEN   ( short) 64
+#define IMRD_MEDIUM_NAME_SIZE  ( short) ( IMRD_MEDIUM_NAME_LEN + 1)
+
+typedef char   IMRT_Medium_Name[ IMRD_MEDIUM_NAME_SIZE];
+
+
+
+typedef short  IMRT_Medium_Type;
+
+#define IMRD_MEDIUM_TYPE_UNKNOWN  ( IMRT_Medium_Type) 0
+#define IMRD_MEDIUM_TYPE_FILE     ( IMRT_Medium_Type) 1
+
+#ifdef MQS_SUPPORT
+#   define IMRD_MEDIUM_TYPE_TUX      ( IMRT_Medium_Type) 2
+#endif /* TUX_SUPPORT */
+
+#ifdef MQS_SUPPORT
+#   define IMRD_MEDIUM_TYPE_MQS      ( IMRT_Medium_Type) 3
+#endif /* MQS_SUPPORT */
+
+
+
+typedef short  IMRT_Medium_Status;
+
+#define IMRD_MEDIUM_STATUS_UNKNOWN  ( IMRT_Medium_Status) 0
+#define IMRD_MEDIUM_STATUS_OPENED   ( IMRT_Medium_Status) 1
+#define IMRD_MEDIUM_STATUS_CLOSED   ( IMRT_Medium_Status) 2
+
+
+
+#define IMRD_MEDIUM_URL_LEN   ( short) 255
+#define IMRD_MEDIUM_URL_SIZE  ( short) ( IMRD_MEDIUM_URL_LEN + 1)
+
+typedef char   IMRT_Medium_URL[ IMRD_MEDIUM_URL_SIZE];
+
+
+
+#define IMRD_MEDIUM_PATH_LEN   ( short) 255
+#define IMRD_MEDIUM_PATH_SIZE  ( short) ( IMRD_MEDIUM_PATH_LEN + 1)
+
+typedef char   IMRT_Medium_Path[ IMRD_MEDIUM_PATH_SIZE];
+
+typedef short IMRT_Medium_Tran_Flag;
+
+#define IMRD_MEDIUM_TRAN_FLAG_UNKNOWN  ( IMRT_Medium_Tran_Flag) 0
+#define IMRD_MEDIUM_TRAN_FLAG_IN       ( IMRT_Medium_Tran_Flag) 1
+#define IMRD_MEDIUM_TRAN_FLAG_OUT      ( IMRT_Medium_Tran_Flag) 2
+
+
+typedef struct IMRT_Medium
+{
+	IMRT_Medium_Name       Name;
+	IMRT_Medium_Type       Type;
+	IMRT_Medium_Status     Status;
+	IMRT_Medium_URL        URL;
+	IMRT_Appl_Id           Appl_Id_Input;
+	IMRT_Appl_Id           Appl_Id_Output;
+	IMRT_Dir_Id            Dir_Id;
+	IMRT_Medium_Tran_Flag  Tran_Flag;
+	size_t                 Byte_Nb;
+	size_t                 Msg_Nb;
+
+	IMRT_Medium_File       File;
+
+#ifdef TUX_SUPPORT
+	IMRT_Medium_Tux        Tux;
+#endif /* TUX_SUPPORT */
+
+#ifdef MQS_SUPPORT
+	IMRT_Medium_MQS        MQS;
+#endif /* MQS_SUPPORT */
+	
+}  IMRT_Medium;
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IMRT_Tran definitions                                                    */
+/*----------------------------------------------------------------------------*/
+
+typedef int  IMRT_Medium_Nb;
+
+typedef struct IMRT_Tran
+{
+	IMRT_Medium     **Medium_Ptr_Tab;
+	IMRT_Medium_Nb    Medium_Nb;
+
+}  IMRT_Tran;
+
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Global Variables                                                           */
+/*----------------------------------------------------------------------------*/
+
+#   ifdef _LIBIO_MNG_
+
+#   else
+
+extern IMRT_Module  IMRG_IOM_Module;
+
+#   endif
+
+
+
+
+
+
+
+/******************************************************************************/
+/*IO Manager API                                                              */
+/******************************************************************************/
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Open IO Manager                                                            */
+/*----------------------------------------------------------------------------*/
+/* IOM_Config_Ptr:   Setup IOM init mode                                      */
+/*----------------------------------------------------------------------------*/
+
+IMRD_IOM_API IMRT_Status  IMR_IOM_Library_Open( IMRT_IOM_Config  *);
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Close IO Manager                                                           */
+/*----------------------------------------------------------------------------*/
+
+IMRD_IOM_API IMRT_Status  IMR_IOM_Library_Close( void);
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Open Medium                                                                */
+/*----------------------------------------------------------------------------*/
+/* Medium_Ptr_Ptr:   Reference to the Pointer to the opened medium            */
+/* Medium_Name:      Name of the medium                                       */
+/* Medium_URL:       Medium URL to open                                       */
+/* Appl_Id_Input:    Input application Id link with the medium                */
+/* Appl_Id_Output:   Output application Id link with the medium               */
+/* Dir_Id:           Medium open direction                                    */
+/*----------------------------------------------------------------------------*/
+
+IMRD_IOM_API IMRT_Status  IMR_IOM_Medium_Open( IMRT_Medium  **, IMRT_Medium_Name, IMRT_Medium_URL, IMRT_Appl_Id, IMRT_Appl_Id, IMRT_Dir_Id);
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Close Medium                                                               */
+/*----------------------------------------------------------------------------*/
+/* Medium_Ptr:   Pointer to the medium to close                               */
+/*----------------------------------------------------------------------------*/
+
+IMRD_IOM_API IMRT_Status  IMR_IOM_Medium_Close( IMRT_Medium  *);
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Read Medium                                                                */
+/*----------------------------------------------------------------------------*/
+/* Buffer_Ptr:   Pointer to the buffer to write                               */
+/* Medium_Ptr:   Pointer to the medium to read                                */
+/* Read_Mode:    Read mode                                                    */
+/*----------------------------------------------------------------------------*/
+
+IMRD_IOM_API IMRT_Status  IMR_IOM_Medium_Read( IMRT_Buffer  *, IMRT_Medium  *, IMRT_Read_Mode);
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Write Medium                                                               */
+/*----------------------------------------------------------------------------*/
+/* Medium_Ptr:   Pointer to the medium to write                               */
+/* Buffer_Ptr:   Pointer to the buffer to read                                */
+/*----------------------------------------------------------------------------*/
+
+IMRD_IOM_API IMRT_Status  IMR_IOM_Medium_Write( IMRT_Medium  *, IMRT_Buffer  *);
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Tran Begin                                                                 */
+/*----------------------------------------------------------------------------*/
+/* Tran_Ptr_Ptr:   Reference to the pointer of the transaction to begin       */
+/* Medium_Count:   Number of medium to enclose into the transaction           */
+/* Medium_1_Ptr:   Pointer to the first medium                                */
+/* ...                                                                        */
+/*----------------------------------------------------------------------------*/
+
+IMRD_IOM_API IMRT_Status  IMR_IOM_Tran_Begin( IMRT_Tran  **, IMRT_Medium_Nb, IMRT_Medium  *, ...);
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Tran Commit                                                                */
+/*----------------------------------------------------------------------------*/
+/* Tran_Ptr:   Pointer to the transaction to commit                           */
+/*----------------------------------------------------------------------------*/
+
+IMRD_IOM_API IMRT_Status  IMR_IOM_Tran_Commit( IMRT_Tran  *);
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Tran Rollback                                                              */
+/*----------------------------------------------------------------------------*/
+/* Tran_Ptr:   Pointer to the transaction to rollback                         */
+/*----------------------------------------------------------------------------*/
+
+IMRD_IOM_API IMRT_Status  IMR_IOM_Tran_Rollback( IMRT_Tran  *);
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+
+#endif
diff --git a/src/libio_mng/src/Makefile b/src/libio_mng/src/Makefile
new file mode 100644
index 0000000..2f00a10
--- /dev/null
+++ b/src/libio_mng/src/Makefile
@@ -0,0 +1,74 @@
+#------------------------------------------------------------------------------
+# Local Makefile
+#------------------------------------------------------------------------------
+# $Workfile:   Makefile  $                                                     
+#------------------------------------------------------------------------------
+# $Author: agibert $                                                        
+# $Date: 2008/11/12 02:25:22 $                                             
+# $Revision: 1.1 $                                                         
+# $Label:  $                                                           
+#------------------------------------------------------------------------------
+
+#------------------------------------------------------------------------------
+# IMR - Interlinking Message Router                                            
+# Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)                
+# mailto:arnaud@rx3.net                                                        
+# http://www.rx3.org/dvp/?dvp=imr                                              
+#------------------------------------------------------------------------------
+# This file is part of IMR                                                     
+#                                                                              
+# This program is free software; you can redistribute it and/or                
+# modify it under the terms of the GNU General Public License                  
+# as published by the Free Software Foundation; either version 2               
+# of the License, or (at your option) any later version.                       
+#                                                                              
+# This program is distributed in the hope that it will be useful,              
+# but WITHOUT ANY WARRANTY; without even the implied warranty of               
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                
+# GNU General Public License for more details.                                 
+#                                                                              
+# You should have received a copy of the GNU General Public License            
+# along with this program; if not, write to the Free Software Foundation,      
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.          
+#------------------------------------------------------------------------------
+
+
+
+
+
+#------------------------------------------------------------------------------
+# Var include
+#------------------------------------------------------------------------------
+
+include ../../Makefile_var.mk
+
+
+
+#------------------------------------------------------------------------------
+# Variables
+#------------------------------------------------------------------------------
+
+TARGET=		libio_mng$(SHLIB_SUFFIX)
+
+OBJ=		libio_mng.o						\
+		io_hdl_file.o
+
+ifeq ($(TUX_SUPPORT),1)
+		OBJ+= io_hdl_tux.o
+endif
+
+ifeq ($(MQS_SUPPORT),1)
+		OBJ+= io_hdl_mqs.o
+endif
+
+EXTRA_INC=	
+
+EXTRA_LIB=	
+
+
+
+#------------------------------------------------------------------------------
+# Rule include
+#------------------------------------------------------------------------------
+
+include ../../Makefile_rule.mk
diff --git a/src/libio_mng/src/io_hdl_file.c b/src/libio_mng/src/io_hdl_file.c
new file mode 100644
index 0000000..cd15384
--- /dev/null
+++ b/src/libio_mng/src/io_hdl_file.c
@@ -0,0 +1,541 @@
+/*----------------------------------------------------------------------------*/
+/* File: io_hdl_file.c   		              		  	      */
+/*----------------------------------------------------------------------------*/
+/*                                                                            */
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#define _LIBIO_MNG_
+#define _IO_HDL_FILE_C_
+
+
+
+#include "io_hdl_file.h" 
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IO_Hdl_File_Open                                                           */
+/*----------------------------------------------------------------------------*/
+/* Medium_Ptr:    Pointer to the medium to open                               */
+/* Medium_Path:   Medium Path to open                                         */
+/* Dir_Id:        Medium open direction                                       */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  IO_Hdl_File_Open( IMRT_Medium  *Medium_Ptr, IMRT_Medium_Path  Medium_Path, IMRT_Dir_Id  Dir_Id)
+{
+    char  *type_ptr, *path_ptr, *read_ptr, *write_ptr;
+
+
+    if( Dir_Id == IMRD_DIR_ID_IN)
+    {
+	type_ptr = "r";
+    }
+    else
+    {
+	if( Dir_Id == IMRD_DIR_ID_OUT)
+	{
+	    type_ptr = "w";
+	}
+	else
+	{
+	    IMRD_LM_LOG_ERROR_1( "Invalid Dir_Id (%d) !", Dir_Id);
+
+	    return( IMRS_KO);
+	}
+    }
+
+    if( ( path_ptr = strstr( Medium_Path, "@")) != NULL)
+    {
+	if( ( path_ptr == Medium_Path) || ( ( path_ptr - Medium_Path + 1) == strlen( Medium_Path)))
+	{
+	    IMRD_LM_LOG_ERROR_1( "Invalid file path [%s] !", Medium_Path);
+
+	    return( IMRS_KO);
+	}
+
+	for( read_ptr = Medium_Path, write_ptr = Medium_Ptr->File.Delim; read_ptr < path_ptr; read_ptr++, write_ptr++)
+	{
+	    if( ( *read_ptr == '\\') && ( read_ptr < ( path_ptr - 1)))
+	    {
+		switch( *( read_ptr + 1))
+		{
+		    case 'n':
+		    {
+			*write_ptr = '\n';
+			break;
+		    }
+
+		    case 't':
+		    {
+			*write_ptr = '\t';
+			break;
+		    }
+
+		    case '\\':
+		    {
+			*write_ptr = '\n';
+			break;
+		    }
+
+		    default:
+		    {
+			*write_ptr = '?';
+			break;
+		    }
+		}
+
+		read_ptr++;
+	    }
+	    else
+	    {
+		*write_ptr = *read_ptr;
+	    }
+	} 
+
+	*write_ptr = '\0';
+
+	Medium_Ptr->File.Delim_Len = write_ptr - Medium_Ptr->File.Delim;
+	Medium_Ptr->File.Msg_Len = 0;
+
+	strcpy( Medium_Ptr->File.Path, ( path_ptr + 1));
+    }
+    else
+    {
+	if( ( path_ptr = strstr( Medium_Path, "#")) != NULL)
+	{
+	    if( ( path_ptr == Medium_Path) || ( ( path_ptr - Medium_Path + 1) == strlen( Medium_Path)))
+	    {
+		IMRD_LM_LOG_ERROR_1( "Invalid file path [%s] !", Medium_Path);
+
+		return( IMRS_KO);
+	    }
+
+	    Medium_Ptr->File.Delim_Len = 0;
+	    Medium_Ptr->File.Delim[ Medium_Ptr->File.Delim_Len] = '\0';
+
+	    Medium_Ptr->File.Msg_Len = atoi( Medium_Path);
+
+	    if( Medium_Ptr->File.Msg_Len <= 0)
+	    {
+		IMRD_LM_LOG_ERROR_1( "Invalid message len [%s] !", Medium_Path);
+
+		return( IMRS_KO);
+	    }
+
+	    strcpy( Medium_Ptr->File.Path, ( path_ptr + 1));
+	}
+	else
+	{
+	    Medium_Ptr->File.Delim_Len = 0;
+	    Medium_Ptr->File.Delim[ Medium_Ptr->File.Delim_Len] = '\0';
+
+	    Medium_Ptr->File.Msg_Len = 0;
+
+	    strcpy( Medium_Ptr->File.Path, Medium_Path);
+	}
+    }
+
+    if( ( Medium_Ptr->File.Handle_Ptr = fopen( Medium_Ptr->File.Path, type_ptr)) == NULL)
+    {
+	IMRD_LM_LOG_ERROR_2( "Can't open file [%s] (%d) !", Medium_Ptr->File.Path, errno);
+
+	return( IMRS_KO);
+    }
+    
+    if( ( Medium_Ptr->File.Buffer_Ptr = malloc( IMRD_FILE_BUFFER_SIZE)) == NULL)
+    {
+	IMRD_LM_LOG_ERROR_1( "Can't allocate File_Buffer (%d) !", errno);
+
+	return( IMRS_KO);
+    }
+
+    Medium_Ptr->File.Buffer_Len = 0;
+    Medium_Ptr->File.Cur_Ptr = Medium_Ptr->File.Buffer_Ptr + IMRD_FILE_BUFFER_LEN;
+
+    IMRD_LM_LOG_TRACE_4( IMRD_LOG_LEVEL_VERBOSE_1, "File: [%s]   mode: [%s]   delim: [%s]   len: [%ld]   opened !", Medium_Ptr->File.Path, type_ptr, Medium_Ptr->File.Delim, Medium_Ptr->File.Msg_Len);
+
+    return( IMRS_OK);
+}
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IO_Hdl_File_Close                                                          */
+/*----------------------------------------------------------------------------*/
+/* Medium_Ptr:    Pointer to the medium to close                              */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  IO_Hdl_File_Close( IMRT_Medium  *Medium_Ptr)
+{
+    if( Medium_Ptr->File.Buffer_Ptr != NULL)
+    {
+	free( Medium_Ptr->File.Buffer_Ptr);
+    }
+
+    if( fclose( Medium_Ptr->File.Handle_Ptr) == EOF)
+    {
+	IMRD_LM_LOG_ERROR_2( "Can't close file [%s] (%d) !", Medium_Ptr->File.Path, errno);
+
+	return( IMRS_KO);
+    }
+
+    IMRD_LM_LOG_TRACE_1( IMRD_LOG_LEVEL_VERBOSE_1, "File: [%s] closed !", Medium_Ptr->File.Path);
+
+    return( IMRS_OK);
+}
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IO_Hdl_File_Mem_Str                                                        */
+/*----------------------------------------------------------------------------*/
+/* Occur_Ptr_Ptr: Pointer to the first occurrence                             */
+/* Area_Ptr:      Memory Area                                                 */
+/* Area_Size:     Size of the Area_Ptr                                        */
+/* Search_Ptr:    Area to search in Area_Ptr                                  */
+/* Search_Size:   Size of the Search_Ptr                                      */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  IO_Hdl_File_Mem_Str( char **Occur_Ptr_Ptr, const char *Area_Ptr, size_t Area_Size, const char *Search_Ptr, size_t Search_Size)
+{
+
+	char * Pos = (char *)Area_Ptr;
+
+	*Occur_Ptr_Ptr = NULL;
+
+	while((Pos != NULL) && (*Occur_Ptr_Ptr == NULL))
+	{
+		Pos = memchr(Pos, Search_Ptr[0], Area_Size - (Pos - Area_Ptr));
+		if ((Area_Size - (Pos - Area_Ptr)) < Search_Size)
+		{
+			Pos = NULL;
+		}
+		else
+		{
+			if (Pos != NULL)
+			{
+				if (memcmp(Pos, Search_Ptr, Search_Size) == 0)
+				{
+					*Occur_Ptr_Ptr = Pos;
+				}
+				else
+				{
+					Pos += 1;
+				}
+			}
+		}
+	}
+
+	return( IMRS_OK);
+}
+
+
+/*----------------------------------------------------------------------------*/
+/* IO_Hdl_File_Read                                                           */
+/*----------------------------------------------------------------------------*/
+/* Buffer_Ptr:    Buffer to write data in                                     */
+/* Read_Len_Ptr:  Number of byte readen                                       */
+/* Medium_Path:   Medium to read                                              */
+/* Read_Mode:     Read mode                                                   */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  IO_Hdl_File_Read( IMRT_Buffer  *Buffer_Ptr, size_t *Read_Len_Ptr, IMRT_Medium  *Medium_Ptr, IMRT_Read_Mode  Read_Mode)
+{
+    IMRT_Buffer_Data  *next_ptr;
+    IMRT_Buffer_Data  *delim_ptr;
+    IMRT_Buffer_Data  *buffer_data_ptr  = NULL;
+    size_t             buffer_data_size = 1;
+    size_t             copy_data_size   = 0;
+    size_t             read_buffer_len  = IMRD_FILE_BUFFER_LEN - Medium_Ptr->File.Delim_Len;
+	IMRT_Status  status_tmp;
+
+	*Read_Len_Ptr = 0;
+
+    if( Medium_Ptr->File.Msg_Len > 0)                                                                                                 /* Msg_Len split mode */
+    {
+	do
+	{
+	    if( Medium_Ptr->File.Cur_Ptr >= ( Medium_Ptr->File.Buffer_Ptr + Medium_Ptr->File.Buffer_Len))                          /* File needs to be read */
+	    {
+		Medium_Ptr->File.Cur_Ptr = Medium_Ptr->File.Buffer_Ptr;
+
+		Medium_Ptr->File.Buffer_Len = fread( Medium_Ptr->File.Buffer_Ptr, sizeof( char), IMRD_FILE_BUFFER_LEN, Medium_Ptr->File.Handle_Ptr);
+
+		if( ferror( Medium_Ptr->File.Handle_Ptr) != 0)
+		{
+		    IMRD_LM_LOG_ERROR_2( "Can't read file [%s] (%d) !", Medium_Ptr->File.Path, ferror( Medium_Ptr->File.Handle_Ptr));
+		    
+		    return( IMRS_KO);
+		}
+	    }
+
+	    copy_data_size = IMRD_MIN( ( Medium_Ptr->File.Buffer_Len - ( Medium_Ptr->File.Cur_Ptr - Medium_Ptr->File.Buffer_Ptr)),
+				       ( Medium_Ptr->File.Msg_Len - buffer_data_size + 1));
+
+	    if( copy_data_size != 0)
+	    {
+		if( ( buffer_data_ptr = realloc( buffer_data_ptr, ( buffer_data_size + copy_data_size))) == NULL)
+		{
+		    IMRD_LM_LOG_ERROR_1( "Can't allocate Buffer_Data (%d) !", errno);
+		    
+		    return( IMRS_KO);
+		}
+		
+		memcpy( ( buffer_data_ptr + buffer_data_size - 1), Medium_Ptr->File.Cur_Ptr, copy_data_size);  /* Copy data from read buffer to copy buffer */
+		buffer_data_size += copy_data_size;
+		
+		Medium_Ptr->File.Cur_Ptr += copy_data_size;
+	    }
+	}
+	while( ( buffer_data_size < Medium_Ptr->File.Msg_Len) && ( Medium_Ptr->File.Buffer_Len > 0));
+    }
+    else                                                                                                                            /* Delimitor split mode */
+    {
+	do
+	{
+	    if( Medium_Ptr->File.Cur_Ptr >= ( Medium_Ptr->File.Buffer_Ptr + read_buffer_len))                                      /* File needs to be read */
+	    {
+		if( Medium_Ptr->File.Cur_Ptr < ( Medium_Ptr->File.Buffer_Ptr + IMRD_FILE_BUFFER_LEN))                 /* Footer needs to be moved to header */
+		{
+		    Medium_Ptr->File.Buffer_Len += Medium_Ptr->File.Buffer_Ptr - Medium_Ptr->File.Cur_Ptr;
+		    memcpy( Medium_Ptr->File.Buffer_Ptr, Medium_Ptr->File.Cur_Ptr, Medium_Ptr->File.Buffer_Len);
+		}
+		else
+		{
+		    Medium_Ptr->File.Buffer_Len = 0;                                                                                     /* Buffer is empty */
+		}
+		
+		Medium_Ptr->File.Cur_Ptr = Medium_Ptr->File.Buffer_Ptr;
+		
+		Medium_Ptr->File.Buffer_Len += fread( ( Medium_Ptr->File.Buffer_Ptr + Medium_Ptr->File.Buffer_Len),
+						      sizeof( char), ( IMRD_FILE_BUFFER_LEN - Medium_Ptr->File.Buffer_Len),
+						      Medium_Ptr->File.Handle_Ptr);
+		
+		if( ferror( Medium_Ptr->File.Handle_Ptr) != 0)
+		{
+		    IMRD_LM_LOG_ERROR_2( "Can't read file [%s] (%d) !", Medium_Ptr->File.Path, ferror( Medium_Ptr->File.Handle_Ptr));
+		    
+		    return( IMRS_KO);
+		}
+	    }
+	    
+	    status_tmp = IO_Hdl_File_Mem_Str(&delim_ptr, Medium_Ptr->File.Cur_Ptr, Medium_Ptr->File.Buffer_Len - (Medium_Ptr->File.Cur_Ptr - Medium_Ptr->File.Buffer_Ptr), Medium_Ptr->File.Delim, Medium_Ptr->File.Delim_Len);
+	    
+	    if( ( Medium_Ptr->File.Delim_Len == 0) ||  ( delim_ptr == NULL))  /* Seek delim. */
+	    {
+		delim_ptr = Medium_Ptr->File.Buffer_Ptr + IMRD_MIN( Medium_Ptr->File.Buffer_Len, read_buffer_len);                          /* No delimitor */
+		next_ptr = delim_ptr;
+	    }
+	    else
+	    {
+		next_ptr = delim_ptr + Medium_Ptr->File.Delim_Len;                                                                       /* Delimitor found */
+		*Read_Len_Ptr = *Read_Len_Ptr + Medium_Ptr->File.Delim_Len;
+	    }
+	    
+	    copy_data_size = delim_ptr - Medium_Ptr->File.Cur_Ptr;
+	    
+	    if( copy_data_size != 0)
+	    {
+		if( ( buffer_data_ptr = realloc( buffer_data_ptr, ( buffer_data_size + copy_data_size))) == NULL)
+		{
+		    IMRD_LM_LOG_ERROR_1( "Can't allocate Buffer_Data (%d) !", errno);
+		    
+		    return( IMRS_KO);
+		}
+		
+		memcpy( ( buffer_data_ptr + buffer_data_size - 1), Medium_Ptr->File.Cur_Ptr, copy_data_size);  /* Copy data from read buffer to copy buffer */
+		buffer_data_size += copy_data_size;
+		
+		Medium_Ptr->File.Cur_Ptr = next_ptr;
+	    }
+	}
+	while( ( next_ptr == delim_ptr) && ( Medium_Ptr->File.Buffer_Len >= read_buffer_len));
+    }
+
+    if( IMR_SDM_Fmt_Id_Get( &( Buffer_Ptr->Fmt_Id), "Fixed") != IMRS_OK)
+    {
+	IMRD_LM_LOG_ERROR_1( "Can't get FmtId: (%d) !", Buffer_Ptr->Fmt_Id);
+	
+	return( IMRS_KO);
+    }
+
+    if( buffer_data_size <= 1)
+    {
+	IMRD_LM_LOG_TRACE_1( IMRD_LOG_LEVEL_VERBOSE_1, "No more data to read from file: [%s] !", Medium_Ptr->File.Path);
+
+	return( IMRS_NO_DATA);
+    }
+    else
+    {
+	buffer_data_ptr[ ( buffer_data_size - 1)] = '\0';
+
+	Buffer_Ptr->Data_Buf_Ptr  = buffer_data_ptr;
+	Buffer_Ptr->Data_Buf_Len  = buffer_data_size - 1;
+	Buffer_Ptr->Data_Buf_Size = buffer_data_size;
+	Buffer_Ptr->Status =        IMRD_BUFFER_STATUS_ALLOCATED;
+
+	*Read_Len_Ptr = *Read_Len_Ptr + buffer_data_size - 1;
+
+	IMRD_LM_LOG_TRACE_2( IMRD_LOG_LEVEL_VERBOSE_1, "Read (%d) bytes from file: [%s] ", Buffer_Ptr->Data_Buf_Len, Medium_Ptr->File.Path);
+
+	return( IMRS_OK);
+    }
+}
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IO_Hdl_File_Write                                                          */
+/*----------------------------------------------------------------------------*/
+/* Medium_Ptr:      Pointer to the medium to write data to                    */
+/* Write_Len_Ptr:   Number of byte writen                                     */
+/* Buffer_Ptr:      Buffer to read                                            */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  IO_Hdl_File_Write( IMRT_Medium  *Medium_Ptr, size_t  *Write_Len_Ptr, IMRT_Buffer  *Buffer_Ptr)
+{
+    char    *padding_buffer_ptr;
+    long     padding_len;
+
+
+    *Write_Len_Ptr = 0;
+
+    if( ( Medium_Ptr->File.Delim_Len != 0) && ( Medium_Ptr->Msg_Nb > 0))
+    {
+	*Write_Len_Ptr = fwrite( Medium_Ptr->File.Delim, sizeof( char), Medium_Ptr->File.Delim_Len, Medium_Ptr->File.Handle_Ptr);
+
+	if( ferror( Medium_Ptr->File.Handle_Ptr) != 0)
+	{
+	    IMRD_LM_LOG_ERROR_2( "Can't write file [%s] (%d) !", Medium_Ptr->URL, ferror( Medium_Ptr->File.Handle_Ptr));
+
+	    return( IMRS_KO);
+	}
+    }
+
+    padding_len = Medium_Ptr->File.Msg_Len - Buffer_Ptr->Data_Buf_Len;
+
+    if( Medium_Ptr->File.Msg_Len != 0 )
+    {
+	if( padding_len < 2)
+	{
+	    IMRD_LM_LOG_ERROR_2( "Buffer size: (%d) too big for message split size: (%d) !", Buffer_Ptr->Data_Buf_Len, Medium_Ptr->File.Msg_Len);
+
+	    return( IMRS_KO);
+	}
+
+	if( ( padding_buffer_ptr = malloc( padding_len)) == NULL)
+	{
+	    IMRD_LM_LOG_ERROR_1( "Can't allocate padding_buffer (%d) !", errno);
+
+	    return( IMRS_KO);
+	}
+	
+	memset( padding_buffer_ptr, ' ', padding_len);
+
+	padding_buffer_ptr[0] = '\0';
+	padding_buffer_ptr[1] = '\0';
+    }
+
+    *Write_Len_Ptr += fwrite( Buffer_Ptr->Data_Buf_Ptr, sizeof( char), Buffer_Ptr->Data_Buf_Len, Medium_Ptr->File.Handle_Ptr);
+
+    if( ferror( Medium_Ptr->File.Handle_Ptr) != 0)
+    {
+	IMRD_LM_LOG_ERROR_2( "Can't write data in file [%s] (%d) !", Medium_Ptr->URL, ferror( Medium_Ptr->File.Handle_Ptr));
+
+	return( IMRS_KO);
+    }
+
+    if( Medium_Ptr->File.Msg_Len != 0 )
+    {
+	*Write_Len_Ptr += fwrite( padding_buffer_ptr, sizeof( char), padding_len, Medium_Ptr->File.Handle_Ptr);
+	
+	free( padding_buffer_ptr);
+
+	if( ferror( Medium_Ptr->File.Handle_Ptr) != 0)
+	{
+	    IMRD_LM_LOG_ERROR_2( "Can't write padding in file [%s] (%d) !", Medium_Ptr->URL, ferror( Medium_Ptr->File.Handle_Ptr));
+	    
+	    return( IMRS_KO);
+	}
+    }
+
+    fflush( Medium_Ptr->File.Handle_Ptr);
+
+    IMRD_LM_LOG_TRACE_2( IMRD_LOG_LEVEL_VERBOSE_1, "Wrote (%d) bytes to file: [%s] ", *Write_Len_Ptr, Medium_Ptr->File.Path);
+
+    return( IMRS_OK);
+}
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IO_Hdl_File_Begin                                                          */
+/*----------------------------------------------------------------------------*/
+/* IMRT_Medium  *Medium_Ptr                                                   */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  IO_Hdl_File_Begin( IMRT_Medium  *Medium_Ptr)
+{
+    return(IMRS_OK);
+}
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IO_Hdl_File_Commit                                                         */
+/*----------------------------------------------------------------------------*/
+/* IMRT_Medium  *Medium_Ptr                                                   */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  IO_Hdl_File_Commit( IMRT_Medium  *Medium_Ptr)
+{
+    return(IMRS_OK);
+}
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IO_Hdl_File_Rollback                                                       */
+/*----------------------------------------------------------------------------*/
+/* IMRT_Medium  *Medium_Ptr                                                   */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  IO_Hdl_File_Rollback( IMRT_Medium  *Medium_Ptr)
+{
+    return(IMRS_OK);
+}
diff --git a/src/libio_mng/src/io_hdl_file.h b/src/libio_mng/src/io_hdl_file.h
new file mode 100644
index 0000000..264d5e6
--- /dev/null
+++ b/src/libio_mng/src/io_hdl_file.h
@@ -0,0 +1,149 @@
+/*----------------------------------------------------------------------------*/
+/* File: libio_mng.h 				         		      */
+/*----------------------------------------------------------------------------*/
+/*                                                                            */
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#ifndef _IO_HDL_FILE_H_
+#define _IO_HDL_FILE_H_
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Global Include                                                             */
+/*----------------------------------------------------------------------------*/
+
+#include <libio_mng.h>
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Defines                                                                    */
+/*----------------------------------------------------------------------------*/
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Prototypes                                                                 */
+/*----------------------------------------------------------------------------*/
+
+#   ifdef _IO_HDL_FILE_C_
+
+IMRT_Status  IO_Hdl_File_Open(  IMRT_Medium  *, IMRT_Medium_Path, IMRT_Dir_Id);
+IMRT_Status  IO_Hdl_File_Close( IMRT_Medium  *);
+IMRT_Status  IO_Hdl_File_Mem_Str( char  **, const char  *, size_t, const char  *, size_t);
+IMRT_Status  IO_Hdl_File_Read(  IMRT_Buffer  *, size_t  *, IMRT_Medium  *, IMRT_Read_Mode);
+IMRT_Status  IO_Hdl_File_Write( IMRT_Medium  *, size_t  *, IMRT_Buffer  *);
+IMRT_Status  IO_Hdl_File_Begin( IMRT_Medium  *Medium_Ptr);
+IMRT_Status  IO_Hdl_File_Commit( IMRT_Medium  *Medium_Ptr);
+IMRT_Status  IO_Hdl_File_Rollback( IMRT_Medium  *Medium_Ptr);
+
+
+#   else
+
+/*----------------------------------------------------------------------------*/
+/* IO_Hdl_File_Open                                                           */
+/*----------------------------------------------------------------------------*/
+/* Medium_Ptr:    Pointer to the medium to open                               */
+/* Medium_Path:   Medium Path to open                                         */
+/* Dir_Id:        Medium open direction                                       */
+/*----------------------------------------------------------------------------*/
+
+extern IMRT_Status  IO_Hdl_File_Open( IMRT_Medium  *, IMRT_Medium_Path, IMRT_Dir_Id);
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IO_Hdl_File_Close                                                          */
+/*----------------------------------------------------------------------------*/
+/* Medium_Ptr:    Pointer to the medium to close                              */
+/*----------------------------------------------------------------------------*/
+
+extern IMRT_Status  IO_Hdl_File_Close( IMRT_Medium  *);
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IO_Hdl_File_Read                                                           */
+/*----------------------------------------------------------------------------*/
+/* Buffer_Ptr:    Buffer to write data in                                     */
+/* Read_Len_Ptr:  Number of byte readen                                       */
+/* Medium_Path:   Medium to read                                              */
+/* Read_Mode:     Read mode                                                   */
+/*----------------------------------------------------------------------------*/
+
+extern IMRT_Status  IO_Hdl_File_Read( IMRT_Buffer  *, size_t  *, IMRT_Medium  *, IMRT_Read_Mode);
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IO_Hdl_File_Write                                                          */
+/*----------------------------------------------------------------------------*/
+/* Medium_Ptr:      Pointer to the medium towrite data to                     */
+/* Write_Len_Ptr:   Number of byte writen                                     */
+/* Buffer_Ptr:      Buffer to read                                            */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  IO_Hdl_File_Write( IMRT_Medium  *, size_t  *, IMRT_Buffer  *);
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IO_Hdl_File_Begin                                                          */
+/*----------------------------------------------------------------------------*/
+/* IMRT_Medium  *Medium_Ptr                                                   */
+/*----------------------------------------------------------------------------*/
+extern IMRT_Status  IO_Hdl_File_Begin( IMRT_Medium  *Medium_Ptr);
+
+
+/*----------------------------------------------------------------------------*/
+/* IO_Hdl_File_Commit                                                         */
+/*----------------------------------------------------------------------------*/
+/* IMRT_Medium  *Medium_Ptr                                                   */
+/*----------------------------------------------------------------------------*/
+extern IMRT_Status  IO_Hdl_File_Commit( IMRT_Medium  *Medium_Ptr);
+
+
+/*----------------------------------------------------------------------------*/
+/* IO_Hdl_File_Rollback                                                       */
+/*----------------------------------------------------------------------------*/
+/* IMRT_Medium  *Medium_Ptr                                                   */
+/*----------------------------------------------------------------------------*/
+extern IMRT_Status  IO_Hdl_File_Rollback( IMRT_Medium  *Medium_Ptr);
+
+#   endif
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+
+#endif
diff --git a/src/libio_mng/src/io_hdl_mqs.c b/src/libio_mng/src/io_hdl_mqs.c
new file mode 100644
index 0000000..63fcd69
--- /dev/null
+++ b/src/libio_mng/src/io_hdl_mqs.c
@@ -0,0 +1,433 @@
+/*----------------------------------------------------------------------------*/
+/* File: io_hdl_mqs.c   		              		  	      */
+/*----------------------------------------------------------------------------*/
+/*                                                                            */
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#define _LIBIO_MNG_
+#define _IO_HDL_MQS_C_
+
+
+
+#include "io_hdl_mqs.h" 
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IO_Hdl_MQS_Open                                                            */
+/*----------------------------------------------------------------------------*/
+/* Medium_Ptr:    Pointer to the medium to open                               */
+/* Medium_Path:   Medium Path to open                                         */
+/* Dir_Id:        Medium open direction                                       */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  IO_Hdl_MQS_Open( IMRT_Medium  *Medium_Ptr, IMRT_Medium_Path  Medium_Path, IMRT_Dir_Id  Dir_Id)
+{
+    MQLONG        comp_code;                         /* completion code               */
+    MQLONG        reason_code;                       /* reason code                   */
+    char         *pos_slash_ptr;
+    MQOD          od             = {MQOD_DEFAULT};   /* Object Descriptor             */
+    MQLONG        options;                           /* MQOPEN/MQCLOSE options        */
+
+
+    if( Dir_Id == IMRD_DIR_ID_IN)
+    {
+	/*positionnenment des option d'ouverture du de la Queue*/
+	options = MQOO_INPUT_AS_Q_DEF | MQOO_FAIL_IF_QUIESCING; /* open queue for input  but not if MQM stopping   */
+    }
+    else
+    {
+	if( Dir_Id == IMRD_DIR_ID_OUT)
+	{
+	    /*positionnenment des option d'ouverture du de la Queue*/
+	    options = MQOO_OUTPUT | MQOO_FAIL_IF_QUIESCING;     /* open queue for output but not if MQM stopping   */
+	}
+	else
+	{
+	    IMRD_LM_LOG_ERROR_1( "Invalid Dir_Id (%d) !", Dir_Id);
+
+	    return( IMRS_KO);
+	}
+    }
+
+    pos_slash_ptr = strstr( Medium_Path, "/");
+    
+    if( pos_slash_ptr == NULL)
+    {
+	IMRD_LM_LOG_ERROR_1( "Invalid mqs path [%s] !", Medium_Path);
+	return( IMRS_KO);
+    }
+
+    strncpy( Medium_Ptr->MQS.Queue_Mng, Medium_Path, strlen( Medium_Path) - strlen( pos_slash_ptr));
+    Medium_Ptr->MQS.Queue_Mng[ strlen( Medium_Path) - strlen( pos_slash_ptr)] = '\0';
+	    
+    strcpy( Medium_Ptr->MQS.Queue_Name, ( pos_slash_ptr + 1));
+		
+    /*queue manager connection*/
+    MQCONN( Medium_Ptr->MQS.Queue_Mng, &( Medium_Ptr->MQS.Conn_Hdl), &comp_code, &reason_code);
+
+    if( comp_code == MQCC_FAILED)
+    {
+	IMRD_LM_LOG_ERROR_2( "MQCONN ended with reason code (%d) for this path [%s] !", reason_code, Medium_Path);
+
+	return( IMRS_KO);
+    }
+
+    strcpy( od.ObjectName, Medium_Ptr->MQS.Queue_Name);
+
+    /*open the queue*/
+    MQOPEN( Medium_Ptr->MQS.Conn_Hdl, &od, options, &( Medium_Ptr->MQS.Obj_Hdl), &comp_code, &reason_code);
+		
+    /* report reason, if any; stop if failed      */
+    if( reason_code != MQRC_NONE)
+    {
+	IMRD_LM_LOG_ERROR_2( "MQOPEN ended with reason code (%d) for this path [%s] !", reason_code, Medium_Path);
+
+	return( IMRS_KO);
+    }
+    
+    if( comp_code == MQCC_FAILED)
+    {
+	IMRD_LM_LOG_ERROR_1( "Unable to open queue for this path [%s] !", Medium_Path);
+
+	return( IMRS_KO);
+    }
+    else
+    {
+	IMRD_LM_LOG_TRACE_3( IMRD_LOG_LEVEL_VERBOSE_1, "Queue_Mng: [%s]   Queue: [%s]   Dir: [%s] opened !", Medium_Ptr->MQS.Queue_Mng, Medium_Ptr->MQS.Queue_Name, ( ( Dir_Id == IMRD_DIR_ID_IN) ? "in" : ( ( Dir_Id == IMRD_DIR_ID_OUT) ? "out" : "unknown")));
+
+	return( IMRS_OK);
+    }
+}
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IO_Hdl_MQS_Close                                                           */
+/*----------------------------------------------------------------------------*/
+/* Medium_Ptr:    Pointer to the medium to close                              */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  IO_Hdl_MQS_Close( IMRT_Medium  *Medium_Ptr)
+{
+    MQLONG        comp_code;                         /* completion code               */
+    MQLONG        reason_code;                       /* reason code                   */
+    char         *pos_slash_ptr;
+    MQOD          od             = {MQOD_DEFAULT};   /* Object Descriptor             */
+
+
+    MQCLOSE( Medium_Ptr->MQS.Conn_Hdl, &( Medium_Ptr->MQS.Obj_Hdl), MQCO_NONE, &comp_code, &reason_code);
+ 
+    if( reason_code != MQRC_NONE)
+    {
+	IMRD_LM_LOG_ERROR_2( "MQCLOSE ended with reason code [%d] for queue: [%s] !", reason_code, Medium_Ptr->MQS.Queue_Name);
+
+	return( IMRS_KO);
+    }
+
+    MQDISC( &Medium_Ptr->MQS.Conn_Hdl, &comp_code, &reason_code);
+
+    /* report reason, if any     */
+    if( reason_code != MQRC_NONE)
+    {
+	IMRD_LM_LOG_ERROR_2( "MQCLOSE ended with reason code [%d] for queue: [%s] !", reason_code, Medium_Ptr->MQS.Queue_Name);
+
+	return( IMRS_KO);
+    }
+    else
+    {
+	IMRD_LM_LOG_TRACE_2( IMRD_LOG_LEVEL_VERBOSE_1, "Queue_Mng: [%s]   Queue: [%s] closed !", Medium_Ptr->MQS.Queue_Mng, Medium_Ptr->MQS.Queue_Name);
+
+	return( IMRS_OK);
+    }
+}
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IO_Hdl_MQS_Read                                                            */
+/*----------------------------------------------------------------------------*/
+/* Buffer_Ptr:    Buffer to write data in                                     */
+/* Read_Len_Ptr:  Number of byte writen                                       */
+/* Medium_Path:   Medium to read                                              */
+/* Read_Mode:     Read mode                                                   */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  IO_Hdl_MQS_Read( IMRT_Buffer  *Buffer_Ptr, size_t  *Read_Len_Ptr, IMRT_Medium  *Medium_Ptr, IMRT_Read_Mode  Read_Mode)
+{
+    MQLONG            comp_code;                        /* completion code               */
+    MQLONG            reason_code;                      /* reason code                   */
+    IMRT_MQS_Buffer  *buffer_ptr;
+    MQLONG            buffer_len;
+    MQGMO             gmo          = {MQGMO_DEFAULT};   /* get message options           */
+    MQMD              md           = {MQMD_DEFAULT};    /* Message Descriptor            */
+
+
+    
+
+    switch( Read_Mode)
+    {
+	case IMRD_READ_MODE_WAIT:
+	{
+	    gmo.Options = MQGMO_WAIT ;
+	    break;
+	}
+	
+	case IMRD_READ_MODE_NO_WAIT:
+	{
+	    gmo.Options = MQGMO_NO_WAIT ;
+	    break;
+	}
+
+	default:
+	{
+	    IMRD_LM_LOG_ERROR_1( "Unknown Read_Mode: (%d) !", Read_Mode);
+
+	    return( IMRS_KO);
+	}
+    }
+
+    gmo.Options      |= MQGMO_CONVERT;
+
+    if( Medium_Ptr->Tran_Flag == IMRD_MEDIUM_TRAN_FLAG_IN)
+    {
+	gmo.Options |= MQGMO_SYNCPOINT;
+    }
+
+//    gmo.WaitInterval =  MQWI_UNLIMITED;      
+    gmo.WaitInterval = 10000;
+
+    if( ( buffer_ptr = malloc( IMRD_MQS_BUFFER_SIZE)) == NULL)
+    {
+	IMRD_LM_LOG_ERROR_1( "Can't allocate MQS Buffer (%d) !", errno);
+	
+	return( IMRS_KO);
+    }
+
+    memcpy( md.MsgId,    MQMI_NONE, sizeof(md.MsgId));
+    memcpy( md.CorrelId, MQCI_NONE, sizeof(md.CorrelId));
+    md.Encoding       = MQENC_NATIVE;
+    md.CodedCharSetId = MQCCSI_Q_MGR;
+
+    do
+    {
+
+	MQGET( Medium_Ptr->MQS.Conn_Hdl, Medium_Ptr->MQS.Obj_Hdl, &md, &gmo, IMRD_MQS_BUFFER_SIZE, buffer_ptr, &buffer_len, &comp_code, &reason_code);
+
+    } while( ( Read_Mode == IMRD_READ_MODE_WAIT) && ( reason_code == MQRC_NO_MSG_AVAILABLE) && ( IMRG_Base.Sig_Trapped == 0));
+
+    if( reason_code != MQRC_NONE)
+    {
+	if( reason_code == MQRC_NO_MSG_AVAILABLE)
+	{
+	    free( buffer_ptr);
+
+	    if( IMRG_Base.Sig_Trapped == 0)
+	    {
+		IMRD_LM_LOG_TRACE_2( IMRD_LOG_LEVEL_VERBOSE_1, "No more data to read from Queue_Mng: [%s]   Queue: [%s] !", Medium_Ptr->MQS.Queue_Mng, Medium_Ptr->MQS.Queue_Name);
+
+		return( IMRS_NO_DATA);
+	    }
+	    else
+	    {
+		IMRD_LM_LOG_TRACE_2( IMRD_LOG_LEVEL_VERBOSE_1, "Signal received during reading from Queue_Mng: [%s]   Queue: [%s] !", Medium_Ptr->MQS.Queue_Mng, Medium_Ptr->MQS.Queue_Name);
+
+		return( IMRS_SIGNAL);
+	    }
+	}
+	else
+	{
+	    if( reason_code == MQRC_TRUNCATED_MSG_FAILED)
+	    {
+		IMRD_LM_LOG_ERROR_2( "MQGET failed: truncated message   rc: [%d]   for queue: [%s] !", reason_code, Medium_Ptr->MQS.Queue_Name);
+
+		return( IMRS_KO);
+	    }
+	    else
+	    {
+		IMRD_LM_LOG_ERROR_2( "MQGET failed:    rc: [%d]   for queue: [%s] !", reason_code, Medium_Ptr->MQS.Queue_Name);
+
+		return( IMRS_KO);
+	    }
+	}
+    }
+    else
+    {
+	if( comp_code == MQCC_FAILED)
+	{
+	    IMRD_LM_LOG_ERROR_2( "MQGET failed: ???   rc: [%d]   for queue: [%s] !", reason_code, Medium_Ptr->MQS.Queue_Name);
+	    
+	    return( IMRS_KO);
+	}
+	else
+	{
+	    
+	    buffer_ptr[ buffer_len] = '\0';            /* add terminator */
+	    
+	    Buffer_Ptr->Data_Buf_Ptr  = (IMRT_Buffer_Data *)buffer_ptr;
+	    Buffer_Ptr->Data_Buf_Len  = (size_t)buffer_len;
+	    Buffer_Ptr->Data_Buf_Size = IMRD_MQS_BUFFER_SIZE;
+	    Buffer_Ptr->Status        = IMRD_BUFFER_STATUS_ALLOCATED;
+	    
+	    *Read_Len_Ptr =  Buffer_Ptr->Data_Buf_Len;
+
+	    if( IMR_SDM_Fmt_Id_Get( &( Buffer_Ptr->Fmt_Id), "Fixed") != IMRS_OK)
+	    {
+		IMRD_LM_LOG_ERROR_1( "Can't get FmtId: (%d)  !", Buffer_Ptr->Fmt_Id);
+		
+		return( IMRS_KO);
+	    }
+	    else
+	    {
+		IMRD_LM_LOG_TRACE_3( IMRD_LOG_LEVEL_VERBOSE_1, "Read (%d) bytes from Queue_Mng: [%s]    Queue: [%s] !", Buffer_Ptr->Data_Buf_Len, Medium_Ptr->MQS.Queue_Mng, Medium_Ptr->MQS.Queue_Name);
+		
+		return( IMRS_OK);
+	    }
+	}
+    }
+}
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IO_Hdl_MQS_Write                                                          */
+/*----------------------------------------------------------------------------*/
+/* Medium_Ptr:      Pointer to the medium to write data to                    */
+/* Write_Len_Ptr:   Number of byte writen                                     */
+/* Buffer_Ptr:      Buffer to read                                            */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  IO_Hdl_MQS_Write( IMRT_Medium  *Medium_Ptr, size_t  *Write_Len_Ptr, IMRT_Buffer  *Buffer_Ptr)
+{
+    MQLONG       comp_code;                        /* completion code               */
+    MQLONG       reason_code;                      /* reason code                   */
+    MQPMO        pmo          = {MQPMO_DEFAULT};   /* put message options           */
+    MQMD         md           = {MQMD_DEFAULT};    /* Message Descriptor            */
+
+
+    memcpy( md.Format, MQFMT_STRING, (size_t)MQ_FORMAT_LENGTH);
+
+    pmo.Options |= MQPMO_NEW_MSG_ID | MQPMO_NEW_CORREL_ID;
+
+    if( Medium_Ptr->Tran_Flag == IMRD_MEDIUM_TRAN_FLAG_IN)
+    {
+	pmo.Options |= MQPMO_SYNCPOINT;
+    }
+
+    MQPUT( Medium_Ptr->MQS.Conn_Hdl, Medium_Ptr->MQS.Obj_Hdl, &md, &pmo, (MQLONG)( Buffer_Ptr->Data_Buf_Len), Buffer_Ptr->Data_Buf_Ptr, &comp_code, &reason_code);
+
+    if( reason_code != MQRC_NONE)
+    {
+	IMRD_LM_LOG_ERROR_2( "MQPUT failed: (%d)   for queue: [%s] !", reason_code, Medium_Ptr->MQS.Queue_Name);
+
+	return( IMRS_KO);
+    }
+    else
+    {
+	*Write_Len_Ptr =  Buffer_Ptr->Data_Buf_Len;
+	IMRD_LM_LOG_TRACE_3( IMRD_LOG_LEVEL_VERBOSE_1, "Wrote (%d) bytes to Queue_Mng: [%s]    Queue: [%s]!", *Write_Len_Ptr, Medium_Ptr->MQS.Queue_Mng, Medium_Ptr->MQS.Queue_Name);
+
+	return( IMRS_OK);
+    }
+}
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IO_Hdl_MQS_Begin                                                           */
+/*----------------------------------------------------------------------------*/
+/* Medium_Ptr:      Pointer to the medium                                     */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  IO_Hdl_MQS_Begin( IMRT_Medium  *Medium_Ptr)
+{
+
+    return(IMRS_OK);
+ 
+}
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IO_Hdl_MQS_Commit                                                          */
+/*----------------------------------------------------------------------------*/
+/* Medium_Ptr:      Pointer to the medium                                     */
+/*----------------------------------------------------------------------------*/
+
+
+IMRT_Status  IO_Hdl_MQS_Commit( IMRT_Medium  *Medium_Ptr)
+{
+    MQLONG       comp_code;                        /* completion code               */
+    MQLONG       reason_code;                      /* reason code                   */
+    IMRT_Status  status;
+
+    status = IMRS_OK; 
+
+    MQCMIT(Medium_Ptr->MQS.Conn_Hdl,
+	   &comp_code,
+	   &reason_code);
+    if( reason_code != MQRC_NONE)
+    {
+	IMRD_LM_LOG_ERROR_2( "MQCMIT failed: (%d)   for queue: [%s] !", reason_code, Medium_Ptr->MQS.Queue_Name);
+	status = IMRS_KO;
+    }
+    return(status);
+ 
+}
+
+/*----------------------------------------------------------------------------*/
+/* IO_Hdl_MQS_Rollback                                                        */
+/*----------------------------------------------------------------------------*/
+/* Medium_Ptr:      Pointer to the medium                                     */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  IO_Hdl_MQS_Rollback( IMRT_Medium  *Medium_Ptr)
+{
+    MQLONG       comp_code;                        /* completion code               */
+    MQLONG       reason_code;                      /* reason code                   */
+    IMRT_Status  status;
+
+    status = IMRS_OK; 
+ 
+    MQBACK(Medium_Ptr->MQS.Conn_Hdl,
+	   &comp_code,
+	   &reason_code);
+    if( reason_code != MQRC_NONE)
+    {
+	IMRD_LM_LOG_ERROR_2( "MQBACK failed: (%d)   for queue: [%s] !", reason_code, Medium_Ptr->MQS.Queue_Name);
+	status = IMRS_KO;
+    }
+ 
+    return(status);
+ 
+}
diff --git a/src/libio_mng/src/io_hdl_mqs.h b/src/libio_mng/src/io_hdl_mqs.h
new file mode 100644
index 0000000..53a4167
--- /dev/null
+++ b/src/libio_mng/src/io_hdl_mqs.h
@@ -0,0 +1,149 @@
+/*----------------------------------------------------------------------------*/
+/* File: io_hdl_mqs.h 				         		      */
+/*----------------------------------------------------------------------------*/
+/*                                                                            */
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#ifndef _IO_HDL_MQS_H_
+#define _IO_HDL_MQS_H_
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Global Include                                                             */
+/*----------------------------------------------------------------------------*/
+
+#include <libio_mng.h>
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Defines                                                                    */
+/*----------------------------------------------------------------------------*/
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Prototypes                                                                 */
+/*----------------------------------------------------------------------------*/
+
+#   ifdef _IO_HDL_MQS_C_
+
+IMRT_Status  IO_Hdl_MQS_Open(  IMRT_Medium  *, IMRT_Medium_Path, IMRT_Dir_Id);
+IMRT_Status  IO_Hdl_MQS_Close( IMRT_Medium  *);
+IMRT_Status  IO_Hdl_MQS_Read(  IMRT_Buffer  *, size_t  *, IMRT_Medium  *, IMRT_Read_Mode);
+IMRT_Status  IO_Hdl_MQS_Write( IMRT_Medium  *, size_t  *, IMRT_Buffer  *);
+IMRT_Status  IO_Hdl_MQS_Commit( IMRT_Medium  *);
+IMRT_Status  IO_Hdl_MQS_Rollback( IMRT_Medium  *);
+IMRT_Status  IO_Hdl_MQS_Begin( IMRT_Medium  *);
+
+#   else
+
+/*----------------------------------------------------------------------------*/
+/* IO_Hdl_MQS_Open                                                            */
+/*----------------------------------------------------------------------------*/
+/* Medium_Ptr:    Pointer to the medium to open                               */
+/* Medium_Path:   Medium Path to open                                         */
+/* Dir_Id:        Medium open direction                                       */
+/*----------------------------------------------------------------------------*/
+
+extern IMRT_Status  IO_Hdl_MQS_Open( IMRT_Medium  *, IMRT_Medium_Path, IMRT_Dir_Id);
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IO_Hdl_MQS_Close                                                           */
+/*----------------------------------------------------------------------------*/
+/* Medium_Ptr:    Pointer to the medium to close                              */
+/*----------------------------------------------------------------------------*/
+
+extern IMRT_Status  IO_Hdl_MQS_Close( IMRT_Medium  *);
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IO_Hdl_MQS_Read                                                            */
+/*----------------------------------------------------------------------------*/
+/* Buffer_Ptr:    Buffer to write data in                                     */
+/* Read_Len_Ptr:  Number of byte writen                                       */
+/* Medium_Path:   Medium to read                                              */
+/* Read_Mode:     Read mode                                                   */
+/*----------------------------------------------------------------------------*/
+
+extern IMRT_Status  IO_Hdl_MQS_Read( IMRT_Buffer  *, size_t  *, IMRT_Medium  *, IMRT_Read_Mode);
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IO_Hdl_MQS_Write                                                           */
+/*----------------------------------------------------------------------------*/
+/* Medium_Ptr:     Pointer to the medium towrite data to                      */
+/* Write_Len_Ptr:  Number of byte writen                                      */
+/* Buffer_Ptr:     Buffer to read                                             */
+/*----------------------------------------------------------------------------*/
+
+extern IMRT_Status  IO_Hdl_MQS_Write( IMRT_Medium  *, size_t  *, IMRT_Buffer  *);
+
+
+/*----------------------------------------------------------------------------*/
+/* IO_Hdl_MQS_Commit                                                          */
+/*----------------------------------------------------------------------------*/
+/* Medium_Ptr:      Pointer to the medium                                     */
+/*----------------------------------------------------------------------------*/
+
+extern IMRT_Status  IO_Hdl_MQS_Commit( IMRT_Medium  *);
+
+/*----------------------------------------------------------------------------*/
+/* IO_Hdl_MQS_Rollback                                                        */
+/*----------------------------------------------------------------------------*/
+/* Medium_Ptr:      Pointer to the medium                                     */
+/*----------------------------------------------------------------------------*/
+
+extern IMRT_Status  IO_Hdl_MQS_Rollback( IMRT_Medium  *);
+
+/*----------------------------------------------------------------------------*/
+/* IO_Hdl_MQS_Begin                                                           */
+/*----------------------------------------------------------------------------*/
+/* Medium_Ptr:      Pointer to the medium                                     */
+/*----------------------------------------------------------------------------*/
+
+extern IMRT_Status  IO_Hdl_MQS_Begin( IMRT_Medium  *);
+
+
+
+#   endif
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+
+#endif
diff --git a/src/libio_mng/src/io_hdl_tux.c b/src/libio_mng/src/io_hdl_tux.c
new file mode 100644
index 0000000..089ff16
--- /dev/null
+++ b/src/libio_mng/src/io_hdl_tux.c
@@ -0,0 +1,595 @@
+/*----------------------------------------------------------------------------*/
+/* File: io_hdl_tux.c   		              		  	      */
+/*----------------------------------------------------------------------------*/
+/*                                                                            */
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#define _LIBIO_MNG_
+#define _IO_HDL_TUX_C_
+
+
+
+#include "io_hdl_tux.h" 
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IO_Hdl_Tux_Open                                                            */
+/*----------------------------------------------------------------------------*/
+/* Medium_Ptr:    Pointer to the medium to open                               */
+/* Medium_Path:   Medium Path to open                                         */
+/* Dir_Id:        Medium open direction                                       */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  IO_Hdl_Tux_Open( IMRT_Medium  *Medium_Ptr, IMRT_Medium_Path  Medium_Path, IMRT_Dir_Id  Dir_Id)
+{
+    char        *Pos_Slash_Ptr;
+
+
+    Pos_Slash_Ptr = strstr(Medium_Path, "/");
+
+    if(Pos_Slash_Ptr == NULL)
+    {
+	IMRD_LM_LOG_ERROR_1( "Invalid tux path [%s] !", Medium_Path);
+
+	return( IMRS_KO);
+    }
+    else
+    {
+	strncpy(Medium_Ptr->Tux.Queue_Space, Medium_Path, strlen(Medium_Path) - strlen(Pos_Slash_Ptr));
+	Medium_Ptr->Tux.Queue_Space[strlen(Medium_Path) - strlen(Pos_Slash_Ptr)] = '\0';
+
+	strcpy(Medium_Ptr->Tux.Queue_Name, (Pos_Slash_Ptr + 1));
+
+	if( Queue_Exist( Medium_Ptr->Tux.Queue_Space, Medium_Ptr->Tux.Queue_Name) != IMRS_OK)
+	{
+	    IMRD_LM_LOG_ERROR_2( "Tux Queue doesn't exist:   Queue_Space: [%s]    Queue: [%s] !", Medium_Ptr->Tux.Queue_Space, Medium_Ptr->Tux.Queue_Name);
+	    return( IMRS_KO);
+	}
+	else
+	{
+	    IMRD_LM_LOG_TRACE_2( IMRD_LOG_LEVEL_VERBOSE_1, "Queue_Space: [%s]   Queue: [%s]   opened !", Medium_Ptr->Tux.Queue_Space, Medium_Ptr->Tux.Queue_Name);
+
+	    return( IMRS_OK);
+	}
+    }
+}
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IO_Hdl_Tux_Close                                                           */
+/*----------------------------------------------------------------------------*/
+/* Medium_Ptr:    Pointer to the medium to close                              */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  IO_Hdl_Tux_Close( IMRT_Medium  *Medium_Ptr)
+{
+    IMRD_LM_LOG_TRACE_2( IMRD_LOG_LEVEL_VERBOSE_1, "Queue_Space: [%s]   Queue: [%s] closed !", Medium_Ptr->Tux.Queue_Space, Medium_Ptr->Tux.Queue_Name);
+ 
+    return( IMRS_OK);
+}
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IO_Hdl_Tux_Read                                                            */
+/*----------------------------------------------------------------------------*/
+/* Buffer_Ptr:    Buffer to write data in                                     */
+/* Read_Len_Ptr:  Number of byte writen                                       */
+/* Medium_Path:   Medium to read                                              */
+/* Read_Mode:     Read mode                                                   */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  IO_Hdl_Tux_Read( IMRT_Buffer  *Buffer_Ptr, size_t *Read_Len_Ptr, IMRT_Medium  *Medium_Ptr, IMRT_Read_Mode  Read_Mode)
+{
+    IMRT_Tux_Buffer  *Tux_Buffer_Ptr = NULL;
+    TPQCTL            queue_param;
+    long              len;
+    long flags;
+
+
+    memset(queue_param.corrid, '\0', sizeof(queue_param.corrid));
+
+    switch( Read_Mode)
+    {
+	case IMRD_READ_MODE_WAIT:
+	{
+	    queue_param.flags = TPQWAIT;
+	    break;
+	}
+	
+	case IMRD_READ_MODE_NO_WAIT:
+	{
+	    break;
+	}
+	
+
+	default:
+	{
+	    IMRD_LM_LOG_ERROR_1( "Unknown Read_Mode: (%d) !", Read_Mode);
+
+	    return( IMRS_KO);
+	}
+    }
+
+    queue_param.diagnostic = 0L;
+
+    if( ( Tux_Buffer_Ptr = (IMRT_Tux_Buffer *)tpalloc(IMRD_FML_TYPE_32, NULL, IMRD_TUX_BUFFER_SIZE)) == NULL)
+    {
+	IMRD_LM_LOG_ERROR_1( "Can't allocate Tux_Buffer_Ptr [%s] !", tpstrerror(tperrno));
+
+	return( IMRS_KO);
+    }
+
+    if( Finit32( (IMRT_Tux_Buffer *)Tux_Buffer_Ptr, (FLDLEN32)IMRD_TUX_BUFFER_SIZE) == -1)
+    {
+	IMRD_LM_LOG_ERROR_1( "Can't initialize Tux_Buffer_Ptr [%s] !", Fstrerror32(Ferror32));
+
+	return( IMRS_KO);
+    }
+
+
+    if( tpdequeue( Medium_Ptr->Tux.Queue_Space, Medium_Ptr->Tux.Queue_Name, &queue_param, (char **)&Tux_Buffer_Ptr, &len, TPNOTIME) == -1)
+    {
+	switch( tperrno)
+	{
+	    case TPGOTSIG:
+	    {
+		IMRD_LM_LOG_TRACE_2( IMRD_LOG_LEVEL_VERBOSE_1, "Signal received during reading from QSpace [%s]   QueueName [%s] !", Medium_Ptr->Tux.Queue_Space, Medium_Ptr->Tux.Queue_Name);
+
+		return( IMRS_SIGNAL);
+	    }
+
+	    default:
+	    {
+		switch( queue_param.diagnostic)
+		{
+		    case QMENOMSG:
+		    {
+			IMRD_LM_LOG_TRACE_2( IMRD_LOG_LEVEL_VERBOSE_1, "No more data to read from QSpace [%s]   QueueName [%s] !", Medium_Ptr->Tux.Queue_Space, Medium_Ptr->Tux.Queue_Name);
+			
+			return( IMRS_NO_DATA);
+		    }
+
+		    default:
+		    {
+			IMRD_LM_LOG_ERROR_4( "Can't read buffer from QSpace [%s]   QueueName [%s] : [%s] [%d] !", Medium_Ptr->Tux.Queue_Space, Medium_Ptr->Tux.Queue_Name, tpstrerror(tperrno), queue_param.diagnostic);
+
+			return( IMRS_KO);
+		    }
+		}
+	    }
+	}
+    }
+    else
+    {
+	Buffer_Ptr->Data_Buf_Ptr  = (IMRT_Buffer_Data *)Tux_Buffer_Ptr;
+	Buffer_Ptr->Data_Buf_Len  = Fused32( Tux_Buffer_Ptr);
+	Buffer_Ptr->Data_Buf_Size = Fsizeof32( Tux_Buffer_Ptr);
+	Buffer_Ptr->Status =        IMRD_BUFFER_STATUS_ALLOCATED;
+
+	*Read_Len_Ptr =  Buffer_Ptr->Data_Buf_Len;
+
+	if( IMR_SDM_Fmt_Id_Get( &( Buffer_Ptr->Fmt_Id), "FML") != IMRS_OK)
+	{
+	    IMRD_LM_LOG_ERROR_0( "Can't get FmtId !");
+
+	    return( IMRS_KO);
+	}
+	else
+	{
+	    IMRD_LM_LOG_TRACE_3( IMRD_LOG_LEVEL_VERBOSE_1, "Read (%d) bytes from Queue_Space: [%s]   Queue: [%s] !", Buffer_Ptr->Data_Buf_Len, Medium_Ptr->Tux.Queue_Space, Medium_Ptr->Tux.Queue_Name);
+
+	    return( IMRS_OK);
+	}
+    }
+}
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IO_Hdl_Tux_Write                                                           */
+/*----------------------------------------------------------------------------*/
+/* Medium_Ptr:      Pointer to the medium to write data to                    */
+/* Write_Len_Ptr:   Number of byte writen                                     */
+/* Buffer_Ptr:      Buffer to read                                            */
+/* Write_Len_Ptr:   Number of byte writen                                     */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  IO_Hdl_Tux_Write( IMRT_Medium  *Medium_Ptr, size_t  *Write_Len_Ptr, IMRT_Buffer  *Buffer_Ptr)
+{
+    TPQCTL  queue_param;
+
+    memset( queue_param.corrid, '\0', sizeof( queue_param.corrid));
+    queue_param.flags = 0L;
+    queue_param.diagnostic = 0L; 
+ 
+    if( tpenqueue( Medium_Ptr->Tux.Queue_Space, Medium_Ptr->Tux.Queue_Name, &queue_param, Buffer_Ptr->Data_Buf_Ptr, 0, TPNOFLAGS) == -1)
+    {
+	IMRD_LM_LOG_ERROR_3( "Can't write buffer to QSpace [%s] QueueName [%s] : [%s] !", Medium_Ptr->Tux.Queue_Space, Medium_Ptr->Tux.Queue_Name, tpstrerror(tperrno) );
+	
+
+	return( IMRS_KO);
+    }
+    else
+    {
+	*Write_Len_Ptr =  Buffer_Ptr->Data_Buf_Len;
+	IMRD_LM_LOG_TRACE_3( IMRD_LOG_LEVEL_VERBOSE_1, "Wrote (%d) bytes to Queue_Space: [%s]    Queue: [%s]!", *Write_Len_Ptr, Medium_Ptr->Tux.Queue_Space, Medium_Ptr->Tux.Queue_Name);
+	
+	return( IMRS_OK);
+    }
+}
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Queue_Alloc                                                                */
+/*----------------------------------------------------------------------------*/
+/* Buf_Ptr_Ptr:   Tuxedo Buffer                                               */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  Queue_Alloc( IMRT_Tux_Buffer  **Buf_Ptr_Ptr)
+{
+    if( ( *Buf_Ptr_Ptr = (IMRT_Tux_Buffer *)tpalloc( IMRD_FML_TYPE_32, NULL, IMRD_TUX_BUFFER_SIZE)) == NULL) 
+    {
+	IMRD_LM_LOG_ERROR_1( "Can't tpalloc Buffer: [%s] !", tpstrerror( tperrno));
+
+	return( IMRS_KO);
+    }
+
+    if( Finit32( (IMRT_Tux_Buffer *)*Buf_Ptr_Ptr, (FLDLEN32)IMRD_TUX_BUFFER_SIZE) == -1)
+    {
+	IMRD_LM_LOG_ERROR_1( "Can't Finit32 Buffer: [%s] !", Fstrerror32( Ferror32));
+
+	return( IMRS_KO);
+    }
+
+    return( IMRS_OK);
+}
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Queue_Free                                                                 */
+/*----------------------------------------------------------------------------*/
+/* Buf_Ptr:   Tuxedo Buffer                                                   */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  Queue_Free( IMRT_Tux_Buffer  *Buf_Ptr)
+{
+    if( Buf_Ptr != NULL)
+    {
+	tpfree( (char *)Buf_Ptr);
+    }
+}
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Queue_Exist_Mib                                                            */
+/*----------------------------------------------------------------------------*/
+/* Queue_Space:        Queue Space Name                                       */
+/* Queue_Name:         Queue Name                                             */
+/* Request_Buf_Ptr:    Request Tuxedo Buffer                                  */
+/* Response_Buf_Ptr:   Response Tuxedo Buffer                                 */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  Queue_Exist_Mib( IMRT_Tux_Queue_Space Queue_Space, IMRT_Tux_Queue_Name Queue_Name, IMRT_Tux_Buffer  *Request_Buf_Ptr, IMRT_Tux_Buffer  *Response_Buf_Ptr)
+{
+    IMRT_Tux_Lmid        lmid;
+    long                 fldid1, fldid2;
+    long                 nb_occurs = 0L;
+    long                 rlen = 0L;
+    IMRT_Tux_Open_Info   open_info;
+    char                *qmconfig, *appqspacename;
+    int                  i;
+
+
+    if( Fchg32( Request_Buf_Ptr, TA_OPERATION, 0, "GET", 0) == -1)
+    {
+	IMRD_LM_LOG_ERROR_1( "Fchg32 TA_OPERATION: [%s] !", Fstrerror32( Ferror32));
+	return( IMRS_KO);
+    }
+
+    if( Fchg32( Request_Buf_Ptr, TA_CLASS, 0, "T_GROUP", 0) == -1)
+    {
+	IMRD_LM_LOG_ERROR_1( "Fchg32 TA_CLASS: [%s] !", Fstrerror32( Ferror32));
+	return( IMRS_KO);
+    }
+
+    if( Fchg32( Request_Buf_Ptr, TA_TMSNAME, 0, "TMS_QM", 0) == -1)
+    {
+	IMRD_LM_LOG_ERROR_1( "Fchg32 TA_TMSNAME: [%s] !", Fstrerror32( Ferror32));
+	return( IMRS_KO);
+    }
+
+    fldid1 = TA_OPENINFO;
+    if( Fchg32( Request_Buf_Ptr, TA_FILTER, 0, (char *)&fldid1, 0) == -1)
+    {
+	IMRD_LM_LOG_ERROR_1( "Fchg32 TA_FILTER: [%s] !", Fstrerror32( Ferror32));
+	return( IMRS_KO);
+    }
+
+    fldid2 = TA_LMID;
+    if( Fchg32( Request_Buf_Ptr, TA_FILTER, 1, (char *)&fldid2, 0) == -1)
+    {
+	IMRD_LM_LOG_ERROR_1( "Fchg32 TA_FILTER: [%s] !", Fstrerror32( Ferror32));
+	return( IMRS_KO);
+    }
+
+    if( tpcall( IMRD_TMIB_SERVICE, (void *)Request_Buf_Ptr,0, (char**)&Response_Buf_Ptr, &rlen, 0L) < 0)
+    {
+	IMRD_LM_LOG_ERROR_1( "Error tpcall: [%s] !", tpstrerror( tperrno));
+	return( IMRS_KO);
+    }
+
+    if( Fget32( Response_Buf_Ptr, TA_OCCURS, 0, (char *)&nb_occurs, NULL) == -1 )
+    {
+	IMRD_LM_LOG_ERROR_1( "Fget32 TA_OCCURS: [%s] !", Fstrerror32( Ferror32));
+	return( IMRS_KO);
+    }
+    
+    for( i=0; i < nb_occurs; i++)
+    {
+	if( Fget32( Response_Buf_Ptr, TA_OPENINFO, i, open_info, NULL) == -1)
+	{
+	    IMRD_LM_LOG_ERROR_1( "Fget32 TA_OPENINFO: [%s] !", Fstrerror32( Ferror32));
+	    return( IMRS_KO);
+	}
+	
+	qmconfig         = (char *)strchr(open_info, ':')+1;
+	appqspacename    = (char *)strchr(qmconfig, ':');
+	appqspacename[0] = 0;
+	appqspacename++;
+	
+	if( strcmp( appqspacename, Queue_Space) == 0)
+	{
+	    i = nb_occurs;
+	}
+    }
+
+    if( Fget32( Response_Buf_Ptr, TA_LMID, 0, lmid, NULL) == -1)
+    {
+	IMRD_LM_LOG_ERROR_1( "Fget32 TA_LMID: [%s] !", Fstrerror32( Ferror32));
+	return( IMRS_KO);
+    }
+    
+    if( Finit32( (FBFR32 *)Request_Buf_Ptr, (FLDLEN32)IMRD_TUX_BUFFER_SIZE) == -1 )
+    {
+	IMRD_LM_LOG_ERROR_1( "Finit32 Buffer1: [%s] !", Fstrerror32( Ferror32));
+	return( IMRS_KO);
+    }
+    
+    if( Finit32( (FBFR32 *)Response_Buf_Ptr, (FLDLEN32)IMRD_TUX_BUFFER_SIZE) == -1 )
+    {
+	IMRD_LM_LOG_ERROR_1( "Finit32 Buffer2: [%s] !", Fstrerror32( Ferror32));
+	return( IMRS_KO);
+    }
+    
+    if( Fchg32( Request_Buf_Ptr, TA_OPERATION, 0, "GET", 0) == -1)
+    {
+	IMRD_LM_LOG_ERROR_1( "Fchg32 TA_OPERATION: [%s] !", Fstrerror32( Ferror32));
+	return( IMRS_KO);
+    }
+    
+    if( Fchg32( Request_Buf_Ptr, TA_CLASS, 0, "T_APPQ", 0) == -1)
+    {
+	IMRD_LM_LOG_ERROR_1( "Fchg32 TA_CLASS: [%s] !", Fstrerror32( Ferror32));
+	return( IMRS_KO);
+    }
+    
+    if( Fchg32( Request_Buf_Ptr, TA_APPQSPACENAME, 0, Queue_Space, 0) == -1)
+    {
+	IMRD_LM_LOG_ERROR_1( "Fchg32 TA_APPQSPACENAME: [%s] !", Fstrerror32( Ferror32));
+	return( IMRS_KO);
+    }
+    
+    if( Fchg32( Request_Buf_Ptr, TA_APPQNAME, 0, Queue_Name, 0) == -1)
+    {
+	IMRD_LM_LOG_ERROR_1( "Fchg32 TA_APPQNAME: [%s] !", Fstrerror32( Ferror32));
+	return( IMRS_KO);
+    }
+    
+    if( Fchg32( Request_Buf_Ptr, TA_QMCONFIG, 0, qmconfig, 0) == -1)
+    {
+	IMRD_LM_LOG_ERROR_1( "Fchg32 TA_QMCONFIG: [%s] !", Fstrerror32( Ferror32));
+	return( IMRS_KO);
+    }
+    
+    if( Fchg32( Request_Buf_Ptr, TA_LMID, 0, lmid, 0) == -1)
+    {
+	IMRD_LM_LOG_ERROR_1( "Fchg32 TA_LMID: [%s] !", Fstrerror32( Ferror32));
+	return( IMRS_KO);
+    }
+    
+    fldid1 = TA_APPQNAME;
+    if( Fchg32( Request_Buf_Ptr, TA_FILTER, 0, (char *)&fldid1, 0) == -1)
+    {
+	IMRD_LM_LOG_ERROR_1( "Fchg32 TA_FILTER: [%s] !", Fstrerror32( Ferror32));
+	return( IMRS_KO);
+    }
+    
+    if( tpcall( IMRD_TMIB_SERVICE, (void *)Request_Buf_Ptr, 0, (char**)&Response_Buf_Ptr, &rlen, 0L) < 0)
+    {
+	IMRD_LM_LOG_ERROR_1( "Error tpcall: [%s] !", tpstrerror( tperrno));
+	return( IMRS_KO);
+    }
+
+    if( Fget32( Response_Buf_Ptr, TA_OCCURS, 0, (char *)&nb_occurs, NULL) == -1)
+    {
+	IMRD_LM_LOG_ERROR_1( "Fget32 TA_OCCURS: [%s] !", Fstrerror32( Ferror32));
+	return( IMRS_KO);
+    }
+    
+    if( nb_occurs != 0)
+    {
+	return( IMRS_OK);
+    }
+    else
+    {
+	return( IMRS_KO);
+    }
+}
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IO_Hdl_Tux_Exist_Queue                                                     */
+/*----------------------------------------------------------------------------*/
+/* Queue_Space:   Queue Space Name                                            */
+/* Queue_Name:    Queue Name                                                  */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  Queue_Exist( IMRT_Tux_Queue_Space  Queue_Space, IMRT_Tux_Queue_Name  Queue_Name)
+{
+    IMRT_Status       status;
+    IMRT_Tux_Buffer  *Request_Buffer_Ptr, *Response_Buffer_Ptr;
+
+
+    if( ( status = Queue_Alloc( &Request_Buffer_Ptr)) == IMRS_OK)
+    {
+	if( ( status = Queue_Alloc( &Response_Buffer_Ptr)) == IMRS_OK)
+	{
+	    status = Queue_Exist_Mib( Queue_Space, Queue_Name, Request_Buffer_Ptr, Response_Buffer_Ptr);
+	    
+	    Queue_Free( Response_Buffer_Ptr);
+	}
+	
+	Queue_Free( Request_Buffer_Ptr);
+    }
+
+    return( status);
+}
+
+
+/*----------------------------------------------------------------------------*/
+/* IO_Hdl_Tux_Begin                                                           */
+/*----------------------------------------------------------------------------*/
+/* IMRT_Medium  *Medium_Ptr                                                   */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  IO_Hdl_Tux_Begin( IMRT_Medium  *Medium_Ptr)
+{
+    long flags ;
+    IMRT_Status status;
+
+    flags = 0;
+    status = IMRS_OK;
+    
+
+    if(IMRG_HDL_TUX_MODE == IMRD_HDL_TUX_NOT_IN_TRANS)
+    {
+	if( tpbegin(IMRD_HDL_TUX_TIME_OUT,flags) == -1)
+	{
+	    IMRD_LM_LOG_ERROR_1( "Tpbegin error: [%s] !", tpstrerror(tperrno));
+	    status = IMRS_KO;
+	}
+        else
+	{
+	    IMRG_HDL_TUX_MODE = IMRD_HDL_TUX_IN_TRANS;
+	}
+    }
+      return(status);
+    
+
+}
+
+
+/*----------------------------------------------------------------------------*/
+/* IO_Hdl_Tux_Commit                                                           */
+/*----------------------------------------------------------------------------*/
+/* IMRT_Medium  *Medium_Ptr                                                   */
+/*----------------------------------------------------------------------------*/
+IMRT_Status  IO_Hdl_Tux_Commit( IMRT_Medium  *Medium_Ptr)
+{
+    long flags ;
+    IMRT_Status status;
+
+    flags = 0;
+    status = IMRS_OK;
+    
+   if(IMRG_HDL_TUX_MODE == IMRD_HDL_TUX_IN_TRANS)
+   {
+       if( tpcommit(flags) == -1)
+       {
+	   IMRD_LM_LOG_ERROR_1( "Tpcommit error: [%s] !", tpstrerror(tperrno));
+	   status = IMRS_KO;
+       }
+       else
+       {
+	   IMRG_HDL_TUX_MODE = IMRD_HDL_TUX_NOT_IN_TRANS;
+       }
+   }
+    return(status);
+
+}
+
+/*----------------------------------------------------------------------------*/
+/* IO_Hdl_Tux_Rollback                                                        */
+/*----------------------------------------------------------------------------*/
+/* IMRT_Medium  *Medium_Ptr                                                   */
+/*----------------------------------------------------------------------------*/
+IMRT_Status  IO_Hdl_Tux_Rollback( IMRT_Medium  *Medium_Ptr)
+{
+    long flags ;
+    IMRT_Status status;
+
+    flags = 0;
+    status = IMRS_OK;
+    
+    if(IMRG_HDL_TUX_MODE == IMRD_HDL_TUX_IN_TRANS)
+    {
+	if( tpabort(flags) == -1)
+	{
+	    IMRD_LM_LOG_ERROR_1( "Tabort error: [%s] !", tpstrerror(tperrno));
+	    status = IMRS_KO;
+	}
+	else
+	{
+	    IMRG_HDL_TUX_MODE = IMRD_HDL_TUX_NOT_IN_TRANS;
+	}
+    }
+     
+    return(status);
+
+}
diff --git a/src/libio_mng/src/io_hdl_tux.h b/src/libio_mng/src/io_hdl_tux.h
new file mode 100644
index 0000000..b26092c
--- /dev/null
+++ b/src/libio_mng/src/io_hdl_tux.h
@@ -0,0 +1,171 @@
+/*----------------------------------------------------------------------------*/
+/* File: io_hdl_tux.h 				         		      */
+/*----------------------------------------------------------------------------*/
+/*                                                                            */
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#ifndef _IO_HDL_TUX_H_
+#define _IO_HDL_TUX_H_
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Global Include                                                             */
+/*----------------------------------------------------------------------------*/
+
+#include <libio_mng.h>
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Defines                                                                    */
+/*----------------------------------------------------------------------------*/
+
+#define IMRD_FML_TYPE_32                      "FML32"
+#define IMRD_TMIB_SERVICE                     ".TMIB"
+#define IMRD_HDL_TUX_TIME_OUT                 0
+
+
+
+typedef short  IMRT_HDL_TUX_TRAN_MODE ;
+
+#define IMRD_HDL_TUX_IN_TRANS          (IMRT_HDL_TUX_TRAN_MODE)1
+#define IMRD_HDL_TUX_NOT_IN_TRANS      (IMRT_HDL_TUX_TRAN_MODE)0
+
+#   ifdef _IO_HDL_TUX_C_
+
+IMRT_HDL_TUX_TRAN_MODE IMRG_HDL_TUX_MODE = IMRD_HDL_TUX_NOT_IN_TRANS ;
+
+#   endif /* _IO_HDL_TUX_C_ */
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Prototypes                                                                 */
+/*----------------------------------------------------------------------------*/
+
+#   ifdef _IO_HDL_TUX_C_
+
+IMRT_Status  IO_Hdl_Tux_Open(  IMRT_Medium  *, IMRT_Medium_Path, IMRT_Dir_Id);
+IMRT_Status  IO_Hdl_Tux_Close( IMRT_Medium  *);
+IMRT_Status  IO_Hdl_Tux_Read(  IMRT_Buffer  *, size_t  *, IMRT_Medium  *, IMRT_Read_Mode);
+IMRT_Status  IO_Hdl_Tux_Write( IMRT_Medium  *, size_t  *, IMRT_Buffer  *);
+IMRT_Status  Queue_Alloc( IMRT_Tux_Buffer  **);
+IMRT_Status  Queue_Free( IMRT_Tux_Buffer  *);
+IMRT_Status  Queue_Exist_Mib( IMRT_Tux_Queue_Space , IMRT_Tux_Queue_Name , IMRT_Tux_Buffer  *, IMRT_Tux_Buffer  *);
+IMRT_Status  Queue_Exist( IMRT_Tux_Queue_Space , IMRT_Tux_Queue_Name);
+IMRT_Status  IO_Hdl_Tux_Begin( IMRT_Medium  *Medium_Ptr);
+IMRT_Status  IO_Hdl_Tux_Commit( IMRT_Medium  *Medium_Ptr);
+IMRT_Status  IO_Hdl_Tux_Rollback( IMRT_Medium  *Medium_Ptr);
+
+#   else
+
+/*----------------------------------------------------------------------------*/
+/* IO_Hdl_Tux_Open                                                            */
+/*----------------------------------------------------------------------------*/
+/* Medium_Ptr:    Pointer to the medium to open                               */
+/* Medium_Path:   Medium Path to open                                         */
+/* Dir_Id:        Medium open direction                                       */
+/*----------------------------------------------------------------------------*/
+
+extern IMRT_Status  IO_Hdl_Tux_Open( IMRT_Medium  *, IMRT_Medium_Path, IMRT_Dir_Id);
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IO_Hdl_Tux_Close                                                           */
+/*----------------------------------------------------------------------------*/
+/* Medium_Ptr:    Pointer to the medium to close                              */
+/*----------------------------------------------------------------------------*/
+
+extern IMRT_Status  IO_Hdl_Tux_Close( IMRT_Medium  *);
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IO_Hdl_Tux_Read                                                            */
+/*----------------------------------------------------------------------------*/
+/* Buffer_Ptr:    Buffer to write data in                                     */
+/* Read_Len_Ptr:  Number of byte writen                                       */
+/* Medium_Path:   Medium to read                                              */
+/* Read_Mode:     Read mode                                                   */
+/*----------------------------------------------------------------------------*/
+
+extern IMRT_Status  IO_Hdl_Tux_Read( IMRT_Buffer  *, size_t  *, IMRT_Medium  *, IMRT_Read_Mode);
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IO_Hdl_Tux_Write                                                           */
+/*----------------------------------------------------------------------------*/
+/* Medium_Ptr:   Pointer to the medium towrite data to                        */
+/* Write_Len_Ptr:   Number of byte writen                                     */
+/* Buffer_Ptr:   Buffer to read                                               */
+/*----------------------------------------------------------------------------*/
+
+extern IMRT_Status  IO_Hdl_Tux_Write( IMRT_Medium  *, size_t  *, IMRT_Buffer  *);
+
+
+/*----------------------------------------------------------------------------*/
+/* IO_Hdl_Tux_Begin                                                           */
+/*----------------------------------------------------------------------------*/
+/* IMRT_Medium  *Medium_Ptr                                                   */
+/*----------------------------------------------------------------------------*/
+extern IMRT_Status  IO_Hdl_Tux_Begin( IMRT_Medium  *Medium_Ptr);
+
+
+/*----------------------------------------------------------------------------*/
+/* IO_Hdl_Tux_Commit                                                          */
+/*----------------------------------------------------------------------------*/
+/* IMRT_Medium  *Medium_Ptr                                                   */
+/*----------------------------------------------------------------------------*/
+extern IMRT_Status  IO_Hdl_Tux_Commit( IMRT_Medium  *Medium_Ptr);
+
+/*----------------------------------------------------------------------------*/
+/* IO_Hdl_Tux_Rollback                                                        */
+/*----------------------------------------------------------------------------*/
+/* IMRT_Medium  *Medium_Ptr                                                   */
+/*----------------------------------------------------------------------------*/
+extern IMRT_Status  IO_Hdl_Tux_Rollback( IMRT_Medium  *Medium_Ptr);
+
+
+#   endif
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+
+#endif
+
+
+
+
diff --git a/src/libio_mng/src/libio_mng.c b/src/libio_mng/src/libio_mng.c
new file mode 100644
index 0000000..4e59803
--- /dev/null
+++ b/src/libio_mng/src/libio_mng.c
@@ -0,0 +1,542 @@
+/*----------------------------------------------------------------------------*/
+/* $Workfile:   libio_mng.c  $                                                */                                            
+/*----------------------------------------------------------------------------*/
+/* $Author: agibert $                                                      */
+/* $Date: 2008/11/12 02:25:22 $                                           */
+/* $Revision: 1.1 $                                                       */
+/* $Label:  $                                                         */
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#define _LIBIO_MNG_
+#define _LIBIO_MNG_C_
+
+#include "libio_mng.h"
+
+
+
+
+
+
+
+/******************************************************************************/
+/* IO Manager API                                                             */
+/******************************************************************************/
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Open IO Manager                                                            */
+/*----------------------------------------------------------------------------*/
+/* Lib_Flag:   Setup IOM init mode                                            */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  IMR_IOM_Library_Open( IMRT_IOM_Config  *Config_Ptr)
+{
+    if( IMRG_IOM_Module.Lib.Status != IMRD_LIB_STATUS_CLOSED)
+    {
+	IMRD_LM_LOG_ERROR_0( "Library not closed !");
+
+	return( IMRS_KO);
+    }
+    else
+    {
+	IMRG_IOM_Module.Lib.Status = IMRD_LIB_STATUS_OPENED;
+
+	IMRD_LM_LOG_TRACE_0( IMRD_LOG_LEVEL_VERBOSE_1, "Library opened !");
+
+	return( IMRS_OK);
+    }
+}
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Close IO Manager                                                           */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  IMR_IOM_Library_Close()
+{
+    if( IMRG_IOM_Module.Lib.Status != IMRD_LIB_STATUS_OPENED)
+    {
+	IMRD_LM_LOG_ERROR_0( "Library not opened !");
+
+	return( IMRS_KO);
+    }
+    else
+    {
+	IMRG_IOM_Module.Lib.Status = IMRD_LIB_STATUS_CLOSED;
+
+	IMRD_LM_LOG_TRACE_0( IMRD_LOG_LEVEL_VERBOSE_1, "Library closed !");
+
+	return( IMRS_OK);
+    }
+}
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Parse Medium URL                                                           */
+/*----------------------------------------------------------------------------*/
+/* Hdl_Name:      Handler name parsed                                         */
+/* Medium_Path:   Medium path parsed                                          */
+/* Medium_URL:    Medium URL to parse                                         */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  IOM_URL_Parse( IMRT_IO_Hdl_Name Hdl_Name, IMRT_Medium_Path  Medium_Path, IMRT_Medium_URL  Medium_URL)
+{
+    char  *ptr;
+
+
+    if( ( ( ptr = strstr( Medium_URL, "://")) == NULL) || ( ptr == Medium_URL) || ( ( ptr - Medium_URL + 3) == strlen( Medium_URL)))
+    {
+	return( IMRS_KO);
+    }
+
+    strncpy( Hdl_Name, Medium_URL, ( ptr - Medium_URL));
+    Hdl_Name[ ptr - Medium_URL] = '\0';
+
+    strcpy( Medium_Path, ( ptr + 3));
+
+    return( IMRS_OK);
+}
+
+
+
+
+	
+/*----------------------------------------------------------------------------*/
+/* Get Medium Type from Handler Name                                          */
+/*----------------------------------------------------------------------------*/
+/* Medium_Type_Ptr:   Medium type to return                                   */
+/* Handler_Name:      IO Handler Name                                         */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  IOM_Medium_Type_Get( IMRT_Medium_Type  *Medium_Type_Ptr,  IMRT_IO_Hdl_Name  Hdl_Name)
+{
+    IMRT_Medium_Type  i;
+
+
+    for( i = 0; ( i < IMRD_IO_HDL_NB) && ( strcmp( IMRG_IOM_Base.IO_Hdl_Tab[i].Name, Hdl_Name) != 0) ; i++);
+
+    if( i < IMRD_IO_HDL_NB)
+    {
+	*Medium_Type_Ptr = i;
+	return( IMRS_OK);
+    }
+    else
+    {
+	return( IMRS_KO);
+    }
+}
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Open Medium                                                                */
+/*----------------------------------------------------------------------------*/
+/* Medium_Ptr_Ptr:   Reference to the Pointer to the opened medium            */
+/* Medium_Name:      Name of the medium                                       */
+/* Medium_URL:       Medium URL to open                                       */
+/* Appl_Id_Input:    Input application Id link with the medium                */
+/* Appl_Id_Output:   Output application Id link with the medium               */
+/* Dir_Id:           Medium open direction                                    */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  IMR_IOM_Medium_Open( IMRT_Medium  **Medium_Ptr_Ptr, IMRT_Medium_Name  Medium_Name, IMRT_Medium_URL  Medium_URL, IMRT_Appl_Id  Appl_Id_Input, IMRT_Appl_Id  Appl_Id_Output, IMRT_Dir_Id  Dir_Id)
+{
+    IMRT_Status       status;
+    IMRT_IO_Hdl_Name  hdl_name;
+    IMRT_Medium_Path  medium_path;
+    IMRT_Medium_Type  medium_type;
+
+
+    if( ( status = IOM_URL_Parse( hdl_name, medium_path, Medium_URL)) != IMRS_OK)
+    {
+	IMRD_LM_LOG_ERROR_1( "Can't parse URL [%s] !", Medium_URL);
+
+	return( IMRS_KO);
+    }
+	
+    if( ( status = IOM_Medium_Type_Get( &medium_type,  hdl_name)) != IMRS_OK)
+    {
+	IMRD_LM_LOG_ERROR_1( "Can't get medium type [%s] !", hdl_name);
+	
+	return( IMRS_KO);
+    }
+
+    if( ( *Medium_Ptr_Ptr = malloc( sizeof( IMRT_Medium))) == NULL)
+    {
+	IMRD_LM_LOG_ERROR_2( "Can't allocate Medium [%s]: (%d) !", Medium_Name, errno);
+
+	return( IMRS_KO);
+    }
+
+    strcpy( ( *Medium_Ptr_Ptr)->Name, Medium_Name);
+    ( *Medium_Ptr_Ptr)->Type =   medium_type;
+    ( *Medium_Ptr_Ptr)->Status = IMRD_MEDIUM_STATUS_CLOSED;
+    strcpy( ( *Medium_Ptr_Ptr)->URL, Medium_URL);
+    ( *Medium_Ptr_Ptr)->Appl_Id_Input = Appl_Id_Input;
+    ( *Medium_Ptr_Ptr)->Appl_Id_Output = Appl_Id_Output;
+    ( *Medium_Ptr_Ptr)->Dir_Id = Dir_Id;
+    ( *Medium_Ptr_Ptr)->Tran_Flag = IMRD_MEDIUM_TRAN_FLAG_OUT;
+    ( *Medium_Ptr_Ptr)->Byte_Nb = 0;
+    ( *Medium_Ptr_Ptr)->Msg_Nb = 0;
+
+
+    if( IMRG_IOM_Base.IO_Hdl_Tab[ medium_type].Open_Ptr( *Medium_Ptr_Ptr, medium_path, Dir_Id) != IMRS_OK)
+    {
+	IMRD_LM_LOG_ERROR_1( "Can't open Medium [%s] !", Medium_Name);
+	free( *Medium_Ptr_Ptr);
+
+	return( IMRS_KO);
+    }
+    else
+    {
+	( *Medium_Ptr_Ptr)->Status = IMRD_MEDIUM_STATUS_OPENED;
+
+	return( IMRS_OK);
+    }
+}    
+   
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Close Medium                                                               */
+/*----------------------------------------------------------------------------*/
+/* Medium_Ptr:   Pointer to the medium to close                               */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  IMR_IOM_Medium_Close( IMRT_Medium  *Medium_Ptr)
+{
+    if(  Medium_Ptr->Status == IMRD_MEDIUM_STATUS_OPENED)
+    {
+	if( IMRG_IOM_Base.IO_Hdl_Tab[ Medium_Ptr->Type].Close_Ptr( Medium_Ptr) != IMRS_OK)
+	{
+	    IMRD_LM_LOG_ERROR_0( "Can't close Medium !");
+
+	    return( IMRS_KO);
+	}
+    }
+
+    IMRD_LM_LOG_INFO_4( "Medium [%s]: (%d) bytes %s in (%d) messages.", Medium_Ptr->Name, Medium_Ptr->Byte_Nb, ( ( Medium_Ptr->Dir_Id == IMRD_DIR_ID_IN) ? "read" : "writen"), Medium_Ptr->Msg_Nb);
+
+    free( Medium_Ptr);
+
+    return( IMRS_OK);
+}
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Read Medium                                                                */
+/*----------------------------------------------------------------------------*/
+/* Buffer_Ptr:   Pointer to the buffer to write                               */
+/* Medium_Ptr:   Pointer to the medium to read                                */
+/* Read_Mode:    Read mode                                                    */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  IMR_IOM_Medium_Read( IMRT_Buffer  *Buffer_Ptr, IMRT_Medium  *Medium_Ptr, IMRT_Read_Mode  Read_Mode)
+{
+    size_t       read_len;
+    IMRT_Status  status;
+
+
+    if(  Medium_Ptr->Status == IMRD_MEDIUM_STATUS_OPENED)
+    {
+	if( ( status = IMRG_IOM_Base.IO_Hdl_Tab[ Medium_Ptr->Type].Read_Ptr( Buffer_Ptr, &read_len, Medium_Ptr, Read_Mode)) == IMRS_KO)
+	{
+	    IMRD_LM_LOG_ERROR_1( "Can't read Medium [%s] !", Medium_Ptr->Name);
+
+	    return( IMRS_KO);
+	}
+
+	if( status == IMRS_OK)
+	{
+	    Medium_Ptr->Byte_Nb += read_len;
+	    Medium_Ptr->Msg_Nb++;
+
+	    Buffer_Ptr->Appl_Id_Input  = Medium_Ptr->Appl_Id_Input;
+	    Buffer_Ptr->Appl_Id_Output = Medium_Ptr->Appl_Id_Output;
+	    Buffer_Ptr->Dir_Id         = Medium_Ptr->Dir_Id;
+	    Buffer_Ptr->Flag           = IMRD_BUFFER_FLAG_CLOSED;
+	}
+    }
+    else
+    {
+	IMRD_LM_LOG_ERROR_1( "Can't read closed Medium [%s] !", Medium_Ptr->Name);
+
+	return( IMRS_KO);
+    }
+
+    return( status);
+}
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Write Medium                                                               */
+/*----------------------------------------------------------------------------*/
+/* Medium_Ptr:   Pointer to the medium to write                               */
+/* Buffer_Ptr:   Pointer to the buffer to read                                */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  IMR_IOM_Medium_Write( IMRT_Medium  *Medium_Ptr, IMRT_Buffer  *Buffer_Ptr)
+{
+    size_t  write_len;
+
+
+    if(  Medium_Ptr->Status == IMRD_MEDIUM_STATUS_OPENED)
+    {
+	if( IMRG_IOM_Base.IO_Hdl_Tab[ Medium_Ptr->Type].Write_Ptr( Medium_Ptr, &write_len, Buffer_Ptr) != IMRS_OK)
+	{
+	    IMRD_LM_LOG_ERROR_1( "Can't write Medium [%s]!", Medium_Ptr->Name);
+
+	    return( IMRS_KO);
+	}
+
+	Medium_Ptr->Byte_Nb += write_len;
+	Medium_Ptr->Msg_Nb++;
+    }
+    else
+    {
+	IMRD_LM_LOG_ERROR_1( "Can't write closed Medium [%s]!", Medium_Ptr->Name);
+
+	return( IMRS_KO);
+    }
+
+    return( IMRS_OK);
+}
+
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Tran Begin                                                                 */
+/*----------------------------------------------------------------------------*/
+/* Tran_Ptr_Ptr:   Reference to the pointer of the transaction to begin       */
+/* Medium_Count:   Number of medium to enclose into the transaction           */
+/* Medium_1_Ptr:   Pointer to the first medium                                */
+/* ...                                                                        */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  IMR_IOM_Tran_Begin( IMRT_Tran  **Tran_Ptr_Ptr, IMRT_Medium_Nb  Medium_Nb, IMRT_Medium  *Medium_1_Ptr, ...)
+{
+    int           index;
+    va_list       medium_list;
+    IMRT_Medium  *medium_ptr;
+    IMRT_Status   status;
+
+
+    status = IMRS_OK;
+    medium_ptr = NULL;
+
+    if( Medium_Nb != 0)
+    {
+	va_start( medium_list, Medium_1_Ptr);
+
+	
+	if( ( *Tran_Ptr_Ptr = (IMRT_Tran  *)malloc( sizeof( IMRT_Tran))) == NULL)
+	{
+	    IMRD_LM_LOG_ERROR_1( "Can't malloc Tran: (%d) !", errno);
+	    return( IMRS_KO);
+	}
+
+	if( ( (*Tran_Ptr_Ptr)->Medium_Ptr_Tab = (IMRT_Medium  **)malloc( sizeof(IMRT_Medium  **) * Medium_Nb)) == NULL)
+	{
+	    IMRD_LM_LOG_ERROR_1( "Can't malloc Tran Medium_Ptr_Tab: (%d) !", errno);
+	    return( IMRS_KO);
+	}
+
+	(*Tran_Ptr_Ptr)->Medium_Nb  = Medium_Nb;
+	
+	for( index = 0; index < Medium_Nb; index++)
+	{
+	    if( index == 0)
+	    {
+		( ( *Tran_Ptr_Ptr)->Medium_Ptr_Tab)[index] = Medium_1_Ptr;
+
+		medium_ptr = Medium_1_Ptr;
+	    }
+	    else
+	    {
+		medium_ptr = (IMRT_Medium  *)va_arg( medium_list, IMRT_Medium  *);
+		if( medium_ptr != NULL)
+		{
+		    (*Tran_Ptr_Ptr)->Medium_Ptr_Tab[index] = medium_ptr;
+		}
+		else
+		{
+		    IMRD_LM_LOG_ERROR_0( "Can't get medium !");
+		    status = IMRS_KO;
+		}
+	    }
+
+	    if( status == IMRS_OK)
+	    {	
+		status = IMRG_IOM_Base.IO_Hdl_Tab[medium_ptr->Type].Begin_Ptr( medium_ptr);
+
+		if( status != IMRS_OK)
+		{
+		    IMRD_LM_LOG_ERROR_1( "Begin failed for Medium [%s] !", medium_ptr->Name);
+		}
+		else
+		{
+		    (*Tran_Ptr_Ptr)->Medium_Ptr_Tab[index]->Tran_Flag =  IMRD_MEDIUM_TRAN_FLAG_IN;
+		}
+	    }	
+
+	}
+	va_end( medium_list);
+    }
+    else
+    {
+	IMRD_LM_LOG_ERROR_1( "BEGIN : Invalid number of medium (%d) !",Medium_Nb );
+	status = IMRS_KO ;
+    }
+
+    return( status);
+}
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Tran Commit                                                                */
+/*----------------------------------------------------------------------------*/
+/* Tran_Ptr:   Pointer to the transaction to commit                           */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  IMR_IOM_Tran_Commit( IMRT_Tran  *Tran_Ptr)
+{
+    IMRT_Status  status;
+    int          index;
+
+
+    status = IMRS_OK;
+
+    IMRD_LM_LOG_TRACE_1( IMRD_LOG_LEVEL_VERBOSE_1, "Medium Nb to commit: (%d)", Tran_Ptr->Medium_Nb );
+
+    for( index = 0; index < Tran_Ptr->Medium_Nb; index++)
+    {
+	IMRD_LM_LOG_TRACE_2( IMRD_LOG_LEVEL_VERBOSE_1, "Medium [%s] Tran_Flag: (%d)", Tran_Ptr->Medium_Ptr_Tab[index]->Name, Tran_Ptr->Medium_Ptr_Tab[index]->Tran_Flag);
+
+	if( Tran_Ptr->Medium_Ptr_Tab[index]->Tran_Flag == IMRD_MEDIUM_TRAN_FLAG_IN)
+	{
+	    IMRD_LM_LOG_TRACE_1( IMRD_LOG_LEVEL_VERBOSE_1, "Commiting medium [%s]...",Tran_Ptr->Medium_Ptr_Tab[index]->Name); 
+
+	    status = IMRG_IOM_Base.IO_Hdl_Tab[Tran_Ptr->Medium_Ptr_Tab[index]->Type].Commit_Ptr(Tran_Ptr->Medium_Ptr_Tab[index]);
+
+	    if( status == IMRS_OK)
+	    {
+		Tran_Ptr->Medium_Ptr_Tab[index]->Tran_Flag = IMRD_MEDIUM_TRAN_FLAG_OUT;
+	    }
+	    else
+	    {
+		IMRD_LM_LOG_ERROR_1( "Commit failed for medium [%s] !",  Tran_Ptr->Medium_Ptr_Tab[index]->Name);
+	    }
+	}    
+
+    }
+
+    if( Tran_Ptr->Medium_Ptr_Tab != NULL)
+    {
+	free( Tran_Ptr->Medium_Ptr_Tab);
+    }
+
+    free( Tran_Ptr);
+
+    return( status);
+}
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Tran Rollback                                                              */
+/*----------------------------------------------------------------------------*/
+/* Tran_Ptr:   Pointer to the transaction to rollback                         */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  IMR_IOM_Tran_Rollback( IMRT_Tran  *Tran_Ptr)
+{
+
+    IMRT_Status  status;
+    int          index;
+
+
+    status = IMRS_OK;
+
+    IMRD_LM_LOG_TRACE_1( IMRD_LOG_LEVEL_VERBOSE_1, "Medium Nb to rollback: (%d)", Tran_Ptr->Medium_Nb );
+
+    for( index = 0; index < Tran_Ptr->Medium_Nb; index++)
+    {
+	IMRD_LM_LOG_TRACE_2( IMRD_LOG_LEVEL_VERBOSE_1, "Medium [%s] Tran_Flag: (%d)", Tran_Ptr->Medium_Ptr_Tab[index]->Name, Tran_Ptr->Medium_Ptr_Tab[index]->Tran_Flag);
+
+	if( Tran_Ptr->Medium_Ptr_Tab[index]->Tran_Flag == IMRD_MEDIUM_TRAN_FLAG_IN)
+        {
+	    status = IMRG_IOM_Base.IO_Hdl_Tab[Tran_Ptr->Medium_Ptr_Tab[index]->Type].Rollback_Ptr(Tran_Ptr->Medium_Ptr_Tab[index]);
+
+	    if(status == IMRS_OK)
+	    {
+		Tran_Ptr->Medium_Ptr_Tab[index]->Tran_Flag = IMRD_MEDIUM_TRAN_FLAG_OUT;
+	    }
+	    else
+            {
+		IMRD_LM_LOG_ERROR_1( "Rollback failed for medium [%s] !", Tran_Ptr->Medium_Ptr_Tab[index]->Name);
+	    }
+	}
+    }
+
+    if( Tran_Ptr->Medium_Ptr_Tab != NULL)
+    {
+	free( Tran_Ptr->Medium_Ptr_Tab);
+    }
+
+    free( Tran_Ptr);
+
+    return( status);
+}
+
+
+
+
+
diff --git a/src/libio_mng/src/libio_mng.h b/src/libio_mng/src/libio_mng.h
new file mode 100644
index 0000000..de0cd6b
--- /dev/null
+++ b/src/libio_mng/src/libio_mng.h
@@ -0,0 +1,194 @@
+/*----------------------------------------------------------------------------*/
+/* File: libio_mng.h 				         		      */
+/*----------------------------------------------------------------------------*/
+/*                                                                            */
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#ifndef _LIBIO_MNG_H_
+#define _LIBIO_MNG_H_
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Global Include                                                             */
+/*----------------------------------------------------------------------------*/
+
+#include <imr.h>
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Lib Definitions                                                            */
+/*----------------------------------------------------------------------------*/
+
+#define IMRD_IOM_MODULE_ID                ( IMRT_Module_Id) 3
+#define IMRD_IOM_MODULE_NAME            ( IMRT_Module_Name) "iom"
+#define IMRD_IOM_MODULE_NAME_LONG  ( IMRT_Module_Name_Long) "IO Manager"
+#define IMRD_IOM_MODULE_VERSION      ( IMRT_Module_Version) "@(#) VERSIONIMR: $Label:  $   $Date: 2008/11/12 02:25:22 $   $Workfile:   libio_mng.h  $"
+
+#define IMRD_MODULE_PTR                                     &IMRG_IOM_Module
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Local Definitions                                                          */
+/*----------------------------------------------------------------------------*/
+
+#define IMRD_IO_HDL_NAME_LEN   (short) 255
+#define IMRD_IO_HDL_NAME_SIZE  (short) ( IMRD_IO_HDL_NAME_LEN + 1)
+
+typedef char   IMRT_IO_Hdl_Name[ IMRD_IO_HDL_NAME_SIZE];
+
+
+
+typedef IMRT_Status  ( IMRT_IO_Hdl_Open) ( IMRT_Medium  *, IMRT_Medium_Path, IMRT_Dir_Id);
+typedef IMRT_Status  ( IMRT_IO_Hdl_Close)( IMRT_Medium  *);
+typedef IMRT_Status  ( IMRT_IO_Hdl_Read) ( IMRT_Buffer  *, size_t  *, IMRT_Medium  *, IMRT_Read_Mode);
+typedef IMRT_Status  ( IMRT_IO_Hdl_Write)( IMRT_Medium  *, size_t  *, IMRT_Buffer  *);
+typedef IMRT_Status  ( IMRT_IO_Hdl_Begin) ( IMRT_Medium  *);
+typedef IMRT_Status  ( IMRT_IO_Hdl_Commit) ( IMRT_Medium  *);
+typedef IMRT_Status  ( IMRT_IO_Hdl_Rollback)( IMRT_Medium  *);
+
+
+
+typedef struct IMRT_IO_Hdl
+{
+	IMRT_IO_Hdl_Name     Name;
+	IMRT_IO_Hdl_Open     *Open_Ptr;
+	IMRT_IO_Hdl_Close    *Close_Ptr;
+	IMRT_IO_Hdl_Read     *Read_Ptr;
+	IMRT_IO_Hdl_Write    *Write_Ptr;
+        IMRT_IO_Hdl_Begin    *Begin_Ptr;
+	IMRT_IO_Hdl_Commit   *Commit_Ptr;
+	IMRT_IO_Hdl_Rollback *Rollback_Ptr;
+ 
+	
+}  IMRT_IO_Hdl;
+
+
+
+typedef short  IMRT_IO_Hdl_Nb;
+
+#define IMRD_IO_HDL_NB  ( IMRT_IO_Hdl_Nb) 4
+
+
+
+typedef struct IMRT_IO_Base
+{
+	IMRT_IO_Hdl  IO_Hdl_Tab[ IMRD_IO_HDL_NB];
+}  IMRT_IO_Base;
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Prototypes                                                                 */
+/*----------------------------------------------------------------------------*/
+
+#   ifdef _LIBIO_MNG_C_
+
+IMRT_Status  IOM_URL_Parse( IMRT_IO_Hdl_Name, IMRT_Medium_Path, IMRT_Medium_URL);
+IMRT_Status  IOM_Medium_Type_Get( IMRT_Medium_Type  *,  IMRT_IO_Hdl_Name);
+
+#   endif
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Local Includes                                                             */
+/*----------------------------------------------------------------------------*/
+
+#include "io_hdl_file.h"
+
+#ifdef TUX_SUPPORT
+#   include "io_hdl_tux.h"
+#endif /* TUX_SUPPORT */
+
+#ifdef MQS_SUPPORT
+#   include "io_hdl_mqs.h"
+#endif /* MQS_SUPPORT */
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Global Variables                                                           */
+/*----------------------------------------------------------------------------*/
+
+#   ifdef _LIBIO_MNG_C_
+
+IMRT_IO_Base  IMRG_IOM_Base = 
+{
+    {
+	{ "Unknown",         NULL,              NULL,              NULL,             NULL, NULL, NULL, NULL},
+	{ "file", IO_Hdl_File_Open, IO_Hdl_File_Close, IO_Hdl_File_Read, IO_Hdl_File_Write,IO_Hdl_File_Begin,IO_Hdl_File_Commit,IO_Hdl_File_Rollback },
+
+#ifdef TUX_SUPPORT
+	{ "tux",  IO_Hdl_Tux_Open,  IO_Hdl_Tux_Close,  IO_Hdl_Tux_Read,  IO_Hdl_Tux_Write, IO_Hdl_Tux_Begin, IO_Hdl_Tux_Commit, IO_Hdl_Tux_Rollback},
+#endif /* TUX_SUPPORT */
+
+#ifdef MQS_SUPPORT
+	{ "mqs",  IO_Hdl_MQS_Open,  IO_Hdl_MQS_Close,  IO_Hdl_MQS_Read,  IO_Hdl_MQS_Write, IO_Hdl_MQS_Begin, IO_Hdl_MQS_Commit, IO_Hdl_MQS_Rollback},
+#endif /* MQS_SUPPORT */
+    }
+};
+
+
+
+IMRT_Module  IMRG_IOM_Module = 
+{
+    IMRD_IOM_MODULE_ID,
+    IMRD_IOM_MODULE_NAME,
+    IMRD_IOM_MODULE_NAME_LONG,
+    IMRD_IOM_MODULE_VERSION,
+    IMRD_MODULE_TYPE_LIBRARY,
+    {
+	IMRD_LIB_STATUS_CLOSED,
+	( IMRT_Lib_Open    *) &IMR_IOM_Library_Open,
+	( IMRT_Lib_Close   *) &IMR_IOM_Library_Close
+    }
+};
+
+#   else
+
+extern IMRT_IO_Base  IMRG_IOM_Base;
+extern IMRT_Module   IMRG_IOM_Module;
+
+#   endif
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+
+#endif
diff --git a/src/liblog_mng/include/log_mng.h b/src/liblog_mng/include/log_mng.h
new file mode 100644
index 0000000..bd9e98d
--- /dev/null
+++ b/src/liblog_mng/include/log_mng.h
@@ -0,0 +1,397 @@
+/*----------------------------------------------------------------------------*/
+/* File: log_mng.h 				         		      */
+/*----------------------------------------------------------------------------*/
+/*                                                                            */
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#ifndef _LOG_MNG_H_
+#define _LOG_MNG_H_
+
+
+
+#include <imr.h>
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IMRD_LM_API definition                                                     */
+/*----------------------------------------------------------------------------*/
+
+#   ifdef _LIBLOG_MNG_
+#       define IMRD_LM_API  
+#   else
+#       define IMRD_LM_API  extern
+#   endif
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Status definition                                                          */
+/*----------------------------------------------------------------------------*/
+
+#define IMRS_LM_LOG (IMRT_Status) 2
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Log Type definition                                                        */
+/*----------------------------------------------------------------------------*/
+
+#define IMRD_LOG_TYPE_NB               (short) 5
+
+
+
+typedef short  IMRT_Log_Type_Id;
+
+#define IMRD_LOG_TYPE_ID_UNKNOWN  (IMRT_Log_Type_Id) 0
+#define IMRD_LOG_TYPE_ID_TRACE    (IMRT_Log_Type_Id) 1
+#define IMRD_LOG_TYPE_ID_INFO     (IMRT_Log_Type_Id) 2
+#define IMRD_LOG_TYPE_ID_WARNING  (IMRT_Log_Type_Id) 3
+#define IMRD_LOG_TYPE_ID_ERROR    (IMRT_Log_Type_Id) 4
+
+
+
+typedef char  *IMRT_Log_Type_Name;
+
+#define IMRD_LOG_TYPE_NAME_UNKNOWN  (IMRT_Log_Type_Name) "???"
+#define IMRD_LOG_TYPE_NAME_TRACE    (IMRT_Log_Type_Name) "TRA"
+#define IMRD_LOG_TYPE_NAME_INFO     (IMRT_Log_Type_Name) "INF"
+#define IMRD_LOG_TYPE_NAME_WARNING  (IMRT_Log_Type_Name) "WRN"
+#define IMRD_LOG_TYPE_NAME_ERROR    (IMRT_Log_Type_Name) "ERR"
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Log Level definition                                                       */
+/*----------------------------------------------------------------------------*/
+
+typedef short  IMRT_Log_Level;
+
+#define IMRD_LOG_LEVEL_UNSET      ( IMRT_Log_Level) -1
+
+#define IMRD_LOG_LEVEL_MIN        ( IMRT_Log_Level) 0
+#define IMRD_LOG_LEVEL_MAX        ( IMRT_Log_Level) 999
+
+#define IMRD_LOG_LEVEL_VERBOSE_0  ( IMRT_Log_Level) 10
+#define IMRD_LOG_LEVEL_VERBOSE_1  ( IMRT_Log_Level) 20
+#define IMRD_LOG_LEVEL_VERBOSE_2  ( IMRT_Log_Level) 30
+
+#define IMRD_LOG_LEVEL_DEFAULT    ( IMRT_Log_Level) 10
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IMRT_File_Name definition                                                  */
+/*----------------------------------------------------------------------------*/
+
+typedef char  *IMRT_File_Name;
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IMRT_Line_Id definition                                                    */
+/*----------------------------------------------------------------------------*/
+
+typedef long  IMRT_Line_Id;
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Log Fmt definition                                                         */
+/*----------------------------------------------------------------------------*/
+
+typedef char  *IMRT_Log_Fmt;
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IMRT_Log_Id_Bit definition                                                 */
+/*----------------------------------------------------------------------------*/
+
+typedef size_t  IMRT_Log_Id_Bit_Offset;
+typedef size_t  IMRT_Log_Id_Bit_Size;
+
+
+
+typedef struct IMRT_Log_Id_Bit
+{
+	IMRT_Log_Id_Bit_Offset  Offset;
+	IMRT_Log_Id_Bit_Size    Size;
+}  IMRT_Log_Id_Bit;
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IMRT_Log_Id_Struct definition                                              */
+/*----------------------------------------------------------------------------*/
+
+typedef short   IMRT_Bit_Nb;
+typedef size_t  IMRT_Log_Size;
+
+
+
+typedef struct IMRT_Log_Id_Struct
+{
+	IMRT_Bit_Nb       Bit_Nb;
+	IMRT_Log_Size     Log_Size;
+        IMRT_Log_Id_Bit  *Log_Id_Bit_Ptr;
+} IMRT_Log_Id_Struct;
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IMRT_Log_Msg_Header definition                                             */
+/*----------------------------------------------------------------------------*/
+
+typedef char  *IMRT_Log_Id_Header;
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* LM_Config definition                                                       */
+/*----------------------------------------------------------------------------*/
+
+typedef struct IMRT_LM_Config
+{
+	IMRT_Path       Log_File;
+	IMRT_Module_Id  Module_Nb;
+	IMRT_Log_Level  Level_Tab[ IMRD_LOG_TYPE_NB][ IMRD_MODULE_NB_MAX];
+}  IMRT_LM_Config;
+
+
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Global Variables                                                           */
+/*----------------------------------------------------------------------------*/
+
+#   ifdef _LIBLOG_MNG_
+
+#   else
+
+extern IMRT_Module  IMRG_LM_Module;
+
+#   endif
+
+
+
+
+
+
+
+/******************************************************************************/
+/* Log Manager API                                                            */
+/******************************************************************************/
+
+/*----------------------------------------------------------------------------*/
+/* Log Trace Macros                                                           */
+/*----------------------------------------------------------------------------*/
+
+#define IMRD_LM_LOG_TRACE_0( Level, Fmt)                                  if( IMR_LM_Log_Write( IMRD_LOG_TYPE_ID_TRACE,   (Level), IMRD_MODULE_PTR, __FILE__, __LINE__, IMRD_TRUE, (Fmt)) != IMRS_OK) return( IMRS_KO);
+#define IMRD_LM_LOG_TRACE_1( Level, Fmt, Arg1)                            if( IMR_LM_Log_Write( IMRD_LOG_TYPE_ID_TRACE,   (Level), IMRD_MODULE_PTR, __FILE__, __LINE__, IMRD_TRUE, (Fmt), (Arg1)) != IMRS_OK) return(IMRS_KO);
+#define IMRD_LM_LOG_TRACE_2( Level, Fmt, Arg1, Arg2)                      if( IMR_LM_Log_Write( IMRD_LOG_TYPE_ID_TRACE,   (Level), IMRD_MODULE_PTR, __FILE__, __LINE__, IMRD_TRUE, (Fmt), (Arg1), (Arg2)) != IMRS_OK) return(IMRS_KO);
+#define IMRD_LM_LOG_TRACE_3( Level, Fmt, Arg1, Arg2, Arg3)                if( IMR_LM_Log_Write( IMRD_LOG_TYPE_ID_TRACE,   (Level), IMRD_MODULE_PTR, __FILE__, __LINE__, IMRD_TRUE, (Fmt), (Arg1), (Arg2), (Arg3)) != IMRS_OK) return(IMRS_KO);
+#define IMRD_LM_LOG_TRACE_4( Level, Fmt, Arg1, Arg2, Arg3, Arg4)          if( IMR_LM_Log_Write( IMRD_LOG_TYPE_ID_TRACE,   (Level), IMRD_MODULE_PTR, __FILE__, __LINE__, IMRD_TRUE, (Fmt), (Arg1), (Arg2), (Arg3), (Arg4)) != IMRS_OK) return(IMRS_KO);
+#define IMRD_LM_LOG_TRACE_5( Level, Fmt, Arg1, Arg2, Arg3, Arg4, Arg5)    if( IMR_LM_Log_Write( IMRD_LOG_TYPE_ID_TRACE,   (Level), IMRD_MODULE_PTR, __FILE__, __LINE__, IMRD_TRUE, (Fmt), (Arg1), (Arg2), (Arg3), (Arg4), (Arg5)) != IMRS_OK) return(IMRS_KO);
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Log Info Macros                                                            */
+/*----------------------------------------------------------------------------*/
+
+#define IMRD_LM_LOG_INFO_0( Fmt)                                   if(IMR_LM_Log_Write( IMRD_LOG_TYPE_ID_INFO,    IMRD_LOG_LEVEL_DEFAULT, IMRD_MODULE_PTR, __FILE__, __LINE__, IMRD_TRUE, (Fmt)) != IMRS_OK ) return(IMRS_KO);
+#define IMRD_LM_LOG_INFO_1( Fmt, Arg1)                              if( IMR_LM_Log_Write( IMRD_LOG_TYPE_ID_INFO,    IMRD_LOG_LEVEL_DEFAULT, IMRD_MODULE_PTR, __FILE__, __LINE__, IMRD_TRUE, (Fmt), (Arg1)) != IMRS_OK) return(IMRS_KO) ;
+#define IMRD_LM_LOG_INFO_2( Fmt, Arg1, Arg2)                       if( IMR_LM_Log_Write( IMRD_LOG_TYPE_ID_INFO,    IMRD_LOG_LEVEL_DEFAULT, IMRD_MODULE_PTR, __FILE__, __LINE__, IMRD_TRUE, (Fmt), (Arg1), (Arg2)) != IMRS_OK) return(IMRS_KO);
+#define IMRD_LM_LOG_INFO_3( Fmt, Arg1, Arg2, Arg3)                 if( IMR_LM_Log_Write( IMRD_LOG_TYPE_ID_INFO,    IMRD_LOG_LEVEL_DEFAULT, IMRD_MODULE_PTR, __FILE__, __LINE__, IMRD_TRUE, (Fmt), (Arg1), (Arg2), (Arg3)) != IMRS_OK) return(IMRS_KO);
+#define IMRD_LM_LOG_INFO_4( Fmt, Arg1, Arg2, Arg3, Arg4)           if( IMR_LM_Log_Write( IMRD_LOG_TYPE_ID_INFO,    IMRD_LOG_LEVEL_DEFAULT, IMRD_MODULE_PTR, __FILE__, __LINE__, IMRD_TRUE, (Fmt), (Arg1), (Arg2), (Arg3), (Arg4)) != IMRS_OK) return(IMRS_KO);
+#define IMRD_LM_LOG_INFO_5( Fmt, Arg1, Arg2, Arg3, Arg4, Arg5)     if( IMR_LM_Log_Write( IMRD_LOG_TYPE_ID_INFO,    IMRD_LOG_LEVEL_DEFAULT, IMRD_MODULE_PTR, __FILE__, __LINE__, IMRD_TRUE, (Fmt), (Arg1), (Arg2), (Arg3), (Arg4), (Arg5)) != IMRS_OK) return(IMRS_KO);
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Log Warning Macros                                                         */
+/*----------------------------------------------------------------------------*/
+
+#define IMRD_LM_LOG_WARNING_0( Fmt)                                if(IMR_LM_Log_Write( IMRD_LOG_TYPE_ID_WARNING, IMRD_LOG_LEVEL_DEFAULT, IMRD_MODULE_PTR, __FILE__, __LINE__, IMRD_TRUE, (Fmt)) != IMRS_OK) return(IMRS_KO);
+#define IMRD_LM_LOG_WARNING_1( Fmt, Arg1)                          if(IMR_LM_Log_Write( IMRD_LOG_TYPE_ID_WARNING, IMRD_LOG_LEVEL_DEFAULT, IMRD_MODULE_PTR, __FILE__, __LINE__, IMRD_TRUE, (Fmt), (Arg1)) != IMRS_OK) return(IMRS_KO);
+#define IMRD_LM_LOG_WARNING_2( Fmt, Arg1, Arg2)                    if( IMR_LM_Log_Write( IMRD_LOG_TYPE_ID_WARNING, IMRD_LOG_LEVEL_DEFAULT, IMRD_MODULE_PTR, __FILE__, __LINE__, IMRD_TRUE, (Fmt), (Arg1), (Arg2)) != IMRS_OK) return(IMRS_KO);
+#define IMRD_LM_LOG_WARNING_3( Fmt, Arg1, Arg2, Arg3)              if( IMR_LM_Log_Write( IMRD_LOG_TYPE_ID_WARNING, IMRD_LOG_LEVEL_DEFAULT, IMRD_MODULE_PTR, __FILE__, __LINE__, IMRD_TRUE, (Fmt), (Arg1), (Arg2), (Arg3)) != IMRS_OK) return(IMRS_KO);
+#define IMRD_LM_LOG_WARNING_4( Fmt, Arg1, Arg2, Arg3, Arg4)        if( IMR_LM_Log_Write( IMRD_LOG_TYPE_ID_WARNING, IMRD_LOG_LEVEL_DEFAULT, IMRD_MODULE_PTR, __FILE__, __LINE__, IMRD_TRUE, (Fmt), (Arg1), (Arg2), (Arg3), (Arg4)) != IMRS_OK) return(IMRS_KO);
+#define IMRD_LM_LOG_WARNING_5( Fmt, Arg1, Arg2, Arg3, Arg4, Arg5)  if( IMR_LM_Log_Write( IMRD_LOG_TYPE_ID_WARNING, IMRD_LOG_LEVEL_DEFAULT, IMRD_MODULE_PTR, __FILE__, __LINE__, IMRD_TRUE, (Fmt), (Arg1), (Arg2), (Arg3), (Arg4), (Arg5)) != IMRS_OK) return(IMRS_KO);
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Log Error Macros                                                           */
+/*----------------------------------------------------------------------------*/
+
+#define IMRD_LM_LOG_ERROR_0( Fmt)                                  if( IMR_LM_Log_Write( IMRD_LOG_TYPE_ID_ERROR,   IMRD_LOG_LEVEL_DEFAULT, IMRD_MODULE_PTR, __FILE__, __LINE__, IMRD_TRUE, (Fmt)) != IMRS_OK) return(IMRS_KO);
+#define IMRD_LM_LOG_ERROR_1( Fmt, Arg1)                            if(IMR_LM_Log_Write( IMRD_LOG_TYPE_ID_ERROR,   IMRD_LOG_LEVEL_DEFAULT, IMRD_MODULE_PTR, __FILE__, __LINE__, IMRD_TRUE, (Fmt), (Arg1)) != IMRS_OK) return(IMRS_KO) ;
+#define IMRD_LM_LOG_ERROR_2( Fmt, Arg1, Arg2)                      if( IMR_LM_Log_Write( IMRD_LOG_TYPE_ID_ERROR,   IMRD_LOG_LEVEL_DEFAULT, IMRD_MODULE_PTR, __FILE__, __LINE__, IMRD_TRUE, (Fmt), (Arg1), (Arg2)) != IMRS_OK) return(IMRS_KO);
+#define IMRD_LM_LOG_ERROR_3( Fmt, Arg1, Arg2, Arg3)                if( IMR_LM_Log_Write( IMRD_LOG_TYPE_ID_ERROR,   IMRD_LOG_LEVEL_DEFAULT, IMRD_MODULE_PTR, __FILE__, __LINE__, IMRD_TRUE, (Fmt), (Arg1), (Arg2), (Arg3)) != IMRS_OK) return(IMRS_KO);
+#define IMRD_LM_LOG_ERROR_4( Fmt, Arg1, Arg2, Arg3, Arg4)          if(IMR_LM_Log_Write( IMRD_LOG_TYPE_ID_ERROR,   IMRD_LOG_LEVEL_DEFAULT, IMRD_MODULE_PTR, __FILE__, __LINE__, IMRD_TRUE, (Fmt), (Arg1), (Arg2), (Arg3), (Arg4)) != IMRS_OK) return(IMRS_KO);
+#define IMRD_LM_LOG_ERROR_5( Fmt, Arg1, Arg2, Arg3, Arg4, Arg5)    if( IMR_LM_Log_Write( IMRD_LOG_TYPE_ID_ERROR,   IMRD_LOG_LEVEL_DEFAULT, IMRD_MODULE_PTR, __FILE__, __LINE__, IMRD_TRUE, (Fmt), (Arg1), (Arg2), (Arg3), (Arg4), (Arg5)) != IMRS_OK ) return(IMRS_KO);
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Exec Trace Macros                                                          */
+/*----------------------------------------------------------------------------*/
+
+#define IMRD_LM_STREAM_OUT  stream_out
+
+#define IMRD_LM_EXEC_TRACE( Level, Msg_Pre, Func, Msg_Post)		\
+    {									\
+	FILE  *stream_out;						\
+									\
+									\
+	if( IMR_LM_Log_Trigger( IMRD_LOG_TYPE_ID_TRACE, (Level), IMRD_MODULE_PTR) == IMRS_LM_LOG) \
+	{								\
+	    stream_out = IMR_LM_Stream_Out_Get();			\
+									\
+	    IMR_LM_Log_Write( IMRD_LOG_TYPE_ID_TRACE,   (Level), IMRD_MODULE_PTR, __FILE__, __LINE__, IMRD_FALSE, (Msg_Pre)); \
+	    (Func);							\
+	    fprintf( stream_out, "%s%s", (Msg_Post), "\n");		\
+	    fflush( stream_out);					\
+	}								\
+    }
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Log Buffer Id Macro                                                        */
+/*----------------------------------------------------------------------------*/
+
+#define IMRD_LM_LOG_BUFFER_ID( Buffer_Ptr, Log_Id_Struct_Ptr, Log_Id_Header)  if( IMR_LM_Log_Buffer_Id( (Buffer_Ptr), (Log_Id_Struct_Ptr), (Log_Id_Header), IMRD_LOG_TYPE_ID_INFO, IMRD_LOG_LEVEL_DEFAULT, IMRD_MODULE_PTR, __FILE__, __LINE__, IMRD_TRUE) != IMRS_OK) return(IMRS_KO);
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Open Log Manager                                                           */
+/*----------------------------------------------------------------------------*/
+/* LM_Config_Ptr:   Setup LM init mode                                        */
+/*----------------------------------------------------------------------------*/
+
+IMRD_LM_API IMRT_Status  IMR_LM_Library_Open( IMRT_LM_Config  *);
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Close Log Manager                                                          */
+/*----------------------------------------------------------------------------*/
+
+IMRD_LM_API IMRT_Status  IMR_LM_Library_Close( void);
+
+
+
+/*----------------------------------------------------------------------------*/
+/* LM_Stream_Out_Get                                                          */
+/*----------------------------------------------------------------------------*/
+
+IMRD_LM_API FILE  *IMR_LM_Stream_Out_Get( void);
+
+
+
+/*----------------------------------------------------------------------------*/
+/* LM_Log_Trigger                                                             */
+/*----------------------------------------------------------------------------*/
+/* Log_Type_Id:  Type id of log                                               */
+/* Log_Level:    Level of log                                                 */
+/* Module_Ptr:   Loger module pointer                                         */
+/*----------------------------------------------------------------------------*/
+
+IMRD_LM_API IMRT_Status  IMR_LM_Log_Trigger( IMRT_Log_Type_Id, IMRT_Log_Level, IMRT_Module  *);
+
+
+
+/*----------------------------------------------------------------------------*/
+/* LM_Log_Write                                                               */
+/*----------------------------------------------------------------------------*/
+/* Log_Type_Id:  Type id of log                                               */
+/* Log_Level:    Level of log                                                 */
+/* Module_Ptr:   Loger module pointer                                         */
+/* File_Name:    Loger file name                                              */
+/* Line_Id:      Loger line id                                                */
+/* LF_Flag:      Add or not a LF at EOF                                       */
+/* Log_Fmt:      Format string a la printf                                    */
+/* ...:          Optional args                                                */
+/*----------------------------------------------------------------------------*/
+
+IMRD_LM_API IMRT_Status  IMR_LM_Log_Write( IMRT_Log_Type_Id, IMRT_Log_Level, IMRT_Module  *, IMRT_File_Name, IMRT_Line_Id, IMRT_Boolean, IMRT_Log_Fmt, ...);
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Log_Buffer_Id                                                              */
+/*----------------------------------------------------------------------------*/
+/* Buffer_Ptr:         buffer to identify                                     */
+/* Log_Id_Struct_Ptr:  Log_Id_Heap to use                                     */
+/* Log_Id_Header_Ptr:  message to log as header                               */
+/* Log_Type_Id:        Type id of log                                         */
+/* Log_Level:          Level of log                                           */
+/* Module_Ptr:         Loger module pointer                                   */
+/* File_Name:          Loger file name                                        */
+/* Line_Id:            Loger line id                                          */
+/* LF_Flag:            Add or not a LF at EOF                                 */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  IMR_LM_Log_Buffer_Id( IMRT_Buffer  *, IMRT_Log_Id_Struct  *, IMRT_Log_Id_Header, IMRT_Log_Type_Id, IMRT_Log_Level, IMRT_Module  *, IMRT_File_Name, IMRT_Line_Id, IMRT_Boolean);
+
+
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+
+#endif
diff --git a/src/liblog_mng/src/Makefile b/src/liblog_mng/src/Makefile
new file mode 100644
index 0000000..a1889b4
--- /dev/null
+++ b/src/liblog_mng/src/Makefile
@@ -0,0 +1,65 @@
+#------------------------------------------------------------------------------
+# Local Makefile
+#------------------------------------------------------------------------------
+# $Workfile:   Makefile  $                                                     
+#------------------------------------------------------------------------------
+# $Author: agibert $                                                        
+# $Date: 2008/11/12 02:25:22 $                                             
+# $Revision: 1.1 $                                                         
+# $Label:  $                                                           
+#------------------------------------------------------------------------------
+
+#------------------------------------------------------------------------------
+# IMR - Interlinking Message Router                                            
+# Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)                
+# mailto:arnaud@rx3.net                                                        
+# http://www.rx3.org/dvp/?dvp=imr                                              
+#------------------------------------------------------------------------------
+# This file is part of IMR                                                     
+#                                                                              
+# This program is free software; you can redistribute it and/or                
+# modify it under the terms of the GNU General Public License                  
+# as published by the Free Software Foundation; either version 2               
+# of the License, or (at your option) any later version.                       
+#                                                                              
+# This program is distributed in the hope that it will be useful,              
+# but WITHOUT ANY WARRANTY; without even the implied warranty of               
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                
+# GNU General Public License for more details.                                 
+#                                                                              
+# You should have received a copy of the GNU General Public License            
+# along with this program; if not, write to the Free Software Foundation,      
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.          
+#------------------------------------------------------------------------------
+
+
+
+
+
+#------------------------------------------------------------------------------
+# Var include
+#------------------------------------------------------------------------------
+
+include ../../Makefile_var.mk
+
+
+
+#------------------------------------------------------------------------------
+# Variables
+#------------------------------------------------------------------------------
+
+TARGET=		liblog_mng$(SHLIB_SUFFIX)
+
+OBJ=		liblog_mng.o
+
+EXTRA_INC=	
+
+EXTRA_LIB=	
+
+
+
+#------------------------------------------------------------------------------
+# Rule include
+#------------------------------------------------------------------------------
+
+include ../../Makefile_rule.mk
diff --git a/src/liblog_mng/src/liblog_mng.c b/src/liblog_mng/src/liblog_mng.c
new file mode 100644
index 0000000..3b68757
--- /dev/null
+++ b/src/liblog_mng/src/liblog_mng.c
@@ -0,0 +1,362 @@
+/*----------------------------------------------------------------------------*/
+/* $Workfile:   liblog_mng.c  $                                               */
+/*----------------------------------------------------------------------------*/
+/* $Author: agibert $                                                      */
+/* $Date: 2008/11/12 02:25:22 $                                           */
+/* $Revision: 1.1 $                                                       */
+/* $Label:  $                                                         */
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#define _LIBLOG_MNG_
+#define _LIBLOG_MNG_C_
+
+#include "liblog_mng.h"
+
+
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Open Log Manager                                                           */
+/*----------------------------------------------------------------------------*/
+/* Lib_Flag:   Setup IOM init mode                                            */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  IMR_LM_Library_Open( IMRT_LM_Config  *Config_Ptr)
+{
+    IMRT_Module_Id    module_id;
+    IMRT_Log_Type_Id  log_type_id;
+
+
+    if( IMRG_LM_Module.Lib.Status != IMRD_LIB_STATUS_CLOSED)
+    {
+	IMRD_LM_LOG_ERROR_0( "Library not closed !");
+
+	return( IMRS_KO);
+    }
+    else
+    {
+	strcpy( IMRG_LM_Base.Config.Log_File, Config_Ptr->Log_File);
+
+	if( strcmp( Config_Ptr->Log_File, "-") == 0)
+	{
+	    IMRG_LM_Base.Stream_Out = stderr;
+	}
+	else
+	{
+	    if( ( IMRG_LM_Base.Stream_Out = fopen( Config_Ptr->Log_File, "a")) == NULL)
+	    {
+		IMRD_LM_LOG_ERROR_2( "Can't open log file [%s] (%d) !", IMRG_LM_Base.Config.Log_File, errno);
+
+		return( IMRS_KO);
+	    }
+	}
+
+
+
+	IMRG_LM_Base.Config.Module_Nb = Config_Ptr->Module_Nb;
+
+	for( module_id = 0; module_id < IMRG_LM_Base.Config.Module_Nb; module_id++)
+	{
+	    for( log_type_id = 0; log_type_id < IMRD_LOG_TYPE_NB; log_type_id++)
+	    {
+		IMRG_LM_Base.Config.Level_Tab[ log_type_id][ module_id] = Config_Ptr->Level_Tab[ log_type_id][ module_id];
+	    }
+	}
+
+	IMRG_LM_Module.Lib.Status = IMRD_LIB_STATUS_OPENED;
+
+	IMRD_LM_LOG_TRACE_0( IMRD_LOG_LEVEL_VERBOSE_1, "Library opened !");
+
+	return( IMRS_OK);
+    }
+}
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Close Log Manager                                                          */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  IMR_LM_Library_Close()
+{
+    if( IMRG_LM_Module.Lib.Status != IMRD_LIB_STATUS_OPENED)
+    {
+	IMRD_LM_LOG_ERROR_0( "Library not opened !");
+
+	return( IMRS_KO);
+    }
+    else
+    {
+	if( ( IMRG_LM_Base.Stream_Out != stderr) && ( fclose( IMRG_LM_Base.Stream_Out) == EOF))
+	{
+	    IMRD_LM_LOG_ERROR_2( "Can't close log file [%s] (%d) !", IMRG_LM_Base.Config.Log_File, errno);
+
+	    return( IMRS_KO);
+	}
+
+	IMRG_LM_Module.Lib.Status = IMRD_LIB_STATUS_CLOSED;
+
+	IMRD_LM_LOG_TRACE_0( IMRD_LOG_LEVEL_VERBOSE_1, "Library closed !");
+
+	return( IMRS_OK);
+    }
+}
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* LM_Stream_Out_Get                                                          */
+/*----------------------------------------------------------------------------*/
+/*                                                                            */
+/*----------------------------------------------------------------------------*/
+
+FILE  *IMR_LM_Stream_Out_Get( void)
+{
+    if( IMRG_LM_Base.Stream_Out == NULL)
+    {
+	return( stderr);
+    }
+    else
+    {
+	return( IMRG_LM_Base.Stream_Out);
+    }
+}
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* LM_Log_Trigger                                                             */
+/*----------------------------------------------------------------------------*/
+/* Log_Type_Id:  Type id of log                                               */
+/* Log_Level:    Level of log                                                 */
+/* Module_Ptr:   Loger module pointer                                         */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  IMR_LM_Log_Trigger( IMRT_Log_Type_Id  Log_Type_Id, IMRT_Log_Level  Log_Level, IMRT_Module  *Module_Ptr)
+{
+    FILE     *Stream_Out;
+
+
+    Stream_Out = IMR_LM_Stream_Out_Get();
+
+    if( ( Log_Type_Id < 0) || ( Log_Type_Id >= IMRD_LOG_TYPE_NB))
+    {
+	fprintf( Stream_Out, "liblog_mng: %s: Invalid Log_Type_Id (%d) !\n", __FILE__, errno);
+
+	return( IMRS_KO);
+    }
+    
+    if( IMRG_LM_Module.Lib.Status == IMRD_LIB_STATUS_OPENED)
+    {
+	if ( IMRG_LM_Base.Config.Level_Tab[ Log_Type_Id][ Module_Ptr->Id] != IMRD_LOG_LEVEL_UNSET)
+	{
+	    if( Log_Level > IMRG_LM_Base.Config.Level_Tab[ Log_Type_Id][ Module_Ptr->Id])
+	    {
+		return( IMRS_OK);
+	    }
+	}
+	else
+	{
+	    if( Log_Level > IMRG_LM_Base.Config.Level_Tab[ Log_Type_Id][ IMRD_MODULE_ID_UNKNOWN])
+	    {
+		return( IMRS_OK);
+	    }
+	}
+    }
+    else
+    {
+	if( Log_Type_Id == IMRD_LOG_TYPE_ID_TRACE)
+	{
+	    return( IMRS_OK);
+	}
+    }
+
+    return( IMRS_LM_LOG);
+}
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* LM_Log_Write                                                               */
+/*----------------------------------------------------------------------------*/
+/* Log_Type_Id:  Type id of log                                               */
+/* Log_Level:    Level of log                                                 */
+/* Module_Ptr:   Loger module pointer                                         */
+/* File_Name:    Loger file name                                              */
+/* Line_Id:      Loger line id                                                */
+/* LF_Flag:      Add or not a LF at EOF                                       */
+/* Log_Fmt:      Format string a la printf                                    */
+/* ...:          Optional args                                                */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  IMR_LM_Log_Write( IMRT_Log_Type_Id  Log_Type_Id, IMRT_Log_Level  Log_Level, IMRT_Module  *Module_Ptr, IMRT_File_Name  File_Name, IMRT_Line_Id  Line_Id, IMRT_Boolean  LF_Flag, IMRT_Log_Fmt  Log_Fmt, ...)
+{
+           va_list       args;
+	   FILE         *Stream_Out;
+	   IMRT_Status   status;
+           char          fmt[255];
+    struct timeval       cur_timeval;
+    struct tm           *tm_ptr;
+    int  rc;
+
+
+    Stream_Out = IMR_LM_Stream_Out_Get();
+
+    if( ( status = IMR_LM_Log_Trigger( Log_Type_Id, Log_Level, Module_Ptr)) != IMRS_LM_LOG)
+    {
+	return( status);
+    }
+
+    gettimeofday( &cur_timeval, NULL);
+
+    if( ( tm_ptr = localtime( &( cur_timeval.tv_sec))) == NULL)
+    {
+	fprintf( Stream_Out, "liblog_mng: %s: can't convert localtime (%d) !\n", __FILE__, errno);
+
+	return( IMRS_KO);
+    }
+
+    va_start( args, Log_Fmt);
+
+    sprintf( fmt, "%02d/%02d/%02d %02d:%02d:%02d.%04d %3s %03d %-4s %-21s %-4d %s%s",
+	     ( tm_ptr->tm_year - 100), tm_ptr->tm_mon, tm_ptr->tm_mday, tm_ptr->tm_hour, tm_ptr->tm_min, tm_ptr->tm_sec, ( cur_timeval.tv_usec / 100),
+	     IMRG_LM_Base.Log_Type_Tab[ Log_Type_Id], Log_Level, Module_Ptr->Name, File_Name, Line_Id,
+	     Log_Fmt,
+	     ( ( LF_Flag == IMRD_TRUE) ? "\n" : ""));
+
+    rc = vfprintf( Stream_Out, fmt, args);
+    
+    if( rc  < 0)
+    {
+	fprintf(stderr, "liblog_mng: Can't log messages (%d) !!!\n", errno);
+	ND_Library_StdErr_Set( NULL);
+	return(IMRS_KO);
+    }
+
+    fflush( Stream_Out);
+
+    va_end( args);
+
+    return( IMRS_OK);
+}
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Log_Buffer_Id                                                              */
+/*----------------------------------------------------------------------------*/
+/* Buffer_Ptr:         buffer to identify                                     */
+/* Log_Id_Struct_Ptr:  Log_Id_Heap to use                                     */
+/* Log_Id_Header_Ptr:  message to log as header                               */
+/* Log_Type_Id:        Type id of log                                         */
+/* Log_Level:          Level of log                                           */
+/* Module_Ptr:         Loger module pointer                                   */
+/* File_Name:          Loger file name                                        */
+/* Line_Id:            Loger line id                                          */
+/* LF_Flag:            Add or not a LF at EOF                                 */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  IMR_LM_Log_Buffer_Id( IMRT_Buffer  *Buffer_Ptr, IMRT_Log_Id_Struct  *Log_Id_Struct_Ptr, IMRT_Log_Id_Header  Log_Id_Header, IMRT_Log_Type_Id  Log_Type_Id, IMRT_Log_Level  Log_Level, IMRT_Module  *Module_Ptr, IMRT_File_Name  File_Name, IMRT_Line_Id  Line_Id, IMRT_Boolean  LF_Flag)
+{
+  IMRT_Status   status;
+  char         *log_string, *log_ptr, *buf_ptr;
+  int           idx;
+   
+
+  if( Log_Id_Struct_Ptr->Bit_Nb > 0 )
+  {
+      if( Log_Id_Struct_Ptr->Log_Id_Bit_Ptr != NULL)
+      {
+	  if( Buffer_Ptr->Data_Buf_Ptr != NULL)
+	  {
+	      /* allocation = taille total des Id + ( deux crochets + un espace entre chaque id ) * le nombre d'Id */
+
+	      if( ( log_string = malloc( Log_Id_Struct_Ptr->Log_Size + ( 3 * Log_Id_Struct_Ptr->Bit_Nb) + 1)) != NULL)
+	      {
+		  for( idx = 0, log_ptr = log_string; idx < Log_Id_Struct_Ptr->Bit_Nb; idx++)
+		  {
+		      *(log_ptr++) = ' ';
+		      *(log_ptr++) = '[';
+
+		      for( buf_ptr = Buffer_Ptr->Data_Buf_Ptr + Log_Id_Struct_Ptr->Log_Id_Bit_Ptr[ idx].Offset;
+			   ( *buf_ptr != '\0') && ( buf_ptr < ( Buffer_Ptr->Data_Buf_Ptr
+								+ Log_Id_Struct_Ptr->Log_Id_Bit_Ptr[ idx].Offset
+								+ Log_Id_Struct_Ptr->Log_Id_Bit_Ptr[ idx].Size));
+			   buf_ptr++)
+		      {
+			  *(log_ptr++) = isprint( *buf_ptr) ? *buf_ptr : '.';
+		      }
+
+		      *(log_ptr++) = ']';
+		  }
+
+		  *log_ptr = '\0';
+
+		  IMR_LM_Log_Write( Log_Type_Id, Log_Level, Module_Ptr, File_Name, Line_Id, LF_Flag, "%s%s", Log_Id_Header, log_string);
+
+		  free( log_string);
+
+		  status = IMRS_OK;
+	      }
+	      else
+	      {
+		  IMRD_LM_LOG_ERROR_1( "Allocation error ! (%d)", errno);
+		  status = IMRS_KO;
+	      }
+	      
+	  }
+	  else
+	  {
+	      IMRD_LM_LOG_ERROR_0( "Buffer data NULL !");
+	      status = IMRS_KO;
+	  }
+      }
+      else
+      {
+	  IMRD_LM_LOG_ERROR_0( "Log_Id_Bit_Ptr Null !");
+	  status = IMRS_KO;
+      }    
+  }
+  else
+  {
+      status = IMRS_OK;
+  }    
+
+  return( status);
+}
diff --git a/src/liblog_mng/src/liblog_mng.h b/src/liblog_mng/src/liblog_mng.h
new file mode 100644
index 0000000..9874633
--- /dev/null
+++ b/src/liblog_mng/src/liblog_mng.h
@@ -0,0 +1,141 @@
+/*----------------------------------------------------------------------------*/
+/* File: liblog_mng.h 				         		      */
+/*----------------------------------------------------------------------------*/
+/*                                                                            */
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#ifndef _LIBLOG_MNG_H_
+#define _LIBLOG_MNG_H_
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Global Include                                                             */
+/*----------------------------------------------------------------------------*/
+
+#include <imr.h>
+#include <time.h>
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Lib Definition                                                             */
+/*----------------------------------------------------------------------------*/
+
+#define IMRD_LM_MODULE_ID                ( IMRT_Module_Id) 1
+#define IMRD_LM_MODULE_NAME            ( IMRT_Module_Name) "lm"
+#define IMRD_LM_MODULE_NAME_LONG  ( IMRT_Module_Name_Long) "Log Manager"
+#define IMRD_LM_MODULE_VERSION      ( IMRT_Module_Version) "@(#) VERSIONIMR: $Label:  $   $Date: 2008/11/12 02:25:22 $   $Workfile:   liblog_mng.h  $"
+
+#define IMRD_MODULE_PTR                                    &IMRG_LM_Module
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Local Definitions                                                          */
+/*----------------------------------------------------------------------------*/
+
+typedef struct IMRT_LM_Base
+{
+	IMRT_Log_Type_Name   Log_Type_Tab[ IMRD_LOG_TYPE_NB];
+	IMRT_LM_Config       Config;
+	FILE                *Stream_Out;
+}  IMRT_LM_Base;
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Prototypes                                                                 */
+/*----------------------------------------------------------------------------*/
+
+#   ifdef _LIBLOG_MNG_C_
+
+#   endif
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Local Includes                                                             */
+/*----------------------------------------------------------------------------*/
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Global Variables                                                           */
+/*----------------------------------------------------------------------------*/
+
+#   ifdef _LIBLOG_MNG_C_
+
+IMRT_LM_Base  IMRG_LM_Base =
+{
+    { IMRD_LOG_TYPE_NAME_UNKNOWN, IMRD_LOG_TYPE_NAME_TRACE, IMRD_LOG_TYPE_NAME_INFO, IMRD_LOG_TYPE_NAME_WARNING, IMRD_LOG_TYPE_NAME_ERROR},
+    { "", 0, { 0 } },
+    NULL
+};
+
+
+
+IMRT_Module  IMRG_LM_Module =
+{ 
+    IMRD_LM_MODULE_ID,
+    IMRD_LM_MODULE_NAME,
+    IMRD_LM_MODULE_NAME_LONG,
+    IMRD_LM_MODULE_VERSION,
+    IMRD_MODULE_TYPE_LIBRARY,
+    {
+	IMRD_LIB_STATUS_CLOSED,
+	( IMRT_Lib_Open    *) &IMR_LM_Library_Open,
+	( IMRT_Lib_Close   *) &IMR_LM_Library_Close
+    }
+};
+
+#   else
+
+extern IMRT_LM_Base  IMRG_LM_Base;
+extern IMRT_Module   IMRG_LM_Module;
+
+#   endif
+
+
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+
+#endif
diff --git a/src/libmapping_mng/include/mapping_mng.h b/src/libmapping_mng/include/mapping_mng.h
new file mode 100644
index 0000000..ed53e79
--- /dev/null
+++ b/src/libmapping_mng/include/mapping_mng.h
@@ -0,0 +1,159 @@
+/*----------------------------------------------------------------------------*/
+/* File: mapping_mng.h 				                              */
+/*----------------------------------------------------------------------------*/
+/*                                                                            */
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#ifndef _MAPPING_MNG_H_
+#define _MAPPING_MNG_H_
+
+
+
+#include <imr.h>
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IMRD_MM_API definition                                                     */
+/*----------------------------------------------------------------------------*/
+
+#   ifdef _LIBMAPPING_MNG_C_
+#       define IMRD_MM_API  
+#   else
+#       define IMRD_MM_API  extern
+#   endif
+
+
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* MM_Config definition                                                       */
+/*----------------------------------------------------------------------------*/
+
+typedef struct IMRT_MM_Config
+{
+	IMRT_Boolean  XML_Format;
+}  IMRT_MM_Config;
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Global Variables                                                           */
+/*----------------------------------------------------------------------------*/
+
+#   ifdef _LIBMAPPING_MNG_
+
+#   else
+
+extern IMRT_Module  IMRG_MM_Module;
+
+#   endif
+
+
+
+
+
+
+
+/******************************************************************************/
+/* Mapping Manager API                                                        */
+/******************************************************************************/
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Open Mapping Manager                                                       */
+/*----------------------------------------------------------------------------*/
+
+IMRD_MM_API IMRT_Status  IMR_MM_Library_Open( IMRT_MM_Config  *);
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Close Mapping Manager                                                      */
+/*----------------------------------------------------------------------------*/
+
+IMRD_MM_API IMRT_Status  IMR_MM_Library_Close( void);
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Buffer allocation	                                                      */
+/*----------------------------------------------------------------------------*/
+/* (O) Buffer_Ptr_Ptr :   Buffer pointer pointer		    	      */
+/*----------------------------------------------------------------------------*/
+
+IMRD_MM_API IMRT_Status IMR_MM_Buffer_Alloc( IMRT_Buffer **);
+
+
+/*----------------------------------------------------------------------------*/
+/* Buffer free			                                              */
+/*----------------------------------------------------------------------------*/
+/* (IO) Buffer_Ptr_Ptr :   Buffer pointer pointer		    	      */
+/*----------------------------------------------------------------------------*/
+
+IMRD_MM_API IMRT_Status	IMR_MM_Buffer_Free( IMRT_Buffer **);
+
+
+/*----------------------------------------------------------------------------*/
+/* Buffer check			                                              */
+/*----------------------------------------------------------------------------*/
+/* (I) Buffer_Ptr :   Buffer pointer 					      */
+/*----------------------------------------------------------------------------*/
+
+IMRD_MM_API IMRT_Status	IMR_MM_Buffer_Check (IMRT_Buffer *);
+
+
+/*----------------------------------------------------------------------------*/
+/* Buffer list			                                              */
+/*----------------------------------------------------------------------------*/
+/* (I) Buffer_Ptr :   Buffer pointer 					      */
+/* (I) texte 	  :   Text to print		 			      */
+/*----------------------------------------------------------------------------*/
+
+IMRD_MM_API IMRT_Status	IMR_MM_Buffer_List( IMRT_Buffer *, char *);
+
+
+/*----------------------------------------------------------------------------*/
+/* Buffer mapping		                                              */
+/*----------------------------------------------------------------------------*/
+/* (I) Output_Buffer_Ptr :   Output buffer pointer 			      */
+/* (I) Input_Buffer_Ptr  :   Input buffer pointer		 	      */
+/*----------------------------------------------------------------------------*/
+
+IMRD_MM_API IMRT_Status IMR_MM_Buffer_Map( IMRT_Buffer *,  IMRT_Buffer *);
+
+
+/*----------------------------------------------------------------------------*/
+
+#endif
diff --git a/src/libmapping_mng/src/Makefile b/src/libmapping_mng/src/Makefile
new file mode 100644
index 0000000..8be00f1
--- /dev/null
+++ b/src/libmapping_mng/src/Makefile
@@ -0,0 +1,81 @@
+#------------------------------------------------------------------------------
+# Local Makefile
+#------------------------------------------------------------------------------
+# $Workfile:   Makefile  $                                                     
+#------------------------------------------------------------------------------
+# $Author: agibert $                                                        
+# $Date: 2008/11/12 02:25:22 $                                             
+# $Revision: 1.1 $                                                         
+# $Label:  $                                                           
+#------------------------------------------------------------------------------
+
+#------------------------------------------------------------------------------
+# IMR - Interlinking Message Router                                            
+# Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)                
+# mailto:arnaud@rx3.net                                                        
+# http://www.rx3.org/dvp/?dvp=imr                                              
+#------------------------------------------------------------------------------
+# This file is part of IMR                                                     
+#                                                                              
+# This program is free software; you can redistribute it and/or                
+# modify it under the terms of the GNU General Public License                  
+# as published by the Free Software Foundation; either version 2               
+# of the License, or (at your option) any later version.                       
+#                                                                              
+# This program is distributed in the hope that it will be useful,              
+# but WITHOUT ANY WARRANTY; without even the implied warranty of               
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                
+# GNU General Public License for more details.                                 
+#                                                                              
+# You should have received a copy of the GNU General Public License            
+# along with this program; if not, write to the Free Software Foundation,      
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.          
+#------------------------------------------------------------------------------
+
+
+
+
+
+#------------------------------------------------------------------------------
+# Var include
+#------------------------------------------------------------------------------
+
+include ../../Makefile_var.mk
+
+
+
+#------------------------------------------------------------------------------
+# Variables
+#------------------------------------------------------------------------------
+
+TARGET=		libmapping_mng$(SHLIB_SUFFIX)
+
+OBJ=		libmapping_mng.o					\
+		map_scheduler.o						\
+		buffer_mng.o						\
+		cnv_hdl_pad_right.o                                     \
+		cnv_hdl_pad_left.o					\
+		cnv_hdl_pad_num.o                                      	\
+		cnv_hdl_strip_right.o                                 	\
+		cnv_hdl_strip_left.o					\
+		cnv_hdl_cut_right.o                                     \
+		cnv_hdl_strip_num.o					\
+		fmt_hdl_fixed.o						\
+		fmt_hdl_xml.o						\
+		fmt_hdl_dltd.o
+
+ifeq ($(TUX_SUPPORT),1)
+		OBJ+=	fmt_hdl_fml.o
+endif
+
+EXTRA_INC=	
+
+EXTRA_LIB=	
+
+
+
+#------------------------------------------------------------------------------
+# Rule include
+#------------------------------------------------------------------------------
+
+include ../../Makefile_rule.mk
diff --git a/src/libmapping_mng/src/buffer_mng.c b/src/libmapping_mng/src/buffer_mng.c
new file mode 100644
index 0000000..ed79e5f
--- /dev/null
+++ b/src/libmapping_mng/src/buffer_mng.c
@@ -0,0 +1,1276 @@
+/*----------------------------------------------------------------------------*/
+/* File: buffer_mng.c					   		      */
+/*----------------------------------------------------------------------------*/
+/*                                                                            */
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#define _LIBMAPPING_MNG_
+#define _BUFFER_MNG_C_
+
+#include "buffer_mng.h" 
+
+
+IMRT_Status	MM_Buffer_DeInit()
+{
+	IMRT_Status status;
+	char *func_name = "MM_Buffer_DeInit";
+	int indice;
+	IMRT_StrHdl_Fmt_Func *StrHdl_Fmt_dynamic_ptr;
+	IMRT_StrHdl_Cnv_Func *StrHdl_Cnv_dynamic_ptr;
+	
+
+	status = IMRS_OK;
+	indice = 0;
+	StrHdl_Fmt_dynamic_ptr = NULL;
+	StrHdl_Cnv_dynamic_ptr = NULL;
+	
+	if ((IMRG_MM_StrHdl_Fmt_Func_Tab != NULL) && (IMRG_MM_StrHdl_Cnv_Func_Tab != NULL))
+	{
+		while (   (status == IMRS_OK)
+		       && (indice < IMRG_Taille_Fmt_Max) )
+		{
+		        StrHdl_Fmt_dynamic_ptr = &(IMRG_MM_StrHdl_Fmt_Func_Tab[indice]);
+		
+	        	if (( StrHdl_Fmt_dynamic_ptr != NULL) && (StrHdl_Fmt_dynamic_ptr->DeInit_Ptr != NULL))
+	        	{
+	        		status = StrHdl_Fmt_dynamic_ptr->DeInit_Ptr();
+	        	}
+	        	indice++;
+	        }
+	        
+	
+		indice = 0;
+		
+		while (   (status == IMRS_OK)
+		       && (indice < IMRG_Taille_Cnv_Max) )
+		{
+		        StrHdl_Cnv_dynamic_ptr = &(IMRG_MM_StrHdl_Cnv_Func_Tab[indice]);
+		
+	        	if ((StrHdl_Cnv_dynamic_ptr != NULL) && (StrHdl_Cnv_dynamic_ptr->DeInit_Ptr != NULL))
+	        	{
+	        		status = StrHdl_Cnv_dynamic_ptr->DeInit_Ptr();
+	        	}
+	        	indice++;
+	        }
+	}
+	
+	if ( IMRG_MM_StrHdl_Fmt_Func_Tab != NULL)
+	{
+		free( IMRG_MM_StrHdl_Fmt_Func_Tab );
+	}
+        
+	if ( IMRG_MM_StrHdl_Cnv_Func_Tab != NULL)
+	{
+		free( IMRG_MM_StrHdl_Cnv_Func_Tab );
+	}
+
+	IMRG_Input_Buffer_Ptr    = NULL;
+	IMRG_Output_Buffer_Ptr   = NULL;
+	IMRG_Taille_Fmt_Max          = 0;
+	IMRG_Taille_Cnv_Max          = 0;
+
+
+	return ( status );
+}
+
+IMRT_Status	MM_Buffer_Init()
+{
+        
+	IMRT_Status status;
+	char *func_name = "MM_Buffer_Init";
+
+	
+	status = IMRS_OK;
+	IMRG_Input_Buffer_Ptr    = NULL;
+	IMRG_Output_Buffer_Ptr   = NULL;
+	IMRG_Taille_Fmt_Max          = 0;
+	IMRG_Taille_Cnv_Max          = 0;
+	IMRG_MM_StrHdl_Fmt_Func_Tab = NULL;
+	IMRG_MM_StrHdl_Cnv_Func_Tab = NULL;
+	
+	handle = dlopen (NULL , RTLD_LAZY);
+	if (handle == NULL)
+	{
+	        IMRD_LM_LOG_ERROR_1("dlopen failed  [%s]" , dlerror());
+	        status = IMRS_KO;
+	}
+	
+	
+	status = IMR_SDM_Fmt_Proceed(IMR_MM_Fmt_Add);
+
+	if ( status != IMRS_OK)
+	{
+		IMRD_LM_LOG_ERROR_1("Format proceed ended with status (%d)" , status);
+	}
+	else
+	{
+	        status = IMR_SDM_Cnv_Proceed(IMR_MM_Cnv_Add);
+		if ( status != IMRS_OK)
+		{
+		        IMRD_LM_LOG_ERROR_1("Conversion functions proceed ended with status (%d)" , status);
+		}
+
+	}
+	
+
+	return ( status );
+	
+}
+
+
+IMRT_Status IMR_MM_Fmt_Add(IMRT_Fmt_Id Format_Id , IMRT_Fmt_Name Format_Name , IMRT_Fmt_Id Fmt_Id_Nb)
+{
+	IMRT_Status                     status;
+	char                            *func_name = "IMR_MM_Fmt_Add";
+	size_t                          tableau_size;
+	IMRT_StrHdl_Fmt_Func            *StrHdl_Fmt_dynamic_ptr;
+        char                            func_ptr_name[100];
+        char                            ptr_name[100];
+        IMRT_Boolean                    fmt_is_unknown;
+        IMRT_Boolean                    it_is_OK;
+        
+	IMRD_LM_LOG_TRACE_0(IMRD_LOG_LEVEL_VERBOSE_2 , "============================================================================")
+	IMRD_LM_LOG_TRACE_0(IMRD_LOG_LEVEL_VERBOSE_2 , "Initialisation format demand : Begin");
+	IMRD_LM_LOG_TRACE_2(IMRD_LOG_LEVEL_VERBOSE_2 , "Format Id : (%d) name :  (%s)" , Format_Id , Format_Name);	
+
+        fmt_is_unknown = IMRD_FALSE;        
+        it_is_OK = IMRD_TRUE;
+        status = IMRS_OK;
+        StrHdl_Fmt_dynamic_ptr = NULL;
+        
+        memset( func_ptr_name, '\0', sizeof(func_ptr_name) );
+        memset( ptr_name, '\0', sizeof(ptr_name) );
+        
+        if (strcmp(Format_Name,IMRD_FMT_NAME_UNKNOWN) == 0)
+                fmt_is_unknown = IMRD_TRUE;
+                
+        if (IMRG_MM_StrHdl_Fmt_Func_Tab == NULL)
+        {
+		IMRD_LM_LOG_TRACE_1(IMRD_LOG_LEVEL_VERBOSE_2 , "Format_Id Max  : (%d)" , Fmt_Id_Nb);	
+                tableau_size = (sizeof(IMRT_StrHdl_Fmt_Func) * Fmt_Id_Nb);
+                IMRG_MM_StrHdl_Fmt_Func_Tab = (IMRT_StrHdl_Fmt_Func *) malloc( tableau_size );
+                if (IMRG_MM_StrHdl_Fmt_Func_Tab== NULL)
+                {
+                        status = IMRS_KO;
+                        IMRD_LM_LOG_ERROR_0("malloc IMRG_MM_StrHdl_Fmt_Func_Tab failed" );
+                }
+                else
+                {
+                        memset( IMRG_MM_StrHdl_Fmt_Func_Tab, '\0', tableau_size );
+                        IMRG_Taille_Fmt_Max = Fmt_Id_Nb;
+                }
+        }
+        
+        if (status == IMRS_OK)
+        {
+                StrHdl_Fmt_dynamic_ptr = &(IMRG_MM_StrHdl_Fmt_Func_Tab[Format_Id]);
+                strcpy( StrHdl_Fmt_dynamic_ptr->Nom , Format_Name);
+
+                strcpy(ptr_name , "Init");
+                sprintf(func_ptr_name,"MM_%s_StrHdl_%s",Format_Name,ptr_name);
+                StrHdl_Fmt_dynamic_ptr->Init_Ptr = ( IMRT_MM_Fmt_Hdl_Init  *)dlsym(handle , func_ptr_name);
+                if ((StrHdl_Fmt_dynamic_ptr->Init_Ptr == NULL) && (!fmt_is_unknown))
+                        it_is_OK = IMRD_FALSE;
+                        
+                if (it_is_OK)
+                {                
+                        strcpy(ptr_name , "DeInit");
+                        sprintf(func_ptr_name,"MM_%s_StrHdl_%s",Format_Name,ptr_name);
+                        StrHdl_Fmt_dynamic_ptr->DeInit_Ptr = ( IMRT_MM_Fmt_Hdl_DeInit  *)dlsym(handle , func_ptr_name);
+                        if ((StrHdl_Fmt_dynamic_ptr->DeInit_Ptr == NULL) &&( !fmt_is_unknown))
+                                it_is_OK = IMRD_FALSE;
+                }
+                
+                if (it_is_OK)
+                {                
+                        strcpy(ptr_name , "Data_Free");
+                        sprintf(func_ptr_name,"MM_%s_StrHdl_%s",Format_Name,ptr_name);                
+                        StrHdl_Fmt_dynamic_ptr->Data_Free_Ptr   = (IMRT_MM_Fmt_Hdl_Data_Free *)dlsym(handle , func_ptr_name);
+                        if ((StrHdl_Fmt_dynamic_ptr->Data_Free_Ptr == NULL) && (!fmt_is_unknown))
+                                it_is_OK = IMRD_FALSE;
+                }
+                
+                if (it_is_OK)
+                {
+                        strcpy(ptr_name , "Ident");
+                        sprintf(func_ptr_name,"MM_%s_StrHdl_%s",Format_Name,ptr_name);        	
+                        StrHdl_Fmt_dynamic_ptr->Ident_Ptr        = (IMRT_MM_Fmt_Hdl_Ident *)dlsym(handle , func_ptr_name);
+                        if ((StrHdl_Fmt_dynamic_ptr->Ident_Ptr == NULL) && (!fmt_is_unknown))
+                                it_is_OK = IMRD_FALSE;
+                }
+                
+                if (it_is_OK)
+                {                
+                        strcpy(ptr_name , "Open");
+                        sprintf(func_ptr_name,"MM_%s_StrHdl_%s",Format_Name,ptr_name);        	
+                        StrHdl_Fmt_dynamic_ptr->Open_Ptr        = (IMRT_MM_Fmt_Hdl_Open *)dlsym(handle , func_ptr_name);
+                        if ((StrHdl_Fmt_dynamic_ptr->Open_Ptr == NULL) && (!fmt_is_unknown))
+                                it_is_OK = IMRD_FALSE;
+                }
+                
+                if (it_is_OK)
+                {                
+                        strcpy(ptr_name , "Close");
+                        sprintf(func_ptr_name,"MM_%s_StrHdl_%s",Format_Name,ptr_name);		
+                        StrHdl_Fmt_dynamic_ptr->Close_Ptr       = (IMRT_MM_Fmt_Hdl_Close *)dlsym(handle , func_ptr_name);
+                        if ((StrHdl_Fmt_dynamic_ptr->Close_Ptr == NULL) && (!fmt_is_unknown))
+                                it_is_OK = IMRD_FALSE;
+                }
+                
+                if (it_is_OK)
+                {                
+                        strcpy(ptr_name , "Data_List");
+                        sprintf(func_ptr_name,"MM_%s_StrHdl_%s",Format_Name,ptr_name);		
+                        StrHdl_Fmt_dynamic_ptr->Data_List_Ptr   = (IMRT_MM_Fmt_Hdl_Data_List *)dlsym(handle , func_ptr_name);
+                        if ((StrHdl_Fmt_dynamic_ptr->Data_List_Ptr == NULL) && (!fmt_is_unknown))
+                                it_is_OK = IMRD_FALSE;
+                }
+                
+                if (it_is_OK)
+                {                
+                        strcpy(ptr_name , "Copy");
+                        sprintf(func_ptr_name,"MM_%s_StrHdl_%s",Format_Name,ptr_name);		
+                        StrHdl_Fmt_dynamic_ptr->Copy_Ptr        = (IMRT_MM_Fmt_Hdl_Copy *)dlsym(handle , func_ptr_name);
+                        if ((StrHdl_Fmt_dynamic_ptr->Copy_Ptr == NULL) && (!fmt_is_unknown))
+                                it_is_OK = IMRD_FALSE;
+                }
+                
+                if (it_is_OK)
+                {                
+                        strcpy(ptr_name , "Flush");
+                        sprintf(func_ptr_name,"MM_%s_StrHdl_%s",Format_Name,ptr_name);		
+                        StrHdl_Fmt_dynamic_ptr->Flush_Ptr       = (IMRT_MM_Fmt_Hdl_Flush *)dlsym(handle , func_ptr_name);
+                        if ((StrHdl_Fmt_dynamic_ptr->Flush_Ptr == NULL) && (!fmt_is_unknown))
+                                it_is_OK = IMRD_FALSE;
+                }
+                
+                if (it_is_OK)
+                {                
+                        strcpy(ptr_name , "Get");
+                        sprintf(func_ptr_name,"MM_%s_StrHdl_%s",Format_Name,ptr_name);		
+                        StrHdl_Fmt_dynamic_ptr->Get_Ptr         = (IMRT_MM_Fmt_Hdl_Get *)dlsym(handle , func_ptr_name);
+                        if ((StrHdl_Fmt_dynamic_ptr->Get_Ptr == NULL) && (!fmt_is_unknown))
+                                it_is_OK = IMRD_FALSE;
+                }
+                
+                if (it_is_OK)
+                {                
+                        strcpy(ptr_name , "Convert");
+                        sprintf(func_ptr_name,"MM_%s_StrHdl_%s",Format_Name,ptr_name);		
+                        StrHdl_Fmt_dynamic_ptr->Cnv_Ptr         = (IMRT_MM_Fmt_Hdl_Cnv *)dlsym(handle , func_ptr_name);
+                        if ((StrHdl_Fmt_dynamic_ptr->Cnv_Ptr == NULL) && (!fmt_is_unknown))
+                                it_is_OK = IMRD_FALSE;
+                }
+                
+                if (it_is_OK)
+                {                
+                        strcpy(ptr_name , "Put");
+                        sprintf(func_ptr_name,"MM_%s_StrHdl_%s",Format_Name,ptr_name);		
+                        StrHdl_Fmt_dynamic_ptr->Put_Ptr         = (IMRT_MM_Fmt_Hdl_Put *)dlsym(handle , func_ptr_name);
+                        if ((StrHdl_Fmt_dynamic_ptr->Put_Ptr == NULL) && (!fmt_is_unknown))
+                                it_is_OK = IMRD_FALSE;
+                }
+                        
+                if (it_is_OK && StrHdl_Fmt_dynamic_ptr->Init_Ptr != NULL)
+                {
+                        status = StrHdl_Fmt_dynamic_ptr->Init_Ptr();
+                        if (status == IMRS_KO)
+                                IMRD_LM_LOG_ERROR_0("Initialisation handlers failed" );
+                }
+                
+                if (!it_is_OK)
+                {
+                        status = IMRS_KO;
+                        IMRD_LM_LOG_ERROR_0("Pointeur null et format different de unknown" );
+                        IMRD_LM_LOG_ERROR_1("dlsym failed [%s]", dlerror());
+                }
+
+        }
+
+	IMRD_LM_LOG_TRACE_1(IMRD_LOG_LEVEL_VERBOSE_2 , "Initialisation format demand : End with status :  (%d)" , status);
+	IMRD_LM_LOG_TRACE_0(IMRD_LOG_LEVEL_VERBOSE_2 ,  "============================================================================")
+
+	return ( status );
+
+}
+
+IMRT_Status IMR_MM_Cnv_Add(IMRT_Cnv_Id Conv_Id , IMRT_Cnv_Name Conv_Name , IMRT_Cnv_Id Conv_Id_Nb)
+{
+	IMRT_Status                     status;
+	char                            *func_name = "IMR_MM_Cnv_Add";
+	size_t                          tableau_size;
+	IMRT_StrHdl_Cnv_Func            *StrHdl_Cnv_dynamic_ptr;
+        char                            func_ptr_name[100];
+        char                            ptr_name[100];
+        IMRT_Boolean                    cnv_is_unknown;
+        IMRT_Boolean                    it_is_OK;
+        
+	IMRD_LM_LOG_TRACE_0(IMRD_LOG_LEVEL_VERBOSE_2 ,  "============================================================================")
+	IMRD_LM_LOG_TRACE_0(IMRD_LOG_LEVEL_VERBOSE_2 , "Initialisation conversion function demand : Begin");
+	IMRD_LM_LOG_TRACE_2(IMRD_LOG_LEVEL_VERBOSE_2 , "Conversion  Id : (%d) name :  (%s)" , Conv_Id , Conv_Name);	
+
+	
+        cnv_is_unknown = IMRD_FALSE;
+        it_is_OK = IMRD_TRUE;
+        status = IMRS_OK;
+        StrHdl_Cnv_dynamic_ptr = NULL;
+        
+        memset( func_ptr_name, '\0', sizeof(func_ptr_name) );
+        memset( ptr_name, '\0', sizeof(ptr_name) );
+
+        if (strcmp(Conv_Name,IMRD_CNV_NAME_UNKNOWN)==0)
+                cnv_is_unknown = IMRD_TRUE;
+        
+        if (IMRG_MM_StrHdl_Cnv_Func_Tab == NULL)
+        {
+	        IMRD_LM_LOG_TRACE_1(IMRD_LOG_LEVEL_VERBOSE_2 , "Conv_Id Max  : (%d)" , Conv_Id_Nb);	
+                tableau_size = (sizeof(IMRT_StrHdl_Cnv_Func) * Conv_Id_Nb);
+                IMRG_MM_StrHdl_Cnv_Func_Tab = (IMRT_StrHdl_Cnv_Func *) malloc( tableau_size );
+                if (IMRG_MM_StrHdl_Cnv_Func_Tab== NULL)
+                {
+                        status = IMRS_KO;
+                        IMRD_LM_LOG_ERROR_0("malloc IMRG_MM_StrHdl_Cnv_Func_Tab failed" );
+                }
+                else
+                {
+                        memset( IMRG_MM_StrHdl_Cnv_Func_Tab, '\0', tableau_size );
+                        IMRG_Taille_Cnv_Max = Conv_Id_Nb;
+                }
+        }
+        
+        if (status == IMRS_OK)
+        {
+                StrHdl_Cnv_dynamic_ptr = &(IMRG_MM_StrHdl_Cnv_Func_Tab[Conv_Id]);
+                strcpy( StrHdl_Cnv_dynamic_ptr->Nom , Conv_Name);
+                strcpy(ptr_name , "Init");
+                sprintf(func_ptr_name,"MM_%s_%s",Conv_Name,ptr_name);
+                StrHdl_Cnv_dynamic_ptr->Init_Ptr = ( IMRT_MM_Cnv_Init  *)dlsym(handle , func_ptr_name);
+                if ((StrHdl_Cnv_dynamic_ptr->Init_Ptr == NULL) && (!cnv_is_unknown))
+                        it_is_OK = IMRD_FALSE;
+                
+                if (it_is_OK)
+                {                
+                        strcpy(ptr_name , "DeInit");
+                        sprintf(func_ptr_name,"MM_%s_%s",Conv_Name,ptr_name);
+                        StrHdl_Cnv_dynamic_ptr->DeInit_Ptr = ( IMRT_MM_Cnv_DeInit  *)dlsym(handle , func_ptr_name);
+                        if ((StrHdl_Cnv_dynamic_ptr->DeInit_Ptr == NULL) && ( !cnv_is_unknown))
+                                it_is_OK = IMRD_FALSE;
+                }
+                
+                if (it_is_OK)
+                {                
+                        strcpy(ptr_name , "Convert");
+                        sprintf(func_ptr_name,"MM_%s_%s",Conv_Name,ptr_name);                
+                        StrHdl_Cnv_dynamic_ptr->Convert_Ptr   = (IMRT_MM_Convert *)dlsym(handle , func_ptr_name);
+                        if ((StrHdl_Cnv_dynamic_ptr->Convert_Ptr == NULL) && ( !cnv_is_unknown))
+                                it_is_OK = IMRD_FALSE;
+                }
+                
+                
+                if (it_is_OK && StrHdl_Cnv_dynamic_ptr->Init_Ptr != NULL)
+                {
+                        status = StrHdl_Cnv_dynamic_ptr->Init_Ptr();
+                        if (status == IMRS_KO)
+                                IMRD_LM_LOG_ERROR_0("Initialisation convert failed" );
+                }
+                
+                if (!it_is_OK)
+                {
+                        status = IMRS_KO;
+                        IMRD_LM_LOG_ERROR_0("Pointeur null et Fonction de conversion differente de unknown" );
+                        IMRD_LM_LOG_ERROR_1("dlsym failed [%s]", dlerror());
+                }
+
+        }
+
+
+	IMRD_LM_LOG_TRACE_1(IMRD_LOG_LEVEL_VERBOSE_2 , "Initialisation conversion function demand : End with status :  (%d)" , status);
+	IMRD_LM_LOG_TRACE_0(IMRD_LOG_LEVEL_VERBOSE_2 ,  "============================================================================")
+        
+	return ( status );
+
+}
+
+
+IMRT_Status  MM_Buffer_List( IMRT_Buffer *Buffer_Ptr, char *texte)
+{
+    char         status_str[10];
+    char         flag_str[10];
+    IMRT_Fmt_Id  fmt_id;
+    IMRT_Status	 status;
+
+
+    status = IMRS_OK;
+    fmt_id = IMRD_FMT_ID_UNKNOWN;
+
+    if (Buffer_Ptr == NULL)
+    {
+    	IMRD_LM_LOG_WARNING_0("Buffer pointer NULL");
+    }
+    else
+    {
+	switch( Buffer_Ptr->Status)
+	{
+		case IMRD_BUFFER_STATUS_ALLOCATED : strcpy( status_str, "ALLOCATED"); break;
+		case IMRD_BUFFER_STATUS_FREED     : strcpy( status_str, "FREED");     break;
+		default                           : strcpy( status_str, "UNKNOWN");   break;
+	}
+	
+	switch (Buffer_Ptr->Flag)
+	{
+		case IMRD_BUFFER_FLAG_OPENED : strcpy( flag_str, "OPENED");  break;
+		case IMRD_BUFFER_FLAG_CLOSED : strcpy( flag_str, "CLOSED");  break;
+		default                      : strcpy( flag_str, "UNKNOWN"); break;
+	}
+	    
+	IMRD_LM_LOG_TRACE_2( IMRD_LOG_LEVEL_VERBOSE_1, "Buffer_List: Buffer: [%s]   Address: (0x%X)", texte, Buffer_Ptr);
+
+	if( ( status = Buffer_Format_Check( Buffer_Ptr->Fmt_Id)) == IMRS_OK)
+	{
+	    fmt_id = Buffer_Ptr->Fmt_Id;
+	}
+	else
+	{
+	    fmt_id = IMRD_FMT_ID_UNKNOWN;
+	}
+
+	IMRD_LM_LOG_TRACE_3( IMRD_LOG_LEVEL_VERBOSE_1, "Buffer_List: Appl_Id_Input: (%2d)               Appl_Id_Output: (%2d)   Dir_Id: (%2d)", Buffer_Ptr->Appl_Id_Input, Buffer_Ptr->Appl_Id_Output, Buffer_Ptr->Dir_Id);
+	IMRD_LM_LOG_TRACE_3( IMRD_LOG_LEVEL_VERBOSE_1, "Buffer_List: Fmt_Id:        (%2d) [%9s]     Msg_Id:         (%2d)", Buffer_Ptr->Fmt_Id, IMRG_MM_StrHdl_Fmt_Func_Tab[fmt_id].Nom, Buffer_Ptr->Msg_Id);
+	IMRD_LM_LOG_TRACE_4( IMRD_LOG_LEVEL_VERBOSE_1, "Buffer_List: Status:        (%2d) [%9s]   Flag:           (%2d) [%7s]", Buffer_Ptr->Status, status_str, Buffer_Ptr->Flag, flag_str);
+	IMRD_LM_LOG_TRACE_1( IMRD_LOG_LEVEL_VERBOSE_1, "Buffer_List: Format attribute:        [%s]" , Buffer_Ptr->FmtAttr_Value);
+	
+	if (IMRG_MM_StrHdl_Fmt_Func_Tab != NULL)
+	{
+		if ( IMRG_MM_StrHdl_Fmt_Func_Tab[fmt_id].Data_List_Ptr == NULL)
+		{
+		    IMRD_LM_LOG_WARNING_1( "Null Fonction List for [%s] format", IMRG_MM_StrHdl_Fmt_Func_Tab[fmt_id].Nom);
+		}
+		else
+		{
+		    status = IMRG_MM_StrHdl_Fmt_Func_Tab[Buffer_Ptr->Fmt_Id].Data_List_Ptr(Buffer_Ptr);
+		}
+	}
+    }
+
+    return ( status );
+}
+
+IMRT_Status MM_Buffer_Alloc (IMRT_Buffer **Buffer_Ptr_Ptr)
+{
+	IMRT_Buffer *buffer_Ptr;
+	IMRT_Status status;
+	char *func_name = "MM_Buffer_Alloc";
+
+	
+	status          = IMRS_OK;
+	buffer_Ptr      = (IMRT_Buffer *) malloc( sizeof(IMRT_Buffer) );
+	
+	
+	if (buffer_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Buffer pointer NULL" );
+	}
+	else
+	if (buffer_Ptr->FmtAttr_Value == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("buffer_Ptr->FmtAttr_Value NULL" );
+	}
+	else
+	if (Buffer_Ptr_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Buffer pointer NULL" );
+	}
+	else
+	{
+		*Buffer_Ptr_Ptr = buffer_Ptr;
+		buffer_Ptr->Appl_Id_Input = IMRD_APPL_ID_UNKNOWN;
+		buffer_Ptr->Appl_Id_Output = IMRD_APPL_ID_UNKNOWN;
+		buffer_Ptr->Dir_Id          = IMRD_DIR_ID_UNKNOWN;
+		buffer_Ptr->Fmt_Id             = IMRD_FMT_ID_UNKNOWN;
+		strcpy(buffer_Ptr->FmtAttr_Value , IMRD_FMTATTR_NAME_UNKNOWN);
+		buffer_Ptr->Msg_Id             = IMRD_MSG_ID_UNKNOWN;
+		buffer_Ptr->Status             = IMRD_BUFFER_STATUS_UNKNOWN;
+		buffer_Ptr->Flag               = IMRD_BUFFER_FLAG_UNKNOWN;
+		buffer_Ptr->Data_Buf_Ptr       = NULL;
+		buffer_Ptr->Data_Tmp_Ptr      = NULL;
+		buffer_Ptr->Data_Tmp_Changed  = IMRD_FALSE;
+		buffer_Ptr->Data_Buf_Size      = 0;
+		buffer_Ptr->Data_Buf_Len       = 0;
+	}                       
+
+	return ( status );
+}     
+
+IMRT_Status Buffer_Data_Free( IMRT_Buffer *Buffer_Ptr)
+{
+	IMRT_Status status;
+	char *func_name = "Buffer_Data_Free";
+	
+	status = IMRS_OK;
+
+	/* recherche du handler */
+	if (Buffer_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Buffer pointer NULL" );
+	}
+	else
+	if (IMRG_MM_StrHdl_Fmt_Func_Tab == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Format tab pointer NULL" );
+	}
+	else
+	{
+		status = Buffer_Format_Check( Buffer_Ptr->Fmt_Id );
+	
+		if (status == IMRS_OK)
+		{
+			if (IMRG_MM_StrHdl_Fmt_Func_Tab[Buffer_Ptr->Fmt_Id].Data_Free_Ptr == NULL)
+			{
+				status = IMRS_KO;
+				IMRD_LM_LOG_ERROR_1("fonction Data_Free = NULL pour format %s" ,
+							IMRG_MM_StrHdl_Fmt_Func_Tab[Buffer_Ptr->Fmt_Id].Nom);
+			}
+			else
+			{
+				status = IMRG_MM_StrHdl_Fmt_Func_Tab[Buffer_Ptr->Fmt_Id].Data_Free_Ptr(Buffer_Ptr);
+			}
+		}
+	}
+
+
+	return ( status );
+}
+
+IMRT_Status MM_Buffer_Free (IMRT_Buffer **Buffer_Ptr_Ptr)
+{
+	IMRT_Status status;
+	char *func_name = "MM_Buffer_Free";
+
+
+	status = IMRS_OK;
+	
+	if (*Buffer_Ptr_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Buffer pointer NULL" );
+	}
+	else	
+	{
+		/* il y a des donnees dans Data_Buf_Ptr ou dans Data_Tmp_Ptr */
+		if ( ((*Buffer_Ptr_Ptr)->Status == IMRD_BUFFER_STATUS_ALLOCATED) ||
+		     ((*Buffer_Ptr_Ptr)->Flag   == IMRD_BUFFER_FLAG_OPENED) )
+		{
+			status = Buffer_Data_Free( *Buffer_Ptr_Ptr );
+		}
+		free(*Buffer_Ptr_Ptr);
+		*Buffer_Ptr_Ptr = NULL;
+	}
+
+	return ( status ) ;
+}     
+
+IMRT_Status MM_Buffer_Clear (IMRT_Buffer *Buffer_Ptr)
+{
+	IMRT_Status status;
+	char *func_name = "MM_Buffer_Clear";
+
+	
+	status = IMRS_OK;
+	
+	if (Buffer_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Buffer pointer NULL" );
+	}
+	else
+	{
+		/* il y a des donnees dans Data_Buf_Ptr ou dans Data_Tmp_Ptr */
+		if ( (Buffer_Ptr->Status == IMRD_BUFFER_STATUS_ALLOCATED) ||
+		     (Buffer_Ptr->Flag   == IMRD_BUFFER_FLAG_OPENED) )
+		{
+			status = Buffer_Data_Free( Buffer_Ptr);
+		}
+		if (status == IMRS_OK)
+		{
+			Buffer_Ptr->Fmt_Id             = IMRD_FMT_ID_UNKNOWN;
+			Buffer_Ptr->Msg_Id             = IMRD_MSG_ID_UNKNOWN;
+			Buffer_Ptr->Status             = IMRD_BUFFER_STATUS_UNKNOWN;
+			Buffer_Ptr->Flag               = IMRD_BUFFER_FLAG_UNKNOWN;
+		}
+	}
+
+	return ( status );
+}     
+
+IMRT_Status Buffer_Format_Check( IMRT_Fmt_Id Format )
+{
+	IMRT_Status status;
+	char *func_name = "Buffer_Format_Check";
+	
+	status = IMRS_OK;
+
+	if ( (Format >= 0) && (Format < IMRG_Taille_Fmt_Max))
+		status =IMRS_OK;
+        else
+        {
+   	        status = IMRS_KO;
+   	        IMRD_LM_LOG_ERROR_1("Format %d incorrect" , Format );
+        }
+
+	return ( status );
+}
+
+IMRT_Status MM_Buffer_Ident_Update( IMRT_Buffer *Buffer_Ptr, 
+                                    IMRT_Fmt_Id Format,
+                                    IMRT_FmtAttr_Value Fmt_Attr ,
+                                    IMRT_Msg_Id Type)
+{
+	IMRT_Status status;
+	char *func_name = "MM_Buffer_Ident_Update";
+	
+	status = IMRS_OK;
+
+	
+	if (Buffer_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Buffer pointer NULL" );
+	}
+	else
+	if (Buffer_Ptr->FmtAttr_Value == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Buffer_Ptr->FmtAttr_Value NULL" );
+	}
+	if (Fmt_Attr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("FmtAttr NULL" );
+	}
+	else
+	{
+		status = Buffer_Format_Check( Format );
+		if (status == IMRS_OK)
+		{
+			/* si le buffer est ouvert le fermer avant de changer de format */
+			if (  (Buffer_Ptr->Flag   == IMRD_BUFFER_FLAG_OPENED)
+			      && ( (Buffer_Ptr->Fmt_Id != Format) || 
+				   (strcmp(Buffer_Ptr->FmtAttr_Value,Fmt_Attr) !=0) ) )
+			{
+			   status = MM_Buffer_Close(Buffer_Ptr);
+			}
+		}
+		if (status == IMRS_OK)
+		{
+			Buffer_Ptr->Fmt_Id = Format;
+			strcpy(Buffer_Ptr->FmtAttr_Value , Fmt_Attr);
+			Buffer_Ptr->Msg_Id = Type;
+		}
+	}
+
+	return ( status );
+}
+
+IMRT_Status MM_Buffer_Ident(IMRT_Msg_Id Msg_Id_Ident , IMRT_Buffer *Buffer_Ptr)
+{
+	IMRT_Status status;
+	char *func_name = "MM_Buffer_Ident";
+        
+        status = IMRS_OK;
+        
+        if (Buffer_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Buffer pointer NULL" );
+	}
+	else
+    {
+       	if (IMRG_MM_StrHdl_Fmt_Func_Tab == NULL)
+       	{
+			status = IMRS_KO;
+			IMRD_LM_LOG_ERROR_0("Format tab pointer NULL" );        		
+       	}
+       	else
+       	{
+			if (Buffer_Ptr->Flag != IMRD_BUFFER_FLAG_OPENED)
+			{
+	        	status = IMRS_KO;
+	        	IMRD_LM_LOG_ERROR_0("Buffer not open" );
+			}
+			else
+			{
+				status = Buffer_Format_Check(Buffer_Ptr->Fmt_Id);
+				if (status == IMRS_OK)
+				{
+					if (IMRG_MM_StrHdl_Fmt_Func_Tab[Buffer_Ptr->Fmt_Id].Ident_Ptr == NULL)
+					{
+						IMRD_LM_LOG_TRACE_1(IMRD_LOG_LEVEL_VERBOSE_1 , "fonction Ident = NULL pour format %s" , 
+								IMRG_MM_StrHdl_Fmt_Func_Tab[Buffer_Ptr->Fmt_Id].Nom);
+					}
+					else
+					{	
+						status = IMRG_MM_StrHdl_Fmt_Func_Tab[Buffer_Ptr->Fmt_Id].Ident_Ptr(&Msg_Id_Ident, Buffer_Ptr);
+					}      
+		    	}
+		       	if (status == IMRS_OK)
+		       	{
+		   	        Buffer_Ptr->Msg_Id = Msg_Id_Ident;
+		       	}
+			}
+		}
+	}
+        
+		
+	return ( status );
+        
+}
+
+
+IMRT_Status MM_Buffer_Open( IMRT_Buffer *Buffer_Ptr)
+{
+	IMRT_Fmt_Id   format_temp;
+	short indice;
+	IMRT_Status status;
+	char *func_name = "MM_Buffer_Open";
+	
+	
+	status = IMRS_OK;
+	indice = 0;
+	format_temp = IMRD_FMT_ID_UNKNOWN;
+	
+	if (Buffer_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Buffer pointer NULL" );
+	}
+	else
+	{
+		format_temp = Buffer_Ptr->Fmt_Id;
+		if (Buffer_Ptr->Flag !=IMRD_BUFFER_FLAG_OPENED)
+		{
+					
+			/* controle validite du format */
+			status = Buffer_Format_Check( format_temp );
+			
+			if (IMRG_MM_StrHdl_Fmt_Func_Tab == NULL)
+			{
+				status = IMRS_KO;
+				IMRD_LM_LOG_ERROR_0("Format tab pointer NULL" );
+			}
+			else
+			{
+				/* format non identifie */
+				if ( format_temp == IMRD_FMT_ID_UNKNOWN )
+				{
+					if ( Buffer_Ptr->Status != IMRD_BUFFER_STATUS_ALLOCATED )
+					{
+						status = IMRS_KO;
+						IMRD_LM_LOG_ERROR_0("Buffer not allocated" );
+					}
+					else
+					{
+						indice = 0;
+						status = IMRS_BAD_FORMAT;
+						while (  (status == IMRS_BAD_FORMAT) 
+						      && (indice < IMRG_Taille_Fmt_Max) )
+						{
+							if (IMRG_MM_StrHdl_Fmt_Func_Tab[indice].Open_Ptr == NULL)
+							{
+								IMRD_LM_LOG_TRACE_1(IMRD_LOG_LEVEL_VERBOSE_1 , "fonction Open = NULL pour format %s" ,
+								             IMRG_MM_StrHdl_Fmt_Func_Tab[indice].Nom);
+							}
+							else
+							{	format_temp = indice;
+								status = IMRG_MM_StrHdl_Fmt_Func_Tab[indice].Open_Ptr( Buffer_Ptr);
+							}
+							indice++;
+						}
+					}
+				}
+				/* format identifie */
+				else
+				{
+					if (status == IMRS_OK)
+					{
+						if (IMRG_MM_StrHdl_Fmt_Func_Tab[Buffer_Ptr->Fmt_Id].Open_Ptr == NULL)
+						{
+							status = IMRS_KO;
+							IMRD_LM_LOG_ERROR_1("fonction Open = NULL pour format %s" ,
+						          IMRG_MM_StrHdl_Fmt_Func_Tab[Buffer_Ptr->Fmt_Id].Nom);
+						}
+						else
+						{
+							status = IMRG_MM_StrHdl_Fmt_Func_Tab[Buffer_Ptr->Fmt_Id].Open_Ptr( Buffer_Ptr);
+						}
+					}
+				}
+			}
+	        	
+	        	if (status == IMRS_OK)
+	        	{
+	        		Buffer_Ptr->Flag = IMRD_BUFFER_FLAG_OPENED;
+	        		if (Buffer_Ptr->Fmt_Id != format_temp)
+	        		        Buffer_Ptr->Fmt_Id = format_temp;
+	        		
+	        	}
+	        }
+        }
+
+		
+	return ( status );
+}
+
+IMRT_Status MM_Buffer_Close(IMRT_Buffer *Buffer_Ptr)
+{
+	IMRT_Status status;
+	char *func_name = "MM_Buffer_Close";
+	
+	
+	status = IMRS_OK;
+
+	if (Buffer_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Buffer pointer NULL" );
+	}
+	else
+	{
+		if (Buffer_Ptr->Flag !=IMRD_BUFFER_FLAG_CLOSED)
+		{
+			status = Buffer_Format_Check( Buffer_Ptr->Fmt_Id );
+			if (status == IMRS_OK)
+			{
+				if (Buffer_Ptr->Flag == IMRD_BUFFER_FLAG_OPENED)
+				{
+					if (IMRG_MM_StrHdl_Fmt_Func_Tab == NULL)
+					{
+						status = IMRS_KO;
+						IMRD_LM_LOG_ERROR_0("Format tab pointer NULL" );
+					}
+					else
+					{
+						if (IMRG_MM_StrHdl_Fmt_Func_Tab[Buffer_Ptr->Fmt_Id].Close_Ptr == NULL)
+						{
+							status = IMRS_KO;
+							IMRD_LM_LOG_ERROR_1("fonction Close = NULL pour format %s" ,
+								          IMRG_MM_StrHdl_Fmt_Func_Tab[Buffer_Ptr->Fmt_Id].Nom);
+						}
+						else
+						{
+							status = IMRG_MM_StrHdl_Fmt_Func_Tab[Buffer_Ptr->Fmt_Id].Close_Ptr(Buffer_Ptr);
+						}
+					}
+				}
+			}
+			if (status == IMRS_OK)
+			{
+				Buffer_Ptr->Flag = IMRD_BUFFER_FLAG_CLOSED;
+			}
+		}
+	}
+
+	return ( status );
+}
+
+/* La fonction suivante n'est pas implementee pour le moment */
+/* Le nom des applications n'est connue que du static data manager */
+IMRT_Status	Buffer_Application_Check( IMRT_Appl_Id Application )
+{
+	IMRT_Status status;
+	char *func_name = "Buffer_Application_Check";
+	
+	
+	status =IMRS_OK;
+	
+
+           	
+	return ( status );
+}
+
+IMRT_Status	Buffer_Direction_Check( IMRT_Dir_Id Direction )
+{
+	IMRT_Status status;
+	char *func_name = "Buffer_Direction_Check";
+	
+
+	if ((Direction == IMRD_DIR_ID_UNKNOWN) ||
+	    (Direction == IMRD_DIR_ID_IN     ) ||
+	    (Direction == IMRD_DIR_ID_OUT    ) )
+		status =IMRS_OK;
+        else
+        {
+           	status = IMRS_KO;
+           	IMRD_LM_LOG_ERROR_1("Incorrect direction %d" , Direction );
+        }
+
+
+	return ( status );
+}
+
+IMRT_Status	Buffer_Statut_Check( IMRT_Buffer_Status Statut )
+{
+	IMRT_Status status;
+	char *func_name = "Buffer_Statut_Check";
+	
+
+	if ((Statut == IMRD_BUFFER_STATUS_UNKNOWN  ) ||
+	    (Statut == IMRD_BUFFER_STATUS_ALLOCATED) ||
+	    (Statut == IMRD_BUFFER_STATUS_FREED    ) )
+		status =IMRS_OK;
+        else
+        {
+           	status = IMRS_KO;
+           	IMRD_LM_LOG_ERROR_1("Incorrect status %d" , Statut );
+        }
+
+	return ( status );
+}
+
+IMRT_Status	Buffer_Etat_Check( IMRT_Buffer_Flag Flag )
+{
+	IMRT_Status status;
+	char *func_name = "Buffer_Etat_Check";
+	
+
+	if ((Flag == IMRD_BUFFER_FLAG_UNKNOWN) ||
+	    (Flag == IMRD_BUFFER_FLAG_OPENED ) ||
+	    (Flag == IMRD_BUFFER_FLAG_CLOSED ) )
+		status =IMRS_OK;
+        else
+        {
+           	status = IMRS_KO;
+           	IMRD_LM_LOG_ERROR_1("Incorrect Flag %d" , Flag )
+        }
+
+	return ( status );
+}
+
+IMRT_Status	MM_Buffer_Check( IMRT_Buffer	*Buffer_Ptr)
+{
+	IMRT_Status status;
+	char *func_name = "MM_Buffer_Check";
+	
+	status = IMRS_OK;
+
+	if (Buffer_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Buffer pointer NULL" );
+	}
+	else
+	{
+		if ( ( Buffer_Application_Check(Buffer_Ptr->Appl_Id_Input  ) == IMRS_OK ) &&
+		     ( Buffer_Application_Check(Buffer_Ptr->Appl_Id_Output ) == IMRS_OK ) &&
+		     ( Buffer_Direction_Check  (Buffer_Ptr->Dir_Id          ) == IMRS_OK ) &&
+		     ( Buffer_Format_Check     (Buffer_Ptr->Fmt_Id             ) == IMRS_OK ) &&
+		     ( Buffer_Statut_Check     (Buffer_Ptr->Status             ) == IMRS_OK ) &&
+		     ( Buffer_Etat_Check       (Buffer_Ptr->Flag               ) == IMRS_OK ) ) 
+			status = IMRS_OK;
+	        else
+	        {
+	           	status = IMRS_KO;
+	           	IMRD_LM_LOG_ERROR_0("Buffer check failed" );
+	        }
+        }
+
+	return ( status );
+}
+
+IMRT_Status MM_Buffer_Copy( IMRT_Buffer *Output_Buffer_Ptr, IMRT_Buffer *Input_Buffer_Ptr)
+{
+	IMRT_Status status;
+	char *func_name = "MM_Buffer_Copy";
+	
+
+	status  = IMRS_OK;
+	
+	
+	if (Input_Buffer_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Input buffer pointer NULL" );
+	}
+	else
+	if (Output_Buffer_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Output buffer pointer NULL" );
+	}
+	else
+	if (IMRG_MM_StrHdl_Fmt_Func_Tab == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Format tab pointer NULL" );
+	}
+	else
+	{
+		/* buffer non identifie => demande identification */	
+		if ( (Input_Buffer_Ptr->Fmt_Id == IMRD_FMT_ID_UNKNOWN) || (Input_Buffer_Ptr->Msg_Id == IMRD_MSG_ID_UNKNOWN) )
+		{
+		   status = MM_Buffer_Open( Input_Buffer_Ptr );
+		}
+		
+		/* s'assurer que les donnees sont dans Data_Buf */
+		if ( status  == IMRS_OK )
+		{
+			if (IMRG_MM_StrHdl_Fmt_Func_Tab[Input_Buffer_Ptr->Fmt_Id].Flush_Ptr == NULL)
+			{
+				status = IMRS_KO;
+				IMRD_LM_LOG_ERROR_1("fonction Flush = NULL pour format %s" , 
+					    IMRG_MM_StrHdl_Fmt_Func_Tab[Input_Buffer_Ptr->Fmt_Id].Nom);
+			}
+			else
+			{
+				status = IMRG_MM_StrHdl_Fmt_Func_Tab[Input_Buffer_Ptr->Fmt_Id].Flush_Ptr(Input_Buffer_Ptr);
+			}
+		}
+		
+		/* reinitialiser le buffer destinataire */
+		if (status == IMRS_OK)
+		{
+			status = MM_Buffer_Clear( Output_Buffer_Ptr );
+		}
+		
+		/* mise a jour du format et du type du buffer destinataire */
+		if (status == IMRS_OK)
+		{
+			status = MM_Buffer_Ident_Update(Output_Buffer_Ptr, 
+			                                Input_Buffer_Ptr->Fmt_Id, 
+			                                Input_Buffer_Ptr->FmtAttr_Value, 
+			                                Input_Buffer_Ptr->Msg_Id);
+		}
+	
+		/* mise a jour des applications et direction du buffer destinataire */
+		if (status == IMRS_OK)
+		{
+			Output_Buffer_Ptr->Appl_Id_Input = Input_Buffer_Ptr->Appl_Id_Input ;
+			Output_Buffer_Ptr->Appl_Id_Output = Input_Buffer_Ptr->Appl_Id_Output ;
+			Output_Buffer_Ptr->Dir_Id = Input_Buffer_Ptr->Dir_Id ;
+		}
+		
+		
+		/* mise a jour de l'attribut du format du buffer destinataire */
+		if (status == IMRS_OK)
+		{
+			strcpy(Output_Buffer_Ptr->FmtAttr_Value , Input_Buffer_Ptr->FmtAttr_Value) ;
+		}
+	
+		
+		/* copie des donnees du buffer source dans le buffer destinataire */
+		if (status == IMRS_OK)
+		{
+			if (IMRG_MM_StrHdl_Fmt_Func_Tab[Input_Buffer_Ptr->Fmt_Id].Copy_Ptr == NULL)
+			{
+				status = IMRS_KO;
+				IMRD_LM_LOG_ERROR_1("fonction Copy = NULL pour format %s" , 
+					    IMRG_MM_StrHdl_Fmt_Func_Tab[Input_Buffer_Ptr->Fmt_Id].Nom);
+			}
+			else
+			{
+				status = IMRG_MM_StrHdl_Fmt_Func_Tab[Input_Buffer_Ptr->Fmt_Id].Copy_Ptr(Output_Buffer_Ptr,
+				                                                                Input_Buffer_Ptr);
+			}
+		}
+		if (status == IMRS_OK)
+		{
+			Output_Buffer_Ptr->Flag = IMRD_BUFFER_FLAG_CLOSED;
+		}
+	}
+
+
+	return ( status );
+}
+
+IMRT_Status MM_Buffer_Map(IMRT_Buffer *Output_Buffer_Ptr, 
+                          IMRT_Buffer *Input_Buffer_Ptr, 
+                          IMRT_MsgMap *MsgMap_Ptr)
+{
+	IMRT_Status status;
+	char *func_name = "MM_Buffer_Map";
+	
+	status = IMRS_OK;
+	
+	if (Input_Buffer_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Input buffer pointer NULL" );
+	}
+	else
+	if (Output_Buffer_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Output buffer pointer NULL" );
+	}
+	else
+	{
+		if ( ( Input_Buffer_Ptr->Flag  != IMRD_BUFFER_FLAG_OPENED ) ||
+		     ( Output_Buffer_Ptr->Flag != IMRD_BUFFER_FLAG_OPENED ) )
+		{
+			status = IMRS_KO;
+			IMRD_LM_LOG_ERROR_0("Buffer input or output not open" );
+		}
+		else
+		{
+			IMRG_Input_Buffer_Ptr  = Input_Buffer_Ptr;
+			IMRG_Output_Buffer_Ptr = Output_Buffer_Ptr;
+			status = IMR_SDM_MsgMap_Proceed( MsgMap_Ptr, IMR_MM_Buffer_FieldMap);
+			if (status != IMRS_OK)
+				IMRD_LM_LOG_ERROR_1("MsgMap proceed ended with status (%d)" , status);
+			IMRG_Input_Buffer_Ptr  = NULL;
+			IMRG_Output_Buffer_Ptr = NULL;
+		}
+	}
+
+
+	return ( status );
+}
+
+IMRT_Status IMR_MM_Buffer_FieldMap( IMRT_Field *Field_Output_Ptr , IMRT_Field *Field_Input_Ptr )
+{
+	IMRT_Buffer      *buffer_ptr;
+	IMRT_Buffer_Data *data_In_ptr;
+	IMRT_Buffer_Data *data_Out_ptr;
+	IMRT_Status status;
+	size_t field_len;
+	IMRT_Boolean cnv_OK;
+	char *func_name = "IMR_MM_Buffer_FieldMap";
+	
+	IMRD_LM_LOG_TRACE_0(IMRD_LOG_LEVEL_VERBOSE_1 ,  "============================================================================")
+	IMRD_LM_LOG_TRACE_0(IMRD_LOG_LEVEL_VERBOSE_1 , "Field map demand : Begin");
+	IMRD_LM_LOG_TRACE_2(IMRD_LOG_LEVEL_VERBOSE_1 , "Field Input name : (%s) Field Output name :  (%s)" , Field_Input_Ptr->Name , Field_Output_Ptr->Name);	
+
+	status  = IMRS_OK;
+	cnv_OK =IMRD_TRUE;
+	data_In_ptr   = NULL;
+	data_Out_ptr   = NULL;
+	buffer_ptr = NULL;
+	field_len = 0L;
+	
+	if (IMRG_Input_Buffer_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Input buffer pointer NULL" );
+	}
+	else
+	if (IMRG_Output_Buffer_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Output buffer pointer NULL" );
+	}
+	else
+	if (IMRG_MM_StrHdl_Fmt_Func_Tab == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Format tab pointer NULL" );
+	}
+	else
+	{
+		buffer_ptr = IMRG_Input_Buffer_Ptr;
+		if (IMRG_MM_StrHdl_Fmt_Func_Tab[buffer_ptr->Fmt_Id].Get_Ptr == NULL)
+		{
+			status = IMRS_KO;
+			IMRD_LM_LOG_ERROR_1("fonction Get = NULL pour format %s" , 
+					 IMRG_MM_StrHdl_Fmt_Func_Tab[buffer_ptr->Fmt_Id].Nom);
+		}
+		else
+		{
+			status = IMRG_MM_StrHdl_Fmt_Func_Tab[buffer_ptr->Fmt_Id].Get_Ptr(&data_In_ptr, 
+			                                                         Field_Input_Ptr,
+			                                                         buffer_ptr ,
+			                                                         &field_len );
+		        IMRD_LM_LOG_TRACE_2(IMRD_LOG_LEVEL_VERBOSE_2 , "Data and len after get [%s] : (%ld)",data_In_ptr,field_len);	
+		}
+		
+	
+		if (status == IMRS_OK)
+		{
+			buffer_ptr = IMRG_Output_Buffer_Ptr;
+			if (IMRG_MM_StrHdl_Fmt_Func_Tab[buffer_ptr->Fmt_Id].Cnv_Ptr == NULL)
+			{
+				cnv_OK = IMRD_FALSE;
+				IMRD_LM_LOG_WARNING_1("fonction de convertion nulle pour handler de format %s" , 
+					    IMRG_MM_StrHdl_Fmt_Func_Tab[buffer_ptr->Fmt_Id].Nom);
+			}
+			else
+			{
+				status = IMRG_MM_StrHdl_Fmt_Func_Tab[buffer_ptr->Fmt_Id].Cnv_Ptr(&data_Out_ptr,
+				                                                         data_In_ptr, 
+				                                                         Field_Output_Ptr,
+				                                                         &field_len,
+				                                                         IMRG_MM_StrHdl_Cnv_Func_Tab);
+		               IMRD_LM_LOG_TRACE_2(IMRD_LOG_LEVEL_VERBOSE_2 , "Data and len after convert [%s] : (%ld)",data_Out_ptr,field_len);
+			}
+		}
+	
+		if (status == IMRS_OK)
+		{
+			if (IMRG_MM_StrHdl_Fmt_Func_Tab[buffer_ptr->Fmt_Id].Put_Ptr == NULL)
+			{
+				status = IMRS_KO;
+				IMRD_LM_LOG_ERROR_1("fonction Put = NULL pour format %s" , 
+					    IMRG_MM_StrHdl_Fmt_Func_Tab[buffer_ptr->Fmt_Id].Nom);
+			        if (cnv_OK)
+			        {
+			                free(data_Out_ptr);
+			                IMRD_LM_LOG_TRACE_0(IMRD_LOG_LEVEL_VERBOSE_2 , "liberation du data_Out_ptr" );
+			        }
+			        else
+			        {
+			                free(data_In_ptr);
+			                IMRD_LM_LOG_TRACE_0(IMRD_LOG_LEVEL_VERBOSE_2 , "liberation du data_In_ptr" );
+			        }
+			}
+			else
+			{
+	       		        if (cnv_OK)
+	       		        {
+	        			status = IMRG_MM_StrHdl_Fmt_Func_Tab[buffer_ptr->Fmt_Id].Put_Ptr(data_Out_ptr, 
+				                                                                        Field_Output_Ptr,
+				                                                                        buffer_ptr,
+				                                                                        field_len);
+	                        }
+	                        else
+	                        {
+	        			status = IMRG_MM_StrHdl_Fmt_Func_Tab[buffer_ptr->Fmt_Id].Put_Ptr(data_In_ptr, 
+				                                                                        Field_Output_Ptr,
+				                                                                        buffer_ptr,
+				                                                                        field_len);
+	                        }
+			}
+		}
+	}
+
+	MM_Buffer_List( buffer_ptr, " Buffer after put");
+	IMRD_LM_LOG_TRACE_1(IMRD_LOG_LEVEL_VERBOSE_2 , "Field map demand : End with status :  (%d)" , status);
+	IMRD_LM_LOG_TRACE_0(IMRD_LOG_LEVEL_VERBOSE_2 ,  "============================================================================")
+
+	return ( status );
+}
diff --git a/src/libmapping_mng/src/buffer_mng.h b/src/libmapping_mng/src/buffer_mng.h
new file mode 100644
index 0000000..4caec3c
--- /dev/null
+++ b/src/libmapping_mng/src/buffer_mng.h
@@ -0,0 +1,175 @@
+/*----------------------------------------------------------------------------*/
+/* File: buffer_mng.h							      */
+/*----------------------------------------------------------------------------*/
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#ifndef _BUFFER_MNG_H_
+#define _BUFFER_MNG_H_
+
+/*----------------------------------------------------------------------------*/
+/* Global Include                                                             */
+/*----------------------------------------------------------------------------*/
+
+#include <dlfcn.h>
+#include "libmapping_mng.h"
+
+/*----------------------------------------------------------------------------*/
+/* Local Includes                                                             */
+/*----------------------------------------------------------------------------*/
+
+#ifdef _BUFFER_MNG_C_
+
+#   include "fmt_hdl_fixed.h"
+#   include "fmt_hdl_xml.h"
+
+#   ifdef TUX_SUPPORT
+#       include "fmt_hdl_fml.h"
+#   endif /* TUX_SUPPORT */
+
+#    include "cnv_hdl_pad_right.h"
+#    include "cnv_hdl_pad_left.h"
+#    include "cnv_hdl_strip_right.h"
+#    include "cnv_hdl_strip_left.h"
+#    include "cnv_hdl_cut_right.h"
+#    include "cnv_hdl_strip_num.h"
+
+#endif
+
+/*----------------------------------------------------------------------------*/
+/* Local definition                                                           */
+/*----------------------------------------------------------------------------*/
+
+#ifdef _BUFFER_MNG_C_
+
+
+        typedef IMRT_Status  (IMRT_MM_Fmt_Hdl_Init)( void );
+        typedef IMRT_Status  (IMRT_MM_Fmt_Hdl_DeInit)( void );
+        typedef IMRT_Status  (IMRT_MM_Fmt_Hdl_Data_Free)( IMRT_Buffer * );
+        typedef IMRT_Status  (IMRT_MM_Fmt_Hdl_Ident)( IMRT_Msg_Id *, IMRT_Buffer * );
+        typedef IMRT_Status  (IMRT_MM_Fmt_Hdl_Open)( IMRT_Buffer * );
+        typedef IMRT_Status  (IMRT_MM_Fmt_Hdl_Close)( IMRT_Buffer * );
+        typedef IMRT_Status  (IMRT_MM_Fmt_Hdl_Data_List)( IMRT_Buffer * );
+        typedef IMRT_Status  (IMRT_MM_Fmt_Hdl_Copy)( IMRT_Buffer * , IMRT_Buffer * );
+        typedef IMRT_Status  (IMRT_MM_Fmt_Hdl_Flush)( IMRT_Buffer * );
+        typedef IMRT_Status  (IMRT_MM_Fmt_Hdl_Get)( IMRT_Buffer_Data ** , IMRT_Field * , IMRT_Buffer * , size_t * );
+        typedef IMRT_Status  (IMRT_MM_Fmt_Hdl_Cnv)( IMRT_Buffer_Data ** , IMRT_Buffer_Data * , IMRT_Field * , size_t *, IMRT_StrHdl_Cnv_Func * );
+        typedef IMRT_Status  (IMRT_MM_Fmt_Hdl_Put)( IMRT_Buffer_Data * , IMRT_Field * , IMRT_Buffer * , size_t );
+
+    typedef struct IMRT_StrHdl_Fmt_Func
+	
+	{   IMRT_Fmt_Name        	Nom;
+	    IMRT_MM_Fmt_Hdl_Init	*Init_Ptr;
+	    IMRT_MM_Fmt_Hdl_DeInit	*DeInit_Ptr;
+	    IMRT_MM_Fmt_Hdl_Data_Free	*Data_Free_Ptr;
+	    IMRT_MM_Fmt_Hdl_Ident	*Ident_Ptr;
+	    IMRT_MM_Fmt_Hdl_Open	*Open_Ptr;
+	    IMRT_MM_Fmt_Hdl_Close	*Close_Ptr;
+	    IMRT_MM_Fmt_Hdl_Data_List	*Data_List_Ptr;
+	    IMRT_MM_Fmt_Hdl_Copy	*Copy_Ptr;
+	    IMRT_MM_Fmt_Hdl_Flush	*Flush_Ptr;
+	    IMRT_MM_Fmt_Hdl_Get	        *Get_Ptr;
+	    IMRT_MM_Fmt_Hdl_Cnv	        *Cnv_Ptr;
+	    IMRT_MM_Fmt_Hdl_Put	        *Put_Ptr;
+	    
+	} IMRT_StrHdl_Fmt_Func;
+
+		
+
+
+#endif
+
+/*----------------------------------------------------------------------------*/
+/*	Global Variables						      */
+/*----------------------------------------------------------------------------*/
+
+#ifdef _BUFFER_MNG_C_
+
+        void                    *handle;
+	IMRT_Buffer             *IMRG_Input_Buffer_Ptr;
+	IMRT_Buffer             *IMRG_Output_Buffer_Ptr;
+
+        
+	IMRT_StrHdl_Fmt_Func    *IMRG_MM_StrHdl_Fmt_Func_Tab;
+	IMRT_Fmt_Id             IMRG_Taille_Fmt_Max;
+
+	IMRT_Cnv_Id             IMRG_Taille_Cnv_Max;     
+
+
+#endif
+
+
+
+/*----------------------------------------------------------------------------*/
+/*	Prototypes																							 */
+/*----------------------------------------------------------------------------*/
+
+#ifdef _BUFFER_MNG_C_
+
+	IMRT_Status	MM_Buffer_Init	        ( void );
+	IMRT_Status	MM_Buffer_DeInit	( void );		
+	IMRT_Status     IMR_MM_Fmt_Add          ( IMRT_Fmt_Id , IMRT_Fmt_Name , IMRT_Fmt_Id );
+        IMRT_Status     IMR_MM_Cnv_Add          ( IMRT_Cnv_Id , IMRT_Cnv_Name , IMRT_Cnv_Id ); 
+	IMRT_Status	MM_Buffer_List		( IMRT_Buffer * , char * );
+	IMRT_Status	MM_Buffer_Alloc		( IMRT_Buffer ** );
+	IMRT_Status	MM_Buffer_Free 		( IMRT_Buffer ** );
+	IMRT_Status     MM_Buffer_Clear		( IMRT_Buffer * );
+        IMRT_Status     MM_Buffer_Ident         ( IMRT_Msg_Id , IMRT_Buffer *);
+	IMRT_Status     MM_Buffer_Open		( IMRT_Buffer * );
+        IMRT_Status     MM_Buffer_Close		( IMRT_Buffer * );
+	IMRT_Status     MM_Buffer_Copy		( IMRT_Buffer * , IMRT_Buffer * );
+	IMRT_Status     MM_Buffer_Map		( IMRT_Buffer * , IMRT_Buffer * , IMRT_MsgMap * );
+	IMRT_Status     MM_Buffer_Ident_Update	( IMRT_Buffer * , IMRT_Fmt_Id , IMRT_FmtAttr_Value  , IMRT_Msg_Id );
+	IMRT_Status	Buffer_Application_Check( IMRT_Appl_Id );
+	IMRT_Status	Buffer_Direction_Check	( IMRT_Dir_Id );
+	IMRT_Status     Buffer_Format_Check	( IMRT_Fmt_Id );
+	IMRT_Status	Buffer_Statut_Check	( IMRT_Buffer_Status );
+	IMRT_Status	Buffer_Etat_Check	( IMRT_Buffer_Flag );
+	IMRT_Status	MM_Buffer_Check		( IMRT_Buffer * );
+	IMRT_Status     Buffer_Data_Free 	( IMRT_Buffer * );
+	IMRT_Status     IMR_MM_Buffer_FieldMap	( IMRT_Field * , IMRT_Field * );
+		
+#else
+
+	extern IMRT_Status	MM_Buffer_Init	        ( void );
+	extern IMRT_Status	MM_Buffer_DeInit	( void );
+	extern IMRT_Status	MM_Buffer_List		( IMRT_Buffer * , char * );
+	extern IMRT_Status	MM_Buffer_Alloc		( IMRT_Buffer ** );
+	extern IMRT_Status	MM_Buffer_Free 		( IMRT_Buffer ** );
+	extern IMRT_Status 	MM_Buffer_Clear		( IMRT_Buffer * );
+	extern IMRT_Status      MM_Buffer_Ident         ( IMRT_Msg_Id , IMRT_Buffer *);
+	extern IMRT_Status 	MM_Buffer_Open		( IMRT_Buffer * );
+	extern IMRT_Status	MM_Buffer_Close		( IMRT_Buffer * );
+	extern IMRT_Status	MM_Buffer_Check		( IMRT_Buffer * );
+	extern IMRT_Status 	MM_Buffer_Copy		( IMRT_Buffer * , IMRT_Buffer * );
+	extern IMRT_Status 	MM_Buffer_Map		( IMRT_Buffer * , IMRT_Buffer * , IMRT_MsgMap * );
+	extern IMRT_Status      MM_Buffer_Ident_Update	( IMRT_Buffer * , IMRT_Fmt_Id , IMRT_FmtAttr_Value , IMRT_Msg_Id );
+
+#endif
+
+
+/*----------------------------------------------------------------------------*/
+
+#endif                                   
diff --git a/src/libmapping_mng/src/cnv_hdl_cut_right.c b/src/libmapping_mng/src/cnv_hdl_cut_right.c
new file mode 100644
index 0000000..5dd9161
--- /dev/null
+++ b/src/libmapping_mng/src/cnv_hdl_cut_right.c
@@ -0,0 +1,113 @@
+/*----------------------------------------------------------------------------*/
+/* File: cnv_hdl_cut_right.c    				         	      */
+/*----------------------------------------------------------------------------*/
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#define _LIBMAPPING_MNG_
+#define _CNV_HANDLER_CUT_RIGHT_C_
+
+#include "cnv_hdl_cut_right.h" 
+
+IMRT_Status	MM_Cut_Right_Init()
+{
+	return (IMRS_OK);
+}
+
+IMRT_Status	MM_Cut_Right_DeInit()
+{
+
+	return (IMRS_OK);
+}
+
+IMRT_Status	MM_Cut_Right_Convert(IMRT_Buffer_Data *Data_Out_Ptr , IMRT_Buffer_Data *Data_In_Ptr , size_t * Len_Ptr , size_t size , IMRT_Cnv_Attr Cnv_Attr )
+{
+	IMRT_Status status;
+	int nb_char_to_rm;
+	int cpt;
+	/*char attr;*/
+	size_t len_tmp;
+	IMRT_Buffer_Data *data_tmp_ptr;
+	char *func_name = "MM_Cut_Right_Convert";
+
+
+        status = IMRS_OK;
+        cpt = 0;
+        
+       	if (Len_Ptr == NULL)
+       	{
+       		IMRD_LM_LOG_ERROR_0("Len pointer NULL" );
+       		status = IMRS_KO;
+       	}
+       	else if (Data_In_Ptr == NULL)
+       	{
+       		IMRD_LM_LOG_ERROR_0("Input pointer NULL" );
+       		status = IMRS_KO;
+       	}
+       	else
+       	if (Data_Out_Ptr == NULL)
+       	{
+       		IMRD_LM_LOG_ERROR_0("Output pointer NULL" );
+       		status = IMRS_KO;
+       	}
+       	else
+       	{
+	        len_tmp = *Len_Ptr ;
+	        nb_char_to_rm = atoi(Cnv_Attr);
+	        if (len_tmp > size)
+	        {
+	        	IMRD_LM_LOG_ERROR_0("Field Len > size" );
+	        	status = IMRS_KO;
+	        }
+	        else
+	        if ((size_t)nb_char_to_rm > len_tmp)
+	        {
+	        	IMRD_LM_LOG_ERROR_2("Nb of char : (%d) > len (%ld)" , nb_char_to_rm , len_tmp);
+	        	status = IMRS_KO;
+	        }
+	        else
+	        if (nb_char_to_rm <= 0)
+	        {
+	        	IMRD_LM_LOG_TRACE_1(IMRD_LOG_LEVEL_VERBOSE_1 , "Nb of char : (%d) Nothing to delete" , nb_char_to_rm);
+	        	status = IMRD_STATUS_NOTHING_TO_DO;
+	        }
+	}
+
+	if (status == IMRS_OK)
+	{
+		
+		memcpy(Data_Out_Ptr , Data_In_Ptr , (len_tmp - nb_char_to_rm));
+		
+	        Data_Out_Ptr[(len_tmp - nb_char_to_rm)] = '\0';       
+	        
+	        *Len_Ptr = (len_tmp - nb_char_to_rm) ;
+	}
+
+	if (status == IMRD_STATUS_NOTHING_TO_DO)
+		status = IMRS_OK;
+
+	return (status);
+}
+
diff --git a/src/libmapping_mng/src/cnv_hdl_cut_right.h b/src/libmapping_mng/src/cnv_hdl_cut_right.h
new file mode 100644
index 0000000..5539402
--- /dev/null
+++ b/src/libmapping_mng/src/cnv_hdl_cut_right.h
@@ -0,0 +1,59 @@
+/*----------------------------------------------------------------------------*/
+/* File: cnv_hdl_cut_right.h    			         	      */
+/*----------------------------------------------------------------------------*/
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#ifndef _CNV_HANDLER_CUT_RIGHT_H_
+#define _CNV_HANDLER_CUT_RIGHT_H_
+
+/*----------------------------------------------------------------------------*/
+/* Global Include                                                             */
+/*----------------------------------------------------------------------------*/
+
+#include "libmapping_mng.h"
+
+/*----------------------------------------------------------------------------*/
+/*	Prototypes							      */
+/*----------------------------------------------------------------------------*/
+
+#ifdef _CNV_HANDLER_CUT_RIGHT_C_
+
+    IMRT_Status	    MM_Cut_Right_Init   ( void );
+    IMRT_Status	    MM_Cut_Right_DeInit ( void );
+    IMRT_Status	    MM_Cut_Right_Convert( IMRT_Buffer_Data * , IMRT_Buffer_Data * , size_t * , size_t , IMRT_Cnv_Attr ); 
+
+#else
+    extern     IMRT_Status	    MM_Cut_Right_Init   ( void );
+    extern     IMRT_Status	    MM_Cut_Right_DeInit ( void );
+    extern     IMRT_Status	    MM_Cut_Right_Convert( IMRT_Buffer_Data * , IMRT_Buffer_Data * , size_t * , size_t , IMRT_Cnv_Attr ); 
+
+#endif
+
+/*----------------------------------------------------------------------------*/
+
+#endif                                   
+
+
diff --git a/src/libmapping_mng/src/cnv_hdl_pad_left.c b/src/libmapping_mng/src/cnv_hdl_pad_left.c
new file mode 100644
index 0000000..3e10458
--- /dev/null
+++ b/src/libmapping_mng/src/cnv_hdl_pad_left.c
@@ -0,0 +1,111 @@
+/*----------------------------------------------------------------------------*/
+/* File: cnv_hdl_pad_left.c    				         	      */
+/*----------------------------------------------------------------------------*/
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#define _LIBMAPPING_MNG_
+#define _CNV_HANDLER_PAD_LEFT_C_
+
+#include "cnv_hdl_pad_left.h" 
+
+IMRT_Status	MM_Pad_Left_Init()
+{
+	return (IMRS_OK);
+}
+
+IMRT_Status	MM_Pad_Left_DeInit()
+{
+
+	return (IMRS_OK);
+}
+
+IMRT_Status	MM_Pad_Left_Convert(IMRT_Buffer_Data *Data_Out_Ptr , IMRT_Buffer_Data *Data_In_Ptr , size_t * Len_Ptr , size_t size , IMRT_Cnv_Attr Cnv_Attr )
+{
+	IMRT_Status status;
+	char attr;
+	size_t compteur;
+	size_t len_tmp;
+	size_t offset;
+	IMRT_Buffer_Data *data_tmp_ptr;
+	char *func_name = "MM_Pad_Left_Convert";
+
+
+       
+        status = IMRS_OK;
+        compteur = 0L;
+        offset = 0L;
+        attr = '0';
+        
+        len_tmp = *Len_Ptr ;
+        
+       	if (Len_Ptr == NULL)
+       	{
+       		IMRD_LM_LOG_ERROR_0("Len pointer NULL" );
+       		status = IMRS_KO;
+       	}
+       	else
+       	if (Data_In_Ptr == NULL)
+       	{
+       		IMRD_LM_LOG_ERROR_0("Input pointer NULL" );
+       		status = IMRS_KO;
+       	}
+       	else
+       	if (Data_Out_Ptr == NULL)
+       	{
+       		IMRD_LM_LOG_ERROR_0("Output pointer NULL" );
+       		status = IMRS_KO;
+       	}
+       	else
+       	{
+       		len_tmp = *Len_Ptr ;
+	        if (len_tmp > size)
+	        {
+	        	IMRD_LM_LOG_ERROR_0("Field Len > size" );
+	        	status = IMRS_KO;
+	        }
+	        else
+	        {
+		        offset = size - len_tmp;
+		        
+		        attr = Cnv_Attr[0];
+		        
+		        memcpy(Data_Out_Ptr + offset , Data_In_Ptr , len_tmp);
+		        data_tmp_ptr = Data_Out_Ptr;
+		        
+		        for (compteur = 0L ; compteur < offset ; compteur++)
+		        {
+		                data_tmp_ptr[compteur] = attr;
+		        }
+		        
+		        data_tmp_ptr[size] = '\0';
+		        *Len_Ptr = size ;
+		}
+	}
+
+
+	return (status);
+}
+
diff --git a/src/libmapping_mng/src/cnv_hdl_pad_left.h b/src/libmapping_mng/src/cnv_hdl_pad_left.h
new file mode 100644
index 0000000..3077683
--- /dev/null
+++ b/src/libmapping_mng/src/cnv_hdl_pad_left.h
@@ -0,0 +1,59 @@
+/*----------------------------------------------------------------------------*/
+/* File: cnv_hdl_pad_left.h    				         	      */
+/*----------------------------------------------------------------------------*/
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#ifndef _CNV_HANDLER_PAD_LEFT_H_
+#define _CNV_HANDLER_PAD_LEFT_H_
+
+/*----------------------------------------------------------------------------*/
+/* Global Include                                                             */
+/*----------------------------------------------------------------------------*/
+
+#include "libmapping_mng.h"
+
+/*----------------------------------------------------------------------------*/
+/*	Prototypes							      */
+/*----------------------------------------------------------------------------*/
+
+#ifdef _CNV_HANDLER_PAD_LEFT_C_
+
+    IMRT_Status	    MM_Pad_Left_Init   ( void );
+    IMRT_Status	    MM_Pad_Left_DeInit ( void );
+    IMRT_Status	    MM_Pad_Left_Convert( IMRT_Buffer_Data * ,IMRT_Buffer_Data * , size_t * , size_t , IMRT_Cnv_Attr ); 
+
+#else
+    extern     IMRT_Status	    MM_Pad_Left_Init   ( void );
+    extern     IMRT_Status	    MM_Pad_Left_DeInit ( void );
+    extern     IMRT_Status	    MM_Pad_Left_Convert( IMRT_Buffer_Data * ,IMRT_Buffer_Data * , size_t * , size_t , IMRT_Cnv_Attr ); 
+
+#endif
+
+/*----------------------------------------------------------------------------*/
+
+#endif                                   
+
+
diff --git a/src/libmapping_mng/src/cnv_hdl_pad_num.c b/src/libmapping_mng/src/cnv_hdl_pad_num.c
new file mode 100644
index 0000000..6c49359
--- /dev/null
+++ b/src/libmapping_mng/src/cnv_hdl_pad_num.c
@@ -0,0 +1,81 @@
+/*----------------------------------------------------------------------------*/
+/* File: cnv_hdl_pad_left.c    				         	      */
+/*----------------------------------------------------------------------------*/
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#define _LIBMAPPING_MNG_
+#define _CNV_HANDLER_PAD_NUM_C_
+
+#include "cnv_hdl_pad_num.h" 
+
+
+
+IMRT_Status	MM_Pad_Num_Init()
+{
+	return (IMRS_OK);
+}
+
+IMRT_Status	MM_Pad_Num_DeInit()
+{
+
+	return (IMRS_OK);
+}
+
+IMRT_Status	MM_Pad_Num_Convert(IMRT_Buffer_Data *Data_Out_Ptr , IMRT_Buffer_Data *Data_In_Ptr , size_t * Len_Ptr , size_t size , IMRT_Cnv_Attr Cnv_Attr )
+{
+	IMRT_Status status;
+	char attr_space[2] ;
+	char attr_zero[2] ;
+	IMRT_Buffer_Data *Tmp_Ptr;
+	char *func_name = "MM_Pad_Num_Convert";
+
+
+	status = IMRS_OK;
+	strcpy(attr_space , " ");
+	strcpy(attr_zero , "0");
+
+	Tmp_Ptr = (IMRT_Buffer_Data *)malloc(size + 1L);
+	if (Tmp_Ptr == NULL)
+	{
+		IMRD_LM_LOG_ERROR_0("Memory allocation failed");
+		status = IMRS_KO;
+	}
+	else
+	{
+		memset(Tmp_Ptr, '\0', (size + 1L));
+	
+		status = MM_Strip_Num_Convert(Tmp_Ptr , Data_In_Ptr , Len_Ptr , size , attr_zero );
+	
+		if (status == IMRS_OK)
+			status = MM_Pad_Left_Convert(Data_Out_Ptr , Tmp_Ptr , Len_Ptr , size , attr_zero );	
+	}
+	if (Tmp_Ptr != NULL)
+		free(Tmp_Ptr);
+
+	return (status);
+
+}
+
diff --git a/src/libmapping_mng/src/cnv_hdl_pad_num.h b/src/libmapping_mng/src/cnv_hdl_pad_num.h
new file mode 100644
index 0000000..4e71b9f
--- /dev/null
+++ b/src/libmapping_mng/src/cnv_hdl_pad_num.h
@@ -0,0 +1,59 @@
+/*----------------------------------------------------------------------------*/
+/* File: cnv_hdl_pad_left.h    				         	      */
+/*----------------------------------------------------------------------------*/
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#ifndef _CNV_HANDLER_PAD_NUM_H_
+#define _CNV_HANDLER_PAD_NUM_H_
+
+/*----------------------------------------------------------------------------*/
+/* Global Include                                                             */
+/*----------------------------------------------------------------------------*/
+
+#include "libmapping_mng.h"
+
+/*----------------------------------------------------------------------------*/
+/*	Prototypes							      */
+/*----------------------------------------------------------------------------*/
+
+#ifdef _CNV_HANDLER_PAD_LEFT_C_
+
+    IMRT_Status	    MM_Pad_Num_Init   ( void );
+    IMRT_Status	    MM_Pad_Num_DeInit ( void );
+    IMRT_Status	    MM_Pad_Num_Convert( IMRT_Buffer_Data * ,IMRT_Buffer_Data * , size_t * , size_t , IMRT_Cnv_Attr ); 
+
+#else
+    extern     IMRT_Status	    MM_Pad_Num_Init   ( void );
+    extern     IMRT_Status	    MM_Pad_Num_DeInit ( void );
+    extern     IMRT_Status	    MM_Pad_Num_Convert( IMRT_Buffer_Data * ,IMRT_Buffer_Data * , size_t * , size_t , IMRT_Cnv_Attr ); 
+
+#endif
+
+/*----------------------------------------------------------------------------*/
+
+#endif                                   
+
+
diff --git a/src/libmapping_mng/src/cnv_hdl_pad_right.c b/src/libmapping_mng/src/cnv_hdl_pad_right.c
new file mode 100644
index 0000000..6774a07
--- /dev/null
+++ b/src/libmapping_mng/src/cnv_hdl_pad_right.c
@@ -0,0 +1,100 @@
+/*----------------------------------------------------------------------------*/
+/* File: cnv_hdl_pad_right.c    				         	      */
+/*----------------------------------------------------------------------------*/
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#define _LIBMAPPING_MNG_
+#define _CNV_HANDLER_PAD_RIGHT_C_
+
+#include "cnv_hdl_pad_right.h" 
+
+IMRT_Status	MM_Pad_Right_Init()
+{
+	return (IMRS_OK);
+}
+
+IMRT_Status	MM_Pad_Right_DeInit()
+{
+
+	return (IMRS_OK);
+}
+
+
+IMRT_Status	MM_Pad_Right_Convert(IMRT_Buffer_Data *Data_Out_Ptr , IMRT_Buffer_Data *Data_In_Ptr , size_t * Len_Ptr , size_t size , IMRT_Cnv_Attr Cnv_Attr )
+{
+	IMRT_Status status;
+	char attr;
+	size_t compteur;
+	size_t len_tmp;
+	IMRT_Buffer_Data *data_tmp_ptr;
+	char *func_name = "MM_Pad_Right_Convert";
+
+        
+        status = IMRS_OK;
+        compteur = 0L;
+        attr = '0';
+
+        len_tmp = *Len_Ptr ;
+                
+        if (len_tmp > size)
+        {
+        	IMRD_LM_LOG_ERROR_0("Field Len > size" );
+        	status = IMRS_KO;
+        }
+        else
+        {
+        	if (Data_In_Ptr == NULL)
+        	{
+        		IMRD_LM_LOG_ERROR_0("Input pointer NULL" );
+        		status = IMRS_KO;
+        	}
+        	else
+        	if (Data_Out_Ptr == NULL)
+        	{
+        		IMRD_LM_LOG_ERROR_0("Output pointer NULL" );
+        		status = IMRS_KO;
+        	}
+        	else
+         	{
+		        attr = Cnv_Attr[0];
+		        
+		        memcpy(Data_Out_Ptr , Data_In_Ptr , len_tmp);
+		        data_tmp_ptr = Data_Out_Ptr + len_tmp ;
+		        
+		        for (compteur = 0L ; compteur < (size - len_tmp) ; compteur++)
+		        {
+		                data_tmp_ptr[compteur] = attr;
+		        }
+		        
+		        data_tmp_ptr[compteur] = '\0';
+		        *Len_Ptr = size ;
+		}
+	}
+
+
+	return (status);
+}
+
diff --git a/src/libmapping_mng/src/cnv_hdl_pad_right.h b/src/libmapping_mng/src/cnv_hdl_pad_right.h
new file mode 100644
index 0000000..ea54a7f
--- /dev/null
+++ b/src/libmapping_mng/src/cnv_hdl_pad_right.h
@@ -0,0 +1,59 @@
+/*----------------------------------------------------------------------------*/
+/* File: cnv_hdl_pad_right.h    				              */
+/*----------------------------------------------------------------------------*/
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#ifndef _CNV_HANDLER_PAD_RIGHT_H_
+#define _CNV_HANDLER_PAD_RIGHT_H_
+
+/*----------------------------------------------------------------------------*/
+/* Global Include                                                             */
+/*----------------------------------------------------------------------------*/
+
+#include "libmapping_mng.h"
+
+/*----------------------------------------------------------------------------*/
+/*	Prototypes							      */
+/*----------------------------------------------------------------------------*/
+
+#ifdef _CNV_HANDLER_PAD_RIGHT_C_
+
+    IMRT_Status	    MM_Pad_Right_Init   ( void );
+    IMRT_Status	    MM_Pad_Right_DeInit ( void );
+    IMRT_Status	    MM_Pad_Right_Convert( IMRT_Buffer_Data * ,IMRT_Buffer_Data * , size_t * , size_t , IMRT_Cnv_Attr ); 
+
+#else
+    extern     IMRT_Status	    MM_Pad_Right_Init   ( void );
+    extern     IMRT_Status	    MM_Pad_Right_DeInit ( void );
+    extern     IMRT_Status	    MM_Pad_Right_Convert( IMRT_Buffer_Data * ,IMRT_Buffer_Data * , size_t * , size_t , IMRT_Cnv_Attr ); 
+
+#endif
+
+/*----------------------------------------------------------------------------*/
+
+#endif                                   
+
+
diff --git a/src/libmapping_mng/src/cnv_hdl_strip_left.c b/src/libmapping_mng/src/cnv_hdl_strip_left.c
new file mode 100644
index 0000000..c9b295f
--- /dev/null
+++ b/src/libmapping_mng/src/cnv_hdl_strip_left.c
@@ -0,0 +1,128 @@
+/*----------------------------------------------------------------------------*/
+/* File: cnv_hdl_strip_left.c    				         	      */
+/*----------------------------------------------------------------------------*/
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#define _LIBMAPPING_MNG_
+#define _CNV_HANDLER_STRIP_LEFT_C_
+
+#include "cnv_hdl_strip_left.h" 
+
+IMRT_Status	MM_Strip_Left_Init()
+{
+	return (IMRS_OK);
+}
+
+IMRT_Status	MM_Strip_Left_DeInit()
+{
+
+	return (IMRS_OK);
+}
+
+IMRT_Status	MM_Strip_Left_Convert(IMRT_Buffer_Data *Data_Out_Ptr , IMRT_Buffer_Data *Data_In_Ptr , size_t * Len_Ptr , size_t size , IMRT_Cnv_Attr Cnv_Attr )
+{
+	IMRT_Status status;
+	char attr;
+	size_t compteur;
+	size_t len_tmp;
+	IMRT_Buffer_Data *data_tmp_ptr;
+	IMRT_Buffer_Data *data_tmp_idx_ptr;
+	char *func_name = "MM_Strip_Left_Convert";
+
+
+        status = IMRS_OK;
+        
+        
+       	if (Len_Ptr == NULL)
+       	{
+       		IMRD_LM_LOG_ERROR_0("Len pointer NULL" );
+       		status = IMRS_KO;
+       	}
+       	else
+       	if (Data_In_Ptr == NULL)
+       	{
+       		IMRD_LM_LOG_ERROR_0("Input pointer NULL" );
+       		status = IMRS_KO;
+       	}
+       	else
+       	if (Data_Out_Ptr == NULL)
+       	{
+       		IMRD_LM_LOG_ERROR_0("Output pointer NULL" );
+       		status = IMRS_KO;
+       	}
+       	else
+       	{
+       		len_tmp = *Len_Ptr ;
+	        if (len_tmp > size)
+	        {
+	        	IMRD_LM_LOG_ERROR_0("Field Len > size" );
+	        	status = IMRS_KO;
+	        }
+	        else
+	        {
+		        attr = Cnv_Attr[0];
+		        
+		        data_tmp_ptr = (IMRT_Buffer_Data *)malloc(size + 1L);
+		        if(data_tmp_ptr == NULL)
+			{
+			    /*erreur allocation */
+			    IMRD_LM_LOG_ERROR_0("Memory allocation failed");
+			    status = IMRS_KO;
+			}
+			else
+			{
+			        memset( data_tmp_ptr, '\0' , (size + 1L) );
+			        data_tmp_idx_ptr = data_tmp_ptr;
+			        memcpy(data_tmp_ptr , Data_In_Ptr , len_tmp) ;
+			        data_tmp_ptr[len_tmp] = '\0';
+			        memset( Data_Out_Ptr, '\0' , (size + 1L) );
+			        
+			        compteur = 0L;
+			        
+			        while ((data_tmp_idx_ptr[0L] == attr) && (compteur < *Len_Ptr))
+			        {
+			                data_tmp_idx_ptr++;
+			                len_tmp--;
+			                compteur++;
+			        }
+			        
+			        data_tmp_idx_ptr[len_tmp] = '\0';       
+			        
+			        memcpy(Data_Out_Ptr , data_tmp_idx_ptr , len_tmp + 1L);
+			        
+			        *Len_Ptr = len_tmp ;
+			        
+				free(data_tmp_ptr);
+			}
+		}
+
+	}
+
+		
+	return (status);
+
+}
+
diff --git a/src/libmapping_mng/src/cnv_hdl_strip_left.h b/src/libmapping_mng/src/cnv_hdl_strip_left.h
new file mode 100644
index 0000000..a40b107
--- /dev/null
+++ b/src/libmapping_mng/src/cnv_hdl_strip_left.h
@@ -0,0 +1,59 @@
+/*----------------------------------------------------------------------------*/
+/* File: cnv_hdl_strip_left.h    				              */
+/*----------------------------------------------------------------------------*/
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#ifndef _CNV_HANDLER_STRIP_LEFT_H_
+#define _CNV_HANDLER_STRIP_LEFT_H_
+
+/*----------------------------------------------------------------------------*/
+/* Global Include                                                             */
+/*----------------------------------------------------------------------------*/
+
+#include "libmapping_mng.h"
+
+/*----------------------------------------------------------------------------*/
+/*	Prototypes							      */
+/*----------------------------------------------------------------------------*/
+
+#ifdef _CNV_HANDLER_STRIP_LEFT_C_
+
+    IMRT_Status	    MM_Strip_Left_Init   ( void );
+    IMRT_Status	    MM_Strip_Left_DeInit ( void );
+    IMRT_Status	    MM_Strip_Left_Convert( IMRT_Buffer_Data * , IMRT_Buffer_Data * , size_t * , size_t , IMRT_Cnv_Attr ); 
+
+#else
+    extern     IMRT_Status	    MM_Strip_Left_Init   ( void );
+    extern     IMRT_Status	    MM_Strip_Left_DeInit ( void );
+    extern     IMRT_Status	    MM_Strip_Left_Convert( IMRT_Buffer_Data * , IMRT_Buffer_Data * , size_t * , size_t , IMRT_Cnv_Attr ); 
+
+#endif
+
+/*----------------------------------------------------------------------------*/
+
+#endif                                   
+
+
diff --git a/src/libmapping_mng/src/cnv_hdl_strip_num.c b/src/libmapping_mng/src/cnv_hdl_strip_num.c
new file mode 100644
index 0000000..c89bc8f
--- /dev/null
+++ b/src/libmapping_mng/src/cnv_hdl_strip_num.c
@@ -0,0 +1,80 @@
+/*----------------------------------------------------------------------------*/
+/* File: cnv_hdl_strip_num.c    				         	      */
+/*----------------------------------------------------------------------------*/
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#define _LIBMAPPING_MNG_
+#define _CNV_HANDLER_STRIP_NUM_C_
+
+#include "cnv_hdl_strip_num.h" 
+
+IMRT_Status	MM_Strip_Num_Init()
+{
+	return (IMRS_OK);
+}
+
+IMRT_Status	MM_Strip_Num_DeInit()
+{
+
+	return (IMRS_OK);
+}
+
+IMRT_Status	MM_Strip_Num_Convert(IMRT_Buffer_Data *Data_Out_Ptr , IMRT_Buffer_Data *Data_In_Ptr , size_t * Len_Ptr , size_t size , IMRT_Cnv_Attr Cnv_Attr )
+{
+	IMRT_Status status;
+	char attr_space[2] ;
+	char attr_zero[2] ;
+	IMRT_Buffer_Data *Data_Tmp_Ptr;
+	char *func_name = "MM_Strip_Num_Convert";
+
+
+	status = IMRS_OK;
+	strcpy(attr_space , " ");
+	strcpy(attr_zero , "0");
+
+	Data_Tmp_Ptr = (IMRT_Buffer_Data *)malloc(size + 1L);
+	if (Data_Tmp_Ptr == NULL)
+	{
+		IMRD_LM_LOG_ERROR_0("Memory allocation failed");
+		status = IMRS_KO;
+	}
+	else
+	{
+		memset(Data_Tmp_Ptr, '\0', (size + 1L));
+	
+		status = MM_Strip_Left_Convert(Data_Tmp_Ptr , Data_In_Ptr , Len_Ptr , size , attr_space );
+		
+		if (status == IMRS_OK)
+			status = MM_Strip_Left_Convert(Data_Out_Ptr , Data_Tmp_Ptr , Len_Ptr , size , attr_zero );
+	}
+
+	if(Data_Tmp_Ptr != NULL)
+		free(Data_Tmp_Ptr);
+
+	return (status);
+
+}
+
diff --git a/src/libmapping_mng/src/cnv_hdl_strip_num.h b/src/libmapping_mng/src/cnv_hdl_strip_num.h
new file mode 100644
index 0000000..282cb20
--- /dev/null
+++ b/src/libmapping_mng/src/cnv_hdl_strip_num.h
@@ -0,0 +1,59 @@
+/*----------------------------------------------------------------------------*/
+/* File: cnv_hdl_strip_num.h    				              */
+/*----------------------------------------------------------------------------*/
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#ifndef _CNV_HANDLER_STRIP_NUM_H_
+#define _CNV_HANDLER_STRIP_NUM_H_
+
+/*----------------------------------------------------------------------------*/
+/* Global Include                                                             */
+/*----------------------------------------------------------------------------*/
+
+#include "libmapping_mng.h"
+
+/*----------------------------------------------------------------------------*/
+/*	Prototypes							      */
+/*----------------------------------------------------------------------------*/
+
+#ifdef _CNV_HANDLER_STRIP_NUM_C_
+
+    IMRT_Status	    MM_Strip_Num_Init   ( void );
+    IMRT_Status	    MM_Strip_Num_DeInit ( void );
+    IMRT_Status	    MM_Strip_Num_Convert( IMRT_Buffer_Data * , IMRT_Buffer_Data * , size_t * , size_t , IMRT_Cnv_Attr ); 
+
+#else
+    extern     IMRT_Status	    MM_Strip_Num_Init   ( void );
+    extern     IMRT_Status	    MM_Strip_Num_DeInit ( void );
+    extern     IMRT_Status	    MM_Strip_Num_Convert( IMRT_Buffer_Data * , IMRT_Buffer_Data * , size_t * , size_t , IMRT_Cnv_Attr ); 
+
+#endif
+
+/*----------------------------------------------------------------------------*/
+
+#endif                                   
+
+
diff --git a/src/libmapping_mng/src/cnv_hdl_strip_right.c b/src/libmapping_mng/src/cnv_hdl_strip_right.c
new file mode 100644
index 0000000..a314387
--- /dev/null
+++ b/src/libmapping_mng/src/cnv_hdl_strip_right.c
@@ -0,0 +1,105 @@
+/*----------------------------------------------------------------------------*/
+/* File: cnv_hdl_strip_right.c    				         	      */
+/*----------------------------------------------------------------------------*/
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#define _LIBMAPPING_MNG_
+#define _CNV_HANDLER_STRIP_RIGHT_C_
+
+#include "cnv_hdl_strip_right.h" 
+
+IMRT_Status	MM_Strip_Right_Init()
+{
+	return (IMRS_OK);
+}
+
+IMRT_Status	MM_Strip_Right_DeInit()
+{
+
+	return (IMRS_OK);
+}
+
+IMRT_Status	MM_Strip_Right_Convert(IMRT_Buffer_Data *Data_Out_Ptr , IMRT_Buffer_Data *Data_In_Ptr , size_t * Len_Ptr , size_t size , IMRT_Cnv_Attr Cnv_Attr )
+{
+	IMRT_Status status;
+	char attr;
+	size_t len_tmp;
+	IMRT_Buffer_Data *data_tmp_ptr;
+	char *func_name = "MM_Strip_Right_Convert";
+
+
+        status = IMRS_OK;
+        
+        
+       	if (Len_Ptr == NULL)
+       	{
+       		IMRD_LM_LOG_ERROR_0("Len pointer NULL" );
+       		status = IMRS_KO;
+       	}
+       	else
+       	if (Data_In_Ptr == NULL)
+       	{
+       		IMRD_LM_LOG_ERROR_0("Input pointer NULL" );
+       		status = IMRS_KO;
+       	}
+       	else
+       	if (Data_Out_Ptr == NULL)
+       	{
+       		IMRD_LM_LOG_ERROR_0("Output pointer NULL" );
+       		status = IMRS_KO;
+       	}
+       	else
+       	{
+       		len_tmp = *Len_Ptr ;
+	        if (len_tmp > size)
+	        {
+	        	IMRD_LM_LOG_ERROR_0("Field Len > size" );
+	        	status = IMRS_KO;
+	        }
+	        else
+	        {
+		        attr = Cnv_Attr[0];
+		        
+		        data_tmp_ptr = Data_In_Ptr + len_tmp ;
+		        
+		       
+		        while ((data_tmp_ptr > Data_In_Ptr) && (*(--data_tmp_ptr) == attr) )
+		        {
+		                len_tmp--;
+		        }
+		        
+		        if (Data_Out_Ptr != Data_In_Ptr)
+		        	memcpy(Data_Out_Ptr , Data_In_Ptr , len_tmp);
+		        Data_Out_Ptr[len_tmp] = '\0';       
+		        
+		        *Len_Ptr = len_tmp ;
+		}
+	}
+
+
+	return (status);
+}
+
diff --git a/src/libmapping_mng/src/cnv_hdl_strip_right.h b/src/libmapping_mng/src/cnv_hdl_strip_right.h
new file mode 100644
index 0000000..acbd5f4
--- /dev/null
+++ b/src/libmapping_mng/src/cnv_hdl_strip_right.h
@@ -0,0 +1,59 @@
+/*----------------------------------------------------------------------------*/
+/* File: cnv_hdl_strip_right.h    			         	      */
+/*----------------------------------------------------------------------------*/
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#ifndef _CNV_HANDLER_STRIP_RIGHT_H_
+#define _CNV_HANDLER_STRIP_RIGHT_H_
+
+/*----------------------------------------------------------------------------*/
+/* Global Include                                                             */
+/*----------------------------------------------------------------------------*/
+
+#include "libmapping_mng.h"
+
+/*----------------------------------------------------------------------------*/
+/*	Prototypes							      */
+/*----------------------------------------------------------------------------*/
+
+#ifdef _CNV_HANDLER_STRIP_RIGHT_C_
+
+    IMRT_Status	    MM_Strip_Right_Init   ( void );
+    IMRT_Status	    MM_Strip_Right_DeInit ( void );
+    IMRT_Status	    MM_Strip_Right_Convert( IMRT_Buffer_Data * , IMRT_Buffer_Data * , size_t * , size_t , IMRT_Cnv_Attr ); 
+
+#else
+    extern     IMRT_Status	    MM_Strip_Right_Init   ( void );
+    extern     IMRT_Status	    MM_Strip_Right_DeInit ( void );
+    extern     IMRT_Status	    MM_Strip_Right_Convert( IMRT_Buffer_Data * , IMRT_Buffer_Data * , size_t * , size_t , IMRT_Cnv_Attr ); 
+
+#endif
+
+/*----------------------------------------------------------------------------*/
+
+#endif                                   
+
+
diff --git a/src/libmapping_mng/src/field.tbls.h b/src/libmapping_mng/src/field.tbls.h
new file mode 100644
index 0000000..c581e0d
--- /dev/null
+++ b/src/libmapping_mng/src/field.tbls.h
@@ -0,0 +1,31 @@
+/*----------------------------------------------------------------------------*/
+/* File: field.tbls.h    	        		         	      */
+/*----------------------------------------------------------------------------*/
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+/*	fname	fldid            */
+/*	-----	-----            */
+#define	FML_MSG_TXT	((FLDID32)201327012)	/* number: 420	 type: carray */
diff --git a/src/libmapping_mng/src/fmt_hdl_dltd.c b/src/libmapping_mng/src/fmt_hdl_dltd.c
new file mode 100644
index 0000000..a415295
--- /dev/null
+++ b/src/libmapping_mng/src/fmt_hdl_dltd.c
@@ -0,0 +1,1079 @@
+/*----------------------------------------------------------------------------*/
+/* File: fmt_hdl_dltd.c    				         	      */
+/* Comptage des occurences : la premiere est numerotee 0        	      */
+/* La zone de donnees Data_Tmp_Ptr du buffer contient la prochaine occurence  */
+/*----------------------------------------------------------------------------*/
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#define _LIBMAPPING_MNG_
+#define _DELIMITED_HANDLER_C_
+
+#include "fmt_hdl_dltd.h" 
+
+IMRT_Status	MM_Delimited_StrHdl_Init()
+{
+	IMRG_Delimited_Buffer_Ident_Ptr = NULL;
+	return (IMRS_OK);
+}
+
+IMRT_Status	MM_Delimited_StrHdl_DeInit()
+{
+	return (IMRS_OK);
+}
+
+IMRT_Status Delimited_Hdl_DataBuf_Alloc( IMRT_Buffer *Buffer_Ptr, size_t Taille_Alloc )
+{
+	IMRT_Buffer_Data *data_Ptr;
+	IMRT_Status status;
+	IMRT_Delimited_TmpId * TmpId_Ptr;
+	char *func_name = "Delimited_Hdl_DataBuf_Alloc";
+
+	
+	status   = IMRS_OK;
+	data_Ptr = NULL;
+	
+	if (Buffer_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Buffer pointer NULL" );
+	}
+	else
+	if (Buffer_Ptr->Status == IMRD_BUFFER_STATUS_ALLOCATED)
+	{
+		if (Taille_Alloc > Buffer_Ptr->Data_Buf_Size)
+		{
+			data_Ptr = (IMRT_Buffer_Data *) realloc ( (void *) Buffer_Ptr->Data_Buf_Ptr, Taille_Alloc );
+			if (data_Ptr == NULL)
+			{
+				status = IMRS_KO;
+				IMRD_LM_LOG_ERROR_0("Realloc error");
+			}
+			else
+			{
+				memset( data_Ptr + Buffer_Ptr->Data_Buf_Size, '\0', Taille_Alloc - Buffer_Ptr->Data_Buf_Size );
+				Buffer_Ptr->Data_Buf_Ptr  = data_Ptr;
+				Buffer_Ptr->Data_Buf_Size = Taille_Alloc;
+			}
+		}
+	}
+	else
+	{
+		data_Ptr = (IMRT_Buffer_Data *) malloc ( Taille_Alloc );
+		if (data_Ptr == NULL)
+		{
+			status = IMRS_KO;
+			IMRD_LM_LOG_ERROR_0("Malloc error");
+		}
+		else
+		{
+			memset( data_Ptr, '\0', Taille_Alloc );
+			Buffer_Ptr->Data_Buf_Ptr  = data_Ptr;
+			Buffer_Ptr->Status        = IMRD_BUFFER_STATUS_ALLOCATED;
+			Buffer_Ptr->Data_Buf_Size = Taille_Alloc;
+			Buffer_Ptr->Data_Buf_Len  = 0;
+		}
+		
+		if (status == IMRS_OK)
+		{
+		        TmpId_Ptr = (IMRT_Delimited_TmpId *) malloc ( sizeof(IMRT_Delimited_TmpId));
+        		if (TmpId_Ptr == NULL)
+        		{
+        			status = IMRS_KO;
+        			IMRD_LM_LOG_ERROR_0("Malloc error");
+        			free(Buffer_Ptr->Data_Buf_Ptr);
+        			Buffer_Ptr->Status = IMRD_BUFFER_STATUS_FREED;
+        			Buffer_Ptr->Data_Buf_Size = 0;
+        		}
+        		else
+        		{
+        		        /* Initialisation de la premiere occurence a 0 */
+        			memset( TmpId_Ptr, '\0', sizeof(IMRT_Delimited_TmpId) );
+        			TmpId_Ptr->TmpId = 0;
+        			Buffer_Ptr->Data_Tmp_Ptr  = (IMRT_Buffer_Data *)(TmpId_Ptr);		
+        		}
+	        }
+
+	}
+	
+
+	return ( status );
+}
+
+IMRT_Status MM_Delimited_StrHdl_Data_Free( IMRT_Buffer  *Buffer_Ptr)
+{
+	IMRT_Status status;
+	char *func_name = "MM_Delimited_StrHdl_Data_Free";
+
+	
+	status = IMRS_OK;
+
+	if (Buffer_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Buffer pointer NULL" );
+	}
+	else
+	if (Buffer_Ptr->Status == IMRD_BUFFER_STATUS_ALLOCATED)
+	{
+		if(Buffer_Ptr->Data_Buf_Ptr != NULL)
+		{
+			free(Buffer_Ptr->Data_Buf_Ptr);
+		}
+		Buffer_Ptr->Data_Buf_Ptr  = NULL;	
+		Buffer_Ptr->Status        = IMRD_BUFFER_STATUS_FREED;
+		Buffer_Ptr->Data_Buf_Size = 0;
+		Buffer_Ptr->Data_Buf_Len  = 0;
+		if(Buffer_Ptr->Data_Tmp_Ptr != NULL)
+			free(Buffer_Ptr->Data_Tmp_Ptr);
+		Buffer_Ptr->Data_Tmp_Ptr  = NULL;
+		Buffer_Ptr->Data_Tmp_Changed = IMRD_FALSE;
+		Buffer_Ptr->Data_Tmp_Ptr  = NULL;
+	}
+
+	return ( status );
+}
+
+IMRT_Status Delimited_Hdl_Format_Ident( IMRT_Buffer *Buffer_Ptr )
+{
+	IMRT_Status status;
+	char *func_name = "Delimited_Hdl_Format_Ident";
+
+
+	if (Buffer_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Buffer pointer NULL" );
+	}
+	else
+	if (Buffer_Ptr->Status == IMRD_BUFFER_STATUS_ALLOCATED)
+	{
+		status = IMRS_OK;
+	}
+	else
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Buffer not allocated");
+	}
+	
+
+	return ( status );
+}
+
+IMRT_Status MM_Delimited_StrHdl_Ident( IMRT_Msg_Id *Msg_Id_Ident_Ptr, 
+                                        IMRT_Buffer *Buffer_Ptr )
+{
+        
+        IMRT_Fmt_Id Format;
+        IMRT_Status status;
+        IMRT_Msg_Id *Msg_Id_Tmp;
+        char *func_name = "MM_Delimited_StrHdl_Ident";
+        
+
+	if (Buffer_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Buffer pointer NULL" );
+	}
+	else
+	if (Msg_Id_Ident_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Msg_Id_Ident_Ptr NULL" );
+	}
+	else
+        {
+        	Format = Buffer_Ptr->Fmt_Id;
+	        Msg_Id_Tmp = Msg_Id_Ident_Ptr;
+	        status = IMRS_OK;
+	
+		IMRG_Delimited_Buffer_Ident_Ptr = Buffer_Ptr;
+		/* Le Msg_Id transmis au SDM est le point de depart de l'identification */
+		/* C'est egalement le resultat qui sera inclus dans le buffer */
+		status = IMR_SDM_MsgIdent_Proceed(Format, 
+		                                  Msg_Id_Tmp,
+		                                  IMR_MM_Delimited_StrHdl_Field_Value,
+		                                  IMR_MM_Delimited_StrHdl_Field_Exist,
+		                                  IMR_MM_Delimited_StrHdl_Msg_Size);
+		IMRG_Delimited_Buffer_Ident_Ptr = NULL;
+	
+	        Msg_Id_Ident_Ptr = Msg_Id_Tmp;
+	}
+
+	return ( status );
+
+}
+
+IMRT_Status Delimited_Hdl_TmpId_Init( IMRT_Buffer *Buffer_Ptr , short nb_occ)
+{
+	IMRT_Status status;
+	IMRT_Delimited_TmpId * TmpId_Ptr;
+	char *func_name = "Delimited_Hdl_TmpId_Init";
+
+	status = IMRS_OK;
+	TmpId_Ptr = NULL;
+        TmpId_Ptr = (IMRT_Delimited_TmpId *) malloc ( sizeof(IMRT_Delimited_TmpId));
+        if (TmpId_Ptr == NULL)
+        {
+                status = IMRS_KO;
+        	IMRD_LM_LOG_ERROR_0("Malloc error");
+        }
+        else
+        if (Buffer_Ptr == NULL)
+        {
+                status = IMRS_KO;
+        	IMRD_LM_LOG_ERROR_0("Buffer pointer null");
+        }
+        else
+        {
+                /* Initialisation de la premiere occurence a 0 */
+        	memset( TmpId_Ptr, '\0', sizeof(IMRT_Delimited_TmpId) );
+        	TmpId_Ptr->TmpId = nb_occ;
+        	Buffer_Ptr->Data_Tmp_Ptr  = (IMRT_Buffer_Data *)(TmpId_Ptr);
+        }
+
+
+        return status;        
+}
+
+
+
+IMRT_Status Delimited_Hdl_Occ_Count( IMRT_Buffer_Data *data_ptr , short *nb_occ , IMRT_FmtAttr_Value attr)
+{
+	IMRT_Status status;
+	IMRT_Buffer_Data *deb_data_ptr;
+	IMRT_Boolean loop_end;
+	short cpt;
+	char indicateur[2];
+	char *delim_ptr;
+	IMRT_FmtAttr_Value delimiteur;
+	char *func_name = "Delimited_Hdl_Occ_Count";
+
+	status = IMRS_OK;
+	deb_data_ptr = NULL;
+	loop_end = IMRD_FALSE;
+	
+	
+        if (nb_occ == NULL)
+        {
+                status = IMRS_KO;
+        	IMRD_LM_LOG_ERROR_0("Nb occ pointer null");
+        }
+        else
+	if ((data_ptr == NULL) || (strcmp(attr , "")==0))
+	{
+	        status = IMRS_KO;
+	        IMRD_LM_LOG_ERROR_0("Error : data pointer NULL or attribute is an empty string");
+	}
+	
+	if ( status == IMRS_OK )
+	{
+		strcpy(delimiteur , "");
+		strncpy(indicateur , attr , 1);
+		indicateur[1] = '\0';
+		delim_ptr = NULL;
+		delim_ptr = (attr);
+		delim_ptr++;
+		strcpy(delimiteur , delim_ptr);
+	
+	
+	/* Controle de validite de l'indicateur  */
+		if ((strcmp(indicateur , "S") != 0) && (strcmp(indicateur , "T") != 0))
+		{
+			status = IMRS_KO;
+			IMRD_LM_LOG_ERROR_1("Indicateur non correct [%s]",indicateur);
+		}
+	}
+
+
+
+	if (status == IMRS_OK)
+	{
+		if (strcmp(data_ptr , "") == 0)
+		{
+			cpt = 0;
+		}
+		else
+		{
+	        	/* La premiŠre occurence est la 0 */        
+	        	cpt = 0;
+	                /* positionnement au debut de la chaine */
+	                deb_data_ptr = data_ptr;
+	                /* boucle de comptage des occurrences */
+	                while (!loop_end)
+	                {
+	                        deb_data_ptr = (IMRT_Buffer_Data *)strstr((const char *)deb_data_ptr , (const char *)delimiteur);
+	                        IMRD_LM_LOG_TRACE_1( IMRD_LOG_LEVEL_VERBOSE_2, "attr [%s]" , delimiteur);
+	                        IMRD_LM_LOG_TRACE_1( IMRD_LOG_LEVEL_VERBOSE_2, "deb_data_ptr [%s]" , deb_data_ptr);
+	                        
+	                        if (deb_data_ptr != NULL)
+	                        {
+	                                cpt++;
+	                                deb_data_ptr++;
+	                        }
+	                        else
+	                                loop_end = IMRD_TRUE;
+	                }
+	                
+	        }
+	        /* si l'indicateur est S il faut rajouter une occurence */
+	        if ((cpt != 0)&&(strcmp(indicateur , "S") == 0))
+	        	cpt++;
+	        	
+	        *nb_occ = cpt;
+        }
+	
+        return status;        
+}
+
+
+IMRT_Status MM_Delimited_StrHdl_Open( IMRT_Buffer *Buffer_Ptr)
+{
+	IMRT_Msg_Id type_temp;
+	IMRT_Status status;
+	IMRT_Delimited_TmpId *TmpId_Ptr;
+	IMRT_Boolean flag_init;
+	short nb_occ;
+	char *func_name = "MM_Delimited_StrHdl_Open";
+	
+
+
+	status = IMRS_OK;
+	nb_occ = 0;
+	flag_init = IMRD_FALSE;
+
+	if (Buffer_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Buffer pointer NULL" );
+	}
+	else
+	{
+		type_temp = Buffer_Ptr->Msg_Id;
+	        if (Buffer_Ptr->Status != IMRD_BUFFER_STATUS_ALLOCATED)
+	        {
+	                
+	                IMRD_LM_LOG_TRACE_0( IMRD_LOG_LEVEL_VERBOSE_2, "Le buffer n'a pas le status allocated");
+		        /* Cas d'open du buffer en ecriture */
+		        /* le type du message est passe */
+		        /* par le SDM : il doit donc etre connu */
+			if (type_temp == IMRD_MSG_ID_UNKNOWN) 
+			{
+				status = IMRS_KO;
+				IMRD_LM_LOG_ERROR_0("Msg Id unknown");
+			}
+			else
+			{
+			        status = Delimited_Hdl_DataBuf_Alloc( Buffer_Ptr, DELIMITED_TAILLE_ALLOC );
+			}
+	        }
+	        else /* le status est allocated */
+	        {
+	                IMRD_LM_LOG_TRACE_0( IMRD_LOG_LEVEL_VERBOSE_2, "Le buffer a  le status allocated");
+	                
+	                /* comptage du nombre d'occurences */
+	                status = Delimited_Hdl_Occ_Count( Buffer_Ptr->Data_Buf_Ptr , &nb_occ , Buffer_Ptr->FmtAttr_Value);
+	                if (Buffer_Ptr->Data_Tmp_Ptr != NULL)
+	                {
+	                	TmpId_Ptr = (IMRT_Delimited_TmpId *)Buffer_Ptr->Data_Tmp_Ptr;
+	                	if (TmpId_Ptr->TmpId != nb_occ)
+	                	{
+	                		flag_init = IMRD_TRUE;
+	                		free(Buffer_Ptr->Data_Tmp_Ptr);
+	                	}
+	                }
+                	else
+                	{
+                		flag_init = IMRD_TRUE;
+                	}	
+
+	                if ((status == IMRS_OK) && (flag_init == IMRD_TRUE))
+	                {
+	                        /* initialisation de Data_Tmp_Ptr avec le nombre d'occurence */
+	                        status = Delimited_Hdl_TmpId_Init(Buffer_Ptr , nb_occ);
+	                }
+	                
+	                
+	                if (status == IMRS_OK)
+	                {
+	                        /* controle du format (inutile actuellement) */
+	                        status = Delimited_Hdl_Format_Ident( Buffer_Ptr ) ;
+	                        if (status != IMRS_OK)
+	                        {
+	                                status = IMRS_BAD_FORMAT;
+	                        }
+	                }
+	        }
+	}
+
+	return ( status );
+}
+
+
+
+IMRT_Status MM_Delimited_StrHdl_Close( IMRT_Buffer *Buffer_Ptr)
+{
+	char *func_name = "MM_Delimited_StrHdl_Close";
+	IMRT_Status	status;
+
+	status = IMRS_OK;
+
+	if (Buffer_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Buffer pointer NULL" );
+	}
+	else
+	{
+		status = MM_Delimited_StrHdl_Flush( Buffer_Ptr ); 
+		if ((status == IMRS_OK) && (Buffer_Ptr->Data_Tmp_Ptr != NULL))
+		{
+			free(Buffer_Ptr->Data_Tmp_Ptr);
+			Buffer_Ptr->Data_Tmp_Ptr = NULL;
+		}
+	}
+
+	return ( status );
+}
+
+IMRT_Status	MM_Delimited_StrHdl_Flush( IMRT_Buffer  *Buffer_Ptr)
+{
+	char *func_name = "MM_Delimited_StrHdl_Flush";
+
+	return (IMRS_OK);
+}
+
+
+
+IMRT_Status MM_Delimited_StrHdl_Data_List( IMRT_Buffer *Buffer_Ptr)
+{
+
+	if (Buffer_Ptr == NULL)
+	{
+		IMRD_LM_LOG_WARNING_0("Buffer pointer NULL" );
+	}
+	else
+	{
+	    IMRD_LM_LOG_TRACE_3( IMRD_LOG_LEVEL_VERBOSE_1, "Buffer_List: Data_Buf_Ptr_Size: (%d)   Data_Buf_Ptr_Len: (%d)   Data_Buf_Ptr: (0x%X)", Buffer_Ptr->Data_Buf_Size, Buffer_Ptr->Data_Buf_Len, Buffer_Ptr->Data_Buf_Ptr);
+	    IMRD_LM_LOG_TRACE_1( IMRD_LOG_LEVEL_VERBOSE_2, "Buffer_List: Data_Buf: [%s]", Buffer_Ptr->Data_Buf_Ptr);
+	    IMRD_LM_LOG_TRACE_2( IMRD_LOG_LEVEL_VERBOSE_1, "Buffer_List: Data_Tmp_Changed: (%d)   Data_Tmp_Ptr: (0x%X)", Buffer_Ptr->Data_Tmp_Changed, Buffer_Ptr->Data_Tmp_Ptr);
+	    if (Buffer_Ptr->Data_Tmp_Ptr != NULL)
+	    	IMRD_LM_LOG_TRACE_1( IMRD_LOG_LEVEL_VERBOSE_2, "Buffer_List: TmpId: (%d)", (short )( ( (IMRT_Delimited_TmpId  *)(Buffer_Ptr->Data_Tmp_Ptr))->TmpId));
+	}
+
+    return (IMRS_OK);
+}
+
+
+
+IMRT_Status MM_Delimited_StrHdl_Copy( IMRT_Buffer *Output_Buffer_Ptr, IMRT_Buffer *Input_Buffer_Ptr )
+{
+	IMRT_Status status;
+	char *func_name = "MM_Delimited_StrHdl_Copy";
+
+	
+	status = IMRS_OK;
+	
+	if (Input_Buffer_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Input buffer pointer NULL" );
+	}
+	else
+	if (Output_Buffer_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Output buffer pointer NULL" );
+	}
+	else
+	/* controle donnees dans Input_Buffer */
+	if (Input_Buffer_Ptr->Status != IMRD_BUFFER_STATUS_ALLOCATED)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Buffer input not allocated");
+	}
+	/* le buffer destinataire ne doit pas comporter de données */ 
+	else if ( ( Output_Buffer_Ptr->Status == IMRD_BUFFER_STATUS_ALLOCATED) ||
+	          ( Output_Buffer_Ptr->Data_Tmp_Ptr != NULL) )
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Buffer output not allocated or Data_Tmp_Ptr no NULL");
+	}
+	else
+	{
+		status = Delimited_Hdl_DataBuf_Alloc(Output_Buffer_Ptr, Input_Buffer_Ptr->Data_Buf_Size);
+		if (status == IMRS_OK)
+		{
+			memcpy( Output_Buffer_Ptr->Data_Buf_Ptr,
+			        Input_Buffer_Ptr->Data_Buf_Ptr,
+			        Input_Buffer_Ptr->Data_Buf_Size);
+			Output_Buffer_Ptr->Data_Buf_Len = Input_Buffer_Ptr->Data_Buf_Len;
+			if (Input_Buffer_Ptr->Data_Tmp_Ptr != NULL)
+			{
+			        memcpy( Output_Buffer_Ptr->Data_Tmp_Ptr,
+			                Input_Buffer_Ptr->Data_Tmp_Ptr,
+			                sizeof(IMRT_Delimited_TmpId));
+			}
+		}
+	}
+ 
+
+	return ( status );
+}
+
+IMRT_Status	Delimited_Hdl_Field_Exist(IMRT_Field *Field_Ptr , IMRT_Buffer *Buffer_Ptr)
+{
+        IMRT_Status status;
+        char *func_name = "Delimited_Hdl_Field_Exist";
+        
+	
+	status   = IMRS_OK;
+
+
+	if (Buffer_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Buffer pointer NULL" );
+	}
+	else
+	if (Field_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Field pointer NULL" );
+	}
+	else
+        if (Field_Ptr->Delimited.Id >= ((IMRT_Delimited_TmpId *)(Buffer_Ptr->Data_Tmp_Ptr))->TmpId)
+        {
+                status   = IMRS_NO_IDENT;
+                IMRD_LM_LOG_TRACE_0(IMRD_LOG_LEVEL_VERBOSE_1 , "Field not exist");
+        }
+        
+
+	return ( status );
+
+}
+
+IMRT_Status	MM_Delimited_StrHdl_Get(IMRT_Buffer_Data **Data_Ptr_Ptr, IMRT_Field *Field_Ptr,  
+                                IMRT_Buffer *Buffer_Ptr , size_t *len )
+{
+	IMRT_Buffer_Data *data_ptr;
+	IMRT_Buffer_Data *deb_data_ptr;
+	IMRT_Buffer_Data *end_data_ptr;
+	IMRT_Status status;
+	IMRT_Status status_ret;
+	char *delim_ptr;
+	IMRT_FmtAttr_Value delimiteur;
+	size_t sizeTmp;
+	size_t delimLen;
+	char indicateur[2];
+	short indice;
+	
+	char *func_name = "MM_Delimited_StrHdl_Get";
+
+	
+	status   = IMRS_OK;
+	deb_data_ptr = NULL;
+	end_data_ptr = NULL;
+	sizeTmp = 0L;
+	indice = 0;
+	
+	if (Data_Ptr_Ptr == NULL) 
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Data_Ptr_Ptr NULL");
+	}
+	else if (len == NULL) 
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("len pointer NULL");
+	}
+	else if (Buffer_Ptr == NULL) 
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Buffer_Ptr NULL");
+	}
+	else if (Field_Ptr == NULL) 
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Field_Ptr NULL");
+	}
+	else if (strcmp((Buffer_Ptr->FmtAttr_Value) , "") == 0)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Delimiteur vide");
+	}
+		
+
+	if ( status == IMRS_OK )
+	{
+		strncpy(indicateur , Buffer_Ptr->FmtAttr_Value , 1);
+		indicateur[1] = '\0';
+		strcpy(delimiteur , "");
+		delim_ptr = (Buffer_Ptr->FmtAttr_Value);
+		delim_ptr++;
+		strcpy(delimiteur , delim_ptr);
+		delimLen = strlen(delimiteur);
+	}
+
+	/* Controle de validite de l'indicateur  */
+	if ((strcmp(indicateur , "S") != 0) && (strcmp(indicateur , "T") != 0))
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_1("Indicateur non correct [%s]",indicateur);
+	}
+
+
+        /* Controle de validite de l'Id */
+        if (status == IMRS_OK)
+        {
+	        if (Field_Ptr->Delimited.Id == IMRD_DELIMITED_ID_UNKNOWN)
+	        {
+	            status   = IMRS_KO;
+	            IMRD_LM_LOG_ERROR_0("Occurence Delimited unknown");
+	        }
+	}
+
+        /* Controle de l'existence du champ */
+        if (status == IMRS_OK)
+                status = Delimited_Hdl_Field_Exist(Field_Ptr , Buffer_Ptr);
+        /* Le champ n'existe pas => on prend la valeur par defaut */
+        if (status == IMRS_NO_IDENT)
+        {
+                sizeTmp = strlen(Field_Ptr->Delimited.Def_Val);
+                data_ptr = (IMRT_Buffer_Data *) malloc ( sizeTmp + 1);
+                if (data_ptr == NULL)
+                {
+                        status   = IMRS_KO;
+                        IMRD_LM_LOG_ERROR_0("Malloc error");
+                }
+                else
+                {
+                        memset( data_ptr, '\0', sizeTmp + 1 );
+                        memcpy(data_ptr , Field_Ptr->Delimited.Def_Val , sizeTmp );
+                        *(data_ptr + sizeTmp) = '\0';
+                        *Data_Ptr_Ptr = data_ptr;
+                        status   = IMRS_OK;
+                }
+        }       
+        /* le champ existe => on extrait la valeur */
+        else if (status == IMRS_OK)
+        {
+                /* positionnement au debut de la chaine */
+                deb_data_ptr = Buffer_Ptr->Data_Buf_Ptr;
+                /* Placement sur la bonne occurence */
+                while ((indice < Field_Ptr->Delimited.Id)&&(status == IMRS_OK))
+                {
+                        deb_data_ptr = (IMRT_Buffer_Data *)strstr((const char *)deb_data_ptr , (const char *)delimiteur);
+                        if (deb_data_ptr == NULL)
+                        {
+                                status   = IMRS_KO;
+                                IMRD_LM_LOG_ERROR_0("Search occurence error");
+                        }
+                        else
+                        {
+                                deb_data_ptr = deb_data_ptr + delimLen ;
+                                indice++;
+                        }
+                }
+                /*positionnement a la fin de la chaine */
+                end_data_ptr = (IMRT_Buffer_Data *)strstr((const char *)deb_data_ptr , (const char *)delimiteur);
+                if (end_data_ptr == NULL)
+                {
+                	/* Si l'indicateur est S */
+                        /* Si c'est la derniere occurence il n'y a pas de delimiteur */
+                        if (strcmp(indicateur , "S") == 0)
+                        	sizeTmp = (Buffer_Ptr->Data_Buf_Len - (deb_data_ptr - (Buffer_Ptr->Data_Buf_Ptr)));
+                        else
+                        {
+                        	status   = IMRS_KO;
+                        	IMRD_LM_LOG_ERROR_0("Incorrect format");
+                        }
+                }
+                else
+                {
+                        sizeTmp = end_data_ptr - deb_data_ptr ;
+                }
+                data_ptr = (IMRT_Buffer_Data *) malloc ( sizeTmp + 1);
+                if (data_ptr == NULL)
+                {
+                        status   = IMRS_KO;
+                        IMRD_LM_LOG_ERROR_0("Malloc error");
+                }
+                else
+                {
+                        memset( data_ptr, '\0', sizeTmp + 1 );
+                        memcpy(data_ptr , deb_data_ptr , sizeTmp );
+                        *(data_ptr + sizeTmp) = '\0';
+                        *Data_Ptr_Ptr = data_ptr;
+                }                
+        }
+
+        if (status == IMRS_OK)
+        {
+                *len = sizeTmp;
+        }
+	
+
+	return ( status );
+}
+
+
+IMRT_Status     IMR_MM_Delimited_StrHdl_Msg_Size( size_t Msg_Size )
+{
+	IMRT_Status status;
+	char *func_name = "IMR_MM_Delimited_StrHdl_Msg_Size";
+
+	IMRD_LM_LOG_TRACE_0(IMRD_LOG_LEVEL_VERBOSE_1 ,  "============================================================================")
+	IMRD_LM_LOG_TRACE_0(IMRD_LOG_LEVEL_VERBOSE_1 , "Size msg demand : Begin");
+	IMRD_LM_LOG_TRACE_1(IMRD_LOG_LEVEL_VERBOSE_1 , "Msg_Size  : (%ld)" , Msg_Size);	
+
+
+        /* Erreur de referentiel */
+        status = IMRS_KO;
+        IMRD_LM_LOG_WARNING_0("Referential error ; this should never happen");
+
+	IMRD_LM_LOG_TRACE_1(IMRD_LOG_LEVEL_VERBOSE_2 , "Size msg demand : End with status :  (%d)" , status);
+	IMRD_LM_LOG_TRACE_0(IMRD_LOG_LEVEL_VERBOSE_2 ,  "============================================================================")
+
+	return ( status );
+}
+
+
+IMRT_Status IMR_MM_Delimited_StrHdl_Field_Exist( IMRT_Field *Field_Ptr )
+{
+	IMRT_Status status;
+	char *func_name = "IMR_MM_Delimited_StrHdl_Field_Exist";
+
+        status = IMRS_OK;
+
+	if (Field_Ptr == NULL) 
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Field_Ptr NULL");
+	}
+	else
+	{
+		IMRD_LM_LOG_TRACE_0(IMRD_LOG_LEVEL_VERBOSE_1 ,  "============================================================================")
+		IMRD_LM_LOG_TRACE_0(IMRD_LOG_LEVEL_VERBOSE_1 , "Existing field demand : Begin");
+		IMRD_LM_LOG_TRACE_1(IMRD_LOG_LEVEL_VERBOSE_1 , "Field Input name  : [%s]" , Field_Ptr->Name);	
+	
+	 	if (IMRG_Delimited_Buffer_Ident_Ptr == NULL)
+		{
+			status = IMRS_KO;
+			IMRD_LM_LOG_ERROR_0("Buffer pointer NULL");
+		}
+		else
+		{
+			status = Delimited_Hdl_Field_Exist( Field_Ptr, IMRG_Delimited_Buffer_Ident_Ptr);
+		}
+	}
+
+
+	IMRD_LM_LOG_TRACE_1(IMRD_LOG_LEVEL_VERBOSE_2 , "Existing field demand : End with status :  (%d)" , status);
+	IMRD_LM_LOG_TRACE_0(IMRD_LOG_LEVEL_VERBOSE_2 ,  "============================================================================")
+
+
+	return ( status );
+}
+
+
+IMRT_Status IMR_MM_Delimited_StrHdl_Field_Value( IMRT_Field *Field_Ptr , IMRT_Field_Value_Id Value_Id )
+{
+	IMRT_Buffer_Data *data_ptr;
+	IMRT_Status status;
+	size_t field_len;
+	char *func_name = "IMR_MM_Delimited_StrHdl_Field_Value";
+
+        status = IMRS_OK;
+
+	if (Field_Ptr == NULL) 
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Field_Ptr NULL");
+	}
+	else
+	{
+		IMRD_LM_LOG_TRACE_0(IMRD_LOG_LEVEL_VERBOSE_1 ,  "============================================================================")
+		IMRD_LM_LOG_TRACE_0(IMRD_LOG_LEVEL_VERBOSE_1 , "Field Value demand : Begin");
+		IMRD_LM_LOG_TRACE_2(IMRD_LOG_LEVEL_VERBOSE_1 , "Field Input name  : [%s] Value Id : [%s]" , Field_Ptr->Name , Value_Id);	
+	
+	
+		field_len = 0L;
+		
+		if (IMRG_Delimited_Buffer_Ident_Ptr == NULL)
+		{
+			status = IMRS_KO;
+			IMRD_LM_LOG_ERROR_0("Buffer pointer NULL");
+		}
+		else
+		{
+			status = MM_Delimited_StrHdl_Get(&data_ptr, Field_Ptr, IMRG_Delimited_Buffer_Ident_Ptr , &field_len);
+		}
+		if (status == IMRS_OK)
+		{
+			IMRD_LM_LOG_TRACE_1(IMRD_LOG_LEVEL_VERBOSE_2 , "Value extracted :  [%s]" , data_ptr);
+			if (strcmp(data_ptr, Value_Id) != 0)
+			{
+				status = IMRS_NO_IDENT;
+			}
+			free(data_ptr);
+		}
+	}
+	
+	IMRD_LM_LOG_TRACE_1(IMRD_LOG_LEVEL_VERBOSE_2 , "Field Value demand : End with status :  (%d)" , status);
+	IMRD_LM_LOG_TRACE_0(IMRD_LOG_LEVEL_VERBOSE_2 ,  "============================================================================")
+
+	return ( status );
+}
+
+IMRT_Status	MM_Delimited_StrHdl_Convert(IMRT_Buffer_Data **Data_Output_Ptr , IMRT_Buffer_Data *Data_Input_Ptr , IMRT_Field *Field_Ptr,  
+                                        size_t *len , IMRT_StrHdl_Cnv_Func *Cnv_Func_Tab )
+{
+	IMRT_Status status;
+	IMRT_Buffer_Data *data_tmp_Ptr = NULL;
+        size_t size;
+	char *func_name = "MM_Delimited_StrHdl_Convert";
+
+
+	
+	status = IMRS_OK;
+
+	if (Data_Output_Ptr == NULL) 
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Data_Output_Ptr NULL");
+	}
+	else if (Cnv_Func_Tab == NULL) 
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Cnv_Func_Tab NULL");
+	}
+	else if (len == NULL) 
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("len pointer NULL");
+	}
+	else if (Field_Ptr == NULL) 
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Field_Ptr NULL");
+	}
+	else
+	if (Data_Input_Ptr == NULL) 
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Data_Input_Ptr NULL");
+	}
+	else
+	{
+ 		size = Field_Ptr->Fixed.Size;
+
+		data_tmp_Ptr = (IMRT_Buffer_Data *)malloc(size + 1L);
+	        memset( data_tmp_Ptr, '\0' , (size + 1L) );
+	
+	
+	        /* Appel de la fonction de convertion */
+	
+		if ((Field_Ptr->Delimited.Cnv_Ptr == NULL) ||(Cnv_Func_Tab[Field_Ptr->Delimited.Cnv_Ptr->Id].Convert_Ptr == NULL))
+		{
+			IMRD_LM_LOG_TRACE_0( IMRD_LOG_LEVEL_VERBOSE_1 , "Pas de fonction de conversion");
+	
+	                if (Data_Input_Ptr != NULL)
+	                {
+	                   	*Data_Output_Ptr = data_tmp_Ptr;
+		        	memcpy(*Data_Output_Ptr,Data_Input_Ptr,*len);
+		        }
+		}
+		else
+		{
+			status = Cnv_Func_Tab[Field_Ptr->Delimited.Cnv_Ptr->Id].Convert_Ptr( data_tmp_Ptr, 
+			                                                         Data_Input_Ptr, 
+			                                                         len ,
+			                                                         size ,
+			                                                         Field_Ptr->Delimited.Cnv_Attr );
+	                *Data_Output_Ptr = data_tmp_Ptr;
+		}
+	}
+
+        if (Data_Input_Ptr != NULL)
+                free(Data_Input_Ptr);
+                
+
+	return ( status );
+
+}
+
+IMRT_Status	MM_Delimited_StrHdl_Put(IMRT_Buffer_Data *Data_Ptr, IMRT_Field *Field_Ptr,  
+                                IMRT_Buffer *Buffer_Ptr , size_t len )
+{
+	IMRT_Buffer_Data *data_buf_ptr;
+	size_t data_len;
+	size_t delim_len;
+	size_t data_max_len;
+	IMRT_Delimited_TmpId *TmpId_Ptr;
+	char *delim_ptr;
+	int occ;
+	IMRT_FmtAttr_Value delimiteur;
+	char indicateur[2];
+	IMRT_Status status;
+	char *func_name = "MM_Delimited_StrHdl_Put";
+
+	
+	status = IMRS_OK;
+	
+	if (Buffer_Ptr == NULL) 
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Buffer_Ptr NULL");
+	}
+	else if (strcmp((Buffer_Ptr->FmtAttr_Value) , "") == 0)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Delimiteur vide");
+	}
+	else if (Field_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Field_Ptr NULL");
+	}
+	else if (Data_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("data pointer NULL");
+	}
+		
+	if ( status == IMRS_OK )
+	{
+		strcpy(delimiteur , "");
+		strncpy(indicateur , Buffer_Ptr->FmtAttr_Value , 1);
+		indicateur[1] = '\0';
+		delim_ptr = NULL;
+		delim_ptr = (Buffer_Ptr->FmtAttr_Value);
+		delim_ptr++;
+		strcpy(delimiteur , delim_ptr);
+		delim_len = strlen(delimiteur);
+	
+	
+	/* Controle de validite de l'indicateur  */
+		if ((strcmp(indicateur , "S") != 0) && (strcmp(indicateur , "T") != 0))
+		{
+			status = IMRS_KO;
+			IMRD_LM_LOG_ERROR_1("Indicateur non correct [%s]",indicateur);
+		}
+	}
+	
+	/* Controle de validite du delimiteur */
+	if ( status == IMRS_OK )
+	{
+		if (strcmp(delimiteur , "") == 0)
+		{
+			status = IMRS_KO;
+			IMRD_LM_LOG_ERROR_0("Delimiteur vide");
+		}
+	}
+	 
+	if ( status == IMRS_OK )
+	{	
+	        /* Controle de validite de l'Id */
+	        if (Field_Ptr->Delimited.Id == IMRD_DELIMITED_ID_UNKNOWN)
+	        {
+	            status   = IMRS_KO;
+	            IMRD_LM_LOG_ERROR_0("Occurence Delimited unknown");
+	        }
+	}
+
+	if ( status == IMRS_OK )
+	{
+        	occ = (((IMRT_Delimited_TmpId *)(Buffer_Ptr->Data_Tmp_Ptr))->TmpId);
+        	/* la len est recuperee de la fonction de convertion */
+        	data_len     = len;
+        	
+        	TmpId_Ptr = (IMRT_Delimited_TmpId *)Buffer_Ptr->Data_Tmp_Ptr;
+        
+        
+                /* Controle de l' occurence */
+                if (Field_Ptr->Delimited.Id > occ)
+        	{
+        		status = IMRS_KO;
+        		IMRD_LM_LOG_ERROR_2("Occurence (%d) not valid in [%s]",Field_Ptr->Delimited.Id,func_name);
+        	}
+        }
+
+	if ( status == IMRS_OK )
+	{
+                /* Controle de la taille */
+                data_max_len = Buffer_Ptr->Data_Buf_Len + data_len + delim_len;
+                if (Buffer_Ptr->Data_Buf_Size <= data_max_len)
+                        status = Delimited_Hdl_DataBuf_Alloc( Buffer_Ptr, data_max_len + 1 ); 
+        }               
+
+
+	/* l'indicateur est 'S' */
+
+	if (( status == IMRS_OK )&&(strcmp(indicateur , "S")) == 0)
+	{
+		/* insertion de la valeur dans les donnees du buffer */
+		
+		data_buf_ptr = Buffer_Ptr->Data_Buf_Ptr + Buffer_Ptr->Data_Buf_Len ;
+		
+		/* on n'insere le d‚limiteur qu'a partir de la deuxieme occurence (1) */
+		if (occ != 0)
+		{
+        		memcpy(data_buf_ptr, delimiteur, delim_len);
+        		memcpy(data_buf_ptr + delim_len , Data_Ptr , data_len) ;				
+        		Buffer_Ptr->Data_Buf_Len = data_max_len;
+		}
+		else
+		{
+		        memcpy(data_buf_ptr , Data_Ptr , data_len) ;
+		        Buffer_Ptr->Data_Buf_Len = Buffer_Ptr->Data_Buf_Len + data_len ;
+		}
+		occ++;
+		TmpId_Ptr->TmpId = (IMRT_Delimited_Id)occ;
+	}
+	else /* l'indicateur est 'T' */
+	if (( status == IMRS_OK )&&(strcmp(indicateur , "T") == 0))
+	{
+		/* insertion de la valeur dans les donnees du buffer */
+		data_buf_ptr = Buffer_Ptr->Data_Buf_Ptr + Buffer_Ptr->Data_Buf_Len ;
+		
+		/* on insere systematiquement le d‚limiteur en fin de chaine */
+       		memcpy(data_buf_ptr , Data_Ptr , data_len) ;				
+       		memcpy(data_buf_ptr + data_len , delimiteur, delim_len);
+       		Buffer_Ptr->Data_Buf_Len = data_max_len;
+		occ++;
+		TmpId_Ptr->TmpId = (IMRT_Delimited_Id)occ;
+		 
+	}
+
+	IMRD_LM_LOG_TRACE_1( IMRD_LOG_LEVEL_VERBOSE_2 , "Prochaine occurence apres put (%d)",TmpId_Ptr->TmpId); 
+	
+	if (Data_Ptr != NULL)
+                free(Data_Ptr);
+
+	
+
+	return ( status );
+}
diff --git a/src/libmapping_mng/src/fmt_hdl_dltd.h b/src/libmapping_mng/src/fmt_hdl_dltd.h
new file mode 100644
index 0000000..0a0622b
--- /dev/null
+++ b/src/libmapping_mng/src/fmt_hdl_dltd.h
@@ -0,0 +1,115 @@
+/*----------------------------------------------------------------------------*/
+/* File: fmt_hdl_dltd.h    				         	      */
+/*----------------------------------------------------------------------------*/
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#ifndef _DELIMITED_HANDLER_H_
+#define _DELIMITED_HANDLER_H_
+
+/*----------------------------------------------------------------------------*/
+/* Global Include                                                             */
+/*----------------------------------------------------------------------------*/
+
+#include "libmapping_mng.h"
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Local definition                                                           */
+/*----------------------------------------------------------------------------*/
+
+#ifdef _DELIMITED_HANDLER_C_
+		
+#   define DELIMITED_TAILLE_ALLOC 100000
+    
+    typedef struct IMRT_Delimited_TmpId
+        {
+	        IMRT_Delimited_Id TmpId;
+        } IMRT_Delimited_TmpId;
+
+
+#endif
+
+
+/*----------------------------------------------------------------------------*/
+/*	Global Variables                                                      */
+/*----------------------------------------------------------------------------*/
+#ifdef _DELIMITED_HANDLER_C_
+		
+    IMRT_Buffer	*IMRG_Delimited_Buffer_Ident_Ptr;
+
+#endif
+
+/*----------------------------------------------------------------------------*/
+/*	Prototypes							      */
+/*----------------------------------------------------------------------------*/
+
+#ifdef _DELIMITED_HANDLER_C_
+
+    IMRT_Status	    MM_Delimited_StrHdl_Init            ( void );
+    IMRT_Status	    MM_Delimited_StrHdl_DeInit          ( void );
+    IMRT_Status	    Delimited_Hdl_DataBuf_Alloc	        ( IMRT_Buffer * , size_t );
+    IMRT_Status	    MM_Delimited_StrHdl_Data_Free       ( IMRT_Buffer * );
+    IMRT_Status	    Delimited_Hdl_Format_Ident	        ( IMRT_Buffer * );
+    IMRT_Status     MM_Delimited_StrHdl_Ident           ( IMRT_Msg_Id * , IMRT_Buffer * );
+    IMRT_Status     Delimited_Hdl_Occ_Count             ( IMRT_Buffer_Data * , short * , IMRT_FmtAttr_Value );
+    IMRT_Status     Delimited_Hdl_TmpId_Init            ( IMRT_Buffer * , short );
+    IMRT_Status	    MM_Delimited_StrHdl_Open	        ( IMRT_Buffer * );
+    IMRT_Status	    MM_Delimited_StrHdl_Close	        ( IMRT_Buffer * );
+    IMRT_Status     MM_Delimited_StrHdl_Flush           ( IMRT_Buffer * );
+    IMRT_Status	    MM_Delimited_StrHdl_Flush           ( IMRT_Buffer * );
+    IMRT_Status	    MM_Delimited_StrHdl_Data_List       ( IMRT_Buffer * );
+    IMRT_Status	    MM_Delimited_StrHdl_Copy	        ( IMRT_Buffer * , IMRT_Buffer * );
+    IMRT_Status	    Delimited_Hdl_Field_Exist           ( IMRT_Field * , IMRT_Buffer * );
+    IMRT_Status     MM_Delimited_StrHdl_Get             ( IMRT_Buffer_Data ** , IMRT_Field * , IMRT_Buffer * , size_t * );
+    IMRT_Status	    MM_Delimited_StrHdl_Convert	        ( IMRT_Buffer_Data ** , IMRT_Buffer_Data * , IMRT_Field * , size_t *, IMRT_StrHdl_Cnv_Func * );
+    IMRT_Status	    MM_Delimited_StrHdl_Put	        ( IMRT_Buffer_Data * , IMRT_Field * , IMRT_Buffer * , size_t );
+    IMRT_Status     IMR_MM_Delimited_StrHdl_Field_Value ( IMRT_Field * , IMRT_Field_Value_Id);
+    IMRT_Status     IMR_MM_Delimited_StrHdl_Field_Exist ( IMRT_Field * );
+    IMRT_Status     IMR_MM_Delimited_StrHdl_Msg_Size    ( size_t );
+#else
+
+    extern IMRT_Status  MM_Delimited_StrHdl_Init            ( void );
+    extern IMRT_Status  MM_Delimited_StrHdl_DeInit          ( void );
+    extern IMRT_Status  MM_Delimited_StrHdl_Library_Open    ( void );
+    extern IMRT_Status  MM_Delimited_StrHdl_Data_Free       ( IMRT_Buffer * );
+    extern IMRT_Status  MM_Delimited_StrHdl_Ident           ( IMRT_Msg_Id * , IMRT_Buffer * );
+    extern IMRT_Status  MM_Delimited_StrHdl_Open            ( IMRT_Buffer * );
+    extern IMRT_Status  MM_Delimited_StrHdl_Close	    ( IMRT_Buffer * );
+    extern IMRT_Status  MM_Delimited_StrHdl_Flush           ( IMRT_Buffer * );
+    extern IMRT_Status  MM_Delimited_StrHdl_Flush	    ( IMRT_Buffer * );
+    extern IMRT_Status  MM_Delimited_StrHdl_Data_List       ( IMRT_Buffer * );
+    extern IMRT_Status  MM_Delimited_StrHdl_Copy	    ( IMRT_Buffer * , IMRT_Buffer * );
+    extern IMRT_Status  MM_Delimited_StrHdl_Get		    ( IMRT_Buffer_Data ** , IMRT_Field * , IMRT_Buffer * , size_t * );
+    extern IMRT_Status	MM_Delimited_StrHdl_Convert	    ( IMRT_Buffer_Data ** , IMRT_Buffer_Data * , IMRT_Field * , size_t *, IMRT_StrHdl_Cnv_Func * );
+    extern IMRT_Status  MM_Delimited_StrHdl_Put		    ( IMRT_Buffer_Data * , IMRT_Field * , IMRT_Buffer * , size_t );
+
+#endif
+
+/*----------------------------------------------------------------------------*/
+
+#endif                                   
+
diff --git a/src/libmapping_mng/src/fmt_hdl_fixed.c b/src/libmapping_mng/src/fmt_hdl_fixed.c
new file mode 100644
index 0000000..cd02ef6
--- /dev/null
+++ b/src/libmapping_mng/src/fmt_hdl_fixed.c
@@ -0,0 +1,744 @@
+/*----------------------------------------------------------------------------*/
+/* File: fmt_hdl_fixed.c    				         	      */
+/*----------------------------------------------------------------------------*/
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#define _LIBMAPPING_MNG_
+#define _FIXED_HANDLER_C_
+
+#include "fmt_hdl_fixed.h" 
+
+IMRT_Status	MM_Fixed_StrHdl_Init()
+{
+	IMRG_Fixed_Buffer_Ident_Ptr = NULL;
+	return (IMRS_OK);
+}
+
+IMRT_Status	MM_Fixed_StrHdl_DeInit()
+{
+
+	return (IMRS_OK);
+}
+IMRT_Status Fixed_Hdl_DataBuf_Alloc( IMRT_Buffer *Buffer_Ptr, size_t Taille_Alloc )
+{
+	IMRT_Buffer_Data *data_Ptr;
+	IMRT_Status status;
+	char *func_name = "Fixed_Hdl_DataBuf_Alloc";
+
+	
+	status   = IMRS_OK;
+	data_Ptr = NULL;
+
+	if (Buffer_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Buffer pointer NULL" );
+	}
+	else
+	if (Buffer_Ptr->Status == IMRD_BUFFER_STATUS_ALLOCATED)
+	{
+		if (Taille_Alloc > Buffer_Ptr->Data_Buf_Size)
+		{
+			data_Ptr = (IMRT_Buffer_Data *) realloc ( (void *) Buffer_Ptr->Data_Buf_Ptr, Taille_Alloc );
+			if (data_Ptr == NULL)
+			{
+				status = IMRS_KO;
+				IMRD_LM_LOG_ERROR_0("Realloc error");
+			}
+			else
+			{
+				memset( data_Ptr + Buffer_Ptr->Data_Buf_Size, '\0', Taille_Alloc - Buffer_Ptr->Data_Buf_Size );
+				Buffer_Ptr->Data_Buf_Ptr  = data_Ptr;
+				Buffer_Ptr->Data_Buf_Size = Taille_Alloc;
+			}
+		}
+	}
+	else
+	{
+		data_Ptr = (IMRT_Buffer_Data *) malloc ( Taille_Alloc );
+		if (data_Ptr == NULL)
+		{
+			status = IMRS_KO;
+			IMRD_LM_LOG_ERROR_0("Malloc error");
+		}
+		else
+		{
+			memset( data_Ptr, '\0', Taille_Alloc );
+			Buffer_Ptr->Data_Buf_Ptr  = data_Ptr;
+			Buffer_Ptr->Status        = IMRD_BUFFER_STATUS_ALLOCATED;
+			Buffer_Ptr->Data_Buf_Size = Taille_Alloc;
+			Buffer_Ptr->Data_Buf_Len  = 0;
+		}
+	}
+	
+
+	return ( status );
+}
+
+IMRT_Status MM_Fixed_StrHdl_Data_Free( IMRT_Buffer  *Buffer_Ptr)
+{
+	IMRT_Status status;
+	char *func_name = "MM_Fixed_StrHdl_Data_Free";
+
+	
+	status = IMRS_OK;
+
+	if (Buffer_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Buffer pointer NULL" );
+	}
+	else
+	if (Buffer_Ptr->Status == IMRD_BUFFER_STATUS_ALLOCATED)
+	{
+		free(Buffer_Ptr->Data_Buf_Ptr);
+		Buffer_Ptr->Data_Buf_Ptr  = NULL;	
+		Buffer_Ptr->Status        = IMRD_BUFFER_STATUS_FREED;
+		Buffer_Ptr->Data_Buf_Size = 0;
+		Buffer_Ptr->Data_Buf_Len  = 0;		
+	}
+
+	return ( status );
+}
+
+IMRT_Status Fixed_Hdl_Format_Ident( IMRT_Buffer *Buffer_Ptr )
+{
+	IMRT_Status status;
+	char *func_name = "Fixed_Hdl_Format_Ident";
+
+
+	if (Buffer_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Buffer pointer NULL" );
+	}
+	else
+	if (Buffer_Ptr->Status == IMRD_BUFFER_STATUS_ALLOCATED)
+	{
+		status = IMRS_OK;
+	}
+	else
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Buffer not allocated");
+	}
+	
+
+	return ( status );
+}
+
+IMRT_Status MM_Fixed_StrHdl_Ident( IMRT_Msg_Id *Msg_Id_Ident_Ptr, 
+                                  IMRT_Buffer *Buffer_Ptr )
+{
+        
+        IMRT_Fmt_Id Format;
+        IMRT_Status status;
+        IMRT_Msg_Id *Msg_Id_Tmp;
+        char *func_name = "MM_Fixed_StrHdl_Ident";
+        
+
+	if (Buffer_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Buffer pointer NULL" );
+	}
+	else
+	if (Msg_Id_Ident_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Msg_Id_Ident_Ptr NULL" );
+	}
+	else
+	{
+	        Format = Buffer_Ptr->Fmt_Id;
+	        Msg_Id_Tmp = Msg_Id_Ident_Ptr;
+	        status = IMRS_OK;
+	
+		IMRG_Fixed_Buffer_Ident_Ptr = Buffer_Ptr;
+		/* Le Msg_Id transmis au SDM est le point de depart de l'identification */
+		/* C'est egalement le resultat qui sera inclus dans le buffer */
+		status = IMR_SDM_MsgIdent_Proceed(Format, 
+		                                  Msg_Id_Tmp,
+		                                  IMR_MM_Fixed_StrHdl_Field_Value,
+		                                  IMR_MM_Fixed_StrHdl_Field_Exist,
+		                                  IMR_MM_Fixed_StrHdl_Msg_Size);
+		IMRG_Fixed_Buffer_Ident_Ptr = NULL;
+	
+	        Msg_Id_Ident_Ptr = Msg_Id_Tmp;
+	}
+
+
+	return ( status );
+
+}
+
+IMRT_Status MM_Fixed_StrHdl_Open( IMRT_Buffer *Buffer_Ptr)
+{
+	IMRT_Msg_Id type_temp;
+	IMRT_Status status;
+	char *func_name = "MM_Fixed_StrHdl_Open";
+
+
+	status = IMRS_OK;
+	if (Buffer_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Buffer pointer NULL" );
+	}
+	else
+	{
+		type_temp = Buffer_Ptr->Msg_Id;
+		/* absence de données */
+		if (Buffer_Ptr->Status != IMRD_BUFFER_STATUS_ALLOCATED)
+		{
+		        /* Cas d'open du buffer en ecriture */
+		        /* le type du message est passe */
+		        /* par le SDM : il doit donc etre connu */
+			if (type_temp == IMRD_MSG_ID_UNKNOWN) 
+			{
+				status = IMRS_KO;
+				IMRD_LM_LOG_ERROR_0("Msg Id unknown");
+			}
+			else
+			{
+				status = Fixed_Hdl_DataBuf_Alloc( Buffer_Ptr, FIXED_TAILLE_ALLOC );
+			}
+		}
+		else 
+	        {
+	                /* controle du format */
+	                status = Fixed_Hdl_Format_Ident( Buffer_Ptr ) ;
+	                if (status != IMRS_OK)
+	                {
+	                        status = IMRS_BAD_FORMAT;
+	                }       
+	        }
+	}
+	
+	
+
+	return ( status );
+}
+
+
+IMRT_Status MM_Fixed_StrHdl_Close( IMRT_Buffer *Buffer_Ptr)
+{
+	char *func_name = "MM_Fixed_StrHdl_Close";
+
+
+	return (IMRS_OK);
+}
+
+IMRT_Status	MM_Fixed_StrHdl_Flush( IMRT_Buffer  *Buffer_Ptr)
+{
+	char *func_name = "MM_Fixed_StrHdl_Flush";
+
+	return (IMRS_OK);
+}
+
+
+
+IMRT_Status MM_Fixed_StrHdl_Data_List( IMRT_Buffer *Buffer_Ptr)
+{
+	if (Buffer_Ptr == NULL)
+	{
+		IMRD_LM_LOG_WARNING_0("Buffer pointer NULL" );
+	}
+	else
+	{
+	    IMRD_LM_LOG_TRACE_3( IMRD_LOG_LEVEL_VERBOSE_1, "Buffer_List: Data_Buf_Ptr_Size: (%d)   Data_Buf_Ptr_Len: (%d)   Data_Buf_Ptr: (0x%X)", Buffer_Ptr->Data_Buf_Size, Buffer_Ptr->Data_Buf_Len, Buffer_Ptr->Data_Buf_Ptr);
+	    IMRD_LM_LOG_TRACE_1( IMRD_LOG_LEVEL_VERBOSE_2, "Buffer_List: Data_Buf: [%s]", Buffer_Ptr->Data_Buf_Ptr);
+	
+	    IMRD_LM_LOG_TRACE_2( IMRD_LOG_LEVEL_VERBOSE_1, "Buffer_List: Data_Tmp_Changed: (%d)   Data_Tmp_Ptr: (0x%X)", Buffer_Ptr->Data_Tmp_Changed, Buffer_Ptr->Data_Tmp_Ptr);
+	    if (Buffer_Ptr->Data_Tmp_Ptr != NULL)
+		    IMRD_LM_LOG_TRACE_1( IMRD_LOG_LEVEL_VERBOSE_2, "Buffer_List: Data_Tmp: [%s]", Buffer_Ptr->Data_Tmp_Ptr);
+	}
+
+    return (IMRS_OK);
+}
+
+
+
+IMRT_Status MM_Fixed_StrHdl_Copy( IMRT_Buffer *Output_Buffer_Ptr, IMRT_Buffer *Input_Buffer_Ptr )
+{
+	IMRT_Status status;
+	char *func_name = "MM_Fixed_StrHdl_Copy";
+
+	
+	status = IMRS_OK;
+	
+	if (Input_Buffer_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Input buffer pointer NULL" );
+	}
+	else
+	if (Output_Buffer_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Output buffer pointer NULL" );
+	}
+	else
+	/* controle donnees dans Input_Buffer */
+	if (Input_Buffer_Ptr->Status != IMRD_BUFFER_STATUS_ALLOCATED)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Buffer input not allocated");
+	}
+	/* le buffer destinataire ne doit pas comporter de données */ 
+	else if ( ( Output_Buffer_Ptr->Status == IMRD_BUFFER_STATUS_ALLOCATED) ||
+	          ( Output_Buffer_Ptr->Data_Tmp_Ptr != NULL) )
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Buffer output not allocated or Data_Tmp_Ptr no NULL");
+	}
+	else
+	{
+		status = Fixed_Hdl_DataBuf_Alloc(Output_Buffer_Ptr, Input_Buffer_Ptr->Data_Buf_Size);
+		if (status == IMRS_OK)
+		{
+			memcpy( Output_Buffer_Ptr->Data_Buf_Ptr,
+			        Input_Buffer_Ptr->Data_Buf_Ptr,
+			        Input_Buffer_Ptr->Data_Buf_Size);
+			Output_Buffer_Ptr->Data_Buf_Len = Input_Buffer_Ptr->Data_Buf_Len;
+		}
+	}
+ 
+
+	return ( status );
+}
+
+IMRT_Status	Fixed_Hdl_Field_Exist(IMRT_Field *Field_Ptr , IMRT_Buffer *Buffer_Ptr)
+{
+        IMRT_Status status;
+        char *func_name = "Fixed_Hdl_Field_Exist";
+        
+        /* En fixed, pas de cas de champ inexistant */      
+	
+	status   = IMRS_OK;
+
+	return ( status );
+
+}
+
+
+IMRT_Status	MM_Fixed_StrHdl_Get(IMRT_Buffer_Data **Data_Ptr_Ptr, IMRT_Field *Field_Ptr,  
+                                IMRT_Buffer *Buffer_Ptr , size_t *len )
+{
+	IMRT_Buffer_Data *data_ptr;
+	IMRT_Status status;
+	int offsetTmp;
+	size_t sizeTmp;
+	char *func_name = "MM_Fixed_StrHdl_Get";
+
+	
+	status   = IMRS_OK;
+	data_ptr = NULL;
+	offsetTmp = 0;
+	sizeTmp = 0L;
+	
+	if (Data_Ptr_Ptr == NULL) 
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Data_Ptr_Ptr NULL");
+	}
+	else if (len == NULL) 
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("len pointer NULL");
+	}
+	else if (Buffer_Ptr == NULL) 
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Buffer_Ptr NULL");
+	}
+	else if (Field_Ptr == NULL) 
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Field_Ptr NULL");
+	}
+	else 
+	   /* Controle de validite de la taille */
+        if (Field_Ptr->Fixed.Size == IMRD_FIXED_SIZE_UNKNOWN)
+        {
+            status   = IMRS_KO;
+            IMRD_LM_LOG_ERROR_0("Size Fixed unknown");
+        }
+
+
+        if (status == IMRS_OK)
+        {
+	/* controle sur l'offset */
+        	if (Field_Ptr->Fixed.Offset > Buffer_Ptr->Data_Buf_Len )
+        	{
+        		status   = IMRS_KO;
+        		IMRD_LM_LOG_ERROR_0("Field offset out of data len");
+        	}
+        }
+	
+        /* Controle de l'existence du champ */
+	if (status == IMRS_OK)
+	{
+	        status = Fixed_Hdl_Field_Exist(Field_Ptr , Buffer_Ptr);
+	}
+	
+        /* Le champ n'existe pas => on prend la valeur par defaut */
+        /* Actuellement, ca ne peut pas arriver en Fixed */
+        if (status == IMRS_NO_IDENT)
+        {
+                sizeTmp = strlen(Field_Ptr->Fixed.Def_Val);
+                data_ptr = (IMRT_Buffer_Data *) malloc ( sizeTmp + 1);
+                if (data_ptr == NULL)
+                {
+                        status   = IMRS_KO;
+                        IMRD_LM_LOG_ERROR_0("Malloc error");
+                }
+                else
+                {
+                        memset( data_ptr, '\0', sizeTmp + 1 );
+                        memcpy(data_ptr , Field_Ptr->Fixed.Def_Val , sizeTmp );
+                        *(data_ptr + sizeTmp) = '\0';
+                        *Data_Ptr_Ptr = data_ptr;
+                        status   = IMRS_OK;
+                }                
+
+        }
+	else if (status == IMRS_OK)
+	{
+		/* cas ou Field_Ptr->Fixed.Size = 0 => on prend tout le champ */
+		/* idem si offset + size > len du message */
+		if((Field_Ptr->Fixed.Size == 0L) ||( Field_Ptr->Fixed.Offset + Field_Ptr->Fixed.Size > Buffer_Ptr->Data_Buf_Len ) )
+		{
+			sizeTmp = Buffer_Ptr->Data_Buf_Len - Field_Ptr->Fixed.Offset;
+		}
+		else
+		{
+			sizeTmp = Field_Ptr->Fixed.Size;
+		}
+		data_ptr = (IMRT_Buffer_Data *) malloc ( sizeTmp + 1);
+		if (data_ptr == NULL)
+		{
+			status = IMRS_KO;
+			IMRD_LM_LOG_ERROR_0("Malloc error");
+		}
+		else
+		{
+			memcpy( data_ptr, 
+			        Buffer_Ptr->Data_Buf_Ptr + Field_Ptr->Fixed.Offset,
+			       sizeTmp);
+			*(data_ptr + sizeTmp) = '\0';
+			*Data_Ptr_Ptr = data_ptr;
+		}
+		
+	}			     
+	
+        if (status == IMRS_OK)
+        {
+                *len = sizeTmp;
+        }
+
+	
+
+	return ( status );
+}
+
+
+IMRT_Status     IMR_MM_Fixed_StrHdl_Msg_Size    ( size_t Msg_Size)
+{
+	IMRT_Status status;
+	char *func_name = "IMR_MM_Fixed_StrHdl_Msg_Size";
+
+ 	if (IMRG_Fixed_Buffer_Ident_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Buffer pointer NULL");
+	}
+	else
+	{
+		IMRD_LM_LOG_TRACE_0(IMRD_LOG_LEVEL_VERBOSE_1 ,  "============================================================================")
+		IMRD_LM_LOG_TRACE_0(IMRD_LOG_LEVEL_VERBOSE_1 , "Size msg demand : Begin");
+		IMRD_LM_LOG_TRACE_1(IMRD_LOG_LEVEL_VERBOSE_1 , "Msg_Size  : (%ld)" , Msg_Size);	
+		IMRD_LM_LOG_TRACE_1(IMRD_LOG_LEVEL_VERBOSE_1 , "Length of the buffer data  : (%ld)" , IMRG_Fixed_Buffer_Ident_Ptr->Data_Buf_Len);	
+	
+	        status = IMRS_OK;
+	
+	        if (Msg_Size != IMRG_Fixed_Buffer_Ident_Ptr->Data_Buf_Len)
+	                status = IMRS_NO_IDENT;
+	}
+
+	IMRD_LM_LOG_TRACE_1(IMRD_LOG_LEVEL_VERBOSE_2 , "Size msg demand : End with status :  (%d)" , status);
+	IMRD_LM_LOG_TRACE_0(IMRD_LOG_LEVEL_VERBOSE_2 ,  "============================================================================")
+
+	return ( status );
+}
+
+
+IMRT_Status IMR_MM_Fixed_StrHdl_Field_Exist( IMRT_Field *Field_Ptr )
+{
+	IMRT_Status status;
+	char *func_name = "IMR_MM_Fixed_StrHdl_Field_Exist";
+
+        status = IMRS_OK;
+
+	if (Field_Ptr == NULL) 
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Field_Ptr NULL");
+	}
+	else
+	{
+		IMRD_LM_LOG_TRACE_0(IMRD_LOG_LEVEL_VERBOSE_1 ,  "============================================================================")
+		IMRD_LM_LOG_TRACE_0(IMRD_LOG_LEVEL_VERBOSE_1 , "Existing field demand : Begin");
+		IMRD_LM_LOG_TRACE_1(IMRD_LOG_LEVEL_VERBOSE_1 , "Field Input name  : [%s]" , Field_Ptr->Name);	
+	
+		if (IMRG_Fixed_Buffer_Ident_Ptr == NULL)
+		{
+			status = IMRS_KO;
+			IMRD_LM_LOG_ERROR_0("Buffer pointer NULL");
+		}
+		else
+		{
+			status = Fixed_Hdl_Field_Exist( Field_Ptr, IMRG_Fixed_Buffer_Ident_Ptr);
+		}
+	}
+
+	IMRD_LM_LOG_TRACE_1(IMRD_LOG_LEVEL_VERBOSE_2 , "Existing field demand : End with status :  (%d)" , status);
+	IMRD_LM_LOG_TRACE_0(IMRD_LOG_LEVEL_VERBOSE_2 ,  "============================================================================")
+
+	return ( status );
+}
+
+IMRT_Status IMR_MM_Fixed_StrHdl_Field_Value( IMRT_Field *Field_Ptr , IMRT_Field_Value_Id Value_Id )
+{
+	IMRT_Buffer_Data *data_ptr;
+	IMRT_Status status;
+	size_t field_len;
+	char *func_name = "IMR_MM_Fixed_StrHdl_Field_Value";
+
+        status = IMRS_OK;
+
+	if (Field_Ptr == NULL) 
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Field_Ptr NULL");
+	}
+	else
+	{
+		IMRD_LM_LOG_TRACE_0(IMRD_LOG_LEVEL_VERBOSE_1 ,  "============================================================================")
+		IMRD_LM_LOG_TRACE_0(IMRD_LOG_LEVEL_VERBOSE_1 , "Field Value demand : Begin");
+		IMRD_LM_LOG_TRACE_2(IMRD_LOG_LEVEL_VERBOSE_1 , "Field Input name  : [%s] Value Id : [%s]" , Field_Ptr->Name , Value_Id);	
+	        
+	        field_len = 0L;
+	        status = IMRS_OK;
+		
+		if (IMRG_Fixed_Buffer_Ident_Ptr == NULL)
+		{
+			status = IMRS_KO;
+			IMRD_LM_LOG_ERROR_0("Buffer pointer NULL");
+		}
+		else
+		{
+			status = MM_Fixed_StrHdl_Get(&data_ptr, Field_Ptr, IMRG_Fixed_Buffer_Ident_Ptr , &field_len );
+		}
+		
+		if (status == IMRS_OK)
+		{
+			IMRD_LM_LOG_TRACE_1(IMRD_LOG_LEVEL_VERBOSE_2 , "Value extracted :  [%s]" , data_ptr);
+			if (strcmp(data_ptr, Value_Id) != 0)
+			{
+				status = IMRS_NO_IDENT;
+			}
+			free(data_ptr);
+		}
+	}
+
+	IMRD_LM_LOG_TRACE_1(IMRD_LOG_LEVEL_VERBOSE_2 , "Field Value demand : End with status :  (%d)" , status);
+	IMRD_LM_LOG_TRACE_0(IMRD_LOG_LEVEL_VERBOSE_2 ,  "============================================================================")
+
+	return ( status );
+}
+
+IMRT_Status	MM_Fixed_StrHdl_Convert(IMRT_Buffer_Data **Data_Output_Ptr , IMRT_Buffer_Data *Data_Input_Ptr , IMRT_Field *Field_Ptr,  
+                                        size_t *len , IMRT_StrHdl_Cnv_Func *Cnv_Func_Tab )
+{
+	IMRT_Status status;
+	size_t size;
+	char *func_name = "MM_Fixed_StrHdl_Convert";
+
+
+
+	
+	status       = IMRS_OK;
+
+	if (Cnv_Func_Tab == NULL) 
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Cnv_Func_Tab NULL");
+	}
+	else if (Data_Output_Ptr == NULL) 
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Data_Output_Ptr NULL");
+	}
+	else if (len == NULL) 
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("len pointer NULL");
+	}
+	else if (Field_Ptr == NULL) 
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Field_Ptr NULL");
+	}
+	else
+	if (Data_Input_Ptr == NULL) 
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Data_Input_Ptr NULL");
+	}
+	else
+	{
+		size = Field_Ptr->Fixed.Size ;
+	
+		*Data_Output_Ptr = (IMRT_Buffer_Data *)malloc(size + 1L);
+		if (*Data_Output_Ptr == NULL)
+		{
+			status = IMRS_KO;
+			IMRD_LM_LOG_ERROR_0("*Data_Output_Ptr NULL");
+		}
+		else
+		{
+		    memset(*Data_Output_Ptr, '\0' , (size + 1L) );
+		
+		        /* Appel de la fonction de convertion */
+			if ((Field_Ptr->Fixed.Cnv_Ptr == NULL) || (Cnv_Func_Tab[Field_Ptr->Fixed.Cnv_Ptr->Id].Convert_Ptr == NULL))
+			{
+				IMRD_LM_LOG_TRACE_0( IMRD_LOG_LEVEL_VERBOSE_1 , "Pas de fonction de conversion");
+		
+		                if (Data_Input_Ptr != NULL)
+			                memcpy(*Data_Output_Ptr,Data_Input_Ptr,*len);
+			}
+			else
+			{
+				status = Cnv_Func_Tab[Field_Ptr->Fixed.Cnv_Ptr->Id].Convert_Ptr(*Data_Output_Ptr, 
+				                                                         Data_Input_Ptr, 
+				                                                         len ,
+				                                                         size ,
+				                                                         Field_Ptr->Fixed.Cnv_Attr);
+			}
+		}
+	}
+
+    if (Data_Input_Ptr != NULL)
+		free(Data_Input_Ptr);
+
+
+	return ( status );
+
+}
+
+
+IMRT_Status	MM_Fixed_StrHdl_Put(IMRT_Buffer_Data *Data_Ptr, IMRT_Field *Field_Ptr,  
+                                IMRT_Buffer *Buffer_Ptr , size_t len )
+{
+	IMRT_Buffer_Data *data_buf_ptr;
+	size_t data_len;
+	size_t data_max_len;
+	IMRT_Status status;
+	char *func_name = "MM_Fixed_StrHdl_Put";
+
+	
+	status       = IMRS_OK;
+
+	if (Buffer_Ptr == NULL) 
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Buffer_Ptr NULL");
+	}
+	else if (Field_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Field_Ptr NULL");
+	}
+	else if (Data_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("data pointer NULL");
+	}
+	else
+        /* Controle de validite de la taille */
+        if (Field_Ptr->Fixed.Size == IMRD_FIXED_SIZE_UNKNOWN)
+        {
+            status   = IMRS_KO;
+            IMRD_LM_LOG_ERROR_0("Size Fixed unknown");
+        }
+
+        if (status == IMRS_OK)
+        {
+	        if (strcmp(Data_Ptr , "") == 0)
+	                status = IMRD_STATUS_NOTHING_TO_DO;
+	}
+
+
+	if ( status == IMRS_OK )
+	{	
+	        data_len     = len ;
+	        data_max_len = Field_Ptr->Fixed.Offset + data_len ;
+
+        	/* controle sur la valeur */
+        	if ( data_len > Field_Ptr->Fixed.Size )
+        	{
+        		status = IMRS_KO;
+        		IMRD_LM_LOG_ERROR_2("Data len (%ld) superior to data size (%ld)",data_len , Field_Ptr->Fixed.Size);
+        	}
+        	else if ( Buffer_Ptr->Data_Buf_Size <= data_max_len )
+        	{
+        		status = Fixed_Hdl_DataBuf_Alloc( Buffer_Ptr, data_max_len + 1 );
+        	}
+        }
+        
+	if ( status == IMRS_OK )
+	{
+		/* insertion de la valeur dans les donnees du buffer */
+		data_buf_ptr = Buffer_Ptr->Data_Buf_Ptr + Field_Ptr->Fixed.Offset;
+		memcpy(data_buf_ptr, Data_Ptr, data_len);
+
+		if ( Buffer_Ptr->Data_Buf_Len < data_max_len )
+		{
+			Buffer_Ptr->Data_Buf_Len = data_max_len;
+		}
+	}			     
+	
+	if (status == IMRD_STATUS_NOTHING_TO_DO)
+	        status = IMRS_OK;
+
+	if (Data_Ptr != NULL)
+                free(Data_Ptr);
+
+
+	return ( status );
+}
+
diff --git a/src/libmapping_mng/src/fmt_hdl_fixed.h b/src/libmapping_mng/src/fmt_hdl_fixed.h
new file mode 100644
index 0000000..007b2aa
--- /dev/null
+++ b/src/libmapping_mng/src/fmt_hdl_fixed.h
@@ -0,0 +1,104 @@
+/*----------------------------------------------------------------------------*/
+/* File: fmt_hdl_fixed.h    				         	      */
+/*----------------------------------------------------------------------------*/
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#ifndef _FIXED_HANDLER_H_
+#define _FIXED_HANDLER_H_
+
+/*----------------------------------------------------------------------------*/
+/* Global Include                                                             */
+/*----------------------------------------------------------------------------*/
+
+#include "libmapping_mng.h"
+
+/*----------------------------------------------------------------------------*/
+/* Local definition                                                           */
+/*----------------------------------------------------------------------------*/
+
+#ifdef _FIXED_HANDLER_C_
+		
+#    define FIXED_TAILLE_ALLOC 100000
+
+#endif
+
+
+/*----------------------------------------------------------------------------*/
+/*	Global Variables                                                      */
+/*----------------------------------------------------------------------------*/
+#ifdef _FIXED_HANDLER_C_
+		
+    IMRT_Buffer	*IMRG_Fixed_Buffer_Ident_Ptr;
+
+#endif
+
+/*----------------------------------------------------------------------------*/
+/*	Prototypes							      */
+/*----------------------------------------------------------------------------*/
+
+#ifdef _FIXED_HANDLER_C_
+
+    IMRT_Status	    MM_Fixed_StrHdl_Init            ( void );
+    IMRT_Status	    MM_Fixed_StrHdl_DeInit          ( void );
+    IMRT_Status	    Fixed_Hdl_DataBuf_Alloc	    ( IMRT_Buffer * , size_t );
+    IMRT_Status	    MM_Fixed_StrHdl_Data_Free       ( IMRT_Buffer * );
+    IMRT_Status	    Fixed_Hdl_Format_Ident	    ( IMRT_Buffer * );
+    IMRT_Status     MM_Fixed_StrHdl_Ident           ( IMRT_Msg_Id * , IMRT_Buffer * );
+    IMRT_Status	    MM_Fixed_StrHdl_Open	    ( IMRT_Buffer * );
+    IMRT_Status	    MM_Fixed_StrHdl_Close	    ( IMRT_Buffer * );
+    IMRT_Status	    MM_Fixed_StrHdl_Flush           ( IMRT_Buffer * );
+    IMRT_Status	    MM_Fixed_StrHdl_Data_List       ( IMRT_Buffer * );
+    IMRT_Status	    MM_Fixed_StrHdl_Copy	    ( IMRT_Buffer * , IMRT_Buffer * );
+    IMRT_Status	    Fixed_Hdl_Field_Exist           ( IMRT_Field * , IMRT_Buffer * );
+    IMRT_Status     MM_Fixed_StrHdl_Get             ( IMRT_Buffer_Data ** , IMRT_Field * , IMRT_Buffer * , size_t * );
+    IMRT_Status	    MM_Fixed_StrHdl_Convert         ( IMRT_Buffer_Data ** , IMRT_Buffer_Data * , IMRT_Field * , size_t *, IMRT_StrHdl_Cnv_Func * );
+    IMRT_Status	    MM_Fixed_StrHdl_Put	            ( IMRT_Buffer_Data * , IMRT_Field * , IMRT_Buffer * , size_t );
+    IMRT_Status     IMR_MM_Fixed_StrHdl_Field_Value ( IMRT_Field * , IMRT_Field_Value_Id);
+    IMRT_Status     IMR_MM_Fixed_StrHdl_Field_Exist ( IMRT_Field * );
+    IMRT_Status     IMR_MM_Fixed_StrHdl_Msg_Size    ( size_t );
+
+#else
+
+    extern IMRT_Status  MM_Fixed_StrHdl_Init            ( void );
+    extern IMRT_Status  MM_Fixed_StrHdl_DeInit          ( void );
+    extern IMRT_Status  MM_Fixed_StrHdl_Library_Open    ( void );
+    extern IMRT_Status  MM_Fixed_StrHdl_Data_Free       ( IMRT_Buffer * );
+    extern IMRT_Status  MM_Fixed_StrHdl_Ident           ( IMRT_Msg_Id * , IMRT_Buffer * );
+    extern IMRT_Status  MM_Fixed_StrHdl_Open	        ( IMRT_Buffer * );
+    extern IMRT_Status  MM_Fixed_StrHdl_Close	        ( IMRT_Buffer * );
+    extern IMRT_Status  MM_Fixed_StrHdl_Flush	        ( IMRT_Buffer * );
+    extern IMRT_Status  MM_Fixed_StrHdl_Data_List       ( IMRT_Buffer * );
+    extern IMRT_Status  MM_Fixed_StrHdl_Copy	        ( IMRT_Buffer * , IMRT_Buffer * );
+    extern IMRT_Status  MM_Fixed_StrHdl_Get		( IMRT_Buffer_Data ** , IMRT_Field * , IMRT_Buffer * , size_t * );
+    extern IMRT_Status  MM_Fixed_StrHdl_Convert         ( IMRT_Buffer_Data ** , IMRT_Buffer_Data * , IMRT_Field * , size_t *, IMRT_StrHdl_Cnv_Func * );
+    extern IMRT_Status  MM_Fixed_StrHdl_Put		( IMRT_Buffer_Data * , IMRT_Field * , IMRT_Buffer * , size_t );
+
+#endif
+
+/*----------------------------------------------------------------------------*/
+
+#endif                                   
+
diff --git a/src/libmapping_mng/src/fmt_hdl_fml.c b/src/libmapping_mng/src/fmt_hdl_fml.c
new file mode 100644
index 0000000..f6d72a2
--- /dev/null
+++ b/src/libmapping_mng/src/fmt_hdl_fml.c
@@ -0,0 +1,835 @@
+/*----------------------------------------------------------------------------*/
+/* File: fmt_hdl_fml.c      				         	      */
+/*----------------------------------------------------------------------------*/
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#define _LIBMAPPING_MNG_
+#define _FML_HANDLER_C_
+
+#include "fmt_hdl_fml.h"
+
+
+IMRT_Status MM_FML_StrHdl_Init()
+{
+	IMRG_FML_Buffer_Ident_Ptr = NULL;
+	return (IMRS_OK);
+}
+
+IMRT_Status MM_FML_StrHdl_DeInit()
+{
+
+	return (IMRS_OK);
+}
+
+IMRT_Status FML_Hdl_DataBuf_Alloc( IMRT_Buffer *Buffer_Ptr )
+{
+	IMRT_Status status;
+	int retour;
+	char *func_name = "FML_Hdl_DataBuf_Alloc";
+	FBFR32  *tpFBbuf;
+	
+
+
+	tpFBbuf = NULL;
+	status = IMRS_OK;
+	retour = 0;
+	
+
+	if (Buffer_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Buffer pointer NULL" );
+	}
+	else
+	if (Buffer_Ptr->Status != IMRD_BUFFER_STATUS_ALLOCATED)
+	{
+		tpFBbuf = (FBFR32 *)tpalloc((char *) IMRD_FML_TYPE , NULL, Fneeded32(IMRD_FML_MAX_FLD, IMRD_FML_SIZE) );
+
+		if (tpFBbuf == NULL)
+		{
+			status = IMRS_KO;
+			IMRD_LM_LOG_ERROR_0("Error tpalloc");
+		}
+	
+		if (status == IMRS_OK)
+		{
+			
+			retour = Finit32(tpFBbuf, (FLDLEN32) Fsizeof32(tpFBbuf));
+
+			if (retour == -1)
+			{
+				if (Ferror32 == FNOSPACE)
+				{
+					IMRD_LM_LOG_ERROR_0("Ferror32 = FNOSPACE");
+				}
+				else if (Ferror32 == FALIGNERR)
+				{
+					IMRD_LM_LOG_ERROR_0("Ferror32 = FALIGNERR");
+				}
+				else if (Ferror32 == FNOTFLD)
+				{
+					IMRD_LM_LOG_ERROR_0("Ferror32 = FNOTFLD");
+				}
+				else if (Ferror32 == FEINVAL)
+				{
+					IMRD_LM_LOG_ERROR_0("Ferror32 = FEINVAL");
+				}
+				else if (Ferror32 == FBADFLD)
+				{
+					IMRD_LM_LOG_ERROR_0("Ferror32 = FBADFLD");
+				}
+		        status = IMRS_KO;
+				tpfree((char *)tpFBbuf);
+			}
+		}
+		
+
+		if (status == IMRS_OK)
+		{
+			Buffer_Ptr->Data_Buf_Ptr  = (IMRT_Buffer_Data *)tpFBbuf;
+			Buffer_Ptr->Status        = IMRD_BUFFER_STATUS_ALLOCATED;
+			Buffer_Ptr->Data_Buf_Size = IMRD_FML_SIZE;
+			Buffer_Ptr->Data_Buf_Len  = 0;
+	
+		}
+	}
+	
+	
+
+	return status;
+
+}
+
+
+IMRT_Status MM_FML_StrHdl_Data_Free( IMRT_Buffer  *Buffer_Ptr)
+{
+	IMRT_Status status;
+	char *func_name = "MM_FML_StrHdl_Data_Free";
+
+	
+	status = IMRS_OK;
+
+	if (Buffer_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Buffer pointer NULL" );
+	}
+	else
+	if (Buffer_Ptr->Status == IMRD_BUFFER_STATUS_ALLOCATED)
+	{
+		tpfree((char *)Buffer_Ptr->Data_Buf_Ptr);
+		Buffer_Ptr->Data_Buf_Ptr  = NULL;	
+		Buffer_Ptr->Status        = IMRD_BUFFER_STATUS_FREED;
+		Buffer_Ptr->Data_Buf_Size = 0;
+		Buffer_Ptr->Data_Buf_Len  = 0;		
+	}
+
+	return ( status );
+}
+
+
+IMRT_Status FML_Hdl_Format_Ident( IMRT_Buffer *Buffer_Ptr )
+{
+	IMRT_Status status;
+	char *func_name = "FML_Hdl_Format_Ident";
+
+
+	status = IMRS_KO;
+
+	if (Buffer_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Buffer pointer NULL" );
+	}
+	else
+	if (Buffer_Ptr->Status == IMRD_BUFFER_STATUS_ALLOCATED)
+	{
+		/* Controle du format FML */
+		if (Fnum32((FBFR32 *)Buffer_Ptr->Data_Buf_Ptr) != -1)
+		{
+			status = IMRS_OK;
+		}
+	}
+	else
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Buffer not allocated");
+	}
+
+
+	return ( status );
+}
+
+IMRT_Status MM_FML_StrHdl_Ident( IMRT_Msg_Id *Msg_Id_Ident_Ptr, 
+                                  IMRT_Buffer *Buffer_Ptr )
+{
+        
+        IMRT_Fmt_Id Format;
+        IMRT_Status status;
+        IMRT_Msg_Id *Msg_Id_Tmp;
+        char *func_name = "MM_FML_StrHdl_Ident";
+        
+
+	if (Buffer_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Buffer pointer NULL" );
+	}
+	else
+	if (Msg_Id_Ident_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Msg_Id_Ident_Ptr NULL" );
+	}
+	else
+	{
+	        Format = Buffer_Ptr->Fmt_Id;
+	        Msg_Id_Tmp = Msg_Id_Ident_Ptr;
+	        status = IMRS_OK;
+	
+		IMRG_FML_Buffer_Ident_Ptr = Buffer_Ptr;
+		/* Le Msg_Id transmis au SDM est le point de depart de l'identification */
+		/* C'est egalement le resultat qui sera inclus dans le buffer */
+		status = IMR_SDM_MsgIdent_Proceed(Format, 
+		                                  Msg_Id_Tmp,
+		                                  IMR_MM_FML_StrHdl_Field_Value,
+		                                  IMR_MM_FML_StrHdl_Field_Exist,
+		                                  IMR_MM_FML_StrHdl_Msg_Size);
+		IMRG_FML_Buffer_Ident_Ptr = NULL;
+	
+	        Msg_Id_Ident_Ptr = Msg_Id_Tmp;
+	}
+
+
+	return ( status );
+
+}
+
+IMRT_Status MM_FML_StrHdl_Open( IMRT_Buffer *Buffer_Ptr)
+{
+	IMRT_Msg_Id type_temp;
+	IMRT_Status status;
+	char *func_name = "MM_FML_StrHdl_Open";
+
+	status = IMRS_OK;
+
+	if (Buffer_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Buffer pointer NULL" );
+	}
+	else
+	{
+		type_temp = Buffer_Ptr->Msg_Id;
+	
+		/* absence de données */
+		if (Buffer_Ptr->Status != IMRD_BUFFER_STATUS_ALLOCATED)
+		{
+		        /* Cas d'open du buffer en ecriture */
+		        /* le type du message est passe */
+		        /* par le SDM : il doit donc etre connu */
+			if (type_temp == IMRD_MSG_ID_UNKNOWN)
+			{
+				status = IMRS_KO;
+				IMRD_LM_LOG_ERROR_0("Msg Id unknown");
+			}
+			else
+			{
+				status = FML_Hdl_DataBuf_Alloc( Buffer_Ptr );
+			}
+		}
+		else  
+		{
+		        /* controle du format */
+		        status = FML_Hdl_Format_Ident( Buffer_Ptr );
+		        /* format non reconnu */
+		        if (status != IMRS_OK)
+		                status = IMRS_BAD_FORMAT;
+		}
+	}
+	
+
+
+	return ( status );
+}
+
+IMRT_Status MM_FML_StrHdl_Close( IMRT_Buffer *Buffer_Ptr)
+{
+	char *func_name = "MM_FML_StrHdl_Close";
+
+	return (IMRS_OK);
+}
+
+IMRT_Status	MM_FML_StrHdl_Flush( IMRT_Buffer  *Buffer_Ptr)
+{
+	char *func_name = "MM_FML_StrHdl_Flush";
+
+	return (IMRS_OK);
+}
+
+IMRT_Status MM_FML_StrHdl_Data_List( IMRT_Buffer *Buffer_Ptr)
+{
+	if (Buffer_Ptr == NULL)
+	{
+		IMRD_LM_LOG_WARNING_0("Buffer pointer NULL" );
+	}
+	else
+	{
+	    IMRD_LM_LOG_TRACE_3( IMRD_LOG_LEVEL_VERBOSE_1, "Buffer_List: Data_Buf_Ptr_Size: (%d)   Data_Buf_Ptr_Len: (%d)   Data_Buf_Ptr: (0x%X)", Buffer_Ptr->Data_Buf_Size, Buffer_Ptr->Data_Buf_Len, Buffer_Ptr->Data_Buf_Ptr);
+	
+	    IMRD_LM_EXEC_TRACE( IMRD_LOG_LEVEL_VERBOSE_2, "Buffer_List: Data_Tmp: [", Ffprint32( (FBFR32 *)Buffer_Ptr->Data_Buf_Ptr, IMRD_LM_STREAM_OUT), "]");
+	
+	    IMRD_LM_LOG_TRACE_2( IMRD_LOG_LEVEL_VERBOSE_1, "Buffer_List: Data_Tmp_Changed: (%d)   Data_Tmp_Ptr: (0x%X)", Buffer_Ptr->Data_Tmp_Changed, Buffer_Ptr->Data_Tmp_Ptr);
+
+	    if (Buffer_Ptr->Data_Tmp_Ptr != NULL)
+		    IMRD_LM_LOG_TRACE_1( IMRD_LOG_LEVEL_VERBOSE_2, "Buffer_List: Data_Tmp: [%s]", Buffer_Ptr->Data_Tmp_Ptr);
+	}
+
+    return( IMRS_OK);
+}
+
+IMRT_Status MM_FML_StrHdl_Copy( IMRT_Buffer *Output_Buffer_Ptr, IMRT_Buffer *Input_Buffer_Ptr )
+{
+	IMRT_Status status;
+	char *func_name = "MM_FML_StrHdl_Copy";
+
+	
+	status = IMRS_OK;
+	
+	if (Input_Buffer_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Input buffer pointer NULL" );
+	}
+	else
+	if (Output_Buffer_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Output buffer pointer NULL" );
+	}
+	else
+	/* controle donnees dans Input_Buffer */
+	if (Input_Buffer_Ptr->Status != IMRD_BUFFER_STATUS_ALLOCATED)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0( "Buffer input not allocated");
+	}
+	/* le buffer destinataire ne doit pas comporter de donnees */ 
+	else if ( ( Output_Buffer_Ptr->Status == IMRD_BUFFER_STATUS_ALLOCATED) ||
+	          ( Output_Buffer_Ptr->Data_Tmp_Ptr != NULL) )
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Buffer output not allocated or Data_Tmp_Ptr no NULL");
+	}
+	else
+	{
+		status = FML_Hdl_DataBuf_Alloc(Output_Buffer_Ptr);
+		if (status == IMRS_OK)
+		{
+			/* copie de buffer FML */
+			Fcpy32((FBFR32 *)Output_Buffer_Ptr->Data_Buf_Ptr , (FBFR32 *)Input_Buffer_Ptr->Data_Buf_Ptr);
+			Output_Buffer_Ptr->Data_Buf_Len = Fused32((FBFR32 *)Output_Buffer_Ptr->Data_Buf_Ptr);
+			
+			/* doit on faire la maj du size et du len pour le FML ??? */
+		}
+	}
+ 
+
+	return ( status );
+}
+
+
+IMRT_Status	FML_Hdl_Field_Exist(IMRT_Field *Field_Ptr , IMRT_Buffer *Buffer_Ptr , FLDID32 FML_Field)
+{
+        IMRT_Status status;	
+	FLDOCC32 retour;
+        char *func_name = "FML_Hdl_Field_Exist";
+        
+	
+	status   = IMRS_OK;
+	retour = 0;
+
+	if (Buffer_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Buffer pointer NULL" );
+	}
+	else
+	if (Field_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Field pointer NULL" );
+	}
+	else
+	{
+	        retour = Foccur32((FBFR32 *)Buffer_Ptr->Data_Buf_Ptr, FML_Field);
+	
+	        if (retour == 0 )
+	        {
+	                status   = IMRS_NO_IDENT;
+	                IMRD_LM_LOG_TRACE_0(IMRD_LOG_LEVEL_VERBOSE_1 , "Field not exist");
+	        }
+	        else if (retour == -1 )
+	        {
+	               status   = IMRS_KO;
+	               IMRD_LM_LOG_ERROR_1("Foccur32 error [%s]" , Fstrerror32(Ferror32));
+	        }
+	}
+        
+
+	return ( status );
+
+}
+
+
+/* dans la fonction get, il conviendra d'etudier la necessite ou non de developper : 
+	- la conversion des types
+	- la possibilite de champ multi-occurrence
+*/
+IMRT_Status	MM_FML_StrHdl_Get(IMRT_Buffer_Data **Data_Ptr_Ptr, IMRT_Field *Field_Ptr,  
+                                IMRT_Buffer *Buffer_Ptr , size_t *len )
+{
+	IMRT_Buffer_Data *data_ptr;
+	IMRT_Status status;
+	int retour;
+	FLDID32 FML_Field;
+	size_t sizeTmp;
+	char *func_name = "MM_FML_StrHdl_Get";
+
+
+	
+	status   = IMRS_OK;
+	retour = 0;
+	data_ptr = NULL;
+	sizeTmp = 0L;
+
+	if (Data_Ptr_Ptr == NULL) 
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Data_Ptr_Ptr NULL");
+	}
+	else if (len == NULL) 
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("len pointer NULL");
+	}
+	else if (Buffer_Ptr == NULL) 
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Buffer_Ptr NULL");
+	}
+	else if (Field_Ptr == NULL) 
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Field_Ptr NULL");
+	}
+	else 
+    	/* Controle de validite du tag */
+    	if (strcmp(Field_Ptr->FML.Tag ,IMRD_FML_TAG_UNKNOWN) == 0)
+    	{
+	        status   = IMRS_KO;
+	        IMRD_LM_LOG_ERROR_0("Tag FML unknown");
+    	}
+
+	if (status == IMRS_OK)
+	{
+	        FML_Field = Fldid32( Field_Ptr->FML.Tag );
+	
+		if ( FML_Field == BADFLDID )
+		{
+			status = IMRS_KO;
+			IMRD_LM_LOG_ERROR_1("Fldid32 %s BADFLDID error",Field_Ptr->FML.Tag );
+		}
+	}
+
+    	if (status == IMRS_OK)
+    	{
+            status = FML_Hdl_Field_Exist(Field_Ptr , Buffer_Ptr , FML_Field);
+    	}
+    	/* Le champ n'existe pas => on prend la valeur par defaut */
+	if (status == IMRS_NO_IDENT)
+    	{
+            sizeTmp = strlen(Field_Ptr->FML.Def_Val);
+            data_ptr = (IMRT_Buffer_Data *) malloc ( sizeTmp + 1);
+            if (data_ptr == NULL)
+            {
+                    status   = IMRS_KO;
+                    IMRD_LM_LOG_ERROR_0("Malloc error");
+	    }
+            else
+            {
+                    memset( data_ptr, '\0', sizeTmp + 1 );
+                    memcpy(data_ptr , Field_Ptr->FML.Def_Val , sizeTmp );
+                    *(data_ptr + sizeTmp) = '\0';
+                    *Data_Ptr_Ptr = data_ptr;
+                    status   = IMRS_OK;
+            }                
+    	}       
+    	/* le champ existe => on extrait la valeur */
+    	else if (status == IMRS_OK)
+	{
+		/*data_ptr = (IMRT_Buffer_Data *) malloc ( (Field_Ptr->Fixed.Size + 1));
+		memset( data_ptr, '\0', Field_Ptr->Fixed.Size + 1 );*/
+		data_ptr = (IMRT_Buffer_Data *) malloc ( IMRD_FML_SIZE);
+		memset( data_ptr, '\0', IMRD_FML_SIZE );
+		retour = (IMRT_Status)Fget32((FBFR32 *)Buffer_Ptr->Data_Buf_Ptr, 
+										FML_Field,
+										(FLDOCC32 )0L,
+										(char *)data_ptr,
+										0);
+
+
+		if (retour == -1)
+		{
+	        	IMRD_LM_LOG_ERROR_3("Fget32 failed with error [%s] Field (%d)  [%s]" , Fstrerror32(Ferror32) , FML_Field, Fname32(FML_Field));
+	        	status = IMRS_KO;
+		}
+		else
+		{
+		    *Data_Ptr_Ptr = data_ptr;
+		    sizeTmp = (size_t) strlen(data_ptr);
+		}    
+	}
+									
+	if (status == IMRS_OK)
+	{
+		*len = sizeTmp;
+	}
+
+
+	return ( status );
+}
+
+
+IMRT_Status     IMR_MM_FML_StrHdl_Msg_Size    ( size_t Msg_Size)
+{
+	IMRT_Status status;
+	char *func_name = "IMR_MM_FML_StrHdl_Msg_Size";
+
+	IMRD_LM_LOG_TRACE_0(IMRD_LOG_LEVEL_VERBOSE_1 ,  "============================================================================")
+	IMRD_LM_LOG_TRACE_0(IMRD_LOG_LEVEL_VERBOSE_1 , "Size msg demand : Begin");
+	IMRD_LM_LOG_TRACE_1(IMRD_LOG_LEVEL_VERBOSE_1 , "Msg_Size  : (%ld)" , Msg_Size);	
+
+        /* Erreur de referentiel */
+        status = IMRS_KO;
+        IMRD_LM_LOG_WARNING_0("Referential error ; this should never happen");
+
+
+	IMRD_LM_LOG_TRACE_1(IMRD_LOG_LEVEL_VERBOSE_2 , "Size msg demand : End with status :  (%d)" , status);
+	IMRD_LM_LOG_TRACE_0(IMRD_LOG_LEVEL_VERBOSE_2 ,  "============================================================================")
+
+	return ( status );
+}
+
+
+IMRT_Status IMR_MM_FML_StrHdl_Field_Exist( IMRT_Field *Field_Ptr )
+{
+	IMRT_Status status;
+	FLDID32 FML_Field;
+	char *func_name = "IMR_MM_FML_StrHdl_Field_Exist";
+
+        status = IMRS_OK;
+
+	if (Field_Ptr == NULL) 
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Field_Ptr NULL");
+	}
+	else
+	{
+		IMRD_LM_LOG_TRACE_0(IMRD_LOG_LEVEL_VERBOSE_1 ,  "============================================================================")
+		IMRD_LM_LOG_TRACE_0(IMRD_LOG_LEVEL_VERBOSE_1 , "Existing field demand : Begin");
+		IMRD_LM_LOG_TRACE_1(IMRD_LOG_LEVEL_VERBOSE_1 , "Field Input name  : [%s]" , Field_Ptr->Name);	
+	
+		if (IMRG_FML_Buffer_Ident_Ptr == NULL)
+		{
+			status = IMRS_KO;
+			IMRD_LM_LOG_ERROR_0("Buffer pointer NULL");
+		}
+		
+		if (status == IMRS_OK)
+		{
+		        FML_Field = Fldid32( Field_Ptr->FML.Tag );
+		}
+			
+		if ( FML_Field == BADFLDID )
+		{
+			status = IMRS_NO_IDENT;
+			IMRD_LM_LOG_TRACE_1(IMRD_LOG_LEVEL_VERBOSE_1 , "Field [%s] BADFLDID error",Field_Ptr->FML.Tag );
+		}
+	
+	        if (status == IMRS_OK)
+	        {
+	                status = FML_Hdl_Field_Exist(Field_Ptr , IMRG_FML_Buffer_Ident_Ptr , FML_Field);
+	        }
+	}
+
+	IMRD_LM_LOG_TRACE_1(IMRD_LOG_LEVEL_VERBOSE_2 , "Existing field demand : End with status :  (%d)" , status);
+	IMRD_LM_LOG_TRACE_0(IMRD_LOG_LEVEL_VERBOSE_2 ,  "============================================================================")
+
+	return ( status );
+}
+
+IMRT_Status IMR_MM_FML_StrHdl_Field_Value( IMRT_Field *Field_Ptr , IMRT_Field_Value_Id Value_Id )
+{
+	IMRT_Buffer_Data *data_ptr;
+	IMRT_Status status;
+	size_t field_len;
+	char *func_name = "IMR_MM_FML_StrHdl_Field_Value";
+
+        status = IMRS_OK;
+
+	if (Field_Ptr == NULL) 
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Field_Ptr NULL");
+	}
+	else
+	{
+		IMRD_LM_LOG_TRACE_0(IMRD_LOG_LEVEL_VERBOSE_1 ,  "============================================================================")
+		IMRD_LM_LOG_TRACE_0(IMRD_LOG_LEVEL_VERBOSE_1 , "Field Value demand : Begin");
+		IMRD_LM_LOG_TRACE_2(IMRD_LOG_LEVEL_VERBOSE_1 , "Field Input name  : [%s] Value Id : [%s]" , Field_Ptr->Name , Value_Id);	
+		
+		field_len = 0L;
+		
+		if (IMRG_FML_Buffer_Ident_Ptr == NULL)
+		{
+			status = IMRS_KO;
+			IMRD_LM_LOG_ERROR_0("Buffer pointer NULL");
+		}
+		else
+		{
+			status = MM_FML_StrHdl_Get(&data_ptr, Field_Ptr, IMRG_FML_Buffer_Ident_Ptr , &field_len );
+		}
+		if (status == IMRS_OK)
+		{
+			IMRD_LM_LOG_TRACE_1(IMRD_LOG_LEVEL_VERBOSE_2 , "Value extracted :  [%s]" , data_ptr);
+			if (strcmp(data_ptr, Value_Id) != 0)
+			{			
+				status = IMRS_NO_IDENT;
+			}
+			free(data_ptr);
+		}
+	}
+
+	IMRD_LM_LOG_TRACE_1(IMRD_LOG_LEVEL_VERBOSE_2 , "Field Value demand : End with status :  (%d)" , status);
+	IMRD_LM_LOG_TRACE_0(IMRD_LOG_LEVEL_VERBOSE_2 ,  "============================================================================")
+
+	return ( status );
+}
+
+IMRT_Status	MM_FML_StrHdl_Convert(IMRT_Buffer_Data **Data_Output_Ptr , IMRT_Buffer_Data *Data_Input_Ptr , IMRT_Field *Field_Ptr,  
+                                       size_t *len , IMRT_StrHdl_Cnv_Func *Cnv_Func_Tab )
+{
+	IMRT_Status status;
+        size_t size;
+	char *func_name = "MM_FML_StrHdl_Convert";
+	
+	status       = IMRS_OK;
+
+	if (len == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("len pointer NULL");
+	}
+	else if (Data_Output_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Data_Output_Ptr NULL");
+	}
+	else
+	{
+		size = *len ;	
+		*Data_Output_Ptr = (IMRT_Buffer_Data *)malloc(size + 1L);
+		if (*Data_Output_Ptr == NULL)
+		{
+			status = IMRS_KO;
+			IMRD_LM_LOG_ERROR_0("*Data_Output_Ptr NULL");
+		}
+		else
+		{
+	        memset( *Data_Output_Ptr, '\0' , (size + 1L) );
+	    }
+
+		if (status == IMRS_OK)
+		{
+			if (Field_Ptr == NULL)
+			{
+				status = IMRS_KO;
+				IMRD_LM_LOG_ERROR_0("Field_Ptr NULL");
+			}
+			else
+			if (Data_Input_Ptr == NULL) 
+			{
+				status = IMRS_KO;
+				IMRD_LM_LOG_ERROR_0("Data_Input_Ptr NULL");
+			}
+			else if (Cnv_Func_Tab == NULL) 
+			{
+				status = IMRS_KO;
+				IMRD_LM_LOG_ERROR_0("Cnv_Func_Tab NULL");
+			}
+			else
+			{
+			        /* Appel de la fonction de convertion */
+				if ((Field_Ptr->FML.Cnv_Ptr == NULL) || (Cnv_Func_Tab[Field_Ptr->FML.Cnv_Ptr->Id].Convert_Ptr == NULL))
+				{
+					IMRD_LM_LOG_TRACE_0( IMRD_LOG_LEVEL_VERBOSE_1 , "Pas de fonction de conversion");
+			
+			                if (Data_Input_Ptr != NULL)
+			                        memcpy(*Data_Output_Ptr,Data_Input_Ptr,*len);
+				}
+				else
+				{
+					status = Cnv_Func_Tab[Field_Ptr->FML.Cnv_Ptr->Id].Convert_Ptr(*Data_Output_Ptr, 
+					                                                         Data_Input_Ptr, 
+					                                                         len,
+					                                                         size ,
+					                                                         Field_Ptr->FML.Cnv_Attr );
+				}
+			    	
+			}
+		}
+	}
+
+    if (Data_Input_Ptr != NULL)
+        free(Data_Input_Ptr);
+
+
+	return ( status );
+
+}
+
+IMRT_Status	MM_FML_StrHdl_Put(IMRT_Buffer_Data *Data_Ptr, IMRT_Field *Field_Ptr,  
+                                IMRT_Buffer *Buffer_Ptr , size_t len )
+{
+	IMRT_Buffer_Data *data_buf_ptr;
+	FLDID32 FML_Field;
+	FLDLEN32 FML_maxlen;
+	IMRT_Status status;
+	int retour;
+	char *func_name = "MM_FML_StrHdl_Put";
+	size_t   longueur;
+	int      FML_Field_Type;
+	
+	status     = IMRS_OK;
+	retour	  = 0;
+	
+	if (Buffer_Ptr == NULL) 
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Buffer_Ptr NULL");
+	}
+	else if (Field_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Field_Ptr NULL");
+	}
+	else if (Data_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("data pointer NULL");
+	}
+	else
+        /* Controle de validite du tag */
+        if (strcmp(Field_Ptr->FML.Tag ,IMRD_FML_TAG_UNKNOWN) == 0)
+        {
+            status   = IMRS_KO;
+            IMRD_LM_LOG_ERROR_0("Tag FML unknown");
+        }
+
+	if ((status == IMRS_OK) && (strcmp(Data_Ptr , "") == 0))
+	        status = IMRD_STATUS_NOTHING_TO_DO;
+
+	if (status == IMRS_OK)
+	{
+        	FML_maxlen = (FLDLEN32)0L;
+        	FML_Field  = Fldid32( Field_Ptr->FML.Tag );
+        	if ( FML_Field == BADFLDID )
+        	{
+        		status = IMRS_KO;
+        		IMRD_LM_LOG_ERROR_1("Fldid32 %s BADFLDID error",Field_Ptr->FML.Tag );
+        	}
+        	else
+        	{
+        		FML_Field_Type = Fldtype32(FML_Field);
+        		if (FML_Field_Type == FLD_CARRAY)
+        		{
+        			longueur = len;
+        		}
+        		else
+        		{
+        			longueur = 0L;
+        		}
+
+        		retour = Fadd32((FBFR32 *)Buffer_Ptr->Data_Buf_Ptr, 
+        				FML_Field,
+        				(char *)Data_Ptr,
+        				(FLDLEN32) longueur);
+        
+        		if (retour == -1)
+        		{
+        			if (Ferror32 == FNOSPACE)
+        				/* prevoir la realloc */
+        			{
+        				IMRD_LM_LOG_ERROR_0("Ferror32 = FNOSPACE");
+        			}
+        			else if (Ferror32 == FALIGNERR)
+        			{
+        				IMRD_LM_LOG_ERROR_0("Ferror32 = FALIGNERR");
+        			}
+        			else if (Ferror32 == FNOTFLD)
+        			{
+        				IMRD_LM_LOG_ERROR_0("Ferror32 = FNOTFLD");
+        			}
+        			else if (Ferror32 == FEINVAL)
+        			{
+        				IMRD_LM_LOG_ERROR_0("Ferror32 = FEINVAL");
+        			}
+        			else if (Ferror32 == FBADFLD)
+        			{
+        				IMRD_LM_LOG_ERROR_0("Ferror32 = FBADFLD");
+        			}
+        			status = IMRS_KO;
+        		}
+        	}
+        }
+        
+	if (status == IMRS_OK)
+	{
+	        /* Mise a jour de la taille du buffer */
+	        Buffer_Ptr->Data_Buf_Len = (Buffer_Ptr->Data_Buf_Len) + Fsizeof32((FBFR32 *)Buffer_Ptr->Data_Buf_Ptr);
+	}
+
+	if (status == IMRD_STATUS_NOTHING_TO_DO)
+	        status = IMRS_OK;
+
+	if (Data_Ptr != NULL)
+                free(Data_Ptr);
+
+
+	return ( status );
+}
diff --git a/src/libmapping_mng/src/fmt_hdl_fml.h b/src/libmapping_mng/src/fmt_hdl_fml.h
new file mode 100644
index 0000000..5716d28
--- /dev/null
+++ b/src/libmapping_mng/src/fmt_hdl_fml.h
@@ -0,0 +1,108 @@
+/*----------------------------------------------------------------------------*/
+/* File: fmt_hdl_xml.h    	        		         	      */
+/*----------------------------------------------------------------------------*/
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#ifndef _FML_HANDLER_H_
+#define _FML_HANDLER_H_
+
+#include "fml.h"
+#include "fml32.h"
+#include "atmi.h"
+#include "field.tbls.h"
+#include "userlog.h"
+
+/*----------------------------------------------------------------------------*/
+/* Global Include                                                             */
+/*----------------------------------------------------------------------------*/
+
+#include "libmapping_mng.h"
+
+/*----------------------------------------------------------------------------*/
+/* Local definition                                                           */
+/*----------------------------------------------------------------------------*/
+
+#ifdef _FML_HANDLER_C_
+
+    #define IMRD_FML_TYPE "FML32"
+    #define IMRD_FML_SIZE (FLDLEN32)10000L
+    #define IMRD_FML_MAX_FLD (FLDOCC32)50L
+
+#endif
+
+/*----------------------------------------------------------------------------*/
+/*	Global Variables			                              */
+/*----------------------------------------------------------------------------*/
+
+#ifdef _FML_HANDLER_C_
+		
+    IMRT_Buffer	*IMRG_FML_Buffer_Ident_Ptr;
+
+#endif
+
+/*----------------------------------------------------------------------------*/
+/*	Prototypes							      */
+/*----------------------------------------------------------------------------*/
+
+#ifdef _FML_HANDLER_C_
+
+    IMRT_Status MM_FML_StrHdl_Init              ( void );
+    IMRT_Status MM_FML_StrHdl_DeInit            ( void );
+    IMRT_Status FML_Hdl_DataBuf_Alloc           ( IMRT_Buffer * );
+    IMRT_Status MM_FML_StrHdl_Data_Free         ( IMRT_Buffer * );
+    IMRT_Status	FML_Hdl_Format_Ident            ( IMRT_Buffer * );
+    IMRT_Status MM_FML_StrHdl_Ident             ( IMRT_Msg_Id * , IMRT_Buffer * );
+    IMRT_Status MM_FML_StrHdl_Open              ( IMRT_Buffer * );
+    IMRT_Status MM_FML_StrHdl_Close             ( IMRT_Buffer * );
+    IMRT_Status	MM_FML_StrHdl_Flush             ( IMRT_Buffer * );
+    IMRT_Status MM_FML_StrHdl_Data_List         ( IMRT_Buffer * );
+    IMRT_Status MM_FML_StrHdl_Copy              ( IMRT_Buffer * , IMRT_Buffer * );
+    IMRT_Status	FML_Hdl_Field_Exist             ( IMRT_Field * , IMRT_Buffer * , FLDID32 );
+    IMRT_Status	MM_FML_StrHdl_Get               (IMRT_Buffer_Data ** , IMRT_Field * , IMRT_Buffer * , size_t * );
+    IMRT_Status	MM_FML_StrHdl_Convert           (IMRT_Buffer_Data ** , IMRT_Buffer_Data * , IMRT_Field * , size_t *, IMRT_StrHdl_Cnv_Func * );
+    IMRT_Status	MM_FML_StrHdl_Put               (IMRT_Buffer_Data * , IMRT_Field * , IMRT_Buffer * , size_t );
+    IMRT_Status IMR_MM_FML_StrHdl_Field_Value   ( IMRT_Field * , IMRT_Field_Value_Id);
+    IMRT_Status IMR_MM_FML_StrHdl_Field_Exist   ( IMRT_Field * );
+    IMRT_Status IMR_MM_FML_StrHdl_Msg_Size      ( size_t );
+
+#else
+
+    extern IMRT_Status MM_FML_StrHdl_Init           ( void );
+    extern IMRT_Status MM_FML_StrHdl_DeInit         ( void );
+    extern IMRT_Status MM_FML_StrHdl_Data_Free      ( IMRT_Buffer * );
+    extern IMRT_Status MM_FML_StrHdl_Ident          ( IMRT_Msg_Id * , IMRT_Buffer * );
+    extern IMRT_Status MM_FML_StrHdl_Open           ( IMRT_Buffer * );
+    extern IMRT_Status MM_FML_StrHdl_Close          ( IMRT_Buffer * );
+    extern IMRT_Status MM_FML_StrHdl_Flush          ( IMRT_Buffer * );
+    extern IMRT_Status MM_FML_StrHdl_Data_List      ( IMRT_Buffer * );
+    extern IMRT_Status MM_FML_StrHdl_Copy           ( IMRT_Buffer * , IMRT_Buffer * );
+    extern IMRT_Status MM_FML_StrHdl_Get            (IMRT_Buffer_Data ** , IMRT_Field * , IMRT_Buffer * , size_t * );
+    extern IMRT_Status MM_FML_StrHdl_Convert        (IMRT_Buffer_Data ** , IMRT_Buffer_Data * , IMRT_Field * , size_t *, IMRT_StrHdl_Cnv_Func * );
+    extern IMRT_Status MM_FML_StrHdl_Put            (IMRT_Buffer_Data * , IMRT_Field * , IMRT_Buffer * , size_t );
+
+#endif   
+
+#endif
diff --git a/src/libmapping_mng/src/fmt_hdl_xml.c b/src/libmapping_mng/src/fmt_hdl_xml.c
new file mode 100644
index 0000000..7240df3
--- /dev/null
+++ b/src/libmapping_mng/src/fmt_hdl_xml.c
@@ -0,0 +1,1260 @@
+/*----------------------------------------------------------------------------*/
+/* File: fmt_hdl_.c      				         	      */
+/*----------------------------------------------------------------------------*/
+/*                                                                            */
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#define _LIBMAPPING_MNG_
+#define _XML_HANDLER_C_
+
+#include "fmt_hdl_xml.h" 
+
+IMRT_Status MM_XML_StrHdl_Init()
+{
+	IMRG_XML_Buffer_Ident_Ptr = NULL;
+	return (IMRS_OK);
+}
+
+IMRT_Status MM_XML_StrHdl_DeInit()
+{
+
+	return (IMRS_OK);
+}
+
+IMRT_Status XML_Hdl_DataTemp_Alloc( IMRT_Buffer *Buffer_Ptr )
+{
+	xmlDocPtr 	xml_doc_ptr=NULL;
+	IMRT_Status status;
+	char *func_name = "XML_Hdl_DataTemp_Alloc";
+
+
+	status = IMRS_OK;
+
+	if (Buffer_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Buffer pointer NULL" );
+	}
+	else
+	if (Buffer_Ptr->Data_Tmp_Ptr == NULL)
+	{
+		if ( Buffer_Ptr->Status == IMRD_BUFFER_STATUS_ALLOCATED)
+		{
+			xml_doc_ptr = xmlParseMemory( (char *) Buffer_Ptr->Data_Buf_Ptr, Buffer_Ptr->Data_Buf_Size);
+		}
+		else
+		{
+			xml_doc_ptr = xmlNewDoc ((xmlChar *) IMRD_XML_VERSION);
+		}
+		if ( xml_doc_ptr == NULL)
+		{
+			status = IMRS_KO;
+			IMRD_LM_LOG_ERROR_0("Pointer xml_doc_ptr NULL");
+		}
+		else
+		{
+			Buffer_Ptr->Data_Tmp_Ptr     = (IMRT_Buffer_Data *) xml_doc_ptr;
+			Buffer_Ptr->Data_Tmp_Changed = IMRD_FALSE;
+		}
+	}
+
+	return ( status );
+}
+
+IMRT_Status XML_Hdl_DataTemp_Free( IMRT_Buffer *Buffer_Ptr )
+{
+	IMRT_Status status;
+	char *func_name = "XML_Hdl_DataTemp_Free";
+
+
+	status = IMRS_OK;
+	if (Buffer_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Buffer pointer NULL" );
+	}
+	else
+	if (Buffer_Ptr->Data_Tmp_Ptr != NULL)
+	{
+		xmlFreeDoc( (xmlDocPtr) Buffer_Ptr->Data_Tmp_Ptr);
+		xmlCleanupParser();
+		Buffer_Ptr->Data_Tmp_Ptr     = NULL;
+		Buffer_Ptr->Data_Tmp_Changed = IMRD_FALSE;
+	}
+
+	return ( status );
+}
+
+IMRT_Status XML_Hdl_DataBuf_Free( IMRT_Buffer *Buffer_Ptr )
+{
+	IMRT_Status status;
+	char *func_name = "XML_Hdl_DataBuf_Free";
+
+
+	status = IMRS_OK;
+	if (Buffer_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Buffer pointer NULL" );
+	}
+	else
+	if (Buffer_Ptr->Status == IMRD_BUFFER_STATUS_ALLOCATED)
+	{
+		xmlFree(Buffer_Ptr->Data_Buf_Ptr);
+		Buffer_Ptr->Data_Buf_Ptr  = NULL;	
+		Buffer_Ptr->Status        = IMRD_BUFFER_STATUS_FREED;
+		Buffer_Ptr->Data_Buf_Size = 0;
+		Buffer_Ptr->Data_Buf_Len  = 0;
+	}
+
+	return ( status );
+}
+
+IMRT_Status MM_XML_StrHdl_Data_Free( IMRT_Buffer  *Buffer_Ptr)
+{
+	IMRT_Status status;
+	char *func_name = "MM_XML_StrHdl_Data_Free";
+
+
+	status = IMRS_OK;
+	
+	if (Buffer_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Buffer pointer NULL" );
+	}
+	else
+	{
+		if ( XML_Hdl_DataBuf_Free( Buffer_Ptr ) != IMRS_OK )
+		{
+			status = IMRS_KO;
+			IMRD_LM_LOG_ERROR_0("Error XML_Hdl_DataBuf_Free");
+			
+		}
+		if ( XML_Hdl_DataTemp_Free( Buffer_Ptr ) != IMRS_OK )
+		{
+			status = IMRS_KO;
+			IMRD_LM_LOG_ERROR_0("Error XML_Hdl_DataTemp_Free");
+		}
+	}
+	
+
+	return ( status );
+}
+
+IMRT_Status XML_Hdl_Format_Ident( IMRT_Buffer *Buffer_Ptr )
+{
+	IMRT_Status status;
+	char *func_name = "XML_Hdl_Format_Ident";
+
+
+	status = IMRS_KO;
+	if (Buffer_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Buffer pointer NULL" );
+	}
+	else
+	if (Buffer_Ptr->Status != IMRD_BUFFER_STATUS_ALLOCATED)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Buffer not allocated");
+	}
+	else
+	{
+		if (*Buffer_Ptr->Data_Buf_Ptr == (IMRT_Buffer_Data) '<')
+		{
+			status = IMRS_OK;
+		}
+        }
+	
+
+	return ( status );
+}
+
+IMRT_Status MM_XML_StrHdl_Ident( IMRT_Msg_Id *Msg_Id_Ident_Ptr, 
+                                  IMRT_Buffer *Buffer_Ptr )
+{
+        
+        IMRT_Fmt_Id Format;
+        IMRT_Status status;
+        IMRT_Msg_Id *Msg_Id_Tmp;
+        char *func_name = "MM_XML_StrHdl_Ident";
+        
+        status = IMRS_OK;
+
+	if (Buffer_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Buffer pointer NULL" );
+	}
+	else
+	if (Msg_Id_Ident_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Msg_Id_Ident_Ptr NULL" );
+	}
+	else
+	{
+	        Format = Buffer_Ptr->Fmt_Id;
+	        Msg_Id_Tmp = Msg_Id_Ident_Ptr;
+	
+		IMRG_XML_Buffer_Ident_Ptr = Buffer_Ptr;
+		/* Le Msg_Id transmis au SDM est le point de depart de l'identification */
+		/* C'est egalement le resultat qui sera inclus dans le buffer */
+		status = IMR_SDM_MsgIdent_Proceed(Format, 
+		                                  Msg_Id_Tmp,
+		                                  IMR_MM_XML_StrHdl_Field_Value,
+		                                  IMR_MM_XML_StrHdl_Field_Exist,
+		                                  IMR_MM_XML_StrHdl_Msg_Size);
+		IMRG_XML_Buffer_Ident_Ptr = NULL;
+	
+	        Msg_Id_Ident_Ptr = Msg_Id_Tmp;
+	}
+
+
+	return ( status );
+
+}
+
+IMRT_Status MM_XML_StrHdl_Open( IMRT_Buffer  *Buffer_Ptr)
+{
+	IMRT_Msg_Id type_temp;
+	IMRT_Status status;
+	char *func_name = "MM_XML_StrHdl_Open";
+
+
+	status = IMRS_OK;
+
+	if (Buffer_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Buffer pointer NULL" );
+	}
+	else
+	if (Buffer_Ptr->Data_Tmp_Ptr != NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Pointer Data_Tmp_Ptr NULL");
+	}
+	else
+	{
+		type_temp = Buffer_Ptr->Msg_Id;
+		/* absence de donnees */
+		if (Buffer_Ptr->Status != IMRD_BUFFER_STATUS_ALLOCATED)
+		{
+		        /* Cas d'open du buffer en ecriture */
+		        /* le type du message est passe */
+		        /* par le SDM : il doit donc etre connu */
+			if (type_temp == IMRD_MSG_ID_UNKNOWN)
+			{
+				status = IMRS_KO;
+				IMRD_LM_LOG_ERROR_0("Msg Id unknown");
+			}
+			else
+			{
+				status = XML_Hdl_DataTemp_Alloc( Buffer_Ptr );
+				Buffer_Ptr->Data_Tmp_Changed = IMRD_TRUE;
+			}
+		}
+		else 
+		{
+		        /* controle du format */
+		        status =  XML_Hdl_Format_Ident( Buffer_Ptr );
+		        if (status != IMRS_OK)
+		                status = IMRS_BAD_FORMAT;
+		        else
+			/* acces aux donnees */
+			        status = XML_Hdl_DataTemp_Alloc( Buffer_Ptr );
+		}
+	}
+
+	return ( status );
+}
+
+IMRT_Status MM_XML_StrHdl_Close( IMRT_Buffer *Buffer_Ptr)
+{
+	IMRT_Status	status;
+	char *func_name = "MM_XML_StrHdl_Close";
+
+	status = IMRS_OK;
+
+	if (Buffer_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Buffer pointer NULL" );
+	}
+	else
+	{
+		status = MM_XML_StrHdl_Flush( Buffer_Ptr ); 
+		if ((status == IMRS_OK) && (Buffer_Ptr->Data_Tmp_Ptr != NULL))
+		{
+			status = XML_Hdl_DataTemp_Free( Buffer_Ptr );
+		}
+	}
+
+	return ( status );
+}
+
+IMRT_Status MM_XML_StrHdl_Flush( IMRT_Buffer *Buffer_Ptr)
+{
+	xmlChar *mem_Ptr;
+	int     size;
+	IMRT_Status status;
+	char *func_name = "MM_XML_StrHdl_Flush";
+
+
+	status = IMRS_OK;
+	if (Buffer_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Buffer pointer NULL" );
+	}
+	else
+	if ((Buffer_Ptr->Data_Tmp_Ptr != NULL) && (Buffer_Ptr->Data_Tmp_Changed == IMRD_TRUE))
+	{			
+		if ( Buffer_Ptr->Status == IMRD_BUFFER_STATUS_ALLOCATED )
+		{
+			status = XML_Hdl_DataBuf_Free( Buffer_Ptr );
+		}
+		
+		if ( status == IMRS_OK )
+		{
+
+			/* Dump an XML document in memory and return the #xmlChar * and it's size in bytes. 
+			It's up to the caller to free the memory with xmlFree(). 
+			The resulting byte array is zero terminated, though the last 0 is not included 
+			in the returned size. */
+		    xmlDocDumpFormatMemory( (xmlDocPtr) Buffer_Ptr->Data_Tmp_Ptr, &mem_Ptr, &size,
+					    ( ( IMRG_MM_Base.Config.XML_Format == IMRD_TRUE) ? 1 : 0));
+
+			if (mem_Ptr != NULL)
+			{
+				Buffer_Ptr->Data_Buf_Ptr  = (IMRT_Buffer_Data *) mem_Ptr;
+				Buffer_Ptr->Status        = IMRD_BUFFER_STATUS_ALLOCATED;
+				Buffer_Ptr->Data_Buf_Size = size + 1;
+				Buffer_Ptr->Data_Buf_Len  = size;
+				Buffer_Ptr->Data_Tmp_Changed = IMRD_FALSE;
+			}
+			else
+			{
+				status == IMRS_KO;
+				IMRD_LM_LOG_ERROR_0("Pointer mem_Ptr = NULL after xmlDocDumpMemory");
+			}
+		}
+	}
+ 
+
+	return ( status );
+}
+
+IMRT_Status  MM_XML_StrHdl_Data_List( IMRT_Buffer  *Buffer_Ptr)
+{
+
+	if (Buffer_Ptr == NULL)
+	{
+		IMRD_LM_LOG_WARNING_0("Buffer pointer NULL" );
+	}
+	else
+	{
+	    IMRD_LM_LOG_TRACE_3( IMRD_LOG_LEVEL_VERBOSE_1, "Buffer_List: Data_Buf_Ptr_Size: (%d)   Data_Buf_Ptr_Len: (%d)   Data_Buf_Ptr: (0x%X)", Buffer_Ptr->Data_Buf_Size, Buffer_Ptr->Data_Buf_Len, Buffer_Ptr->Data_Buf_Ptr);
+	    IMRD_LM_LOG_TRACE_1( IMRD_LOG_LEVEL_VERBOSE_2, "Buffer_List: Data_Buf: [%s]", Buffer_Ptr->Data_Buf_Ptr);
+	
+	    IMRD_LM_LOG_TRACE_2( IMRD_LOG_LEVEL_VERBOSE_1, "Buffer_List: Data_Tmp_Changed: (%d)   Data_Tmp_Ptr: (0x%X)", Buffer_Ptr->Data_Tmp_Changed, Buffer_Ptr->Data_Tmp_Ptr);
+	
+	    if (Buffer_Ptr->Data_Tmp_Ptr != NULL)
+	    {
+		IMRD_LM_EXEC_TRACE( IMRD_LOG_LEVEL_VERBOSE_2, "Buffer_List: Data_Tmp: [", xmlDocFormatDump( IMRD_LM_STREAM_OUT, (xmlDocPtr) Buffer_Ptr->Data_Tmp_Ptr, 1), "]");
+	    }
+	}
+	
+    return ( IMRS_OK);
+}
+
+
+
+IMRT_Status MM_XML_StrHdl_Copy( IMRT_Buffer *Output_Buffer_Ptr, IMRT_Buffer *Input_Buffer_Ptr )
+{
+	IMRT_Status status;
+	char *func_name = "MM_XML_StrHdl_Copy";
+
+	
+	status = IMRS_OK;
+	
+	if (Input_Buffer_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Input buffer pointer NULL" );
+	}
+	else
+	if (Output_Buffer_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Output buffer pointer NULL" );
+	}
+	else
+	/* controle donnees dans Input_Buffer */
+	if (Input_Buffer_Ptr->Status != IMRD_BUFFER_STATUS_ALLOCATED)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Buffer input not allocated");
+	}
+	/* le buffer destinataire ne doit pas comporter de donnees */ 
+	else if ( ( Output_Buffer_Ptr->Status == IMRD_BUFFER_STATUS_ALLOCATED) ||
+	          ( Output_Buffer_Ptr->Data_Tmp_Ptr != NULL) )
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Buffer output not allocated or Data_Tmp_Ptr no NULL");
+	}
+	else
+	{
+		Output_Buffer_Ptr->Data_Buf_Ptr = (IMRT_Buffer_Data *) malloc ( Input_Buffer_Ptr->Data_Buf_Size );
+		if (Output_Buffer_Ptr->Data_Buf_Ptr != NULL)
+		{
+			memcpy( Output_Buffer_Ptr->Data_Buf_Ptr,
+			        Input_Buffer_Ptr->Data_Buf_Ptr,
+			        Input_Buffer_Ptr->Data_Buf_Size);
+			Output_Buffer_Ptr->Status        = IMRD_BUFFER_STATUS_ALLOCATED;
+			Output_Buffer_Ptr->Data_Buf_Size = Input_Buffer_Ptr->Data_Buf_Size;
+			Output_Buffer_Ptr->Data_Buf_Len  = Input_Buffer_Ptr->Data_Buf_Len;
+		}
+		else
+		{
+			status = IMRS_KO;
+			IMRD_LM_LOG_ERROR_0("Pointer Data_Buf_Ptr of output buffer is NULL");
+		}
+	}
+ 
+
+	return ( status );
+}
+
+IMRT_Status	XML_Hdl_Field_Exist(IMRT_Field *Field_Ptr , IMRT_Buffer *Buffer_Ptr)
+{
+        IMRT_Status status;
+	xmlXPathContextPtr context;
+	xmlNodeSetPtr      nodeset;
+	xmlXPathObjectPtr  result;
+	xmlDocPtr          xml_doc_ptr; 
+	xmlChar            *xpath;
+
+        char *func_name = "XML_Hdl_Field_Exist";
+        
+	
+	status   = IMRS_OK;
+
+	if (Buffer_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Buffer pointer NULL" );
+	}
+	else
+	if (Field_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Field pointer NULL" );
+	}
+	else
+	if (Buffer_Ptr->Data_Tmp_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Data_Tmp_Ptr of buffer is NULL");
+	}
+	else
+	{
+		xml_doc_ptr = (xmlDocPtr) Buffer_Ptr->Data_Tmp_Ptr;
+		xpath       = (xmlChar *) Field_Ptr->XML.Tag;
+		context     = xmlXPathNewContext(xml_doc_ptr);
+		result      = xmlXPathEvalExpression(xpath, context);
+		if (result == NULL)
+		{
+			status = IMRS_KO;
+			IMRD_LM_LOG_ERROR_0("XPath eval expression pointer NULL" );			
+		}
+		else
+		{
+
+			if(xmlXPathNodeSetIsEmpty(result->nodesetval))
+			{
+				status = IMRS_NO_IDENT;
+			}
+			else
+			{			
+				nodeset = result->nodesetval;
+				
+				if (nodeset->nodeNr != 1)
+				{
+				        status = IMRS_NO_IDENT;
+				        IMRD_LM_LOG_TRACE_1(IMRD_LOG_LEVEL_VERBOSE_1 , "number of occurences not equal to one for %s",Field_Ptr->Name);
+				}
+			}
+			xmlXPathFreeContext(context);			        
+			xmlXPathFreeObject(result);
+		}
+	}
+
+        
+
+
+	return ( status );
+
+}
+
+
+IMRT_Status	MM_XML_StrHdl_Get(IMRT_Buffer_Data **Data_Ptr_Ptr, IMRT_Field *Field_Ptr,
+                                        IMRT_Buffer *Buffer_Ptr , size_t *len )
+{
+	IMRT_Buffer_Data   *data_ptr;
+	int                sizeTmp;
+	xmlXPathContextPtr context;
+	xmlXPathObjectPtr  result;
+	xmlNodeSetPtr      nodeset;
+	xmlDocPtr          xml_doc_ptr; 
+	xmlChar            *xpath, 
+	                   *xml_data_ptr;
+	IMRT_Status status;
+	char *func_name = "MM_XML_StrHdl_Get";
+
+	
+	status = IMRS_OK;
+	*Data_Ptr_Ptr = NULL;
+	data_ptr = NULL;
+	sizeTmp = 0;
+
+	if (Data_Ptr_Ptr == NULL) 
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Data_Ptr_Ptr NULL");
+	}
+	else if (len == NULL) 
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("len pointer NULL");
+	}
+	else if (Buffer_Ptr == NULL) 
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Buffer_Ptr NULL");
+	}
+	else if (Field_Ptr == NULL) 
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Field_Ptr NULL");
+	}
+
+        /* Controle de validite du tag */
+        if ((status == IMRS_OK) && (strcmp(Field_Ptr->XML.Tag ,IMRD_XML_TAG_UNKNOWN) == 0))
+        {
+            status   = IMRS_KO;
+            IMRD_LM_LOG_ERROR_0("Tag XML unknown");
+        }
+
+	/* controle donnees dans le buffer */
+	if ((status == IMRS_OK) && (Buffer_Ptr->Data_Tmp_Ptr == NULL))
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Data_Tmp_Ptr of buffer is NULL");
+	}
+	else
+	{
+		xml_doc_ptr = (xmlDocPtr) Buffer_Ptr->Data_Tmp_Ptr;
+		xpath       = (xmlChar *) Field_Ptr->XML.Tag;
+		context     = xmlXPathNewContext(xml_doc_ptr);
+		result      = xmlXPathEvalExpression(xpath, context);
+		if (result == NULL)
+		{
+			status = IMRS_KO;
+			IMRD_LM_LOG_ERROR_0("XPath eval expression pointer NULL" );
+		}
+		else if(xmlXPathNodeSetIsEmpty(result->nodesetval))
+		{
+			status = IMRS_NO_IDENT;
+		}
+		xmlXPathFreeContext(context);
+	}
+	
+	
+	
+        /* le champ existe => on extrait la valeur */
+        if (status == IMRS_OK)
+	{
+		nodeset = result->nodesetval;
+		/* nombre d'occurences */
+		if (nodeset->nodeNr != 1)
+		{
+			status = IMRS_KO;
+			IMRD_LM_LOG_ERROR_1("number of occurences not equal to one for %s",Field_Ptr->Name);
+		}
+		else
+		{
+			xml_data_ptr = xmlNodeListGetString(xml_doc_ptr, nodeset->nodeTab[0]->xmlChildrenNode, 1);
+			if (xml_data_ptr == NULL)
+			{
+				status = IMRS_NO_IDENT;
+			}
+			else
+			{
+			    
+			    sizeTmp = strlen((char *)xml_data_ptr) + 1;
+
+//			    IMRD_LM_LOG_TRACE_2( IMRD_LOG_LEVEL_VERBOSE_1, "[%s] (%d)", xml_data_ptr, sizeTmp);
+			    
+			    if( ( *Data_Ptr_Ptr = (IMRT_Buffer_Data *)malloc( sizeTmp)) == NULL)
+			    {
+				status = IMRS_KO;
+				IMRD_LM_LOG_ERROR_0 ( "Can't allocate memory...");
+			    }
+			    else
+			    {
+				UTF8Toisolat1( (unsigned char  *)*Data_Ptr_Ptr, &sizeTmp, xml_data_ptr, &sizeTmp);
+
+//				IMRD_LM_LOG_TRACE_3( IMRD_LOG_LEVEL_VERBOSE_1, "[%s] (%d) (%d)", xml_data_ptr, sizeTmp, strlen( *Data_Ptr_Ptr));
+
+				sizeTmp = strlen( *Data_Ptr_Ptr);
+			    }
+			    
+			    xmlFree( xml_data_ptr);
+			}
+		}
+		
+	}
+
+        /* Le champ n'existe pas => on prend la valeur par defaut */
+        if (status == IMRS_NO_IDENT)
+        {
+                sizeTmp = strlen(Field_Ptr->XML.Def_Val);
+                data_ptr = (IMRT_Buffer_Data *) malloc ( sizeTmp + 1);
+                if (data_ptr == NULL)
+                {
+                        status   = IMRS_KO;
+                        IMRD_LM_LOG_ERROR_0("Malloc error on data_ptr");
+                }
+                else
+                {
+                        memset( data_ptr, '\0', sizeTmp + 1 );
+                        memcpy(data_ptr , Field_Ptr->XML.Def_Val , sizeTmp );
+                        *(data_ptr + sizeTmp) = '\0';
+                        *Data_Ptr_Ptr = data_ptr;
+                        status   = IMRS_OK;
+                }                
+        }       
+
+	if (status == IMRS_OK)
+	{
+		*len = sizeTmp;
+	}
+	
+	if(result != NULL)
+		xmlXPathFreeObject(result);
+
+	return ( status );
+}
+
+
+IMRT_Status     IMR_MM_XML_StrHdl_Msg_Size    ( size_t Msg_Size)
+{
+	IMRT_Status status;
+	char *func_name = "IMR_MM_XML_StrHdl_Msg_Size";
+
+	IMRD_LM_LOG_TRACE_0(IMRD_LOG_LEVEL_VERBOSE_1 ,  "============================================================================")
+	IMRD_LM_LOG_TRACE_0(IMRD_LOG_LEVEL_VERBOSE_1 , "Size msg demand : Begin");
+	IMRD_LM_LOG_TRACE_1(IMRD_LOG_LEVEL_VERBOSE_1 , "Msg_Size  : (%ld)" , Msg_Size);	
+
+        /* Erreur de referentiel */
+        status = IMRS_KO;
+        IMRD_LM_LOG_WARNING_0("Referential error ; this should never happen");
+
+	IMRD_LM_LOG_TRACE_1(IMRD_LOG_LEVEL_VERBOSE_2 , "Size msg demand : End with status :  (%d)" , status);
+	IMRD_LM_LOG_TRACE_0(IMRD_LOG_LEVEL_VERBOSE_2 ,  "============================================================================")
+
+	return ( status );
+}
+
+
+IMRT_Status IMR_MM_XML_StrHdl_Field_Exist( IMRT_Field *Field_Ptr )
+{
+	IMRT_Status status;
+	char *func_name = "IMR_MM_XML_StrHdl_Field_Exist";
+
+        status = IMRS_OK;
+
+	if (Field_Ptr == NULL) 
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Field_Ptr NULL");
+	}
+	else
+	{
+		IMRD_LM_LOG_TRACE_0(IMRD_LOG_LEVEL_VERBOSE_1 ,  "============================================================================")
+		IMRD_LM_LOG_TRACE_0(IMRD_LOG_LEVEL_VERBOSE_1 , "Existing field demand : Begin");
+		IMRD_LM_LOG_TRACE_1(IMRD_LOG_LEVEL_VERBOSE_1 , "Field Input name  : [%s]" , Field_Ptr->Name);	
+	
+		if (IMRG_XML_Buffer_Ident_Ptr == NULL)
+		{
+			status = IMRS_KO;
+			IMRD_LM_LOG_ERROR_0("Buffer pointer NULL");
+		}
+		else
+		{
+			status = XML_Hdl_Field_Exist( Field_Ptr, IMRG_XML_Buffer_Ident_Ptr);
+		}
+	}
+
+	IMRD_LM_LOG_TRACE_1(IMRD_LOG_LEVEL_VERBOSE_2 , "Existing field demand : End with status :  (%d)" , status);
+	IMRD_LM_LOG_TRACE_0(IMRD_LOG_LEVEL_VERBOSE_2 ,  "============================================================================")
+
+	return ( status );
+}
+
+IMRT_Status IMR_MM_XML_StrHdl_Field_Value( IMRT_Field *Field_Ptr , IMRT_Field_Value_Id Value_Id )
+{
+	IMRT_Buffer_Data *data_ptr;
+	IMRT_Status status;
+	size_t field_len;
+	char *func_name = "IMR_MM_XML_StrHdl_Field_Value";
+
+        status = IMRS_OK;
+
+	if (Field_Ptr == NULL) 
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Field_Ptr NULL");
+	}
+	else
+	{
+		IMRD_LM_LOG_TRACE_0(IMRD_LOG_LEVEL_VERBOSE_1 ,  "============================================================================")
+		IMRD_LM_LOG_TRACE_0(IMRD_LOG_LEVEL_VERBOSE_1 , "Field Value demand : Begin");
+		IMRD_LM_LOG_TRACE_2(IMRD_LOG_LEVEL_VERBOSE_1 , "Field Input name  : [%s] Value Id : [%s]" , Field_Ptr->Name , Value_Id);	
+	
+	        field_len = 0L;
+		
+		if (IMRG_XML_Buffer_Ident_Ptr == NULL)
+		{
+			status = IMRS_KO;
+			IMRD_LM_LOG_ERROR_0("Buffer pointer NULL");
+		}
+		else
+		{
+			status = MM_XML_StrHdl_Get(&data_ptr, Field_Ptr, IMRG_XML_Buffer_Ident_Ptr , &field_len );
+		}
+		
+		if (status == IMRS_OK)
+		{
+			IMRD_LM_LOG_TRACE_1(IMRD_LOG_LEVEL_VERBOSE_2 , "Value extracted :  [%s]" , data_ptr);
+			if (strcmp(data_ptr, Value_Id) != 0)
+			{
+				status = IMRS_NO_IDENT;
+			}
+			free(data_ptr);
+		}
+	}
+
+	IMRD_LM_LOG_TRACE_1(IMRD_LOG_LEVEL_VERBOSE_2 , "Field Value demand : End with status :  (%d)" , status);
+	IMRD_LM_LOG_TRACE_0(IMRD_LOG_LEVEL_VERBOSE_2 ,  "============================================================================")
+
+	return ( status );
+}
+
+IMRT_Status	MM_XML_StrHdl_Convert(IMRT_Buffer_Data **Data_Output_Ptr , IMRT_Buffer_Data *Data_Input_Ptr , IMRT_Field *Field_Ptr,  
+                                       size_t *len , IMRT_StrHdl_Cnv_Func *Cnv_Func_Tab )
+{
+	IMRT_Status status;
+        size_t size;
+	char *func_name = "MM_XML_StrHdl_Convert";
+
+
+
+	
+	status = IMRS_OK;
+
+	if (len == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("len pointer NULL");
+	}
+	else if (Data_Output_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Data_Output_Ptr NULL");
+	}
+	else if (Cnv_Func_Tab == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Cnv_Func_Tab NULL");
+	}
+	else
+	{
+		size = *len ;
+	
+		*Data_Output_Ptr = (IMRT_Buffer_Data *)malloc(size + 1L);
+		if (*Data_Output_Ptr == NULL)
+		{
+			status = IMRS_KO;
+			IMRD_LM_LOG_ERROR_0("*Data_Output_Ptr NULL");
+		}
+		else
+		{
+        	memset( *Data_Output_Ptr, '\0' , (size + 1L) );
+
+			if (Field_Ptr == NULL) 
+			{
+				status = IMRS_KO;
+				IMRD_LM_LOG_ERROR_0("Field_Ptr NULL");
+			}
+			else
+			if (Data_Input_Ptr == NULL) 
+			{
+				status = IMRS_KO;
+				IMRD_LM_LOG_ERROR_0("Data_Input_Ptr NULL");
+			}
+			else
+			{
+		                /* Appel de la fonction de convertion */
+				if ((Field_Ptr->XML.Cnv_Ptr == NULL) || (Cnv_Func_Tab[Field_Ptr->XML.Cnv_Ptr->Id].Convert_Ptr == NULL))
+				{
+					IMRD_LM_LOG_TRACE_0( IMRD_LOG_LEVEL_VERBOSE_1 , "Pas de fonction de conversion");
+			
+			                if (Data_Input_Ptr != NULL)
+			                        memcpy(*Data_Output_Ptr,Data_Input_Ptr,*len);
+				}
+				else
+				{
+					status = Cnv_Func_Tab[Field_Ptr->XML.Cnv_Ptr->Id].Convert_Ptr(*Data_Output_Ptr, 
+					                                                         Data_Input_Ptr, 
+					                                                         len,
+					                                                         size ,
+					                                                         Field_Ptr->XML.Cnv_Attr );
+				}
+			}
+		}
+	}
+
+    if (Data_Input_Ptr != NULL)
+        free(Data_Input_Ptr);
+
+
+	return ( status );
+
+}
+
+IMRT_Status  MM_XML_DInit_StructPath(IMRT_PARSE_PATH_XML * Parse_PathStruct_Ptr)
+{
+   int indexe = 0;
+   IMRT_Status status = IMRS_OK;
+
+   if(Parse_PathStruct_Ptr == NULL)
+   {
+	status = IMRS_KO;
+	IMRD_LM_LOG_ERROR_0("Parse_PathStruct_Ptr NULL");
+   }
+   else
+   {
+    if(Parse_PathStruct_Ptr->Father_Table != NULL)
+    {
+	for(indexe=0; indexe < Parse_PathStruct_Ptr->Nb_Father; indexe++)
+	{
+	    if(Parse_PathStruct_Ptr->Father_Table[indexe] != NULL)
+	    {
+	       free(Parse_PathStruct_Ptr->Father_Table[indexe]);
+	    }
+	}
+	free(Parse_PathStruct_Ptr->Father_Table);
+    }
+    Parse_PathStruct_Ptr->Nb_Father = 0; 
+   }
+   return(status);
+}
+
+IMRT_Status MM_XML_Proceed_Path( IMRT_PARSE_PATH_XML * PathXml_Ptr, IMRT_Buffer_Data * value, xmlDocPtr xml_doc_ptr)
+{
+    xmlNodePtr xml_cur_node_ptr;
+    xmlNodePtr root_node_ptr;
+    xmlNodePtr xml_node1_ptr; 
+    xmlNodePtr xml_father_node_ptr;
+    xmlNodePtr xml_brother_node_ptr;
+    xmlAttrPtr Attribute_Ptr;
+    
+    int indexe = 0;
+    IMRT_Status status;
+  
+    
+    status = IMRS_OK;
+
+	if (PathXml_Ptr == NULL) 
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("PathXml_Ptr NULL");
+	}
+	else if (value == NULL) 
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("value NULL");
+	}
+	else
+	if (xml_doc_ptr == NULL) 
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("xml_doc_ptr NULL");
+	}
+	else
+	{
+
+	    xml_cur_node_ptr = xmlDocGetRootElement(xml_doc_ptr);  
+	
+	    for(indexe = 0; indexe < PathXml_Ptr->Nb_Father; indexe++)
+	    {
+	   
+		while( ( xml_cur_node_ptr != NULL) && 
+		       (strcmp((const char*)xml_cur_node_ptr->name ,
+			       (const char*)PathXml_Ptr->Father_Table[indexe]) != 0)
+		    )
+		{
+		    xml_brother_node_ptr = xml_cur_node_ptr;
+		    xml_cur_node_ptr = xml_cur_node_ptr->next;
+	
+		}
+	
+		if(xml_cur_node_ptr == NULL)
+		{
+		    /*il faut creer le root**/
+		    if(indexe == IMRD_FIRST_NODE )
+		    {
+			xml_father_node_ptr = xmlNewNode ( NULL, (const xmlChar *) PathXml_Ptr->Father_Table[indexe]);
+			if(xml_father_node_ptr != NULL)
+	                {
+			    xmlDocSetRootElement( xml_doc_ptr, xml_father_node_ptr );
+			    xml_cur_node_ptr  = xml_father_node_ptr; 
+	                }
+	                else
+			{
+			    /*echec de la creation du nouveau noeud on sort*/
+			    status = IMRS_KO;
+	                    break;  
+	                }
+		    }
+		    else /*il faut creer un fils*/
+		    {
+			 xml_cur_node_ptr = xmlNewChild( xml_father_node_ptr, NULL, (const xmlChar *) (const xmlChar *) PathXml_Ptr->Father_Table[indexe], NULL);
+			 if(xml_cur_node_ptr != NULL)
+			 {    
+			     xml_father_node_ptr= xml_cur_node_ptr;
+		
+			 }
+			 else
+			 {
+			     /*echec de la creation du nouveau noeud on sort*/
+			    status = IMRS_KO;
+	                    break;   
+			 }
+		    }
+		}
+		else
+		{
+		    xml_father_node_ptr = xml_cur_node_ptr;
+		    xml_cur_node_ptr = xml_cur_node_ptr->xmlChildrenNode;
+		
+		}      
+	    }
+	    /*Tout les pere existaient ou on ete crees*/
+	    /*creation d'un fils (feuille et insertion de sa valeur*/
+	    /*le pere vien d'être cree c'est le noeud courant*/
+	    /*si le mode est egale à 0 alors on est mode creation 
+	      le neoud pere vient d'être cree c'est le noeud courant*/
+	         xml_cur_node_ptr = xmlNewChild(  xml_father_node_ptr, NULL, (const xmlChar *) PathXml_Ptr->Soon_Name, NULL);
+		if(xml_cur_node_ptr != NULL)
+	        {
+		    xml_node1_ptr = xmlNewText( (const xmlChar *) value );
+		
+		    if( PathXml_Ptr->Attribute_present == IMRS_OK )
+		    {
+			Attribute_Ptr = xmlNewProp(xml_cur_node_ptr,(const xmlChar *)PathXml_Ptr->Attribute_Name,(const xmlChar *)PathXml_Ptr->Attribute_Value);
+	            }
+	    
+		    xmlAddChild(xml_cur_node_ptr,xml_node1_ptr);
+	        }
+		else
+		{
+		    status = IMRS_KO;
+		}    
+	}
+	
+  
+    return(status);
+}
+
+IMRT_Status MM_XML_SplitAttribute( IMRT_PARSE_PATH_XML * PathXml_Ptr )
+{
+    char * pos_deb_attribute_ptr = NULL;
+    char * pos_fin_attribute_ptr = NULL;
+    size_t len_attribute_value;
+    static const char SEP_XPATH_DEB [] = "[";
+    static const char SEP_XPATH_FIN [] = "]";
+    static const char SEP_ATTRIBUTE [] = "@";
+    IMRT_Status status;
+
+
+	if (PathXml_Ptr == NULL) 
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("PathXml_Ptr NULL");
+	}
+	else
+	{
+	    memset(PathXml_Ptr->Attribute_Name, '\0',sizeof(PathXml_Ptr->Attribute_Name));
+	    memset(PathXml_Ptr->Attribute_Value, '\0',sizeof(PathXml_Ptr->Attribute_Value));
+	    len_attribute_value = 0;
+	    status = IMRS_OK;  
+	  
+	    pos_deb_attribute_ptr = strstr((const char*)PathXml_Ptr->Soon_Name,SEP_XPATH_DEB);
+	    pos_fin_attribute_ptr = strstr((const char*)PathXml_Ptr->Soon_Name,SEP_XPATH_FIN);
+	    PathXml_Ptr->Attribute_present = IMRS_KO;
+	              
+	  
+	    if( (pos_deb_attribute_ptr != NULL) && (pos_fin_attribute_ptr != NULL) )
+	    {
+		
+	                   
+		if(PathXml_Ptr->Soon_Name[(pos_deb_attribute_ptr -PathXml_Ptr->Soon_Name)+1 ] == '@')
+		{
+		    /*on se positionne sur le debut de l'occurence*/
+		    pos_deb_attribute_ptr = pos_deb_attribute_ptr +2;
+	
+		    pos_fin_attribute_ptr = strstr(PathXml_Ptr->Soon_Name,"=");                       
+		    strncpy(PathXml_Ptr->Attribute_Name,pos_deb_attribute_ptr,(pos_fin_attribute_ptr -  pos_deb_attribute_ptr));
+		    PathXml_Ptr->Attribute_Name[(pos_fin_attribute_ptr -  pos_deb_attribute_ptr)] = '\0';
+	
+		    /*on se positionne au debut de la valeur*/
+		    pos_deb_attribute_ptr = pos_fin_attribute_ptr+1;
+	
+		    len_attribute_value = (size_t) ( (PathXml_Ptr->Soon_Name + strlen(PathXml_Ptr->Soon_Name)) - pos_deb_attribute_ptr ) -3; 
+		    strncpy(PathXml_Ptr->Attribute_Value,pos_deb_attribute_ptr+1,len_attribute_value);
+	            PathXml_Ptr->Attribute_present = IMRS_OK ;  
+		}
+	        
+	        pos_deb_attribute_ptr = strstr((const char*)PathXml_Ptr->Soon_Name,SEP_XPATH_DEB);        
+		PathXml_Ptr->Soon_Name[(pos_deb_attribute_ptr - PathXml_Ptr->Soon_Name)] = '\0';     
+	    }
+	}
+	
+    return(status);
+}
+
+IMRT_Status  MM_XML_Split_Path( IMRT_Buffer_Data * Chaine_Ptr , IMRT_PARSE_PATH_XML * PathXml_Ptr )
+{
+    int indexe  = 0;
+    size_t len  =0;
+    const char SEP_XML [] = "/";
+    char * sep_position_prec = NULL;
+    char * sep_position_suiv = NULL;
+    char SEP_XML_CHAR  = '/';
+    IMRT_Status status;
+
+/*initialisation */
+    
+
+    if( Chaine_Ptr == NULL)
+    {
+	IMRD_LM_LOG_ERROR_0("Le pointeur chaine a traiter est NULL");
+	status = IMRS_KO;
+    }
+    else
+    if( PathXml_Ptr == NULL)
+    {
+	IMRD_LM_LOG_ERROR_0("PathXml_Ptr NULL");
+	status = IMRS_KO;
+    }
+    else
+    {
+	PathXml_Ptr->Father_Table = NULL;
+        memset(PathXml_Ptr->Soon_Name, '\0', sizeof(PathXml_Ptr->Soon_Name));
+        PathXml_Ptr->Nb_Father = 0;
+	len =  strlen(Chaine_Ptr);
+	status = IMRS_OK;
+  
+	/*calcul du nombre de pere */
+	for( indexe=0; indexe <len ; indexe++)
+	{
+	    if(Chaine_Ptr[indexe] ==  SEP_XML_CHAR)
+	    {
+		PathXml_Ptr->Nb_Father++;
+	    }
+	}
+	/*si la chaîne commence par un / on en tien pas compte*/
+	if(Chaine_Ptr[0] == SEP_XML_CHAR)
+	{
+	    sep_position_suiv = Chaine_Ptr +1;
+	    sep_position_prec = Chaine_Ptr +1;
+	    PathXml_Ptr->Nb_Father = PathXml_Ptr->Nb_Father -1;
+	}  
+	else
+	{
+	    sep_position_suiv = Chaine_Ptr ;
+	    sep_position_prec = Chaine_Ptr;
+	}
+	/* allocation du tableau de peres */
+	PathXml_Ptr->Father_Table =  (IMRT_FATHER_TABLE)malloc(sizeof(char *) * PathXml_Ptr->Nb_Father);
+	if( PathXml_Ptr->Father_Table == NULL)
+	{
+	    /*erreur d'allocation memoire**/
+	    IMRD_LM_LOG_ERROR_0("Erreur allocation memoire");
+	    status = IMRS_KO;
+	}
+	else
+	{
+	    for(indexe = 0 ; indexe < PathXml_Ptr->Nb_Father; indexe++)
+	    {
+		PathXml_Ptr->Father_Table[indexe] = (char *)malloc(IMRD_FATHER_SIZE);
+		if(PathXml_Ptr->Father_Table[indexe] == NULL)
+		{
+		    /*erreur allocation */
+		    IMRD_LM_LOG_ERROR_0("Erreur allocation memoire");
+		    status = IMRS_KO;
+		    break ;
+		}
+
+	    }
+      
+	    /*eclatement de la chaîne  sur le n elemment on a 
+	      n-1 noeud et le n ieme elment est une feuille*/  
+	    if(status == IMRS_OK)
+	    {
+		for(indexe =0; indexe <= PathXml_Ptr->Nb_Father; indexe++)
+		{
+		    /*on est a la fin de la chaine c'est une feuille */
+		    if( indexe == PathXml_Ptr->Nb_Father )
+		    {
+			strncpy(PathXml_Ptr->Soon_Name,sep_position_suiv,((Chaine_Ptr +len) - sep_position_suiv));
+                        PathXml_Ptr->Soon_Name[((Chaine_Ptr +len) - sep_position_suiv)] = '\0';
+                        status = MM_XML_SplitAttribute(PathXml_Ptr);
+		    }
+		    else
+		    {
+			/*recopie des pere dans le tableau */
+			sep_position_suiv = strstr((const char *)sep_position_suiv, SEP_XML);
+			if( sep_position_suiv != NULL)
+			{
+			    strncpy(PathXml_Ptr->Father_Table[indexe], sep_position_prec, (sep_position_suiv - sep_position_prec));
+			    PathXml_Ptr->Father_Table[indexe][( sep_position_suiv - sep_position_prec)] = '\0';
+
+			    sep_position_suiv  = sep_position_suiv+1; 
+			    sep_position_prec  = sep_position_suiv; 
+			}
+		    }
+		}
+         
+	    }
+	}
+    }
+    return(status); 
+}
+
+
+
+
+IMRT_Status   MM_XML_StrHdl_Put(IMRT_Buffer_Data *Data_Ptr, IMRT_Field *Field_Ptr,  
+				  IMRT_Buffer *Buffer_Ptr , size_t len )
+{
+ char *func_name = "MM_XML_StrHdl_Put";
+ IMRT_Status status;
+ xmlDocPtr  xml_doc_ptr;
+ IMRT_Buffer_Data tagxml_tab[IMRD_XML_TAG_LEN];
+ IMRT_PARSE_PATH_XML Path_XML_Struct;
+
+
+ status = IMRS_OK;
+
+	if (Buffer_Ptr == NULL) 
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Buffer_Ptr NULL");
+	}
+	else if (Field_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Field_Ptr NULL");
+	}
+	else if (Data_Ptr == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("data pointer NULL");
+	}
+	else
+	{ 
+		 /* Controle de validite du tag */
+		 if (strcmp(Field_Ptr->XML.Tag ,IMRD_XML_TAG_UNKNOWN) == 0)
+		 {
+		     status   = IMRS_KO;
+		     IMRD_LM_LOG_ERROR_0("Tag XML unknown");
+		 }
+	}
+
+
+ if ((status == IMRS_OK) && (strcmp(Data_Ptr , "") == 0))
+     status = IMRD_STATUS_NOTHING_TO_DO;
+
+ if (status == IMRS_OK)
+ {
+     /* controle sur le buffer et la valeur */
+     if (Buffer_Ptr->Data_Tmp_Ptr == NULL)
+     {
+	 status = IMRS_KO;
+	 IMRD_LM_LOG_ERROR_0("Buffer pointer NULL");
+     }
+     else 
+     {
+	 xml_doc_ptr = (xmlDocPtr) Buffer_Ptr->Data_Tmp_Ptr;
+	 strcpy( tagxml_tab, (IMRT_Buffer_Data *) Field_Ptr->XML.Tag);
+	 //status = MM_XML_Init_StructPath(&Path_XML_Struct);
+
+         if(status == IMRS_OK)
+	 {
+	     IMRD_LM_LOG_TRACE_1( IMRD_LOG_LEVEL_VERBOSE_2 , "Tag xml [%s] ",tagxml_tab);
+            status =  MM_XML_Split_Path( tagxml_tab ,&Path_XML_Struct  );
+	    if(status == IMRS_OK)
+            {
+		status = MM_XML_Proceed_Path( &Path_XML_Struct,Data_Ptr, xml_doc_ptr);
+            }		
+         }
+	 status = MM_XML_DInit_StructPath(&Path_XML_Struct);
+     }
+ }
+
+	if (status == IMRS_OK)
+	{
+	        /* Mise a jour de la taille du buffer */
+	        Buffer_Ptr->Data_Buf_Len = (Buffer_Ptr->Data_Buf_Len) + len;
+	}
+
+ if (status == IMRD_STATUS_NOTHING_TO_DO)
+        status = IMRS_OK;
+
+	if (Data_Ptr != NULL)
+                free(Data_Ptr);
+
+ return(status);
+}
+
+
diff --git a/src/libmapping_mng/src/fmt_hdl_xml.h b/src/libmapping_mng/src/fmt_hdl_xml.h
new file mode 100644
index 0000000..49c7cc7
--- /dev/null
+++ b/src/libmapping_mng/src/fmt_hdl_xml.h
@@ -0,0 +1,135 @@
+/*----------------------------------------------------------------------------*/
+/* File: fmt_hdl_xml.h    		        		         	      */
+/*----------------------------------------------------------------------------*/
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#ifndef _XML_HANDLER_H_
+#define _XML_HANDLER_H_
+                                      
+#include <libxml/tree.h> 
+#include <libxml/xpath.h>
+
+/*----------------------------------------------------------------------------*/
+/* Global Include                                                             */
+/*----------------------------------------------------------------------------*/
+
+#include "libmapping_mng.h"
+
+
+/*----------------------------------------------------------------------------*/
+/* Local definition                                                           */
+/*----------------------------------------------------------------------------*/
+
+#ifdef _XML_HANDLER_C_
+		
+#    define IMRD_XML_VERSION   "1.0"
+#    define IMRD_XML_BALISE    "/"
+#    define IMRD_SOON_SIZE     100
+#    define IMRD_FIRST_NODE    0
+#    define IMRD_FATHER_SIZE   100
+#    define IMRD_ATTIBUTE_SIZE 100  
+    
+   typedef int     IMRT_NB_FATHER ;
+   typedef char ** IMRT_FATHER_TABLE;
+
+
+   typedef struct IMRT_PARSE_PATH_XML
+   {
+	   IMRT_NB_FATHER Nb_Father;
+           IMRT_Status Attribute_present;
+	   IMRT_FATHER_TABLE Father_Table;
+	   char Soon_Name[IMRD_SOON_SIZE];
+           char Attribute_Name[IMRD_ATTIBUTE_SIZE];
+           char Attribute_Value[IMRD_ATTIBUTE_SIZE];  
+  
+   }IMRT_PARSE_PATH_XML;
+
+#endif
+
+/*----------------------------------------------------------------------------*/
+/*	Global Variables		                                      */
+/*----------------------------------------------------------------------------*/
+
+#ifdef _XML_HANDLER_C_
+		
+    IMRT_Buffer	*IMRG_XML_Buffer_Ident_Ptr;
+
+#endif
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/*	Prototypes			                                      */
+/*----------------------------------------------------------------------------*/
+
+#ifdef _XML_HANDLER_C_
+
+    IMRT_Status MM_XML_StrHdl_Init          ( void );
+    IMRT_Status MM_XML_StrHdl_DeInit        ( void );
+    IMRT_Status	XML_Hdl_DataTemp_Alloc      ( IMRT_Buffer * );
+    IMRT_Status	XML_Hdl_DataTemp_Free       ( IMRT_Buffer * );
+    IMRT_Status	XML_Hdl_DataBuf_Free        ( IMRT_Buffer * );
+    IMRT_Status	MM_XML_StrHdl_Data_Free     ( IMRT_Buffer * );
+    IMRT_Status	XML_Hdl_Format_Ident	    ( IMRT_Buffer * );
+    IMRT_Status MM_XML_StrHdl_Ident         ( IMRT_Msg_Id * , IMRT_Buffer * );
+    IMRT_Status	MM_XML_StrHdl_Open	    ( IMRT_Buffer * );
+    IMRT_Status	MM_XML_StrHdl_Close	    ( IMRT_Buffer * );
+    IMRT_Status	MM_XML_StrHdl_Flush	    ( IMRT_Buffer * );
+    IMRT_Status	MM_XML_StrHdl_Data_List     ( IMRT_Buffer * );
+    IMRT_Status	MM_XML_StrHdl_Copy	    ( IMRT_Buffer * , IMRT_Buffer * );
+    IMRT_Status	XML_Hdl_Field_Exist         ( IMRT_Field * , IMRT_Buffer * );
+    IMRT_Status	MM_XML_StrHdl_Get	    ( IMRT_Buffer_Data ** , IMRT_Field * , IMRT_Buffer * , size_t * );
+    IMRT_Status	MM_XML_StrHdl_Convert	    ( IMRT_Buffer_Data ** , IMRT_Buffer_Data * , IMRT_Field * , size_t *, IMRT_StrHdl_Cnv_Func * );
+    IMRT_Status	MM_XML_StrHdl_Put	    ( IMRT_Buffer_Data * , IMRT_Field * , IMRT_Buffer * , size_t );
+    IMRT_Status IMR_MM_XML_StrHdl_Field_Value   ( IMRT_Field * , IMRT_Field_Value_Id);
+    IMRT_Status IMR_MM_XML_StrHdl_Field_Exist   ( IMRT_Field * );
+    IMRT_Status IMR_MM_XML_StrHdl_Msg_Size      ( size_t );
+    IMRT_Status MM_XML_DInit_StructPath         (IMRT_PARSE_PATH_XML * );
+    IMRT_Status MM_XML_Proceed_Path             ( IMRT_PARSE_PATH_XML * , IMRT_Buffer_Data * , xmlDocPtr );
+    IMRT_Status MM_XML_Split_Path               ( IMRT_Buffer_Data * Chaine_Ptr , IMRT_PARSE_PATH_XML * PathXml_Ptr );
+    IMRT_Status MM_XML_SplitAttribute           ( IMRT_PARSE_PATH_XML * PathXml_Ptr );
+#else
+
+    extern IMRT_Status 	MM_XML_StrHdl_Init      ( void );
+    extern IMRT_Status 	MM_XML_StrHdl_DeInit    ( void );
+    extern IMRT_Status	MM_XML_StrHdl_Data_Free ( IMRT_Buffer * );
+    extern IMRT_Status  MM_XML_StrHdl_Ident     ( IMRT_Msg_Id * , IMRT_Buffer * );
+    extern IMRT_Status	MM_XML_StrHdl_Open 	( IMRT_Buffer * );
+    extern IMRT_Status	MM_XML_StrHdl_Close	( IMRT_Buffer * );
+    extern IMRT_Status	MM_XML_StrHdl_Flush	( IMRT_Buffer * );
+    extern IMRT_Status	MM_XML_StrHdl_Data_List ( IMRT_Buffer * );
+    extern IMRT_Status	MM_XML_StrHdl_Copy	( IMRT_Buffer * , IMRT_Buffer * );
+    extern IMRT_Status	MM_XML_StrHdl_Get	( IMRT_Buffer_Data ** , IMRT_Field * , IMRT_Buffer * , size_t * );
+    extern IMRT_Status	MM_XML_StrHdl_Convert   ( IMRT_Buffer_Data ** , IMRT_Buffer_Data * , IMRT_Field * , size_t *, IMRT_StrHdl_Cnv_Func * );
+    extern IMRT_Status	MM_XML_StrHdl_Put	( IMRT_Buffer_Data * , IMRT_Field * , IMRT_Buffer * , size_t );
+
+#endif
+
+/*----------------------------------------------------------------------------*/
+
+#endif                                   
+
diff --git a/src/libmapping_mng/src/libmapping_mng.c b/src/libmapping_mng/src/libmapping_mng.c
new file mode 100644
index 0000000..adc92fe
--- /dev/null
+++ b/src/libmapping_mng/src/libmapping_mng.c
@@ -0,0 +1,259 @@
+/*----------------------------------------------------------------------------*/
+/* $Workfile:   libmapping_mng.c  $                                           */
+/*----------------------------------------------------------------------------*/
+/* $Author: agibert $                                                      */
+/* $Date: 2008/11/12 02:25:23 $                                           */
+/* $Revision: 1.1 $                                                       */
+/* $Label:  $                                                         */
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#define _LIBMAPPING_MNG_
+#define _LIBMAPPING_MNG_C_
+
+#include "libmapping_mng.h"
+
+
+
+
+
+
+
+/******************************************************************************/
+/* Mapping Manager API                                                        */
+/******************************************************************************/
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Open Mapping Manager                                                       */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  IMR_MM_Library_Open( IMRT_MM_Config  *Config)
+{
+    IMRT_Status	status;
+
+	
+    if( IMRG_MM_Module.Lib.Status != IMRD_LIB_STATUS_CLOSED)
+    {
+	IMRD_LM_LOG_ERROR_0( "Library not closed !");
+	
+	return( IMRS_KO);
+    }
+    else
+    {
+	IMRG_MM_Base.Config.XML_Format = Config->XML_Format;
+
+        status  = IMRS_OK;
+        
+        status = MM_Schedul_Init( );
+        
+        if (status != IMRS_OK)
+        {
+	    IMRD_LM_LOG_ERROR_0("Error MM_Schedul_Init in IMR_MM_Library_Open");
+	}
+	else
+	{
+	    status =   MM_Buffer_Init( ) ;
+	}
+	    
+
+        if( status != IMRS_OK)
+	{
+	    IMRD_LM_LOG_ERROR_0( "Can't open library !");
+	}
+	else
+	{
+	    IMRG_MM_Module.Lib.Status = IMRD_LIB_STATUS_OPENED;
+	    IMRD_LM_LOG_TRACE_0( IMRD_LOG_LEVEL_VERBOSE_1, "Library opened !");
+	}
+                
+	return( status);
+    }
+}
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Close Mapping Manager                                                      */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  IMR_MM_Library_Close()
+{
+    IMRT_Status	status;
+        
+
+    if( IMRG_MM_Module.Lib.Status != IMRD_LIB_STATUS_OPENED)
+    {
+	IMRD_LM_LOG_ERROR_0( "Library not opened !");
+
+	return( IMRS_KO);
+    }
+    else
+    {
+        status  = IMRS_OK;
+        
+        status = MM_Schedul_DeInit( );
+        
+        if (status != IMRS_OK)
+        {
+	        IMRD_LM_LOG_ERROR_0("Error MM_Schedul_DeInit in IMR_MM_Library_Close");
+	}
+	else
+	{
+	        status =   MM_Buffer_DeInit( ) ;
+	}
+	        
+        if( status != IMRS_OK)
+	{
+	    IMRD_LM_LOG_ERROR_0( "Can't close library !");
+	}
+	else
+	{
+	    IMRG_MM_Module.Lib.Status = IMRD_LIB_STATUS_CLOSED;
+
+	    IMRD_LM_LOG_TRACE_0( IMRD_LOG_LEVEL_VERBOSE_1, "Library closed !");
+	}
+
+	return( status) ;
+    }
+}
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Buffer allocation	                                                      */
+/*----------------------------------------------------------------------------*/
+/* (O) Buffer_Ptr_Ptr :   Buffer pointer pointer		    	      */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status	IMR_MM_Buffer_Alloc( IMRT_Buffer **Buffer_Ptr_Ptr)
+{
+        IMRT_Status	status;
+        
+        status  = IMRS_OK;
+
+	status = MM_Buffer_Alloc( Buffer_Ptr_Ptr ) ;
+
+        if (status != IMRS_OK)
+        {
+	        IMRD_LM_LOG_ERROR_0("Error MM_Buffer_Alloc");
+	}
+	else
+	{
+                IMRD_LM_LOG_TRACE_0( IMRD_LOG_LEVEL_VERBOSE_1, "Allocated buffer success");
+        }
+
+	return (status) ;
+}
+
+
+/*----------------------------------------------------------------------------*/
+/* Buffer free			                                              */
+/*----------------------------------------------------------------------------*/
+/* (IO) Buffer_Ptr_Ptr :   Buffer pointer pointer		    	      */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status	IMR_MM_Buffer_Free( IMRT_Buffer **Buffer_Ptr_Ptr)
+{
+        IMRT_Status	status;
+        
+        status  = IMRS_OK;
+
+	status = MM_Buffer_Free( Buffer_Ptr_Ptr ) ;
+
+        if (status != IMRS_OK)
+        {
+	        IMRD_LM_LOG_ERROR_0("Error MM_Buffer_Free");
+	}
+	else
+	{
+                IMRD_LM_LOG_TRACE_0( IMRD_LOG_LEVEL_VERBOSE_1, "Freed buffer success");
+        }
+
+	return (status) ;
+	
+}
+
+
+/*----------------------------------------------------------------------------*/
+/* Buffer check			                                              */
+/*----------------------------------------------------------------------------*/
+/* (I) Buffer_Ptr :   Buffer pointer 					      */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status	IMR_MM_Buffer_Check (IMRT_Buffer *Buffer_Ptr)
+{
+
+        IMRT_Status	status;
+        
+        status  = IMRS_OK;
+
+	status = MM_Buffer_Check( Buffer_Ptr )  ;
+
+        if (status != IMRS_OK)
+        {
+	        IMRD_LM_LOG_ERROR_0("Error MM_Buffer_Check in IMR_MM_Buffer_Check");
+	}
+	else
+	{
+                IMRD_LM_LOG_TRACE_0( IMRD_LOG_LEVEL_VERBOSE_1, "Check buffer success");
+        }
+
+	return (status) ;
+
+}
+
+
+/*----------------------------------------------------------------------------*/
+/* Buffer list			                                              */
+/*----------------------------------------------------------------------------*/
+/* (I) Buffer_Ptr :   Buffer pointer 					      */
+/* (I) texte 	  :   Text to print		 		              */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status	IMR_MM_Buffer_List( IMRT_Buffer *Buffer_Ptr, char *texte)
+{
+	return( MM_Buffer_List( Buffer_Ptr, texte ) );
+}
+
+
+/*----------------------------------------------------------------------------*/
+/* Buffer mapping		                                              */
+/*----------------------------------------------------------------------------*/
+/* (I) Output_Buffer_Ptr :   Output buffer pointer 			      */
+/* (I) Input_Buffer_Ptr  :   Input buffer pointer		 	      */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status IMR_MM_Buffer_Map( IMRT_Buffer *Output_Buffer_Ptr,  IMRT_Buffer *Input_Buffer_Ptr)
+{
+	return ( MM_Schedul_Buffer_Map( Output_Buffer_Ptr, Input_Buffer_Ptr ) );
+}
+
+
diff --git a/src/libmapping_mng/src/libmapping_mng.h b/src/libmapping_mng/src/libmapping_mng.h
new file mode 100644
index 0000000..d3d23b1
--- /dev/null
+++ b/src/libmapping_mng/src/libmapping_mng.h
@@ -0,0 +1,142 @@
+/*----------------------------------------------------------------------------*/
+/* File: libmapping_mng.h 				      		      */
+/*----------------------------------------------------------------------------*/
+/*                                                                            */
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#ifndef _LIBMAPPING_MNG_H_
+#define _LIBMAPPING_MNG_H_
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Global Include                                                             */
+/*----------------------------------------------------------------------------*/
+
+#include <imr.h>
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Lib Definitions                                                            */
+/*----------------------------------------------------------------------------*/
+
+#define IMRD_MM_MODULE_ID                ( IMRT_Module_Id) 4
+#define IMRD_MM_MODULE_NAME            ( IMRT_Module_Name) "mm"
+#define IMRD_MM_MODULE_NAME_LONG  ( IMRT_Module_Name_Long) "Mapping Manager"
+#define IMRD_MM_MODULE_VERSION      ( IMRT_Module_Version) "@(#) VERSIONIMR: $Label:  $   $Date: 2008/11/12 02:25:23 $   $Workfile:   libmapping_mng.h  $"
+
+#define IMRD_MODULE_PTR                                    &IMRG_MM_Module
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Local definition                                                           */
+/*----------------------------------------------------------------------------*/
+
+#define IMRD_STATUS_NOTHING_TO_DO		(IMRT_Status) 4
+
+typedef IMRT_Status  (IMRT_MM_Cnv_Init)( void );
+typedef IMRT_Status  (IMRT_MM_Cnv_DeInit)( void );
+typedef IMRT_Status  (IMRT_MM_Convert)( IMRT_Buffer_Data * , IMRT_Buffer_Data * , size_t * , size_t , IMRT_Cnv_Attr ); 
+
+typedef struct IMRT_StrHdl_Cnv_Func
+	
+{   IMRT_Cnv_Name        	Nom;
+    IMRT_MM_Cnv_Init            *Init_Ptr;
+    IMRT_MM_Cnv_DeInit  	*DeInit_Ptr;
+    IMRT_MM_Convert   	        *Convert_Ptr;	    
+} IMRT_StrHdl_Cnv_Func;
+
+/* a virer apres les tests */      
+IMRT_StrHdl_Cnv_Func    *IMRG_MM_StrHdl_Cnv_Func_Tab;
+
+
+
+typedef struct IMRT_MM_Base
+{
+	IMRT_MM_Config  Config;
+}  IMRT_MM_Base;
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Prototypes                                                                 */
+/*----------------------------------------------------------------------------*/
+
+
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Global Variables                                                           */
+/*----------------------------------------------------------------------------*/
+
+#   ifdef _LIBMAPPING_MNG_C_
+
+IMRT_MM_Base  IMRG_MM_Base =
+{
+    { IMRD_FALSE}
+};
+
+
+
+IMRT_Module  IMRG_MM_Module = 
+{ 
+    IMRD_MM_MODULE_ID,
+    IMRD_MM_MODULE_NAME,
+    IMRD_MM_MODULE_NAME_LONG,
+    IMRD_MM_MODULE_VERSION,
+    IMRD_MODULE_TYPE_LIBRARY,
+    {
+	IMRD_LIB_STATUS_CLOSED,
+	( IMRT_Lib_Open    *) &IMR_MM_Library_Open,
+	( IMRT_Lib_Close   *) &IMR_MM_Library_Close
+    }
+};
+
+#   else
+
+extern IMRT_MM_Base  IMRG_MM_Base;
+extern IMRT_Module   IMRG_MM_Module;
+
+#   endif
+
+
+
+
+
+#endif
diff --git a/src/libmapping_mng/src/map_scheduler.c b/src/libmapping_mng/src/map_scheduler.c
new file mode 100644
index 0000000..1b11370
--- /dev/null
+++ b/src/libmapping_mng/src/map_scheduler.c
@@ -0,0 +1,484 @@
+/*----------------------------------------------------------------------------*/
+/* File: map_scheduler.c					   		         		  	      */
+/*----------------------------------------------------------------------------*/
+/*                                                                            */
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#define _LIBMAPPING_MNG_
+#define _MAP_SCHEDULER_C_
+
+#include "map_scheduler.h" 
+
+IMRT_Status MM_Schedul_Buffer_Map( IMRT_Buffer *Output_Buffer_Ptr, IMRT_Buffer *Input_Buffer_Ptr)
+{
+	IMRT_Status status;
+	short indice;
+	IMRT_Fmt_Id   format_temp;
+	char *func_name = "MM_Schedul_Buffer_Map";
+
+	status = IMRS_OK;
+	indice = 0;
+	format_temp = Input_Buffer_Ptr->Fmt_Id;
+	
+	/* controles sur les buffers */
+	status = Schedul_Buffers_Check(Input_Buffer_Ptr, Output_Buffer_Ptr);
+
+	/* fermeture des buffers */
+	if (status == IMRS_OK)
+	{
+		status = MM_Buffer_Close(Input_Buffer_Ptr);
+	}
+	if (status != IMRS_OK)
+	{
+		IMRD_LM_LOG_ERROR_0("Buffer input close failed");
+	}
+	else
+	{
+		status = MM_Buffer_Close(Output_Buffer_Ptr);
+	}
+
+	if (status != IMRS_OK)
+	{
+		IMRD_LM_LOG_ERROR_0("Buffer output close failed");
+	}
+	else
+	{
+		/* initialisation du tableau */
+		Buffer_Tab[0] = Input_Buffer_Ptr;
+		Buffer_Tab[1] = Output_Buffer_Ptr;
+		for (indice = 2; indice < IMRT_BUFFER_ID_MAX_NB; indice++)
+			Buffer_Tab[indice] = NULL;
+			
+		Input_Buffer_Ptr->Fmt_Id = IMRD_FMT_ID_UNKNOWN ;
+		status = MM_Buffer_Open( Input_Buffer_Ptr );
+
+		IMRD_LM_LOG_TRACE_0(IMRD_LOG_LEVEL_VERBOSE_2 , "Values before MapMath proceed begin :");
+		IMRD_LM_LOG_TRACE_3(IMRD_LOG_LEVEL_VERBOSE_2 , "Output Application : Id (%d) Fmt_Id (%d) Msg type Id (%d)" , Output_Buffer_Ptr->Appl_Id_Output , Output_Buffer_Ptr->Fmt_Id , Output_Buffer_Ptr->Msg_Id);
+		IMRD_LM_LOG_TRACE_3(IMRD_LOG_LEVEL_VERBOSE_2 , "Input Application : Id (%d) Fmt_Id (%d) Msg type Id (%d)" , Input_Buffer_Ptr->Appl_Id_Input , Input_Buffer_Ptr->Fmt_Id , Input_Buffer_Ptr->Msg_Id);
+	
+	
+		if (status != IMRS_OK)
+		{
+			IMRD_LM_LOG_ERROR_0("Buffer input open failed");
+			Input_Buffer_Ptr->Fmt_Id = format_temp;
+		}
+		else
+		{		
+			status = IMR_SDM_MapPath_Proceed( Input_Buffer_Ptr->Appl_Id_Output,
+                                          	Output_Buffer_Ptr->Fmt_Id,
+                                          	Output_Buffer_Ptr->Msg_Id,
+		                                Input_Buffer_Ptr->Appl_Id_Input,                                        	
+                                          	Input_Buffer_Ptr->Fmt_Id,
+                                          	Input_Buffer_Ptr->Msg_Id,
+                                          	IMR_MM_Schedul_Map,
+                                          	IMR_MM_Schedul_Copy,
+                                                IMR_MM_Schedul_Ident);
+			if (status != IMRS_OK)
+			{
+				IMRD_LM_LOG_ERROR_1("MapPath proceed ended with status (%d)", status);
+			}
+        }                         	
+	}
+
+	indice = 2;
+	while (indice < IMRT_BUFFER_ID_MAX_NB)
+	{
+		if (Buffer_Tab[indice] != NULL)
+		{
+			if (MM_Buffer_Free(&Buffer_Tab[indice]) != IMRS_OK)
+			{
+				status = IMRS_KO;
+			        IMRD_LM_LOG_ERROR_1("Buffer (%d) free failed" , indice);
+			}
+		}
+		indice++;
+	}
+	
+	if (MM_Buffer_Close(Input_Buffer_Ptr) != IMRS_OK)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Buffer input close failed");
+	}
+	if (MM_Buffer_Close(Output_Buffer_Ptr) != IMRS_OK)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0("Buffer output close failed");
+	}
+	
+	Buffer_Tab[0] = NULL;
+	Buffer_Tab[1] = NULL;
+
+	return ( status );
+}
+
+IMRT_Status	Schedul_Buffers_Check( IMRT_Buffer *Input_Buffer_Ptr, IMRT_Buffer *Output_Buffer_Ptr)
+{
+	IMRT_Status	status;
+	char *func_name = "Schedul_Buffers_Check";
+
+	
+	status = IMRS_OK;
+	
+	if (Input_Buffer_Ptr == NULL)
+	{
+		status = IMRS_KO;
+	        IMRD_LM_LOG_ERROR_0("Input buffer pointer NULL");		
+	}
+	else
+	if (Output_Buffer_Ptr == NULL)
+	{
+		status = IMRS_KO;
+	        IMRD_LM_LOG_ERROR_0("Output buffer pointer NULL");		
+	}
+	else
+	{
+		if (MM_Buffer_Check(Input_Buffer_Ptr)  != IMRS_OK)
+		{
+			status = IMRS_KO;
+			IMRD_LM_LOG_ERROR_0("Check buffer input failed");
+		}
+		if (MM_Buffer_Check(Output_Buffer_Ptr) != IMRS_OK)
+		{
+			status = IMRS_KO;
+			IMRD_LM_LOG_ERROR_0("Check buffer output failed");
+		}
+		if (Input_Buffer_Ptr->Appl_Id_Input == IMRD_APPL_ID_UNDEFINEDED)
+		{
+			status = IMRS_KO;
+			IMRD_LM_LOG_ERROR_0("Application input buffer equal to undefineded");
+		}
+		if (Input_Buffer_Ptr->Status != IMRD_BUFFER_STATUS_ALLOCATED)
+		{
+			status = IMRS_KO;
+			IMRD_LM_LOG_ERROR_0("Status input buffer equal to unknown");
+		}
+		if (Input_Buffer_Ptr->Data_Buf_Ptr == NULL)
+		{
+			status = IMRS_KO;
+			IMRD_LM_LOG_ERROR_0("Data_Buf_Ptr input buffer equal to NULL");
+		}
+	}
+
+	return ( status );
+}
+
+
+IMRT_Status IMR_MM_Schedul_Ident( IMRT_Fmt_Id *Format_Ptr,
+                                  IMRT_Msg_Id *Type,
+                                  IMRT_Buffer_Id Ident_Buffer_Indice,
+                                  IMRT_Boolean Ident_Total )
+{
+	IMRT_Status	status;
+	IMRT_Msg_Id     TypeTmp;
+	char *func_name = "IMR_MM_Schedul_Ident";
+
+	IMRD_LM_LOG_TRACE_0(IMRD_LOG_LEVEL_VERBOSE_1 ,  "============================================================================")
+	IMRD_LM_LOG_TRACE_0(IMRD_LOG_LEVEL_VERBOSE_1 , "Ident buffer demand : Begin");
+	IMRD_LM_LOG_TRACE_1(IMRD_LOG_LEVEL_VERBOSE_1 , "Ident buffer demand : Buffer       :  (%d)" , Ident_Buffer_Indice);	
+	IMRD_LM_LOG_TRACE_1(IMRD_LOG_LEVEL_VERBOSE_1 , "Ident buffer demand : Format Id    :  (%d)" , *Format_Ptr);	
+	IMRD_LM_LOG_TRACE_1(IMRD_LOG_LEVEL_VERBOSE_1 , "Ident buffer demand : Msg type     :  (%d)" , *Type);	
+	IMRD_LM_LOG_TRACE_1(IMRD_LOG_LEVEL_VERBOSE_1 , "Ident buffer demand : Total ident  :  (%d)" , Ident_Total);	
+	
+	status = IMRS_OK;
+	TypeTmp = IMRD_MSG_ID_UNKNOWN;
+
+	/* controle valeur de l'indice */
+	if ( ( Ident_Buffer_Indice < 0 ) || ( Ident_Buffer_Indice >= IMRT_BUFFER_ID_MAX_NB	) )
+	{
+		status = IMRS_KO;	
+		IMRD_LM_LOG_ERROR_1("Buffer (%d) out of bounds" , Ident_Buffer_Indice);
+	}
+	/* controle allocation d'un buffer pour l'indice */
+	else if ( Buffer_Tab[Ident_Buffer_Indice] == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_1("Buffer (%d) not allocated" , Ident_Buffer_Indice);
+	}
+	else
+	{
+	        TypeTmp = Buffer_Tab[Ident_Buffer_Indice]->Msg_Id;
+	        
+	        if (Ident_Total == IMRD_TRUE) // identification totale
+	        {
+		        status = MM_Buffer_Ident_Update(Buffer_Tab[Ident_Buffer_Indice],
+        		                                IMRD_FMT_ID_UNKNOWN,
+        		                                IMRD_FMTATTR_NAME_UNKNOWN,
+        		                                IMRD_MSG_ID_UNKNOWN);
+                }
+	}
+
+	if ( status != IMRS_OK )
+	{
+	        IMRD_LM_LOG_ERROR_0("MM_Buffer_Ident_Update failed");
+	}
+	else
+	{
+		status = MM_Buffer_Open ( Buffer_Tab[Ident_Buffer_Indice] );
+	}
+	
+	if ( status != IMRS_OK )
+	{
+	        IMRD_LM_LOG_ERROR_1("Buffer (%d) not open" , Ident_Buffer_Indice);
+	}
+	else
+ 	{
+		status = MM_Buffer_Ident ( *Type , Buffer_Tab[Ident_Buffer_Indice] );
+	}
+
+      	if (status != IMRS_OK)
+	{
+	        IMRD_LM_LOG_ERROR_0("MM_Buffer_Ident failed");
+	}
+	else
+       	{
+	        *Format_Ptr = Buffer_Tab[Ident_Buffer_Indice]->Fmt_Id;
+	        *Type = Buffer_Tab[Ident_Buffer_Indice]->Msg_Id;
+	}
+
+	
+       	if ((status != IMRS_OK) && (status != IMRS_KO))
+       	{
+		status = IMRS_OK; 
+	}
+
+	MM_Buffer_List( Buffer_Tab[Ident_Buffer_Indice], " CB Ident end");
+
+	IMRD_LM_LOG_TRACE_1(IMRD_LOG_LEVEL_VERBOSE_1 , "Ident buffer demand end : Format Id    :  (%d)" , *Format_Ptr);	
+	IMRD_LM_LOG_TRACE_1(IMRD_LOG_LEVEL_VERBOSE_1 , "Ident buffer demand end : Msg type     :  (%d)" , *Type);	
+	IMRD_LM_LOG_TRACE_1(IMRD_LOG_LEVEL_VERBOSE_1 , "Ident buffer demand : End with status :  (%d)" , status);
+	IMRD_LM_LOG_TRACE_0(IMRD_LOG_LEVEL_VERBOSE_1 , "============================================================================")
+
+	return ( status );
+}
+	
+IMRT_Status IMR_MM_Schedul_Copy( IMRT_Buffer_Id Output_Buffer_Indice, IMRT_Buffer_Id Input_Buffer_Indice)
+{
+	IMRT_Status	status;
+	IMRT_Buffer *buffer_ptr;
+	char *func_name = "IMR_MM_Schedul_Copy";
+
+
+	IMRD_LM_LOG_TRACE_0(IMRD_LOG_LEVEL_VERBOSE_1 ,  "============================================================================")
+	IMRD_LM_LOG_TRACE_0(IMRD_LOG_LEVEL_VERBOSE_1 , "Copy buffer demand : Begin");
+	IMRD_LM_LOG_TRACE_1(IMRD_LOG_LEVEL_VERBOSE_1 , "Copy buffer demand : Buffer Target  :  (%d)" , Output_Buffer_Indice);	
+	IMRD_LM_LOG_TRACE_1(IMRD_LOG_LEVEL_VERBOSE_1 , "Copy buffer demand : Buffer Source  :  (%d)" , Input_Buffer_Indice);	
+
+        
+	status = IMRS_OK;
+	buffer_ptr = NULL;
+	
+	/* controle la validite des indices */
+	if ( ( Input_Buffer_Indice  < 0 ) || ( Input_Buffer_Indice  >= IMRT_BUFFER_ID_MAX_NB ) ||
+	     ( Output_Buffer_Indice < 0 ) || ( Output_Buffer_Indice >= IMRT_BUFFER_ID_MAX_NB ) )
+	{
+	        IMRD_LM_LOG_ERROR_2("Buffer input with indice (%d) or output with indice (%d) out of bounds" , Input_Buffer_Indice , Output_Buffer_Indice);
+		status = IMRS_KO;	
+	}
+	else if ( Buffer_Tab[Input_Buffer_Indice] == NULL)
+	{
+		status = IMRS_KO;	
+	        IMRD_LM_LOG_ERROR_1("Buffer with indice (%d) not initialized" , Input_Buffer_Indice);
+	}
+	/* allocation du buffer destinataire si necessaire */
+	else if ( Buffer_Tab[Output_Buffer_Indice] == NULL) 
+	{
+		status = MM_Buffer_Alloc(&buffer_ptr);
+		if (status != IMRS_OK)
+		{
+		        IMRD_LM_LOG_ERROR_0("Error MM_Buffer_Alloc");
+		}
+		else
+		{
+			Buffer_Tab[Output_Buffer_Indice] = buffer_ptr;
+		}
+	}
+	MM_Buffer_List( Buffer_Tab[Input_Buffer_Indice], " Before Copy Buffer In");	
+	if (status == IMRS_OK)
+	{
+		status = MM_Buffer_Copy( Buffer_Tab[Output_Buffer_Indice], Buffer_Tab[Input_Buffer_Indice]);
+	}
+	MM_Buffer_List( Buffer_Tab[Output_Buffer_Indice], " After Copy Buffer Out");	
+
+	IMRD_LM_LOG_TRACE_1(IMRD_LOG_LEVEL_VERBOSE_1 , "Copy buffer demand : End with status :  (%d)" , status);
+	IMRD_LM_LOG_TRACE_0(IMRD_LOG_LEVEL_VERBOSE_1 , "============================================================================")
+
+	return ( status );
+}
+
+/*----------------------------------------------------------------------------*/
+/* Buffer Mapping CallBack                                                    */
+/*----------------------------------------------------------------------------*/
+/* (I) Buffer_Id_Target:   Target buffer id                                   */
+/* (I) Fmt_Target:         Target format                                      */
+/* (I) Buffer_Id_Src:      Source buffer id                                   */
+/* (I) Fmt_Src:            Source format                                      */
+/* (I) MsgMap:             Message Map to use                                 */
+/* (I) Clear_Flag:         Clear or not output buffer                         */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  IMR_MM_Schedul_Map( IMRT_Buffer_Id Buffer_Id_Target ,
+                                         IMRT_Fmt_Id Fmt_Target, 
+                                         IMRT_FmtAttr_Value Fmt_Target_Attr ,
+                                         IMRT_Buffer_Id Buffer_Id_Src , 
+                                         IMRT_Fmt_Id Fmt_Src , 
+                                         IMRT_FmtAttr_Value Fmt_Src_Attr ,
+                                         IMRT_MsgMap *MsgMap_ptr , 
+                                         IMRT_MapCmd_Flag Clear_Flag)
+
+{
+	IMRT_Buffer *input_buffer_ptr,
+	            *output_buffer_ptr;
+	IMRT_Status	status;
+	char *func_name = "IMR_MM_Schedul_Map";
+
+	
+	status  = IMRS_OK;
+	input_buffer_ptr = NULL;
+	output_buffer_ptr = NULL;
+
+
+	/* controle buffers */
+	if ( ( Buffer_Id_Src  < 0 ) || ( Buffer_Id_Src  >= IMRT_BUFFER_ID_MAX_NB ) ||
+	     ( Buffer_Id_Target < 0 ) || ( Buffer_Id_Target >= IMRT_BUFFER_ID_MAX_NB ) )	
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_2("Indices buffer input (%d) or output (%d) out of bounds" , Buffer_Id_Src,Buffer_Id_Target);
+	}
+	else if ( Buffer_Tab[Buffer_Id_Src] == NULL)
+	{
+		status = IMRS_KO;	
+		IMRD_LM_LOG_ERROR_1("Buffer with indice (%d) not allocated ",Buffer_Id_Src);
+	}
+	else if (Fmt_Src_Attr == NULL)
+	{
+		status = IMRS_KO;	
+		IMRD_LM_LOG_ERROR_0("Source format attribute NULL");
+	}
+	else if (Fmt_Target_Attr == NULL)
+	{
+		status = IMRS_KO;	
+		IMRD_LM_LOG_ERROR_0("Target format attribute NULL");
+	}
+	else if (MsgMap_ptr == NULL)
+	{
+		status = IMRS_KO;	
+		IMRD_LM_LOG_ERROR_0("Message map pointer NULL");
+	}
+	else if (MsgMap_ptr->Msg_Input_Ptr == NULL)
+	{
+		status = IMRS_KO;	
+		IMRD_LM_LOG_ERROR_0("Message input pointer NULL");
+	}
+	else if (MsgMap_ptr->Msg_Output_Ptr == NULL)
+	{
+		status = IMRS_KO;	
+		IMRD_LM_LOG_ERROR_0("Message output pointer NULL");
+	}
+	
+	if ( status == IMRS_OK )
+	{
+		IMRD_LM_LOG_TRACE_0(IMRD_LOG_LEVEL_VERBOSE_1 , "============================================================================")
+		IMRD_LM_LOG_TRACE_0(IMRD_LOG_LEVEL_VERBOSE_1 , "Mapping buffer demand : Begin");
+		IMRD_LM_LOG_TRACE_1(IMRD_LOG_LEVEL_VERBOSE_1 , "Mapping buffer demand : MsgMap :  (%s)" , (char *) MsgMap_ptr->Name);	
+		IMRD_LM_LOG_TRACE_2(IMRD_LOG_LEVEL_VERBOSE_1 , "Mapping buffer demand : indices Buffers : Src (%d) : Tgt (%d)" , Buffer_Id_Src , Buffer_Id_Target);
+		IMRD_LM_LOG_TRACE_2(IMRD_LOG_LEVEL_VERBOSE_1 , "Mapping buffer demand : formats         : Src (%d) : Tgt (%d)" , Fmt_Src , Fmt_Target);
+		IMRD_LM_LOG_TRACE_2(IMRD_LOG_LEVEL_VERBOSE_1 , "Mapping buffer demand : Attributs       : Src (%s) : Tgt (%s)" , Fmt_Src_Attr , Fmt_Target_Attr);
+		IMRD_LM_LOG_TRACE_2(IMRD_LOG_LEVEL_VERBOSE_1 , "Mapping buffer demand : Types de msg    : Src (%s) : Tgt (%s)" , (char *) MsgMap_ptr->Msg_Input_Ptr->Name , (char *) MsgMap_ptr->Msg_Output_Ptr->Name);
+		IMRD_LM_LOG_TRACE_1(IMRD_LOG_LEVEL_VERBOSE_1 , "Mapping buffer demand : Flag buffer clear :  (%d)" , Clear_Flag);
+		
+		input_buffer_ptr = Buffer_Tab[Buffer_Id_Src];
+		if ( Buffer_Tab[Buffer_Id_Target] == NULL)
+		{
+			status = MM_Buffer_Alloc(&output_buffer_ptr);		
+			if ( status != IMRS_OK )
+			{
+			        IMRD_LM_LOG_ERROR_1("MM_Buffer_Alloc failed for buffer output (%d)",Buffer_Id_Target);
+			}
+			else
+			{
+				Buffer_Tab[Buffer_Id_Target] = output_buffer_ptr;
+			}
+			
+		}
+		else if ( Clear_Flag == IMRD_TRUE )
+		{
+			output_buffer_ptr = Buffer_Tab[Buffer_Id_Target];
+			status = MM_Buffer_Clear(output_buffer_ptr);		
+		}
+		else
+		{
+		        output_buffer_ptr = Buffer_Tab[Buffer_Id_Target];
+		}
+	}
+	/* mise a jour des formats et types des buffers */
+	if ( status == IMRS_OK )
+	{
+		status = MM_Buffer_Ident_Update(input_buffer_ptr,
+		                                Fmt_Src,
+		                                Fmt_Src_Attr,
+		                                MsgMap_ptr->Msg_Input_Ptr->Id);
+	}
+	if ( status == IMRS_OK )
+	{
+		status =MM_Buffer_Ident_Update( output_buffer_ptr,
+		                                Fmt_Target,
+		                                Fmt_Target_Attr,
+		                                MsgMap_ptr->Msg_Output_Ptr->Id);
+	}
+	/* ouverture des buffers */
+	if ( status == IMRS_OK )
+	{
+		status = MM_Buffer_Open( input_buffer_ptr);
+	}
+	if ( status == IMRS_OK )
+	{
+		MM_Buffer_Open( output_buffer_ptr);
+	}
+	
+	MM_Buffer_List( input_buffer_ptr, " Input Buffer Before Mapping");	
+	
+	if ( status == IMRS_OK )
+	{
+		status = MM_Buffer_Map( output_buffer_ptr, input_buffer_ptr, MsgMap_ptr);
+	}                          
+	
+	MM_Buffer_List( output_buffer_ptr, " Output Buffer after Mapping");	
+	
+	IMRD_LM_LOG_TRACE_1(IMRD_LOG_LEVEL_VERBOSE_1 , "Mapping buffer demand : End with status :  (%d)" , status);
+	IMRD_LM_LOG_TRACE_0(IMRD_LOG_LEVEL_VERBOSE_1 ,  "============================================================================")
+	
+	return ( status );
+}
+
+IMRT_Status MM_Schedul_Init()
+{
+      return (IMRS_OK);  
+}
+
+IMRT_Status MM_Schedul_DeInit()
+{
+      return (IMRS_OK);  
+}
diff --git a/src/libmapping_mng/src/map_scheduler.h b/src/libmapping_mng/src/map_scheduler.h
new file mode 100644
index 0000000..fa502e7
--- /dev/null
+++ b/src/libmapping_mng/src/map_scheduler.h
@@ -0,0 +1,88 @@
+/*----------------------------------------------------------------------------*/
+/* File: map_scheduler.h					 	      */
+/*----------------------------------------------------------------------------*/
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#ifndef _MAP_SCHEDULER_H_
+#define _MAP_SCHEDULER_H_
+
+/*----------------------------------------------------------------------------*/
+/* Global Include                                                             */
+/*----------------------------------------------------------------------------*/
+
+#include "libmapping_mng.h"
+
+/*----------------------------------------------------------------------------*/
+/*	Global Variables						      */
+/*----------------------------------------------------------------------------*/
+
+#ifdef _MAP_SCHEDULER_C_
+
+	IMRT_Buffer *Buffer_Tab[IMRT_BUFFER_ID_MAX_NB];
+
+#endif
+
+/*----------------------------------------------------------------------------*/
+/*	Prototypes							      */
+/*----------------------------------------------------------------------------*/
+#ifdef _MAP_SCHEDULER_C_
+
+        IMRT_Status MM_Schedul_Init             ( void );
+        IMRT_Status MM_Schedul_DeInit           ( void );
+        IMRT_Status MM_Schedul_Buffer_Map	( IMRT_Buffer * , IMRT_Buffer * );
+	IMRT_Status Schedul_Buffers_Check	( IMRT_Buffer * , IMRT_Buffer * );
+	IMRT_Status IMR_MM_Schedul_Ident	( IMRT_Fmt_Id * , IMRT_Msg_Id *, IMRT_Buffer_Id , IMRT_Boolean );
+	IMRT_Status IMR_MM_Schedul_Copy		( IMRT_Buffer_Id , IMRT_Buffer_Id );
+
+/*----------------------------------------------------------------------------*/
+/* Buffer Mapping CallBack                                                    */
+/*----------------------------------------------------------------------------*/
+/* (I) Buffer_Id_Target:   Target buffer id                                   */
+/* (I) Fmt_Target:         Target format                                      */
+/* (I) Fmt_Attr_Target:    Target format attribute                            */
+/* (I) Buffer_Id_Src:      Source buffer id                                   */
+/* (I) Fmt_Src:            Source format                                      */
+/* (I) Fmt_Attr_Src:       Source format attribute                            */
+/* (I) MsgMap:             Message Map to use                                 */
+/* (I) Clear_Flag:         Clear or donn't clear output buffer                */
+/*----------------------------------------------------------------------------*/
+        IMRT_Status  IMR_MM_Schedul_Map( IMRT_Buffer_Id, IMRT_Fmt_Id, IMRT_FmtAttr_Value, IMRT_Buffer_Id, IMRT_Fmt_Id, IMRT_FmtAttr_Value, IMRT_MsgMap  *, IMRT_MapCmd_Flag);
+
+/*----------------------------------------------------------------------------*/
+
+
+#else
+
+        extern IMRT_Status MM_Schedul_Init              ( void );
+        extern IMRT_Status MM_Schedul_DeInit            ( void );
+	extern IMRT_Status MM_Schedul_Buffer_Map	( IMRT_Buffer * , IMRT_Buffer * );
+																 
+#endif
+
+
+/*----------------------------------------------------------------------------*/
+
+#endif                                   
diff --git a/src/libmsg_router/include/msg_router.h b/src/libmsg_router/include/msg_router.h
new file mode 100644
index 0000000..505f53f
--- /dev/null
+++ b/src/libmsg_router/include/msg_router.h
@@ -0,0 +1,132 @@
+/*----------------------------------------------------------------------------*/
+/* File: msg_router.h 				         		      */
+/*----------------------------------------------------------------------------*/
+/*                                                                            */
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#ifndef _MSG_ROUTER_H_
+#define _MSG_ROUTER_H_
+
+
+
+#include <imr.h>
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IMRD_MR_API definition                                                     */
+/*----------------------------------------------------------------------------*/
+
+#   ifdef _LIBMSG_ROUTER_
+#       define IMRD_MR_API  
+#   else
+#       define IMRD_MR_API  extern
+#   endif
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* MR_Config definition                                                       */
+/*----------------------------------------------------------------------------*/
+
+typedef struct IMRT_MR_Config
+{
+	IMRT_Boolean        Mapping_Forced;
+	IMRT_Boolean        Continue_Forced;
+	IMRT_Read_Mode      Read_Mode;
+	IMRT_Log_Id_Struct  Log_Id_Struct_Input;
+	IMRT_Log_Id_Struct  Log_Id_Struct_Output;
+}  IMRT_MR_Config;
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Global Variables                                                           */
+/*----------------------------------------------------------------------------*/
+
+#   ifdef _LIBMSG_ROUTER_
+
+#   else
+
+extern IMRT_Module  IMRG_MR_Module;
+
+#   endif
+
+
+
+
+
+
+
+/******************************************************************************/
+/* Msg Router API                                                             */
+/******************************************************************************/
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Open Msg Router                                                            */
+/*----------------------------------------------------------------------------*/
+/* Lib_Flag:   Setup MR init mode                                             */
+/*----------------------------------------------------------------------------*/
+
+IMRD_MR_API IMRT_Status  IMR_MR_Library_Open( IMRT_MR_Config  *);
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Close Msg Router                                                           */
+/*----------------------------------------------------------------------------*/
+
+IMRD_MR_API IMRT_Status  IMR_MR_Library_Close( void);
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Proceed Message Routing                                                    */
+/*----------------------------------------------------------------------------*/
+/* Medium_URL_Output:   Output medium URL                                     */
+/* Appl_Id_Output:      Output application Id                                 */
+/* Medium_URL_Input:    Trash Medium URL                                      */
+/* Medium_URL_Input:    Input Medium URL                                      */
+/* Appl_Id_Input:       Input Application Id                                  */
+/*----------------------------------------------------------------------------*/
+
+IMRD_MR_API IMRT_Status  IMR_MR_Proceed( IMRT_Medium_URL, IMRT_Appl_Id, IMRT_Medium_URL, IMRT_Medium_URL, IMRT_Appl_Id);
+
+
+
+/*----------------------------------------------------------------------------*/
+
+#endif
diff --git a/src/libmsg_router/src/Makefile b/src/libmsg_router/src/Makefile
new file mode 100644
index 0000000..4235e6d
--- /dev/null
+++ b/src/libmsg_router/src/Makefile
@@ -0,0 +1,65 @@
+#------------------------------------------------------------------------------
+# Local Makefile
+#------------------------------------------------------------------------------
+# $Workfile:   Makefile  $                                                     
+#------------------------------------------------------------------------------
+# $Author: agibert $                                                        
+# $Date: 2008/11/12 02:25:23 $                                             
+# $Revision: 1.1 $                                                         
+# $Label:  $                                                           
+#------------------------------------------------------------------------------
+
+#------------------------------------------------------------------------------
+# IMR - Interlinking Message Router                                            
+# Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)                
+# mailto:arnaud@rx3.net                                                        
+# http://www.rx3.org/dvp/?dvp=imr                                              
+#------------------------------------------------------------------------------
+# This file is part of IMR                                                     
+#                                                                              
+# This program is free software; you can redistribute it and/or                
+# modify it under the terms of the GNU General Public License                  
+# as published by the Free Software Foundation; either version 2               
+# of the License, or (at your option) any later version.                       
+#                                                                              
+# This program is distributed in the hope that it will be useful,              
+# but WITHOUT ANY WARRANTY; without even the implied warranty of               
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                
+# GNU General Public License for more details.                                 
+#                                                                              
+# You should have received a copy of the GNU General Public License            
+# along with this program; if not, write to the Free Software Foundation,      
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.          
+#------------------------------------------------------------------------------
+
+
+
+
+
+#------------------------------------------------------------------------------
+# Var include
+#------------------------------------------------------------------------------
+
+include ../../Makefile_var.mk
+
+
+
+#------------------------------------------------------------------------------
+# Variables
+#------------------------------------------------------------------------------
+
+TARGET=		libmsg_router$(SHLIB_SUFFIX)
+
+OBJ=		libmsg_router.o
+
+EXTRA_INC=	
+
+EXTRA_LIB=	
+
+
+
+#------------------------------------------------------------------------------
+# Rule include
+#------------------------------------------------------------------------------
+
+include ../../Makefile_rule.mk
diff --git a/src/libmsg_router/src/libmsg_router.c b/src/libmsg_router/src/libmsg_router.c
new file mode 100644
index 0000000..0f3185b
--- /dev/null
+++ b/src/libmsg_router/src/libmsg_router.c
@@ -0,0 +1,544 @@
+/*----------------------------------------------------------------------------*/
+/* $Workfile:   libmsg_router.c  $                                            */                                            
+/*----------------------------------------------------------------------------*/
+/* $Author: agibert $                                                      */
+/* $Date: 2008/11/12 02:25:23 $                                           */
+/* $Revision: 1.1 $                                                       */
+/* $Label:  $                                                         */
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#define _LIBMSG_ROUTER_
+#define _LIBMSG_ROUTER_C_
+
+#include "libmsg_router.h"
+
+
+
+
+
+
+
+/******************************************************************************/
+/* Msg Router API                                                             */
+/******************************************************************************/
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Open Msg Router                                                            */
+/*----------------------------------------------------------------------------*/
+/* Lib_Flag:   Setup MR init mode                                             */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  IMR_MR_Library_Open( IMRT_MR_Config  *Config_Ptr)
+{
+    int  idx;
+
+
+    if( IMRG_MR_Module.Lib.Status != IMRD_LIB_STATUS_CLOSED)
+    {
+	IMRD_LM_LOG_ERROR_0( "Library not closed !");
+
+	return( IMRS_KO);
+    }
+    else
+    {
+	IMRG_MR_Base.Config.Mapping_Forced  = Config_Ptr->Mapping_Forced;
+	IMRG_MR_Base.Config.Continue_Forced = Config_Ptr->Continue_Forced;
+	IMRG_MR_Base.Config.Read_Mode       = Config_Ptr->Read_Mode;
+
+	if( Config_Ptr->Log_Id_Struct_Input.Bit_Nb != 0)
+        {
+	    IMRG_MR_Base.Config.Log_Id_Struct_Input.Bit_Nb   = Config_Ptr->Log_Id_Struct_Input.Bit_Nb;
+	    IMRG_MR_Base.Config.Log_Id_Struct_Input.Log_Size = Config_Ptr->Log_Id_Struct_Input.Log_Size;
+
+	    if( ( IMRG_MR_Base.Config.Log_Id_Struct_Input.Log_Id_Bit_Ptr =
+		  malloc( IMRG_MR_Base.Config.Log_Id_Struct_Input.Bit_Nb * sizeof( IMRT_Log_Id_Bit))) == NULL)
+	    {
+		IMRD_LM_LOG_ERROR_1( "Can't allocate Input Log_Id_Bit_Ptr (%d) !", errno);
+
+		return( IMRS_OK);
+	    }
+
+	    for( idx = 0; idx < IMRG_MR_Base.Config.Log_Id_Struct_Input.Bit_Nb; idx++)
+	    {
+		IMRG_MR_Base.Config.Log_Id_Struct_Input.Log_Id_Bit_Ptr[idx].Offset = Config_Ptr->Log_Id_Struct_Input.Log_Id_Bit_Ptr[idx].Offset;
+		IMRG_MR_Base.Config.Log_Id_Struct_Input.Log_Id_Bit_Ptr[idx].Size   = Config_Ptr->Log_Id_Struct_Input.Log_Id_Bit_Ptr[idx].Size;
+	    }
+        }
+
+	if( Config_Ptr->Log_Id_Struct_Output.Bit_Nb != 0)
+        {
+	    IMRG_MR_Base.Config.Log_Id_Struct_Output.Bit_Nb   = Config_Ptr->Log_Id_Struct_Output.Bit_Nb;
+	    IMRG_MR_Base.Config.Log_Id_Struct_Output.Log_Size = Config_Ptr->Log_Id_Struct_Output.Log_Size;
+
+	    if( ( IMRG_MR_Base.Config.Log_Id_Struct_Output.Log_Id_Bit_Ptr =
+		  malloc( IMRG_MR_Base.Config.Log_Id_Struct_Output.Bit_Nb * sizeof( IMRT_Log_Id_Bit))) == NULL)
+	    {
+		IMRD_LM_LOG_ERROR_1( "Can't allocate Output Log_Id_Bit_Ptr (%d) !", errno);
+
+		return( IMRS_OK);
+	    }
+
+	    for( idx = 0; idx < IMRG_MR_Base.Config.Log_Id_Struct_Output.Bit_Nb; idx++)
+	    {
+		IMRG_MR_Base.Config.Log_Id_Struct_Output.Log_Id_Bit_Ptr[idx].Offset = Config_Ptr->Log_Id_Struct_Output.Log_Id_Bit_Ptr[idx].Offset;
+		IMRG_MR_Base.Config.Log_Id_Struct_Output.Log_Id_Bit_Ptr[idx].Size   = Config_Ptr->Log_Id_Struct_Output.Log_Id_Bit_Ptr[idx].Size;
+	    }
+        }
+          
+	IMRG_MR_Module.Lib.Status = IMRD_LIB_STATUS_OPENED;
+
+	IMRD_LM_LOG_TRACE_0( IMRD_LOG_LEVEL_VERBOSE_1, "Library opened !");
+
+	return( IMRS_OK);
+    }
+}
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Close Msg Router                                                           */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  IMR_MR_Library_Close()
+{
+    if( IMRG_MR_Module.Lib.Status != IMRD_LIB_STATUS_OPENED)
+    {
+	IMRD_LM_LOG_ERROR_0( "Library not opened !");
+
+	return( IMRS_KO);
+    }
+    else
+    {
+	if( IMRG_MR_Base.Config.Log_Id_Struct_Input.Bit_Nb != 0)
+        {
+	    free( IMRG_MR_Base.Config.Log_Id_Struct_Input.Log_Id_Bit_Ptr);
+        }
+	
+	if( IMRG_MR_Base.Config.Log_Id_Struct_Output.Bit_Nb != 0)
+        {
+	    free( IMRG_MR_Base.Config.Log_Id_Struct_Output.Log_Id_Bit_Ptr);
+        }
+	
+	IMRG_MR_Module.Lib.Status = IMRD_LIB_STATUS_CLOSED;
+	IMRD_LM_LOG_TRACE_0( IMRD_LOG_LEVEL_VERBOSE_1, "Library closed !");
+
+	return( IMRS_OK);
+    }
+}
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Close all allocated resources                                              */
+/*----------------------------------------------------------------------------*/
+/* Buffer_Input_Ptr:    Input buffer                                          */
+/* Buffer_Output_Ptr:   Output buffer                                         */
+/* Medium_Input_Ptr:    Input Medium                                          */
+/* Medium_Output_Ptr:   Output Medium                                         */
+/* Medium_Trash_Ptr:    Output Medium                                         */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  Close_All( IMRT_Buffer  *Buffer_Input_Ptr, IMRT_Buffer  *Buffer_Output_Ptr,
+			IMRT_Medium  *Medium_Input_Ptr, IMRT_Medium  *Medium_Output_Ptr, IMRT_Medium  *Medium_Trash_Ptr)
+{
+    IMRT_Status  status;
+
+
+    if( Buffer_Output_Ptr != NULL)
+    {
+	IMRD_LM_LOG_TRACE_0( IMRD_LOG_LEVEL_VERBOSE_0, "Freeing output buffer...");
+	
+	if( ( status = IMR_MM_Buffer_Free( &Buffer_Output_Ptr)) != IMRS_OK)
+	{
+	    IMRD_LM_LOG_ERROR_1( "Can't free output buffer (%d) !", status);
+	}
+    }
+    
+    if( Buffer_Input_Ptr != NULL)
+    {
+	IMRD_LM_LOG_TRACE_0( IMRD_LOG_LEVEL_VERBOSE_0, "Freeing input buffer...");
+	
+	if( ( status = IMR_MM_Buffer_Free( &Buffer_Input_Ptr)) != IMRS_OK)
+	{
+	    IMRD_LM_LOG_ERROR_1( "Can't free input buffer (%d) !", status);
+	}
+    }
+    
+    if( Medium_Trash_Ptr != NULL)
+    {
+	IMRD_LM_LOG_TRACE_0( IMRD_LOG_LEVEL_VERBOSE_0, "Closing trash medium...");
+	
+	if( ( status = IMR_IOM_Medium_Close( Medium_Trash_Ptr)) != IMRS_OK)
+	{
+	    IMRD_LM_LOG_ERROR_1( "Can't close trash medium (%d) !", status);
+	}
+    }
+
+    if( Medium_Output_Ptr != NULL)
+    {
+	IMRD_LM_LOG_TRACE_0( IMRD_LOG_LEVEL_VERBOSE_0, "Closing output medium...");
+	
+	if( ( status = IMR_IOM_Medium_Close( Medium_Output_Ptr)) != IMRS_OK)
+	{
+	    IMRD_LM_LOG_ERROR_1( "Can't close output medium (%d) !", status);
+	}
+    }
+    
+    if( Medium_Input_Ptr != NULL)
+    {
+	IMRD_LM_LOG_TRACE_0( IMRD_LOG_LEVEL_VERBOSE_0, "Closing input medium...");
+	
+	if( ( status = IMR_IOM_Medium_Close( Medium_Input_Ptr)) != IMRS_OK)
+	{
+	    IMRD_LM_LOG_ERROR_1( "Can't close input medium (%d) !", status);
+	}
+    }
+
+    return( IMRS_OK);
+}
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Proceed Message Routing                                                    */
+/*----------------------------------------------------------------------------*/
+/* Medium_URL_Output:   Output medium URL                                     */
+/* Appl_Id_Output:      Output application Id                                 */
+/* Medium_URL_Input:    Input Medium URL                                      */
+/* Appl_Id_Input:       Input Application Id                                  */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  IMR_MR_Proceed( IMRT_Medium_URL  Medium_URL_Output, IMRT_Appl_Id  Appl_Id_Output,
+			     IMRT_Medium_URL  Medium_URL_Trash,
+                             IMRT_Medium_URL  Medium_URL_Input,  IMRT_Appl_Id  Appl_Id_Input)
+{
+    IMRT_Status    status, return_status = IMRS_OK;
+    IMRT_Boolean   data             = IMRD_TRUE;
+    IMRT_Appl_Id   appl_id_raw;
+    IMRT_Buffer   *buffer_input_ptr = NULL,        *buffer_output_ptr = NULL;
+    IMRT_Medium   *medium_input_ptr = NULL,        *medium_output_ptr = NULL,   *medium_trash_ptr = NULL;
+    IMRT_Tran     *tran_ptr         = NULL;
+
+
+    if( sigsetjmp( IMRG_Base.SigLongJmp_Env, 1) != 0 )
+    {
+	IMRD_LM_LOG_TRACE_1( IMRD_LOG_LEVEL_VERBOSE_0, "Exiting on signal (%d)...", IMRG_Base.Sig_Trapped);
+
+	Close_All( buffer_input_ptr, buffer_output_ptr, medium_input_ptr, medium_output_ptr, medium_trash_ptr);
+
+	return( IMRS_OK);
+    }
+
+    if( IMR_SDM_Appl_Id_Get( &appl_id_raw, "raw") != IMRS_OK)
+    {
+	IMRD_LM_LOG_ERROR_1( "Can't get Appl_Id from [%s] !", "raw");
+
+	return( IMRS_KO);
+    }
+
+    IMRD_LM_LOG_TRACE_0( IMRD_LOG_LEVEL_VERBOSE_0, "Opening input medium...");
+
+    if( ( status = IMR_IOM_Medium_Open( &medium_input_ptr, "Input", Medium_URL_Input, Appl_Id_Input, Appl_Id_Output, IMRD_DIR_ID_IN)) != IMRS_OK)
+    {
+	IMRD_LM_LOG_ERROR_1( "Can't open input medium (%d) !", status);
+
+	return_status = IMRS_KO;
+    }
+    else
+    {
+	IMRD_LM_LOG_TRACE_0( IMRD_LOG_LEVEL_VERBOSE_0, "Opening output medium...");
+
+	if( ( status = IMR_IOM_Medium_Open( &medium_output_ptr, "Output", Medium_URL_Output, Appl_Id_Input, Appl_Id_Output, IMRD_DIR_ID_OUT)) != IMRS_OK)
+	{
+	    IMRD_LM_LOG_ERROR_1( "Can't open output medium (%d) !", status);
+
+	    return_status = IMRS_KO;
+	}
+	else
+	{
+	    if( IMRG_MR_Base.Config.Continue_Forced == IMRD_TRUE)
+	    {
+		IMRD_LM_LOG_TRACE_0( IMRD_LOG_LEVEL_VERBOSE_0, "Opening trash medium...");
+
+		if( ( status = IMR_IOM_Medium_Open( &medium_trash_ptr, "Trash", Medium_URL_Trash, appl_id_raw, appl_id_raw, IMRD_DIR_ID_OUT)) != IMRS_OK)
+		{
+		    IMRD_LM_LOG_ERROR_1( "Can't open trash medium (%d) !", status);
+		    
+		    return_status = IMRS_KO;
+		}
+	    }
+
+	    if( return_status == IMRS_OK)
+	    {
+		do
+		{
+		    IMRD_LM_LOG_TRACE_0( IMRD_LOG_LEVEL_VERBOSE_0, "Allocating input buffer...");
+		    
+		    if( ( status = IMR_MM_Buffer_Alloc( &buffer_input_ptr)) != IMRS_OK)
+		    {
+			IMRD_LM_LOG_ERROR_1( "Can't allocate input buffer (%d) !", status);
+			
+			return_status = IMRS_KO;
+		    }
+		    else
+		    {
+			IMRD_LM_LOG_TRACE_0( IMRD_LOG_LEVEL_VERBOSE_0, "Begining transaction...");
+			
+			if( ( status = IMR_IOM_Tran_Begin( &tran_ptr, 2, medium_output_ptr, medium_input_ptr)) == IMRS_KO)
+			{
+			    IMRD_LM_LOG_ERROR_1( "Can't begin transaction (%d) !", status);
+			    
+			    return_status = IMRS_KO;
+			}
+			else
+			{
+			    IMRD_LM_LOG_TRACE_0( IMRD_LOG_LEVEL_VERBOSE_0, "Reading input medium...");
+			    
+			    if( ( status = IMR_IOM_Medium_Read( buffer_input_ptr, medium_input_ptr, IMRG_MR_Base.Config.Read_Mode)) == IMRS_KO)
+			    {
+				IMRD_LM_LOG_ERROR_1( "Can't read input buffer (%d) !", status);
+				
+				return_status = IMRS_KO;
+			    }
+			    else
+			    {
+				if( status == IMRS_NO_DATA)
+				{
+
+				    
+				    
+				    IMRD_LM_LOG_TRACE_0( IMRD_LOG_LEVEL_VERBOSE_0, "No more data to read...");
+				    
+				    IMRD_LM_LOG_TRACE_0( IMRD_LOG_LEVEL_VERBOSE_0, "Rollbaking transaction...");
+						
+				    if( ( status = IMR_IOM_Tran_Rollback( tran_ptr)) == IMRS_KO)
+				    {
+					IMRD_LM_LOG_ERROR_1( "Can't rollback transaction (%d) !", status);
+					
+					return_status = IMRS_KO;
+				    }
+				    else
+				    {
+					return_status = IMRS_NO_DATA;
+				    }
+				}
+				else
+				{
+				    if( status == IMRS_SIGNAL)
+				    {
+					IMRD_LM_LOG_TRACE_0( IMRD_LOG_LEVEL_VERBOSE_0, "Read interupted by a signal !");
+				    
+					return_status = status;
+				    }
+				    else
+				    {
+					IMR_MM_Buffer_List( buffer_input_ptr, "Input Buffer");
+				    
+					IMRD_LM_LOG_TRACE_0( IMRD_LOG_LEVEL_VERBOSE_0, "Allocating output buffer...");
+				    
+					if( ( status = IMR_MM_Buffer_Alloc( &buffer_output_ptr)) != IMRS_OK)
+					{
+					    IMRD_LM_LOG_ERROR_1( "Can't allocate output buffer (%d) !", status);
+					    
+					    return_status = IMRS_KO;
+					}
+					else
+					{
+					    IMRD_LM_LOG_TRACE_0( IMRD_LOG_LEVEL_VERBOSE_0, "Maping input buffer to output buffer...");
+					    
+					    if( ( status = IMR_MM_Buffer_Map( buffer_output_ptr, buffer_input_ptr)) != IMRS_OK)
+					    {
+						IMRD_LM_LOG_ERROR_1( "Can't map buffers (%d) !", status);
+						
+						if( IMRG_MR_Base.Config.Mapping_Forced == IMRD_TRUE)
+						{
+						    data = IMRD_TRUE;
+						}
+						else
+						{
+						    data = IMRD_FALSE;
+						}
+						
+						if( IMRG_MR_Base.Config.Continue_Forced == IMRD_TRUE)
+						{
+						    IMRD_LM_LOG_TRACE_0( IMRD_LOG_LEVEL_VERBOSE_0, "Writing trash medium...");
+						    
+						    if( ( status = IMR_IOM_Medium_Write( medium_trash_ptr, buffer_input_ptr)) != IMRS_OK)
+						    {
+							IMRD_LM_LOG_ERROR_1( "Can't write input buffer (%d) !", status);
+							
+							return_status = IMRS_KO;
+						    }
+						}
+						else
+						{
+						    return_status = IMRS_KO;
+						}
+					    }
+					    else
+					    {
+						data = IMRD_TRUE;
+					    }
+					    
+					    IMR_MM_Buffer_List( buffer_output_ptr, "Output Buffer");
+					    
+					    if( data == IMRD_TRUE)
+					    {
+						IMRD_LM_LOG_TRACE_0( IMRD_LOG_LEVEL_VERBOSE_0, "Writing output medium...");
+						
+						if( ( status = IMR_IOM_Medium_Write( medium_output_ptr, buffer_output_ptr)) != IMRS_OK)
+						{
+						    IMRD_LM_LOG_ERROR_1( "Can't write output buffer (%d) !", status);
+
+						    return_status = IMRS_KO;
+						}
+					    }
+					    
+					    if( return_status != IMRS_OK)
+					    {
+						IMRD_LM_LOG_TRACE_0( IMRD_LOG_LEVEL_VERBOSE_0, "Rollbaking transaction...");
+						
+						if( ( status = IMR_IOM_Tran_Rollback( tran_ptr)) == IMRS_KO)
+						{
+						    IMRD_LM_LOG_ERROR_1( "Can't rollback transaction (%d) !", status);
+						    
+						    return_status = IMRS_KO;
+						}
+					    }
+					    else
+					    {
+						IMRD_LM_LOG_TRACE_0( IMRD_LOG_LEVEL_VERBOSE_0, "Comiting transaction...");
+						
+						if( ( status = IMR_IOM_Tran_Commit( tran_ptr)) == IMRS_KO)
+						{
+						    IMRD_LM_LOG_ERROR_1( "Can't commit transaction (%d) !", status);
+						    
+						    return_status = IMRS_KO;
+						}
+
+						IMRD_LM_LOG_BUFFER_ID( buffer_input_ptr,  &IMRG_MR_Base.Config.Log_Id_Struct_Input,  IMRD_MR_LOG_ID_HEADER_MSG_INPUT);
+						IMRD_LM_LOG_BUFFER_ID( buffer_output_ptr, &IMRG_MR_Base.Config.Log_Id_Struct_Output, IMRD_MR_LOG_ID_HEADER_MSG_OUTPUT);
+					    }
+				    
+					    IMRD_LM_LOG_TRACE_0( IMRD_LOG_LEVEL_VERBOSE_0, "Freeing output buffer...");
+					    
+					    if( ( status = IMR_MM_Buffer_Free( &buffer_output_ptr)) != IMRS_OK)
+					    {
+						IMRD_LM_LOG_ERROR_1( "Can't free output buffer (%d) !", status);
+						
+						return_status = IMRS_KO;
+					    }
+					    
+					    buffer_output_ptr = NULL;
+					}
+				    }
+				}
+			    }
+			}
+			
+			IMRD_LM_LOG_TRACE_0( IMRD_LOG_LEVEL_VERBOSE_0, "Freeing input buffer...");
+			
+			if( ( status = IMR_MM_Buffer_Free( &buffer_input_ptr)) != IMRS_OK)
+			{
+			    IMRD_LM_LOG_ERROR_1( "Can't free input buffer (%d) !", status);
+			    
+			    return_status = IMRS_KO;
+			}
+			
+			buffer_input_ptr = NULL;
+		    }
+		}
+		while( ( return_status == IMRS_OK) && ( IMRG_Base.Sig_Trapped == 0));
+
+		switch( return_status)
+		{
+		    case IMRS_OK:
+		    case IMRS_NO_DATA:
+		    case IMRS_SIGNAL:
+		    {
+			return_status = IMRS_OK;
+			break;
+		    }
+
+		    case IMRS_KO:
+		    default:
+		    {
+			return_status = IMRS_KO;
+			break;
+		    }
+		}
+		
+		if( IMRG_MR_Base.Config.Continue_Forced == IMRD_TRUE)
+		{
+		    IMRD_LM_LOG_TRACE_0( IMRD_LOG_LEVEL_VERBOSE_0, "Closing trash medium...");
+		    
+		    if( ( status = IMR_IOM_Medium_Close( medium_trash_ptr)) != IMRS_OK)
+		    {
+			IMRD_LM_LOG_ERROR_1( "Can't close trash medium (%d) !", status);
+			
+			return_status = IMRS_KO;
+		    }
+		
+		    medium_trash_ptr = NULL;
+		}
+	    }
+
+	    IMRD_LM_LOG_TRACE_0( IMRD_LOG_LEVEL_VERBOSE_0, "Closing output medium...");
+		    
+	    if( ( status = IMR_IOM_Medium_Close( medium_output_ptr)) != IMRS_OK)
+	    {
+		IMRD_LM_LOG_ERROR_1( "Can't close output medium (%d) !", status);
+
+		return_status = IMRS_KO;
+	    }
+
+	    medium_output_ptr = NULL;
+	}
+		
+	IMRD_LM_LOG_TRACE_0( IMRD_LOG_LEVEL_VERBOSE_0, "Closing input medium...");
+		
+	if( ( status = IMR_IOM_Medium_Close( medium_input_ptr)) != IMRS_OK)
+	{
+	    IMRD_LM_LOG_ERROR_1( "Can't close input medium (%d) !", status);
+
+	    return_status = IMRS_KO;
+	}
+
+	medium_input_ptr = NULL;
+    }
+
+    return( return_status);
+}
+
+
diff --git a/src/libmsg_router/src/libmsg_router.h b/src/libmsg_router/src/libmsg_router.h
new file mode 100644
index 0000000..a1e7e33
--- /dev/null
+++ b/src/libmsg_router/src/libmsg_router.h
@@ -0,0 +1,146 @@
+/*----------------------------------------------------------------------------*/
+/* File: libmsg_router.h 				       		      */
+/*----------------------------------------------------------------------------*/
+/*                                                                            */
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#ifndef _LIBMSG_ROUTER_H_
+#define _LIBMSG_ROUTER_H_
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Global Include                                                             */
+/*----------------------------------------------------------------------------*/
+
+#include <imr.h>
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Lib Definitions                                                            */
+/*----------------------------------------------------------------------------*/
+
+#define IMRD_MR_MODULE_ID                ( IMRT_Module_Id) 5
+#define IMRD_MR_MODULE_NAME            ( IMRT_Module_Name) "mr"
+#define IMRD_MR_MODULE_NAME_LONG  ( IMRT_Module_Name_Long) "Message Router"
+#define IMRD_MR_MODULE_VERSION      ( IMRT_Module_Version) "@(#) VERSIONIMR: $Label:  $   $Date: 2008/11/12 02:25:23 $   $Workfile:   libmsg_router.h  $"
+
+#define IMRD_MODULE_PTR                                    &IMRG_MR_Module
+
+
+
+typedef struct IMRT_MR_Base
+{
+	IMRT_MR_Config  Config;
+}  IMRT_MR_Base;
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Local Definitions                                                          */
+/*----------------------------------------------------------------------------*/
+
+#define IMRD_MR_LOG_ID_HEADER_MSG_INPUT   ( IMRT_Log_Id_Header) "Input  Message Id:"
+#define IMRD_MR_LOG_ID_HEADER_MSG_OUTPUT  ( IMRT_Log_Id_Header) "Output Message Id:"  
+
+
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Prototypes                                                                 */
+/*----------------------------------------------------------------------------*/
+
+#   ifdef _LIBMSG_ROUTER_C_
+
+IMRT_Status  Close_All( IMRT_Buffer  *, IMRT_Buffer  *, IMRT_Medium  *, IMRT_Medium  *, IMRT_Medium  *);
+
+#   endif
+
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Local Includes                                                             */
+/*----------------------------------------------------------------------------*/
+
+
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Global Variables                                                           */
+/*----------------------------------------------------------------------------*/
+
+#   ifdef _LIBMSG_ROUTER_C_
+
+IMRT_MR_Base  IMRG_MR_Base =
+{
+    {
+	IMRD_FALSE,
+	IMRD_READ_MODE_WAIT
+    }
+};
+
+IMRT_Module  IMRG_MR_Module = 
+{ 
+    IMRD_MR_MODULE_ID,
+    IMRD_MR_MODULE_NAME,
+    IMRD_MR_MODULE_NAME_LONG,
+    IMRD_MR_MODULE_VERSION,
+    IMRD_MODULE_TYPE_LIBRARY,
+    {
+	IMRD_LIB_STATUS_CLOSED,
+	( IMRT_Lib_Open    *) &IMR_MR_Library_Open,
+	( IMRT_Lib_Close   *) &IMR_MR_Library_Close
+    }
+};
+
+#   else
+
+extern IMRT_MR_Base  IMRG_MR_Base;
+extern IMRT_Module   IMRG_MR_Module;
+
+#   endif
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+
+#endif
diff --git a/src/libnode/GNU-FDL.txt b/src/libnode/GNU-FDL.txt
new file mode 100644
index 0000000..b42936b
--- /dev/null
+++ b/src/libnode/GNU-FDL.txt
@@ -0,0 +1,355 @@
+		GNU Free Documentation License
+		   Version 1.1, March 2000
+
+ Copyright (C) 2000  Free Software Foundation, Inc.
+     59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+0. PREAMBLE
+
+The purpose of this License is to make a manual, textbook, or other
+written document "free" in the sense of freedom: to assure everyone
+the effective freedom to copy and redistribute it, with or without
+modifying it, either commercially or noncommercially.  Secondarily,
+this License preserves for the author and publisher a way to get
+credit for their work, while not being considered responsible for
+modifications made by others.
+
+This License is a kind of "copyleft", which means that derivative
+works of the document must themselves be free in the same sense.  It
+complements the GNU General Public License, which is a copyleft
+license designed for free software.
+
+We have designed this License in order to use it for manuals for free
+software, because free software needs free documentation: a free
+program should come with manuals providing the same freedoms that the
+software does.  But this License is not limited to software manuals;
+it can be used for any textual work, regardless of subject matter or
+whether it is published as a printed book.  We recommend this License
+principally for works whose purpose is instruction or reference.
+
+
+1. APPLICABILITY AND DEFINITIONS
+
+This License applies to any manual or other work that contains a
+notice placed by the copyright holder saying it can be distributed
+under the terms of this License.  The "Document", below, refers to any
+such manual or work.  Any member of the public is a licensee, and is
+addressed as "you".
+
+A "Modified Version" of the Document means any work containing the
+Document or a portion of it, either copied verbatim, or with
+modifications and/or translated into another language.
+
+A "Secondary Section" is a named appendix or a front-matter section of
+the Document that deals exclusively with the relationship of the
+publishers or authors of the Document to the Document's overall subject
+(or to related matters) and contains nothing that could fall directly
+within that overall subject.  (For example, if the Document is in part a
+textbook of mathematics, a Secondary Section may not explain any
+mathematics.)  The relationship could be a matter of historical
+connection with the subject or with related matters, or of legal,
+commercial, philosophical, ethical or political position regarding
+them.
+
+The "Invariant Sections" are certain Secondary Sections whose titles
+are designated, as being those of Invariant Sections, in the notice
+that says that the Document is released under this License.
+
+The "Cover Texts" are certain short passages of text that are listed,
+as Front-Cover Texts or Back-Cover Texts, in the notice that says that
+the Document is released under this License.
+
+A "Transparent" copy of the Document means a machine-readable copy,
+represented in a format whose specification is available to the
+general public, whose contents can be viewed and edited directly and
+straightforwardly with generic text editors or (for images composed of
+pixels) generic paint programs or (for drawings) some widely available
+drawing editor, and that is suitable for input to text formatters or
+for automatic translation to a variety of formats suitable for input
+to text formatters.  A copy made in an otherwise Transparent file
+format whose markup has been designed to thwart or discourage
+subsequent modification by readers is not Transparent.  A copy that is
+not "Transparent" is called "Opaque".
+
+Examples of suitable formats for Transparent copies include plain
+ASCII without markup, Texinfo input format, LaTeX input format, SGML
+or XML using a publicly available DTD, and standard-conforming simple
+HTML designed for human modification.  Opaque formats include
+PostScript, PDF, proprietary formats that can be read and edited only
+by proprietary word processors, SGML or XML for which the DTD and/or
+processing tools are not generally available, and the
+machine-generated HTML produced by some word processors for output
+purposes only.
+
+The "Title Page" means, for a printed book, the title page itself,
+plus such following pages as are needed to hold, legibly, the material
+this License requires to appear in the title page.  For works in
+formats which do not have any title page as such, "Title Page" means
+the text near the most prominent appearance of the work's title,
+preceding the beginning of the body of the text.
+
+
+2. VERBATIM COPYING
+
+You may copy and distribute the Document in any medium, either
+commercially or noncommercially, provided that this License, the
+copyright notices, and the license notice saying this License applies
+to the Document are reproduced in all copies, and that you add no other
+conditions whatsoever to those of this License.  You may not use
+technical measures to obstruct or control the reading or further
+copying of the copies you make or distribute.  However, you may accept
+compensation in exchange for copies.  If you distribute a large enough
+number of copies you must also follow the conditions in section 3.
+
+You may also lend copies, under the same conditions stated above, and
+you may publicly display copies.
+
+
+3. COPYING IN QUANTITY
+
+If you publish printed copies of the Document numbering more than 100,
+and the Document's license notice requires Cover Texts, you must enclose
+the copies in covers that carry, clearly and legibly, all these Cover
+Texts: Front-Cover Texts on the front cover, and Back-Cover Texts on
+the back cover.  Both covers must also clearly and legibly identify
+you as the publisher of these copies.  The front cover must present
+the full title with all words of the title equally prominent and
+visible.  You may add other material on the covers in addition.
+Copying with changes limited to the covers, as long as they preserve
+the title of the Document and satisfy these conditions, can be treated
+as verbatim copying in other respects.
+
+If the required texts for either cover are too voluminous to fit
+legibly, you should put the first ones listed (as many as fit
+reasonably) on the actual cover, and continue the rest onto adjacent
+pages.
+
+If you publish or distribute Opaque copies of the Document numbering
+more than 100, you must either include a machine-readable Transparent
+copy along with each Opaque copy, or state in or with each Opaque copy
+a publicly-accessible computer-network location containing a complete
+Transparent copy of the Document, free of added material, which the
+general network-using public has access to download anonymously at no
+charge using public-standard network protocols.  If you use the latter
+option, you must take reasonably prudent steps, when you begin
+distribution of Opaque copies in quantity, to ensure that this
+Transparent copy will remain thus accessible at the stated location
+until at least one year after the last time you distribute an Opaque
+copy (directly or through your agents or retailers) of that edition to
+the public.
+
+It is requested, but not required, that you contact the authors of the
+Document well before redistributing any large number of copies, to give
+them a chance to provide you with an updated version of the Document.
+
+
+4. MODIFICATIONS
+
+You may copy and distribute a Modified Version of the Document under
+the conditions of sections 2 and 3 above, provided that you release
+the Modified Version under precisely this License, with the Modified
+Version filling the role of the Document, thus licensing distribution
+and modification of the Modified Version to whoever possesses a copy
+of it.  In addition, you must do these things in the Modified Version:
+
+A. Use in the Title Page (and on the covers, if any) a title distinct
+   from that of the Document, and from those of previous versions
+   (which should, if there were any, be listed in the History section
+   of the Document).  You may use the same title as a previous version
+   if the original publisher of that version gives permission.
+B. List on the Title Page, as authors, one or more persons or entities
+   responsible for authorship of the modifications in the Modified
+   Version, together with at least five of the principal authors of the
+   Document (all of its principal authors, if it has less than five).
+C. State on the Title page the name of the publisher of the
+   Modified Version, as the publisher.
+D. Preserve all the copyright notices of the Document.
+E. Add an appropriate copyright notice for your modifications
+   adjacent to the other copyright notices.
+F. Include, immediately after the copyright notices, a license notice
+   giving the public permission to use the Modified Version under the
+   terms of this License, in the form shown in the Addendum below.
+G. Preserve in that license notice the full lists of Invariant Sections
+   and required Cover Texts given in the Document's license notice.
+H. Include an unaltered copy of this License.
+I. Preserve the section entitled "History", and its title, and add to
+   it an item stating at least the title, year, new authors, and
+   publisher of the Modified Version as given on the Title Page.  If
+   there is no section entitled "History" in the Document, create one
+   stating the title, year, authors, and publisher of the Document as
+   given on its Title Page, then add an item describing the Modified
+   Version as stated in the previous sentence.
+J. Preserve the network location, if any, given in the Document for
+   public access to a Transparent copy of the Document, and likewise
+   the network locations given in the Document for previous versions
+   it was based on.  These may be placed in the "History" section.
+   You may omit a network location for a work that was published at
+   least four years before the Document itself, or if the original
+   publisher of the version it refers to gives permission.
+K. In any section entitled "Acknowledgements" or "Dedications",
+   preserve the section's title, and preserve in the section all the
+   substance and tone of each of the contributor acknowledgements
+   and/or dedications given therein.
+L. Preserve all the Invariant Sections of the Document,
+   unaltered in their text and in their titles.  Section numbers
+   or the equivalent are not considered part of the section titles.
+M. Delete any section entitled "Endorsements".  Such a section
+   may not be included in the Modified Version.
+N. Do not retitle any existing section as "Endorsements"
+   or to conflict in title with any Invariant Section.
+
+If the Modified Version includes new front-matter sections or
+appendices that qualify as Secondary Sections and contain no material
+copied from the Document, you may at your option designate some or all
+of these sections as invariant.  To do this, add their titles to the
+list of Invariant Sections in the Modified Version's license notice.
+These titles must be distinct from any other section titles.
+
+You may add a section entitled "Endorsements", provided it contains
+nothing but endorsements of your Modified Version by various
+parties--for example, statements of peer review or that the text has
+been approved by an organization as the authoritative definition of a
+standard.
+
+You may add a passage of up to five words as a Front-Cover Text, and a
+passage of up to 25 words as a Back-Cover Text, to the end of the list
+of Cover Texts in the Modified Version.  Only one passage of
+Front-Cover Text and one of Back-Cover Text may be added by (or
+through arrangements made by) any one entity.  If the Document already
+includes a cover text for the same cover, previously added by you or
+by arrangement made by the same entity you are acting on behalf of,
+you may not add another; but you may replace the old one, on explicit
+permission from the previous publisher that added the old one.
+
+The author(s) and publisher(s) of the Document do not by this License
+give permission to use their names for publicity for or to assert or
+imply endorsement of any Modified Version.
+
+
+5. COMBINING DOCUMENTS
+
+You may combine the Document with other documents released under this
+License, under the terms defined in section 4 above for modified
+versions, provided that you include in the combination all of the
+Invariant Sections of all of the original documents, unmodified, and
+list them all as Invariant Sections of your combined work in its
+license notice.
+
+The combined work need only contain one copy of this License, and
+multiple identical Invariant Sections may be replaced with a single
+copy.  If there are multiple Invariant Sections with the same name but
+different contents, make the title of each such section unique by
+adding at the end of it, in parentheses, the name of the original
+author or publisher of that section if known, or else a unique number.
+Make the same adjustment to the section titles in the list of
+Invariant Sections in the license notice of the combined work.
+
+In the combination, you must combine any sections entitled "History"
+in the various original documents, forming one section entitled
+"History"; likewise combine any sections entitled "Acknowledgements",
+and any sections entitled "Dedications".  You must delete all sections
+entitled "Endorsements."
+
+
+6. COLLECTIONS OF DOCUMENTS
+
+You may make a collection consisting of the Document and other documents
+released under this License, and replace the individual copies of this
+License in the various documents with a single copy that is included in
+the collection, provided that you follow the rules of this License for
+verbatim copying of each of the documents in all other respects.
+
+You may extract a single document from such a collection, and distribute
+it individually under this License, provided you insert a copy of this
+License into the extracted document, and follow this License in all
+other respects regarding verbatim copying of that document.
+
+
+7. AGGREGATION WITH INDEPENDENT WORKS
+
+A compilation of the Document or its derivatives with other separate
+and independent documents or works, in or on a volume of a storage or
+distribution medium, does not as a whole count as a Modified Version
+of the Document, provided no compilation copyright is claimed for the
+compilation.  Such a compilation is called an "aggregate", and this
+License does not apply to the other self-contained works thus compiled
+with the Document, on account of their being thus compiled, if they
+are not themselves derivative works of the Document.
+
+If the Cover Text requirement of section 3 is applicable to these
+copies of the Document, then if the Document is less than one quarter
+of the entire aggregate, the Document's Cover Texts may be placed on
+covers that surround only the Document within the aggregate.
+Otherwise they must appear on covers around the whole aggregate.
+
+
+8. TRANSLATION
+
+Translation is considered a kind of modification, so you may
+distribute translations of the Document under the terms of section 4.
+Replacing Invariant Sections with translations requires special
+permission from their copyright holders, but you may include
+translations of some or all Invariant Sections in addition to the
+original versions of these Invariant Sections.  You may include a
+translation of this License provided that you also include the
+original English version of this License.  In case of a disagreement
+between the translation and the original English version of this
+License, the original English version will prevail.
+
+
+9. TERMINATION
+
+You may not copy, modify, sublicense, or distribute the Document except
+as expressly provided for under this License.  Any other attempt to
+copy, modify, sublicense or distribute the Document is void, and will
+automatically terminate your rights under this License.  However,
+parties who have received copies, or rights, from you under this
+License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+
+10. FUTURE REVISIONS OF THIS LICENSE
+
+The Free Software Foundation may publish new, revised versions
+of the GNU Free Documentation License from time to time.  Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.  See
+http://www.gnu.org/copyleft/.
+
+Each version of the License is given a distinguishing version number.
+If the Document specifies that a particular numbered version of this
+License "or any later version" applies to it, you have the option of
+following the terms and conditions either of that specified version or
+of any later version that has been published (not as a draft) by the
+Free Software Foundation.  If the Document does not specify a version
+number of this License, you may choose any version ever published (not
+as a draft) by the Free Software Foundation.
+
+
+ADDENDUM: How to use this License for your documents
+
+To use this License in a document you have written, include a copy of
+the License in the document and put the following copyright and
+license notices just after the title page:
+
+      Copyright (c)  YEAR  YOUR NAME.
+      Permission is granted to copy, distribute and/or modify this document
+      under the terms of the GNU Free Documentation License, Version 1.1
+      or any later version published by the Free Software Foundation;
+      with the Invariant Sections being LIST THEIR TITLES, with the
+      Front-Cover Texts being LIST, and with the Back-Cover Texts being LIST.
+      A copy of the license is included in the section entitled "GNU
+      Free Documentation License".
+
+If you have no Invariant Sections, write "with no Invariant Sections"
+instead of saying which ones are invariant.  If you have no
+Front-Cover Texts, write "no Front-Cover Texts" instead of
+"Front-Cover Texts being LIST"; likewise for Back-Cover Texts.
+
+If your document contains nontrivial examples of program code, we
+recommend releasing these examples in parallel under your choice of
+free software license, such as the GNU General Public License,
+to permit their use in free software.
diff --git a/src/libnode/GNU-GPL.txt b/src/libnode/GNU-GPL.txt
new file mode 100644
index 0000000..5b6e7c6
--- /dev/null
+++ b/src/libnode/GNU-GPL.txt
@@ -0,0 +1,340 @@
+		    GNU GENERAL PUBLIC LICENSE
+		       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.
+                       59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Library General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+		    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+			    NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
+	    How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Library General
+Public License instead of this License.
diff --git a/src/libnode/GNU-LGPL.txt b/src/libnode/GNU-LGPL.txt
new file mode 100644
index 0000000..b1e3f5a
--- /dev/null
+++ b/src/libnode/GNU-LGPL.txt
@@ -0,0 +1,504 @@
+		  GNU LESSER GENERAL PUBLIC LICENSE
+		       Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+     59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL.  It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it.  You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations below.
+
+  When we speak of free software, we are referring to freedom of use,
+not price.  Our General Public Licenses are designed to make sure that
+you have the freedom to distribute copies of free software (and charge
+for this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+  To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights.  These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  To protect each distributor, we want to make it very clear that
+there is no warranty for the free library.  Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+
+  Finally, software patents pose a constant threat to the existence of
+any free program.  We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder.  Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+  Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License.  This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License.  We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+  When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library.  The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom.  The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+  We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License.  It also provides other free software developers Less
+of an advantage over competing non-free programs.  These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries.  However, the Lesser license provides advantages in certain
+special circumstances.
+
+  For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it becomes
+a de-facto standard.  To achieve this, non-free programs must be
+allowed to use the library.  A more frequent case is that a free
+library does the same job as widely used non-free libraries.  In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+  In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software.  For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+  Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+
+		  GNU LESSER GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+  
+  1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+  You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+  2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) The modified work must itself be a software library.
+
+    b) You must cause the files modified to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    c) You must cause the whole of the work to be licensed at no
+    charge to all third parties under the terms of this License.
+
+    d) If a facility in the modified Library refers to a function or a
+    table of data to be supplied by an application program that uses
+    the facility, other than as an argument passed when the facility
+    is invoked, then you must make a good faith effort to ensure that,
+    in the event an application does not supply such function or
+    table, the facility still operates, and performs whatever part of
+    its purpose remains meaningful.
+
+    (For example, a function in a library to compute square roots has
+    a purpose that is entirely well-defined independent of the
+    application.  Therefore, Subsection 2d requires that any
+    application-supplied function or table used by this function must
+    be optional: if the application does not supply it, the square
+    root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library.  To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License.  (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.)  Do not make any other change in
+these notices.
+
+  Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+  This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+  4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+  If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library".  Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+  However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library".  The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+  When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library.  The
+threshold for this to be true is not precisely defined by law.
+
+  If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work.  (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+  Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+  6. As an exception to the Sections above, you may also combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+  You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License.  You must supply a copy of this License.  If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License.  Also, you must do one
+of these things:
+
+    a) Accompany the work with the complete corresponding
+    machine-readable source code for the Library including whatever
+    changes were used in the work (which must be distributed under
+    Sections 1 and 2 above); and, if the work is an executable linked
+    with the Library, with the complete machine-readable "work that
+    uses the Library", as object code and/or source code, so that the
+    user can modify the Library and then relink to produce a modified
+    executable containing the modified Library.  (It is understood
+    that the user who changes the contents of definitions files in the
+    Library will not necessarily be able to recompile the application
+    to use the modified definitions.)
+
+    b) Use a suitable shared library mechanism for linking with the
+    Library.  A suitable mechanism is one that (1) uses at run time a
+    copy of the library already present on the user's computer system,
+    rather than copying library functions into the executable, and (2)
+    will operate properly with a modified version of the library, if
+    the user installs one, as long as the modified version is
+    interface-compatible with the version that the work was made with.
+
+    c) Accompany the work with a written offer, valid for at
+    least three years, to give the same user the materials
+    specified in Subsection 6a, above, for a charge no more
+    than the cost of performing this distribution.
+
+    d) If distribution of the work is made by offering access to copy
+    from a designated place, offer equivalent access to copy the above
+    specified materials from the same place.
+
+    e) Verify that the user has already received a copy of these
+    materials or that you have already sent this user a copy.
+
+  For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it.  However, as a special exception,
+the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+  It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system.  Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+  7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+    a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities.  This must be distributed under the terms of the
+    Sections above.
+
+    b) Give prominent notice with the combined library of the fact
+    that part of it is a work based on the Library, and explaining
+    where to find the accompanying uncombined form of the same work.
+
+  8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License.  Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License.  However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+  9. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Library or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+  10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties with
+this License.
+
+  11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded.  In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+  13. The Free Software Foundation may publish revised and/or new
+versions of the Lesser General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation.  If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+  14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission.  For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this.  Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+			    NO WARRANTY
+
+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
+           How to Apply These Terms to Your New Libraries
+
+  If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change.  You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+  To apply these terms, attach the following notices to the library.  It is
+safest to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the library's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the
+  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
+
+  <signature of Ty Coon>, 1 April 1990
+  Ty Coon, President of Vice
+
+That's all there is to it!
+
+
diff --git a/src/libnode/ReadMe.txt b/src/libnode/ReadMe.txt
new file mode 100644
index 0000000..5b2e6ac
--- /dev/null
+++ b/src/libnode/ReadMe.txt
@@ -0,0 +1,44 @@
+# %RCSfile: ReadMe.txt,v %
+# %Revision: 2.8 %
+# %Name: libnode-2_1_0-1 %
+# %Date: 2005/01/24 01:19:50 %
+# %Author: agibert %
+
+
+
+
+
+Welcome to LibNode 2.1.x !
+
+
+
+This release of LibNode supports the following OS:
+	- Linux 2.2.x, 2.4.x and 2.6.x (tested on RedHat & Mandrake),
+	- Solaris 2.6,
+	- Windows NT4, 2000 and XP.
+
+
+
+The support of LibVer is now optional (To enable it, use: make _LIBVER_SUPPORT=1 all).
+
+LibNode support LibShMem 2.0.0 and LibDataStr 2.0.0 !
+
+
+
+Warning: Associated documentation (including the comments !) is outdated...
+Please read demo and ndbench code.
+
+
+
+Libnode is licensed under the LGPL/GPL GNU Licenses.
+For more information, please read the corresponding source file headers.
+The license details can be found in the GNU-GPL.txt, GNU-LGPL.txt and GNU-FDL.txt files.
+
+
+
+Enjoy it!
+
+Your LibNode Team.
+
+arnaud@rx3.net
+http://www.rx3.org/dvp/libnode
diff --git a/src/libnode/ReleaseNotes.txt b/src/libnode/ReleaseNotes.txt
new file mode 100644
index 0000000..d631beb
--- /dev/null
+++ b/src/libnode/ReleaseNotes.txt
@@ -0,0 +1,220 @@
+# %RCSfile: ReleaseNotes.txt,v %
+# %Revision: 2.20 %
+# %Name: libnode-2_1_0-1 %
+# %Date: 2005/01/24 00:50:55 %
+# %Author: agibert %
+
+
+
+
+
+------------------------------------------------------------------------------------------------------------------------------------
+LibNode V 2.1.0-1 - A. Gibert - 24/01/05
+------------------------------------------------------------------------------------------------------------------------------------
+
+All:		This new LibNode branch (2.1.x) should support the forthcoming new LibShMem branch (2.0.x),
+LibNode:	Add symbol lookup support for manager, allocator and desallocator functions call,
+		New Allocator and desallocator API interace,
+		Code cleanup,
+NDBench:	DS_Open now support an arg in order to use or not symbol lookup,
+		Add test-*-s.ndb batch files witch use symbol lookup.
+
+
+
+------------------------------------------------------------------------------------------------------------------------------------
+LibNode V 2.0.7-1 - A. Gibert - 20/01/05
+------------------------------------------------------------------------------------------------------------------------------------
+
+All:		Add to Makefile.var auto version label detection from CVS Tag.
+		This should be the final release of the 2.0 branch,
+		This new release is developped for the MICOT/Target project (Banque de France - Paris).
+LibNode:	Minor bug fixes in ND_*_Info_Print() functions and ND_Library_StdErr_Set alias defines.
+
+
+
+------------------------------------------------------------------------------------------------------------------------------------
+LibNode V 2.0.6-1 - A. Gibert - 24/08/04
+------------------------------------------------------------------------------------------------------------------------------------
+
+All:		Generate *-c executables with checking mode enabled (ND_MODE=1),
+		Code clean up and more cleanly indented,
+		This new release is developped for the MICOT/Target project (Banque de France - Paris),
+LibNode:	Add OpenStruct tracing support (Enabled by ND_MODE=1 and Debug=1),
+		Re-implement for Unix and Windows target, full address checking in ND_Address_Check(),
+NDDemo0:	Add LibNode 2.0.6 support: Add ND_Library_Open/Close() calls,
+NDBench:	Add Lib_Open, Lib_Close, Index_Value_Break and Index_Node_Break command,
+		Improve random number generation,
+		Add test-10.ndb and test-errror.ndb batch files.
+
+
+
+------------------------------------------------------------------------------------------------------------------------------------
+LibNode V 2.0.5-1 - A. Gibert / M. Regimbeau - 28/07/03
+------------------------------------------------------------------------------------------------------------------------------------
+
+All:		Add a new Makefile system (Makefile.rule and Makefile.var),
+		Add 'make distrib' support,
+		Add libnode.spec file,
+		Move node.h from lib directory to include directory.
+
+
+
+------------------------------------------------------------------------------------------------------------------------------------
+LibNode V 2.0.4-1 - A. Gibert - 29/07/02
+------------------------------------------------------------------------------------------------------------------------------------
+
+All:		This release of libnode pass with sucess valgrind test on linux.
+LibNode:	Add and use ND_Index_Clear() private API,
+NbBench:	Add fclose() call at the end of batch_run.
+
+
+
+------------------------------------------------------------------------------------------------------------------------------------
+LibNode V 2.0.3-1 - A. Gibert - 09/04/02
+------------------------------------------------------------------------------------------------------------------------------------
+
+All:		Fix Microsoft Visual Project to generate Debug and Release config correctly,
+LibNode:	Change index type numeric print value from decimal to hexa in ND_Index_Info_Print() API,
+LibNode:	Add new cases in ND_Index_Convert() handling (List->List:FIFO and List->List:LIFO),
+LibNode:	Generate in Debug mode libnoded.lib, libnoded.dll, libnoded_a.lib,
+LibNode:	Generate in Release mode libnode.lib, libnode.dll, libnode_a.lib,
+Demo0:		Generate in Debug mode demo0d.exe and in Release mode demo0d.exe,
+NbBench:	Generate in Debug mode ndbenchd.exe and in Release mode ndbenchd.exe.
+
+
+
+------------------------------------------------------------------------------------------------------------------------------------
+LibNode V 2.0.2-2 - A. Gibert - 01/03/02
+------------------------------------------------------------------------------------------------------------------------------------
+
+All:		Add GNU-GPL.txt, GNU-LGPL.txt and GNU-FDL.txt license files,
+All:		Add license stuff in ReandMe.
+LibNode:	Add LGPL header in libnode.c, libnode.h and node.h,
+LibNode:	Replace GPL by LGPL in libnode.rc,
+Demo0:		Add GPL header in demo0.c,
+NbBench:	Add GPL header in ndbench.c.
+
+
+
+------------------------------------------------------------------------------------------------------------------------------------
+LibNode V 2.0.2-1 - A. Gibert - 27/02/02
+------------------------------------------------------------------------------------------------------------------------------------
+
+All:		Makefiles now generate static and dynamic objects,
+All:		Add no libver support in Makefiles,
+LibNode:	VisualStudio Project now generate Windows DLL and use libnode.rc resource file,
+LibNode:	Rename Index_Open_Nb into Index_Open_Count,
+LibNode:	Fix bugs in ND_Node_Root_Alloc() on Index_Open_Count handling,
+LibNode:	Minor fix into ND_DataStruct_Check_I() and ND_Index_Check_I() functions,
+NbBench:	Implement Index_Close and Index_Info_Print functions.
+
+
+
+------------------------------------------------------------------------------------------------------------------------------------
+LibNode V 2.0.1-1 - A. Gibert - 28/11/01
+------------------------------------------------------------------------------------------------------------------------------------
+
+LibNode:	Fix the error level of TIMAS_KO: it's now an error status.
+
+
+
+------------------------------------------------------------------------------------------------------------------------------------
+LibNode V 2.0.0-1 - A. Gibert - 26/11/01
+------------------------------------------------------------------------------------------------------------------------------------
+
+All:		Merge the main CVS trunc with the win32 branche (2.0.0-alpha5),
+		Switch file release to 2.0.
+
+
+
+------------------------------------------------------------------------------------------------------------------------------------
+LibNode V 2.0.0-alpha5 - A. Gibert - 25/10/01
+------------------------------------------------------------------------------------------------------------------------------------
+
+LibNode:	Add Open/Close Index support,
+LibNode:	Fix return code next to empty struct manipulations,
+NdBench:	Add full multi index support.
+
+
+
+------------------------------------------------------------------------------------------------------------------------------------
+LibNode V 2.0.0-alpha4 - A. Gibert - 28/09/01
+------------------------------------------------------------------------------------------------------------------------------------
+
+All:		Add optional libver support,
+LibNode:	Fix missing recursive offset args,
+LibNode:	Start to fix some return code of empty struct manipulations,
+NdBench:	Fix local stack pointer big bug.
+
+
+
+------------------------------------------------------------------------------------------------------------------------------------
+LibNode V 2.0.0-alpha3 - A. Gibert - 18/9/01
+------------------------------------------------------------------------------------------------------------------------------------
+
+New manager args interface (again !),
+ndbench support batch mode.
+
+
+
+------------------------------------------------------------------------------------------------------------------------------------
+LibNode V 2.0.0-alpha2 - A. Gibert - 08/09/01
+------------------------------------------------------------------------------------------------------------------------------------
+
+Re-enable libver support for unix,
+Bug fixes,
+Code cleanup.
+
+
+
+------------------------------------------------------------------------------------------------------------------------------------
+LibNode V 2.0.0-alpha1 - A. Gibert - 07/09/01
+------------------------------------------------------------------------------------------------------------------------------------
+
+Add Full win32 support,
+Remove libver support,
+Multi index support,
+New manager args format,
+Major Code cleanup et standardisation.
+This new version (2.0.x) is developped for the TIMA project (Misys IBS - France).
+
+
+
+------------------------------------------------------------------------------------------------------------------------------------
+LibNode V 1.0.0 - S. Mas / A. Gibert - 18/07/00
+------------------------------------------------------------------------------------------------------------------------------------
+
+Unix (Linux and Solaris) version only, for BDM project (Société Générale - Paris)
+Major code rewrite.
+
+
+
+------------------------------------------------------------------------------------------------------------------------------------
+LibNode V 0.2.2 - A. Gibert - 01/06/93
+------------------------------------------------------------------------------------------------------------------------------------
+
+Embeded version on OS/2 2.1 (Companie Générale des Eaux - Paris)
+
+
+
+------------------------------------------------------------------------------------------------------------------------------------
+LibNode V 0.2.1 - A. Gibert - 01/04/92
+------------------------------------------------------------------------------------------------------------------------------------
+
+Amiga and PC support (Bareau de Draguignan - Ste Maxime).
+
+
+
+------------------------------------------------------------------------------------------------------------------------------------
+LibNode V 0.2.0 - A. Gibert - 01/03/91
+------------------------------------------------------------------------------------------------------------------------------------
+
+C version aided by p2c tools on Pyramid (Swansee University - Wales).
+
+
+
+------------------------------------------------------------------------------------------------------------------------------------
+LibNode V 0.1.0 - A. Gibert - 01/12/90
+------------------------------------------------------------------------------------------------------------------------------------
+
+Inital version in Pascal on Pyramid (Swansee University - Wales).
diff --git a/src/libnode/ToDo.txt b/src/libnode/ToDo.txt
new file mode 100644
index 0000000..e7ef09a
--- /dev/null
+++ b/src/libnode/ToDo.txt
@@ -0,0 +1,14 @@
+# %RCSfile: ToDo.txt,v %
+# %Revision: 2.5 %
+# %Name: libnode-2_1_0-1 %
+# %Date: 2005/01/24 01:19:50 %
+# %Author: agibert %
+
+
+
+
+
+- Check LibShMem/LibDataStr support (via symbol lookup support),
+- Add Cache Value option,
+- New English documentation (man/tex),
+- Improve API consitency.
diff --git a/src/libnode/demo/nddemo0.c b/src/libnode/demo/nddemo0.c
new file mode 100644
index 0000000..444ce55
--- /dev/null
+++ b/src/libnode/demo/nddemo0.c
@@ -0,0 +1,686 @@
+/*---------------------------------------------------------------------------------*/
+/* %RCSfile: nddemo0.c,v %                                                         */
+/*---------------------------------------------------------------------------------*/
+/* %Revision: 2.8 %                                                                */
+/* %Name: libnode-2_1_0-1 %                                                        */
+/* %Date: 2004/08/23 22:48:37 %                                                    */
+/* %Author: agibert %                                                              */
+/*---------------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------------*/
+/* This file is part of LibNode                                                    */
+/*                                                                                 */
+/*    LibNode is free software; you can redistribute it and/or modify              */
+/*    it under the terms of the GNU General Public Licence as published by         */
+/*    the Free Software Foundation; either version 2 of the License, or            */
+/*    (at your option) any later version.                                          */
+/*                                                                                 */
+/*    LibNode is distributed in the hope that it will be useful,                   */
+/*    but WITHOUT ANY WARRANTY; without even the implied warranty of               */
+/*    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                */
+/*    GNU Lesser General Public License for more details.                          */
+/*                                                                                 */
+/*    You should have received a copy of the GNU General Public License            */
+/*    along with LibNode; if not, write to the Free Software                       */
+/*    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA    */
+/*---------------------------------------------------------------------------------*/
+
+
+
+
+
+#include <stdio.h>
+#include <errno.h>
+
+#include <node.h>
+ 
+
+
+#define DEMO_FILE_NAME          "nddemo0.dat"
+#define STRING_LEN              ( short) 1024
+#define STRING_SIZE             ( short) ( STRING_LEN + 1)
+#define VAL_LEN                 ( short) 64
+#define VAL_SIZE                ( short) ( VAL_LEN + 1)
+#define INDEX_NB                ( short) 4
+
+#define NDD_CMD_INDEX0_PRINT    ( NDT_Command) 64
+#define NDD_CMD_INDEX1_PRINT    ( NDT_Command) 65
+#define NDD_CMD_INDEX2_PRINT    ( NDT_Command) 66
+#define NDD_CMD_INDEX3_PRINT    ( NDT_Command) 67
+
+
+
+typedef struct Demo_Value
+{
+	char  Val0[ VAL_SIZE];
+	char  Val1[ VAL_SIZE];
+	char  Val2[ VAL_SIZE];
+	char  Val3[ VAL_SIZE];
+} Demo_Value;
+
+
+
+/*---------------------------------------------------------------------------------*/
+/*    Prototypes                                                                   */
+/*---------------------------------------------------------------------------------*/
+
+NDT_Status  Demo_DS_Manager( NDT_Root  *, NDT_Index_Id, NDT_Node  *, NDT_Command, va_list);
+void        DataStruct_Load( NDT_Root  *,  FILE  *);
+void        DataStruct_Load( NDT_Root  *,  FILE  *);
+void        Demo( char  *, short);
+int         main( int, char  **);
+
+
+
+
+
+
+
+/*---------------------------------------------------------------------------------*/
+/*                                                                                 */
+/*---------------------------------------------------------------------------------*/
+
+NDT_Status  Demo_DS_Manager( NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id, NDT_Node  *Node_Ptr, NDT_Command  Command, va_list  Args)
+{
+    NDT_Command_Name  Command_Name;
+
+
+    switch( Command)
+    {
+        case NDD_CMD_MANAGER_VERSION:
+        {
+            NDT_Version_Name  *Version_Name_Ptr = (NDT_Version_Name  *)va_arg( Args, NDT_Version_Name  *);
+
+
+            Command_Name = "NDD_CMD_MANAGER_VERSION";
+
+            *Version_Name_Ptr = "%Revision: 2.8 %   %Name: libnode-2_1_0-1 %   %Date: 2004/08/23 22:48:37 %   %Author: agibert %";
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_INDEX_GET:
+        {
+            /*
+	      NDT_Index_Id  *Reply_Index_Id_Ptr = (NDT_Index_Id  *)va_arg( Args, NDT_Index_Id  *);
+	      NDT_Command   *Reply_Command_Ptr  =  (NDT_Command  *)va_arg( Args, NDT_Command  *);
+	      NDT_Command    Cmd                =     (NDT_Command)va_arg( Args, NDT_Command);
+	      void          *Value_ptr          =         (void  *)va_arg( Args, void  *);
+            */
+            NDT_Index_Id  *Reply_Index_Id_Ptr = (NDT_Index_Id  *)va_arg( Args, NDT_Index_Id  *);
+            NDT_Command   *Reply_Command_Ptr  =  (NDT_Command  *)va_arg( Args, NDT_Command  *);
+            NDT_Command    Cmd                =     (NDT_Command)va_arg( Args, NDT_Command);
+            Demo_Value    *Value_ptr          =   (Demo_Value  *)va_arg( Args, Demo_Value  *);
+
+
+            Command_Name = "NDD_CMD_INDEX_GET";
+
+            switch(Cmd)
+            {
+                case NDD_CMD_INDEX0_PRINT:
+                {
+                    *Reply_Index_Id_Ptr = 0;
+                    *Reply_Command_Ptr = NDD_CMD_VALUE_PRINT;
+                    break;
+                }
+
+                case NDD_CMD_INDEX1_PRINT:
+                {
+                    *Reply_Index_Id_Ptr = 1;
+                    *Reply_Command_Ptr = NDD_CMD_VALUE_PRINT;
+                    break;
+                }
+
+                case NDD_CMD_INDEX2_PRINT:
+                {
+                    *Reply_Index_Id_Ptr = 2;
+                    *Reply_Command_Ptr = NDD_CMD_VALUE_PRINT;
+                    break;
+                }
+
+                case NDD_CMD_INDEX3_PRINT:
+                {
+                    *Reply_Index_Id_Ptr = 3;
+                    *Reply_Command_Ptr = NDD_CMD_VALUE_PRINT;
+                    break;
+                }
+
+                default:
+                {
+                    *Reply_Index_Id_Ptr = Index_Id;
+                    *Reply_Command_Ptr = Cmd;
+                    break;
+                }
+            }
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_ALLOC:
+        {
+            /*
+	      void       **Value_Ptr_Ptr =   (void **)va_arg( Args, void  **);
+	      va_list      user_args     =   (va_list)va_arg( Args, va_list);
+	      user_type    user_data     = (user_type)va_arg( user_args, user_type);
+	      ... =       (...)va_arg( user_args, ...);
+            */
+            Demo_Value  **Value_Ptr_Ptr = va_arg( Args, Demo_Value  **);
+
+
+            Command_Name = "NDD_CMD_VALUE_ALLOC";
+
+            if( ( *Value_Ptr_Ptr = (Demo_Value  *)malloc( sizeof(Demo_Value))) == NULL)
+            {
+                return(NDS_ERRMEM);
+            }
+            else
+            {
+                (*Value_Ptr_Ptr)->Val0[0] = '\0';
+                (*Value_Ptr_Ptr)->Val1[0] = '\0';
+                (*Value_Ptr_Ptr)->Val2[0] = '\0';
+                (*Value_Ptr_Ptr)->Val3[0] = '\0';
+
+                return( NDS_OK);
+            }
+        }
+
+        case NDD_CMD_VALUE_FREE:
+        {
+            /*
+	      void       *Value_Ptr =    (void *)va_arg( Args, void  *);
+	      va_list     user_args =   (va_list)va_arg( Args, va_list);
+	      user_type   user_data = (user_type)va_arg( user_args, user_type);
+	      ... =       (...)va_arg( user_args, ...);
+            */
+            Demo_Value  *Value_Ptr = (Demo_Value  *)va_arg( Args, Demo_Value  *);
+
+
+            Command_Name = "NDD_CMD_VALUE_FREE";
+
+            free( Value_Ptr);
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_COMP:
+        {
+            /*
+	      void       *Value1_Ptr =    (void *)va_arg( Args, void  *);
+	      void       *Value2_Ptr =    (void *)va_arg( Args, void  *);
+	      va_list     user_args  =   (va_list)va_arg( Args, va_list);
+	      user_type   user_data  = (user_type)va_arg( user_args, user_type);
+	      ... =       (...)va_arg( user_args, ...);
+            */
+            Demo_Value    *Value1_Ptr = va_arg( Args, Demo_Value  *);
+            Demo_Value    *Value2_Ptr = va_arg( Args, Demo_Value  *);
+
+
+            Command_Name = "NDD_CMD_VALUE_COMP";
+
+            switch( Index_Id)
+            {
+                case 0:
+                {
+                    int     rc;
+
+
+                    rc = strcmp( Value1_Ptr->Val0, Value2_Ptr->Val0);
+
+                    if( rc < 0)
+                    {
+                        return( NDS_LOWER);
+                    }
+                    else
+                    {
+                        if( rc > 0)
+                        {
+                            return( NDS_GREATER);
+                        }
+                        else
+                        {
+                            return( NDS_EQUAL);
+                        }
+                    }
+                }
+
+                case 1:
+                {
+                    int  val1 = atoi( Value1_Ptr->Val1);
+                    int  val2 = atoi( Value2_Ptr->Val1);
+
+
+                    if( val1 < val2)
+                    {
+                        return( NDS_LOWER);
+                    }
+                    else
+                    {
+                        if( val1 > val2)
+                        {
+                            return( NDS_GREATER);
+                        }
+                        else
+                        {
+                            return( NDS_EQUAL);
+                        }
+                    }
+                }
+
+                case 2:
+                {
+                    int  val1 = strlen( Value1_Ptr->Val2);
+                    int  val2 = strlen( Value2_Ptr->Val2);
+
+
+                    if( val1 < val2)
+                    {
+                        return( NDS_LOWER);
+                    }
+                    else
+                    {
+                        if( val1 > val2)
+                        {
+                            return( NDS_GREATER);
+                        }
+                        else
+                        {
+                            return( NDS_EQUAL);
+                        }
+                    }
+                }
+
+                default:
+                {
+                    printf( "Unknown COMP idx (%d) !\n", Index_Id);
+                    return( NDS_KO);
+                }
+            }
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_ADD:
+        {
+            /*
+	      void       *Value_Ptr =    (void *)va_arg( Args, void  *);
+	      va_list     user_args =   (va_list)va_arg( Args, va_list);
+	      user_type   user_data = (user_type)va_arg( user_args, user_type);
+	      ... =       (...)va_arg( user_args, ...);
+            */
+
+            Command_Name = "NDD_CMD_VALUE_ADD";
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_REMOVE:
+        {
+            /*
+	      void       *Value_Ptr =    (void *)va_arg( Args, void  *);
+	      va_list     user_args =   (va_list)va_arg( Args, va_list);
+	      user_type   user_data = (user_type)va_arg( user_args, user_type);
+	      ... =       (...)va_arg( user_args, ...);
+            */
+
+            Command_Name = "NDD_CMD_VALUE_REMOVE";
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_PRINT:
+        {
+            /*
+	      NDT_Node             *Next_Node_Ptr   =         (NDT_Node  *)va_arg( Args, NDT_Node  *);
+	      va_list               lib_args        =             (va_list)va_arg( Args, va_list);
+	      FILE                 *Out             =             (FILE  *)va_arg( lib_args, FILE  *);
+	      NDT_Recursive_Mode    Recursive_Mode  =  (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode);
+	      NDT_Recursive_Depth   Recursive_Depth = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth);
+	      va_list               user_args       =             (va_list)va_arg( lib_args, va_list);
+	      user_type             user_data       =           (user_type)va_arg( user_args, user_type);
+	      ... =                 (...)va_arg( user_args, ...);
+
+	      void                 *Value_Ptr       = Node_Ptr->Value;
+            */
+            NDT_Node             *Next_Node_Ptr   =         (NDT_Node  *)va_arg( Args, NDT_Node  *);
+            va_list               lib_args        =             (va_list)va_arg( Args, va_list);
+            FILE                 *Out             =             (FILE  *)va_arg( lib_args, FILE  *);
+            NDT_Recursive_Mode    Recursive_Mode  =  (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode);
+            NDT_Recursive_Depth   Recursive_Depth = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth);
+
+            Demo_Value           *Value_Ptr       = Node_Ptr->Value;
+
+
+            Command_Name = "NDD_CMD_VALUE_PRINT";
+
+            fprintf( Out, "Val0: (%s)   Val1: (%s)   Val2: (%s)   Val3: (%s)\n",
+		     Value_Ptr->Val0, Value_Ptr->Val1, Value_Ptr->Val2, Value_Ptr->Val3);
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_INFO_PRINT:
+        {
+            /*
+	      NDT_Node             *Next_Node_Ptr   =         (NDT_Node  *)va_arg( Args, NDT_Node  *);
+	      va_list               lib_args        =             (va_list)va_arg( Args, va_list);
+	      FILE                 *Out             =             (FILE  *)va_arg( lib_args, FILE  *);
+	      NDT_Recursive_Mode    Recursive_Mode  =  (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode);
+	      NDT_Recursive_Depth   Recursive_Depth = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth);
+	      va_list               user_args       =             (va_list)va_arg( lib_args, va_list);
+	      user_type             user_data       =           (user_type)va_arg( user_args, user_type);
+	      ... =                 (...)va_arg( user_args, ...);
+
+	      void                 *Value_Ptr       = Node_Ptr->Value;
+            */
+
+            Command_Name = "NDD_CMD_INFO_PRINT";
+
+            return( NDS_OK);
+        }
+
+        default:
+        {
+            printf( "Demo_DS_Manager() called with an undefined command %d\n", Command);
+            return( NDS_ERRAPI);
+        }
+    }
+
+    printf( "Demo_DS_Manager() called with command %d (%s)\n", Command, Command_Name);
+    return( NDS_OK);
+}
+
+
+
+
+
+/*---------------------------------------------------------------------------------*/
+/*                                                                                 */
+/*---------------------------------------------------------------------------------*/
+
+void  DataStruct_Load( NDT_Root  *ds_ptr,  FILE  *demo_file)
+{
+    NDT_Status         status;
+    char            *str;
+    char             input_string[STRING_SIZE];
+    char             val0[VAL_SIZE], val1[VAL_SIZE], val2[VAL_SIZE], val3[VAL_SIZE];
+    Demo_Value        *value_ptr;
+
+    
+    while( !feof( demo_file))
+    {
+        str = fgets( input_string, STRING_SIZE, demo_file);
+        if( ( (const int)str != EOF) && ( str != NULL))
+        {
+            if( strlen( input_string) >= STRING_LEN)
+            {
+                printf( "Input line too long ! Skipping ...");
+                    
+                while( !feof( demo_file) && strlen( input_string) >= STRING_LEN)
+                {
+                    printf( ".");
+                    str = fgets( input_string, STRING_SIZE, demo_file);
+                }
+
+                printf("\n");
+            }
+            else
+            {
+                if( input_string[0] != '#')
+                {
+                    if( sscanf( input_string, "%s %s %s %s\n", val0, val1, val2, val3) != 4)
+                    {
+                        printf( "Input line scaning error... Skipping !\n");
+                    }
+                    else
+                    {
+                        printf( "Input line read: \t(%s)\t(%s)\t(%s)\t(%s)\n", val0, val1, val2, val3);
+			printf( "Allocate Vallue: ");
+
+                        if( ( status = ND_Value_Alloc( ds_ptr, (void  **)&value_ptr)) != NDS_OK)
+                        {
+                            printf( "ND_Value_Alloc() failed (%d) !\n", status);
+                        }
+                        else
+                        {
+                            printf( "Ok !\n");
+
+                            strcpy( value_ptr->Val0, val0);
+                            strcpy( value_ptr->Val1, val1);
+                            strcpy( value_ptr->Val2, val2);
+                            strcpy( value_ptr->Val3, val3);
+
+                            printf( "Add Vallue: ");
+
+                            if( ( status = ND_DataStruct_Value_Add( ds_ptr, (void  **)value_ptr)) != NDS_OK)
+                            {
+                                printf( "ND_Value_Add() failed (%d) !\n", status);
+                            }
+                            else
+                            {
+                                printf( "Ok !\n");
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+
+
+
+
+/*---------------------------------------------------------------------------------*/
+/*                                                                                   */
+/*---------------------------------------------------------------------------------*/
+
+void  DataStruct_Dump( NDT_Root  *ds_ptr)
+{
+    NDT_Status  status;
+
+
+    printf( "Print DataStructure Info:\n");
+
+    if( ( status = ND_DataStruct_Info_Print( stdout, ds_ptr, NDD_RECURSIVE_MODE_PARENT_CHILD, 0, 0)) != NDS_OK)
+    {
+        printf( "ND_DataStruct_Info_Print() failed (%d) !\n", status);
+    }
+
+    printf( "\n");
+
+
+
+    printf( "Traverse DataStructure Index 0:\n");
+
+    if( ( status = ND_DataStruct_Traverse( ds_ptr, NDD_CMD_INDEX0_PRINT, stdout, NDD_RECURSIVE_MODE_PARENT, 0)) != NDS_OK)
+    {
+        printf( "ND_DataStruct_Traverse() failed (%d) !\n", status);
+    }
+
+    printf( "\n");
+
+
+
+    printf( "Traverse DataStructure Index 1:\n");
+
+    if( ( status = ND_DataStruct_Traverse( ds_ptr, NDD_CMD_INDEX1_PRINT, stdout, NDD_RECURSIVE_MODE_PARENT, 0)) != NDS_OK)
+    {
+        printf( "ND_DataStruct_Traverse() failed (%d) !\n", status);
+    }
+
+    printf( "\n");
+
+
+
+    printf( "Traverse DataStructure Index 2:\n");
+
+    if( ( status = ND_DataStruct_Traverse( ds_ptr, NDD_CMD_INDEX2_PRINT, stdout, NDD_RECURSIVE_MODE_PARENT, 0)) != NDS_OK)
+    {
+        printf( "ND_DataStruct_Traverse() failed (%d) !\n", status);
+    }
+
+    printf( "\n");
+
+
+
+    printf( "Traverse DataStructure Index 3:\n");
+
+    if( ( status = ND_DataStruct_Traverse( ds_ptr, NDD_CMD_INDEX3_PRINT, stdout, NDD_RECURSIVE_MODE_PARENT, 0)) != NDS_OK)
+    {
+        printf( "ND_DataStruct_Traverse() failed (%d) !\n", status);
+    }
+
+    printf( "\n");
+}
+            
+
+
+
+            
+/*---------------------------------------------------------------------------------*/
+/*                                                                                 */
+/*---------------------------------------------------------------------------------*/
+
+void Demo( char  *Demo_File_Name, short  Optimized_Mode)
+{
+    NDT_Status         status;
+    NDT_Root        *demo_ds_ptr;
+    NDT_Index_Type     index_type_initial_tab[INDEX_NB] = 
+	{
+	    (NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_LIST | NDD_INDEX_SUBTYPE_FIFO),
+	    (NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_LIST | NDD_INDEX_SUBTYPE_FIFO),
+	    (NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_LIST | NDD_INDEX_SUBTYPE_FIFO),
+	    (NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_LIST | NDD_INDEX_SUBTYPE_FIFO)
+	};
+    NDT_Index_Type     index_type_final_tab[INDEX_NB] = 
+	{
+	    (NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_TREE | NDD_INDEX_SUBTYPE_BALANCED),
+	    (NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_LIST | NDD_INDEX_SUBTYPE_SORTED),
+	    (NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_TREE | NDD_INDEX_SUBTYPE_BALANCED),
+	    (NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_LIST | NDD_INDEX_SUBTYPE_FIFO)
+	};
+    NDT_Index_Type  *index_type_ptr;
+    FILE            *demo_file;
+
+
+    printf( "Open library: ");
+
+    if( ( status = ND_Library_Open( NDD_TRUE)) != NDS_OK)
+    {
+        printf( "ND_Library_Open() failed (%d) !\n", status);
+    }
+    else
+    {
+        printf( "Ok !\n");
+
+	printf( "Create demo DataStructure: ");
+
+	if( Optimized_Mode)
+	{
+	    index_type_ptr = index_type_initial_tab;
+	}
+	else
+	{
+	    index_type_ptr = index_type_final_tab;
+	}
+
+	if( ( status = ND_DataStruct_Open( &demo_ds_ptr, INDEX_NB, index_type_ptr, "Demo_DS_Manager", Demo_DS_Manager, NULL, NULL, NULL, NULL,0,  NULL)) != NDS_OK)
+	{
+	    printf( "ND_DataStruct_Open() failed (%d) !\n", status);
+	}
+	else
+	{
+	    printf( "Ok !\n");
+
+	    printf( "Open demo datafile: ");
+
+	    if( ( demo_file = fopen( Demo_File_Name, "r")) == NULL)
+	    {
+		printf( "fopen() failed (%d/%s) !\n", errno, strerror(errno));
+	    }
+	    else
+	    {
+		printf( "Ok !\n");
+
+
+
+		printf( "\n\n\nLaod Data File:\n\n");
+		DataStruct_Load( demo_ds_ptr, demo_file);
+            
+		if( Optimized_Mode)
+		{
+		    printf( "\n\n\nInitial Structure Dump:\n\n");
+		    DataStruct_Dump( demo_ds_ptr);
+            
+		    printf( "Convert data structure: ");
+
+		    if( ( status = ND_DataStruct_Convert( demo_ds_ptr, index_type_final_tab)) != NDS_OK)
+		    {
+			printf( "ND_DataStruct_Convert() failed (%d) !\n", status);
+		    }
+		    else
+		    {
+			printf( "Ok !\n");
+		    }
+		}
+
+
+
+		printf( "\n\n\nFinal Structure Dump:\n\n");
+		DataStruct_Dump( demo_ds_ptr);
+
+		printf( "Close demo datafile: ");
+
+		if( fclose( demo_file) != 0)
+		{
+		    printf( "fclose() failed (%d/%s) !\n", errno, strerror(errno));
+		}
+		else
+		{
+		    printf( "Ok !\n");
+		}
+	    }
+
+
+	    printf( "Close demo DataStructure: ");
+    
+	    if( ( status = ND_DataStruct_Close( demo_ds_ptr)) != NDS_OK)
+	    {
+		printf( "ND_DataStruct_Close() failed (%d) !\n", status);
+	    }
+	    else
+	    {
+		printf( "Ok !\n");
+	    }
+	}
+
+        printf( "Close library: ");
+    
+        if( ( status = ND_Library_Close()) != NDS_OK)
+        {
+            printf( "ND_Library_Close() failed (%d) !\n", status);
+        }
+        else
+        {
+            printf( "Ok !\n");
+        }
+    }
+}
+
+
+
+
+
+/*---------------------------------------------------------------------------------*/
+/*                                                                                 */
+/*---------------------------------------------------------------------------------*/
+
+int main( int  argc, char  **argv)
+{
+    printf( "Non Optimized Demo\n------------------\n\n\n");
+    Demo( DEMO_FILE_NAME, 0);
+
+    printf( "\n\n\n\n\nOptimized Demo\n--------------\n\n\n");
+    Demo( DEMO_FILE_NAME, 1);
+}
diff --git a/src/libnode/demo/nddemo0.dat b/src/libnode/demo/nddemo0.dat
new file mode 100644
index 0000000..07ddfe8
--- /dev/null
+++ b/src/libnode/demo/nddemo0.dat
@@ -0,0 +1,15 @@
+#---------------------------------------------------------------------------------
+# %RCSfile: nddemo0.dat,v %								
+#---------------------------------------------------------------------------------
+# %Revision: 2.1 %								
+# %Name: libnode-2_1_0-1 %									
+# %Date: 2003/07/16 00:17:02 %							
+# %Author: agibert %								
+#---------------------------------------------------------------------------------
+ggg	1	xxxxxx	example
+aaa	7	x	this
+bbb	6	xxx	is
+ccc	5	xxxxx	a
+ddd	4	xxxx	really
+eee	3	xxxxxxx	good
+fff	2	xx	libnode
diff --git a/src/libnode/include/node.h b/src/libnode/include/node.h
new file mode 100644
index 0000000..2d83cda
--- /dev/null
+++ b/src/libnode/include/node.h
@@ -0,0 +1,926 @@
+/*----------------------------------------------------------------------------*/
+/* $Workfile:   node.h  $                                                     */
+/*----------------------------------------------------------------------------*/
+/* $Author: agibert $                                                      */
+/* $Date: 2008/11/12 02:25:23 $                                           */
+/* $Revision: 1.1 $                                                        */
+/* $Label:  $                                                         */
+/*----------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------------*/
+/* %RCSfile: node.h,v %					       			   */
+/*---------------------------------------------------------------------------------*/
+/* %Revision: 2.12 %			      					   */
+/* %Name: libnode-2_1_0-1 %									   */
+/* %Date: 2005/01/20 00:00:25 %							   */
+/* %Author: agibert %								   */
+/*---------------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------------*/
+/* This file is part of LibNode                                                    */
+/*                                                                                 */
+/*    LibNode is free software; you can redistribute it and/or modify              */
+/*    it under the terms of the GNU Lesser General Public Licence as published by  */
+/*    the Free Software Foundation; either version 2.1 of the License, or          */
+/*    (at your option) any later version.                                          */
+/*                                                                                 */
+/*    LibNode is distributed in the hope that it will be useful,                   */
+/*    but WITHOUT ANY WARRANTY; without even the implied warranty of               */
+/*    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                */
+/*    GNU Lesser General Public License for more details.                          */
+/*                                                                                 */
+/*    You should have received a copy of the GNU Lesser General Public License     */
+/*    along with LibNode; if not, write to the Free Software                       */
+/*    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA    */
+/*---------------------------------------------------------------------------------*/
+
+
+
+
+
+
+#ifndef _LIBNODE_H_
+#   define _LIBNODE_H_
+
+#   ifdef __cplusplus
+extern "C" {
+#   endif
+
+#   include <stdlib.h>
+#   include <stdio.h>
+#   include <string.h>
+#   include <stdarg.h>
+
+#   ifdef _LIBVER_SUPPORT
+#       include <ver.h>
+#   endif
+
+
+
+
+
+
+
+#define NDD_TRUE  1
+
+#define NDD_FALSE 0
+
+#define NDD_MIN(A,B)  ((A > B) ? B : A)
+
+#define NDD_MAX(A,B)  ((A < B) ? B : A)
+
+
+
+/*
+  Différence de profondeur entre la branche la plus courte et
+  la plus longue d'un arbre.
+  Le dépassement de ce seuil provoque le rééquilibrage de l'arbre
+*/
+
+#define DEF_MAX_DIF   100
+
+/* Types de structure */
+
+typedef short  NDT_Root_Type;
+
+typedef int NDT_Index_Type;
+
+#define NDD_INDEX_MSK               0xffff
+#define NDD_INDEX_RMSK              0x0000
+
+#define NDD_INDEX_STATUS_UNKNOWN    0x0000
+#define NDD_INDEX_STATUS_OPENED     0x0001
+#define NDD_INDEX_STATUS_CLOSED     0x0002
+#define NDD_INDEX_STATUS_MSK        (NDD_INDEX_STATUS_UNKNOWN | NDD_INDEX_STATUS_OPENED | NDD_INDEX_STATUS_CLOSED)
+#define NDD_INDEX_STATUS_RMSK       (NDD_INDEX_MSK ^ NDD_INDEX_STATUS_MSK)
+
+#define ND_INDEX_STATUS_VALUE_UNKNOWN_IS( v)    ( ( (v) & NDD_INDEX_STATUS_MSK) == NDD_INDEX_STATUS_UNKNOWN)
+#define ND_INDEX_STATUS_VALUE_OPENED_IS( v)     ( ( (v) & NDD_INDEX_STATUS_MSK) == NDD_INDEX_STATUS_OPENED)
+#define ND_INDEX_STATUS_VALUE_CLOSED_IS( v)     ( ( (v) & NDD_INDEX_STATUS_MSK) == NDD_INDEX_STATUS_CLOSED)
+#define ND_INDEX_STATUS_UNKNOWN_IS( r, i)       ND_INDEX_STATUS_VALUE_UNKNOWN_IS( (r)->Index_Tab[(i)].Type)
+#define ND_INDEX_STATUS_OPENED_IS( r, i)        ND_INDEX_STATUS_VALUE_OPENED_IS( (r)->Index_Tab[(i)].Type)
+#define ND_INDEX_STATUS_CLOSED_IS( r, i)        ND_INDEX_STATUS_VALUE_CLOSED_IS( (r)->Index_Tab[(i)].Type)
+
+#define ND_INDEX_STATUS_VALUE_ASCII_GET( v)     ( ND_INDEX_STATUS_VALUE_UNKNOWN_IS( (v)) ? "UNKNOWN" : ( ND_INDEX_STATUS_VALUE_OPENED_IS( (v)) ? "OPENED" : ( ND_INDEX_STATUS_VALUE_CLOSED_IS( (v)) ? "CLOSED" : "???")))
+#define ND_INDEX_STATUS_ASCII_GET( r, i)        ND_INDEX_STATUS_VALUE_ASCII_GET( (r)->Index_Tab[(i)].Type)
+
+
+
+#define NDD_INDEX_TYPE_UNKNOWN      0x0000
+#define NDD_INDEX_TYPE_LIST         0x0010
+#define NDD_INDEX_TYPE_TREE         0x0020
+#define NDD_INDEX_TYPE_MSK          (NDD_INDEX_TYPE_UNKNOWN | NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)
+#define NDD_INDEX_TYPE_RMSK         (NDD_INDEX_MSK ^ NDD_INDEX_TYPE_MSK)
+
+#define ND_INDEX_TYPE_VALUE_UNKNOWN_IS( v)  ( ( (v) & NDD_INDEX_TYPE_MSK) == NDD_INDEX_TYPE_UNKNOWN)
+#define ND_INDEX_TYPE_VALUE_LIST_IS( v)     ( ( (v) & NDD_INDEX_TYPE_MSK) == NDD_INDEX_TYPE_LIST)
+#define ND_INDEX_TYPE_VALUE_TREE_IS( v)     ( ( (v) & NDD_INDEX_TYPE_MSK) == NDD_INDEX_TYPE_TREE)
+
+#define ND_INDEX_TYPE_UNKNOWN_IS( r, i)     ND_INDEX_TYPE_VALUE_UNKNOWN_IS( (r)->Index_Tab[(i)].Type)
+#define ND_INDEX_TYPE_LIST_IS( r, i)        ND_INDEX_TYPE_VALUE_LIST_IS( (r)->Index_Tab[(i)].Type)
+#define ND_INDEX_TYPE_TREE_IS( r, i)        ND_INDEX_TYPE_VALUE_TREE_IS( (r)->Index_Tab[(i)].Type)
+
+#define ND_INDEX_TYPE_VALUE_ASCII_GET( v)   ( ND_INDEX_TYPE_VALUE_UNKNOWN_IS( (v)) ? "UNKNOWN" : ( ND_INDEX_TYPE_VALUE_LIST_IS( (v)) ? "LIST" : ( ND_INDEX_TYPE_VALUE_TREE_IS( (v)) ? "TREE" : "???")))
+
+#define ND_INDEX_TYPE_ASCII_GET( r, i)      ND_INDEX_TYPE_VALUE_ASCII_GET( (r)->Index_Tab[(i)].Type)
+
+
+
+#define NDD_INDEX_SUBTYPE_UNKNOWN      0x0000
+#define NDD_INDEX_SUBTYPE_FIFO         0x0100    /* principe de la file d'attente (First In First Out) */
+#define NDD_INDEX_SUBTYPE_LILO         NDD_INDEX_SUBTYPE_FIFO
+#define NDD_INDEX_SUBTYPE_LIFO         0x0200    /* principe de la pile (First In Last Out) */
+#define NDD_INDEX_SUBTYPE_FILO         NDD_INDEX_SUBTYPE_LIFO
+#define NDD_INDEX_SUBTYPE_SORTED       0x0300    /* liste triée */
+#define NDD_INDEX_SUBTYPE_UNBALANCED   0x0400
+#define NDD_INDEX_SUBTYPE_BALANCED     0x0500    /* arbre auto-équilibré */
+#define NDD_INDEX_SUBTYPE_MSK          ( NDD_INDEX_SUBTYPE_UNKNOWN | NDD_INDEX_SUBTYPE_FIFO | NDD_INDEX_SUBTYPE_FILO | NDD_INDEX_SUBTYPE_SORTED | NDD_INDEX_SUBTYPE_UNBALANCED | NDD_INDEX_SUBTYPE_BALANCED)
+#define NDD_INDEX_SUBTYPE_RMSK         (NDD_INDEX_MSK ^ NDD_INDEX_SUBTYPE_MSK)
+
+#define ND_INDEX_SUBTYPE_VALUE_UNKNOWN_IS( v)     ( ( (v) & NDD_INDEX_SUBTYPE_MSK) == NDD_INDEX_SUBTYPE_UNKNOWN)
+#define ND_INDEX_SUBTYPE_VALUE_FIFO_IS( v)        ( ( (v) & NDD_INDEX_SUBTYPE_MSK) == NDD_INDEX_SUBTYPE_FIFO)
+#define ND_INDEX_SUBTYPE_VALUE_LILO_IS( v)	  ND_INDEX_SUBTYPE_VALUE_FIFO_IS( v)
+#define ND_INDEX_SUBTYPE_VALUE_LIFO_IS( v)	  ( ( (v) & NDD_INDEX_SUBTYPE_MSK) == NDD_INDEX_SUBTYPE_LIFO)
+#define ND_INDEX_SUBTYPE_VALUE_FILO_IS( v)	  ND_INDEX_SUBTYPE_LIFO_IS( r, i)
+#define ND_INDEX_SUBTYPE_VALUE_SORTED_IS( v)      ( ( (v) & NDD_INDEX_SUBTYPE_MSK) == NDD_INDEX_SUBTYPE_SORTED)
+#define ND_INDEX_SUBTYPE_VALUE_UNBALANCED_IS( v)  ( ( (v) & NDD_INDEX_SUBTYPE_MSK) == NDD_INDEX_SUBTYPE_UNBALANCED)
+#define ND_INDEX_SUBTYPE_VALUE_BALANCED_IS( v)    ( ( (v) & NDD_INDEX_SUBTYPE_MSK) == NDD_INDEX_SUBTYPE_BALANCED)
+
+#define ND_INDEX_SUBTYPE_UNKNOWN_IS( r, i)        ND_INDEX_SUBTYPE_VALUE_UNKNOWN_IS( (r)->Index_Tab[(i)].Type)
+#define ND_INDEX_SUBTYPE_FIFO_IS( r, i)           ND_INDEX_SUBTYPE_VALUE_FIFO_IS( (r)->Index_Tab[(i)].Type)
+#define ND_INDEX_SUBTYPE_LILO_IS( r, i)	          ND_INDEX_SUBTYPE_VALUE_LILO_IS( (r)->Index_Tab[(i)].Type)
+#define ND_INDEX_SUBTYPE_LIFO_IS( r, i)	          ND_INDEX_SUBTYPE_VALUE_LIFO_IS( (r)->Index_Tab[(i)].Type)
+#define ND_INDEX_SUBTYPE_FILO_IS( r, i)	          ND_INDEX_SUBTYPE_VALUE_FILO_IS( (r)->Index_Tab[(i)].Type)
+#define ND_INDEX_SUBTYPE_SORTED_IS( r, i)         ND_INDEX_SUBTYPE_VALUE_SORTED_IS( (r)->Index_Tab[(i)].Type)
+#define ND_INDEX_SUBTYPE_UNBALANCED_IS( r, i)     ND_INDEX_SUBTYPE_VALUE_UNBALANCED_IS( (r)->Index_Tab[(i)].Type)
+#define ND_INDEX_SUBTYPE_BALANCED_IS( r, i)       ND_INDEX_SUBTYPE_VALUE_BALANCED_IS( (r)->Index_Tab[(i)].Type)
+
+#define ND_INDEX_SUBTYPE_VALUE_ASCII_GET( v)      ( ND_INDEX_SUBTYPE_VALUE_UNKNOWN_IS( v) ? "UNKNOWN" : ( ND_INDEX_SUBTYPE_VALUE_FIFO_IS( v) ? "FIFO" : ( ND_INDEX_SUBTYPE_VALUE_LIFO_IS( v) ? "LIFO" : ( ND_INDEX_SUBTYPE_VALUE_SORTED_IS( v) ? "SORTED" : ( ND_INDEX_SUBTYPE_VALUE_UNBALANCED_IS( v) ? "UNBALANCED" : ( ND_INDEX_SUBTYPE_VALUE_BALANCED_IS( v) ? "BALANCED" : "???"))))))
+#define ND_INDEX_SUBTYPE_ASCII_GET( r, i)         ND_INDEX_SUBTYPE_VALUE_ASCII_GET( (r)->Index_Tab[(i)].Type)
+
+
+
+/* Commandes du manager */
+
+typedef int  NDT_Command;
+
+#define NDD_CMD_UNKNOWN	        (NDT_Command)0
+#define NDD_CMD_MANAGER_VERSION	(NDT_Command)1
+#define NDD_CMD_INDEX_GET       (NDT_Command)2
+#define NDD_CMD_VALUE_ALLOC     (NDT_Command)3
+#define NDD_CMD_VALUE_FREE      (NDT_Command)4
+#define NDD_CMD_VALUE_COMP      (NDT_Command)5
+#define NDD_CMD_VALUE_ADD       (NDT_Command)6
+#define NDD_CMD_VALUE_REMOVE    (NDT_Command)7
+#define NDD_CMD_VALUE_PRINT     (NDT_Command)8
+#define NDD_CMD_VALUE_FIND      (NDT_Command)9
+#define NDD_CMD_INFO_PRINT      (NDT_Command)10
+
+#define NDD_CMD_USER_TRAVERSE	(NDT_Command)17
+
+
+typedef char  *NDT_Command_Name;
+typedef char  *NDT_Version_Name;
+
+
+
+/* Types de réponse du manager ou code retour des diverses fonctions */
+
+typedef int NDT_Status;
+
+#define ND_ERROR(s)               ((s) <= 0)	/* All negative or 0 status are errors */
+
+#define NDS_OK                     1
+#define NDS_KO                     0
+
+#define NDS_YES                    1
+#define NDS_NO                     0
+
+#define NDS_EQUAL                  1
+#define NDS_GREATER                2
+#define NDS_LOWER                  3
+
+#define NDS_ERRMEM                -1       /* Problème d'allocation mémoire */
+#define NDS_ERRAPI                -2       /* Utilisation incorrecte des API */
+
+
+
+typedef short  NDT_Index_Id;
+typedef short  NDT_Index_Nb;
+
+#define NDD_INDEX_UNKNOWN  (NDT_Index_Id)-1
+#define NDD_INDEX_PRIMARY  (NDT_Index_Id)0
+
+
+
+struct NDT_Root;
+struct NDT_Node;
+
+
+
+/* Pointeur de fonction sur le manager */
+
+#define NDD_MANAGER_NAME_LEN_MAX   64
+#define NDD_MANAGER_NAME_SIZE_MAX  (NDD_MANAGER_NAME_LEN_MAX + 1)
+
+typedef char  *NDT_Manager_Name;
+
+typedef NDT_Status NDT_Manager( struct NDT_Root  *, NDT_Index_Id, struct NDT_Node  *, NDT_Command, va_list);
+
+
+/* Pointeur de fonction sur l'allocateur */
+
+#define NDD_ALLOCATOR_NAME_LEN_MAX   64
+#define NDD_ALLOCATOR_NAME_SIZE_MAX  (NDD_ALLOCATOR_NAME_LEN_MAX + 1)
+
+typedef char  *NDT_Allocator_Name;
+
+typedef NDT_Status  NDT_Allocator( void **, size_t, void *);
+
+
+/* Pointeur de fonction sur le désallocateur */
+
+#define NDD_DESALLOCATOR_NAME_LEN_MAX   64
+#define NDD_DESALLOCATOR_NAME_SIZE_MAX  (NDD_DESALLOCATOR_NAME_LEN_MAX + 1)
+
+typedef char  *NDT_Desallocator_Name;
+
+typedef NDT_Status  NDT_Desallocator( void *, void *);
+
+
+
+
+typedef struct NDT_Index
+{
+	NDT_Index_Type    Type;               /* Type de la structure (liste, arbre ... ) */
+
+	long              Node_Number;        /* Nombre de noeuds dans la structure */
+	long              Min_Depth;          /* Profondeur minimale de l'arbre */
+	long              Max_Depth;          /* Profondeur maximale de l'arbre */
+	long              Max_Dif;            /* Différence maximale autorisée entre la branche la plus courte et la plus longue */
+	long              Nb_Equ;             /* Nombre de réquilibrages réalisés sur l'arbre */
+	struct NDT_Node  *Head;               /* Noeud de tête */
+	struct NDT_Node  *Tail;              /* Noeud de queue */
+	struct NDT_Node  *Save;               /* Pointeur de sauvegarde (utile pour la fonction de restauration) */
+
+} NDT_Index;
+
+
+
+typedef struct NDT_Root
+{
+/*	NDT_Root_Type		  Type;*/				/* Root Structure Type */
+/*	NDT_DataStruct_Type   DS_Type;*/			/* Type de la structure (liste, arbre ... ) */
+
+	NDT_Manager       *Manager_Ptr;									 /* Pointeur sur la fonction manager */
+	char               Manager_Name[NDD_MANAGER_NAME_SIZE_MAX];		 /* Nom de la fonction manager */
+	NDT_Allocator     *Allocator_Ptr;								 /* Pointeur sur la fonction d'allocation */
+	char               Allocator_Name[NDD_ALLOCATOR_NAME_SIZE_MAX];    /* Nom de la fonction d'allocation */
+	NDT_Desallocator  *Desallocator_Ptr;							 /* Pointeur sur la fonction de désallocation */
+	char               Desallocator_Name[NDD_DESALLOCATOR_NAME_SIZE_MAX]; /* Nom de la fonction de désallocation */
+
+	short              Own_Value;              /* Indique si la structure est propriétaire de ses valeurs */
+	void              *User_Ptr;               /* Pointeur utilisable librement par l'utilisateur */
+
+	NDT_Index_Nb       Index_Nb;
+	NDT_Index_Nb       Index_Open_Count;
+	NDT_Index          Index_Tab[1];
+
+} NDT_Root;
+
+
+
+typedef struct NDT_DataStruct
+{
+
+	NDT_Root	  *Root_Ptr;
+
+	NDT_Manager       *Manager_Ptr;            /* Manager function pointer */
+	NDT_Allocator     *Allocator_Ptr;          /* Allocator function pointer */
+	NDT_Desallocator  *Desallocator_Ptr;       /* Desallocator function pointer */
+
+} NDT_DataStruct;
+
+
+
+/* Structure de noeud */
+
+typedef struct NDT_Node
+{
+	NDT_Root         *Root;
+	NDT_Index_Id	  Index;
+	struct NDT_Node	 *Parent;
+	struct NDT_Node	 *Left;
+	struct NDT_Node	 *Right;
+	void		 *Value;
+} NDT_Node;
+
+
+
+typedef int  NDT_Recursive_Mode;
+typedef int  NDT_Recursive_Depth;
+typedef int  NDT_Recursive_Offset;
+
+#define NDD_RECURSIVE_MODE_UNKNOWN	 (NDT_Recursive_Mode)0x00
+#define NDD_RECURSIVE_MODE_PARENT	 (NDT_Recursive_Mode)0x01
+#define NDD_RECURSIVE_MODE_CHILD	 (NDT_Recursive_Mode)0x02
+#define NDD_RECURSIVE_MODE_PARENT_CHILD	 (NDT_Recursive_Mode)0x03
+
+#define ND_RECURSIVE_PARENT_IS(m)	 (m & NDD_RECURSIVE_MODE_PARENT)
+#define ND_RECURSIVE_CHILD_IS(m)	 (m & NDD_RECURSIVE_MODE_CHILD)
+
+#define ND_RECURSIVE_PRINT_OFFSET        8
+
+
+
+/* Définition des alias de l'API */
+
+#ifndef ND_MODE
+#define ND_MODE     0
+#endif
+
+#if ND_MODE == 1 /* API sans vérification des arguments */
+
+#define ND_Library_Open             ND_Library_Open_I
+#define ND_Library_Close            ND_Library_Close_I
+#define ND_Library_StdErr_Set       ND_Library_StdErr_Set_I
+
+#define ND_DataStruct_Open          ND_DataStruct_Open_I
+#define ND_DataStruct_Close         ND_DataStruct_Close_I
+#define ND_DataStruct_Flush         ND_DataStruct_Flush_I
+#define ND_DataStruct_Check         ND_DataStruct_Check_I
+#define ND_DataStruct_Convert       ND_DataStruct_Convert_I
+#define ND_DataStruct_Reorg         ND_DataStruct_Reorg_I
+#define ND_DataStruct_Traverse_V    ND_DataStruct_Traverse_VI
+#define ND_DataStruct_Traverse      ND_DataStruct_Traverse_I
+#define ND_DataStruct_Info_Print    ND_DataStruct_Info_Print_I
+#define ND_DataStruct_Value_Add     ND_DataStruct_Value_Add_I
+#define ND_DataStruct_Value_Remove  ND_DataStruct_Value_Remove_I
+#define ND_DataStruct_Value_Print   ND_DataStruct_Value_Print_I
+#define ND_DataStruct_Value_Find    ND_DataStruct_Value_Find_I
+
+#define ND_Index_Open		    ND_Index_Open_I
+#define ND_Index_Close		    ND_Index_Close_I
+#define ND_Index_Flush		    ND_Index_Flush_I
+#define ND_Index_Check		    ND_Index_Check_I
+#define ND_Index_Convert	    ND_Index_Convert_I
+#define ND_Index_Reorg		    ND_Index_Reorg_I
+#define ND_Index_Traverse_V	    ND_Index_Traverse_VI
+#define ND_Index_Traverse	    ND_Index_Traverse_I
+#define ND_Index_Info_Print	    ND_Index_Info_Print_I
+#define ND_Index_Value_Add	    ND_Index_Value_Add_I
+#define ND_Index_Value_Remove	    ND_Index_Value_Remove_I
+#define ND_Index_Value_Print	    ND_Index_Value_Print_I
+#define ND_Index_Node_Add           ND_Index_Node_Add_I
+#define ND_Index_Node_Remove        ND_Index_Node_Remove_I
+#define ND_Index_Node_First_Get     ND_Index_Node_First_Get_I
+#define ND_Index_Node_Last_Get      ND_Index_Node_Last_Get_I
+#define ND_Index_Node_Next_Get      ND_Index_Node_Next_Get_I
+#define ND_Index_Node_Previous_Get  ND_Index_Node_Previous_Get_I
+#define ND_Index_Node_Find          ND_Index_Node_Find_I
+
+#define ND_Node_Root_Get            ND_Node_Root_Get_I
+
+#define ND_Value_Alloc              ND_Value_Alloc_I
+#define ND_Value_Free               ND_Value_Free_I
+
+#define ND_Manager_Exec_V           ND_Manager_Exec_VI
+#define ND_Manager_Exec             ND_Manager_Exec_I
+#define ND_Allocator_Exec           ND_Allocator_Exec_I
+#define ND_Desallocator_Exec        ND_Desallocator_Exec_I
+
+#else /* API avec vérification des arguments */
+
+#define ND_Library_Open             ND_Library_Open_C
+#define ND_Library_Close            ND_Library_Close_C
+#define ND_Library_StdErr_Set       ND_Library_StdErr_Set_C
+
+#define ND_DataStruct_Open          ND_DataStruct_Open_C
+#define ND_DataStruct_Close         ND_DataStruct_Close_C
+#define ND_DataStruct_Flush         ND_DataStruct_Flush_C
+#define ND_DataStruct_Check         ND_DataStruct_Check_C
+#define ND_DataStruct_Convert       ND_DataStruct_Convert_C
+#define ND_DataStruct_Reorg         ND_DataStruct_Reorg_C
+#define ND_DataStruct_Traverse_V    ND_DataStruct_Traverse_VC
+#define ND_DataStruct_Traverse      ND_DataStruct_Traverse_C
+#define ND_DataStruct_Info_Print    ND_DataStruct_Info_Print_C
+#define ND_DataStruct_Value_Add     ND_DataStruct_Value_Add_C
+#define ND_DataStruct_Value_Remove  ND_DataStruct_Value_Remove_C
+#define ND_DataStruct_Value_Print   ND_DataStruct_Value_Print_C
+#define ND_DataStruct_Value_Find    ND_DataStruct_Value_Find_C
+
+#define ND_Index_Open		    ND_Index_Open_C
+#define ND_Index_Close		    ND_Index_Close_C
+#define ND_Index_Flush		    ND_Index_Flush_C
+#define ND_Index_Check		    ND_Index_Check_C
+#define ND_Index_Convert	    ND_Index_Convert_C
+#define ND_Index_Reorg		    ND_Index_Reorg_C
+#define ND_Index_Traverse_V	    ND_Index_Traverse_VC
+#define ND_Index_Traverse	    ND_Index_Traverse_C
+#define ND_Index_Info_Print	    ND_Index_Info_Print_C
+#define ND_Index_Value_Add	    ND_Index_Value_Add_C
+#define ND_Index_Value_Remove	    ND_Index_Value_Remove_C
+#define ND_Index_Value_Print	    ND_Index_Value_Print_C
+#define ND_Index_Node_Add           ND_Index_Node_Add_C
+#define ND_Index_Node_Remove        ND_Index_Node_Remove_C
+#define ND_Index_Node_First_Get     ND_Index_Node_First_Get_C
+#define ND_Index_Node_Last_Get      ND_Index_Node_Last_Get_C
+#define ND_Index_Node_Next_Get      ND_Index_Node_Next_Get_C
+#define ND_Index_Node_Previous_Get  ND_Index_Node_Previous_Get_C
+#define ND_Index_Node_Find          ND_Index_Node_Find_C
+
+#define ND_Node_Root_Get            ND_Node_Root_Get_C
+
+#define ND_Value_Alloc              ND_Value_Alloc_C
+#define ND_Value_Free               ND_Value_Free_C
+
+#define ND_Manager_Exec_V           ND_Manager_Exec_VC
+#define ND_Manager_Exec             ND_Manager_Exec_C
+#define ND_Allocator_Exec           ND_Allocator_Exec_C
+#define ND_Desallocator_Exec        ND_Desallocator_Exec_C
+
+#endif
+
+
+
+/*------------------------------------------------------------------------------*/
+
+#	if defined(_WIN32) && !defined(LIBNODE_STATIC)
+#		ifndef _LIBNODE_C_
+#			define NDD_DLL_API __declspec(dllimport)
+#		else
+#			define NDD_DLL_API __declspec(dllexport)
+#		endif
+#	else
+#		define NDD_DLL_API
+#	endif
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Initialisation du contexte de la librairie                                   */
+/*------------------------------------------------------------------------------*/
+NDD_DLL_API NDT_Status  ND_Library_Open_I ( int Debug_Mode );
+NDD_DLL_API NDT_Status  ND_Library_Open_C ( int Debug_Mode );
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Fermeture du contexte de la librairie                                        */
+/*------------------------------------------------------------------------------*/
+NDD_DLL_API NDT_Status  ND_Library_Close_I( void);
+NDD_DLL_API NDT_Status  ND_Library_Close_C( void);
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Définition de la sortie standard des messages d'erreur de la librairie       */
+/*------------------------------------------------------------------------------*/
+NDD_DLL_API NDT_Status  ND_Library_StdErr_Set_I( FILE  *);
+NDD_DLL_API NDT_Status  ND_Library_StdErr_Set_C( FILE  *);
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Création d'une nouvelle structure de données                                 */
+/*------------------------------------------------------------------------------*/
+/* (O) Root: adresse d'un pointeur sur la racine de la nouvelle structure       */
+/* (I) Type: type de la structure.de données (liste ou arbre binaire)           */
+/* (I) Allocator: pointeur vers la fonction d'allocation                        */
+/* (I) Desallocator: pointeur vers la fonction de désallocation                 */
+/* (I) Data : pointeur de données utiles à l'allocateur                         */
+/* (I) Own_Value : indique si la structure est propriétaire de ses valeurs      */
+/*------------------------------------------------------------------------------*/
+NDD_DLL_API NDT_Status  ND_DataStruct_Open_I( NDT_Root  **, NDT_Index_Nb, NDT_Index_Type  *, NDT_Manager_Name, NDT_Manager  *, NDT_Allocator_Name, NDT_Allocator  *, NDT_Desallocator_Name, NDT_Desallocator  *, short, void  *);
+NDD_DLL_API NDT_Status  ND_DataStruct_Open_C( NDT_Root  **, NDT_Index_Nb, NDT_Index_Type  *, NDT_Manager_Name, NDT_Manager  *, NDT_Allocator_Name, NDT_Allocator  *, NDT_Desallocator_Name, NDT_Desallocator  *, short, void  *);
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Destruction d'une structure de données                                       */
+/*------------------------------------------------------------------------------*/
+/* (O) Root: pointeur sur la racine de la structure de données                  */
+/*------------------------------------------------------------------------------*/
+NDD_DLL_API NDT_Status  ND_DataStruct_Close_I( NDT_Root  *);
+NDD_DLL_API NDT_Status  ND_DataStruct_Close_C( NDT_Root  *);
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Destruction d'une structure de données                                       */
+/*------------------------------------------------------------------------------*/
+/* (O) Root: pointeur sur la racine de la structure de données                  */
+/*------------------------------------------------------------------------------*/
+NDD_DLL_API NDT_Status  ND_DataStruct_Flush_I( NDT_Root  *);
+NDD_DLL_API NDT_Status  ND_DataStruct_Flush_C( NDT_Root  *);
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Function de réparation d'une structure :                                     */
+/*  - vérifie que tous les noeuds sont correctement liés les uns aux autres     */
+/*  - corrige les informations statistiques de la racine                        */
+/*------------------------------------------------------------------------------*/
+/* (I) Root         : pointeur sur la racine de la structure                    */
+/* (O) Nb_Detected  : pointeur sur le nombre d'erreurs                          */
+/* (O) Nb_Corrected : pointeur sur le nombre d'erreurs                          */
+/* (I) Out          : flux de sortie du rapport                                 */
+/*------------------------------------------------------------------------------*/
+NDD_DLL_API NDT_Status  ND_DataStruct_Check_I( NDT_Root  *, int  *, int  *, FILE  *);
+NDD_DLL_API NDT_Status  ND_DataStruct_Check_C( NDT_Root  *, int  *, int  *, FILE  *);
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Réorganisation d'une structure de données :                                  */
+/*      - ordonnancement d'une liste non ordonnée                               */
+/*      - réquilibrage d'un arbre non auto-équilibré                            */
+/*------------------------------------------------------------------------------*/
+/* (I) Root: pointeur sur la racine de la structure de données                  */
+/*------------------------------------------------------------------------------*/
+NDD_DLL_API NDT_Status  ND_DataStruct_Reorg_I( NDT_Root  *);
+NDD_DLL_API NDT_Status  ND_DataStruct_Reorg_C( NDT_Root  *);
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Conversion d'une structure de données d'un type en un autre                  */
+/*------------------------------------------------------------------------------*/
+/* (I) Root: pointeur sur la racine de la structure de données                  */
+/* (I) Target_Type: type de structure cible                                     */
+/*------------------------------------------------------------------------------*/
+NDD_DLL_API NDT_Status  ND_DataStruct_Convert_I( NDT_Root  *, NDT_Index_Type  *);
+NDD_DLL_API NDT_Status  ND_DataStruct_Convert_C( NDT_Root  *, NDT_Index_Type  *);
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Parcours de tous les noeuds d'une structure de données et exécution d'une    */
+/* commande sur chacun d'eux                                                    */
+/*------------------------------------------------------------------------------*/
+/* (I) Root: pointeur sur la racine de la structure de données                  */
+/* (I) Command: Commande à exécuter sur chaque noeud traversé                   */
+/* (I) Data: pointeur de données utilisateur                                    */
+/*------------------------------------------------------------------------------*/
+NDD_DLL_API NDT_Status  ND_DataStruct_Traverse_VI( NDT_Root  *, NDT_Command, va_list);
+NDD_DLL_API NDT_Status  ND_DataStruct_Traverse_VC( NDT_Root  *, NDT_Command, va_list);
+NDD_DLL_API NDT_Status  ND_DataStruct_Traverse_I(  NDT_Root  *, NDT_Command, ...);
+NDD_DLL_API NDT_Status  ND_DataStruct_Traverse_C(  NDT_Root  *, NDT_Command, ...);
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Affichage d'informations sur une structure de données                        */
+/*------------------------------------------------------------------------------*/
+/* (I) Root: pointeur sur la racine de la structure de données                  */
+/* (I) Out : flux de sortie                                                     */
+/*------------------------------------------------------------------------------*/
+NDD_DLL_API NDT_Status  ND_DataStruct_Info_Print_I( FILE  *, NDT_Root  *, NDT_Recursive_Mode, NDT_Recursive_Depth, NDT_Recursive_Offset);
+NDD_DLL_API NDT_Status  ND_DataStruct_Info_Print_C( FILE  *, NDT_Root  *, NDT_Recursive_Mode, NDT_Recursive_Depth, NDT_Recursive_Offset);
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Ajout d'une valeur à une structure de données                                */
+/*------------------------------------------------------------------------------*/
+/* (I) Root: pointeur sur la racine de la structure de données                  */
+/* (I) Value: pointeur sur la valeur à ajouter                                  */
+/*------------------------------------------------------------------------------*/
+NDD_DLL_API NDT_Status  ND_DataStruct_Value_Add_I( NDT_Root  *, void  *);
+NDD_DLL_API NDT_Status  ND_DataStruct_Value_Add_C( NDT_Root  *, void  *);
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Suppression du premier noeud correspondant à une valeur donnée               */
+/*------------------------------------------------------------------------------*/
+/* (I) Root            : pointeur sur la racine de la structure de données      */
+/* (I) Reference_Value : pointeur sur la valeur de référence                    */
+/* (I) Removed_Value   : adresse d'un pointeur sur la valeur supprimée          */
+/*------------------------------------------------------------------------------*/
+NDD_DLL_API NDT_Status  ND_DataStruct_Value_Remove_I( NDT_Root  *, void  *);
+NDD_DLL_API NDT_Status  ND_DataStruct_Value_Remove_C( NDT_Root  *, void  *);
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Affichage de la valeur de tous les noeuds d'une structure de données         */
+/*------------------------------------------------------------------------------*/
+/* (I) Root: pointeur sur la racine de la structure de données                  */
+/* (I) Out : flux de sortie                                                     */
+/*------------------------------------------------------------------------------*/
+NDD_DLL_API NDT_Status  ND_DataStruct_Value_Print_VI( FILE  *, NDT_Root  *, NDT_Recursive_Mode, NDT_Recursive_Depth, NDT_Recursive_Offset, va_list);
+NDD_DLL_API NDT_Status  ND_DataStruct_Value_Print_I(  FILE  *, NDT_Root  *, NDT_Recursive_Mode, NDT_Recursive_Depth, NDT_Recursive_Offset, ...);
+NDD_DLL_API NDT_Status  ND_DataStruct_Value_Print_C(  FILE  *, NDT_Root  *, NDT_Recursive_Mode, NDT_Recursive_Depth, NDT_Recursive_Offset, ...);
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Recherche un noeud à partir d'une valeur                                     */
+/*------------------------------------------------------------------------------*/
+/* (I) Root : pointeur sur la racine de l'abre                                  */
+/* (O) Node : pointeur sur le noeud à récuperer                                 */
+/* (I) Value  : pointeur sur la valeur à rechercher                             */
+/* (I) Data  : pointeur de données                                              */
+/*------------------------------------------------------------------------------*/
+
+NDD_DLL_API NDT_Status  ND_DataStruct_Value_Find_VI( void  **, NDT_Root  *, void  *, va_list);
+NDD_DLL_API NDT_Status  ND_DataStruct_Value_Find_VC( void  **, NDT_Root  *, void  *, va_list);
+NDD_DLL_API NDT_Status  ND_DataStruct_Value_Find_I(  void  **, NDT_Root  *, void  *, ...);
+NDD_DLL_API NDT_Status  ND_DataStruct_Value_Find_C(  void  **, NDT_Root  *, void  *, ...);
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Create a new index (not yet implemented !)                                   */
+/*------------------------------------------------------------------------------*/
+/* (O) Root: adresse d'un pointeur sur la racine de la nouvelle structure       */
+/* (I) Type: type de la structure.de données (liste ou arbre binaire)           */
+/* (I) Allocator: pointeur vers la fonction d'allocation                        */
+/* (I) Desallocator: pointeur vers la fonction de désallocation                 */
+/* (I) Data : pointeur de données utiles à l'allocateur                         */
+/* (I) Own_Value : indique si la structure est propriétaire de ses valeurs      */
+/*------------------------------------------------------------------------------*/
+NDD_DLL_API NDT_Status  ND_Index_Open_I( NDT_Root  *, NDT_Index_Id, NDT_Index_Type);
+NDD_DLL_API NDT_Status  ND_Index_Open_C( NDT_Root  *, NDT_Index_Id, NDT_Index_Type);
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Remove an Index (not yet implemented !)                                      */
+/*------------------------------------------------------------------------------*/
+/* (O) Root: pointeur sur la racine de la structure de données                  */
+/*------------------------------------------------------------------------------*/
+NDD_DLL_API NDT_Status  ND_Index_Close_I( NDT_Root  *, NDT_Index_Id);
+NDD_DLL_API NDT_Status  ND_Index_Close_C( NDT_Root  *, NDT_Index_Id);
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Remove an Index (not yet implemented !)                                      */
+/*------------------------------------------------------------------------------*/
+/* (O) Root: pointeur sur la racine de la structure de données                  */
+/*------------------------------------------------------------------------------*/
+NDD_DLL_API NDT_Status  ND_Index_Flush_I( NDT_Root  *, NDT_Index_Id);
+NDD_DLL_API NDT_Status  ND_Index_Flush_C( NDT_Root  *, NDT_Index_Id);
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Function de réparation d'une structure :                                     */
+/*  - vérifie que tous les noeuds sont correctement liés les uns aux autres     */
+/*  - corrige les informations statistiques de la racine                        */
+/*------------------------------------------------------------------------------*/
+/* (I) Root         : pointeur sur la racine de la structure                    */
+/* (O) Nb_Detected  : pointeur sur le nombre d'erreurs                          */
+/* (O) Nb_Corrected : pointeur sur le nombre d'erreurs                          */
+/* (I) Out          : flux de sortie du rapport                                 */
+/*------------------------------------------------------------------------------*/
+NDD_DLL_API NDT_Status  ND_Index_Check_I( NDT_Root  *, NDT_Index_Id, int  *, int  *, FILE  *);
+NDD_DLL_API NDT_Status  ND_Index_Check_C( NDT_Root  *, NDT_Index_Id, int  *, int  *, FILE  *);
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Conversion d'une structure de données d'un type en un autre                  */
+/*------------------------------------------------------------------------------*/
+/* (I) Root: pointeur sur la racine de la structure de données                  */
+/* (I) Target_Type: type de structure cible                                     */
+/*------------------------------------------------------------------------------*/
+NDD_DLL_API NDT_Status  ND_Index_Convert_I ( NDT_Root  *, NDT_Index_Id, NDT_Index_Type);
+NDD_DLL_API NDT_Status  ND_Index_Convert_C ( NDT_Root  *, NDT_Index_Id, NDT_Index_Type);
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Réorganisation d'une structure de données :                                  */
+/*      - ordonnancement d'une liste non ordonnée                               */
+/*      - réquilibrage d'un arbre non auto-équilibré                            */
+/*------------------------------------------------------------------------------*/
+/* (I) Root: pointeur sur la racine de la structure de données                  */
+/*------------------------------------------------------------------------------*/
+NDD_DLL_API NDT_Status  ND_Index_Reorg_I( NDT_Root  *, NDT_Index_Id);
+NDD_DLL_API NDT_Status  ND_Index_Reorg_C( NDT_Root  *, NDT_Index_Id);
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Parcours de tous les noeuds d'une structure de données et exécution d'une    */
+/* commande sur chacun d'eux                                                    */
+/*------------------------------------------------------------------------------*/
+/* (I) Root: pointeur sur la racine de la structure de données                  */
+/* (I) Command: Commande à exécuter sur chaque noeud traversé                   */
+/* (I) Data: pointeur de données utilisateur                                    */
+/*------------------------------------------------------------------------------*/
+NDD_DLL_API NDT_Status  ND_Index_Traverse_VI( NDT_Root  *, NDT_Index_Id, NDT_Command, va_list);
+NDD_DLL_API NDT_Status  ND_Index_Traverse_VC( NDT_Root  *, NDT_Index_Id, NDT_Command, va_list);
+NDD_DLL_API NDT_Status  ND_Index_Traverse_I(  NDT_Root  *, NDT_Index_Id, NDT_Command, ...);
+NDD_DLL_API NDT_Status  ND_Index_Traverse_C(  NDT_Root  *, NDT_Index_Id, NDT_Command, ...);
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Parcours de tous les noeuds d'une structure de données et exécution d'une    */
+/* commande sur chacun d'eux                                                    */
+/*------------------------------------------------------------------------------*/
+/* (I) Root: pointeur sur la racine de la structure de données                  */
+/* (I) Command: Commande à exécuter sur chaque noeud traversé                   */
+/* (I) Data: pointeur de données utilisateur                                    */
+/*------------------------------------------------------------------------------*/
+NDD_DLL_API NDT_Status  ND_Index_Info_Print_I( FILE  *, NDT_Root  *, NDT_Index_Id, NDT_Recursive_Mode, NDT_Recursive_Depth, NDT_Recursive_Offset);
+NDD_DLL_API NDT_Status  ND_Index_Info_Print_C( FILE  *, NDT_Root  *, NDT_Index_Id, NDT_Recursive_Mode, NDT_Recursive_Depth, NDT_Recursive_Offset);
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Ajout d'une valeur à une structure de données                                */
+/*------------------------------------------------------------------------------*/
+/* (I) Root: pointeur sur la racine de la structure de données                  */
+/* (I) Value: pointeur sur la valeur à ajouter                                  */
+/*------------------------------------------------------------------------------*/
+NDD_DLL_API NDT_Status  ND_Index_Value_Add_I( NDT_Root  *, NDT_Index_Id, void  *);
+NDD_DLL_API NDT_Status  ND_Index_Value_Add_C( NDT_Root  *, NDT_Index_Id, void  *);
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Suppression du premier noeud correspondant à une valeur donnée               */
+/*------------------------------------------------------------------------------*/
+/* (I) Root            : pointeur sur la racine de la structure de données      */
+/* (I) Reference_Value : pointeur sur la valeur de référence                    */
+/* (I) Removed_Value   : adresse d'un pointeur sur la valeur supprimée          */
+/*------------------------------------------------------------------------------*/
+NDD_DLL_API NDT_Status  ND_Index_Value_Remove_I( NDT_Root  *, NDT_Index_Id, void  *);
+NDD_DLL_API NDT_Status  ND_Index_Value_Remove_C( NDT_Root  *, NDT_Index_Id, void  *);
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Affichage de la valeur de tous les noeuds d'une structure de données         */
+/*------------------------------------------------------------------------------*/
+/* (I) Root: pointeur sur la racine de la structure de données                  */
+/* (I) Out : flux de sortie                                                     */
+/*------------------------------------------------------------------------------*/
+NDD_DLL_API NDT_Status  ND_Index_Value_Print_VI( FILE  *, NDT_Root  *, NDT_Index_Id, NDT_Recursive_Mode, NDT_Recursive_Depth, NDT_Recursive_Offset, va_list);
+NDD_DLL_API NDT_Status  ND_Index_Value_Print_I(  FILE  *, NDT_Root  *, NDT_Index_Id, NDT_Recursive_Mode, NDT_Recursive_Depth, NDT_Recursive_Offset, ...);
+NDD_DLL_API NDT_Status  ND_Index_Value_Print_C(  FILE  *, NDT_Root  *, NDT_Index_Id, NDT_Recursive_Mode, NDT_Recursive_Depth, NDT_Recursive_Offset, ...);
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Ajout d'un noeud à une structure de données                                  */
+/*------------------------------------------------------------------------------*/
+/* (I) Root: pointeur sur la racine de la structure de données                  */
+/* (I) Node: pointeur sur le noeud à ajouter                                    */
+/*------------------------------------------------------------------------------*/
+NDD_DLL_API NDT_Status  ND_Index_Node_Add_I( NDT_Root  *, NDT_Index_Id, NDT_Node  *);
+NDD_DLL_API NDT_Status  ND_Index_Node_Add_C( NDT_Root  *, NDT_Index_Id, NDT_Node  *);
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Suppression d'un noeud dans une structure de données                         */
+/*------------------------------------------------------------------------------*/
+/* (I) Node: pointeur sur le noeud à supprimer de la structure de données       */
+/*------------------------------------------------------------------------------*/
+NDD_DLL_API NDT_Status  ND_Index_Node_Remove_I( NDT_Node  *);
+NDD_DLL_API NDT_Status  ND_Index_Node_Remove_C( NDT_Node  *);
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Récupération du premier noeud d'une structure                                */
+/*------------------------------------------------------------------------------*/
+/* (I) Root : pointeur sur la racine dont on cherche le premier noeud           */
+/* (O) Node : pointeur sur le noeud à récupérer                                 */
+/*------------------------------------------------------------------------------*/
+NDD_DLL_API NDT_Status  ND_Index_Node_First_Get_I( NDT_Node  **, NDT_Root  *, NDT_Index_Id);
+NDD_DLL_API NDT_Status  ND_Index_Node_First_Get_C( NDT_Node  **, NDT_Root  *, NDT_Index_Id);
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Récupération du dernier noeud d'une structure                                */
+/*------------------------------------------------------------------------------*/
+/* (I) Root: pointeur sur la racine dont on cherche le dernier noeud            */
+/* (O) Node : pointeur sur le noeud à récupérer                                 */
+/*------------------------------------------------------------------------------*/
+NDD_DLL_API NDT_Status  ND_Index_Node_Last_Get_I( NDT_Node  **, NDT_Root  *, NDT_Index_Id);
+NDD_DLL_API NDT_Status  ND_Index_Node_Last_Get_C( NDT_Node  **, NDT_Root  *, NDT_Index_Id);
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Récupération du noeud suivant                                                */
+/*------------------------------------------------------------------------------*/
+/* (I) Node: pointeur sur le noeud dont on cherche le suivant                   */
+/* (O) Next_Node : pointeur sur le noeud suivant                                */
+/*------------------------------------------------------------------------------*/
+NDD_DLL_API NDT_Status  ND_Index_Node_Next_Get_I( NDT_Node  **, NDT_Node  *);
+NDD_DLL_API NDT_Status  ND_Index_Node_Next_Get_C( NDT_Node  **, NDT_Node  *);
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Récupération du noeud précédant                                              */
+/*------------------------------------------------------------------------------*/
+/* (I) Node: pointeur sur le noeud dont on cherche le précédant                 */
+/* (O) Prev_Node : pointeur sur le noeud précédant                              */
+/*------------------------------------------------------------------------------*/
+NDD_DLL_API NDT_Status  ND_Index_Node_Previous_Get_I( NDT_Node  **, NDT_Node  *);
+NDD_DLL_API NDT_Status  ND_Index_Node_Previous_Get_C( NDT_Node  **, NDT_Node  *);
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Recherche un noeud à partir d'une valeur                                     */
+/*------------------------------------------------------------------------------*/
+/* (I) Root : pointeur sur la racine de l'abre                                  */
+/* (O) Node : pointeur sur le noeud à récuperer                                 */
+/* (I) Value  : pointeur sur la valeur à rechercher                             */
+/* (I) Data  : pointeur de données                                              */
+/*------------------------------------------------------------------------------*/
+NDD_DLL_API NDT_Status  ND_Index_Node_Find_VI( NDT_Node  **, NDT_Root  *, NDT_Index_Id, void  *, va_list);
+NDD_DLL_API NDT_Status  ND_Index_Node_Find_VC( NDT_Node  **, NDT_Root  *, NDT_Index_Id, void  *, va_list);
+NDD_DLL_API NDT_Status  ND_Index_Node_Find_I(  NDT_Node  **, NDT_Root  *, NDT_Index_Id, void  *, ...);
+NDD_DLL_API NDT_Status  ND_Index_Node_Find_C(  NDT_Node  **, NDT_Root  *, NDT_Index_Id, void  *, ...);
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Récupération de la racine d'une structure                                    */
+/*------------------------------------------------------------------------------*/
+/* (O) Root: Adresse du pointeur sur la racine à récupérer                      */
+/* (I) Node: pointeur sur le noeud dont on cherche la racine                    */
+/*------------------------------------------------------------------------------*/
+NDD_DLL_API NDT_Status  ND_Node_Root_Get_I( NDT_Root  **, NDT_Node  *);
+NDD_DLL_API NDT_Status  ND_Node_Root_Get_C( NDT_Root  **, NDT_Node  *);
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Allocation d'une valeur d'une structure de données                           */
+/*------------------------------------------------------------------------------*/
+/* (I) Root  : pointeur sur la racine de la structure de données                */
+/* (O) Value : adresse d'un pointeur sur la valeur à allouer                    */
+/* (I) ...   : arguments relatifs à l'allocation de la valeur                   */
+/*------------------------------------------------------------------------------*/
+NDD_DLL_API NDT_Status  ND_Value_Alloc_I( NDT_Root  *, void  **, ...);
+NDD_DLL_API NDT_Status  ND_Value_Alloc_C( NDT_Root  *, void  **, ...);
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Désallocation d'une valeur d'une structure de données                        */
+/*------------------------------------------------------------------------------*/
+/* (I) Root: pointeur sur la racine de la structure de données                  */
+/* (I) Value: pointeur sur la valeur à désallouer                               */
+/*------------------------------------------------------------------------------*/
+NDD_DLL_API NDT_Status  ND_Value_Free_I( NDT_Root  *, void  *);
+NDD_DLL_API NDT_Status  ND_Value_Free_C( NDT_Root  *, void  *);
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Exécution d'une fonction Manager dont le nom est passé en paramètre          */
+/*------------------------------------------------------------------------------*/
+/* (I) Function : nom de la fonction manager à exécuter                         */
+/*------------------------------------------------------------------------------*/
+NDD_DLL_API NDT_Status  ND_Manager_Exec_VI( NDT_Root  *, NDT_Index_Id, NDT_Node  *, NDT_Command, va_list);
+NDD_DLL_API NDT_Status  ND_Manager_Exec_VC( NDT_Root  *, NDT_Index_Id, NDT_Node  *, NDT_Command, va_list);
+NDD_DLL_API NDT_Status  ND_Manager_Exec_I(  NDT_Root  *, NDT_Index_Id, NDT_Node  *, NDT_Command, ...);
+NDD_DLL_API NDT_Status  ND_Manager_Exec_C(  NDT_Root  *, NDT_Index_Id, NDT_Node  *, NDT_Command, ...);
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Exécution d'une fonction d'allocation dont le nom est passé en paramètre     */
+/*------------------------------------------------------------------------------*/
+/* (I) Function : nom de la fonction à exécuter                                 */
+/* (O) Ptr : adresse d'un pointeur sur la zone à allouer                        */
+/* (I) Size : taille de la zone à allouer                                       */
+/* (I) Data : pointeur de données utiles à l'allocateur                         */
+/*------------------------------------------------------------------------------*/
+NDD_DLL_API NDT_Status  ND_Allocator_Exec_I( void  **, size_t, NDT_Allocator_Name, NDT_Allocator  *, void  *);
+NDD_DLL_API NDT_Status  ND_Allocator_Exec_C( void  **, size_t, NDT_Allocator_Name, NDT_Allocator  *, void  *);
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Exécution d'une fonction de désallocation le dont nom est passé en paramètre */
+/*------------------------------------------------------------------------------*/
+/* (I) Function : nom de la fonction à exécuter                                 */
+/* (I) Function : nom de la fonction à exécuter                                 */
+/* (I) Ptr : adresse de la zone à désallouer                                    */
+/* (I) Data : pointeur de données utiles au désallocateur                       */
+/*------------------------------------------------------------------------------*/
+NDD_DLL_API NDT_Status  ND_Desallocator_Exec_I( void  *, NDT_Desallocator_Name, NDT_Desallocator  *, void  *);
+NDD_DLL_API NDT_Status  ND_Desallocator_Exec_C( void  *, NDT_Desallocator_Name, NDT_Desallocator  *, void  *);
+
+
+
+#   ifdef __cplusplus
+}
+#   endif
+
+#endif
diff --git a/src/libnode/src/Makefile b/src/libnode/src/Makefile
new file mode 100644
index 0000000..bbd7722
--- /dev/null
+++ b/src/libnode/src/Makefile
@@ -0,0 +1,42 @@
+#------------------------------------------------------------------------------
+# Local Makefile
+#------------------------------------------------------------------------------
+# $Workfile:   Makefile  $                                                     
+#------------------------------------------------------------------------------
+# $Author: agibert $                                                        
+# $Date: 2008/11/12 02:25:23 $                                             
+# $Revision: 1.1 $                                                         
+# $Label:  $                                                           
+#------------------------------------------------------------------------------
+
+
+
+
+
+#------------------------------------------------------------------------------
+# Var include
+#------------------------------------------------------------------------------
+
+include ../../Makefile_var.mk
+
+
+
+#------------------------------------------------------------------------------
+# Variables
+#------------------------------------------------------------------------------
+
+TARGET=		libnode$(SHLIB_SUFFIX)
+
+OBJ=		libnode.o
+
+#EXTRA_INC=	
+
+#EXTRA_LIB=	
+
+
+
+#------------------------------------------------------------------------------
+# Rule include
+#------------------------------------------------------------------------------
+
+include ../../Makefile_rule.mk
diff --git a/src/libnode/src/libnode.c b/src/libnode/src/libnode.c
new file mode 100644
index 0000000..3145883
--- /dev/null
+++ b/src/libnode/src/libnode.c
@@ -0,0 +1,5819 @@
+/*----------------------------------------------------------------------------*/
+/* $Workfile:   libnode.c  $                                                  */
+/*----------------------------------------------------------------------------*/
+/* $Author: agibert $                                                      */
+/* $Date: 2008/11/12 02:25:23 $                                           */
+/* $Revision: 1.1 $                                                        */
+/* $Label:  $                                                         */
+/*----------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------------*/
+/* %RCSfile: libnode.c,v %							   */
+/*---------------------------------------------------------------------------------*/
+/* %Revision: 2.15 %								   */
+/* %Name: libnode-2_1_0-1 %									   */
+/* %Date: 2005/01/19 23:59:41 %							   */
+/* %Author: agibert %								   */
+/*---------------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------------*/
+/* This file is part of LibNode                                                    */
+/*                                                                                 */
+/*    LibNode is free software; you can redistribute it and/or modify              */
+/*    it under the terms of the GNU Lesser General Public Licence as published by  */
+/*    the Free Software Foundation; either version 2.1 of the License, or          */
+/*    (at your option) any later version.                                          */
+/*                                                                                 */
+/*    LibNode is distributed in the hope that it will be useful,                   */
+/*    but WITHOUT ANY WARRANTY; without even the implied warranty of               */
+/*    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                */
+/*    GNU Lesser General Public License for more details.                          */
+/*                                                                                 */
+/*    You should have received a copy of the GNU Lesser General Public License     */
+/*    along with LibNode; if not, write to the Free Software                       */
+/*    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA    */
+/*---------------------------------------------------------------------------------*/
+
+
+
+
+
+#define _LIBNODE_C_
+
+#include <libnode.h>
+
+#ifdef _LIBVER_SUPPORT
+VER_INFO_EXPORT( libnode, "%Revision: 2.15 %", "%Name: libnode-2_1_0-1 %", __FILE__, "%Author: agibert %")
+#endif
+
+char IMRG_ND_WHAT_IDENT[] = "@(#) VERSIONIMR: $Label:  $   $Date: 2008/11/12 02:25:23 $   $Workfile:   libnode.c  $";
+
+
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/*------------------------------------------------------------------------------*/
+/*                      Node Manager Template                                   */
+/*------------------------------------------------------------------------------*/
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_Default_Manager( NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id, NDT_Node  *Node_Ptr, NDT_Command  Command, va_list  Args)
+{
+    NDT_Command_Name  Command_Name;
+
+
+    switch( Command)
+    {
+        case NDD_CMD_MANAGER_VERSION:
+        {
+            NDT_Version_Name  *Version_Name_Ptr = (NDT_Version_Name  *)va_arg( Args, NDT_Version_Name  *);
+
+
+            Command_Name = "NDD_CMD_MANAGER_VERSION";
+
+            *Version_Name_Ptr = "%Revision: 2.15 %   %Name: libnode-2_1_0-1 %   %Date: 2005/01/19 23:59:41 %   %Author: agibert %";
+
+            return( NDS_OK);
+	}
+
+        case NDD_CMD_INDEX_GET:
+        {
+            /*
+	      NDT_Index_Id  *Reply_Index_Id_Ptr = (NDT_Index_Id  *)va_arg( Args, NDT_Index_Id  *);
+	      NDT_Command   *Reply_Command_Ptr  =  (NDT_Command  *)va_arg( Args, NDT_Command  *);
+	      NDT_Command    Cmd                =     (NDT_Command)va_arg( Args, NDT_Command);
+	      void          *Value_ptr          =         (void  *)va_arg( Args, void  *);
+            */
+            NDT_Index_Id  *Reply_Index_Id_Ptr = (NDT_Index_Id  *)va_arg( Args, NDT_Index_Id  *);
+            NDT_Command   *Reply_Command_Ptr  =  (NDT_Command  *)va_arg( Args, NDT_Command  *);
+            NDT_Command    Cmd                =     (NDT_Command)va_arg( Args, NDT_Command);
+            void          *Value_ptr          =         (void  *)va_arg( Args, void  *);
+
+
+            Command_Name = "NDD_CMD_INDEX_GET";
+
+            switch(Cmd)
+            {
+                /*
+		  case NDT_CMD_SOME_USER_CMD:
+		  {
+		  *Reply_Index_Id_Ptr = 0;
+		  *Reply_Command_Ptr = NDD_CMD_SOME_OTHER_CMD;
+		  break;
+		  }
+
+		  ...
+                */
+
+                default:
+                {
+		    *Reply_Index_Id_Ptr = Index_Id;
+		    *Reply_Command_Ptr = Cmd;
+		    break;
+		}
+	    }
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_ALLOC:
+        {
+            /*
+	      void       **Value_Ptr_Ptr =  (void  **)va_arg( Args, void  **);
+	      va_list      user_args	   =   (va_list)va_arg( Args, va_list);
+	      user_type    user_data	   = (user_type)va_arg( user_args, user_type);
+	      ... =       (...)va_arg( user_args, ...);
+            */
+
+
+            Command_Name = "NDD_CMD_VALUE_ALLOC";
+
+            /*
+	      if( ( *Value_Ptr_Ptr = (void  *)malloc( sizeof(void))) == NULL)
+	      {
+	      return(NDS_ERRMEM);
+	      }
+	      else
+	      {
+	      ...
+
+	      return( NDS_OK);
+	      }
+            */
+        }
+
+        case NDD_CMD_VALUE_FREE:
+        {
+            /*
+	      void       *Value_Ptr =   (void  *)va_arg( Args, void  *);
+	      va_list     user_args =   (va_list)va_arg( Args, va_list);
+	      user_type   user_data = (user_type)va_arg( user_args, user_type);
+	      ... =       (...)va_arg( user_args, ...);
+            */
+
+
+            Command_Name = "NDD_CMD_VALUE_FREE";
+
+	    /*
+	      free( Value_Ptr);
+
+	      return( NDS_OK);
+	    */
+        }
+
+        case NDD_CMD_VALUE_COMP:
+        {
+            /*
+	      void       *Value1_Ptr =   (void  *)va_arg( Args, void  *);
+	      void       *Value2_Ptr =   (void  *)va_arg( Args, void  *);
+	      va_list     user_args  =   (va_list)va_arg( Args, va_list);
+	      user_type   user_data  = (user_type)va_arg( user_args, user_type);
+	      ... =       (...)va_arg( user_args, ...);
+            */
+
+
+            Command_Name = "NDD_CMD_VALUE_COMP";
+
+            /*
+	      switch( Index_Id)
+	      {
+	      case 0:
+	      {
+	      int	 rc;
+
+
+	      rc = strcmp( Value1_Ptr->..., Value2_Ptr->...);
+
+	      if( rc < 0)
+	      {
+	      return(NDS_LOWER);
+	      }
+	      else
+	      {
+	      if( rc > 0)
+	      {
+	      return(NDS_GREATER);
+	      }
+	      else
+	      {
+	      return(NDS_EQUAL);
+	      }
+	      }
+	      }
+
+	      case 1:
+	      {
+	      int  val1 = atoi(Value1_Ptr->...);
+	      int  val2 = atoi(Value2_Ptr->...);
+
+
+	      if( val1 < val2)
+	      {
+	      return(NDS_LOWER);
+	      }
+	      else
+	      {
+	      if( val1 > val2)
+	      {
+	      return(NDS_GREATER);
+	      }
+	      else
+	      {
+	      return(NDS_EQUAL);
+	      }
+	      }
+	      }
+
+	      case 2:
+	      {
+	      ...
+	      }
+
+	      default:
+	      {
+	      printf( "Unknown COMP idx (%d) !\n", Index_Id);
+	      return( NDS_KO);
+	      }
+	      }
+
+	      return( NDS_OK);
+            */
+        }
+
+        case NDD_CMD_VALUE_ADD:
+        {
+            /*
+	      void       *Value_Ptr =   (void  *)va_arg( Args, void  *);
+	      va_list     user_args =   (va_list)va_arg( Args, va_list);
+	      user_type   user_data = (user_type)va_arg( user_args, user_type);
+	      ... =       (...)va_arg( user_args, ...);
+            */
+
+
+            Command_Name = "NDD_CMD_VALUE_ADD";
+
+	    /*
+	      return( NDS_OK);
+	    */
+        }
+
+        case NDD_CMD_VALUE_REMOVE:
+        {
+            /*
+	      void       *Value_Ptr =   (void  *)va_arg( Args, void  *);
+	      va_list     user_args =   (va_list)va_arg( Args, va_list);
+	      user_type   user_data = (user_type)va_arg( user_args, user_type);
+	      ... =       (...)va_arg( user_args, ...);
+            */
+
+
+            Command_Name = "NDD_CMD_VALUE_REMOVE";
+	    /*
+	      return( NDS_OK);
+            */
+        }
+
+        case NDD_CMD_VALUE_PRINT:
+        {
+            /*
+	      NDT_Node              *Next_Node_Ptr    =          (NDT_Node  *)va_arg( Args, NDT_Node  *);
+	      va_list                lib_args         =              (va_list)va_arg( Args, va_list);
+	      FILE                  *Out              =              (FILE  *)va_arg( lib_args, FILE  *);
+	      NDT_Recursive_Mode     Recursive_Mode   =   (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode);
+	      NDT_Recursive_Depth    Recursive_Depth  =  (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth);
+	      NDT_Recursive_Offset   Recursive_Offset = (NDT_Recursive_Offset)va_arg( lib_args, NDT_Recursive_Offset);
+	      va_list                user_args        =              (va_list)va_arg( lib_args, va_list);
+	      user_type              user_data        =            (user_type)va_arg( user_args, user_type);
+	      ... =                  (...)va_arg( user_args, ...);
+
+	      void                  *Value_Ptr       = Node_Ptr->Value;
+            */
+
+
+            Command_Name = "NDD_CMD_VALUE_PRINT";
+
+            /*
+	      fprintf( Out, "...\n", Value_Ptr->..., ...);
+
+	      return( NDS_OK);
+            */
+        }
+
+        case NDD_CMD_INFO_PRINT:
+        {
+            /*
+	      NDT_Node              *Next_Node_Ptr    =          (NDT_Node  *)va_arg( Args, NDT_Node  *);
+	      va_list                lib_args         =              (va_list)va_arg( Args, va_list);
+	      FILE                  *Out              =              (FILE  *)va_arg( lib_args, FILE  *);
+	      NDT_Recursive_Mode     Recursive_Mode   =   (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode);
+	      NDT_Recursive_Depth    Recursive_Depth  =  (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth);
+	      NDT_Recursive_Offset   Recursive_Offset = (NDT_Recursive_Offset)va_arg( lib_args, NDT_Recursive_Offset);
+	      va_list                user_args        =              (va_list)va_arg( lib_args, va_list);
+	      user_type              user_data        =            (user_type)va_arg( user_args, user_type);
+	      ... =                  (...)va_arg( user_args, ...);
+
+	      void                  *Value_Ptr        = Node_Ptr->Value;
+            */
+
+
+            Command_Name = "NDD_CMD_INFO_PRINT";
+
+	    /*
+	      return( NDS_OK);
+	    */
+        }
+
+        case NDD_CMD_USER_TRAVERSE:
+        {
+            /*
+	      NDT_Node   *Next_Node_Ptr = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+	      va_list     user_args     =     (va_list)va_arg( Args, va_list);
+	      user_type   user_data     =   (user_type)va_arg( user_args, user_type);
+	      ... =         (...)va_arg( user_args, ...);
+
+	      void       *Value_Ptr     = Node_Ptr->Value;
+            */
+	
+	
+            Command_Name = "NDD_CMD_USER_TRAVERSE";
+
+	    /*
+	      return( NDS_OK);
+	    */
+	}
+
+        default:
+	{
+            printf( "ND_Default_Manager() called with an undefined command %d\n", Command);
+            return(NDS_ERRAPI);
+        }
+    }
+
+    printf( "ND_Default_Manager() called with command %d (%s)\n", Command, Command_Name);
+    return(NDS_OK);
+}
+
+
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* OpenStruct Manager                                                           */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_OpenStruct_Manager( NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id, NDT_Node  *Node_Ptr, NDT_Command  Command, va_list  Args)
+{
+    NDT_Command_Name  Command_Name;
+
+
+    switch( Command)
+    {
+        case NDD_CMD_MANAGER_VERSION:
+        {
+            NDT_Version_Name  *Version_Name_Ptr = (NDT_Version_Name  *)va_arg( Args, NDT_Version_Name  *);
+
+
+            Command_Name = "NDD_CMD_MANAGER_VERSION";
+
+            *Version_Name_Ptr = "%Revision: 2.15 %   %Name: libnode-2_1_0-1 %   %Date: 2005/01/19 23:59:41 %   %Author: agibert %";
+
+            return( NDS_OK);
+	}
+
+        case NDD_CMD_INDEX_GET:
+        {
+            /*
+	      NDT_Index_Id  *Reply_Index_Id_Ptr = (NDT_Index_Id  *)va_arg( Args, NDT_Index_Id  *);
+	      NDT_Command   *Reply_Command_Ptr  =  (NDT_Command  *)va_arg( Args, NDT_Command  *);
+	      NDT_Command    Cmd                =     (NDT_Command)va_arg( Args, NDT_Command);
+	      void          *Value_ptr          =         (void  *)va_arg( Args, void  *);
+            */
+            NDT_Index_Id  *Reply_Index_Id_Ptr = (NDT_Index_Id  *)va_arg( Args, NDT_Index_Id  *);
+            NDT_Command   *Reply_Command_Ptr  =  (NDT_Command  *)va_arg( Args, NDT_Command  *);
+            NDT_Command    Cmd                =     (NDT_Command)va_arg( Args, NDT_Command);
+            void          *Value_ptr          =         (void  *)va_arg( Args, void  *);
+
+
+            Command_Name = "NDD_CMD_INDEX_GET";
+
+            switch(Cmd)
+            {
+                default:
+                {
+		    *Reply_Index_Id_Ptr = Index_Id;
+		    *Reply_Command_Ptr = Cmd;
+		    break;
+		}
+	    }
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_ALLOC:
+        {
+            /*
+	      void       **Value_Ptr_Ptr =  (void  **)va_arg( Args, void  **);
+	      va_list      user_args	   =   (va_list)va_arg( Args, va_list);
+	      user_type    user_data	   = (user_type)va_arg( user_args, user_type);
+	      ... =       (...)va_arg( user_args, ...);
+            */
+
+
+            Command_Name = "NDD_CMD_VALUE_ALLOC";
+
+	    return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_FREE:
+        {
+            /*
+	      void       *Value_Ptr =   (void  *)va_arg( Args, void  *);
+	      va_list     user_args =   (va_list)va_arg( Args, va_list);
+	      user_type   user_data = (user_type)va_arg( user_args, user_type);
+	      ... =       (...)va_arg( user_args, ...);
+            */
+
+
+            Command_Name = "NDD_CMD_VALUE_FREE";
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_COMP:
+        {
+            /*
+	      void       *Value1_Ptr =   (void  *)va_arg( Args, void  *);
+	      void       *Value2_Ptr =   (void  *)va_arg( Args, void  *);
+	      va_list     user_args  =   (va_list)va_arg( Args, va_list);
+	      user_type   user_data  = (user_type)va_arg( user_args, user_type);
+	      ... =       (...)va_arg( user_args, ...);
+            */
+
+            void       *Value1_Ptr =   (void  *)va_arg( Args, void  *);
+            void       *Value2_Ptr =   (void  *)va_arg( Args, void  *);
+
+
+            Command_Name = "NDD_CMD_VALUE_COMP";
+
+            switch( Index_Id)
+            {
+                case 0:
+                {
+                    if( Value1_Ptr < Value2_Ptr)
+                    {
+                        return(NDS_LOWER);
+		    }
+                    else
+                    {
+                        if( Value1_Ptr > Value2_Ptr)
+                        {
+                            return(NDS_GREATER);
+                        }
+                        else
+                        {
+                            return(NDS_EQUAL);
+                        }
+                    }
+                }
+
+                default:
+                {
+                    printf( "Unknown COMP idx (%d) !\n", Index_Id);
+                    return( NDS_KO);
+                }
+            }
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_ADD:
+        {
+            /*
+	      void       *Value_Ptr =   (void  *)va_arg( Args, void  *);
+	      va_list     user_args =   (va_list)va_arg( Args, va_list);
+	      user_type   user_data = (user_type)va_arg( user_args, user_type);
+	      ... =       (...)va_arg( user_args, ...);
+            */
+
+
+            Command_Name = "NDD_CMD_VALUE_ADD";
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_REMOVE:
+        {
+            /*
+	      void       *Value_Ptr =   (void  *)va_arg( Args, void  *);
+	      va_list     user_args =   (va_list)va_arg( Args, va_list);
+	      user_type   user_data = (user_type)va_arg( user_args, user_type);
+	      ... =       (...)va_arg( user_args, ...);
+            */
+
+
+            Command_Name = "NDD_CMD_VALUE_REMOVE";
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_PRINT:
+        {
+            /*
+	      NDT_Node              *Next_Node_Ptr    =          (NDT_Node  *)va_arg( Args, NDT_Node  *);
+	      va_list                lib_args         =              (va_list)va_arg( Args, va_list);
+	      FILE                  *Out              =              (FILE  *)va_arg( lib_args, FILE  *);
+	      NDT_Recursive_Mode     Recursive_Mode   =   (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode);
+	      NDT_Recursive_Depth    Recursive_Depth  =  (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth);
+	      NDT_Recursive_Offset   Recursive_Offset = (NDT_Recursive_Offset)va_arg( lib_args, NDT_Recursive_Offset);
+	      va_list                user_args        =              (va_list)va_arg( lib_args, va_list);
+	      user_type              user_data        =            (user_type)va_arg( user_args, user_type);
+	      ... =                  (...)va_arg( user_args, ...);
+
+	      void                  *Value_Ptr       = Node_Ptr->Value;
+            */
+
+
+            Command_Name = "NDD_CMD_VALUE_PRINT";
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_INFO_PRINT:
+        {
+            /*
+	      NDT_Node              *Next_Node_Ptr    =          (NDT_Node  *)va_arg( Args, NDT_Node  *);
+	      va_list                lib_args         =              (va_list)va_arg( Args, va_list);
+	      FILE                  *Out              =              (FILE  *)va_arg( lib_args, FILE  *);
+	      NDT_Recursive_Mode     Recursive_Mode   =   (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode);
+	      NDT_Recursive_Depth    Recursive_Depth  =  (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth);
+	      NDT_Recursive_Offset   Recursive_Offset = (NDT_Recursive_Offset)va_arg( lib_args, NDT_Recursive_Offset);
+	      va_list                user_args        =              (va_list)va_arg( lib_args, va_list);
+	      user_type              user_data        =            (user_type)va_arg( user_args, user_type);
+	      ... =                  (...)va_arg( user_args, ...);
+
+	      void                  *Value_Ptr        = Node_Ptr->Value;
+            */
+
+            NDT_Node              *Next_Node_Ptr    =          (NDT_Node  *)va_arg( Args, NDT_Node  *);
+            va_list                lib_args         =              (va_list)va_arg( Args, va_list);
+            FILE                  *Out              =              (FILE  *)va_arg( lib_args, FILE  *);
+            NDT_Recursive_Mode     Recursive_Mode   =   (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode);
+            NDT_Recursive_Depth    Recursive_Depth  =  (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth);
+            NDT_Recursive_Offset   Recursive_Offset = (NDT_Recursive_Offset)va_arg( lib_args, NDT_Recursive_Offset);
+
+            void                  *Value_Ptr        = Node_Ptr->Value;
+
+
+            Command_Name = "NDD_CMD_INFO_PRINT";
+
+            return( ND_DataStruct_Info_Print_I( Out, (NDT_Root  *)Value_Ptr, Recursive_Mode, --Recursive_Depth, ++Recursive_Offset));
+        }
+
+        default:
+	{
+            printf( "OpenStruct_Manager() called with an undefined command %d\n", Command);
+            return( NDS_ERRAPI);
+        }
+    }
+
+    printf( "OpenStruct_Manager() called with command %d (%s)\n", Command, Command_Name);
+    return( NDS_OK);
+}
+
+
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/*------------------------------------------------------------------------------*/
+/*                              FONCTIONS PUBLIQUES                             */
+/*------------------------------------------------------------------------------*/
+/*------------------------------------------------------------------------------*/
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Initialisation du contexte de la librairie                                   */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_Library_Open_I( int  Debug_Mode)
+{
+    NDG_Base.Debug_Mode = Debug_Mode;
+    NDG_Base.Open_Status = NDD_TRUE;
+
+    if( Debug_Mode == NDD_TRUE)
+    {
+        ND_Library_StdErr_Set_I( stderr);
+    }
+
+#if !defined(_WIN32)
+    if( ( NDG_Base.DL_Ptr = dlopen(  NULL, ( RTLD_NOW | RTLD_GLOBAL))) == NULL)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Library_Open: can't dlopen [%s]", dlerror());
+        ND_Error_Print();
+
+        return( NDS_KO);
+    }
+#endif
+
+    return( NDS_OK);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Initialisation du contexte de la librairie                                   */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_Library_Open_C( int  Debug_Mode)
+{
+    NDT_Status  status;
+
+
+    if( NDG_Base.Open_Status != NDD_FALSE)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Library_Open_C: library is not closed");
+        ND_Error_Print();
+
+        return( NDS_KO);
+    }
+    else
+    {
+        if( Debug_Mode == NDD_TRUE)
+        {
+	    if( ( status = ND_DataStruct_Open_I( &(NDG_Base.OpenStruct_Ptr), 1, NDG_Base.OpenStruct_Index_Type, "ND_OpenStruct_Manager", ND_OpenStruct_Manager, NULL, NULL, NULL, NULL, 0,  NULL)) != NDS_OK)
+	    {
+	        sprintf( NDG_Base.Err_String, "Error ND_Library_Open_C: can't open OpenStruct");
+		ND_Error_Print();
+
+		return( NDS_KO);
+	    }
+	}
+    }
+
+    return( ND_Library_Open_I( Debug_Mode));
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Fermeture du contexte de la librairie                                        */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_Library_Close_I( void)
+{
+    NDT_Symbol  *Symbol, *Next_Symbol;
+
+
+    /* Désallocation de la table des symboles locale */
+
+    Symbol = NDG_Base.Symbol_First_Ptr;
+
+    while( Symbol)
+    {
+	Next_Symbol = Symbol->Next;
+	free( Symbol->Name);
+	free( Symbol);
+	Symbol = Next_Symbol;
+    }
+
+    NDG_Base.Symbol_First_Ptr = (NDT_Symbol  *)NULL;
+
+#if !defined(_WIN32)
+/*
+    if( dlclose( NDG_Base.DL_Ptr) != 0)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Library_Open: can't dlclose [%s]", dlerror());
+        ND_Error_Print();
+
+        return( NDS_KO);
+    }
+*/
+/* dlclose buggy on HPUX... 8^/ */
+#endif
+
+    NDG_Base.Open_Status = NDD_FALSE;
+
+    return( NDS_OK);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Fermeture du contexte de la librairie                                        */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_Library_Close_C( void)
+{
+    NDT_Status  status;
+
+
+    if( NDG_Base.Open_Status != NDD_TRUE)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Library_Close_C: library is not opened");
+        ND_Error_Print();
+
+        return( NDS_KO);
+    }
+
+    if( ( NDG_Base.Debug_Mode == NDD_TRUE) && ( NDG_Base.Err_Stream != NULL))
+    {
+	if( NDG_Base.OpenStruct_Ptr->Index_Tab[NDD_INDEX_PRIMARY].Node_Number > 0)
+	{
+	    sprintf( NDG_Base.Err_String, "Error ND_Library_Close_C: Unclosed DataStruct:");
+	    ND_Error_Print();
+
+	    if( ( status = ND_DataStruct_Info_Print_I( NDG_Base.Err_Stream, NDG_Base.OpenStruct_Ptr, NDD_RECURSIVE_MODE_PARENT_CHILD, 0, 0)) != NDS_OK)
+	    {
+		sprintf( NDG_Base.Err_String, "Error ND_Library_Close_C: can't print OpenStruct info");
+		ND_Error_Print();
+
+		return( NDS_KO);
+	    }
+	}
+
+	if( ( status = ND_DataStruct_Close_I( NDG_Base.OpenStruct_Ptr)) != NDS_OK)
+	{
+	    sprintf( NDG_Base.Err_String, "Error ND_Library_Close_C: can't close OpenStruct");
+	    ND_Error_Print();
+	    
+	    return( NDS_KO);
+	}
+    }
+
+    return( ND_Library_Close_I());
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Définition de la sortie standard des messages d'erreur de la librairie       */
+/*------------------------------------------------------------------------------*/
+/* (I) Out : flux de sortie de l'affichage des messages d'erreur                */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status ND_Library_StdErr_Set_I( FILE  *Out)
+{
+    NDG_Base.Err_Stream = Out;
+
+    return( NDS_OK);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Définition de la sortie standard des messages d'erreur de la librairie       */
+/*------------------------------------------------------------------------------*/
+/* (I) Out : flux de sortie de l'affichage des messages d'erreur                */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_Library_StdErr_Set_C( FILE  *Out)
+{
+    if( NDG_Base.Open_Status != NDD_TRUE)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Library_StdErr_Set_C: library is not opened");
+        ND_Error_Print();
+
+        return( NDS_KO);
+    }
+
+    return( ND_Library_StdErr_Set_I( Out));
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Création d'une nouvelle structure de données                                 */
+/*------------------------------------------------------------------------------*/
+/* (O) Root: adresse d'un pointeur sur la racine de la nouvelle structure       */
+/* (I) Type: type de la structure.de données (liste ou arbre binaire)           */
+/* (I) Allocator: pointeur vers la fonction d'allocation                        */
+/* (I) Desallocator: pointeur vers la fonction de désallocation                 */
+/* (I) Data : pointeur de données utiles à l'allocateur                         */
+/* (I) Own_Value : indique si la structure est propriétaire de ses valeurs      */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_Index_Open_I( NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id, NDT_Index_Type  Type)
+{
+    NDT_Status   status;
+    NDT_Node    *node_ptr;
+
+
+    if( ( status = ND_Index_Clear( Root_Ptr, Index_Id)) != NDS_OK)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Index_Open_I: Index cleaning error");
+        ND_Error_Print();
+
+        return( NDS_KO);
+    }
+
+    Root_Ptr->Index_Tab[Index_Id].Type = Type & NDD_INDEX_STATUS_RMSK | NDD_INDEX_STATUS_OPENED ;
+
+    Root_Ptr->Index_Open_Count++;
+
+    if( Index_Id != NDD_INDEX_PRIMARY)
+    {
+        if( ( status = ND_Index_Node_First_Get_I( &node_ptr, Root_Ptr, NDD_INDEX_PRIMARY)) != NDS_OK)
+        {
+            sprintf( NDG_Base.Err_String, "Error ND_Index_Open_I: can't get first primary index node");
+            ND_Error_Print();
+
+            return( NDS_KO);
+	}
+
+        while( node_ptr != NULL)
+        {
+            if( ( status = ND_Index_Value_Add_I( Root_Ptr, Index_Id, node_ptr->Value)) != NDS_OK)
+            {
+                sprintf( NDG_Base.Err_String, "Error ND_Index_Open_I: can't add value");
+                ND_Error_Print();
+
+                return( NDS_KO);
+	    }
+
+            if( ( status = ND_Index_Node_Next_Get_I( &node_ptr, node_ptr)) != NDS_OK)
+            {
+                sprintf( NDG_Base.Err_String, "Error ND_Index_Open_I: can't get next node");
+                ND_Error_Print();
+
+                return( NDS_KO);
+	    }
+        }
+    }
+
+    return( NDS_OK);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Création d'une nouvelle structure de données                                 */
+/*------------------------------------------------------------------------------*/
+/* (O) Root: adresse d'un pointeur sur la racine de la nouvelle structure       */
+/* (I) Type: type de la structure.de données (liste ou arbre binaire)           */
+/* (I) Allocator: pointeur vers la fonction d'allocation                        */
+/* (I) Desallocator: pointeur vers la fonction de désallocation                 */
+/* (I) Data : pointeur de données utiles à l'allocateur                         */
+/* (I) Own_Value : indique si la structure est propriétaire de ses valeurs      */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_Index_Open_C( NDT_Root  *Root_Ptr,  NDT_Index_Id  Index_Id, NDT_Index_Type  Type)
+{
+    if( !Root_Ptr)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Index_Open_C: structure root is null");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    if( NDG_Base.Open_Status != NDD_TRUE)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Index_Open_C: library is not open");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    if( !ND_INDEX_STATUS_CLOSED_IS( Root_Ptr, Index_Id))
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Index_Open_C: index is not closed");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    if( ( Root_Ptr->Index_Open_Count == 0) && ( Index_Id != NDD_INDEX_PRIMARY))
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Index_Open_I: fist opened index should be the primary");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    return( ND_Index_Open_I( Root_Ptr, Index_Id, Type));
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Création d'une nouvelle structure de données                                 */
+/*------------------------------------------------------------------------------*/
+/* (O) Root: adresse d'un pointeur sur la racine de la nouvelle structure       */
+/* (I) Type: type de la structure.de données (liste ou arbre binaire)           */
+/* (I) Allocator: pointeur vers la fonction d'allocation                        */
+/* (I) Desallocator: pointeur vers la fonction de désallocation                 */
+/* (I) Data : pointeur de données utiles à l'allocateur                         */
+/* (I) Own_Value : indique si la structure est propriétaire de ses valeurs      */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status ND_DataStruct_Open_I( NDT_Root  **Root_Ptr_Ptr, NDT_Index_Nb  Index_Nb, NDT_Index_Type  *Type_Ptr, NDT_Manager_Name  Manager_Name, NDT_Manager  *Manager_Ptr,
+				 NDT_Allocator_Name  Allocator_Name, NDT_Allocator  *Allocator_Ptr, NDT_Desallocator_Name  Desallocator_Name, NDT_Desallocator  *Desallocator_Ptr, short  Own_Value, void  *Data)
+{
+    NDT_Status		    status;
+    NDT_Manager_Name	    Real_Manager_Name;
+    NDT_Manager		   *Real_Manager_Ptr;
+    NDT_Allocator_Name	    Real_Allocator_Name;
+    NDT_Allocator	   *Real_Allocator_Ptr;
+    NDT_Desallocator_Name   Real_Desallocator_Name;
+    NDT_Desallocator	   *Real_Desallocator_Ptr;
+
+
+    /* Valeurs par défaut des fonctions d'allocation et de désallocation */
+
+#if defined(_WIN32)
+    if( ( Manager_Name != NULL) && ( Manager_Ptr == NULL))
+    {
+	sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Open_I: no symbol lookup support, Manager_Ptr shouldn't be NULL");
+	ND_Error_Print();
+
+	return( NDS_ERRAPI);
+    }
+#endif
+
+    if( ( Manager_Name != NULL) || ( Manager_Ptr != NULL))
+    {
+        Real_Manager_Name = Manager_Name;
+	Real_Manager_Ptr  = Manager_Ptr;
+    }
+    else
+    {
+        Real_Manager_Name = "ND_Default_Manager";
+	Real_Manager_Ptr  = ND_Default_Manager;
+    }
+
+#if defined(_WIN32)
+    if( ( Allocator_Name != NULL) && ( Allocator_Ptr == NULL))
+    {
+	sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Open_I: no symbol lookup support, Allocator_Ptr shouldn't be NULL");
+	ND_Error_Print();
+
+	return( NDS_ERRAPI);
+    }
+#endif
+
+    if( ( Allocator_Name != NULL) || ( Allocator_Ptr != NULL))
+    {
+        Real_Allocator_Name = Allocator_Name;
+	Real_Allocator_Ptr  = Allocator_Ptr;
+    }
+    else
+    {
+        Real_Allocator_Name = "ND_Default_Allocator";
+	Real_Allocator_Ptr  = ND_Default_Allocator;
+    }
+
+#if defined(_WIN32)
+    if( ( Desallocator_Name != NULL) && ( Desallocator_Ptr == NULL))
+    {
+	sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Open_I: no symbol lookup support, Desallocator_Ptr shouldn't be NULL");
+	ND_Error_Print();
+
+	return( NDS_ERRAPI);
+    }
+#endif
+
+    if( ( Desallocator_Name != NULL) || ( Desallocator_Ptr != NULL))
+    {
+        Real_Desallocator_Name = Desallocator_Name;
+	Real_Desallocator_Ptr  = Desallocator_Ptr;
+    }
+    else
+    {
+        Real_Desallocator_Name = "ND_Default_Desallocator";
+	Real_Desallocator_Ptr  = ND_Default_Desallocator;
+    }
+
+    status = ND_Node_Root_Alloc( Root_Ptr_Ptr, Index_Nb, Type_Ptr, Real_Manager_Name, Real_Manager_Ptr, Real_Allocator_Name, Real_Allocator_Ptr, Real_Desallocator_Name, Real_Desallocator_Ptr, Own_Value, Data);
+
+    if( ND_ERROR( status)) return( status);
+
+    return( NDS_OK);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Création d'une nouvelle structure de données                                 */
+/*------------------------------------------------------------------------------*/
+/* (O) Root: adresse d'un pointeur sur la racine de la nouvelle structure       */
+/* (I) Type: type de la structure.de données (liste ou arbre binaire)           */
+/* (I) Allocator: pointeur vers la fonction d'allocation                        */
+/* (I) Desallocator: pointeur vers la fonction de désallocation                 */
+/* (I) Data : pointeur de données utiles à l'allocateur                         */
+/* (I) Own_Value : indique si la structure est propriétaire de ses valeurs      */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_DataStruct_Open_C( NDT_Root  **Root_Ptr_Ptr, NDT_Index_Nb  Index_Nb, NDT_Index_Type  *Type_Ptr, NDT_Manager_Name  Manager_Name, NDT_Manager  *Manager_Ptr,
+				  NDT_Allocator_Name  Allocator_Name, NDT_Allocator  *Allocator_Ptr, NDT_Desallocator_Name  Desallocator_Name, NDT_Desallocator  *Desallocator_Ptr, short  Own_Value, void  *Data_Ptr)
+{
+    NDT_Status  status;
+
+
+    if( NDG_Base.Open_Status != NDD_TRUE)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Open_C: library is not open");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    if( ( status = ND_DataStruct_Open_I( Root_Ptr_Ptr, Index_Nb, Type_Ptr, Manager_Name, Manager_Ptr, Allocator_Name, Allocator_Ptr, Desallocator_Name, Desallocator_Ptr, Own_Value, Data_Ptr)) != NDS_OK)
+    {
+	return( status);
+    }
+
+    if( ( NDG_Base.Debug_Mode == NDD_TRUE) && ( NDG_Base.Open_Status == NDD_TRUE))
+    {
+        if( ( status = ND_DataStruct_Value_Add_I( NDG_Base.OpenStruct_Ptr, (void  **)*Root_Ptr_Ptr)) != NDS_OK)
+        {
+	    sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Open_C: can't add value in OpenStruct");
+	    ND_Error_Print();
+
+	    return( NDS_KO);
+	}
+    }
+
+    return( NDS_OK);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Destruction d'une structure de données                                       */
+/*------------------------------------------------------------------------------*/
+/* (O) Root: pointeur sur la racine de la structure de données à détruire       */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status   ND_Index_Close_I( NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id)
+{
+    NDT_Status  status;
+
+
+    if( ( Root_Ptr->Index_Open_Count != 1) && ( Index_Id == NDD_INDEX_PRIMARY))
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Index_Close_I: the primary should be the last closed");
+        ND_Error_Print();
+        return(NDS_ERRAPI);
+    }
+
+    status = ND_Index_Flush_I( Root_Ptr, Index_Id);
+    if( ND_ERROR( status)) return( status);
+
+    Root_Ptr->Index_Tab[ Index_Id].Type = Root_Ptr->Index_Tab[ Index_Id].Type & NDD_INDEX_STATUS_RMSK | NDD_INDEX_STATUS_CLOSED;
+
+    Root_Ptr->Index_Open_Count--;
+
+    return( NDS_OK);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Destruction d'une structure de données                                       */
+/*------------------------------------------------------------------------------*/
+/* (O) Root: pointeur sur la racine de la structure de données à détruire       */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_Index_Close_C( NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id)
+{
+    if( NDG_Base.Open_Status != NDD_TRUE)
+    {
+	sprintf( NDG_Base.Err_String, "Error ND_Index_Close_C: library is not open");
+	ND_Error_Print();
+
+	return( NDS_ERRAPI);
+    }
+
+    if( !Root_Ptr)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Index_Close_C: structure root is null");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    if( !ND_INDEX_STATUS_OPENED_IS( Root_Ptr, Index_Id))
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Index_Close_C: index is not opened");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    return( ND_Index_Close_I( Root_Ptr, Index_Id));
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Destruction d'une structure de données                                       */
+/*------------------------------------------------------------------------------*/
+/* (O) Root: pointeur sur la racine de la structure de données à détruire       */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_DataStruct_Close_I( NDT_Root  *Root_Ptr)
+{
+    NDT_Status    status;
+
+
+    status = ND_DataStruct_Flush_I( Root_Ptr);
+    if( ND_ERROR( status)) return( status);
+
+    return( ND_Node_Root_Free( Root_Ptr));
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Destruction d'une structure de données                                       */
+/*------------------------------------------------------------------------------*/
+/* (O) Root: pointeur sur la racine de la structure de données à détruire       */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_DataStruct_Close_C( NDT_Root  *Root_Ptr)
+{
+    NDT_Status  status;
+
+
+    if( NDG_Base.Open_Status != NDD_TRUE)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Close_C: library is not open");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    if (!Root_Ptr)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Close_C: structure root is null");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    if( ( status = ND_DataStruct_Close_I( Root_Ptr)) != NDS_OK)
+    {
+	return( status);
+    }
+
+    if( NDG_Base.Debug_Mode == NDD_TRUE)
+    {
+        if( ( status = ND_DataStruct_Value_Remove_I( NDG_Base.OpenStruct_Ptr, (void  *)Root_Ptr)) != NDS_OK)
+        {
+	    sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Close_I: can't remove value from OpenStruct");
+	    ND_Error_Print();
+
+	    return( NDS_KO);
+	}
+    }
+
+    return( NDS_OK);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* (O) Root: pointeur sur la racine de la structure de données à détruire       */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_Index_Flush_I( NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id)
+{
+    NDT_Status   status;
+    NDT_Node    *Node_Ptr,  *Next_Node_Ptr;
+ 
+
+    ND_Index_Node_First_Get_I( &Node_Ptr, Root_Ptr, Index_Id);
+
+    while( Node_Ptr)
+    {
+        Next_Node_Ptr = NULL;
+        ND_Index_Node_Next_Get_I( &Next_Node_Ptr, Node_Ptr);
+
+        if( Index_Id == NDD_INDEX_PRIMARY)
+        {
+            status = ND_Manager_Exec_I( Root_Ptr, Index_Id, Node_Ptr, NDD_CMD_VALUE_FREE, Node_Ptr->Value);
+            if( ND_ERROR( status)) return( status);
+	}
+        else
+        {
+            status = ND_Manager_Exec_I( Root_Ptr, Index_Id, Node_Ptr, NDD_CMD_VALUE_REMOVE, Node_Ptr->Value);
+            if( ND_ERROR( status)) return( status);
+        }
+
+        status = ND_Index_Node_Remove_I( Node_Ptr);
+        if( ND_ERROR( status)) return( status);
+
+        status = ND_Node_Free( Root_Ptr, Node_Ptr);
+        if (ND_ERROR( status)) return( status);
+       
+        Node_Ptr = Next_Node_Ptr;
+    }
+
+    return( NDS_OK);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Destruction d'une structure de données                                       */
+/*------------------------------------------------------------------------------*/
+/* (O) Root: pointeur sur la racine de la structure de données à détruire       */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_Index_Flush_C( NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id)
+{
+    if( NDG_Base.Open_Status != NDD_TRUE)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Index_Flush_C: library is not open");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    if( !Root_Ptr)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Index_Flush_C: structure root is null");
+        ND_Error_Print();
+
+        return(NDS_ERRAPI);
+    }
+
+    return( ND_Index_Flush_I( Root_Ptr, Index_Id));
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Destruction d'une structure de données                                       */
+/*------------------------------------------------------------------------------*/
+/* (O) Root: pointeur sur la racine de la structure de données à détruire       */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_DataStruct_Flush_I( NDT_Root  *Root_Ptr)
+{
+    NDT_Status    status;
+    NDT_Index_Id  index_id;
+
+
+    for( index_id = ( Root_Ptr->Index_Nb - 1); index_id >= 0 ; index_id--)
+    {
+        status = ND_Index_Flush_I( Root_Ptr, index_id);
+        if( ND_ERROR( status)) return( status);
+    }
+
+    return( NDS_OK);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Destruction d'une structure de données                                       */
+/*------------------------------------------------------------------------------*/
+/* (O) Root: pointeur sur la racine de la structure de données à détruire       */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_DataStruct_Flush_C( NDT_Root  *Root_Ptr)
+{
+    if( NDG_Base.Open_Status != NDD_TRUE)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Flush_C: library is not open");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    if (!Root_Ptr)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Flush_C: structure root is null");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    return ND_DataStruct_Flush_I( Root_Ptr);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Function de réparation d'une structure :                                     */
+/*  - vérifie que tous les noeuds sont correctement liés les uns aux autres     */
+/*  - corrige les informations statistiques de la racine                        */
+/*------------------------------------------------------------------------------*/
+/* (I) Root         : pointeur sur la racine de la structure                    */
+/* (O) Nb_Detected  : pointeur sur le nombre d'erreurs détectées                */
+/* (O) Nb_Corrected : pointeur sur le nombre d'erreurs corrigées                */
+/* (I) Out          : flux de sortie du rapport                                 */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_Index_Check_I( NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id, int  *Detected_Nb_Ptr,  int  *Corrected_Nb_Ptr,  FILE  *Out)
+{
+    *Detected_Nb_Ptr = 0;
+    *Corrected_Nb_Ptr = 0;
+
+
+    if( ND_INDEX_STATUS_OPENED_IS( Root_Ptr, Index_Id))
+    {
+	if( ND_INDEX_TYPE_LIST_IS( Root_Ptr, Index_Id))
+	{
+	    ND_List_Check( Root_Ptr, Index_Id, Detected_Nb_Ptr, Corrected_Nb_Ptr, Out);
+	}
+	else if( ND_INDEX_TYPE_TREE_IS( Root_Ptr, Index_Id))
+	{
+	    ND_Tree_Check( Root_Ptr, Index_Id, Detected_Nb_Ptr, Corrected_Nb_Ptr, Out);
+	}
+	else
+	{
+	    sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Check_I: unknown structure type (%d) in structure (%p:%d)\n", Root_Ptr->Index_Tab[Index_Id].Type, Root_Ptr, Index_Id);
+	    ND_Error_Print();
+
+	    (*Detected_Nb_Ptr)++;
+	    return( NDS_OK);
+	}
+
+        /* Affichage du résultat de la procédure de vérification */
+
+        if( *Detected_Nb_Ptr == 0)
+        {
+            fprintf( Out, "No error detected in the node structure (%p:%d)\n", Root_Ptr, Index_Id);
+        }
+        else
+        {
+            fprintf( Out, "%d/%d error(s) corrected in the node structure (%p:%d)\n", *Corrected_Nb_Ptr, *Detected_Nb_Ptr, Root_Ptr, Index_Id);
+        }
+    }
+ 
+    return( NDS_OK);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Function de réparation d'une structure :                                     */
+/*  - vérifie que tous les noeuds sont correctement liés les uns aux autres     */
+/*  - corrige les informations statistiques de la racine                        */
+/*------------------------------------------------------------------------------*/
+/* (I) Root         : pointeur sur la racine de la structure                    */
+/* (O) Nb_Detected  : pointeur sur le nombre d'erreurs détectées                */
+/* (O) Nb_Corrected : pointeur sur le nombre d'erreurs corrigées                */
+/* (I) Out          : flux de sortie du rapport                                 */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_Index_Check_C( NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id, int  *Nb_Detected_Ptr, int  *Nb_Corrected_Ptr, FILE  *Out)
+{
+    if( NDG_Base.Open_Status != NDD_TRUE)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Index_Check_C: library is not open");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    if( !Root_Ptr)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Index_Check_C: structure root is null");
+        ND_Error_Print();
+
+        (*Nb_Detected_Ptr)++;
+
+        return(NDS_ERRAPI);
+    }
+
+    if( !Out)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Index_Check_C: the stream descriptor is null");
+        ND_Error_Print();
+
+        return(NDS_ERRAPI);
+    }
+
+    return( ND_Index_Check_I( Root_Ptr, Index_Id, Nb_Detected_Ptr, Nb_Corrected_Ptr, Out));
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Function de réparation d'une structure :                                     */
+/*  - vérifie que tous les noeuds sont correctement liés les uns aux autres     */
+/*  - corrige les informations statistiques de la racine                        */
+/*------------------------------------------------------------------------------*/
+/* (I) Root         : pointeur sur la racine de la structure                    */
+/* (O) Nb_Detected  : pointeur sur le nombre d'erreurs détectées                */
+/* (O) Nb_Corrected : pointeur sur le nombre d'erreurs corrigées                */
+/* (I) Out          : flux de sortie du rapport                                 */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_DataStruct_Check_I( NDT_Root  *Root_Ptr, int  *Error_Detected_Nb_Ptr,  int  *Error_Corrected_Nb_Ptr,  FILE  *Out)
+{
+    NDT_Status    status;
+    NDT_Index_Id  index_id;
+    int			  index_error_detected_nb, index_error_corrected_nb;
+
+
+    for( index_id = 0; index_id < Root_Ptr->Index_Nb; index_id++)
+    {
+        status = ND_Index_Check_I( Root_Ptr, index_id, &index_error_detected_nb,  &index_error_corrected_nb, Out);
+        if( ND_ERROR(status)) return(status);
+
+        *Error_Detected_Nb_Ptr  = *Error_Detected_Nb_Ptr  + index_error_detected_nb;
+        *Error_Corrected_Nb_Ptr = *Error_Corrected_Nb_Ptr + index_error_corrected_nb;
+    }
+
+    return( NDS_OK);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Function de réparation d'une structure :                                     */
+/*  - vérifie que tous les noeuds sont correctement liés les uns aux autres     */
+/*  - corrige les informations statistiques de la racine                        */
+/*------------------------------------------------------------------------------*/
+/* (I) Root         : pointeur sur la racine de la structure                    */
+/* (O) Nb_Detected  : pointeur sur le nombre d'erreurs détectées                */
+/* (O) Nb_Corrected : pointeur sur le nombre d'erreurs corrigées                */
+/* (I) Out          : flux de sortie du rapport                                 */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status ND_DataStruct_Check_C( NDT_Root  *Root_Ptr, int  *Nb_Detected_Ptr, int  *Nb_Corrected_Ptr, FILE  *Out)
+{
+    if( NDG_Base.Open_Status != NDD_TRUE)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Check_C: library is not open");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    if( !Root_Ptr)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Check_C: structure root is null");
+        ND_Error_Print();
+        (*Nb_Detected_Ptr)++;
+
+        return( NDS_ERRAPI);
+    }
+
+    if( !Out)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Check_C: the stream descriptor is null");
+        ND_Error_Print();
+        return( NDS_ERRAPI);
+    }
+
+    return( ND_DataStruct_Check_I( Root_Ptr, Nb_Detected_Ptr, Nb_Corrected_Ptr, Out));
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Conversion d'une structure de données d'un type en un autre                  */
+/*------------------------------------------------------------------------------*/
+/* (I) Root : pointeur sur la racine de la structure de données à convertir     */
+/* (I) Target_Type : type de structure cible                                    */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_Index_Convert_I( NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id, NDT_Index_Type  Target_Type)
+{
+    NDT_Status rc;
+
+
+    if( ND_INDEX_STATUS_OPENED_IS( Root_Ptr, Index_Id))
+    {
+	switch( Root_Ptr->Index_Tab[Index_Id].Type & NDD_INDEX_TYPE_MSK)
+	{
+	    case NDD_INDEX_TYPE_LIST:
+	    {
+
+		switch( Target_Type & ( NDD_INDEX_TYPE_MSK | NDD_INDEX_SUBTYPE_MSK))
+		{
+		    case( NDD_INDEX_TYPE_LIST | NDD_INDEX_SUBTYPE_SORTED):
+		    {
+			rc = ND_List_Sort( Root_Ptr, Index_Id);
+			if( ND_ERROR( rc)) return( rc);
+
+			Root_Ptr->Index_Tab[Index_Id].Type = Target_Type;
+
+			return( rc);
+		    }
+
+		    case( NDD_INDEX_TYPE_LIST | NDD_INDEX_SUBTYPE_FIFO):
+		    case( NDD_INDEX_TYPE_LIST | NDD_INDEX_SUBTYPE_LIFO):
+		    {
+			Root_Ptr->Index_Tab[Index_Id].Type = Target_Type;
+
+			return( NDS_OK);
+		    }
+
+
+		    case( NDD_INDEX_TYPE_TREE | NDD_INDEX_SUBTYPE_BALANCED):
+		    case( NDD_INDEX_TYPE_TREE | NDD_INDEX_SUBTYPE_UNBALANCED):
+		    {
+			rc = ND_List_Sort( Root_Ptr, Index_Id);
+			if( rc != NDS_OK) return( rc);
+
+			rc = ND_Tree_Make( Root_Ptr, Index_Id);
+			if( ND_ERROR( rc)) return( rc);
+
+			Root_Ptr->Index_Tab[Index_Id].Type = Target_Type;
+
+			return( rc);
+		    }
+
+		    default:
+		    {
+			return( NDS_KO);
+		    }
+		}
+
+		break;
+	    }
+
+	    case NDD_INDEX_TYPE_TREE:
+	    {
+		switch( Target_Type & ( NDD_INDEX_TYPE_MSK | NDD_INDEX_SUBTYPE_MSK))
+		{
+		    case( NDD_INDEX_TYPE_LIST | NDD_INDEX_SUBTYPE_SORTED):
+		    case( NDD_INDEX_TYPE_LIST | NDD_INDEX_SUBTYPE_FIFO):
+		    case( NDD_INDEX_TYPE_LIST | NDD_INDEX_SUBTYPE_LIFO):
+		    {
+
+			rc = ND_List_Make( Root_Ptr, Index_Id);
+			if( ND_ERROR( rc)) return( rc);
+
+			Root_Ptr->Index_Tab[Index_Id].Type = Target_Type;
+
+			return( rc);
+		    }
+
+		    default:
+		    {
+			return( NDS_KO);
+		    }
+		}
+
+		break;
+	    }
+
+	    default:
+	    {
+		sprintf( NDG_Base.Err_String, "Error ND_Index_Convert_I: unknown structure type (%d)", Root_Ptr->Index_Tab[Index_Id].Type);
+		ND_Error_Print ();
+		return NDS_ERRAPI;
+	    }
+	}
+    }
+
+    return( NDS_OK);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Conversion d'une structure de données d'un type en un autre                  */
+/*------------------------------------------------------------------------------*/
+/* (I) Root : pointeur sur la racine de la structure de données à convertir     */
+/* (I) Target_Type : type de structure cible                                    */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_Index_Convert_C( NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id, NDT_Index_Type  Target_Type)
+{
+    if( NDG_Base.Open_Status != NDD_TRUE)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Index_Convert_C: library is not open");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    if( !Root_Ptr)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Index_Convert_C: structure root is null");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    return( ND_Index_Convert_I( Root_Ptr, Index_Id, Target_Type));
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Conversion d'une structure de données d'un type en un autre                  */
+/*------------------------------------------------------------------------------*/
+/* (I) Root : pointeur sur la racine de la structure de données à convertir     */
+/* (I) Target_Type : type de structure cible                                    */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_DataStruct_Convert_I( NDT_Root  *Root_Ptr, NDT_Index_Type  *Target_Type_Ptr)
+{
+    NDT_Status    rc;
+    NDT_Index_Nb  idx;
+
+
+    for( idx = 0; idx < Root_Ptr->Index_Nb; idx++)
+    {
+	rc = ND_Index_Convert_I( Root_Ptr, idx, Target_Type_Ptr[idx]);
+	if( ND_ERROR(rc)) return rc;
+    }
+
+    return( NDS_OK);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Conversion d'une structure de données d'un type en un autre                  */
+/*------------------------------------------------------------------------------*/
+/* (I) Root : pointeur sur la racine de la structure de données à convertir     */
+/* (I) Target_Type : type de structure cible                                    */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_DataStruct_Convert_C( NDT_Root  *Root_Ptr, NDT_Index_Type  *Target_Type_Ptr)
+{
+    if( NDG_Base.Open_Status != NDD_TRUE)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Convert_C: library is not open");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    if( !Root_Ptr)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Convert_C: structure root is null");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    if( !Target_Type_Ptr)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Convert_C: target type ptr is null");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    return( ND_DataStruct_Convert_I( Root_Ptr, Target_Type_Ptr));
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Réorganisation d'une structure de données                                    */
+/*      - ordonnancement d'une liste non ordonnée                               */
+/*      - réquilibrage d'un arbre non auto-équilibré                            */
+/*------------------------------------------------------------------------------*/
+/* (I) Root : pointeur sur la racine de la structure de données à supprimer     */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_Index_Reorg_I( NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id)
+{
+    NDT_Status    status;
+
+
+    if( ND_INDEX_STATUS_OPENED_IS( Root_Ptr, Index_Id))
+    {
+	if( ( status = ND_INDEX_TYPE_LIST_IS( Root_Ptr, Index_Id)))
+	{
+	    if ( !ND_INDEX_SUBTYPE_SORTED_IS( Root_Ptr, Index_Id))
+	    {
+		if( ( status = ND_List_Sort( Root_Ptr, Index_Id)) != NDS_OK)
+		{
+		    return( status);
+		}
+	    }
+	}
+	else
+	{
+	    if( ND_INDEX_TYPE_TREE_IS( Root_Ptr, Index_Id))
+	    {
+		if( ( status = ND_Tree_Equalize( Root_Ptr, Index_Id)) != NDS_OK)
+		{
+		    return( status);
+		}
+	    }
+	    else
+	    {
+		sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Reorg_C: unknown structure type (%d) in structure (%p:%d)\n", Root_Ptr->Index_Tab[Index_Id].Type, Root_Ptr, Index_Id);
+		ND_Error_Print();
+
+		return( NDS_ERRAPI);
+	    }
+	}
+    }
+
+    return( NDS_OK);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Réorganisation d'une structure de données                                    */
+/*      - ordonnancement d'une liste non ordonnée                               */
+/*      - réquilibrage d'un arbre non auto-équilibré                            */
+/*------------------------------------------------------------------------------*/
+/* (I) Root : pointeur sur la racine de la structure de données à supprimer     */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_Index_Reorg_C( NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id)
+{
+    if( NDG_Base.Open_Status != NDD_TRUE)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Index_Reorg_C: library is not open");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    if( !Root_Ptr)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Reorg_C: structure root is null");
+        ND_Error_Print ();
+
+        return( NDS_ERRAPI);
+    }
+
+    return( ND_Index_Reorg_I( Root_Ptr, Index_Id));
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Réorganisation d'une structure de données                                    */
+/*      - ordonnancement d'une liste non ordonnée                               */
+/*      - réquilibrage d'un arbre non auto-équilibré                            */
+/*------------------------------------------------------------------------------*/
+/* (I) Root : pointeur sur la racine de la structure de données à supprimer     */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_DataStruct_Reorg_I( NDT_Root  *Root_Ptr)
+{
+    NDT_Status    status;
+    NDT_Index_Id  index_id;
+
+
+    for( index_id = 0; index_id < Root_Ptr->Index_Nb; index_id++)
+    {
+	status = ND_Index_Reorg_I( Root_Ptr, index_id);
+        if( ND_ERROR( status)) return status;
+    }
+
+    return( NDS_OK);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Réorganisation d'une structure de données                                    */
+/*      - ordonnancement d'une liste non ordonnée                               */
+/*      - réquilibrage d'un arbre non auto-équilibré                            */
+/*------------------------------------------------------------------------------*/
+/* (I) Root : pointeur sur la racine de la structure de données à supprimer     */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_DataStruct_Reorg_C( NDT_Root  *Root_Ptr)
+{
+    if( NDG_Base.Open_Status != NDD_TRUE)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Reorg_C: library is not open");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    if( !Root_Ptr)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Reorg_C: structure root is null");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    return( ND_DataStruct_Reorg_I( Root_Ptr));
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Parcours de tous les noeuds d'une structure de données et exécution d'une    */
+/* commande sur chacun d'eux                                                    */
+/*------------------------------------------------------------------------------*/
+/* (I) Root     : pointeur sur la racine de la structure de données à parcourir */
+/* (I) Command  : Commande à exécuter sur chaque noeud traversé                 */
+/* (I) Data     : pointeur de données utilisateur                               */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status ND_Index_Traverse_VI( NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id, NDT_Command  Command, va_list  Args)
+{
+    NDT_Status   rc;
+    NDT_Node    *Node_Ptr,  *Next_Node_Ptr;
+ 
+
+    ND_Index_Node_First_Get_I( &Node_Ptr, Root_Ptr, Index_Id);
+
+    while( Node_Ptr)
+    {
+        Next_Node_Ptr = NULL;
+        ND_Index_Node_Next_Get_I( &Next_Node_Ptr, Node_Ptr);
+
+	switch (Command)
+        {
+            case NDD_CMD_VALUE_REMOVE:
+            case NDD_CMD_VALUE_FREE:
+	    {
+
+		rc = ND_Manager_Exec_I( Root_Ptr, Index_Id, Node_Ptr, Command, Node_Ptr->Value, Args);
+		if (ND_ERROR( rc)) return rc;
+
+                rc = ND_Index_Node_Remove_I( Node_Ptr);
+                if( ND_ERROR( rc)) return rc;
+
+                rc = ND_Node_Free( Root_Ptr, Node_Ptr);
+                if (ND_ERROR(rc)) return rc;
+       
+		break;
+	    }
+
+            default:
+	    {
+		rc = ND_Manager_Exec_I( Root_Ptr, Index_Id, Node_Ptr, Command, Next_Node_Ptr, Args);
+		if (ND_ERROR( rc)) return rc;
+
+                break;
+	    }
+        }
+
+        Node_Ptr = Next_Node_Ptr;
+    }
+
+    return( NDS_OK);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Parcours de tous les noeuds d'une structure de données et exécution d'une    */
+/* commande sur chacun d'eux                                                    */
+/*------------------------------------------------------------------------------*/
+/* (I) Root     : pointeur sur la racine de la structure de données à parcourir */
+/* (I) Command  : Commande à exécuter sur chaque noeud traversé                 */
+/* (I) Data     : pointeur de données utilisateur                               */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_Index_Traverse_VC( NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id, NDT_Command  Command, va_list  Args)
+{
+    if( NDG_Base.Open_Status != NDD_TRUE)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Index_Traverse_VC: library is not open");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    if( !Root_Ptr)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Traverse_VC: structure root is null");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    return( ND_Index_Traverse_VI( Root_Ptr, Index_Id, Command, Args));
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Parcours de tous les noeuds d'une structure de données et exécution d'une    */
+/* commande sur chacun d'eux                                                    */
+/*------------------------------------------------------------------------------*/
+/* (I) Root     : pointeur sur la racine de la structure de données à parcourir */
+/* (I) Command  : Commande à exécuter sur chaque noeud traversé                 */
+/* (I) Data     : pointeur de données utilisateur                               */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status ND_Index_Traverse_I( NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id, NDT_Command  Command, ...)
+{
+    NDT_Status   status;
+    va_list      args;
+    NDT_Node    *Node_Ptr,  *Next_Node_Ptr;
+
+
+    va_start( args, Command);
+
+    ND_Index_Node_First_Get_I( &Node_Ptr, Root_Ptr, Index_Id);
+
+    status = NDS_OK;
+
+    while( Node_Ptr)
+    {
+        Next_Node_Ptr = NULL;
+        ND_Index_Node_Next_Get_I( &Next_Node_Ptr, Node_Ptr);
+
+        switch (Command)
+        {
+            case NDD_CMD_VALUE_REMOVE:
+            case NDD_CMD_VALUE_FREE:
+            {
+
+                status = ND_Manager_Exec_I( Root_Ptr, Index_Id, Node_Ptr, Command, Node_Ptr->Value, args);
+                if( ND_ERROR( status)) return( status);
+
+                status = ND_Index_Node_Remove_I( Node_Ptr);
+                if( ND_ERROR( status)) return( status);
+
+                status = ND_Node_Free( Root_Ptr, Node_Ptr);
+                if (ND_ERROR( status)) return( status);
+       
+                break;
+            }
+
+            default:
+            {
+                status = ND_Manager_Exec_I( Root_Ptr, Index_Id, Node_Ptr, Command, Next_Node_Ptr, args);
+                if( ND_ERROR( status)) return( status);
+
+                break;
+	    }
+        }
+
+        Node_Ptr = Next_Node_Ptr;
+    }
+
+    va_end( args);
+
+    return( status);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Parcours de tous les noeuds d'une structure de données et exécution d'une    */
+/* commande sur chacun d'eux                                                    */
+/*------------------------------------------------------------------------------*/
+/* (I) Root     : pointeur sur la racine de la structure de données à parcourir */
+/* (I) Command  : Commande à exécuter sur chaque noeud traversé                 */
+/* (I) Data     : pointeur de données utilisateur                               */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_Index_Traverse_C( NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id, NDT_Command  Command, ...)
+{
+    NDT_Status  status;
+    va_list     args;
+
+
+    va_start( args, Command);
+
+    if( NDG_Base.Open_Status != NDD_TRUE)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Traverse_C: library is not open");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    if( !Root_Ptr)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Traverse_C: structure root is null");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    status = ND_Index_Traverse_VI( Root_Ptr, Index_Id, Command, args);
+
+    va_end( args);
+
+    return( status);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Parcours de tous les noeuds d'une structure de données et exécution d'une    */
+/* commande sur chacun d'eux                                                    */
+/*------------------------------------------------------------------------------*/
+/* (I) Root     : pointeur sur la racine de la structure de données à parcourir */
+/* (I) Command  : Commande à exécuter sur chaque noeud traversé                 */
+/* (I) Data     : pointeur de données utilisateur                               */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status ND_DataStruct_Traverse_VI( NDT_Root  *Root_Ptr, NDT_Command  Command, va_list Args)
+{
+    NDT_Status    status;
+    NDT_Index_Id  new_index;
+    NDT_Command   new_cmd;
+
+
+    status = ND_Manager_Exec_I( Root_Ptr, NDD_INDEX_PRIMARY, NULL, NDD_CMD_INDEX_GET, &new_index, &new_cmd, Command, NULL);
+    if( ND_ERROR(status)) return( status);
+
+    return( ND_Index_Traverse_VI( Root_Ptr, new_index, new_cmd, Args));
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Parcours de tous les noeuds d'une structure de données et exécution d'une    */
+/* commande sur chacun d'eux                                                    */
+/*------------------------------------------------------------------------------*/
+/* (I) Root     : pointeur sur la racine de la structure de données à parcourir */
+/* (I) Command  : Commande à exécuter sur chaque noeud traversé                 */
+/* (I) Data     : pointeur de données utilisateur                               */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_DataStruct_Traverse_VC( NDT_Root  *Root_Ptr, NDT_Command  Command, va_list  Args)
+{
+    if( NDG_Base.Open_Status != NDD_TRUE)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Traverse_VC: library is not open");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    if( !Root_Ptr)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Traverse_VC: structure root is null");
+        ND_Error_Print();
+        return( NDS_ERRAPI);
+    }
+
+    return( ND_DataStruct_Traverse_VI( Root_Ptr, Command, Args));
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Parcours de tous les noeuds d'une structure de données et exécution d'une    */
+/* commande sur chacun d'eux                                                    */
+/*------------------------------------------------------------------------------*/
+/* (I) Root     : pointeur sur la racine de la structure de données à parcourir */
+/* (I) Command  : Commande à exécuter sur chaque noeud traversé                 */
+/* (I) Data     : pointeur de données utilisateur                               */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status ND_DataStruct_Traverse_I( NDT_Root  *Root_Ptr, NDT_Command  Command, ...)
+{
+    NDT_Status    status;
+    va_list       args;
+    NDT_Index_Id  new_index;
+    NDT_Command   new_cmd;
+
+
+    va_start( args, Command);
+
+    status = ND_Manager_Exec_I( Root_Ptr, NDD_INDEX_PRIMARY, NULL, NDD_CMD_INDEX_GET, &new_index, &new_cmd, Command, NULL);
+    if( ND_ERROR( status)) return( status);
+
+    status = ND_Index_Traverse_VI( Root_Ptr, new_index, new_cmd, args);
+
+    va_end( args);
+
+    return( status);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Parcours de tous les noeuds d'une structure de données et exécution d'une    */
+/* commande sur chacun d'eux                                                    */
+/*------------------------------------------------------------------------------*/
+/* (I) Root     : pointeur sur la racine de la structure de données à parcourir */
+/* (I) Command  : Commande à exécuter sur chaque noeud traversé                 */
+/* (I) Data     : pointeur de données utilisateur                               */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_DataStruct_Traverse_C( NDT_Root  *Root_Ptr, NDT_Command  Command, ...)
+{
+    NDT_Status  status;
+    va_list     args;
+
+
+    va_start( args, Command);
+
+    if( NDG_Base.Open_Status != NDD_TRUE)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Taverse_C: library is not open");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    if( !Root_Ptr)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Traverse_C: structure root is null");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    status = ND_DataStruct_Traverse_VI( Root_Ptr, Command, args);
+
+    va_end( args);
+
+    return( status);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Affichage d'informations sur une structure de données                        */
+/*------------------------------------------------------------------------------*/
+/* (I) Root: pointeur sur la racine de la structure de données                  */
+/* (I) Out : flux de sortie                                                     */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status ND_Index_Info_Print_I( FILE  *Out, NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id, NDT_Recursive_Mode  Recursive_Mode, NDT_Recursive_Depth  Recursive_Depth, NDT_Recursive_Offset Recursive_Offset)
+{
+    NDT_Status  status;
+    char        offset[255];
+
+
+    if( ND_RECURSIVE_PARENT_IS( Recursive_Mode))
+    {
+        memset( offset, ' ', Recursive_Offset * ND_RECURSIVE_PRINT_OFFSET);
+	offset[Recursive_Offset * ND_RECURSIVE_PRINT_OFFSET] = '\0';
+
+	fprintf( Out, "%s    Index Id: (%d)\tType: (%#06x) [%s:%s:%s]\tNode Nb: (%d)\tHead: (%s%p)\tTail: (%s%p)\n%s    Min Depth: (%d)\tMax Depth: (%d)\tMax Dif: (%d)\tNb Equ: (%d)\tSave: (%s%p)\n\n",
+		offset, Index_Id, Root_Ptr->Index_Tab[Index_Id].Type, ND_INDEX_STATUS_ASCII_GET( Root_Ptr, Index_Id), ND_INDEX_TYPE_ASCII_GET( Root_Ptr, Index_Id), ND_INDEX_SUBTYPE_ASCII_GET( Root_Ptr, Index_Id),
+		Root_Ptr->Index_Tab[Index_Id].Node_Number,
+		NDD_PRINTF_PTR_PREFIX, Root_Ptr->Index_Tab[Index_Id].Head, NDD_PRINTF_PTR_PREFIX, Root_Ptr->Index_Tab[Index_Id].Tail,
+		offset, Root_Ptr->Index_Tab[Index_Id].Min_Depth, Root_Ptr->Index_Tab[Index_Id].Max_Depth, Root_Ptr->Index_Tab[Index_Id].Max_Dif, Root_Ptr->Index_Tab[Index_Id].Nb_Equ,
+		NDD_PRINTF_PTR_PREFIX, Root_Ptr->Index_Tab[Index_Id].Save);
+    }
+
+    if( ND_RECURSIVE_CHILD_IS(Recursive_Mode))
+    {
+        status = ND_Index_Traverse_I( Root_Ptr, Index_Id, NDD_CMD_INFO_PRINT, Out, NDD_RECURSIVE_MODE_PARENT_CHILD, Recursive_Depth, Recursive_Offset);
+    }
+    else
+    {
+        status = NDS_OK;
+    }
+
+    return( status);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Affichage d'informations sur une structure de données                        */
+/*------------------------------------------------------------------------------*/
+/* (I) Root: pointeur sur la racine de la structure de données                  */
+/* (I) Out : flux de sortie                                                     */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_Index_Info_Print_C( FILE  *Out, NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id, NDT_Recursive_Mode  Recursive_Mode, NDT_Recursive_Depth  Recursive_Depth, NDT_Recursive_Offset  Recursive_Offset)
+{
+    if( NDG_Base.Open_Status != NDD_TRUE)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Index_Info_Print_C: library is not open");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    if( !Root_Ptr)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Index_Info_Print_C: structure root is null");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    if( !Out)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Index_Info_Print_C: the stream descriptor is null");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    return( ND_Index_Info_Print_I( Out, Root_Ptr, Index_Id, Recursive_Mode, Recursive_Depth, Recursive_Offset));
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Affichage d'informations sur une structure de données                        */
+/*------------------------------------------------------------------------------*/
+/* (I) Root: pointeur sur la racine de la structure de données                  */
+/* (I) Out : flux de sortie                                                     */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status ND_DataStruct_Info_Print_I( FILE  *Out, NDT_Root  *Root_Ptr, NDT_Recursive_Mode  Recursive_Mode, NDT_Recursive_Depth  Recursive_Depth, NDT_Recursive_Offset Recursive_Offset)
+{
+    NDT_Status	      status;
+    NDT_Index_Nb      idx;
+    NDT_Version_Name  version_name;
+    char              offset[255];
+
+
+    if( ND_RECURSIVE_PARENT_IS( Recursive_Mode))
+    {
+        memset( offset, ' ', Recursive_Offset * ND_RECURSIVE_PRINT_OFFSET);
+	offset[Recursive_Offset * ND_RECURSIVE_PRINT_OFFSET] = '\0';
+
+	status = ND_Manager_Exec_I( Root_Ptr, NDD_INDEX_UNKNOWN, NULL, NDD_CMD_MANAGER_VERSION, &version_name);
+	if( ND_ERROR( status)) return( status);
+
+	fprintf( Out, "%sRoot: (%s%p)\tIndex Nb: (%d)\tIndex Open Count: (%d)\tManager: (%s%p) [%s]\n%sAllocator: (%s%p) [%s]\tDesallocator: (%s%p) [%s]\tUser: (%s%p)\n%sManager Version: [%s]\n\n",
+		offset, NDD_PRINTF_PTR_PREFIX, Root_Ptr, Root_Ptr->Index_Nb, Root_Ptr->Index_Open_Count, NDD_PRINTF_PTR_PREFIX, Root_Ptr->Manager_Ptr, Root_Ptr->Manager_Name,
+                offset, NDD_PRINTF_PTR_PREFIX, Root_Ptr->Allocator_Ptr, Root_Ptr->Allocator_Name, NDD_PRINTF_PTR_PREFIX, Root_Ptr->Desallocator_Ptr, Root_Ptr->Desallocator_Name, NDD_PRINTF_PTR_PREFIX, Root_Ptr->User_Ptr,
+		offset, version_name);
+    }
+
+    if( ND_RECURSIVE_CHILD_IS( Recursive_Mode))
+    {
+        for( idx = NDD_INDEX_PRIMARY; idx < Root_Ptr->Index_Nb; idx++)
+	{
+	    status = ND_Index_Info_Print_I( Out, Root_Ptr, idx, NDD_RECURSIVE_MODE_PARENT, 0, Recursive_Offset);
+	    if( ND_ERROR( status)) return( status);
+	}
+
+	return( ND_Index_Info_Print_I( Out, Root_Ptr, NDD_INDEX_PRIMARY, NDD_RECURSIVE_MODE_CHILD, Recursive_Depth, Recursive_Offset));
+    }
+    else
+    {
+        return( NDS_OK);
+    }
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Affichage d'informations sur une structure de données                        */
+/*------------------------------------------------------------------------------*/
+/* (I) Root: pointeur sur la racine de la structure de données                  */
+/* (I) Out : flux de sortie                                                     */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_DataStruct_Info_Print_C( FILE  *Out, NDT_Root  *Root_Ptr, NDT_Recursive_Mode  Recursive_Mode, NDT_Recursive_Depth  Recursive_Depth, NDT_Recursive_Offset  Recursive_Offset)
+{
+    if( NDG_Base.Open_Status != NDD_TRUE)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Info_Print_C: library is not open");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    if( !Root_Ptr)
+    {
+        sprintf (NDG_Base.Err_String, "Error ND_DataStruct_Info_Print_C: structure root is null");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    if( !Out)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Info_Print_C: the stream descriptor is null");
+        ND_Error_Print();
+        return( NDS_ERRAPI);
+    }
+
+    return( ND_DataStruct_Info_Print_I( Out, Root_Ptr, Recursive_Mode, Recursive_Depth, Recursive_Offset));
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Ajout d'une valeur à une structure de données                                */
+/*------------------------------------------------------------------------------*/
+/* (I) Root   : pointeur sur la racine de la structure de données               */
+/* (I) Value  : pointeur sur la valeur à ajouter à la structure de données      */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_Index_Value_Add_I( NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id, void  *Value_Ptr)
+{
+    NDT_Status	  status;
+
+
+    if( ND_INDEX_TYPE_LIST_IS( Root_Ptr, Index_Id))
+    {
+        status = ND_List_Value_Add( Root_Ptr, Index_Id, Value_Ptr);
+        if(ND_ERROR( status)) return( status);
+    }
+    else if( ND_INDEX_TYPE_TREE_IS( Root_Ptr, Index_Id))
+    {
+        status = ND_Tree_Value_Add( Root_Ptr, Index_Id, Value_Ptr);
+	if(ND_ERROR( status)) return( status);
+    }
+    else
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Index_Value_Add_I: unknown structure type (%d)", Root_Ptr->Index_Tab[Index_Id].Type);
+        ND_Error_Print();
+        return( NDS_ERRAPI);
+    }
+
+    return( NDS_OK);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Ajout d'une valeur à une structure de données                                */
+/*------------------------------------------------------------------------------*/
+/* (I) Root   : pointeur sur la racine de la structure de données               */
+/* (I) Value  : pointeur sur la valeur à ajouter à la structure de données      */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_Index_Value_Add_C( NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id, void  *Value_Ptr)
+{
+    if( NDG_Base.Open_Status != NDD_TRUE)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Index_Value_Add_C: library is not open");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    if( !Root_Ptr)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Index_Value_Add_C: structure root is null");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    if( !Value_Ptr)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Index_Value_Add_C: the value to add is null");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    return( ND_Index_Value_Add_I( Root_Ptr, Index_Id, Value_Ptr));
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Ajout d'une valeur à une structure de données                                */
+/*------------------------------------------------------------------------------*/
+/* (I) Root   : pointeur sur la racine de la structure de données               */
+/* (I) Value  : pointeur sur la valeur à ajouter à la structure de données      */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_DataStruct_Value_Add_I( NDT_Root  *Root_Ptr, void  *Value_Ptr)
+{
+    NDT_Status	  status;
+    NDT_Index_Id  index_id;
+
+
+    for( index_id = 0; index_id < Root_Ptr->Index_Nb; index_id++)
+    {
+        if( ND_INDEX_STATUS_OPENED_IS( Root_Ptr, index_id))
+        {
+            status = ND_Index_Value_Add_I( Root_Ptr, index_id, Value_Ptr);
+            if( ND_ERROR( status)) return( status);
+        }
+    }
+
+    return( NDS_OK);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Ajout d'une valeur à une structure de données                                */
+/*------------------------------------------------------------------------------*/
+/* (I) Root   : pointeur sur la racine de la structure de données               */
+/* (I) Value  : pointeur sur la valeur à ajouter à la structure de données      */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_DataStruct_Value_Add_C( NDT_Root  *Root_Ptr, void  *Value_Ptr)
+{
+    if( NDG_Base.Open_Status != NDD_TRUE)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Value_Add_C: library is not open");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    if( !Root_Ptr)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Value_Add_C: structure root is null");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    if( !Value_Ptr)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_DatatStruct_Value_Add_C: the value to add is null");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    return( ND_DataStruct_Value_Add_I( Root_Ptr, Value_Ptr));
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Suppression du premier noeud correspondant à une valeur donnée               */
+/*------------------------------------------------------------------------------*/
+/* (I) Root            : pointeur sur la racine de la structure de données      */
+/* (I) Reference_Value : pointeur sur la valeur de référence                    */
+/* (I) Removed_Value   : adresse d'un pointeur sur la valeur supprimée          */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_Index_Value_Remove_I( NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id, void  *Value_Ptr)
+{
+    NDT_Status	   status;
+    NDT_Node      *node_ptr;
+
+
+    /* Recherche du premier noeud correspondant à la valeur de référence */
+
+    status = ND_Index_Node_Find_I( &node_ptr, Root_Ptr, Index_Id, Value_Ptr);
+    if( ND_ERROR( status)) return( status);
+
+    if( !node_ptr) return( NDS_OK);
+
+    /* manager call */
+
+    status = ND_Manager_Exec_I( Root_Ptr, Index_Id, node_ptr, NDD_CMD_VALUE_REMOVE, Value_Ptr);
+    if (ND_ERROR( status)) return( status);
+
+    /* Retrait du noeud de la structure */
+
+    status = ND_Index_Node_Remove_I( node_ptr);
+    if( ND_ERROR( status)) return( status);
+
+    /* Désallocation du noeud */
+
+    status = ND_Node_Free( Root_Ptr, node_ptr);
+
+    return( status);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Suppression du premier noeud correspondant à une valeur donnée               */
+/*------------------------------------------------------------------------------*/
+/* (I) Root            : pointeur sur la racine de la structure de données      */
+/* (I) Reference_Value : pointeur sur la valeur de référence                    */
+/* (I) Removed_Value   : adresse d'un pointeur sur la valeur supprimée          */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_Index_Value_Remove_C( NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id, void  *Value_Ptr)
+{
+    if( NDG_Base.Open_Status != NDD_TRUE)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Index_Value_Remove_C: library is not open");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    if( !Root_Ptr)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Index_Value_Remove_C: structure root is null");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    if( !Value_Ptr)
+    {
+        sprintf (NDG_Base.Err_String, "Error ND_Index_Value_Remove_C: the value is null");
+        ND_Error_Print ();
+
+        return( NDS_ERRAPI);
+    }
+
+    return( ND_Index_Value_Remove_I( Root_Ptr, Index_Id, Value_Ptr));
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Suppression du premier noeud correspondant à une valeur donnée               */
+/*------------------------------------------------------------------------------*/
+/* (I) Root            : pointeur sur la racine de la structure de données      */
+/* (I) Reference_Value : pointeur sur la valeur de référence                    */
+/* (I) Removed_Value   : adresse d'un pointeur sur la valeur supprimée          */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_DataStruct_Value_Remove_I( NDT_Root  *Root_Ptr, void  *Value_Ptr)
+{
+    NDT_Status	  status;
+    NDT_Index_Id  index_id;
+
+
+    for( index_id = 0; index_id < Root_Ptr->Index_Nb; index_id++)
+    {
+        if( ND_INDEX_STATUS_OPENED_IS( Root_Ptr, index_id))
+        {
+            status = ND_Index_Value_Remove_I( Root_Ptr, index_id, Value_Ptr);
+            if( ND_ERROR( status)) return( status);
+	}
+    }
+
+    return( NDS_OK);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Suppression du premier noeud correspondant à une valeur donnée               */
+/*------------------------------------------------------------------------------*/
+/* (I) Root            : pointeur sur la racine de la structure de données      */
+/* (I) Reference_Value : pointeur sur la valeur de référence                    */
+/* (I) Removed_Value   : adresse d'un pointeur sur la valeur supprimée          */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_DataStruct_Value_Remove_C( NDT_Root  *Root_Ptr, void  *Value_Ptr)
+{
+    if( NDG_Base.Open_Status != NDD_TRUE)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Value_Remove_C: library is not open");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    if( !Root_Ptr)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Value_Remove_C: structure root is null");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    if( !Value_Ptr)
+    {
+        sprintf (NDG_Base.Err_String, "Error ND_DataStruct_Value_Remove_C: the value is null");
+        ND_Error_Print ();
+
+        return( NDS_ERRAPI);
+    }
+
+    return( ND_DataStruct_Value_Remove_I( Root_Ptr, Value_Ptr));
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Affichage d'une structure de données                                         */
+/*------------------------------------------------------------------------------*/
+/* (I) Root : pointeur sur la racine de la structure de données à afficher      */
+/* (I) Out  : flux de sortie                                                    */
+/*------------------------------------------------------------------------------*/
+NDT_Status ND_Index_Value_Print_VI( FILE  *Out, NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id, NDT_Recursive_Mode  Recursive_Mode,  NDT_Recursive_Depth  Recursive_Depth, NDT_Recursive_Offset  Recursive_Offset, va_list  Args)
+{
+    NDT_Status  status;
+
+
+    status = ND_Index_Traverse_I( Root_Ptr, Index_Id, NDD_CMD_VALUE_PRINT, Out, Recursive_Mode, Recursive_Depth, Recursive_Offset, Args);
+
+    return( status);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Affichage d'une structure de données                                         */
+/*------------------------------------------------------------------------------*/
+/* (I) Root : pointeur sur la racine de la structure de données à afficher      */
+/* (I) Out  : flux de sortie                                                    */
+/*------------------------------------------------------------------------------*/
+NDT_Status ND_Index_Value_Print_I( FILE  *Out, NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id, NDT_Recursive_Mode  Recursive_Mode, NDT_Recursive_Depth  Recursive_Depth, NDT_Recursive_Offset  Recursive_Offset, ...)
+{
+    NDT_Status  status;
+    va_list     user_args;
+
+
+    va_start( user_args, Recursive_Offset);
+
+    status = ND_Index_Traverse_I( Root_Ptr, Index_Id, NDD_CMD_VALUE_PRINT, Out, Recursive_Mode, Recursive_Depth, Recursive_Offset, user_args);
+
+    va_end( user_args);
+
+    return( status);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Affichage d'une structure de données                                         */
+/*------------------------------------------------------------------------------*/
+/* (I) Root : pointeur sur la racine de la structure de données à afficher      */
+/* (I) Out  : flux de sortie                                                    */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_Index_Value_Print_C( FILE  *Out, NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id, NDT_Recursive_Mode  Recursive_Mode, NDT_Recursive_Depth  Recursive_Depth, NDT_Recursive_Offset  Recursive_Offset, ...)
+{
+    NDT_Status  status;
+    va_list     user_args;
+
+
+    va_start( user_args, Recursive_Offset);
+
+    if( NDG_Base.Open_Status != NDD_TRUE)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Index_Value_Print_C: library is not open");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    if( !Root_Ptr)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Index_Value_Print_C: structure root is null");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    if( !Out)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Index_Value_Print_C: the stream descriptor is null");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    status = ND_Index_Value_Print_VI( Out, Root_Ptr, Index_Id, Recursive_Mode, Recursive_Depth, Recursive_Offset, user_args);
+
+    va_end( user_args);
+
+    return( status);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Affichage d'une structure de données                                         */
+/*------------------------------------------------------------------------------*/
+/* (I) Root : pointeur sur la racine de la structure de données à afficher      */
+/* (I) Out  : flux de sortie                                                    */
+/*------------------------------------------------------------------------------*/
+NDT_Status ND_DataStruct_Value_Print_VI( FILE  *Out, NDT_Root  *Root_Ptr, NDT_Recursive_Mode  Recursive_Mode, NDT_Recursive_Depth  Recursive_Depth, NDT_Recursive_Offset  Recursive_Offset, va_list  User_Args)
+{
+    NDT_Status  status;
+
+    status = ND_DataStruct_Traverse_I( Root_Ptr, NDD_CMD_VALUE_PRINT, Out, Recursive_Mode, Recursive_Depth, Recursive_Offset, User_Args);
+
+    return( status);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Affichage d'une structure de données                                         */
+/*------------------------------------------------------------------------------*/
+/* (I) Root : pointeur sur la racine de la structure de données à afficher      */
+/* (I) Out  : flux de sortie                                                    */
+/*------------------------------------------------------------------------------*/
+NDT_Status ND_DataStruct_Value_Print_I( FILE  *Out, NDT_Root  *Root_Ptr, NDT_Recursive_Mode  Recursive_Mode, NDT_Recursive_Depth  Recursive_Depth, NDT_Recursive_Offset  Recursive_Offset, ...)
+{
+    NDT_Status  status;
+    va_list     user_args;
+
+
+    va_start( user_args, Recursive_Offset);
+
+    status = ND_DataStruct_Traverse_I( Root_Ptr, NDD_CMD_VALUE_PRINT, Out, Recursive_Mode, Recursive_Depth, Recursive_Offset, user_args);
+
+    va_end( user_args);
+
+    return( status);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Affichage d'une structure de données                                         */
+/*------------------------------------------------------------------------------*/
+/* (I) Root : pointeur sur la racine de la structure de données à afficher      */
+/* (I) Out  : flux de sortie                                                    */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_DataStruct_Value_Print_C( FILE  *Out, NDT_Root  *Root_Ptr, NDT_Recursive_Mode  Recursive_Mode, NDT_Recursive_Depth  Recursive_Depth, NDT_Recursive_Offset  Recursive_Offset, ...)
+{
+    NDT_Status  status;
+    va_list     user_args;
+
+
+    va_start( user_args, Recursive_Offset);
+
+    if( NDG_Base.Open_Status != NDD_TRUE)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Value_Print_C: library is not open");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    if( !Root_Ptr)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Value_Print_C: structure root is null");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    if( !Out)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Value_Print_C: the stream descriptor is null");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    status =  ND_DataStruct_Value_Print_VI( Out, Root_Ptr, Recursive_Mode, Recursive_Depth, Recursive_Offset, user_args);
+
+    va_end( user_args);
+
+    return( status);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Ajout d'un noeud à une structure de données                                  */
+/*------------------------------------------------------------------------------*/
+/* (I) Root : pointeur sur la racine de la structure de données                 */
+/* (I) Node : pointeur sur le noeud à ajouter                                   */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_Index_Node_Add_I( NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id, NDT_Node  *Node_Ptr )
+{
+    if( ND_INDEX_TYPE_LIST_IS( Root_Ptr, Index_Id)) return ND_List_Node_Add( Root_Ptr, Index_Id, Node_Ptr);
+    else if( ND_INDEX_TYPE_TREE_IS( Root_Ptr, Index_Id)) return ND_Tree_Node_Add( Root_Ptr, Index_Id, Node_Ptr);
+    else
+    {
+        sprintf (NDG_Base.Err_String, "Error ND_Index_Node_Add_I: unknown structure type (%d)", Root_Ptr->Index_Tab[Index_Id].Type);
+        ND_Error_Print ();
+        return( NDS_ERRAPI);
+    }
+
+    return( NDS_KO);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Ajout d'un noeud à une structure de données                                  */
+/*------------------------------------------------------------------------------*/
+/* (I) Root : pointeur sur la racine de la structure de données                 */
+/* (I) Node : pointeur sur le noeud à ajouter                                   */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_Index_Node_Add_C( NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id, NDT_Node  *Node_Ptr)
+{ 
+    if( NDG_Base.Open_Status != NDD_TRUE)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Index_Node_Add_C: library is not open");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    if( !Root_Ptr)
+    {
+        sprintf (NDG_Base.Err_String, "Error ND_Index_Node_Add_C: structure root is null");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    if( !Node_Ptr)
+    {
+        sprintf (NDG_Base.Err_String, "Error ND_Index_Node_Add_C: the node to add is null");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    return( ND_Index_Node_Add_I( Root_Ptr, Index_Id, Node_Ptr));
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Suppression d'un noeud dans une structure de données                         */
+/*------------------------------------------------------------------------------*/
+/* (I) Node: pointeur sur le noeud à supprimer                                  */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_Index_Node_Remove_I( NDT_Node  *Node_Ptr)
+{
+    NDT_Root      *root_ptr;
+    NDT_Index_Id   index_id;
+
+
+    root_ptr = Node_Ptr->Root;
+    index_id = Node_Ptr->Index;
+
+    if( ND_INDEX_TYPE_LIST_IS( root_ptr, index_id)) return ND_List_Node_Remove( Node_Ptr);
+    else if( ND_INDEX_TYPE_TREE_IS( root_ptr, index_id))
+    {
+        NDT_Node  **tmp_ptr_ptr;
+
+        /* On récupère l'adresse du lien entre le noeud à supprimer et son père */
+
+        if( Node_Ptr->Parent)
+        {
+            /* Cas général */
+
+            if( Node_Ptr == Node_Ptr->Parent->Left) tmp_ptr_ptr = &(Node_Ptr->Parent->Left);
+            else tmp_ptr_ptr = &(Node_Ptr->Parent->Right);
+        }
+        else
+        {
+            /* Cas du noeud racine */
+
+            tmp_ptr_ptr = NULL;
+        }
+
+        if( Node_Ptr->Right)
+        {
+            NDT_Node  *Right_Node_Ptr = Node_Ptr->Right;
+            NDT_Node  *Left_Node_Ptr = Node_Ptr->Left;
+            NDT_Node  *First_Node_Ptr;
+
+            /*
+	      On sauve le fils gauche du noeud à supprimer dans un pointeur de
+	      sauvegarde pour pouvoir le récupérer au cas où la procédure serait
+	      interrompue (recovery).
+            */
+
+            root_ptr->Index_Tab[index_id].Save = Left_Node_Ptr;
+
+            /* On remplace le noeud supprimé par son sous-arbre droit */
+
+            if( !tmp_ptr_ptr) root_ptr->Index_Tab[index_id].Head = root_ptr->Index_Tab[index_id].Tail = Node_Ptr->Right;
+            else *tmp_ptr_ptr = Node_Ptr->Right;
+
+            Right_Node_Ptr->Parent = Node_Ptr->Parent;
+
+            /* On attache le sous-arbre gauche au premier noeud du sous-arbre droit */
+
+            if( root_ptr->Index_Tab[index_id].Save)
+            {
+                First_Node_Ptr = ND_Tree_Node_First_Recursive_Get(Right_Node_Ptr);
+
+                First_Node_Ptr->Left = root_ptr->Index_Tab[index_id].Save;
+
+                root_ptr->Index_Tab[index_id].Save->Parent = First_Node_Ptr;
+
+                root_ptr->Index_Tab[index_id].Save = NULL;
+            }
+        }
+        else
+        {
+            /* On remplace le noeud supprimé par son sous-arbre gauche */
+
+            if( !tmp_ptr_ptr) root_ptr->Index_Tab[index_id].Head = root_ptr->Index_Tab[index_id].Tail = Node_Ptr->Left;
+            else *tmp_ptr_ptr = Node_Ptr->Left;
+
+            if( Node_Ptr->Left) Node_Ptr->Left->Parent = Node_Ptr->Parent;
+        }
+
+        root_ptr->Index_Tab[index_id].Node_Number--;
+
+        /* Pas de mise à jour des informations de profondeur : trop coûteux */
+
+        Node_Ptr->Root = NULL;
+        Node_Ptr->Index = NDD_INDEX_UNKNOWN;
+        Node_Ptr->Left = NULL;
+        Node_Ptr->Right = NULL;
+        Node_Ptr->Parent = NULL;
+    }
+    else
+    {
+        sprintf (NDG_Base.Err_String, "Error ND_Index_Node_Remove_I: unknown structure type (%d)", root_ptr->Index_Tab[index_id].Type);
+        ND_Error_Print ();
+        return(NDS_ERRAPI);
+    }
+
+    return(NDS_OK);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Suppression d'un noeud dans une structure de données                         */
+/*------------------------------------------------------------------------------*/
+/* (I) Node: pointeur sur le noeud à supprimer                                  */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_Index_Node_Remove_C( NDT_Node  *Node_Ptr)
+{
+    if( NDG_Base.Open_Status != NDD_TRUE)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Index_Node_Remove_C: library is not open");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    if( !Node_Ptr)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Index_Node_Remove_C: the node to remove is null");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    return( ND_Index_Node_Remove_I( Node_Ptr));
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Récupération du premier noeud d'une structure                                */
+/*------------------------------------------------------------------------------*/
+/* (I) Root       : pointeur sur la racine dont on cherche le premier noeud     */
+/* (O) First_Node : adresse du pointeur sur le premier noeud                    */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status ND_Index_Node_First_Get_I( NDT_Node  **First_Node_Ptr_Ptr, NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id)
+{
+    *First_Node_Ptr_Ptr = NULL;
+
+    if( ND_INDEX_TYPE_LIST_IS(Root_Ptr, Index_Id)) *First_Node_Ptr_Ptr = (Root_Ptr->Index_Tab)[Index_Id].Head;
+
+    else if( ND_INDEX_TYPE_TREE_IS(Root_Ptr, Index_Id)) *First_Node_Ptr_Ptr = ND_Tree_Node_First_Recursive_Get( Root_Ptr->Index_Tab[Index_Id].Head);
+
+    //    if(!*First_Node_Ptr_Ptr) return(NDS_KO);
+
+    return( NDS_OK);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Récupération du premier noeud d'une structure                                */
+/*------------------------------------------------------------------------------*/
+/* (I) Root       : pointeur sur la racine dont on cherche le premier noeud     */
+/* (O) First_Node : adresse du pointeur sur le premier noeud                    */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_Index_Node_First_Get_C( NDT_Node  **First_Node_Ptr_Ptr, NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id)
+{
+    if( NDG_Base.Open_Status != NDD_TRUE)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Index_Node_First_Get_C: library is not open");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    if( !Root_Ptr)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Index_Node_First_Get_C: structure root is null");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    return( ND_Index_Node_First_Get_I( First_Node_Ptr_Ptr, Root_Ptr, Index_Id));
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Récupération du dernier noeud d'une structure                                */
+/*------------------------------------------------------------------------------*/
+/* (I) Root      : pointeur sur la racine dont on cherche le dernier noeud      */
+/* (O) Last_Node : adresse du pointeur sur le premier noeud                     */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status ND_Index_Node_Last_Get_I ( NDT_Node  **Last_Node_Ptr_Ptr, NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id)
+{
+    *Last_Node_Ptr_Ptr = NULL;
+
+    if( ND_INDEX_TYPE_LIST_IS(Root_Ptr, Index_Id)) *Last_Node_Ptr_Ptr = Root_Ptr->Index_Tab[Index_Id].Tail;
+
+    else if( ND_INDEX_TYPE_TREE_IS(Root_Ptr, Index_Id)) *Last_Node_Ptr_Ptr = ND_Tree_Node_Last_Recursive_Get( Root_Ptr->Index_Tab[Index_Id].Head);
+
+    //    if(!*Last_Node_Ptr_Ptr) return(NDS_KO);
+
+    return( NDS_OK);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Récupération du dernier noeud d'une structure                                */
+/*------------------------------------------------------------------------------*/
+/* (I) Root      : pointeur sur la racine dont on cherche le dernier noeud      */
+/* (O) Last_Node : adresse du pointeur sur le premier noeud                     */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_Index_Node_Last_Get_C( NDT_Node  **Last_Node_Ptr_Ptr, NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id)
+{
+    if( NDG_Base.Open_Status != NDD_TRUE)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Index_Node_Last_Get_C: library is not open");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    if( !Root_Ptr)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Index_Node_Last_Get_C: structure root is null");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    return( ND_Index_Node_Last_Get_I( Last_Node_Ptr_Ptr, Root_Ptr, Index_Id));
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Récupération du noeud suivant                                                */
+/*------------------------------------------------------------------------------*/
+/* (I) Node      : pointeur sur le noeud dont on cherche le suivant             */
+/* (O) Next_Node : adresse du pointeur sur le noeud suivant                     */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status ND_Index_Node_Next_Get_I ( NDT_Node  **Next_Node_Ptr_Ptr, NDT_Node  *Node_Ptr)
+{
+    if( ND_INDEX_TYPE_LIST_IS( Node_Ptr->Root, Node_Ptr->Index))
+    {
+        *Next_Node_Ptr_Ptr = Node_Ptr->Right;
+    }
+    else if( ND_INDEX_TYPE_TREE_IS( Node_Ptr->Root, Node_Ptr->Index))
+    {
+        if( !Node_Ptr->Right)
+	{
+	    *Next_Node_Ptr_Ptr = ND_Tree_Parent_Next_Recursive_Get(Node_Ptr);
+	}
+        else
+	{
+	    *Next_Node_Ptr_Ptr = ND_Tree_Node_First_Recursive_Get(Node_Ptr->Right);
+	}
+    }
+
+    //    if(!*Next_Node_Ptr_Ptr) return(NDS_KO);
+
+    return( NDS_OK);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Récupération du noeud suivant                                                */
+/*------------------------------------------------------------------------------*/
+/* (I) Node      : pointeur sur le noeud dont on cherche le suivant             */
+/* (O) Next_Node : adresse du pointeur sur le noeud suivant                     */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_Index_Node_Next_Get_C( NDT_Node  **Next_Node_Ptr_Ptr, NDT_Node  *Node_Ptr)
+{
+    if( NDG_Base.Open_Status != NDD_TRUE)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Index_Node_Next_Get_C: library is not open");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    if( !Node_Ptr)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Index_Node_Next_Get_C: node is null");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    return( ND_Index_Node_Next_Get_I( Next_Node_Ptr_Ptr, Node_Ptr));
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Récupération du noeud précédant                                              */
+/*------------------------------------------------------------------------------*/
+/* (I) Node      : pointeur sur le noeud dont on cherche le précédant           */
+/* (O) Prev_Node : adresse du pointeur sur le noeud suivant                     */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_Index_Node_Previous_Get_I( NDT_Node  **Prev_Node_Ptr_Ptr, NDT_Node  *Node_Ptr)
+{
+    if( ND_INDEX_TYPE_LIST_IS( Node_Ptr->Root, Node_Ptr->Index)) *Prev_Node_Ptr_Ptr = Node_Ptr->Left;
+
+    if( ND_INDEX_TYPE_TREE_IS( Node_Ptr->Root, Node_Ptr->Index))
+    {
+        if( !Node_Ptr->Left)
+	{
+	    *Prev_Node_Ptr_Ptr = ND_Tree_Parent_Previous_Recursive_Get( Node_Ptr);
+	}
+        else
+	{
+	    *Prev_Node_Ptr_Ptr = ND_Tree_Node_Last_Recursive_Get( Node_Ptr->Left);
+	}
+    }
+
+    //    if( !*Prev_Node_Ptr_Ptr) return( NDS_KO);
+
+    return( NDS_OK);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Récupération du noeud précédant                                              */
+/*------------------------------------------------------------------------------*/
+/* (I) Node      : pointeur sur le noeud dont on cherche le précédant           */
+/* (O) Prev_Node : adresse du pointeur sur le noeud suivant                     */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_Index_Node_Previous_Get_C( NDT_Node  **Prev_Node_Ptr_Ptr, NDT_Node  *Node_Ptr)
+{
+    if( NDG_Base.Open_Status != NDD_TRUE)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Index_Node_Previous_Get_C: library is not open");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    if( !Node_Ptr)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Index_Node_Previous_Get_C: node is null");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    return( ND_Index_Node_Previous_Get_I( Prev_Node_Ptr_Ptr, Node_Ptr));
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Recherche un noeud à partir d'une valeur                                     */
+/*------------------------------------------------------------------------------*/
+/* (I) Root     : pointeur sur la racine de l'abre                              */
+/* (O) Node     : adresse du pointeur sur le noeud à récuperer                  */
+/* (I) Value    : pointeur sur la valeur à rechercher                           */
+/* (I) Data     : pointeur de données                                           */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_Index_Node_Find_VI( NDT_Node  **Node_Ptr_Ptr, NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id, void  *Value_Ptr, va_list  Args)
+{
+    if( ND_INDEX_TYPE_LIST_IS( Root_Ptr, Index_Id))
+    {
+        *Node_Ptr_Ptr = ND_List_Node_Find( Root_Ptr, Index_Id, Value_Ptr, Args);
+    }
+    else if ( ND_INDEX_TYPE_TREE_IS( Root_Ptr, Index_Id))
+    {
+        *Node_Ptr_Ptr = ND_Tree_Node_Find( Root_Ptr, Index_Id, Value_Ptr, Args);
+    }
+    else
+    {
+        sprintf (NDG_Base.Err_String, "Error ND_Index_Node_Find_VI: unknown structure type (%d)", Root_Ptr->Index_Tab[Index_Id].Type);
+        ND_Error_Print ();
+
+	return( NDS_KO);
+    }
+
+    return( NDS_OK);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Recherche un noeud à partir d'une valeur                                     */
+/*------------------------------------------------------------------------------*/
+/* (I) Root     : pointeur sur la racine de l'abre                              */
+/* (O) Node     : adresse du pointeur sur le noeud à récuperer                  */
+/* (I) Value    : pointeur sur la valeur à rechercher                           */
+/* (I) Data     : pointeur de données                                           */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_Index_Node_Find_VC( NDT_Node  **Node_Ptr_Ptr, NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id, void  *Value_Ptr, va_list  Args)
+{
+    NDT_Status  status;
+
+
+    if( NDG_Base.Open_Status != NDD_TRUE)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Index_Node_Find_VC: library is not open");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    if( !Root_Ptr)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Index_Node_Find_VC: structure root is null");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    if( !Value_Ptr)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Index_Node_Find_VC: the value to find is null");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    status = ND_Index_Node_Find_VI( Node_Ptr_Ptr, Root_Ptr, Index_Id, Value_Ptr, Args);
+
+
+    return( status);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Recherche un noeud à partir d'une valeur                                     */
+/*------------------------------------------------------------------------------*/
+/* (I) Root     : pointeur sur la racine de l'abre                              */
+/* (O) Node     : adresse du pointeur sur le noeud à récuperer                  */
+/* (I) Value    : pointeur sur la valeur à rechercher                           */
+/* (I) Data     : pointeur de données                                           */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_Index_Node_Find_I( NDT_Node  **Node_Ptr_Ptr, NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id, void  *Value_Ptr, ...)
+{
+    va_list  user_args;
+
+
+    va_start( user_args,  Value_Ptr);
+
+    if( ND_INDEX_TYPE_LIST_IS( Root_Ptr, Index_Id))
+    {
+        *Node_Ptr_Ptr = ND_List_Node_Find( Root_Ptr, Index_Id, Value_Ptr, user_args);
+    }
+    else if ( ND_INDEX_TYPE_TREE_IS( Root_Ptr, Index_Id))
+    {
+        *Node_Ptr_Ptr = ND_Tree_Node_Find( Root_Ptr, Index_Id, Value_Ptr, user_args);
+    }
+    else
+    {
+        sprintf (NDG_Base.Err_String, "Error ND_Index_Node_Find_I: unknown structure type (%d)", Root_Ptr->Index_Tab[Index_Id].Type);
+        ND_Error_Print ();
+    }
+
+    va_end( user_args);
+
+    return( NDS_OK);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Recherche un noeud à partir d'une valeur                                     */
+/*------------------------------------------------------------------------------*/
+/* (I) Root     : pointeur sur la racine de l'abre                              */
+/* (O) Node     : adresse du pointeur sur le noeud à récuperer                  */
+/* (I) Value    : pointeur sur la valeur à rechercher                           */
+/* (I) Data     : pointeur de données                                           */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_Index_Node_Find_C( NDT_Node  **Node_Ptr_Ptr, NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id, void  *Value_Ptr, ...)
+{
+    NDT_Status  status;
+    va_list     user_args;
+
+
+    va_start( user_args, Value_Ptr);
+
+    if( NDG_Base.Open_Status != NDD_TRUE)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Index_Node_Find_C: library is not open");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    if( !Root_Ptr)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Index_Node_Find_C: structure root is null");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    if( !Value_Ptr)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Index_Node_Find_C: the value to find is null");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    status = ND_Index_Node_Find_VI( Node_Ptr_Ptr, Root_Ptr, Index_Id, Value_Ptr, user_args);
+
+    va_end( user_args);
+
+    return( status);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Recherche un noeud à partir d'une valeur                                     */
+/*------------------------------------------------------------------------------*/
+/* (I) Root     : pointeur sur la racine de l'abre                              */
+/* (O) Node     : adresse du pointeur sur le noeud à récuperer                  */
+/* (I) Value    : pointeur sur la valeur à rechercher                           */
+/* (I) Data     : pointeur de données                                           */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_DataStruct_Value_Find_VI( void  **Value_Ptr_Ptr, NDT_Root  *Root_Ptr, void  *Ref_Value_Ptr, va_list  Args)
+{
+    NDT_Status     status;
+    NDT_Index_Id   new_index;
+    NDT_Command    new_cmd;
+    NDT_Node      *node_ptr;
+
+
+    status = ND_Manager_Exec_I( Root_Ptr, NDD_INDEX_PRIMARY, NULL, NDD_CMD_INDEX_GET, &new_index, &new_cmd, NDD_CMD_VALUE_FIND, Ref_Value_Ptr);
+    if( ND_ERROR(status)) return( status);
+
+    status = ND_Index_Node_Find_VI( &node_ptr, Root_Ptr, new_index, Ref_Value_Ptr, Args);
+    if( ND_ERROR(status)) return( status);
+
+    if( node_ptr != NULL)
+    {
+        *Value_Ptr_Ptr = node_ptr->Value;
+    }
+    else
+    {
+        *Value_Ptr_Ptr = NULL;
+    }
+
+    return( NDS_OK);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Recherche un noeud à partir d'une valeur                                     */
+/*------------------------------------------------------------------------------*/
+/* (I) Root     : pointeur sur la racine de l'abre                              */
+/* (O) Node     : adresse du pointeur sur le noeud à récuperer                  */
+/* (I) Value    : pointeur sur la valeur à rechercher                           */
+/* (I) Data     : pointeur de données                                           */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_DataStruct_Value_Find_VC( void  **Value_Ptr_Ptr, NDT_Root  *Root_Ptr, void  *Ref_Value_Ptr, va_list  Args)
+{
+    NDT_Status  status;
+
+
+    if( NDG_Base.Open_Status != NDD_TRUE)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Value_Find_VC: library is not open");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    if( !Root_Ptr)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Value_Find_VC: structure root is null");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    if( !Ref_Value_Ptr)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Value_Find_VC: the ref value to find is null");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    status = ND_DataStruct_Value_Find_VI( Value_Ptr_Ptr, Root_Ptr, Ref_Value_Ptr, Args);
+
+    return( status);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Recherche un noeud à partir d'une valeur                                     */
+/*------------------------------------------------------------------------------*/
+/* (I) Root     : pointeur sur la racine de l'abre                              */
+/* (O) Node     : adresse du pointeur sur le noeud à récuperer                  */
+/* (I) Value    : pointeur sur la valeur à rechercher                           */
+/* (I) Data     : pointeur de données                                           */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_DataStruct_Value_Find_I( void  **Value_Ptr_Ptr, NDT_Root  *Root_Ptr, void  *Ref_Value_Ptr, ...)
+{
+    NDT_Status     status;
+    va_list        user_args;
+    NDT_Index_Id   new_index;
+    NDT_Command    new_cmd;
+    NDT_Node      *node_ptr;
+
+
+    va_start( user_args,  Ref_Value_Ptr);
+
+    status = ND_Manager_Exec_I( Root_Ptr, NDD_INDEX_PRIMARY, NULL, NDD_CMD_INDEX_GET, &new_index, &new_cmd, NDD_CMD_VALUE_FIND, Ref_Value_Ptr);
+    if( ND_ERROR(status)) return( status);
+
+    status = ND_Index_Node_Find_VI( &node_ptr, Root_Ptr, new_index, Ref_Value_Ptr, user_args);
+    if( ND_ERROR(status)) return( status);
+
+    if( node_ptr != NULL)
+    {
+        *Value_Ptr_Ptr = node_ptr->Value;
+    }
+    else
+    {
+        *Value_Ptr_Ptr = NULL;
+    }
+
+    va_end( user_args);
+
+    return( NDS_OK);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Recherche un noeud à partir d'une valeur                                     */
+/*------------------------------------------------------------------------------*/
+/* (I) Root     : pointeur sur la racine de l'abre                              */
+/* (O) Node     : adresse du pointeur sur le noeud à récuperer                  */
+/* (I) Value    : pointeur sur la valeur à rechercher                           */
+/* (I) Data     : pointeur de données                                           */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_DataStruct_Value_Find_C( void  **Value_Ptr_Ptr, NDT_Root  *Root_Ptr, void  *Ref_Value_Ptr, ...)
+{
+    NDT_Status  status;
+    va_list     user_args;
+
+
+    va_start( user_args, Ref_Value_Ptr);
+
+    if( NDG_Base.Open_Status != NDD_TRUE)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Value_Find_C: library is not open");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    if( !Root_Ptr)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Value_Find_C: structure root is null");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    if( !Ref_Value_Ptr)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Value_Find_C: the ref value to find is null");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    status = ND_DataStruct_Value_Find_VI( Value_Ptr_Ptr, Root_Ptr, Ref_Value_Ptr, user_args);
+
+    va_end( user_args);
+
+    return(status);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Récupération de la racine d'une structure                                    */
+/*------------------------------------------------------------------------------*/
+/* (O) Root : adresse du pointeur sur la racine à récupérer                     */
+/* (I) Node : pointeur sur le noeud dont on cherche la racine                   */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status ND_Node_Root_Get_I( NDT_Root  **Root_Ptr_Ptr, NDT_Node  *Node_Ptr)
+{
+    *Root_Ptr_Ptr = Node_Ptr->Root;
+
+    return NDS_OK;
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Récupération de la racine d'une structure                                    */
+/*------------------------------------------------------------------------------*/
+/* (O) Root : adresse du pointeur sur la racine à récupérer                     */
+/* (I) Node : pointeur sur le noeud dont on cherche la racine                   */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_Node_Root_Get_C( NDT_Root  **Root_Ptr_Ptr, NDT_Node  *Node_Ptr )
+{
+    if( NDG_Base.Open_Status != NDD_TRUE)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Node_Root_Get_C: library is not open");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    if( !Node_Ptr)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Node_Root_Get_C: node is null");
+        ND_Error_Print();
+
+        return(NDS_ERRAPI);
+    }
+
+    return( ND_Node_Root_Get_I( Root_Ptr_Ptr, Node_Ptr));
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Allocation d'une valeur d'une structure de données                           */
+/*------------------------------------------------------------------------------*/
+/* (I) Root  : pointeur sur la racine de la structure de données                */
+/* (O) Value : adresse d'un pointeur sur la valeur à allouer                    */
+/* (I) ...   : arguments relatifs à l'allocation de la valeur                   */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_Value_Alloc_I( NDT_Root  *Root_Ptr, void  **Value_Ptr_Ptr, ...)
+{
+    NDT_Status	rc;
+    va_list		user_args;
+
+
+    /* Récupération des arguments pour l'allocation de la valeur */
+
+    va_start( user_args, Value_Ptr_Ptr);
+
+    /* Appel du manager */
+
+    rc = ND_Manager_Exec_I( Root_Ptr, NDD_INDEX_UNKNOWN, NULL, NDD_CMD_VALUE_ALLOC, Value_Ptr_Ptr, user_args);
+
+    va_end( user_args);
+
+    return( rc);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Allocation d'une valeur d'une structure de données                           */
+/*------------------------------------------------------------------------------*/
+/* (I) Root  : pointeur sur la racine de la structure de données                */
+/* (O) Value : adresse d'un pointeur sur la valeur à allouer                    */
+/* (I) ...   : arguments relatifs à l'allocation de la valeur                   */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_Value_Alloc_C( NDT_Root  *Root_Ptr, void  **Value_Ptr_Ptr, ...)
+{
+    NDT_Status  rc;
+    va_list     user_args;
+
+
+    if( NDG_Base.Open_Status != NDD_TRUE)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Value_Alloc_C: library is not open");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    if( !Root_Ptr)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Value_Alloc_C: structure root is null");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    /* Récupération des arguments pour l'allocation de la valeur */
+
+    va_start( user_args, Value_Ptr_Ptr);
+
+    /* Appel du manager */
+
+    rc = ND_Manager_Exec_I( Root_Ptr, NDD_INDEX_UNKNOWN, NULL, NDD_CMD_VALUE_ALLOC, Value_Ptr_Ptr, user_args);
+
+    va_end( user_args);
+
+    return( rc);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Désallocation d'une valeur d'une structure de données                        */
+/*------------------------------------------------------------------------------*/
+/* (I) Root: pointeur sur la racine de la structure de données                  */
+/* (I) Value: pointeur sur la valeur à désallouer                               */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_Value_Free_I( NDT_Root  *Root_Ptr, void  *Value_Ptr)
+{
+    return( ND_Manager_Exec_I( Root_Ptr, NDD_INDEX_UNKNOWN, NULL, NDD_CMD_VALUE_FREE, Value_Ptr));
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Désallocation d'une valeur d'une structure de données                        */
+/*------------------------------------------------------------------------------*/
+/* (I) Root: pointeur sur la racine de la structure de données                  */
+/* (I) Value: pointeur sur la valeur à désallouer                               */
+/*------------------------------------------------------------------------------*/
+NDT_Status ND_Value_Free_C( NDT_Root  *Root_Ptr, void  *Value_Ptr)
+{
+    if( NDG_Base.Open_Status != NDD_TRUE)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Value_Free_C: library is not open");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    if( !Root_Ptr)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Value_Free_C: structure root is null");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    if( !Value_Ptr)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Value_Free_C: the value to free is null");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    /* Appel du manager */
+
+    return( ND_Value_Free_I( Root_Ptr, Value_Ptr));
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Exécution d'une fonction Manager dont le nom est passé en paramètre          */
+/*------------------------------------------------------------------------------*/
+/* (I) Function : nom de la fonction manager à exécuter                         */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_Manager_Exec_VI( NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id, NDT_Node  *Node_Ptr, NDT_Command  Command, va_list  Args)
+{
+    NDT_Status    status;
+    NDT_Manager  *manager_ptr;
+
+
+    if(  Root_Ptr->Manager_Ptr != NULL)
+    {
+	manager_ptr = Root_Ptr->Manager_Ptr;
+    }
+    else
+    {
+	if( ND_Symbol_Find( (void  **)&manager_ptr, Root_Ptr->Manager_Name) != NDS_OK)
+	{
+	    sprintf( NDG_Base.Err_String, "ND_Manager_Exec_VI: cant't find manger function");
+	    ND_Error_Print();
+
+	    return( NDS_KO);
+	}
+    }
+
+    status = manager_ptr( Root_Ptr, Index_Id, Node_Ptr, Command, Args);
+
+    return( status);
+}
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Exécution d'une fonction Manager dont le nom est passé en paramètre          */
+/*------------------------------------------------------------------------------*/
+/* (I) Function : nom de la fonction manager à exécuter                         */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_Manager_Exec_VC( NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id, NDT_Node  *Node_Ptr, NDT_Command  Command, va_list  Args)
+{
+    NDT_Status  status;
+
+
+    if( NDG_Base.Open_Status != NDD_TRUE)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Manager_Exec_VC: library is not open");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    if( !Root_Ptr)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Manager_Exec_VC: structure root is null");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    if( !Root_Ptr->Manager_Ptr || !*(Root_Ptr->Manager_Ptr))
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Manager_Exec_VC: undefined function name");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    status = ND_Manager_Exec_VI( Root_Ptr, Index_Id, Node_Ptr, Command, Args);
+
+    return( status);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Exécution d'une fonction Manager dont le nom est passé en paramètre          */
+/*------------------------------------------------------------------------------*/
+/* (I) Function : nom de la fonction manager à exécuter                         */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_Manager_Exec_I( NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id, NDT_Node  *Node_Ptr, NDT_Command  Command, ...)
+{
+    NDT_Status    status;
+    va_list       args;
+    NDT_Manager  *manager_ptr;
+
+	
+    va_start( args, Command);
+
+    if(  Root_Ptr->Manager_Ptr != NULL)
+    {
+	manager_ptr = Root_Ptr->Manager_Ptr;
+    }
+    else
+    {
+	if( ND_Symbol_Find( (void  **)&manager_ptr, Root_Ptr->Manager_Name) != NDS_OK)
+	{
+	    sprintf( NDG_Base.Err_String, "ND_Manager_Exec_I: cant't find manger function");
+	    ND_Error_Print();
+
+	    return( NDS_KO);
+	}
+    }
+
+    status = manager_ptr( Root_Ptr, Index_Id, Node_Ptr, Command, args);
+
+    va_end( args);
+
+    return( status);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Exécution d'une fonction Manager dont le nom est passé en paramètre          */
+/*------------------------------------------------------------------------------*/
+/* (I) Function : nom de la fonction manager à exécuter                         */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_Manager_Exec_C( NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id, NDT_Node  *Node_Ptr, NDT_Command  Command, ...)
+{
+    NDT_Status   status;
+    va_list	 args;
+
+
+    va_start( args, Command);
+
+    if( NDG_Base.Open_Status != NDD_TRUE)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Manager_Exec_C: library is not open");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    if( !Root_Ptr)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Manager_Exec_C: structure root is null");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    if( !Root_Ptr->Manager_Ptr || !*(Root_Ptr->Manager_Ptr))
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Manager_Exec_C: undefined function name");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    status = ND_Manager_Exec_VI( Root_Ptr, Index_Id, Node_Ptr, Command, args);
+
+    va_end( args);
+
+    return( status);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Exécution d'une fonction d'allocation dont le nom est passé en paramètre     */
+/*------------------------------------------------------------------------------*/
+/* (I) Function : nom de la fonction à exécuter                                 */
+/* (O) Ptr      : adresse d'un pointeur sur la zone à allouer                   */
+/* (I) Size     : taille de la zone à allouer                                   */
+/* (I) Data     : données utilisateur utiles à l'allocateur                     */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_Allocator_Exec_I( void  **Ptr_Ptr, size_t  Size, NDT_Allocator_Name   Allocator_Name, NDT_Allocator  *Allocator_Ptr, void  *Data_Ptr)
+{
+    NDT_Allocator  *allocator_ptr;
+
+
+    if( Allocator_Ptr != NULL)
+    {
+	allocator_ptr = Allocator_Ptr;
+    }
+    else
+    {
+	if( ND_Symbol_Find( (void  **)&allocator_ptr, Allocator_Name) != NDS_OK)
+	{
+	    sprintf( NDG_Base.Err_String, "Error ND_Manager_Exec_I: cant't find allocator function");
+	    ND_Error_Print();
+
+	    return( NDS_KO);
+	}
+    }
+
+    return allocator_ptr( Ptr_Ptr, Size, Data_Ptr);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Exécution d'une fonction d'allocation dont le nom est passé en paramètre     */
+/*------------------------------------------------------------------------------*/
+/* (I) Function : nom de la fonction à exécuter                                 */
+/* (O) Ptr      : adresse d'un pointeur sur la zone à allouer                   */
+/* (I) Size     : taille de la zone à allouer                                   */
+/* (I) Data     : données utilisateur utiles à l'allocateur                     */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_Allocator_Exec_C( void  **Ptr_Ptr, size_t  Size, NDT_Allocator_Name   Allocator_Name, NDT_Allocator  *Allocator_Ptr, void  *Data_Ptr)
+{
+    if( NDG_Base.Open_Status != NDD_TRUE)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Allocator_Exec_C: library is not open");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    if( ( Allocator_Name == NULL) && ( Allocator_Ptr == NULL))
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Allocator_Exec_C: undefined function name");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    return( ND_Allocator_Exec_I( Ptr_Ptr, Size, Allocator_Name, Allocator_Ptr, Data_Ptr));
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Exécution d'une fonction de désallocation dont nom est passé en paramètre    */
+/*------------------------------------------------------------------------------*/
+/* (I) Function : nom de la fonction à exécuter                                 */
+/* (I) Ptr      : adresse de la zone à désallouer                               */
+/* (I) Data     : données utilisateur utiles à l'allocateur                     */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status ND_Desallocator_Exec_I( void  *Ptr, NDT_Desallocator_Name  Desallocator_Name, NDT_Desallocator  *Desallocator_Ptr, void  *Data_Ptr)
+{
+    NDT_Desallocator  *desallocator_ptr;
+
+
+    if( Desallocator_Ptr != NULL)
+    {
+	desallocator_ptr = Desallocator_Ptr;
+    }
+    else
+    {
+	if( ND_Symbol_Find( (void  **)&desallocator_ptr, Desallocator_Name) != NDS_OK)
+	{
+	    sprintf( NDG_Base.Err_String, "Error ND_Manager_Exec_I: cant't find desallocator function");
+	    ND_Error_Print();
+
+	    return( NDS_KO);
+	}
+    }
+
+    return( desallocator_ptr( Ptr, Data_Ptr));
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Exécution d'une fonction de désallocation dont nom est passé en paramètre    */
+/*------------------------------------------------------------------------------*/
+/* (I) Function : nom de la fonction à exécuter                                 */
+/* (I) Ptr      : adresse de la zone à désallouer                               */
+/* (I) Data     : données utilisateur utiles à l'allocateur                     */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status ND_Desallocator_Exec_C( void  *Ptr, NDT_Desallocator_Name  Desallocator_Name, NDT_Desallocator  *Desallocator_Ptr, void  *Data_Ptr)
+{
+    if( NDG_Base.Open_Status != NDD_TRUE)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Desallocator_Exec_C: library is not open");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    if( ( Desallocator_Name == NULL) && ( Desallocator_Ptr == NULL))
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Desallocator_Exec_C: undefined function name");
+        ND_Error_Print();
+
+        return( NDS_ERRAPI);
+    }
+
+    return( ND_Desallocator_Exec_I( Ptr, Desallocator_Name, Desallocator_Ptr, Data_Ptr));
+}
+
+
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/*------------------------------------------------------------------------------*/
+/*                              PRIVATE FUNCTIONS                               */
+/*------------------------------------------------------------------------------*/
+/*------------------------------------------------------------------------------*/
+
+/*------------------------------------------------------------------------------*/
+/* Symbol Lookup                                                                */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_Symbol_Find( void  **Ptr_Ptr, const char  *Symbol_Name)
+{
+#if !defined(_WIN32)
+    NDT_Symbol  *Symbol_Ptr;
+
+
+    /* Recherche du symbole dans la table des symboles locale */
+
+    Symbol_Ptr = NDG_Base.Symbol_First_Ptr;
+
+    while( Symbol_Ptr)
+    {
+        if( !strcmp( Symbol_Ptr->Name, Symbol_Name))
+	{
+	    *Ptr_Ptr = Symbol_Ptr->Ptr;
+	    return( NDS_OK);
+	}
+        else 
+	{
+	    Symbol_Ptr = Symbol_Ptr->Next;
+	}
+    }
+
+
+    /* Si le symbole n'a pas été trouvée dans la table des symboles locale, on l'y ajoute */
+
+    if( ( *Ptr_Ptr = dlsym( NDG_Base.DL_Ptr, (const char  *)Symbol_Name)) == NULL)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Symbol_Find: unable to find \"%s\"' in symbol table (%s)", Symbol_Name, dlerror());
+        ND_Error_Print();
+
+        return( NDS_KO);
+    }
+
+    Symbol_Ptr = (NDT_Symbol  *)malloc( sizeof( NDT_Symbol));
+    if( Symbol_Ptr == NULL)
+    {
+        sprintf( NDG_Base.Err_String, "Error ND_Symbol_Find: no more memory");
+        ND_Error_Print();
+
+        return( NDS_KO);
+    }
+    else
+    {
+        Symbol_Ptr->Name = strdup (Symbol_Name);
+        Symbol_Ptr->Ptr  = *Ptr_Ptr;
+        Symbol_Ptr->Next = NDG_Base.Symbol_First_Ptr;
+
+	NDG_Base.Symbol_First_Ptr = Symbol_Ptr;
+    }
+#endif
+
+    return( NDS_OK);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Allocation d'un noeud                                                        */
+/*------------------------------------------------------------------------------*/
+/* (I) Root : pointeur sur la racine de la structure                            */
+/* (O) Node : adresse du pointeur sur le nouveau noeud                          */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_Node_Alloc( NDT_Root  *Root_Ptr, NDT_Node  **Node_Ptr_Ptr )
+{
+    NDT_Status  rc;
+
+
+    rc = ND_Allocator_Exec_I( (void  **)Node_Ptr_Ptr, sizeof(NDT_Node), Root_Ptr->Allocator_Name, Root_Ptr->Allocator_Ptr, Root_Ptr->User_Ptr);
+    if( ND_ERROR( rc)) return( rc);
+
+    (*Node_Ptr_Ptr)->Root   = NULL;
+    (*Node_Ptr_Ptr)->Index  = NDD_INDEX_UNKNOWN;
+    (*Node_Ptr_Ptr)->Parent = NULL;
+    (*Node_Ptr_Ptr)->Left   = NULL;
+    (*Node_Ptr_Ptr)->Right  = NULL;
+    (*Node_Ptr_Ptr)->Value  = NULL;
+
+    return( NDS_OK);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Désallocation d'un noeud                                                     */
+/*------------------------------------------------------------------------------*/
+/* (I) Root: pointeur sur la racine de la structure                             */
+/* (I) Node : pointeur sur le noeud à détruire                                  */
+/*------------------------------------------------------------------------------*/
+NDT_Status ND_Node_Free( NDT_Root  *Root_Ptr, NDT_Node  *Node_Ptr)
+{
+    return( ND_Desallocator_Exec_I( Node_Ptr, Root_Ptr->Desallocator_Name, Root_Ptr->Desallocator_Ptr, Root_Ptr->User_Ptr));
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Création d'une nouvelle structure de données                                 */
+/*------------------------------------------------------------------------------*/
+/* (O) Root: adresse d'un pointeur sur la racine de la nouvelle structure       */
+/* (I) Type: type de la structure.de données (liste ou arbre binaire)           */
+/* (I) Allocator: pointeur vers la fonction d'allocation                        */
+/* (I) Desallocator: pointeur vers la fonction de désallocation                 */
+/* (I) Data : pointeur de données utiles à l'allocateur                         */
+/* (I) Own_Value : indique si la structure est propriétaire de ses valeurs      */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_Index_Clear( NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id)
+{
+    Root_Ptr->Index_Tab[Index_Id].Type        = NDD_INDEX_STATUS_UNKNOWN;
+
+    Root_Ptr->Index_Tab[Index_Id].Head        = NULL;
+    Root_Ptr->Index_Tab[Index_Id].Tail        = NULL;
+    Root_Ptr->Index_Tab[Index_Id].Save        = NULL;
+
+    Root_Ptr->Index_Tab[Index_Id].Max_Dif     = DEF_MAX_DIF;
+
+    Root_Ptr->Index_Tab[Index_Id].Node_Number = 0;
+    Root_Ptr->Index_Tab[Index_Id].Max_Depth   = 0;
+    Root_Ptr->Index_Tab[Index_Id].Min_Depth   = NDD_HUGE_LONG;
+    Root_Ptr->Index_Tab[Index_Id].Nb_Equ      = 0;
+
+    return( NDS_OK);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Allocation d'une racine de structure de données                              */
+/*------------------------------------------------------------------------------*/
+/* (O) New_Root: adresse du pointeur sur la nouvelle racine                     */
+/* (I) Type: type de la structure de données                                    */
+/* (I) Allocator: pointeur vers la fonction d'allocation                        */
+/* (I) Desallocator: pointeur vers la fonction de désallocation                 */
+/* (I) Data : pointeur de données utiles à l'allocateur                         */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status ND_Node_Root_Alloc( NDT_Root  **Root_Ptr_Ptr, NDT_Index_Nb  Index_Nb, NDT_Index_Type  *Type_Ptr, char  *Manager_Name, NDT_Manager  *Manager_Ptr, char  *Allocator_Name, NDT_Allocator  *Allocator_Ptr, char  *Desallocator_Name, NDT_Desallocator  *Desallocator_Ptr, short  Own_Value, void  *Data_Ptr)
+{
+    NDT_Status    status;
+    NDT_Index_Id  index_id;
+
+
+    status = ND_Allocator_Exec_I( (void **)Root_Ptr_Ptr, ( sizeof( NDT_Root) + sizeof(NDT_Index) * (Index_Nb - 1)), Allocator_Name, Allocator_Ptr, Data_Ptr);
+    if( ND_ERROR(status)) return( status);
+
+    if( strlen(Manager_Name) > NDD_MANAGER_NAME_LEN_MAX) return( NDS_ERRAPI);
+    strcpy( (*Root_Ptr_Ptr)->Manager_Name, Manager_Name);
+    (*Root_Ptr_Ptr)->Manager_Ptr      = Manager_Ptr;
+
+    if( strlen(Allocator_Name) > NDD_ALLOCATOR_NAME_LEN_MAX) return( NDS_ERRAPI);
+    strcpy( (*Root_Ptr_Ptr)->Allocator_Name, Allocator_Name);
+    (*Root_Ptr_Ptr)->Allocator_Ptr    = Allocator_Ptr;
+
+    if( strlen(Desallocator_Name) > NDD_DESALLOCATOR_NAME_LEN_MAX) return( NDS_ERRAPI);
+    strcpy( (*Root_Ptr_Ptr)->Desallocator_Name, Desallocator_Name);
+    (*Root_Ptr_Ptr)->Desallocator_Ptr = Desallocator_Ptr;
+
+    (*Root_Ptr_Ptr)->Own_Value        = Own_Value;
+    (*Root_Ptr_Ptr)->User_Ptr         = Data_Ptr;
+
+    (*Root_Ptr_Ptr)->Index_Nb         = Index_Nb;
+    (*Root_Ptr_Ptr)->Index_Open_Count = 0;
+
+    for( index_id = 0; index_id < Index_Nb; index_id++)
+    {
+	if( ( Type_Ptr[index_id] & NDD_INDEX_STATUS_MSK) ==  NDD_INDEX_STATUS_OPENED)
+        {
+            status = ND_Index_Open_I( *Root_Ptr_Ptr, index_id, Type_Ptr[index_id]);
+            if( ND_ERROR( status)) return( status);
+	}
+	else
+	{
+	    if( ( status = ND_Index_Clear( *Root_Ptr_Ptr, index_id)) != NDS_OK)
+	    {
+	        sprintf( NDG_Base.Err_String, "Error ND_Index_Open_I: Index cleaning error");
+		ND_Error_Print();
+		return( NDS_KO);
+	    }
+
+	    ( *Root_Ptr_Ptr)->Index_Tab[index_id].Type = NDD_INDEX_STATUS_CLOSED;
+	}
+    }
+
+    return( NDS_OK);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Désallocation de la racine d'une structure de donnée                         */
+/*------------------------------------------------------------------------------*/
+/* (I) Root : pointeur sur la racine à détruire                                 */
+/*------------------------------------------------------------------------------*/
+NDT_Status ND_Node_Root_Free( NDT_Root  *Root_Ptr)
+{
+    return( ND_Desallocator_Exec_I( Root_Ptr, Root_Ptr->Desallocator_Name, Root_Ptr->Desallocator_Ptr, Root_Ptr->User_Ptr));
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Ajout d'un noeud à une liste chaînée                                         */
+/*------------------------------------------------------------------------------*/
+/* (I) Root : pointeur sur la racine de la liste                                */
+/* (I) New_Node : pointeur sur le noeud à ajouter                               */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_List_Node_Add( NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id, NDT_Node  *New_Node_Ptr)
+{
+    /* Ajout dans une liste triée */
+
+    if( ND_INDEX_SUBTYPE_SORTED_IS( Root_Ptr, Index_Id))
+    {
+        NDT_Node    *node_ptr;
+        NDT_Status   rc;
+
+
+        New_Node_Ptr->Root = Root_Ptr;
+	New_Node_Ptr->Index = Index_Id;
+        New_Node_Ptr->Parent = New_Node_Ptr->Left = New_Node_Ptr->Right = NULL;
+
+        /*
+	  Une liste triée peut être orientée de 2 manières :
+
+	  - FIFO : un noeud sera inséré APRES un noeud de même valeur (par défaut)
+	  - FILO : un noeud sera inséré AVANT un noeud de même valeur
+        */
+
+        if( ND_INDEX_SUBTYPE_LIFO_IS( Root_Ptr, Index_Id))
+        {
+            /* Pour une liste triée orientée FILO, on parcourt la liste en sens normal */
+
+            node_ptr = Root_Ptr->Index_Tab[Index_Id].Head;
+
+            while( node_ptr)
+            {
+                rc = ND_Manager_Exec_I( Root_Ptr, Index_Id, node_ptr, NDD_CMD_VALUE_COMP, New_Node_Ptr->Value, node_ptr->Value, NULL);
+
+                if(rc == NDS_GREATER)
+		    node_ptr = node_ptr->Right;
+                else
+                {
+                    /* On insère avant le noeud courant si le nouveau noeud est de valeur inférieure ou égale */
+
+                    New_Node_Ptr->Left = node_ptr->Left;
+                    New_Node_Ptr->Right = node_ptr;
+
+                    if(!node_ptr->Left) Root_Ptr->Index_Tab[Index_Id].Head = New_Node_Ptr;
+                    else node_ptr->Left->Right = New_Node_Ptr;
+
+                    node_ptr->Left = New_Node_Ptr;
+                    node_ptr = NULL;
+                }
+            }
+
+            /* Insertion en queue de liste si le noeud n'a pas été inséré */
+
+            if(!New_Node_Ptr->Left && !New_Node_Ptr->Right)
+            {
+                if( !Root_Ptr->Index_Tab[Index_Id].Tail) Root_Ptr->Index_Tab[Index_Id].Head = Root_Ptr->Index_Tab[Index_Id].Tail = New_Node_Ptr;
+                else
+                {
+                    Root_Ptr->Index_Tab[Index_Id].Tail->Right = New_Node_Ptr;
+                    New_Node_Ptr->Left = Root_Ptr->Index_Tab[Index_Id].Tail;
+                    Root_Ptr->Index_Tab[Index_Id].Tail = New_Node_Ptr;
+                }
+            }
+        }
+        else
+        {
+            /* Pour une liste triée orientée FIFO, on parcourt la liste dans le sens inverse */
+
+            node_ptr = Root_Ptr->Index_Tab[Index_Id].Tail;
+            while( node_ptr)
+            {
+		rc = ND_Manager_Exec_I( Root_Ptr, Index_Id, node_ptr, NDD_CMD_VALUE_COMP, New_Node_Ptr->Value, node_ptr->Value, NULL);
+
+                /* On insère après le noeud courant si le nouveau noeud est de valeur strictement supérieure ou égale */
+
+                if( rc == NDS_LOWER) node_ptr = node_ptr->Left;
+                else
+                {
+                    New_Node_Ptr->Left = node_ptr;
+                    New_Node_Ptr->Right = node_ptr->Right;
+
+                    if( !node_ptr->Right) Root_Ptr->Index_Tab[Index_Id].Tail = New_Node_Ptr;
+                    else node_ptr->Right->Left = New_Node_Ptr;
+
+                    node_ptr->Right = New_Node_Ptr;
+                    node_ptr = NULL;
+                }
+            }
+
+            /* Insertion en tête de liste si le noeud n'a pas été inséré */
+
+            if( !New_Node_Ptr->Left && !New_Node_Ptr->Right)
+            {
+                if( !Root_Ptr->Index_Tab[Index_Id].Head) Root_Ptr->Index_Tab[Index_Id].Head = Root_Ptr->Index_Tab[Index_Id].Tail = New_Node_Ptr;
+                else
+                {
+                    Root_Ptr->Index_Tab[Index_Id].Head->Left = New_Node_Ptr;
+                    New_Node_Ptr->Right = Root_Ptr->Index_Tab[Index_Id].Head;
+                    Root_Ptr->Index_Tab[Index_Id].Head = New_Node_Ptr;
+                }
+            }
+        }
+
+        Root_Ptr->Index_Tab[Index_Id].Node_Number++;
+
+        return( NDS_OK);
+    }
+    else
+    {
+        /* FIFO = ajout en queue de liste */
+
+        if( ND_INDEX_SUBTYPE_FIFO_IS( Root_Ptr, Index_Id))
+        {
+            New_Node_Ptr->Root   = Root_Ptr;
+	    New_Node_Ptr->Index  = Index_Id;
+            New_Node_Ptr->Parent = NULL;
+            New_Node_Ptr->Left   = Root_Ptr->Index_Tab[Index_Id].Tail;
+            New_Node_Ptr->Right  = NULL;
+
+            if( !Root_Ptr->Index_Tab[Index_Id].Head) Root_Ptr->Index_Tab[Index_Id].Head = New_Node_Ptr;
+            else Root_Ptr->Index_Tab[Index_Id].Tail->Right = New_Node_Ptr;
+
+            Root_Ptr->Index_Tab[Index_Id].Tail = New_Node_Ptr;
+            Root_Ptr->Index_Tab[Index_Id].Node_Number++;
+
+            return( NDS_OK);
+        }
+
+        /* FILO = ajout en tête de liste */
+
+        if( ND_INDEX_SUBTYPE_LIFO_IS( Root_Ptr, Index_Id))
+        {
+
+            New_Node_Ptr->Root   = Root_Ptr;
+	    New_Node_Ptr->Index  = Index_Id;
+            New_Node_Ptr->Parent = NULL;
+            New_Node_Ptr->Left   = NULL;
+            New_Node_Ptr->Right  = Root_Ptr->Index_Tab[Index_Id].Head;
+
+            if( !Root_Ptr->Index_Tab[Index_Id].Tail) Root_Ptr->Index_Tab[Index_Id].Tail = New_Node_Ptr;
+            else Root_Ptr->Index_Tab[Index_Id].Head->Left = New_Node_Ptr;
+
+            Root_Ptr->Index_Tab[Index_Id].Head = New_Node_Ptr;
+            Root_Ptr->Index_Tab[Index_Id].Node_Number++;
+
+            return( NDS_OK);
+        }
+    }
+
+    printf( "ND_List_Node_Add: unknown list type (%d)\n", Root_Ptr->Index_Tab[Index_Id].Type);
+    return( NDS_ERRAPI);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Ajout d'une nouvelle valeur à une liste                                      */
+/*------------------------------------------------------------------------------*/
+/* (I) Root : pointeur sur la racine de la liste                                */
+/* (I) Value : pointeur sur la valeur à ajouter                                 */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_List_Value_Add( NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id, void  *Value_Ptr)
+{
+    NDT_Status   rc;
+    NDT_Node    *node_ptr;
+
+
+    rc = ND_Node_Alloc( Root_Ptr, &node_ptr);
+    if( ND_ERROR(rc)) return(rc);
+
+    node_ptr->Value = Value_Ptr;
+
+//    return ND_List_Node_Add( Root, Node);
+
+    rc = ND_List_Node_Add( Root_Ptr, Index_Id, node_ptr);
+    if( ND_ERROR(rc))
+    {
+	return( rc);
+    }
+    else
+    {
+	return( ND_Manager_Exec_I( Root_Ptr, Index_Id, node_ptr, NDD_CMD_VALUE_ADD, Value_Ptr, NULL));
+    }
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Ajout d'un noeud à un arbre binaire                                          */
+/*------------------------------------------------------------------------------*/
+/* (I) Root : pointeur sur la racine de l'arbre                                 */
+/* (I) Value : pointeur sur la valeur à ajouter                                 */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_Tree_Value_Add( NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id, void  *Value_Ptr)
+{
+    NDT_Status rc;
+    NDT_Node    *node_ptr;
+
+
+    rc = ND_Node_Alloc( Root_Ptr, &node_ptr);
+    if( ND_ERROR(rc)) return(rc);
+
+    node_ptr->Value = Value_Ptr;
+
+//    return ND_Tree_Node_Add( Root, Node);
+
+    rc = ND_Tree_Node_Add( Root_Ptr, Index_Id, node_ptr);
+    if( ND_ERROR(rc))
+    {
+	return( rc);
+    }
+    else
+    {
+	return ND_Manager_Exec_I( Root_Ptr, Index_Id, node_ptr, NDD_CMD_VALUE_ADD,  Value_Ptr, NULL);
+    }
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Recherche une valeur dans une liste et retourne le noeud correspondant       */
+/*------------------------------------------------------------------------------*/
+/* (I) Root     : pointeur sur la racine de la liste                            */
+/* (I) Value    : pointeur sur la valeur à rechercher                           */
+/* (I) Data     : pointeur de données                                           */
+/*------------------------------------------------------------------------------*/
+
+NDT_Node  *ND_List_Node_Find( NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id, void  *Value_Ptr, va_list User_Args)
+{
+    NDT_Node    *node_ptr;
+    NDT_Status   rc;
+
+
+    node_ptr = Root_Ptr->Index_Tab[Index_Id].Head;
+
+    if( ND_INDEX_SUBTYPE_SORTED_IS( Root_Ptr, Index_Id))
+    {
+        /* Pour les listes triées, la recherche peut être optimisée */
+
+        while( node_ptr)
+        {
+            rc = ND_Manager_Exec_I( Root_Ptr, Index_Id, node_ptr, NDD_CMD_VALUE_COMP, Value_Ptr, node_ptr->Value, User_Args);
+
+            switch( rc)
+            {
+                case NDS_EQUAL:
+		{
+                    return(node_ptr);
+		}
+
+                case NDS_LOWER:
+		{
+                    /* Ce n'est pas a peine de continuer car on a déjà dépassé la valeur recherchée */
+
+                    return(NULL);
+		}
+
+                case NDS_GREATER:
+		{
+                    node_ptr = node_ptr->Right;
+                    break;
+		}
+            }
+        }
+    }
+    else
+    {
+        /* Pour les listes non triées, il faut parcourir toute la liste */
+
+        while( node_ptr && ( ND_Manager_Exec_I( Root_Ptr, Index_Id, node_ptr, NDD_CMD_VALUE_COMP, Value_Ptr, node_ptr->Value, User_Args) != NDS_EQUAL))
+	{
+            node_ptr = node_ptr->Right;
+	}
+    }
+
+    return( node_ptr);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Recherche un noeud dans un arbre et retourne le pointeur sur le noeud        */
+/*------------------------------------------------------------------------------*/
+/* (I) Root     : pointeur sur la racine de l'abre                              */
+/* (I) Value    : pointeur sur la valeur à rechercher                           */
+/* (I) Data     : pointeur de données                                           */
+/*------------------------------------------------------------------------------*/
+
+/*------------------------------ Recursive Kernel ------------------------------*/
+
+NDT_Node  *ND_Tree_Node_Recursive_Find( NDT_Node  *Node_Ptr, void  *Value_Ptr, va_list  User_Args)
+{
+    NDT_Status  answer;
+
+
+    if( !Node_Ptr) return(NULL);
+
+    answer = ND_Manager_Exec_I( Node_Ptr->Root, Node_Ptr->Index, Node_Ptr, NDD_CMD_VALUE_COMP, Value_Ptr, Node_Ptr->Value, User_Args);
+
+    /* Noeud trouvé */
+
+    if( answer == NDS_EQUAL) return(Node_Ptr);
+
+    /* Continuation de la recherche par appel récursif */
+
+    if( answer == NDS_LOWER) return( ND_Tree_Node_Recursive_Find( Node_Ptr->Left, Value_Ptr, User_Args));
+
+    if( answer == NDS_GREATER) return( ND_Tree_Node_Recursive_Find( Node_Ptr->Right, Value_Ptr, User_Args));
+
+    return( NULL);
+}
+
+
+
+/*-------------------------------- main body ---------------------------------*/
+
+NDT_Node  *ND_Tree_Node_Find( NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id, void  *Value_Ptr, va_list  User_Args)
+{
+    return( ND_Tree_Node_Recursive_Find( Root_Ptr->Index_Tab[Index_Id].Head, Value_Ptr, User_Args));
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Recherche du premier noeud parent situé après                                */
+/*------------------------------------------------------------------------------*/
+/* (I) Node : pointeur sur le noeud                                             */
+/*------------------------------------------------------------------------------*/
+
+NDT_Node  *ND_Tree_Parent_Next_Recursive_Get( NDT_Node  *Node_Ptr)
+{
+    if( !Node_Ptr->Parent) return( NULL);
+
+    if( Node_Ptr == Node_Ptr->Parent->Right) return( ND_Tree_Parent_Next_Recursive_Get( Node_Ptr->Parent));
+
+    return( Node_Ptr->Parent);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Recherche du premier noeud parent situé avant                                */
+/*------------------------------------------------------------------------------*/
+/* (I) Node : pointeur sur le noeud                                             */
+/*------------------------------------------------------------------------------*/
+
+NDT_Node  *ND_Tree_Parent_Previous_Recursive_Get( NDT_Node  *Node_Ptr)
+{
+    if( !Node_Ptr->Parent) return( NULL);
+
+    if( Node_Ptr == Node_Ptr->Parent->Left) return( ND_Tree_Parent_Previous_Recursive_Get( Node_Ptr->Parent));
+
+    return( Node_Ptr->Parent);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Supprime le noeud d'une liste                                                */
+/*------------------------------------------------------------------------------*/
+/* (I) Node  : pointeur sur le noeud à supprimer                                */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_List_Node_Remove( NDT_Node  *Node_Ptr)
+{
+    if( !Node_Ptr->Left) Node_Ptr->Root->Index_Tab[Node_Ptr->Index].Head = Node_Ptr->Right;
+    else Node_Ptr->Left->Right = Node_Ptr->Right;
+
+    if( !Node_Ptr->Right) Node_Ptr->Root->Index_Tab[Node_Ptr->Index].Tail = Node_Ptr->Left;
+    else Node_Ptr->Right->Left = Node_Ptr->Left;
+
+    Node_Ptr->Root->Index_Tab[Node_Ptr->Index].Node_Number--;
+
+    Node_Ptr->Root  = NULL;
+    Node_Ptr->Index = NDD_INDEX_UNKNOWN;
+    Node_Ptr->Left  = NULL;
+    Node_Ptr->Right = NULL;
+
+    return( NDS_OK);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Conversion d'un arbre en liste chaînée                                       */
+/*------------------------------------------------------------------------------*/
+/* (I) Root : pointeur sur la racine du la structure à convertir                */
+/*------------------------------------------------------------------------------*/
+
+/*------------------------------- Recursive Kernel -----------------------------*/
+
+NDT_Status  ND_List_Recursive_Make( NDT_Node  *Node_Ptr, NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id)
+{
+    NDT_Node  *right_node_ptr;
+
+
+    if( !Node_Ptr) return NDS_OK;
+
+    if( ND_List_Recursive_Make( Node_Ptr->Left, Root_Ptr, Index_Id) != NDS_OK) return NDS_KO;
+
+    right_node_ptr = Node_Ptr->Right;
+
+    if( ND_List_Node_Add( Root_Ptr, Index_Id, Node_Ptr) != NDS_OK) return NDS_KO;
+
+    return( ND_List_Recursive_Make( right_node_ptr, Root_Ptr, Index_Id));
+}
+
+
+
+/*--------------------------------- main body --------------------------------*/
+
+NDT_Status  ND_List_Make( NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id)
+{
+    NDT_Node  *node_ptr;
+
+
+    node_ptr = Root_Ptr->Index_Tab[Index_Id].Head;
+
+    Root_Ptr->Index_Tab[Index_Id].Head        = NULL;
+    Root_Ptr->Index_Tab[Index_Id].Tail        = NULL;
+    Root_Ptr->Index_Tab[Index_Id].Max_Dif     = DEF_MAX_DIF;
+    Root_Ptr->Index_Tab[Index_Id].Node_Number = 0;
+    Root_Ptr->Index_Tab[Index_Id].Max_Depth   = 0;
+    Root_Ptr->Index_Tab[Index_Id].Min_Depth   = NDD_HUGE_LONG;
+    Root_Ptr->Index_Tab[Index_Id].Nb_Equ      = 0;
+    Root_Ptr->Index_Tab[Index_Id].Type        = NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_LIST | NDD_INDEX_SUBTYPE_FIFO;
+
+    return( ND_List_Recursive_Make( node_ptr, Root_Ptr, Index_Id));
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Conversion d'une structure en arbre binaire                                  */
+/*------------------------------------------------------------------------------*/
+/* (I) Root : pointeur sur la racine du la structure à convertir                */
+/* (I) Type : type du futur arbre                                               */
+/*------------------------------------------------------------------------------*/
+
+/*------------------------------- Recursive Kernel -----------------------------*/
+
+NDT_Node  *ND_Tree_Recursive_Make( long  Depth, long  Node_Number, NDT_Node  *Node_Ptr )
+{
+    long       middle_pos, left_len, right_len, i;
+    NDT_Node  *left_node_ptr, *middle_node_ptr, *right_node_ptr;
+
+
+    if( !Node_Ptr) return( NULL);
+
+    /* On calcule le milieu de la liste */
+
+    middle_pos = Node_Number / 2 + 1;
+    middle_node_ptr = Node_Ptr;
+
+    for( i = 1; i < middle_pos; i++) middle_node_ptr = middle_node_ptr->Right;
+
+    /* On coupe la liste en deux */
+
+    if( middle_node_ptr->Left)
+    {
+        middle_node_ptr->Left->Right = NULL;
+        left_node_ptr = Node_Ptr;
+        left_len = middle_pos - 1;
+    }
+    else
+    {
+        left_node_ptr = NULL;
+        left_len = 0;
+    }
+
+    if( middle_node_ptr->Right)
+    {
+        middle_node_ptr->Right->Left = NULL;
+        right_node_ptr = middle_node_ptr->Right;
+        right_len = Node_Number - middle_pos;
+    }
+    else
+    {
+        right_node_ptr = NULL;
+        right_len = 0;
+    }
+
+    /* Construction des sous-arbres */
+
+    middle_node_ptr->Left = ND_Tree_Recursive_Make( Depth + 1, left_len, left_node_ptr);
+
+    middle_node_ptr->Right = ND_Tree_Recursive_Make( Depth + 1, right_len, right_node_ptr);
+
+    if( middle_node_ptr->Left) middle_node_ptr->Left->Parent = middle_node_ptr;
+
+    if( middle_node_ptr->Right) middle_node_ptr->Right->Parent = middle_node_ptr;
+
+    /* Mise à jour des informations statistiques de la structure */
+
+    middle_node_ptr->Root->Index_Tab[middle_node_ptr->Index].Node_Number++;
+
+    if( !middle_node_ptr->Left && !middle_node_ptr->Right)
+    {
+        /*
+	  Si le noeud courant est une feuille, on met éventuellement à jour
+	  les longueurs minimale et maximale des branches de l'arbre
+        */
+
+        if( Depth > middle_node_ptr->Root->Index_Tab[middle_node_ptr->Index].Max_Depth)
+	{
+	    middle_node_ptr->Root->Index_Tab[middle_node_ptr->Index].Max_Depth = Depth;
+	}
+
+        if( Depth < middle_node_ptr->Root->Index_Tab[middle_node_ptr->Index].Min_Depth)
+	{
+	    middle_node_ptr->Root->Index_Tab[middle_node_ptr->Index].Min_Depth = Depth;
+	}
+    }
+
+    return( middle_node_ptr);
+}
+
+
+
+/*--------------------------------- main body --------------------------------*/
+
+NDT_Status  ND_Tree_Make( NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id )
+{
+    NDT_Status   rc;
+    NDT_Node    *node_ptr;
+    long         node_number;
+
+
+    if( ND_INDEX_SUBTYPE_SORTED_IS( Root_Ptr, Index_Id))
+    {
+        rc = ND_List_Sort( Root_Ptr, Index_Id);
+        if( ND_ERROR(rc)) return( rc);
+    }
+
+    node_ptr = Root_Ptr->Index_Tab[Index_Id].Head;
+    node_number = Root_Ptr->Index_Tab[Index_Id].Node_Number;
+
+    Root_Ptr->Index_Tab[Index_Id].Head        = NULL;
+    Root_Ptr->Index_Tab[Index_Id].Tail        = NULL;
+    Root_Ptr->Index_Tab[Index_Id].Max_Dif     = DEF_MAX_DIF;
+    Root_Ptr->Index_Tab[Index_Id].Node_Number = 0;
+    Root_Ptr->Index_Tab[Index_Id].Max_Depth   = 0;
+    Root_Ptr->Index_Tab[Index_Id].Min_Depth   = NDD_HUGE_LONG;
+    Root_Ptr->Index_Tab[Index_Id].Nb_Equ      = 0;
+    Root_Ptr->Index_Tab[Index_Id].Type        = NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_TREE | NDD_INDEX_SUBTYPE_BALANCED;
+
+    Root_Ptr->Index_Tab[Index_Id].Head = Root_Ptr->Index_Tab[Index_Id].Tail = ND_Tree_Recursive_Make( 1, node_number, node_ptr);
+
+    return( NDS_OK);
+}
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Equilibrage d'un arbre binaire                                             */
+/*----------------------------------------------------------------------------*/
+/* (I) Root : pointeur sur la racine de l'arbre                               */
+/*----------------------------------------------------------------------------*/
+
+NDT_Status  ND_Tree_Equalize( NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id)
+{
+    NDT_Status       rc;
+    NDT_Index_Type   type;
+    long             max_dif, nb_equ;
+
+
+    type    = Root_Ptr->Index_Tab[Index_Id].Type;
+    max_dif = Root_Ptr->Index_Tab[Index_Id].Max_Dif;
+    nb_equ  = Root_Ptr->Index_Tab[Index_Id].Nb_Equ;
+
+    rc = ND_List_Make( Root_Ptr, Index_Id);
+    if( ND_ERROR(rc)) return(rc);
+
+    Root_Ptr->Index_Tab[Index_Id].Type = NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_LIST | NDD_INDEX_SUBTYPE_SORTED;
+
+    rc = ND_Tree_Make( Root_Ptr, Index_Id);
+    if( ND_ERROR(rc)) return(rc);
+
+    Root_Ptr->Index_Tab[Index_Id].Type    = type;
+    Root_Ptr->Index_Tab[Index_Id].Max_Dif = max_dif;
+    Root_Ptr->Index_Tab[Index_Id].Nb_Equ  = nb_equ + 1;
+
+    return( NDS_OK);
+}
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Retourne la profondeur de la plus grande branche à partir d'un noeud       */
+/*----------------------------------------------------------------------------*/
+/* (I) Node : pointeur sur le noeud                                           */
+/*----------------------------------------------------------------------------*/
+
+long  ND_Tree_MaxDepth_Get( NDT_Node  *Node_Ptr)
+{
+    long  Max_Left, Max_Right;
+
+
+    if( !Node_Ptr) return( 0);
+
+    Max_Left = ND_Tree_MaxDepth_Get( Node_Ptr->Left);
+
+    Max_Right = ND_Tree_MaxDepth_Get( Node_Ptr->Right);
+
+    return( NDD_MAX( Max_Left, Max_Right) + 1 );
+}
+
+/*----------------------------------------------------------------------------*/
+/* Retourne la profondeur de la plus petite branche à partir d'un noeud       */
+/*----------------------------------------------------------------------------*/
+/* (I) Node : pointeur sur le noeud                                           */
+/*----------------------------------------------------------------------------*/
+
+long  ND_Tree_MinDepth_Get( NDT_Node  *Node_Ptr)
+{
+    long  Min_Left, Min_Right;
+
+
+    if( !Node_Ptr) return( 0);
+
+    Min_Left = ND_Tree_MinDepth_Get( Node_Ptr->Left);
+
+    Min_Right = ND_Tree_MinDepth_Get( Node_Ptr->Right);
+
+    return( NDD_MIN( Min_Left, Min_Right) + 1 );
+}
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Ajoute un noeud à un arbre                                                 */
+/*----------------------------------------------------------------------------*/
+/* (I) Root : pointeur sur la racine de l'arbre                               */
+/* (I) Node : pointeur sur le noeud à ajouter                                 */
+/*----------------------------------------------------------------------------*/
+
+/*------------------------------ Recursive Kernel ----------------------------*/
+
+void  ND_Tree_Node_Recursive_Add( NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id, NDT_Node  *Parent_Node,  NDT_Node  **Node_Ptr_Ptr, long  Depth, NDT_Node  *New_Node_Ptr )
+{
+    if( *Node_Ptr_Ptr)
+    {
+        /* Appel récursif */
+
+        if( ND_Manager_Exec_I( Root_Ptr, Index_Id, (*Node_Ptr_Ptr), NDD_CMD_VALUE_COMP, New_Node_Ptr->Value, (*Node_Ptr_Ptr)->Value, NULL) == NDS_LOWER)
+            ND_Tree_Node_Recursive_Add( Root_Ptr, Index_Id, (*Node_Ptr_Ptr), &((*Node_Ptr_Ptr)->Left), Depth + 1, New_Node_Ptr);
+        else
+            ND_Tree_Node_Recursive_Add( Root_Ptr, Index_Id, (*Node_Ptr_Ptr), &((*Node_Ptr_Ptr)->Right), Depth + 1, New_Node_Ptr);
+    }
+    else
+    {
+        long Max_Depth, Min_Depth;
+
+        /* Rattachement du nouveau noeud à l'arbre */
+
+        New_Node_Ptr->Root = Root_Ptr;
+        New_Node_Ptr->Index = Index_Id;
+        New_Node_Ptr->Parent = Parent_Node;
+
+        *Node_Ptr_Ptr = New_Node_Ptr;
+
+        /* Mise à jour des informations statistiques de la structure */
+
+        Root_Ptr->Index_Tab[Index_Id].Node_Number++;
+
+        Max_Depth = ND_Tree_MaxDepth_Get( New_Node_Ptr);
+
+        Min_Depth = ND_Tree_MinDepth_Get( New_Node_Ptr);
+
+        if( Max_Depth + Depth - 1 > Root_Ptr->Index_Tab[Index_Id].Max_Depth) Root_Ptr->Index_Tab[Index_Id].Max_Depth = Max_Depth + Depth - 1;
+
+        if( Min_Depth + Depth - 1 < Root_Ptr->Index_Tab[Index_Id].Min_Depth) Root_Ptr->Index_Tab[Index_Id].Min_Depth = Min_Depth +  Depth - 1 ;
+    }
+}
+
+
+
+/*-------------------------------- main body ---------------------------------*/
+
+NDT_Status  ND_Tree_Node_Add( NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id, NDT_Node  *Node_Ptr)
+{
+    ND_Tree_Node_Recursive_Add( Root_Ptr, Index_Id, NULL, &(Root_Ptr->Index_Tab[Index_Id].Head), 1, Node_Ptr);
+
+    if( ND_INDEX_SUBTYPE_BALANCED_IS( Root_Ptr, Index_Id) && Root_Ptr->Index_Tab[Index_Id].Max_Depth - Root_Ptr->Index_Tab[Index_Id].Min_Depth > Root_Ptr->Index_Tab[Index_Id].Max_Dif)
+        return( ND_Tree_Equalize( Root_Ptr, Index_Id));
+
+    return( NDS_OK);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Ajoute tous les noeud d'une liste à un arbre                                 */
+/*------------------------------------------------------------------------------*/
+/* (I) Tree_Root : pointeur sur la racine de l'arbre                            */
+/* (I) List_Root : pointeur sur la racine de la liste                           */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_Tree_List_Add( NDT_Root  *Tree_Root_Ptr, NDT_Index_Id  Tree_Index_Id, NDT_Root  *List_Root_Ptr, NDT_Index_Id  List_Index_Id)
+{
+    NDT_Status   rc;
+    NDT_Node	*node_ptr;
+
+
+    node_ptr = List_Root_Ptr->Index_Tab[List_Index_Id].Head;
+
+    while( node_ptr)
+    {
+        rc = ND_Tree_Node_Add( Tree_Root_Ptr, Tree_Index_Id, node_ptr);
+        if( ND_ERROR( rc)) return( rc);
+        node_ptr = node_ptr->Right;
+    }
+
+    return( NDS_OK);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Affiche toutes les informations d'une structure de données                   */
+/*------------------------------------------------------------------------------*/
+/* (I) Root : pointeur sur la racine de la structure                            */
+/*------------------------------------------------------------------------------*/
+
+/*------------------------------- Recursive Kernel -----------------------------*/
+
+void  ND_Tree_Recursive_Print( NDT_Node  *Node_Ptr, long  Depth, FILE  *Out)
+{
+    const int BRANCH_LEN = 4;
+
+
+    if( !Node_Ptr) return;
+
+    if( Node_Ptr->Right)
+    {
+        ND_Tree_Recursive_Print( Node_Ptr->Right, Depth + 1, Out);
+        fprintf( Out, "%*s/\n", (int)(Depth * BRANCH_LEN - 1), "");
+    }
+
+    fprintf( Out, "%*s (%p) ", (int)((Depth - 1) * BRANCH_LEN), "", Node_Ptr);
+
+/*  Affichage des toutes les informations (noeud et valeur) :
+
+if( Node->Root) fprintf( Out, "Root=%p ", Node->Root);
+if( Node->Parent) fprintf( Out, "Parent=%p ", Node->Parent);
+if( Node->Left) fprintf( Out, "Left=%p ", Node->Left);
+if( Node->Right) fprintf( Out, "Right=%p ", Node->Right);
+
+fprintf( Out, "Value=[");
+ND_Manager_Exec( Node->Root->Manager, NDD_CMD_PRINT_VALUE, Node->Value, Out);
+fprintf( Out, "]\n");
+*/
+
+/*  Affichage de la valeur seule : */
+
+    ND_Manager_Exec_I( Node_Ptr->Root, Node_Ptr->Index, Node_Ptr, NDD_CMD_VALUE_PRINT, Node_Ptr->Value, Out, NULL);
+    fprintf( Out, "\n");
+
+    if( Node_Ptr->Left)
+    {
+        fprintf( Out, "%*s\\\n", (int)( Depth * BRANCH_LEN - 1), "");
+        ND_Tree_Recursive_Print( Node_Ptr->Left, Depth + 1, Out);
+    }
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Function de comparaison de noeuds (pour le quick sort)                       */
+/*------------------------------------------------------------------------------*/
+
+int ND_Node_Compare( void  **Node1_Ptr_Ptr, void  **Node2_Ptr_Ptr)
+{
+    NDT_Status rc;
+
+
+    rc = ND_Manager_Exec_I( ( ( NDT_Node *)( *Node1_Ptr_Ptr))->Root, ( ( NDT_Node *)(*Node1_Ptr_Ptr))->Index, *Node1_Ptr_Ptr, NDD_CMD_VALUE_COMP, ( (NDT_Node *) (*Node1_Ptr_Ptr))->Value, ( ( NDT_Node *)( *Node2_Ptr_Ptr))->Value, NULL);
+
+    switch( (int)rc)
+    {
+        case NDS_EQUAL:   return(  0);
+	case NDS_LOWER:   return( -1);
+	case NDS_GREATER: return(  1);
+
+        default:
+	{
+            sprintf( NDG_Base.Err_String, "Error ND_Node_Compare : incorrect return code from the manager: %d", rc);
+            ND_Error_Print();
+
+            return( 0);
+	}
+    }
+}
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Ordonne une liste chaînée :                                                */
+/*----------------------------------------------------------------------------*/
+/* (I) Root : pointeur sur la racine de la liste à trier                      */
+/*----------------------------------------------------------------------------*/
+
+NDT_Status ND_List_Sort( NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id)
+{
+    int		i;
+    NDT_Node   *node_ptr;
+    void      **tab;
+
+
+    if( Root_Ptr->Index_Tab[Index_Id].Node_Number < 2) return NDS_OK;
+
+    /* Allocation d'un tableau de pointeur de noeuds */
+
+    tab = (void **)malloc( Root_Ptr->Index_Tab[Index_Id].Node_Number * sizeof( NDT_Node *));
+
+    /* On remplit le tableau avec les noeuds de la structure à trier */
+
+    i = 0;
+    node_ptr = Root_Ptr->Index_Tab[Index_Id].Head;
+
+    while( node_ptr)
+    {
+        tab[i] = node_ptr;
+        node_ptr = node_ptr->Right;
+        i++;
+    }
+
+    /* Tri du tableau de pointeurs de noeuds */
+
+    qsort( (void *)tab, (size_t)( Root_Ptr->Index_Tab[Index_Id].Node_Number), sizeof( NDT_Node *), ( int (*)( const void *, const void *))&ND_Node_Compare);
+
+    /* On met à jour les liens entre les noeuds */
+
+    for( i = 0; i < Root_Ptr->Index_Tab[Index_Id].Node_Number; i++)
+    {
+        node_ptr = (NDT_Node *)tab[i];
+
+        node_ptr->Left = (i ? (NDT_Node *)( tab[i - 1]) : NULL);
+        node_ptr->Right = (i != Root_Ptr->Index_Tab[Index_Id].Node_Number - 1 ? (NDT_Node *)( tab[i + 1]) : NULL);
+    }
+
+    Root_Ptr->Index_Tab[Index_Id].Head = (NDT_Node *)( tab[0]);
+    Root_Ptr->Index_Tab[Index_Id].Tail = (NDT_Node *)( tab[Root_Ptr->Index_Tab[Index_Id].Node_Number - 1]);
+
+    /* Désallocation du tableau */
+
+    free(tab);
+
+    return( NDS_OK);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Récupère le premier noeud dans un sous-arbre                                 */
+/*------------------------------------------------------------------------------*/
+/* (I) Node : pointeur sur le noeud racine du sous-arbre                        */
+/*------------------------------------------------------------------------------*/
+
+NDT_Node  *ND_Tree_Node_First_Recursive_Get( NDT_Node  *Node_Ptr)
+{
+    if( !Node_Ptr) return NULL;
+
+    if( !Node_Ptr->Left) return( Node_Ptr);
+
+    return( ND_Tree_Node_First_Recursive_Get( Node_Ptr->Left));
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Récupère le dernier noeud dans un sous-arbre                                 */
+/*------------------------------------------------------------------------------*/
+/* (I) Node : pointeur sur le noeud racine du sous-arbre                        */
+/*------------------------------------------------------------------------------*/
+
+NDT_Node  *ND_Tree_Node_Last_Recursive_Get( NDT_Node  *Node_Ptr)
+{
+    if( !Node_Ptr) return NULL;
+
+    if( !Node_Ptr->Right) return( Node_Ptr);
+
+    return ND_Tree_Node_Last_Recursive_Get( Node_Ptr->Right);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Redéfinition de la fonction malloc() avec retour de type NDT_Status          */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_Default_Allocator( void  **Ptr_Ptr, size_t  Size, void  *Data_Ptr)
+{
+    *Ptr_Ptr = malloc( Size);
+
+
+    if( !*Ptr_Ptr) return( NDS_ERRMEM);
+
+    return( NDS_OK);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Redéfinition de la fonction free() avec retour de type NDT_Status            */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_Default_Desallocator( void  *Ptr, void  *Data_Ptr)
+{
+    if( !Ptr) return( NDS_ERRAPI);
+
+    free( Ptr);
+
+    return( NDS_OK);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Function de vérification d'une liste :                                       */
+/*------------------------------------------------------------------------------*/
+
+void  ND_List_Check( NDT_Root *Root_Ptr, NDT_Index_Id  Index_Id, int  *Nb_Detected_Ptr, int  *Nb_Corrected_Ptr, FILE  *Out)
+{
+    /* On vérifie les liens entre les noeuds */
+
+    ND_List_Link_Check( Root_Ptr, Index_Id, Nb_Detected_Ptr, Nb_Corrected_Ptr, Out);
+
+    /* On vérifie les valeurs des noeuds */
+
+    ND_Value_Check( Root_Ptr, Index_Id, Nb_Detected_Ptr, Nb_Corrected_Ptr, Out);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Function de vérification et correction des liens entre noeuds d'une liste    */
+/*------------------------------------------------------------------------------*/
+
+void ND_List_Link_Check( NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id, int  *Nb_Detected_Ptr, int  *Nb_Corrected_Ptr, FILE  *Out)
+{
+    NDT_Node  *node_ptr;
+    int	       left2right_node_number = 0;
+    int	       right2left_node_number = 0;
+
+
+    /*
+      On commence à vérifier si l'on trouve le même nombre de noeuds
+      en parcourant la liste de droite à gauche, puis de gauche à droite
+    */
+
+    node_ptr = Root_Ptr->Index_Tab[Index_Id].Head;
+
+    while( node_ptr)
+    {
+        left2right_node_number++;
+        node_ptr = node_ptr->Right;
+    }
+
+    node_ptr = Root_Ptr->Index_Tab[Index_Id].Tail;
+
+    while( node_ptr)
+    {
+        right2left_node_number++;
+        node_ptr = node_ptr->Left;
+    }
+
+    /* Cas où tout est OK */
+
+    if( left2right_node_number == Root_Ptr->Index_Tab[Index_Id].Node_Number && left2right_node_number == right2left_node_number) return;
+
+    /* Cas où le nombre de noeuds n'a simplement pas été mis à jour au niveau de la racine */
+
+    if( left2right_node_number == right2left_node_number)
+    {
+        Root_Ptr->Index_Tab[Index_Id].Node_Number = left2right_node_number;
+        fprintf( Out, "\t- number of node has been corrected on structure %p:%d\n", Root_Ptr, Index_Id);
+        (*Nb_Detected_Ptr)++;
+        (*Nb_Corrected_Ptr)++;
+        return;
+    }
+
+    /* Cas où le parcours de gauche à droite est plus complet : il manque un lien 'Left' */
+
+    if( left2right_node_number > right2left_node_number)
+    {
+        node_ptr = Root_Ptr->Index_Tab[Index_Id].Head;
+
+        while( node_ptr)
+        {
+            if( node_ptr->Right && ( node_ptr->Right->Left != node_ptr))
+            {
+		fprintf( Out, "\t- link 'Left' has been corrected on node %p of structure %p:%d\n", node_ptr->Right, Root_Ptr, Index_Id);
+		node_ptr->Right->Left = node_ptr;
+		(*Nb_Detected_Ptr)++;
+		(*Nb_Corrected_Ptr)++;
+            }
+
+            if( !node_ptr->Right && ( node_ptr != Root_Ptr->Index_Tab[Index_Id].Tail))
+            {
+		fprintf( Out, "\t- link 'Tail' has been corrected on structure %p:%d\n", Root_Ptr, Index_Id);
+		Root_Ptr->Index_Tab[Index_Id].Tail = node_ptr;
+		(*Nb_Detected_Ptr)++;
+		(*Nb_Corrected_Ptr)++;
+            }
+
+            node_ptr = node_ptr->Right;
+        }
+
+        if( Root_Ptr->Index_Tab[Index_Id].Node_Number != left2right_node_number)
+        {
+            fprintf( Out, "\t- number of node has been corrected on structure %p:%d\n", Root_Ptr, Index_Id);
+            Root_Ptr->Index_Tab[Index_Id].Node_Number = left2right_node_number;
+            (*Nb_Detected_Ptr)++;
+            (*Nb_Corrected_Ptr)++;
+        }
+
+        return;
+    }
+
+    /* Cas où le parcours de droite à gauche est plus complet : il manque un lien 'Right' */
+
+    if( right2left_node_number > left2right_node_number)
+    {
+        node_ptr = Root_Ptr->Index_Tab[Index_Id].Tail;
+
+        while( node_ptr)
+        {
+            if( node_ptr->Left && ( node_ptr->Left->Right != node_ptr))
+            {
+		fprintf( Out, "\t- link 'Right' has been corrected on node %p of list %p:%d\n", node_ptr->Left, Root_Ptr, Index_Id);
+		node_ptr->Left->Right = node_ptr;
+		(*Nb_Detected_Ptr)++;
+		(*Nb_Corrected_Ptr)++;
+            }
+
+            if( !node_ptr->Left && ( node_ptr != Root_Ptr->Index_Tab[Index_Id].Head))
+            {
+		fprintf( Out, "\t- link 'Head' has been corrected on the structure root %p:%d\n", Root_Ptr, Index_Id);
+		Root_Ptr->Index_Tab[Index_Id].Head = node_ptr;
+		(*Nb_Detected_Ptr)++;
+		(*Nb_Corrected_Ptr)++;
+            }
+
+            node_ptr = node_ptr->Left;
+        }
+
+        if( Root_Ptr->Index_Tab[Index_Id].Node_Number != right2left_node_number)
+        {
+            fprintf( Out, "\t- number of node has been corrected on structure %p:%d\n", Root_Ptr, Index_Id);
+            Root_Ptr->Index_Tab[Index_Id].Node_Number = right2left_node_number;
+            (*Nb_Detected_Ptr)++;
+            (*Nb_Corrected_Ptr)++;
+        }
+    }
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Function de vérification des valeurs des noeuds d'une liste                  */
+/*------------------------------------------------------------------------------*/
+
+void  ND_Value_Check( NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id, int  *Nb_Detected, int  *Nb_Corrected, FILE  *Out)
+{
+    NDT_Node  *node_ptr, *next_node_ptr;
+
+
+    /* Chaque noeud sans valeur est purement et simplement supprimé de la liste */
+
+    ND_Index_Node_First_Get_I( &node_ptr, Root_Ptr, Index_Id);
+
+    while( node_ptr)
+    {
+        ND_Index_Node_Next_Get_I( &next_node_ptr, node_ptr);
+
+        if( !node_ptr->Value)
+        {
+            fprintf( Out, "\t- node %p has been removed from structure %p:%d because no value is attached to it\n", node_ptr, Root_Ptr, Index_Id);
+
+            ND_Index_Node_Remove_I( node_ptr);
+
+            node_ptr = next_node_ptr;
+
+            (*Nb_Detected)++;
+            (*Nb_Corrected)++;
+        }
+        else if( ND_Address_Check( node_ptr->Value) != NDS_OK)
+        {
+            fprintf (Out, "\t- node %p has been removed from structure %p:%d because its value cannot be accessed\n", node_ptr, Root_Ptr, Index_Id);
+
+            ND_Index_Node_Remove_I( node_ptr);
+
+            node_ptr = next_node_ptr;
+
+            (*Nb_Detected)++;
+            (*Nb_Corrected)++;
+        }
+        else ND_Index_Node_Next_Get( &node_ptr, node_ptr);
+    }
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Function de vérification d'un arbre  :                                       */
+/*------------------------------------------------------------------------------*/
+
+void  ND_Tree_Check( NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id, int  *Nb_Detected_Ptr, int  *Nb_Corrected_Ptr, FILE  *Out)
+{
+    /* On vérifie les liens entre les noeuds */
+
+    ND_Tree_Link_Check( Root_Ptr, Index_Id, Nb_Detected_Ptr, Nb_Corrected_Ptr, Out);
+
+    /* On vérifie les valeurs attachées aux noeuds */
+
+    ND_Value_Check( Root_Ptr, Index_Id, Nb_Detected_Ptr, Nb_Corrected_Ptr, Out);
+
+    /* On met à jour les informations statistiques de la racine */
+
+    Root_Ptr->Index_Tab[Index_Id].Max_Depth = ND_Tree_MaxDepth_Get( Root_Ptr->Index_Tab[Index_Id].Head);
+    Root_Ptr->Index_Tab[Index_Id].Min_Depth = ND_Tree_MaxDepth_Get( Root_Ptr->Index_Tab[Index_Id].Head);
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Function de vérification et correction des liens entre noeuds d'un arbre     */
+/*------------------------------------------------------------------------------*/
+
+void  ND_Tree_Link_Check( NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id, int  *Nb_Detected_Ptr, int  *Nb_Corrected_Ptr, FILE  *Out)
+{
+    /* On vérifie les liens 'Parent' et les liens 'Root' de chaque noeud */
+
+    if( Root_Ptr->Index_Tab[Index_Id].Head)
+    {
+        if( Root_Ptr->Index_Tab[Index_Id].Head->Root != Root_Ptr)
+        {
+            Root_Ptr->Index_Tab[Index_Id].Head->Root = Root_Ptr;
+            fprintf( Out, "\t- link 'Root' has been corrected on node %p of structure %p:%d\n", Root_Ptr->Index_Tab[Index_Id].Head, Root_Ptr, Index_Id);
+            (*Nb_Detected_Ptr)++;
+            (*Nb_Corrected_Ptr)++;
+        }
+
+        ND_Tree_Link_Recursive_Check( Root_Ptr->Index_Tab[Index_Id].Head, Nb_Detected_Ptr, Nb_Corrected_Ptr, Out);
+    }
+
+    /*
+      On vérifie si le lien 'Save' contient un noeud (cela signifie
+      que la procédure ND_Node_Remove n'a pas été jusqu'à son terme).
+    */
+
+    if( Root_Ptr->Index_Tab[Index_Id].Save)
+    {
+        NDT_Node  *node_ptr;
+
+
+        /* On attache le noeud contenu dans 'Save' à l'arbre s'il n'existe pas déjà */
+
+        if( ND_Index_Node_Find_I( &node_ptr, Root_Ptr, Index_Id, Root_Ptr->Index_Tab[Index_Id].Save->Value, NULL) != NDS_OK)
+        {
+            ND_Index_Node_Add_I( Root_Ptr, Index_Id, Root_Ptr->Index_Tab[Index_Id].Save);
+            fprintf( Out, "\t- saved node %p has been restored to structure %p:%d\n", Root_Ptr->Index_Tab[Index_Id].Save, Root_Ptr, Index_Id);
+            (*Nb_Detected_Ptr)++;
+            (*Nb_Corrected_Ptr)++;
+        }
+
+        Root_Ptr->Index_Tab[Index_Id].Save = NULL;
+    }
+}
+
+
+
+/*------------------------------ Recursive Kernel ------------------------------*/
+
+void  ND_Tree_Link_Recursive_Check( NDT_Node  *Node_Ptr, int  *Nb_Detected_Ptr, int  *Nb_Corrected_Ptr, FILE  *Out)
+{
+    if( Node_Ptr->Left)
+    {
+        if( Node_Ptr->Left->Root != Node_Ptr->Root)
+        {
+            Node_Ptr->Left->Root = Node_Ptr->Root;
+            fprintf( Out, "\t- link 'Root' has been corrected on node %p of structure %p:%d\n", Node_Ptr->Left, Node_Ptr->Root, Node_Ptr->Index);
+            (*Nb_Detected_Ptr)++;
+            (*Nb_Corrected_Ptr)++;
+        }
+
+        if( Node_Ptr->Left->Parent != Node_Ptr)
+        {
+            Node_Ptr->Left->Parent = Node_Ptr;
+            fprintf( Out, "\t- link 'Parent' has been corrected on node %p of structure %p:%d\n", Node_Ptr->Left, Node_Ptr->Root, Node_Ptr->Index);
+            (*Nb_Detected_Ptr)++;
+            (*Nb_Corrected_Ptr)++;
+        }
+
+        /* Appel récursif */
+
+        ND_Tree_Link_Recursive_Check( Node_Ptr->Left, Nb_Detected_Ptr, Nb_Corrected_Ptr, Out);
+    }
+
+    if( Node_Ptr->Right)
+    {
+        if( Node_Ptr->Right->Root != Node_Ptr->Root)
+        {
+            Node_Ptr->Right->Root = Node_Ptr->Root;
+            fprintf( Out, "\t- link 'Root' has been corrected on node %p of structure %p:%d\n", Node_Ptr->Right, Node_Ptr->Root, Node_Ptr->Index);
+            (*Nb_Detected_Ptr)++;
+            (*Nb_Corrected_Ptr)++;
+        }
+
+        if( Node_Ptr->Right->Parent != Node_Ptr)
+        {
+            Node_Ptr->Right->Parent = Node_Ptr;
+            fprintf( Out, "\t- link 'Parent' has been corrected on node %p of structure %p:%d\n", Node_Ptr->Right, Node_Ptr->Root, Node_Ptr->Index);
+            (*Nb_Detected_Ptr)++;
+            (*Nb_Corrected_Ptr)++;
+        }
+
+        /* Appel récursif */
+
+        ND_Tree_Link_Recursive_Check( Node_Ptr->Right, Nb_Detected_Ptr, Nb_Corrected_Ptr, Out);
+    }
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Target address access try                                                    */
+/*------------------------------------------------------------------------------*/
+
+NDT_Status  ND_Address_Check( void  *Address)
+{
+#if !defined(_WIN32)
+    NDT_Status        status;
+    int               rc;
+    int               test;
+    struct sigaction  act = {0}, oact_bus, oact_segv;
+
+    act.sa_handler = ND_Signal_Trap;
+
+    NDG_Base.Sig_Trapped = 0;
+
+
+
+    /* Trap SIGBUS and SIGSEGV */
+
+    if( ( rc = sigaction( SIGBUS, &act, &oact_bus)) != 0)
+    {
+	sprintf( NDG_Base.Err_String, "Error ND_Address_Check: sigaction (Add SIGBUS Hdl) rc: %d   errno: %d", rc, errno);
+	ND_Error_Print();
+
+	return( NDS_KO);
+    }
+
+    if( ( rc = sigaction( SIGSEGV, &act, &oact_segv)) != 0)
+    {
+	sprintf( NDG_Base.Err_String, "Error ND_Address_Check: sigaction (Add SIGSEGV Hdl) rc: %d   errno: %d", rc, errno);
+	ND_Error_Print();
+
+	return( NDS_KO);
+    }
+
+
+
+    /* Target address access try */
+
+    if( sigsetjmp( NDG_Base.SigLongJmp_Env, 1) == 0 )
+    {
+	test = *( (int *)Address);
+
+	status = NDS_OK;
+    }
+    else
+    {
+	status = NDS_KO;
+    }
+
+
+
+    /* Untrap SIGBUS and SIGSEGV */
+
+    if( ( rc = sigaction( SIGBUS, &oact_bus, &act)) != 0)
+    {
+	sprintf( NDG_Base.Err_String, "Error ND_Address_Check: sigaction (Remove SIGBUS Hdl) rc: %d   errno: %d", rc, errno);
+	ND_Error_Print();
+
+	return( NDS_KO);
+    }
+
+    if( ( rc = sigaction( SIGSEGV, &oact_segv, &act)) != 0)
+    {
+	sprintf( NDG_Base.Err_String, "Error ND_Address_Check: sigaction (Remove SIGSEGV Hdl) rc: %d   errno: %d", rc, errno);
+	ND_Error_Print();
+
+	return( NDS_KO);
+    }
+
+    return( status);
+#else
+    NDT_Status      status;
+    int             test;
+    void (__cdecl  *old_sigsegv_sighandler)(int);
+
+
+    NDG_Base.Sig_Trapped = 0;
+
+
+
+    /* Trap SIGSEGV */
+
+    if( ( old_sigsegv_sighandler = signal( SIGSEGV, ND_Signal_Trap)) == SIG_ERR)
+    {
+	sprintf( NDG_Base.Err_String, "Error ND_Address_Check: signal (Add SIGSEGV Hdl) errno: %d", errno);
+	ND_Error_Print();
+
+	return( NDS_KO);
+    }
+
+
+
+    /* Target address access try */
+
+    if( setjmp( NDG_Base.SigLongJmp_Env) == 0 )
+    {
+	test = *( (int *)Address);
+
+	status = NDS_OK;
+    }
+    else
+    {
+	status = NDS_KO;
+    }
+
+
+
+    /* Untrap SIGSEGV */
+
+    if( ( old_sigsegv_sighandler = signal( SIGSEGV, old_sigsegv_sighandler)) == SIG_ERR)
+    {
+	sprintf( NDG_Base.Err_String, "Error ND_Address_Check: signal (Remove SIGSEGV Hdl) errno: %d", errno);
+	ND_Error_Print();
+
+	return( NDS_KO);
+    }
+
+    return( status);
+#endif
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Trap d'un signal                                                             */
+/*------------------------------------------------------------------------------*/
+
+void  ND_Signal_Trap( int  Sig_Num)
+{
+    NDG_Base.Sig_Trapped = Sig_Num;
+
+#if !defined(_WIN32)
+    siglongjmp( NDG_Base.SigLongJmp_Env, 1);
+#else
+    longjmp( NDG_Base.SigLongJmp_Env, 1);
+#endif
+}
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/* Routine d'affichage d'un message d'erreur                                    */
+/*------------------------------------------------------------------------------*/
+
+void  ND_Error_Print( void)
+{
+    if( NDG_Base.Err_Stream) fprintf( ( NDG_Base.Err_Stream == (FILE *)-1 ) ? stderr : NDG_Base.Err_Stream, "%s\n", NDG_Base.Err_String);
+}
diff --git a/src/libnode/src/libnode.h b/src/libnode/src/libnode.h
new file mode 100644
index 0000000..6793135
--- /dev/null
+++ b/src/libnode/src/libnode.h
@@ -0,0 +1,356 @@
+/*----------------------------------------------------------------------------*/
+/* $Workfile:   libnode.h  $                                                  */
+/*----------------------------------------------------------------------------*/
+/* $Author: agibert $                                                      */
+/* $Date: 2008/11/12 02:25:23 $                                           */
+/* $Revision: 1.1 $                                                        */
+/* $Label:  $                                                         */
+/*----------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------------*/
+/* %RCSfile: libnode.h,v %							   */
+/*---------------------------------------------------------------------------------*/
+/* %Revision: 2.9 %								   */
+/* %Name: libnode-2_1_0-1 %									   */
+/* %Date: 2005/01/19 23:59:42 %							   */
+/* %Author: agibert %							           */
+/*---------------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------------*/
+/* This file is part of LibNode                                                    */
+/*                                                                                 */
+/*    LibNode is free software; you can redistribute it and/or modify              */
+/*    it under the terms of the GNU Lesser General Public Licence as published by  */
+/*    the Free Software Foundation; either version 2.1 of the License, or          */
+/*    (at your option) any later version.                                          */
+/*                                                                                 */
+/*    LibNode is distributed in the hope that it will be useful,                   */
+/*    but WITHOUT ANY WARRANTY; without even the implied warranty of               */
+/*    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                */
+/*    GNU Lesser General Public License for more details.                          */
+/*                                                                                 */
+/*    You should have received a copy of the GNU Lesser General Public License     */
+/*    along with LibNode; if not, write to the Free Software                       */
+/*    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA    */
+/*---------------------------------------------------------------------------------*/
+
+
+
+
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include <signal.h>
+#include <setjmp.h>
+#include <dlfcn.h>
+
+
+
+/* Utilisation des API de la LIBNODE sans vérification des arguments */
+
+#define ND_MODE 1
+
+#include <node.h>
+
+
+
+
+
+
+
+#ifdef __linux
+#   define NDD_PRINTF_PTR_PREFIX  ""
+#else
+#   define NDD_PRINTF_PTR_PREFIX  "0x"
+#endif
+
+
+
+
+
+#define NDD_HUGE_LONG ( long) 0xFFFFFFL
+
+
+
+/* Table des symboles locale */
+
+struct NDT_Symbol;
+
+typedef struct NDT_Symbol
+{
+	void               *Ptr;
+	char               *Name;
+	struct NDT_Symbol  *Next;
+} NDT_Symbol;
+
+
+
+/* LibNode Global Base Structure */
+
+typedef struct NDT_Base
+{
+	int              Open_Status;
+	int              Debug_Mode;
+	char             Err_String[512];
+	FILE            *Err_Stream;
+	int              Sig_Trapped;
+#if !defined(_WIN32)
+	sigjmp_buf       SigLongJmp_Env;
+#else
+	jmp_buf          SigLongJmp_Env;
+#endif
+	NDT_Symbol      *Symbol_First_Ptr;
+	void            *DL_Ptr;
+	NDT_Index_Type   OpenStruct_Index_Type[1];
+	NDT_Root        *OpenStruct_Ptr;
+} NDT_Base;
+
+NDT_Base  NDG_Base = 
+{
+    NDD_FALSE,
+    NDD_TRUE,
+    "",
+    (FILE *) -1,
+    0,
+    {0},
+    (NDT_Symbol  *) NULL,
+    NULL,
+    { NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_LIST | NDD_INDEX_SUBTYPE_FIFO},
+    (NDT_Root  *)   NULL
+};
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/*------------------------------------------------------------------------------*/
+/*       Fonctions et procédures privées de la librairie  (moyen niveau)        */
+/*------------------------------------------------------------------------------*/
+/*------------------------------------------------------------------------------*/
+
+/*------------------------------------------------------------------------------*/
+/* Manager par défaut                                                           */
+/*------------------------------------------------------------------------------*/
+/* (I) va_list Arguments : Liste d'arguments contextuels                        */
+/*------------------------------------------------------------------------------*/
+NDT_Status  ND_Default_Manager( NDT_Root  *, NDT_Index_Id, NDT_Node  *, NDT_Command, va_list);
+
+/*------------------------------------------------------------------------------*/
+/* OpenStruct Manager                                                           */
+/*------------------------------------------------------------------------------*/
+/* (I) va_list Arguments : Liste d'arguments contextuels                        */
+/*------------------------------------------------------------------------------*/
+NDT_Status  ND_OpenStruct_Manager( NDT_Root  *, NDT_Index_Id, NDT_Node  *, NDT_Command, va_list);
+
+/*------------------------------------------------------------------------------*/
+/* Redéfinition de la fonction malloc() avec retour de type NDT_Status          */
+/*------------------------------------------------------------------------------*/
+NDT_Status  ND_Default_Allocator( void  **, size_t, void  *);
+
+/*------------------------------------------------------------------------------*/
+/* Redéfinition de la fonction free() avec retour de type NDT_Status            */
+/*------------------------------------------------------------------------------*/
+NDT_Status  ND_Default_Desallocator( void  *, void  *);
+
+/*------------------------------------------------------------------------------*/
+/* Création d'un noeud                                                          */
+/*------------------------------------------------------------------------------*/
+/* (I) Root     : adresse de la racine pour laquelle on crée un noeud           */
+/* (O) New_Node : adresse du pointeur sur le nouveau noeud                      */
+/*------------------------------------------------------------------------------*/
+NDT_Status ND_Node_Alloc( NDT_Root * Root, NDT_Node ** New_Node);
+
+/*------------------------------------------------------------------------------*/
+/* Destruction d'un noeud                                                       */
+/*------------------------------------------------------------------------------*/
+/* (I) Root : adresse de la racine dans laquelle on détruit un noeud            */
+/* (I) Node : pointeur sur le noeud à détruire                                  */
+/*------------------------------------------------------------------------------*/
+NDT_Status  ND_Node_Free( NDT_Root  *, NDT_Node  *);
+
+/*------------------------------------------------------------------------------*/
+/* Création d'une nouvelle structure de données                                 */
+/*------------------------------------------------------------------------------*/
+/* (O) Root: adresse d'un pointeur sur la racine de la nouvelle structure       */
+/* (I) Type: type de la structure.de données (liste ou arbre binaire)           */
+/* (I) Allocator: pointeur vers la fonction d'allocation                        */
+/* (I) Desallocator: pointeur vers la fonction de désallocation                 */
+/* (I) Data : pointeur de données utiles à l'allocateur                         */
+/* (I) Own_Value : indique si la structure est propriétaire de ses valeurs      */
+/*------------------------------------------------------------------------------*/
+NDT_Status  ND_Index_Clear( NDT_Root  *, NDT_Index_Id);
+
+/*------------------------------------------------------------------------------*/
+/* Création de la racine d'une structure de données quelconque                  */
+/*------------------------------------------------------------------------------*/
+/* (O) New_Root     : adresse du pointeur sur la nouvelle racine                */
+/* (I) Type         : type de la structure de données                           */
+/* (I) Allocater    : pointeur vers la fonction d'allocation                    */
+/* (I) Desallocater : pointeur vers la fonction de désallocation                */
+/* (I) Data         : pointeur de données utiles à l'allocateur                 */
+/*------------------------------------------------------------------------------*/
+NDT_Status  ND_Node_Root_Alloc( NDT_Root  **, NDT_Index_Nb, NDT_Index_Type[], char  *, NDT_Manager  *, char  *, NDT_Allocator  *, char  *, NDT_Desallocator  *, short, void  *);
+
+/*------------------------------------------------------------------------------*/
+/* Destruction d'une racine                                                     */
+/*------------------------------------------------------------------------------*/
+/* (I) Root : pointeur sur la racine à détruire                                 */
+/*------------------------------------------------------------------------------*/
+NDT_Status  ND_Node_Root_Free( NDT_Root  *);
+
+/*------------------------------------------------------------------------------*/
+/* Ajout d'un noeud à une liste chaînée                                         */
+/*------------------------------------------------------------------------------*/
+/* (I) Root     : pointeur sur la racine de la liste                            */
+/* (I) New_Node : pointeur sur le noeud à ajouter                               */
+/*------------------------------------------------------------------------------*/
+NDT_Status  ND_List_Node_Add( NDT_Root  *, NDT_Index_Id, NDT_Node  *);
+
+/*------------------------------------------------------------------------------*/
+/* Ajout d'une nouvelle valeur à une liste                                      */
+/*------------------------------------------------------------------------------*/
+/* (I) Root     : pointeur sur la racine de la liste                            */
+/* (I) Value    : pointeur sur la valeur à ajouter                              */
+/*------------------------------------------------------------------------------*/
+NDT_Status  ND_List_Value_Add( NDT_Root  *, NDT_Index_Id, void  *);
+
+/*------------------------------------------------------------------------------*/
+/* Ajout d'un noeud à un arbre binaire                                          */
+/*------------------------------------------------------------------------------*/
+/* (I) Root     : pointeur sur la racine de l'arbre                             */
+/* (I) Value    : pointeur sur la valeur à ajouter                              */
+/*------------------------------------------------------------------------------*/
+NDT_Status  ND_Tree_Value_Add( NDT_Root  *, NDT_Index_Id, void  *);
+
+/*------------------------------------------------------------------------------*/
+/* Supprime le noeud d'une liste                                                */
+/*------------------------------------------------------------------------------*/
+/* (I) Node  : pointeur sur le noeud à supprimer                                */
+/*------------------------------------------------------------------------------*/
+NDT_Status  ND_List_Node_Remove( NDT_Node  *);
+
+/*------------------------------------------------------------------------------*/
+/* Conversion d'une structure en liste chaînée                                  */
+/*------------------------------------------------------------------------------*/
+/* (I) Root : pointeur sur la racine du la structure à convertir                */
+/*------------------------------------------------------------------------------*/
+NDT_Status  ND_List_Make( NDT_Root  *, NDT_Index_Id);
+
+/*------------------------------------------------------------------------------*/
+/* Recherche une valeur dans une liste et retourne le noeud correspondant       */
+/*------------------------------------------------------------------------------*/
+NDT_Node  *ND_List_Node_Find( NDT_Root  *, NDT_Index_Id, void  *, va_list);
+
+/*------------------------------------------------------------------------------*/
+/* Recherche un noeud dans un arbre et retourne le pointeur sur le noeud        */
+/*------------------------------------------------------------------------------*/
+NDT_Node  *ND_Tree_Node_Find( NDT_Root  *, NDT_Index_Id, void  *, va_list);
+
+/*------------------------------------------------------------------------------*/
+/* Conversion d'une structure en arbre binaire                                  */
+/*------------------------------------------------------------------------------*/
+/* (I) Root : pointeur sur la racine du la structure à convertir                */
+/* (I) Type : type du futur arbre                                               */
+/*------------------------------------------------------------------------------*/
+NDT_Status  ND_Tree_Make( NDT_Root  *, NDT_Index_Id);
+
+/*------------------------------------------------------------------------------*/
+/* Equilibrage d'un arbre                                                       */
+/*------------------------------------------------------------------------------*/
+/* (I) Root : pointeur sur la racine de l'arbre                                 */
+/*------------------------------------------------------------------------------*/
+NDT_Status  ND_Tree_Equalize( NDT_Root  *, NDT_Index_Id);
+
+/*------------------------------------------------------------------------------*/
+/* Retourne la profondeur de la plus grande branche à partir d'un noeud         */
+/*------------------------------------------------------------------------------*/
+/* (I) Node : pointeur sur le noeud                                             */
+/*------------------------------------------------------------------------------*/
+long  ND_Tree_MaxDepth_Get( NDT_Node  *);
+
+/*------------------------------------------------------------------------------*/
+/* Retourne la profondeur de la plus petite branche à partir d'un noeud         */
+/*------------------------------------------------------------------------------*/
+/* (I) Node : pointeur sur le noeud                                             */
+/*------------------------------------------------------------------------------*/
+long  ND_Tree_MinDepth_Get( NDT_Node  *);
+
+/*------------------------------------------------------------------------------*/
+/* Ajout d'un noeud à un arbre binaire                                          */
+/*------------------------------------------------------------------------------*/
+/* (I) Root    : pointeur sur la racine de l'arbre                              */
+/* (I) Node : pointeur sur le noeud à ajouter                                   */
+/*------------------------------------------------------------------------------*/
+NDT_Status  ND_Tree_Node_Add( NDT_Root  *, NDT_Index_Id, NDT_Node  *);
+
+/*------------------------------------------------------------------------------*/
+/* Ajoute tous les noeud d'une liste à un arbre                                 */
+/*------------------------------------------------------------------------------*/
+/* (I) Tree_Root : pointeur sur la racine de l'arbre                            */
+/* (I) List_Root : pointeur sur la racine de la liste                           */
+/*------------------------------------------------------------------------------*/
+NDT_Status  ND_Tree_List_Add( NDT_Root  *, NDT_Index_Id, NDT_Root  *, NDT_Index_Id);
+
+/*------------------------------------------------------------------------------*/
+/* Fonction de comparaison de noeuds (pour le quick sort)                       */
+/*------------------------------------------------------------------------------*/
+int  ND_Node_Compare( void  **, void  **);
+
+/*------------------------------------------------------------------------------*/
+/* Ordonne une liste chaînée selon l'algorithme du tri à bulle                  */
+/*------------------------------------------------------------------------------*/
+/* (I) Root : pointeur sur la racine de la liste à trier                        */
+/*------------------------------------------------------------------------------*/
+NDT_Status  ND_List_Sort( NDT_Root  *, NDT_Index_Id);
+
+
+
+
+
+
+/*------------------------------------------------------------------------------*/
+/*------------------------------------------------------------------------------*/
+/*                              PRIVATE FUNCTIONS                               */
+/*------------------------------------------------------------------------------*/
+/*------------------------------------------------------------------------------*/
+
+void  ND_List_Check( NDT_Root  *, NDT_Index_Id, int  *, int  *, FILE  *);
+
+void  ND_List_Link_Check( NDT_Root  *, NDT_Index_Id, int  *, int  *, FILE  *);
+
+void  ND_Value_Check( NDT_Root  *, NDT_Index_Id, int  *, int  *, FILE  *);
+
+void  ND_Tree_Check( NDT_Root  *, NDT_Index_Id, int  *, int  *, FILE  *);
+
+void  ND_Tree_Link_Check( NDT_Root  *, NDT_Index_Id, int  *, int  *, FILE  *);
+
+NDT_Status  ND_List_Recursive_Make( NDT_Node  *, NDT_Root  *, NDT_Index_Id);
+
+NDT_Node  *ND_Tree_Recursive_Make( long, long, NDT_Node  *);
+
+void  ND_Tree_Node_Recursive_Add( NDT_Root  *, NDT_Index_Id, NDT_Node  *, NDT_Node  **, long , NDT_Node  *);
+
+NDT_Node  *ND_Tree_Node_First_Recursive_Get( NDT_Node  *);
+
+NDT_Node  *ND_Tree_Node_Last_Recursive_Get( NDT_Node  *);
+
+NDT_Node  *ND_Tree_Node_Recursive_Find( NDT_Node  *, void  *, va_list);
+
+NDT_Node  *ND_Tree_Parent_Next_Recursive_Get( NDT_Node  *);
+
+NDT_Node  *ND_Tree_Parent_Previous_Recursive_Get( NDT_Node  *);
+
+void  ND_Tree_Recursive_Print( NDT_Node  *, long, FILE  *);
+
+void  ND_Tree_Link_Recursive_Check( NDT_Node  *, int  *, int  *, FILE  *);
+
+NDT_Status  ND_Symbol_Find( void  **, const char  *);
+
+void  ND_Error_Print( void);
+
+void  ND_Signal_Trap( int);
+
+NDT_Status  ND_Address_Check( void  *);
diff --git a/src/libnode/util/ndbench.c b/src/libnode/util/ndbench.c
new file mode 100644
index 0000000..6e232a0
--- /dev/null
+++ b/src/libnode/util/ndbench.c
@@ -0,0 +1,1602 @@
+/*---------------------------------------------------------------------------------*/
+/* %RCSfile: ndbench.c,v %                                                         */
+/*---------------------------------------------------------------------------------*/
+/* %Revision: 2.9 %                                                                */
+/* %Name: libnode-2_1_0-1 %                                                        */
+/* %Date: 2005/01/20 00:07:27 %                                                    */
+/* %Author: agibert %                                                              */
+/*---------------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------------*/
+/* This file is part of LibNode                                                    */
+/*                                                                                 */
+/*    LibNode is free software; you can redistribute it and/or modify              */
+/*    it under the terms of the GNU General Public Licence as published by         */
+/*    the Free Software Foundation; either version 2 of the License, or            */
+/*    (at your option) any later version.                                          */
+/*                                                                                 */
+/*    LibNode is distributed in the hope that it will be useful,                   */
+/*    but WITHOUT ANY WARRANTY; without even the implied warranty of               */
+/*    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                */
+/*    GNU Lesser General Public License for more details.                          */
+/*                                                                                 */
+/*    You should have received a copy of the GNU General Public License            */
+/*    along with LibNode; if not, write to the Free Software                       */
+/*    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA    */
+/*---------------------------------------------------------------------------------*/
+
+
+
+
+
+/*---------------------------------------------------------------------------------*/
+/* Includes                                                                        */
+/*---------------------------------------------------------------------------------*/
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+#include <ctype.h>
+
+
+
+#ifdef _WIN32 
+#   include <sys/timeb.h>
+#else
+#   include <sys/time.h>
+#endif
+
+#ifdef _LIBVER_SUPPORT
+#   include <ver.h>
+#endif
+
+
+
+
+
+/*---------------------------------------------------------------------------------*/
+/* Defines                                                                         */
+/*---------------------------------------------------------------------------------*/
+
+#ifdef _LIBVER_SUPPORT
+VER_INFO_EXPORT( ndbench, "%Revision: 2.9 %", "%Name: libnode-2_1_0-1 %", __FILE__, "%Author: agibert %");
+#   define USAGE "Usage : %s [ --help | --version [-v] | --batch_run <batch_file_name>]\n"
+#else
+#   define USAGE "Usage : %s [ --help | --batch_run <batch_file_name>]\n"
+#endif
+
+#include <node.h>
+
+
+
+#define QUIT                     0
+#define LIB_OPEN                 1
+#define LIB_CLOSE                2
+#define DS_OPEN                  3
+#define DS_CLOSE                 4
+#define DS_FLUSH                 5
+#define DS_CHECK                 6
+#define DS_REORG                 7
+#define DS_INFO_PRINT            8
+#define DS_VALUE_ADD             9
+#define DS_VALUE_REMOVE         10
+#define DS_VALUE_PRINT          11
+#define DS_VALUE_FIND           12
+#define INDEX_LIST_OPEN         13
+#define INDEX_TREE_OPEN         14
+#define INDEX_CLOSE             15
+#define INDEX_FLUSH             16
+#define INDEX_CHECK             17
+#define INDEX_LIST_SUBTYPE_SET  18
+#define INDEX_LIST_TO_TREE      19
+#define INDEX_TREE_SUBTYPE_SET  20
+#define INDEX_TREE_TO_LIST      21
+#define INDEX_REORG             22
+#define INDEX_INFO_PRINT        23
+#define INDEX_VALUE_PRINT       24
+#define INDEX_VALUE_BREAK       25
+#define INDEX_NODE_BREAK        26
+#define BATCH_RUN               27
+
+#define COMMAND_NB              28
+
+#define INDEX_NB                32
+
+
+
+#define DS_STATE_UNKNOWN  0
+#define DS_STATE_OPENED   1
+#define DS_STATE_CLOSED   2
+
+
+
+#define ARG_SIZE          ( 32 + 1)
+
+
+
+#define BUF_LEN            99
+#define BUF_SIZE           (BUF_LEN + 1)
+
+
+
+
+
+/*---------------------------------------------------------------------------------*/
+/* Types                                                                           */
+/*---------------------------------------------------------------------------------*/
+
+typedef struct Command
+{
+
+	short           id;
+	char            Name[25];
+	char            FullName[64];
+	short           DS_State;
+	NDT_Index_Type  Index_Type;
+
+} Command;
+
+typedef char  Arg[32 + 1];
+
+
+
+/* Mesure des temps d'exécution */
+
+#ifdef _WIN32 
+
+typedef struct
+{
+	double         sec;
+	struct _timeb  start;
+	struct _timeb  stop;
+}  cpt;
+
+#   define t_start(x)   { _ftime( &(x.start));}
+#   define t_stop(x)    { _ftime( &(x.stop)); x.sec = (double)(x.stop.time) - (double)(x.start.time) + ((double)(x.stop.millitm) - (double)(x.start.millitm)) / 1000;}
+#   define seed_get(x)  (int)( (x).start.time)
+
+#else
+
+typedef struct
+{
+	double          sec;
+	struct timeval  start;
+	struct timeval  stop;
+}  cpt;
+
+#   define t_start(x)   { gettimeofday( &((x).start), NULL);}
+#   define t_stop(x)    { gettimeofday( &((x).stop), NULL); (x).sec = (double)((x).stop.tv_sec) - (double)((x).start.tv_sec) + ((double)((x).stop.tv_usec) - (double)((x).start.tv_usec)) / 1000000;}
+#   define seed_get(x)  (int)( (x).start.tv_sec)
+
+#endif
+
+cpt t_exec;
+
+
+
+/* Définition des valeurs attachées aux noeuds de la structure */
+
+typedef struct
+{
+	int    Id;
+	char  *Nom;
+} T_Module;
+
+
+
+NDT_Index_Type  idx_type_tab[INDEX_NB];
+
+NDT_Index_Type  idx_type_fifo          = NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_LIST | NDD_INDEX_SUBTYPE_FIFO;
+
+NDT_Index_Type  idx_type_sorted_list   = NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_LIST | NDD_INDEX_SUBTYPE_SORTED;
+
+NDT_Index_Type  idx_type_balanced_tree = NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_TREE | NDD_INDEX_SUBTYPE_BALANCED;
+
+
+
+
+
+/*---------------------------------------------------------------------------------*/
+/* Prototype                                                                       */
+/*---------------------------------------------------------------------------------*/
+
+NDT_Status  Module_Manager( NDT_Root  *, NDT_Index_Id, NDT_Node  *, NDT_Command, va_list);
+
+void  Menu_Print( FILE  *, NDT_Root  *);
+void  Command_Get( int  *, char  **, char  **, FILE  *, FILE  *, short);
+void  Command_Exec_Begin_Print( FILE  *, int);
+void  Command_Exec_End_Print( FILE  *, int, cpt, int);
+void  Command_Index_Range_Get( FILE  *, int  *, int  *, char  *, FILE  *, int, char  *);
+void  Command_Exec( NDT_Root  **, FILE  *, int, char  *, char  *, FILE  *);
+void  Batch_Run( NDT_Root  **, FILE  *, FILE  *, short);
+
+
+
+
+
+/*---------------------------------------------------------------------------------*/
+/* Global Variable                                                                 */
+/*---------------------------------------------------------------------------------*/
+
+Command  Command_Tab[] =
+{
+    { QUIT,                   "Quit",                   "Quit",                             ( DS_STATE_OPENED | DS_STATE_CLOSED), ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
+    { LIB_OPEN,               "Lib_Open",               "Open Library",                     ( DS_STATE_OPENED | DS_STATE_CLOSED), ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
+    { LIB_CLOSE,              "Lib_Close",              "Close Library",                    ( DS_STATE_OPENED | DS_STATE_CLOSED), ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
+    { DS_OPEN,                "DS_Open",                "Open DataStructure",               ( DS_STATE_CLOSED),                   ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
+    { DS_CLOSE,               "DS_Close",               "Close DataStructure",              ( DS_STATE_OPENED),                   ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
+    { DS_FLUSH,               "DS_Flush",               "Flush DataStructure",              ( DS_STATE_OPENED),                   ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
+    { DS_CHECK,               "DS_Check",               "Check DataStructure",              ( DS_STATE_OPENED),                   ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
+    { DS_REORG,               "DS_Reorg",               "Reorg DataStructure",              ( DS_STATE_OPENED),                   ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
+    { DS_INFO_PRINT,          "DS_Info_Print",          "Print DataStructure Informations", ( DS_STATE_OPENED),                   ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
+    { DS_VALUE_ADD,           "DS_Value_Add",           "Add Values to DataStructure",      ( DS_STATE_OPENED),                   ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
+    { DS_VALUE_REMOVE,        "DS_Value_Remove",        "Remove Values from DataStructure", ( DS_STATE_OPENED),                   ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
+    { DS_VALUE_PRINT,         "DS_Value_Print",         "Print DataStructure Values",       ( DS_STATE_OPENED),                   ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
+    { DS_VALUE_FIND,          "DS_Value_Find",          "Find Values in DataStructure",     ( DS_STATE_OPENED),                   ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
+    { INDEX_LIST_OPEN,        "Index_List_Open",        "Open List Index",                  ( DS_STATE_CLOSED),                   ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
+    { INDEX_TREE_OPEN,        "Index_Tree_Open",        "Open Tree Index",                  ( DS_STATE_CLOSED),                   ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
+    { INDEX_CLOSE,            "Index_Close",            "Close Index",                      ( DS_STATE_OPENED),                   ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
+    { INDEX_FLUSH,            "Index_Flush",            "Flush  Index",                     ( DS_STATE_OPENED),                   ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
+    { INDEX_CHECK,            "Index_Check",            "Check  Index",                     ( DS_STATE_OPENED),                   ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
+    { INDEX_LIST_SUBTYPE_SET, "Index_List_SubType_Set", "Set List SubType",                 ( DS_STATE_OPENED),                   ( NDD_INDEX_TYPE_LIST)},
+    { INDEX_LIST_TO_TREE,     "Index_List_To_Tree",     "Convert List to Tree",             ( DS_STATE_OPENED),                   ( NDD_INDEX_TYPE_LIST)},
+    { INDEX_TREE_SUBTYPE_SET, "Index_Tree_SubType_Set", "Set Tree SubType",                 ( DS_STATE_OPENED),                   ( NDD_INDEX_TYPE_TREE)},
+    { INDEX_TREE_TO_LIST,     "Index_Tree_To_List",     "Convert Tree to List",             ( DS_STATE_OPENED),                   ( NDD_INDEX_TYPE_TREE)},
+    { INDEX_REORG,            "Index_Reorg",            "Reorg Index",                      ( DS_STATE_OPENED),                   ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
+    { INDEX_INFO_PRINT,       "Index_Info_Print",       "Print Index Informations",         ( DS_STATE_OPENED),                   ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
+    { INDEX_VALUE_PRINT,      "Index_Value_Print",      "Print Index Values",               ( DS_STATE_OPENED),                   ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
+    { INDEX_VALUE_BREAK,      "Index_Value_Break",      "Break Index Value",                ( DS_STATE_OPENED),                   ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
+    { INDEX_NODE_BREAK,       "Index_Node_Break",       "Break Index Node",                 ( DS_STATE_OPENED),                   ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
+    { BATCH_RUN,              "Batch_Run",              "Run NDBench Bach",                 ( DS_STATE_OPENED | DS_STATE_CLOSED), ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)}
+};
+
+
+
+
+
+/*---------------------------------------------------------------------------------*/
+/*                                                                                 */
+/*---------------------------------------------------------------------------------*/
+
+NDT_Status  Module_Manager( NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id, NDT_Node  *Node_Ptr, NDT_Command  Command, va_list  Args)
+{
+    NDT_Command_Name  Command_Name;
+
+
+    switch( Command)
+    {
+        case NDD_CMD_MANAGER_VERSION:
+        {
+            NDT_Version_Name  *Version_Name_Ptr = (NDT_Version_Name  *)va_arg( Args, NDT_Version_Name  *);
+
+            Command_Name = "NDD_CMD_MANAGER_VERSION";
+
+            *Version_Name_Ptr = "%Revision: 2.9 %   %Name: libnode-2_1_0-1 %   %Date: 2005/01/20 00:07:27 %   %Author: agibert %";
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_INDEX_GET:
+        {
+            /*
+	      NDT_Index_Id  *Reply_Index_Id_Ptr = (NDT_Index_Id  *)va_arg( Args, NDT_Index_Id  *);
+	      NDT_Command   *Reply_Command_Ptr  =  (NDT_Command  *)va_arg( Args, NDT_Command  *);
+	      NDT_Command    Cmd                =     (NDT_Command)va_arg( Args, NDT_Command);
+	      void          *Value_ptr          =         (void  *)va_arg( Args, void  *);
+            */
+            NDT_Index_Id   *Reply_Index_Id_Ptr = (NDT_Index_Id  *)va_arg( Args, NDT_Index_Id  *);
+            NDT_Command    *Reply_Command_Ptr  =  (NDT_Command  *)va_arg( Args, NDT_Command  *);
+            NDT_Command     Cmd                =     (NDT_Command)va_arg( Args, NDT_Command);
+            T_Module      **Module_Ptr_Ptr     =    (T_Module  **)va_arg( Args, T_Module  **);
+
+
+            Command_Name = "NDD_CMD_INDEX_GET";
+
+            switch(Cmd)
+            {
+                /*
+		  case NDT_CMD_SOME_USER_CMD:
+		  {
+		  *Reply_Index_Id_Ptr = 0;
+		  *Reply_Command_Ptr = NDD_CMD_SOME_OTHER_CMD;
+		  break;
+		  }
+		  ...
+                */
+
+                default:
+                {
+                    *Reply_Index_Id_Ptr = Index_Id;
+                    *Reply_Command_Ptr = Cmd;
+                    break;
+                }
+            }
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_ALLOC:
+        {
+            /*
+	      void       **Value_Ptr_Ptr =   (void **)va_arg( Args, void  **);
+	      va_list      user_args     =   (va_list)va_arg( Args, va_list);
+	      user_type    user_data     = (user_type)va_arg( user_args, user_type);
+	      ... =       (...)va_arg( user_args, ...);
+            */
+            T_Module  **Module_Ptr_Ptr = (T_Module  **)va_arg( Args, T_Module  **);
+            va_list     user_args      =      (va_list)va_arg( Args, va_list);
+            char       *Nom            =      (char  *)va_arg( user_args, char  *);
+            int         Id             =          (int)va_arg( user_args, int);
+
+
+            Command_Name = "NDD_CMD_VALUE_ALLOC";
+
+            if( ( *Module_Ptr_Ptr = (T_Module  *)malloc( sizeof(T_Module))) != NULL)
+            {
+                (*Module_Ptr_Ptr)->Nom = strdup(Nom);
+                (*Module_Ptr_Ptr)->Id = Id;
+
+                return( NDS_OK);
+            }
+            else
+            {
+                return( NDS_KO);
+            }
+
+        }
+
+        case NDD_CMD_VALUE_FREE:
+        {
+            /*
+	      void       *Value_Ptr =    (void *)va_arg( Args, void  *);
+	      va_list     user_args =   (va_list)va_arg( Args, va_list);
+	      user_type   user_data = (user_type)va_arg( user_args, user_type);
+	      ... =       (...)va_arg( user_args, ...);
+            */
+            T_Module  *Module_Ptr = (T_Module  *)va_arg( Args, T_Module  *);
+
+
+            Command_Name = "NDD_CMD_VALUE_FREE";
+
+
+            free( Module_Ptr->Nom);
+            free( Module_Ptr);
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_COMP:
+        {
+            /*
+	      void       *Value1_Ptr =    (void *)va_arg( Args, void  *);
+	      void       *Value2_Ptr =    (void *)va_arg( Args, void  *);
+	      va_list     user_args  =   (va_list)va_arg( Args, va_list);
+	      user_type   user_data  = (user_type)va_arg( user_args, user_type);
+	      ... =       (...)va_arg( user_args, ...);
+            */
+            T_Module  *Value1 = (T_Module  *)va_arg( Args, T_Module  *);
+            T_Module  *Value2 = (T_Module  *)va_arg( Args, T_Module  *);
+
+
+            Command_Name = "NDD_CMD_VALUE_COMP";
+
+            if( ( Index_Id >= 0) && ( Index_Id < INDEX_NB))
+            {
+                int  rc;
+
+
+                rc = Value1->Id - Value2->Id;
+
+                if( rc < 0)
+                {
+                    return(NDS_LOWER);
+                }
+                else
+                {
+                    if( rc > 0)
+                    {
+                        return(NDS_GREATER);
+                    }
+                    else
+                    {
+                        return(NDS_EQUAL);
+                    }
+                }
+            }
+	    else
+	    {
+                printf( "Unknown COMP idx (%d) !\n", Index_Id);
+                return( NDS_KO);
+            }
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_ADD:
+        {
+            /*
+	      void       *Value_Ptr =    (void *)va_arg( Args, void  *);
+	      va_list     user_args =   (va_list)va_arg( Args, va_list);
+	      user_type   user_data = (user_type)va_arg( user_args, user_type);
+	      ... =       (...)va_arg( user_args, ...);
+            */
+
+
+            Command_Name = "NDD_CMD_VALUE_ADD";
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_REMOVE:
+        {
+            /*
+	      void       *Value_Ptr =    (void *)va_arg( Args, void  *);
+	      va_list     user_args =   (va_list)va_arg( Args, va_list);
+	      user_type   user_data = (user_type)va_arg( user_args, user_type);
+	      ... =       (...)va_arg( user_args, ...);
+            */
+
+
+            Command_Name = "NDD_CMD_VALUE_REMOVE";
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_PRINT:
+        {
+            /*
+	      NDT_Node             *Next_Node_Ptr   =         (NDT_Node  *)va_arg( Args, NDT_Node  *);
+	      va_list               lib_args        =             (va_list)va_arg( Args, va_list);
+	      FILE                 *Out             =             (FILE  *)va_arg( lib_args, FILE  *);
+	      NDT_Recursive_Mode    Recursive_Mode  =  (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode);
+	      NDT_Recursive_Depth   Recursive_Depth = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth);
+	      va_list               user_args       =             (va_list)va_arg( lib_args, va_list);
+	      user_type             user_data       =           (user_type)va_arg( user_args, user_type);
+	      ... =                 (...)va_arg( user_args, ...);
+
+	      void                 *Value_Ptr       = Node_Ptr->Value;
+            */
+            NDT_Node             *Next_Node_Ptr   =         (NDT_Node  *)va_arg( Args, NDT_Node  *);
+            va_list               lib_args        =             (va_list)va_arg( Args, va_list);
+            FILE                 *Out             =             (FILE  *)va_arg( lib_args, FILE  *);
+            NDT_Recursive_Mode    Recursive_Mode  =  (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode);
+            NDT_Recursive_Depth   Recursive_Depth = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth);
+
+            T_Module             *Module_Ptr      = Node_Ptr->Value;
+
+
+            Command_Name = "NDD_CMD_VALUE_PRINT";
+
+            fprintf( Out, "Id=%d\tNom=\"%s\"\n", Module_Ptr->Id, Module_Ptr->Nom);
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_INFO_PRINT:
+        {
+            /*
+	      NDT_Node             *Next_Node_Ptr   =         (NDT_Node  *)va_arg( Args, NDT_Node  *);
+	      va_list               lib_args        =             (va_list)va_arg( Args, va_list);
+	      FILE                 *Out                      =             (FILE  *)va_arg( lib_args, FILE  *);
+	      NDT_Recursive_Mode    Recursive_Mode  =  (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode);
+	      NDT_Recursive_Depth   Recursive_Depth = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth);
+	      va_list               user_args       =             (va_list)va_arg( lib_args, va_list);
+	      user_type             user_data       =           (user_type)va_arg( user_args, user_type);
+	      ... =                 (...)va_arg( user_args, ...);
+
+	      void                 *Value_Ptr       = Node_Ptr->Value;
+            */
+
+
+            Command_Name = "NDD_CMD_INFO_PRINT";
+
+            return( NDS_OK);
+
+        }
+
+        default:
+        {
+            printf( "Module_Manager() called with an undefined command %d\n", Command);
+            return( NDS_ERRAPI);
+
+        }
+    }
+
+    printf( "Module_Manager() called with command %d (%s)\n", Command, Command_Name);
+    return( NDS_OK);
+}
+
+
+
+
+
+/*---------------------------------------------------------------------------------*/
+/*                                                                                 */
+/*---------------------------------------------------------------------------------*/
+
+void  Menu_Print( FILE  *File_Output, NDT_Root  *DS_Ptr)
+{
+    short  i;
+    char   headc;
+
+
+    fprintf( File_Output, "\n-----------------------------------------------------------------------\nMenu :\n");
+
+    for( i = 0; i < COMMAND_NB; i++)
+    {
+        if( ( DS_Ptr && ( Command_Tab[i].DS_State & DS_STATE_OPENED) && ( DS_Ptr->Index_Tab[0].Type & Command_Tab[i].Index_Type))
+            || ( !DS_Ptr && ( Command_Tab[i].DS_State & DS_STATE_CLOSED)))
+        {
+            headc = '-';
+        }
+        else
+        {
+            headc = '*';
+        }          
+        
+        fprintf( File_Output, "\t%c (%2d) [%s]%*s%s\n", headc, i, Command_Tab[i].Name, ( 25 - strlen(Command_Tab[i].Name)), " ", Command_Tab[i].FullName);
+    }
+}
+
+
+
+
+
+/*---------------------------------------------------------------------------------*/
+/*                                                                                 */
+/*---------------------------------------------------------------------------------*/
+
+void  Command_Get( int  *choice, char  **arg1, char  **arg2, FILE  *File_Output, FILE  *File_Input, short  Interactive_Flag)
+{
+    char   buf[100];
+    char  *tmp_arg1, *tmp_arg2;
+
+
+    do
+    {
+        if( Interactive_Flag)
+        {
+            fprintf( File_Output, "\nChoice ? ");
+        }
+
+        if( fgets( buf, BUF_LEN, File_Input) != NULL)
+        {
+            while( ( buf[ strlen( buf) - 1] == '\r') || ( buf[ strlen( buf) - 1] == '\n') || ( buf[ strlen( buf) - 1] == '\t') || ( buf[ strlen( buf) - 1] == ' '))
+            {
+                buf[ strlen( buf) - 1] = '\0';
+            }
+
+            if( isdigit( *buf))
+            {
+                *choice = atoi( buf);
+            }
+            else
+            {
+                for( *choice = 0; ( *choice < COMMAND_NB) && ( strncmp( buf, Command_Tab[*choice].Name, strlen(Command_Tab[*choice].Name))) ; (*choice)++);
+            }
+
+            if( ( *choice < 0) || ( *choice >= COMMAND_NB))
+            {
+                if( strlen( buf) != 0) fprintf( File_Output, "\nUndefined choice (%s) !\n",buf);
+
+                *choice = -1;
+                *arg1 = NULL;
+                *arg2 = NULL;
+            }
+            else
+            {
+                if( ( tmp_arg1 = strstr( buf, " ")) != NULL)
+                {
+                    tmp_arg1++;
+
+                    if( ( tmp_arg2 = strstr( tmp_arg1, " ")) != NULL)
+                    {
+                        *tmp_arg2 = '\0';
+                        tmp_arg2++;
+
+                        *arg2 = malloc( ARG_SIZE);
+                        if( *arg2 != NULL) strcpy( *arg2, tmp_arg2);
+                    }
+                    else
+                    {
+                        *arg2 = NULL;
+                    }
+
+                    *arg1 = malloc( ARG_SIZE);
+                    if( *arg1 != NULL) strcpy( *arg1, tmp_arg1);
+                }
+                else
+                {
+                    *arg1 = NULL;
+                    *arg2 = NULL;
+                }
+            }
+        }
+        else
+        {
+            *choice = 0;
+            *arg1 = NULL;
+            *arg2 = NULL;
+        }
+    }
+    while( *choice == -1);
+}
+
+
+
+
+
+/*---------------------------------------------------------------------------------*/
+/*                                                                                 */
+/*---------------------------------------------------------------------------------*/
+
+void  Command_Exec_Begin_Print( FILE  *File_Output, int  Choice)
+{
+    fprintf( File_Output, "%s: %s...\n", Command_Tab[Choice].Name, Command_Tab[Choice].FullName);
+    fflush( File_Output);
+}
+
+
+
+
+
+/*---------------------------------------------------------------------------------*/
+/*                                                                                 */
+/*---------------------------------------------------------------------------------*/
+
+void  Command_Exec_End_Print( FILE  *File_Output, int  Choice, cpt  T_Exec, int  nb)
+{
+    if( nb == 1)
+    {
+	fprintf( File_Output, "%s: Completed in (%.4f) second !\n", Command_Tab[Choice].Name, T_Exec.sec);
+    }
+    else
+    {
+	fprintf( File_Output, "%s: Completed in (%.4f) second, (%.2f) per second !\n", Command_Tab[Choice].Name, T_Exec.sec, nb / T_Exec.sec);
+    }
+}
+
+
+
+
+
+/*---------------------------------------------------------------------------------*/
+/*                                                                                 */
+/*---------------------------------------------------------------------------------*/
+
+void  Command_Index_Range_Get( FILE  *File_Output, int  *Low, int  *High, char  *Arg, FILE  *File_Input, int  Choice, char  *Obj_Name)
+{
+    char   buf[100];
+    char  *tmp;
+
+
+    if( Arg == NULL)
+    {
+        fprintf( File_Output, "%s: %s range (?-?) : ", Command_Tab[Choice].Name, Obj_Name);
+        fgets( buf, BUF_LEN, File_Input);
+
+        Arg = buf;
+    }
+
+    tmp = strstr( Arg, "-");
+
+    if( tmp != NULL)
+    {
+        *tmp = '\0';
+        *Low = atoi( Arg);
+        tmp++;
+        *High = atoi( tmp);
+  
+        if( ( *High < *Low) || ( !strcmp( Obj_Name, "Index") && ( *High >= INDEX_NB)))
+        {
+            fprintf( File_Output, "%s: Invalit range (%d-%d) !\n", Command_Tab[Choice].Name, *Low, *High);
+            *Low = *High = -1;
+        }
+    }
+    else
+    {
+        fprintf( File_Output, "%s: Invalit range !\n", Command_Tab[Choice].Name);
+        *Low = *High = -1;
+    }
+}
+
+
+
+
+
+/*---------------------------------------------------------------------------------*/
+/*                                                                                 */
+/*---------------------------------------------------------------------------------*/
+
+void  Command_Exec( NDT_Root  **DS_Ptr_Ptr, FILE  *File_Output, int  Choice, char  *Arg1, char  *Arg2, FILE  *File_Input)
+{
+    int             low, high, i, j, nb_removed, Nb_Detected, Nb_Corrected;
+    T_Module        Ref_Module, *Module_Ptr;
+    char            buf[BUF_SIZE];
+    NDT_Index_Type  index_subtype;
+
+
+    fprintf( File_Output, "\n");
+
+    switch( Choice)
+    {
+        case QUIT:
+        {
+            break;
+        }
+
+        case LIB_OPEN:
+        {
+            Command_Exec_Begin_Print( File_Output, Choice);
+
+	    if( Arg1 == NULL)
+	    {
+		fprintf( File_Output, "Library_Open: Debug Mode ( 0:OFF | 1:ON) ? ");
+		fgets( buf, BUF_LEN, File_Input);
+
+		Arg1 = buf;
+	    }
+
+	    Choice = atoi( Arg1);
+
+            t_start( t_exec);
+            ND_Library_Open( Choice);
+            t_stop( t_exec);
+
+            Command_Exec_End_Print( File_Output, Choice, t_exec, 1);
+            break;
+        }
+
+        case LIB_CLOSE:
+        {
+            Command_Exec_Begin_Print( File_Output, Choice);
+
+            t_start( t_exec);
+            ND_Library_Close();
+            t_stop( t_exec);
+
+            Command_Exec_End_Print( File_Output, Choice, t_exec, 1);
+            break;
+        }
+
+        case DS_OPEN:
+        {
+            Command_Exec_Begin_Print( File_Output, Choice);
+
+	    if( Arg1 == NULL)
+	    {
+		fprintf( File_Output, "DataStruct_Open: Symbol Lookup ( 0:OFF | 1:ON) ? ");
+		fgets( buf, BUF_LEN, File_Input);
+
+		Arg1 = buf;
+	    }
+
+	    Choice = atoi( Arg1);
+
+            for( i = 0; i < INDEX_NB; i++)
+            {
+                idx_type_tab[i] = NDD_INDEX_STATUS_CLOSED;
+            }
+
+            t_start( t_exec);
+	    if( Choice == 0)
+	    {
+		ND_DataStruct_Open( DS_Ptr_Ptr, INDEX_NB, idx_type_tab, "Module_Manager", Module_Manager, NULL, NULL, NULL, NULL, NDD_TRUE, NULL);
+	    }
+	    else
+	    {
+		ND_DataStruct_Open( DS_Ptr_Ptr, INDEX_NB, idx_type_tab, "Module_Manager",           NULL, NULL, NULL, NULL, NULL, NDD_TRUE, NULL);
+	    }
+            t_stop( t_exec);
+
+            Command_Exec_End_Print( File_Output, Choice, t_exec, 1);
+            break;
+        }
+
+        case DS_CLOSE:
+        {
+            Command_Exec_Begin_Print( File_Output, Choice);
+
+            t_start( t_exec);
+            ND_DataStruct_Close( *DS_Ptr_Ptr);
+            t_stop( t_exec);
+
+            *DS_Ptr_Ptr = NULL;
+
+            Command_Exec_End_Print( File_Output, Choice, t_exec, 1);
+            break;
+        }
+
+        case DS_FLUSH:
+        {
+            Command_Exec_Begin_Print( File_Output, Choice);
+
+            t_start( t_exec);
+            ND_DataStruct_Flush( *DS_Ptr_Ptr);
+            t_stop( t_exec);
+
+            Command_Exec_End_Print( File_Output, Choice, t_exec, 1);
+            break;
+        }
+
+        case DS_CHECK:
+        {
+            Command_Exec_Begin_Print( File_Output, Choice);
+
+            Nb_Corrected = Nb_Detected = 0;
+
+            t_start( t_exec);
+            ND_DataStruct_Check( *DS_Ptr_Ptr, &Nb_Detected, &Nb_Corrected, File_Output);
+            t_stop( t_exec);
+
+            Command_Exec_End_Print( File_Output, Choice, t_exec, 1);
+            break;
+        }
+
+        case DS_REORG:
+        {
+            Command_Exec_Begin_Print( File_Output, Choice);
+
+            t_start( t_exec);
+            ND_DataStruct_Reorg( *DS_Ptr_Ptr);
+            t_stop( t_exec);
+
+            Command_Exec_End_Print( File_Output, Choice, t_exec, 1);
+            break;
+        }
+
+        case DS_INFO_PRINT:
+        {
+            Command_Exec_Begin_Print( File_Output, Choice);
+
+            ND_DataStruct_Info_Print( File_Output, *DS_Ptr_Ptr, NDD_RECURSIVE_MODE_PARENT_CHILD, 99, 0);
+
+            break;
+        }
+
+        case DS_VALUE_ADD:
+        {
+            int  order;
+
+
+            Command_Index_Range_Get( File_Output, &low, &high, Arg1, File_Input, Choice, "Value");
+
+	    if( low != -1)
+	    {
+		if( Arg2 == NULL)
+		{
+		    fprintf( File_Output, "DS_Value_Add: Add order ( 0:croissant | 1:decroissant) ? ");
+		    fgets( buf, BUF_LEN ,stdin);
+
+		    Arg2 = buf;
+		}
+
+		order = atoi( Arg2);
+
+		fprintf( File_Output, "DS_Value_Add: Adding from: (%d)   to: (%d)    order: (%d)...\n", low, high, order);
+		fflush( File_Output);
+
+		t_start( t_exec);
+
+		if( order == 0)
+		{
+		    i = low;
+		    j = high + 1;
+
+		    while( i < j)
+		    {
+			if( ND_Value_Alloc( *DS_Ptr_Ptr, (void **)&Module_Ptr, "x", i) == NDS_OK)
+			{
+			    ND_DataStruct_Value_Add( *DS_Ptr_Ptr, Module_Ptr);
+			}
+			else
+			{
+			    fprintf( File_Output, "DS_Value_Add: Allocation Failled !\n");
+			    break;
+			}
+
+			i++;
+		    }
+		}
+		else
+		{
+		    i = high;
+		    j = low - 1;
+
+		    while( i > j)
+		    {
+			if( ND_Value_Alloc( *DS_Ptr_Ptr, (void **)&Module_Ptr, "x", i) == NDS_OK)
+			{
+			    ND_DataStruct_Value_Add( *DS_Ptr_Ptr, Module_Ptr);
+			}
+			else
+			{
+			    fprintf( File_Output, "DS_Value_Add: Allocation Failled !\n");
+			    break;
+			}
+
+			i--;
+		    }
+		}
+
+                t_stop( t_exec);
+
+		Command_Exec_End_Print( File_Output, Choice, t_exec, high - low);
+	    }
+
+            break;
+        }
+
+        case DS_VALUE_REMOVE:
+        {
+            int  order;
+            nb_removed = 0;
+
+
+            Command_Index_Range_Get( File_Output, &low, &high, Arg1, File_Input, Choice, "Value");
+
+	    if( low != -1)
+	    {
+		if( Arg2 == NULL)
+		{
+		    fprintf( File_Output, "\nDS_Value_Remove: Remove order (croissant=0 | decroissant=1) ? ");
+		    fgets( buf, BUF_LEN, File_Input);
+
+		    Arg2 = buf;
+		}
+
+		order = atoi( Arg2);
+
+		t_start( t_exec);
+
+		if( order == 0)
+		{
+		    i = low;
+		    j = high + 1;
+
+		    while( i < j)
+		    {
+			Ref_Module.Id = i;
+
+			if( ( ND_DataStruct_Value_Find( (void **)&Module_Ptr, *DS_Ptr_Ptr, &Ref_Module) == NDS_OK) && ( Module_Ptr != NULL))
+			{
+			    if( ND_DataStruct_Value_Remove( *DS_Ptr_Ptr, (void **)&Module_Ptr) == NDS_OK)
+			    {
+				nb_removed++;
+				ND_Value_Free( *DS_Ptr_Ptr, Module_Ptr);
+			    }
+			}
+
+			i++;
+		    }
+		}
+		else
+		{
+		    i = high;
+		    j = low - 1;
+		    t_start( t_exec);
+
+		    while( i > j)
+		    {
+			Ref_Module.Id = i;
+
+			if( ( ND_DataStruct_Value_Find( (void **)&Module_Ptr, *DS_Ptr_Ptr, &Ref_Module) == NDS_OK) && ( Module_Ptr != NULL))
+			{
+			    if( ND_DataStruct_Value_Remove( *DS_Ptr_Ptr, (void **)&Module_Ptr) == NDS_OK)
+			    {
+				nb_removed++;
+				ND_Value_Free( *DS_Ptr_Ptr, Module_Ptr);        
+			    }
+			}
+
+			i--;
+		    }
+		}
+
+		t_stop( t_exec);
+
+		Command_Exec_End_Print( File_Output, Choice, t_exec, high - low);
+	    }
+
+            break;
+        }
+
+        case DS_VALUE_PRINT:
+        {
+            Command_Exec_Begin_Print( File_Output, Choice);
+
+            ND_DataStruct_Value_Print( File_Output, *DS_Ptr_Ptr, NDD_RECURSIVE_MODE_PARENT_CHILD, 99, 0);
+            break;
+        }
+
+        case DS_VALUE_FIND:
+        {
+            Command_Index_Range_Get( File_Output, &low, &high, Arg1, File_Input, Choice, "Search");
+
+	    if( low != -1)
+	    {
+		fprintf( File_Output, "DS_Value_Find: from: (%d)   to: (%d)...\n", low, high);
+		fflush( File_Output);
+
+		i = low;
+		j = high + 1;
+
+		t_start( t_exec);
+
+		while( i < j)
+		{
+		    Ref_Module.Id = low + (int)( (double)( high - low) * rand() / ( RAND_MAX + 1.0));
+		    ND_DataStruct_Value_Find( (void *)&Module_Ptr, *DS_Ptr_Ptr, &Ref_Module);
+		    i++;
+		}
+
+		t_stop (t_exec);
+
+		Command_Exec_End_Print( File_Output, Choice, t_exec, high - low);
+	    }
+
+            break;
+        }
+
+        case INDEX_LIST_OPEN:
+        {
+            Command_Index_Range_Get( File_Output, &low, &high, Arg1, File_Input, Choice, "Index");
+
+            if( low != -1)
+            {
+		fprintf( File_Output, "Index_List_Open: Opening a FIFO List from: (%d)   to: (%d)...\n", low, high);
+		fflush( File_Output);
+
+		t_start( t_exec);
+
+		for( i  = low; i <= high; i++)
+		{
+		    ND_Index_Open( *DS_Ptr_Ptr, (NDT_Index_Id)i, idx_type_fifo);
+		}
+
+		t_stop( t_exec);
+
+		Command_Exec_End_Print( File_Output, Choice, t_exec, high - low);
+	    }
+
+            break;
+        }
+
+        case INDEX_TREE_OPEN:
+        {
+            Command_Index_Range_Get( File_Output, &low, &high, Arg1, File_Input, Choice, "Index");
+
+            if( low != -1)
+            {
+
+                fprintf( File_Output, "Index_Tree_Open: Opening a balanced Tree from: (%d)   to: (%d)...\n", low, high);
+                fflush( File_Output);
+
+                t_start( t_exec);
+
+                for( i  = low; i <= high; i++)
+		{
+                    ND_Index_Open( *DS_Ptr_Ptr, (NDT_Index_Id)i, idx_type_balanced_tree);
+		}
+
+                t_stop( t_exec);
+
+		Command_Exec_End_Print( File_Output, Choice, t_exec, high - low);
+	    }
+
+            break;
+        }
+
+        case INDEX_CLOSE:
+        {
+            Command_Index_Range_Get( File_Output, &low, &high, Arg1, File_Input, Choice, "Index");
+
+            if( low != -1)
+            {
+
+                fprintf( File_Output, "Index_Close: Closing index from: (%d)   to: (%d)...\n", low, high);
+                fflush( File_Output);
+
+                t_start( t_exec);
+
+                for( i  = high; i >= low; i--)
+                {
+                    ND_Index_Close( *DS_Ptr_Ptr, (NDT_Index_Id)i);
+      	        }
+
+                t_stop( t_exec);
+
+                Command_Exec_End_Print( File_Output, Choice, t_exec, high - low);
+            }
+
+            break;
+        }
+
+        case INDEX_LIST_SUBTYPE_SET:
+        {
+	    int subtype;
+
+
+            Command_Index_Range_Get( File_Output, &low, &high, Arg1, File_Input, Choice, "Index");
+
+            if( low != -1)
+            {
+                if( Arg2 == NULL)
+		{
+		    fprintf( File_Output, "Index_List_SubType_Set: List SubType ( 0:FIFO | 1:LIFO | 2:Sorted) ? ");
+		    fgets( buf, BUF_LEN, File_Input);
+
+		    Arg2 = buf;
+		}
+
+		subtype = atoi( Arg2);
+
+                switch( subtype)
+                {
+                    case 0:
+                    {
+                        index_subtype = NDD_INDEX_SUBTYPE_FIFO;
+                        break;
+                    }
+
+                    case 1:
+                    {
+                        index_subtype = NDD_INDEX_SUBTYPE_FILO;
+                        break;
+                    }
+
+                    case 2:
+                    {
+                        index_subtype = NDD_INDEX_SUBTYPE_SORTED;
+                        break;
+                    }
+
+                    default:
+                    {
+                        index_subtype = NDD_INDEX_SUBTYPE_UNKNOWN;
+                        printf ("Index_List_SubType_Set: Invalid selection (%d) !\n", subtype);
+                        break;
+                    }
+                }
+
+		if( index_subtype != NDD_INDEX_SUBTYPE_UNKNOWN)
+		{
+		    fprintf( File_Output, "Index_List_SubType_Set: Setting List SubType to: (%d) (%s) !\n", index_subtype, ND_INDEX_SUBTYPE_VALUE_ASCII_GET( index_subtype));
+
+		    t_start( t_exec);
+
+		    for( i  = low; i <= high; i++)
+		    {
+			if( ND_INDEX_TYPE_LIST_IS( *DS_Ptr_Ptr, i))
+			{
+			    (*DS_Ptr_Ptr)->Index_Tab[i].Type = ( (*DS_Ptr_Ptr)->Index_Tab[i].Type & NDD_INDEX_SUBTYPE_RMSK) | index_subtype;
+			}
+			else
+			{
+			    fprintf( File_Output, "Index_List_SubType_Set: Error: index (%d) is not a List !\n", i);
+			}
+		    }
+
+		    t_stop( t_exec);
+
+		    Command_Exec_End_Print( File_Output, Choice, t_exec, high - low);
+		}
+	    }
+
+	    break;
+        }
+
+        case INDEX_TREE_SUBTYPE_SET:
+        {
+	    int subtype;
+
+
+            Command_Index_Range_Get( File_Output, &low, &high, Arg1, File_Input, Choice, "Index");
+
+            if( low != -1)
+            {
+		if( Arg2 == NULL)
+		{
+		    fprintf( File_Output, "Index_Tree_SubType_Set: Tree SubType (0:UnBalanced | 1:Balanced) ? ");
+		    fgets( buf, BUF_LEN, stdin);
+
+		    Arg2 = buf;
+		}
+
+		subtype = atoi( Arg2);
+
+                switch( subtype)
+                {
+                    case 0:
+                    {
+                        index_subtype = NDD_INDEX_SUBTYPE_UNBALANCED;
+                        break;
+                    }
+
+                    case 1:
+                    {
+                        index_subtype = NDD_INDEX_SUBTYPE_BALANCED;
+                        break;
+                    }
+
+                    default:
+                    {
+			index_subtype = NDD_INDEX_SUBTYPE_UNKNOWN;
+                        printf ("Index_Tree_SubType_Set: Invalid selection (%d)!\n", subtype);
+                        break;
+                    }
+		}
+
+		if( index_subtype != NDD_INDEX_SUBTYPE_UNKNOWN)
+		{
+ 
+		    t_start( t_exec);
+
+		    for( i  = low; i <= high; i++)
+		    {
+			if( ND_INDEX_TYPE_TREE_IS( *DS_Ptr_Ptr, i))
+			{
+			    (*DS_Ptr_Ptr)->Index_Tab[i].Type = ( (*DS_Ptr_Ptr)->Index_Tab[i].Type & NDD_INDEX_SUBTYPE_RMSK) | index_subtype;
+			}
+			else
+			{
+			    fprintf( File_Output, "Index_Tree_SubType_Set: Error: index (%d) is not a Tree !\n", i);
+			}
+		    }
+
+		    t_stop( t_exec);
+
+		    Command_Exec_End_Print( File_Output, Choice, t_exec, high - low);
+		}
+	    }
+
+	    break;
+        }
+
+        case INDEX_REORG:
+        {
+            Command_Index_Range_Get( File_Output, &low, &high, Arg1, File_Input, Choice, "Index");
+
+            if( low != -1)
+            {
+		t_start( t_exec);
+
+		for( i  = low; i <= high; i++)
+		{
+		    fprintf( File_Output, "Index_Reorg: Reorganizing index (%d)...\n", i);
+		    fflush( File_Output);
+
+		    ND_Index_Reorg( *DS_Ptr_Ptr, (NDT_Index_Id)i);
+		}
+
+		t_stop( t_exec);
+
+		Command_Exec_End_Print( File_Output, Choice, t_exec, high - low);
+	    }
+
+	    break;
+        }
+
+        case INDEX_TREE_TO_LIST:
+        {
+            Command_Index_Range_Get( File_Output, &low, &high, Arg1, File_Input, Choice, "Index");
+
+            if( low != -1)
+            {
+                t_start( t_exec);
+
+                for( i  = low; i <= high; i++)
+		{
+                    fprintf( File_Output, "Index_Tree_To_List: Converting Index (%d)...\n", i);
+                    fflush( File_Output);
+
+                    ND_Index_Convert( *DS_Ptr_Ptr, (NDT_Index_Id)i, idx_type_sorted_list);
+                }
+
+                t_stop (t_exec);
+
+		Command_Exec_End_Print( File_Output, Choice, t_exec, high - low);
+	    }
+
+            break;
+        }
+
+        case INDEX_LIST_TO_TREE:
+        {
+            Command_Index_Range_Get( File_Output, &low, &high, Arg1, File_Input, Choice, "Index");
+
+            if( low != -1)
+            {
+                t_start( t_exec);
+
+                for( i  = low; i <= high; i++)
+		{
+                    fprintf( File_Output, "Index_List_To_Tree: Converting Index (%d)...\n", i);
+                    fflush( File_Output);
+
+                    ND_Index_Convert( *DS_Ptr_Ptr, (NDT_Index_Id)i, idx_type_balanced_tree);
+                }
+
+                t_stop (t_exec);
+
+		Command_Exec_End_Print( File_Output, Choice, t_exec, high - low);
+	    }
+
+            break;
+        }
+
+        case INDEX_INFO_PRINT:
+        {
+            Command_Index_Range_Get( File_Output, &low, &high, Arg1, File_Input, Choice, "Index");
+
+            if( low != -1)
+            {
+                fprintf( File_Output, "Index_Info_Print: Printing index from: (%d)   to: (%d)...\n", low, high);
+                fflush( File_Output);
+
+                for( i  = low; i <= high; i++)
+      	        {
+		    ND_Index_Info_Print( File_Output, *DS_Ptr_Ptr, (NDT_Index_Id)i, NDD_RECURSIVE_MODE_PARENT_CHILD, 99, 0);
+                }
+	    }
+
+            break;
+        }
+
+        case INDEX_VALUE_PRINT:
+        {
+            fprintf( File_Output, "DS_Value_Print:\n");
+            fflush( File_Output);
+
+            ND_DataStruct_Value_Print( File_Output, *DS_Ptr_Ptr, NDD_RECURSIVE_MODE_PARENT_CHILD, 99, 0);
+            break;
+        }
+
+        case INDEX_VALUE_BREAK:
+        {
+	    int        position;
+	    NDT_Node  *node_ptr;
+
+
+            Command_Index_Range_Get( File_Output, &low, &high, Arg1, File_Input, Choice, "Index");
+
+            if( low != -1)
+            {
+		if( Arg2 == NULL)
+		{
+		    fprintf( File_Output, "Index_Value_Break: Value position (0:Head | 1:Tail | 2:Random) ? ");
+		    fgets( buf, BUF_LEN, stdin);
+
+		    Arg2 = buf;
+		}
+
+		position = atoi( Arg2);
+
+                fprintf( File_Output, "Index_Value_Break: Breaking %s values from index : (%d)   to: (%d)...\n",
+			 ( position == 0 ) ? "Head" : ( ( position == 1) ? "Tail" : "Random"),
+			 low, high);
+                fflush( File_Output);
+
+                t_start( t_exec);
+
+                fprintf( File_Output, "Index_Value_Break: Breaking value of nodes: ");
+                fflush( File_Output);
+
+                for( i  = low; i <= high; i++)
+      	        {
+		    switch( position)
+		    {
+			case 0:
+			{
+			    node_ptr  =(*DS_Ptr_Ptr)->Index_Tab[i].Head;
+			    break;
+			}
+
+			case 1:
+			{
+			    node_ptr=(*DS_Ptr_Ptr)->Index_Tab[i].Tail;
+			    break;
+			}
+
+			case 2:
+			{
+			    j = (int)( (double)( (*DS_Ptr_Ptr)->Index_Tab[i].Node_Number) * rand() / ( RAND_MAX + 1.0));
+
+			    for( node_ptr = (*DS_Ptr_Ptr)->Index_Tab[i].Head; j > 0; j--)
+			    {
+				node_ptr = node_ptr->Right;
+			    }
+
+			    break;
+			}
+		    }
+
+		    fprintf( File_Output, "0x(%x)", node_ptr);
+		    fflush( File_Output);
+
+		    node_ptr->Value = (void  *)-1;
+                }
+
+                t_stop (t_exec);
+
+		fprintf( File_Output, "\n");
+		fflush( File_Output);
+
+		Command_Exec_End_Print( File_Output, Choice, t_exec, high - low);
+	    }
+
+            break;
+        }
+
+        case INDEX_NODE_BREAK:
+        {
+
+            break;
+        }
+
+        case INDEX_CHECK:
+        {
+            Command_Index_Range_Get( File_Output, &low, &high, Arg1, File_Input, Choice, "Index");
+
+            if( low != -1)
+            {
+                t_start( t_exec);
+
+                for( i  = low; i <= high; i++)
+		{
+                    fprintf( File_Output, "Index_Check: Checking Index (%d)...\n", i);
+                    fprintf( File_Output, "Index_Check: ");
+                    fflush( File_Output);
+
+		    Nb_Corrected = Nb_Detected = 0;
+		    ND_Index_Check( *DS_Ptr_Ptr, (NDT_Index_Id)i, &Nb_Detected, &Nb_Corrected, File_Output);
+                }
+
+                t_stop (t_exec);
+
+		Command_Exec_End_Print( File_Output, Choice, t_exec, high - low);
+	    }
+
+            break;
+        }
+
+        case BATCH_RUN:
+        {
+            FILE  *file_input;
+
+
+            if( Arg1 == NULL)
+            {
+                fprintf( File_Output, "Batch_Run: Batch file name ? ");
+
+                fgets( buf, BUF_LEN, stdin);
+                buf[ strlen( buf) - 1] = '\0';
+                Arg1 = buf;
+            }
+
+            file_input = fopen( Arg1, "r");
+
+            if( file_input == NULL)
+            {
+                fprintf( File_Output, "Batch_Run: Can't open file (%s)!\n", Arg1);
+            }
+            else
+            {
+                fprintf( File_Output, "\n\n--------------------------------------------------------------------------------\n");
+                fprintf( File_Output, "Batch_Run: Starting execution (%s)...\n", Arg1);
+                Batch_Run( DS_Ptr_Ptr, File_Output, file_input, 0);
+                fprintf( File_Output, "\n");
+                fprintf( File_Output, "Batch_Run: Ending execution (%s)...\n", Arg1);
+
+		fclose( file_input);
+            }
+
+            break;
+        }
+
+        default:
+        {
+            fprintf( File_Output, "\nUndefined command (%d) !\n", Choice);
+        }
+    }
+}
+
+
+
+
+
+/*---------------------------------------------------------------------------------*/
+/*                                                                                 */
+/*---------------------------------------------------------------------------------*/
+
+void  Batch_Run( NDT_Root  **DS_Ptr_Ptr, FILE  *File_Output, FILE  *File_Input, short  Interactive_Flag)
+{
+    int    choice;
+    char  *arg1, *arg2;
+
+
+    do
+    {
+        if( Interactive_Flag)
+        {
+            Menu_Print( File_Output, *DS_Ptr_Ptr);
+        }
+
+        Command_Get( &choice, &arg1, &arg2, File_Output, File_Input, Interactive_Flag);
+
+        if( ( choice != QUIT) && ( choice != -1))
+        {
+            Command_Exec( DS_Ptr_Ptr, File_Output, choice, arg1, arg2, File_Input);
+        }
+
+	if( arg1 != NULL) free( arg1);
+	if( arg2 != NULL) free( arg2);
+    }
+    while( choice != QUIT);
+}
+
+
+
+
+
+/*---------------------------------------------------------------------------------*/
+/*                                                                                 */
+/*---------------------------------------------------------------------------------*/
+
+int  main( int  argc, char  **argv)
+{
+    NDT_Root  *ds_ptr = NULL;
+
+
+    /* Init Random numbers... */
+
+    t_start( t_exec);
+    t_stop( t_exec);
+    srand( seed_get(t_exec));
+
+
+
+    /* Args Parsing */
+
+    if( argc >= 2)
+    {
+        if( !strcmp( argv[1], "--help"))
+        {
+            fprintf( stderr, USAGE, argv[0]);
+            return( 1);
+        }
+#ifdef _LIBVER_SUPPORT
+        else if( !strcmp( argv[1], "--version"))
+        {
+            if( argc >= 3 && !strcmp( argv[2], "-v"))
+            {
+                return( VER_Object_Print( stdout, VERD_VERBOSE));
+            }
+            else
+            {
+	        return( VER_Object_Print( stdout, VERD_MINIMAL));
+            }
+        }
+#endif
+        else if( !strcmp( argv[1], "--batch_run"))
+        {
+            /* Batch Mode */
+
+            Command_Exec( &ds_ptr, stdout, BATCH_RUN, argv[2], NULL, stdin);
+
+            return( 0);
+        }
+        else
+        {
+            fprintf( stderr, USAGE, argv[0]);
+            return( -1);
+        }
+    }
+
+
+
+    /* Interactive Mode */
+
+    Batch_Run( &ds_ptr, stdout, stdin, 1);
+
+    return( 0);
+}
diff --git a/src/libnode/util/test-10-s.ndb b/src/libnode/util/test-10-s.ndb
new file mode 100644
index 0000000..cf2138c
--- /dev/null
+++ b/src/libnode/util/test-10-s.ndb
@@ -0,0 +1,10 @@
+Lib_Open 0
+DS_Open 1
+Index_List_Open 0-0
+DS_Value_Add 1-10 0
+DS_Value_Find 1-10
+Index_List_To_Tree 0-0
+DS_Value_Find 1-10
+DS_Check
+DS_Close
+Lib_Close
diff --git a/src/libnode/util/test-10.ndb b/src/libnode/util/test-10.ndb
new file mode 100644
index 0000000..76e86c8
--- /dev/null
+++ b/src/libnode/util/test-10.ndb
@@ -0,0 +1,10 @@
+Lib_Open 0
+DS_Open 0
+Index_List_Open 0-0
+DS_Value_Add 1-10 0
+DS_Value_Find 1-10
+Index_List_To_Tree 0-0
+DS_Value_Find 1-10
+DS_Check
+DS_Close
+Lib_Close
diff --git a/src/libnode/util/test-100K-s.ndb b/src/libnode/util/test-100K-s.ndb
new file mode 100644
index 0000000..5429713
--- /dev/null
+++ b/src/libnode/util/test-100K-s.ndb
@@ -0,0 +1,10 @@
+Lib_Open 0
+DS_Open 1
+Index_List_Open 0-0
+DS_Value_Add 1-100000 0
+DS_Value_Find 49900-50100
+Index_List_To_Tree 0-0
+DS_Value_Find 1-100000
+DS_Check
+DS_Close
+Lib_Close
diff --git a/src/libnode/util/test-100K.ndb b/src/libnode/util/test-100K.ndb
new file mode 100644
index 0000000..a0279e7
--- /dev/null
+++ b/src/libnode/util/test-100K.ndb
@@ -0,0 +1,10 @@
+Lib_Open 0
+DS_Open 0
+Index_List_Open 0-0
+DS_Value_Add 1-100000 0
+DS_Value_Find 49900-50100
+Index_List_To_Tree 0-0
+DS_Value_Find 1-100000
+DS_Check
+DS_Close
+Lib_Close
diff --git a/src/libnode/util/test-10K-s.ndb b/src/libnode/util/test-10K-s.ndb
new file mode 100644
index 0000000..3586b39
--- /dev/null
+++ b/src/libnode/util/test-10K-s.ndb
@@ -0,0 +1,10 @@
+Lib_Open 0
+DS_Open 1
+Index_List_Open 0-0
+DS_Value_Add 1-10000 0
+DS_Value_Find 4000-6000
+Index_List_To_Tree 0-0
+DS_Value_Find 1-10000
+DS_Check
+DS_Close
+Lib_Close
diff --git a/src/libnode/util/test-10K.ndb b/src/libnode/util/test-10K.ndb
new file mode 100644
index 0000000..088f6e4
--- /dev/null
+++ b/src/libnode/util/test-10K.ndb
@@ -0,0 +1,10 @@
+Lib_Open 0
+DS_Open 0
+Index_List_Open 0-0
+DS_Value_Add 1-10000 0
+DS_Value_Find 4000-6000
+Index_List_To_Tree 0-0
+DS_Value_Find 1-10000
+DS_Check
+DS_Close
+Lib_Close
diff --git a/src/libnode/util/test-1M-s.ndb b/src/libnode/util/test-1M-s.ndb
new file mode 100644
index 0000000..87d9c6d
--- /dev/null
+++ b/src/libnode/util/test-1M-s.ndb
@@ -0,0 +1,10 @@
+Lib_Open 0
+DS_Open 1
+Index_List_Open 0-0
+DS_Value_Add 1-1000000 0
+DS_Value_Find 499990-500010
+Index_List_To_Tree 0-0
+DS_Value_Find 1-1000000
+DS_Check
+DS_Close
+Lib_Close
diff --git a/src/libnode/util/test-1M.ndb b/src/libnode/util/test-1M.ndb
new file mode 100644
index 0000000..5ccf43c
--- /dev/null
+++ b/src/libnode/util/test-1M.ndb
@@ -0,0 +1,10 @@
+Lib_Open 0
+DS_Open 0
+Index_List_Open 0-0
+DS_Value_Add 1-1000000 0
+DS_Value_Find 499990-500010
+Index_List_To_Tree 0-0
+DS_Value_Find 1-1000000
+DS_Check
+DS_Close
+Lib_Close
diff --git a/src/libnode/util/test-all.ndb b/src/libnode/util/test-all.ndb
new file mode 100644
index 0000000..cc341de
--- /dev/null
+++ b/src/libnode/util/test-all.ndb
@@ -0,0 +1,9 @@
+Batch_Run test-error.ndb
+Batch_Run test-10.ndb
+Batch_Run test-10-s.ndb
+Batch_Run test-10K.ndb
+Batch_Run test-10K-s.ndb
+Batch_Run test-100K.ndb
+Batch_Run test-100K-s.ndb
+Batch_Run test-1M.ndb
+Batch_Run test-1M-s.ndb
diff --git a/src/libnode/util/test-error.ndb b/src/libnode/util/test-error.ndb
new file mode 100644
index 0000000..df0ddbe
--- /dev/null
+++ b/src/libnode/util/test-error.ndb
@@ -0,0 +1,15 @@
+DS_Open 0
+Lib_Open 0
+DS_Open 0
+Index_List_Open 0-0
+DS_Value_Add 1-10 0
+Lib_Close
+Lib_Open 1
+DS_Open 0
+Index_List_Open 0-0
+DS_Value_Add 1-10 0
+Index_Value_Break 0-0 0
+Index_Value_Break 0-0 1
+Index_Value_Break 0-0 2
+DS_Check
+Lib_Close
diff --git a/src/libstatic_data_mng/include/static_data_mng.h b/src/libstatic_data_mng/include/static_data_mng.h
new file mode 100644
index 0000000..82712be
--- /dev/null
+++ b/src/libstatic_data_mng/include/static_data_mng.h
@@ -0,0 +1,420 @@
+/*----------------------------------------------------------------------------*/
+/* File: static_data_mng.h 				    		      */
+/*----------------------------------------------------------------------------*/
+/*                                                                            */
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#ifndef _STATIC_DATA_MNG_H_
+#define _STATIC_DATA_MNG_H_
+
+
+
+#include <imr.h>
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IMRD_API definition                                                        */
+/*----------------------------------------------------------------------------*/
+
+#   ifdef _LIBSTATIC_DATA_MNG_C_
+#       define IMRD_SDM_API  
+#   else
+#       define IMRD_SDM_API  extern
+#   endif
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IMRT_SDM_Config                                                            */
+/*----------------------------------------------------------------------------*/
+
+typedef short  IMRT_SDM_Flag;
+
+#define IMRD_SDM_FLAG_UNKNOWN  ( IMRT_SDM_Flag) 0
+#define IMRD_SDM_FLAG_XML      ( IMRT_SDM_Flag) 1
+#define IMRD_SDM_FLAG_SQL      ( IMRT_SDM_Flag) 2
+
+
+
+typedef struct
+{
+	IMRT_SDM_Flag  Flag;
+	IMRT_Path      Lib_Path;
+}  IMRT_SDM_Config;
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IMRT_MsgMap_Id definition                                                */
+/*----------------------------------------------------------------------------*/
+
+typedef int  IMRT_MsgMap_Id;
+
+#define IMRD_MSGMAP_ID_UNKNOWN  ( IMRT_MsgMap_Id) 0
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IMRT_MsgMap definition                                                     */
+/*----------------------------------------------------------------------------*/
+
+typedef struct IMRT_MsgMap
+{
+	IMRT_MsgMap_Id  Id;
+	char            Name[IMRD_NAME_SIZE];
+	IMRT_Msg       *Msg_Input_Ptr;
+	IMRT_Msg       *Msg_Output_Ptr;
+	NDT_Root       *FieldMap_Struct_Ptr;
+}  IMRT_MsgMap;
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IMRT_Jump definition                                                       */
+/*----------------------------------------------------------------------------*/
+
+typedef struct IMRT_Jump
+{
+	IMRT_Fmt  *Fmt_Ptr;
+	IMRT_Msg  *Msg_Ptr;
+	int        Branche_Id;
+}  IMRT_Jump;
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IMRT_MapCmd                                                                */
+/*----------------------------------------------------------------------------*/
+
+/*#define IMRD_JUMP_NB_MAX   ( short) 40*/
+
+
+
+typedef short  IMRT_MapCmd_Id;
+
+
+
+typedef short  IMRT_MapCmd_Type;
+
+#define IMRD_MAPCMD_TYPE_UNKNOWN  ( IMRT_MapCmd_Type) 0
+#define IMRD_MAPCMD_TYPE_MAP      ( IMRT_MapCmd_Type) 1
+#define IMRD_MAPCMD_TYPE_COPY     ( IMRT_MapCmd_Type) 2
+#define IMRD_MAPCMD_TYPE_IDENT    ( IMRT_MapCmd_Type) 3
+#define IMRD_MAPCMD_TYPE_GOTO     ( IMRT_MapCmd_Type) 4
+
+
+
+typedef short  IMRT_MapCmd_Branch_Id;
+
+
+
+typedef short  IMRT_MapCmd_Flag;
+
+
+
+typedef struct IMRT_MapCmd
+{
+	IMRT_MapCmd_Id          MapCmd_Id;
+	IMRT_MapCmd_Type        TypeCmd;
+	IMRT_MapCmd_Branch_Id   Branche_Id; 
+	IMRT_Boolean            Ident_Total;
+	IMRT_Msg               *Ident_First_Msg_Ptr;
+	IMRT_Fmt               *Fmt_Input_Ptr;
+	IMRT_FmtAttr           *FmtAttr_Input_Ptr;
+	IMRT_Fmt               *Fmt_Output_Ptr;
+	IMRT_FmtAttr           *FmtAttr_Output_Ptr;
+	IMRT_Buffer_Id          Buffer_Id_Input;
+	IMRT_Buffer_Id          Buffer_Id_Output;
+	IMRT_Buffer_Id          Buffer_Id_Ident;
+	IMRT_MapCmd_Flag        Clear_Flag;
+	IMRT_MsgMap            *MsgMap_Ptr;
+	IMRT_MapCmd_Branch_Id   Goto_Branche_Id; 
+	int						JmpTbleNbElts;
+	IMRT_Jump               *Jump_Tab;
+}  IMRT_MapCmd;
+
+
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Global Variables                                                           */
+/*----------------------------------------------------------------------------*/
+
+#   ifdef _LIBSTATIC_DATA_MNG_
+
+#   else
+
+extern IMRT_Module  IMRG_SDM_Module;
+
+#   endif
+
+
+
+
+
+
+
+/******************************************************************************/
+/* Static Data Manager Client CallBack                                        */
+/******************************************************************************/
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Format Add CallBack                                                        */
+/*----------------------------------------------------------------------------*/
+/* (I) Fmt_Id:      Format id                                                 */
+/* (I) Fmt_Name:    Format name                                               */
+/* (I) Fmt_Id_Nb:   Total number of format                                    */
+/*----------------------------------------------------------------------------*/
+
+typedef IMRT_Status  IMRT_SDMCB_Fmt_Add( IMRT_Fmt_Id, IMRT_Fmt_Name, IMRT_Fmt_Id);
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Convert Add CallBack                                                       */
+/*----------------------------------------------------------------------------*/
+/* (I) Cnv_Id:      Convert id                                                */
+/* (I) Cnv_Name:    Convert name                                              */
+/* (I) Cnv_Id_Nb:   Total number of convert                                   */
+/*----------------------------------------------------------------------------*/
+
+typedef IMRT_Status  IMRT_SDMCB_Cnv_Add( IMRT_Cnv_Id, IMRT_Cnv_Name, IMRT_Cnv_Id);
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Buffer Mapping CallBack                                                    */
+/*----------------------------------------------------------------------------*/
+/* (I) Buffer_Id_Target:   Target buffer id                                   */
+/* (I) Fmt_Target:         Target format                                      */
+/* (I) Fmt_Attr_Target:    Target format attribute                            */
+/* (I) Buffer_Id_Src:      Source buffer id                                   */
+/* (I) Fmt_Src:            Source format                                      */
+/* (I) Fmt_Attr_Src:       Source format attribute                            */
+/* (I) MsgMap:             Message Map to use                                 */
+/* (I) Clear_Flag:         Clear or donn't clear output buffer                */
+/*----------------------------------------------------------------------------*/
+
+typedef IMRT_Status  IMRT_SDMCB_Buffer_Map( IMRT_Buffer_Id, IMRT_Fmt_Id, IMRT_FmtAttr_Value, IMRT_Buffer_Id, IMRT_Fmt_Id, IMRT_FmtAttr_Value, IMRT_MsgMap  *, IMRT_MapCmd_Flag);
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Buffer Copy CallBack                                                       */
+/*----------------------------------------------------------------------------*/
+/* (I) Buffer_Id_Target:   Target buffer id                                   */
+/* (I) Buffer_Id_Src:      Source buffer id                                   */
+/*----------------------------------------------------------------------------*/
+
+typedef IMRT_Status  IMRT_SDMCB_Buffer_Copy( IMRT_Buffer_Id, IMRT_Buffer_Id);
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Buffer Identification CallBack                                             */
+/*----------------------------------------------------------------------------*/
+/* (O)   Fmt_Id_Ptr:      Buffer format to return                             */
+/* (I/O) Msg_Id_Ptr:      Buffer message id to read (if not total) and return */
+/* (I)   Buffer_Id_Ptr:   Id of the buffer to identify                        */
+/* (I)   Ident_Total:     True if total identification                        */
+/*----------------------------------------------------------------------------*/
+
+typedef IMRT_Status  IMRT_SDMCB_Buffer_Ident( IMRT_Fmt_Id  *, IMRT_Msg_Id  *, IMRT_Buffer_Id, IMRT_Boolean);
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Field Mapping CallBack                                                     */
+/*----------------------------------------------------------------------------*/
+/* (I) Field_Target_Ptr:   Target Field pointer                               */
+/* (I) Field_Source_Ptr:   Source Field pointer                               */
+/*----------------------------------------------------------------------------*/
+
+typedef IMRT_Status  IMRT_SDMCB_Field_Map( IMRT_Field  *, IMRT_Field  *);
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Field Ident CallBack                                                       */
+/*----------------------------------------------------------------------------*/
+/* (I) FieldMap_Ptr:   FielMap pointer                                        */
+/*----------------------------------------------------------------------------*/
+
+typedef IMRT_Status  IMRT_SDMCB_Ident_Field_Value( IMRT_Field  *, IMRT_Field_Value_Id);
+
+
+typedef IMRT_Status  IMRT_SDMCB_Ident_Field_Exist( IMRT_Field *);
+
+
+typedef IMRT_Status  IMRT_SDMCB_Ident_Msg_Size( size_t);
+
+
+
+
+
+/******************************************************************************/
+/* Static Data Manager API                                                    */
+/******************************************************************************/
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Open Static Data Manager                                                   */
+/*----------------------------------------------------------------------------*/
+/* Lib_Flag:   Setup SDM init mode (XML, SQL, ...)                            */
+/*----------------------------------------------------------------------------*/
+
+IMRD_SDM_API IMRT_Status  IMR_SDM_Library_Open( IMRT_SDM_Config  *);
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Close Static Data Manager                                                  */
+/*----------------------------------------------------------------------------*/
+
+IMRD_SDM_API IMRT_Status  IMR_SDM_Library_Close( void);
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Dump Data Structures to SQL files                                          */
+/*----------------------------------------------------------------------------*/
+IMRD_SDM_API IMRT_Status  IMR_SDM_SQL_Dump(void);
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Dump Data Structures to XML files                                          */
+/*----------------------------------------------------------------------------*/
+IMRD_SDM_API IMRT_Status  IMR_SDM_XML_Dump(void);
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Proceed Format                                                             */
+/*----------------------------------------------------------------------------*/
+/* (I) CCB_Fmt_Add_Ptr:   Format add callback                                 */
+/*----------------------------------------------------------------------------*/
+
+IMRD_SDM_API IMRT_Status  IMR_SDM_Fmt_Proceed( IMRT_SDMCB_Fmt_Add  *);
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Proceed Convert                                                            */
+/*----------------------------------------------------------------------------*/
+/* (I) CCB_Cnv_Add_Ptr:   Convert add callback                                */
+/*----------------------------------------------------------------------------*/
+IMRD_SDM_API IMRT_Status  IMR_SDM_Cnv_Proceed( IMRT_SDMCB_Cnv_Add  *);
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Proceed Convert                                                            */
+/*----------------------------------------------------------------------------*/
+/* (I) CCB_Cnv_Add_Ptr:   Convert add callback                                */
+/*----------------------------------------------------------------------------*/
+
+IMRD_SDM_API IMRT_Status  IMR_SDM_Cnv_Proceed( IMRT_SDMCB_Cnv_Add  *);
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Proceed Mapping Path                                                       */
+/*----------------------------------------------------------------------------*/
+/* (I) Appl_Id_Target:         Target buffer application id                   */
+/* (I) Fmt_Id_Target:          Target buffer format id                        */
+/* (I) Msg_Id_Target:          Target buffer message id                       */
+/* (I) ApplId_Src:             Source buffer application id                   */
+/* (I) Fmt_Id_Src:             Source buffer format id                        */
+/* (I) Msg_Id_Src:             Source buffer message id                       */
+/* (I) CCB_Buffer_Map_Ptr:     Buffer mapping callback                        */
+/* (I) CCB_Buffer_Copy_Ptr:    Buffer copy callback                           */
+/* (I) CCB_Buffer_Ident_Ptr:   Buffer identification callback                 */
+/*----------------------------------------------------------------------------*/
+
+IMRD_SDM_API IMRT_Status  IMR_SDM_MapPath_Proceed( IMRT_Appl_Id, IMRT_Fmt_Id, IMRT_Msg_Id,
+					       IMRT_Appl_Id, IMRT_Fmt_Id, IMRT_Msg_Id,
+					       IMRT_SDMCB_Buffer_Map  *, IMRT_SDMCB_Buffer_Copy  *, IMRT_SDMCB_Buffer_Ident  *);
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Proceed Buffer Mapping                                                     */
+/*----------------------------------------------------------------------------*/
+/* (I) MsgMap_Ptr:          Message map pointer                               */
+/* (I) CCB_Field_Map_Ptr:   Field mapping callback                            */
+/*----------------------------------------------------------------------------*/
+
+IMRD_SDM_API IMRT_Status  IMR_SDM_MsgMap_Proceed( IMRT_MsgMap  *, IMRT_SDMCB_Field_Map  *);
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Proceed Message Identification                                             */
+/*----------------------------------------------------------------------------*/
+/* (I) Fmt_Id:                Target buffer format id                         */
+/* (I) Msg_Id:                Target buffer message id                        */
+/* (I) CCB_Field_Ident_Ptr:   Field ident callback                            */
+/*----------------------------------------------------------------------------*/
+
+IMRD_SDM_API IMRT_Status  IMR_SDM_MsgIdent_Proceed( IMRT_Fmt_Id, IMRT_Msg_Id  *, IMRT_SDMCB_Ident_Field_Value  *, IMRT_SDMCB_Ident_Field_Exist *, IMRT_SDMCB_Ident_Msg_Size *);
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Convert Buffer Format Name to Buffer Format Id                             */
+/*----------------------------------------------------------------------------*/
+
+IMRD_SDM_API IMRT_Status  IMR_SDM_Fmt_Id_Get( IMRT_Fmt_Id  *, const IMRT_Fmt_Name);
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Convert Buffer Appli Name to Buffer Appli Id                               */
+/*----------------------------------------------------------------------------*/
+IMRD_SDM_API IMRT_Status  IMR_SDM_Appl_Id_Get( IMRT_Appl_Id  *, const IMRT_Appl_Name);
+
+
+
+#endif
diff --git a/src/libstatic_data_mng/src/Makefile b/src/libstatic_data_mng/src/Makefile
new file mode 100644
index 0000000..dfc6541
--- /dev/null
+++ b/src/libstatic_data_mng/src/Makefile
@@ -0,0 +1,79 @@
+#------------------------------------------------------------------------------
+# Local Makefile
+#------------------------------------------------------------------------------
+# $Workfile:   Makefile  $                                                     
+#------------------------------------------------------------------------------
+# $Author: agibert $                                                        
+# $Date: 2008/11/12 02:25:23 $                                             
+# $Revision: 1.1 $                                                         
+# $Label:  $                                                           
+#------------------------------------------------------------------------------
+
+#------------------------------------------------------------------------------
+# IMR - Interlinking Message Router                                            
+# Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)                
+# mailto:arnaud@rx3.net                                                        
+# http://www.rx3.org/dvp/?dvp=imr                                              
+#------------------------------------------------------------------------------
+# This file is part of IMR                                                     
+#                                                                              
+# This program is free software; you can redistribute it and/or                
+# modify it under the terms of the GNU General Public License                  
+# as published by the Free Software Foundation; either version 2               
+# of the License, or (at your option) any later version.                       
+#                                                                              
+# This program is distributed in the hope that it will be useful,              
+# but WITHOUT ANY WARRANTY; without even the implied warranty of               
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                
+# GNU General Public License for more details.                                 
+#                                                                              
+# You should have received a copy of the GNU General Public License            
+# along with this program; if not, write to the Free Software Foundation,      
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.          
+#------------------------------------------------------------------------------
+
+
+
+
+
+#------------------------------------------------------------------------------
+# Var include
+#------------------------------------------------------------------------------
+
+include ../../Makefile_var.mk
+
+
+
+#------------------------------------------------------------------------------
+# Variables
+#------------------------------------------------------------------------------
+
+TARGET=		libstatic_data_mng$(SHLIB_SUFFIX)
+
+OBJ=		libstatic_data_mng.o					\
+		arc_hdl_xml.o						\
+		buffer_info_mng.o					\
+		mapping_info_mng.o					\
+		struct_info_mng.o					\
+		buffer_info_xml.o					\
+		mapping_info_xml.o					\
+		struct_info_xml.o
+
+ifeq ($(ORACLE_SUPPORT),1)
+		OBJ+=	arc_hdl_sql.o					\
+			buffer_info_sql.o				\
+			mapping_info_sql.o				\
+			struct_info_sql.o
+endif
+
+EXTRA_INC=	
+
+EXTRA_LIB=	
+
+
+
+#------------------------------------------------------------------------------
+# Rule include
+#------------------------------------------------------------------------------
+
+include ../../Makefile_rule.mk
diff --git a/src/libstatic_data_mng/src/arc_hdl_sql.h b/src/libstatic_data_mng/src/arc_hdl_sql.h
new file mode 100644
index 0000000..6e660fc
--- /dev/null
+++ b/src/libstatic_data_mng/src/arc_hdl_sql.h
@@ -0,0 +1,101 @@
+/*----------------------------------------------------------------------------*/
+/* File: arc_hdl_sql.h 				                 	      */
+/*----------------------------------------------------------------------------*/
+/*                                                                            */
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#ifndef _ARC_HDL_SQL_H_
+#   define _ARC_HDL_SQL_H_
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Global Include                                                             */
+/*----------------------------------------------------------------------------*/
+
+#   include <libstatic_data_mng.h>
+#   include <sqlca.h>
+
+
+/*----------------------------------------------------------------------------*/
+/* Global variables                                                           */
+/*----------------------------------------------------------------------------*/
+#   ifdef _ARC_HDL_SQL_PC_
+
+typedef short  IMRT_DB_Open_Flag;
+
+#define IMRD_DB_OPEN_FLAG_UNKNOWN  ( IMRT_DB_Open_Flag) 0
+#define IMRD_DB_OPEN_FLAG_OPENED   ( IMRT_DB_Open_Flag) 1
+#define IMRD_DB_OPEN_FLAG_CLOSED   ( IMRT_DB_Open_Flag) 2
+
+
+
+typedef struct IMRT_SDM_SQL_Base
+{
+    IMRT_DB_Open_Flag  Open_Flag;
+
+} IMRT_SDM_SQL_Base;
+
+
+
+IMRT_SDM_SQL_Base  IMRG_SDM_SQL_Base =
+{
+	IMRD_DB_OPEN_FLAG_CLOSED
+};
+
+#	endif
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Prototypes                                                                 */
+/*----------------------------------------------------------------------------*/
+
+#   ifdef _ARC_HDL_SQL_PC_
+
+IMRT_Status SDM_HDR_SQL_Init(IMRT_SDM_Flag  Flag);
+IMRT_Status SDM_HDR_SQL_DInit(void);
+IMRT_Status SDM_SQL_ConnectOra(void);
+IMRT_Status SDM_SQL_DisconnectOra(void);
+IMRT_Status SDM_SQL_Set_Struct_Version(IMRT_Data_Version *, char *);
+
+#   else
+
+extern IMRT_Status SDM_HDR_SQL_Init(IMRT_SDM_Flag  Flag);
+extern IMRT_Status SDM_HDR_SQL_DInit(void);
+extern IMRT_Status SDM_SQL_ConnectOra(void);
+extern IMRT_Status SDM_SQL_DisconnectOra(void);
+extern IMRT_Status SDM_SQL_Set_Struct_Version(IMRT_Data_Version *, char *);
+
+#   endif
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+
+#endif
diff --git a/src/libstatic_data_mng/src/arc_hdl_sql.pc b/src/libstatic_data_mng/src/arc_hdl_sql.pc
new file mode 100644
index 0000000..e15cf67
--- /dev/null
+++ b/src/libstatic_data_mng/src/arc_hdl_sql.pc
@@ -0,0 +1,185 @@
+/*----------------------------------------------------------------------------*/
+/* File: arc_hdl_sql.pc   		         		  	      */
+/*----------------------------------------------------------------------------*/
+/*                                                                            */
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#define _LIBSTATIC_DATA_MNG_
+#define _ARC_HDL_SQL_PC_
+
+#include "arc_hdl_sql.h" 
+
+
+IMRT_Status SDM_HDR_SQL_Init(IMRT_SDM_Flag  Flag)
+{
+  IMRT_Status  status;
+
+  status = IMRS_OK;
+
+  if (Flag == IMRD_SDM_FLAG_SQL)
+  {
+    status = SDM_SQL_ConnectOra();
+    if (status == IMRS_OK)
+    {
+      IMRG_SDM_SQL_Base.Open_Flag = IMRD_DB_OPEN_FLAG_OPENED;
+    }
+  }
+
+  return(status);
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status SDM_HDR_SQL_DInit(void)
+{
+  IMRT_Status  status;
+
+  status = IMRS_OK;
+
+  if (IMRG_SDM_SQL_Base.Open_Flag == IMRD_DB_OPEN_FLAG_OPENED)
+  {
+    status = SDM_SQL_DisconnectOra();
+  }
+
+  return(status);
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status SDM_SQL_ConnectOra(void)
+{
+  IMRT_Status  status;
+  const char sFunctionName []="SDM_SQL_ConnectOra";
+  EXEC SQL BEGIN DECLARE SECTION;
+      VARCHAR vConnectString[50];
+  EXEC SQL END DECLARE SECTION;
+
+  status = IMRS_OK;
+  strcpy ( (char *) vConnectString.arr, "/");
+  vConnectString.len = strlen( (char *) vConnectString.arr );
+
+  EXEC SQL CONNECT :vConnectString ;
+  if (sqlca.sqlcode != 0)
+  {
+    IMRD_LM_LOG_ERROR_3("Erreur %s. Erreur Oracle : %d - %s !", sFunctionName, sqlca.sqlcode, sqlca.sqlerrm.sqlerrmc);
+    status = IMRS_KO;
+  }
+
+  return(status);
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status SDM_SQL_DisconnectOra(void)
+{
+  IMRT_Status  status;
+  const char sFunctionName []="SDM_SQL_DisconnectOra";
+
+  status = IMRS_OK;
+
+  EXEC SQL COMMIT WORK RELEASE;
+  if (sqlca.sqlcode != 0)
+  {
+    IMRD_LM_LOG_ERROR_3("Erreur %s. Erreur Oracle : %d - %s !", sFunctionName, sqlca.sqlcode, sqlca.sqlerrm.sqlerrmc);
+    status = IMRS_KO;
+  }
+
+  return(status);
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  SDM_SQL_Set_Struct_Version(IMRT_Data_Version *Data_Version_Ptr, char *Component_Ptr)
+{
+	const char sFunctionName []="SDM_SQL_Get_Struct_Version";
+	IMRT_Status   status;
+
+	EXEC SQL BEGIN DECLARE SECTION;
+		VARCHAR    vVersName[IMRD_SDMD_VERS_NAME_LEN];
+		VARCHAR    vVersLabel[IMRD_SDMD_VERS_LABEL_LEN];
+		VARCHAR    vVersDate[IMRD_SDMD_VERS_DATE_LEN];
+
+		short      hIndVersName;
+		short      hIndVersLabel;
+		short      hIndVersDate;
+	EXEC SQL END DECLARE SECTION;
+
+
+	/* initialisation */
+	status = IMRS_OK;
+
+	strcpy((char*) vVersName.arr, Component_Ptr);
+	vVersName.len = strlen((char*) vVersName.arr );
+
+	memset(vVersLabel.arr, '\0', (size_t) IMRD_SDMD_VERS_LABEL_LEN);
+	memset(vVersDate.arr, '\0', (size_t) IMRD_SDMD_VERS_DATE_LEN);
+
+	EXEC SQL DECLARE cur_imr_version CURSOR FOR
+		SELECT VERS_LABEL, VERS_DATE
+		FROM   IMR_DATA_VERSION
+		WHERE  VERS_NAME = :vVersName;
+
+	EXEC SQL OPEN cur_imr_version;
+
+	EXEC SQL FETCH cur_imr_version
+	INTO :vVersLabel:hIndVersLabel,
+	     :vVersDate:hIndVersDate;
+
+	if (sqlca.sqlcode == 0) 
+	{
+		if (hIndVersLabel >= 0)
+		{
+			strcpy(Data_Version_Ptr->Label, (char*)vVersLabel.arr);
+		}
+		else
+		{
+			Data_Version_Ptr->Label[0] = '\0';
+		}
+			
+		if (hIndVersDate >= 0)
+		{
+			strcpy(Data_Version_Ptr->Date, (char*)vVersDate.arr);
+		}
+		else
+		{
+			Data_Version_Ptr->Date[0] = '\0';
+		}
+	}
+	else
+	{
+		status = IMRS_KO;
+	}
+
+	EXEC SQL CLOSE cur_imr_version;
+
+	return(status);  
+
+}
+
+/*----------------------------------------------------------------------------*/
+/*                                                                            */
+/*----------------------------------------------------------------------------*/
+
diff --git a/src/libstatic_data_mng/src/arc_hdl_xml.c b/src/libstatic_data_mng/src/arc_hdl_xml.c
new file mode 100644
index 0000000..1f2b3dc
--- /dev/null
+++ b/src/libstatic_data_mng/src/arc_hdl_xml.c
@@ -0,0 +1,76 @@
+/*----------------------------------------------------------------------------*/
+/* File: arc_hdl_xml.c   		         		  	      */
+/*----------------------------------------------------------------------------*/
+/*                                                                            */
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#define _LIBSTATIC_DATA_MNG_
+#define _ARC_HDL_XML_C_
+
+#include "arc_hdl_xml.h" 
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/*Raise Error                                                                 */
+/*ctx : contexte avec lequele la fonction est appelée                         */
+/*functionname : nom de la focntion qui léve l'erreur                         */
+/*lib_error :  libellé de l'erreur                                            */
+/*code : code de l'erreur                                                     */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status SDM_HDR_XML_Init(IMRT_SDM_Flag  Flag)
+{
+
+  return(IMRS_OK);
+
+}
+
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status SDM_HDR_XML_DInit(void)
+{
+
+  return(IMRS_OK);
+
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+void SDM_RaiseError(xmlParserCtxt * Ctx_Sax_Ptr, IMRT_Error * Struct_Error_Ptr ,IMRT_Status * Flag_Error , 
+		    const char* functionname, const char* lib_error, const int code )
+{
+  
+  fprintf(stderr,"\nRaise error <%s>",lib_error);
+  Ctx_Sax_Ptr->sax = &ErrorSAXHandlerStruct;
+  *Flag_Error = IMRS_KO;
+  Struct_Error_Ptr->errorCode = code;
+  strcpy(Struct_Error_Ptr->libError,lib_error) ;
+  strcpy(Struct_Error_Ptr->function,functionname);
+}
diff --git a/src/libstatic_data_mng/src/arc_hdl_xml.h b/src/libstatic_data_mng/src/arc_hdl_xml.h
new file mode 100644
index 0000000..532b540
--- /dev/null
+++ b/src/libstatic_data_mng/src/arc_hdl_xml.h
@@ -0,0 +1,113 @@
+/*----------------------------------------------------------------------------*/
+/* File: arc_hdl_xml.h 				                 	      */
+/*----------------------------------------------------------------------------*/
+/*                                                                            */
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#ifndef _ARC_HDL_XML_H_
+#   define _ARC_HDL_XML_H_
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Global Include                                                             */
+/*----------------------------------------------------------------------------*/
+
+#   include <libstatic_data_mng.h>
+
+
+
+#   ifdef _ARC_HDL_XML_C_
+/*-----------------------------------------------------------------------------*/
+/*Globale Variable                                                             */
+/*-----------------------------------------------------------------------------*/
+
+
+xmlSAXHandler ErrorSAXHandlerStruct = {
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    1,
+    NULL,
+    NULL,
+    NULL,
+    NULL
+};
+# else
+extern xmlSAXHandler ErrorSAXHandlerStruct; 
+
+# endif
+/*----------------------------------------------------------------------------*/
+/* Prototypes                                                                 */
+/*----------------------------------------------------------------------------*/
+
+#   ifdef _ARC_HDL_XML_C_
+
+IMRT_Status SDM_HDR_XML_Init(IMRT_SDM_Flag  Flag);
+IMRT_Status SDM_HDR_XML_DInit(void);
+void SDM_RaiseError(xmlParserCtxt * Ctx_Sax_Ptr, IMRT_Error * Struct_Erro_Ptr ,IMRT_Status * Flag_Error , 
+		    const char* functionname, const char* lib_error, const int code );
+
+#   else
+
+extern IMRT_Status SDM_HDR_XML_Init(IMRT_SDM_Flag  Flag);
+extern IMRT_Status SDM_HDR_XML_DInit(void);
+extern 	void SDM_RaiseError(xmlParserCtxt * Ctx_Sax_Ptr, IMRT_Error * Struct_Erro_Ptr ,IMRT_Status * Flag_Error , 
+			    const char* functionname, const char* lib_error, const int code );
+
+#   endif
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+
+#endif
diff --git a/src/libstatic_data_mng/src/buffer_info_mng.c b/src/libstatic_data_mng/src/buffer_info_mng.c
new file mode 100644
index 0000000..20dad2b
--- /dev/null
+++ b/src/libstatic_data_mng/src/buffer_info_mng.c
@@ -0,0 +1,2909 @@
+/*----------------------------------------------------------------------------*/
+/* File: buffer_info_mng.c   		         		  	      */
+/*----------------------------------------------------------------------------*/
+/*                                                                            */
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#define _LIBSTATIC_DATA_MNG_
+#define _BUFFER_INFO_MNG_C_
+
+#include "buffer_info_mng.h" 
+
+IMRT_Status  SDM_DataStruct_Finalize(NDT_Root  *ds_Ptr, NDT_Index_Type *Index_Type_Ptr, short hMaxEntries)
+{
+	NDT_Status    nd_status;
+	IMRT_Status   status;
+	short  Compteur;
+
+	Compteur = 0;
+	status = IMRS_OK;
+
+	do
+	{
+		if (Compteur == 0)
+		{
+		    nd_status = ND_DataStruct_Convert(ds_Ptr, Index_Type_Ptr);
+		  
+			if(nd_status != NDS_OK)
+			{
+				
+				status = IMRS_KO;
+			}
+		}
+		else
+		{
+			nd_status = ND_Index_Open(ds_Ptr, Compteur, Index_Type_Ptr[Compteur]);
+			if(nd_status != NDS_OK)
+			{
+				
+				status = IMRS_KO;
+			}
+		}
+
+		Compteur = Compteur + 1;
+	} while((nd_status == NDS_OK)&&(Compteur < hMaxEntries));
+ 
+	return(status);	
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+void SDM_IniTableCritere(IMRT_Status Table[],const int NbElement)
+{
+  int i;
+  for(i =0; i<NbElement;i++)
+  {
+    Table[i] = IMRS_OK;
+  }
+}
+
+
+void SDM_CompareCritereMapPath(IMRT_Status CitereTable[],
+			       const int NbCritere,
+			       SDMT_CritereRecChemin * Critere,
+			       IMRT_MapPath * myMapPath,
+			       IMRT_Status  *Valide )
+{
+    int indexe;
+    
+    SDM_IniTableCritere(CitereTable,NbCritere);
+    
+    if( (Critere->InputAppli != IMRD_APPL_ID_UNKNOWN) &&
+        (Critere->InputAppli != myMapPath->Appl_Input_Ptr->Id) &&
+        (myMapPath->Appl_Input_Ptr->Id != IMRD_APPL_ID_UNKNOWN)
+	)
+    {
+		CitereTable[SDMD_CRI_IA] = IMRS_KO;
+    }
+    if( (Critere->OutputAppli != IMRD_APPL_ID_UNKNOWN ) &&
+        (Critere->OutputAppli != myMapPath->Appl_Output_Ptr->Id) &&
+        (myMapPath->Appl_Output_Ptr->Id != IMRD_APPL_ID_UNKNOWN )
+	)
+    {
+		CitereTable[SDMD_CRI_OA] = IMRS_KO;
+    }
+    if( (Critere->InputFormat != IMRD_FMT_ID_UNKNOWN) &&
+        (Critere->InputFormat != myMapPath->Fmt_Input_Ptr->Id) &&
+        (myMapPath->Fmt_Input_Ptr->Id != IMRD_FMT_ID_UNKNOWN)
+	)
+    {
+		CitereTable[SDMD_CRI_IF] = IMRS_KO;
+    }
+    if( (Critere->OutputFormat != IMRD_FMT_ID_UNKNOWN) &&
+        (Critere->OutputFormat != myMapPath->Fmt_Output_Ptr->Id) &&
+        (myMapPath->Fmt_Output_Ptr->Id != IMRD_FMT_ID_UNKNOWN)
+        )
+    {
+		CitereTable[SDMD_CRI_OF] = IMRS_KO;
+    }
+    
+    *Valide=IMRS_OK;
+    for(indexe =0; indexe <NbCritere;indexe++)
+    {
+        if(CitereTable[indexe] == IMRS_KO)
+	{
+	    *Valide = IMRS_KO;            
+    }
+    }
+}
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Appl Manager                                                               */
+/*----------------------------------------------------------------------------*/
+
+NDT_Status  SDM_Appl_Manager( NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id, NDT_Node  *Node_Ptr, NDT_Command  Command, va_list  Args)
+{
+    NDT_Command_Name  Command_Name;
+
+
+    switch( Command)
+    {
+	case NDD_CMD_MANAGER_VERSION:
+        {
+            NDT_Version_Name  *Version_Name_Ptr = (NDT_Version_Name  *)va_arg( Args, NDT_Version_Name  *);
+
+
+            Command_Name = "NDD_CMD_MANAGER_VERSION";
+            *Version_Name_Ptr = "Revision: 2.1    Name: libnode-2_0_4-1    Date: 2002/02/28 22:00:35    Author: agibert ";
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_INDEX_GET:
+        {
+            /*
+	      NDT_Index_Id  *Reply_Index_Id_Ptr = (NDT_Index_Id  *)va_arg( Args, NDT_Index_Id  *);
+	      NDT_Command   *Reply_Command_Ptr  = (NDT_Command  *)va_arg( Args, NDT_Command  *);
+	      NDT_Command    Cmd                = (NDT_Command)va_arg( Args, NDT_Command);
+	      void          *Value_ptr          = (void  *)va_arg( Args, void  *);
+            */
+            NDT_Index_Id  *Reply_Index_Id_Ptr = (NDT_Index_Id  *)va_arg( Args, NDT_Index_Id  *);
+            NDT_Command   *Reply_Command_Ptr  = (NDT_Command  *)va_arg( Args, NDT_Command  *);
+            NDT_Command    Cmd                = (NDT_Command)va_arg( Args, NDT_Command);
+            IMRT_Appl    * Value_ptr          = (IMRT_Appl  *)va_arg( Args, IMRT_Appl  *);
+
+
+            Command_Name = "NDD_CMD_INDEX_GET";
+
+            switch(Cmd)
+            {
+                case IMRD_SDMD_CMD_INDEX0_PRINT:
+                {
+                    *Reply_Index_Id_Ptr = 0;
+                    *Reply_Command_Ptr = NDD_CMD_VALUE_PRINT;
+
+                    break;
+                }
+                default:
+                {
+                    *Reply_Index_Id_Ptr = Index_Id;
+                    *Reply_Command_Ptr = Cmd;
+
+                    break;
+                }
+            }
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_ALLOC:
+        {
+            /*
+	      void       **Value_Ptr_Ptr = (void **)va_arg( Args, void  **);
+	      va_list      user_args     = (va_list)va_arg( Args, va_list);
+	      user_type    user_data     = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+            */
+            IMRT_Appl  **Value_Ptr_Ptr = va_arg( Args, IMRT_Appl  **);
+
+
+            Command_Name = "NDD_CMD_VALUE_ALLOC";
+
+            if( ( *Value_Ptr_Ptr = (IMRT_Appl  *)malloc( sizeof(IMRT_Appl))) == NULL)
+            {
+                return( NDS_ERRMEM);
+            }
+            else
+            {
+                SDM_InitAppl(*Value_Ptr_Ptr);
+                return( NDS_OK);
+            }
+        }
+
+        case NDD_CMD_VALUE_FREE:
+        {
+            /*
+	      void       *Value_Ptr = (void *)va_arg( Args, void  *);
+	      va_list     user_args = (va_list)va_arg( Args, va_list);
+	      user_type   user_data = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+            */
+            IMRT_Appl  *Value_Ptr = (IMRT_Appl  *)va_arg( Args, IMRT_Appl  *);
+            Command_Name = "NDD_CMD_VALUE_FREE";
+
+            free( Value_Ptr);
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_COMP:
+        {
+            /*
+	      void       *Value1_Ptr = (void *)va_arg( Args, void  *);
+	      void       *Value2_Ptr = (void *)va_arg( Args, void  *);
+	      va_list     user_args  = (va_list)va_arg( Args, va_list);
+	      user_type   user_data  = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+            */
+            IMRT_Appl    *Value1_Ptr = va_arg( Args, IMRT_Appl  *);
+            IMRT_Appl    *Value2_Ptr = va_arg( Args, IMRT_Appl  *);
+
+
+            Command_Name = "NDD_CMD_VALUE_COMP";
+
+            switch( Index_Id)
+            {
+                case 0:
+                {
+                    if( Value1_Ptr->Id < Value2_Ptr->Id)
+                    {
+                        return( NDS_LOWER);
+                    }
+                    else
+                    {
+                        if( Value1_Ptr->Id > Value2_Ptr->Id)
+                        {
+                            return( NDS_GREATER);
+                        }
+                        else
+                        {
+                            return( NDS_EQUAL);
+                        }
+                    }
+                }
+
+                case 1:
+                {
+                    int     rc;
+
+
+                    rc=strcmp( Value1_Ptr->Name, Value2_Ptr->Name);
+
+                    if( rc <0)
+                    {
+                        return( NDS_LOWER);
+                    }
+                    else
+                    {
+                        if( rc > 0)
+                        {
+                            return( NDS_GREATER);
+                        }
+                        else
+                        {
+                            return( NDS_EQUAL);
+                        }
+                    }
+                }
+
+                default:
+                {
+                     return( NDS_KO);
+                }
+            }
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_ADD:
+        {
+            /*
+	      void       *Value_Ptr = (void *)va_arg( Args, void  *);
+	      va_list     user_args = (va_list)va_arg( Args, va_list);
+	      user_type   user_data = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+            */
+
+            Command_Name = "NDD_CMD_VALUE_ADD";
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_REMOVE:
+        {
+            /*
+	      void       *Value_Ptr = (void *)va_arg( Args, void  *);
+	      va_list     user_args = (va_list)va_arg( Args, va_list);
+	      user_type   user_data = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+            */
+
+            Command_Name = "NDD_CMD_VALUE_REMOVE";
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_PRINT:
+        {
+            /*
+	      NDT_Node             *Next_Node_Ptr   = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+	      va_list               lib_args        = (va_list)va_arg( Args, va_list);
+	      FILE                 *Out             = (FILE  *)va_arg( lib_args, FILE  *);
+	      NDT_Recursive_Mode    Recursive_Mode  = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode);
+	      NDT_Recursive_Depth   Recursive_Depth = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth);
+	      va_list               user_args       = (va_list)va_arg( lib_args, va_list);
+	      user_type             user_data       = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+	      void                 *Value_Ptr       = Node_Ptr->Value;
+            */
+            NDT_Node             *Next_Node_Ptr   = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+            va_list               lib_args        = (va_list)va_arg( Args, va_list);
+            FILE                 *Out             = (FILE  *)va_arg( lib_args, FILE  *);
+            NDT_Recursive_Mode    Recursive_Mode  = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode);
+            NDT_Recursive_Depth   Recursive_Depth = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth);
+
+            IMRT_Appl           *Value_Ptr            = Node_Ptr->Value;
+
+
+            Command_Name = "NDD_CMD_VALUE_PRINT";
+
+            fprintf( Out, "Name: (%s) \n", Value_Ptr->Name);
+            return( NDS_OK);
+
+        }
+
+        case NDD_CMD_INFO_PRINT:
+        {
+            /*
+	      NDT_Node             *Next_Node_Ptr   = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+	      va_list               lib_args        = (va_list)va_arg( Args, va_list);
+	      FILE                 *Out             = (FILE  *)va_arg( lib_args, FILE  *);
+	      NDT_Recursive_Mode    Recursive_Mode  = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode);
+	      NDT_Recursive_Depth   Recursive_Depth = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth);
+	      va_list               user_args       = (va_list)va_arg( lib_args, va_list);
+	      user_type             user_data       = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+	      void                 *Value_Ptr       = Node_Ptr->Value;
+            */
+
+            Command_Name = "NDD_CMD_INFO_PRINT";
+
+            return( NDS_OK);
+        }
+
+		case IMRD_SDMD_CMD_API_SQL_DUMP:
+		{
+		/*
+			NDT_Node   *Next_Node_Ptr = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+			va_list     user_args     =     (va_list)va_arg( Args, va_list);
+			user_type   user_data     =   (user_type)va_arg( user_args, user_type);
+								  ... =         (...)va_arg( user_args, ...);
+
+  			void       *Value_Ptr     = Node_Ptr->Value;
+		*/
+			NDT_Node        *Next_Node_Ptr = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+			va_list          user_args     =     (va_list)va_arg( Args, va_list);
+			FILE            *Out           =     (FILE  *)va_arg( user_args, FILE  *);
+
+			IMRT_Appl        *Appl_Ptr  = Node_Ptr->Value;
+
+
+			Command_Name = "IMRD_SDMD_CMD_API_SQL_DUMP";
+
+			fprintf( Out, "INSERT INTO IMR_APPLI(APPLI_ID, APPLI_NAME) VALUES(%d, '%s');\n",
+					Appl_Ptr->Id, Appl_Ptr->Name);
+
+			return( NDS_OK);
+		}
+
+		case IMRD_SDMD_CMD_API_XML_DUMP:
+		{
+		/*
+			NDT_Node   *Next_Node_Ptr = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+			va_list     user_args     =     (va_list)va_arg( Args, va_list);
+			user_type   user_data     =   (user_type)va_arg( user_args, user_type);
+								  ... =         (...)va_arg( user_args, ...);
+
+  			void       *Value_Ptr     = Node_Ptr->Value;
+		*/
+			NDT_Node        *Next_Node_Ptr = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+			va_list          user_args     =     (va_list)va_arg( Args, va_list);
+			FILE            *Out           =     (FILE  *)va_arg( user_args, FILE  *);
+
+			IMRT_Appl        *Appl_Ptr  = Node_Ptr->Value;
+
+
+			Command_Name = "IMRD_SDMD_CMD_API_XML_DUMP";
+
+			fprintf( Out, "\t<%s>\n", IMRD_SDMD_TAG_APPLI);
+
+			fprintf( Out, "\t\t<%s>%s</%s>\n", 
+						IMRD_SDMD_TAG_NAME, Appl_Ptr->Name, IMRD_SDMD_TAG_NAME);
+
+			fprintf( Out, "\t</%s>\n", IMRD_SDMD_TAG_APPLI);
+
+			return( NDS_OK);
+		}
+
+        default:
+        {
+            IMRD_LM_LOG_ERROR_1( "SDM_Appl_Manager() called with an undefined command %d\n", Command);
+            return NDS_ERRAPI;
+        }
+    }
+
+    
+    return NDS_OK;
+}
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* FmtAttr Manager                                                            */
+/*----------------------------------------------------------------------------*/
+
+NDT_Status  SDM_FmtAttr_Manager( NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id, NDT_Node  *Node_Ptr, NDT_Command  Command, va_list  Args)
+{
+    NDT_Command_Name  Command_Name;
+    IMRT_Status       status;
+
+
+    switch( Command)
+    {
+	case NDD_CMD_MANAGER_VERSION:
+        {
+            NDT_Version_Name  *Version_Name_Ptr = (NDT_Version_Name  *)va_arg( Args, NDT_Version_Name  *);
+
+
+            Command_Name = "NDD_CMD_MANAGER_VERSION";
+            *Version_Name_Ptr = "Revision: 2.1    Name: libnode-2_0_4-1    Date: 2002/02/28 22:00:35    Author: agibert ";
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_INDEX_GET:
+        {
+            /*
+	      NDT_Index_Id  *Reply_Index_Id_Ptr = (NDT_Index_Id  *)va_arg( Args, NDT_Index_Id  *);
+	      NDT_Command   *Reply_Command_Ptr  = (NDT_Command  *)va_arg( Args, NDT_Command  *);
+	      NDT_Command    Cmd                = (NDT_Command)va_arg( Args, NDT_Command);
+	      void          *Value_ptr          = (void  *)va_arg( Args, void  *);
+            */
+            NDT_Index_Id  *Reply_Index_Id_Ptr = (NDT_Index_Id  *)va_arg( Args, NDT_Index_Id  *);
+            NDT_Command   *Reply_Command_Ptr  = (NDT_Command  *)va_arg( Args, NDT_Command  *);
+            NDT_Command    Cmd                = (NDT_Command)va_arg( Args, NDT_Command);
+            IMRT_FmtAttr  *Value_ptr          = (IMRT_FmtAttr  *)va_arg( Args, IMRT_FmtAttr  *);
+
+
+            Command_Name = "NDD_CMD_INDEX_GET";
+
+            switch(Cmd)
+            {
+                case IMRD_SDMD_CMD_INDEX0_PRINT:
+                {
+                    *Reply_Index_Id_Ptr = 0;
+                    *Reply_Command_Ptr = NDD_CMD_VALUE_PRINT;
+
+                    break;
+                }
+                default:
+                {
+                    *Reply_Index_Id_Ptr = Index_Id;
+                    *Reply_Command_Ptr = Cmd;
+
+                    break;
+                }
+            }
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_ALLOC:
+        {
+            /*
+	      void       **Value_Ptr_Ptr = (void **)va_arg( Args, void  **);
+	      va_list      user_args     = (va_list)va_arg( Args, va_list);
+	      user_type    user_data     = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+            */
+            IMRT_FmtAttr  **Value_Ptr_Ptr = va_arg( Args, IMRT_FmtAttr  **);
+
+
+            Command_Name = "NDD_CMD_VALUE_ALLOC";
+
+            if( ( *Value_Ptr_Ptr = (IMRT_FmtAttr  *)malloc( sizeof(IMRT_FmtAttr))) == NULL)
+            {
+                return( NDS_ERRMEM);
+            }
+            else
+            {
+                SDM_InitFmtAttr(*Value_Ptr_Ptr);
+                return( NDS_OK);
+            }
+        }
+
+        case NDD_CMD_VALUE_FREE:
+        {
+            /*
+	      void       *Value_Ptr = (void *)va_arg( Args, void  *);
+	      va_list     user_args = (va_list)va_arg( Args, va_list);
+	      user_type   user_data = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+            */
+            IMRT_FmtAttr  *Value_Ptr = (IMRT_FmtAttr  *)va_arg( Args, IMRT_FmtAttr  *);
+            Command_Name = "NDD_CMD_VALUE_FREE";
+
+            free( Value_Ptr);
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_COMP:
+        {
+            /*
+	      void       *Value1_Ptr = (void *)va_arg( Args, void  *);
+	      void       *Value2_Ptr = (void *)va_arg( Args, void  *);
+	      va_list     user_args  = (va_list)va_arg( Args, va_list);
+	      user_type   user_data  = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+            */
+            IMRT_FmtAttr    *Value1_Ptr = va_arg( Args, IMRT_FmtAttr  *);
+            IMRT_FmtAttr    *Value2_Ptr = va_arg( Args, IMRT_FmtAttr  *);
+
+
+            Command_Name = "NDD_CMD_VALUE_COMP";
+
+            switch( Index_Id)
+            {
+                case 0:
+                {
+                    if( Value1_Ptr->Id < Value2_Ptr->Id)
+                    {
+                        return( NDS_LOWER);
+                    }
+                    else
+                    {
+                        if( Value1_Ptr->Id > Value2_Ptr->Id)
+                        {
+                            return( NDS_GREATER);
+                        }
+                        else
+                        {
+                            return( NDS_EQUAL);
+                        }
+                    }
+                }
+
+                case 1:
+                {
+                    int     rc;
+
+
+                    rc=strcmp( Value1_Ptr->Name, Value2_Ptr->Name);
+
+                    if( rc <0)
+                    {
+                        return( NDS_LOWER);
+                    }
+                    else
+                    {
+                        if( rc > 0)
+                        {
+                            return( NDS_GREATER);
+                        }
+                        else
+                        {
+                            return( NDS_EQUAL);
+                        }
+                    }
+                }
+
+                default:
+                {
+                   IMRD_LM_LOG_ERROR_1( "SDM_FmtAttr_Manager Unknown COMP idx (%d) !\n", Index_Id);
+
+                    return( NDS_KO);
+                }
+            }
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_ADD:
+        {
+            /*
+	      void       *Value_Ptr = (void *)va_arg( Args, void  *);
+	      va_list     user_args = (va_list)va_arg( Args, va_list);
+	      user_type   user_data = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+            */
+
+            Command_Name = "NDD_CMD_VALUE_ADD";
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_REMOVE:
+        {
+            /*
+	      void       *Value_Ptr = (void *)va_arg( Args, void  *);
+	      va_list     user_args = (va_list)va_arg( Args, va_list);
+	      user_type   user_data = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+            */
+
+            Command_Name = "NDD_CMD_VALUE_REMOVE";
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_PRINT:
+        {
+            /*
+	      NDT_Node             *Next_Node_Ptr   = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+	      va_list               lib_args        = (va_list)va_arg( Args, va_list);
+	      FILE                 *Out             = (FILE  *)va_arg( lib_args, FILE  *);
+	      NDT_Recursive_Mode    Recursive_Mode  = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode);
+	      NDT_Recursive_Depth   Recursive_Depth = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth);
+	      va_list               user_args       = (va_list)va_arg( lib_args, va_list);
+	      user_type             user_data       = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+	      void                 *Value_Ptr       = Node_Ptr->Value;
+            */
+            NDT_Node             *Next_Node_Ptr   = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+            va_list               lib_args        = (va_list)va_arg( Args, va_list);
+            FILE                 *Out             = (FILE  *)va_arg( lib_args, FILE  *);
+            NDT_Recursive_Mode    Recursive_Mode  = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode);
+            NDT_Recursive_Depth   Recursive_Depth = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth);
+
+            IMRT_FmtAttr         *FmtAttr_Ptr     = Node_Ptr->Value;
+
+
+            Command_Name = "NDD_CMD_VALUE_PRINT";
+
+            fprintf( Out, "Id: (%d) Name: (%s) Value: (%s) \n", FmtAttr_Ptr->Id, FmtAttr_Ptr->Name, FmtAttr_Ptr->Value);
+            return( NDS_OK);
+
+        }
+
+        case NDD_CMD_INFO_PRINT:
+        {
+            /*
+	      NDT_Node             *Next_Node_Ptr   = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+	      va_list               lib_args        = (va_list)va_arg( Args, va_list);
+	      FILE                 *Out             = (FILE  *)va_arg( lib_args, FILE  *);
+	      NDT_Recursive_Mode    Recursive_Mode  = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode);
+	      NDT_Recursive_Depth   Recursive_Depth = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth);
+	      va_list               user_args       = (va_list)va_arg( lib_args, va_list);
+	      user_type             user_data       = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+	      void                 *Value_Ptr       = Node_Ptr->Value;
+            */
+
+            Command_Name = "NDD_CMD_INFO_PRINT";
+
+            return( NDS_OK);
+        }
+
+		case IMRD_SDMD_CMD_API_SQL_DUMP:
+		{
+		/*
+			NDT_Node   *Next_Node_Ptr = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+			va_list     user_args     =     (va_list)va_arg( Args, va_list);
+			user_type   user_data     =   (user_type)va_arg( user_args, user_type);
+								  ... =         (...)va_arg( user_args, ...);
+
+  			void       *Value_Ptr     = Node_Ptr->Value;
+		*/
+			NDT_Node        *Next_Node_Ptr = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+			va_list          user_args     =     (va_list)va_arg( Args, va_list);
+			FILE            *Out           =     (FILE  *)va_arg( user_args, FILE  *);
+			IMRT_FmtAttr    *FmtAttr_Ptr   = Node_Ptr->Value;
+
+			char   * FmtAttr_Value_convert_Ptr;
+
+			Command_Name = "IMRD_SDMD_CMD_API_SQL_DUMP";
+
+				FmtAttr_Value_convert_Ptr = (char *) malloc(IMRD_FMTATTR_VALUE_SIZE);
+				status = SDM_ConvertAttributeInv(FmtAttr_Ptr->Value, FmtAttr_Value_convert_Ptr);
+       			fprintf( Out, "INSERT INTO IMR_FMT_ATTR(FMTATTR_ID, FMTATTR_NAME, FMTATTR_VALUE) VALUES(%d, '%s', '%s');\n", 
+       						FmtAttr_Ptr->Id, FmtAttr_Ptr->Name, FmtAttr_Value_convert_Ptr);
+       			free(FmtAttr_Value_convert_Ptr);
+
+			return( NDS_OK);
+		}
+
+		case IMRD_SDMD_CMD_API_XML_DUMP:
+		{
+		/*
+			NDT_Node   *Next_Node_Ptr = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+			va_list     user_args     =     (va_list)va_arg( Args, va_list);
+			user_type   user_data     =   (user_type)va_arg( user_args, user_type);
+								  ... =         (...)va_arg( user_args, ...);
+
+  			void       *Value_Ptr     = Node_Ptr->Value;
+		*/
+			NDT_Node        *Next_Node_Ptr = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+			va_list          user_args     =     (va_list)va_arg( Args, va_list);
+			FILE            *Out           =     (FILE  *)va_arg( user_args, FILE  *);
+			IMRT_FmtAttr    *FmtAttr_Ptr   =      Node_Ptr->Value;
+
+			char   * FmtAttr_Value_convert_Ptr;
+
+			Command_Name = "IMRD_SDMD_CMD_API_XML_DUMP";
+
+			fprintf( Out, "\t<%s>\n", IMRD_SDMD_TAG_FMTATTR);
+
+			fprintf( Out, "\t\t<%s>%s</%s>\n", 
+						IMRD_SDMD_TAG_NAME, FmtAttr_Ptr->Name, IMRD_SDMD_TAG_NAME);
+
+			FmtAttr_Value_convert_Ptr = (char *) malloc(IMRD_FMTATTR_VALUE_SIZE);
+			status = SDM_ConvertAttributeInv(FmtAttr_Ptr->Value, FmtAttr_Value_convert_Ptr);
+			fprintf( Out, "\t\t<%s>%s</%s>\n", 
+						IMRD_SDMD_TAG_VALUE, FmtAttr_Value_convert_Ptr, IMRD_SDMD_TAG_VALUE);
+
+			fprintf( Out, "\t</%s>\n", IMRD_SDMD_TAG_FMTATTR);
+   			free(FmtAttr_Value_convert_Ptr);
+
+			return( NDS_OK);
+		}
+
+        default:
+        {
+            IMRD_LM_LOG_ERROR_1( "SDM_FmtAttr_Manager() called with an undefined command %d\n", Command);
+            return NDS_ERRAPI;
+        }
+    }
+
+    
+    return NDS_OK;
+}
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* FmtMsg Manager                                                             */
+/*----------------------------------------------------------------------------*/
+
+NDT_Status  SDM_FmtMsg_Manager( NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id, NDT_Node  *Node_Ptr, NDT_Command  Command, va_list  Args)
+{
+    NDT_Command_Name  Command_Name;
+    NDT_Status        status;
+    IMRT_Status statuscb;
+    /*static short  Num_Ordre=0;*/
+
+
+    switch( Command)
+    {
+        case NDD_CMD_MANAGER_VERSION:
+        {
+            NDT_Version_Name  *Version_Name_Ptr = (NDT_Version_Name  *)va_arg( Args, NDT_Version_Name  *);
+
+            Command_Name = "NDD_CMD_MANAGER_VERSION";
+            *Version_Name_Ptr = "Revision: 2.1    Name: libnode-2_0_4-1    Date: 2002/02/28 22:00:35    Author: agibert ";
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_INDEX_GET:
+        {
+            /*
+	      NDT_Index_Id  *Reply_Index_Id_Ptr = (NDT_Index_Id  *)va_arg( Args, NDT_Index_Id  *);
+	      NDT_Command   *Reply_Command_Ptr  = (NDT_Command  *)va_arg( Args, NDT_Command  *);
+	      NDT_Command    Cmd                = (NDT_Command)va_arg( Args, NDT_Command);
+	      void          *Value_ptr          = (void  *)va_arg( Args, void  *);
+            */
+            NDT_Index_Id  *Reply_Index_Id_Ptr = (NDT_Index_Id  *)va_arg( Args, NDT_Index_Id  *);
+            NDT_Command   *Reply_Command_Ptr  = (NDT_Command  *)va_arg( Args, NDT_Command  *);
+            NDT_Command    Cmd                = (NDT_Command)va_arg( Args, NDT_Command);
+            IMRT_FmtMsg    * Value_ptr       = (IMRT_FmtMsg  *)va_arg( Args, IMRT_FmtMsg  *);
+
+
+            Command_Name = "NDD_CMD_INDEX_GET";
+
+            switch(Cmd)
+            {
+                case IMRD_SDMD_CMD_INDEX0_PRINT:
+                {
+                    *Reply_Index_Id_Ptr = 0;
+                    *Reply_Command_Ptr = NDD_CMD_VALUE_PRINT;
+
+                    break;
+                }
+
+                case IMRD_SDMD_CMD_EXECUTE:
+                {
+                    *Reply_Index_Id_Ptr = 0;
+                    *Reply_Command_Ptr = NDD_CMD_EXECUTE;
+
+                    break;
+                }
+
+                default:
+                {
+                    *Reply_Index_Id_Ptr = Index_Id;
+                    *Reply_Command_Ptr = Cmd;
+
+                    break;
+                }
+            }
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_ALLOC:
+        {
+            /*
+	      void       **Value_Ptr_Ptr = (void **)va_arg( Args, void  **);
+	      va_list      user_args     = (va_list)va_arg( Args, va_list);
+	      user_type    user_data     = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+            */
+            IMRT_FmtMsg  **Value_Ptr_Ptr = va_arg( Args, IMRT_FmtMsg  **);
+
+
+            Command_Name = "NDD_CMD_VALUE_ALLOC";
+
+            if( ( *Value_Ptr_Ptr = (IMRT_FmtMsg  *)malloc( sizeof(IMRT_FmtMsg))) == NULL)
+            {
+                return( NDS_ERRMEM);
+            }
+            else
+            {
+                SDM_InitFmtMsg(*Value_Ptr_Ptr);
+
+                return( NDS_OK);
+            }
+
+        }
+
+        case NDD_CMD_VALUE_FREE:
+        {
+            /*
+	      void       *Value_Ptr = (void *)va_arg( Args, void  *);
+	      va_list     user_args = (va_list)va_arg( Args, va_list);
+	      user_type   user_data = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+            */
+           
+            /*IMRT_Fmt  *Value_Ptr = (IMRT_Fmt  *)va_arg( Args, IMRT_Fmt  *);
+
+
+            Command_Name = "NDD_CMD_VALUE_FREE";
+
+            free( Value_Ptr->FmtAttr_Ptr);
+            free( Value_Ptr);*/
+
+
+			IMRT_FmtMsg		*Value_Ptr = (IMRT_FmtMsg  *)va_arg( Args, IMRT_FmtMsg  *);
+
+            Command_Name = "NDD_CMD_VALUE_FREE";
+
+            free( Value_Ptr);
+
+            return( NDS_OK);
+
+        }
+
+        case NDD_CMD_VALUE_COMP:
+        {
+            /*
+	      void       *Value1_Ptr = (void *)va_arg( Args, void  *);
+	      void       *Value2_Ptr = (void *)va_arg( Args, void  *);
+	      va_list     user_args  = (va_list)va_arg( Args, va_list);
+	      user_type   user_data  = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+            */
+            IMRT_Msg    * Value1_Ptr = (IMRT_Msg *)va_arg( Args, NDT_Node *);
+            IMRT_Msg    * Value2_Ptr = (IMRT_Msg *)va_arg( Args, NDT_Node *);
+
+
+            Command_Name = "NDD_CMD_VALUE_COMP";
+
+            switch( Index_Id)
+            {
+                case 0:
+                {
+                    int     rc;
+
+
+                    rc = strcmp( Value1_Ptr->Name, Value1_Ptr->Name);
+
+                    if( rc < 0)
+                    {
+                        return( NDS_LOWER);
+                    }
+                    else
+                    {
+                        if( rc > 0)
+                        {
+                            return( NDS_GREATER);
+                        }
+                        else
+                        {
+                            return( NDS_EQUAL);
+                        }
+                    }
+                }
+
+                default:
+                {
+                    IMRD_LM_LOG_ERROR_1("SDM_FmtMsg_Manager Unknown COMP idx (%d) !\n", Index_Id);
+
+                    return( NDS_KO);
+                }
+            }
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_ADD:
+        {
+            /*
+	      void       *Value_Ptr = (void *)va_arg( Args, void  *);
+	      va_list     user_args = (va_list)va_arg( Args, va_list);
+	      user_type   user_data = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+            */
+
+            Command_Name = "NDD_CMD_VALUE_ADD";
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_REMOVE:
+        {
+            /*
+	      void       *Value_Ptr = (void *)va_arg( Args, void  *);
+	      va_list     user_args = (va_list)va_arg( Args, va_list);
+	      user_type   user_data = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+            */
+
+            Command_Name = "NDD_CMD_VALUE_REMOVE";
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_PRINT:
+        {
+            /*
+	      NDT_Node             *Next_Node_Ptr   = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+	      va_list               lib_args        = (va_list)va_arg( Args, va_list);
+	      FILE                 *Out             = (FILE  *)va_arg( lib_args, FILE  *);
+	      NDT_Recursive_Mode    Recursive_Mode  = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode);
+	      NDT_Recursive_Depth   Recursive_Depth = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth);
+	      va_list               user_args       = (va_list)va_arg( lib_args, va_list);
+	      user_type             user_data       = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+	      void                 *Value_Ptr       = Node_Ptr->Value;
+            */
+            NDT_Node             *Next_Node_Ptr   = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+            va_list               lib_args        = (va_list)va_arg( Args, va_list);
+            FILE                 *Out             = (FILE  *)va_arg( lib_args, FILE  *);
+            NDT_Recursive_Mode    Recursive_Mode  = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode);
+            NDT_Recursive_Depth   Recursive_Depth = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth);
+            IMRT_FmtMsg          *Value_Ptr = Node_Ptr->Value;
+
+
+            Command_Name = "NDD_CMD_VALUE_PRINT";
+
+            fprintf( Out, "\tFmtMsg - Msg Name: (%s) Branche Id: (%d)  Attribute:  (%s)\n", Value_Ptr->Msg_Ptr->Name, Value_Ptr->Branche_Id, Value_Ptr->FmtAttr_Ptr->Value);
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_INFO_PRINT:
+        {
+            /*
+	      NDT_Node             *Next_Node_Ptr   = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+	      va_list               lib_args        = (va_list)va_arg( Args, va_list);
+	      FILE                 *Out             = (FILE  *)va_arg( lib_args, FILE  *);
+	      NDT_Recursive_Mode    Recursive_Mode  = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode);
+	      NDT_Recursive_Depth   Recursive_Depth = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth);
+	      va_list               user_args       = (va_list)va_arg( lib_args, va_list);
+	      user_type             user_data       = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+	      void                 *Value_Ptr       = Node_Ptr->Value;
+            */
+            Command_Name = "NDD_CMD_INFO_PRINT";
+
+            return( NDS_OK);
+        }
+        case NDD_CMD_EXECUTE:
+        {
+            /*
+	      NDT_Node             *Next_Node_Ptr   = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+	      va_list               lib_args        = (va_list)va_arg( Args, va_list);
+	      FILE                 *Out             = (FILE  *)va_arg( lib_args, FILE  *);
+	      NDT_Recursive_Mode    Recursive_Mode  = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode);
+	      NDT_Recursive_Depth   Recursive_Depth = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth);
+	      va_list               user_args       = (va_list)va_arg( lib_args, va_list);
+	      user_type             user_data       = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+	      void                 *Value_Ptr       = Node_Ptr->Value;
+            */
+            NDT_Node *Next_Node_Ptr            = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+            va_list lib_args                   = (va_list)va_arg( Args, va_list);
+            FILE *Out                          = (FILE  *)va_arg( lib_args, FILE  *);
+            NDT_Recursive_Mode Recursive_Mode  = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode);
+            va_list user_args                  = (va_list)va_arg( Args, va_list);
+            IMRT_SDM_IdentMessage *  IdentStruct_Ptr   = (IMRT_SDM_IdentMessage *)va_arg(lib_args,IMRT_SDM_IdentMessage *);
+
+            IMRT_FmtMsg     *FmtMsg_Ptr        = (IMRT_FmtMsg *)Node_Ptr->Value;
+            IMRT_Msg        *Msg_Ptr           = (IMRT_Msg *)FmtMsg_Ptr->Msg_Ptr;
+
+            Command_Name = "NDD_CMD_EXECUTE";
+            status = NDS_OK;
+            statuscb = IMRS_OK;
+
+	 	    if (IdentStruct_Ptr->Mode == IMRD_SKIP_MODE)
+	    {
+		if (IdentStruct_Ptr->Id == Msg_Ptr->Id)
+		{
+		    IdentStruct_Ptr->Mode = IMRD_NORMALE_MODE;
+		    IdentStruct_Ptr->Branche_Id = FmtMsg_Ptr->Branche_Id;
+		}
+            }
+            else
+            {
+		if (FmtMsg_Ptr->Branche_Id == IdentStruct_Ptr->Branche_Id)
+		{
+		    if(Msg_Ptr->Size != 0 )
+		    {
+			statuscb = IdentStruct_Ptr->Ident_Msg_SizeFunc_Ptr(Msg_Ptr->Size);
+		    }
+
+		    if(statuscb == IMRS_OK)
+		    {
+			status = ND_DataStruct_Traverse( Msg_Ptr->Field_Struct_Ptr, IMRD_SDMD_CMD_EXECUTE, stdout, NDD_RECURSIVE_MODE_PARENT, IdentStruct_Ptr); 
+                            
+			if(status == NDS_OK)
+			{
+			    strcpy( IdentStruct_Ptr->Type, Msg_Ptr->Name);
+			    IdentStruct_Ptr->Id = Msg_Ptr->Id;  
+			    status = NDS_IDENT_OK;
+			}
+			else if(status == NDS_KO)
+			{
+			    status = NDS_KO;
+			}
+			else
+			{ 
+			    status = NDS_OK;
+			}
+		    }
+		    else if(statuscb == IMRS_NO_IDENT) 
+		    {
+			status = NDS_OK;
+		    }
+		    else
+		    {
+			status = NDS_KO;
+		    }
+		}
+		else
+		{
+		    status = NDS_NO_IDENT;
+		}
+	    }
+
+            return (status);
+        }
+
+	case IMRD_SDMD_CMD_CHECK_FMT_ATTR:
+		{
+		/*
+			NDT_Node   *Next_Node_Ptr = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+			va_list     user_args     =     (va_list)va_arg( Args, va_list);
+			user_type   user_data     =   (user_type)va_arg( user_args, user_type);
+								  ... =         (...)va_arg( user_args, ...);
+
+  			void       *Value_Ptr     = Node_Ptr->Value;
+		*/
+			NDT_Node        *Next_Node_Ptr = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+			va_list          user_args     =     (va_list)va_arg( Args, va_list);
+			/*FILE            *Out           =     (FILE  *)va_arg( user_args, FILE  *);*/
+			IMRT_Msg        *Msg_Ptr         =     (IMRT_Msg  *)va_arg( user_args, IMRT_Msg  *);
+			IMRT_FmtAttr    *FmtAttr_Ptr     =     (IMRT_FmtAttr *)va_arg( user_args, IMRT_FmtAttr  *);
+
+			IMRT_FmtMsg        *FmtMsg_Ptr  = Node_Ptr->Value;
+
+			Command_Name = "IMRD_SDMD_CMD_CHECK_FMT_ATTR";
+
+			if((FmtMsg_Ptr->Msg_Ptr == Msg_Ptr) &&
+			   (FmtMsg_Ptr->FmtAttr_Ptr == FmtAttr_Ptr))
+			{
+				return( NDS_NODE_FOUND);
+			}
+			return( NDS_OK);
+		}
+
+	case IMRD_SDMD_CMD_API_SQL_DUMP:
+		{
+		/*
+			NDT_Node   *Next_Node_Ptr = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+			va_list     user_args     =     (va_list)va_arg( Args, va_list);
+			user_type   user_data     =   (user_type)va_arg( user_args, user_type);
+								  ... =         (...)va_arg( user_args, ...);
+
+  			void       *Value_Ptr     = Node_Ptr->Value;
+		*/
+			NDT_Node        *Next_Node_Ptr = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+			va_list          user_args     =     (va_list)va_arg( Args, va_list);
+			FILE            *Out           =     (FILE  *)va_arg( user_args, FILE  *);
+			IMRT_Fmt_Id      Fmt_Id        =     (IMRT_Fmt_Id)va_arg( user_args, IMRT_Fmt_Id);
+			short           *Num_Ordre     =     (short *)va_arg( user_args, short *);
+
+			IMRT_FmtMsg         *FmtMsg_Ptr  = Node_Ptr->Value;
+			IMRT_FmtAttr_Id  FmtAttr_Id;
+
+
+			Command_Name = "IMRD_SDMD_CMD_API_SQL_DUMP";
+
+			*Num_Ordre += 1;
+			if (FmtMsg_Ptr->FmtAttr_Ptr == NULL)
+			{
+				FmtAttr_Id = IMRD_FMTATTR_ID_UNKNOWN;
+			}
+			else
+			{
+				FmtAttr_Id = FmtMsg_Ptr->FmtAttr_Ptr->Id;
+			}
+				
+			fprintf( Out, "INSERT INTO IMR_FMT_MSG(MSG_ID, FORMAT_ID, FMTATTR_Id, NUM_ORDRE_FMT_MSG, FMTMSG_BRANCHE_ID) VALUES(%d, %d, %d, %d, %d);\n",
+					FmtMsg_Ptr->Msg_Ptr->Id, Fmt_Id, FmtAttr_Id, *Num_Ordre, FmtMsg_Ptr->Branche_Id);
+
+			return( NDS_OK);
+		}
+
+		case IMRD_SDMD_CMD_API_XML_DUMP:
+		{
+		/*
+			NDT_Node   *Next_Node_Ptr = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+			va_list     user_args     =     (va_list)va_arg( Args, va_list);
+			user_type   user_data     =   (user_type)va_arg( user_args, user_type);
+								  ... =         (...)va_arg( user_args, ...);
+
+  			void       *Value_Ptr     = Node_Ptr->Value;
+		*/
+			NDT_Node        *Next_Node_Ptr = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+			va_list          user_args     =     (va_list)va_arg( Args, va_list);
+			FILE            *Out           =     (FILE  *)va_arg( user_args, FILE  *);
+
+			IMRT_FmtMsg        *FmtMsg_Ptr  = Node_Ptr->Value;
+
+			Command_Name = "IMRD_SDMD_CMD_API_XML_DUMP";
+
+			fprintf( Out, "\t\t<%s>\n", IMRD_SDMD_TAG_FMTMSG);
+
+			fprintf( Out, "\t\t\t<%s>%s</%s>\n", 
+					IMRD_SDMD_TAG_NAME, FmtMsg_Ptr->Msg_Ptr->Name, IMRD_SDMD_TAG_NAME);
+
+			fprintf( Out, "\t\t\t<%s>%d</%s>\n", 
+					IMRD_SDMD_TAG_BRANCHE_ID, FmtMsg_Ptr->Branche_Id, IMRD_SDMD_TAG_BRANCHE_ID);
+
+			if (FmtMsg_Ptr->FmtAttr_Ptr != NULL)
+			{
+				if (strcmp(FmtMsg_Ptr->FmtAttr_Ptr->Name, IMRD_FMTATTR_NAME_UNKNOWN) != 0)
+				{
+					fprintf( Out, "\t\t\t<%s>%s</%s>\n", 
+						IMRD_SDMD_TAG_FMTATTR_NAME, FmtMsg_Ptr->FmtAttr_Ptr->Name, IMRD_SDMD_TAG_FMTATTR_NAME);
+				}
+			}
+
+
+			fprintf( Out, "\t\t</%s>\n", IMRD_SDMD_TAG_FMTMSG);
+
+			return( NDS_OK);
+		}
+
+        default:
+        {
+           IMRD_LM_LOG_ERROR_1("SDM_FmtMsg_Manager() called with an undefined command %d\n", Command);
+
+            return( NDS_ERRAPI);
+        }
+    }
+    return( NDS_OK);
+}
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Fmt Manager                                                                */
+/*----------------------------------------------------------------------------*/
+
+NDT_Status  SDM_Fmt_Manager( NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id, NDT_Node  *Node_Ptr, NDT_Command  Command, va_list  Args)
+{
+    NDT_Command_Name  Command_Name;
+    NDT_Status        status;
+    IMRT_Status       imr_status;
+
+
+    switch( Command)
+    {
+        case NDD_CMD_MANAGER_VERSION:
+        {
+            NDT_Version_Name  *Version_Name_Ptr = (NDT_Version_Name  *)va_arg( Args, NDT_Version_Name  *);
+
+
+            Command_Name = "NDD_CMD_MANAGER_VERSION";
+
+            *Version_Name_Ptr = "Revision: 2.1    Name: libnode-2_0_4-1    Date: 2002/02/28 22:00:35    Author: agibert ";
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_INDEX_GET:
+        {
+            /*
+	      NDT_Index_Id  *Reply_Index_Id_Ptr = (NDT_Index_Id  *)va_arg( Args, NDT_Index_Id  *);
+	      NDT_Command   *Reply_Command_Ptr  = (NDT_Command  *)va_arg( Args, NDT_Command  *);
+	      NDT_Command    Cmd                = (NDT_Command)va_arg( Args, NDT_Command);
+	      void          *Value_ptr          = (void  *)va_arg( Args, void  *);
+            */
+            NDT_Index_Id  *Reply_Index_Id_Ptr = (NDT_Index_Id  *)va_arg( Args, NDT_Index_Id  *);
+            NDT_Command   *Reply_Command_Ptr  = (NDT_Command  *)va_arg( Args, NDT_Command  *);
+            NDT_Command    Cmd                = (NDT_Command)va_arg( Args, NDT_Command);
+            IMRT_Fmt    * Value_ptr           = (IMRT_Fmt  *)va_arg( Args, IMRT_Fmt  *);
+
+
+            Command_Name = "NDD_CMD_INDEX_GET";
+
+            switch(Cmd)
+            {
+                case IMRD_SDMD_CMD_INDEX0_PRINT:
+                {
+                    *Reply_Index_Id_Ptr = 0;
+                    *Reply_Command_Ptr = NDD_CMD_VALUE_PRINT;
+
+                    break;
+                }
+
+                default:
+                {
+                    *Reply_Index_Id_Ptr = Index_Id;
+                    *Reply_Command_Ptr = Cmd;
+
+                    break;
+                }
+            }
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_ALLOC:
+        {
+            /*
+	      void       **Value_Ptr_Ptr = (void **)va_arg( Args, void  **);
+	      va_list      user_args     = (va_list)va_arg( Args, va_list);
+	      user_type    user_data     = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+            */
+            IMRT_Fmt  **Value_Ptr_Ptr = va_arg( Args, IMRT_Fmt  **);
+
+
+            Command_Name = "NDD_CMD_VALUE_ALLOC";
+
+            if( ( *Value_Ptr_Ptr = (IMRT_Fmt  *)malloc( sizeof(IMRT_Fmt))) == NULL)
+            {
+                return( NDS_ERRMEM);
+            }
+            else
+            {
+                SDM_InitFormat(*Value_Ptr_Ptr);
+
+                if( ( status = ND_DataStruct_Open( &((*Value_Ptr_Ptr)->FmtMsg_Struct_Ptr), IMRD_SDMD_INDEX_NB, index_type_initial_tab, "SDM_FmtMsg_Manager", SDM_FmtMsg_Manager, NULL, NULL, NULL, NULL,0,  NULL)) != NDS_OK)
+				{
+                  IMRD_LM_LOG_ERROR_1( "ND_DataStruct_Open() Format failed (%d) !\n", status);
+				}
+                return( NDS_OK);
+            }
+        }
+
+        case NDD_CMD_VALUE_FREE:
+        {
+            /*
+	      void       *Value_Ptr = (void *)va_arg( Args, void  *);
+	      va_list     user_args = (va_list)va_arg( Args, va_list);
+	      user_type   user_data = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+            */
+            IMRT_Fmt  *Value_Ptr = (IMRT_Fmt  *)va_arg( Args, IMRT_Fmt  *);
+
+
+            Command_Name = "NDD_CMD_VALUE_FREE";
+
+            if( ( status = ND_DataStruct_Close( Value_Ptr->FmtMsg_Struct_Ptr)) != NDS_OK)
+	    {
+		IMRD_LM_LOG_ERROR_1( "ND_DataStruct_Close() Format failed (%d) !\n", status);
+		return( status);
+	    }
+            free( Value_Ptr);
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_COMP:
+        {
+            /*
+	      void       *Value1_Ptr = (void *)va_arg( Args, void  *);
+	      void       *Value2_Ptr = (void *)va_arg( Args, void  *);
+	      va_list     user_args  = (va_list)va_arg( Args, va_list);
+	      user_type   user_data  = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+            */
+            IMRT_Fmt    *Value1_Ptr = va_arg( Args, IMRT_Fmt  *);
+            IMRT_Fmt    *Value2_Ptr = va_arg( Args, IMRT_Fmt  *);
+
+
+            Command_Name = "NDD_CMD_VALUE_COMP";
+
+            switch( Index_Id)
+            {
+                
+                case 0:
+                {
+                    if( Value1_Ptr->Id < Value2_Ptr->Id)
+                    {
+                        return( NDS_LOWER);
+                  }
+                    else
+                    {
+                        if( Value1_Ptr->Id > Value2_Ptr->Id)
+                        {
+                            return( NDS_GREATER);
+                        }
+                        else
+                        {
+                            return( NDS_EQUAL);
+                        }
+                    }
+                }
+
+                case 1:
+                {
+                    int     rc;
+
+
+                    rc=strcmp( Value1_Ptr->Name, Value2_Ptr->Name);
+
+                    if( rc <0)
+                    {
+                        return( NDS_LOWER);
+                    }
+                    else
+                    {
+                        if( rc > 0)
+                        {
+                            return( NDS_GREATER);
+                        }
+                        else
+                        {
+                            return( NDS_EQUAL);
+                        }
+                    }
+                }
+
+                default:
+                {
+                    IMRD_LM_LOG_ERROR_1( "Unknown COMP idx (%d) !\n", Index_Id);
+
+                    return( NDS_KO);
+                }
+            }
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_ADD:
+        {
+            /*
+	      void       *Value_Ptr = (void *)va_arg( Args, void  *);
+	      va_list     user_args = (va_list)va_arg( Args, va_list);
+	      user_type   user_data = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+            */
+            Command_Name = "NDD_CMD_VALUE_ADD";
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_REMOVE:
+        {
+            /*
+	      void       *Value_Ptr = (void *)va_arg( Args, void  *);
+	      va_list     user_args = (va_list)va_arg( Args, va_list);
+	      user_type   user_data = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+            */
+            Command_Name = "NDD_CMD_VALUE_REMOVE";
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_PRINT:
+        {
+            /*
+	      NDT_Node             *Next_Node_Ptr    = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+	      va_list               lib_args         = (va_list)va_arg( Args, va_list);
+	      FILE                 *Out              = (FILE  *)va_arg( lib_args, FILE  *);
+	      NDT_Recursive_Mode    Recursive_Mode   = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode);
+	      NDT_Recursive_Depth   Recursive_Depth  = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth);
+	      NDT_Recursive_Offset  Recursive_Offset = (NDT_Recursive_Offset)va_arg( lib_args, NDT_Recursive_Offset);
+	      va_list               user_args        = (va_list)va_arg( lib_args, va_list);
+	      user_type             user_data        = (user_type)va_arg( user_args, user_type);
+	      ...  = (...)va_arg( user_args, ...);
+	      void                 *Value_Ptr        = Node_Ptr->Value;
+            */
+            NDT_Node             *Next_Node_Ptr    = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+            va_list               lib_args         = (va_list)va_arg( Args, va_list);
+            FILE                 *Out              = (FILE  *)va_arg( lib_args, FILE  *);
+            NDT_Recursive_Mode    Recursive_Mode   = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode);
+            NDT_Recursive_Depth   Recursive_Depth  = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth);
+            NDT_Recursive_Offset  Recursive_Offset = (NDT_Recursive_Offset)va_arg( lib_args, NDT_Recursive_Offset);
+
+            IMRT_Fmt           *Value_Ptr       = Node_Ptr->Value;
+
+
+            Command_Name = "NDD_CMD_VALUE_PRINT";
+
+            fprintf( Out, "Format - Name: (%s) \n",Value_Ptr->Name);
+
+            return( ND_DataStruct_Value_Print( Out, Value_Ptr->FmtMsg_Struct_Ptr, NDD_RECURSIVE_MODE_PARENT_CHILD, --Recursive_Depth, ++Recursive_Offset));
+        }
+
+        case NDD_CMD_INFO_PRINT:
+        {
+            /*
+	      NDT_Node             *Next_Node_Ptr   = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+	      va_list               lib_args        = (va_list)va_arg( Args, va_list);
+	      FILE                 *Out             = (FILE  *)va_arg( lib_args, FILE  *);
+	      NDT_Recursive_Mode    Recursive_Mode  = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode);
+	      NDT_Recursive_Depth   Recursive_Depth = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth);
+	      va_list               user_args       = (va_list)va_arg( lib_args, va_list);
+	      user_type             user_data       = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+	      void                 *Value_Ptr       = Node_Ptr->Value;
+            */
+
+            Command_Name = "NDD_CMD_INFO_PRINT";
+
+            return( NDS_OK);
+        }
+
+        case IMRD_SDMD_CMD_EXECUTE:
+        { /*
+            NDT_Node             *Next_Node_Ptr    = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+            va_list               lib_args         = (va_list)va_arg( Args, va_list);
+            FILE                 *Out              = (FILE  *)va_arg( lib_args, FILE  *);
+            NDT_Recursive_Mode    Recursive_Mode   = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode);
+            NDT_Recursive_Depth   Recursive_Depth  = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth);
+            NDT_Recursive_Offset  Recursive_Offset = (NDT_Recursive_Offset)va_arg( lib_args, NDT_Recursive_Offset);
+            va_list               user_args        = (va_list)va_arg( lib_args, va_list);
+            user_type             user_data        = (user_type)va_arg( user_args, user_type);
+	    ...  = (...)va_arg( user_args, ...);
+            void                 *Value_Ptr        = Node_Ptr->Value;
+	  */
+            IMRT_Fmt *  Value_Ptr             = (IMRT_Fmt*)Node_Ptr->Value;
+            NDT_Node *Next_Node_Ptr                = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+            va_list lib_args                       = (va_list)va_arg( Args, va_list);
+            FILE *Out                              = (FILE  *)va_arg( lib_args, FILE  *);
+            NDT_Recursive_Mode    Recursive_Mode   = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode);
+            IMRT_SDMCB_Fmt_Add   * FmtProceedFunc      = ( IMRT_SDMCB_Fmt_Add *)va_arg(lib_args, IMRT_SDMCB_Fmt_Add *);
+            
+            imr_status = FmtProceedFunc(Value_Ptr->Id, Value_Ptr->Name, IMRG_SDM_Base.RootFmt->Index_Tab[NDD_INDEX_PRIMARY].Node_Number);
+            if(imr_status == IMRS_OK)
+            {
+	            status = NDS_OK;
+            }
+            else
+            {
+	            status = NDS_KO;
+            }
+
+			return(status);
+        }
+
+		case IMRD_SDMD_CMD_API_SQL_DUMP:
+		{
+		/*
+			NDT_Node   *Next_Node_Ptr = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+			va_list     user_args     =     (va_list)va_arg( Args, va_list);
+			user_type   user_data     =   (user_type)va_arg( user_args, user_type);
+								  ... =         (...)va_arg( user_args, ...);
+
+  			void       *Value_Ptr     = Node_Ptr->Value;
+		*/
+			NDT_Node        *Next_Node_Ptr = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+			va_list          user_args     =     (va_list)va_arg( Args, va_list);
+			FILE            *Out           =     (FILE  *)va_arg( user_args, FILE  *);
+
+			IMRT_Fmt        *Fmt_Ptr  = Node_Ptr->Value;
+			short  Num_Ordre=0;
+
+			Command_Name = "IMRD_SDMD_CMD_API_SQL_DUMP";
+
+			fprintf( Out, "INSERT INTO IMR_FORMAT(FORMAT_ID, FORMAT_NAME) VALUES(%d, '%s');\n",
+					Fmt_Ptr->Id, Fmt_Ptr->Name);
+
+		    if( ( status = ND_DataStruct_Traverse( Fmt_Ptr->FmtMsg_Struct_Ptr, IMRD_SDMD_CMD_API_SQL_DUMP, Out, Fmt_Ptr->Id, &Num_Ordre)) != NDS_OK)
+			{
+			    IMRD_LM_LOG_ERROR_1( "ND_DataStruct_Traverse failed (%d)...\n",status);
+				return(NDS_KO);
+			}
+
+			return( NDS_OK);
+		}
+
+		case IMRD_SDMD_CMD_API_XML_DUMP:
+		{
+		/*
+			NDT_Node   *Next_Node_Ptr = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+			va_list     user_args     =     (va_list)va_arg( Args, va_list);
+			user_type   user_data     =   (user_type)va_arg( user_args, user_type);
+								  ... =         (...)va_arg( user_args, ...);
+
+  			void       *Value_Ptr     = Node_Ptr->Value;
+		*/
+			NDT_Node        *Next_Node_Ptr = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+			va_list          user_args     =     (va_list)va_arg( Args, va_list);
+			FILE            *Out           =     (FILE  *)va_arg( user_args, FILE  *);
+
+			IMRT_Fmt        *Fmt_Ptr  = Node_Ptr->Value;
+
+
+			Command_Name = "IMRD_SDMD_CMD_API_XML_DUMP";
+
+			fprintf( Out, "\t<%s>\n", IMRD_SDMD_TAG_FORMAT);
+
+			fprintf( Out, "\t\t<%s>%s</%s>\n", 
+						IMRD_SDMD_TAG_NAME, Fmt_Ptr->Name, IMRD_SDMD_TAG_NAME);
+
+		    if( ( status = ND_DataStruct_Traverse( Fmt_Ptr->FmtMsg_Struct_Ptr, IMRD_SDMD_CMD_API_XML_DUMP, Out)) != NDS_OK)
+			{
+			    IMRD_LM_LOG_ERROR_1( "ND_DataStruct_Traverse failed (%d)...\n",status);
+				return(NDS_KO);
+			}
+
+			fprintf( Out, "\t</%s>\n", IMRD_SDMD_TAG_FORMAT);
+
+			return( NDS_OK);
+		}
+
+        default:
+        {
+            IMRD_LM_LOG_ERROR_1( "SDM_Fmt_Manager() called with an undefined command %d\n", Command);
+
+            return( NDS_ERRAPI);
+        }
+    }
+
+   
+
+    return( NDS_OK);
+}
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* MapCmd Manager                                                             */
+/*----------------------------------------------------------------------------*/
+
+NDT_Status  SDM_MapCmd_Manager( NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id, NDT_Node  *Node_Ptr, NDT_Command  Command, va_list Args)
+{
+    NDT_Command_Name        Command_Name;
+    SDMT_CritereRecChemin * Recherche = NULL;
+    IMRT_Status     statusTmp;
+    char functioname[] = "SDM_MapCmd_Manager";
+	int                i;
+  
+   
+    
+
+    switch( Command)
+    {
+        case NDD_CMD_MANAGER_VERSION:
+        {
+            NDT_Version_Name  *Version_Name_Ptr = (NDT_Version_Name  *)va_arg( Args, NDT_Version_Name  *);
+
+
+            Command_Name = "NDD_CMD_MANAGER_VERSION";
+
+            *Version_Name_Ptr = "Revision: 2.1    Name: libnode-2_0_4-1    Date: 2002/02/28 22:00:35    Author: agibert ";
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_INDEX_GET:
+        {
+            /*
+	      NDT_Index_Id  *Reply_Index_Id_Ptr = (NDT_Index_Id  *)va_arg( Args, NDT_Index_Id  *);
+	      NDT_Command   *Reply_Command_Ptr  = (NDT_Command  *)va_arg( Args, NDT_Command  *);
+	      NDT_Command    Cmd                = (NDT_Command)va_arg( Args, NDT_Command);
+	      void          *Value_ptr          = (void  *)va_arg( Args, void  *);
+            */
+            NDT_Index_Id  *Reply_Index_Id_Ptr = (NDT_Index_Id  *)va_arg( Args, NDT_Index_Id  *);
+            NDT_Command   *Reply_Command_Ptr  = (NDT_Command  *)va_arg( Args, NDT_Command  *);
+            NDT_Command    Cmd                = (NDT_Command)va_arg( Args, NDT_Command);
+            IMRT_MapCmd    * Value_ptr        = (IMRT_MapCmd  *)va_arg( Args, IMRT_MapCmd  *);
+
+            Command_Name = "NDD_CMD_INDEX_GET";
+
+            switch(Cmd)
+            {
+                case IMRD_SDMD_CMD_INDEX0_PRINT:
+                {
+                    *Reply_Index_Id_Ptr = 0;
+                    *Reply_Command_Ptr = NDD_CMD_VALUE_PRINT;
+                    break;
+                }
+
+                case IMRD_SDMD_CMD_EXECUTE:
+                {
+		    *Reply_Index_Id_Ptr = 0;
+		    *Reply_Command_Ptr = NDD_CMD_EXECUTE;
+		    break;
+                }
+
+                default:
+                {
+                    *Reply_Index_Id_Ptr = Index_Id;
+                    *Reply_Command_Ptr = Cmd;
+                    break;
+                }
+            }
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_ALLOC:
+        {
+            /*
+	      void       **Value_Ptr_Ptr = (void **)va_arg( Args, void  **);
+	      va_list      user_args     = (va_list)va_arg( Args, va_list);
+	      user_type    user_data     = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+            */
+            IMRT_MapCmd  **Value_Ptr_Ptr = va_arg( Args, IMRT_MapCmd  **);
+
+            Command_Name = "NDD_CMD_VALUE_ALLOC";
+
+            if( ( *Value_Ptr_Ptr = (IMRT_MapCmd  *)malloc( sizeof(IMRT_MapCmd))) == NULL)
+            {
+                return( NDS_ERRMEM);
+            }
+            else
+            {
+                SDM_InitMapCmd( *Value_Ptr_Ptr);
+                return( NDS_OK);
+            }
+        }
+
+        case NDD_CMD_VALUE_FREE:
+        {
+            /*
+	      void       *Value_Ptr = (void *)va_arg( Args, void  *);
+	      va_list     user_args = (va_list)va_arg( Args, va_list);
+	      user_type   user_data = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+            */
+            IMRT_MapCmd  *Value_Ptr = (IMRT_MapCmd  *)va_arg( Args, IMRT_MapCmd  *);
+
+            Command_Name = "NDD_CMD_VALUE_FREE";
+			
+			free(Value_Ptr->Jump_Tab);
+            free( Value_Ptr);
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_COMP:
+        {
+            /*
+	      void       *Value1_Ptr = (void *)va_arg( Args, void  *);
+	      void       *Value2_Ptr = (void *)va_arg( Args, void  *);
+	      va_list     user_args  = (va_list)va_arg( Args, va_list);
+	      user_type   user_data  = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+            */
+            IMRT_MapCmd    *Value1_Ptr = va_arg( Args, IMRT_MapCmd  *);
+            IMRT_MapCmd    *Value2_Ptr = va_arg( Args, IMRT_MapCmd  *);
+
+
+            Command_Name = "NDD_CMD_VALUE_COMP";
+
+            switch( Index_Id)
+            {
+                case 0:
+                {
+		    if( Value1_Ptr->MapCmd_Id<Value2_Ptr->MapCmd_Id)
+                    {
+                        return( NDS_LOWER);
+                    }
+                    else
+                    {
+                        if( Value1_Ptr->MapCmd_Id > Value2_Ptr->MapCmd_Id)
+                        {
+                            return( NDS_GREATER);
+                        }
+                        else
+                        {
+                            return( NDS_EQUAL);
+                        }
+                    }
+                }
+
+                default:
+                {
+                    IMRD_LM_LOG_ERROR_1( "Unknown COMP idx (%d) !\n", Index_Id);
+                    return( NDS_KO);
+                }
+            }
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_ADD:
+        {
+            /*
+	      void       *Value_Ptr = (void *)va_arg( Args, void  *);
+	      va_list     user_args = (va_list)va_arg( Args, va_list);
+	      user_type   user_data = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+            */
+
+            Command_Name = "NDD_CMD_VALUE_ADD";
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_REMOVE:
+        {
+            /*
+	      void       *Value_Ptr = (void *)va_arg( Args, void  *);
+	      va_list     user_args = (va_list)va_arg( Args, va_list);
+	      user_type   user_data = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+            */
+            Command_Name = "NDD_CMD_VALUE_REMOVE";
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_PRINT:
+        {
+            /*
+	      NDT_Node             *Next_Node_Ptr   = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+	      va_list               lib_args        = (va_list)va_arg( Args, va_list);
+	      FILE                 *Out             = (FILE  *)va_arg( lib_args, FILE  *);
+	      NDT_Recursive_Mode    Recursive_Mode  = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode);
+	      NDT_Recursive_Depth   Recursive_Depth = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth);
+	      va_list               user_args       = (va_list)va_arg( lib_args, va_list);
+	      user_type             user_data       = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+	      void                 *Value_Ptr       = Node_Ptr->Value;
+            */
+            NDT_Node             *Next_Node_Ptr   = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+            va_list               lib_args        = (va_list)va_arg( Args, va_list);
+            FILE                 *Out             = (FILE  *)va_arg( lib_args, FILE  *);
+            NDT_Recursive_Mode    Recursive_Mode  = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode);
+            NDT_Recursive_Depth   Recursive_Depth = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth);
+
+            IMRT_MapCmd           *Value_Ptr       = Node_Ptr->Value;
+			char                   Local_Ident_Total;
+
+	    Command_Name = "NDD_CMD_VALUE_PRINT";
+
+	    if( Value_Ptr->TypeCmd == IMRD_MAPCMD_TYPE_MAP)
+	    {
+		fprintf( Out,"type_commande (mapper)\n");
+	    }
+	    else if( Value_Ptr->TypeCmd == IMRD_MAPCMD_TYPE_COPY)
+	    {
+		fprintf( Out,"type_commande (copier)\n");
+	    }
+	    else if( Value_Ptr->TypeCmd == IMRD_MAPCMD_TYPE_IDENT)
+	    {
+		fprintf( Out,"type_commande (identifier)\n");
+	    }
+	    else if( Value_Ptr->TypeCmd == IMRD_MAPCMD_TYPE_GOTO)
+	    {
+		fprintf( Out,"type_commande (go_to)\n");
+	    }
+
+		if (Value_Ptr->Ident_Total == IMRD_TRUE)
+		{
+			Local_Ident_Total = IMRD_YES;
+		}
+		else
+		{
+			Local_Ident_Total = IMRD_NO;
+		}
+
+	    fprintf( Out, "IdMapCmd: (%d) Ident_Total: (%c) InputFormat: (%s)  InputFormat_Attr: (%s)  OutputFormat: (%s) OutputFormat_Attr: (%s) \n Branche_id (%d) OutputBuffer: (%d) InputBuffer : (%d) MappingRule: (%s) NumBufferToIdent (%d)  \n",
+		     Value_Ptr->MapCmd_Id, Local_Ident_Total, Value_Ptr->Fmt_Input_Ptr->Name, Value_Ptr->FmtAttr_Input_Ptr->Value,
+		     Value_Ptr->Fmt_Output_Ptr->Name,Value_Ptr->FmtAttr_Output_Ptr->Value, Value_Ptr->Branche_Id,
+		     Value_Ptr->Buffer_Id_Input,Value_Ptr->Buffer_Id_Output, 
+		     Value_Ptr->MsgMap_Ptr->Name , Value_Ptr->Buffer_Id_Ident);
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_INFO_PRINT:
+        {
+            /*
+	      NDT_Node             *Next_Node_Ptr   = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+	      va_list               lib_args        = (va_list)va_arg( Args, va_list);
+	      FILE                 *Out             = (FILE  *)va_arg( lib_args, FILE  *);
+	      NDT_Recursive_Mode    Recursive_Mode  = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode);
+	      NDT_Recursive_Depth   Recursive_Depth = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth);
+	      va_list               user_args       = (va_list)va_arg( lib_args, va_list);
+	      user_type             user_data       = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+	      void                 *Value_Ptr       = Node_Ptr->Value;
+            */
+            
+            Command_Name = "NDD_CMD_INFO_PRINT";
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_EXECUTE:
+        {
+            /*
+	      NDT_Node             *Next_Node_Ptr   = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+	      va_list               lib_args        = (va_list)va_arg( Args, va_list);
+	      FILE                 *Out             = (FILE  *)va_arg( lib_args, FILE  *);
+	      NDT_Recursive_Mode    Recursive_Mode  = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode);
+	      NDT_Recursive_Depth   Recursive_Depth = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth);
+	      va_list               user_args       = (va_list)va_arg( lib_args, va_list);
+	      user_type             user_data       = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+	      void                 *Value_Ptr       = Node_Ptr->Value;
+            */
+	        IMRT_MapCmd *  Value_Ptr = (IMRT_MapCmd*)Node_Ptr->Value;
+	    	IMRT_Status statuscb;
+	        int branche =-1;
+	        IMRT_Fmt_Id  Format;
+	        NDT_Status status;
+	        NDT_Node     *node_ptr_input;
+	        NDT_Node     *node_ptr_output;
+	        IMRT_Msg_Id  BufferType;
+	        NDT_Node *Next_Node_Ptr   = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+	        va_list lib_args          = (va_list)va_arg( Args, va_list);
+	        FILE *Out                 = (FILE  *)va_arg( lib_args, FILE  *);
+	        NDT_Recursive_Mode    Recursive_Mode  = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode);
+	        va_list user_args         = (va_list)va_arg( Args, va_list);
+	        SDMT_CritereRecChemin *Recherche        = (SDMT_CritereRecChemin *)va_arg(lib_args,SDMT_CritereRecChemin *);
+	        IMRT_Mode_Traverse * Mode_Normal_Erreur_Ptr = (IMRT_Mode_Traverse *)va_arg(lib_args, IMRT_Mode_Traverse *);
+
+    
+            Command_Name = "NDD_CMD_EXECUTE";
+		    statuscb = IMRS_OK;
+
+            if(Value_Ptr->Branche_Id == Recherche->Branche_id)
+            {
+				switch(Value_Ptr->TypeCmd)
+				{
+					case IMRD_MAPCMD_TYPE_MAP:
+					{
+						statuscb = Recherche->CallBackBCommandeMap(Value_Ptr->Buffer_Id_Output ,
+											 Value_Ptr->Fmt_Output_Ptr->Id,
+											 ( (Value_Ptr->FmtAttr_Output_Ptr == NULL) ? NULL : Value_Ptr->FmtAttr_Output_Ptr->Value),
+											 Value_Ptr->Buffer_Id_Input,
+											 Value_Ptr->Fmt_Input_Ptr->Id ,
+											 ( (Value_Ptr->FmtAttr_Input_Ptr == NULL) ? NULL : Value_Ptr->FmtAttr_Input_Ptr->Value), 
+											 Value_Ptr->MsgMap_Ptr ,
+											 Value_Ptr->Clear_Flag);
+						break;
+					}
+
+					case IMRD_MAPCMD_TYPE_COPY:
+					{
+						statuscb = Recherche->CallBackCommandeCopy(Value_Ptr->Buffer_Id_Output, Value_Ptr->Buffer_Id_Input);
+						break;
+					}
+
+					case IMRD_MAPCMD_TYPE_IDENT:
+					{
+						IMRT_Status found = IMRS_KO;
+						Format = IMRD_FMT_ID_UNKNOWN;
+						BufferType = Value_Ptr->Ident_First_Msg_Ptr->Id;
+						statuscb = Recherche->CallBackCommandeIdent(&Format,
+											&BufferType,
+											Value_Ptr->Buffer_Id_Ident,
+											Value_Ptr->Ident_Total);
+						if(statuscb == IMRS_OK)
+						{
+							for(i=0; i<Value_Ptr->JmpTbleNbElts; i++)
+							{
+								if ((Format == Value_Ptr->Jump_Tab[i].Fmt_Ptr->Id) && 
+								    (BufferType == Value_Ptr->Jump_Tab[i].Msg_Ptr->Id))
+								{
+									Recherche->Branche_id = Value_Ptr->Jump_Tab[i].Branche_Id;
+									found = IMRS_OK;
+								}
+							}
+
+							if(found == IMRS_KO)
+							{
+								statuscb = IMRS_KO;
+							}
+						}
+
+						break;
+					}
+
+					case IMRD_MAPCMD_TYPE_GOTO:
+					{
+					    Recherche->Branche_id = Value_Ptr->Goto_Branche_Id;
+
+					    break;
+					}
+
+					default:
+					{
+					    strcpy(Recherche->FataError.function,functioname);
+					    Recherche->FataError.errorCode = SDMD_CODE_ERROR_7;
+					    strcpy(Recherche->FataError.libError,SDMD_LIB_ERROR_7);
+	
+					    return( NDS_KO);
+					}
+				}
+
+				if (*Mode_Normal_Erreur_Ptr == IMRD_NORMALE_MODE)
+				{
+					if (statuscb != IMRS_OK)
+					{
+						*Mode_Normal_Erreur_Ptr = IMRD_ERREUR_MODE;
+						Recherche->Branche_id = IMRD_LATEST_BRANCHE;
+					}
+				}
+		    }
+	
+            return( NDS_OK);
+        }
+	case IMRD_SDMD_CMD_API_SQL_DUMP:
+		{
+		/*
+			NDT_Node   *Next_Node_Ptr = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+			va_list     user_args     =     (va_list)va_arg( Args, va_list);
+			user_type   user_data     =   (user_type)va_arg( user_args, user_type);
+								  ... =         (...)va_arg( user_args, ...);
+
+  			void       *Value_Ptr     = Node_Ptr->Value;
+		*/
+			NDT_Node        *Next_Node_Ptr = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+			va_list          user_args     =     (va_list)va_arg( Args, va_list);
+			FILE            *Out           =     (FILE  *)va_arg( user_args, FILE  *);
+			int              MapPath_Id    =     (int)va_arg( user_args, int);
+			IMRT_MapCmd        *MapCmd_Ptr  = Node_Ptr->Value;
+
+
+			Command_Name = "IMRD_SDMD_CMD_API_SQL_DUMP";
+
+			fprintf( Out, "INSERT INTO IMR_MAPCMD(MAPCMD_ID, MAPCMD_TYPE, CURRENT_BRANCHE_ID) VALUES(%d, %d, %d);\n",
+						MapCmd_Ptr->MapCmd_Id, MapCmd_Ptr->TypeCmd, MapCmd_Ptr->Branche_Id);
+
+			fprintf( Out, "INSERT INTO IMR_CMD_MAP_PATH(MAP_PATH_ID, MAPCMD_ID) VALUES(%d, %d);\n",
+						MapPath_Id, MapCmd_Ptr->MapCmd_Id);
+
+			if(MapCmd_Ptr->TypeCmd == IMRD_MAPCMD_TYPE_IDENT)
+			{
+				if(MapCmd_Ptr->Ident_Total == IMRD_FALSE)
+				{
+					fprintf( Out, "INSERT INTO IMR_CMD_IDENT(MAPCMD_ID, IDENT_BUFFER_ID, IDENT_TOTAL, IDENT_FIRST_MSG_ID) VALUES(%d, %d, '%c', %d);\n",
+						MapCmd_Ptr->MapCmd_Id, MapCmd_Ptr->Buffer_Id_Ident, IMRD_NO, MapCmd_Ptr->Ident_First_Msg_Ptr->Id);
+				}
+				else
+				{
+					fprintf( Out, "INSERT INTO IMR_CMD_IDENT(MAPCMD_ID, IDENT_BUFFER_ID, IDENT_TOTAL, IDENT_FIRST_MSG_ID) VALUES(%d, %d, '%c', %d);\n",
+						MapCmd_Ptr->MapCmd_Id, MapCmd_Ptr->Buffer_Id_Ident, IMRD_YES, MapCmd_Ptr->Ident_First_Msg_Ptr->Id);
+				}
+
+				for(i=0; i<MapCmd_Ptr->JmpTbleNbElts; i++)
+				{
+					fprintf( Out, "INSERT INTO IMR_JUMP_TABLE(MAPCMD_ID, MSG_ID, FORMAT_ID, NUM_ORDRE_JUMP, IDENT_BRANCHE_ID) VALUES(%d, %d, %d, %d, %d);\n",
+						MapCmd_Ptr->MapCmd_Id, MapCmd_Ptr->Jump_Tab[i].Msg_Ptr->Id, MapCmd_Ptr->Jump_Tab[i].Fmt_Ptr->Id, i, MapCmd_Ptr->Jump_Tab[i].Branche_Id);
+				}
+
+			}
+			else if(MapCmd_Ptr->TypeCmd == IMRD_MAPCMD_TYPE_MAP)
+			{
+				fprintf( Out, "INSERT INTO IMR_CMD_MAP(MAPCMD_ID, FORMAT_IN_ID, FMTATTR_IN_ID, FORMAT_OUT_ID, FMTATTR_OUT_ID, MSG_MAP_ID, MAP_BUFFER_ID_INPUT, MAP_BUFFER_ID_OUTPUT, CLEAR_FLAG) VALUES(%d, %d, %d, %d, %d, %d, %d, %d, %d);\n",
+						MapCmd_Ptr->MapCmd_Id, MapCmd_Ptr->Fmt_Input_Ptr->Id, MapCmd_Ptr->FmtAttr_Input_Ptr->Id, MapCmd_Ptr->Fmt_Output_Ptr->Id, MapCmd_Ptr->FmtAttr_Output_Ptr->Id, 
+						MapCmd_Ptr->MsgMap_Ptr->Id, MapCmd_Ptr->Buffer_Id_Input, MapCmd_Ptr->Buffer_Id_Output, MapCmd_Ptr->Clear_Flag);
+			}
+			else if(MapCmd_Ptr->TypeCmd == IMRD_MAPCMD_TYPE_COPY)
+			{
+				fprintf( Out, "INSERT INTO IMR_CMD_COPY(MAPCMD_ID, COPY_BUFFER_ID_INPUT, COPY_BUFFER_ID_OUTPUT) VALUES(%d, %d, %d);\n",
+						MapCmd_Ptr->MapCmd_Id, MapCmd_Ptr->Buffer_Id_Input, MapCmd_Ptr->Buffer_Id_Output);
+			}
+			else if(MapCmd_Ptr->TypeCmd == IMRD_MAPCMD_TYPE_GOTO)
+			{
+				fprintf( Out, "INSERT INTO IMR_CMD_GOTO(MAPCMD_ID, GOTO_BRANCHE_ID) VALUES(%d, %d);\n",
+						MapCmd_Ptr->MapCmd_Id, MapCmd_Ptr->Goto_Branche_Id);
+			}
+			
+
+			return( NDS_OK);
+		}
+
+		case IMRD_SDMD_CMD_API_XML_DUMP:
+		{
+		/*
+			NDT_Node   *Next_Node_Ptr = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+			va_list     user_args     =     (va_list)va_arg( Args, va_list);
+			user_type   user_data     =   (user_type)va_arg( user_args, user_type);
+								  ... =         (...)va_arg( user_args, ...);
+
+  			void       *Value_Ptr     = Node_Ptr->Value;
+		*/
+			NDT_Node        *Next_Node_Ptr = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+			va_list          user_args     =     (va_list)va_arg( Args, va_list);
+			FILE            *Out           =     (FILE  *)va_arg( user_args, FILE  *);
+
+			IMRT_MapCmd        *MapCmd_Ptr  = Node_Ptr->Value;
+
+
+			Command_Name = "IMRD_SDMD_CMD_API_XML_DUMP";
+
+			fprintf( Out, "\t\t\t<%s>\n", IMRD_SDMD_TAG_MAPCMD);
+
+			fprintf( Out, "\t\t\t\t<%s>%d</%s>\n", 
+					IMRD_SDMD_TAG_BRANCHE_ID, MapCmd_Ptr->Branche_Id, IMRD_SDMD_TAG_BRANCHE_ID);
+
+			if(MapCmd_Ptr->TypeCmd == IMRD_MAPCMD_TYPE_IDENT)
+			{
+				fprintf( Out, "\t\t\t\t<%s>\n", IMRD_SDMD_TAG_IDENTIFIER);
+
+				fprintf( Out, "\t\t\t\t\t<%s>%d</%s>\n",
+					IMRD_SDMD_TAG_NUMBUFFER, MapCmd_Ptr->Buffer_Id_Ident, IMRD_SDMD_TAG_NUMBUFFER);
+
+				if(MapCmd_Ptr->Ident_Total == IMRD_FALSE)
+				{
+					fprintf( Out, "\t\t\t\t\t<%s>%c</%s>\n", 
+						IMRD_SDMD_TAG_IDENTTOTAL, IMRD_NO, IMRD_SDMD_TAG_IDENTTOTAL);
+				}
+				else
+				{
+					fprintf( Out, "\t\t\t\t\t<%s>%c</%s>\n", 
+						IMRD_SDMD_TAG_IDENTTOTAL, IMRD_YES, IMRD_SDMD_TAG_IDENTTOTAL);
+				}
+
+				if(MapCmd_Ptr->Ident_First_Msg_Ptr != NULL)
+				{
+					fprintf( Out, "\t\t\t\t\t<%s>%s</%s>\n", 
+						IMRD_SDMD_TAG_TYPE, MapCmd_Ptr->Ident_First_Msg_Ptr->Name, IMRD_SDMD_TAG_TYPE);
+				}
+
+				for(i=0; i<MapCmd_Ptr->JmpTbleNbElts; i++)
+				{
+					fprintf( Out, "\t\t\t\t\t<%s>\n", IMRD_SDMD_TAG_GO_TO);
+						fprintf( Out, "\t\t\t\t\t\t<%s>%s</%s>\n", 
+						IMRD_SDMD_TAG_FORMAT, MapCmd_Ptr->Jump_Tab[i].Fmt_Ptr->Name, IMRD_SDMD_TAG_FORMAT);
+
+					fprintf( Out, "\t\t\t\t\t\t<%s>%s</%s>\n", 
+						IMRD_SDMD_TAG_TYPE, MapCmd_Ptr->Jump_Tab[i].Msg_Ptr->Name, IMRD_SDMD_TAG_TYPE);
+
+					fprintf( Out, "\t\t\t\t\t\t<%s>%d</%s>\n", 
+						IMRD_SDMD_TAG_BRANCHE_ID, MapCmd_Ptr->Jump_Tab[i].Branche_Id, IMRD_SDMD_TAG_BRANCHE_ID);
+						fprintf( Out, "\t\t\t\t\t</%s>\n", IMRD_SDMD_TAG_GO_TO);
+				}
+
+				fprintf( Out, "\t\t\t\t</%s>\n", IMRD_SDMD_TAG_IDENTIFIER);
+			}
+			else if(MapCmd_Ptr->TypeCmd == IMRD_MAPCMD_TYPE_MAP)
+			{
+				fprintf( Out, "\t\t\t\t<%s>\n", IMRD_SDMD_TAG_MAPPER);
+
+				fprintf( Out, "\t\t\t\t\t<%s>%s</%s>\n", 
+					IMRD_SDMD_TAG_INPUTFORMAT, MapCmd_Ptr->Fmt_Input_Ptr->Name, IMRD_SDMD_TAG_INPUTFORMAT);
+
+				if(strcmp(MapCmd_Ptr->FmtAttr_Input_Ptr->Value, IMRD_SDMD_EMPTY_STRING) != 0)
+				{
+					fprintf( Out, "\t\t\t\t\t<%s>%s</%s>\n", 
+						IMRD_SDMD_TAG_INPUTFORMAT_ATTR, MapCmd_Ptr->FmtAttr_Input_Ptr->Name, IMRD_SDMD_TAG_INPUTFORMAT_ATTR);
+				}
+
+				fprintf( Out, "\t\t\t\t\t<%s>%s</%s>\n", 
+					IMRD_SDMD_TAG_OUTPUTFORMAT, MapCmd_Ptr->Fmt_Output_Ptr->Name, IMRD_SDMD_TAG_OUTPUTFORMAT);
+
+				if(strcmp(MapCmd_Ptr->FmtAttr_Output_Ptr->Value, IMRD_SDMD_EMPTY_STRING) != 0)
+				{
+					fprintf( Out, "\t\t\t\t\t<%s>%s</%s>\n", 
+						IMRD_SDMD_TAG_OUTPUTFORMAT_ATTR, MapCmd_Ptr->FmtAttr_Output_Ptr->Name, IMRD_SDMD_TAG_OUTPUTFORMAT_ATTR);
+				}
+
+				fprintf( Out, "\t\t\t\t\t<%s>%d</%s>\n", 
+					IMRD_SDMD_TAG_INPUTBUFFER, MapCmd_Ptr->Buffer_Id_Input, IMRD_SDMD_TAG_INPUTBUFFER);
+
+				fprintf( Out, "\t\t\t\t\t<%s>%d</%s>\n", 
+					IMRD_SDMD_TAG_OUTPUTBUFFER, MapCmd_Ptr->Buffer_Id_Output, IMRD_SDMD_TAG_OUTPUTBUFFER);
+
+				if(MapCmd_Ptr->Clear_Flag != 0)
+				{
+					fprintf( Out, "\t\t\t\t\t<%s>%d</%s>\n", 
+						IMRD_SDMD_TAG_CLEARFLAG, MapCmd_Ptr->Clear_Flag, IMRD_SDMD_TAG_CLEARFLAG);
+				}
+
+				fprintf( Out, "\t\t\t\t\t<%s>%s</%s>\n", 
+					IMRD_SDMD_TAG_MSGMAP, MapCmd_Ptr->MsgMap_Ptr->Name, IMRD_SDMD_TAG_MSGMAP);
+
+				fprintf( Out, "\t\t\t\t</%s>\n", IMRD_SDMD_TAG_MAPPER);
+			}
+			else if(MapCmd_Ptr->TypeCmd == IMRD_MAPCMD_TYPE_COPY)
+			{
+				fprintf( Out, "\t\t\t\t<%s>\n", IMRD_SDMD_TAG_COPIE);
+
+				fprintf( Out, "\t\t\t\t\t<%s>%d</%s>\n", 
+					IMRD_SDMD_TAG_INPUTBUFFER, MapCmd_Ptr->Buffer_Id_Input, IMRD_SDMD_TAG_INPUTBUFFER);
+
+				fprintf( Out, "\t\t\t\t\t<%s>%d</%s>\n", 
+					IMRD_SDMD_TAG_OUTPUTBUFFER, MapCmd_Ptr->Buffer_Id_Output, IMRD_SDMD_TAG_OUTPUTBUFFER);
+
+				fprintf( Out, "\t\t\t\t</%s>\n", IMRD_SDMD_TAG_COPIE);
+			}
+			else if(MapCmd_Ptr->TypeCmd == IMRD_MAPCMD_TYPE_GOTO)
+			{
+				fprintf( Out, "\t\t\t\t<%s>\n", IMRD_SDMD_TAG_GO_TO);
+
+				fprintf( Out, "\t\t\t\t\t<%s>%d</%s>\n", 
+					IMRD_SDMD_TAG_BRANCHE_ID, MapCmd_Ptr->Goto_Branche_Id, IMRD_SDMD_TAG_BRANCHE_ID);
+
+				fprintf( Out, "\t\t\t\t</%s>\n", IMRD_SDMD_TAG_GO_TO);
+			}
+
+			fprintf( Out, "\t\t\t</%s>\n", IMRD_SDMD_TAG_MAPCMD);
+
+			return( NDS_OK);
+		}
+
+        default:
+        {
+            IMRD_LM_LOG_ERROR_1( "with an undefined command %d\n", Command);
+
+            return( NDS_ERRAPI);
+        }
+    }
+
+    return( NDS_OK);
+}
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* MapPath Manager                                                            */
+/*----------------------------------------------------------------------------*/
+
+NDT_Status  SDM_MapPath_Manager( NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id, NDT_Node  *Node_Ptr, NDT_Command  Command, va_list  Args)
+{
+    NDT_Command_Name        Command_Name;
+    NDT_Status              status;
+    SDMT_CritereRecChemin  *Recherche = NULL;
+    IMRT_Status             TableCritere[SDMD_NB_CRITERE_CHEMIN];
+    IMRT_Status             Valide;
+    char                    functioname[] = "Manager_MapPath";
+    
+
+    switch( Command)
+    {
+        case NDD_CMD_MANAGER_VERSION:
+        {
+            NDT_Version_Name  *Version_Name_Ptr = (NDT_Version_Name  *)va_arg( Args, NDT_Version_Name  *);
+
+
+            Command_Name = "NDD_CMD_MANAGER_VERSION";
+
+            *Version_Name_Ptr = "Revision: 2.1    Name: libnode-2_0_4-1    Date: 2002/02/28 22:00:35    Author: agibert ";
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_INDEX_GET:
+        {
+            /*
+	      NDT_Index_Id  *Reply_Index_Id_Ptr = (NDT_Index_Id  *)va_arg( Args, NDT_Index_Id  *);
+	      NDT_Command   *Reply_Command_Ptr  = (NDT_Command  *)va_arg( Args, NDT_Command  *);
+	      NDT_Command    Cmd                = (NDT_Command)va_arg( Args, NDT_Command);
+	      void          *Value_ptr          = (void  *)va_arg( Args, void  *);
+            */
+            NDT_Index_Id  *Reply_Index_Id_Ptr = (NDT_Index_Id  *)va_arg( Args, NDT_Index_Id  *);
+            NDT_Command   *Reply_Command_Ptr  = (NDT_Command  *)va_arg( Args, NDT_Command  *);
+            NDT_Command    Cmd                = (NDT_Command)va_arg( Args, NDT_Command);
+            IMRT_MapPath    *Value_ptr        = (IMRT_MapPath  *)va_arg( Args, IMRT_MapPath  *);
+            Command_Name = "NDD_CMD_INDEX_GET";
+
+            switch(Cmd)
+            {
+                case IMRD_SDMD_CMD_INDEX0_PRINT:
+                {
+                    *Reply_Index_Id_Ptr = 0;
+                    *Reply_Command_Ptr = NDD_CMD_VALUE_PRINT;
+                    break;
+                }
+
+                default:
+                {
+                    *Reply_Index_Id_Ptr = Index_Id;
+                    *Reply_Command_Ptr = Cmd;
+                    break;
+                }
+            }
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_ALLOC:
+        {
+            /*
+	      void       **Value_Ptr_Ptr = (void **)va_arg( Args, void  **);
+	      va_list      user_args     = (va_list)va_arg( Args, va_list);
+	      user_type    user_data     = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+            */
+            IMRT_MapPath  **Value_Ptr_Ptr = va_arg( Args, IMRT_MapPath  **);
+
+            Command_Name = "NDD_CMD_VALUE_ALLOC";
+
+            if( ( *Value_Ptr_Ptr = (IMRT_MapPath  *)malloc( sizeof(IMRT_MapPath))) == NULL)
+            {
+                return(NDS_ERRMEM);
+            }
+            else
+            {
+                SDM_InitMapPath(*Value_Ptr_Ptr);
+                if( ( status = ND_DataStruct_Open( &(*Value_Ptr_Ptr)->MapCmd_Struct_Ptr, IMRD_SDMD_INDEX_NB, index_type_initial_tab, "SDM_MapCmd_Manager", SDM_MapCmd_Manager, NULL, NULL, NULL, NULL,0,NULL)) != NDS_OK)
+		{
+		    IMRD_LM_LOG_ERROR_1( "ND_DataStruct_Open() MapCmd failed (%d) !\n", status);
+		    return(NDS_KO);
+		}
+
+                return( NDS_OK);
+            }
+        }
+
+        case NDD_CMD_VALUE_FREE:
+        {
+            /*
+	      void       *Value_Ptr = (void *)va_arg( Args, void  *);
+	      va_list     user_args = (va_list)va_arg( Args, va_list);
+	      user_type   user_data = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+            */
+            IMRT_MapPath  *Value_Ptr = (IMRT_MapPath  *)va_arg( Args, IMRT_MapPath  *);
+
+            Command_Name = "NDD_CMD_VALUE_FREE";
+            if(Value_Ptr->MapCmd_Struct_Ptr != NULL)
+            {	if( ( status = ND_DataStruct_Close(Value_Ptr->MapCmd_Struct_Ptr)) != NDS_OK)
+				{
+				    IMRD_LM_LOG_ERROR_1( "ND_DataStruct_Close() failed (%d) !\n", status);
+				    return(status);
+				}
+            }
+
+            free( Value_Ptr);
+            
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_COMP:
+        {
+            /*
+	      void       *Value1_Ptr = (void *)va_arg( Args, void  *);
+	      void       *Value2_Ptr = (void *)va_arg( Args, void  *);
+	      va_list     user_args  = (va_list)va_arg( Args, va_list);
+	      user_type   user_data  = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+            */
+            
+            IMRT_MapPath *Value1_Ptr = va_arg( Args, IMRT_MapPath  *);
+            IMRT_MapPath *Value2_Ptr = va_arg( Args, IMRT_MapPath  *);
+            va_list user_args   = (va_list)va_arg( Args, va_list);    
+            
+            Command_Name = "NDD_CMD_VALUE_COMP";
+
+                switch( Index_Id)
+                {
+				    case 0:
+				    {
+						if( Value1_Ptr->idMapPath< Value2_Ptr->idMapPath)
+						{
+						    return(NDS_LOWER);
+						}
+						else
+						{
+						    if( Value1_Ptr->idMapPath > Value2_Ptr->idMapPath)
+						    {
+								return(NDS_GREATER);
+						    }
+						    else
+						    {
+								return(NDS_EQUAL);
+						    }
+						}
+				    }
+
+				    default:
+				    {
+						IMRD_LM_LOG_ERROR_1( "Unknown COMP idx (%d) !\n", Index_Id);
+						return( NDS_KO);
+				    }
+                }  /* end switch */
+
+                return( NDS_OK);
+	    
+        }
+
+        case NDD_CMD_VALUE_ADD:
+        {
+            /*
+	      void       *Value_Ptr = (void *)va_arg( Args, void  *);
+	      va_list     user_args = (va_list)va_arg( Args, va_list);
+	      user_type   user_data = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+            */
+
+            Command_Name = "NDD_CMD_VALUE_ADD";
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_REMOVE:
+        {
+            /*
+	      void       *Value_Ptr = (void *)va_arg( Args, void  *);
+	      va_list     user_args = (va_list)va_arg( Args, va_list);
+	      user_type   user_data = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+            */
+
+            Command_Name = "NDD_CMD_VALUE_REMOVE";
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_PRINT:
+        {
+            /*
+	      NDT_Node             *Next_Node_Ptr    = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+	      va_list               lib_args         = (va_list)va_arg( Args, va_list);
+	      FILE                 *Out              = (FILE  *)va_arg( lib_args, FILE  *);
+	      NDT_Recursive_Mode    Recursive_Mode   = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode);
+	      NDT_Recursive_Depth   Recursive_Depth  = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth);
+	      NDT_Recursive_Offset  Recursive_Offset = (NDT_Recursive_Offset)va_arg( lib_args, NDT_Recursive_Offset);
+	      va_list               user_args        = (va_list)va_arg( lib_args, va_list);
+	      user_type             user_data        = (user_type)va_arg( user_args, user_type);
+	      ...  = (...)va_arg( user_args, ...);
+
+	      void                 *Value_Ptr        = Node_Ptr->Value;
+            */
+            NDT_Node             *Next_Node_Ptr    = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+            va_list               lib_args         = (va_list)va_arg( Args, va_list);
+            FILE                 *Out              = (FILE  *)va_arg( lib_args, FILE  *);
+            NDT_Recursive_Mode    Recursive_Mode   = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode);
+            NDT_Recursive_Depth   Recursive_Depth  = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth);
+            NDT_Recursive_Offset  Recursive_Offset = (NDT_Recursive_Offset)va_arg( lib_args, NDT_Recursive_Offset);
+
+            IMRT_MapPath          *Value_Ptr       = Node_Ptr->Value;
+
+            Command_Name = "NDD_CMD_VALUE_PRINT";
+
+           
+            fprintf( Out, "idMapPath: (%d)   InputFormat: (%s) OutputFormat: (%s)  InputAppli: (%s)  OutputAppli: (%s)   \n",
+		     Value_Ptr->idMapPath, 
+		     Value_Ptr->Fmt_Input_Ptr->Name, 
+		     Value_Ptr->Fmt_Output_Ptr->Name,
+		     Value_Ptr->Appl_Input_Ptr->Name,
+		     Value_Ptr->Appl_Output_Ptr->Name);
+
+            return( ND_DataStruct_Value_Print( Out, Value_Ptr->MapCmd_Struct_Ptr, NDD_RECURSIVE_MODE_PARENT_CHILD, --Recursive_Depth, ++Recursive_Offset));
+            
+        }
+
+        case NDD_CMD_INFO_PRINT:
+        {
+            /*
+	      NDT_Node             *Next_Node_Ptr    = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+	      va_list               lib_args         = (va_list)va_arg( Args, va_list);
+	      FILE                 *Out              = (FILE  *)va_arg( lib_args, FILE  *);
+	      NDT_Recursive_Mode    Recursive_Mode   = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode);
+	      NDT_Recursive_Depth   Recursive_Depth  = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth);
+	      NDT_Recursive_Offset  Recursive_Offset = (NDT_Recursive_Offset)va_arg( lib_args, NDT_Recursive_Offset);
+	      va_list               user_args        = (va_list)va_arg( lib_args, va_list);
+	      user_type             user_data        = (user_type)va_arg( user_args, user_type);
+	      ...  = (...)va_arg( user_args, ...);
+
+	      void                 *Value_Ptr       = Node_Ptr->Value;
+            */
+
+            NDT_Node             *Next_Node_Ptr    = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+	    va_list               lib_args         = (va_list)va_arg( Args, va_list);
+	    FILE                 *Out              = (FILE  *)va_arg( lib_args, FILE  *);
+	    NDT_Recursive_Mode    Recursive_Mode   =(NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode);
+	    NDT_Recursive_Depth   Recursive_Depth  = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth);
+	    NDT_Recursive_Offset  Recursive_Offset = (NDT_Recursive_Offset)va_arg( lib_args, NDT_Recursive_Offset);
+			      
+	    IMRT_MapPath  *MapPath_Ptr                      = Node_Ptr->Value;
+
+	    Command_Name = "NDD_CMD_INFO_PRINT";
+
+	    return( ND_DataStruct_Info_Print( Out, MapPath_Ptr->MapCmd_Struct_Ptr, NDD_RECURSIVE_MODE_PARENT_CHILD, --Recursive_Depth, ++Recursive_Offset));
+	}
+	case NDD_CMD_FIND_MAPPATH:
+        {
+            /*
+	      NDT_Node             *Next_Node_Ptr   = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+	      va_list               lib_args        = (va_list)va_arg( Args, va_list);
+	      FILE                 *Out             = (FILE  *)va_arg( lib_args, FILE  *);
+	      NDT_Recursive_Mode    Recursive_Mode  = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode);
+	      NDT_Recursive_Depth   Recursive_Depth = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth);
+	      va_list               user_args       = (va_list)va_arg( lib_args, va_list);
+	      user_type             user_data       = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+	      void                 *Value_Ptr       = Node_Ptr->Value;
+            */
+            
+            
+	      NDT_Node             *Next_Node_Ptr   = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+	      va_list                 user_args       = (va_list)va_arg( Args, va_list);
+	      FILE                   *Out             = (FILE  *)va_arg( user_args, FILE  *);
+	      SDMT_CritereRecChemin  *Recherche       = (SDMT_CritereRecChemin *)va_arg( user_args, SDMT_CritereRecChemin *);
+
+	      IMRT_MapPath    *Value_Ptr       = 	Node_Ptr->Value;
+	      IMRT_Mode_Traverse  Mode_Normal_Erreur = IMRD_NORMALE_MODE;
+
+        Command_Name = "NDD_CMD_FIND_MAPPATH";
+
+		SDM_CompareCritereMapPath(TableCritere, SDMD_NB_CRITERE_CHEMIN,Recherche, Value_Ptr, &Valide);
+                /*le chemin de mappin vérifie les critére de la demande
+                  on va traverser la structure MapCmd qui contient toutes
+                  les commandes pour le chemin de mapping sélectionné
+                */
+                if(Valide == IMRS_OK)
+                {
+		   
+		    IMRD_LM_LOG_TRACE_1( IMRD_LOG_LEVEL_VERBOSE_1, "Mappath match Id : <%d>", Value_Ptr->idMapPath);
+		    		status = (IMRT_Status)ND_DataStruct_Traverse( Value_Ptr->MapCmd_Struct_Ptr, IMRD_SDMD_CMD_EXECUTE, stdout, NDD_RECURSIVE_MODE_PARENT,Recherche, &Mode_Normal_Erreur);
+		    		if ((status != NDS_OK) || (Mode_Normal_Erreur != IMRD_NORMALE_MODE))
+		    	    {
+						IMRD_LM_LOG_ERROR_1( "ND_DataStruct_Traverse() failed (%d) !\n", status);
+						return(NDS_KO);
+		    	    }
+
+		    		return(NDS_NODE_FOUND);
+                }
+                return (NDS_OK);
+        }
+
+	case IMRD_SDMD_CMD_API_SQL_DUMP:
+	{
+	/*
+		NDT_Node   *Next_Node_Ptr = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+		va_list     user_args     =     (va_list)va_arg( Args, va_list);
+		user_type   user_data     =   (user_type)va_arg( user_args, user_type);
+							  ... =         (...)va_arg( user_args, ...);
+
+		void       *Value_Ptr     = Node_Ptr->Value;
+	*/
+		NDT_Node        *Next_Node_Ptr = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+		va_list          user_args     =     (va_list)va_arg( Args, va_list);
+		FILE            *Out           =     (FILE  *)va_arg( user_args, FILE  *);
+
+		IMRT_MapPath    *MapPath_Ptr  = Node_Ptr->Value;
+
+
+		Command_Name = "IMRD_SDMD_CMD_API_SQL_DUMP";
+
+		fprintf( Out, "INSERT INTO IMR_MAPPATH(MAP_PATH_ID, APPLI_IN_ID, APPLI_OUT_ID, FORMAT_IN_ID, FORMAT_OUT_ID) VALUES(%d, %d, %d, %d, %d);\n",
+						MapPath_Ptr->idMapPath, MapPath_Ptr->Appl_Input_Ptr->Id, MapPath_Ptr->Appl_Output_Ptr->Id, MapPath_Ptr->Fmt_Input_Ptr->Id, MapPath_Ptr->Fmt_Output_Ptr->Id);
+		
+	    if( ( status = ND_DataStruct_Traverse( MapPath_Ptr->MapCmd_Struct_Ptr, IMRD_SDMD_CMD_API_SQL_DUMP, Out, MapPath_Ptr->idMapPath)) != NDS_OK)
+		{
+		    IMRD_LM_LOG_ERROR_1( "ND_DataStruct_Traverse failed (%d)...\n",status);
+			return(NDS_KO);
+		}
+
+		return( NDS_OK);
+	}
+
+	case IMRD_SDMD_CMD_API_XML_DUMP:
+	{
+	/*
+		NDT_Node   *Next_Node_Ptr = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+		va_list     user_args     =     (va_list)va_arg( Args, va_list);
+		user_type   user_data     =   (user_type)va_arg( user_args, user_type);
+							  ... =         (...)va_arg( user_args, ...);
+
+		void       *Value_Ptr     = Node_Ptr->Value;
+	*/
+		NDT_Node        *Next_Node_Ptr = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+		va_list          user_args     =     (va_list)va_arg( Args, va_list);
+		FILE            *Out           =     (FILE  *)va_arg( user_args, FILE  *);
+
+		IMRT_MapPath    *MapPath_Ptr  = Node_Ptr->Value;
+
+
+		Command_Name = "IMRD_SDMD_CMD_API_XML_DUMP";
+
+		fprintf( Out, "\t<%s>\n", IMRD_SDMD_TAG_MAPPATH);
+
+		fprintf( Out, "\t\t<%s>%s</%s>\n", 
+					IMRD_SDMD_TAG_INPUTAPPLI, MapPath_Ptr->Appl_Input_Ptr->Name, IMRD_SDMD_TAG_INPUTAPPLI);
+
+		fprintf( Out, "\t\t<%s>%s</%s>\n", 
+					IMRD_SDMD_TAG_OUTPUTAPPLI, MapPath_Ptr->Appl_Output_Ptr->Name, IMRD_SDMD_TAG_OUTPUTAPPLI);
+
+		fprintf( Out, "\t\t<%s>%s</%s>\n", 
+					IMRD_SDMD_TAG_INPUTFORMAT, MapPath_Ptr->Fmt_Input_Ptr->Name, IMRD_SDMD_TAG_INPUTFORMAT);
+
+		fprintf( Out, "\t\t<%s>%s</%s>\n", 
+					IMRD_SDMD_TAG_OUTPUTFORMAT, MapPath_Ptr->Fmt_Output_Ptr->Name, IMRD_SDMD_TAG_OUTPUTFORMAT);
+		
+
+	    if( ( status = ND_DataStruct_Traverse( MapPath_Ptr->MapCmd_Struct_Ptr, IMRD_SDMD_CMD_API_XML_DUMP, Out)) != NDS_OK)
+		{
+		    IMRD_LM_LOG_ERROR_1( "ND_DataStruct_Traverse failed (%d)...\n",status);
+			return(NDS_KO);
+		}
+
+		fprintf( Out, "\t</%s>\n", IMRD_SDMD_TAG_MAPPATH);
+
+		return( NDS_OK);
+	}
+
+	default:
+	{
+            IMRD_LM_LOG_ERROR_1("called with an undefined command %d\n", Command);
+
+            return( NDS_ERRAPI);
+	}
+    }
+
+    return( NDS_OK);
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status SDM_BufferInfo_Init(IMRT_SDM_Config  * Lib_Config_Ptr)
+{
+    IMRT_Status  status;
+
+    if(Lib_Config_Ptr->Flag == IMRD_SDM_FLAG_XML)
+    {
+		status = SDM_XML_BufferInfo_Init(Lib_Config_Ptr->Lib_Path);
+    }
+    else
+    {
+#ifdef ORACLE_SUPPORT
+		status = SDM_SQL_BufferInfo_Init();
+#else
+		status = IMRS_OK;
+#endif /* ORACLE_SUPPORT */
+    }
+
+    return(status);
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status SDM_Close_RootMapPath(void)
+{
+	IMRT_Status  status;
+	NDT_Status   nd_status;
+
+	status = IMRS_OK;
+
+	if(IMRG_SDM_Base.RootMapPath != NULL)
+	{
+		if (IMRG_SDM_Base.RootMapPath->User_Ptr != NULL)
+		{
+			free(IMRG_SDM_Base.RootMapPath->User_Ptr);
+		}
+
+		if( ( nd_status = ND_DataStruct_Close(IMRG_SDM_Base.RootMapPath)) != NDS_OK)
+		{
+			IMRD_LM_LOG_ERROR_1( "RootMapPath ND_DataStruct_Close() failed (%d) !\n", nd_status);
+			status = IMRS_KO;
+		}
+	}
+
+	return(status);
+
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status SDM_Close_RootAppl(void)
+{
+	IMRT_Status  status;
+	NDT_Status   nd_status;
+
+	status = IMRS_OK;
+
+	if(IMRG_SDM_Base.RootAppl != NULL)
+	{
+		if (IMRG_SDM_Base.RootAppl->User_Ptr != NULL)
+		{
+			free(IMRG_SDM_Base.RootAppl->User_Ptr);
+		}
+
+		if( ( nd_status = ND_DataStruct_Close(IMRG_SDM_Base.RootAppl)) != NDS_OK)
+		{
+			IMRD_LM_LOG_ERROR_1("ND_DataStruct_Close() failed (%d) !\n", nd_status);
+			status = IMRS_KO;
+		}
+	}
+
+	return(status);
+
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status SDM_Close_RootFmtAttr(void)
+{
+	IMRT_Status  status;
+	NDT_Status   nd_status;
+
+	status = IMRS_OK;
+
+	if(IMRG_SDM_Base.RootFmtAttr != NULL)
+	{
+		if (IMRG_SDM_Base.RootFmtAttr->User_Ptr != NULL)
+		{
+			free(IMRG_SDM_Base.RootFmtAttr->User_Ptr);
+		}
+
+		if( ( nd_status = ND_DataStruct_Close(IMRG_SDM_Base.RootFmtAttr)) != NDS_OK)
+		{
+			IMRD_LM_LOG_ERROR_1("ND_DataStruct_Close() failed (%d) !\n", nd_status);
+			status = IMRS_KO;
+		}
+	}
+
+	return(status);
+
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status SDM_Close_RootFmt(void)
+{
+	IMRT_Status  status;
+	NDT_Status   nd_status;
+
+	status = IMRS_OK;
+
+	if(IMRG_SDM_Base.RootFmt != NULL)
+	{
+		if (IMRG_SDM_Base.RootFmt->User_Ptr != NULL)
+		{
+			free(IMRG_SDM_Base.RootFmt->User_Ptr);
+		}
+
+		if( ( nd_status = ND_DataStruct_Close(IMRG_SDM_Base.RootFmt)) != NDS_OK)
+		{
+			IMRD_LM_LOG_ERROR_1( "ND_DataStruct_Close() failed (%d) !\n", nd_status);
+			status = IMRS_KO;
+		}
+	}
+
+	return(status);
+
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status SDM_BufferInfo_DInit(void)
+{
+	IMRT_Status  status, StatusMapPath, StatusAppl, StatusFmtAttr, StatusFmt;
+
+	status = IMRS_OK;
+
+	StatusMapPath = SDM_Close_RootMapPath();
+	StatusAppl = SDM_Close_RootAppl();
+	StatusFmtAttr = SDM_Close_RootFmtAttr();
+	StatusFmt = SDM_Close_RootFmt();
+
+	if((StatusMapPath == IMRS_KO)||(StatusAppl == IMRS_KO)||(StatusFmtAttr == IMRS_KO)||(StatusFmt == IMRS_KO))
+	{
+		status = IMRS_KO;
+	}
+
+	return(status);
+
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  SDM_MapPath_Proceed( IMRT_Appl_Id  Appl_Id_Target, IMRT_Fmt_Id  Fmt_Id_Target, IMRT_Msg_Id  Msg_Id_Target,
+				  IMRT_Appl_Id  ApplId_Src,     IMRT_Fmt_Id  Fmt_Id_Src,    IMRT_Msg_Id  Msg_Id_Src,
+				  IMRT_SDMCB_Buffer_Map    *CCB_Buffer_Map_Ptr,
+				  IMRT_SDMCB_Buffer_Copy   *CCB_Buffer_Copy_Ptr,
+				  IMRT_SDMCB_Buffer_Ident  *CCB_Buffer_Ident_Ptr)
+
+{
+    SDMT_CritereRecChemin Recherche;
+    NDT_Node *            node_ptr;
+    IMRT_Status            status;
+    IMRT_MapPath          mymappath;
+  
+    Recherche.Branche_id        = 0;
+    Recherche.InputAppli =   ApplId_Src;
+    Recherche.OutputAppli=   Appl_Id_Target;
+    Recherche.InputFormat       = Fmt_Id_Src;
+    Recherche.OutputFormat      = Fmt_Id_Target;
+    Recherche.InputType =  Msg_Id_Src;
+    Recherche.OutputType = Msg_Id_Target;
+    Recherche.CallBackCommandeIdent = CCB_Buffer_Ident_Ptr;
+    Recherche.CallBackBCommandeMap  = CCB_Buffer_Map_Ptr;
+    Recherche.CallBackCommandeCopy  = CCB_Buffer_Copy_Ptr;
+      
+    status = (IMRT_Status)ND_DataStruct_Traverse( IMRG_SDM_Base.RootMapPath, NDD_CMD_FIND_MAPPATH, stdout,&Recherche);
+    
+    if(status != NDS_NODE_FOUND)
+    {
+		status = IMRS_KO;
+    }
+    else
+    {
+    	status  = IMRS_OK;
+    }
+    return(status);
+}
+
+IMRT_Status SDM_MsgIdent_Proceed( IMRT_Fmt_Id  Fmt_Id, IMRT_Msg_Id  *Msg_Id, IMRT_SDMCB_Ident_Field_Value  *CCB_Ident_Field_Value_Ptr, IMRT_SDMCB_Ident_Field_Exist *CCB_Ident_Field_Exist_Ptr, IMRT_SDMCB_Ident_Msg_Size *CCB_Ident_Msg_Size_Ptr)
+{
+/*IMRT_SDMCB_Field_Ident  *CCB_Field_Ident_Ptr*/
+
+    IMRT_Status status;
+    IMRT_Fmt   Fmt;
+    IMRT_Fmt * Fmt2;
+    NDT_Root    * FmtMsg_Ptr ;
+    NDT_Node    * node_ptr;
+    IMRT_SDM_IdentMessage Struct_Indent;
+    char functionname [] = "IMR_IdentificationMessage";
+    char DescErr[IMRD_SDMD_DESCERR_LEN];
+  
+    Struct_Indent.Ident_Msg_SizeFunc_Ptr = CCB_Ident_Msg_Size_Ptr;
+    Struct_Indent.Ident_Field_ExistFunc_Ptr = CCB_Ident_Field_Exist_Ptr;
+    Struct_Indent.Ident_Field_ValueFunc_Ptr = CCB_Ident_Field_Value_Ptr;
+
+	Struct_Indent.Id = *Msg_Id;
+	Struct_Indent.Mode = IMRD_SKIP_MODE;
+	
+
+    /*recherche de la liste des message en fonction du format*/
+    Fmt.Id = Fmt_Id;
+    if((status = (IMRT_Status)ND_Index_Node_Find( &node_ptr, IMRG_SDM_Base.RootFmt,
+						  IMRD_SDMD_FMT_IDX_ID, &Fmt, NULL)) != NDS_OK)
+    {
+	snprintf(DescErr,sizeof(DescErr),SDMD_LIB_ERROR_8,Fmt.Id);
+        status = IMRS_KO;
+    }
+    else
+    {
+	Fmt2 = (IMRT_Fmt *)node_ptr->Value;
+	FmtMsg_Ptr = Fmt2->FmtMsg_Struct_Ptr;
+	status = (IMRT_Status)ND_DataStruct_Traverse( FmtMsg_Ptr, IMRD_SDMD_CMD_EXECUTE, stdout, NDD_RECURSIVE_MODE_PARENT,&Struct_Indent);
+	    
+	if(status == (IMRT_Status)NDS_IDENT_OK)
+	{
+	    *Msg_Id = Struct_Indent.Id;
+	    status = IMRS_OK;
+	}
+	else if((status == (IMRT_Status)NDS_KO))
+	{
+	    status = IMRS_KO;
+	    snprintf(DescErr,sizeof(DescErr),SDMD_LIB_ERROR_9,Fmt.Name);
+	}
+	else
+	{
+	    *Msg_Id = IMRD_MSG_ID_UNKNOWN; 
+	    status = IMRS_OK;
+	}
+    }
+
+    return(status);
+
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  SDM_Fmt_Proceed( IMRT_SDMCB_Fmt_Add  *CCB_Fmt_Add_Ptr)
+{
+
+    IMRT_Status status;
+    NDT_Status  nd_status;
+
+	status = IMRS_OK;
+    if( ( nd_status = ND_DataStruct_Traverse( IMRG_SDM_Base.RootFmt, IMRD_SDMD_CMD_EXECUTE, stdout, NDD_RECURSIVE_MODE_PARENT, CCB_Fmt_Add_Ptr)) != NDS_OK)
+    {
+	  IMRD_LM_LOG_ERROR_1("ND_DataStruct_Traverse() failed (%d) !\n", nd_status);
+	  status = IMRS_KO;
+    }
+
+    return(status);
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+void SDM_InitMapCmd(IMRT_MapCmd * mymapcmd)
+{
+ int i;
+ mymapcmd->MapCmd_Id         = 0;
+ mymapcmd->TypeCmd           = IMRD_MAPCMD_TYPE_UNKNOWN;
+ mymapcmd->Fmt_Input_Ptr       = NULL;
+ mymapcmd->FmtAttr_Input_Ptr = NULL;
+ mymapcmd->Fmt_Output_Ptr      = NULL;
+ mymapcmd->FmtAttr_Output_Ptr = NULL;
+ mymapcmd->Branche_Id        = -1;
+ mymapcmd->Buffer_Id_Input	     = -1;
+ mymapcmd->Buffer_Id_Output	     = -1;
+ mymapcmd->MsgMap_Ptr       = NULL;
+ mymapcmd->Buffer_Id_Ident  = -1;
+ mymapcmd->Clear_Flag         = 0;
+ mymapcmd->Goto_Branche_Id  = -1;
+ mymapcmd->Ident_Total = IMRD_TRUE;
+ mymapcmd->Ident_First_Msg_Ptr = NULL;
+ mymapcmd->JmpTbleNbElts = 0;
+ mymapcmd->Jump_Tab = NULL;
+ /*for( i =0 ; i<IMRD_JUMP_NB_MAX;i++)
+ {
+   mymapcmd->Jump_Tab[i].Fmt_Ptr       = NULL;
+   mymapcmd->Jump_Tab[i].Msg_Ptr       = NULL;
+   mymapcmd->Jump_Tab[i].Branche_Id = -1;
+ } */
+
+}
+
+
+void SDM_InitMapPath(IMRT_MapPath * mymappath)
+{
+  mymappath->idMapPath    = 0;
+  mymappath->Fmt_Input_Ptr  = NULL;
+  mymappath->Fmt_Output_Ptr = NULL;
+  mymappath->Appl_Input_Ptr   = NULL;
+  mymappath->Appl_Output_Ptr  = NULL;
+  mymappath->MapCmd_Struct_Ptr =NULL;
+}
+
+void SDM_InitFormat(IMRT_Fmt * myformat)
+{
+  myformat->Id= IMRD_FMT_ID_UNKNOWN;
+  memset(myformat->Name,0,sizeof(myformat->Name));
+}
+
+void SDM_InitFmtAttr(IMRT_FmtAttr * myFmtAttr)
+{
+  myFmtAttr->Id = IMRD_FMTATTR_ID_UNKNOWN;
+  strcpy(myFmtAttr->Name, IMRD_FMTATTR_NAME_UNKNOWN);
+  memset(myFmtAttr->Value,'\0',sizeof(myFmtAttr->Value));
+}
+
+void SDM_InitFmtMsg(IMRT_FmtMsg * myFmtMsg)
+{
+  myFmtMsg->Msg_Ptr = NULL;
+  myFmtMsg->Branche_Id = IMRD_BRANCHE_ID_UNKNOWN;
+  myFmtMsg->FmtAttr_Ptr = NULL;
+}
+
+
+void SDM_InitAppl(IMRT_Appl * Appl_Ptr)
+{
+    Appl_Ptr->Id = IMRD_APPL_ID_UNKNOWN;
+    memset(Appl_Ptr->Name,0,sizeof(Appl_Ptr->Name));
+}
diff --git a/src/libstatic_data_mng/src/buffer_info_mng.h b/src/libstatic_data_mng/src/buffer_info_mng.h
new file mode 100644
index 0000000..ea1ea95
--- /dev/null
+++ b/src/libstatic_data_mng/src/buffer_info_mng.h
@@ -0,0 +1,258 @@
+/*----------------------------------------------------------------------------*/
+/* File: buffer_info_mng.h 				         	      */
+/*----------------------------------------------------------------------------*/
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#ifndef _BUFFER_INFO_MNG_H_
+#   define _BUFFER_INFO_MNG_H_
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Global Include                                                             */
+/*----------------------------------------------------------------------------*/
+
+#   include <libstatic_data_mng.h>
+
+
+/*----------------------------------------------------------------------------*/
+/* Local definition                                                             */
+/*----------------------------------------------------------------------------*/
+
+
+/*----------------------------------------------------------------------------*/
+/* XML TAG                                                                    */
+/*----------------------------------------------------------------------------*/
+#define IMRD_SDMD_FMTATTR_STRUCT    "fmtattr_struct"
+#define IMRD_SDMD_APPLI_STRUCT      "appl_struct"
+#define IMRD_SDMD_FMT_STRUCT        "fmt_struct"
+#define IMRD_SDMD_MAPPATH_STRUCT    "mappath_struct"
+
+/* Nom des fichiers pour le chargement XML */
+#define SDMD_FMTATTR_FILE           "sd_fmtattr_struct.xml"
+#define SDMD_APPLI_FILE             "sd_appl_struct.xml"
+#define SDMD_FORMAT_FILE            "sd_fmt_struct.xml"
+#define SDMD_MAPPATH_FILE           "sd_mappath_struct.xml"
+
+
+
+#define SDMD_CRI_IA 0 /*Critére input appli*/
+#define SDMD_CRI_OA 1 /*Critére output appli*/
+#define SDMD_CRI_IF 2 /*Critére input format*/
+#define SDMD_CRI_OF 3 /*Critére output format*/
+#define SDMD_CRI_IT 4 /*Critére input type*/
+#define SDMD_CRI_OT 5 /*Critére ouput type*/
+
+#define SDMD_NB_CRITERE_CHEMIN 4
+
+
+typedef struct IMRT_Appl
+{
+	IMRT_Appl_Id   Id;
+	IMRT_Appl_Name Name ;
+
+} IMRT_Appl;
+
+typedef struct IMRT_MapPath
+{
+	int      idMapPath;
+	IMRT_Fmt   * Fmt_Input_Ptr;
+	IMRT_Fmt   * Fmt_Output_Ptr;
+	IMRT_Appl  * Appl_Input_Ptr;
+	IMRT_Appl  * Appl_Output_Ptr;
+	NDT_Root   * MapCmd_Struct_Ptr;
+} IMRT_MapPath;
+
+
+/*typedef struct SDMT_FmtMsg
+{
+	char name [IMRD_NAME_LEN];
+	IMRT_Msg * msg;
+ 
+} SDMT_FmtMsg;
+*/
+
+
+typedef struct SDMT_CritereRecChemin
+{
+	IMRT_Appl_Id   InputAppli;
+	IMRT_Appl_Id   OutputAppli;
+	IMRT_Fmt_Id    InputFormat;
+	IMRT_Fmt_Id    OutputFormat;
+	IMRT_Msg_Id    InputType;
+	IMRT_Msg_Id    OutputType;
+	int  Branche_id;
+	IMRT_Error FataError;
+	IMRT_SDMCB_Buffer_Ident * CallBackCommandeIdent;
+	IMRT_SDMCB_Buffer_Map   * CallBackBCommandeMap;
+	IMRT_SDMCB_Buffer_Copy  * CallBackCommandeCopy;
+
+} SDMT_CritereRecChemin;
+
+/********************************************************************/
+/*       Les index du Manager SDM_Appl_Manager                      */
+/********************************************************************/
+#define IMRD_SDMD_APPL_STRUCT_IDX_NB                (short)2
+
+static NDT_Index_Type  Appl_Struct_initial_idx_tab[IMRD_SDMD_APPL_STRUCT_IDX_NB] = 
+{
+      (NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_LIST | NDD_INDEX_SUBTYPE_SORTED),
+      (NDD_INDEX_STATUS_CLOSED)
+};
+
+static NDT_Index_Type  Appl_Struct_final_idx_tab[IMRD_SDMD_APPL_STRUCT_IDX_NB] = 
+{
+      (NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_TREE | NDD_INDEX_SUBTYPE_BALANCED),
+      (NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_TREE | NDD_INDEX_SUBTYPE_BALANCED)
+};
+
+#define IMRD_SDMD_APPL_IDX_ID                (short)0
+#define IMRD_SDMD_APPL_IDX_NAME              (short)1
+
+/********************************************************************/
+/*       Les index du Manager SDM_FmtAttr_Manager                   */
+/********************************************************************/
+#define IMRD_SDMD_FMTATTR_STRUCT_IDX_NB                (short)2
+
+static NDT_Index_Type  FmtAttr_Struct_initial_idx_tab[IMRD_SDMD_FMTATTR_STRUCT_IDX_NB] = 
+{
+      (NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_LIST | NDD_INDEX_SUBTYPE_SORTED),
+      (NDD_INDEX_STATUS_CLOSED)
+};
+
+static NDT_Index_Type  FmtAttr_Struct_final_idx_tab[IMRD_SDMD_FMTATTR_STRUCT_IDX_NB] = 
+{
+      (NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_TREE | NDD_INDEX_SUBTYPE_BALANCED),
+      (NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_TREE | NDD_INDEX_SUBTYPE_BALANCED)
+};
+
+#define IMRD_SDMD_FMTATTR_IDX_ID                (short)0
+#define IMRD_SDMD_FMTATTR_IDX_NAME              (short)1
+
+
+/********************************************************************/
+/*       Les index du Manager SDM_Fmt_Manager                       */
+/********************************************************************/
+#define IMRD_SDMD_FMT_STRUCT_IDX_NB                (short)2
+
+static NDT_Index_Type  Fmt_Struct_initial_idx_tab[IMRD_SDMD_FMT_STRUCT_IDX_NB] = 
+{
+      (NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_LIST | NDD_INDEX_SUBTYPE_SORTED),
+      (NDD_INDEX_STATUS_CLOSED)
+};
+
+static NDT_Index_Type  Fmt_Struct_final_idx_tab[IMRD_SDMD_FMT_STRUCT_IDX_NB] = 
+{
+      (NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_TREE | NDD_INDEX_SUBTYPE_BALANCED),
+      (NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_TREE | NDD_INDEX_SUBTYPE_BALANCED)
+};
+
+#define IMRD_SDMD_FMT_IDX_ID                (short)0
+#define IMRD_SDMD_FMT_IDX_NAME              (short)1
+
+
+/*----------------------------------------------------------------------------*/
+/* Prototypes                                                                 */
+/*----------------------------------------------------------------------------*/
+
+#   ifdef _BUFFER_INFO_MNG_C_
+IMRT_Status  SDM_DataStruct_Finalize(NDT_Root  *, NDT_Index_Type *, short );
+NDT_Status  SDM_Appl_Manager(    NDT_Root  *, NDT_Index_Id, NDT_Node  *, NDT_Command, va_list);
+NDT_Status  SDM_FmtAttr_Manager(    NDT_Root  *, NDT_Index_Id, NDT_Node  *, NDT_Command, va_list);
+NDT_Status  SDM_FmtMsg_Manager(  NDT_Root  *, NDT_Index_Id, NDT_Node  *, NDT_Command, va_list);
+NDT_Status  SDM_Fmt_Manager(     NDT_Root  *, NDT_Index_Id, NDT_Node  *, NDT_Command, va_list);
+NDT_Status  SDM_MapCmd_Manager(  NDT_Root  *, NDT_Index_Id, NDT_Node  *, NDT_Command, va_list);
+NDT_Status  SDM_MapPath_Manager( NDT_Root  *, NDT_Index_Id, NDT_Node  *, NDT_Command, va_list);
+IMRT_Status  SDM_MapPath_Proceed( IMRT_Appl_Id  Appl_Id_Target, IMRT_Fmt_Id  Fmt_Id_Target, IMRT_Msg_Id  Msg_Id_Target,
+				  IMRT_Appl_Id  ApplId_Src,     IMRT_Fmt_Id  Fmt_Id_Src,    IMRT_Msg_Id  Msg_Id_Src,
+				  IMRT_SDMCB_Buffer_Map    *CCB_Buffer_Map_Ptr,
+				  IMRT_SDMCB_Buffer_Copy   *CCB_Buffer_Copy_Ptr,
+				  IMRT_SDMCB_Buffer_Ident  *CCB_Buffer_Ident_Ptr);
+IMRT_Status  SDM_Fmt_Proceed( IMRT_SDMCB_Fmt_Add  *CCB_Fmt_Add_Ptr);
+void SDM_CompareCritereMapPath(IMRT_Status CitereTable[],
+			       const int NbCritere,
+			       SDMT_CritereRecChemin * Critere,
+			       IMRT_MapPath * myMapPath,
+			       IMRT_Status  *Valide );
+void SDM_IniTableCritere(IMRT_Status Table[],const int NbElement);
+void SDM_InitMapCmd(IMRT_MapCmd * mymapcmd);
+void SDM_InitMapPath(IMRT_MapPath * mymappath);
+void SDM_InitFormat(IMRT_Fmt * myformat);
+void SDM_InitFmtAttr(IMRT_FmtAttr * myFmtAttr);
+void SDM_InitFmtMsg(IMRT_FmtMsg * myFmtMsg);
+void SDM_InitAppl(IMRT_Appl * Appl_Ptr); 
+IMRT_Status SDM_BufferInfo_Init(IMRT_SDM_Config  * Lib_Config_Ptr);
+IMRT_Status SDM_Close_RootMapPath(void);
+IMRT_Status SDM_Close_RootAppl(void);
+IMRT_Status SDM_Close_RootFmtAttr(void);
+IMRT_Status SDM_Close_RootFmt(void);
+IMRT_Status SDM_BufferInfo_DInit(void);
+
+#   else
+
+extern IMRT_Status  SDM_DataStruct_Finalize(NDT_Root  *ds_Ptr, NDT_Index_Type *Index_Id_Ptr, short hMaxEntries);
+extern NDT_Status  SDM_Appl_Manager(    NDT_Root  *, NDT_Index_Id, NDT_Node  *, NDT_Command, va_list);
+extern NDT_Status  SDM_FmtAttr_Manager(    NDT_Root  *, NDT_Index_Id, NDT_Node  *, NDT_Command, va_list);
+extern NDT_Status  SDM_FmtMsg_Manager(  NDT_Root  *, NDT_Index_Id, NDT_Node  *, NDT_Command, va_list);
+extern NDT_Status  SDM_Fmt_Manager(     NDT_Root  *, NDT_Index_Id, NDT_Node  *, NDT_Command, va_list);
+extern NDT_Status  SDM_MapCmd_Manager(  NDT_Root  *, NDT_Index_Id, NDT_Node  *, NDT_Command, va_list);
+extern NDT_Status  SDM_MapPath_Manager( NDT_Root  *, NDT_Index_Id, NDT_Node  *, NDT_Command, va_list);
+extern IMRT_Status SDM_MapPath_Proceed( IMRT_Appl_Id  Appl_Id_Target, IMRT_Fmt_Id  Fmt_Id_Target, IMRT_Msg_Id  Msg_Id_Target,
+					IMRT_Appl_Id  ApplId_Src,     IMRT_Fmt_Id  Fmt_Id_Src,    IMRT_Msg_Id  Msg_Id_Src,
+					IMRT_SDMCB_Buffer_Map    *CCB_Buffer_Map_Ptr,
+					IMRT_SDMCB_Buffer_Copy   *CCB_Buffer_Copy_Ptr,
+					IMRT_SDMCB_Buffer_Ident  *CCB_Buffer_Ident_Ptr);
+extern IMRT_Status  SDM_Fmt_Proceed( IMRT_SDMCB_Fmt_Add  *CCB_Fmt_Add_Ptr);
+extern IMRT_Status SDM_BufferInfo_Init(IMRT_SDM_Config  * Lib_Config_Ptr);
+extern IMRT_Status SDM_Close_RootMapPath(void);
+extern IMRT_Status SDM_Close_RootAppl(void);
+extern IMRT_Status SDM_Close_RootFmtAttr(void);
+extern IMRT_Status SDM_Close_RootFmt(void);
+extern IMRT_Status SDM_BufferInfo_DInit(void);
+#   endif
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Local Includes                                                             */
+/*----------------------------------------------------------------------------*/
+
+#   ifdef _BUFFER_INFO_MNG_C_
+
+#       include "buffer_info_xml.h"
+#       include "buffer_info_sql.h"
+
+#   endif
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+
+#endif
diff --git a/src/libstatic_data_mng/src/buffer_info_sql.h b/src/libstatic_data_mng/src/buffer_info_sql.h
new file mode 100644
index 0000000..f7a5644
--- /dev/null
+++ b/src/libstatic_data_mng/src/buffer_info_sql.h
@@ -0,0 +1,113 @@
+/*----------------------------------------------------------------------------*/
+/* File: buffer_info_sql.h 				         	      */
+/*----------------------------------------------------------------------------*/
+/*                                                                            */
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#ifndef _BUFFER_INFO_SQL_H_
+#   define _BUFFER_INFO_SQL_H_
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Global Include                                                             */
+/*----------------------------------------------------------------------------*/
+
+#   include <libstatic_data_mng.h>
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Prototypes                                                                 */
+/*----------------------------------------------------------------------------*/
+
+#   ifdef _BUFFER_INFO_SQL_PC_
+
+IMRT_Status SDM_SQL_BufferInfo_Init();
+IMRT_Status SDM_SQL_Load_FmtAttr(NDT_Root **myRootFmtAttr_Ptr_Ptr);
+IMRT_Status SDM_SQL_Load_Appli(NDT_Root **myRootAppli_Ptr_Ptr);
+IMRT_Status SDM_SQL_Load_Format(NDT_Root  **myRootFormat_Ptr_Ptr);
+IMRT_Status SDM_SQL_LoadFmtMsg(IMRT_Fmt  *myFormat_Ptr);
+IMRT_Status SDM_SQL_Load_MapPath(NDT_Root **myRootMapPath_Ptr_Ptr);
+IMRT_Status SDM_SQL_LoadMapCmd(IMRT_MapPath  *myMapPath_Ptr);
+IMRT_Status SDM_SQL_Load_JumpTable(IMRT_Jump  **JumpTable_Ptr_Ptr, int *JumpTableNbElt_Ptr, IMRT_MapCmd_Id IdMapCmd);
+IMRT_Status SDM_SQL_Dump_FmtAttr_Header(FILE *dump_file);
+IMRT_Status SDM_SQL_Dump_FmtAttr_Body(FILE *dump_file);
+IMRT_Status SDM_SQL_Dump_FmtAttr_Footer(FILE *dump_file);
+IMRT_Status SDM_SQL_Dump_FmtAttr(void);
+IMRT_Status SDM_SQL_Dump_Appli_Header(FILE *dump_file);
+IMRT_Status SDM_SQL_Dump_Appli_Body(FILE *dump_file);
+IMRT_Status SDM_SQL_Dump_Appli_Footer(FILE *dump_file);
+IMRT_Status SDM_SQL_Dump_Appli(void);
+IMRT_Status SDM_SQL_Dump_Format_Header(FILE *dump_file);
+IMRT_Status SDM_SQL_Dump_Format_Body(FILE *dump_file);
+IMRT_Status SDM_SQL_Dump_Format_Footer(FILE *dump_file);
+IMRT_Status SDM_SQL_Dump_Format(void);
+IMRT_Status SDM_SQL_Dump_MapPath_Header(FILE *dump_file);
+IMRT_Status SDM_SQL_Dump_MapPath_Body(FILE *dump_file);
+IMRT_Status SDM_SQL_Dump_MapPath_Footer(FILE *dump_file);
+IMRT_Status SDM_SQL_Dump_MapPath(void);
+IMRT_Status SDM_SQL_BufferInfo_Dump(void);
+
+#   else
+
+extern IMRT_Status SDM_SQL_BufferInfo_Init();
+extern IMRT_Status SDM_SQL_Load_FmtAttr(NDT_Root **myRootFmtAttr_Ptr_Ptr);
+extern IMRT_Status SDM_SQL_Load_Appli(NDT_Root **myRootAppli_Ptr_Ptr);
+extern IMRT_Status SDM_SQL_Load_Format(NDT_Root  **myRootFormat_Ptr_Ptr);
+extern IMRT_Status SDM_SQL_LoadFmtMsg(IMRT_Fmt  *myFormat_Ptr);
+extern IMRT_Status SDM_SQL_Load_MapPath(NDT_Root **myRootMapPath_Ptr_Ptr);
+extern IMRT_Status SDM_SQL_LoadMapCmd(IMRT_MapPath  *myMapPath_Ptr);
+extern IMRT_Status SDM_SQL_Load_JumpTable(IMRT_Jump  **JumpTable_Ptr_Ptr, int *JumpTableNbElt_Ptr, IMRT_MapCmd_Id IdMapCmd);
+extern IMRT_Status SDM_SQL_Dump_FmtAttr_Header(FILE *dump_file);
+extern IMRT_Status SDM_SQL_Dump_FmtAttr_Body(FILE *dump_file);
+extern IMRT_Status SDM_SQL_Dump_FmtAttr_Footer(FILE *dump_file);
+extern IMRT_Status SDM_SQL_Dump_FmtAttr(void);
+extern IMRT_Status SDM_SQL_Dump_Appli_Header(FILE *dump_file);
+extern IMRT_Status SDM_SQL_Dump_Appli_Body(FILE *dump_file);
+extern IMRT_Status SDM_SQL_Dump_Appli_Footer(FILE *dump_file);
+extern IMRT_Status SDM_SQL_Dump_Appli(void);
+extern IMRT_Status SDM_SQL_Dump_Format_Header(FILE *dump_file);
+extern IMRT_Status SDM_SQL_Dump_Format_Body(FILE *dump_file);
+extern IMRT_Status SDM_SQL_Dump_Format_Footer(FILE *dump_file);
+extern IMRT_Status SDM_SQL_Dump_Format(void);
+extern IMRT_Status SDM_SQL_Dump_MapPath_Header(FILE *dump_file);
+extern IMRT_Status SDM_SQL_Dump_MapPath_Body(FILE *dump_file);
+extern IMRT_Status SDM_SQL_Dump_MapPath_Footer(FILE *dump_file);
+extern IMRT_Status SDM_SQL_Dump_MapPath(void);
+extern IMRT_Status SDM_SQL_BufferInfo_Dump(void);
+
+#   endif
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+
+#endif
diff --git a/src/libstatic_data_mng/src/buffer_info_sql.pc b/src/libstatic_data_mng/src/buffer_info_sql.pc
new file mode 100644
index 0000000..4849aed
--- /dev/null
+++ b/src/libstatic_data_mng/src/buffer_info_sql.pc
@@ -0,0 +1,1476 @@
+/*----------------------------------------------------------------------------*/
+/* File: buffer_info_sql.pc   		         		  	      */
+/*----------------------------------------------------------------------------*/
+/*                                                                            */
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#define _LIBSTATIC_DATA_MNG_
+#define _BUFFER_INFO_SQL_PC_
+
+#include "buffer_info_sql.h" 
+
+
+IMRT_Status SDM_SQL_BufferInfo_Init()
+{
+    IMRT_Status  status, StatusTmp;
+   
+	IMRD_LM_LOG_TRACE_0( IMRD_LOG_LEVEL_VERBOSE_0, "Loading FmtAttr...");
+    status = SDM_SQL_Load_FmtAttr(&(IMRG_SDM_Base.RootFmtAttr));
+	if(status == IMRS_OK)
+	{
+		IMRD_LM_LOG_INFO_1( "FmtAtt loaded: (%d)", IMRG_SDM_Base.RootFmtAttr->Index_Tab[NDD_INDEX_PRIMARY].Node_Number);
+
+		IMRD_LM_LOG_TRACE_0( IMRD_LOG_LEVEL_VERBOSE_0, "Loading Fmt...");
+	    status = SDM_SQL_Load_Format(&(IMRG_SDM_Base.RootFmt));
+		if(status == IMRS_OK)
+		{
+			IMRD_LM_LOG_INFO_1( "Fmt loaded: (%d)", IMRG_SDM_Base.RootFmt->Index_Tab[NDD_INDEX_PRIMARY].Node_Number);
+	
+			IMRD_LM_LOG_TRACE_0( IMRD_LOG_LEVEL_VERBOSE_0, "Loading Appl...");
+			status = SDM_SQL_Load_Appli(&(IMRG_SDM_Base.RootAppl));
+			if(status == IMRS_OK)
+			{
+			    IMRD_LM_LOG_INFO_1( "Appl loaded: (%d)", IMRG_SDM_Base.RootAppl->Index_Tab[NDD_INDEX_PRIMARY].Node_Number);
+	
+			    IMRD_LM_LOG_TRACE_0( IMRD_LOG_LEVEL_VERBOSE_0, "Loading MapPath...");
+			    status = SDM_SQL_Load_MapPath(&(IMRG_SDM_Base.RootMapPath));
+				if(status == IMRS_OK)
+				{
+					IMRD_LM_LOG_INFO_1( "MapPath loaded: (%d)", IMRG_SDM_Base.RootMapPath->Index_Tab[NDD_INDEX_PRIMARY].Node_Number);
+				}
+				else
+				{
+					IMRD_LM_LOG_ERROR_0( "Can't load MapPath !");
+					StatusTmp = SDM_Close_RootFmtAttr();
+					StatusTmp = SDM_Close_RootFmt();
+					StatusTmp = SDM_Close_RootAppl();
+				}
+			}
+			else
+			{
+			    IMRD_LM_LOG_ERROR_0( "Can't load Appl !");
+				StatusTmp = SDM_Close_RootFmtAttr();
+				StatusTmp = SDM_Close_RootFmt();
+			}
+		}
+		else
+		{
+			IMRD_LM_LOG_ERROR_0( "Can't load Fmt !");
+			StatusTmp = SDM_Close_RootFmtAttr();
+		}
+	}
+	else
+	{
+		IMRD_LM_LOG_ERROR_0( "Can't load FmtAttr !");
+	}
+
+	return(status);
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status SDM_SQL_Load_FmtAttr(NDT_Root **myRootFmtAttr_Ptr_Ptr)
+{
+	const char sFunctionName []="SDM_SQL_Load_FmtAttr";
+	NDT_Status    nd_status;
+	IMRT_Status   status, statusTmp;
+	NDT_Index_Type  *index_type_ptr;
+	IMRT_FmtAttr    *myFmtAttr;
+	IMRT_Data_Version   *Data_Version_Ptr;
+
+	EXEC SQL BEGIN DECLARE SECTION;
+		IMRT_FmtAttr_Id  hFmtAttrId;
+		VARCHAR       vFmtAttrName[IMRD_FMTATTR_NAME_SIZE];
+		VARCHAR       vFmtAttrValue[IMRD_FMTATTR_VALUE_SIZE];
+		short         hIndFmtAttrId;
+		short         hIndFmtAttrName;
+		short         hIndFmtAttrValue;
+	EXEC SQL END DECLARE SECTION;
+
+
+	/* initialisation */
+	index_type_ptr = FmtAttr_Struct_initial_idx_tab;
+
+	Data_Version_Ptr = (IMRT_Data_Version *) malloc(sizeof(IMRT_Data_Version));
+	status = SDM_SQL_Set_Struct_Version(Data_Version_Ptr, "FmtAttr");
+	if (status != IMRS_OK)
+	{
+		return(IMRS_KO);
+	}
+
+	nd_status = ND_DataStruct_Open(myRootFmtAttr_Ptr_Ptr, IMRD_SDMD_FMTATTR_STRUCT_IDX_NB,index_type_ptr, "SDM_FmtAttr_Manager",SDM_FmtAttr_Manager, NULL, NULL, NULL, NULL,0, Data_Version_Ptr);
+	if(nd_status != NDS_OK)
+	{
+		IMRD_LM_LOG_ERROR_2( "%s : ND_DataStruct_Open  -- SDM_FmtAttr_Manager failed (%d) !", sFunctionName, nd_status);
+		status = IMRS_KO;
+	}
+	else
+	{
+		EXEC SQL DECLARE cur_imr_fmt_attr CURSOR FOR
+			SELECT FMTATTR_ID, FMTATTR_NAME, FMTATTR_VALUE
+			FROM   IMR_FMT_ATTR
+			ORDER BY FMTATTR_ID ASC;
+
+		EXEC SQL OPEN cur_imr_fmt_attr;
+		do
+		{
+			memset(vFmtAttrName.arr, '\0', (size_t) IMRD_FMTATTR_NAME_SIZE);
+			memset(vFmtAttrValue.arr, '\0', (size_t) IMRD_FMTATTR_VALUE_SIZE);
+
+			EXEC SQL FETCH cur_imr_fmt_attr
+			INTO :hFmtAttrId:hIndFmtAttrId,
+			   :vFmtAttrName:hIndFmtAttrName,
+			   :vFmtAttrValue:hIndFmtAttrValue;
+
+			if (sqlca.sqlcode == 0) 
+			{
+				/* creation d'un nouvelle objet FmtAttr */
+				nd_status = ND_Value_Alloc( *myRootFmtAttr_Ptr_Ptr, (void  **)&(myFmtAttr));
+				if(nd_status != NDS_OK)
+				{
+					IMRD_LM_LOG_ERROR_2( "%s : ND_Value_Alloc -- SDM_FmtAttr_Manager  failed (%d) !", sFunctionName, nd_status);
+					status = IMRS_KO;
+				}
+				else
+				{
+					/* Ajout de l'objet Appli */
+					myFmtAttr->Id = hFmtAttrId;
+					if(hIndFmtAttrName >= 0)
+					{
+						strcpy(myFmtAttr->Name, (char *) vFmtAttrName.arr); 
+					}
+
+					if(hIndFmtAttrValue >= 0)
+					{
+						statusTmp = SDM_ConvertAttribute((char *) vFmtAttrValue.arr, myFmtAttr->Value);
+					}
+
+					nd_status = ND_DataStruct_Value_Add( *myRootFmtAttr_Ptr_Ptr, (void  *)(myFmtAttr));
+					if(nd_status != NDS_OK)
+					{
+						IMRD_LM_LOG_ERROR_2( "%s : ND_DataStruct_Value_Add -- SDM_FmtAttr_Manager  failed (%d) !", sFunctionName, nd_status);
+						status = IMRS_KO;
+					}
+				}
+			}
+		} while((sqlca.sqlcode == 0)&&(nd_status == NDS_OK)&&(status == IMRS_OK));
+
+		if (sqlca.sqlcode < 0)
+		{
+			IMRD_LM_LOG_ERROR_3( "Erreur %s. Erreur Oracle : %d - %s !", sFunctionName, sqlca.sqlcode, sqlca.sqlerrm.sqlerrmc);
+			status = IMRS_KO;
+		}
+
+		EXEC SQL CLOSE cur_imr_fmt_attr;
+	}
+
+	if(status == IMRS_OK)
+	{
+		index_type_ptr = FmtAttr_Struct_final_idx_tab;
+		status = SDM_DataStruct_Finalize(*myRootFmtAttr_Ptr_Ptr, index_type_ptr, IMRD_SDMD_FMTATTR_STRUCT_IDX_NB);
+		/*SDM_DataStruct_Dump(*myRootFmtAttr_Ptr_Ptr);*/
+	}
+	else
+	{
+		nd_status = ND_DataStruct_Close(*myRootFmtAttr_Ptr_Ptr);
+		if(nd_status != NDS_OK)
+		{
+			IMRD_LM_LOG_ERROR_1( "ND_DataStruct_Close() failed (%d) !", nd_status);
+			status == IMRS_KO;
+		}
+	}
+
+	return(status);  
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status SDM_SQL_Load_Appli(NDT_Root **myRootAppli_Ptr_Ptr)
+{
+	const char sFunctionName []="SDM_SQL_Load_Appli";
+	NDT_Status    nd_status;
+	IMRT_Status   status;
+	NDT_Index_Type  *index_type_ptr;
+	IMRT_Appl  *myAppli;
+	IMRT_Data_Version   *Data_Version_Ptr;
+
+	EXEC SQL BEGIN DECLARE SECTION;
+		IMRT_Appl_Id  hAppliId;
+		VARCHAR       vAppliName[IMRD_APPL_NAME_SIZE];
+		short         hIndAppliId;
+		short         hIndAppliName;
+	EXEC SQL END DECLARE SECTION;
+
+
+	/* initialisation */
+	index_type_ptr = Appl_Struct_initial_idx_tab;
+
+	Data_Version_Ptr = (IMRT_Data_Version *) malloc(sizeof(IMRT_Data_Version));
+	status = SDM_SQL_Set_Struct_Version(Data_Version_Ptr, "Appl");
+	if (status != IMRS_OK)
+	{
+		return(IMRS_KO);
+	}
+
+	nd_status = ND_DataStruct_Open(myRootAppli_Ptr_Ptr, IMRD_SDMD_APPL_STRUCT_IDX_NB,index_type_ptr, "SDM_Appl_Manager",SDM_Appl_Manager, NULL, NULL, NULL, NULL,0, Data_Version_Ptr);
+	if(nd_status != NDS_OK)
+	{
+		IMRD_LM_LOG_ERROR_2( "%s : ND_DataStruct_Open  -- SDM_Appl_Manager failed (%d) !", sFunctionName, nd_status);
+		status = IMRS_KO;
+	}
+	else
+	{
+		EXEC SQL DECLARE cur_imr_appli CURSOR FOR
+			SELECT APPLI_ID, APPLI_NAME
+			FROM   IMR_APPLI
+			ORDER BY APPLI_ID ASC;
+
+		EXEC SQL OPEN cur_imr_appli;
+		do
+		{
+			memset(vAppliName.arr, '\0', (size_t) IMRD_APPL_NAME_SIZE);
+
+			EXEC SQL FETCH cur_imr_appli
+			INTO :hAppliId:hIndAppliId,
+			   :vAppliName:hIndAppliName;
+
+			if (sqlca.sqlcode == 0) 
+			{
+				/* creation d'un nouvelle objet appli */
+				nd_status = ND_Value_Alloc( *myRootAppli_Ptr_Ptr, (void  **)&(myAppli));
+				if(nd_status != NDS_OK)
+				{
+					IMRD_LM_LOG_ERROR_2( "%s : ND_Value_Alloc -- SDM_Appl_Manager  failed (%d) !", sFunctionName, nd_status);
+					status = IMRS_KO;
+				}
+				else
+				{
+					/* Ajout de l'objet Appli */
+					myAppli->Id = hAppliId;
+					strcpy(myAppli->Name, (char *) vAppliName.arr); 
+
+					nd_status = ND_DataStruct_Value_Add( *myRootAppli_Ptr_Ptr, (void  *)(myAppli));
+					if(nd_status != NDS_OK)
+					{
+						IMRD_LM_LOG_ERROR_2( "%s : ND_DataStruct_Value_Add -- SDM_Appl_Manager  failed (%d) !", sFunctionName, nd_status);
+						status = IMRS_KO;
+					}
+				}
+			}
+		} while((sqlca.sqlcode == 0)&&(nd_status == NDS_OK)&&(status == IMRS_OK));
+
+		if (sqlca.sqlcode < 0)
+		{
+			IMRD_LM_LOG_ERROR_3( "Erreur %s. Erreur Oracle : %d - %s !", sFunctionName, sqlca.sqlcode, sqlca.sqlerrm.sqlerrmc);
+			status = IMRS_KO;
+		}
+
+		EXEC SQL CLOSE cur_imr_appli;
+	}
+
+	if(status == IMRS_OK)
+	{
+		index_type_ptr = Appl_Struct_final_idx_tab;
+		status = SDM_DataStruct_Finalize(*myRootAppli_Ptr_Ptr, index_type_ptr, IMRD_SDMD_APPL_STRUCT_IDX_NB);
+		/*SDM_DataStruct_Dump(*myRootAppli_Ptr_Ptr);*/
+	}
+	else
+	{
+		nd_status = ND_DataStruct_Close(*myRootAppli_Ptr_Ptr);
+		if(nd_status != NDS_OK)
+		{
+			IMRD_LM_LOG_ERROR_1( "ND_DataStruct_Close() failed (%d) !", nd_status);
+			status == IMRS_KO;
+		}
+	}
+
+	return(status);  
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status SDM_SQL_Load_Format(NDT_Root  **myRootFormat_Ptr_Ptr)
+{
+	const char sFunctionName []="SDM_SQL_Load_Format";
+	NDT_Status    nd_status;
+	IMRT_Status   status;
+	NDT_Index_Type  *index_type_ptr;
+	IMRT_Fmt  *myFmt_Ptr;
+	IMRT_Data_Version   *Data_Version_Ptr;
+
+	EXEC SQL BEGIN DECLARE SECTION;
+		IMRT_Fmt_Id  hFormatId;
+		VARCHAR      vFormatName[IMRD_FMT_NAME_SIZE];
+		short        hIndFormatId;
+		short        hIndFormatName;
+	EXEC SQL END DECLARE SECTION;
+	
+	/* initialisation */
+	index_type_ptr = Fmt_Struct_initial_idx_tab;
+
+	Data_Version_Ptr = (IMRT_Data_Version *) malloc(sizeof(IMRT_Data_Version));
+	status = SDM_SQL_Set_Struct_Version(Data_Version_Ptr, "Fmt");
+	if (status != IMRS_OK)
+	{
+		return(IMRS_KO);
+	}
+
+	nd_status = ND_DataStruct_Open(myRootFormat_Ptr_Ptr, IMRD_SDMD_FMT_STRUCT_IDX_NB,index_type_ptr, "SDM_Fmt_Manager",SDM_Fmt_Manager, NULL, NULL, NULL, NULL,0, Data_Version_Ptr);
+	if(nd_status != NDS_OK)
+	{
+		IMRD_LM_LOG_ERROR_2( "%s : ND_DataStruct_Open -- SDM_Fmt_Manager  failed (%d) !", sFunctionName, nd_status);
+		status = IMRS_KO;
+	}
+	else
+	{
+		EXEC SQL DECLARE cur_imr_format CURSOR FOR
+			SELECT FORMAT_ID, FORMAT_NAME
+			FROM   IMR_FORMAT
+			ORDER BY FORMAT_ID ASC;
+
+		EXEC SQL OPEN cur_imr_format;
+		do
+		{
+			memset(vFormatName.arr, '\0', (size_t) IMRD_FMT_NAME_SIZE);
+
+			EXEC SQL FETCH cur_imr_format 
+				INTO :hFormatId:hIndFormatId,
+				     :vFormatName:hIndFormatName;
+			if (sqlca.sqlcode == 0) 
+			{
+				/* creation d'un nouveau objet format */
+				nd_status = ND_Value_Alloc( *myRootFormat_Ptr_Ptr, (void  **)&(myFmt_Ptr));
+				if(nd_status != NDS_OK)
+				{
+					IMRD_LM_LOG_ERROR_2( "%s : ND_Value_Alloc -- SDM_Fmt_Manager  failed (%d) !", sFunctionName, nd_status);
+					status = IMRS_KO;
+				}
+				else
+				{
+					/* Ajout de l'objet Format */
+					myFmt_Ptr->Id = hFormatId;
+					strcpy(myFmt_Ptr->Name, (char *) vFormatName.arr); 
+
+					status = SDM_SQL_LoadFmtMsg(myFmt_Ptr);
+
+					if (status == IMRS_OK)
+					{
+						/* Add   */
+						nd_status = ND_DataStruct_Value_Add( *myRootFormat_Ptr_Ptr, (void  *)(myFmt_Ptr));
+						if(nd_status != NDS_OK)
+						{
+							IMRD_LM_LOG_ERROR_2( "%s : ND_DataStruct_Value_Add -- SDM_Fmt_Manager  failed (%d) !", sFunctionName, nd_status);
+							status = IMRS_KO;
+						}
+					}
+				}
+			}
+		} while((sqlca.sqlcode == 0)&&(nd_status == NDS_OK)&&(status == IMRS_OK));
+
+		if (sqlca.sqlcode < 0)
+		{
+			IMRD_LM_LOG_ERROR_3( "Erreur %s. Erreur Oracle : %d - %s !", sFunctionName, sqlca.sqlcode, sqlca.sqlerrm.sqlerrmc);
+			status = IMRS_KO;
+		}
+
+		EXEC SQL CLOSE cur_imr_format;
+
+		if(status == IMRS_OK)
+		{
+			index_type_ptr = Fmt_Struct_final_idx_tab;
+			status = SDM_DataStruct_Finalize(*myRootFormat_Ptr_Ptr, index_type_ptr, IMRD_SDMD_FMT_STRUCT_IDX_NB);
+			/*SDM_DataStruct_Dump( *myRootFormat_Ptr_Ptr);*/
+		}
+		else
+		{
+            if(myFmt_Ptr->FmtMsg_Struct_Ptr != NULL)
+			{
+                nd_status = ND_DataStruct_Close(myFmt_Ptr->FmtMsg_Struct_Ptr);
+				if(nd_status != NDS_OK)
+				{
+					IMRD_LM_LOG_ERROR_1( "ND_DataStruct_Close() failed (%d) !", nd_status);
+				}
+            }
+			
+			nd_status = ND_DataStruct_Close(*myRootFormat_Ptr_Ptr);
+			if(nd_status != NDS_OK)
+			{
+				IMRD_LM_LOG_ERROR_1( "ND_DataStruct_Close() failed (%d) !", nd_status);
+			}
+		}
+	}
+  
+	return(status);  
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status SDM_SQL_LoadFmtMsg(IMRT_Fmt  *myFormat_Ptr)
+{
+	const char sFunctionName []="SDM_SQL_LoadFmtMsg";
+	NDT_Status    nd_status;
+	IMRT_Status   status, statusTmp;
+	NDT_Node     *node_ptr;
+	IMRT_Msg      message;
+	IMRT_FmtMsg  *myFmtMsg_Ptr;
+	IMRT_FmtAttr  fmtattr;
+
+	EXEC SQL BEGIN DECLARE SECTION;
+		IMRT_Msg_Id      hMsgId;
+		IMRT_FmtAttr_Id  hFmtAttrId;
+		IMRT_Branche_Id  hFmtMsgBrancheId;
+
+		short            hIndMsgId;
+		short            hIndFmtAttrId;
+		short            hIndFmtMsgBrancheId;
+	EXEC SQL END DECLARE SECTION;
+
+	
+	status = IMRS_OK;
+
+	EXEC SQL DECLARE cur_imr_fmt_msg CURSOR FOR
+		SELECT MSG_ID, FMTATTR_ID, FMTMSG_BRANCHE_ID
+		FROM   IMR_FMT_MSG
+		WHERE  FORMAT_ID = :myFormat_Ptr->Id
+		ORDER BY NUM_ORDRE_FMT_MSG ASC;
+
+	EXEC SQL OPEN cur_imr_fmt_msg;
+	do
+	{
+		EXEC SQL FETCH cur_imr_fmt_msg 
+				INTO :hMsgId:hIndMsgId,
+					 :hFmtAttrId:hIndFmtAttrId,
+					 :hFmtMsgBrancheId:hIndFmtMsgBrancheId;
+		if (sqlca.sqlcode == 0) 
+		{
+			/* Allacation de ListField */
+			nd_status = ND_Value_Alloc( myFormat_Ptr->FmtMsg_Struct_Ptr, (void  **)&(myFmtMsg_Ptr)); 
+			if (nd_status != NDS_OK)
+			{
+				IMRD_LM_LOG_ERROR_2( "%s : ND_Value_Alloc  -- Field failed (%d) !", sFunctionName, nd_status);
+				status = IMRS_KO;
+			}
+			else
+			{
+				/*recherch du message avec le nom*/
+				message.Id = hMsgId;
+				nd_status = ND_Index_Node_Find( &node_ptr, IMRG_SDM_Base.RootMsg,
+				                               IMRD_SDMD_MSG_IDX_ID, &message, NULL);
+				if((nd_status != NDS_OK)||(node_ptr == NULL))
+				{
+					IMRD_LM_LOG_ERROR_1( "Erreur lors de la recherche Message  <%d> !", message.Id);
+					status = IMRS_KO;
+				}
+				else
+				{
+					myFmtMsg_Ptr->Msg_Ptr = node_ptr->Value;
+				}
+
+				if(status == IMRS_OK)
+				{
+					if(hIndFmtMsgBrancheId >= 0)
+					{
+						myFmtMsg_Ptr->Branche_Id = hFmtMsgBrancheId;
+					}
+
+					if(hIndFmtAttrId >= 0)
+					{
+						fmtattr.Id = hFmtAttrId;
+						nd_status = ND_Index_Node_Find( &node_ptr, IMRG_SDM_Base.RootFmtAttr,
+						                               IMRD_SDMD_FMTATTR_IDX_ID, &fmtattr, NULL);
+						if((nd_status != NDS_OK)||(node_ptr == NULL))
+						{
+							IMRD_LM_LOG_ERROR_1( "Erreur lors de la recherche du FmtAttr  <%d> !", fmtattr.Id);
+							status = IMRS_KO;
+						}
+						else
+						{
+							myFmtMsg_Ptr->FmtAttr_Ptr = node_ptr->Value;
+						}
+					}
+
+					if(status == IMRS_OK)
+					{
+						nd_status = ND_DataStruct_Value_Add( myFormat_Ptr->FmtMsg_Struct_Ptr, (void  *)(myFmtMsg_Ptr));
+						if(nd_status != NDS_OK)
+						{
+							IMRD_LM_LOG_ERROR_1( "ND_Value_Add() failed (%d) !", nd_status);
+							status = IMRS_KO;
+						}
+					}
+				}
+			}
+		}
+	} while((sqlca.sqlcode == 0)&&(nd_status == NDS_OK)&&(status == IMRS_OK));
+
+	if (sqlca.sqlcode < 0)
+	{
+		IMRD_LM_LOG_ERROR_3( "Erreur %s. Erreur Oracle : %d - %s !", sFunctionName, sqlca.sqlcode, sqlca.sqlerrm.sqlerrmc);
+		status = IMRS_KO;
+	}
+
+	EXEC SQL CLOSE cur_imr_fmt_msg;
+
+	if(status != IMRS_OK)
+	{
+		free(myFmtMsg_Ptr);
+	}
+	/*if(status != IMRS_OK)
+	{
+		nd_status = ND_Value_Free(myFormat_Ptr->FmtMsg_Struct_Ptr, (void  **)&(myFmtMsg_Ptr));
+		printf("1111111   %d  pointer %lx\n", nd_status, myFmtMsg_Ptr);
+	}*/
+
+	return(status);  
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status SDM_SQL_Load_MapPath(NDT_Root **myRootMapPath_Ptr_Ptr)
+{
+  const char sFunctionName []="SDM_SQL_Load_MapPath";
+  NDT_Status    nd_status;
+  IMRT_Status   status;
+  NDT_Index_Type  *index_type_ptr;
+  IMRT_MapPath   *myMapPath_Ptr;
+  NDT_Node       *node_ptr;
+  IMRT_MsgMap    msgmap;
+  IMRT_Appl      appli;
+  IMRT_Fmt       fmt;
+  IMRT_Msg       msg;
+  IMRT_Data_Version   *Data_Version_Ptr;
+
+  EXEC SQL BEGIN DECLARE SECTION;
+      short   hMapPathId;
+      IMRT_Fmt_Id hFormatInId;
+      IMRT_Fmt_Id hFormatOutId;
+      IMRT_Appl_Id hAppliInId;
+      IMRT_Appl_Id hAppliOutId;
+      short   hIndMapPathId;
+      short   hIndFormatInId;
+      short   hIndFormatOutId;
+      short   hIndAppliInId;
+      short   hIndAppliOutId;
+  EXEC SQL END DECLARE SECTION;
+
+  /*initialisation des indexes*/
+  index_type_ptr = index_type_initial_tab;
+
+  Data_Version_Ptr = (IMRT_Data_Version *) malloc(sizeof(IMRT_Data_Version));
+  status = SDM_SQL_Set_Struct_Version(Data_Version_Ptr, "MapPath");
+  if (status != IMRS_OK)
+  {
+  	return(IMRS_KO);
+  }
+
+  nd_status = ND_DataStruct_Open(myRootMapPath_Ptr_Ptr, IMRD_SDMD_INDEX_NB, index_type_ptr, "SDM_MapPath_Manager",SDM_MapPath_Manager, NULL, NULL, NULL, NULL,0, Data_Version_Ptr);
+  if(nd_status != NDS_OK)
+  {
+    IMRD_LM_LOG_ERROR_2( "%s : ND_DataStruct_Open -- SDM_MapPath_Manager  failed (%d) !", sFunctionName, nd_status);
+    return(IMRS_KO);
+  }
+  else
+  {
+    EXEC SQL DECLARE cur_imr_map_path CURSOR FOR
+    	SELECT MAP_PATH_ID, APPLI_IN_ID, APPLI_OUT_ID, FORMAT_IN_ID, FORMAT_OUT_ID
+    	FROM IMR_MAPPATH
+    	ORDER BY MAP_PATH_ID ASC;
+
+    EXEC SQL OPEN cur_imr_map_path;
+    do
+    {
+
+      EXEC SQL FETCH cur_imr_map_path
+      		INTO :hMapPathId:hIndMapPathId,
+      		     :hAppliInId:hIndAppliInId,
+      		     :hAppliOutId:hIndAppliOutId,
+      		     :hFormatInId:hIndFormatInId,
+      		     :hFormatOutId:hIndFormatOutId;
+      if (sqlca.sqlcode == 0) 
+      {
+        nd_status = ND_Value_Alloc( *myRootMapPath_Ptr_Ptr, (void  **)&(myMapPath_Ptr));
+        if(nd_status != NDS_OK)
+        {
+          IMRD_LM_LOG_ERROR_2( "%s : ND_Value_Alloc -- SDM_MapPath_Manager  failed (%d) !", sFunctionName, nd_status);
+          return(IMRS_KO);
+        }
+        else
+        {
+          myMapPath_Ptr->idMapPath = hMapPathId;
+          /*   APPLI IN  */
+          appli.Id = hAppliInId;
+          nd_status = ND_Index_Node_Find( &node_ptr, IMRG_SDM_Base.RootAppl,
+                                      IMRD_SDMD_APPL_IDX_ID, &appli, NULL);
+          if((nd_status != NDS_OK)||(node_ptr == NULL))
+          {
+            IMRD_LM_LOG_ERROR_1( "Erreur lors de la recherche du IN Appli <%d> !", appli.Id);
+            return(IMRS_KO);
+          }
+          else
+          {
+            myMapPath_Ptr->Appl_Input_Ptr = node_ptr->Value;
+          }
+          /*   APPLI OUT  */
+          appli.Id = hAppliOutId;
+          nd_status = ND_Index_Node_Find( &node_ptr, IMRG_SDM_Base.RootAppl,
+                                      IMRD_SDMD_APPL_IDX_ID, &appli, NULL);
+          if((nd_status != NDS_OK)||(node_ptr == NULL))
+          {
+            IMRD_LM_LOG_ERROR_1( "Erreur lors de la recherche du OUT Appli <%d> !", appli.Id);
+            return(IMRS_KO);
+          }
+          else
+          {
+            myMapPath_Ptr->Appl_Output_Ptr = node_ptr->Value;
+          }
+          /*   FORMAT IN   */
+          fmt.Id = hFormatInId;
+          nd_status = ND_Index_Node_Find( &node_ptr, IMRG_SDM_Base.RootFmt,
+                                      IMRD_SDMD_FMT_IDX_ID, &fmt, NULL);
+          if((nd_status != NDS_OK)||(node_ptr == NULL))
+          {
+            IMRD_LM_LOG_ERROR_1( "Erreur lors de la recherche du Format IN <%d> !", fmt.Id);
+            return(IMRS_KO);
+          }
+          else
+          {
+            myMapPath_Ptr->Fmt_Input_Ptr = node_ptr->Value;
+          }
+          /*   FORMAT OUT   */
+          fmt.Id = hFormatOutId;
+          nd_status = ND_Index_Node_Find( &node_ptr, IMRG_SDM_Base.RootFmt,
+                                      IMRD_SDMD_FMT_IDX_ID, &fmt, NULL);
+          if((nd_status != NDS_OK)||(node_ptr == NULL))
+          {
+            IMRD_LM_LOG_ERROR_1( "Erreur lors de la recherche du Format OUT <%d> !", fmt.Id);
+            return(IMRS_KO);
+          }
+          else
+          {
+            myMapPath_Ptr->Fmt_Output_Ptr = node_ptr->Value;
+          }
+
+          status = SDM_SQL_LoadMapCmd(myMapPath_Ptr);
+          if (status == IMRS_OK)
+          {
+            /*** Add  ***/
+            nd_status = ND_DataStruct_Value_Add(*myRootMapPath_Ptr_Ptr, (void  *)(myMapPath_Ptr));
+            if(nd_status != NDS_OK)
+            {
+              IMRD_LM_LOG_ERROR_2( "%s : ND_DataStruct_Value_Add -- SDM_MapPath_Manager  failed (%d) !", sFunctionName, nd_status);
+              return(IMRS_KO);
+            }
+          }
+        }
+      }
+    } while((sqlca.sqlcode == 0)&&(nd_status == NDS_OK)&&(status == IMRS_OK));
+
+    if (sqlca.sqlcode < 0)
+    {
+      IMRD_LM_LOG_ERROR_3( "Erreur %s. Erreur Oracle : %d - %s !", sFunctionName, sqlca.sqlcode, sqlca.sqlerrm.sqlerrmc);
+      status = IMRS_KO;
+    }
+
+    EXEC SQL CLOSE cur_imr_map_path;
+
+    if(status == IMRS_OK)
+    {
+      /*SDM_DataStruct_Dump(*myRootMapPath_Ptr_Ptr);*/
+    }
+    else
+    {
+      if(myMapPath_Ptr->MapCmd_Struct_Ptr != NULL)
+      {
+        nd_status = ND_DataStruct_Close(myMapPath_Ptr->MapCmd_Struct_Ptr);
+        if(nd_status != NDS_OK)
+        {
+          IMRD_LM_LOG_ERROR_1( "ND_DataStruct_Close() failed (%d) !", nd_status);
+        }
+      }
+
+      nd_status = ND_DataStruct_Close(*myRootMapPath_Ptr_Ptr);
+      if(nd_status != NDS_OK)
+      {
+        IMRD_LM_LOG_ERROR_1( "ND_DataStruct_Close() failed (%d) !", nd_status);
+      }
+    }
+  }
+
+  return(status);
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status SDM_SQL_LoadMapCmd(IMRT_MapPath  *myMapPath_Ptr)
+
+{
+  const char sFunctionName []="SDM_SQL_LoadMapCmd";
+  NDT_Status    nd_status;
+  IMRT_Status   status, statusTmp;
+  NDT_Index_Type  *index_type_ptr;
+  NDT_Node     *node_ptr;
+  IMRT_MapCmd  *myMapCmd_Ptr;
+  IMRT_MsgMap  msgmap;
+  IMRT_Fmt     fmt;
+  IMRT_Msg     Msg;
+  int		   myJumpTableNbElt;
+  IMRT_Jump    myJumpTable;
+  IMRT_FmtAttr  fmtattr;
+
+  EXEC SQL BEGIN DECLARE SECTION;
+     short   hMapCmdId;
+     short   hMapCmdType;
+     IMRT_MapCmd_Branch_Id  hCurrentBrancheId;
+     short   hCopyBufferIdInput;
+     short   hCopyBufferIdOutput;
+     IMRT_Fmt_Id      hFormatInId;
+     IMRT_FmtAttr_Id  hFmtAttrInId;
+     IMRT_Fmt_Id      hFormatOutId;
+     IMRT_FmtAttr_Id  hFmtAttrOutId;
+     IMRT_MsgMap_Id hMsgMapId;
+     short   hMapBufferIdInput;
+     short   hMapBufferIdOutput;
+     short   hClearFlag;
+     short   hBufferIdIdent;
+     char    IdentTotal;
+     IMRT_Msg_Id  hIdentFirstMsgId;
+     IMRT_MapCmd_Branch_Id  hGotoBrancheId;
+
+     short   hIndMapCmdId;
+     short   hIndMapCmdType;
+     short   hIndCurrentBrancheId;
+     short   hIndCopyBufferIdInput;
+     short   hIndCopyBufferIdOutput;
+     short   hIndFormatInId;
+     short   hIndFmtAttrInId;
+     short   hIndFormatOutId;
+     short   hIndFmtAttrOutId;
+     short   hIndMsgMapId;
+     short   hIndMapBufferIdInput;
+     short   hIndMapBufferIdOutput;
+     short   hIndClearFlag;
+     short   hIndBufferIdIdent;
+     short   hIndIdentTotal;
+     short   hIndIdentFirstMsgId;
+     short   hIndGotoBrancheId;
+  EXEC SQL END DECLARE SECTION;
+
+  /*initialisation des indexes*/
+  index_type_ptr = index_type_initial_tab;
+  status = IMRS_OK;
+  myJumpTableNbElt = 0;
+
+  EXEC SQL DECLARE cur_imr_cmd_map_path CURSOR FOR
+  	SELECT A.MAPCMD_ID, B.MAPCMD_TYPE, B.CURRENT_BRANCHE_ID, 
+  	       C.COPY_BUFFER_ID_INPUT, C.COPY_BUFFER_ID_OUTPUT,
+  	       D.FORMAT_IN_ID, D.FMTATTR_IN_ID, D.FORMAT_OUT_ID, D.FMTATTR_OUT_ID, 
+  	       D.MSG_MAP_ID, D.MAP_BUFFER_ID_INPUT, D.MAP_BUFFER_ID_OUTPUT, D.CLEAR_FLAG,
+  	       F.IDENT_BUFFER_ID, F.IDENT_TOTAL, F.IDENT_FIRST_MSG_ID, G.GOTO_BRANCHE_ID
+    	FROM   IMR_CMD_MAP_PATH A, IMR_MAPCMD B, IMR_CMD_COPY C, 
+    	       IMR_CMD_MAP D, IMR_CMD_IDENT F, IMR_CMD_GOTO G
+    	WHERE  A.MAPCMD_ID = B.MAPCMD_ID
+    	AND    B.MAPCMD_ID = C.MAPCMD_ID(+)
+    	AND    B.MAPCMD_ID = D.MAPCMD_ID(+)
+    	AND    B.MAPCMD_ID = F.MAPCMD_ID(+)
+    	AND    B.MAPCMD_ID = G.MAPCMD_ID(+)
+    	AND    A.MAP_PATH_ID = :myMapPath_Ptr->idMapPath
+    	ORDER BY A.MAPCMD_ID ASC;
+
+  EXEC SQL OPEN cur_imr_cmd_map_path;
+  do
+  {
+
+    EXEC SQL FETCH cur_imr_cmd_map_path 
+    		INTO :hMapCmdId:hIndMapCmdId,
+    		     :hMapCmdType:hIndMapCmdType,
+    		     :hCurrentBrancheId:hIndCurrentBrancheId,
+    		     :hCopyBufferIdInput:hIndCopyBufferIdInput,
+    		     :hCopyBufferIdOutput:hIndCopyBufferIdOutput,
+    		     :hFormatInId:hIndFormatInId,
+    		     :hFmtAttrInId:hIndFmtAttrInId,
+    		     :hFormatOutId:hIndFormatOutId,
+    		     :hFmtAttrOutId:hIndFmtAttrOutId,
+    		     :hMsgMapId:hIndMsgMapId,
+    		     :hMapBufferIdInput:hIndMapBufferIdInput,
+    		     :hMapBufferIdOutput:hIndMapBufferIdOutput,
+    		     :hClearFlag:hIndClearFlag,
+    		     :hBufferIdIdent:hIndBufferIdIdent,
+    		     :IdentTotal:hIndIdentTotal,
+    		     :hIdentFirstMsgId:hIndIdentFirstMsgId,
+    		     :hGotoBrancheId:hIndGotoBrancheId;
+
+    if (sqlca.sqlcode == 0) 
+    {
+      /* Alloc */
+      nd_status = ND_Value_Alloc( myMapPath_Ptr->MapCmd_Struct_Ptr, (void  **)&(myMapCmd_Ptr));
+      if(nd_status != NDS_OK)
+      {
+        IMRD_LM_LOG_ERROR_2( "%s : ND_Value_Alloc -- MapCmd  failed (%d) !", sFunctionName, nd_status);
+        status = IMRS_KO;
+      }
+      else
+      {
+        /* Add */
+        /********************************************************/
+        myMapCmd_Ptr->MapCmd_Id = hMapCmdId;
+        myMapCmd_Ptr->TypeCmd = hMapCmdType;
+        if (hIndCurrentBrancheId >= 0)
+          myMapCmd_Ptr->Branche_Id = hCurrentBrancheId;
+        if (hMapCmdType == IMRD_MAPCMD_TYPE_MAP)
+        {
+          if (hIndMapBufferIdInput >= 0)
+            myMapCmd_Ptr->Buffer_Id_Input = hMapBufferIdInput; 
+          if (hIndMapBufferIdOutput >= 0)
+            myMapCmd_Ptr->Buffer_Id_Output = hMapBufferIdOutput; 
+        }
+        else if (hMapCmdType == IMRD_MAPCMD_TYPE_COPY)
+             {
+               if (hIndCopyBufferIdInput >= 0)
+                 myMapCmd_Ptr->Buffer_Id_Input = hCopyBufferIdInput; 
+               if (hIndCopyBufferIdOutput >= 0)
+                 myMapCmd_Ptr->Buffer_Id_Output = hCopyBufferIdOutput; 
+             }
+        if (hIndClearFlag >= 0)
+          myMapCmd_Ptr->Clear_Flag = hClearFlag; 
+        if (hIndBufferIdIdent >= 0)
+          myMapCmd_Ptr->Buffer_Id_Ident = hBufferIdIdent;
+        if (hIndIdentTotal >= 0)
+        {
+          if (IdentTotal == IMRD_YES)
+            myMapCmd_Ptr->Ident_Total = IMRD_TRUE;
+          else
+            myMapCmd_Ptr->Ident_Total = IMRD_FALSE;
+        }
+		if (hIndIdentFirstMsgId >= 0)
+		{
+			Msg.Id = hIdentFirstMsgId;
+			nd_status = ND_Index_Node_Find( &node_ptr, IMRG_SDM_Base.RootMsg,
+			                          IMRD_SDMD_MSG_IDX_ID, &Msg, NULL);
+			if((nd_status != NDS_OK)||(node_ptr == NULL))
+			{
+				IMRD_LM_LOG_ERROR_1( "Erreur lors de la recherche du Message <%d> !", Msg.Id);
+				status = IMRS_KO;
+			}
+			else
+			{
+				myMapCmd_Ptr->Ident_First_Msg_Ptr = node_ptr->Value;
+			}
+		}
+
+        /********************************************************/
+
+        if (hMapCmdType == IMRD_MAPCMD_TYPE_GOTO)
+        {
+			myMapCmd_Ptr->Goto_Branche_Id = hGotoBrancheId;
+		}
+
+        if (hMapCmdType == IMRD_MAPCMD_TYPE_MAP)
+        {
+          /*   FORMAT IN   */
+          fmt.Id = hFormatInId;
+          nd_status = ND_Index_Node_Find( &node_ptr, IMRG_SDM_Base.RootFmt,
+                                      IMRD_SDMD_FMT_IDX_ID, &fmt, NULL);
+          if((nd_status != NDS_OK)||(node_ptr == NULL))
+          {
+            IMRD_LM_LOG_ERROR_1( "Erreur lors de la recherche du Format IN <%d> !", fmt.Id);
+            status = IMRS_KO;
+          }
+          else
+          {
+            myMapCmd_Ptr->Fmt_Input_Ptr = node_ptr->Value;
+          }
+
+          if (hIndFmtAttrInId >= 0)
+          {
+	          fmtattr.Id = hFmtAttrInId;
+	          nd_status = ND_Index_Node_Find( &node_ptr, IMRG_SDM_Base.RootFmtAttr,
+	                                      IMRD_SDMD_FMTATTR_IDX_ID, &fmtattr, NULL);
+	          if((nd_status != NDS_OK)||(node_ptr == NULL))
+	          {
+	            IMRD_LM_LOG_ERROR_1( "Erreur lors de la recherche du FmtAttr IN <%d> !", fmtattr.Id);
+	            status = IMRS_KO;
+	          }
+	          else
+	          {
+	            myMapCmd_Ptr->FmtAttr_Input_Ptr = node_ptr->Value;
+	          }
+          }
+          /*   FORMAT OUT   */
+          fmt.Id = hFormatOutId;
+          nd_status = ND_Index_Node_Find( &node_ptr, IMRG_SDM_Base.RootFmt,
+                                      IMRD_SDMD_FMT_IDX_ID, &fmt, NULL);
+          if((nd_status != NDS_OK)||(node_ptr == NULL))
+          {
+            IMRD_LM_LOG_ERROR_1( "Erreur lors de la recherche du Format OUT <%d> !", fmt.Id);
+            status = IMRS_KO;
+          }
+          else
+          {
+            myMapCmd_Ptr->Fmt_Output_Ptr = node_ptr->Value;
+          }
+
+          if (hIndFmtAttrOutId >= 0)
+          {
+	          fmtattr.Id = hFmtAttrOutId;
+	          nd_status = ND_Index_Node_Find( &node_ptr, IMRG_SDM_Base.RootFmtAttr,
+	                                      IMRD_SDMD_FMTATTR_IDX_ID, &fmtattr, NULL);
+	          if((nd_status != NDS_OK)||(node_ptr == NULL))
+	          {
+	            IMRD_LM_LOG_ERROR_1( "Erreur lors de la recherche du FmtAttr OUT <%d> !", fmtattr.Id);
+	            status = IMRS_KO;
+	          }
+	          else
+	          {
+	            myMapCmd_Ptr->FmtAttr_Output_Ptr = node_ptr->Value;
+	          }
+          }
+          /*   MsgMap   */
+          msgmap.Id = hMsgMapId;
+          nd_status = ND_Index_Node_Find( &node_ptr, IMRG_SDM_Base.RootMsgMap,
+                                      IMRD_SDMD_MSGMAP_IDX_ID, &msgmap, NULL);
+          if((nd_status != NDS_OK)||(node_ptr == NULL))
+          {
+            IMRD_LM_LOG_ERROR_1( "Erreur lors de la recherche du MSGMAP <%d> !", msgmap.Id);
+            status = IMRS_KO;
+          }
+          else
+          {
+            myMapCmd_Ptr->MsgMap_Ptr = node_ptr->Value;
+          }
+        }
+        /***********    Jump Table    ************/
+        if((hMapCmdType == IMRD_MAPCMD_TYPE_IDENT)&&(status == IMRS_OK))
+        {
+          status = SDM_SQL_Load_JumpTable(&(myMapCmd_Ptr->Jump_Tab), &myJumpTableNbElt, hMapCmdId);
+	  	  if (status != IMRS_OK)
+	      {
+	        IMRD_LM_LOG_ERROR_1( "Erreur lors du chargement de la Jump Table : <%d> !", status);
+	      }
+	      else
+	      {
+	      	myMapCmd_Ptr->JmpTbleNbElts = myJumpTableNbElt;
+	      }
+        }
+
+        nd_status = ND_DataStruct_Value_Add( myMapPath_Ptr->MapCmd_Struct_Ptr, (void  *)(myMapCmd_Ptr));
+        if(nd_status != NDS_OK)
+        {
+          IMRD_LM_LOG_ERROR_2( "%s : ND_DataStruct_Value_Add -- MapCmd  failed (%d) !", sFunctionName, nd_status);
+          status = IMRS_KO;
+        }
+      }
+    }
+  } while((sqlca.sqlcode == 0)&&(nd_status == NDS_OK)&&(status == IMRS_OK));
+
+  if(status != IMRS_OK)
+  {
+	free(myMapCmd_Ptr);
+  }
+
+  if (sqlca.sqlcode < 0)
+  {
+    IMRD_LM_LOG_ERROR_3( "Erreur %s. Erreur Oracle : %d - %s !", sFunctionName, sqlca.sqlcode, sqlca.sqlerrm.sqlerrmc);
+    status = IMRS_KO;
+  }
+
+  EXEC SQL CLOSE cur_imr_cmd_map_path;
+
+  return(status);  
+  
+}
+
+
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status SDM_SQL_Load_JumpTable(IMRT_Jump  **JumpTable_Ptr_Ptr, int * JumpTableNbElt_Ptr ,IMRT_MapCmd_Id IdMapCmd)
+{
+  IMRT_Status     status;
+  NDT_Status      nd_status;
+  const char sFunctionName []="SDM_SQL_Load_JumpTable";
+
+  EXEC SQL BEGIN DECLARE SECTION;
+     IMRT_Msg_Id  hMsgId;
+     IMRT_Fmt_Id  hFormatId;
+     short   hBrancheIdIdent;
+     short   hIndMsgId;
+     short   hIndFormatId;
+     short   hIndBrancheIdIdent;
+  EXEC SQL END DECLARE SECTION;
+
+  IMRT_Fmt    fmt;
+  IMRT_Msg    msg;
+  NDT_Node    *node_ptr;
+  IMRT_Jump   *jump_ptr;
+  short   IndexTable;
+	
+  status = IMRS_OK;
+  IndexTable = -1;
+  jump_ptr = NULL;
+  
+  EXEC SQL DECLARE cur_imr_jump_table CURSOR FOR
+  	SELECT MSG_ID, FORMAT_ID, IDENT_BRANCHE_ID 
+    FROM   IMR_JUMP_TABLE
+    WHERE  MAPCMD_ID = :IdMapCmd
+    ORDER BY NUM_ORDRE_JUMP ASC;
+
+  EXEC SQL OPEN cur_imr_jump_table;
+  do
+  {
+
+    EXEC SQL FETCH cur_imr_jump_table 
+    		INTO :hMsgId:hIndMsgId,
+    		     :hFormatId:hIndFormatId, 
+    		     :hBrancheIdIdent:hIndBrancheIdIdent; 
+
+    if (sqlca.sqlcode == 0) 
+    {
+      IndexTable = IndexTable + 1;
+	  *JumpTableNbElt_Ptr = IndexTable + 1;
+  	  jump_ptr = (IMRT_Jump *)realloc((void *)*JumpTable_Ptr_Ptr , 
+  									(size_t)((IndexTable + 1) * sizeof(IMRT_Jump)));
+  	  if (jump_ptr == NULL)
+	  {
+          IMRD_LM_LOG_ERROR_0( "Erreur lors de la reallocation de la Jump Table !");
+          return(IMRS_KO);
+      }
+	  else
+	  {  
+	      *JumpTable_Ptr_Ptr = jump_ptr;
+	      if (hIndBrancheIdIdent >= 0)
+	        (*JumpTable_Ptr_Ptr)[IndexTable].Branche_Id = hBrancheIdIdent;
+	  }
+
+      /*   FORMAT   */
+      fmt.Id = hFormatId;
+      nd_status = ND_Index_Node_Find( &node_ptr, IMRG_SDM_Base.RootFmt,
+                                      IMRD_SDMD_FMT_IDX_ID, &fmt, NULL);
+      if((nd_status != NDS_OK)||(node_ptr == NULL))
+      {
+          IMRD_LM_LOG_ERROR_1( "Erreur lors de la recherche Message  <%d> !", fmt.Id);
+          return(IMRS_KO);
+      }
+      else
+      {
+         (*JumpTable_Ptr_Ptr)[IndexTable].Fmt_Ptr = node_ptr->Value;
+      }
+      /*    Msg  */
+      msg.Id = hMsgId;
+      nd_status = ND_Index_Node_Find( &node_ptr, IMRG_SDM_Base.RootMsg,
+                                      IMRD_SDMD_MSG_IDX_ID, &msg, NULL);
+      if((nd_status != NDS_OK)||(node_ptr == NULL))
+      {
+          IMRD_LM_LOG_ERROR_1( "Erreur lors de la recherche Message  <%d> !", msg.Id);
+          return(IMRS_KO);
+      }
+      else
+      {
+        (*JumpTable_Ptr_Ptr)[IndexTable].Msg_Ptr = node_ptr->Value;
+      }
+    }
+  } while((sqlca.sqlcode == 0)&&(nd_status == NDS_OK));
+
+  if (sqlca.sqlcode < 0)
+  {
+    IMRD_LM_LOG_ERROR_3( "Erreur %s. Erreur Oracle : %d - %s !", sFunctionName, sqlca.sqlcode, sqlca.sqlerrm.sqlerrmc);
+    status = IMRS_KO;
+  }
+
+  EXEC SQL CLOSE cur_imr_jump_table;
+
+
+  return(status);
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  SDM_SQL_Dump_FmtAttr_Header(FILE *dump_file)
+{
+	fprintf(dump_file, "---------------------------------------------------\n");
+	fprintf(dump_file, "--  Init file of IMR_FMT_ATTR                    --\n");
+	fprintf(dump_file, "---------------------------------------------------\n\n");
+	fprintf(dump_file, "INSERT INTO IMR_DATA_VERSION(VERS_NAME, VERS_LABEL, VERS_DATE) VALUES('FmtAttr', '%s', '%s');\n\n",
+						((IMRT_Data_Version *)(IMRG_SDM_Base.RootFmtAttr->User_Ptr))->Label,
+						((IMRT_Data_Version *)(IMRG_SDM_Base.RootFmtAttr->User_Ptr))->Date);
+	fprintf(dump_file, "Delete IMR_FMT_ATTR;\n\n");
+	return( IMRS_OK);
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  SDM_SQL_Dump_FmtAttr_Body(FILE *dump_file)
+{
+	IMRT_Status  status;
+	NDT_Status  nd_status;
+
+	if( ( nd_status = ND_DataStruct_Traverse( IMRG_SDM_Base.RootFmtAttr, IMRD_SDMD_CMD_API_SQL_DUMP, dump_file)) != NDS_OK)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0( "SQL Dump RootFmtAttr failed !");
+	}
+	else
+	{
+		status = IMRS_OK;
+	}
+
+	return(status);
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  SDM_SQL_Dump_FmtAttr_Footer(FILE *dump_file)
+{
+	fprintf(dump_file, "\nCommit;\n");
+	return( IMRS_OK);
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  SDM_SQL_Dump_FmtAttr(void)
+{
+	IMRT_Status     status;
+	char	    dump_filename[255];
+	FILE	   *dump_file;
+
+	strcpy(dump_filename, "init_imr_fmt_attr.sql");
+
+	if( ( dump_file = fopen( dump_filename, "w")) == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_1( "Can't open dump file (%s) !", dump_filename);
+	}
+	else
+	{
+		status = SDM_SQL_Dump_FmtAttr_Header(dump_file);
+		if(status == IMRS_OK)
+		{
+			status = SDM_SQL_Dump_FmtAttr_Body(dump_file);
+			if(status == IMRS_OK)
+			{
+				status = SDM_SQL_Dump_FmtAttr_Footer(dump_file);
+			}
+		}
+
+		fclose( dump_file);
+	}
+
+	return(status);
+
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  SDM_SQL_Dump_Appli_Header(FILE *dump_file)
+{
+	fprintf(dump_file, "---------------------------------------------------\n");
+	fprintf(dump_file, "--  Init file of IMR_APPLI                       --\n");
+	fprintf(dump_file, "---------------------------------------------------\n\n");
+	fprintf(dump_file, "INSERT INTO IMR_DATA_VERSION(VERS_NAME, VERS_LABEL, VERS_DATE) VALUES('Appl', '%s', '%s');\n\n",
+						((IMRT_Data_Version *)(IMRG_SDM_Base.RootAppl->User_Ptr))->Label,
+						((IMRT_Data_Version *)(IMRG_SDM_Base.RootAppl->User_Ptr))->Date);
+	fprintf(dump_file, "Delete IMR_APPLI;\n\n");
+	return( IMRS_OK);
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  SDM_SQL_Dump_Appli_Body(FILE *dump_file)
+{
+	IMRT_Status  status;
+	NDT_Status  nd_status;
+
+	if( ( nd_status = ND_DataStruct_Traverse( IMRG_SDM_Base.RootAppl, IMRD_SDMD_CMD_API_SQL_DUMP, dump_file)) != NDS_OK)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0( "SQL Dump RootAppl failed !");
+	}
+	else
+	{
+		status = IMRS_OK;
+	}
+
+	return(status);
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  SDM_SQL_Dump_Appli_Footer(FILE *dump_file)
+{
+	fprintf(dump_file, "\nCommit;\n");
+	return( IMRS_OK);
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  SDM_SQL_Dump_Appli(void)
+{
+	IMRT_Status     status;
+	char	    dump_filename[255];
+	FILE	   *dump_file;
+
+	strcpy(dump_filename, "init_imr_appli.sql");
+
+	if( ( dump_file = fopen( dump_filename, "w")) == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_1( "Can't open dump file (%s) !", dump_filename);
+	}
+	else
+	{
+		status = SDM_SQL_Dump_Appli_Header(dump_file);
+		if(status == IMRS_OK)
+		{
+			status = SDM_SQL_Dump_Appli_Body(dump_file);
+			if(status == IMRS_OK)
+			{
+				status = SDM_SQL_Dump_Appli_Footer(dump_file);
+			}
+		}
+
+		fclose( dump_file);
+	}
+
+	return(status);
+
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  SDM_SQL_Dump_Format_Header(FILE *dump_file)
+{
+	fprintf(dump_file, "---------------------------------------------------\n");
+	fprintf(dump_file, "--  Init file of IMR_FORMAT & IMR_FMT_MSG        --\n");
+	fprintf(dump_file, "---------------------------------------------------\n\n");
+	fprintf(dump_file, "INSERT INTO IMR_DATA_VERSION(VERS_NAME, VERS_LABEL, VERS_DATE) VALUES('Fmt', '%s', '%s');\n\n",
+						((IMRT_Data_Version *)(IMRG_SDM_Base.RootFmt->User_Ptr))->Label,
+						((IMRT_Data_Version *)(IMRG_SDM_Base.RootFmt->User_Ptr))->Date);
+	fprintf(dump_file, "Delete IMR_FMT_MSG;\n\n");
+	fprintf(dump_file, "Delete IMR_FORMAT;\n\n");
+	return( IMRS_OK);
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  SDM_SQL_Dump_Format_Body(FILE *dump_file)
+{
+	IMRT_Status  status;
+	NDT_Status  nd_status;
+
+	if( ( nd_status = ND_DataStruct_Traverse( IMRG_SDM_Base.RootFmt, IMRD_SDMD_CMD_API_SQL_DUMP, dump_file)) != NDS_OK)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0( "SQL Dump RootFmt failed !");
+	}
+	else
+	{
+		status = IMRS_OK;
+	}
+
+	return(status);
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  SDM_SQL_Dump_Format_Footer(FILE *dump_file)
+{
+	fprintf(dump_file, "\nCommit;\n");
+	return( IMRS_OK);
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  SDM_SQL_Dump_Format(void)
+{
+	IMRT_Status     status;
+	char	    dump_filename[255];
+	FILE	   *dump_file;
+
+	strcpy(dump_filename, "init_imr_format.sql");
+
+	if( ( dump_file = fopen( dump_filename, "w")) == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_1( "Can't open dump file (%s) !", dump_filename);
+	}
+	else
+	{
+		status = SDM_SQL_Dump_Format_Header(dump_file);
+		if(status == IMRS_OK)
+		{
+			status = SDM_SQL_Dump_Format_Body(dump_file);
+			if(status == IMRS_OK)
+			{
+				status = SDM_SQL_Dump_Format_Footer(dump_file);
+			}
+		}
+
+		fclose( dump_file);
+	}
+
+	return(status);
+
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  SDM_SQL_Dump_MapPath_Header(FILE *dump_file)
+{
+	fprintf(dump_file, "---------------------------------------------------\n");
+	fprintf(dump_file, "--  Init file of IMR_MAPPATH & IMR_CMD_MAP_PATH  --\n");
+	fprintf(dump_file, "--               IMR_MAPCMD & IMR_CMD_IDENT      --\n");
+	fprintf(dump_file, "--               IMR_JUMP_TABLE & IMR_CMD_MAP    --\n");
+	fprintf(dump_file, "--               IMR_CMD_GOTO & IMR_CMD_COPY     --\n");
+	fprintf(dump_file, "---------------------------------------------------\n\n");
+	fprintf(dump_file, "INSERT INTO IMR_DATA_VERSION(VERS_NAME, VERS_LABEL, VERS_DATE) VALUES('MapPath', '%s', '%s');\n\n",
+						((IMRT_Data_Version *)(IMRG_SDM_Base.RootMapPath->User_Ptr))->Label,
+						((IMRT_Data_Version *)(IMRG_SDM_Base.RootMapPath->User_Ptr))->Date);
+	fprintf(dump_file, "Delete IMR_CMD_COPY;\n\n");
+	fprintf(dump_file, "Delete IMR_CMD_GOTO;\n\n");
+	fprintf(dump_file, "Delete IMR_CMD_MAP;\n\n");
+	fprintf(dump_file, "Delete IMR_JUMP_TABLE;\n\n");
+	fprintf(dump_file, "Delete IMR_CMD_IDENT;\n\n");
+	fprintf(dump_file, "Delete IMR_MAPCMD;\n\n");
+	fprintf(dump_file, "Delete IMR_CMD_MAP_PATH;\n\n");
+	fprintf(dump_file, "Delete IMR_MAPPATH;\n\n");
+	return( IMRS_OK);
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  SDM_SQL_Dump_MapPath_Body(FILE *dump_file)
+{
+	IMRT_Status  status;
+	NDT_Status  nd_status;
+
+	if( ( nd_status = ND_DataStruct_Traverse( IMRG_SDM_Base.RootMapPath, IMRD_SDMD_CMD_API_SQL_DUMP, dump_file)) != NDS_OK)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0( "SQL Dump RootMapPath failed !");
+	}
+	else
+	{
+		status = IMRS_OK;
+	}
+
+	return(status);
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  SDM_SQL_Dump_MapPath_Footer(FILE *dump_file)
+{
+	fprintf(dump_file, "\nCommit;\n");
+	return( IMRS_OK);
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  SDM_SQL_Dump_MapPath(void)
+{
+	IMRT_Status     status;
+	char	    dump_filename[255];
+	FILE	   *dump_file;
+
+	strcpy(dump_filename, "init_imr_mappath.sql");
+
+	if( ( dump_file = fopen( dump_filename, "w")) == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_1( "Can't open dump file (%s) !", dump_filename);
+	}
+	else
+	{
+		status = SDM_SQL_Dump_MapPath_Header(dump_file);
+		if(status == IMRS_OK)
+		{
+			status = SDM_SQL_Dump_MapPath_Body(dump_file);
+			if(status == IMRS_OK)
+			{
+				status = SDM_SQL_Dump_MapPath_Footer(dump_file);
+			}
+		}
+
+		fclose( dump_file);
+	}
+
+	return(status);
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  SDM_SQL_BufferInfo_Dump(void)
+{
+	IMRT_Status     status;
+	char	    dump_filename[255];
+	FILE	   *dump_file;
+
+	status = SDM_SQL_Dump_Appli();
+
+	if(status == IMRS_OK)
+	{
+		status = SDM_SQL_Dump_Format();
+		if(status == IMRS_OK)
+		{
+			status = SDM_SQL_Dump_MapPath();
+			if(status == IMRS_OK)
+			{
+				status = SDM_SQL_Dump_FmtAttr();
+				if(status == IMRS_OK)
+				{
+					strcpy(dump_filename, "init_imr_mapcmd_type.sql");
+				
+					if( ( dump_file = fopen( dump_filename, "w")) == NULL)
+					{
+						status = IMRS_KO;
+						IMRD_LM_LOG_ERROR_1( "Can't open dump file (%s) !", dump_filename);
+					}
+					else
+					{
+						fprintf(dump_file, "---------------------------------------------------\n");
+						fprintf(dump_file, "--  Init file of IMR_MAPCMD_TYPE                 --\n");
+						fprintf(dump_file, "---------------------------------------------------\n\n");
+						fprintf(dump_file, "Delete IMR_MAPCMD_TYPE;\n\n");
+	
+						fprintf(dump_file, "INSERT INTO IMR_MAPCMD_TYPE(MAPCMD_TYPE) VALUES(0);\n");
+						fprintf(dump_file, "INSERT INTO IMR_MAPCMD_TYPE(MAPCMD_TYPE) VALUES(1);\n");
+						fprintf(dump_file, "INSERT INTO IMR_MAPCMD_TYPE(MAPCMD_TYPE) VALUES(2);\n");
+						fprintf(dump_file, "INSERT INTO IMR_MAPCMD_TYPE(MAPCMD_TYPE) VALUES(3);\n");
+						fprintf(dump_file, "INSERT INTO IMR_MAPCMD_TYPE(MAPCMD_TYPE) VALUES(4);\n");
+	
+						fprintf(dump_file, "\nCommit;\n");
+	
+						fclose( dump_file);
+					}
+				}
+			}
+		}
+	}
+
+	return(status);
+}
+/*----------------------------------------------------------------------------*/
+/*                                                                            */
+/*----------------------------------------------------------------------------*/
diff --git a/src/libstatic_data_mng/src/buffer_info_xml.c b/src/libstatic_data_mng/src/buffer_info_xml.c
new file mode 100644
index 0000000..8f908d2
--- /dev/null
+++ b/src/libstatic_data_mng/src/buffer_info_xml.c
@@ -0,0 +1,1837 @@
+/*----------------------------------------------------------------------------*/
+/* File: buffer_info_xml.c   		         		  	      */
+/*----------------------------------------------------------------------------*/
+/*                                                                            */
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#define _LIBSTATIC_DATA_MNG_
+#define _BUFFER_INFO_XML_C_
+
+#include "buffer_info_xml.h" 
+
+
+
+IMRT_Status SDM_XML_BufferInfo_Init(IMRT_Path    Lib_Path)
+{
+	SDMT_BufferInfo_Contexte Buffer_Info_Ctx;
+	IMRT_Status  status, StatusTmp;
+    char	     Xml_File_Name[255];
+
+
+    IMRD_LM_LOG_TRACE_0( IMRD_LOG_LEVEL_VERBOSE_0, "Loading FmtAttr...");
+
+    Buffer_Info_Ctx.flagerror = 0;
+    Buffer_Info_Ctx.CptFmtAttr  = IMRD_FMTATTR_ID_UNKNOWN;             
+	memset(Buffer_Info_Ctx.PathArray,0,sizeof(Buffer_Info_Ctx.PathArray));
+	Buffer_Info_Ctx.PresentLevelTag = IMRD_SDMD_MIN_LEVEL_TAG;
+    memset(Xml_File_Name,0,sizeof(Xml_File_Name));
+	strcpy(Xml_File_Name, Lib_Path);
+	strcat(Xml_File_Name, "/");
+	strcat(Xml_File_Name, SDMD_FMTATTR_FILE);
+
+    status = SDM_XML_Load_FmtAttr(Xml_File_Name, &(Buffer_Info_Ctx));
+
+    if(status == IMRS_OK)
+    {
+	IMRG_SDM_Base.RootFmtAttr = Buffer_Info_Ctx.RootFmtAttr;
+
+	IMRD_LM_LOG_INFO_1( "FmtAtt loaded: (%d)", IMRG_SDM_Base.RootFmtAttr->Index_Tab[NDD_INDEX_PRIMARY].Node_Number);
+
+	IMRD_LM_LOG_TRACE_0( IMRD_LOG_LEVEL_VERBOSE_0, "Loading Fmt...");
+
+	    Buffer_Info_Ctx.flagerror = 0;
+	    Buffer_Info_Ctx.CptFmt  = IMRD_FMT_ID_UNKNOWN;             
+		memset(Buffer_Info_Ctx.PathArray,0,sizeof(Buffer_Info_Ctx.PathArray));
+		Buffer_Info_Ctx.PresentLevelTag = IMRD_SDMD_MIN_LEVEL_TAG;
+	    memset(Xml_File_Name,0,sizeof(Xml_File_Name));
+		strcpy(Xml_File_Name, Lib_Path);
+		strcat(Xml_File_Name, "/");
+		strcat(Xml_File_Name, SDMD_FORMAT_FILE);
+	
+	    status = SDM_XML_Load_Format(Xml_File_Name, &(Buffer_Info_Ctx));
+	      
+	    if(status == IMRS_OK)
+	    {
+		IMRG_SDM_Base.RootFmt = Buffer_Info_Ctx.RootFormat;
+
+		IMRD_LM_LOG_INFO_1( "Fmt loaded: (%d)", IMRG_SDM_Base.RootFmt->Index_Tab[NDD_INDEX_PRIMARY].Node_Number);
+	
+		IMRD_LM_LOG_TRACE_0( IMRD_LOG_LEVEL_VERBOSE_0, "Loading Appl...");
+
+			memset(Buffer_Info_Ctx.PathArray,0,sizeof(Buffer_Info_Ctx.PathArray));
+			Buffer_Info_Ctx.PresentLevelTag = IMRD_SDMD_MIN_LEVEL_TAG;
+		    Buffer_Info_Ctx.CptAppl = IMRD_APPL_ID_UNKNOWN;
+		    memset(Xml_File_Name,0,sizeof(Xml_File_Name));
+			strcpy(Xml_File_Name, Lib_Path);
+			strcat(Xml_File_Name, "/");
+			strcat(Xml_File_Name, SDMD_APPLI_FILE);
+	
+			status = SDM_XML_Load_Appli(Xml_File_Name, &(Buffer_Info_Ctx));
+			if(status == IMRS_OK)
+			{
+			    IMRG_SDM_Base.RootAppl = Buffer_Info_Ctx.RootAppli;
+
+			    IMRD_LM_LOG_INFO_1( "Appl loaded: (%d)", IMRG_SDM_Base.RootAppl->Index_Tab[NDD_INDEX_PRIMARY].Node_Number);
+	
+			    IMRD_LM_LOG_TRACE_0( IMRD_LOG_LEVEL_VERBOSE_0, "Loading MapPath...");
+
+			    Buffer_Info_Ctx.NbMapPath = 0 ;
+			    Buffer_Info_Ctx.NbMapCmd  = 0 ;
+				memset(Buffer_Info_Ctx.PathArray,0,sizeof(Buffer_Info_Ctx.PathArray));
+				Buffer_Info_Ctx.PresentLevelTag = IMRD_SDMD_MIN_LEVEL_TAG;
+			    memset(Xml_File_Name,0,sizeof(Xml_File_Name));
+				strcpy(Xml_File_Name, Lib_Path);
+				strcat(Xml_File_Name, "/");
+				strcat(Xml_File_Name, SDMD_MAPPATH_FILE);
+			    status = SDM_XML_Load_MapPath(Xml_File_Name, &(Buffer_Info_Ctx));
+			    if(status == IMRS_OK)
+			    {
+				IMRG_SDM_Base.RootMapPath = Buffer_Info_Ctx.RootMapPath;
+				
+				IMRD_LM_LOG_INFO_1( "MapPath loaded: (%d)", IMRG_SDM_Base.RootMapPath->Index_Tab[NDD_INDEX_PRIMARY].Node_Number);
+			    }
+			    else
+			    {
+				IMRD_LM_LOG_ERROR_0( "Can't load MapPath !");
+
+					StatusTmp = SDM_Close_RootFmtAttr();
+					StatusTmp = SDM_Close_RootFmt();
+					StatusTmp = SDM_Close_RootAppl();
+			    }
+			    
+			}
+			else
+			{
+			    IMRD_LM_LOG_ERROR_0( "Can't load Appl !");
+
+				StatusTmp = SDM_Close_RootFmtAttr();
+			    StatusTmp = SDM_Close_RootFmt();
+			}
+	    }
+	    else
+	    {
+		StatusTmp = SDM_Close_RootFmtAttr();
+
+		IMRD_LM_LOG_ERROR_0( "Can't load Fmt !");
+	    }
+    }
+    else
+    {
+		IMRD_LM_LOG_ERROR_0( "Can't load FmtAttr !");
+    }
+
+    return(status);
+
+}
+
+
+
+static IMRT_Status error(SDMT_BufferInfo_Contexte *ctx , const char *msg, ...)
+{
+    xmlParserCtxt * SaxCtx;
+  
+    SaxCtx = ctx->SaxCtxHdl;
+  
+    IMRD_LM_LOG_ERROR_1( "CallBack error: <%s> !",msg);
+
+    SaxCtx->sax  = &ErrorSAXHandlerStruct;
+    ctx->flagerror = 1;
+    ctx->FataError.errorCode = SDMD_XML_CODE_ERROR_1;
+    strcpy(ctx->FataError.libError,msg) ;
+    
+}
+
+IMRT_Status  startElementNsAppli( SDMT_BufferInfo_Contexte * ctx , 
+			  const xmlChar *localname,
+			  const xmlChar *prefix,
+			  const xmlChar *URI,
+			  int nb_namespaces,
+			  const xmlChar **namespaces,
+			  int nb_attributes,
+			  int nb_defaulted,
+			  const xmlChar **attributes)
+{
+    NDT_Status  nd_status;
+    const char   functionname [] = "startElementNsAppli";
+    char         DescErr [IMRD_SDMD_DESCERR_LEN]; 
+  
+    if(strcmp((const char*)localname, IMRD_SDMD_TAG_APPLI) == 0)
+    {
+		/*création d'un nouvelle objet appli*/
+		if( ( nd_status = ND_Value_Alloc( ctx->RootAppli, (void  **)&(ctx->CurrentAppli)) != NDS_OK))
+		{
+		    snprintf(DescErr,sizeof(DescErr),SDMD_XML_LIB_ERROR_5,IMRD_SDMD_TAG_APPLI);
+		    SDM_RaiseError(ctx->SaxCtxHdl,&(ctx->FataError),&(ctx->flagerror), functionname, DescErr, SDMD_XML_CODE_ERROR_5 );
+		}
+    }
+}
+
+
+IMRT_Status startElementNsFmtAttr( SDMT_BufferInfo_Contexte * ctx , 
+			const xmlChar *localname,
+			const xmlChar *prefix,
+			const xmlChar *URI,
+			int nb_namespaces,
+			const xmlChar **namespaces,
+			int nb_attributes,
+			int nb_defaulted,
+			const xmlChar **attributes)
+{
+    NDT_Status   nd_status;
+    const char   functionname [] = "startElementNsFmtAttr";
+    char         DescErr [IMRD_SDMD_DESCERR_LEN]; 
+  
+    if(strcmp((const char*)localname, IMRD_SDMD_TAG_FMTATTR) == 0)
+    {
+		/*création d'un nouvelle objet FmtAttr*/
+		if( ( nd_status = ND_Value_Alloc( ctx->RootFmtAttr, (void  **)&(ctx->CurrentFmtAttr)) != NDS_OK))
+		{
+		    snprintf(DescErr,sizeof(DescErr),SDMD_XML_LIB_ERROR_5,IMRD_SDMD_TAG_FMTATTR);
+		    SDM_RaiseError(ctx->SaxCtxHdl,&(ctx->FataError),&(ctx->flagerror), functionname, DescErr, SDMD_XML_CODE_ERROR_5 );
+		}
+    }
+
+}
+
+
+IMRT_Status startElementNsFmt( SDMT_BufferInfo_Contexte * ctx , 
+			const xmlChar *localname,
+			const xmlChar *prefix,
+			const xmlChar *URI,
+			int nb_namespaces,
+			const xmlChar **namespaces,
+			int nb_attributes,
+			int nb_defaulted,
+			const xmlChar **attributes)
+{
+    NDT_Status   nd_status;
+    const char   functionname [] = "startElementNsFmt";
+    char         DescErr [IMRD_SDMD_DESCERR_LEN]; 
+    
+    
+    if(strcmp((const char*)localname,IMRD_SDMD_TAG_FORMAT) == 0)
+    {
+		/*création d'un nouvel objet format*/
+		if(( nd_status = ND_Value_Alloc( ctx->RootFormat, (void  **)&(ctx->CurrentFormat)) != NDS_OK))
+		{
+		    snprintf(DescErr,sizeof(DescErr),SDMD_XML_LIB_ERROR_5,IMRD_SDMD_TAG_FORMAT);
+		    SDM_RaiseError(ctx->SaxCtxHdl,&(ctx->FataError),&(ctx->flagerror), functionname, DescErr, SDMD_XML_CODE_ERROR_5 );
+		}
+	    else
+		{
+			ctx->PresentLevelTag = ctx->PresentLevelTag + 1;
+			strcpy(ctx->PathArray[ctx->PresentLevelTag], (char*)localname);
+	    }
+    }
+    else if (strcmp((const char*)localname,IMRD_SDMD_TAG_FMTMSG) == 0)
+    {
+		/*creation d'un nouvel objet FmtMsg*/
+		if( ( nd_status = ND_Value_Alloc( ctx->CurrentFormat->FmtMsg_Struct_Ptr, (void  **)&(ctx->CurrentFmtMsg)) != NDS_OK))
+		{
+			snprintf(DescErr,sizeof(DescErr),SDMD_XML_LIB_ERROR_3, IMRD_SDMD_TAG_FMTMSG);
+			SDM_RaiseError(ctx->SaxCtxHdl,&(ctx->FataError),&(ctx->flagerror), functionname , DescErr, SDMD_XML_CODE_ERROR_3 );
+		}
+		ctx->PresentLevelTag = ctx->PresentLevelTag + 1;
+		strcpy(ctx->PathArray[ctx->PresentLevelTag], (char*)localname);
+    }
+  
+}
+
+IMRT_Status startElementNsMapPath( SDMT_BufferInfo_Contexte * ctx , 
+			    const xmlChar *localname,
+			    const xmlChar *prefix,
+			    const xmlChar *URI,
+			    int nb_namespaces,
+			    const xmlChar **namespaces,
+			    int nb_attributes,
+			    int nb_defaulted,
+			    const xmlChar **attributes)
+{
+    NDT_Status         nd_status;
+    const char         functionname [] = "startElementNsMapPath";
+    char               DescErr [IMRD_SDMD_DESCERR_LEN]; 
+    IMRT_Jump		*jump_ptr;
+ 
+   if(strcmp((const char *)localname, IMRD_SDMD_TAG_MAPPATH) == 0)
+   {
+		/*creation d'un nouvel objet MapPath*/
+		if( ( nd_status = ND_Value_Alloc(ctx->RootMapPath,(void  **)&(ctx->CurrentMapPath)) != NDS_OK))
+		{
+		    snprintf(DescErr,sizeof(DescErr),SDMD_XML_LIB_ERROR_3, IMRD_SDMD_TAG_MAPPATH);
+		    SDM_RaiseError(ctx->SaxCtxHdl,&(ctx->FataError),&(ctx->flagerror), functionname ,DescErr, SDMD_XML_CODE_ERROR_3);
+		}
+		ctx->PresentLevelTag = ctx->PresentLevelTag + 1;
+		strcpy(ctx->PathArray[ctx->PresentLevelTag], (char*)localname);
+	}
+   else if (strcmp((const char *)localname, IMRD_SDMD_TAG_MAPCMD) == 0)
+   {
+		/*creation d'un nouvel objet MapCmd*/
+		if( ( nd_status = ND_Value_Alloc( ctx->CurrentMapPath->MapCmd_Struct_Ptr, (void  **)&(ctx->CurrentMapCmd)) != NDS_OK))
+		{
+			snprintf(DescErr,sizeof(DescErr),SDMD_XML_LIB_ERROR_3, IMRD_SDMD_TAG_MAPCMD);
+			SDM_RaiseError(ctx->SaxCtxHdl,&(ctx->FataError),&(ctx->flagerror), functionname , DescErr, SDMD_XML_CODE_ERROR_3 );
+		}
+		ctx->PresentLevelTag = ctx->PresentLevelTag + 1;
+		strcpy(ctx->PathArray[ctx->PresentLevelTag], (char*)localname);
+	}
+   else if ((strcmp((const char *)localname, IMRD_SDMD_TAG_MAPPER)     == 0) ||
+            (strcmp((const char *)localname, IMRD_SDMD_TAG_COPIE)      == 0)
+           )
+   {
+		ctx->PresentLevelTag = ctx->PresentLevelTag + 1;
+		strcpy(ctx->PathArray[ctx->PresentLevelTag], (char*)localname);
+	}
+    else if(strcmp((const char *)localname, IMRD_SDMD_TAG_IDENTIFIER) == 0)
+    {
+		ctx->PresentLevelTag = ctx->PresentLevelTag + 1;
+		strcpy(ctx->PathArray[ctx->PresentLevelTag], (char*)localname);
+		ctx->IdxJpTble = 0;
+	}
+    else if(strcmp((const char*)localname,IMRD_SDMD_TAG_GO_TO)== 0)
+    {
+		ctx->PresentLevelTag = ctx->PresentLevelTag + 1;
+		strcpy(ctx->PathArray[ctx->PresentLevelTag], (char*)localname);
+		
+		if (ctx->PresentLevelTag == IMRD_SDMD_LEVEL_TAG_3)
+		{
+		  	jump_ptr = (IMRT_Jump *)realloc((void *)ctx->CurrentMapCmd->Jump_Tab , 
+										(size_t)((ctx->CurrentMapCmd->JmpTbleNbElts + 1) * sizeof(IMRT_Jump)));
+		  	if (jump_ptr == NULL)
+		  	{
+			    snprintf(DescErr, sizeof(DescErr), SDMD_XML_LIB_ERROR_3, "Jump Table");
+			    SDM_RaiseError(ctx->SaxCtxHdl,&(ctx->FataError),&(ctx->flagerror), functionname , DescErr, SDMD_XML_CODE_ERROR_3);  	  		
+		  	}
+		  	else
+		  	{	
+		  	    ctx->CurrentMapCmd->Jump_Tab = jump_ptr;
+		  	    ctx->CurrentMapCmd->JmpTbleNbElts++;
+		  	}
+		}
+    }
+
+}
+
+
+
+IMRT_Status endElementNsAppli( SDMT_BufferInfo_Contexte * ctx, 
+			const xmlChar *localname,
+			const xmlChar *prefix,
+			const xmlChar *URI)
+{
+    NDT_Status        nd_status;
+    IMRT_Status       status_tmp;
+    const char        fonctionname [] ="endElementNsAppli";
+    char              DescErr[IMRD_SDMD_DESCERR_LEN];
+  
+    if(strcmp((const char*)localname, IMRD_SDMD_TAG_APPLI) == 0)
+    {
+		/*insertion de l'appli courante*/
+		/*insertion du format*/
+	    ctx->CurrentAppli->Id =  ctx->CptAppl;
+		if( ( nd_status = ND_DataStruct_Value_Add( ctx->RootAppli, (void  *)(ctx->CurrentAppli))) != NDS_OK)
+		{
+		    snprintf(DescErr,sizeof(DescErr),SDMD_XML_LIB_ERROR_3, IMRD_SDMD_TAG_APPLI);
+		    SDM_RaiseError(ctx->SaxCtxHdl,&(ctx->FataError),&(ctx->flagerror), fonctionname , DescErr, SDMD_XML_CODE_ERROR_3 );
+		}
+	    ctx->CptAppl ++;
+    }
+    else if(strcmp((const char*)localname, IMRD_SDMD_TAG_NAME) == 0)
+    {
+		strcpy(ctx->CurrentAppli->Name, ctx->value);
+    }
+    else if (strcmp((const char *)localname, IMRD_SDMD_TAG_VERSION) == 0)
+    {
+		IMRD_LM_LOG_INFO_1( "[Appl]: [%s]", ctx->value);
+		status_tmp = SDM_Set_Struct_Version((IMRT_Data_Version *)ctx->RootAppli->User_Ptr, (char *)ctx->value);
+    }
+}
+
+
+IMRT_Status endElementNsFmtAttr( SDMT_BufferInfo_Contexte * ctx, 
+			const xmlChar *localname,
+			const xmlChar *prefix,
+			const xmlChar *URI)
+{
+    NDT_Status        nd_status;
+    IMRT_Status       status, status_tmp;
+    const char        fonctionname [] ="endElementNsFmtAttr";
+    char              DescErr[IMRD_SDMD_DESCERR_LEN];
+  
+    if(strcmp((const char*)localname, IMRD_SDMD_TAG_FMTATTR) == 0)
+    {
+	    ctx->CurrentFmtAttr->Id =  ctx->CptFmtAttr;
+		if( ( nd_status = ND_DataStruct_Value_Add( ctx->RootFmtAttr, (void  *)(ctx->CurrentFmtAttr))) != NDS_OK)
+		{
+		    snprintf(DescErr,sizeof(DescErr),SDMD_XML_LIB_ERROR_3, IMRD_SDMD_TAG_FMTATTR);
+		    SDM_RaiseError(ctx->SaxCtxHdl,&(ctx->FataError),&(ctx->flagerror), fonctionname , DescErr, SDMD_XML_CODE_ERROR_3 );
+		}
+	    ctx->CptFmtAttr ++;
+    }
+    else if(strcmp((const char*)localname, IMRD_SDMD_TAG_NAME) == 0)
+    {
+		strcpy(ctx->CurrentFmtAttr->Name, ctx->value);
+    }
+    else if(strcmp((const char*)localname, IMRD_SDMD_TAG_VALUE) == 0)
+    {
+		memset(ctx->CurrentFmtAttr->Value,'\0', IMRD_FMTATTR_VALUE_SIZE);
+		status = SDM_ConvertAttribute(ctx->value, ctx->CurrentFmtAttr->Value);
+    }
+    else if (strcmp((const char *)localname, IMRD_SDMD_TAG_VERSION) == 0)
+    {
+		IMRD_LM_LOG_INFO_1( "[FmtAtt]: [%s]", ctx->value);
+		status_tmp = SDM_Set_Struct_Version((IMRT_Data_Version *)ctx->RootFmtAttr->User_Ptr, (char *)ctx->value);
+    }
+}
+
+
+IMRT_Status endElementNsMapPath( SDMT_BufferInfo_Contexte * ctx, 
+			  const xmlChar *localname,
+			  const xmlChar *prefix,
+			  const xmlChar *URI)
+{
+    NDT_Node *      node_ptr;
+    NDT_Status      nd_status;
+    IMRT_Status     status, status_tmp;
+    IMRT_MsgMap     msgmap;
+    IMRT_Appl       appli;
+    IMRT_Fmt        fmt;
+    IMRT_Msg        msg;
+    IMRT_FmtAttr  FmtAttr;
+    char fonctionname [] = "endElementNsMapPath";
+    char DescErr[IMRD_SDMD_DESCERR_LEN];
+
+
+  if (strcmp((const char *)localname, IMRD_SDMD_TAG_FORMAT) == 0)
+  {
+
+	  strcpy(fmt.Name, ctx->value);
+	  if(((nd_status = ND_Index_Node_Find( &node_ptr, IMRG_SDM_Base.RootFmt,
+					 IMRD_SDMD_FMT_IDX_NAME, &fmt, NULL)) != NDS_OK)||
+			(node_ptr == NULL))
+	  {
+	    snprintf(DescErr,sizeof(DescErr),SDMD_XML_LIB_ERROR_4,IMRD_SDMD_TAG_FORMAT, fmt.Name );
+	    SDM_RaiseError(ctx->SaxCtxHdl,&(ctx->FataError),&(ctx->flagerror), fonctionname , DescErr, SDMD_XML_CODE_ERROR_4 );
+	  }
+	  else
+ 	  {
+	    ctx->CurrentMapCmd->Jump_Tab[ctx->IdxJpTble].Fmt_Ptr = node_ptr->Value;
+	  }	
+  }
+  else if (strcmp((const char *)localname, IMRD_SDMD_TAG_BRANCHE_ID) == 0)
+  {
+  	switch(ctx->PresentLevelTag)
+  	{
+  	  case IMRD_SDMD_LEVEL_TAG_1:  /* IMRD_SDMD_TAG_MAPCMD */
+  	  {
+  	  	ctx->CurrentMapCmd->Branche_Id = atoi(ctx->value);
+  		break;	
+      }
+
+  	  case IMRD_SDMD_LEVEL_TAG_2:   /* Command go_to */
+  	  {
+  	  	ctx->CurrentMapCmd->Goto_Branche_Id = atoi(ctx->value);
+  		break;	
+      }
+
+  	  case IMRD_SDMD_LEVEL_TAG_3:   /* Jump Table */
+  	  {
+	  	ctx->CurrentMapCmd->Jump_Tab[ctx->IdxJpTble].Branche_Id = atoi(ctx->value);
+  		break;	
+      }
+
+  	  default:
+  	  {
+        snprintf(DescErr, sizeof(DescErr), SDMD_XML_LIB_ERROR_10, SDMD_MAPPATH_FILE);
+        SDM_RaiseError(ctx->SaxCtxHdl,&(ctx->FataError),&(ctx->flagerror), fonctionname , DescErr, SDMD_XML_CODE_ERROR_10);
+  	  }
+    } /* end switch */
+  }
+  else if (strcmp((const char *)localname, IMRD_SDMD_TAG_TYPE) == 0)
+  {
+  	switch(ctx->PresentLevelTag)
+  	{
+  	  case IMRD_SDMD_LEVEL_TAG_2:
+  	  {
+		strcpy(msg.Name, ctx->value);
+		if(((nd_status = ND_Index_Node_Find( &node_ptr, IMRG_SDM_Base.RootMsg,
+						 IMRD_SDMD_MSG_IDX_NAME, &msg, NULL)) != NDS_OK)||
+			(node_ptr == NULL))
+		{
+		    snprintf(DescErr,sizeof(DescErr),SDMD_XML_LIB_ERROR_4,IMRD_SDMD_TAG_TYPE, msg.Name );
+		    SDM_RaiseError(ctx->SaxCtxHdl,&(ctx->FataError),&(ctx->flagerror), fonctionname , DescErr, SDMD_XML_CODE_ERROR_4 );
+		}
+		else
+		{
+		    ctx->CurrentMapCmd->Ident_First_Msg_Ptr = node_ptr->Value;
+		}
+  		break;	
+      }
+
+  	  case IMRD_SDMD_LEVEL_TAG_3:
+  	  {
+		strcpy(msg.Name, ctx->value);
+		if(((nd_status = ND_Index_Node_Find( &node_ptr, IMRG_SDM_Base.RootMsg,
+						 IMRD_SDMD_MSG_IDX_NAME, &msg, NULL)) != NDS_OK)||
+			(node_ptr == NULL))
+		{
+		    snprintf(DescErr,sizeof(DescErr),SDMD_XML_LIB_ERROR_4,IMRD_SDMD_TAG_TYPE, msg.Name );
+		    SDM_RaiseError(ctx->SaxCtxHdl,&(ctx->FataError),&(ctx->flagerror), fonctionname , DescErr, SDMD_XML_CODE_ERROR_4 );
+		}
+		else
+		{
+		    ctx->CurrentMapCmd->Jump_Tab[ctx->IdxJpTble].Msg_Ptr = node_ptr->Value;
+		}
+  		break;	
+      }
+
+  	  default:
+  	  {
+        snprintf(DescErr, sizeof(DescErr), SDMD_XML_LIB_ERROR_10, SDMD_MAPPATH_FILE);
+        SDM_RaiseError(ctx->SaxCtxHdl,&(ctx->FataError),&(ctx->flagerror), fonctionname , DescErr, SDMD_XML_CODE_ERROR_10);
+  	  }
+    } /* end switch */
+  }
+  else if (strcmp((const char *)localname, IMRD_SDMD_TAG_INPUTFORMAT) == 0)
+  {
+	strcpy(fmt.Name, ctx->value);
+	if(((nd_status = ND_Index_Node_Find( &node_ptr, IMRG_SDM_Base.RootFmt,
+					 IMRD_SDMD_FMT_IDX_NAME, &fmt, NULL)) != NDS_OK)||
+		(node_ptr == NULL))
+	{
+	    snprintf(DescErr,sizeof(DescErr),SDMD_XML_LIB_ERROR_4,IMRD_SDMD_TAG_INPUTFORMAT, fmt.Name );
+	    SDM_RaiseError(ctx->SaxCtxHdl,&(ctx->FataError),&(ctx->flagerror), fonctionname , DescErr, SDMD_XML_CODE_ERROR_4 );
+	}
+	else
+	{
+	  	switch(ctx->PresentLevelTag)
+	  	{
+	  	  case IMRD_SDMD_LEVEL_TAG_2:
+	  	  {
+			ctx->CurrentMapCmd->Fmt_Input_Ptr = node_ptr->Value;
+	  		break;	
+	      }
+	
+	  	  case IMRD_SDMD_LEVEL_TAG_0:
+	  	  {
+	  	  	ctx->CurrentMapPath->Fmt_Input_Ptr = node_ptr->Value;
+	  		break;	
+	      }
+	
+	  	  default:
+	  	  {
+	        snprintf(DescErr, sizeof(DescErr), SDMD_XML_LIB_ERROR_10, SDMD_MAPPATH_FILE);
+	        SDM_RaiseError(ctx->SaxCtxHdl,&(ctx->FataError),&(ctx->flagerror), fonctionname , DescErr, SDMD_XML_CODE_ERROR_10);
+	  	  }
+	    } /* end switch */
+	}
+  }
+  else if (strcmp((const char *)localname, IMRD_SDMD_TAG_INPUTFORMAT_ATTR) == 0)
+  {
+  	switch(ctx->PresentLevelTag)
+  	{
+  	  case IMRD_SDMD_LEVEL_TAG_2:
+  	  {
+
+	    strcpy(FmtAttr.Name, ctx->value);
+		if(((nd_status = ND_Index_Node_Find( &node_ptr, IMRG_SDM_Base.RootFmtAttr,
+						 IMRD_SDMD_FMTATTR_IDX_NAME, &FmtAttr, NULL)) != NDS_OK)||
+			(node_ptr == NULL))
+		{
+		    snprintf(DescErr,sizeof(DescErr),SDMD_XML_LIB_ERROR_4,IMRD_SDMD_TAG_TYPE, FmtAttr.Name );
+		    SDM_RaiseError(ctx->SaxCtxHdl,&(ctx->FataError),&(ctx->flagerror), fonctionname , DescErr, SDMD_XML_CODE_ERROR_4 );
+		}
+		else
+		{
+		    ctx->CurrentMapCmd->FmtAttr_Input_Ptr = node_ptr->Value;
+		}
+        
+  		break;	
+      }
+
+  	  default:
+  	  {
+        snprintf(DescErr, sizeof(DescErr), SDMD_XML_LIB_ERROR_10, SDMD_MAPPATH_FILE);
+        SDM_RaiseError(ctx->SaxCtxHdl,&(ctx->FataError),&(ctx->flagerror), fonctionname , DescErr, SDMD_XML_CODE_ERROR_10);
+  	  }
+    } /* end switch */
+  }
+  else if (strcmp((const char *)localname, IMRD_SDMD_TAG_OUTPUTFORMAT) == 0)
+  {
+	strcpy(fmt.Name, ctx->value);
+	if(((nd_status = ND_Index_Node_Find( &node_ptr, IMRG_SDM_Base.RootFmt,
+					 IMRD_SDMD_FMT_IDX_NAME, &fmt, NULL)) != NDS_OK)||
+		(node_ptr == NULL))
+	{
+	    snprintf(DescErr,sizeof(DescErr),SDMD_XML_LIB_ERROR_4,IMRD_SDMD_TAG_OUTPUTFORMAT, fmt.Name );
+	    SDM_RaiseError(ctx->SaxCtxHdl,&(ctx->FataError),&(ctx->flagerror), fonctionname , DescErr, SDMD_XML_CODE_ERROR_4 );
+	}
+	else
+	{
+	  	switch(ctx->PresentLevelTag)
+	  	{
+	  	  case IMRD_SDMD_LEVEL_TAG_2:
+	  	  {
+			ctx->CurrentMapCmd->Fmt_Output_Ptr = node_ptr->Value;
+	  		break;	
+	      }
+	
+	  	  case IMRD_SDMD_LEVEL_TAG_0:
+	  	  {
+	  	  	ctx->CurrentMapPath->Fmt_Output_Ptr = node_ptr->Value;
+	  		break;	
+	      }
+	
+	  	  default:
+	  	  {
+	        snprintf(DescErr, sizeof(DescErr), SDMD_XML_LIB_ERROR_10, SDMD_MAPPATH_FILE);
+	        SDM_RaiseError(ctx->SaxCtxHdl,&(ctx->FataError),&(ctx->flagerror), fonctionname , DescErr, SDMD_XML_CODE_ERROR_10);
+	  	  }
+	    } /* end switch */
+	}
+  }
+  else if (strcmp((const char *)localname, IMRD_SDMD_TAG_OUTPUTFORMAT_ATTR) == 0)
+  {
+  	switch(ctx->PresentLevelTag)
+  	{
+  	  case IMRD_SDMD_LEVEL_TAG_2:
+  	  {
+	    strcpy(FmtAttr.Name, ctx->value);
+		if(((nd_status = ND_Index_Node_Find( &node_ptr, IMRG_SDM_Base.RootFmtAttr,
+						 IMRD_SDMD_FMTATTR_IDX_NAME, &FmtAttr, NULL)) != NDS_OK)||
+			(node_ptr == NULL))
+		{
+		    snprintf(DescErr,sizeof(DescErr),SDMD_XML_LIB_ERROR_4,IMRD_SDMD_TAG_TYPE, FmtAttr.Name );
+		    SDM_RaiseError(ctx->SaxCtxHdl,&(ctx->FataError),&(ctx->flagerror), fonctionname , DescErr, SDMD_XML_CODE_ERROR_4 );
+		}
+		else
+		{
+		    ctx->CurrentMapCmd->FmtAttr_Output_Ptr = node_ptr->Value;
+		}
+  		break;	
+      }
+
+  	  default:
+  	  {
+        snprintf(DescErr, sizeof(DescErr), SDMD_XML_LIB_ERROR_10, SDMD_MAPPATH_FILE);
+        SDM_RaiseError(ctx->SaxCtxHdl,&(ctx->FataError),&(ctx->flagerror), fonctionname , DescErr, SDMD_XML_CODE_ERROR_10);
+  	  }
+    }  /* end switch */
+  }
+  else if (strcmp((const char *)localname, IMRD_SDMD_TAG_INPUTBUFFER) == 0)
+  {
+  	ctx->CurrentMapCmd->Buffer_Id_Input = atoi(ctx->value);
+  }
+  else if (strcmp((const char *)localname, IMRD_SDMD_TAG_OUTPUTBUFFER) == 0)
+  {
+  	ctx->CurrentMapCmd->Buffer_Id_Output = atoi(ctx->value);
+  }
+  else if (strcmp((const char *)localname, IMRD_SDMD_TAG_NUMBUFFER) == 0)
+  {
+  	ctx->CurrentMapCmd->Buffer_Id_Ident = atoi(ctx->value);
+  }
+  else if (strcmp((const char *)localname, IMRD_SDMD_TAG_INPUTAPPLI) == 0)
+  {
+	strcpy(appli.Name, ctx->value);
+	if(((nd_status = ND_Index_Node_Find( &node_ptr, IMRG_SDM_Base.RootAppl,
+					 IMRD_SDMD_APPL_IDX_NAME, &appli, NULL)) != NDS_OK)||
+		(node_ptr == NULL))
+	{
+	    snprintf(DescErr,sizeof(DescErr),SDMD_XML_LIB_ERROR_4,IMRD_SDMD_TAG_INPUTAPPLI, appli.Name );
+	    SDM_RaiseError(ctx->SaxCtxHdl,&(ctx->FataError),&(ctx->flagerror), fonctionname , DescErr, SDMD_XML_CODE_ERROR_4 );
+	}
+	else
+	{
+	    ctx->CurrentMapPath->Appl_Input_Ptr = node_ptr->Value;
+	}
+  }
+  else if (strcmp((const char *)localname, IMRD_SDMD_TAG_OUTPUTAPPLI) == 0)
+  {
+	strcpy(appli.Name, ctx->value);
+	if(((nd_status = ND_Index_Node_Find( &node_ptr, IMRG_SDM_Base.RootAppl,
+					 IMRD_SDMD_APPL_IDX_NAME, &appli, NULL)) != NDS_OK)||
+		(node_ptr == NULL))
+	{
+	    snprintf(DescErr,sizeof(DescErr),SDMD_XML_LIB_ERROR_4,IMRD_SDMD_TAG_INPUTAPPLI, appli.Name );
+	    SDM_RaiseError(ctx->SaxCtxHdl,&(ctx->FataError),&(ctx->flagerror), fonctionname , DescErr, SDMD_XML_CODE_ERROR_4 );
+	}
+	else
+	{
+	    ctx->CurrentMapPath->Appl_Output_Ptr = node_ptr->Value;
+	}
+  }
+  else if (strcmp((const char *)localname, IMRD_SDMD_TAG_IDENTTOTAL) == 0)
+  {
+  	if(*(ctx->value) == IMRD_YES)
+  	{
+  		ctx->CurrentMapCmd->Ident_Total = IMRD_TRUE;
+  	}
+  	else
+  	{
+  		ctx->CurrentMapCmd->Ident_Total = IMRD_FALSE;
+  	}
+  }
+  else if (strcmp((const char *)localname, IMRD_SDMD_TAG_MSGMAP) == 0)
+  {
+	strcpy(msgmap.Name, ctx->value);
+	if(((nd_status = ND_Index_Node_Find( &node_ptr, IMRG_SDM_Base.RootMsgMap,
+					 IMRD_SDMD_MSGMAP_IDX_NAME, &msgmap, NULL)) != NDS_OK)||
+		(node_ptr == NULL))
+	{
+	    snprintf(DescErr,sizeof(DescErr),SDMD_XML_LIB_ERROR_4,IMRD_SDMD_TAG_MSGMAP, msgmap.Name );
+	    SDM_RaiseError(ctx->SaxCtxHdl,&(ctx->FataError),&(ctx->flagerror), fonctionname , DescErr, SDMD_XML_CODE_ERROR_4 );
+	}
+	else
+	{
+	    ctx->CurrentMapCmd->MsgMap_Ptr = node_ptr->Value;
+	}
+  }
+  else if (strcmp((const char *)localname, IMRD_SDMD_TAG_CLEARFLAG) == 0)
+  {
+  	ctx->CurrentMapCmd->Clear_Flag = atoi(ctx->value);
+  }
+  else if (strcmp((const char *)localname, IMRD_SDMD_TAG_GO_TO) == 0)
+  {
+  	ctx->CurrentMapCmd->TypeCmd = IMRD_MAPCMD_TYPE_GOTO;
+  	if(ctx->PresentLevelTag == IMRD_SDMD_LEVEL_TAG_3)
+  	{
+	  		ctx->IdxJpTble++;
+	  	
+  	}
+    memset(ctx->PathArray[ctx->PresentLevelTag],0,sizeof(IMRD_SDMD_SIZE_TAG_SIZE));
+    ctx->PresentLevelTag = ctx->PresentLevelTag - 1;
+  }
+  else if (strcmp((const char *)localname, IMRD_SDMD_TAG_IDENTIFIER) == 0)
+  {
+	ctx->CurrentMapCmd->TypeCmd = IMRD_MAPCMD_TYPE_IDENT;
+    memset(ctx->PathArray[ctx->PresentLevelTag],0,sizeof(IMRD_SDMD_SIZE_TAG_SIZE));
+    ctx->PresentLevelTag = ctx->PresentLevelTag - 1;
+    ctx->IdxJpTble = 0;
+  }
+  else if (strcmp((const char *)localname, IMRD_SDMD_TAG_MAPPER) == 0)
+  {
+	ctx->CurrentMapCmd->TypeCmd = IMRD_MAPCMD_TYPE_MAP;
+
+    if (ctx->CurrentMapCmd->FmtAttr_Input_Ptr == NULL)
+    {
+	    strcpy(FmtAttr.Name, IMRD_FMTATTR_NAME_UNKNOWN);
+		if(((nd_status = ND_Index_Node_Find( &node_ptr, IMRG_SDM_Base.RootFmtAttr,
+						 IMRD_SDMD_FMTATTR_IDX_NAME, &FmtAttr, NULL)) != NDS_OK)||
+			(node_ptr == NULL))
+		{
+		    snprintf(DescErr,sizeof(DescErr),SDMD_XML_LIB_ERROR_4,IMRD_SDMD_TAG_TYPE, FmtAttr.Name );
+		    SDM_RaiseError(ctx->SaxCtxHdl,&(ctx->FataError),&(ctx->flagerror), fonctionname , DescErr, SDMD_XML_CODE_ERROR_4 );
+		}
+		else
+		{
+		    ctx->CurrentMapCmd->FmtAttr_Input_Ptr = node_ptr->Value;
+		}
+	}
+    if (ctx->CurrentMapCmd->FmtAttr_Output_Ptr == NULL)
+    {
+	    strcpy(FmtAttr.Name, IMRD_FMTATTR_NAME_UNKNOWN);
+		if(((nd_status = ND_Index_Node_Find( &node_ptr, IMRG_SDM_Base.RootFmtAttr,
+						 IMRD_SDMD_FMTATTR_IDX_NAME, &FmtAttr, NULL)) != NDS_OK)||
+			(node_ptr == NULL))
+		{
+		    snprintf(DescErr,sizeof(DescErr),SDMD_XML_LIB_ERROR_4,IMRD_SDMD_TAG_TYPE, FmtAttr.Name );
+		    SDM_RaiseError(ctx->SaxCtxHdl,&(ctx->FataError),&(ctx->flagerror), fonctionname , DescErr, SDMD_XML_CODE_ERROR_4 );
+		}
+		else
+		{
+		    ctx->CurrentMapCmd->FmtAttr_Output_Ptr = node_ptr->Value;
+		}
+	}
+
+    memset(ctx->PathArray[ctx->PresentLevelTag],0,sizeof(IMRD_SDMD_SIZE_TAG_SIZE));
+    ctx->PresentLevelTag = ctx->PresentLevelTag - 1;
+  }
+  else if (strcmp((const char *)localname, IMRD_SDMD_TAG_COPIE) == 0)
+  {
+	ctx->CurrentMapCmd->TypeCmd = IMRD_MAPCMD_TYPE_COPY;
+    memset(ctx->PathArray[ctx->PresentLevelTag],0,sizeof(IMRD_SDMD_SIZE_TAG_SIZE));
+    ctx->PresentLevelTag = ctx->PresentLevelTag - 1;
+  }
+  else if (strcmp((const char *)localname, IMRD_SDMD_TAG_MAPCMD) == 0)
+  {
+	if(ctx->CurrentMapCmd->Ident_First_Msg_Ptr == NULL)
+	{
+		msg.Id = IMRD_MSG_ID_UNKNOWN;
+		if(((nd_status = ND_Index_Node_Find( &node_ptr, IMRG_SDM_Base.RootMsg,
+						 IMRD_SDMD_MSG_IDX_ID, &msg, NULL)) != NDS_OK)||
+			(node_ptr == NULL))
+		{
+		    snprintf(DescErr,sizeof(DescErr),SDMD_XML_LIB_ERROR_4,IMRD_SDMD_TAG_TYPE, "unknown" );
+		    SDM_RaiseError(ctx->SaxCtxHdl,&(ctx->FataError),&(ctx->flagerror), fonctionname , DescErr, SDMD_XML_CODE_ERROR_4 );
+		}
+		else
+		{
+		    ctx->CurrentMapCmd->Ident_First_Msg_Ptr = node_ptr->Value;
+		}
+	}
+
+	if (ctx->CurrentMapCmd->TypeCmd == IMRD_MAPCMD_TYPE_MAP)
+	{
+		status = SDM_Control_Fmt_Attr(ctx->CurrentMapCmd->MsgMap_Ptr->Msg_Input_Ptr,
+									  ctx->CurrentMapCmd->Fmt_Input_Ptr->FmtMsg_Struct_Ptr,
+									  ctx->CurrentMapCmd->FmtAttr_Input_Ptr);
+
+		if (status == IMRS_OK)
+		{
+			status = SDM_Control_Fmt_Attr(ctx->CurrentMapCmd->MsgMap_Ptr->Msg_Output_Ptr,
+										  ctx->CurrentMapCmd->Fmt_Output_Ptr->FmtMsg_Struct_Ptr,
+										  ctx->CurrentMapCmd->FmtAttr_Output_Ptr);
+
+			if (status != IMRS_OK)
+			{
+			    snprintf(DescErr,sizeof(DescErr),SDMD_LIB_ERROR_11 );
+			    SDM_RaiseError(ctx->SaxCtxHdl,&(ctx->FataError),&(ctx->flagerror), fonctionname , DescErr, SDMD_CODE_ERROR_11 );
+			}
+		}
+		else
+		{
+		    snprintf(DescErr,sizeof(DescErr),SDMD_LIB_ERROR_11 );
+		    SDM_RaiseError(ctx->SaxCtxHdl,&(ctx->FataError),&(ctx->flagerror), fonctionname , DescErr, SDMD_CODE_ERROR_11 );
+		}
+	}
+
+	ctx->CurrentMapCmd->MapCmd_Id = ctx->NbMapCmd;
+	if( ( nd_status = ND_DataStruct_Value_Add( ctx->CurrentMapPath->MapCmd_Struct_Ptr, (void *)(ctx->CurrentMapCmd))) != NDS_OK)
+	{
+	    snprintf(DescErr,sizeof(DescErr),SDMD_XML_LIB_ERROR_2,IMRD_SDMD_TAG_MAPCMD );
+	    SDM_RaiseError(ctx->SaxCtxHdl,&(ctx->FataError),&(ctx->flagerror), fonctionname , DescErr, SDMD_XML_CODE_ERROR_2 );
+	}
+	ctx->NbMapCmd++;
+    memset(ctx->PathArray[ctx->PresentLevelTag],0,sizeof(IMRD_SDMD_SIZE_TAG_SIZE));
+    ctx->PresentLevelTag = ctx->PresentLevelTag - 1;
+  }
+  else if (strcmp((const char *)localname, IMRD_SDMD_TAG_MAPPATH) == 0)
+  {
+	ctx->CurrentMapPath->idMapPath = ctx->NbMapPath;
+
+	if( ( nd_status = ND_DataStruct_Value_Add( ctx->RootMapPath, (void *)(ctx->CurrentMapPath))) != NDS_OK)
+	{
+	    snprintf(DescErr,sizeof(DescErr),SDMD_XML_LIB_ERROR_2,IMRD_SDMD_TAG_MAPPATH );
+	    SDM_RaiseError(ctx->SaxCtxHdl,&(ctx->FataError),&(ctx->flagerror), fonctionname , DescErr, SDMD_XML_CODE_ERROR_2 );
+	}
+	ctx->NbMapPath++;
+    memset(ctx->PathArray[ctx->PresentLevelTag],0,sizeof(IMRD_SDMD_SIZE_TAG_SIZE));
+    ctx->PresentLevelTag = ctx->PresentLevelTag - 1;
+  }
+  else if (strcmp((const char *)localname, IMRD_SDMD_TAG_VERSION) == 0)
+  {
+	IMRD_LM_LOG_INFO_1( "[MapPath]: [%s]", ctx->value);
+	status_tmp = SDM_Set_Struct_Version((IMRT_Data_Version *)ctx->RootMapPath->User_Ptr, (char *)ctx->value);
+  }
+
+}
+
+
+IMRT_Status endElementNsFmt ( SDMT_BufferInfo_Contexte * ctx, 
+		       const xmlChar *localname,
+		       const xmlChar *prefix,
+		       const xmlChar *URI)
+{
+    NDT_Node    * node_ptr;
+    NDT_Status    nd_status;
+    IMRT_Status status, status_tmp;
+    IMRT_Msg      message;
+    IMRT_FmtAttr  FmtAttr;
+    const char   functionname [] = "endElementNsFmt";
+    char         DescErr [IMRD_SDMD_DESCERR_LEN]; 
+
+   
+	if (strcmp((const char *)localname, IMRD_SDMD_TAG_NAME) == 0)
+	{
+		switch(ctx->PresentLevelTag)
+		{
+		  case IMRD_SDMD_LEVEL_TAG_0:
+		  {
+		  	strcpy(ctx->CurrentFormat->Name, ctx->value);
+			break;	
+		  }
+		  case IMRD_SDMD_LEVEL_TAG_1:
+		  {
+		    /*recherch du message avec le nom*/
+		    strcpy(message.Name, ctx->value);
+		    if(((nd_status = ND_Index_Node_Find( &node_ptr, IMRG_SDM_Base.RootMsg,
+						     IMRD_SDMD_MSG_IDX_NAME, &message, NULL)) != NDS_OK)||
+			   (node_ptr == NULL))
+		    {
+				snprintf(DescErr,sizeof(DescErr),SDMD_XML_LIB_ERROR_5, IMRD_SDMD_TAG_FORMAT);
+			    SDM_RaiseError(ctx->SaxCtxHdl,&(ctx->FataError),&(ctx->flagerror), functionname, DescErr, SDMD_XML_CODE_ERROR_5 );
+		    }
+		    else
+		    {
+		    	ctx->CurrentFmtMsg->Msg_Ptr = node_ptr->Value;
+		    }
+
+			break;	
+		  }
+		
+		  default:
+		  {
+		    snprintf(DescErr, sizeof(DescErr), SDMD_XML_LIB_ERROR_10, SDMD_FORMAT_FILE);
+		    SDM_RaiseError(ctx->SaxCtxHdl,&(ctx->FataError),&(ctx->flagerror), functionname , DescErr, SDMD_XML_CODE_ERROR_10);
+		  }
+		} /* end switch */
+	}
+	else if (strcmp((const char *)localname, IMRD_SDMD_TAG_BRANCHE_ID) == 0)
+	{
+		ctx->CurrentFmtMsg->Branche_Id = atoi(ctx->value);
+	}
+	else if (strcmp((const char *)localname, IMRD_SDMD_TAG_FMTATTR_NAME) == 0)
+	{
+	    strcpy(FmtAttr.Name, ctx->value);
+		if(((nd_status = ND_Index_Node_Find( &node_ptr, IMRG_SDM_Base.RootFmtAttr,
+						 IMRD_SDMD_FMTATTR_IDX_NAME, &FmtAttr, NULL)) != NDS_OK)||
+			(node_ptr == NULL))
+		{
+		    snprintf(DescErr,sizeof(DescErr),SDMD_XML_LIB_ERROR_4,IMRD_SDMD_TAG_TYPE, FmtAttr.Name );
+		    SDM_RaiseError(ctx->SaxCtxHdl,&(ctx->FataError),&(ctx->flagerror), functionname , DescErr, SDMD_XML_CODE_ERROR_4 );
+		}
+		else
+		{
+		    ctx->CurrentFmtMsg->FmtAttr_Ptr = node_ptr->Value;
+		}
+	}
+	else if (strcmp((const char *)localname, IMRD_SDMD_TAG_FORMAT) == 0)
+	{
+
+		/*insertion du format*/
+		ctx->CurrentFormat->Id =  ctx->CptFmt;
+		if( ( nd_status = ND_DataStruct_Value_Add( ctx->RootFormat, (void  *)(ctx->CurrentFormat))) != NDS_OK)
+		{
+		    snprintf(DescErr,sizeof(DescErr),SDMD_XML_LIB_ERROR_5,IMRD_SDMD_TAG_FORMAT);
+		    SDM_RaiseError(ctx->SaxCtxHdl,&(ctx->FataError),&(ctx->flagerror), functionname, DescErr, SDMD_XML_CODE_ERROR_5 );
+		}
+		ctx->CptFmt ++;
+	    memset(ctx->PathArray[ctx->PresentLevelTag],0,sizeof(IMRD_SDMD_SIZE_TAG_SIZE));
+		ctx->PresentLevelTag = ctx->PresentLevelTag - 1;
+	}
+	else if (strcmp((const char *)localname, IMRD_SDMD_TAG_FMTMSG) == 0)
+	{
+		if( ( nd_status = ND_DataStruct_Value_Add( ctx->CurrentFormat->FmtMsg_Struct_Ptr, (void  *)(ctx->CurrentFmtMsg))) != NDS_OK)
+		{
+			snprintf(DescErr,sizeof(DescErr),SDMD_XML_LIB_ERROR_5, IMRD_SDMD_TAG_FMTMSG);
+			SDM_RaiseError(ctx->SaxCtxHdl,&(ctx->FataError),&(ctx->flagerror), functionname, DescErr, SDMD_XML_CODE_ERROR_5 );
+		}
+	    memset(ctx->PathArray[ctx->PresentLevelTag],0,sizeof(IMRD_SDMD_SIZE_TAG_SIZE));
+		ctx->PresentLevelTag = ctx->PresentLevelTag - 1;
+	}
+	else if (strcmp((const char *)localname, IMRD_SDMD_TAG_VERSION) == 0)
+	{
+		IMRD_LM_LOG_INFO_1( "[Fmt]: [%s]", ctx->value);
+		status_tmp = SDM_Set_Struct_Version((IMRT_Data_Version *)ctx->RootFormat->User_Ptr, (char *)ctx->value);
+	}
+}
+
+
+
+IMRT_Status Buff_Info_characters(SDMT_BufferInfo_Contexte * ctx , const xmlChar *ch, int len)
+{
+    char output[40];
+    int i;
+    
+    memset(ctx->value,0, sizeof(ctx->value));
+    
+    for (i = 0;(i<len) && (i < IMRD_SDMD_VALUE_LEN);i++)
+	ctx->value[i] = ch[i];
+    ctx->value[i] = 0;
+}
+
+
+
+IMRT_Status SDM_XML_Load_Appli( char *demo_file, SDMT_BufferInfo_Contexte *mycontexte)
+{
+    IMRT_Status     status;
+    NDT_Status      nd_status;
+    char * docname = NULL;
+    NDT_Index_Type  *index_type_ptr;
+    xmlDocPtr doc = NULL;
+    xmlDtdPtr dtd;
+    xmlParserCtxtPtr ctxt =NULL;
+    xmlSAXHandlerPtr SAXHandler;
+    xmlSAXHandlerPtr SAXHandler_Sav;
+    const char functionname []="SDM_XML_Load_Appli";
+    char DescErr[IMRD_SDMD_DESCERR_LEN];
+	IMRT_Data_Version   *Data_Version_Ptr;
+
+    LIBXML_TEST_VERSION
+	xmlKeepBlanksDefault(0);	
+    xmlSAXDefaultVersion(2);
+    xmlLineNumbersDefault(1);
+	
+    status = IMRS_OK;
+    docname = demo_file;
+    ctxt = xmlNewParserCtxt();
+    /*initialisation des indexes*/
+    index_type_ptr =  Appl_Struct_initial_idx_tab;
+  
+
+    if(ctxt != NULL)
+    {
+		mycontexte->flagerror  = IMRS_OK;
+		SAXHandler            = &SaxAppliHandlerStruct;
+		mycontexte->SaxCtxHdl = ctxt;
+		ctxt->userData        = mycontexte;
+		SAXHandler_Sav        = ctxt->sax;
+		ctxt->sax             = SAXHandler;
+		ctxt->sax2            = 1 ;
+	    
+		Data_Version_Ptr = (IMRT_Data_Version *) malloc(sizeof(IMRT_Data_Version));
+		Data_Version_Ptr->Label[0] = '\0';
+		Data_Version_Ptr->Date[0] = '\0';
+		if( ( nd_status = ND_DataStruct_Open(&(mycontexte->RootAppli),IMRD_SDMD_APPL_STRUCT_IDX_NB,index_type_ptr, "SDM_Appl_Manager",SDM_Appl_Manager, NULL, NULL, NULL, NULL,0, Data_Version_Ptr)) != NDS_OK)
+		{
+		    status = IMRS_KO;
+		    snprintf(DescErr,sizeof(DescErr),SDMD_XML_LIB_ERROR_5,IMRD_SDMD_TAG_APPLI);
+		    SDM_RaiseError(mycontexte->SaxCtxHdl,&(mycontexte->FataError),&(mycontexte->flagerror), functionname, DescErr, SDMD_XML_CODE_ERROR_5 );
+		}
+		else
+		{
+		    doc = xmlCtxtReadFile(ctxt,docname,NULL,XML_PARSE_DTDATTR+XML_PARSE_DTDVALID);
+		    if (ctxt->lastError.code != XML_ERR_OK)
+		    {
+		    	status = IMRS_KO;
+		    	IMRD_LM_LOG_ERROR_3( "Erreur de parsing du fichier (%s): (%s) line (%d) !", docname, ctxt->lastError.message, ctxt->lastError.line);
+		    }
+			else if(mycontexte->flagerror != IMRS_OK)
+			{
+				status = IMRS_KO;
+				IMRD_LM_LOG_ERROR_1( "%s !", mycontexte->FataError.libError);
+			}
+		    else
+		    {
+				index_type_ptr =Appl_Struct_final_idx_tab;
+				status = SDM_DataStruct_Finalize(mycontexte->RootAppli,index_type_ptr, IMRD_SDMD_APPL_STRUCT_IDX_NB);
+				/*SDM_DataStruct_Dump(mycontexte->RootAppli);*/
+			}
+		}
+
+		if((status != IMRS_OK)&&(mycontexte->RootAppli != NULL))
+		{
+			free(mycontexte->RootAppli->User_Ptr);
+			nd_status = ND_DataStruct_Close(mycontexte->RootAppli);
+		}
+
+	    ctxt->sax = SAXHandler_Sav ;
+	    xmlFreeParserCtxt(ctxt);
+    }
+    else
+    {
+		status = IMRS_KO;
+    }
+
+	return(status);
+
+}
+
+
+IMRT_Status  SDM_XML_Load_FmtAttr( char *demo_file, SDMT_BufferInfo_Contexte *mycontexte)
+{
+    IMRT_Status     status;
+    NDT_Status      nd_status;
+    char * docname = NULL;
+    NDT_Index_Type  *index_type_ptr;
+    xmlDocPtr doc = NULL;
+    xmlDtdPtr dtd;
+    xmlParserCtxtPtr ctxt =NULL;
+    xmlSAXHandlerPtr SAXHandler;
+    xmlSAXHandlerPtr SAXHandler_Sav;
+    const char functionname[]= "SDM_XML_Load_FmtAttr";
+    char DescErr[IMRD_SDMD_DESCERR_LEN];
+	IMRT_Data_Version   *Data_Version_Ptr;
+
+    LIBXML_TEST_VERSION
+	xmlKeepBlanksDefault(0);	
+    xmlSAXDefaultVersion(2);
+    xmlLineNumbersDefault(1);
+	
+    status = IMRS_OK;
+    docname = demo_file;
+    ctxt = xmlNewParserCtxt();
+    /*initialisation des indexes*/
+    index_type_ptr =  FmtAttr_Struct_initial_idx_tab;
+  
+    if(ctxt != NULL)
+    {
+	mycontexte->flagerror  = IMRS_OK;
+	SAXHandler            = &SaxFmtAttrHandlerStruct;
+	mycontexte->SaxCtxHdl = ctxt;
+	ctxt->userData        = mycontexte;
+	SAXHandler_Sav        = ctxt->sax;
+	ctxt->sax             = SAXHandler;
+	ctxt->sax2            = 1 ;
+
+	Data_Version_Ptr = (IMRT_Data_Version *) malloc(sizeof(IMRT_Data_Version));
+	Data_Version_Ptr->Label[0] = '\0';
+	Data_Version_Ptr->Date[0] = '\0';
+	if( ( nd_status = ND_DataStruct_Open(&(mycontexte->RootFmtAttr),IMRD_SDMD_FMTATTR_STRUCT_IDX_NB,index_type_ptr, "SDM_FmtAttr_Manager",SDM_FmtAttr_Manager, NULL, NULL, NULL, NULL,0, Data_Version_Ptr)) != NDS_OK)
+	{
+	    status = IMRS_KO;
+	    snprintf(DescErr,sizeof(DescErr),SDMD_XML_LIB_ERROR_5,IMRD_SDMD_TAG_FMTATTR);
+	    SDM_RaiseError(mycontexte->SaxCtxHdl,&(mycontexte->FataError),&(mycontexte->flagerror), functionname, DescErr, SDMD_XML_CODE_ERROR_5 );
+	}
+	else
+	{
+	    doc = xmlCtxtReadFile(ctxt,docname,NULL,XML_PARSE_DTDATTR+XML_PARSE_DTDVALID);
+	    if (ctxt->lastError.code != XML_ERR_OK)
+	    {
+	    	status = IMRS_KO;
+	    	IMRD_LM_LOG_ERROR_3( "Erreur de parsing du fichier (%s): (%s) line (%d) !", docname, ctxt->lastError.message, ctxt->lastError.line);
+	    }
+		else if(mycontexte->flagerror != IMRS_OK)
+		{
+			status = IMRS_KO;
+			IMRD_LM_LOG_ERROR_1( "%s !", mycontexte->FataError.libError);
+		}
+	    else
+	    {
+			index_type_ptr = FmtAttr_Struct_final_idx_tab;
+			status = SDM_DataStruct_Finalize(mycontexte->RootFmtAttr, index_type_ptr, IMRD_SDMD_FMTATTR_STRUCT_IDX_NB);
+			/*SDM_DataStruct_Dump( mycontexte->RootFmtAttr);*/
+		}
+	}
+
+	if((status != IMRS_OK)&&(mycontexte->RootFmtAttr != NULL))
+	{
+		free(mycontexte->RootFmtAttr->User_Ptr);
+		nd_status = ND_DataStruct_Close(mycontexte->RootFmtAttr);
+	}
+
+	ctxt->sax = SAXHandler_Sav ;
+    xmlFreeParserCtxt(ctxt);
+    }
+    else
+    {
+		status = IMRS_KO;
+    }
+
+	return(status);
+
+}
+
+
+
+IMRT_Status  SDM_XML_Load_Format( char *demo_file, SDMT_BufferInfo_Contexte *mycontexte)
+{
+    IMRT_Status     status;
+    NDT_Status      nd_status;
+    char * docname = NULL;
+    NDT_Index_Type  *index_type_ptr;
+    xmlDocPtr doc = NULL;
+    xmlDtdPtr dtd;
+    xmlParserCtxtPtr ctxt =NULL;
+    xmlSAXHandlerPtr SAXHandler_Sav;
+    xmlSAXHandlerPtr SAXHandler;
+    const char functionname[]= "SDM_XML_Load_Format";
+    char DescErr[IMRD_SDMD_DESCERR_LEN];
+	IMRT_Data_Version   *Data_Version_Ptr;
+
+    LIBXML_TEST_VERSION
+	xmlKeepBlanksDefault(0);	
+    xmlSAXDefaultVersion(2);
+    xmlLineNumbersDefault(1);
+	
+    status = IMRS_OK;
+    docname = demo_file;
+    ctxt = xmlNewParserCtxt();
+    /*initialisation des indexes*/
+    index_type_ptr =  Fmt_Struct_initial_idx_tab;
+  
+    if(ctxt != NULL)
+    {
+	mycontexte->flagerror  = IMRS_OK;
+	SAXHandler            = &SaxFmtHandlerStruct;
+	mycontexte->SaxCtxHdl = ctxt;
+	ctxt->userData        = mycontexte;
+	SAXHandler_Sav        = ctxt->sax;
+	ctxt->sax             = SAXHandler;
+	ctxt->sax2            = 1 ;
+    
+	Data_Version_Ptr = (IMRT_Data_Version *) malloc(sizeof(IMRT_Data_Version));
+	Data_Version_Ptr->Label[0] = '\0';
+	Data_Version_Ptr->Date[0] = '\0';
+	if( ( nd_status = ND_DataStruct_Open(&(mycontexte->RootFormat),IMRD_SDMD_FMT_STRUCT_IDX_NB,index_type_ptr, "SDM_Fmt_Manager",SDM_Fmt_Manager, NULL, NULL, NULL, NULL,0, Data_Version_Ptr)) != NDS_OK)
+	{
+	    status = IMRS_KO;
+	    snprintf(DescErr,sizeof(DescErr),SDMD_XML_LIB_ERROR_5,IMRD_SDMD_TAG_FORMAT);
+	    SDM_RaiseError(mycontexte->SaxCtxHdl,&(mycontexte->FataError),&(mycontexte->flagerror), functionname, DescErr, SDMD_XML_CODE_ERROR_5 );
+	}
+	else
+	{
+	    doc = xmlCtxtReadFile(ctxt,docname,NULL,XML_PARSE_DTDATTR+XML_PARSE_DTDVALID);
+	    if (ctxt->lastError.code != XML_ERR_OK)
+	    {
+	    	status = IMRS_KO;
+	    	IMRD_LM_LOG_ERROR_3( "Erreur de parsing du fichier (%s): (%s) line (%d) !", docname, ctxt->lastError.message, ctxt->lastError.line);
+	    }
+		else if(mycontexte->flagerror != IMRS_OK)
+		{
+			status = IMRS_KO;
+			IMRD_LM_LOG_ERROR_1( "%s !", mycontexte->FataError.libError);
+		}
+	    else
+	    {
+			index_type_ptr = Fmt_Struct_final_idx_tab;
+			status = SDM_DataStruct_Finalize(mycontexte->RootFormat, index_type_ptr, IMRD_SDMD_FMT_STRUCT_IDX_NB);
+			/*SDM_DataStruct_Dump( mycontexte->RootFormat);*/
+		}
+	}
+
+	if((status != IMRS_OK)&&(mycontexte->RootFormat != NULL))
+	{
+		free(mycontexte->RootFormat->User_Ptr);
+		nd_status = ND_DataStruct_Close(mycontexte->RootFormat);
+	}
+
+	ctxt->sax = SAXHandler_Sav ;
+    xmlFreeParserCtxt(ctxt);
+    }
+    else
+    {
+		status = IMRS_KO;
+    }
+
+	return(status);
+
+}
+
+
+
+IMRT_Status SDM_XML_Load_MapPath( char *demo_file, SDMT_BufferInfo_Contexte *mycontexte)
+{
+    IMRT_Status    status;
+    NDT_Status     nd_status;
+    char * docname = NULL;
+    NDT_Index_Type  *index_type_ptr;
+    xmlDocPtr doc = NULL;
+    xmlDtdPtr dtd;
+    xmlParserCtxtPtr ctxt =NULL;
+    xmlSAXHandlerPtr SAXHandler;
+    xmlSAXHandlerPtr SAXHandler_Sav;
+    const char functionname []="SDM_XML_Load_MapPath";
+    char DescErr[IMRD_SDMD_DESCERR_LEN];
+	IMRT_Data_Version   *Data_Version_Ptr;
+
+
+    LIBXML_TEST_VERSION
+	xmlKeepBlanksDefault(0);	
+    xmlSAXDefaultVersion(2);
+    xmlLineNumbersDefault(1);
+	
+    status = IMRS_OK;
+    docname = demo_file;
+    ctxt = xmlNewParserCtxt();
+    /*initialisation des indexes*/
+    index_type_ptr = index_type_initial_tab;
+  
+    if(ctxt != NULL)
+    {
+	mycontexte->flagerror  = IMRS_OK;
+	SAXHandler            = &SaxMapPathHandlerStruct;
+	mycontexte->SaxCtxHdl = ctxt;
+	ctxt->userData        = mycontexte;
+	SAXHandler_Sav        = ctxt->sax ;
+	ctxt->sax             = SAXHandler;
+	ctxt->sax2            = 1 ;
+
+	Data_Version_Ptr = (IMRT_Data_Version *) malloc(sizeof(IMRT_Data_Version));
+	Data_Version_Ptr->Label[0] = '\0';
+	Data_Version_Ptr->Date[0] = '\0';
+	if( ( nd_status = ND_DataStruct_Open(&(mycontexte->RootMapPath), IMRD_SDMD_INDEX_NB, index_type_ptr, "SDM_MapPath_Manager",SDM_MapPath_Manager, NULL, NULL, NULL, NULL,0, Data_Version_Ptr)) != NDS_OK)
+	{
+	    status = IMRS_KO;
+	    snprintf(DescErr,sizeof(DescErr),SDMD_XML_LIB_ERROR_5,IMRD_SDMD_TAG_MAPPATH);
+	    SDM_RaiseError(mycontexte->SaxCtxHdl,&(mycontexte->FataError),&(mycontexte->flagerror), functionname, DescErr, SDMD_XML_CODE_ERROR_5 );
+	}
+	else
+	{
+	    doc = xmlCtxtReadFile(ctxt,docname,NULL,XML_PARSE_DTDATTR+XML_PARSE_DTDVALID);
+	    if (ctxt->lastError.code != XML_ERR_OK)
+	    {
+	    	status = IMRS_KO;
+	    	IMRD_LM_LOG_ERROR_3( "Erreur de parsing du fichier (%s): (%s) line (%d) !", docname, ctxt->lastError.message, ctxt->lastError.line);
+	    }
+		else if(mycontexte->flagerror != IMRS_OK)
+		{
+			status = IMRS_KO;
+			IMRD_LM_LOG_ERROR_1( "%s !", mycontexte->FataError.libError);
+		}
+	    else
+	    {
+			/*SDM_DataStruct_Dump(mycontexte->RootMapPath);*/
+		}
+	}
+
+	if(status != IMRS_OK)
+	{
+	    if(mycontexte->CurrentMapPath != NULL)
+            {
+		if(mycontexte->CurrentMapPath->MapCmd_Struct_Ptr != NULL)
+		{
+		  nd_status = ND_DataStruct_Close(mycontexte->CurrentMapPath->MapCmd_Struct_Ptr);
+                  if(nd_status == NDS_OK)
+		  {
+		      free(mycontexte->CurrentMapPath);
+                  }  
+                }
+            }
+            if(mycontexte->CurrentMapCmd != NULL)
+            {
+		     free(mycontexte->CurrentMapCmd);
+            }
+
+            if(mycontexte->CurrentFormat != NULL)
+            {
+		if(mycontexte->CurrentFormat->FmtMsg_Struct_Ptr != NULL)
+		{
+		    nd_status = ND_DataStruct_Close(mycontexte->CurrentFormat->FmtMsg_Struct_Ptr);
+		    if(nd_status == NDS_OK)
+		    {
+			free(mycontexte->CurrentFormat);
+		    }  
+                }		 
+ 
+            }
+            
+            if(mycontexte->CurrentFmtMsg != NULL)
+            {
+		free(mycontexte->CurrentFmtMsg);
+            }
+            if (mycontexte->CurrentAppli  != NULL)
+            {
+                free(mycontexte->CurrentAppli);
+            }
+
+	    if(mycontexte->RootMapPath != NULL)
+	    {
+	    free(mycontexte->RootMapPath->User_Ptr);
+		nd_status = ND_DataStruct_Close(mycontexte->RootMapPath);
+	    }
+
+	    if(mycontexte->RootFormat != NULL)
+	    {
+	    free(mycontexte->RootFormat->User_Ptr);
+		nd_status = ND_DataStruct_Close(mycontexte->RootFormat);
+	    }
+
+		if(mycontexte->RootFmtAttr != NULL)
+		{
+			free(mycontexte->RootFmtAttr->User_Ptr);
+			nd_status = ND_DataStruct_Close(mycontexte->RootFmtAttr);
+		}
+
+	    if(mycontexte->RootAppli != NULL)
+	    {
+	    free(mycontexte->RootAppli->User_Ptr);
+		nd_status = ND_DataStruct_Close(mycontexte->RootAppli);
+	    }
+	}
+
+	ctxt->sax = SAXHandler_Sav ;
+    xmlFreeParserCtxt(ctxt);
+  } /* end if(ctxt != NULL) */
+  else
+  {
+  	status = IMRS_KO;
+  }
+
+  return(status);
+
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  SDM_XML_Dump_FmtAttr_Header(FILE *dump_file)
+{
+	fprintf(dump_file, "<?xml version=\"1.0\" ?>\n");
+	fprintf(dump_file, "<!-- FmtAttr Struct definitions -->\n");
+	fprintf(dump_file, "<%s>\n", IMRD_SDMD_FMTATTR_STRUCT);
+	fprintf(dump_file, "<version>@(#) VERSIONIMR: $Label:  $   $Date: 2008/11/12 02:25:23 $   $Workfile:   buffer_info_xml.c  $</version>\n", 
+				((IMRT_Data_Version *)IMRG_SDM_Base.RootFmtAttr->User_Ptr)->Label,
+				((IMRT_Data_Version *)IMRG_SDM_Base.RootFmtAttr->User_Ptr)->Date);
+	return( IMRS_OK);
+
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  SDM_XML_Dump_FmtAttr_Body(FILE *dump_file)
+{
+	IMRT_Status  status;
+	NDT_Status  nd_status;
+
+	if( ( nd_status = ND_DataStruct_Traverse( IMRG_SDM_Base.RootFmtAttr, IMRD_SDMD_CMD_API_XML_DUMP, dump_file)) != NDS_OK)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_1( "XML Dump RootFmtAttr failed (%d) !", nd_status);
+	}
+	else
+	{
+		status = IMRS_OK;
+	}
+
+	return(status);
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  SDM_XML_Dump_FmtAttr_Footer(FILE *dump_file)
+{
+	fprintf(dump_file, "<!-- FmtAttr Struct definitions footer -->\n");
+	fprintf(dump_file, "</%s>\n", IMRD_SDMD_FMTATTR_STRUCT);
+	return( IMRS_OK);
+
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  SDM_XML_Dump_FmtAttr(void)
+{
+	IMRT_Status     status;
+	char	    dump_filename[255];
+	FILE	   *dump_file;
+
+	strcpy(dump_filename, SDMD_FMTATTR_FILE);
+
+	if( ( dump_file = fopen( dump_filename, "w")) == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_1( "Can't open dump file (%s) !", dump_filename);
+	}
+	else
+	{
+		status = SDM_XML_Dump_FmtAttr_Header(dump_file);
+		if(status == IMRS_OK)
+		{
+			status = SDM_XML_Dump_FmtAttr_Body(dump_file);
+			if(status == IMRS_OK)
+			{
+				status = SDM_XML_Dump_FmtAttr_Footer(dump_file);
+			}
+		}
+
+		fclose( dump_file);
+	}
+
+	return(status);
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  SDM_XML_Dump_Appli_Header(FILE *dump_file)
+{
+	fprintf(dump_file, "<?xml version=\"1.0\" ?>\n");
+	fprintf(dump_file, "<!-- Appl Struct definitions -->\n");
+	fprintf(dump_file, "<%s>\n", IMRD_SDMD_APPLI_STRUCT);
+	fprintf(dump_file, "<version>@(#) VERSIONIMR: $Label:  $   $Date: 2008/11/12 02:25:23 $   $Workfile:   buffer_info_xml.c  $</version>\n", 
+				((IMRT_Data_Version *)IMRG_SDM_Base.RootAppl->User_Ptr)->Label,
+				((IMRT_Data_Version *)IMRG_SDM_Base.RootAppl->User_Ptr)->Date);
+	return( IMRS_OK);
+
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  SDM_XML_Dump_Appli_Body(FILE *dump_file)
+{
+	IMRT_Status  status;
+	NDT_Status  nd_status;
+
+	if( ( nd_status = ND_DataStruct_Traverse( IMRG_SDM_Base.RootAppl, IMRD_SDMD_CMD_API_XML_DUMP, dump_file)) != NDS_OK)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_1( "XML Dump RootAppl failed (%d) !", nd_status);
+	}
+	else
+	{
+		status = IMRS_OK;
+	}
+
+	return(status);
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  SDM_XML_Dump_Appli_Footer(FILE *dump_file)
+{
+	fprintf(dump_file, "<!-- Appl Struct definitions footer -->\n");
+	fprintf(dump_file, "</%s>\n", IMRD_SDMD_APPLI_STRUCT);
+	return( IMRS_OK);
+
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  SDM_XML_Dump_Appli(void)
+{
+	IMRT_Status     status;
+	char	    dump_filename[255];
+	FILE	   *dump_file;
+
+	strcpy(dump_filename, SDMD_APPLI_FILE);
+
+	if( ( dump_file = fopen( dump_filename, "w")) == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_1( "Can't open dump file (%s) !", dump_filename);
+	}
+	else
+	{
+		status = SDM_XML_Dump_Appli_Header(dump_file);
+		if(status == IMRS_OK)
+		{
+			status = SDM_XML_Dump_Appli_Body(dump_file);
+			if(status == IMRS_OK)
+			{
+				status = SDM_XML_Dump_Appli_Footer(dump_file);
+			}
+		}
+
+		fclose( dump_file);
+	}
+
+	return(status);
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  SDM_XML_Dump_Format_Header(FILE *dump_file)
+{
+	fprintf(dump_file, "<?xml version=\"1.0\" ?>\n");
+	fprintf(dump_file, "<!-- Fmt Struct definitions -->\n");
+	fprintf(dump_file, "<%s>\n", IMRD_SDMD_FMT_STRUCT);
+	fprintf(dump_file, "<version>@(#) VERSIONIMR: $Label:  $   $Date: 2008/11/12 02:25:23 $   $Workfile:   buffer_info_xml.c  $</version>\n",
+				((IMRT_Data_Version *)IMRG_SDM_Base.RootFmt->User_Ptr)->Label,
+				((IMRT_Data_Version *)IMRG_SDM_Base.RootFmt->User_Ptr)->Date);
+	return( IMRS_OK);
+
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  SDM_XML_Dump_Format_Body(FILE *dump_file)
+{
+	IMRT_Status  status;
+	NDT_Status  nd_status;
+
+	if( ( nd_status = ND_DataStruct_Traverse( IMRG_SDM_Base.RootFmt, IMRD_SDMD_CMD_API_XML_DUMP, dump_file)) != NDS_OK)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_1( "XML Dump RootFmt failed (%d) !", nd_status);
+	}
+	else
+	{
+		status = IMRS_OK;		
+	}
+
+	return(status);
+
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  SDM_XML_Dump_Format_Footer(FILE *dump_file)
+{
+	fprintf(dump_file, "<!-- Fmt Struct definitions footer -->\n");
+	fprintf(dump_file, "</%s>\n", IMRD_SDMD_FMT_STRUCT);
+	return( IMRS_OK);
+
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  SDM_XML_Dump_Format(void)
+{
+	IMRT_Status     status;
+	char	    dump_filename[255];
+	FILE	   *dump_file;
+
+	strcpy(dump_filename, SDMD_FORMAT_FILE);
+
+	if( ( dump_file = fopen( dump_filename, "w")) == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_1( "Can't open dump file (%s) !", dump_filename);
+	}
+	else
+	{
+		status = SDM_XML_Dump_Format_Header(dump_file);
+		if(status == IMRS_OK)
+		{
+			status = SDM_XML_Dump_Format_Body(dump_file);
+			if(status == IMRS_OK)
+			{
+				status = SDM_XML_Dump_Format_Footer(dump_file);
+			}
+		}
+
+		fclose( dump_file);
+	}
+
+	return(status);
+
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  SDM_XML_Dump_MapPath_Header(FILE *dump_file)
+{
+	fprintf(dump_file, "<?xml version=\"1.0\" ?>\n");
+	fprintf(dump_file, "<!-- MapPath Struct definitions -->\n");
+	fprintf(dump_file, "<%s>\n", IMRD_SDMD_MAPPATH_STRUCT);
+	fprintf(dump_file, "<version>@(#) VERSIONIMR: $Label:  $   $Date: 2008/11/12 02:25:23 $   $Workfile:   buffer_info_xml.c  $</version>\n", 
+				((IMRT_Data_Version *)IMRG_SDM_Base.RootMapPath->User_Ptr)->Label,
+				((IMRT_Data_Version *)IMRG_SDM_Base.RootMapPath->User_Ptr)->Date);
+	return( IMRS_OK);
+
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  SDM_XML_Dump_MapPath_Body(FILE *dump_file)
+{
+	IMRT_Status  status;
+	NDT_Status  nd_status;
+
+	if( ( nd_status = ND_DataStruct_Traverse( IMRG_SDM_Base.RootMapPath, IMRD_SDMD_CMD_API_XML_DUMP, dump_file)) != NDS_OK)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_1( "XML Dump RootMapPath failed (%d) !", nd_status);
+	}
+	else
+	{
+		status = IMRS_OK;		
+	}
+
+	return(status);
+
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  SDM_XML_Dump_MapPath_Footer(FILE *dump_file)
+{
+	fprintf(dump_file, "<!-- MapPath Struct definitions footer -->\n");
+	fprintf(dump_file, "</%s>\n", IMRD_SDMD_MAPPATH_STRUCT);
+	return( IMRS_OK);
+
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  SDM_XML_Dump_MapPath(void)
+{
+	IMRT_Status  status;
+	char	    dump_filename[255];
+	FILE	   *dump_file;
+
+	strcpy(dump_filename, SDMD_MAPPATH_FILE);
+
+	if( ( dump_file = fopen( dump_filename, "w")) == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_1( "Can't open dump file (%s) !", dump_filename);
+	}
+	else
+	{
+		status = SDM_XML_Dump_MapPath_Header(dump_file);
+		if(status == IMRS_OK)
+		{
+			status = SDM_XML_Dump_MapPath_Body(dump_file);
+			if(status == IMRS_OK)
+			{
+				status = SDM_XML_Dump_MapPath_Footer(dump_file);
+			}
+		}
+
+		fclose( dump_file);
+	}
+
+	return(status);
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  SDM_XML_BufferInfo_Dump(void)
+{
+	IMRT_Status  status;
+
+	status = SDM_XML_Dump_Appli();
+	if(status == IMRS_OK)
+	{
+		status = SDM_XML_Dump_Format();
+		if(status == IMRS_OK)
+		{
+			status = SDM_XML_Dump_MapPath();
+			if(status == IMRS_OK)
+			{
+				status = SDM_XML_Dump_FmtAttr();
+			}
+		}
+	}
+
+	return(status);
+
+}
+
+/*----------------------------------------------------------------------------*/
+/*                                                                            */
+/*----------------------------------------------------------------------------*/
+IMRT_Status  SDM_ConvertAttribute(char * Attribute_ptr, char * Attribute_convert_ptr)
+{
+	
+    char * read_ptr ;
+    char * write_ptr; 
+    IMRT_Status status;
+    char *unescaped;
+    char   sHexa[4];
+
+    status = IMRS_OK;
+
+    for( read_ptr = Attribute_ptr, write_ptr =Attribute_convert_ptr ; *read_ptr != '\0'; read_ptr++, write_ptr++)
+	{
+
+		if (*read_ptr == '%')
+		{
+			memset(sHexa, '\0', sizeof(sHexa));
+			strncpy(sHexa, read_ptr, 3); 
+			write_ptr = (char *)xmlURIUnescapeString(sHexa, strlen(sHexa), write_ptr);
+			read_ptr ++;
+			read_ptr ++;
+		}
+		else
+		{
+			if( ( *read_ptr == '\\') && ( *(read_ptr+1) != '\0') )
+			{
+				switch( *( read_ptr + 1))
+				{
+					case 'n':
+					{
+						*write_ptr = '\n';
+						break;
+					}
+	
+					case 't':
+					{
+						*write_ptr = '\t';
+						break;
+					}
+	
+					case '\\':
+					{
+						*write_ptr = '\\';
+						break;
+					}
+	
+					case 'r':
+					{
+						*write_ptr = '\r';
+						break;
+					}
+	
+					case 'T':
+					{
+						*write_ptr = 'T';
+						break;
+					}
+	
+					case 'S':
+					{
+						*write_ptr = 'S';
+						break;
+					}
+	
+					default:
+					{
+						*write_ptr = '?';
+						break;
+					}
+				}
+	
+				read_ptr++;
+			}
+			else
+			{
+				if (( *read_ptr == '\n') || (*read_ptr == '\t'))
+				{
+	//				*write_ptr = '';
+				}
+				else
+				{
+					*write_ptr = *read_ptr;
+				}
+			}
+		}
+	}
+
+	*write_ptr = '\0';
+
+	return(status);
+}
+
+
+IMRT_Status  SDM_ConvertAttributeInv(char * Attrinute_Ptr, char * Attribute_convert_ptr)
+{
+    const xmlChar * string_to_escape = (xmlChar *)Attrinute_Ptr;
+    const xmlChar * list = (xmlChar *)"TS";
+    xmlChar * Ret=NULL;
+
+    memset(Attribute_convert_ptr, '\0', IMRD_FMTATTR_VALUE_SIZE);
+    Ret = xmlURIEscapeStr(string_to_escape, list);
+    if (Ret != NULL)
+    {
+    	strcpy(Attribute_convert_ptr, (char *)Ret);
+    }
+    xmlFree(Ret);
+
+    return(IMRS_OK);
+}
+
+
+IMRT_Status  SDM_Control_Fmt_Attr(IMRT_Msg * Msg_Ptr, NDT_Root * FmtMsg_Struct_Ptr, IMRT_FmtAttr  * FmtAttr_Ptr)
+{
+    IMRT_Status status;
+	NDT_Status  nd_status;
+
+	status = IMRS_OK;
+
+	if (strcmp(FmtAttr_Ptr->Name , IMRD_FMTATTR_NAME_UNKNOWN) != 0)
+	{
+		nd_status = ND_DataStruct_Traverse(FmtMsg_Struct_Ptr, IMRD_SDMD_CMD_CHECK_FMT_ATTR, Msg_Ptr, FmtAttr_Ptr);
+		if (nd_status == NDS_NODE_FOUND)
+		{
+			status = IMRS_OK;
+		}
+		else
+		{
+			status = IMRS_KO;
+		}
+	}
+
+	return(status);
+}
diff --git a/src/libstatic_data_mng/src/buffer_info_xml.h b/src/libstatic_data_mng/src/buffer_info_xml.h
new file mode 100644
index 0000000..599cd00
--- /dev/null
+++ b/src/libstatic_data_mng/src/buffer_info_xml.h
@@ -0,0 +1,426 @@
+/*----------------------------------------------------------------------------*/
+/* File: buffer_info_xml.h 				         	      */
+/*----------------------------------------------------------------------------*/
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#ifndef _BUFFER_INFO_XML_H_
+#   define _BUFFER_INFO_XML_H_
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Global Include                                                             */
+/*----------------------------------------------------------------------------*/
+
+#   include <buffer_info_mng.h>
+
+/*----------------------------------------------------------------------------*/
+/* Locale Constantes                                                          */
+/*----------------------------------------------------------------------------*/
+
+#define IMRD_SDMD_TAG_FMTATTR        "fmtattr"
+#define IMRD_SDMD_TAG_FMTATTR_NAME   "fmtattr_name"
+
+
+/*definition des tags xml pour le chargement des structure Format et FmtMsg*/
+#define IMRD_SDMD_TAG_FORMAT  "format"
+#define IMRD_SDMD_TAG_FMTMSG  "fmtmsg"
+
+/*definition des tags xml pour le chargement de la structure Application*/
+
+#define IMRD_SDMD_TAG_APPLI        "appli"
+
+/*definition des tags xml pour le chargement de les structures MapPath et MapCmd*/
+#define IMRD_SDMD_TAG_MAPPATH            "mappath"
+#define IMRD_SDMD_TAG_INPUTAPPLI         "inputappli"
+#define IMRD_SDMD_TAG_OUTPUTAPPLI        "outputappli"
+#define IMRD_SDMD_TAG_INPUTFORMAT        "inputformat"
+#define IMRD_SDMD_TAG_INPUTFORMAT_ATTR   "inputformat_attr"
+#define IMRD_SDMD_TAG_OUTPUTFORMAT       "outputformat"
+#define IMRD_SDMD_TAG_OUTPUTFORMAT_ATTR  "outputformat_attr"
+#define IMRD_SDMD_TAG_MAPCMD             "mapcmd"
+#define IMRD_SDMD_TAG_BRANCHE_ID         "branche_id"
+#define IMRD_SDMD_TAG_MAPPER             "mapper"
+#define IMRD_SDMD_TAG_CLEARFLAG          "clearflag"
+#define IMRD_SDMD_TAG_INPUTBUFFER        "inputbuffer"
+#define IMRD_SDMD_TAG_OUTPUTBUFFER       "outputbuffer"
+#define IMRD_SDMD_TAG_IDENTIFIER         "identifier"
+#define IMRD_SDMD_TAG_NUMBUFFER          "numbuffer"
+#define IMRD_SDMD_TAG_GO_TO              "go_to"
+#define IMRD_SDMD_TAG_TYPE               "type"
+#define IMRD_SDMD_TAG_COPIE              "copie"
+#define IMRD_SDMD_TAG_IDENTTOTAL         "identtotal"
+#define IMRD_SDMD_TAG_ATTRIBUTE          "attribute"
+#define IMRD_SDMD_TAG_VALUE              "value"
+
+
+/*----------------------------------------------------------------------------*/
+/* Local definition                                                           */
+/*----------------------------------------------------------------------------*/
+
+
+typedef IMRT_Status (* xml_endeElement)(void * ctx, const xmlChar * localname, const xmlChar * prefix, const xmlChar * URI);
+
+typedef struct SDMT_BufferInfo_Contexte
+{
+	char value[IMRD_SDMD_VALUE_LEN];
+    IMRT_Array_Xml_Path PathArray;
+    IMRT_Level_Tag PresentLevelTag;
+	int  IdxJpTble;
+	int  NbMapPath;
+	int  NbMapCmd;
+	IMRT_Appl_Id     CptAppl;
+	IMRT_FmtAttr_Id  CptFmtAttr;
+	IMRT_Fmt_Id      CptFmt;
+	IMRT_MapPath   * CurrentMapPath;
+	IMRT_MapCmd    * CurrentMapCmd;
+	IMRT_Appl      * CurrentAppli;
+	IMRT_FmtMsg    * CurrentFmtMsg;
+	IMRT_Fmt       * CurrentFormat;
+	IMRT_FmtAttr   * CurrentFmtAttr;
+	NDT_Root       * RootFmtAttr;
+	NDT_Root       * RootFormat;
+	NDT_Root       * RootAppli;
+	NDT_Root       * RootMapPath;
+	xmlParserCtxt  * SaxCtxHdl; 
+	IMRT_Error     FataError;
+	IMRT_Status    flagerror;
+}SDMT_BufferInfo_Contexte;
+
+
+/*----------------------------------------------------------------------------*/
+/* Prototypes                                                                 */
+/*----------------------------------------------------------------------------*/
+
+#   ifdef _BUFFER_INFO_XML_C_
+
+static IMRT_Status error(SDMT_BufferInfo_Contexte *ctx , const char *msg, ...);
+
+IMRT_Status startElementNsFmtAttr( SDMT_BufferInfo_Contexte * ctx , 
+							            const xmlChar *localname,
+							            const xmlChar *prefix,
+							            const xmlChar *URI,
+							            int nb_namespaces,
+							            const xmlChar **namespaces,
+							            int nb_attributes,
+							            int nb_defaulted,
+							            const xmlChar **attributes);
+
+IMRT_Status startElementNsAppli( SDMT_BufferInfo_Contexte * ctx , 
+							            const xmlChar *localname,
+							            const xmlChar *prefix,
+							            const xmlChar *URI,
+							            int nb_namespaces,
+							            const xmlChar **namespaces,
+							            int nb_attributes,
+							            int nb_defaulted,
+							            const xmlChar **attributes);
+
+IMRT_Status startElementNsFmt( SDMT_BufferInfo_Contexte * ctx , 
+							          const xmlChar *localname,
+							          const xmlChar *prefix,
+							          const xmlChar *URI,
+							          int nb_namespaces,
+							          const xmlChar **namespaces,
+							          int nb_attributes,
+							          int nb_defaulted,
+							          const xmlChar **attributes);
+
+IMRT_Status startElementNsMapPath( SDMT_BufferInfo_Contexte * ctx , 
+							              const xmlChar *localname,
+							              const xmlChar *prefix,
+							              const xmlChar *URI,
+							              int nb_namespaces,
+							              const xmlChar **namespaces,
+							              int nb_attributes,
+							              int nb_defaulted,
+							              const xmlChar **attributes);
+
+IMRT_Status endElementNsAppli( SDMT_BufferInfo_Contexte * ctx, 
+							          const xmlChar *localname,
+							          const xmlChar *prefix,
+							          const xmlChar *URI);
+
+IMRT_Status endElementNsFmtAttr( SDMT_BufferInfo_Contexte * ctx, 
+							          const xmlChar *localname,
+							          const xmlChar *prefix,
+							          const xmlChar *URI);
+
+IMRT_Status endElementNsFmt ( SDMT_BufferInfo_Contexte * ctx, 
+							         const xmlChar *localname,
+							         const xmlChar *prefix,
+							         const xmlChar *URI);
+
+IMRT_Status endElementNsMapPath( SDMT_BufferInfo_Contexte * ctx, 
+							            const xmlChar *localname,
+							            const xmlChar *prefix,
+							            const xmlChar *URI);
+							            
+IMRT_Status Buff_Info_characters(SDMT_BufferInfo_Contexte * ctx , const xmlChar *ch, int len);
+
+IMRT_Status  SDM_XML_Load_FmtAttr(   char *demo_file, SDMT_BufferInfo_Contexte *mycontexte);
+IMRT_Status  SDM_XML_Load_Appli(   char *demo_file, SDMT_BufferInfo_Contexte *mycontexte);
+IMRT_Status  SDM_XML_Load_Format(  char *demo_file, SDMT_BufferInfo_Contexte *mycontexte);
+IMRT_Status  SDM_XML_Load_MapPath( char *demo_file, SDMT_BufferInfo_Contexte *mycontexte);
+IMRT_Status  SDM_XML_BufferInfo_Init(IMRT_Path    Lib_Path);
+IMRT_Status  SDM_Dump_XML_FmtAttr_Header(FILE *dump_file);
+IMRT_Status  SDM_Dump_XML_FmtAttr_Body(FILE *dump_file);
+IMRT_Status  SDM_Dump_XML_FmtAttr_Footer(FILE *dump_file);
+IMRT_Status  SDM_Dump_XML_FmtAttr(void);
+IMRT_Status  SDM_Dump_XML_Appli_Header(FILE *dump_file);
+IMRT_Status  SDM_Dump_XML_Appli_Body(FILE *dump_file);
+IMRT_Status  SDM_Dump_XML_Appli_Footer(FILE *dump_file);
+IMRT_Status  SDM_Dump_XML_Appli(void);
+IMRT_Status  SDM_Dump_XML_Format_Header(FILE *dump_file);
+IMRT_Status  SDM_Dump_XML_Format_Body(FILE *dump_file);
+IMRT_Status  SDM_Dump_XML_Format_Footer(FILE *dump_file);
+IMRT_Status  SDM_XML_Dump_Format(void);
+IMRT_Status  SDM_XML_Dump_MapPath_Header(FILE *dump_file);
+IMRT_Status  SDM_XML_Dump_MapPath_Body(FILE *dump_file);
+IMRT_Status  SDM_XML_Dump_MapPath_Footer(FILE *dump_file);
+IMRT_Status  SDM_XML_Dump_MapPath(void);
+IMRT_Status  SDM_XML_BufferInfo_Dump(void);
+IMRT_Status  SDM_ConvertAttribute(char * Attrinute_ptr, char * Attribute_convert_ptr);
+IMRT_Status  SDM_ConvertAttributeInv(char * Attrinute_Ptr, char * Attribute_convert_ptr);
+IMRT_Status  SDM_Control_Fmt_Attr(IMRT_Msg *, NDT_Root *, IMRT_FmtAttr *);
+#   else
+
+extern  IMRT_Status  SDM_XML_Load_FmtAttr(   char *demo_file, SDMT_BufferInfo_Contexte *mycontexte);
+extern  IMRT_Status  SDM_XML_Load_Appli( char *demo_file, SDMT_BufferInfo_Contexte *mycontexte);
+extern  IMRT_Status  SDM_XML_Load_Format( char *demo_file, SDMT_BufferInfo_Contexte *mycontexte);
+extern  IMRT_Status  SDM_XML_Load_MapPath( char *demo_file, SDMT_BufferInfo_Contexte *mycontexte);
+extern  IMRT_Status  SDM_XML_BufferInfo_Init(IMRT_Path    Lib_Path);
+extern  IMRT_Status  SDM_Dump_XML_FmtAttr_Header(FILE *dump_file);
+extern  IMRT_Status  SDM_Dump_XML_FmtAttr_Body(FILE *dump_file);
+extern  IMRT_Status  SDM_Dump_XML_FmtAttr_Footer(FILE *dump_file);
+extern  IMRT_Status  SDM_Dump_XML_FmtAttr(void);
+extern  IMRT_Status  SDM_Dump_XML_Appli_Header(FILE *dump_file);
+extern  IMRT_Status  SDM_Dump_XML_Appli_Body(FILE *dump_file);
+extern  IMRT_Status  SDM_Dump_XML_Appli_Footer(FILE *dump_file);
+extern  IMRT_Status  SDM_Dump_XML_Appli(void);
+extern  IMRT_Status  SDM_Dump_XML_Format_Header(FILE *dump_file);
+extern  IMRT_Status  SDM_Dump_XML_Format_Body(FILE *dump_file);
+extern  IMRT_Status  SDM_Dump_XML_Format_Footer(FILE *dump_file);
+extern  IMRT_Status  SDM_XML_Dump_Format(void);
+extern  IMRT_Status  SDM_XML_Dump_MapPath_Header(FILE *dump_file);
+extern  IMRT_Status  SDM_XML_Dump_MapPath_Body(FILE *dump_file);
+extern  IMRT_Status  SDM_XML_Dump_MapPath_Footer(FILE *dump_file);
+extern  IMRT_Status  SDM_XML_Dump_MapPath(void);
+extern  IMRT_Status  SDM_XML_BufferInfo_Dump(void);
+extern  IMRT_Status  SDM_Control_Fmt_Attr(IMRT_Msg *, NDT_Root *, IMRT_FmtAttr *);
+#   endif
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Global Variables                                                           */
+/*----------------------------------------------------------------------------*/
+#   ifdef _BUFFER_INFO_XML_C_
+
+/*xmlSAXHandler Buff_Info_Error_SAX_Hdl_Struct = {
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    1,
+    NULL,
+    NULL,
+    NULL,
+    NULL
+    };*/
+xmlSAXHandler SaxFmtHandlerStruct = {
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    (charactersSAXFunc)(Buff_Info_characters),
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    (errorSAXFunc)(error),
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    1,
+    NULL,
+    (startElementNsSAX2Func)(startElementNsFmt),
+    (endElementNsSAX2Func)(endElementNsFmt),
+    NULL
+};
+
+
+xmlSAXHandler SaxAppliHandlerStruct = {
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    (charactersSAXFunc)(Buff_Info_characters),
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    (errorSAXFunc)error,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    1,
+    NULL,
+    (startElementNsSAX2Func)(startElementNsAppli),
+    (endElementNsSAX2Func)(endElementNsAppli),
+    NULL
+};
+
+xmlSAXHandler SaxFmtAttrHandlerStruct = {
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    (charactersSAXFunc)(Buff_Info_characters),
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    (errorSAXFunc)error,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    1,
+    NULL,
+    (startElementNsSAX2Func)(startElementNsFmtAttr),
+    (endElementNsSAX2Func)(endElementNsFmtAttr),
+    NULL
+};
+
+
+xmlSAXHandler SaxMapPathHandlerStruct = {
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    (charactersSAXFunc)(Buff_Info_characters),
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    (errorSAXFunc)error,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    1,
+    NULL,
+    (startElementNsSAX2Func)(startElementNsMapPath),
+    (endElementNsSAX2Func)(endElementNsMapPath),
+    NULL
+};
+
+
+
+
+#   endif
+
+/*----------------------------------------------------------------------------*/
+
+#endif
diff --git a/src/libstatic_data_mng/src/libstatic_data_mng.c b/src/libstatic_data_mng/src/libstatic_data_mng.c
new file mode 100644
index 0000000..e374596
--- /dev/null
+++ b/src/libstatic_data_mng/src/libstatic_data_mng.c
@@ -0,0 +1,527 @@
+/*----------------------------------------------------------------------------*/
+/* $Workfile:   libstatic_data_mng.c  $                                       */
+/*----------------------------------------------------------------------------*/
+/* $Author: agibert $                                                      */
+/* $Date: 2008/11/12 02:25:23 $                                           */
+/* $Revision: 1.1 $                                                       */
+/* $Label:  $                                                         */
+/*----------------------------------------------------------------------------*/
+/*----------------------------------------------------------------------------*/
+/* File: libstatic_data_mng.c   				  	      */
+/*----------------------------------------------------------------------------*/
+/*                                                                            */
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#define _LIBSTATIC_DATA_MNG_
+#define _LIBSTATIC_DATA_MNG_C_
+
+#include "libstatic_data_mng.h"
+
+
+
+
+
+
+
+/******************************************************************************/
+/* Static Data Manager API                                                    */
+/******************************************************************************/
+
+/*----------------------------------------------------------------------------*/
+/* Open Static Data Manager                                                   */
+/*----------------------------------------------------------------------------*/
+/* Lib_Flag:   Setup SDM init mode (XML, SQL, ...)                            */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  IMR_SDM_Library_Open( IMRT_SDM_Config * Lib_Config_Ptr)
+{
+  IMRT_Status  status, StatusTmp;
+  NDT_Status   nd_status;
+
+
+ 
+    if( IMRG_SDM_Module.Lib.Status != IMRD_LIB_STATUS_CLOSED)
+    {
+	IMRD_LM_LOG_ERROR_0( "Library not closed !");
+
+	return( IMRS_KO);
+    }
+    else
+    {
+#ifdef ORACLE_SUPPORT
+	if(( (status = SDM_HDR_SQL_Init(Lib_Config_Ptr->Flag)) != IMRS_OK)||( (status = SDM_HDR_XML_Init(Lib_Config_Ptr->Flag)) != IMRS_OK))
+	{
+	    status = IMRS_KO;
+	}
+#else
+	    status = IMRS_OK;
+#endif /* ORACLE_SUPPORT */
+
+	if( status == IMRS_OK )
+	{
+	    status = SDM_StructInfo_Init(Lib_Config_Ptr);
+	    if( status == IMRS_OK )
+	    {
+		status = SDM_MapInfo_Init(Lib_Config_Ptr);
+		if( status == IMRS_OK )
+		{
+		    status = SDM_BufferInfo_Init(Lib_Config_Ptr);
+		    if( status != IMRS_OK )
+		    {
+			StatusTmp = SDM_MapInfo_DInit();
+			StatusTmp = SDM_StructInfo_DInit();
+		    }
+		}
+		else
+		{
+		    StatusTmp = SDM_StructInfo_DInit();
+		}
+	    }
+
+	}
+
+	if( status == IMRS_OK)
+	{
+	    IMRG_SDM_Module.Lib.Status = IMRD_LIB_STATUS_OPENED;
+
+	    IMRD_LM_LOG_TRACE_0( IMRD_LOG_LEVEL_VERBOSE_1, "Library opened !");
+	}
+
+	return(status);
+    }
+}
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Close Static Data Manager                                                  */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  IMR_SDM_Library_Close( void)
+{
+  IMRT_Status  status;
+
+
+    if( IMRG_SDM_Module.Lib.Status != IMRD_LIB_STATUS_OPENED)
+    {
+	IMRD_LM_LOG_ERROR_0( "Library not opened !");
+
+	return( IMRS_KO);
+    }
+    else
+    {
+	status = IMRS_OK;
+
+	if( ((status = SDM_BufferInfo_DInit()) != IMRS_OK)||
+	    ((status = SDM_MapInfo_DInit())    != IMRS_OK)||
+	    ((status = SDM_StructInfo_DInit()) != IMRS_OK)||
+
+#ifdef ORACLE_SUPPORT
+	    ((status = SDM_HDR_SQL_DInit())    != IMRS_OK)||
+#endif /* ORACLE_SUPPORT */
+
+	    ((status = SDM_HDR_XML_DInit())    != IMRS_OK) )
+	{
+	    status = IMRS_KO;
+	}
+	else
+	{
+	    IMRG_SDM_Module.Lib.Status = IMRD_LIB_STATUS_CLOSED;
+
+	    IMRD_LM_LOG_TRACE_0( IMRD_LOG_LEVEL_VERBOSE_1, "Library closed !");
+	}
+
+	return(status);
+    }
+}
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Proceed Format                                                             */
+/*----------------------------------------------------------------------------*/
+/* (I) CCB_Fmt_Add_Ptr:   Format add callback                                 */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  IMR_SDM_Fmt_Proceed( IMRT_SDMCB_Fmt_Add  *CCB_Fmt_Add_Ptr)
+{
+    IMRT_Status status;
+
+    status = SDM_Fmt_Proceed(CCB_Fmt_Add_Ptr); 
+
+    return(status);
+}
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Proceed Convert                                                            */
+/*----------------------------------------------------------------------------*/
+/* (I) CCB_Cnv_Add_Ptr:   Convert add callback                                */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  IMR_SDM_Cnv_Proceed( IMRT_SDMCB_Cnv_Add  *CCB_Cnv_Add_Ptr)
+{
+    IMRT_Status status;
+
+    status = SDM_Cnv_Proceed(CCB_Cnv_Add_Ptr); 
+
+    return(status);
+}
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Proceed Mapping Path                                                       */
+/*----------------------------------------------------------------------------*/
+/* (I) Appl_Id_Target:         Target buffer application id                   */
+/* (I) Fmt_Id_Target:          Target buffer format id                        */
+/* (I) Msg_Id_Target:          Target buffer message id                       */
+/* (I) ApplId_Src:             Source buffer application id                   */
+/* (I) Fmt_Id_Src:             Source buffer format id                        */
+/* (I) Msg_Id_Src:             Source buffer message id                       */
+/* (I) CCB_Buffer_Map_Ptr:     Buffer mapping callback                        */
+/* (I) CCB_Buffer_Copy_Ptr:    Buffer copy callback                           */
+/* (I) CCB_Buffer_Ident_Ptr:   Buffer identification callback                 */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  IMR_SDM_MapPath_Proceed( IMRT_Appl_Id  Appl_Id_Target, IMRT_Fmt_Id  Fmt_Id_Target, IMRT_Msg_Id  Msg_Id_Target,
+				      IMRT_Appl_Id  ApplId_Src,     IMRT_Fmt_Id  Fmt_Id_Src,    IMRT_Msg_Id  Msg_Id_Src,
+				      IMRT_SDMCB_Buffer_Map    *CCB_Buffer_Map_Ptr,
+				      IMRT_SDMCB_Buffer_Copy   *CCB_Buffer_Copy_Ptr,
+				      IMRT_SDMCB_Buffer_Ident  *CCB_Buffer_Ident_Ptr)
+{
+    IMRT_Status status;
+
+    status = SDM_MapPath_Proceed(Appl_Id_Target,Fmt_Id_Target,Msg_Id_Target,
+				 ApplId_Src,Fmt_Id_Src, Msg_Id_Src,
+				 CCB_Buffer_Map_Ptr,
+				 CCB_Buffer_Copy_Ptr,
+				 CCB_Buffer_Ident_Ptr); 
+  
+}
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Proceed Buffer Mapping                                                     */
+/*----------------------------------------------------------------------------*/
+/* (I) MsgMap_Ptr:          Message map pointer                               */
+/* (I) CCB_Field_Map_Ptr:   Field mapping callback                            */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  IMR_SDM_MsgMap_Proceed( IMRT_MsgMap  *MsgMap_Ptr, IMRT_SDMCB_Field_Map  *CCB_Field_Map_Ptr)
+{
+
+    IMRT_Status status;
+
+    status = IMRS_OK;
+    
+    if(SDM_MsgMap_Proceed(MsgMap_Ptr,CCB_Field_Map_Ptr) != NDS_OK)
+    {
+	status = IMRS_KO;
+    }
+    
+    return(status);
+   
+}
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Proceed Message Identification                                             */
+/*----------------------------------------------------------------------------*/
+/* (I) Fmt_Id:                Target buffer format id                         */
+/* (O) Msg_Id_Ptr:            Target buffer message id to return              */
+/* (I) CCB_Field_Ident_Ptr:   Field ident callback                            */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  IMR_SDM_MsgIdent_Proceed( IMRT_Fmt_Id  Fmt_Id, IMRT_Msg_Id  *Msg_Id, IMRT_SDMCB_Ident_Field_Value  *CCB_Ident_Field_Value_Ptr, 
+									   IMRT_SDMCB_Ident_Field_Exist  *CCB_Ident_Field_Exist_Ptr, IMRT_SDMCB_Ident_Msg_Size  *CCB_Ident_Msg_Size_Ptr)
+{
+    IMRT_Status status;
+
+    status = SDM_MsgIdent_Proceed( Fmt_Id, Msg_Id, CCB_Ident_Field_Value_Ptr, CCB_Ident_Field_Exist_Ptr, CCB_Ident_Msg_Size_Ptr);
+    
+}
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Convert Buffer Format Name to Buffer Format Id                             */
+/*----------------------------------------------------------------------------*/
+/* (O) Fmt_Id_Ptr:   Buffer format id                                         */
+/* (I) Fmt_Name:     Buffer format name                                       */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  IMR_SDM_Fmt_Id_Get( IMRT_Fmt_Id  *Fmt_Id_Ptr, const IMRT_Fmt_Name  Fmt_Name)
+{
+    IMRT_Status  status;
+    NDT_Status   nd_status;
+    NDT_Node    *node_ptr;
+    IMRT_Fmt     Fmt;
+
+
+	strcpy(Fmt.Name, Fmt_Name);
+
+	if(((nd_status = ND_Index_Node_Find( &node_ptr, IMRG_SDM_Base.RootFmt,
+					 IMRD_SDMD_FMT_IDX_NAME,&Fmt,NULL)) != NDS_OK)||
+		(node_ptr == NULL))
+	{
+	    printf("\nErreur lors de la recherche de Format Name <%s>\n", Fmt_Name);
+	    status = IMRS_KO;
+	}
+	else
+	{
+		*Fmt_Id_Ptr = ( ( IMRT_Fmt *)( node_ptr->Value))->Id;
+		status = IMRS_OK;		
+	}
+
+	return(status);	
+}
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Convert Buffer Appli Name to Buffer Appli Id                               */
+/*----------------------------------------------------------------------------*/
+/* (O) Appl_Id_Ptr:   Buffer appli id                                         */
+/* (I) Appl_Name:     Buffer appli name                                       */
+/*----------------------------------------------------------------------------*/
+
+IMRT_Status  IMR_SDM_Appl_Id_Get( IMRT_Appl_Id  *Appl_Id_Ptr, const IMRT_Appl_Name Appl_Name)
+{
+    IMRT_Status  status;
+    NDT_Status   nd_status;
+    NDT_Node    *node_ptr;
+    IMRT_Appl    Appli;
+
+
+	strcpy(Appli.Name, Appl_Name);
+
+	if(((nd_status = ND_Index_Node_Find( &node_ptr, IMRG_SDM_Base.RootAppl,
+					 IMRD_SDMD_APPL_IDX_NAME,&Appli,NULL)) != NDS_OK)||
+		(node_ptr == NULL))
+	{
+	    printf("\nErreur lors de la recherche de Appli Name <%s>\n", Appl_Name);
+	    status = IMRS_KO;
+	}
+	else
+	{
+		*Appl_Id_Ptr = ( ( IMRT_Appl *)( node_ptr->Value))->Id;
+		status = IMRS_OK;		
+	}
+
+	return(status);	
+}
+
+
+
+void  SDM_DataStruct_Dump( NDT_Root  *ds_ptr )
+{
+    NDT_Status  status;
+
+
+    printf( "Print DataStructure Info:\n");
+
+    if( ( status = ND_DataStruct_Info_Print( stdout, ds_ptr, NDD_RECURSIVE_MODE_PARENT_CHILD, 0, 0)) != NDS_OK)
+    {
+        printf( "ND_DataStruct_Info_Print() failed (%d) !\n", status);
+    }
+
+    printf( "\n");
+    printf( "Traverse DataStructure Index 0:\n");
+
+    if( ( status = ND_DataStruct_Traverse( ds_ptr, IMRD_SDMD_CMD_INDEX0_PRINT, stdout, NDD_RECURSIVE_MODE_PARENT, 0)) != NDS_OK)
+    {
+        printf( "ND_DataStruct_Traverse() failed (%d) !\n", status);
+    }
+}
+
+
+
+
+
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  IMR_SDM_SQL_Dump(void)
+{
+	IMRT_Status     status;
+
+#ifdef ORACLE_SUPPORT
+
+	IMRD_LM_LOG_TRACE_0( IMRD_LOG_LEVEL_VERBOSE_0, "SQL Dump ...");
+
+	status = SDM_SQL_StructInfo_Dump();
+	if(status == IMRS_OK)
+	{
+		status = SDM_SQL_MapInfo_Dump();
+		if(status == IMRS_OK)
+		{
+			status = SDM_SQL_BufferInfo_Dump();
+		}
+	}
+#else
+	status = IMRS_OK;
+#endif /* ORACLE_SUPPORT */
+
+	return(status);
+}
+
+
+
+
+
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  IMR_SDM_XML_Dump(void)
+{
+	IMRT_Status     status;
+
+	IMRD_LM_LOG_TRACE_0( IMRD_LOG_LEVEL_VERBOSE_0, "XML Dump ...");
+
+	status = SDM_XML_StructInfo_Dump();
+	if(status == IMRS_OK)
+	{
+		status = SDM_XML_MapInfo_Dump();
+		if(status == IMRS_OK)
+		{
+			status = SDM_XML_BufferInfo_Dump();
+		}
+	}
+
+	return(status);
+
+}
+
+
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  SDM_Set_Struct_Version(IMRT_Data_Version *Data_Version_Ptr, char *Version_String_Ptr)
+{
+	char    *Pos1_Ptr, *Pos2_Ptr;
+	char    *Pos3_Ptr;
+	char    Label[IMRD_SDMD_VERS_LABEL_LEN];
+	char    Date[IMRD_SDMD_VERS_DATE_LEN];
+	int    i;
+
+	strcpy(Label, "");
+	strcpy(Date, "");
+
+	Pos1_Ptr = strstr( Version_String_Ptr, "Label:");
+	if (Pos1_Ptr != NULL)
+	{
+		Pos2_Ptr = strstr( Pos1_Ptr, "$");
+		if (Pos2_Ptr == NULL)
+		{
+			return(IMRS_KO);
+		}
+
+		strncpy(Label, Pos1_Ptr+6, Pos2_Ptr - Pos1_Ptr - 6);
+		Label[Pos2_Ptr - Pos1_Ptr - 6]='\0';
+		Pos3_Ptr = Label;
+		i = strlen(Pos3_Ptr);
+		while((Pos3_Ptr[0] == ' ') && (i >= 0))
+		{
+			Pos3_Ptr ++;
+			i --;
+		}
+
+		i = strlen(Pos3_Ptr);
+		while((Pos3_Ptr[i-1] == ' ') && (i > 0))
+		{
+			i --;
+		}
+
+		if (i > 0)
+		{
+			strncpy(Data_Version_Ptr->Label, Pos3_Ptr, i);
+			Data_Version_Ptr->Label[i]= '\0';
+		}
+
+		Pos1_Ptr = strstr( Version_String_Ptr, "Date:");
+		if (Pos1_Ptr != NULL)
+		{
+			Pos2_Ptr = strstr( Pos1_Ptr, "$");
+			if (Pos2_Ptr == NULL)
+			{
+				return(IMRS_KO);
+			}
+
+			strncpy(Date, Pos1_Ptr+5, Pos2_Ptr - Pos1_Ptr - 5);
+			Date[Pos2_Ptr - Pos1_Ptr - 5]='\0';
+			Pos3_Ptr = Date;
+			i = strlen(Pos3_Ptr);
+			while((Pos3_Ptr[0] == ' ') && (i >= 0))
+			{
+				Pos3_Ptr ++;
+				i --;
+			}
+
+			i = strlen(Pos3_Ptr);
+			while((Pos3_Ptr[i-1] == ' ') && (i > 0))
+			{
+				i --;
+			}
+
+			if (i > 0)
+			{
+				strncpy(Data_Version_Ptr->Date, Pos3_Ptr, i);
+				Data_Version_Ptr->Date[i]= '\0';
+			}
+		}	
+		else
+		{
+			return(IMRS_KO);
+		}
+	}
+	else
+	{
+		return(IMRS_KO);
+	}
+
+	return(IMRS_OK);
+
+}
diff --git a/src/libstatic_data_mng/src/libstatic_data_mng.h b/src/libstatic_data_mng/src/libstatic_data_mng.h
new file mode 100644
index 0000000..5ca0662
--- /dev/null
+++ b/src/libstatic_data_mng/src/libstatic_data_mng.h
@@ -0,0 +1,319 @@
+/*----------------------------------------------------------------------------*/
+/* File: libstatic_data_mng.h 				      		      */
+/*----------------------------------------------------------------------------*/
+/*                                                                             */
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#ifndef _LIBSTATIC_DATA_MNG_H_
+#define _LIBSTATIC_DATA_MNG_H_
+
+
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Global Include                                                             */
+/*----------------------------------------------------------------------------*/
+
+#include <imr.h>
+#include <libxml/xmlmemory.h>
+#include <libxml/parser.h> 
+#include <libxml/uri.h> 
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Lib Definitions                                                            */
+/*----------------------------------------------------------------------------*/
+
+#define IMRD_SDM_MODULE_ID                ( IMRT_Module_Id) 2
+#define IMRD_SDM_MODULE_NAME            ( IMRT_Module_Name) "sdm"
+#define IMRD_SDM_MODULE_NAME_LONG  ( IMRT_Module_Name_Long) "Static Data Manager"
+#define IMRD_SDM_MODULE_VERSION      ( IMRT_Module_Version)  "@(#) VERSIONIMR: $Label:  $   $Date: 2008/11/12 02:25:23 $   $Workfile:   libstatic_data_mng.h  $"
+
+#define IMRD_MODULE_PTR                                     &IMRG_SDM_Module
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Local Definition                                                           */
+/*----------------------------------------------------------------------------*/
+
+#define IMRD_SDMD_FUNCTION_NAME_LEN   20
+#define IMRD_SDMD_LIB_ERROR_LEN       60
+#define IMRD_SDMD_VALUE_LEN           255
+#define IMRD_SDMD_MARKUP_LEN          255
+#define IMRD_SDMD_DESCERR_LEN         60
+
+#define IMRD_SDMD_SEP_NAME "-"
+#define IMRD_SDMD_EMPTY_STRING ""
+
+#define IMRD_SDMD_CMD_INDEX0_PRINT    (NDT_Command)64
+#define IMRD_SDMD_CMD_EXECUTE         (NDT_Command)68
+#define NDD_CMD_EXECUTE               (NDT_Command)20
+
+#define IMRD_SDMD_CMD_API_XML_FILE_DUMP   (NDT_Command)70
+#define IMRD_SDMD_CMD_API_SQL_FILE_DUMP   (NDT_Command)71
+#define IMRD_SDMD_CMD_API_SQL_DDBB_DUMP   (NDT_Command)72
+
+#define IMRD_SDMD_CMD_API_XML_DUMP        (NDT_Command)80
+#define IMRD_SDMD_CMD_API_SQL_DUMP        (NDT_Command)81
+#define NDD_CMD_FIND_MAPPATH			  (NDT_Command)82
+
+#define IMRD_SDMD_CMD_CHECK_FMT_ATTR      (NDT_Command)83
+
+/*définition de code retour spécifique pour la lib_node*/
+
+#define NDS_NODE_FOUND				      (NDT_Status)-1000
+#define NDS_IDENT_OK                                  (NDT_Status)-1010 
+#define NDS_NO_IDENT                                  (NDT_Status)-1020 
+/**/
+
+
+#define IMRD_SDMD_MAX_LINE_DUMP_FILE        500
+
+#define IMRD_SDMD_INDEX_NB                (short)1
+
+#define IMRD_SDMD_TAG_VERSION       "version"
+#define IMRD_SDMD_TAG_NAME          "name"
+#define IMRD_SDMD_TAG_MSGMAP        "msgmap"
+#define IMRD_SDMD_MSGMAP_IDX_ID                (short)0
+#define IMRD_SDMD_MSGMAP_IDX_NAME              (short)1
+
+/*Liste des codes erreurs*/
+#define SDMD_XML_CODE_ERROR_1   1
+#define SDMD_XML_LIB_ERROR_1    "Balise non reconnu"
+#define SDMD_XML_CODE_ERROR_2   2
+#define SDMD_XML_LIB_ERROR_2    "Insertion de l'objet %s impossible"
+#define SDMD_XML_CODE_ERROR_3   3
+#define SDMD_XML_LIB_ERROR_3    "allocationde l'objet %s impossible"
+#define SDMD_XML_CODE_ERROR_4   4
+#define SDMD_XML_LIB_ERROR_4    "l'objet %s de valeur %s est absent"
+#define SDMD_XML_CODE_ERROR_5   5
+#define SDMD_XML_LIB_ERROR_5    "Impossible d'ouvrir la strcuture %s"
+#define SDMD_CODE_ERROR_6        6
+#define SDMD_LIB_ERROR_6         "Impossible de trouvers un chemin de mapping"
+#define SDMD_CODE_ERROR_7        7
+#define SDMD_LIB_ERROR_7         "La commande %d n'est pas une commande connut"
+#define SDMD_CODE_ERROR_8        8
+#define SDMD_LIB_ERROR_8         "Le format %s n'est pas un présent dans la liste des formats"
+#define SDMD_CODE_ERROR_9        9
+#define SDMD_LIB_ERROR_9         "Indentification du message impossible"
+
+#define SDMD_XML_CODE_ERROR_10   10
+#define SDMD_XML_LIB_ERROR_10    "Erreur de chargement du fichier XML %s"
+
+#define SDMD_CODE_ERROR_11       11
+#define SDMD_LIB_ERROR_11        "Erreur de control de coherence de Format Attribute"
+
+
+#define IMRD_SDMD_VERS_NAME_LEN           30
+#define IMRD_SDMD_VERS_LABEL_LEN          30
+#define IMRD_SDMD_VERS_DATE_LEN           30
+
+
+/*----------------------------------------------------------------------------*/
+/* IMRT_Mode_Traverse definition                                              */
+/*----------------------------------------------------------------------------*/
+
+typedef short  IMRT_Mode_Traverse;
+
+#define IMRD_SKIP_MODE     ( IMRT_Mode_Traverse) 0
+#define IMRD_NORMALE_MODE  ( IMRT_Mode_Traverse) 1
+#define IMRD_ERREUR_MODE   ( IMRT_Mode_Traverse) 2
+
+
+#define IMRD_LATEST_BRANCHE   ( IMRT_Branche_Id) 100
+
+static NDT_Index_Type  index_type_initial_tab[IMRD_SDMD_INDEX_NB] = 
+{
+      (NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_LIST | NDD_INDEX_SUBTYPE_SORTED)
+};
+
+typedef struct IMRT_Error
+{
+ char function [IMRD_SDMD_FUNCTION_NAME_LEN];
+ int  errorCode;
+ char libError[IMRD_SDMD_LIB_ERROR_LEN];
+} IMRT_Error;
+
+
+typedef struct IMRT_SDM_Base
+{
+  NDT_Root       * RootMsg;
+  NDT_Root       * RootMsgMap;
+  NDT_Root       * RootFmtAttr;
+  NDT_Root       * RootFmt;
+  NDT_Root       * RootAppl;
+  NDT_Root       * RootMapPath;
+  NDT_Root       * RootCnv;
+} IMRT_SDM_Base;
+
+typedef struct IMRT_SDM_IdentMessage
+{
+ IMRT_Msg_Name Type;
+ IMRT_Msg_Id   Id;
+ IMRT_Mode_Traverse  Mode;
+ IMRT_Branche_Id     Branche_Id;
+ IMRT_SDMCB_Ident_Msg_Size     *Ident_Msg_SizeFunc_Ptr;
+ IMRT_SDMCB_Ident_Field_Exist  *Ident_Field_ExistFunc_Ptr;
+ IMRT_SDMCB_Ident_Field_Value  *Ident_Field_ValueFunc_Ptr;
+} IMRT_SDM_IdentMessage;
+
+
+typedef struct IMRT_Data_Version
+{
+ char Label [IMRD_SDMD_VERS_LABEL_LEN];
+ char Date[IMRD_SDMD_VERS_DATE_LEN];
+} IMRT_Data_Version;
+
+
+/*----------------------------------------------------------------------------*/
+/* IMRT_Array_Xml_Path definition                                             */
+/*----------------------------------------------------------------------------*/
+
+#define IMRD_SDMD_MIN_LEVEL_TAG           ( short ) -1
+#define IMRD_SDMD_MAX_LEVEL_TAG           ( short ) 10
+#define IMRD_SDMD_LEVEL_TAG_0             ( short ) 0
+#define IMRD_SDMD_LEVEL_TAG_1             ( short ) 1
+#define IMRD_SDMD_LEVEL_TAG_2             ( short ) 2
+#define IMRD_SDMD_LEVEL_TAG_3             ( short ) 3
+#define IMRD_SDMD_LEVEL_TAG_4             ( short ) 4
+#define IMRD_SDMD_LEVEL_TAG_5             ( short ) 5
+#define IMRD_SDMD_LEVEL_TAG_6             ( short ) 6
+#define IMRD_SDMD_LEVEL_TAG_7             ( short ) 7
+#define IMRD_SDMD_LEVEL_TAG_8             ( short ) 8
+#define IMRD_SDMD_LEVEL_TAG_9             ( short ) 9
+#define IMRD_SDMD_SIZE_TAG_LEN            ( short ) 30
+#define IMRD_SDMD_SIZE_TAG_SIZE           ( short ) ( IMRD_SDMD_SIZE_TAG_LEN + 1)
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IMRT_Array_Xml_Path definition                                             */
+/*----------------------------------------------------------------------------*/
+
+typedef char IMRT_Level_Name[IMRD_SDMD_SIZE_TAG_SIZE];
+
+typedef IMRT_Level_Name  IMRT_Array_Xml_Path[IMRD_SDMD_MAX_LEVEL_TAG];
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* IMRT_Level_Tag definition                                                  */
+/*----------------------------------------------------------------------------*/
+typedef short IMRT_Level_Tag;
+
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Prototypes                                                                 */
+/*----------------------------------------------------------------------------*/
+
+#   ifdef _LIBSTATIC_DATA_MNG_C_
+
+void  SDM_DataStruct_Dump( NDT_Root  * );
+IMRT_Status  SDM_Set_Struct_Version(IMRT_Data_Version *, char *);
+#   else
+
+extern  void  SDM_DataStruct_Dump( NDT_Root  * );
+extern  IMRT_Status  SDM_Set_Struct_Version(IMRT_Data_Version *, char *);
+#   endif 
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Local Includes                                                             */
+/*----------------------------------------------------------------------------*/
+
+#include "arc_hdl_xml.h"
+
+#ifdef ORACLE_SUPPORT
+#   include "arc_hdl_sql.h"
+#endif /* ORACLE_SUPPORT */
+
+#include "buffer_info_mng.h"
+#include "mapping_info_mng.h"
+#include "struct_info_mng.h"
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Global Variables                                                           */
+/*----------------------------------------------------------------------------*/
+
+
+#   ifdef _LIBSTATIC_DATA_MNG_C_
+
+IMRT_SDM_Base  IMRG_SDM_Base;
+
+
+
+IMRT_Module  IMRG_SDM_Module = 
+{ 
+    IMRD_SDM_MODULE_ID,
+    IMRD_SDM_MODULE_NAME,
+    IMRD_SDM_MODULE_NAME_LONG,
+    IMRD_SDM_MODULE_VERSION,
+    IMRD_MODULE_TYPE_LIBRARY,
+    {
+	IMRD_LIB_STATUS_CLOSED,
+	( IMRT_Lib_Open    *) &IMR_SDM_Library_Open,
+	( IMRT_Lib_Close   *) &IMR_SDM_Library_Close
+    }
+};
+
+#   else
+
+extern IMRT_SDM_Base  IMRG_SDM_Base;
+extern IMRT_Module    IMRG_SDM_Module;
+
+#   endif
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+
+#endif
diff --git a/src/libstatic_data_mng/src/mapping_info_mng.c b/src/libstatic_data_mng/src/mapping_info_mng.c
new file mode 100644
index 0000000..d589d6a
--- /dev/null
+++ b/src/libstatic_data_mng/src/mapping_info_mng.c
@@ -0,0 +1,843 @@
+/*----------------------------------------------------------------------------*/
+/* File: mapping_info_mng.c   		         		  	      */
+/*----------------------------------------------------------------------------*/
+/*                                                                            */
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#define _LIBSTATIC_DATA_MNG_
+#define _MAPPING_INFO_MNG_C_
+
+#include "mapping_info_mng.h" 
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* FieldMap Manager                                                           */
+/*----------------------------------------------------------------------------*/
+
+NDT_Status  SDM_FieldMap_Manager( NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id, NDT_Node  *Node_Ptr, NDT_Command  Command, va_list  Args)
+{
+    NDT_Command_Name  Command_Name;
+
+
+    switch( Command)
+    {
+        case NDD_CMD_MANAGER_VERSION:
+        {
+            NDT_Version_Name  *Version_Name_Ptr = (NDT_Version_Name  *)va_arg( Args, NDT_Version_Name  *);
+
+
+            Command_Name = "NDD_CMD_MANAGER_VERSION";
+
+            *Version_Name_Ptr = "Revision: 2.1    Name: libnode-2_0_4-1    Date: 2002/02/28 22:00:35    Author: agibert ";
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_INDEX_GET:
+        {
+            /*
+	      NDT_Index_Id  *Reply_Index_Id_Ptr = (NDT_Index_Id  *)va_arg( Args, NDT_Index_Id  *);
+	      NDT_Command   *Reply_Command_Ptr  = (NDT_Command  *)va_arg( Args, NDT_Command  *);
+	      NDT_Command    Cmd                = (NDT_Command)va_arg( Args, NDT_Command);
+	      void          *Value_ptr          = (void  *)va_arg( Args, void  *);
+            */
+            NDT_Index_Id  *Reply_Index_Id_Ptr =  (NDT_Index_Id  *)va_arg( Args, NDT_Index_Id  *);
+            NDT_Command   *Reply_Command_Ptr  =  (NDT_Command  *)va_arg( Args, NDT_Command  *);
+            NDT_Command    Cmd                =  (NDT_Command)va_arg( Args, NDT_Command);
+            IMRT_FieldMap    * Value_ptr      =  (IMRT_FieldMap  *)va_arg( Args, IMRT_FieldMap  *);
+
+
+            Command_Name = "NDD_CMD_INDEX_GET";
+
+            switch(Cmd)
+            {
+                case IMRD_SDMD_CMD_INDEX0_PRINT:
+                {
+                    *Reply_Index_Id_Ptr = 0;
+                    *Reply_Command_Ptr = NDD_CMD_VALUE_PRINT;
+
+                    break;
+                }
+                case IMRD_SDMD_CMD_EXECUTE:
+                {
+                    *Reply_Index_Id_Ptr = 0;
+                    *Reply_Command_Ptr = NDD_CMD_EXECUTE;
+
+                    break;
+                }
+
+                default:
+                {
+                    *Reply_Index_Id_Ptr = Index_Id;
+                    *Reply_Command_Ptr = Cmd;
+
+                    break;
+                }
+            }
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_ALLOC:
+        {
+            /*
+	      void       **Value_Ptr_Ptr = (void **)va_arg( Args, void  **);
+	      va_list      user_args     = (va_list)va_arg( Args, va_list);
+	      user_type    user_data     = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+            */
+            IMRT_FieldMap  **Value_Ptr_Ptr = va_arg( Args, IMRT_FieldMap  **);
+
+
+            Command_Name = "NDD_CMD_VALUE_ALLOC";
+
+            if( ( *Value_Ptr_Ptr = (IMRT_FieldMap  *)malloc( sizeof(IMRT_FieldMap))) == NULL)
+            {
+                return( NDS_ERRMEM);
+            }
+            else
+            {
+                SDM_InitFieldMap( *Value_Ptr_Ptr);
+
+                return( NDS_OK);
+            }
+        }
+
+        case NDD_CMD_VALUE_FREE:
+        {
+            /*
+	      void       *Value_Ptr = (void *)va_arg( Args, void  *);
+	      va_list     user_args = (va_list)va_arg( Args, va_list);
+	      user_type   user_data = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+            */
+            IMRT_FieldMap  *Value_Ptr = (IMRT_FieldMap  *)va_arg( Args, IMRT_FieldMap  *);
+
+
+            Command_Name = "NDD_CMD_VALUE_FREE";
+
+            free( Value_Ptr);
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_COMP:
+        {
+            /*
+	      void       *Value1_Ptr = (void *)va_arg( Args, void  *);
+	      void       *Value2_Ptr = (void *)va_arg( Args, void  *);
+	      va_list     user_args  = (va_list)va_arg( Args, va_list);
+	      user_type   user_data  = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+            */
+            IMRT_FieldMap    *Value1_Ptr = va_arg( Args, IMRT_FieldMap  *);
+            IMRT_FieldMap    *Value2_Ptr = va_arg( Args, IMRT_FieldMap  *);
+
+
+            Command_Name = "NDD_CMD_VALUE_COMP";
+
+            switch( Index_Id)
+            {
+                case 0:
+                {
+                    if( Value1_Ptr->Id < Value2_Ptr->Id)
+                    {
+                        return( NDS_LOWER);
+                    }
+                    else
+                    {
+                        if( Value1_Ptr->Id > Value2_Ptr->Id)
+                        {
+                            return( NDS_GREATER);
+                        }
+                        else
+                        {
+                            return( NDS_EQUAL);
+                        }
+                    }
+                }
+                
+                default:
+                {
+                    printf( "Unknown COMP idx (%d) !\n", Index_Id);
+
+                    return( NDS_KO);
+                }
+            }
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_ADD:
+        {
+            /*
+	      void       *Value_Ptr = (void *)va_arg( Args, void  *);
+	      va_list     user_args = (va_list)va_arg( Args, va_list);
+	      user_type   user_data = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+            */
+
+            Command_Name = "NDD_CMD_VALUE_ADD";
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_REMOVE:
+        {
+            /*
+	      void       *Value_Ptr = (void *)va_arg( Args, void  *);
+	      va_list     user_args = (va_list)va_arg( Args, va_list);
+	      user_type   user_data = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+            */
+
+            Command_Name = "NDD_CMD_VALUE_REMOVE";
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_PRINT:
+        {
+            /*
+	      NDT_Node             *Next_Node_Ptr   = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+	      va_list               lib_args        = (va_list)va_arg( Args, va_list);
+	      FILE                 *Out             = (FILE  *)va_arg( lib_args, FILE  *);
+	      NDT_Recursive_Mode    Recursive_Mode  = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode);
+	      NDT_Recursive_Depth   Recursive_Depth = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth);
+	      va_list               user_args       = (va_list)va_arg( lib_args, va_list);
+	      user_type             user_data       = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+	      void                 *Value_Ptr       = Node_Ptr->Value;
+            */
+            NDT_Node             *Next_Node_Ptr   =         (NDT_Node  *)va_arg( Args, NDT_Node  *);
+            va_list               lib_args        =             (va_list)va_arg( Args, va_list);
+            FILE                 *Out             =             (FILE  *)va_arg( lib_args, FILE  *);
+            NDT_Recursive_Mode    Recursive_Mode  =  (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode);
+            NDT_Recursive_Depth   Recursive_Depth = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth);
+
+            IMRT_FieldMap           *Value_Ptr       = Node_Ptr->Value;
+
+
+            Command_Name = "NDD_CMD_VALUE_PRINT";
+
+            fprintf( Out, "Id: (%d) InputField: (%s)  OutputField: (%s)\n",
+		     Value_Ptr->Id, Value_Ptr->Field_Input_Ptr->Name, Value_Ptr->Field_Output_Ptr->Name);
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_INFO_PRINT:
+        {
+            /*
+	      NDT_Node             *Next_Node_Ptr   = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+	      va_list               lib_args        = (va_list)va_arg( Args, va_list);
+	      FILE                 *Out             = (FILE  *)va_arg( lib_args, FILE  *);
+	      NDT_Recursive_Mode    Recursive_Mode  = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode);
+	      NDT_Recursive_Depth   Recursive_Depth = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth);
+	      va_list               user_args       = (va_list)va_arg( lib_args, va_list);
+	      user_type             user_data       = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+	      void                 *Value_Ptr       = Node_Ptr->Value;
+            */
+
+            Command_Name = "NDD_CMD_INFO_PRINT";
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_EXECUTE:
+        { /*
+            NDT_Node             *Next_Node_Ptr    = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+            va_list               lib_args         = (va_list)va_arg( Args, va_list);
+            FILE                 *Out              = (FILE  *)va_arg( lib_args, FILE  *);
+            NDT_Recursive_Mode    Recursive_Mode   = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode);
+            NDT_Recursive_Depth   Recursive_Depth  = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth);
+            NDT_Recursive_Offset  Recursive_Offset = (NDT_Recursive_Offset)va_arg( lib_args, NDT_Recursive_Offset);
+            va_list               user_args        = (va_list)va_arg( lib_args, va_list);
+            user_type             user_data        = (user_type)va_arg( user_args, user_type);
+	    ...  = (...)va_arg( user_args, ...);
+            void                 *Value_Ptr        = Node_Ptr->Value;
+	  */
+            IMRT_FieldMap *  Value_Ptr             = (IMRT_FieldMap*)Node_Ptr->Value;
+            NDT_Node *Next_Node_Ptr                = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+            va_list lib_args                       = (va_list)va_arg( Args, va_list);
+            FILE *Out                              = (FILE  *)va_arg( lib_args, FILE  *);
+            NDT_Recursive_Mode    Recursive_Mode   = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode);
+            va_list user_args                      = (va_list)va_arg( Args, va_list);
+            IMRT_SDMCB_Field_Map * MappingFieldFunc      = ( IMRT_SDMCB_Field_Map *)va_arg(lib_args, IMRT_SDMCB_Field_Map *);
+            IMRT_Status   status;
+
+            status = MappingFieldFunc(Value_Ptr->Field_Output_Ptr, Value_Ptr->Field_Input_Ptr);
+			if (status == IMRS_KO)
+			{
+				return( NDS_KO);
+			}
+            return( NDS_OK);
+        }
+
+		case IMRD_SDMD_CMD_API_SQL_DUMP:
+		{
+		/*
+			NDT_Node   *Next_Node_Ptr = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+			va_list     user_args     =     (va_list)va_arg( Args, va_list);
+			user_type   user_data     =   (user_type)va_arg( user_args, user_type);
+								  ... =         (...)va_arg( user_args, ...);
+
+  			void       *Value_Ptr     = Node_Ptr->Value;
+		*/
+			NDT_Node        *Next_Node_Ptr = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+			va_list          user_args     =     (va_list)va_arg( Args, va_list);
+			FILE            *Out           =     (FILE  *)va_arg( user_args, FILE  *);
+			IMRT_MsgMap_Id  MsgMap_Id      =     (IMRT_MsgMap_Id)va_arg( user_args, IMRT_MsgMap_Id);
+			IMRT_FieldMap   *FieldMap_Ptr  = Node_Ptr->Value;
+
+
+			Command_Name = "IMRD_SDMD_CMD_API_SQL_DUMP";
+			
+			fprintf( Out, "INSERT INTO IMR_FIELD_MAP(FIELD_MAP_ID, MSG_MAP_ID, FIELD_IN_ID, FIELD_OUT_ID) VALUES(%d, %d, %d, %d);\n",
+					FieldMap_Ptr->Id, MsgMap_Id, FieldMap_Ptr->Field_Input_Ptr->Id, FieldMap_Ptr->Field_Output_Ptr->Id);
+
+			return( NDS_OK);
+		}
+
+		case IMRD_SDMD_CMD_API_XML_DUMP:
+		{
+		/*
+			NDT_Node   *Next_Node_Ptr = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+			va_list     user_args     =     (va_list)va_arg( Args, va_list);
+			user_type   user_data     =   (user_type)va_arg( user_args, user_type);
+								  ... =         (...)va_arg( user_args, ...);
+
+  			void       *Value_Ptr     = Node_Ptr->Value;
+		*/
+			NDT_Node        *Next_Node_Ptr = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+			va_list          user_args     =     (va_list)va_arg( Args, va_list);
+			FILE            *Out           =     (FILE  *)va_arg( user_args, FILE  *);
+
+			IMRT_FieldMap   *FieldMap_Ptr  = Node_Ptr->Value;
+
+
+			Command_Name = "IMRD_SDMD_CMD_API_XML_DUMP";
+
+			fprintf( Out, "\t\t\t<%s>\n\t\t\t\t<%s>%s</%s>\n\t\t\t\t<%s>%s</%s>\n\t\t\t</%s>\n", IMRD_SDMD_TAG_FIELDMAP,
+						IMRD_SDMD_TAG_INPUTFIELD, FieldMap_Ptr->Field_Input_Ptr->Name, IMRD_SDMD_TAG_INPUTFIELD, 
+						IMRD_SDMD_TAG_OUTPUTFIELD, FieldMap_Ptr->Field_Output_Ptr->Name, IMRD_SDMD_TAG_OUTPUTFIELD, 
+						IMRD_SDMD_TAG_FIELDMAP);
+
+			return( NDS_OK);
+		}
+
+        default:
+        {
+            printf( "SDM_FieldMap_Manager() called with an undefined command %d\n", Command);
+
+            return( NDS_ERRAPI);
+        }
+    }
+
+    printf( "SDM_FieldMap_Manager() called with command %d (%s)\n", Command, Command_Name);
+
+    return( NDS_OK);
+}
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* MsgMap Manager                                                             */
+/*----------------------------------------------------------------------------*/
+
+NDT_Status  SDM_MsgMap_Manager( NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id, NDT_Node  *Node_Ptr, NDT_Command  Command, va_list  Args)
+{
+    NDT_Command_Name  Command_Name;
+    NDT_Status        status;
+
+
+    switch( Command)
+    {
+        case NDD_CMD_MANAGER_VERSION:
+        {
+            NDT_Version_Name  *Version_Name_Ptr = (NDT_Version_Name  *)va_arg( Args, NDT_Version_Name  *);
+
+
+            Command_Name = "NDD_CMD_MANAGER_VERSION";
+
+            *Version_Name_Ptr = "Revision: 2.1    Name: libnode-2_0_4-1    Date: 2002/02/28 22:00:35    Author: agibert ";
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_INDEX_GET:
+        {
+            /*
+	      NDT_Index_Id  *Reply_Index_Id_Ptr = (NDT_Index_Id  *)va_arg( Args, NDT_Index_Id  *);
+	      NDT_Command   *Reply_Command_Ptr  = (NDT_Command  *)va_arg( Args, NDT_Command  *);
+	      NDT_Command    Cmd                = (NDT_Command)va_arg( Args, NDT_Command);
+	      void          *Value_ptr          = (void  *)va_arg( Args, void  *);
+            */
+            NDT_Index_Id  *Reply_Index_Id_Ptr = (NDT_Index_Id  *)va_arg( Args, NDT_Index_Id  *);
+            NDT_Command   *Reply_Command_Ptr  = (NDT_Command  *)va_arg( Args, NDT_Command  *);
+            NDT_Command    Cmd                = (NDT_Command)va_arg( Args, NDT_Command);
+            IMRT_MsgMap  *      Value_ptr     = (IMRT_MsgMap  *)va_arg( Args, IMRT_MsgMap  *);
+
+
+            Command_Name = "NDD_CMD_INDEX_GET";
+
+            switch(Cmd)
+            {
+                case IMRD_SDMD_CMD_INDEX0_PRINT:
+                {
+                    *Reply_Index_Id_Ptr = 0;
+                    *Reply_Command_Ptr = NDD_CMD_VALUE_PRINT;
+
+                    break;
+                }
+
+				case IMRD_SDMD_CMD_API_SQL_DUMP:
+				{
+                    *Reply_Index_Id_Ptr = IMRD_SDMD_MSGMAP_IDX_ID;
+                    *Reply_Command_Ptr = IMRD_SDMD_CMD_API_SQL_DUMP;
+                    break;
+				}
+
+				case IMRD_SDMD_CMD_API_XML_DUMP:
+				{
+                    *Reply_Index_Id_Ptr = IMRD_SDMD_MSGMAP_IDX_ID;
+                    *Reply_Command_Ptr = IMRD_SDMD_CMD_API_XML_DUMP;
+                    break;
+				}
+
+                default:
+                {
+                    *Reply_Index_Id_Ptr = Index_Id;
+                    *Reply_Command_Ptr = Cmd;
+
+                    break;
+                }
+            }
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_ALLOC:
+        {
+            /*
+	      void       **Value_Ptr_Ptr = (void **)va_arg( Args, void  **);
+	      va_list      user_args     = (va_list)va_arg( Args, va_list);
+	      user_type    user_data     = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+            */
+            IMRT_MsgMap  **Value_Ptr_Ptr = va_arg( Args, IMRT_MsgMap  **);
+
+
+            Command_Name = "NDD_CMD_VALUE_ALLOC";
+
+            if( ( *Value_Ptr_Ptr = (IMRT_MsgMap  *)malloc( sizeof(IMRT_MsgMap))) == NULL)
+            {
+                return( NDS_ERRMEM);
+            }
+            else
+            {
+                SDM_InitMsgMap(*Value_Ptr_Ptr);
+
+                if( ( status = ND_DataStruct_Open( &(*Value_Ptr_Ptr)->FieldMap_Struct_Ptr, IMRD_SDMD_INDEX_NB, index_type_initial_tab, "SDM_FieldMap_Manager", SDM_FieldMap_Manager, NULL, NULL, NULL, NULL,0,  NULL)) != NDS_OK)
+		{
+		    printf( "ND_DataStruct_Open() FieldMap failed (%d) !\n", status);
+		}
+
+                return( NDS_OK);
+            }
+        }
+
+        case NDD_CMD_VALUE_FREE:
+        {
+            /*
+	      void       *Value_Ptr = (void *)va_arg( Args, void  *);
+	      va_list     user_args = (va_list)va_arg( Args, va_list);
+	      user_type   user_data = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+            */
+            IMRT_MsgMap  *Value_Ptr = (IMRT_MsgMap  *)va_arg( Args, IMRT_MsgMap  *);
+
+
+            Command_Name = "NDD_CMD_VALUE_FREE";
+
+            if(Value_Ptr->FieldMap_Struct_Ptr != NULL)
+            {  if( ( status = ND_DataStruct_Close(Value_Ptr->FieldMap_Struct_Ptr)) != NDS_OK)
+		{
+		    printf( "ND_DataStruct_Close() failed (%d) !\n", status);
+
+		    return(status);
+		}
+            }
+
+            free( Value_Ptr);
+            
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_COMP:
+        {
+            /*
+	      void       *Value1_Ptr = (void *)va_arg( Args, void  *);
+	      void       *Value2_Ptr = (void *)va_arg( Args, void  *);
+	      va_list     user_args  = (va_list)va_arg( Args, va_list);
+	      user_type   user_data  = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+            */
+            IMRT_MsgMap     *Value1_Ptr = va_arg( Args, IMRT_MsgMap  *);
+            IMRT_MsgMap     *Value2_Ptr = va_arg( Args, IMRT_MsgMap  *);
+
+
+            Command_Name = "NDD_CMD_VALUE_COMP";
+
+            switch( Index_Id)
+            {
+                case IMRD_SDMD_MSGMAP_IDX_ID:
+                {
+                    if( Value1_Ptr->Id < Value2_Ptr->Id)
+                    {
+                        return( NDS_LOWER);
+                    }
+                    else
+                    {
+                        if( Value1_Ptr->Id > Value2_Ptr->Id)
+                        {
+                            return( NDS_GREATER);
+                        }
+                        else
+                        {
+                            return( NDS_EQUAL);
+                        }
+                    }
+                }
+
+                case IMRD_SDMD_MSGMAP_IDX_NAME:
+                {
+                    int     rc;
+
+
+                    rc=strcmp( Value1_Ptr->Name, Value2_Ptr->Name);
+
+                    if( rc <0)
+                    {
+                        return( NDS_LOWER);
+                    }
+                    else
+                    {
+                        if( rc > 0)
+                        {
+                            return( NDS_GREATER);
+                        }
+                        else
+                        {
+                            return( NDS_EQUAL);
+                        }
+                    }
+                }
+
+                default:
+                {
+                    printf( "Unknown COMP idx (%d) !\n", Index_Id);
+
+                    return( NDS_KO);
+                }
+            }
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_ADD:
+        {
+            /*
+	      void       *Value_Ptr = (void *)va_arg( Args, void  *);
+	      va_list     user_args = (va_list)va_arg( Args, va_list);
+	      user_type   user_data = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+            */
+
+            Command_Name = "NDD_CMD_VALUE_ADD";
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_REMOVE:
+        {
+            /*
+	      void       *Value_Ptr = (void *)va_arg( Args, void  *);
+	      va_list     user_args = (va_list)va_arg( Args, va_list);
+	      user_type   user_data = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+            */
+
+            Command_Name = "NDD_CMD_VALUE_REMOVE";
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_PRINT:
+        {
+            /*
+	      NDT_Node             *Next_Node_Ptr    = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+	      va_list               lib_args         = (va_list)va_arg( Args, va_list);
+	      FILE                 *Out              = (FILE  *)va_arg( lib_args, FILE  *);
+	      NDT_Recursive_Mode    Recursive_Mode   = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode);
+	      NDT_Recursive_Depth   Recursive_Depth  = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth);
+	      NDT_Recursive_Offset  Recursive_Offset = (NDT_Recursive_Offset)va_arg( lib_args, NDT_Recursive_Offset);
+	      va_list               user_args        = (va_list)va_arg( lib_args, va_list);
+	      user_type             user_data        = (user_type)va_arg( user_args, user_type);
+	      ...  = (...)va_arg( user_args, ...);
+	      void                 *Value_Ptr       = Node_Ptr->Value;
+            */
+            NDT_Node             *Next_Node_Ptr    = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+            va_list               lib_args         = (va_list)va_arg( Args, va_list);
+            FILE                 *Out              = (FILE  *)va_arg( lib_args, FILE  *);
+            NDT_Recursive_Mode    Recursive_Mode   = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode);
+            NDT_Recursive_Depth   Recursive_Depth  = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth);
+            NDT_Recursive_Offset  Recursive_Offset = (NDT_Recursive_Offset)va_arg( lib_args, NDT_Recursive_Offset);
+
+            IMRT_MsgMap           *Value_Ptr       = Node_Ptr->Value;
+
+
+            Command_Name = "NDD_CMD_VALUE_PRINT";
+
+            printf("Adresse avant traverse (%x)\n",Value_Ptr);
+
+            fprintf( Out, "Name: (%s)   InputMsgName: (%s)   OutputMsgName: (%s)   \n",
+		     Value_Ptr->Name, Value_Ptr->Msg_Input_Ptr->Name, Value_Ptr->Msg_Output_Ptr->Name);
+
+            return( ND_DataStruct_Value_Print( Out, Value_Ptr->FieldMap_Struct_Ptr, NDD_RECURSIVE_MODE_PARENT_CHILD, --Recursive_Depth, ++Recursive_Offset));
+        }
+
+        case NDD_CMD_INFO_PRINT:
+        {
+            /*
+	      NDT_Node             *Next_Node_Ptr    = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+	      va_list               lib_args         = (va_list)va_arg( Args, va_list);
+	      FILE                 *Out              = (FILE  *)va_arg( lib_args, FILE  *);
+	      NDT_Recursive_Mode    Recursive_Mode   = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode);
+	      NDT_Recursive_Depth   Recursive_Depth  = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth);
+	      NDT_Recursive_Offset  Recursive_Offset = (NDT_Recursive_Offset)va_arg( lib_args, NDT_Recursive_Offset);
+	      va_list               user_args        = (va_list)va_arg( lib_args, va_list);
+	      user_type             user_data        = (user_type)va_arg( user_args, user_type);
+	      ...  = (...)va_arg( user_args, ...);
+	      void                 *Value_Ptr        = Node_Ptr->Value;
+            */
+
+            NDT_Node             *Next_Node_Ptr    = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+	    va_list               lib_args         = (va_list)va_arg( Args, va_list);
+	    FILE                 *Out              = (FILE  *)va_arg( lib_args, FILE  *);
+	    NDT_Recursive_Mode    Recursive_Mode   = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode);
+	    NDT_Recursive_Depth   Recursive_Depth  = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth);
+	    NDT_Recursive_Offset  Recursive_Offset = (NDT_Recursive_Offset)va_arg( lib_args, NDT_Recursive_Offset);
+			      
+	    IMRT_MsgMap  *Msg_Ptr                    = Node_Ptr->Value;
+
+
+	    Command_Name = "NDD_CMD_INFO_PRINT";
+
+	    return( ND_DataStruct_Info_Print( Out, Msg_Ptr->FieldMap_Struct_Ptr, NDD_RECURSIVE_MODE_PARENT_CHILD, --Recursive_Depth, ++Recursive_Offset));
+        }
+        
+		
+		case IMRD_SDMD_CMD_API_SQL_DUMP:
+		{
+		/*
+			NDT_Node   *Next_Node_Ptr = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+			va_list     user_args     =     (va_list)va_arg( Args, va_list);
+			user_type   user_data     =   (user_type)va_arg( user_args, user_type);
+								  ... =         (...)va_arg( user_args, ...);
+
+  			void       *Value_Ptr     = Node_Ptr->Value;
+		*/
+			NDT_Node        *Next_Node_Ptr = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+			va_list          user_args     =     (va_list)va_arg( Args, va_list);
+			FILE            *Out           =     (FILE  *)va_arg( user_args, FILE  *);
+
+			IMRT_MsgMap     *MsgMap_Ptr    = Node_Ptr->Value;
+
+
+			Command_Name = "IMRD_SDMD_CMD_API_SQL_DUMP";
+
+			fprintf( Out, "INSERT INTO IMR_MSG_MAP(MSG_MAP_ID, MSG_MAP_NAME, MSG_IN_ID, MSG_OUT_ID) VALUES(%d, '%s', %d, %d);\n",
+					MsgMap_Ptr->Id, MsgMap_Ptr->Name, MsgMap_Ptr->Msg_Input_Ptr->Id, MsgMap_Ptr->Msg_Output_Ptr->Id);
+
+		    if( ( status = ND_DataStruct_Traverse( MsgMap_Ptr->FieldMap_Struct_Ptr, IMRD_SDMD_CMD_API_SQL_DUMP, Out, MsgMap_Ptr->Id)) != NDS_OK)
+			{
+				printf( "ND_DataStruct_Traverse failed (%d)...\n");
+				return(NDS_KO);
+			}
+
+			return( NDS_OK);
+		}
+
+		case IMRD_SDMD_CMD_API_XML_DUMP:
+		{
+		/*
+			NDT_Node   *Next_Node_Ptr = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+			va_list     user_args     =     (va_list)va_arg( Args, va_list);
+			user_type   user_data     =   (user_type)va_arg( user_args, user_type);
+								  ... =         (...)va_arg( user_args, ...);
+
+  			void       *Value_Ptr     = Node_Ptr->Value;
+		*/
+			NDT_Node        *Next_Node_Ptr = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+			va_list          user_args     =     (va_list)va_arg( Args, va_list);
+			FILE            *Out           =     (FILE  *)va_arg( user_args, FILE  *);
+
+			IMRT_MsgMap     *MsgMap_Ptr    = Node_Ptr->Value;
+
+
+			Command_Name = "IMRD_SDMD_CMD_API_XML_DUMP";
+
+			fprintf( Out, "\t<%s>\n\t\t<%s>%s</%s>\n\t\t<%s>%s</%s>\n\t\t<%s>%s</%s>\n\t\t<%s>\n", IMRD_SDMD_TAG_MSGMAP, 
+						IMRD_SDMD_TAG_NAME, MsgMap_Ptr->Name, IMRD_SDMD_TAG_NAME,
+						IMRD_SDMD_TAG_INPUTMSG, MsgMap_Ptr->Msg_Input_Ptr->Name, IMRD_SDMD_TAG_INPUTMSG,
+						IMRD_SDMD_TAG_OUTPUTMSG, MsgMap_Ptr->Msg_Output_Ptr->Name, IMRD_SDMD_TAG_OUTPUTMSG,
+						IMRD_SDMD_TAG_FIELDMAPSTRUCT);
+
+		    if( ( status = ND_DataStruct_Traverse( MsgMap_Ptr->FieldMap_Struct_Ptr, IMRD_SDMD_CMD_API_XML_DUMP, Out)) != NDS_OK)
+			{
+				printf( "ND_DataStruct_Traverse failed (%d)...\n");
+				return(NDS_KO);
+			}
+
+			fprintf( Out, "\t\t</%s>\n\t</%s>\n", IMRD_SDMD_TAG_FIELDMAPSTRUCT, IMRD_SDMD_TAG_MSGMAP);
+
+			return( NDS_OK);
+		}
+
+
+		default:
+        {
+            printf( "SDM_MsgMap_Manager() called with an undefined command %d\n", Command);
+
+            return( NDS_ERRAPI);
+        }
+    }
+
+    printf( "SDM_MsgMap_Manager() called with command %d (%s)\n", Command, Command_Name);
+
+    return( NDS_OK);
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status SDM_MapInfo_Init(IMRT_SDM_Config * Lib_Config_Ptr)
+{
+    IMRT_Status  status;
+    if(Lib_Config_Ptr->Flag == IMRD_SDM_FLAG_XML)
+    {
+		status = SDM_XML_MapInfo_Init(Lib_Config_Ptr->Lib_Path);
+    }
+    else
+    {
+#ifdef ORACLE_SUPPORT
+		status = SDM_SQL_MapInfo_Init();
+#else
+		status = IMRS_OK;
+#endif /* ORACLE_SUPPORT */
+    }
+    return(status);
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status SDM_Close_RootMsgMap(void)
+{
+	IMRT_Status  status;
+	NDT_Status   nd_status;
+
+	status = IMRS_OK;
+
+	if(IMRG_SDM_Base.RootMsgMap != NULL)
+	{
+		if (IMRG_SDM_Base.RootMsgMap->User_Ptr != NULL)
+		{
+			free(IMRG_SDM_Base.RootMsgMap->User_Ptr);
+		}
+
+		if( ( nd_status = ND_DataStruct_Close(IMRG_SDM_Base.RootMsgMap)) != NDS_OK)
+		{
+			printf( "RootMsgMap ND_DataStruct_Close() failed (%d) !\n", nd_status);
+			status = IMRS_KO;
+		}
+	}
+
+	return(status);
+
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status SDM_MapInfo_DInit(void)
+{
+	IMRT_Status  status, StatusMsgMap;
+	NDT_Status   nd_status;
+
+	status = IMRS_OK;
+
+	StatusMsgMap = SDM_Close_RootMsgMap();
+
+	if(StatusMsgMap == IMRS_KO)
+	{
+		status = IMRS_KO;
+	}
+
+	return(status);
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  SDM_MsgMap_Proceed( IMRT_MsgMap  *MsgMap_Ptr, IMRT_SDMCB_Field_Map  *CCB_Field_Map_Ptr)
+{
+
+    NDT_Status status;
+
+    if( ( status = ND_DataStruct_Traverse( MsgMap_Ptr->FieldMap_Struct_Ptr, IMRD_SDMD_CMD_EXECUTE, stdout, NDD_RECURSIVE_MODE_PARENT,CCB_Field_Map_Ptr)) != NDS_OK)
+    {
+	printf( "ND_DataStruct_Traverse() failed (%d) !\n", status);
+    }
+    return((IMRT_Status)status);
+}
+
+void SDM_InitMsgMap(IMRT_MsgMap * mymsgmap)
+{
+  memset(mymsgmap->Name,0,sizeof(mymsgmap->Name));
+  mymsgmap->Msg_Input_Ptr   = NULL;
+  mymsgmap->Msg_Output_Ptr  = NULL;
+  mymsgmap->FieldMap_Struct_Ptr   = NULL;
+}
+
+void SDM_InitFieldMap(IMRT_FieldMap * myfieldmap)
+{
+ myfieldmap->Id = IMRD_FIELDMAP_ID_UNKNOWN;
+ myfieldmap->Field_Input_Ptr  = NULL;
+ myfieldmap->Field_Output_Ptr = NULL;
+}
diff --git a/src/libstatic_data_mng/src/mapping_info_mng.h b/src/libstatic_data_mng/src/mapping_info_mng.h
new file mode 100644
index 0000000..fcdc407
--- /dev/null
+++ b/src/libstatic_data_mng/src/mapping_info_mng.h
@@ -0,0 +1,118 @@
+/*----------------------------------------------------------------------------*/
+/* File: mapping_info_mng.h 				         	      */
+/*----------------------------------------------------------------------------*/
+/*                                                                            */
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#ifndef _MAPPING_INFO_MNG_H_
+#   define _MAPPING_INFO_MNG_H_
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Global Include                                                             */
+/*----------------------------------------------------------------------------*/
+
+#   include <libstatic_data_mng.h>
+
+
+/*----------------------------------------------------------------------------*/
+/* XML TAG                                                                    */
+/*----------------------------------------------------------------------------*/
+#define IMRD_SDMD_TAG_MSGMAP_STRUCT "msgmap_struct" 
+
+/* Nom des fichiers pour le chargement XML */
+#define SDMD_MSGMAP_FILE            "sd_msgmap_struct.xml"
+
+
+/********************************************************************/
+/*       Les index du Manager SDM_MsgMap_Manager                    */
+/********************************************************************/
+#define IMRD_SDMD_MSGMAP_STRUCT_IDX_NB                (short)2
+
+static NDT_Index_Type  MsgMap_Struct_initial_idx_tab[IMRD_SDMD_MSGMAP_STRUCT_IDX_NB] = 
+{
+      (NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_LIST | NDD_INDEX_SUBTYPE_SORTED),
+      (NDD_INDEX_STATUS_CLOSED)
+};
+
+static NDT_Index_Type  MsgMap_Struct_final_idx_tab[IMRD_SDMD_MSGMAP_STRUCT_IDX_NB] = 
+{
+      (NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_TREE | NDD_INDEX_SUBTYPE_BALANCED),
+      (NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_TREE | NDD_INDEX_SUBTYPE_BALANCED)
+};
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Prototypes                                                                 */
+/*----------------------------------------------------------------------------*/
+
+#   ifdef _MAPPING_INFO_MNG_C_
+
+NDT_Status  SDM_FieldMap_Manager( NDT_Root  *, NDT_Index_Id, NDT_Node  *, NDT_Command, va_list);
+NDT_Status  SDM_MsgMap_Manager(   NDT_Root  *, NDT_Index_Id, NDT_Node  *, NDT_Command, va_list);
+IMRT_Status SDM_MapInfoInfo_Init(IMRT_Lib_Flag  Lib_Flag);
+IMRT_Status SDM_Close_RootMsgMap(void);
+IMRT_Status SDM_MapInfo_Init(IMRT_SDM_Config  * Lib_Config_Ptr);
+IMRT_Status SDM_MapInfo_DInit(void);
+IMRT_Status  SDM_MsgMap_Proceed( IMRT_MsgMap  *MsgMap_Ptr, IMRT_SDMCB_Field_Map  *CCB_Field_Map_Ptr);
+void SDM_InitMsgMap(IMRT_MsgMap * mymsgmap);
+void SDM_InitFieldMap(IMRT_FieldMap * myfieldmap);
+
+#   else
+
+extern NDT_Status  SDM_FieldMap_Manager( NDT_Root  *, NDT_Index_Id, NDT_Node  *, NDT_Command, va_list);
+extern NDT_Status  SDM_MsgMap_Manager(   NDT_Root  *, NDT_Index_Id, NDT_Node  *, NDT_Command, va_list);
+extern IMRT_Status SDM_MapInfo_Init(IMRT_SDM_Config  * Lib_Config_Ptr);
+extern IMRT_Status SDM_Close_RootMsgMap(void);
+extern IMRT_Status SDM_MapInfo_DInit(void);
+extern IMRT_Status  SDM_MsgMap_Proceed( IMRT_MsgMap  *MsgMap_Ptr, IMRT_SDMCB_Field_Map  *CCB_Field_Map_Ptr);
+
+#   endif
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Local Includes                                                             */
+/*----------------------------------------------------------------------------*/
+
+#   ifdef _MAPPING_INFO_MNG_C_
+
+#       include "mapping_info_xml.h"
+#       include "mapping_info_sql.h"
+
+#   endif
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+
+#endif
diff --git a/src/libstatic_data_mng/src/mapping_info_sql.h b/src/libstatic_data_mng/src/mapping_info_sql.h
new file mode 100644
index 0000000..fb308f0
--- /dev/null
+++ b/src/libstatic_data_mng/src/mapping_info_sql.h
@@ -0,0 +1,79 @@
+/*----------------------------------------------------------------------------*/
+/* File: mapping_info_sql.h 				         	      */
+/*----------------------------------------------------------------------------*/
+/*                                                                            */
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#ifndef _MAPPING_INFO_SQL_H_
+#   define _MAPPING_INFO_SQL_H_
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Global Include                                                             */
+/*----------------------------------------------------------------------------*/
+
+#   include <libstatic_data_mng.h>
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Prototypes                                                                 */
+/*----------------------------------------------------------------------------*/
+
+#   ifdef _MAPPING_INFO_SQL_PC_
+
+IMRT_Status SDM_SQL_MapInfo_Init(void);
+IMRT_Status SDM_SQL_Load_MsgMap(NDT_Root  **myRootMsgMap_Ptr_Ptr);
+IMRT_Status SDM_SQL_LoadFieldMap(IMRT_MsgMap *myMsgMap);
+IMRT_Status SDM_SQL_Dump_MsgMap_Header(FILE *dump_file);
+IMRT_Status SDM_SQL_Dump_MsgMap_Body(FILE *dump_file);
+IMRT_Status SDM_SQL_Dump_MsgMap_Footer(FILE *dump_file);
+IMRT_Status SDM_SQL_Dump_MsgMap(void);
+IMRT_Status SDM_SQL_MapInfo_Dump(void);
+
+#   else
+
+extern IMRT_Status SDM_SQL_MapInfo_Init(void);
+extern IMRT_Status SDM_SQL_Load_MsgMap(NDT_Root  **myRootMsgMap_Ptr_Ptr);
+extern IMRT_Status SDM_SQL_LoadFieldMap(IMRT_MsgMap *myMsgMap);
+extern IMRT_Status SDM_SQL_Dump_MsgMap_Header(FILE *dump_file);
+extern IMRT_Status SDM_SQL_Dump_MsgMap_Body(FILE *dump_file);
+extern IMRT_Status SDM_SQL_Dump_MsgMap_Footer(FILE *dump_file);
+extern IMRT_Status SDM_SQL_Dump_MsgMap(void);
+extern IMRT_Status SDM_SQL_MapInfo_Dump(void);
+
+#   endif
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+
+#endif
diff --git a/src/libstatic_data_mng/src/mapping_info_sql.pc b/src/libstatic_data_mng/src/mapping_info_sql.pc
new file mode 100644
index 0000000..57f3608
--- /dev/null
+++ b/src/libstatic_data_mng/src/mapping_info_sql.pc
@@ -0,0 +1,402 @@
+/*----------------------------------------------------------------------------*/
+/* File: mapping_info_sql.pc   		         		  	      */
+/*----------------------------------------------------------------------------*/
+/*                                                                            */
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#define _LIBSTATIC_DATA_MNG_
+#define _MAPPING_INFO_SQL_PC_
+
+#include "mapping_info_sql.h" 
+
+IMRT_Status SDM_SQL_MapInfo_Init(void)
+{
+    IMRT_Status   status;
+
+    IMRD_LM_LOG_TRACE_0( IMRD_LOG_LEVEL_VERBOSE_0, "Loading MsgMap...");
+    status = SDM_SQL_Load_MsgMap(&(IMRG_SDM_Base.RootMsgMap));
+
+    if(status == IMRS_OK)
+    {
+		IMRD_LM_LOG_INFO_1( "MsgMap loaded: (%d)", IMRG_SDM_Base.RootMsgMap->Index_Tab[NDD_INDEX_PRIMARY].Node_Number);
+    }
+    else
+    {
+		IMRD_LM_LOG_ERROR_0( "Can't load MsgMap !");
+    }
+
+    return(status);
+    
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status SDM_SQL_Load_MsgMap(NDT_Root  **myRootMsgMap_Ptr_Ptr)
+{
+    const char sFunctionName []="SDM_SQL_Load_MsgMap";
+    NDT_Status       nd_status;
+    IMRT_Status      status;
+    NDT_Index_Type  *index_type_ptr;
+    IMRT_Msg         message;
+    NDT_Node        *node_ptr;
+    IMRT_MsgMap     *myMsgMap_Ptr;
+	IMRT_Data_Version   *Data_Version_Ptr;
+
+    EXEC SQL BEGIN DECLARE SECTION;
+	    IMRT_MsgMap_Id hMsgMapId;
+	    VARCHAR vMsgMapName[IMRD_NAME_SIZE];
+	    IMRT_Msg_Id hMsgInId;
+	    IMRT_Msg_Id hMsgOutId;
+
+	    short   hIndMsgMapId;
+	    short   hIndMsgMapName;
+	    short   hIndMsgInId;
+	    short   hIndMsgOutId;
+    EXEC SQL END DECLARE SECTION;
+
+	
+    /*initialisation des indexes*/
+    index_type_ptr =  MsgMap_Struct_initial_idx_tab;
+
+	Data_Version_Ptr = (IMRT_Data_Version *) malloc(sizeof(IMRT_Data_Version));
+	status = SDM_SQL_Set_Struct_Version(Data_Version_Ptr, "MsgMap");
+	if (status != IMRS_OK)
+	{
+		return(IMRS_KO);
+	}
+
+    nd_status = ND_DataStruct_Open(myRootMsgMap_Ptr_Ptr, IMRD_SDMD_MSGMAP_STRUCT_IDX_NB, index_type_ptr, "SDM_MsgMap_Manager",SDM_MsgMap_Manager, NULL, NULL, NULL, NULL,0, Data_Version_Ptr);
+    if (nd_status != NDS_OK)
+    {
+		IMRD_LM_LOG_ERROR_2( "%s : ND_DataStruct_Open  -- SDM_MsgMap_Manager failed (%d) !", sFunctionName, nd_status);
+		status = IMRS_KO;
+    }
+    else
+    {
+		EXEC SQL DECLARE cur_imr_msg_map CURSOR FOR
+		    SELECT MSG_MAP_ID, MSG_MAP_NAME, MSG_IN_ID, MSG_OUT_ID
+		    FROM   IMR_MSG_MAP
+		    ORDER BY MSG_MAP_ID ASC;
+	
+		EXEC SQL OPEN cur_imr_msg_map;
+		do
+		{
+		    memset(vMsgMapName.arr, '\0', (size_t) IMRD_NAME_SIZE);
+	
+		    EXEC SQL FETCH cur_imr_msg_map
+	      		INTO :hMsgMapId:hIndMsgMapId,
+	      			 :vMsgMapName:hIndMsgMapName,
+					 :hMsgInId:hIndMsgInId,
+					 :hMsgOutId:hIndMsgOutId;
+		    if (sqlca.sqlcode == 0) 
+		    {
+				/* creation d'un nouveau objet MsgMap */
+				nd_status = ND_Value_Alloc( *myRootMsgMap_Ptr_Ptr, (void  **)&(myMsgMap_Ptr));
+				if(nd_status != NDS_OK)
+				{
+				    IMRD_LM_LOG_ERROR_2( "%s : ND_Value_Alloc  -- SDM_MsgMap_Manager failed (%d) !", sFunctionName, nd_status);
+				    status = IMRS_KO;
+				}
+				else
+				{
+				    myMsgMap_Ptr->Id = hMsgMapId;
+				    strcpy(myMsgMap_Ptr->Name, (char *) vMsgMapName.arr);
+				    /**** Message InPut  ****/
+				    message.Id = hMsgInId;
+				    nd_status = ND_Index_Node_Find( &node_ptr, IMRG_SDM_Base.RootMsg,
+								     IMRD_SDMD_MSG_IDX_ID, &message, NULL);
+				    if((nd_status != NDS_OK)||(node_ptr == NULL))
+				    {
+						IMRD_LM_LOG_ERROR_1( "Erreur lors de la recherche du Message IN <%d> !", message.Id);
+						status = IMRS_KO;
+				    }
+				    else
+				    {
+						myMsgMap_Ptr->Msg_Input_Ptr = node_ptr->Value;
+				    }
+				    /**** Message OutPut  ****/
+				    message.Id = hMsgOutId;
+				    nd_status = ND_Index_Node_Find( &node_ptr, IMRG_SDM_Base.RootMsg,
+								     IMRD_SDMD_MSG_IDX_ID, &message, NULL);
+				    if((nd_status != NDS_OK)||(node_ptr == NULL))
+				    {
+						IMRD_LM_LOG_ERROR_1( "Erreur lors de la recherche du Message Out <%d> !", message.Id);
+						status = IMRS_KO;
+				    }
+				    else
+				    {
+						myMsgMap_Ptr->Msg_Output_Ptr = node_ptr->Value;
+				    }
+		
+				    status = SDM_SQL_LoadFieldMap(myMsgMap_Ptr);
+				    if (status == IMRS_OK)
+				    {
+						/* Ajout du message */
+						nd_status = ND_DataStruct_Value_Add( *myRootMsgMap_Ptr_Ptr, (void  *)myMsgMap_Ptr);
+						if(nd_status != NDS_OK)
+						{
+						    IMRD_LM_LOG_ERROR_2( "%s : ND_DataStruct_Value_Add  -- SDM_MsgMap_Manager failed (%d) !", sFunctionName, nd_status);
+						    status = IMRS_KO;
+						}
+				    }
+				}
+		    }
+		} while((sqlca.sqlcode == 0)&&(nd_status == NDS_OK)&&(status == IMRS_OK));
+	
+		if (sqlca.sqlcode < 0)
+		{
+		    IMRD_LM_LOG_ERROR_3( "Erreur %s. Erreur Oracle : %d - %s !", sFunctionName, sqlca.sqlcode, sqlca.sqlerrm.sqlerrmc);
+		    status = IMRS_KO;
+		}
+	
+		EXEC SQL CLOSE cur_imr_msg_map;
+	
+		if(status == IMRS_OK)
+		{
+			index_type_ptr = MsgMap_Struct_final_idx_tab;
+			status = SDM_DataStruct_Finalize(*myRootMsgMap_Ptr_Ptr, index_type_ptr, IMRD_SDMD_MSGMAP_STRUCT_IDX_NB);
+		    /*SDM_DataStruct_Dump(*myRootMsgMap_Ptr_Ptr);*/
+		}
+		else
+		{
+            if(myMsgMap_Ptr->FieldMap_Struct_Ptr != NULL)
+			{
+                nd_status = ND_DataStruct_Close(myMsgMap_Ptr->FieldMap_Struct_Ptr);
+			    if(nd_status != NDS_OK)
+			    {
+					IMRD_LM_LOG_ERROR_1( "ND_DataStruct_Close() failed (%d) !", nd_status);
+			    }
+            }
+
+		    nd_status = ND_DataStruct_Close(*myRootMsgMap_Ptr_Ptr);
+		    if(nd_status != NDS_OK)
+		    {
+				IMRD_LM_LOG_ERROR_1( "ND_DataStruct_Close() failed (%d) !", nd_status);
+		    }
+		}
+    }
+
+    return(status);
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status SDM_SQL_LoadFieldMap(IMRT_MsgMap *myMsgMap_Ptr)
+{
+    const char sFunctionName []="SDM_SQL_LoadFieldMap";
+    NDT_Status    nd_status;
+    IMRT_Status   status;
+    IMRT_Field     myField;
+    NDT_Node      *node_ptr;
+    IMRT_FieldMap *myFieldMap_Ptr;
+
+    EXEC SQL BEGIN DECLARE SECTION;
+	    IMRT_FieldMap_Id   hFieldMapId;
+	    IMRT_Field_Id  hFieldInId;
+	    IMRT_Field_Id  hFieldOutId;
+
+	    short   hIndFieldMapId;
+	    short   hIndFieldInId;
+	    short   hIndFieldOutId;
+    EXEC SQL END DECLARE SECTION;
+	
+    status = IMRS_OK;
+
+    EXEC SQL DECLARE cur_imr_field_map CURSOR FOR
+	  	SELECT FIELD_MAP_ID, FIELD_IN_ID, FIELD_OUT_ID
+		FROM   IMR_FIELD_MAP
+		WHERE  MSG_MAP_ID = :myMsgMap_Ptr->Id
+		ORDER BY FIELD_MAP_ID ASC;
+
+    EXEC SQL OPEN cur_imr_field_map;
+    do
+    {
+	
+		EXEC SQL FETCH cur_imr_field_map
+		    INTO :hFieldMapId:hIndFieldMapId,
+		    	 :hFieldInId:hIndFieldInId,
+		    	 :hFieldOutId:hIndFieldOutId;
+	
+		if (sqlca.sqlcode == 0) 
+		{
+		    /* Allacation de FieldMap */
+		    nd_status = ND_Value_Alloc( myMsgMap_Ptr->FieldMap_Struct_Ptr, (void  **)&(myFieldMap_Ptr));
+		    if(nd_status != NDS_OK)
+		    {
+				IMRD_LM_LOG_ERROR_2( "%s : ND_Value_Alloc  -- FieldMap failed (%d) !", sFunctionName, nd_status);
+				status = IMRS_KO;
+		    }
+		    else
+		    {
+				/* Ajout du Field */
+				myFieldMap_Ptr->Id = hFieldMapId;
+				/**** Field InPut  ****/
+				myField.Id = hFieldInId;
+				nd_status = ND_Index_Node_Find(&node_ptr, myMsgMap_Ptr->Msg_Input_Ptr->Field_Struct_Ptr,
+							       IMRD_SDMD_FIELD_IDX_ID,&myField,NULL);
+				if((nd_status != NDS_OK)||(node_ptr == NULL))
+				{
+				    IMRD_LM_LOG_ERROR_1( "Erreur lors de la recherche du In Field <%d> !", hFieldInId);
+				    status = IMRS_KO;
+				}
+				else
+				{
+				    myFieldMap_Ptr->Field_Input_Ptr = node_ptr->Value;
+				}
+				/**** Field OutPut  ****/
+				myField.Id = hFieldOutId;
+				nd_status = ND_Index_Node_Find(&node_ptr, myMsgMap_Ptr->Msg_Output_Ptr->Field_Struct_Ptr,
+							       IMRD_SDMD_FIELD_IDX_ID,&myField,NULL);
+				if((nd_status != NDS_OK)||(node_ptr == NULL))
+				{
+				    IMRD_LM_LOG_ERROR_1( "Erreur lors de la recherche du In Field <%d> !", hFieldOutId);
+				    status = IMRS_KO;
+				}
+				else
+				{
+				    myFieldMap_Ptr->Field_Output_Ptr = node_ptr->Value;
+				}
+		
+				nd_status = ND_DataStruct_Value_Add( myMsgMap_Ptr->FieldMap_Struct_Ptr, (void *)(myFieldMap_Ptr));
+				if(nd_status != NDS_OK)
+				{
+				    IMRD_LM_LOG_ERROR_2( "%s : ND_DataStruct_Value_Add  -- FieldMap failed (%d) !", sFunctionName, nd_status);
+				    status = IMRS_KO;
+				}
+		    }
+		}
+    } while((sqlca.sqlcode == 0)&&(nd_status == NDS_OK)&&(status == IMRS_OK));
+
+	if(status != IMRS_OK)
+	{
+		free(myFieldMap_Ptr);
+	}
+
+    if (sqlca.sqlcode < 0)
+    {
+		IMRD_LM_LOG_ERROR_3( "Erreur %s. Erreur Oracle : %d - %s !", sFunctionName, sqlca.sqlcode, sqlca.sqlerrm.sqlerrmc);
+		status = IMRS_KO;
+    }
+
+    EXEC SQL CLOSE cur_imr_field_map;
+
+    return(status);  
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  SDM_SQL_Dump_MsgMap_Header(FILE *dump_file)
+{
+	fprintf(dump_file, "---------------------------------------------------\n");
+	fprintf(dump_file, "--  Init file of IMR_MSG_MAP & IMR_FIELD_MAP     --\n");
+	fprintf(dump_file, "---------------------------------------------------\n\n");
+	fprintf(dump_file, "INSERT INTO IMR_DATA_VERSION(VERS_NAME, VERS_LABEL, VERS_DATE) VALUES('MsgMap', '%s', '%s');\n\n",
+						((IMRT_Data_Version *)(IMRG_SDM_Base.RootMsgMap->User_Ptr))->Label,
+						((IMRT_Data_Version *)(IMRG_SDM_Base.RootMsgMap->User_Ptr))->Date);
+	fprintf(dump_file, "Delete IMR_FIELD_MAP;\n\n");
+	fprintf(dump_file, "Delete IMR_MSG_MAP;\n\n");
+	return( IMRS_OK);
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  SDM_SQL_Dump_MsgMap_Body(FILE *dump_file)
+{
+	IMRT_Status  status;
+	NDT_Status  nd_status;
+
+	if( ( nd_status = ND_DataStruct_Traverse( IMRG_SDM_Base.RootMsgMap, IMRD_SDMD_CMD_API_SQL_DUMP, dump_file)) != NDS_OK)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0( "SQL Dump RootMsgMap failed !");
+	}
+	else
+	{
+		status = IMRS_OK;
+	}
+
+	return(status);
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  SDM_SQL_Dump_MsgMap_Footer(FILE *dump_file)
+{
+	fprintf(dump_file, "\nCommit;\n");
+	return( IMRS_OK);
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  SDM_SQL_Dump_MsgMap(void)
+{
+	IMRT_Status     status;
+	char	    dump_filename[255];
+	FILE	   *dump_file;
+
+	strcpy(dump_filename, "init_imr_msg_map.sql");
+
+	if( ( dump_file = fopen( dump_filename, "w")) == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_1( "Can't open dump file (%s) !", dump_filename);
+	}
+	else
+	{
+		status = SDM_SQL_Dump_MsgMap_Header(dump_file);
+		if(status == IMRS_OK)
+		{
+			status = SDM_SQL_Dump_MsgMap_Body(dump_file);
+			if(status == IMRS_OK)
+			{
+				status = SDM_SQL_Dump_MsgMap_Footer(dump_file);
+			}
+		}
+
+		fclose( dump_file);
+	}
+
+	return(status);
+
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status SDM_SQL_MapInfo_Dump(void)
+{
+	IMRT_Status  status;
+
+	status = SDM_SQL_Dump_MsgMap();
+
+	return(status);
+
+}
+
+
+
+/*----------------------------------------------------------------------------*/
+/*                                                                            */
+/*----------------------------------------------------------------------------*/
diff --git a/src/libstatic_data_mng/src/mapping_info_xml.c b/src/libstatic_data_mng/src/mapping_info_xml.c
new file mode 100644
index 0000000..6cf0258
--- /dev/null
+++ b/src/libstatic_data_mng/src/mapping_info_xml.c
@@ -0,0 +1,547 @@
+/*----------------------------------------------------------------------------*/
+/* File: mapping_info_xml.c   		         		  	      */
+/*----------------------------------------------------------------------------*/
+/*                                                                            */
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#define _LIBSTATIC_DATA_MNG_
+#define _MAPPING_INFO_XML_C_
+
+#include "mapping_info_xml.h" 
+
+
+IMRT_Status SDM_MsgMap_Ctxt_Close(SDMT_MsgMap_Contexte * MsgMap_Ctx_Ptr)
+{
+	NDT_Status   nd_status;
+
+	if(MsgMap_Ctx_Ptr->RootMsgMap != NULL)
+	{
+		if( ( nd_status = ND_DataStruct_Close(MsgMap_Ctx_Ptr->RootMsgMap)) != NDS_OK)
+		{
+		    IMRD_LM_LOG_ERROR_1( "MsgMap Struct close failed: (%d) !", nd_status);
+		}
+	}
+
+    if(MsgMap_Ctx_Ptr->SaxCtxHdl != NULL)
+    {
+    	xmlFreeParserCtxt(MsgMap_Ctx_Ptr->SaxCtxHdl);
+    }
+
+}
+
+
+
+
+
+IMRT_Status SDM_XML_MapInfo_Init(IMRT_Path    Lib_Path)
+{
+    SDMT_MsgMap_Contexte MsgMap_Ctx;
+    IMRT_Status  status;
+    char	     Xml_File_Name[255];
+
+    
+    IMRD_LM_LOG_TRACE_0( IMRD_LOG_LEVEL_VERBOSE_0, "Loading MsgMap...");
+
+    MsgMap_Ctx.flagerror = 0;
+
+    MsgMap_Ctx.CptMsgMap = IMRD_MSGMAP_ID_UNKNOWN;
+    MsgMap_Ctx.CptFieldMap = IMRD_FIELDMAP_ID_UNKNOWN;
+    memset(MsgMap_Ctx.PathArray,0,sizeof(MsgMap_Ctx.PathArray));
+    MsgMap_Ctx.PresentLevelTag = IMRD_SDMD_MIN_LEVEL_TAG;
+
+    memset(Xml_File_Name,0,sizeof(Xml_File_Name));
+    strcpy(Xml_File_Name, Lib_Path);
+    strcat(Xml_File_Name, "/");
+    strcat(Xml_File_Name, SDMD_MSGMAP_FILE);
+
+    status = SDM_XML_Load_MsgMap(Xml_File_Name, &(MsgMap_Ctx));
+
+    if(status != IMRS_OK)
+    {
+	IMRD_LM_LOG_ERROR_0( "Can't load MsgMap !");
+    }
+    else
+    {
+	IMRG_SDM_Base.RootMsgMap = MsgMap_Ctx.RootMsgMap;
+	IMRD_LM_LOG_INFO_1( "MsgMap loaded: (%d)", IMRG_SDM_Base.RootMsgMap->Index_Tab[NDD_INDEX_PRIMARY].Node_Number);
+    }
+    
+    return(status);
+}
+
+
+
+
+
+static IMRT_Status error(SDMT_MsgMap_Contexte *ctx , const char *msg, ...)
+{
+    xmlParserCtxt * SaxCtx;
+  
+    SaxCtx = ctx->SaxCtxHdl;
+  
+    IMRD_LM_LOG_ERROR_1( "CallBack error: <%s> !",msg);
+
+    SaxCtx->sax = &ErrorSAXHandlerStruct;
+    ctx->flagerror = 1;
+    ctx->FataError.errorCode = SDMD_XML_CODE_ERROR_1;
+    strcpy(ctx->FataError.libError,msg) ;
+}
+
+
+
+
+
+IMRT_Status startElementNsMap( SDMT_MsgMap_Contexte * ctx , 
+			const xmlChar *localname,
+			const xmlChar *prefix,
+			const xmlChar *URI,
+			int nb_namespaces,
+			const xmlChar **namespaces,
+			int nb_attributes,
+			int nb_defaulted,
+			const xmlChar **attributes)
+{
+    NDT_Status         nd_status;
+    const char         functionname [] = "startElementNsMap";
+    char               DescErr[IMRD_SDMD_DESCERR_LEN];
+ 
+
+    if(strcmp((const char*)localname,IMRD_SDMD_TAG_FIELDMAP) == 0)
+    {
+	if( ( nd_status = ND_Value_Alloc( ctx->CurrentMsgMap->FieldMap_Struct_Ptr, (void  **)&(ctx->CurrentFieldMap)) != NDS_OK))
+	{
+	    IMRD_LM_LOG_ERROR_1( "ND_Value_Alloc() failed (%d) !", nd_status);
+
+	    snprintf(DescErr,sizeof(DescErr),SDMD_XML_LIB_ERROR_3,IMRD_SDMD_TAG_FIELDMAP);
+	    SDM_RaiseError(ctx->SaxCtxHdl,&(ctx->FataError),&(ctx->flagerror), functionname , DescErr, SDMD_XML_CODE_ERROR_3 );
+	}
+	else
+	{
+	    ctx->PresentLevelTag = ctx->PresentLevelTag + 1;
+	    strcpy(ctx->PathArray[ctx->PresentLevelTag], (char*)localname);
+	}
+    }
+    else if(strcmp((const char*)localname, IMRD_SDMD_TAG_MSGMAP) == 0)
+    {
+	if( ( nd_status = ND_Value_Alloc( ctx->RootMsgMap, (void  **)&(ctx->CurrentMsgMap)) != NDS_OK))
+	{
+	    IMRD_LM_LOG_ERROR_1( "ND_Value_Alloc() failed (%d) !", nd_status);
+	    
+	    snprintf(DescErr,sizeof(DescErr),SDMD_XML_LIB_ERROR_3,IMRD_SDMD_TAG_MSGMAP);
+	    SDM_RaiseError(ctx->SaxCtxHdl,&(ctx->FataError),&(ctx->flagerror), functionname , DescErr, SDMD_XML_CODE_ERROR_3 );
+	}
+	else
+	{
+	    ctx->PresentLevelTag = ctx->PresentLevelTag + 1;
+	    strcpy(ctx->PathArray[ctx->PresentLevelTag], (char*)localname);
+	}
+    }
+    else if(strcmp((const char*)localname, IMRD_SDMD_TAG_FIELDMAPSTRUCT) == 0)
+    {
+	ctx->PresentLevelTag = ctx->PresentLevelTag + 1;
+	strcpy(ctx->PathArray[ctx->PresentLevelTag], (char*)localname);
+    }
+
+}
+
+
+
+
+
+IMRT_Status endElementNsMap( SDMT_MsgMap_Contexte * ctx, 
+		      const xmlChar *localname,
+		      const xmlChar *prefix,
+		      const xmlChar *URI)
+{
+    IMRT_Status   status_tmp;
+    NDT_Node *    node_ptr;
+    NDT_Status    nd_status;
+    IMRT_Msg      message;
+    IMRT_Field    field;
+    const char    functionname [] = "endElementNsMap";
+    char          DescErr[IMRD_SDMD_DESCERR_LEN];
+
+
+    if (strcmp((const char *)localname, IMRD_SDMD_TAG_NAME) == 0)
+    {
+	strcpy(ctx->CurrentMsgMap->Name, ctx->value);
+    }
+    else if (strcmp((const char*)localname,IMRD_SDMD_TAG_INPUTMSG) == 0)
+    {
+	strcpy(message.Name,ctx->value);
+	if(((nd_status = ND_Index_Node_Find( &node_ptr, IMRG_SDM_Base.RootMsg, IMRD_SDMD_MSG_IDX_NAME, &message, NULL)) != NDS_OK)||
+	   (node_ptr == NULL))
+	{
+	    IMRD_LM_LOG_ERROR_1( "IN Msg lookup failed: [%s] !", ctx->value);
+
+	    snprintf(DescErr,sizeof(DescErr), SDMD_XML_LIB_ERROR_4,IMRD_SDMD_TAG_INPUTMSG,message.Name);
+	    SDM_RaiseError(ctx->SaxCtxHdl,&(ctx->FataError),&(ctx->flagerror),functionname,DescErr,SDMD_XML_CODE_ERROR_4);
+	}
+	else
+	{
+	    ctx->CurrentMsgMap->Msg_Input_Ptr = node_ptr->Value;
+	}
+    }
+    else if (strcmp((const char*)localname,IMRD_SDMD_TAG_OUTPUTMSG) == 0)
+    {
+	strcpy(message.Name,ctx->value);
+	if( ( ( nd_status = ND_Index_Node_Find( &node_ptr, IMRG_SDM_Base.RootMsg, IMRD_SDMD_MSG_IDX_NAME,&message,NULL)) != NDS_OK)||
+	    ( node_ptr == NULL))
+	{
+	    IMRD_LM_LOG_ERROR_1( "OUT Msg lookup failed: [%s] !", ctx->value);
+
+	    snprintf(DescErr,sizeof(DescErr),SDMD_XML_LIB_ERROR_4,IMRD_SDMD_TAG_OUTPUTMSG,message.Name);
+	    SDM_RaiseError(ctx->SaxCtxHdl,&(ctx->FataError),&(ctx->flagerror),functionname,DescErr,SDMD_XML_CODE_ERROR_4);
+	}
+	else
+	{
+	    ctx->CurrentMsgMap->Msg_Output_Ptr = node_ptr->Value;
+	}
+    }
+    else if (strcmp((const char*)localname,IMRD_SDMD_TAG_INPUTFIELD) == 0)
+    {
+	strcpy(field.Name, ctx->value);
+	if( ( ( nd_status = ND_Index_Node_Find(&node_ptr, ctx->CurrentMsgMap->Msg_Input_Ptr->Field_Struct_Ptr, IMRD_SDMD_FIELD_IDX_NAME,&field,NULL)) != NDS_OK)||
+	    ( node_ptr == NULL))
+	{
+	    printf("\nErreur lors de la recherche du In Field <%s> %s\n",ctx->value, ctx->CurrentMsgMap->Msg_Input_Ptr->Name);
+	    snprintf(DescErr,sizeof(DescErr),SDMD_XML_LIB_ERROR_4,IMRD_SDMD_TAG_INPUTFIELD,field.Name);
+	    SDM_RaiseError(ctx->SaxCtxHdl,&(ctx->FataError),&(ctx->flagerror),functionname,DescErr,SDMD_XML_CODE_ERROR_4);
+	}
+	else
+	{
+	    ctx->CurrentFieldMap->Field_Input_Ptr = node_ptr->Value;
+	}
+    }
+    else if (strcmp((const char*)localname,IMRD_SDMD_TAG_OUTPUTFIELD) == 0)
+    {
+	strcpy(field.Name, ctx->value);
+	if(((nd_status = ND_Index_Node_Find(&node_ptr, ctx->CurrentMsgMap->Msg_Output_Ptr->Field_Struct_Ptr,
+					    IMRD_SDMD_FIELD_IDX_NAME,&field,NULL)) != NDS_OK)||
+	   (node_ptr == NULL))
+	{
+	    snprintf(DescErr,sizeof(DescErr),SDMD_XML_LIB_ERROR_4,IMRD_SDMD_TAG_OUTPUTFIELD, field.Name);
+	    SDM_RaiseError(ctx->SaxCtxHdl,&(ctx->FataError),&(ctx->flagerror),functionname,DescErr,SDMD_XML_CODE_ERROR_4);
+	}
+	else
+	{
+	    ctx->CurrentFieldMap->Field_Output_Ptr = node_ptr->Value;
+	}
+    }
+    else if (strcmp((const char*)localname,IMRD_SDMD_TAG_FIELDMAP) == 0)
+    {
+	ctx->CurrentFieldMap->Id = ctx->CptFieldMap;
+	
+	/*Creation de l'identifiant name de l'objet FieldMap*/
+	if( ( nd_status = ND_DataStruct_Value_Add( ctx->CurrentMsgMap->FieldMap_Struct_Ptr, (void *)(ctx->CurrentFieldMap))) != NDS_OK)
+	{
+	    IMRD_LM_LOG_ERROR_1( "FieldMap add failed: (%d) !", nd_status);
+
+	    snprintf(DescErr,sizeof(DescErr),SDMD_XML_LIB_ERROR_2,IMRD_SDMD_TAG_FIELDMAP );
+	    SDM_RaiseError(ctx->SaxCtxHdl,&(ctx->FataError),&(ctx->flagerror), functionname , DescErr, SDMD_XML_CODE_ERROR_2 );
+	}
+	else
+	{
+	    ctx->CptFieldMap ++;
+	    memset(ctx->PathArray[ctx->PresentLevelTag],0,sizeof(IMRD_SDMD_SIZE_TAG_SIZE));
+	    ctx->PresentLevelTag = ctx->PresentLevelTag - 1;
+	}
+    }
+    else if (strcmp((const char*)localname, IMRD_SDMD_TAG_MSGMAP) == 0)
+    {
+	ctx->CptMsgMap ++;
+	ctx->CurrentMsgMap->Id = ctx->CptMsgMap;
+
+	/*Creation de l'identifiant name de l'objet MsgMap*/
+	if( ( nd_status = ND_DataStruct_Value_Add( ctx->RootMsgMap, (void  *)(ctx->CurrentMsgMap))) != NDS_OK)
+	{
+	    IMRD_LM_LOG_ERROR_1( "MsgMap add failed: (%d) !", nd_status);
+	    
+	    snprintf(DescErr,sizeof(DescErr),SDMD_XML_LIB_ERROR_2,IMRD_SDMD_TAG_MSGMAP );
+	    SDM_RaiseError(ctx->SaxCtxHdl,&(ctx->FataError),&(ctx->flagerror), functionname , DescErr, SDMD_XML_CODE_ERROR_2 );
+	}
+	else
+	{
+	    memset(ctx->PathArray[ctx->PresentLevelTag],0,sizeof(IMRD_SDMD_SIZE_TAG_SIZE));
+	    ctx->PresentLevelTag = ctx->PresentLevelTag - 1;
+	}
+    }
+    else if (strcmp((const char*)localname, IMRD_SDMD_TAG_FIELDMAPSTRUCT) == 0)
+    {
+	memset(ctx->PathArray[ctx->PresentLevelTag],0,sizeof(IMRD_SDMD_SIZE_TAG_SIZE));
+	ctx->PresentLevelTag = ctx->PresentLevelTag - 1;
+    }
+    else if (strcmp((const char *)localname, IMRD_SDMD_TAG_VERSION) == 0)
+    {
+		IMRD_LM_LOG_INFO_1( "[MsgMap]: [%s]", ctx->value);
+		status_tmp = SDM_Set_Struct_Version((IMRT_Data_Version *)ctx->RootMsgMap->User_Ptr, (char *)ctx->value);
+    }
+
+}
+
+
+
+
+
+IMRT_Status Map_Info_characters(SDMT_MsgMap_Contexte * ctx , const xmlChar *ch, int len)
+{
+    char output[40];
+    int i;
+    
+    memset(ctx->value,0, sizeof(ctx->value));
+    
+    for (i = 0;(i<len) && (i < IMRD_SDMD_VALUE_LEN);i++)
+	ctx->value[i] = ch[i];
+    ctx->value[i] = 0;
+
+}
+
+IMRT_Status SDM_XML_Load_MsgMap( char *demo_file, SDMT_MsgMap_Contexte *mycontexte)
+{
+    IMRT_Status     status;
+    NDT_Status      nd_status;
+    char * docname = NULL;
+    NDT_Index_Type  *index_type_ptr;
+    xmlDocPtr doc = NULL;
+    xmlDtdPtr dtd;
+    xmlParserCtxtPtr ctxt =NULL;
+    xmlSAXHandlerPtr SAXHandler;
+    xmlSAXHandlerPtr SAXHandler_sav;
+    const char functionname[] ="SDM_XML_Load_MsgMap";
+    char DescErr[IMRD_SDMD_DESCERR_LEN];
+	IMRT_Data_Version   *Data_Version_Ptr;
+
+    LIBXML_TEST_VERSION
+	xmlKeepBlanksDefault(0);	
+    xmlSAXDefaultVersion(2);
+    xmlLineNumbersDefault(1);
+	
+    status = IMRS_OK;
+    docname = demo_file;
+    ctxt = xmlNewParserCtxt();
+
+    /*initialisation des indexes*/
+    index_type_ptr =  MsgMap_Struct_initial_idx_tab;
+
+    if(ctxt != NULL)
+    {
+	mycontexte->flagerror  = IMRS_OK;
+	SAXHandler       = &SaxMapHandlerStruct;
+	mycontexte->SaxCtxHdl  = ctxt;
+	ctxt->userData        = mycontexte;
+	SAXHandler_sav        = ctxt->sax;
+	ctxt->sax             = SAXHandler;
+	ctxt->sax2            = 1 ;
+	    
+	Data_Version_Ptr = (IMRT_Data_Version *) malloc(sizeof(IMRT_Data_Version));
+	Data_Version_Ptr->Label[0] = '\0';
+	Data_Version_Ptr->Date[0] = '\0';
+	if( ( nd_status = ND_DataStruct_Open(&(mycontexte->RootMsgMap), IMRD_SDMD_MSGMAP_STRUCT_IDX_NB, index_type_ptr, "SDM_MsgMap_Manager",SDM_MsgMap_Manager, NULL, NULL, NULL, NULL,0, Data_Version_Ptr)) != NDS_OK)
+	{
+	    status = IMRS_KO;
+
+	    IMRD_LM_LOG_ERROR_1( "Can't open RootMsgMap: (%d) !", nd_status);
+
+	    snprintf(DescErr,sizeof(DescErr),SDMD_XML_LIB_ERROR_5,IMRD_SDMD_TAG_MSGMAP);
+	    SDM_RaiseError(mycontexte->SaxCtxHdl,&(mycontexte->FataError),&(mycontexte->flagerror), functionname, DescErr, SDMD_XML_CODE_ERROR_5 );
+	}
+	else
+	{
+	    doc = xmlCtxtReadFile(ctxt,docname,NULL,XML_PARSE_DTDATTR+XML_PARSE_DTDVALID);
+	    if (ctxt->lastError.code != XML_ERR_OK)
+	    {
+		status = IMRS_KO;
+		printf("Erreur de parsing du fichier %s.\n%s\n", docname, ctxt->lastError.message);
+	    }
+	    else if(mycontexte->flagerror != IMRS_OK)
+	    {
+		status = IMRS_KO;
+		printf("%s\n", mycontexte->FataError.libError);
+	    }
+	    else
+	    {
+		index_type_ptr = MsgMap_Struct_final_idx_tab;
+		status = SDM_DataStruct_Finalize(mycontexte->RootMsgMap,index_type_ptr, IMRD_SDMD_MSGMAP_STRUCT_IDX_NB);
+		/*SDM_DataStruct_Dump( mycontexte->RootMsgMap);*/
+	    }
+	}
+	
+	if((status != IMRS_OK)&&(mycontexte->RootMsgMap != NULL))
+	{
+	    if(mycontexte->CurrentMsgMap != NULL)
+	    {
+		if(mycontexte->CurrentMsgMap->FieldMap_Struct_Ptr != NULL)
+		{
+		    nd_status = ND_DataStruct_Close(mycontexte->CurrentMsgMap->FieldMap_Struct_Ptr);
+		}
+		if(nd_status = NDS_OK)
+		{
+		    free(mycontexte->CurrentMsgMap);
+		}    
+	    }
+            
+	    if(mycontexte->CurrentFieldMap != NULL)
+	    {
+		free(mycontexte->CurrentFieldMap);
+	    }
+	    if(mycontexte->RootMsgMap != NULL)
+	    {
+		nd_status = ND_DataStruct_Close(mycontexte->RootMsgMap);
+	    }
+	}
+	
+		  
+	ctxt->sax = SAXHandler_sav;
+	xmlFreeParserCtxt(ctxt);
+    }
+    else
+    {
+	status = IMRS_KO;
+    }
+    
+    return(status);
+}
+
+
+
+
+
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  SDM_XML_Dump_MsgMap_Header(FILE *dump_file)
+{
+	fprintf(dump_file, "<?xml version=\"1.0\" ?>\n");
+	fprintf(dump_file, "<!-- MsgMap Struct definitions -->\n");
+	fprintf(dump_file, "<%s>\n", IMRD_SDMD_TAG_MSGMAP_STRUCT);
+	fprintf(dump_file, "<version>@(#) VERSIONIMR: $Label:  $   $Date: 2008/11/12 02:25:23 $   $Workfile:   mapping_info_xml.c  $</version>\n", 
+				((IMRT_Data_Version *)IMRG_SDM_Base.RootMsgMap->User_Ptr)->Label,
+				((IMRT_Data_Version *)IMRG_SDM_Base.RootMsgMap->User_Ptr)->Date);
+	return( IMRS_OK);
+
+}
+
+
+
+
+
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  SDM_XML_Dump_MsgMap_Body(FILE *dump_file)
+{
+    IMRT_Status  status;
+    NDT_Status   nd_status;
+    
+    if( ( nd_status = ND_DataStruct_Traverse( IMRG_SDM_Base.RootMsgMap, IMRD_SDMD_CMD_API_XML_DUMP, dump_file)) != NDS_OK)
+    {
+	status = IMRS_KO;
+	printf( "XML Dump RootMsgMap failed (%d)...\n");
+    }
+    else
+    {
+	status = IMRS_OK;		
+    }
+    
+    return(status);
+}
+
+
+
+
+
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  SDM_XML_Dump_MsgMap_Footer(FILE *dump_file)
+{
+    fprintf(dump_file, "<!-- MsgMap Struct definitions footer -->\n");
+    fprintf(dump_file, "</%s>\n", IMRD_SDMD_TAG_MSGMAP_STRUCT);
+
+    return( IMRS_OK);
+}
+
+
+
+
+
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  SDM_XML_Dump_MsgMap(void)
+{
+    IMRT_Status     status;
+    char	    dump_filename[255];
+    FILE	   *dump_file;
+    
+    strcpy(dump_filename, SDMD_MSGMAP_FILE);
+	
+    if( ( dump_file = fopen( dump_filename, "w")) == NULL)
+    {
+	status = IMRS_KO;
+	printf( "Can't open dump file (%s) !\n", dump_filename);
+    }
+    else
+    {
+	status = SDM_XML_Dump_MsgMap_Header(dump_file);
+	if(status == IMRS_OK)
+	{
+	    status = SDM_XML_Dump_MsgMap_Body(dump_file);
+	    if(status == IMRS_OK)
+	    {
+		status = SDM_XML_Dump_MsgMap_Footer(dump_file);
+	    }
+	}
+	
+	fclose( dump_file);
+    }
+    
+    return(status);
+}
+
+
+
+
+
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status SDM_XML_MapInfo_Dump(void)
+{
+	IMRT_Status     status;
+
+	status = SDM_XML_Dump_MsgMap();
+
+	return(status);
+}
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/*                                                                            */
+/*----------------------------------------------------------------------------*/
diff --git a/src/libstatic_data_mng/src/mapping_info_xml.h b/src/libstatic_data_mng/src/mapping_info_xml.h
new file mode 100644
index 0000000..6d3ffb3
--- /dev/null
+++ b/src/libstatic_data_mng/src/mapping_info_xml.h
@@ -0,0 +1,202 @@
+/*----------------------------------------------------------------------------*/
+/* File: mapping_info_xml.h 				         	      */
+/*----------------------------------------------------------------------------*/
+/*                                                                            */
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#ifndef _MAPPING_INFO_XML_H_
+#   define _MAPPING_INFO_XML_H_
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Global Include                                                             */
+/*----------------------------------------------------------------------------*/
+
+#   include <libstatic_data_mng.h>
+
+/*----------------------------------------------------------------------------*/
+/* Local constantes                                                           */
+/*----------------------------------------------------------------------------*/
+
+/*definition des tags xml pour le chargement des structure MsgMap et FieldMap*/
+
+#define IMRD_SDMD_TAG_NAME              "name"
+#define IMRD_SDMD_TAG_INPUTMSG          "inputmessage"
+#define IMRD_SDMD_TAG_OUTPUTMSG         "outputmessage"
+#define IMRD_SDMD_TAG_FIELDMAP          "fieldmap"
+#define IMRD_SDMD_TAG_FIELDMAPSTRUCT    "fieldmapstruct"
+#define IMRD_SDMD_TAG_INPUTFIELD        "inputfield"
+#define IMRD_SDMD_TAG_OUTPUTFIELD       "outputfield"
+#define IMRD_SDMD_TAG_MSGFIELDMAPSTRUCT "msgfieldmapstruct"
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Local Definition                                                           */
+/*----------------------------------------------------------------------------*/
+
+
+typedef struct SDMT_MsgMap_Contexte
+{
+  char value[IMRD_SDMD_VALUE_LEN];
+  IMRT_Array_Xml_Path PathArray;
+  IMRT_Level_Tag PresentLevelTag;
+  IMRT_MsgMap_Id    CptMsgMap;
+  IMRT_FieldMap_Id  CptFieldMap;
+  IMRT_FieldMap  * CurrentFieldMap;
+  IMRT_MsgMap    * CurrentMsgMap;
+  NDT_Root       * RootMsgMap;
+  xmlParserCtxt  * SaxCtxHdl; 
+  IMRT_Error     FataError;
+  IMRT_Status    flagerror;
+}SDMT_MsgMap_Contexte;
+
+/*----------------------------------------------------------------------------*/
+/* Prototypes                                                                 */
+/*----------------------------------------------------------------------------*/
+
+#   ifdef _MAPPING_INFO_XML_C_
+
+static IMRT_Status error(SDMT_MsgMap_Contexte *ctx , const char *msg, ...);
+IMRT_Status Map_Info_characters(SDMT_MsgMap_Contexte * ctx , const xmlChar *ch, int len);
+IMRT_Status endElementNsMap( SDMT_MsgMap_Contexte * ctx, 
+							        const xmlChar *localname,
+							        const xmlChar *prefix,
+							        const xmlChar *URI);
+IMRT_Status startElementNsMap( SDMT_MsgMap_Contexte * ctx , 
+							          const xmlChar *localname,
+							          const xmlChar *prefix,
+							          const xmlChar *URI,
+							          int nb_namespaces,
+							          const xmlChar **namespaces,
+							          int nb_attributes,
+							          int nb_defaulted,
+							          const xmlChar **attributes);
+IMRT_Status SDM_XML_Load_MsgMap( char *demo_file, SDMT_MsgMap_Contexte *mycontexte);
+IMRT_Status SDM_MsgMap_Ctxt_Close(SDMT_MsgMap_Contexte * MsgMap_Ctx_Ptr);
+IMRT_Status SDM_XML_MapInfo_Init(IMRT_Path    Lib_Path);
+IMRT_Status  SDM_XML_Dump_MsgMap_Header(FILE *dump_file);
+IMRT_Status  SDM_XML_Dump_MsgMap_Body(FILE *dump_file);
+IMRT_Status  SDM_XML_Dump_MsgMap_Footer(FILE *dump_file);
+IMRT_Status  SDM_XML_Dump_MsgMap(void);
+IMRT_Status  SDM_XML_MapInfo_Dump(void);
+
+#   else
+
+extern IMRT_Status SDM_XML_Load_MsgMap( char *demo_file, SDMT_MsgMap_Contexte *mycontexte);
+extern IMRT_Status SDM_XML_MapInfo_Init(IMRT_Path    Lib_Path);
+extern IMRT_Status  SDM_XML_Dump_MsgMap_Header(FILE *dump_file);
+extern IMRT_Status  SDM_XML_Dump_MsgMap_Body(FILE *dump_file);
+extern IMRT_Status  SDM_XML_Dump_MsgMap_Footer(FILE *dump_file);
+extern IMRT_Status  SDM_XML_Dump_MsgMap(void);
+extern IMRT_Status  SDM_XML_MapInfo_Dump(void);
+
+#   endif
+
+
+#   ifdef _MAPPING_INFO_XML_C_
+
+
+/*xmlSAXHandler Map_Info_Error_SAX_Hdl_Struct = {
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    1,
+    NULL,
+    NULL,
+    NULL,
+    NULL
+    };*/
+
+xmlSAXHandler SaxMapHandlerStruct = {
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    (charactersSAXFunc)(Map_Info_characters),
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    (errorSAXFunc)(error),
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    1,
+    NULL,
+    (startElementNsSAX2Func)(startElementNsMap),
+    (endElementNsSAX2Func)(endElementNsMap),
+    NULL
+};
+
+
+#   endif
+
+
+
+
+/*----------------------------------------------------------------------------*/
+
+#endif
diff --git a/src/libstatic_data_mng/src/struct_info_mng.c b/src/libstatic_data_mng/src/struct_info_mng.c
new file mode 100644
index 0000000..0ee2312
--- /dev/null
+++ b/src/libstatic_data_mng/src/struct_info_mng.c
@@ -0,0 +1,1684 @@
+/*----------------------------------------------------------------------------*/
+/* File: struct_info_mng.c   		         		  	      */
+/*----------------------------------------------------------------------------*/
+/*                                                                            */
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#define _LIBSTATIC_DATA_MNG_
+#define _STRUCT_INFO_MNG_C_
+
+#include "struct_info_mng.h" 
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Cnv Manager                                                               */
+/*----------------------------------------------------------------------------*/
+
+NDT_Status  SDM_Cnv_Manager( NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id, NDT_Node  *Node_Ptr, NDT_Command  Command, va_list  Args)
+{
+    NDT_Command_Name  Command_Name;
+
+
+    switch( Command)
+    {
+	case NDD_CMD_MANAGER_VERSION:
+        {
+            NDT_Version_Name  *Version_Name_Ptr = (NDT_Version_Name  *)va_arg( Args, NDT_Version_Name  *);
+
+
+            Command_Name = "NDD_CMD_MANAGER_VERSION";
+            *Version_Name_Ptr = "Revision: 2.1    Name: libnode-2_0_4-1    Date: 2002/02/28 22:00:35    Author: agibert ";
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_INDEX_GET:
+        {
+            /*
+	      NDT_Index_Id  *Reply_Index_Id_Ptr = (NDT_Index_Id  *)va_arg( Args, NDT_Index_Id  *);
+	      NDT_Command   *Reply_Command_Ptr  = (NDT_Command  *)va_arg( Args, NDT_Command  *);
+	      NDT_Command    Cmd                = (NDT_Command)va_arg( Args, NDT_Command);
+	      void          *Cnv_ptr            = (void  *)va_arg( Args, void  *);
+            */
+            NDT_Index_Id  *Reply_Index_Id_Ptr = (NDT_Index_Id  *)va_arg( Args, NDT_Index_Id  *);
+            NDT_Command   *Reply_Command_Ptr  = (NDT_Command  *)va_arg( Args, NDT_Command  *);
+            NDT_Command    Cmd                = (NDT_Command)va_arg( Args, NDT_Command);
+            IMRT_Cnv      *Cnv_ptr            = (IMRT_Cnv  *)va_arg( Args, IMRT_Cnv  *);
+
+
+            Command_Name = "NDD_CMD_INDEX_GET";
+
+            switch(Cmd)
+            {
+                case IMRD_SDMD_CMD_INDEX0_PRINT:
+                {
+                    *Reply_Index_Id_Ptr = 0;
+                    *Reply_Command_Ptr = NDD_CMD_VALUE_PRINT;
+
+                    break;
+                }
+
+				case IMRD_SDMD_CMD_API_SQL_DUMP:
+				{
+                    *Reply_Index_Id_Ptr = IMRD_SDMD_CNV_IDX_ID;
+                    *Reply_Command_Ptr = IMRD_SDMD_CMD_API_SQL_DUMP;
+                    break;
+				}
+
+				case IMRD_SDMD_CMD_API_XML_DUMP:
+				{
+                    *Reply_Index_Id_Ptr = IMRD_SDMD_CNV_IDX_ID;
+                    *Reply_Command_Ptr = IMRD_SDMD_CMD_API_XML_DUMP;
+                    break;
+				}
+
+                default:
+                {
+                    *Reply_Index_Id_Ptr = Index_Id;
+                    *Reply_Command_Ptr = Cmd;
+
+                    break;
+                }
+            }
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_ALLOC:
+        {
+            /*
+	      void       **Cnv_ptr_Ptr   = (void **)va_arg( Args, void  **);
+	      va_list      user_args     = (va_list)va_arg( Args, va_list);
+	      user_type    user_data     = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+            */
+            IMRT_Cnv  **Cnv_ptr_Ptr  = va_arg( Args, IMRT_Cnv  **);
+
+
+            Command_Name = "NDD_CMD_VALUE_ALLOC";
+
+            if( ( *Cnv_ptr_Ptr = (IMRT_Cnv  *)malloc( sizeof(IMRT_Cnv))) == NULL)
+            {
+                return( NDS_ERRMEM);
+            }
+            else
+            {
+                SDM_InitCnv(*Cnv_ptr_Ptr);
+                return( NDS_OK);
+            }
+        }
+
+        case NDD_CMD_VALUE_FREE:
+        {
+            /*
+	      void       *Cnv_ptr   = (void *)va_arg( Args, void  *);
+	      va_list     user_args = (va_list)va_arg( Args, va_list);
+	      user_type   user_data = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+            */
+            IMRT_Cnv  *Cnv_ptr = (IMRT_Cnv  *)va_arg( Args, IMRT_Cnv  *);
+            Command_Name = "NDD_CMD_VALUE_FREE";
+
+            free( Cnv_ptr);
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_COMP:
+        {
+            /*
+	      void       *Value1_Ptr = (void *)va_arg( Args, void  *);
+	      void       *Value2_Ptr = (void *)va_arg( Args, void  *);
+	      va_list     user_args  = (va_list)va_arg( Args, va_list);
+	      user_type   user_data  = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+            */
+            IMRT_Cnv    *Value1_Ptr = va_arg( Args, IMRT_Cnv  *);
+            IMRT_Cnv    *Value2_Ptr = va_arg( Args, IMRT_Cnv  *);
+
+
+            Command_Name = "NDD_CMD_VALUE_COMP";
+
+            switch( Index_Id)
+            {
+                case IMRD_SDMD_CNV_IDX_ID:
+                {
+                    if( Value1_Ptr->Id < Value2_Ptr->Id)
+                    {
+                        return( NDS_LOWER);
+                    }
+                    else
+                    {
+                        if( Value1_Ptr->Id > Value2_Ptr->Id)
+                        {
+                            return( NDS_GREATER);
+                        }
+                        else
+                        {
+                            return( NDS_EQUAL);
+                        }
+                    }
+                }
+
+                case IMRD_SDMD_CNV_IDX_NAME:
+                {
+                    int     rc;
+
+
+                    rc=strcmp( Value1_Ptr->Name, Value2_Ptr->Name);
+
+                    if( rc <0)
+                    {
+                        return( NDS_LOWER);
+                    }
+                    else
+                    {
+                        if( rc > 0)
+                        {
+                            return( NDS_GREATER);
+                        }
+                        else
+                        {
+                            return( NDS_EQUAL);
+                        }
+                    }
+                }
+
+                default:
+                {
+                    printf( "Unknown COMP idx (%d) !\n", Index_Id);
+
+                    return( NDS_KO);
+                }
+            }
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_ADD:
+        {
+            /*
+	      void       *Cnv_ptr   = (void *)va_arg( Args, void  *);
+	      va_list     user_args = (va_list)va_arg( Args, va_list);
+	      user_type   user_data = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+            */
+
+            Command_Name = "NDD_CMD_VALUE_ADD";
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_REMOVE:
+        {
+            /*
+	      void       *Cnv_ptr   = (void *)va_arg( Args, void  *);
+	      va_list     user_args = (va_list)va_arg( Args, va_list);
+	      user_type   user_data = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+            */
+
+            Command_Name = "NDD_CMD_VALUE_REMOVE";
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_PRINT:
+        {
+            /*
+	      NDT_Node             *Next_Node_Ptr   = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+	      va_list               lib_args        = (va_list)va_arg( Args, va_list);
+	      FILE                 *Out             = (FILE  *)va_arg( lib_args, FILE  *);
+	      NDT_Recursive_Mode    Recursive_Mode  = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode);
+	      NDT_Recursive_Depth   Recursive_Depth = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth);
+	      va_list               user_args       = (va_list)va_arg( lib_args, va_list);
+	      user_type             user_data       = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+	      void                 *Cnv_ptr         = Node_Ptr->Value;
+            */
+            NDT_Node             *Next_Node_Ptr   = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+            va_list               lib_args        = (va_list)va_arg( Args, va_list);
+            FILE                 *Out             = (FILE  *)va_arg( lib_args, FILE  *);
+            NDT_Recursive_Mode    Recursive_Mode  = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode);
+            NDT_Recursive_Depth   Recursive_Depth = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth);
+
+            IMRT_Cnv             *Cnv_ptr         = Node_Ptr->Value;
+
+
+            Command_Name = "NDD_CMD_VALUE_PRINT";
+
+            fprintf( Out, "Id: (%d)   Name: (%s)\n", Cnv_ptr->Id, Cnv_ptr->Name);
+            return( NDS_OK);
+
+        }
+
+        case NDD_CMD_INFO_PRINT:
+        {
+            /*
+	      NDT_Node             *Next_Node_Ptr   = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+	      va_list               lib_args        = (va_list)va_arg( Args, va_list);
+	      FILE                 *Out             = (FILE  *)va_arg( lib_args, FILE  *);
+	      NDT_Recursive_Mode    Recursive_Mode  = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode);
+	      NDT_Recursive_Depth   Recursive_Depth = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth);
+	      va_list               user_args       = (va_list)va_arg( lib_args, va_list);
+	      user_type             user_data       = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+	      void                 *Cnv_ptr         = Node_Ptr->Value;
+            */
+
+            Command_Name = "NDD_CMD_INFO_PRINT";
+
+            return( NDS_OK);
+        }
+
+        case IMRD_SDMD_CMD_EXECUTE:
+        { /*
+            NDT_Node             *Next_Node_Ptr    = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+            va_list               lib_args         = (va_list)va_arg( Args, va_list);
+            FILE                 *Out              = (FILE  *)va_arg( lib_args, FILE  *);
+            NDT_Recursive_Mode    Recursive_Mode   = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode);
+            NDT_Recursive_Depth   Recursive_Depth  = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth);
+            NDT_Recursive_Offset  Recursive_Offset = (NDT_Recursive_Offset)va_arg( lib_args, NDT_Recursive_Offset);
+            va_list               user_args        = (va_list)va_arg( lib_args, va_list);
+            user_type             user_data        = (user_type)va_arg( user_args, user_type);
+	    ...  = (...)va_arg( user_args, ...);
+            void                 *Cnv_ptr          = Node_Ptr->Value;
+	  */
+            IMRT_Cnv   *  Cnv_ptr                  = (IMRT_Cnv*)Node_Ptr->Value;
+            NDT_Node *Next_Node_Ptr                = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+            va_list lib_args                       = (va_list)va_arg( Args, va_list);
+            FILE *Out                              = (FILE  *)va_arg( lib_args, FILE  *);
+            NDT_Recursive_Mode    Recursive_Mode   = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode);
+            IMRT_SDMCB_Cnv_Add   * CnvProceedFunc  = ( IMRT_SDMCB_Cnv_Add *)va_arg(lib_args, IMRT_SDMCB_Cnv_Add *);
+            
+            CnvProceedFunc(Cnv_ptr->Id, Cnv_ptr->Name, IMRG_SDM_Base.RootCnv->Index_Tab[NDD_INDEX_PRIMARY].Node_Number);
+
+            return( NDS_OK);
+        }
+
+		case IMRD_SDMD_CMD_API_SQL_DUMP:
+		{
+		/*
+			NDT_Node   *Next_Node_Ptr = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+			va_list     user_args     =     (va_list)va_arg( Args, va_list);
+			user_type   user_data     =   (user_type)va_arg( user_args, user_type);
+								  ... =         (...)va_arg( user_args, ...);
+
+  			void       *Cnv_ptr      = Node_Ptr->Value;
+		*/
+			NDT_Node        *Next_Node_Ptr = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+			va_list          user_args     =     (va_list)va_arg( Args, va_list);
+			FILE            *Out           =     (FILE  *)va_arg( user_args, FILE  *);
+
+			IMRT_Cnv        *Cnv_Ptr       = Node_Ptr->Value;
+
+
+			Command_Name = "IMRD_SDMD_CMD_API_SQL_DUMP";
+
+			fprintf( Out, "INSERT INTO IMR_CNV(CNV_ID, CNV_NAME) VALUES(%d, '%s');\n",
+					Cnv_Ptr->Id, Cnv_Ptr->Name);
+
+			return( NDS_OK);
+		}
+
+		case IMRD_SDMD_CMD_API_XML_DUMP:
+		{
+		/*
+			NDT_Node   *Next_Node_Ptr = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+			va_list     user_args     =     (va_list)va_arg( Args, va_list);
+			user_type   user_data     =   (user_type)va_arg( user_args, user_type);
+								  ... =         (...)va_arg( user_args, ...);
+
+  			void       *Cnv_ptr       = Node_Ptr->Value;
+		*/
+			NDT_Node        *Next_Node_Ptr = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+			va_list          user_args     =     (va_list)va_arg( Args, va_list);
+            FILE            *Out           =     (FILE  *)va_arg( user_args, FILE  *);
+
+			IMRT_Cnv        *Cnv_Ptr       = Node_Ptr->Value;
+
+
+			Command_Name = "IMRD_SDMD_CMD_API_XML_DUMP";
+
+			fprintf( Out, "\t<%s>\n", IMRD_SDMD_TAG_CNV);
+
+			fprintf( Out, "\t\t<%s>%s</%s>\n", IMRD_SDMD_TAG_NAME, Cnv_Ptr->Name, IMRD_SDMD_TAG_NAME);
+
+			fprintf( Out, "\t</%s>\n", IMRD_SDMD_TAG_CNV);
+
+
+			return( NDS_OK);
+		}
+
+        default:
+        {
+            printf( "SDM_Cnv_Manager() called with an undefined command %d\n", Command);
+            return NDS_ERRAPI;
+        }
+    }
+
+    printf( "SDM_Cnv_Manager() called with command %d (%s)\n", Command, Command_Name);
+    return NDS_OK;
+}
+
+
+/*----------------------------------------------------------------------------*/
+/* Field Manager                                                              */
+/*----------------------------------------------------------------------------*/
+
+NDT_Status SDM_Field_Manager( NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id, NDT_Node  *Node_Ptr, NDT_Command  Command, va_list  Args)
+{
+    NDT_Command_Name  Command_Name;
+    NDT_Status         status;
+
+
+    switch( Command)
+    {
+        case NDD_CMD_MANAGER_VERSION:
+        {
+            NDT_Version_Name  *Version_Name_Ptr = (NDT_Version_Name  *)va_arg( Args, NDT_Version_Name  *);
+
+
+            Command_Name = "NDD_CMD_MANAGER_VERSION";
+
+            *Version_Name_Ptr = "Revision: 2.1    Name: libnode-2_0_4-1    Date: 2002/02/28 22:00:35    Author: agibert ";
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_INDEX_GET:
+        {
+            /*
+	      NDT_Index_Id  *Reply_Index_Id_Ptr = (NDT_Index_Id  *)va_arg( Args, NDT_Index_Id  *);
+	      NDT_Command   *Reply_Command_Ptr  = (NDT_Command  *)va_arg( Args, NDT_Command  *);
+	      NDT_Command    Cmd                = (NDT_Command)va_arg( Args, NDT_Command);
+	      void          *Value_ptr          = (void  *)va_arg( Args, void  *);
+            */
+            NDT_Index_Id  *Reply_Index_Id_Ptr = (NDT_Index_Id  *)va_arg( Args, NDT_Index_Id  *);
+            NDT_Command   *Reply_Command_Ptr  = (NDT_Command  *)va_arg( Args, NDT_Command  *);
+            NDT_Command    Cmd                = (NDT_Command)va_arg( Args, NDT_Command);
+            IMRT_Field    * Field_ptr         = (IMRT_Field  *)va_arg( Args, IMRT_Field  *);
+
+
+            Command_Name = "NDD_CMD_INDEX_GET";
+
+            switch(Cmd)
+            {
+                case IMRD_SDMD_CMD_INDEX0_PRINT:
+                {
+                    *Reply_Index_Id_Ptr = 0;
+                    *Reply_Command_Ptr = NDD_CMD_VALUE_PRINT;
+
+                    break;
+                }
+
+                case IMRD_SDMD_CMD_EXECUTE:
+                {
+                    *Reply_Index_Id_Ptr = 0;
+                    *Reply_Command_Ptr = NDD_CMD_EXECUTE;
+ 				    break;
+                }
+
+				case IMRD_SDMD_CMD_API_SQL_DUMP:
+				{
+                    *Reply_Index_Id_Ptr = IMRD_SDMD_FIELD_IDX_ID;
+                    *Reply_Command_Ptr = IMRD_SDMD_CMD_API_SQL_DUMP;
+                    break;
+				}
+
+				case IMRD_SDMD_CMD_API_XML_DUMP:
+				{
+                    *Reply_Index_Id_Ptr = IMRD_SDMD_FIELD_IDX_ID;
+                    *Reply_Command_Ptr = IMRD_SDMD_CMD_API_XML_DUMP;
+                    break;
+				}
+
+                default:
+                {
+                    *Reply_Index_Id_Ptr = Index_Id;
+                    *Reply_Command_Ptr = Cmd;
+
+                    break;
+                }
+            }
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_ALLOC:
+        {
+            /*
+	      void       **Field_ptr_Ptr = (void **)va_arg( Args, void  **);
+	      va_list      user_args     = (va_list)va_arg( Args, va_list);
+	      user_type    user_data     = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+            */
+            IMRT_Field  **Field_ptr_Ptr = va_arg( Args, IMRT_Field  **);
+
+
+            Command_Name = "NDD_CMD_VALUE_ALLOC";
+
+            if( ( *Field_ptr_Ptr = (IMRT_Field  *)malloc( sizeof(IMRT_Field))) == NULL)
+            {
+                return( NDS_ERRMEM);
+            }
+            else
+            {
+                SDM_InitField(*Field_ptr_Ptr);
+                
+                return( NDS_OK);
+            }
+        }
+
+        case NDD_CMD_VALUE_FREE:
+        {
+            /*
+	      void       *Field_ptr = (void *)va_arg( Args, void  *);
+	      va_list     user_args = (va_list)va_arg( Args, va_list);
+	      user_type   user_data = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+            */
+            IMRT_Field  *Field_ptr = (IMRT_Field  *)va_arg( Args, IMRT_Field  *);
+
+
+            Command_Name = "NDD_CMD_VALUE_FREE";
+
+            free( Field_ptr);
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_COMP:
+        {
+            /*
+	      void       *Value1_Ptr = (void *)va_arg( Args, void  *);
+	      void       *Value2_Ptr = (void *)va_arg( Args, void  *);
+	      va_list     user_args  = (va_list)va_arg( Args, va_list);
+	      user_type   user_data  = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+            */
+            IMRT_Field    *Value1_Ptr = va_arg( Args, IMRT_Field  *);
+            IMRT_Field    *Value2_Ptr = va_arg( Args, IMRT_Field  *);
+
+
+            Command_Name = "NDD_CMD_VALUE_COMP";
+
+            switch( Index_Id)
+            {
+                case IMRD_SDMD_FIELD_IDX_ID:
+                {
+                    if( Value1_Ptr->Id < Value2_Ptr->Id)
+                    {
+                        return( NDS_LOWER);
+                    }
+                    else
+                    {
+                        if( Value1_Ptr->Id > Value2_Ptr->Id)
+                        {
+                            return( NDS_GREATER);
+                        }
+                        else
+                        {
+                            return( NDS_EQUAL);
+                        }
+                    }
+                }
+
+                case IMRD_SDMD_FIELD_IDX_NAME:
+                {
+                    int     rc;
+
+
+                    rc=strcmp( Value1_Ptr->Name, Value2_Ptr->Name);
+
+                    if( rc <0)
+                    {
+                        return( NDS_LOWER);
+                    }
+                    else
+                    {
+                        if( rc > 0)
+                        {
+                            return( NDS_GREATER);
+                        }
+                        else
+                        {
+                            return( NDS_EQUAL);
+                        }
+                    }
+                }
+
+                default:
+                {
+                    printf( "Unknown COMP idx (%d) !\n", Index_Id);
+
+                    return( NDS_KO);
+                }
+            }
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_ADD:
+        {
+            /*
+	      void       *Field_ptr = (void *)va_arg( Args, void  *);
+	      va_list     user_args = (va_list)va_arg( Args, va_list);
+	      user_type   user_data = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+            */
+
+            Command_Name = "NDD_CMD_VALUE_ADD";
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_REMOVE:
+        {
+            /*
+	      void       *Field_ptr = (void *)va_arg( Args, void  *);
+	      va_list     user_args = (va_list)va_arg( Args, va_list);
+	      user_type   user_data = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+            */
+
+            Command_Name = "NDD_CMD_VALUE_REMOVE";
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_PRINT:
+        {
+            /*
+	      NDT_Node             *Next_Node_Ptr   = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+	      va_list               lib_args        = (va_list)va_arg( Args, va_list);
+	      FILE                 *Out             = (FILE  *)va_arg( lib_args, FILE  *);
+	      NDT_Recursive_Mode    Recursive_Mode  = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode);
+	      NDT_Recursive_Depth   Recursive_Depth = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth);
+	      va_list               user_args       = (va_list)va_arg( lib_args, va_list);
+	      user_type             user_data       = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+	      void                 *Field_ptr       = Node_Ptr->Value;
+            */
+            NDT_Node             *Next_Node_Ptr   =         (NDT_Node  *)va_arg( Args, NDT_Node  *);
+            va_list               lib_args        =             (va_list)va_arg( Args, va_list);
+            FILE                 *Out             =             (FILE  *)va_arg( lib_args, FILE  *);
+            NDT_Recursive_Mode    Recursive_Mode  =  (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode);
+            NDT_Recursive_Depth   Recursive_Depth = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth);
+
+            IMRT_Field           *Field_ptr       = Node_Ptr->Value;
+			char                 Local_Exist;
+
+            Command_Name = "NDD_CMD_VALUE_PRINT";
+
+			if (Field_ptr->Exist == IMRD_TRUE)
+			{
+				Local_Exist = IMRD_YES;
+			}
+			else
+			{
+				Local_Exist = IMRD_NO;
+			}
+
+            fprintf( Out, "Name: (%s) Valueid: (%s) Exist: (%c)\n\tFixed - offset: (%d) size: (%d) Def_Val: (%s) Cnv_Name: (%s) Cnv_Attr: (%s)\n\tFML - tag: (%s) Def_Val: (%s) Cnv_Name: (%s) Cnv_Attr: (%s)\n\tXML - Tag: (%s) Def_Val: (%s) Cnv_Name: (%s) Cnv_Attr: (%s)\n\tTagged - Tag: (%s) Def_Val: (%s) Cnv_Name: (%s) Cnv_Attr: (%s)\n\tInternal - Tag: (%s) Def_Val: (%s) Cnv_Name: (%s) Cnv_Attr: (%s)\n\tDelimited - Id: (%d) Def_Val: (%s) Cnv_Name: (%s) Cnv_Attr: (%s)\n",
+		     Field_ptr->Name, Field_ptr->Value_Id, Local_Exist,
+		     Field_ptr->Fixed.Offset, Field_ptr->Fixed.Size, Field_ptr->Fixed.Def_Val, Field_ptr->Fixed.Cnv_Ptr->Name, Field_ptr->Fixed.Cnv_Attr,
+		     Field_ptr->FML.Tag,      Field_ptr->FML.Def_Val,       Field_ptr->FML.Cnv_Ptr->Name,       Field_ptr->FML.Cnv_Attr,
+		     Field_ptr->XML.Tag,      Field_ptr->XML.Def_Val,       Field_ptr->XML.Cnv_Ptr->Name,       Field_ptr->XML.Cnv_Attr,
+		     Field_ptr->Tagged.Tag,   Field_ptr->Tagged.Def_Val,    Field_ptr->Tagged.Cnv_Ptr->Name,    Field_ptr->Tagged.Cnv_Attr, 
+		     Field_ptr->Internal.Tag, Field_ptr->Internal.Def_Val,  Field_ptr->Internal.Cnv_Ptr->Name,  Field_ptr->Internal.Cnv_Attr, 
+		     Field_ptr->Delimited.Id, Field_ptr->Delimited.Def_Val, Field_ptr->Delimited.Cnv_Ptr->Name, Field_ptr->Delimited.Cnv_Attr);
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_INFO_PRINT:
+        {
+            /*
+	      NDT_Node             *Next_Node_Ptr   = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+	      va_list               lib_args        = (va_list)va_arg( Args, va_list);
+	      FILE                 *Out             = (FILE  *)va_arg( lib_args, FILE  *);
+	      NDT_Recursive_Mode    Recursive_Mode  = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode);
+	      NDT_Recursive_Depth   Recursive_Depth = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth);
+	      va_list               user_args       = (va_list)va_arg( lib_args, va_list);
+	      user_type             user_data       = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+	      void                 *Field_ptr       = Node_Ptr->Value;
+            */
+
+            Command_Name = "NDD_CMD_INFO_PRINT";
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_EXECUTE:
+        {
+	    /*
+	      NDT_Node             *Next_Node_Ptr   = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+	      va_list               lib_args        = (va_list)va_arg( Args, va_list);
+	      FILE                 *Out             = (FILE  *)va_arg( lib_args, FILE  *);
+	      NDT_Recursive_Mode    Recursive_Mode  = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode);
+	      NDT_Recursive_Depth   Recursive_Depth = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth);
+	      va_list               user_args       = (va_list)va_arg( lib_args, va_list);
+	      user_type             user_data       = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+	      void                 *Field_ptr       = Node_Ptr->Value;
+            */
+            IMRT_Field *  Field_ptr            = (IMRT_Field *)Node_Ptr->Value;
+            NDT_Node *Next_Node_Ptr            = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+            va_list lib_args                   = (va_list)va_arg( Args, va_list);
+            FILE *Out                          = (FILE  *)va_arg( lib_args, FILE  *);
+            NDT_Recursive_Mode Recursive_Mode  = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode);
+            va_list user_args                  = (va_list)va_arg( Args, va_list);
+            IMRT_SDM_IdentMessage * IdentStruct   = (IMRT_SDM_IdentMessage *)va_arg(lib_args,IMRT_SDM_IdentMessage *);
+            
+            if(Field_ptr->Exist == IMRD_TRUE)
+            {
+		status = IdentStruct-> Ident_Field_ExistFunc_Ptr(Field_ptr);
+		
+		
+		/*if( ((Next_Node_Ptr == NULL) && (status == (NDT_Status)IMRS_NO_IDENT)) || (status == (NDT_Status)IMRS_KO))
+		{
+		    return( NDS_KO);
+		}
+                else if (status = (NDT_Status)IMRS_OK)
+		{
+		    return(NDS_IDENT_OK);
+		    }*/
+		
+		if( status != IMRS_OK)
+		{
+		    return(status);
+		}
+            }
+
+            if(strcmp(Field_ptr->Value_Id, IMRD_SDMD_EMPTY_STRING) != 0)
+            {
+		status = IdentStruct-> Ident_Field_ValueFunc_Ptr(Field_ptr, Field_ptr->Value_Id);
+		
+		
+		/*if( ((Next_Node_Ptr == NULL) && (status == (NDT_Status)IMRS_NO_IDENT)) || (status == (NDT_Status)IMRS_KO) )
+		{
+		    return( NDS_KO);
+		}
+                else if (status == (NDT_Status)IMRS_OK)
+                {
+                    return(NDS_IDENT_OK);
+		    }*/
+                
+		if( status != IMRS_OK)
+		{
+		    return(status);
+		}
+
+            }
+	            
+            return(NDS_OK);
+        }
+
+		case IMRD_SDMD_CMD_API_SQL_DUMP:
+		{
+		/*
+			NDT_Node   *Next_Node_Ptr = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+			va_list     user_args     =     (va_list)va_arg( Args, va_list);
+			user_type   user_data     =   (user_type)va_arg( user_args, user_type);
+								  ... =         (...)va_arg( user_args, ...);
+
+  			void       *Field_ptr     = Node_Ptr->Value;
+		*/
+			NDT_Node        *Next_Node_Ptr = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+			va_list          user_args     =     (va_list)va_arg( Args, va_list);
+			FILE            *Out           =     (FILE  *)va_arg( user_args, FILE  *);
+			IMRT_Field_Id    MsgId         =     (IMRT_Field_Id)va_arg( user_args, IMRT_Field_Id);
+
+			IMRT_Field      *Field_Ptr     = Node_Ptr->Value;
+
+			Command_Name = "IMRD_SDMD_CMD_API_SQL_DUMP";
+
+			fprintf( Out, "INSERT INTO IMR_FIELD(FIELD_ID, FIELD_NAME, MSG_ID, FIELD_VALUEID, FIELD_EXIST) VALUES(%d, '%s', %d, '%s', ",
+					Field_Ptr->Id, Field_Ptr->Name, MsgId, Field_Ptr->Value_Id);
+
+			if(Field_Ptr->Exist == IMRD_TRUE)
+			{
+				fprintf( Out, "'%c');\n", IMRD_YES);
+			}
+			else
+			{
+				fprintf( Out, "'%c');\n", IMRD_NO);
+			}
+
+
+
+			if(Field_Ptr->Fixed.Size != -1)
+			{
+				fprintf( Out, "INSERT INTO IMR_FIXEDFIELD(FIELD_ID, FIXED_FIELD_OFFSET, FIXED_FIELD_SIZE, FIXED_FIELD_CNV_ID, FIXED_FIELD_CNV_ATTR, FIXED_FIELD_DEF_VAL) VALUES(%d, %d, %d, ",
+					Field_Ptr->Id, Field_Ptr->Fixed.Offset, Field_Ptr->Fixed.Size);
+
+				if(Field_Ptr->Fixed.Cnv_Ptr != NULL)
+				{
+					fprintf( Out, "%d, '%s', '%s');\n",
+						Field_Ptr->Fixed.Cnv_Ptr->Id, Field_Ptr->Fixed.Cnv_Attr, Field_Ptr->Fixed.Def_Val);
+				}
+				else
+				{
+					fprintf( Out, "NULL, '%s', '%s');\n",
+						Field_Ptr->Fixed.Cnv_Attr, Field_Ptr->Fixed.Def_Val);
+				}
+			}
+
+			if(strcmp(Field_Ptr->FML.Tag, IMRD_SDMD_EMPTY_STRING) != 0)
+			{
+				fprintf( Out, "INSERT INTO IMR_FMLFIELD(FIELD_ID, FML_FIELD_TAG, FML_FIELD_CNV_ID, FML_FIELD_CNV_ATTR, FML_FIELD_DEF_VAL) VALUES(%d, '%s', ",
+					Field_Ptr->Id, Field_Ptr->FML.Tag);
+
+				if(Field_Ptr->FML.Cnv_Ptr != NULL)
+				{
+					fprintf( Out, "%d, '%s', '%s');\n",
+						Field_Ptr->FML.Cnv_Ptr->Id, Field_Ptr->FML.Cnv_Attr, Field_Ptr->FML.Def_Val);
+				}
+				else
+				{
+					fprintf( Out, "NULL, '%s', '%s');\n",
+						Field_Ptr->FML.Cnv_Attr, Field_Ptr->FML.Def_Val);
+				}
+			}
+
+			if(strcmp(Field_Ptr->XML.Tag, IMRD_SDMD_EMPTY_STRING) != 0)
+			{
+				fprintf( Out, "INSERT INTO IMR_XMLFIELD(FIELD_ID, XML_FIELD_TAG, XML_FIELD_CNV_ID, XML_FIELD_CNV_ATTR, XML_FIELD_DEF_VAL) VALUES(%d, '%s', ",
+					Field_Ptr->Id, Field_Ptr->XML.Tag);
+
+				if(Field_Ptr->XML.Cnv_Ptr != NULL)
+				{
+					fprintf( Out, "%d, '%s', '%s');\n",
+						Field_Ptr->XML.Cnv_Ptr->Id, Field_Ptr->XML.Cnv_Attr, Field_Ptr->XML.Def_Val);
+				}
+				else
+				{
+					fprintf( Out, "NULL, '%s', '%s');\n",
+						Field_Ptr->XML.Cnv_Attr, Field_Ptr->XML.Def_Val);
+				}
+			}
+
+			if(strcmp(Field_Ptr->Tagged.Tag, IMRD_SDMD_EMPTY_STRING) != 0)
+			{
+				fprintf( Out, "INSERT INTO IMR_TAGGEDFIELD(FIELD_ID, TAGGED_FIELD_TAG, TAGGED_FIELD_CNV_ID, TAGGED_FIELD_CNV_ATTR, TAGGED_FIELD_DEF_VAL) VALUES(%d, '%s', ",
+					Field_Ptr->Id, Field_Ptr->Tagged.Tag);
+
+				if(Field_Ptr->Tagged.Cnv_Ptr != NULL)
+				{
+					fprintf( Out, "%d, '%s', '%s');\n",
+						Field_Ptr->Tagged.Cnv_Ptr->Id, Field_Ptr->Tagged.Cnv_Attr, Field_Ptr->Tagged.Def_Val);
+				}
+				else
+				{
+					fprintf( Out, "NULL, '%s', '%s');\n",
+						Field_Ptr->Tagged.Cnv_Attr, Field_Ptr->Tagged.Def_Val);
+				}
+			}
+
+			if(strcmp(Field_Ptr->Internal.Tag, IMRD_SDMD_EMPTY_STRING) != 0)
+			{
+				fprintf( Out, "INSERT INTO IMR_INTERNALFIELD(FIELD_ID, INTERNAL_FIELD_TAG, INTERNAL_FIELD_CNV_ID, INTERNAL_FIELD_CNV_ATTR, INTERNAL_FIELD_DEF_VAL) VALUES(%d, '%s', ",
+					Field_Ptr->Id, Field_Ptr->Internal.Tag);
+
+				if(Field_Ptr->Internal.Cnv_Ptr != NULL)
+				{
+					fprintf( Out, "%d, '%s', '%s');\n",
+						Field_Ptr->Internal.Cnv_Ptr->Id, Field_Ptr->Internal.Cnv_Attr, Field_Ptr->Internal.Def_Val);
+				}
+				else
+				{
+					fprintf( Out, "NULL, '%s', '%s');\n",
+						Field_Ptr->Internal.Cnv_Attr, Field_Ptr->Internal.Def_Val);
+				}
+			}
+
+			if(Field_Ptr->Delimited.Id != IMRD_DELIMITED_ID_UNKNOWN)
+			{
+				fprintf( Out, "INSERT INTO IMR_DELIMITEDFIELD(FIELD_ID, DELIMITED_FIELD_ID, DELIMITED_FIELD_CNV_ID, DELIMITED_FIELD_CNV_ATTR, DELIMITED_FIELD_DEF_VAL) VALUES(%d, %d, ",
+					Field_Ptr->Id, Field_Ptr->Delimited.Id);
+
+				if(Field_Ptr->Delimited.Cnv_Ptr != NULL)
+				{
+					fprintf( Out, "%d, '%s', '%s');\n",
+						Field_Ptr->Delimited.Cnv_Ptr->Id, Field_Ptr->Delimited.Cnv_Attr, Field_Ptr->Delimited.Def_Val);
+				}
+				else
+				{
+					fprintf( Out, "NULL, '%s', '%s');\n",
+						Field_Ptr->Delimited.Cnv_Attr, Field_Ptr->Delimited.Def_Val);
+				}
+			}
+
+			return( NDS_OK);
+		}
+
+		case IMRD_SDMD_CMD_API_XML_DUMP:
+		{
+		/*
+			NDT_Node   *Next_Node_Ptr = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+			va_list     user_args     =     (va_list)va_arg( Args, va_list);
+			user_type   user_data     =   (user_type)va_arg( user_args, user_type);
+								  ... =         (...)va_arg( user_args, ...);
+
+  			void       *Field_ptr     = Node_Ptr->Value;
+		*/
+			NDT_Node        *Next_Node_Ptr = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+			va_list          user_args     = (va_list)va_arg( Args, va_list);
+			FILE            *Out           = (FILE  *)va_arg( user_args, FILE  *);
+
+			IMRT_Field      *Field_Ptr     = Node_Ptr->Value;
+
+
+			Command_Name = "IMRD_SDMD_CMD_API_XML_DUMP";
+
+			fprintf( Out, "\t\t<%s>\n", IMRD_SDMD_TAG_FIELD);
+
+			if(strcmp(Field_Ptr->Name, IMRD_SDMD_EMPTY_STRING) != 0)
+			{
+				fprintf( Out, "\t\t\t<%s>%s</%s>\n", IMRD_SDMD_TAG_NAME, Field_Ptr->Name, IMRD_SDMD_TAG_NAME);
+			}
+
+			if(strcmp(Field_Ptr->Value_Id, IMRD_SDMD_EMPTY_STRING) != 0)
+			{
+				fprintf( Out, "\t\t\t<%s>%s</%s>\n", IMRD_SDMD_TAG_VALUEID, Field_Ptr->Value_Id, IMRD_SDMD_TAG_VALUEID);
+			}
+
+			if(Field_Ptr->Exist == IMRD_TRUE)
+			{
+				fprintf( Out, "\t\t\t<%s>%c</%s>\n", IMRD_SDMD_TAG_EXIST, IMRD_YES, IMRD_SDMD_TAG_EXIST);
+			}
+
+			if((Field_Ptr->Fixed.Size != -1)||(Field_Ptr->Fixed.Cnv_Ptr != NULL)||(strcmp(Field_Ptr->Fixed.Def_Val, IMRD_SDMD_EMPTY_STRING) != 0))
+			{
+				fprintf( Out, "\t\t\t<%s>\n\t\t\t\t<%s>%d</%s>\n\t\t\t\t<%s>%d</%s>\n", IMRD_SDMD_TAG_FIXED, 
+						IMRD_SDMD_TAG_OFFSET, Field_Ptr->Fixed.Offset, IMRD_SDMD_TAG_OFFSET, 
+						IMRD_SDMD_TAG_SIZE, Field_Ptr->Fixed.Size, IMRD_SDMD_TAG_SIZE);
+
+				if(Field_Ptr->Fixed.Cnv_Ptr != NULL)
+				{
+					fprintf( Out, "\t\t\t\t<%s>\n\t\t\t\t\t<%s>%s</%s>\n",
+							IMRD_SDMD_TAG_CNV, 
+							IMRD_SDMD_TAG_NAME, Field_Ptr->Fixed.Cnv_Ptr->Name, IMRD_SDMD_TAG_NAME);
+
+					if(strcmp(Field_Ptr->Fixed.Cnv_Attr, IMRD_SDMD_EMPTY_STRING) != 0)
+					{
+						fprintf( Out, "\t\t\t\t\t<%s>%s</%s>\n", 
+										IMRD_SDMD_TAG_ATTRIBUTE, Field_Ptr->Fixed.Cnv_Attr, IMRD_SDMD_TAG_ATTRIBUTE);
+					}
+					
+					fprintf( Out, "\t\t\t\t</%s>\n", IMRD_SDMD_TAG_CNV);
+				}
+
+				if(strcmp(Field_Ptr->Fixed.Def_Val, IMRD_SDMD_EMPTY_STRING) != 0)
+				{
+					fprintf( Out, "\t\t\t\t<%s>%s</%s>\n",
+					IMRD_SDMD_TAG_DEFVAL, Field_Ptr->Fixed.Def_Val, IMRD_SDMD_TAG_DEFVAL);
+				}
+
+				fprintf( Out, "\t\t\t</%s>\n", IMRD_SDMD_TAG_FIXED);
+			}
+
+
+			if((strcmp(Field_Ptr->Tagged.Tag, IMRD_SDMD_EMPTY_STRING) != 0)||
+				(Field_Ptr->Tagged.Cnv_Ptr != NULL)||
+				(strcmp(Field_Ptr->Tagged.Def_Val, IMRD_SDMD_EMPTY_STRING) != 0))
+			{
+				fprintf( Out, "\t\t\t<%s>\n\t\t\t\t<%s>%s</%s>\n", IMRD_SDMD_TAG_TAGGED, 
+						IMRD_SDMD_TAG_NAME, Field_Ptr->Tagged.Tag, IMRD_SDMD_TAG_NAME);
+
+				if(Field_Ptr->Tagged.Cnv_Ptr != NULL)
+				{
+					fprintf( Out, "\t\t\t\t<%s>\n\t\t\t\t\t<%s>%s</%s>\n",
+							IMRD_SDMD_TAG_CNV, 
+							IMRD_SDMD_TAG_NAME, Field_Ptr->Tagged.Cnv_Ptr->Name, IMRD_SDMD_TAG_NAME);
+
+					if(strcmp(Field_Ptr->Tagged.Cnv_Attr, IMRD_SDMD_EMPTY_STRING) != 0)
+					{
+						fprintf( Out, "\t\t\t\t\t<%s>%s</%s>\n", 
+										IMRD_SDMD_TAG_ATTRIBUTE, Field_Ptr->Tagged.Cnv_Attr, IMRD_SDMD_TAG_ATTRIBUTE);
+					}
+					
+					fprintf( Out, "\t\t\t\t</%s>\n", IMRD_SDMD_TAG_CNV);
+				}
+
+				if(strcmp(Field_Ptr->Tagged.Def_Val, IMRD_SDMD_EMPTY_STRING) != 0)
+				{
+					fprintf( Out, "\t\t\t\t<%s>%s</%s>\n",
+					IMRD_SDMD_TAG_DEFVAL, Field_Ptr->Tagged.Def_Val, IMRD_SDMD_TAG_DEFVAL);
+				}
+
+				fprintf( Out, "\t\t\t</%s>\n", IMRD_SDMD_TAG_TAGGED);
+
+			}
+
+			if((strcmp(Field_Ptr->Internal.Tag, IMRD_SDMD_EMPTY_STRING) != 0)||
+				(Field_Ptr->Internal.Cnv_Ptr != NULL)||
+				(strcmp(Field_Ptr->Internal.Def_Val, IMRD_SDMD_EMPTY_STRING) != 0))
+			{
+				fprintf( Out, "\t\t\t<%s>\n\t\t\t\t<%s>%s</%s>\n", IMRD_SDMD_TAG_INTERNE, 
+						IMRD_SDMD_TAG_NAME, Field_Ptr->Internal.Tag, IMRD_SDMD_TAG_NAME);
+
+				if(Field_Ptr->Internal.Cnv_Ptr != NULL)
+				{
+					fprintf( Out, "\t\t\t\t<%s>\n\t\t\t\t\t<%s>%s</%s>\n",
+							IMRD_SDMD_TAG_CNV, 
+							IMRD_SDMD_TAG_NAME, Field_Ptr->Internal.Cnv_Ptr->Name, IMRD_SDMD_TAG_NAME);
+
+					if(strcmp(Field_Ptr->Internal.Cnv_Attr, IMRD_SDMD_EMPTY_STRING) != 0)
+					{
+						fprintf( Out, "\t\t\t\t\t<%s>%s</%s>\n", 
+										IMRD_SDMD_TAG_ATTRIBUTE, Field_Ptr->Internal.Cnv_Attr, IMRD_SDMD_TAG_ATTRIBUTE);
+					}
+					
+					fprintf( Out, "\t\t\t\t</%s>\n", IMRD_SDMD_TAG_CNV); 
+				}
+
+				if(strcmp(Field_Ptr->Internal.Def_Val, IMRD_SDMD_EMPTY_STRING) != 0)
+				{
+					fprintf( Out, "\t\t\t\t<%s>%s</%s>\n",
+					IMRD_SDMD_TAG_DEFVAL, Field_Ptr->Internal.Def_Val, IMRD_SDMD_TAG_DEFVAL);
+				}
+
+				fprintf( Out, "\t\t\t</%s>\n", IMRD_SDMD_TAG_INTERNE);
+
+			}
+
+
+			if((strcmp(Field_Ptr->FML.Tag, IMRD_SDMD_EMPTY_STRING) != 0)||
+				(Field_Ptr->FML.Cnv_Ptr != NULL)||
+				(strcmp(Field_Ptr->FML.Def_Val, IMRD_SDMD_EMPTY_STRING) != 0))
+			{
+				fprintf( Out, "\t\t\t<%s>\n\t\t\t\t<%s>%s</%s>\n", IMRD_SDMD_TAG_FML, 
+						IMRD_SDMD_TAG_NAME, Field_Ptr->FML.Tag, IMRD_SDMD_TAG_NAME);
+
+				if(Field_Ptr->FML.Cnv_Ptr != NULL)
+				{
+					fprintf( Out, "\t\t\t\t<%s>\n\t\t\t\t\t<%s>%s</%s>\n",
+							IMRD_SDMD_TAG_CNV, 
+							IMRD_SDMD_TAG_NAME, Field_Ptr->FML.Cnv_Ptr->Name, IMRD_SDMD_TAG_NAME);
+
+					if(strcmp(Field_Ptr->FML.Cnv_Attr, IMRD_SDMD_EMPTY_STRING) != 0)
+					{
+						fprintf( Out, "\t\t\t\t\t<%s>%s</%s>\n", 
+										IMRD_SDMD_TAG_ATTRIBUTE, Field_Ptr->FML.Cnv_Attr, IMRD_SDMD_TAG_ATTRIBUTE);
+					}
+					
+					fprintf( Out, "\t\t\t\t</%s>\n", IMRD_SDMD_TAG_CNV); 
+				}
+
+				if(strcmp(Field_Ptr->FML.Def_Val, IMRD_SDMD_EMPTY_STRING) != 0)
+				{
+					fprintf( Out, "\t\t\t\t<%s>%s</%s>\n",
+					IMRD_SDMD_TAG_DEFVAL, Field_Ptr->FML.Def_Val, IMRD_SDMD_TAG_DEFVAL);
+				}
+
+				fprintf( Out, "\t\t\t</%s>\n", IMRD_SDMD_TAG_FML);
+
+			}
+
+			if((strcmp(Field_Ptr->XML.Tag, IMRD_SDMD_EMPTY_STRING) != 0)||
+				(Field_Ptr->XML.Cnv_Ptr != NULL)||
+				(strcmp(Field_Ptr->XML.Def_Val, IMRD_SDMD_EMPTY_STRING) != 0))
+			{
+				fprintf( Out, "\t\t\t<%s>\n\t\t\t\t<%s>%s</%s>\n", IMRD_SDMD_TAG_XML, 
+						IMRD_SDMD_TAG_NAME, Field_Ptr->XML.Tag, IMRD_SDMD_TAG_NAME);
+
+				if(Field_Ptr->XML.Cnv_Ptr != NULL)
+				{
+					fprintf( Out, "\t\t\t\t<%s>\n\t\t\t\t\t<%s>%s</%s>\n",
+							IMRD_SDMD_TAG_CNV, 
+							IMRD_SDMD_TAG_NAME, Field_Ptr->XML.Cnv_Ptr->Name, IMRD_SDMD_TAG_NAME);
+
+					if(strcmp(Field_Ptr->XML.Cnv_Attr, IMRD_SDMD_EMPTY_STRING) != 0)
+					{
+						fprintf( Out, "\t\t\t\t\t<%s>%s</%s>\n", 
+										IMRD_SDMD_TAG_ATTRIBUTE, Field_Ptr->XML.Cnv_Attr, IMRD_SDMD_TAG_ATTRIBUTE);
+					}
+					
+					fprintf( Out, "\t\t\t\t</%s>\n", IMRD_SDMD_TAG_CNV); 
+				}
+
+				if(strcmp(Field_Ptr->XML.Def_Val, IMRD_SDMD_EMPTY_STRING) != 0)
+				{
+					fprintf( Out, "\t\t\t\t<%s>%s</%s>\n",
+					IMRD_SDMD_TAG_DEFVAL, Field_Ptr->XML.Def_Val, IMRD_SDMD_TAG_DEFVAL);
+				}
+
+				fprintf( Out, "\t\t\t</%s>\n", IMRD_SDMD_TAG_XML);
+
+			}
+
+
+			if((Field_Ptr->Delimited.Id != IMRD_DELIMITED_ID_UNKNOWN)||
+				(Field_Ptr->Delimited.Cnv_Ptr != NULL)||
+				(strcmp(Field_Ptr->Delimited.Def_Val, IMRD_SDMD_EMPTY_STRING) != 0))
+			{
+				fprintf( Out, "\t\t\t<%s>\n\t\t\t\t<%s>%d</%s>\n", IMRD_SDMD_TAG_DELIMITED, 
+						IMRD_SDMD_TAG_ID, Field_Ptr->Delimited.Id, IMRD_SDMD_TAG_ID);
+				
+				if(Field_Ptr->Delimited.Cnv_Ptr != NULL)
+				{
+					fprintf( Out, "\t\t\t\t<%s>\n\t\t\t\t\t<%s>%s</%s>\n",
+							IMRD_SDMD_TAG_CNV, 
+							IMRD_SDMD_TAG_NAME, Field_Ptr->Delimited.Cnv_Ptr->Name, IMRD_SDMD_TAG_NAME);
+
+					if(strcmp(Field_Ptr->Delimited.Cnv_Attr, IMRD_SDMD_EMPTY_STRING) != 0)
+					{
+						fprintf( Out, "\t\t\t\t\t<%s>%s</%s>\n", 
+										IMRD_SDMD_TAG_ATTRIBUTE, Field_Ptr->Delimited.Cnv_Attr, IMRD_SDMD_TAG_ATTRIBUTE);
+					}
+					
+					fprintf( Out, "\t\t\t\t</%s>\n", IMRD_SDMD_TAG_CNV); 
+				}
+
+				if(strcmp(Field_Ptr->Delimited.Def_Val, IMRD_SDMD_EMPTY_STRING) != 0)
+				{
+					fprintf( Out, "\t\t\t\t<%s>%s</%s>\n",
+					IMRD_SDMD_TAG_DEFVAL, Field_Ptr->Delimited.Def_Val, IMRD_SDMD_TAG_DEFVAL);
+				}
+
+				fprintf( Out, "\t\t\t</%s>\n", IMRD_SDMD_TAG_DELIMITED);
+			}
+
+			fprintf( Out, "\t\t</%s>\n", IMRD_SDMD_TAG_FIELD);
+
+			return( NDS_OK);
+		}
+
+
+        default:
+        {
+            printf( "SDM_Field_Manager() called with an undefined command %d\n", Command);
+
+            return( NDS_ERRAPI);
+        }
+    }
+
+    printf( "SDM_Field_Manager() called with command %d (%s)\n", Command, Command_Name);
+
+    return( NDS_OK);
+}
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Msg Manager                                                                */
+/*----------------------------------------------------------------------------*/
+
+NDT_Status  SDM_Msg_Manager( NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id, NDT_Node  *Node_Ptr, NDT_Command  Command, va_list  Args)
+{
+    NDT_Command_Name  Command_Name;
+    NDT_Status         status;
+
+
+    switch( Command)
+    {
+        case NDD_CMD_MANAGER_VERSION:
+        {
+            NDT_Version_Name  *Version_Name_Ptr = (NDT_Version_Name  *)va_arg( Args, NDT_Version_Name  *);
+
+
+            Command_Name = "NDD_CMD_MANAGER_VERSION";
+
+            *Version_Name_Ptr = "Revision: 2.1    Name: libnode-2_0_4-1    Date: 2002/02/28 22:00:35    Author: agibert ";
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_INDEX_GET:
+        {
+            /*
+	      NDT_Index_Id  *Reply_Index_Id_Ptr = (NDT_Index_Id  *)va_arg( Args, NDT_Index_Id  *);
+	      NDT_Command   *Reply_Command_Ptr  = (NDT_Command  *)va_arg( Args, NDT_Command  *);
+	      NDT_Command    Cmd                = (NDT_Command)va_arg( Args, NDT_Command);
+	      void          *Value_ptr          = (void  *)va_arg( Args, void  *);
+            */
+            NDT_Index_Id  *Reply_Index_Id_Ptr = (NDT_Index_Id  *)va_arg( Args, NDT_Index_Id  *);
+            NDT_Command   *Reply_Command_Ptr  = (NDT_Command  *)va_arg( Args, NDT_Command  *);
+            NDT_Command    Cmd                = (NDT_Command)va_arg( Args, NDT_Command);
+            IMRT_Msg      *Msg_ptr            = (IMRT_Msg  *)va_arg( Args, IMRT_Msg  *);
+
+
+            Command_Name = "NDD_CMD_INDEX_GET";
+
+            switch(Cmd)
+            {
+                case IMRD_SDMD_CMD_INDEX0_PRINT:
+                {
+                    *Reply_Index_Id_Ptr = 0;
+                    *Reply_Command_Ptr = NDD_CMD_VALUE_PRINT;
+
+                    break;
+                }
+
+				case IMRD_SDMD_CMD_API_SQL_DUMP:
+				{
+                    *Reply_Index_Id_Ptr = IMRD_SDMD_MSG_IDX_ID;
+                    *Reply_Command_Ptr = IMRD_SDMD_CMD_API_SQL_DUMP;
+                    break;
+				}
+
+				case IMRD_SDMD_CMD_API_XML_DUMP:
+				{
+                    *Reply_Index_Id_Ptr = IMRD_SDMD_MSG_IDX_ID;
+                    *Reply_Command_Ptr = IMRD_SDMD_CMD_API_XML_DUMP;
+                    break;
+				}
+
+                default:
+                {
+                    *Reply_Index_Id_Ptr = Index_Id;
+                    *Reply_Command_Ptr = Cmd;
+
+                    break;
+                }
+            }
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_ALLOC:
+        {
+            /*
+	      void       **Msg_ptr_Ptr   = (void **)va_arg( Args, void  **);
+	      va_list      user_args     = (va_list)va_arg( Args, va_list);
+	      user_type    user_data     = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+            */
+            IMRT_Msg  **Msg_ptr_Ptr = va_arg( Args, IMRT_Msg  **);
+			NDT_Index_Type  *index_type_ptr;
+
+
+            Command_Name = "NDD_CMD_VALUE_ALLOC";
+
+            if( ( *Msg_ptr_Ptr = (IMRT_Msg  *)malloc( sizeof(IMRT_Msg))) == NULL)
+            {
+                return( NDS_ERRMEM);
+            }
+            else
+            {
+
+                SDM_InitMessage(*Msg_ptr_Ptr);
+                
+				index_type_ptr =  Msg_Struct_initial_idx_tab;
+
+                if( ( status = ND_DataStruct_Open( &(*Msg_ptr_Ptr)->Field_Struct_Ptr, IMRD_SDMD_FIELD_STRUCT_IDX_NB, index_type_ptr, "SDM__Field_Manager", SDM_Field_Manager, NULL, NULL, NULL, NULL,0,  NULL)) != NDS_OK)
+				{
+				    printf( "ND_DataStruct_Open() Field failed (%d) !\n", status);
+                    return(NDS_KO);
+				}
+
+                return( NDS_OK);
+            }
+        }
+
+        case NDD_CMD_VALUE_FREE:
+        {
+            /*
+	      void       *Msg_ptr   = (void *)va_arg( Args, void  *);
+	      va_list     user_args = (va_list)va_arg( Args, va_list);
+	      user_type   user_data = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+            */
+            IMRT_Msg  *Msg_ptr  = (IMRT_Msg  *)va_arg( Args, IMRT_Msg  *);
+
+
+            Command_Name = "NDD_CMD_VALUE_FREE";
+            if(Msg_ptr->Field_Struct_Ptr != NULL)
+            {  if( ( status = ND_DataStruct_Close(Msg_ptr->Field_Struct_Ptr)) != NDS_OK)
+				{
+				    printf( "ND_DataStruct_Close() failed (%d) !\n", status);
+				    return(status);
+				}
+            }
+
+            free( Msg_ptr);
+            
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_COMP:
+        {
+            /*
+	      void       *Value1_Ptr = (void *)va_arg( Args, void  *);
+	      void       *Value2_Ptr = (void *)va_arg( Args, void  *);
+	      va_list     user_args  = (va_list)va_arg( Args, va_list);
+	      user_type   user_data  = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+            */
+            IMRT_Msg     *Value1_Ptr = va_arg( Args, IMRT_Msg  *);
+            IMRT_Msg     *Value2_Ptr = va_arg( Args, IMRT_Msg  *);
+
+
+            Command_Name = "NDD_CMD_VALUE_COMP";
+
+            switch( Index_Id)
+            {
+                case IMRD_SDMD_MSG_IDX_ID:
+                {
+                    if( Value1_Ptr->Id < Value2_Ptr->Id)
+                    {
+                        return( NDS_LOWER);
+                    }
+                    else
+                    {
+                        if( Value1_Ptr->Id > Value2_Ptr->Id)
+                        {
+                            return( NDS_GREATER);
+                        }
+                        else
+                        {
+                            return( NDS_EQUAL);
+                        }
+                    }
+                }
+
+                case IMRD_SDMD_MSG_IDX_NAME:
+                {
+                    int     rc;
+                    
+                    rc = strcmp( Value1_Ptr->Name, Value2_Ptr->Name);
+
+                    if( rc < 0)
+                    {
+                        return( NDS_LOWER);
+                    }
+                    else
+                    {
+                        if( rc > 0)
+                        {
+                            return( NDS_GREATER);
+                        }
+                        else
+                        {
+                            return( NDS_EQUAL);
+                        }
+                    }
+                }
+
+                 default:
+                {
+                    printf( "Unknown COMP idx (%d) !\n", Index_Id);
+                    return( NDS_KO);
+                }
+            }
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_ADD:
+        {
+            /*
+	      void       *Msg_ptr   = (void *)va_arg( Args, void  *);
+	      va_list     user_args = (va_list)va_arg( Args, va_list);
+	      user_type   user_data = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+            */
+
+            Command_Name = "NDD_CMD_VALUE_ADD";
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_REMOVE:
+        {
+            /*
+	      void       *Msg_ptr   = (void *)va_arg( Args, void  *);
+	      va_list     user_args = (va_list)va_arg( Args, va_list);
+	      user_type   user_data = (user_type)va_arg( user_args, user_type);
+	      ... = (...)va_arg( user_args, ...);
+            */
+
+            Command_Name = "NDD_CMD_VALUE_REMOVE";
+
+            return( NDS_OK);
+        }
+
+        case NDD_CMD_VALUE_PRINT:
+        {
+            /*
+	      NDT_Node             *Next_Node_Ptr    = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+	      va_list               lib_args         = (va_list)va_arg( Args, va_list);
+	      FILE                 *Out              = (FILE  *)va_arg( lib_args, FILE  *);
+	      NDT_Recursive_Mode    Recursive_Mode   = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode);
+	      NDT_Recursive_Depth   Recursive_Depth  = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth);
+	      NDT_Recursive_Offset  Recursive_Offset = (NDT_Recursive_Offset)va_arg( lib_args, NDT_Recursive_Offset);
+	      va_list               user_args        = (va_list)va_arg( lib_args, va_list);
+	      user_type             user_data        = (user_type)va_arg( user_args, user_type);
+	      ...  = (...)va_arg( user_args, ...);
+
+	      void                 *Msg_ptr           = Node_Ptr->Value;
+            */
+            NDT_Node             *Next_Node_Ptr   =         (NDT_Node  *)va_arg( Args, NDT_Node  *);
+            va_list               lib_args        =             (va_list)va_arg( Args, va_list);
+            FILE                 *Out             =             (FILE  *)va_arg( lib_args, FILE  *);
+            NDT_Recursive_Mode    Recursive_Mode  =  (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode);
+            NDT_Recursive_Depth   Recursive_Depth = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth);
+            NDT_Recursive_Offset  Recursive_Offset = (NDT_Recursive_Offset)va_arg( lib_args, NDT_Recursive_Offset);
+
+            IMRT_Msg             *Msg_ptr          = Node_Ptr->Value;
+
+
+            Command_Name = "NDD_CMD_VALUE_PRINT";
+
+            printf("Adresse avant traverse (%x)\n",Msg_ptr);
+
+            fprintf( Out, "Type: (%s)   Size: (%d)   \n",
+		     Msg_ptr->Name,  Msg_ptr->Size);
+
+            return( ND_DataStruct_Value_Print( Out, Msg_ptr->Field_Struct_Ptr, NDD_RECURSIVE_MODE_PARENT_CHILD, --Recursive_Depth, ++Recursive_Offset));
+            
+        }
+
+        case NDD_CMD_INFO_PRINT:
+        {
+            /*
+	      NDT_Node             *Next_Node_Ptr    = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+	      va_list               lib_args         = (va_list)va_arg( Args, va_list);
+	      FILE                 *Out              = (FILE  *)va_arg( lib_args, FILE  *);
+	      NDT_Recursive_Mode    Recursive_Mode   = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode);
+	      NDT_Recursive_Depth   Recursive_Depth  = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth);
+	      NDT_Recursive_Offset  Recursive_Offset = (NDT_Recursive_Offset)va_arg( lib_args, NDT_Recursive_Offset);
+	      va_list               user_args        = (va_list)va_arg( lib_args, va_list);
+	      user_type             user_data        = (user_type)va_arg( user_args, user_type);
+	      ...  = (...)va_arg( user_args, ...);
+
+	      void                 *Msg_ptr          = Node_Ptr->Value;
+            */
+
+            NDT_Node             *Next_Node_Ptr    = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+	    va_list               lib_args         = (va_list)va_arg( Args, va_list);
+	    FILE                 *Out              = (FILE  *)va_arg( lib_args, FILE  *);
+	    NDT_Recursive_Mode    Recursive_Mode   = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode);
+	    NDT_Recursive_Depth   Recursive_Depth  = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth);
+	    NDT_Recursive_Offset  Recursive_Offset = (NDT_Recursive_Offset)va_arg( lib_args, NDT_Recursive_Offset);
+			      
+	    IMRT_Msg  *Msg_Ptr                     = Node_Ptr->Value;
+
+        
+	    Command_Name = "NDD_CMD_INFO_PRINT";
+
+
+	    return( ND_DataStruct_Info_Print( Out, Msg_Ptr->Field_Struct_Ptr, NDD_RECURSIVE_MODE_PARENT_CHILD, --Recursive_Depth, ++Recursive_Offset));
+
+	}
+
+	case IMRD_SDMD_CMD_API_SQL_DUMP:
+	{
+	/*
+		NDT_Node   *Next_Node_Ptr = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+		va_list     user_args     =     (va_list)va_arg( Args, va_list);
+		user_type   user_data     =   (user_type)va_arg( user_args, user_type);
+							  ... =         (...)va_arg( user_args, ...);
+
+		void       *Msg_ptr       = Node_Ptr->Value;
+	*/
+		NDT_Node        *Next_Node_Ptr = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+		va_list          user_args     =     (va_list)va_arg( Args, va_list);
+		FILE            *Out           =     (FILE  *)va_arg( user_args, FILE  *);
+
+		IMRT_Msg        *Msg_Ptr       = Node_Ptr->Value;
+
+
+		Command_Name = "IMRD_SDMD_CMD_API_SQL_DUMP";
+
+		fprintf( Out, "INSERT INTO IMR_MSG(MSG_ID, MSG_NAME, MSG_SIZE) VALUES(%d, '%s', %d);\n",
+				Msg_Ptr->Id, Msg_Ptr->Name, Msg_Ptr->Size);
+
+	    if( ( status = ND_DataStruct_Traverse( Msg_Ptr->Field_Struct_Ptr, IMRD_SDMD_CMD_API_SQL_DUMP, Out, Msg_Ptr->Id)) != NDS_OK)
+		{
+			printf( "ND_DataStruct_Traverse failed (%d)...\n");
+			return(NDS_KO);
+		}
+
+		return( NDS_OK);
+	}
+
+	case IMRD_SDMD_CMD_API_XML_DUMP:
+	{
+	/*
+		NDT_Node   *Next_Node_Ptr = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+		va_list     user_args     =     (va_list)va_arg( Args, va_list);
+		user_type   user_data     =   (user_type)va_arg( user_args, user_type);
+							  ... =         (...)va_arg( user_args, ...);
+
+		void       *Msg_ptr       = Node_Ptr->Value;
+	*/
+		NDT_Node        *Next_Node_Ptr = (NDT_Node  *)va_arg( Args, NDT_Node  *);
+		va_list          user_args     =     (va_list)va_arg( Args, va_list);
+		FILE            *Out           =     (FILE  *)va_arg( user_args, FILE  *);
+
+		IMRT_Msg        *Msg_Ptr       = Node_Ptr->Value;
+
+
+		Command_Name = "IMRD_SDMD_CMD_API_XML_DUMP";
+
+		fprintf( Out, "\t<%s>\n\t\t<%s>%s</%s>\n", IMRD_SDMD_TAG_MESSAGE, 
+					IMRD_SDMD_TAG_NAME, Msg_Ptr->Name, IMRD_SDMD_TAG_NAME);
+
+		if(Msg_Ptr->Size != 0)
+		{
+			fprintf( Out, "\t\t<%s>%ld</%s>\n",
+					IMRD_SDMD_TAG_SIZE, Msg_Ptr->Size, IMRD_SDMD_TAG_SIZE);
+		}
+
+	    if( ( status = ND_DataStruct_Traverse( Msg_Ptr->Field_Struct_Ptr, IMRD_SDMD_CMD_API_XML_DUMP, Out)) != NDS_OK)
+		{
+			printf( "ND_DataStruct_Traverse failed (%d)...\n");
+			return(NDS_KO);
+		}
+
+		fprintf( Out, "\t</%s>\n", IMRD_SDMD_TAG_MESSAGE);
+
+		return( NDS_OK);
+	}
+
+	default:
+        {
+            printf( "SDM_Msg_Manager() called with an undefined command %d\n", Command);
+
+            return( NDS_ERRAPI);
+        }
+    }
+
+    printf( "SDM_Msg_Manager() called with command %d (%s)\n", Command, Command_Name);
+
+    return( NDS_OK);
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status SDM_StructInfo_Init(IMRT_SDM_Config * Lib_Config_Ptr)
+{
+    IMRT_Status  status;
+
+    if(Lib_Config_Ptr->Flag == IMRD_SDM_FLAG_XML)
+    {
+		status= SDM_XML_StructInfo_Init(Lib_Config_Ptr->Lib_Path);
+    }
+    else
+    {
+#ifdef ORACLE_SUPPORT
+		status = SDM_SQL_StructInfo_Init();
+#else
+		status = IMRS_OK;
+#endif /* ORACLE_SUPPORT */
+    }
+
+    return(status);
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status SDM_Close_RootCnv(void)
+{
+	IMRT_Status  status;
+	NDT_Status   nd_status;
+
+	status = IMRS_OK;
+
+	if(IMRG_SDM_Base.RootCnv != NULL)
+	{
+		if (IMRG_SDM_Base.RootCnv->User_Ptr != NULL)
+		{
+			free(IMRG_SDM_Base.RootCnv->User_Ptr);
+		}
+
+		if( ( nd_status = ND_DataStruct_Close(IMRG_SDM_Base.RootCnv)) != NDS_OK)
+		{
+			printf( "RootCnv ND_DataStruct_Close() failed (%d) !\n", nd_status);
+			status = IMRS_KO;
+		}
+	}
+
+	return(status);
+
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status SDM_Close_RootMsg(void)
+{
+	IMRT_Status  status;
+	NDT_Status   nd_status;
+
+	status = IMRS_OK;
+
+	if(IMRG_SDM_Base.RootMsg != NULL)
+	{
+		if (IMRG_SDM_Base.RootMsg->User_Ptr != NULL)
+		{
+			free(IMRG_SDM_Base.RootMsg->User_Ptr);
+		}
+
+		if( ( nd_status = ND_DataStruct_Close(IMRG_SDM_Base.RootMsg)) != NDS_OK)
+		{
+			printf( "RootMsg ND_DataStruct_Close() failed (%d) !\n", nd_status);
+			status = IMRS_KO;
+		}
+	}
+
+	return(status);
+
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status SDM_StructInfo_DInit(void)
+{
+	IMRT_Status  status, StatusCnv, StatusMsg;
+
+	status = IMRS_OK;
+
+	StatusCnv = SDM_Close_RootCnv();
+	StatusMsg = SDM_Close_RootMsg();
+
+	if((StatusCnv == IMRS_KO)||(StatusMsg == IMRS_KO))
+	{
+		status = IMRS_KO;
+	}
+
+	return(status);
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  SDM_Cnv_Proceed( IMRT_SDMCB_Cnv_Add  *CCB_Cnv_Add_Ptr)
+{
+
+    IMRT_Status status;
+    NDT_Status  nd_status;
+
+	status = IMRS_OK;
+    if( ( nd_status = ND_DataStruct_Traverse( IMRG_SDM_Base.RootCnv, IMRD_SDMD_CMD_EXECUTE, stdout, NDD_RECURSIVE_MODE_PARENT, CCB_Cnv_Add_Ptr)) != NDS_OK)
+    {
+	  printf( "ND_DataStruct_Traverse() failed (%d) !\n", nd_status);
+	  status = IMRS_KO;
+    }
+
+    return(status);
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+void SDM_InitMessage(IMRT_Msg * mymessage)
+{
+    mymessage->Id = IMRD_MSG_ID_UNKNOWN;
+    memset(mymessage->Name,0,sizeof(mymessage->Name));
+    mymessage->Size      = 0;
+    mymessage->Field_Struct_Ptr   = NULL;
+}
+
+void SDM_InitField(IMRT_Field * myfield)
+{
+    memset(myfield->Name,0,sizeof(myfield->Name));
+    memset(myfield->Value_Id,0,sizeof(myfield->Value_Id));
+	myfield->Exist = IMRD_FALSE;
+
+    myfield->Fixed.Offset = 0;
+    myfield->Fixed.Size = -1;
+    memset(myfield->Fixed.Def_Val,'\0',sizeof(myfield->Fixed.Def_Val));
+    myfield->Fixed.Cnv_Ptr = NULL;
+    memset(myfield->Fixed.Cnv_Attr,0,sizeof(myfield->Fixed.Cnv_Attr));
+
+    memset(myfield->XML.Tag,0,sizeof(myfield->XML.Tag));
+    memset(myfield->XML.Def_Val,'\0',sizeof(myfield->XML.Def_Val));
+    myfield->XML.Cnv_Ptr = NULL;
+    memset(myfield->XML.Cnv_Attr,0,sizeof(myfield->XML.Cnv_Attr));
+
+    memset(myfield->FML.Tag,0,sizeof(myfield->FML.Tag));
+    memset(myfield->FML.Def_Val,'\0',sizeof(myfield->FML.Def_Val));
+    myfield->FML.Cnv_Ptr = NULL;
+    memset(myfield->FML.Cnv_Attr,0,sizeof(myfield->FML.Cnv_Attr));
+
+    memset(myfield->Tagged.Tag,0,sizeof(myfield->Tagged.Tag));
+    memset(myfield->Tagged.Def_Val,'\0',sizeof(myfield->Tagged.Def_Val));
+    myfield->Tagged.Cnv_Ptr = NULL;
+    memset(myfield->Tagged.Cnv_Attr,0,sizeof(myfield->Tagged.Cnv_Attr));
+
+    memset(myfield->Internal.Tag,0,sizeof(myfield->Internal.Tag));
+    memset(myfield->Internal.Def_Val,'\0',sizeof(myfield->Internal.Def_Val));
+    myfield->Internal.Cnv_Ptr = NULL;
+    memset(myfield->Internal.Cnv_Attr,0,sizeof(myfield->Internal.Cnv_Attr));
+
+    myfield->Delimited.Id = IMRD_DELIMITED_ID_UNKNOWN;
+    memset(myfield->Delimited.Def_Val,'\0',sizeof(myfield->Delimited.Def_Val));
+    myfield->Delimited.Cnv_Ptr = NULL;
+    memset(myfield->Delimited.Cnv_Attr,0,sizeof(myfield->Delimited.Cnv_Attr));
+}
+
+void SDM_InitCnv(IMRT_Cnv * Cnv_Ptr)
+{
+    Cnv_Ptr->Id = IMRD_CNV_ID_UNKNOWN;
+    memset(Cnv_Ptr->Name,0,sizeof(Cnv_Ptr->Name));
+}
+
+
diff --git a/src/libstatic_data_mng/src/struct_info_mng.h b/src/libstatic_data_mng/src/struct_info_mng.h
new file mode 100644
index 0000000..1474f06
--- /dev/null
+++ b/src/libstatic_data_mng/src/struct_info_mng.h
@@ -0,0 +1,170 @@
+/*----------------------------------------------------------------------------*/
+/* File: struct_info_mng.h 				      		      */
+/*----------------------------------------------------------------------------*/
+/*                                                                            */
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#ifndef _STRUCT_INFO_MNG_H_
+#   define _STRUCT_INFO_MNG_H_
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Global Include                                                             */
+/*----------------------------------------------------------------------------*/
+
+#   include <libstatic_data_mng.h>
+
+
+/*----------------------------------------------------------------------------*/
+/* XML TAG                                                                    */
+/*----------------------------------------------------------------------------*/
+#define IMRD_SDMD_TAG_CNV_STRUCT    "cnv_struct"
+#define IMRD_SDMD_TAG_MSG_STRUCT    "msg_struct"
+
+
+/* Nom des fichiers pour le chargement XML */
+#define SDMD_MSGFIELD_FILE          "sd_msg_struct.xml"
+#define SDMD_CNV_FILE               "sd_cnv_struct.xml"
+
+
+/********************************************************************/
+/*       Les index du Manager SDM_Msg_Manager                       */
+/********************************************************************/
+#define IMRD_SDMD_MSG_STRUCT_IDX_NB                (short)2
+
+static NDT_Index_Type  Msg_Struct_initial_idx_tab[IMRD_SDMD_MSG_STRUCT_IDX_NB] = 
+{
+      (NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_LIST | NDD_INDEX_SUBTYPE_SORTED),
+      (NDD_INDEX_STATUS_CLOSED)
+};
+
+static NDT_Index_Type  Msg_Struct_final_idx_tab[IMRD_SDMD_MSG_STRUCT_IDX_NB] = 
+{
+      (NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_TREE | NDD_INDEX_SUBTYPE_BALANCED),
+      (NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_TREE | NDD_INDEX_SUBTYPE_BALANCED)
+};
+
+#define IMRD_SDMD_MSG_IDX_ID                (short)0
+#define IMRD_SDMD_MSG_IDX_NAME              (short)1
+
+
+/********************************************************************/
+/*       Les index du Manager SDM_Field_Manager                     */
+/********************************************************************/
+#define IMRD_SDMD_FIELD_STRUCT_IDX_NB                (short)2
+
+static NDT_Index_Type  Field_Struct_initial_idx_tab[IMRD_SDMD_FIELD_STRUCT_IDX_NB] = 
+{
+      (NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_LIST | NDD_INDEX_SUBTYPE_SORTED),
+      (NDD_INDEX_STATUS_CLOSED)
+};
+
+static NDT_Index_Type  Field_Struct_final_idx_tab[IMRD_SDMD_FIELD_STRUCT_IDX_NB] = 
+{
+      (NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_TREE | NDD_INDEX_SUBTYPE_BALANCED),
+      (NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_TREE | NDD_INDEX_SUBTYPE_BALANCED)
+};
+
+#define IMRD_SDMD_FIELD_IDX_ID                (short)0
+#define IMRD_SDMD_FIELD_IDX_NAME              (short)1
+
+
+/********************************************************************/
+/*       Les index du Manager SDM_Cnv_Manager                      */
+/********************************************************************/
+#define IMRD_SDMD_CNV_STRUCT_IDX_NB                (short)2
+
+static NDT_Index_Type  Cnv_Struct_initial_idx_tab[IMRD_SDMD_CNV_STRUCT_IDX_NB] = 
+{
+      (NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_LIST | NDD_INDEX_SUBTYPE_SORTED),
+      (NDD_INDEX_STATUS_CLOSED)
+};
+
+static NDT_Index_Type  Cnv_Struct_final_idx_tab[IMRD_SDMD_CNV_STRUCT_IDX_NB] = 
+{
+      (NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_TREE | NDD_INDEX_SUBTYPE_BALANCED),
+      (NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_TREE | NDD_INDEX_SUBTYPE_BALANCED)
+};
+
+#define IMRD_SDMD_CNV_IDX_ID                (short)0
+#define IMRD_SDMD_CNV_IDX_NAME              (short)1
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Prototypes                                                                 */
+/*----------------------------------------------------------------------------*/
+
+#   ifdef _STRUCT_INFO_MNG_C_
+
+NDT_Status  SDM_Cnv_Manager(    NDT_Root  *, NDT_Index_Id, NDT_Node  *, NDT_Command, va_list);
+NDT_Status  SDM_Field_Manager( NDT_Root  *, NDT_Index_Id, NDT_Node  *, NDT_Command, va_list);
+NDT_Status  SDM_Msg_Manager(   NDT_Root  *, NDT_Index_Id, NDT_Node  *, NDT_Command, va_list);
+IMRT_Status SDM_StructInfo_Init(IMRT_SDM_Config * Lib_Config_Ptr);
+IMRT_Status SDM_Close_RootCnv(void);
+IMRT_Status SDM_Close_RootMsg(void);
+IMRT_Status SDM_StructInfo_DInit(void);
+IMRT_Status  SDM_Cnv_Proceed( IMRT_SDMCB_Cnv_Add  *CCB_Cnv_Add_Ptr);
+void SDM_InitMessage(IMRT_Msg * mymessage);
+void SDM_InitField(IMRT_Field * myfield);
+void SDM_InitCnv(IMRT_Cnv * Cnv_Ptr);
+
+#   else
+
+extern NDT_Status  SDM_Cnv_Manager(    NDT_Root  *, NDT_Index_Id, NDT_Node  *, NDT_Command, va_list);
+extern NDT_Status  SDM_Field_Manager( NDT_Root  *, NDT_Index_Id, NDT_Node  *, NDT_Command, va_list);
+extern NDT_Status  SDM_Msg_Manager(   NDT_Root  *, NDT_Index_Id, NDT_Node  *, NDT_Command, va_list);
+extern IMRT_Status SDM_StructInfo_Init(IMRT_SDM_Config * Lib_Config_Ptr);
+extern IMRT_Status SDM_Close_RootCnv(void);
+extern IMRT_Status SDM_Close_RootMsg(void);
+extern IMRT_Status SDM_StructInfo_DInit(void);
+extern IMRT_Status  SDM_Cnv_Proceed( IMRT_SDMCB_Cnv_Add  *CCB_Cnv_Add_Ptr);
+
+#   endif
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Local Includes                                                             */
+/*----------------------------------------------------------------------------*/
+
+#   ifdef _STRUCT_INFO_MNG_C_
+
+#       include "struct_info_xml.h"
+#       include "struct_info_sql.h"
+
+#   endif
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+
+#endif
diff --git a/src/libstatic_data_mng/src/struct_info_sql.h b/src/libstatic_data_mng/src/struct_info_sql.h
new file mode 100644
index 0000000..673febc
--- /dev/null
+++ b/src/libstatic_data_mng/src/struct_info_sql.h
@@ -0,0 +1,87 @@
+/*----------------------------------------------------------------------------*/
+/* File: struct_info_sql.h 				         	      */
+/*----------------------------------------------------------------------------*/
+/*                                                                            */
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#ifndef _STRUCT_INFO_SQL_H_
+#   define _STRUCT_INFO_SQL_H_
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Global Include                                                             */
+/*----------------------------------------------------------------------------*/
+
+#   include <libstatic_data_mng.h>
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Prototypes                                                                 */
+/*----------------------------------------------------------------------------*/
+
+#   ifdef _STRUCT_INFO_SQL_PC_
+
+IMRT_Status SDM_SQL_StructInfo_Init(void);
+IMRT_Status SDM_SQL_Load_Cnv(NDT_Root **myRootCnv_Ptr_Ptr);
+IMRT_Status SDM_SQL_Load_MsgAndField(NDT_Root **myRootMessage_Ptr_Ptr);
+IMRT_Status SDM_SQL_LoadFieldMsg(IMRT_Msg  *myMsg_Ptr);
+IMRT_Status SDM_SQL_Dump_Msg_Header(FILE *dump_file);
+IMRT_Status SDM_SQL_Dump_Msg_Body(FILE *dump_file);
+IMRT_Status SDM_SQL_Dump_Msg_Footer(FILE *dump_file);
+IMRT_Status SDM_SQL_Dump_Msg(void);
+IMRT_Status SDM_SQL_Dump_Cnv_Header(FILE *dump_file);
+IMRT_Status SDM_SQL_Dump_Cnv_Body(FILE *dump_file);
+IMRT_Status SDM_SQL_Dump_Cnv_Footer(FILE *dump_file);
+IMRT_Status SDM_SQL_Dump_Cnv(void);
+
+#   else
+
+extern IMRT_Status SDM_SQL_StructInfo_Init(void);
+extern IMRT_Status SDM_SQL_Load_Cnv(NDT_Root **myRootCnv_Ptr_Ptr);
+extern IMRT_Status SDM_SQL_Load_MsgAndField(NDT_Root **myRootMessage_Ptr_Ptr);
+extern IMRT_Status SDM_SQL_LoadFieldMsg(IMRT_Msg  *myMsg_Ptr);
+extern IMRT_Status SDM_SQL_Dump_Msg_Header(FILE *dump_file);
+extern IMRT_Status SDM_SQL_Dump_Msg_Body(FILE *dump_file);
+extern IMRT_Status SDM_SQL_Dump_Msg_Footer(FILE *dump_file);
+extern IMRT_Status SDM_SQL_Dump_Msg(void);
+extern IMRT_Status SDM_SQL_Dump_Cnv_Header(FILE *dump_file);
+extern IMRT_Status SDM_SQL_Dump_Cnv_Body(FILE *dump_file);
+extern IMRT_Status SDM_SQL_Dump_Cnv_Footer(FILE *dump_file);
+extern IMRT_Status SDM_SQL_Dump_Cnv(void);
+
+#   endif
+
+
+
+
+
+/*----------------------------------------------------------------------------*/
+
+#endif
diff --git a/src/libstatic_data_mng/src/struct_info_sql.pc b/src/libstatic_data_mng/src/struct_info_sql.pc
new file mode 100644
index 0000000..efb33d6
--- /dev/null
+++ b/src/libstatic_data_mng/src/struct_info_sql.pc
@@ -0,0 +1,825 @@
+/*----------------------------------------------------------------------------*/
+/* File: struct_info_sql.pc   		         		  	      */
+/*----------------------------------------------------------------------------*/
+/*                                                                            */
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#define _LIBSTATIC_DATA_MNG_
+#define _STRUCT_INFO_SQL_PC_
+
+#include "struct_info_sql.h" 
+
+
+IMRT_Status SDM_SQL_StructInfo_Init(void)
+{
+	IMRT_Status  status, StatusTmp;
+
+	IMRD_LM_LOG_TRACE_0( IMRD_LOG_LEVEL_VERBOSE_0, "Loading Cnv...");
+    status = SDM_SQL_Load_Cnv(&(IMRG_SDM_Base.RootCnv));
+	if(status == IMRS_OK)
+	{
+	    IMRD_LM_LOG_INFO_1( "Cnv loaded: (%d)", IMRG_SDM_Base.RootCnv->Index_Tab[NDD_INDEX_PRIMARY].Node_Number);
+
+		IMRD_LM_LOG_TRACE_0( IMRD_LOG_LEVEL_VERBOSE_0, "Loading Msg and Field...");
+		status = SDM_SQL_Load_MsgAndField(&(IMRG_SDM_Base.RootMsg));
+	
+		if(status == IMRS_OK)
+		{
+			IMRD_LM_LOG_INFO_1( "Msg and Field loaded: (%d)", IMRG_SDM_Base.RootMsg->Index_Tab[NDD_INDEX_PRIMARY].Node_Number);
+		}
+		else
+		{
+			IMRD_LM_LOG_ERROR_0( "Can't load Msg and Field !");
+			StatusTmp = SDM_Close_RootCnv();
+		}
+
+	}
+	else
+	{
+	    IMRD_LM_LOG_ERROR_0( "Can't load Cnv !");
+	}
+
+	return(status);
+
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status SDM_SQL_Load_Cnv(NDT_Root **myRootCnv_Ptr_Ptr)
+{
+  const char sFunctionName []="SDM_SQL_Load_Cnv";
+  NDT_Status    nd_status;
+  IMRT_Status   status;
+  NDT_Index_Type  *index_type_ptr;
+  IMRT_Cnv  *myCnv_Ptr;
+  IMRT_Data_Version   *Data_Version_Ptr;
+
+  EXEC SQL BEGIN DECLARE SECTION;
+      IMRT_Cnv_Id   hCnvId;
+      VARCHAR       vCnvName[IMRD_CNV_NAME_SIZE];
+      short         hIndCnvId;
+      short         hIndCnvName;
+  EXEC SQL END DECLARE SECTION;
+
+  /*initialisation des indexes*/
+  index_type_ptr = Cnv_Struct_initial_idx_tab;
+
+  Data_Version_Ptr = (IMRT_Data_Version *) malloc(sizeof(IMRT_Data_Version));
+  status = SDM_SQL_Set_Struct_Version(Data_Version_Ptr, "Cnv");
+  if (status != IMRS_OK)
+  {
+  	return(IMRS_KO);
+  }
+
+  nd_status = ND_DataStruct_Open(myRootCnv_Ptr_Ptr, IMRD_SDMD_CNV_STRUCT_IDX_NB,index_type_ptr, "SDM_Cnv_Manager",SDM_Cnv_Manager, NULL, NULL, NULL, NULL,0, Data_Version_Ptr);
+  if(nd_status != NDS_OK)
+  {
+    IMRD_LM_LOG_ERROR_2( "%s : ND_DataStruct_Open  -- SDM_Cnv_Manager failed (%d) !", sFunctionName, nd_status);
+    status = IMRS_KO;
+  }
+  else
+  {
+    EXEC SQL DECLARE cur_imr_cnv_hdr CURSOR FOR
+    	SELECT CNV_ID, CNV_NAME
+    	FROM   IMR_CNV;
+
+    EXEC SQL OPEN cur_imr_cnv_hdr;
+    do
+    {
+      memset(vCnvName.arr, '\0', (size_t) IMRD_CNV_NAME_SIZE);
+
+      EXEC SQL FETCH cur_imr_cnv_hdr
+	  		INTO :hCnvId:hIndCnvId,
+      	         :vCnvName:hIndCnvName;
+      
+      if (sqlca.sqlcode == 0) 
+      {
+      	/* création d'un nouvelle objet CNV */
+        nd_status = ND_Value_Alloc( *myRootCnv_Ptr_Ptr, (void  **)&(myCnv_Ptr));
+        if(nd_status != NDS_OK)
+        {
+          IMRD_LM_LOG_ERROR_2( "%s : ND_Value_Alloc -- SDM_Cnv_Manager  failed (%d) !", sFunctionName, nd_status);
+          status = IMRS_KO;
+        }
+        else
+        {
+          /* Ajout de l'objet CNV */
+          myCnv_Ptr->Id = hCnvId;
+          strcpy(myCnv_Ptr->Name, (char *) vCnvName.arr); 
+
+          nd_status = ND_DataStruct_Value_Add( *myRootCnv_Ptr_Ptr, (void  *)(myCnv_Ptr));
+          if(nd_status != NDS_OK)
+          {
+            IMRD_LM_LOG_ERROR_2( "%s : ND_DataStruct_Value_Add -- SDM_Cnv_Manager  failed (%d) !", sFunctionName, nd_status);
+            status = IMRS_KO;
+          }
+        }
+      }
+    } while((sqlca.sqlcode == 0)&&(nd_status == NDS_OK)&&(status == IMRS_OK));
+
+    if (sqlca.sqlcode < 0)
+    {
+      IMRD_LM_LOG_ERROR_3( "Erreur %s. Erreur Oracle : %d - %s !", sFunctionName, sqlca.sqlcode, sqlca.sqlerrm.sqlerrmc);
+      status = IMRS_KO;
+    }
+
+    EXEC SQL CLOSE cur_imr_cnv_hdr;
+
+    if(status == IMRS_OK)
+    {
+      index_type_ptr = Cnv_Struct_final_idx_tab;
+      status = SDM_DataStruct_Finalize(*myRootCnv_Ptr_Ptr, index_type_ptr, IMRD_SDMD_CNV_STRUCT_IDX_NB);
+      /*SDM_DataStruct_Dump(*myRootCnv_Ptr_Ptr);*/
+    }
+    else
+    {
+      nd_status = ND_DataStruct_Close(*myRootCnv_Ptr_Ptr);
+      if(nd_status != NDS_OK)
+      {
+        IMRD_LM_LOG_ERROR_1( "ND_DataStruct_Close() failed (%d) !", nd_status);
+      }
+    }
+
+  }
+  return(status);  
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status SDM_SQL_Load_MsgAndField(NDT_Root **myRootMessage_Ptr_Ptr)
+{
+  const char sFunctionName []="SDM_SQL_Load_MsgAndField";
+  NDT_Status    nd_status;
+  IMRT_Status   status;
+  NDT_Index_Type  *index_type_ptr;
+  IMRT_Msg  *myMsg_Ptr;
+  IMRT_Data_Version   *Data_Version_Ptr;
+
+  EXEC SQL BEGIN DECLARE SECTION;
+      IMRT_Msg_Id hMsgId;
+      VARCHAR vMsgName[IMRD_NAME_SIZE];
+      short   hMsgSize;
+      short   hIndMsgId;
+      short   hIndMsgName;
+      short   hIndMsgSize;
+  EXEC SQL END DECLARE SECTION;
+
+  /*initialisation des indexes*/
+  index_type_ptr = Msg_Struct_initial_idx_tab;
+
+  Data_Version_Ptr = (IMRT_Data_Version *) malloc(sizeof(IMRT_Data_Version));
+  status = SDM_SQL_Set_Struct_Version(Data_Version_Ptr, "Msg-Field");
+  if (status != IMRS_OK)
+  {
+  	return(IMRS_KO);
+  }
+
+  nd_status = ND_DataStruct_Open(myRootMessage_Ptr_Ptr, IMRD_SDMD_MSG_STRUCT_IDX_NB, index_type_ptr, "SDM_Msg_Manager",SDM_Msg_Manager, NULL, NULL, NULL, NULL,0, Data_Version_Ptr);
+  if (nd_status != NDS_OK)
+  {
+      IMRD_LM_LOG_ERROR_2( "%s : ND_DataStruct_Open  -- SDM_Msg_Manager failed (%d) !", sFunctionName, nd_status);
+      status = IMRS_KO;
+  }
+  else
+  {
+    EXEC SQL DECLARE cur_imr_msg CURSOR FOR
+    	SELECT MSG_ID, MSG_NAME, MSG_SIZE
+    	FROM  IMR_MSG;
+
+    EXEC SQL OPEN cur_imr_msg;
+    do
+    {
+      memset(vMsgName.arr, '\0', (size_t) IMRD_NAME_SIZE);
+      EXEC SQL FETCH cur_imr_msg 
+      		INTO :hMsgId:hIndMsgId,
+      		     :vMsgName:hIndMsgName,
+      		     :hMsgSize:hIndMsgSize;
+      if (sqlca.sqlcode == 0) 
+      {
+        nd_status = ND_Value_Alloc( *myRootMessage_Ptr_Ptr, (void  **)&(myMsg_Ptr));
+        if (nd_status != NDS_OK)
+        {
+          IMRD_LM_LOG_ERROR_2( "%s : ND_Value_Alloc  -- SDM_Msg_Manager failed (%d) !", sFunctionName, nd_status);
+          status = IMRS_KO;
+        }
+        else
+        {
+          myMsg_Ptr->Id = hMsgId;
+          if (hIndMsgName >= 0)
+            strcpy(myMsg_Ptr->Name, (char *) vMsgName.arr);
+          if (hIndMsgSize >= 0)
+            myMsg_Ptr->Size = hMsgSize; 
+
+          status = SDM_SQL_LoadFieldMsg(myMsg_Ptr);
+          if (status == IMRS_OK)
+          {
+            /* Ajout du message */
+            nd_status = ND_DataStruct_Value_Add( *myRootMessage_Ptr_Ptr, (void  *)(myMsg_Ptr));
+            if (nd_status != NDS_OK)
+            {
+              IMRD_LM_LOG_ERROR_2( "%s : ND_DataStruct_Value_Add  -- SDM_Msg_Manager failed (%d) !", sFunctionName, nd_status);
+              status = IMRS_KO;
+            }
+          }
+        }
+      }
+    } while((sqlca.sqlcode == 0)&&(nd_status == NDS_OK)&&(status == IMRS_OK));
+
+    if (sqlca.sqlcode < 0)
+    {
+      IMRD_LM_LOG_ERROR_3( "Erreur %s. Erreur Oracle : %d - %s !", sFunctionName, sqlca.sqlcode, sqlca.sqlerrm.sqlerrmc);
+      status = IMRS_KO;
+    }
+
+    EXEC SQL CLOSE cur_imr_msg;
+
+    if(status == IMRS_OK)
+    {
+      index_type_ptr = Msg_Struct_final_idx_tab;
+      status = SDM_DataStruct_Finalize(*myRootMessage_Ptr_Ptr, index_type_ptr, IMRD_SDMD_MSG_STRUCT_IDX_NB);
+      /*SDM_DataStruct_Dump( *myRootMessage_Ptr_Ptr);*/
+    }
+    else
+    {
+      if(myMsg_Ptr->Field_Struct_Ptr != NULL)
+	  {
+        nd_status = ND_DataStruct_Close(myMsg_Ptr->Field_Struct_Ptr);
+        if(nd_status != NDS_OK)
+        {
+          IMRD_LM_LOG_ERROR_1( "ND_DataStruct_Close() failed (%d) !", nd_status);
+        }
+      }
+
+      nd_status = ND_DataStruct_Close(*myRootMessage_Ptr_Ptr);
+      if(nd_status != NDS_OK)
+      {
+        IMRD_LM_LOG_ERROR_1( "ND_DataStruct_Close() failed (%d) !", nd_status);
+      }
+    }
+  }
+  
+  return(status);
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status SDM_SQL_LoadFieldMsg(IMRT_Msg  *myMsg_Ptr)
+{
+  const char sFunctionName []="SDM_SQL_LoadFieldMsg";
+  NDT_Status    nd_status;
+  IMRT_Status   status;
+  IMRT_Field   *myField_Ptr;
+  NDT_Node     *node_ptr;
+  IMRT_Cnv      myCnv;
+
+  EXEC SQL BEGIN DECLARE SECTION;
+     IMRT_Field_Id hFieldId;
+     VARCHAR      vFieldName[IMRD_NAME_SIZE];
+     VARCHAR      vFieldValueid[IMRD_VALUE_ID_SIZE];
+     VARCHAR      vFieldExist[IMRD_EXIST_SIZE];
+     long         hFieldFixedOffset;
+     long         hFieldFixedSize;
+     VARCHAR      vFieldFixedDefVal[IMRD_VALUE_SIZE];
+     IMRT_Cnv_Id  hFieldFixedCnvId;
+     VARCHAR      vFieldFixedCnvAttr[IMRD_CNV_ATTR_SIZE];
+     VARCHAR      vFieldFmlTag[IMRD_FML_TAG_SIZE];
+     VARCHAR      vFieldFmlDefVal[IMRD_VALUE_SIZE];
+     IMRT_Cnv_Id  hFieldFmlCnvId;
+     VARCHAR      vFieldFmlCnvAttr[IMRD_CNV_ATTR_SIZE];
+     VARCHAR      vFieldXmlTag[IMRD_XML_TAG_SIZE];
+     VARCHAR      vFieldXmlDefVal[IMRD_VALUE_SIZE];
+     IMRT_Cnv_Id  hFieldXmlCnvId;
+     VARCHAR      vFieldXmlCnvAttr[IMRD_CNV_ATTR_SIZE];
+     VARCHAR      vFieldTaggedTag[IMRD_TAGGED_TAG_SIZE];
+     VARCHAR      vFieldTaggedDefVal[IMRD_VALUE_SIZE];
+     IMRT_Cnv_Id  hFieldTaggedCnvId;
+     VARCHAR      vFieldTaggedCnvAttr[IMRD_CNV_ATTR_SIZE];
+     VARCHAR      vFieldInternalTag[IMRD_INTERNAL_TAG_SIZE];
+     VARCHAR      vFieldInternalDefVal[IMRD_VALUE_SIZE];
+     IMRT_Cnv_Id  hFieldInternalCnvId;
+     VARCHAR      vFieldInternalCnvAttr[IMRD_CNV_ATTR_SIZE];
+     IMRT_Delimited_Id hFieldDelimitedId;
+     VARCHAR      vFieldDelimitedDefVal[IMRD_VALUE_SIZE];
+     IMRT_Cnv_Id  hFieldDelimitedCnvId;
+     VARCHAR      vFieldDelimitedCnvAttr[IMRD_CNV_ATTR_SIZE];
+
+     short   hIndFieldId;
+     short   hIndFieldName;
+     short   hIndFieldValueid;
+     short   hIndFieldExist;
+     short   hIndFieldFixedOffset;
+     short   hIndFieldFixedSize;
+     short   hIndFieldFixedDefVal;
+     short   hIndFieldFixedCnvId;
+     short   hIndFieldFixedCnvAttr;
+     short   hIndFieldFmlTag;
+     short   hIndFieldFmlDefVal;
+     short   hIndFieldFmlCnvId;
+     short   hIndFieldFmlCnvAttr;
+     short   hIndFieldXmlTag;
+     short   hIndFieldXmlDefVal;
+     short   hIndFieldXmlCnvId;
+     short   hIndFieldXmlCnvAttr;
+     short   hIndFieldTaggedTag;
+     short   hIndFieldTaggedDefVal;
+     short   hIndFieldTaggedCnvId;
+     short   hIndFieldTaggedCnvAttr;
+     short   hIndFieldInternalTag;
+     short   hIndFieldInternalDefVal;
+     short   hIndFieldInternalCnvId;
+     short   hIndFieldInternalCnvAttr;
+     short   hIndFieldDelimitedId;
+     short   hIndFieldDelimitedDefVal;
+     short   hIndFieldDelimitedCnvId;
+     short   hIndFieldDelimitedCnvAttr;
+  EXEC SQL END DECLARE SECTION;
+
+  status = IMRS_OK;
+
+  EXEC SQL DECLARE cur_imr_field CURSOR FOR
+  	SELECT IMR_FIELD.FIELD_ID, 
+		   IMR_FIELD.FIELD_NAME, 
+    	   IMR_FIELD.FIELD_VALUEID,
+    	   IMR_FIELD.FIELD_EXIST,
+    	   IMR_FIXEDFIELD.FIXED_FIELD_OFFSET,
+    	   IMR_FIXEDFIELD.FIXED_FIELD_SIZE,
+    	   IMR_FIXEDFIELD.FIXED_FIELD_CNV_ID,
+    	   IMR_FIXEDFIELD.FIXED_FIELD_CNV_ATTR,
+    	   IMR_FIXEDFIELD.FIXED_FIELD_DEF_VAL,
+    	   IMR_FMLFIELD.FML_FIELD_TAG,
+    	   IMR_FMLFIELD.FML_FIELD_CNV_ID,
+    	   IMR_FMLFIELD.FML_FIELD_CNV_ATTR,
+    	   IMR_FMLFIELD.FML_FIELD_DEF_VAL,
+    	   IMR_XMLFIELD.XML_FIELD_TAG,
+    	   IMR_XMLFIELD.XML_FIELD_CNV_ID,
+    	   IMR_XMLFIELD.XML_FIELD_CNV_ATTR,
+    	   IMR_XMLFIELD.XML_FIELD_DEF_VAL,
+    	   IMR_TAGGEDFIELD.TAGGED_FIELD_TAG,
+    	   IMR_TAGGEDFIELD.TAGGED_FIELD_CNV_ID,
+    	   IMR_TAGGEDFIELD.TAGGED_FIELD_CNV_ATTR,
+    	   IMR_TAGGEDFIELD.TAGGED_FIELD_DEF_VAL,
+    	   IMR_INTERNALFIELD.INTERNAL_FIELD_TAG,
+    	   IMR_INTERNALFIELD.INTERNAL_FIELD_CNV_ID,
+    	   IMR_INTERNALFIELD.INTERNAL_FIELD_CNV_ATTR,
+    	   IMR_INTERNALFIELD.INTERNAL_FIELD_DEF_VAL,
+    	   IMR_DELIMITEDFIELD.DELIMITED_FIELD_ID,
+    	   IMR_DELIMITEDFIELD.DELIMITED_FIELD_CNV_ID,
+    	   IMR_DELIMITEDFIELD.DELIMITED_FIELD_CNV_ATTR,
+    	   IMR_DELIMITEDFIELD.DELIMITED_FIELD_DEF_VAL
+    FROM IMR_FIELD, IMR_FIXEDFIELD, IMR_FMLFIELD, IMR_XMLFIELD,
+    	 IMR_TAGGEDFIELD, IMR_INTERNALFIELD, IMR_DELIMITEDFIELD
+    WHERE  IMR_FIELD.FIELD_ID = IMR_FIXEDFIELD.FIELD_ID(+) 
+	AND    IMR_FIELD.FIELD_ID = IMR_FMLFIELD.FIELD_ID(+) 
+	AND    IMR_FIELD.FIELD_ID = IMR_XMLFIELD.FIELD_ID(+) 
+	AND    IMR_FIELD.FIELD_ID = IMR_TAGGEDFIELD.FIELD_ID(+) 
+	AND    IMR_FIELD.FIELD_ID = IMR_INTERNALFIELD.FIELD_ID(+) 
+	AND    IMR_FIELD.FIELD_ID = IMR_DELIMITEDFIELD.FIELD_ID(+) 
+    AND    IMR_FIELD.MSG_ID = :myMsg_Ptr->Id;
+
+  EXEC SQL OPEN cur_imr_field;
+  do
+  {
+    memset(vFieldName.arr, '\0', (size_t) IMRD_NAME_SIZE);
+    memset(vFieldValueid.arr, '\0', (size_t) IMRD_VALUE_ID_SIZE);
+    memset(vFieldExist.arr, '\0', (size_t) IMRD_EXIST_SIZE);
+    memset(vFieldFixedDefVal.arr, '\0', (size_t) IMRD_VALUE_SIZE);
+    memset(vFieldFixedCnvAttr.arr, '\0', (size_t) IMRD_CNV_ATTR_SIZE);
+    memset(vFieldFmlTag.arr, '\0', (size_t) IMRD_FML_TAG_SIZE);
+    memset(vFieldFmlDefVal.arr, '\0', (size_t) IMRD_VALUE_SIZE);
+    memset(vFieldFmlCnvAttr.arr, '\0', (size_t) IMRD_CNV_ATTR_SIZE);
+    memset(vFieldXmlTag.arr, '\0', (size_t) IMRD_XML_TAG_SIZE);
+    memset(vFieldXmlDefVal.arr, '\0', (size_t) IMRD_VALUE_SIZE);
+    memset(vFieldXmlCnvAttr.arr, '\0', (size_t) IMRD_CNV_ATTR_SIZE);
+    memset(vFieldTaggedTag.arr, '\0', (size_t) IMRD_TAGGED_TAG_SIZE);
+    memset(vFieldTaggedDefVal.arr, '\0', (size_t) IMRD_VALUE_SIZE);
+    memset(vFieldTaggedCnvAttr.arr, '\0', (size_t) IMRD_CNV_ATTR_SIZE);
+    memset(vFieldInternalTag.arr, '\0', (size_t) IMRD_INTERNAL_TAG_SIZE);
+    memset(vFieldInternalDefVal.arr, '\0', (size_t) IMRD_VALUE_SIZE);
+    memset(vFieldInternalCnvAttr.arr, '\0', (size_t) IMRD_CNV_ATTR_SIZE);
+    memset(vFieldDelimitedDefVal.arr, '\0', (size_t) IMRD_VALUE_SIZE);
+    memset(vFieldDelimitedCnvAttr.arr, '\0', (size_t) IMRD_CNV_ATTR_SIZE);
+
+    EXEC SQL FETCH cur_imr_field 
+    		INTO :hFieldId:hIndFieldId,
+    			 :vFieldName:hIndFieldName,
+    		     :vFieldValueid:hIndFieldValueid, 
+    		     :vFieldExist:hIndFieldExist, 
+    		     :hFieldFixedOffset:hIndFieldFixedOffset,
+    		     :hFieldFixedSize:hIndFieldFixedSize,
+    		     :hFieldFixedCnvId:hIndFieldFixedCnvId,
+    		     :vFieldFixedCnvAttr:hIndFieldFixedCnvAttr,
+    		     :vFieldFixedDefVal:hIndFieldFixedDefVal,
+    		     :vFieldFmlTag:hIndFieldFmlTag,
+    		     :hFieldFmlCnvId:hIndFieldFmlCnvId,
+    		     :vFieldFmlCnvAttr:hIndFieldFmlCnvAttr,
+    		     :vFieldFmlDefVal:hIndFieldFmlDefVal,
+    		     :vFieldXmlTag:hIndFieldXmlTag,
+    		     :hFieldXmlCnvId:hIndFieldXmlCnvId,
+    		     :vFieldXmlCnvAttr:hIndFieldXmlCnvAttr,
+    		     :vFieldXmlDefVal:hIndFieldXmlDefVal,
+    		     :vFieldTaggedTag:hIndFieldTaggedTag,
+    		     :hFieldTaggedCnvId:hIndFieldTaggedCnvId,
+    		     :vFieldTaggedCnvAttr:hIndFieldTaggedCnvAttr,
+    		     :vFieldTaggedDefVal:hIndFieldTaggedDefVal,
+    		     :vFieldInternalTag:hIndFieldInternalTag,
+    		     :hFieldInternalCnvId:hIndFieldInternalCnvId,
+    		     :vFieldInternalCnvAttr:hIndFieldInternalCnvAttr,
+    		     :vFieldInternalDefVal:hIndFieldInternalDefVal,
+    		     :hFieldDelimitedId:hIndFieldDelimitedId,
+    		     :hFieldDelimitedCnvId:hIndFieldDelimitedCnvId,
+    		     :vFieldDelimitedCnvAttr:hIndFieldDelimitedCnvAttr,
+    		     :vFieldDelimitedDefVal:hIndFieldDelimitedDefVal;
+
+    if (sqlca.sqlcode == 0) 
+    {
+      /* Allacation de ListField */
+      nd_status = ND_Value_Alloc( myMsg_Ptr->Field_Struct_Ptr, (void  **)&(myField_Ptr)); 
+      if (nd_status != NDS_OK)
+      {
+		IMRD_LM_LOG_ERROR_2( "%s : ND_Value_Alloc  -- Field failed (%d) !", sFunctionName, nd_status);
+		status = IMRS_KO;
+      }
+      else
+      {
+        /* Ajout du Field */
+        myField_Ptr->Id = hFieldId;
+        strcpy(myField_Ptr->Name, (char *) vFieldName.arr);
+        if (hIndFieldValueid >= 0)
+          strcpy(myField_Ptr->Value_Id, (char *) vFieldValueid.arr);
+        if (hIndFieldExist >= 0)
+        {
+          if(vFieldExist.arr[0] == IMRD_YES)
+          {
+          	myField_Ptr->Exist = IMRD_TRUE;
+          }
+          else
+          {
+          	myField_Ptr->Exist = IMRD_FALSE;
+          }
+        }
+
+        if (hIndFieldFixedOffset >= 0)
+          myField_Ptr->Fixed.Offset = hFieldFixedOffset; 
+        if (hIndFieldFixedSize >= 0)
+          myField_Ptr->Fixed.Size = hFieldFixedSize; 
+        if (hIndFieldFixedDefVal >= 0)
+          strcpy(myField_Ptr->Fixed.Def_Val, (char *) vFieldFixedDefVal.arr); 
+        if (hIndFieldFixedCnvId >= 0)
+        {
+           myCnv.Id = hFieldFixedCnvId;
+	       if(((nd_status = ND_Index_Node_Find( &node_ptr, IMRG_SDM_Base.RootCnv,
+			  	               IMRD_SDMD_CNV_IDX_ID, &myCnv, NULL)) != NDS_OK)||
+				(node_ptr == NULL))
+	       {
+			 IMRD_LM_LOG_ERROR_1( "Erreur lors de la recherche de Cnv <%d> !", myCnv.Id);
+			 status = IMRS_KO;
+	       }
+  	  	   else
+  	  	   {
+  	  		 myField_Ptr->Fixed.Cnv_Ptr = node_ptr->Value;
+  	  	   }
+		}
+
+        if (hIndFieldFixedCnvAttr >= 0)
+          strcpy(myField_Ptr->Fixed.Cnv_Attr, (char *) vFieldFixedCnvAttr.arr);
+
+        if (hIndFieldFmlTag >= 0)
+          strcpy(myField_Ptr->FML.Tag, (char *) vFieldFmlTag.arr);
+        if (hIndFieldFmlDefVal >= 0)
+          strcpy(myField_Ptr->FML.Def_Val, (char *) vFieldFmlDefVal.arr); 
+        if (hIndFieldFmlCnvId >= 0)
+        {
+           myCnv.Id = hFieldFmlCnvId;
+	       if(((nd_status = ND_Index_Node_Find( &node_ptr, IMRG_SDM_Base.RootCnv,
+			  	               IMRD_SDMD_CNV_IDX_ID, &myCnv, NULL)) != NDS_OK)||
+				(node_ptr == NULL))
+	       {
+			 IMRD_LM_LOG_ERROR_1( "Erreur lors de la recherche de Cnv <%d> !", myCnv.Id);
+			 status = IMRS_KO;
+	       }
+  	  	   else
+  	  	   {
+  	  		 myField_Ptr->FML.Cnv_Ptr = node_ptr->Value;
+  	  	   }
+		}
+        if (hIndFieldFmlCnvAttr >= 0)
+          strcpy(myField_Ptr->FML.Cnv_Attr, (char *) vFieldFmlCnvAttr.arr);
+
+        if (hIndFieldXmlTag >= 0)
+          strcpy(myField_Ptr->XML.Tag, (char *) vFieldXmlTag.arr);
+        if (hIndFieldXmlDefVal >= 0)
+          strcpy(myField_Ptr->XML.Def_Val, (char *) vFieldXmlDefVal.arr); 
+        if (hIndFieldXmlCnvId >= 0)
+        {
+           myCnv.Id = hFieldXmlCnvId;
+	       if(((nd_status = ND_Index_Node_Find( &node_ptr, IMRG_SDM_Base.RootCnv,
+			  	               IMRD_SDMD_CNV_IDX_ID, &myCnv, NULL)) != NDS_OK)||
+				(node_ptr == NULL))
+	       {
+			 IMRD_LM_LOG_ERROR_1( "Erreur lors de la recherche de Cnv <%d> !", myCnv.Id);
+			 status = IMRS_KO;
+	       }
+  	  	   else
+  	  	   {
+  	  		 myField_Ptr->XML.Cnv_Ptr = node_ptr->Value;
+  	  	   }
+		}
+        if (hIndFieldXmlCnvAttr >= 0)
+          strcpy(myField_Ptr->XML.Cnv_Attr, (char *) vFieldXmlCnvAttr.arr);
+
+        if (hIndFieldTaggedTag >= 0)
+          strcpy(myField_Ptr->Tagged.Tag, (char *) vFieldTaggedTag.arr);
+        if (hIndFieldTaggedDefVal >= 0)
+          strcpy(myField_Ptr->Tagged.Def_Val, (char *) vFieldTaggedDefVal.arr); 
+        if (hIndFieldTaggedCnvId >= 0)
+        {
+           myCnv.Id = hFieldTaggedCnvId;
+	       if(((nd_status = ND_Index_Node_Find( &node_ptr, IMRG_SDM_Base.RootCnv,
+			  	               IMRD_SDMD_CNV_IDX_ID, &myCnv, NULL)) != NDS_OK)||
+				(node_ptr == NULL))
+	       {
+			 IMRD_LM_LOG_ERROR_1( "Erreur lors de la recherche de Cnv <%d> !", myCnv.Id);
+			 status = IMRS_KO;
+	       }
+  	  	   else
+  	  	   {
+  	  		 myField_Ptr->Tagged.Cnv_Ptr = node_ptr->Value;
+  	  	   }
+		}
+        if (hIndFieldTaggedCnvAttr >= 0)
+          strcpy(myField_Ptr->Tagged.Cnv_Attr, (char *) vFieldTaggedCnvAttr.arr);
+
+        if (hIndFieldInternalTag >= 0)
+          strcpy(myField_Ptr->Internal.Tag, (char *) vFieldInternalTag.arr);
+        if (hIndFieldInternalDefVal >= 0)
+          strcpy(myField_Ptr->Internal.Def_Val, (char *) vFieldInternalDefVal.arr); 
+        if (hIndFieldInternalCnvId >= 0)
+        {
+           myCnv.Id = hFieldInternalCnvId;
+	       if(((nd_status = ND_Index_Node_Find( &node_ptr, IMRG_SDM_Base.RootCnv,
+			  	               IMRD_SDMD_CNV_IDX_ID, &myCnv, NULL)) != NDS_OK)||
+				(node_ptr == NULL))
+	       {
+			 IMRD_LM_LOG_ERROR_1( "Erreur lors de la recherche de Cnv <%d> !", myCnv.Id);
+			 status = IMRS_KO;
+	       }
+  	  	   else
+  	  	   {
+  	  		 myField_Ptr->Internal.Cnv_Ptr = node_ptr->Value;
+  	  	   }
+		}
+        if (hIndFieldInternalCnvAttr >= 0)
+          strcpy(myField_Ptr->Internal.Cnv_Attr, (char *) vFieldInternalCnvAttr.arr);
+
+        if (hIndFieldDelimitedId >= 0)
+          myField_Ptr->Delimited.Id = hFieldDelimitedId;
+        if (hIndFieldDelimitedDefVal >= 0)
+          strcpy(myField_Ptr->Delimited.Def_Val, (char *) vFieldDelimitedDefVal.arr); 
+        if (hIndFieldDelimitedCnvId >= 0)
+        {
+           myCnv.Id = hFieldDelimitedCnvId;
+	       if(((nd_status = ND_Index_Node_Find( &node_ptr, IMRG_SDM_Base.RootCnv,
+			  	               IMRD_SDMD_CNV_IDX_ID, &myCnv, NULL)) != NDS_OK)||
+				(node_ptr == NULL))
+	       {
+			 IMRD_LM_LOG_ERROR_1( "Erreur lors de la recherche de Cnv <%d> !", myCnv.Id);
+			 status = IMRS_KO;
+	       }
+  	  	   else
+  	  	   {
+  	  		 myField_Ptr->Delimited.Cnv_Ptr = node_ptr->Value;
+  	  	   }
+		}
+        if (hIndFieldDelimitedCnvAttr >= 0)
+          strcpy(myField_Ptr->Delimited.Cnv_Attr, (char *) vFieldDelimitedCnvAttr.arr);
+
+        nd_status = ND_DataStruct_Value_Add( myMsg_Ptr->Field_Struct_Ptr, (void  *)(myField_Ptr)); 
+        if (nd_status != NDS_OK)
+        {
+          IMRD_LM_LOG_ERROR_2( "%s : ND_DataStruct_Value_Add  -- Field failed (%d) !", sFunctionName, nd_status);
+          status = IMRS_KO;
+        }
+      }
+    }
+  } while((sqlca.sqlcode == 0)&&(nd_status == NDS_OK)&&(status == IMRS_OK));
+
+  if(status != IMRS_OK)
+  {
+    free(myField_Ptr);
+  }
+
+  if (sqlca.sqlcode < 0)
+  {
+    IMRD_LM_LOG_ERROR_3( "Erreur %s. Erreur Oracle : %d - %s !", sFunctionName, sqlca.sqlcode, sqlca.sqlerrm.sqlerrmc);
+    status = IMRS_KO;
+  }
+
+  EXEC SQL CLOSE cur_imr_field;
+
+  return(status);  
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  SDM_SQL_Dump_Msg_Header(FILE *dump_file)
+{
+	fprintf(dump_file, "---------------------------------------------------------\n");
+	fprintf(dump_file, "--  Init file of IMR_MSG & IMR_FIELD & IMR_FMLFIELD    --\n");
+	fprintf(dump_file, "--               IMR_XMLFIELD & IMR_DELIMITEDFIELD     --\n");
+	fprintf(dump_file, "--               IMR_FIXEDFIELD & IMR_TAGGEDFIELD      --\n");
+	fprintf(dump_file, "--               IMR_INTERNALFIELD                     --\n");
+	fprintf(dump_file, "---------------------------------------------------------\n\n");
+	fprintf(dump_file, "INSERT INTO IMR_DATA_VERSION(VERS_NAME, VERS_LABEL, VERS_DATE) VALUES('Msg-Field', '%s', '%s');\n\n",
+						((IMRT_Data_Version *)IMRG_SDM_Base.RootMsg->User_Ptr)->Label, 
+						((IMRT_Data_Version *)IMRG_SDM_Base.RootMsg->User_Ptr)->Date);
+	fprintf(dump_file, "Delete IMR_INTERNALFIELD;\n\n");
+	fprintf(dump_file, "Delete IMR_TAGGEDFIELD;\n\n");
+	fprintf(dump_file, "Delete IMR_FIXEDFIELD;\n\n");
+	fprintf(dump_file, "Delete IMR_DELIMITEDFIELD;\n\n");
+	fprintf(dump_file, "Delete IMR_XMLFIELD;\n\n");
+	fprintf(dump_file, "Delete IMR_FMLFIELD;\n\n");
+	fprintf(dump_file, "Delete IMR_FIELD;\n\n");
+	fprintf(dump_file, "Delete IMR_MSG;\n\n");
+	return( IMRS_OK);
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  SDM_SQL_Dump_Msg_Body(FILE *dump_file)
+{
+	IMRT_Status  status;
+	NDT_Status  nd_status;
+
+	if( ( nd_status = ND_DataStruct_Traverse( IMRG_SDM_Base.RootMsg, IMRD_SDMD_CMD_API_SQL_DUMP, dump_file)) != NDS_OK)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0( "SQL Dump RootMsg failed !");
+	}
+	else
+	{
+		status = IMRS_OK;
+	}
+
+	return(status);
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  SDM_SQL_Dump_Msg_Footer(FILE *dump_file)
+{
+	fprintf(dump_file, "\nCommit;\n");
+	return( IMRS_OK);
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  SDM_SQL_Dump_Msg(void)
+{
+	IMRT_Status     status;
+	char	    dump_filename[255];
+	FILE	   *dump_file;
+
+	strcpy(dump_filename, "init_imr_msg.sql");
+
+	if( ( dump_file = fopen( dump_filename, "w")) == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_1( "Can't open dump file (%s) !", dump_filename);
+	}
+	else
+	{
+		status = SDM_SQL_Dump_Msg_Header(dump_file);
+		if(status == IMRS_OK)
+		{
+			status = SDM_SQL_Dump_Msg_Body(dump_file);
+			if(status == IMRS_OK)
+			{
+				status = SDM_SQL_Dump_Msg_Footer(dump_file);
+			}
+		}
+
+		fclose( dump_file);
+	}
+
+	return(status);
+
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  SDM_SQL_Dump_Cnv_Header(FILE *dump_file)
+{
+	fprintf(dump_file, "---------------------------------------------------\n");
+	fprintf(dump_file, "--  Init file of IMR_CNV                         --\n");
+	fprintf(dump_file, "---------------------------------------------------\n\n");
+	fprintf(dump_file, "INSERT INTO IMR_DATA_VERSION(VERS_NAME, VERS_LABEL, VERS_DATE) VALUES('Cnv', '%s', '%s');\n\n",
+						((IMRT_Data_Version *)IMRG_SDM_Base.RootCnv->User_Ptr)->Label, 
+						((IMRT_Data_Version *)IMRG_SDM_Base.RootCnv->User_Ptr)->Date);
+	fprintf(dump_file, "Delete IMR_CNV;\n\n");
+	return( IMRS_OK);
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  SDM_SQL_Dump_Cnv_Body(FILE *dump_file)
+{
+	IMRT_Status  status;
+	NDT_Status  nd_status;
+
+	if( ( nd_status = ND_DataStruct_Traverse( IMRG_SDM_Base.RootCnv, IMRD_SDMD_CMD_API_SQL_DUMP, dump_file)) != NDS_OK)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_0( "SQL Dump RootCnv failed !");
+	}
+	else
+	{
+		status = IMRS_OK;
+	}
+
+	return(status);
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  SDM_SQL_Dump_Cnv_Footer(FILE *dump_file)
+{
+	fprintf(dump_file, "\nCommit;\n");
+	return( IMRS_OK);
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  SDM_SQL_Dump_Cnv(void)
+{
+	IMRT_Status     status;
+	char	    dump_filename[255];
+	FILE	   *dump_file;
+
+	strcpy(dump_filename, "init_imr_cnv.sql");
+
+	if( ( dump_file = fopen( dump_filename, "w")) == NULL)
+	{
+		status = IMRS_KO;
+		IMRD_LM_LOG_ERROR_1( "Can't open dump file (%s) !", dump_filename);
+	}
+	else
+	{
+		status = SDM_SQL_Dump_Cnv_Header(dump_file);
+		if(status == IMRS_OK)
+		{
+			status = SDM_SQL_Dump_Cnv_Body(dump_file);
+			if(status == IMRS_OK)
+			{
+				status = SDM_SQL_Dump_Cnv_Footer(dump_file);
+			}
+		}
+
+		fclose( dump_file);
+	}
+
+	return(status);
+
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  SDM_SQL_StructInfo_Dump(void)
+{
+	IMRT_Status     status;
+
+	status = SDM_SQL_Dump_Cnv();
+	if(status == IMRS_OK)
+	{
+		status = SDM_SQL_Dump_Msg();
+	}
+
+	return(status);
+
+}
+
+/*----------------------------------------------------------------------------*/
+/*                                                                            */
+/*----------------------------------------------------------------------------*/
diff --git a/src/libstatic_data_mng/src/struct_info_xml.c b/src/libstatic_data_mng/src/struct_info_xml.c
new file mode 100644
index 0000000..7c4fb87
--- /dev/null
+++ b/src/libstatic_data_mng/src/struct_info_xml.c
@@ -0,0 +1,943 @@
+/*----------------------------------------------------------------------------*/
+/* File: struct_info_xml.c   		         		  	      */
+/*----------------------------------------------------------------------------*/
+/*                                                                            */
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#define _LIBSTATIC_DATA_MNG_
+#define _STRUCT_INFO_XML_C_
+
+#include "struct_info_xml.h"
+
+
+IMRT_Status SDM_XML_StructInfo_Init(IMRT_Path    Lib_Path)
+{
+    SDMT_StructInfo_Contexte StructInfo_Ctx;
+    IMRT_Status  status, StatusTmp;
+    char	     Xml_File_Name[255];
+
+    StructInfo_Ctx.flagerror = 0;
+    StructInfo_Ctx.CptCnv = IMRD_CNV_ID_UNKNOWN;
+
+
+
+    IMRD_LM_LOG_TRACE_0( IMRD_LOG_LEVEL_VERBOSE_0, "Loading Cnv...");
+
+    memset(Xml_File_Name,0,sizeof(Xml_File_Name));
+	strcpy(Xml_File_Name, Lib_Path);
+	strcat(Xml_File_Name, "/");
+	strcat(Xml_File_Name, SDMD_CNV_FILE);
+    status = SDM_XML_Load_Cnv((char *)Xml_File_Name, &(StructInfo_Ctx));
+    if(status != IMRS_OK)
+    {
+	IMRD_LM_LOG_ERROR_0( "Can't load Cnv !");
+    }
+    else
+    {
+    	IMRG_SDM_Base.RootCnv = StructInfo_Ctx.RootCnv;
+ 	
+ 		IMRD_LM_LOG_INFO_1( "Cnv loaded: (%d)", IMRG_SDM_Base.RootCnv->Index_Tab[NDD_INDEX_PRIMARY].Node_Number);
+
+	    StructInfo_Ctx.CptMsg = IMRD_MSG_ID_UNKNOWN;
+	    StructInfo_Ctx.CptField = IMRD_FIELD_ID_UNKNOWN;
+	    memset(StructInfo_Ctx.PathArray,0,sizeof(StructInfo_Ctx.PathArray));
+	    StructInfo_Ctx.PresentLevelTag = IMRD_SDMD_MIN_LEVEL_TAG;
+
+	    IMRD_LM_LOG_TRACE_0( IMRD_LOG_LEVEL_VERBOSE_0, "Loading Msg and Field...");
+
+	    memset(Xml_File_Name,0,sizeof(Xml_File_Name));
+		strcpy(Xml_File_Name, Lib_Path);
+		strcat(Xml_File_Name, "/");
+		strcat(Xml_File_Name, SDMD_MSGFIELD_FILE);
+
+	    status =  SDM_XML_Load_MsgAndField((char *)Xml_File_Name, &(StructInfo_Ctx));
+
+	    if(status != IMRS_OK)
+	    {
+		IMRD_LM_LOG_ERROR_0( "Can't load Msg and Field !");
+			StatusTmp = SDM_Close_RootCnv();
+	    }
+	    else
+	    {
+	    	IMRG_SDM_Base.RootMsg = StructInfo_Ctx.RootMessage;
+
+			IMRD_LM_LOG_INFO_1( "Msg and Field loaded: (%d)", IMRG_SDM_Base.RootMsg->Index_Tab[NDD_INDEX_PRIMARY].Node_Number);
+	    }
+	}
+
+    return(status);
+
+} 
+
+
+static IMRT_Status error(SDMT_StructInfo_Contexte *ctx , const char *msg, ...)
+{
+    xmlParserCtxt * SaxCtx;
+  
+    SaxCtx = ctx->SaxCtxHdl;
+  
+    IMRD_LM_LOG_ERROR_1( "CallBack error: <%s> !",msg);
+
+    SaxCtx->sax = &ErrorSAXHandlerStruct;
+    ctx->flagerror = 1;
+    ctx->FataError.errorCode = SDMD_XML_CODE_ERROR_1;
+    strcpy(ctx->FataError.libError,msg) ;
+}
+
+
+IMRT_Status startElementNsCnv( SDMT_StructInfo_Contexte * ctx , 
+			  const xmlChar *localname,
+			  const xmlChar *prefix,
+			  const xmlChar *URI,
+			  int nb_namespaces,
+			  const xmlChar **namespaces,
+			  int nb_attributes,
+			  int nb_defaulted,
+			  const xmlChar **attributes)
+{
+    NDT_Status  status;
+  
+    if(strcmp((const char*)localname,IMRD_SDMD_TAG_CNV) == 0)
+    {
+		/*création d'un nouvelle objet Cnv*/
+		if( ( status = ND_Value_Alloc( ctx->RootCnv, (void  **)&(ctx->CurrentCnv)) != NDS_OK))
+		{
+		    IMRD_LM_LOG_ERROR_1( "ND_Value_Alloc() failed (%d) !", status);
+		}
+    }
+
+}
+
+
+IMRT_Status startElementNS( SDMT_StructInfo_Contexte * ctx , 
+							       const xmlChar *localname,
+							       const xmlChar *prefix,
+							       const xmlChar *URI,
+							       int nb_namespaces,
+							       const xmlChar **namespaces,
+							       int nb_attributes,
+							       int nb_defaulted,
+							       const xmlChar **attributes)
+{
+   NDT_Status         status;
+   char DescErr[IMRD_SDMD_DESCERR_LEN];
+   const char fonctionname [] = "startElementNS";
+   
+   
+   if(strcmp((const char *)localname, IMRD_SDMD_TAG_MESSAGE) == 0)
+   {
+		/*création d'un objet msg*/
+		if( ( status = ND_Value_Alloc( ctx->RootMessage, (void  **)&(ctx->CurrentMessage))) != NDS_OK)
+		{
+		  snprintf(DescErr,sizeof(DescErr),SDMD_XML_LIB_ERROR_3,IMRD_SDMD_TAG_MESSAGE);
+		  SDM_RaiseError(ctx->SaxCtxHdl,&(ctx->FataError),&(ctx->flagerror), fonctionname , DescErr,SDMD_XML_CODE_ERROR_3);
+		}
+
+		ctx->PresentLevelTag = ctx->PresentLevelTag + 1;
+		strcpy(ctx->PathArray[ctx->PresentLevelTag], (char*)localname);
+   }
+   else if (strcmp((const char *)localname, IMRD_SDMD_TAG_FIELD) == 0)
+   {
+      if( ( status = ND_Value_Alloc( ctx->CurrentMessage->Field_Struct_Ptr, (void  **)&(ctx->CurrentField))) != NDS_OK)
+      {
+	    snprintf(DescErr,sizeof(DescErr),SDMD_XML_LIB_ERROR_3,IMRD_SDMD_TAG_MESSAGE);
+	    SDM_RaiseError(ctx->SaxCtxHdl,&(ctx->FataError),&(ctx->flagerror), fonctionname , DescErr, SDMD_XML_CODE_ERROR_3 );
+      }
+      ctx->PresentLevelTag = ctx->PresentLevelTag + 1;
+	  strcpy(ctx->PathArray[ctx->PresentLevelTag], (char*)localname);
+   }
+   else if ((strcmp((const char *)localname, IMRD_SDMD_TAG_FIXED)    == 0) ||
+            (strcmp((const char *)localname, IMRD_SDMD_TAG_INTERNE)  == 0) ||
+            (strcmp((const char *)localname, IMRD_SDMD_TAG_TAGGED)   == 0) ||
+            (strcmp((const char *)localname, IMRD_SDMD_TAG_XML)      == 0) ||
+            (strcmp((const char *)localname, IMRD_SDMD_TAG_DELIMITED)== 0) ||
+            (strcmp((const char *)localname, IMRD_SDMD_TAG_FML)      == 0)
+           )
+   {
+      ctx->PresentLevelTag = ctx->PresentLevelTag + 1;
+	  strcpy(ctx->PathArray[ctx->PresentLevelTag], (char*)localname);
+   }
+   else if (strcmp((const char *)localname, IMRD_SDMD_TAG_CNV) == 0)
+   {
+      ctx->PresentLevelTag = ctx->PresentLevelTag + 1;
+	  strcpy(ctx->PathArray[ctx->PresentLevelTag], (char*)localname);
+   }
+
+}
+
+
+IMRT_Status endElementNsCnv( SDMT_StructInfo_Contexte * ctx, 
+			const xmlChar *localname,
+			const xmlChar *prefix,
+			const xmlChar *URI)
+{
+    IMRT_Status       status_tmp;
+    NDT_Status         status;
+    const char        fonctionname [] ="endElementNsCnv";
+    char              DescErr[IMRD_SDMD_DESCERR_LEN];
+  
+    if(strcmp((const char*)localname, IMRD_SDMD_TAG_CNV) == 0)
+    {
+	    ctx->CurrentCnv->Id =  ctx->CptCnv;
+		if( ( status = ND_DataStruct_Value_Add( ctx->RootCnv, (void  *)(ctx->CurrentCnv))) != NDS_OK)
+		{
+		    IMRD_LM_LOG_ERROR_1( "ND_Value_Alloc() failed (%d) !", status);
+
+		    snprintf(DescErr,sizeof(DescErr),SDMD_XML_LIB_ERROR_3,IMRD_SDMD_TAG_CNV);
+		    SDM_RaiseError(ctx->SaxCtxHdl,&(ctx->FataError),&(ctx->flagerror), fonctionname , DescErr, SDMD_XML_CODE_ERROR_3 );
+		}
+	    ctx->CptCnv ++;
+    }
+
+    if(strcmp((const char*)localname, IMRD_SDMD_TAG_NAME) == 0)
+    {
+		strcpy(ctx->CurrentCnv->Name, ctx->value);
+    }
+    else if (strcmp((const char *)localname, IMRD_SDMD_TAG_VERSION) == 0)
+    {
+		IMRD_LM_LOG_INFO_1( "[Cnv]: [%s]", ctx->value);
+		status_tmp = SDM_Set_Struct_Version((IMRT_Data_Version *)ctx->RootCnv->User_Ptr, (char *)ctx->value);
+    }
+}
+
+
+IMRT_Status endElementNS( SDMT_StructInfo_Contexte * ctx, 
+							     const xmlChar *localname,
+							     const xmlChar *prefix,
+							     const xmlChar *URI)
+{
+  IMRT_Status    status_tmp;
+  NDT_Status     status;
+  xmlParserCtxt * SaxCtx;
+  char DescErr[IMRD_SDMD_DESCERR_LEN];
+  const char fonctionname [] = "endElementNS";
+  NDT_Node     *node_ptr;
+  IMRT_Cnv      myCnv;
+  NDT_Status    nd_status;
+  NDT_Index_Type  *index_type_ptr;
+
+  if (strcmp((const char *)localname, IMRD_SDMD_TAG_NAME) == 0)
+  {
+  	switch(ctx->PresentLevelTag)
+  	{
+  	  case IMRD_SDMD_LEVEL_TAG_0:
+  	  {
+  	  	strcpy(ctx->CurrentMessage->Name, ctx->value);
+  		break;	
+      }
+  	  case IMRD_SDMD_LEVEL_TAG_1:
+  	  {
+  	  	strcpy(ctx->CurrentField->Name, ctx->value);
+  		break;	
+      }
+  	  case IMRD_SDMD_LEVEL_TAG_2:
+  	  {
+  	  	if(strcmp(ctx->PathArray[ctx->PresentLevelTag], IMRD_SDMD_TAG_INTERNE) == 0)
+  	  	{
+  	  	    strcpy(ctx->CurrentField->Internal.Tag, ctx->value);
+  	  	}
+  	  	else if(strcmp(ctx->PathArray[ctx->PresentLevelTag], IMRD_SDMD_TAG_TAGGED) == 0)
+  	  	{
+  	  	    strcpy(ctx->CurrentField->Tagged.Tag, ctx->value);
+        }
+        else if(strcmp(ctx->PathArray[ctx->PresentLevelTag], IMRD_SDMD_TAG_XML) == 0)
+  	  	{
+  	  	    strcpy(ctx->CurrentField->XML.Tag, ctx->value);
+  	  	}
+        else if(strcmp(ctx->PathArray[ctx->PresentLevelTag], IMRD_SDMD_TAG_FML) == 0)
+  	  	{
+  	  	    strcpy(ctx->CurrentField->FML.Tag, ctx->value);
+  	  	}
+  	  	          
+  		break;	
+      }
+  	  case IMRD_SDMD_LEVEL_TAG_3:
+  	  {
+  	  	if(strcmp(ctx->PathArray[ctx->PresentLevelTag-1], IMRD_SDMD_TAG_FIXED) == 0)
+  	  	{
+           strcpy(myCnv.Name, ctx->value);
+	       if(((nd_status = ND_Index_Node_Find( &node_ptr, ctx->RootCnv,
+			  	               IMRD_SDMD_CNV_IDX_NAME, &myCnv, NULL)) != NDS_OK)||
+				(node_ptr == NULL))
+	       {
+	         snprintf(DescErr,sizeof(DescErr),SDMD_XML_LIB_ERROR_4,IMRD_SDMD_TAG_CNV, myCnv.Name );
+	         SDM_RaiseError(ctx->SaxCtxHdl,&(ctx->FataError),&(ctx->flagerror), fonctionname , DescErr, SDMD_XML_CODE_ERROR_4 );
+	       }
+  	  	   else
+  	  	   {
+  	  		 ctx->CurrentField->Fixed.Cnv_Ptr = node_ptr->Value;
+  	  	   }
+  	  	}
+  	  	else if(strcmp(ctx->PathArray[ctx->PresentLevelTag-1], IMRD_SDMD_TAG_INTERNE) == 0)
+  	  	{
+           strcpy(myCnv.Name, ctx->value);
+	       if(((nd_status = ND_Index_Node_Find( &node_ptr, ctx->RootCnv,
+			  	               IMRD_SDMD_CNV_IDX_NAME, &myCnv, NULL)) != NDS_OK)||
+				(node_ptr == NULL))
+	       {
+	         snprintf(DescErr,sizeof(DescErr),SDMD_XML_LIB_ERROR_4,IMRD_SDMD_TAG_CNV, myCnv.Name );
+	         SDM_RaiseError(ctx->SaxCtxHdl,&(ctx->FataError),&(ctx->flagerror), fonctionname , DescErr, SDMD_XML_CODE_ERROR_4 );
+	       }
+  	  	   else
+  	  	   {
+  	  		 ctx->CurrentField->Internal.Cnv_Ptr = node_ptr->Value;
+  	  	   }
+  	  	}
+  	  	else if(strcmp(ctx->PathArray[ctx->PresentLevelTag-1], IMRD_SDMD_TAG_TAGGED) == 0)
+  	  	{
+           strcpy(myCnv.Name, ctx->value);
+	       if(((nd_status = ND_Index_Node_Find( &node_ptr, ctx->RootCnv,
+			  	               IMRD_SDMD_CNV_IDX_NAME, &myCnv, NULL)) != NDS_OK)||
+				(node_ptr == NULL))
+	       {
+	         snprintf(DescErr,sizeof(DescErr),SDMD_XML_LIB_ERROR_4,IMRD_SDMD_TAG_CNV, myCnv.Name );
+	         SDM_RaiseError(ctx->SaxCtxHdl,&(ctx->FataError),&(ctx->flagerror), fonctionname , DescErr, SDMD_XML_CODE_ERROR_4 );
+	       }
+  	  	   else
+  	  	   {
+  	  		 ctx->CurrentField->Tagged.Cnv_Ptr = node_ptr->Value;
+  	  	   }
+        }
+        else if(strcmp(ctx->PathArray[ctx->PresentLevelTag-1], IMRD_SDMD_TAG_XML) == 0)
+  	  	{
+           strcpy(myCnv.Name, ctx->value);
+	       if(((nd_status = ND_Index_Node_Find( &node_ptr, ctx->RootCnv,
+			  	               IMRD_SDMD_CNV_IDX_NAME, &myCnv, NULL)) != NDS_OK)||
+				(node_ptr == NULL))
+	       {
+	         snprintf(DescErr,sizeof(DescErr),SDMD_XML_LIB_ERROR_4,IMRD_SDMD_TAG_CNV, myCnv.Name );
+	         SDM_RaiseError(ctx->SaxCtxHdl,&(ctx->FataError),&(ctx->flagerror), fonctionname , DescErr, SDMD_XML_CODE_ERROR_4 );
+	       }
+  	  	   else
+  	  	   {
+  	  		 ctx->CurrentField->XML.Cnv_Ptr = node_ptr->Value;
+  	  	   }
+  	  	}
+        else if(strcmp(ctx->PathArray[ctx->PresentLevelTag-1], IMRD_SDMD_TAG_FML) == 0)
+  	  	{
+           strcpy(myCnv.Name, ctx->value);
+	       if(((nd_status = ND_Index_Node_Find( &node_ptr, ctx->RootCnv,
+			  	               IMRD_SDMD_CNV_IDX_NAME, &myCnv, NULL)) != NDS_OK)||
+				(node_ptr == NULL))
+	       {
+	         snprintf(DescErr,sizeof(DescErr),SDMD_XML_LIB_ERROR_4,IMRD_SDMD_TAG_CNV, myCnv.Name );
+	         SDM_RaiseError(ctx->SaxCtxHdl,&(ctx->FataError),&(ctx->flagerror), fonctionname , DescErr, SDMD_XML_CODE_ERROR_4 );
+	       }
+  	  	   else
+  	  	   {
+  	  		 ctx->CurrentField->FML.Cnv_Ptr = node_ptr->Value;
+  	  	   }
+  	  	}
+        else if(strcmp(ctx->PathArray[ctx->PresentLevelTag-1], IMRD_SDMD_TAG_DELIMITED) == 0)
+  	  	{
+           strcpy(myCnv.Name, ctx->value);
+	       if(((nd_status = ND_Index_Node_Find( &node_ptr, ctx->RootCnv,
+			  	               IMRD_SDMD_CNV_IDX_NAME, &myCnv, NULL)) != NDS_OK)||
+				(node_ptr == NULL))
+	       {
+	         snprintf(DescErr,sizeof(DescErr),SDMD_XML_LIB_ERROR_4,IMRD_SDMD_TAG_CNV, myCnv.Name );
+	         SDM_RaiseError(ctx->SaxCtxHdl,&(ctx->FataError),&(ctx->flagerror), fonctionname , DescErr, SDMD_XML_CODE_ERROR_4 );
+	       }
+  	  	   else
+  	  	   {
+  	  		 ctx->CurrentField->Delimited.Cnv_Ptr = node_ptr->Value;
+  	  	   }
+  	  	}
+  	  	          
+  		break;	
+      }
+  	  default:
+  	  {
+        snprintf(DescErr, sizeof(DescErr), SDMD_XML_LIB_ERROR_10, SDMD_MSGFIELD_FILE);
+        SDM_RaiseError(ctx->SaxCtxHdl,&(ctx->FataError),&(ctx->flagerror), fonctionname , DescErr, SDMD_XML_CODE_ERROR_10);
+  	  }
+    } /* end switch */
+  }
+  else if (strcmp((const char *)localname, IMRD_SDMD_TAG_SIZE) == 0)
+  {
+  	switch(ctx->PresentLevelTag)
+  	{
+  	  case IMRD_SDMD_LEVEL_TAG_0:
+  	  {
+  	  	ctx->CurrentMessage->Size = atoi(ctx->value);
+  		break;	
+      }
+  	  case IMRD_SDMD_LEVEL_TAG_2:
+  	  {
+  	  	ctx->CurrentField->Fixed.Size = atoi(ctx->value);
+  		break;	
+      }
+  	  default:
+  	  {
+        snprintf(DescErr, sizeof(DescErr), SDMD_XML_LIB_ERROR_10, SDMD_MSGFIELD_FILE);
+        SDM_RaiseError(ctx->SaxCtxHdl,&(ctx->FataError),&(ctx->flagerror), fonctionname , DescErr, SDMD_XML_CODE_ERROR_10);
+  	  }
+    } /* end switch */
+  }
+  else if (strcmp((const char *)localname, IMRD_SDMD_TAG_ATTRIBUTE) == 0)
+  {
+  	switch(ctx->PresentLevelTag)
+  	{
+  	  case IMRD_SDMD_LEVEL_TAG_3:
+  	  {
+  	  	if(strcmp(ctx->PathArray[ctx->PresentLevelTag-1], IMRD_SDMD_TAG_FIXED) == 0)
+  	  	{
+  	  		strcpy(ctx->CurrentField->Fixed.Cnv_Attr, ctx->value);
+  	  	}
+  	  	else if(strcmp(ctx->PathArray[ctx->PresentLevelTag-1], IMRD_SDMD_TAG_INTERNE) == 0)
+  	  	{
+  	  	    strcpy(ctx->CurrentField->Internal.Cnv_Attr, ctx->value);
+  	  	}
+  	  	else if(strcmp(ctx->PathArray[ctx->PresentLevelTag-1], IMRD_SDMD_TAG_TAGGED) == 0)
+  	  	{
+  	  	    strcpy(ctx->CurrentField->Tagged.Cnv_Attr, ctx->value);
+        }
+        else if(strcmp(ctx->PathArray[ctx->PresentLevelTag-1], IMRD_SDMD_TAG_XML) == 0)
+  	  	{
+  	  	    strcpy(ctx->CurrentField->XML.Cnv_Attr, ctx->value);
+  	  	}
+        else if(strcmp(ctx->PathArray[ctx->PresentLevelTag-1], IMRD_SDMD_TAG_FML) == 0)
+  	  	{
+  	  	    strcpy(ctx->CurrentField->FML.Cnv_Attr, ctx->value);
+  	  	}
+        else if(strcmp(ctx->PathArray[ctx->PresentLevelTag-1], IMRD_SDMD_TAG_DELIMITED) == 0)
+  	  	{
+  	  	    strcpy(ctx->CurrentField->Delimited.Cnv_Attr, ctx->value);
+  	  	}
+
+  	  	break;	
+      }
+  	  default:
+  	  {
+        snprintf(DescErr, sizeof(DescErr), SDMD_XML_LIB_ERROR_10, SDMD_MSGFIELD_FILE);
+        SDM_RaiseError(ctx->SaxCtxHdl,&(ctx->FataError),&(ctx->flagerror), fonctionname , DescErr, SDMD_XML_CODE_ERROR_10);
+  	  }
+    } /* end switch */
+  }
+  else if (strcmp((const char *)localname, IMRD_SDMD_TAG_DEFVAL) == 0)
+  {
+  	switch(ctx->PresentLevelTag)
+  	{
+  	  case IMRD_SDMD_LEVEL_TAG_2:
+  	  {
+  	  	if(strcmp(ctx->PathArray[ctx->PresentLevelTag], IMRD_SDMD_TAG_FIXED) == 0)
+  	  	{
+  	  		strcpy(ctx->CurrentField->Fixed.Def_Val, ctx->value);
+  	  	}
+  	  	else if(strcmp(ctx->PathArray[ctx->PresentLevelTag], IMRD_SDMD_TAG_INTERNE) == 0)
+  	  	{
+  	  	    strcpy(ctx->CurrentField->Internal.Def_Val, ctx->value);
+  	  	}
+  	  	else if(strcmp(ctx->PathArray[ctx->PresentLevelTag], IMRD_SDMD_TAG_TAGGED) == 0)
+  	  	{
+  	  	    strcpy(ctx->CurrentField->Tagged.Def_Val, ctx->value);
+        }
+        else if(strcmp(ctx->PathArray[ctx->PresentLevelTag], IMRD_SDMD_TAG_XML) == 0)
+  	  	{
+  	  	    strcpy(ctx->CurrentField->XML.Def_Val, ctx->value);
+  	  	}
+        else if(strcmp(ctx->PathArray[ctx->PresentLevelTag], IMRD_SDMD_TAG_FML) == 0)
+  	  	{
+  	  	    strcpy(ctx->CurrentField->FML.Def_Val, ctx->value);
+  	  	}
+        else if(strcmp(ctx->PathArray[ctx->PresentLevelTag], IMRD_SDMD_TAG_DELIMITED) == 0)
+  	  	{
+  	  	    strcpy(ctx->CurrentField->Delimited.Def_Val, ctx->value);
+  	  	}
+
+  	  	break;	
+      }
+  	  default:
+  	  {
+        snprintf(DescErr, sizeof(DescErr), SDMD_XML_LIB_ERROR_10, SDMD_MSGFIELD_FILE);
+        SDM_RaiseError(ctx->SaxCtxHdl,&(ctx->FataError),&(ctx->flagerror), fonctionname , DescErr, SDMD_XML_CODE_ERROR_10);
+  	  }
+    } /* end switch */
+  }
+  else if (strcmp((const char *)localname, IMRD_SDMD_TAG_OFFSET) == 0)
+  {
+  	ctx->CurrentField->Fixed.Offset = atoi(ctx->value);
+  }
+  else if (strcmp((const char *)localname, IMRD_SDMD_TAG_ID) == 0)
+  {
+  	ctx->CurrentField->Delimited.Id = atoi(ctx->value);
+  }
+  else if (strcmp((const char *)localname, IMRD_SDMD_TAG_VALUEID) == 0)
+  {
+  	strcpy(ctx->CurrentField->Value_Id, ctx->value);
+  }
+  else if (strcmp((const char *)localname, IMRD_SDMD_TAG_EXIST) == 0)
+  {
+  	if(*(ctx->value) == IMRD_YES)
+  	{
+  		ctx->CurrentField->Exist = IMRD_TRUE;
+  	}
+  	else
+  	{
+  		ctx->CurrentField->Exist = IMRD_FALSE;
+  	}
+  }
+  else if ( (strcmp((const char*)localname, IMRD_SDMD_TAG_MESSAGE)== 0) ) 
+  {
+ 
+    ctx->CurrentMessage->Id = ctx->CptMsg;
+
+	index_type_ptr = Field_Struct_final_idx_tab;
+	status = SDM_DataStruct_Finalize(ctx->CurrentMessage->Field_Struct_Ptr, index_type_ptr, IMRD_SDMD_FIELD_STRUCT_IDX_NB);
+	if(status == IMRS_KO)
+	{
+		printf("Erreur lors de la finalisation de Field_Struct_Ptr \n");
+	}
+
+    if( ( nd_status = ND_DataStruct_Value_Add( ctx->RootMessage, (void  *)(ctx->CurrentMessage))) != NDS_OK)
+    {
+      snprintf(DescErr,sizeof(DescErr),SDMD_XML_LIB_ERROR_2,IMRD_SDMD_TAG_MESSAGE);
+      SDM_RaiseError(ctx->SaxCtxHdl,&(ctx->FataError),&(ctx->flagerror), fonctionname , DescErr, SDMD_XML_CODE_ERROR_2 );
+    }
+    ctx->CptMsg++;
+    memset(ctx->PathArray[ctx->PresentLevelTag],0,sizeof(IMRD_SDMD_SIZE_TAG_SIZE));
+    ctx->PresentLevelTag = ctx->PresentLevelTag - 1;
+  }
+  else if( (strcmp((const char*)localname, IMRD_SDMD_TAG_FIELD)== 0) )
+  {
+    ctx->CptField++;
+    ctx->CurrentField->Id = ctx->CptField;
+    
+    if( ( nd_status = ND_DataStruct_Value_Add( ctx->CurrentMessage->Field_Struct_Ptr, (void  *)(ctx->CurrentField))) != NDS_OK)
+    {
+      snprintf(DescErr,sizeof(DescErr),SDMD_XML_LIB_ERROR_2,IMRD_SDMD_TAG_FIELD);
+      SDM_RaiseError(ctx->SaxCtxHdl,&(ctx->FataError),&(ctx->flagerror), fonctionname , DescErr, SDMD_XML_CODE_ERROR_2 );
+    }
+    memset(ctx->PathArray[ctx->PresentLevelTag],0,sizeof(IMRD_SDMD_SIZE_TAG_SIZE));
+    ctx->PresentLevelTag = ctx->PresentLevelTag - 1;
+  }
+  else if ((strcmp((const char *)localname, IMRD_SDMD_TAG_FIXED)     == 0) ||
+            (strcmp((const char *)localname, IMRD_SDMD_TAG_INTERNE)  == 0) ||
+            (strcmp((const char *)localname, IMRD_SDMD_TAG_TAGGED)   == 0) ||
+            (strcmp((const char *)localname, IMRD_SDMD_TAG_XML)      == 0) ||
+            (strcmp((const char *)localname, IMRD_SDMD_TAG_DELIMITED)== 0) ||
+            (strcmp((const char *)localname, IMRD_SDMD_TAG_CNV)      == 0) ||
+            (strcmp((const char *)localname, IMRD_SDMD_TAG_FML)      == 0)
+           )
+  {
+    memset(ctx->PathArray[ctx->PresentLevelTag],0,sizeof(IMRD_SDMD_SIZE_TAG_SIZE));
+    ctx->PresentLevelTag = ctx->PresentLevelTag - 1;
+  }
+  else if (strcmp((const char *)localname, IMRD_SDMD_TAG_VERSION) == 0)
+  {
+	IMRD_LM_LOG_INFO_1( "[Msg-Field]: [%s]", ctx->value);
+	status_tmp = SDM_Set_Struct_Version((IMRT_Data_Version *)ctx->RootMessage->User_Ptr, (char *)ctx->value);
+  }
+}
+
+IMRT_Status charactersDebug(SDMT_StructInfo_Contexte * ctx , const xmlChar *ch, int len)
+{
+    char output[40];
+    int i;
+    
+    memset(ctx->value,0, sizeof(ctx->value));
+    
+    for (i = 0;(i<len) && (i < IMRD_SDMD_VALUE_LEN);i++)
+	    ctx->value[i] = ch[i];
+      ctx->value[i] = 0;
+
+}
+
+
+IMRT_Status SDM_XML_Load_Cnv( char *demo_file, SDMT_StructInfo_Contexte *mycontexte)
+{
+    IMRT_Status  status;
+    NDT_Status   nd_status;
+    char * docname = NULL;
+    NDT_Index_Type  *index_type_ptr;
+    xmlDocPtr doc = NULL;
+    xmlDtdPtr dtd;
+    xmlParserCtxtPtr ctxt =NULL;
+    xmlSAXHandlerPtr SAXHandler;
+    xmlSAXHandlerPtr SAXHandler_Sav;
+    const char functionname []="SDM_XML_Load_Cnv";
+    char DescErr[IMRD_SDMD_DESCERR_LEN];
+	IMRT_Data_Version   *Data_Version_Ptr;
+
+    LIBXML_TEST_VERSION
+	xmlKeepBlanksDefault(0);	
+    xmlSAXDefaultVersion(2);
+    xmlLineNumbersDefault(1);
+	
+    status = IMRS_OK;
+    docname = demo_file;
+    ctxt = xmlNewParserCtxt();
+    /*initialisation des indexes*/
+    index_type_ptr =  Appl_Struct_initial_idx_tab;
+  
+
+  if(ctxt != NULL)
+  {
+	mycontexte->flagerror  = IMRS_OK;
+	SAXHandler            = &SaxCnvHandlerStruct;
+	mycontexte->SaxCtxHdl = ctxt;
+	ctxt->userData        = mycontexte;
+	SAXHandler_Sav        = ctxt->sax;
+	ctxt->sax             = SAXHandler;
+	ctxt->sax2            = 1 ;
+    
+	Data_Version_Ptr = (IMRT_Data_Version *) malloc(sizeof(IMRT_Data_Version));
+	Data_Version_Ptr->Label[0] = '\0';
+	Data_Version_Ptr->Date[0] = '\0';
+	if( ( nd_status = ND_DataStruct_Open(&(mycontexte->RootCnv),IMRD_SDMD_CNV_STRUCT_IDX_NB,index_type_ptr, "SDM_Cnv_Manager",SDM_Cnv_Manager, NULL, NULL, NULL, NULL,0, Data_Version_Ptr)) != NDS_OK)
+	{
+		status = IMRS_KO;
+	    printf( "ND_DataStruct_Open() failed (%d) !\n", nd_status);
+	    snprintf(DescErr,sizeof(DescErr),SDMD_XML_LIB_ERROR_5,IMRD_SDMD_TAG_CNV);
+	    SDM_RaiseError(mycontexte->SaxCtxHdl,&(mycontexte->FataError),&(mycontexte->flagerror), functionname, DescErr, SDMD_XML_CODE_ERROR_5 );
+	}
+	else
+	{
+		/* DAHBI ND_DataStruct_Info_Print(stderr, mycontexte->RootCnv, NDD_RECURSIVE_MODE_PARENT_CHILD, 0, 0);*/
+	    doc = xmlCtxtReadFile(ctxt, docname, NULL, XML_PARSE_DTDATTR+XML_PARSE_DTDVALID);
+	    if (ctxt->lastError.code != XML_ERR_OK)
+	    {
+	    	status = IMRS_KO;
+	    	printf("Erreur de parsing du fichier %s.\n%s\n", docname, ctxt->lastError.message);
+	    }
+		else if(mycontexte->flagerror != IMRS_OK)
+		{
+			status = IMRS_KO;
+			printf("%s\n", mycontexte->FataError.libError);
+		}
+	    else
+	    {
+			index_type_ptr = Cnv_Struct_final_idx_tab;
+			status = SDM_DataStruct_Finalize(mycontexte->RootCnv,index_type_ptr, IMRD_SDMD_CNV_STRUCT_IDX_NB);
+			/*SDM_DataStruct_Dump(mycontexte->RootCnv);*/
+	    }
+	}
+
+	if((status != IMRS_OK)&&(mycontexte->RootCnv != NULL))
+	{
+	    if(mycontexte->CurrentCnv != NULL)
+            {
+		free(mycontexte->CurrentCnv);
+            }	
+	    nd_status = ND_DataStruct_Close(mycontexte->RootCnv);
+	}
+
+	ctxt->sax = SAXHandler_Sav;
+	xmlFreeParserCtxt(ctxt);
+  } /* end if(ctxt != NULL) */
+  else
+  {
+  	status = IMRS_KO;
+  }
+
+  return(status);
+
+}
+
+
+IMRT_Status  SDM_XML_Load_MsgAndField( char *demo_file, SDMT_StructInfo_Contexte * mycontexte)
+{
+  IMRT_Status     status;
+  NDT_Status      nd_status;
+  char * docname = NULL;
+	NDT_Index_Type  *index_type_ptr;
+	xmlDocPtr doc = NULL;
+	xmlDtdPtr dtd;
+	xmlParserCtxtPtr ctxt =NULL;
+	xmlSAXHandlerPtr debugSAXHandler;
+	xmlSAXHandlerPtr SAXHandler_Sav;
+	const char functionname []="SDM_XML_Load_MsgAndField";
+	char DescErr[IMRD_SDMD_DESCERR_LEN];
+	IMRT_Data_Version   *Data_Version_Ptr;
+
+  LIBXML_TEST_VERSION
+	xmlKeepBlanksDefault(0);	
+	xmlSAXDefaultVersion(2);
+	xmlLineNumbersDefault(1);
+	
+  status = IMRS_OK;
+  docname = demo_file;
+  ctxt = xmlNewParserCtxt();
+  /*initialisation des indexes*/
+  index_type_ptr =  Msg_Struct_initial_idx_tab;
+
+  if(ctxt != NULL)
+  {
+    mycontexte->flagerror  = IMRS_OK;
+    debugSAXHandler        = &debugSAXHandlerStruct;
+    mycontexte->SaxCtxHdl  = ctxt;
+    ctxt->userData         = mycontexte;
+    SAXHandler_Sav        = ctxt->sax;
+    ctxt->sax              = debugSAXHandler;
+    ctxt->sax2             = 1 ;
+    
+    /*xmlSetGenericErrorFunc(NULL,CatchError);*/
+	Data_Version_Ptr = (IMRT_Data_Version *) malloc(sizeof(IMRT_Data_Version));
+	Data_Version_Ptr->Label[0] = '\0';
+	Data_Version_Ptr->Date[0] = '\0';
+    if( ( nd_status = ND_DataStruct_Open(&(mycontexte->RootMessage),IMRD_SDMD_MSG_STRUCT_IDX_NB, index_type_ptr, "SDM__Msg_Manager",SDM_Msg_Manager, NULL, NULL, NULL, NULL,0, Data_Version_Ptr)) != NDS_OK)
+    {
+    	status = IMRS_KO;
+        snprintf(DescErr,sizeof(DescErr),SDMD_XML_LIB_ERROR_5,IMRD_SDMD_TAG_MESSAGE);
+        SDM_RaiseError(mycontexte->SaxCtxHdl,&(mycontexte->FataError),&(mycontexte->flagerror), functionname, DescErr, SDMD_XML_CODE_ERROR_5 );
+    }
+    else
+    {
+      doc = xmlCtxtReadFile(ctxt, docname, NULL, XML_PARSE_DTDATTR+XML_PARSE_DTDVALID);
+      if (ctxt->lastError.code != XML_ERR_OK)
+	  {
+	    	status = IMRS_KO;
+	    	printf("Erreur de parsing du fichier %s.\n%s\n", docname, ctxt->lastError.message);
+	  }
+	  else if(mycontexte->flagerror != IMRS_OK)
+	  {
+		status = IMRS_KO;
+		printf("%s\n", mycontexte->FataError.libError);
+	  }
+      else
+      {
+			index_type_ptr = Msg_Struct_final_idx_tab;
+			status = SDM_DataStruct_Finalize(mycontexte->RootMessage, index_type_ptr, IMRD_SDMD_MSG_STRUCT_IDX_NB);
+			/*SDM_DataStruct_Dump( mycontexte->RootMessage);*/
+	  }
+    }
+
+	if(status != IMRS_OK)
+	{
+	    if( mycontexte->CurrentMessage != NULL)
+	    {
+		if(mycontexte->CurrentMessage->Field_Struct_Ptr != NULL)
+		{
+                    nd_status = ND_DataStruct_Close(mycontexte->CurrentMessage->Field_Struct_Ptr);
+                }
+                if( nd_status != NDS_OK)
+		{
+		    free(mycontexte->CurrentMessage);
+		}
+            }
+            if(mycontexte->CurrentField != NULL)
+	    {
+		free(mycontexte->CurrentField);
+            }
+	    if(mycontexte->RootMessage != NULL)
+	    {
+		nd_status = ND_DataStruct_Close(mycontexte->RootMessage);
+	    }
+	    /*if(mycontexte->RootCnv != NULL)
+	    {
+		nd_status = ND_DataStruct_Close(mycontexte->RootCnv);
+		}*/
+	}
+
+	ctxt->sax = SAXHandler_Sav;
+	xmlFreeParserCtxt(ctxt);
+  }
+  else
+  {
+  	status = IMRS_KO;
+  }
+
+  return(status);
+
+}
+
+
+
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  SDM_XML_Dump_Cnv_Header(FILE *dump_file)
+{
+	fprintf(dump_file, "<?xml version=\"1.0\" ?>\n");
+	fprintf(dump_file, "<!-- Cnv Struct definitions -->\n");
+	fprintf(dump_file, "<%s>\n", IMRD_SDMD_TAG_CNV_STRUCT);
+	fprintf(dump_file, "<version>@(#) VERSIONIMR: $Label:  $   $Date: 2008/11/12 02:25:23 $   $Workfile:   struct_info_xml.c  $</version>\n", 
+				((IMRT_Data_Version *)IMRG_SDM_Base.RootCnv->User_Ptr)->Label,
+				((IMRT_Data_Version *)IMRG_SDM_Base.RootCnv->User_Ptr)->Date);
+	return( IMRS_OK);
+
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  SDM_XML_Dump_Cnv_Body(FILE *dump_file)
+{
+	IMRT_Status  status;
+	NDT_Status  nd_status;
+
+	if( ( nd_status = ND_DataStruct_Traverse( IMRG_SDM_Base.RootCnv, IMRD_SDMD_CMD_API_XML_DUMP, dump_file)) != NDS_OK)
+	{
+		status = IMRS_KO;
+		printf( "XML Dump RootCnv failed (%d)...\n");
+	}
+	else
+	{
+		status = IMRS_OK;
+	}
+
+	return(status);
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  SDM_XML_Dump_Cnv_Footer(FILE *dump_file)
+{
+	fprintf(dump_file, "<!-- Cnv Struct definitions footer -->\n");
+	fprintf(dump_file, "</%s>\n", IMRD_SDMD_TAG_CNV_STRUCT);
+	return( IMRS_OK);
+
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  SDM_XML_Dump_Cnv(void)
+{
+	IMRT_Status     status;
+	char	    dump_filename[255];
+	FILE	   *dump_file;
+
+	strcpy(dump_filename, SDMD_CNV_FILE);
+
+	if( ( dump_file = fopen( dump_filename, "w")) == NULL)
+	{
+		status = IMRS_KO;
+		printf( "Can't open dump file (%s) !\n", dump_filename);
+	}
+	else
+	{
+		status = SDM_XML_Dump_Cnv_Header(dump_file);
+		if(status == IMRS_OK)
+		{
+			status = SDM_XML_Dump_Cnv_Body(dump_file);
+			if(status == IMRS_OK)
+			{
+				status = SDM_XML_Dump_Cnv_Footer(dump_file);
+			}
+		}
+
+		fclose( dump_file);
+	}
+
+	return(status);
+
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  SDM_XML_Dump_Msg_Header(FILE *dump_file)
+{
+	fprintf(dump_file, "<?xml version=\"1.0\" ?>\n");
+	fprintf(dump_file, "<!-- Msg Struct definitions -->\n");
+	fprintf(dump_file, "<%s>\n", IMRD_SDMD_TAG_MSG_STRUCT);
+	fprintf(dump_file, "<version>@(#) VERSIONIMR: $Label:  $   $Date: 2008/11/12 02:25:23 $   $Workfile:   struct_info_xml.c  $</version>\n", 
+				((IMRT_Data_Version *)IMRG_SDM_Base.RootMsg->User_Ptr)->Label,
+				((IMRT_Data_Version *)IMRG_SDM_Base.RootMsg->User_Ptr)->Date);
+	return( IMRS_OK);
+	
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  SDM_XML_Dump_Msg_Body(FILE *dump_file)
+{
+	IMRT_Status  status;
+	NDT_Status   nd_status;
+
+	if( ( nd_status = ND_DataStruct_Traverse( IMRG_SDM_Base.RootMsg, IMRD_SDMD_CMD_API_XML_DUMP, dump_file)) != NDS_OK)
+	{
+		status = IMRS_KO;
+		printf( "XML Dump RootMsg failed (%d)...\n");
+	}
+	else
+	{
+		status = IMRS_OK;
+	}
+
+	return(status);
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  SDM_XML_Dump_Msg_Footer(FILE *dump_file)
+{
+	fprintf(dump_file, "<!-- Msg Struct definitions footer -->\n");
+	fprintf(dump_file, "</%s>\n", IMRD_SDMD_TAG_MSG_STRUCT);
+	return( IMRS_OK);
+
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  SDM_XML_Dump_Msg(void)
+{
+	IMRT_Status     status;
+	char	    dump_filename[255];
+	FILE	   *dump_file;
+
+	strcpy(dump_filename, SDMD_MSGFIELD_FILE);
+
+	if( ( dump_file = fopen( dump_filename, "w")) == NULL)
+	{
+		status = IMRS_KO;
+		printf( "Can't open dump file (%s) !\n", dump_filename);
+	}
+	else
+	{
+		status = SDM_XML_Dump_Msg_Header(dump_file);
+		if(status == IMRS_OK)
+		{
+			status = SDM_XML_Dump_Msg_Body(dump_file);
+			if(status == IMRS_OK)
+			{
+				status = SDM_XML_Dump_Msg_Footer(dump_file);
+			}
+		}
+
+		fclose( dump_file);
+	}
+
+	return(status);
+}
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+IMRT_Status  SDM_XML_StructInfo_Dump(void)
+{
+	IMRT_Status     status;
+
+	status = SDM_XML_Dump_Cnv();
+
+	if(status == IMRS_OK)
+	{
+		status = SDM_XML_Dump_Msg();
+	}
+
+	return(status);
+}
+
+/*----------------------------------------------------------------------------*/
+/*                                                                            */
+/*----------------------------------------------------------------------------*/
diff --git a/src/libstatic_data_mng/src/struct_info_xml.h b/src/libstatic_data_mng/src/struct_info_xml.h
new file mode 100644
index 0000000..9f6776f
--- /dev/null
+++ b/src/libstatic_data_mng/src/struct_info_xml.h
@@ -0,0 +1,277 @@
+/*----------------------------------------------------------------------------*/
+/* File: struct_info_xml.h 				         	      */
+/*----------------------------------------------------------------------------*/
+/*                                                                            */
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/* IMR - Interlinking Message Router                                          */
+/* Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)              */
+/* mailto:arnaud@rx3.net                                                      */
+/* http://www.rx3.org/dvp/?dvp=imr                                            */
+/*----------------------------------------------------------------------------*/
+/* This file is part of IMR                                                   */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or              */
+/* modify it under the terms of the GNU General Public License                */
+/* as published by the Free Software Foundation; either version 2             */
+/* of the License, or (at your option) any later version.                     */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of             */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              */
+/* GNU General Public License for more details.                               */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program; if not, write to the Free Software Foundation,    */
+/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.        */
+/*----------------------------------------------------------------------------*/
+
+#ifndef _STRUCT_INFO_XML_H_
+#   define _STRUCT_INFO_XML_H_
+
+
+
+/*----------------------------------------------------------------------------*/
+/* Global Include                                                             */
+/*----------------------------------------------------------------------------*/
+
+#   include <libstatic_data_mng.h>
+
+/*----------------------------------------------------------------------------*/
+/* Local constantes                                                           */
+/*----------------------------------------------------------------------------*/
+
+/*definition des tags xml pour le chargement des structure Msg et Field*/
+#define IMRD_SDMD_TAG_MESSAGE       "message"
+#define IMRD_SDMD_TAG_FIELD         "field"
+#define IMRD_SDMD_TAG_VALUEID       "valueid"
+#define IMRD_SDMD_TAG_FIXED         "fixed"
+#define IMRD_SDMD_TAG_OFFSET        "offset"
+#define IMRD_SDMD_TAG_SIZE          "size"
+#define IMRD_SDMD_TAG_TAGGED        "tagged"
+#define IMRD_SDMD_TAG_TAG           "tag"
+#define IMRD_SDMD_TAG_INTERNE       "interne"
+#define IMRD_SDMD_TAG_INTERNAL_NAME "internal_name"
+#define IMRD_SDMD_TAG_FORMAT        "format"
+#define IMRD_SDMD_TAG_XML           "xml"
+#define IMRD_SDMD_TAG_FML           "fml"
+#define IMRD_SDMD_TAG_DELIMITED     "delimited"
+#define IMRD_SDMD_TAG_ID            "id"
+#define IMRD_SDMD_TAG_DEFVAL        "defval"
+#define IMRD_SDMD_TAG_CNV           "cnv"
+#define IMRD_SDMD_TAG_ATTRIBUTE     "attribute"
+#define IMRD_SDMD_TAG_EXIST         "exist"
+
+
+/*----------------------------------------------------------------------------*/
+/* Local Definition                                                           */
+/*----------------------------------------------------------------------------*/
+
+
+
+typedef struct SDMT_StructInfo_Contexte
+{
+	char value[IMRD_SDMD_VALUE_LEN];
+    IMRT_Array_Xml_Path PathArray;
+    IMRT_Level_Tag PresentLevelTag;
+    IMRT_Msg_Id     CptMsg;
+    IMRT_Field_Id   CptField;
+    IMRT_Cnv_Id     CptCnv;
+	IMRT_Field    * CurrentField;
+	IMRT_Msg      * CurrentMessage;
+	IMRT_Cnv      * CurrentCnv;
+	NDT_Root      * RootMessage;
+	NDT_Root      * RootCnv;
+	xmlParserCtxt * SaxCtxHdl; 
+	IMRT_Error      FataError;
+	IMRT_Status     flagerror;
+}SDMT_StructInfo_Contexte;
+
+/*----------------------------------------------------------------------------*/
+/* Prototypes                                                                 */
+/*----------------------------------------------------------------------------*/
+
+#   ifdef _STRUCT_INFO_XML_C_
+
+static IMRT_Status error(SDMT_StructInfo_Contexte *ctx , const char *msg, ...);
+
+IMRT_Status startElementNsCnv( SDMT_StructInfo_Contexte * ctx , 
+             const xmlChar *localname,
+             const xmlChar *prefix,
+             const xmlChar *URI,
+             int nb_namespaces,
+             const xmlChar **namespaces,
+             int nb_attributes,
+             int nb_defaulted,
+             const xmlChar **attributes);
+
+IMRT_Status startElementNS( SDMT_StructInfo_Contexte * ctx , 
+		     const xmlChar *localname,
+		     const xmlChar *prefix,
+		     const xmlChar *URI,
+		     int nb_namespaces,
+		     const xmlChar **namespaces,
+		     int nb_attributes,
+		     int nb_defaulted,
+		     const xmlChar **attributes);
+
+IMRT_Status endElementNsCnv( SDMT_StructInfo_Contexte * ctx, 
+		   const xmlChar *localname,
+		   const xmlChar *prefix,
+		   const xmlChar *URI);
+
+IMRT_Status endElementNS( SDMT_StructInfo_Contexte * ctx, 
+		   const xmlChar *localname,
+		   const xmlChar *prefix,
+		   const xmlChar *URI);
+
+IMRT_Status charactersDebug(SDMT_StructInfo_Contexte * ctx , const xmlChar *ch, int len);
+
+IMRT_Status  SDM_XML_Load_Cnv(   char *demo_file, SDMT_StructInfo_Contexte *mycontexte);
+IMRT_Status  SDM_XML_Load_MsgAndField( char *demo_file, SDMT_StructInfo_Contexte * mycontexte);
+IMRT_Status SDM_XML_StructInfo_Init(IMRT_Path    Lib_Path);
+IMRT_Status  SDM_XML_Dump_Cnv_Header(FILE *dump_file);
+IMRT_Status  SDM_XML_Dump_Cnv_Body(FILE *dump_file);
+IMRT_Status  SDM_XML_Dump_Cnv_Footer(FILE *dump_file);
+IMRT_Status  SDM_XML_Dump_Cnv(void);
+IMRT_Status  SDM_XML_Dump_Msg_Header(FILE *dump_file);
+IMRT_Status  SDM_XML_Dump_Msg_Body(FILE *dump_file);
+IMRT_Status  SDM_XML_Dump_Msg_Footer(FILE *dump_file);
+IMRT_Status  SDM_XML_Dump_Msg(void);
+IMRT_Status  SDM_XML_StructInfo_Dump(void);
+
+#   else
+
+extern IMRT_Status  SDM_XML_Load_Cnv(   char *demo_file, SDMT_StructInfo_Contexte *mycontexte);
+extern IMRT_Status  SDM_XML_Load_MsgAndField( char *demo_file, SDMT_StructInfo_Contexte * mycontexte);
+extern IMRT_Status SDM_XML_StructInfo_Init(IMRT_Path    Lib_Path);
+extern IMRT_Status  SDM_XML_Dump_Cnv_Header(FILE *dump_file);
+extern IMRT_Status  SDM_XML_Dump_Cnv_Body(FILE *dump_file);
+extern IMRT_Status  SDM_XML_Dump_Cnv_Footer(FILE *dump_file);
+extern IMRT_Status  SDM_XML_Dump_Cnv(void);
+extern IMRT_Status  SDM_XML_Dump_Msg_Header(FILE *dump_file);
+extern IMRT_Status  SDM_XML_Dump_Msg_Body(FILE *dump_file);
+extern IMRT_Status  SDM_XML_Dump_Msg_Footer(FILE *dump_file);
+extern IMRT_Status  SDM_XML_Dump_Msg(void);
+extern IMRT_Status  SDM_XML_StructInfo_Dump(void);
+
+#   endif
+
+/*----------------------------------------------------------------------------*/
+/* Globale Variables                                                          */
+/*----------------------------------------------------------------------------*/
+
+#   ifdef _STRUCT_INFO_XML_C_
+
+/*xmlSAXHandler ErrorSAXHandlerStruct = {
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    1,
+    NULL,
+    NULL,
+    NULL,
+    NULL
+    };*/
+
+xmlSAXHandler SaxCnvHandlerStruct = {
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    (charactersSAXFunc)(charactersDebug),
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    (errorSAXFunc)error,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    1,
+    NULL,
+    (startElementNsSAX2Func)(startElementNsCnv),
+    (endElementNsSAX2Func)(endElementNsCnv),
+    NULL
+};
+xmlSAXHandler debugSAXHandlerStruct = {
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    (charactersSAXFunc)(charactersDebug),
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    (errorSAXFunc)(error),
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    1,
+    NULL,
+    (startElementNsSAX2Func)(startElementNS),
+    (endElementNsSAX2Func)(endElementNS),
+    NULL
+};
+
+
+
+#   endif
+
+/*----------------------------------------------------------------------------*/
+
+#endif
diff --git a/src/libxml/AUTHORS b/src/libxml/AUTHORS
new file mode 100644
index 0000000..cf2e9a6
--- /dev/null
+++ b/src/libxml/AUTHORS
@@ -0,0 +1,5 @@
+Daniel Veillard <daniel@veillard.com>
+Bjorn Reese <breese@users.sourceforge.net>
+William Brack <wbrack@mmm.com.hk>
+Igor Zlatkovic <igor@zlatkovic.com> for the Windows port
+Aleksey Sanin <aleksey@aleksey.com>
diff --git a/src/libxml/COPYING b/src/libxml/COPYING
new file mode 100644
index 0000000..417e955
--- /dev/null
+++ b/src/libxml/COPYING
@@ -0,0 +1,27 @@
+Except where otherwise noted in the source code (e.g. the files hash.c,
+list.c and the trio files, which are covered by a similar licence but
+with different Copyright notices) all the files are:
+
+ Copyright (C) 1998-2003 Daniel Veillard.  All Rights Reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is fur-
+nished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FIT-
+NESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+DANIEL VEILLARD BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CON-
+NECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of Daniel Veillard shall not
+be used in advertising or otherwise to promote the sale, use or other deal-
+ings in this Software without prior written authorization from him.
+
diff --git a/src/libxml/ChangeLog b/src/libxml/ChangeLog
new file mode 100644
index 0000000..09ed24a
--- /dev/null
+++ b/src/libxml/ChangeLog
@@ -0,0 +1,20389 @@
+Sun Apr 18 23:45:46 CEST 2004 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in: preparing 2.6.9 release
+	* doc/* News: updated and rebuilt the docs
+
+Sun Apr 18 22:51:43 CEST 2004 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: relaxed id() to not check taht the name(s) passed
+	  are actually NCName, decided this in agreement with Aleksey Sanin
+	  since existing specs like Visa3D broke that conformance checking
+	  and other tools seems to not implement it sigh...
+	* SAX2.c: check attribute decls for xml:id and the value is an
+	  NCName.
+	* test/xmlid/id_err* result/xmlid/id_err*: added error testing
+
+Sun Apr 18 21:46:17 CEST 2004 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: work around Microsoft compiler NaN bug raise reported
+	  by Mark Vakoc
+	* xmlschemas.c include/libxml/schemasInternals.h 
+	  include/libxml/xmlerror.h: fixed a recusive extention schemas
+	  compilation error raised by taihei goi
+
+Sun Apr 18 16:57:02 CEST 2004 Daniel Veillard <daniel@veillard.com>
+
+	* libxml.spec.in: keep the ChangeLog compressed 
+	* xmlreader.c: fix a segfault when using Close()
+	* python/tests/Makefile.am python/tests/reader8.py: test for
+	  the Close() reader API.
+
+Sat Apr 17 22:42:13 HKT 2004 William Brack <wbrack@mmm.com.hk>
+
+	* xmlschemas.c, xmlwriter.c, doc/examples/parse4.c,
+	  doc/examples/io2.c: minor warning cleanup (no change to logic)
+	* xinclude: fixed return value for internal function
+	  xmlXIncludeLoadFallback (now always 0 or -1)
+
+Sat Apr 17 21:32:32 HKT 2004 William Brack <wbrack@mmm.com.hk>
+
+	* valid.c: small enhancement to fix bug 139791
+
+Fri Apr 16 18:44:47 CEST 2004 Daniel Veillard <daniel@veillard.com>
+
+	* xmlschemas.c include/libxml/schemasInternals.h
+	  include/libxml/xmlerror.h: applied patches from Kasimier Buchcik
+	  for the attribute use support
+	* test/schemas/attruse* result/schemas/attruse*: added the
+	  tests to the regression suite.
+
+Fri Apr 16 18:22:25 CEST 2004 Daniel Veillard <daniel@veillard.com>
+
+	* xmlsave.c: move the TODO as comments as the function while not
+	  finished are usable as-is
+	* xmlschemas.c include/libxml/xmlerror.h: patch from Kasimier Buchcik
+	  implementing union
+	* test/schemas/union_0_0.x* result/schemas/union_0_0*: added example
+	* python/Makefile.am: applied fix from Mike Hommey
+
+Fri Apr 16 23:58:42 HKT 2004 William Brack <wbrack@mmm.com.hk>
+
+	* parser.c: fixed problem with detecting external dtd
+	  encoding (bug 135229).
+	* Makefile.am: minor change to test label
+
+Fri Apr 16 16:09:31 HKT 2004 William Brack <wbrack@mmm.com.hk>
+
+	* xinclude.c: fixed problem causing duplicate fallback
+	  execution (bug 139520)
+	* test/XInclude/docs/fallback2.xml result/XInclude/fallback2.*:
+	  added testcase
+
+Fri Apr  9 23:49:37 CEST 2004 Daniel Veillard <daniel@veillard.com>
+
+	* SAX2.c include/libxml/tree.h: adding xml:id draft support
+	* Makefile.am test/xmlid/id_tst* result/xmlid/id_tst*: adding
+	  4 first regression tests
+
+Fri Apr  9 11:56:08 CEST 2004 Daniel Veillard <daniel@veillard.com>
+
+	* libxml.spec.in: fixing Red Hat bug #120482 , libxml2-python
+	  should depend on the version of python used to compile it.
+
+Mon Apr  5 09:07:24 CEST 2004 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLparser.c: applied patch from James Bursa, frameset should
+	  close head.
+
+Fri Apr  2 22:02:24 HKT 2004 William Brack <wbrack@mmm.com.hk>
+
+	* relaxng.c: fixed problem in xmlRelaxNGCompareNameClasses
+	  which was causing check-relaxng-test-suite.py test 351 to fail.
+	  
+Fri Apr  2 17:03:48 HKT 2004 William Brack <wbrack@mmm.com.hk>
+
+	* nanohttp.c: implemented fix for M$ IIS redirect provided
+	  by Ian Hummel
+	* relaxng.c: fixed problem with notAllowed compilation
+	  (bug 138793)
+
+Thu Apr  1 22:07:52 CEST 2004 Daniel Veillard <daniel@veillard.com>
+
+	* uri.c: fix for xmlUriEscape on "http://user@somewhere.com"
+	  from Mark Vakoc.
+
+2004-04-01  Johan Dahlin  <johan@gnome.org>
+
+	* python/.cvsignore: Add generated files, to make cvs silent.
+
+Thu Apr  1 12:41:36 CEST 2004 Daniel Veillard <daniel@veillard.com>
+
+	* xmlschemas.c: small signed-ness patch from Steve Little
+
+Wed Mar 31 17:47:28 CEST 2004 Daniel Veillard <daniel@veillard.com>
+
+	* xmlregexp.c: patched a bug in parsing production 1 and 2 of
+	  xmlschemas regexp that William pointed out while working on
+	  #134120
+	* test/regexp/branch result/regexp/branch: added a specific
+	  regression test
+
+Wed Mar 31 09:50:32 HKT 2004 William Brack <wbrack@mmm.com.hk>
+
+	* Makefile.am: added PYTHONPATH to python tests for Schemas
+	  and RelaxNG
+	* test/xsdtest/xsdtestsuite.xml: added testfile for
+	  SchemasPythonTests
+	  
+Mon Mar 29 16:56:49 CEST 2004 Daniel Veillard <daniel@veillard.com>
+
+	* doc/examples/examples.xsl doc/examples/index.html: added
+	  information about compiling on Unix
+
+Mon Mar 29 14:18:12 CEST 2004 Daniel Veillard <daniel@veillard.com>
+
+	* catalog.c: fixes the comments for xmlCatalogDump and xmlDumpACatalog
+	* doc/*: rebuilt to update
+
+Sun Mar 28 18:11:41 CEST 2004 Daniel Veillard <daniel@veillard.com>
+
+	* xmlsave.c: optimize indentation based on the new context
+
+Sun Mar 28 14:17:10 CEST 2004 Daniel Veillard <daniel@veillard.com>
+
+	* doc/examples/xpath2.c doc/examples/xpath2.res: handle and explain
+	  a very tricky problem when modifying the tree based on an XPath
+	  result query.
+
+Sat Mar 27 09:56:14 PST 2004 William Brack <wbrack@mmm.com.hk>
+
+	* relaxng.c: fixed problem with IS_COMPILABLE flag
+	  (bug 130216)
+
+Fri Mar 26 18:28:32 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: applied patch from Dave Beckett to correct line number
+	  errors when using push with CDATA
+
+Fri Mar 26 14:53:58 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* doc/examples/xpath1.c: added a test template
+	* doc/examples/xpath2.c doc/examples/xpath2.res doc/examples/*:
+	  added a new example, and make valgrind target 
+
+Fri Mar 26 11:47:29 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: apply fix for #136693
+
+Thu Mar 25 20:21:01 MST 2004 John Fleck <jfleck@inkstain.net>
+
+	* doc/examples/io2.c
+	* doc/examples/io2.res
+	add xmlDocDumpMemory example in response to mailing list FAQ
+	(rebuilt xml and html also)
+
+Thu Mar 25 10:33:05 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* debugXML.c testXPath.c xmllint.c xmlschemastypes.c: applied
+	  patch from Mark Vakoc avoiding using xmlParse* option and use
+	  xmlRead* instead
+	* win32/Makefile.bcb: patch to Borland C++ builder from Eric Zurcher
+	  to avoid problems with some pathnames.
+
+Tue Mar 23 12:35:08 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in doc/* News: preparing 2.6.8 release, updated and rebuilt
+	  the docs.
+	* Makefile.am: use valgring fro the new Python based regression tests
+
+Mon Mar 22 20:07:27 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* relaxng.c: remove a memory leak on schemas type facets.
+	* check-relaxng-test-suite.py check-relaxng-test-suite2.py
+	  check-xsddata-test-suite.py: reduce verbosity
+	* configure.in Makefile.am: incorporated the Python regressions
+	  tests for Relax-NG and Schemas Datatype to "make tests"
+
+Mon Mar 22 16:16:18 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* xmlwriter.c include/libxml/xmlwriter.h doc/* : applied patch from
+	  Alfred Mickautsch for better DTD support.
+	* SAX2.c HTMLparser.c parser.c xinclude.c xmllint.c xmlreader.c
+	  xmlschemas.c: fixed bug #137867 i.e. fixed properly the way
+	  reference counting is handled in the XML parser which had the
+	  side effect of removing a lot of hazardous cruft added to try
+	  to fix the problems associated as they popped up.
+	* xmlIO.c: FILE * close fixup for stderr/stdout
+
+Sun Mar 21 19:19:41 HKT 2004 William Brack <wbrack@mmm.com.hk>
+
+	* relaxng.c: added an error message when an element is not
+	  found within a <choice> (bug 126093)
+	  
+Sat Mar 20 22:25:18 HKT 2004 William Brack <wbrack@mmm.com.hk>
+
+	* xmlregexp.c: enhanced the logic of parsing char groups to
+	  better handle initial or ending '-' (bug 135972)
+
+Sat Mar 20 19:26:03 HKT 2004 William Brack <wbrack@mmm.com.hk>
+
+	* relaxng.c: added check for external reference in 
+	  xmlRelaxNGGetElements (bug 137718)
+	* test/relaxng/rngbug-001.*, result/relaxng/rngbug-001*: added
+	  regression test for above
+
+Wed Mar 17 16:37:22 HKT 2004 William Brack <wbrack@mmm.com.hk>
+
+	* nanohttp.c: added a close for the local file descriptor
+	  (bug 137474)
+
+Mon Mar 15 15:46:59 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* xmlsave.c: switched the output routines to use the new context.
+
+Mon Mar 15 10:37:18 HKT 2004 William Brack <wbrack@mmm.com.hk>
+
+	* relaxng.c: enhanced to ignore XML_XINCLUDE_START and XML_XINCLUDE_END
+	  nodes (bug 137153)
+
+Sun Mar 14 13:19:20 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* xmlschemastypes.c: applied patch from John Belmonte for anyURI.
+
+Wed Mar 10 17:22:48 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: fix bug reported by Holger Rauch
+	* test/att8 result/noent/att8 result/att8 result/att8.rdr
+	  result/att8.sax: added the test to th regression suite
+
+Wed Mar 10 19:42:22 HKT 2004 William Brack <wbrack@mmm.com.hk>
+
+	* doc/search.php: Minor change for later verson of php requiring
+	  $HTTP_GET_VARS.
+
+Wed Mar 10 00:12:31 HKT 2004 William Brack <wbrack@mmm.com.hk>
+
+	* tree.c: Changed the flag to xmlDocCopyNode (and similar routines),
+	  previously used only for recursion, to use a value of '2' to
+	  indicate copy properties & namespaces, but not children.
+	* xinclude.c: changed the handling of ranges to use the above new
+	  facility.  Fixes Bug 134268.
+
+Tue Mar  9 18:48:51 HKT 2004 William Brack <wbrack@mmm.com.hk>
+
+	* win32/Makefile.bcb, win32/Makefile.mingw, win32/Makefile.msvc:
+	  added new module xmlsave with patch supplied by Eric Zurcher
+	  (second attempt - don't know what happened to the first one!)
+
+Tue Mar  9 09:59:25 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* python/libxml.c python/libxml.py: applied patch from Anthony Carrico
+	  providing Python bindings for the Canonicalization C14N support.
+
+Mon Mar  8 11:12:23 CET 2004 Hagen Moebius <hagen.moebius@starschiffchen.de>
+
+	* .cvsignore and python/.cvsignore patched
+
+Mon Mar  8 22:33:14 HKT 2004 William Brack <wbrack@mmm.com.hk>
+
+	* xinclude.c: enhanced to assure that if xpointer is called
+	  for a document, the XML_PARSE_NOENT flag is set before parsing
+	  the included document so that entities will automatically get
+	  taken care of.
+	* xpointer.c: corrected code so that, if an XML_ENTITY_REF node
+	  is encountered, it will log it and not crash (bug 135713)
+
+Sun Mar  7 19:03:48 HKT 2004 William Brack <wbrack@mmm.com.hk>
+
+	* xinclude.c: modified to make sub-includes inherit the
+	  parse flags from the parent document (bug 132597)
+
+Fri Mar  5 01:13:22 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* xmlschemas.c: QName handling fixes for the XML Schemas
+	  support from Adam Dickmeiss
+	* test/schemas/po1_0.xsd: also fix the schemas
+	* test/schemas/ns[12]* result/schemas/ns[12]*: added the specific
+	  regression tests
+
+Thu Mar  4 23:03:02 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in doc/Makefile.am include/libxml/Makefile.am:
+	  paalied patch from Julio M. Merino Vidal fixing bug #134751
+	  to fix --with-html-dir option.
+	* doc/*: rebuilt fully the docs 
+	* doc/html/libxml-xmlsave.html: new file from new header.
+
+Thu Mar  4 16:57:50 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* debugXML.c testHTML.c tree.c doc/examples/*.c
+	  include/libxml/xmlsave.h: fixing compilation bug with some options
+	  disabled as well as --with-minimum should fix #134695
+
+Thu Mar  4 15:00:45 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* xmlcatalog.c: allow fallback to URI lookup when SYSTEM fails,
+	  should close #134092
+
+Thu Mar  4 14:39:38 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am tree.c xmlsave.c include/libxml/xmlsave.h: commiting
+	  the new xmlsave module before the actuall big code change.
+
+Thu Mar  4 12:38:53 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* xmlschemas.c: applied patch from Adam Dickmeiss for mixed content
+	* test/schemas/mixed* result/schemas/mixed*: added his regression
+	  tests too.
+
+Mon Mar  1 15:22:06 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* testSAX.c: fix a compilation problem about a missing timb include
+
+Sat Feb 28 22:35:32 HKT 2004 William Brack <wbrack@mmm.com.hk>
+
+	* testSAX.c: small enhancement to prevent trying to print
+	  strings with null pointers (caused "make tests" errors on
+	  HP-UX)
+
+Thu Feb 26 20:19:40 MST 2004 John Fleck <jfleck@inkstain.net>
+
+	* doc/xmllint.xml
+	* doc/xmllint.1
+	* doc/xmllint.html
+	* doc/xmlcatalog_man.xml
+	* doc/xmlcatalog.1
+	* doc/xmlcatalog_man.html
+	applying patch from Mike Hommey to clarify XML_CATALOG_FILES
+	use
+
+Thu Feb 26 23:47:43 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am: patch for cross-compilation to Windows from
+	  Christophe de VIENNE.
+
+Thu Feb 26 18:52:11 HKT 2004 William Brack <wbrack@mmm.com.hk>
+
+	* doc/*.html, doc/html/*.html: regenerated docs using older
+	  version of xsltproc pending resolution of AVT problem
+
+Thu Feb 26 10:56:29 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am: applied patch from Charles Bozeman to not use
+	  the system xmllint.
+
+Wed Feb 25 18:07:05 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/xmlexports.h: applied patch from Roland Schwingel
+	  for MingW
+
+Wed Feb 25 13:57:25 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am catalog.c configure.in: applied a cleanup patch
+	  from Peter Breitenlohner
+	* tree.c: removed a doc build warning by fixing a param comment
+	* doc/* : rebuilt the docs
+
+Wed Feb 25 13:33:07 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* valid.c HTMLparser.c: avoid ID error message if using
+	  HTML_PARSE_NOERROR should fix #130762
+
+Wed Feb 25 12:50:53 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* debugXML.c relaxng.c valid.c xinclude.c xmllint.c xmlreader.c:
+	  fixing compilation and link option when configuring with
+	  --without-valid should fix #135309
+
+Wed Feb 25 11:36:06 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* catalog.c: fixed the main issues reported by Peter Breitenlohner
+	* parser.c: cleanup
+	* valid.c: speedup patch from Petr Pajas
+
+Wed Feb 25 16:07:14 HKT 2004 William Brack <wbrack@mmm.com.hk>
+
+	* xpath.c: fixed a memory leak (xmlXPathLangFunction) reported
+	  on the list by Mike Hommey
+
+Mon Feb 23 17:28:34 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* doc/* NEWS configure.in: preparing 2.6.7 release, updated and
+	  rebuilt the documentation.
+
+Mon Feb 23 11:52:12 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* python/tests/*.py: applied patch from Malcolm Tredinnick
+	  to avoid tabs in python sources, should fix #135095
+
+Sun Feb 22 23:16:23 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* testSAX.c: add --timing option
+	* relaxng.c: use the psvi field of the nodes instead of _private
+	  which may be used for other purposes.
+
+Sat Feb 21 16:57:48 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* encoding.c: small patch to try to fix a warning with Sun One compiler
+
+Sat Feb 21 16:22:35 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* encoding.c: small patch removing a warning with MS compiler.
+
+Sat Feb 21 13:52:30 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* debugXML.c: added "relaxng" option to the debugging shell
+	* Makefile.am test/errors/* result/errors/*: some regression tests
+	  for some error tests cases.
+
+Fri Feb 20 09:56:47 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: xmlAttrSerializeTxtContent don't segfault if NULL
+	  is passed.
+	* test/att7 result//att7*: adding an old regression test
+	  laying around on my laptop
+
+Thu Feb 19 17:33:36 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* xmlreader.c: fixed xmllint --memory --stream memory consumption
+	  on large file by using xmlParserInputBufferCreateStatic() with
+	  the mmap'ed file 
+
+Thu Feb 19 13:56:53 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: some clarification in xmlDocDumpMemory() documentation
+	* xmllint.c: fixed xmllint --stream --timing to get timings back
+
+Wed Feb 18 15:20:42 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: fixed a problem in push mode when attribute contains
+	  unescaped '>' characters, fixes bug #134566
+	* test/att6 result//att6*: added the test to the regression suite
+
+Tue Feb 17 17:26:31 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* valid.c: removing a non-linear behaviour from ID/IDREF raised
+	  by Petr Pajas. Call xmlListAppend instead of xmlListInsert in
+	  xmlAddRef
+
+Tue Feb 17 13:27:27 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* python/tests/indexes.py python/tests/reader.py: indicated
+	  encoding of the test file, needed for python 2.3
+
+Tue Feb 17 21:08:11 HKT 2004 William Brack <wbrack@mmm.com.hk>
+
+	* xpath.c: fixed problem with numbers having > 19
+	  fractional places (bug 133921)
+
+Tue Feb 17 12:47:20 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: applied optimization patch from Petr Pajas
+
+Tue Feb 17 12:39:08 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* xmlwriter.c include/libxml/xmlwriter.h: applied update
+	  from Alfred Mickautsch and the added patch from Lucas Brasilino
+
+Sun Feb 15 12:01:30 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* benchmark.png index.html xml.html: updating the benchmark
+	  graph and using a PNG instead of a GIF
+	* xmlreader.c: updated the TODO
+
+Sat Feb 14 18:55:40 MST 2004 John Fleck <jfleck@inkstain.net>
+
+	* doc/tutorial/xmltutorial.xml
+	* doc/tutorial/xmltutorial.pdf
+	* doc/tutorial/*.html
+	Fix bug in XPath example in the tutorial, thanks to Carlos, whose
+	last name I don't know, for pointing this out
+
+Thu Feb 12 16:28:12 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* NEWS configure.in: preparing release of 2.6.6
+	* doc/*: updated the docs and rebuilt them
+
+Thu Feb 12 13:41:16 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* xmlregexp.c: fixing bug #132930 with the provided patch, a bit
+	  suspicious about it but this is fairly contained and regression
+	  tests still passes.
+	* test/schemas/all1* result/schemas/all1*: added the test to
+	  the regression suite.
+
+Thu Feb 12 12:54:26 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: fixed bug #132575 about finding the end of the
+	  internal subset in push mode.
+	* test/intsubset.xml result/intsubset.xml* result/noent/intsubset.xml:
+	  added the test to the regression suite
+
+Wed Feb 11 14:19:31 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* parserInternals.c xmlIO.c encoding.c include/libxml/parser.h
+	  include/libxml/xmlIO.h: added xmlByteConsumed() interface
+	* doc/*: updated the benchmark rebuilt the docs
+	* python/tests/Makefile.am python/tests/indexes.py: added a
+	  specific regression test for xmlByteConsumed()
+	* include/libxml/encoding.h rngparser.c tree.c: small cleanups
+
+Wed Feb 11 08:13:58 HKT 2004 William Brack <wbrack@mmm.com.hk
+
+	* tree.c: fixed missing output of internal DTD param entities when
+	  nothing else present in DTD (bug 134052)
+
+Tue Feb 10 19:24:38 HKT 2004 William Brack <wbrack@mmm.com.hk>
+
+	* encoding.c: applied patch supplied by Christophe Dubach
+	  to fix problem with --with-minimum configuration
+	  (bug 133773)
+	* nanoftp.c: fixed potential buffer overflow problem,
+	  similar to fix just applied to nanohttp.c.
+	  
+Mon Feb  9 18:40:21 CET 2004 Igor Zlatkovic <igor@zlatkovic.com>
+
+	* nanohttp.c: fixed the fix for the buffer overflow, thanx
+	  William :-)
+
+Mon Feb  9 22:37:14 HKT 2004 William Brack <wbrack@mmm.com.hk>
+
+	* acinclude.m4, configure.in: fixed problem concerning
+	  determining SOCKLEN_T as pointed out by Daniel Richard G.
+	  on the mailing list
+
+Mon Feb  9 15:31:24 CET 2004 Igor Zlatkovic <igor@zlatkovic.com>
+
+	* nanohttp.c: fixed buffer overflow reported by Yuuichi Teranishi
+
+Mon Feb  9 13:45:59 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: small patch from Philip Ludlam to avoid warnings.
+
+Mon Feb  9 13:41:47 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* encoding.c: applied a small patch from Alfred Mickautsch
+	  to avoid an out of bound error in isolat1ToUTF8()
+
+Mon Feb  9 13:35:50 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* xinclude.c: remove the warning on the 2001 namespace
+	* parser.c parserInternals.c xpath.c: remove some warnings
+	  when compiling with MSVC6
+	* nanohttp.c: applied a patch when using _WINSOCKAPI_
+
+Sun Feb  8 12:09:55 HKT 2004 William Brack <wbrack@mmm.com.hk>
+
+	* xinclude.c: added a small hack to fix interference between
+	  my fixes for bugs 132585 and 132588.
+	* python/libxml.c: fixed problem with serialization of namespace
+	  reported on the mailing list by Anthony Carrico
+
+Sat Feb  7 16:53:11 HKT 2004 William Brack <wbrack@mmm.com.hk>
+
+	* xinclude.c: fixed problem with function xmlXIncludeCopyRange
+	  (bug 133686).
+
+Fri Feb  6 21:03:41 HKT 2004 William Brack <wbrack@mmm.com.hk>
+
+	* xmlwriter.c: fixed problem with return value of
+	  xmlTextWriterWriteIndent() (bug 133297)
+
+Fri Feb  6 19:07:04 HKT 2004 William Brack <wbrack@mmm.com.hk>
+
+	* xinclude.c: changed coding to output good XIncludes when
+	  one or more bad ones are present (bug 132588)
+
+Fri Feb  6 17:34:21 HKT 2004 William Brack <wbrack@mmm.com.hk>
+
+	* xinclude.c: corrected handling of empty fallback condition
+	  (bug 132585)
+
+Fri Feb  6 15:28:36 HKT 2004 William Brack <wbrack@mmm.com.hk>
+
+	* HTMLparser.c: added initialisation for ctxt->vctxt
+	  in HTMLInitParser (bug 133127)
+	* valid.c: minor cosmetic change (removed ATTRIBUTE_UNUSED
+	  from several function params)
+
+Tue Feb  3 16:48:57 PST 2004 William Brack <wbrack@mmm.com.hk>
+
+	* xinclude.c: fixed problem regarding freeing of dictionary
+	  when there are errors within an XInclude file (bug 133106).
+	  Thanks to Oleg Paraschenko for the assistance.
+
+Tue Feb  3 09:53:18 PST 2004 William Brack <wbrack@mmm.com.hk>
+
+	* xmlschemastypes.c: fixed validation of maxLength with no
+	  content using patch submitted by Eric Haszlakiewicz
+	  (bug 133259)
+
+Tue Feb  3 09:21:09 CET 2004 Igor Zlatkovic <igor@zlatkovic.com>
+
+	* include/libxml/xmlreader.h include/libxml/xmlmemory.h: added
+	  calling convention to the public function prototypes (rep by
+	  Cameron Johnson)
+	* include/libxml/xmlexports.h: fixed mingw+msys compilation
+	  (rep by Mikhail Grushinskiy)
+	
+Mon Feb  2 20:22:18 PST 2004 William Brack <wbrack@mmm.com.hk>
+
+	* xmlwriter.c: enhanced output indenting (bug 133264)
+	
+Mon Feb  2 16:13:33 PST 2004 William Brack <wbrack@mmm.com.hk>
+
+	* xmlreader.c, include/libxml/xmlreader.h: applied patch from
+	  Steve Ball to provide structured error reports.
+
+Sun Feb  1 01:48:14 PST 2004 William Brack <wbrack@mmm.com.hk>
+
+	* tree.c, include/libxml/tree.h: moved serialization of
+	  attribute text data (xmlSerializeContent) into a separate
+	  routine (xmlSerializeTxtContent) so it can be used by xmlwriter.c
+	* xmlwriter.c: changed handling of attribute string to use the
+	  routine above (fixed bug 131548)
+
+Sat Jan 31 08:22:02 MST 2004 John Fleck <jfleck@inkstain.net
+
+	* doc/examples/reader1.c, reader2.c, reader3.c
+	* doc/examples/examples.xml
+	* doc/examples/*.html
+	add note that reader examples need libmxl2 > 2.6, rebuild
+	html - this time doing it correctly :-)
+
+Fri Jan 30 20:45:36 MST 2004 John Fleck <jfleck@inkstain.net>
+
+	* doc/examples/examples.xml
+	* doc/examples/*.html
+	add note that reader examples need libmxl2 > 2.6, rebuild
+	html
+
+Thu Jan 29 23:51:48 PST 2004 William Brack <wbrack@mmm.com.hk>
+
+	* xpath.c: added (void *) type override to prevent
+	  warning on Solaris (Bug 132671)
+
+Wed Jan 28 07:20:37 MST 2004 John Fleck <jfleck@inkstain.net>
+
+	* doc/examples/Makefile.am
+	per Jan. 15 email to the list from oliverst, the index.html
+	file from this directory wasn't making it into the tarball
+
+Mon Jan 26 18:01:00 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* acinclude.m4: applied fix from Alexander Winston for a problem
+	  related to automake-1.8 , c.f. #132513 and #129861
+
+Mon Jan 26 12:53:11 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* doc/examples/index.py: don't rely on . being on the path for
+	  make tests, should keep Mr. Crozat quiet until next time...
+
+Sun Jan 25 21:45:03 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in NEWS doc/*: preparing release 2.6.5, rebuilt the
+	  docs, checked rngparser stuff does not end up in the tarball
+
+Sun Jan 25 20:59:20 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* python/libxml.c: applied patch from Frederic Peters
+	  fixing the wrong arg order in xpath callback in bug #130980
+
+Sun Jan 25 20:52:09 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* xinclude.c: fixing #130453 XInclude element with no href attribute
+	* relaxng.c rngparser.c include/libxml2/relaxng.h: fully integrating 
+	  the compact syntax will require more work, postponed for the
+	  2.6.5 release.
+
+Sat Jan 24 09:30:22 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/schemasInternals.h xmlschemas.c: applied patch from
+	  Steve Ball to avoid a double-free.
+
+Fri Jan 23 14:03:21 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* doc/examples/*: added io1.c an example ox xmlIO usage and io1.res
+	  test result, fixed a awful lot of memory leaks showing up in
+	  testWriter.c, changed the examples and the Makefiles to test
+	  memory leaks.
+	* xmlwriter.c: fixed a memory leak
+	* Makefile.am: run the doc/examples regression tests as part of
+	  make tests
+	* xpath.c include/libxml/xpath.h: added xmlXPathCtxtCompile() to
+	  compile an XPath expression within a context, currently the goal
+	  is to be able to reuse the XSLT stylesheet dictionnary, but this
+	  opens the door to others possible optimizations.
+	* dict.c include/libxml/dict.h: added xmlDictCreateSub() which allows
+	  to build a new dictionnary based on another read-only dictionnary.
+	  This is needed for XSLT to keep the stylesheet dictionnary read-only
+	  while being able to reuse the strings for the transformation
+	  dictionnary.
+	* xinclude.c: fixed a dictionnar reference counting problem occuring
+	  when document parsing failed.
+	* testSAX.c: adding option --repeat for timing 100times the parsing
+	* doc/* : rebuilt all the docs
+
+Thu Jan 22 14:17:05 2004  Aleksey Sanin  <aleksey@aleksey.com>
+
+	* xmlmemory.c: make xmlReallocLoc() accept NULL pointer
+
+Thu Jan 22 08:26:20 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* xmlschemastypes.c: applied patch from John Belmonte for
+	  normalizedString datatype support.
+
+Thu Jan 22 10:43:22 HKT 2004 William Brack <wbrack@mmm.com.hk>
+
+	* xpath.c: fixed problem with union when last() is used
+	  in predicate (bug #131971)
+	* xpointer.c: minor change to comment for doc generation
+
+Wed Jan 21 17:03:17 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: fixed bug #131745 raised by Shaun McCance with the
+	  suggested patch
+
+Wed Jan 21 10:59:55 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* xmlwriter.c: applied patch from Alfred Mickautsch fixing a memory
+	  leak reported on the list.
+
+Thu Jan 15 00:48:46 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* python/generator.py python/tests/tstLastError.py: applied
+	  patch from Stephane Bidoul to add enums to the Python bindings.
+
+Tue Jan 13 21:50:05 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* testHTML.c: another small patch from Mark Vadoc
+
+Tue Jan 13 21:39:58 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLparser.c relaxng.c testRelax.c testSchemas.c: applied
+	  patch from Mark Vadoc to not use SAX1 unless necessary.
+
+Mon Jan 12 17:22:57 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* dict.c parser.c xmlstring.c: some parser optimizations,
+	  xmllint --memory --timing --repeat --stream ./db10000.xml
+	  went down from 16.5 secs to 15.5 secs.
+
+Thu Jan  8 17:57:50 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* xmlschemas.c: removed a memory leak remaining from the switch
+	  to a dictionnary for string allocations c.f. #130891
+
+Thu Jan  8 17:48:46 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* xmlreader.c: fixing some problem if configured --without-xinclude
+	  c.f. #130902
+
+Thu Jan  8 17:42:48 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in: changed AC_OUTPUT() macro to avoid a cygwin problem
+	  c.f. #130896
+
+Thu Jan  8 00:36:00 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* win32/Makefile.bcb win32/Makefile.mingw win32/Makefile.msvc:
+	  applying patch from Mark Vakoc for Windows
+	* doc/catalog.html doc/encoding.html doc/xml.html: applied doc
+	  fixes from Sven Zimmerman
+
+Tue Jan  6 23:51:46 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* python/libxml2-python-api.xml python/libxml_wrap.h python/types.c
+	  python/tests/Makefile.am python/tests/tstLastError.py: applied 
+	  patch from Stephane Bidoul for structured error handling from
+	  python, and the associated test
+
+Tue Jan  6 23:18:11 HKT 2004 William Brack <wbrack@mmm.com.hk>
+
+	* configure.in: fixed Bug130593
+	* xmlwriter.c: fixed compilation warning
+
+Tue Jan  6 15:15:23 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/xmlstring.h: fixed the comment in the header
+	* doc/*: rebuilt the docs
+
+Tue Jan  6 19:40:04 HKT 2004 William Brack <wbrack@mmm.com.hk>
+
+	* encoding.c, parser.c, xmlstring.c, Makefile.am,
+	  include/libxml/Makefile.am, include/libxml/catalog.c,
+	  include/libxml/chvalid.h, include/libxml/encoding.h,
+	  include/libxml/parser.h, include/libxml/relaxng.h,
+	  include/libxml/tree.h, include/libxml/xmlwriter.h,
+	  include/libxml/xmlstring.h:
+	  moved string and UTF8 routines out of parser.c and encoding.c
+	  into a new module xmlstring.c with include file
+	  include/libxml/xmlstring.h mostly using patches from Reid
+	  Spencer.  Since xmlChar now defined in xmlstring.h, several
+	  include files needed to have a #include added for safety.
+	* doc/apibuild.py: added some additional sorting for various
+	  references displayed in the APIxxx.html files.  Rebuilt the
+	  docs, and also added new file for xmlstring module.
+	* configure.in: small addition to help my testing; no effect on
+	  normal usage.
+	* doc/search.php: added $_GET[query] so that persistent globals
+	  can be disabled (for recent versions of PHP)
+
+Mon Jan  5 20:47:07 MST 2004 John Fleck <jfleck@inkstain.net>
+
+	* doc/tutorial/customfo.xsl
+	* doc/tutorial/customhtml.xsl
+	update custom tutorial-building stylesheets in preparation
+	for tutorial update
+
+Tue Jan  6 00:10:33 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* rngparser.c: commiting the compact relax ng parser. It's not
+	  completely finished, it's not integrated but I want to save the
+	  current state
+
+Mon Jan  5 22:22:48 HKT 2004 William Brack <wbrack@mmm.com.hk>
+
+	* doc/apibuild.py, doc/APIconstructors.html, doc/libxml2-refs.xml,
+	  win32/libxml2.def.src: fixed apibuild.py's generation of
+	  "constructors" to be in alphabetical order (instead of previous
+	  random sequence); regenerated resulting files.
+
+Mon Jan  5 14:03:59 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* xmlwriter.c: applied patch from Lucas Brasilino fixing an indent
+	  problem.
+
+Sun Jan  4 18:54:29 MST 2004 John Fleck <jfleck@inkstain.net>
+
+	* doc/newapi.xsl: change background color of function
+	declaration to improve readability
+	* doc/*: rebuild docs with new stylesheet
+
+Sun Jan  4 22:45:14 HKT 2004 William Brack <wbarck@mmm.com.hk>
+
+	* parser.c, include/libxml/parser.h: added a routine
+	  xmlStrncatNew to create a new string from 2 frags.
+	* tree.c: added code to check if node content is from
+	  dictionary before trying to change or concatenate.
+
+Sun Jan  4 08:57:51 HKT 2004 William Brack <wbrack@mmm.com.hk>
+
+	* xmlmemory.c: applied suggestion from Miloslav Trmac (see
+	  Bug 130419) and eliminated xmlInitMemoryDone.  More
+	  improvement needed.
+	* xml2-config.in: added an additional flag (--exec-prefix) to
+	  allow library directory to be different from include directory
+	  (Bug 129558).
+	  
+Fri Jan  2 21:22:18 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* error.c: applied patch from Stéphane Bidoul for structured error
+	  reporting.
+
+Fri Jan  2 21:03:17 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/xmlwriter.h xmlwriter.c: applied the patch from
+	  Lucas Brasilino to add indentation support to xmlWriter
+
+Fri Jan  2 22:58:29 HKT 2004 William Brack <wbrack@mmm.com.hk>
+
+	* xinclude.c: fixed problem with "recursive" include (fallback
+	  contains another include - Bug 129969)
+
+Fri Jan  2 11:40:06 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+	* SAX2.c: found and fixed a bug misallocating some non
+	  blank text node strings from the dictionnary.
+	* xmlmemory.c: fixed a problem with the memory debug mutex
+	  release.
+
+Wed Dec 31 22:02:37 HKT 2003 William Brack <wbrack@mmm.com.hk>
+
+	* xinclude.c: fixed problem caused by wrong dictionary
+	  reference count, reported on the list by Christopher
+	  Grayce.
+
+Wed Dec 31 15:55:55 HKT 2003 William Brack <wbrack@mmm.com.hk>
+
+	* python/generator.py, python/libxml2class.txt: fixed problem
+	  pointed out by Stéphane Bidoul on the list.
+	* xinclude.c, xpointer.c, xpath.c, include/libxml/xpointer.h:
+	  completed modifications required to fix Bug 129967 (at last!).
+	  Now wait to see how long before further trouble...
+
+Tue Dec 30 16:26:13 HKT 2003 William Brack <wbrack@mmm.com.hk>
+
+	* parser.c, xmlmemory.c, include/libxml/xmlmemory.h: Fixed
+	  memory leak reported by Dave Beckett
+	* xmlschemas.c: Removed spurious comment reported on the mailing
+	  list
+	* xinclude.c, xpath.c, xpointer.c, libxml/include/xpointer.h:
+	  Further work on Bug 129967 concerning xpointer range handling
+	  and range-to function; much better, but still not complete
+
+Mon Dec 29 18:08:05 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* valid.c: xmlValidateElement could crash for element holding a 
+	  namespace declaration but not in a namespace. Oliver Fischer 
+	  provided the example.
+
+Mon Dec 29 11:29:31 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmllint.c: issue validation status on stderr, not stdout as suggested
+	  by Pawel Palucha
+	* result/relaxng/*: this change slightly all the output from RNG 
+	  regressions.
+
+Mon Dec 28 10:47:32 HKT 2003 William Brack <wbrack@mmm.com.hk>
+
+	* xmlschemas.c: edited a couple of comments in accordance with
+	  posting on the mailing list (no logic change)
+	* xpointer.c: working on Bug 129967, added check for NULL
+	  nodeset to prevent crash.  Further work required.
+	* xpath.c: working on Bug 129967, added code to handle
+	  XPATH_LOCATIONSET in RANGETO code, also added code to
+	  handle it in xmlXPathEvaluatePredicateResult.  Further
+	  work required.
+
+Sat Dec 27 12:32:58 HKT 2003 William Brack <wbrack@mmm.com.hk>
+
+	* xmlschemas.c: added tests for xs:all to assure minOccurs
+	  and maxOccurs <= 1 (Bug 130020)
+
+Sat Dec 27 09:53:06 HKT 2003 William Brack <wbrack@mmm.com.hk>
+
+	* xmlregexp.c: fixed xmlFAParseCharRange for Unicode ranges
+	  with patch from Charles Bozeman.
+
+Fri Dec 26 14:03:41 HKT 2003 William Brack <wbrack@mmm.com.hk>
+
+	* xmlregexp.c: fixed problem causing segfault on validation error
+	  condition (reported on mailing list)
+
+Thu Dec 25 21:16:22 HKT 2003 William Brack <wbrack@mmm.com.hk>
+
+	* xmlschemas.c: fixed missing dictionaries for Memory and Doc
+	  parser contexts (problem reported on mailing list)
+	* doc/apibuild.py: small change to prevent duplicate lines
+	  on API functions list.  It will take effect the next time
+	  the docs are rebuilt.
+
+Wed Dec 24 12:54:25 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in NEWS doc/*: updated the docs and prepared a new
+	  release 2.6.4
+
+Wed Dec 24 12:07:52 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* legacy.c: remove deprecated warning on startElement()
+
+Wed Dec 24 12:04:35 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xinclude.c result/XInclude/nodes2.*: XInclude xpointer support
+	  was broken with the new namespace. Fixes #129932
+
+Wed Dec 24 00:29:30 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmlschemas.c include/libxml/schemasInternals.h: types might be
+	  redefined in includes, quick fix to allow this but lacks the 
+	  equality of the redefinition test.
+
+Tue Dec 23 15:14:37 HKT 2003 William Brack <wbrack@mmm.com.hk>
+
+	* valid.c: fixed bug concerning validation using external
+	  dtd of element with mutiple namespace declarations
+	  (Bug 129821)
+
+Tue Dec 23 11:41:42 HKT 2003 William Brack <wbrack@mmm.com.hk>
+
+	* tree.c: inhibited production of "(null):" in xmlGetNodePath
+	  when node has default namespace (Bug 129710)
+
+Tue Dec 23 09:29:14 HKT 2003 William Brack <wbrack@mmm.com.hk>
+
+	* xpath.c: small enhancement to xmlXPathCmpNodes to assure
+	  document order for attributes is retained (Bug 129331)
+
+Mon Dec 22 19:06:16 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c xmlreader.c: change xmlReadFd() xmlCtxtReadFd()
+	  xmlReaderNewFd() xmlReaderForFd(), change those to not close
+	  the file descriptor. Updated the comment, should close #129683
+
+Mon Dec 22 00:34:09 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xinclude.c: fixed a serious problem in XInclude #129021
+
+Sun Dec 21 13:59:54 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: fixed bug #129489, propagation of parsing flags 
+	  in entities.
+	* parser.c xmlreader.c: improved the comments of parsing options
+
+Sun Dec 21 18:14:04 HKT 2003 William Brack <wbrack@mmm.com.hk>
+
+	* python/Makefile.am, python/tests/Makefile.am,
+	  doc/Makefile.am: applied fixes to allow build from
+	  'outside' directory (Bug 129172)
+
+Sat Dec 20 16:42:07 MST 2003 John Fleck <jfleck@inkstain.net>
+
+	* tree.c - add explanation of namespace inheritance when
+	ns is NULL to xmlNewChild and xmlNewTextChild API doc
+
+Sat Dec 20 18:17:28 HKT 2003 William Brack <wbrack@mmm.com.hk>
+
+	* include/libxml/xpathInternals.h: undid last change (my
+	  bad).  Put necessary fix in libxslt/libexslt instead.
+	* include/libxml/DOCBparser.h: put test for __GCC__ on
+	  warning directive (Bug 129105)
+
+Sat Dec 20 10:48:37 HKT 2003 William Brack <wbrack@mmm.com.hk>
+
+	* include/libxml/xpathInternals.h: fixed xmlXPathReturnString
+	  to cater for NULL pointer (bug 129561)
+	* globals.c: added comment to suppress documentation warning
+	* doc/apibuild.py: fixed problem which caused last APIchunkxx.html
+	  to be lost.  Rebuilt doc/* (including adding APIchunk26.html)
+	  
+Fri Dec 19 18:24:02 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmlreader.c: trying to fix #129692 xmlTextReaderExpand() when
+	  using an xmlReaderWalker()
+
+Thu Dec 18 20:10:34 MST 2003 John Fleck <jfleck@inkstain.net>
+
+	* tree.c: fix misc. typos in doc comments
+	* include/libxml/tree.h: elaborate on macro define doc comments
+	* doc/*: rebuild docs
+
+Wed Dec 17 16:07:33 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* doc/examples/*: don't call the result files .out but .res as
+	  the Makefiles tend to try generating binaries for .out targets...
+
+Tue Dec 16 20:53:54 MST 2003 John Fleck <jfleck@inkstain.net>
+
+	* doc/html/libxml-pattern.html: - cvs add API docs for new
+	pattern stuff
+
+Tue Dec 16 20:40:40 MST 2003 John Fleck <jfleck@inkstain.net>
+
+	* tree.c
+	* doc/*:
+	Elaborate in documentation discussion of xmlNewChild
+	and xmlNewTextChild. Thanks to Steve Lenti for pointing
+	out the usefulness of a more explicit explanation of the
+	reserved character escaping issue.
+
+Fri Dec 12 15:55:15 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmlcatalog.c: applied patch from Stefan Kost
+
+Thu Dec 11 15:15:31 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* doc/examples/testWriter.c: applied small fix from Lucas Brasilino
+
+Thu Dec 11 14:55:22 CET 2003 Igor Zlatkovic <igor@zlatkovic.com>
+
+	* win32/Makefile.* win32/configure.js: Added pattern support
+
+Wed Dec 10 14:11:20 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in doc/* libxml.spec.in: preparing release of
+	  libxml2-2.6.3, updated and regenerated the docs.
+
+Wed Dec 10 11:43:33 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* SAX2.c pattern.c: removed some compilation warnings
+
+Wed Dec 10 11:16:29 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmllint.c: fixing bug #119264 xmllint failing to report
+	  serialization errors in some cases.
+
+Tue Dec  9 23:50:23 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* entities.c: fixed an XML entites content serialization 
+	  potentially triggered by XInclude, see #126817
+
+Tue Dec  9 16:12:50 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmlwriter.c: applied the patch to xmlTextWriterStartPI()
+	  suggested by Daniel Schulman in #128313
+
+Tue Dec  9 15:18:32 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in Makefile.am: another patch from Kenneth Haley
+	  for Mingw, c.f. #128787
+
+Tue Dec  9 15:07:09 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/xmlexports.h: applied patch from Kenneth Haley
+	  for compiling on Mingw see #128786
+
+Tue Dec  9 14:52:59 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmllint.c: some flags were not passed down correctly as
+	  parsing options. Fixes #126806
+
+Tue Dec  9 12:29:26 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xinclude.c xmllint.c xmlreader.c include/libxml/xinclude.h
+	  include/libxml/xmlerror.h: augmented the XInclude API
+	  to be able to pass XML parser flags down to the Inclusion
+	  process. Also resynchronized with the Last Call W3C Working
+	  Draft 10 November 2003 for the xpointer attribute.
+	* Makefile.am test/XInclude/docs/nodes[23].xml 
+	  result/XInclude/*: augmented the tests for the new namespace and
+	  testing the xpointer attribute, changed the way error messages
+	  are tested
+	* doc/*: regenerated the documentation
+
+Mon Dec  8 18:38:26 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* error.c: filter warning messages if the global setting blocks them
+	* xinclude.c xmlreader.c include/libxml/xinclude.h
+	  include/libxml/xmlerror.h: updated the change of namespace at
+	  the XInclude level, raise a warning if the old one is found,
+	  and some cleanup
+
+Mon Dec  8 13:09:39 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: tentative fix for #126117 character reference in
+	  attributes output problem in some cornercase.
+
+Mon Dec  8 11:08:45 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* python/libxml.py: tried to fix the problems reported in 
+	  bug #126735
+	* xpath.c SAX2.c error.c parser.c valid.c include/libxml/xmlerror.h:
+	  fixed again some problem trying to use the structured error
+	  handlers, c.f. bug #126735
+	* result/VC/ElementValid: tiny change due to the fix
+
+Sun Dec  7 22:27:31 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* error.c: fixed __xmlRaiseError to use structured error handlers
+	  defined by xmlSetStructuredErrorFunc(), fixes bug #126211
+
+Sun Dec  7 20:30:53 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: attempt to fix #126211 ... 
+
+Fri Dec  5 17:07:29 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* pattern.c xmlreader.c xmllint.c include/libxml/pattern.h
+	  include/libxml/xmlreader.h: fixed the pattern interfaces
+	  but not yet the parser to handle the namespaces.
+	* doc/examples/reader3.c doc/*: fixed the example, rebuilt the docs.
+
+Fri Dec  5 15:49:44 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* globals.c xmlwriter.c doc/apibuild.py include/libxml/globals.h 
+	  include/libxml/pattern.h include/libxml/schemasInternals.h
+	  include/libxml/xmlexports.h include/libxml/xmlwriter.h: cleanup
+	  the make rebuild in doc, this include new directive to stop
+	  documentation warnings
+	* doc/* doc/html/*: rebuilt the docs
+	* pattern.c xmlreader.c include/libxml/pattern.h
+	  include/libxml/xmlreader.h: adding xmlTextReaderPreservePattern()
+	  to save nodes while scanning the tree with the reader, cleanup
+	  the way element were freed, and xmlTextReaderPreserve()
+	  implementation, the API might change for namespace binding support
+	  when compiling patterns.
+	* doc/examples/*: added reader3.c exposing the xmlTextReaderPreserve()
+
+Thu Dec  4 15:10:57 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* python/libxml.py: oops forgot to modify/commit the new code.
+
+Thu Dec  4 13:29:19 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* python/generator.py python/libxml.c python/libxml_wrap.h:
+	  cleanup the output buffer support to at least get the basic
+	  to work
+	* python/tests/outbuf.py python/tests/serialize.py: fixes and
+	  cleanup.
+	* include/libxml/xmlwriter.h: cleanup
+
+Wed Dec  3 21:38:56 MST 2003 John Fleck <jfleck@inkstain.net>
+
+	* include/libxml/xmlversion.h.in
+	* doc/*: add WITH_TRIO comment so it shows up in the docs, rebuild
+	  docs
+
+Wed Dec  3 13:10:08 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* config.h.in configure.in xmlregexp.c: fix bug #128401 affecting
+	  regexp quantifiers
+
+Tue Dec  2 23:29:56 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* pattern.c include/libxml/pattern.h: adding the pattern node
+	  selection code. Inheried in part from libxslt but smaller.
+	* Makefile.am configure.in include/libxml/xmlversion.h.in:
+	  integrated the pattern module, made it a configure time option
+	* xmllint.c: added --pattern to test when doing --stream
+
+Tue Dec  2 11:25:25 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmlreader.c: fixed a problem in xmlreader validation when
+	  streaming exposed by reader2 example.
+
+Mon Dec  1 20:40:51 MST 2003 John Fleck <jfleck@inkstain.net>
+
+	* doc/xml.html
+	* doc/docs.html:
+	add reference to the Code Examples page to docs.html list
+	of resources
+
+Mon Dec  1 12:30:28 CET 2003 Igor Zlatkovic <igor@zlatkovic.com>
+
+	* win32/Makefile.bcb win32/configure.js: Applied the BCB patch
+	  from Eric
+
+Sun Nov 30 21:33:37 MST 2003 John Fleck <jfleck@inkstain.net>
+
+	* include/libxml/xinclude.h
+	* doc/*: Add comments for macro definitions in xinclude.h and
+	rebuild the docs
+
+Sun Nov 30 21:06:29 MST 2003 John Fleck <jfleck@inkstain.net>
+
+	* doc/docdescr.doc
+	Updating William's explanation of how to build docs, 
+	reflecting Daniel's new docs build system
+
+Sat Nov 29 18:38:22 HKT 2003 William Brack <wbrack@mmm.com.hk>
+
+	* xmlmemory.c: enhanced by adding mutex to protect global
+	  structures in a multi-threading environment.  This fixed
+	  some random errors on the Threads regression tests.
+	  
+Fri Nov 28 21:39:49 MST 2003 John Fleck <jfleck@inkstain.net>
+
+	* doc/xml.html doc/python.html: fix tst.py text, which didn't
+	  import sys
+
+Fri Nov 28 17:28:47 HKT 2003 William Brack <wbrack@mmm.com.hk>
+
+	* encoding.c, include/libxml/encoding.h: Enhanced the handling of
+	  UTF-16, UTF-16LE and UTF-16BE encodings.  Now UTF-16 output is
+	  handled internally by default, with proper BOM and UTF-16LE
+	  encoding.  Native UTF-16LE and UTF-16BE encoding will not generate
+	  BOM on output, and will be automatically recognized on input.
+	* test/utf16lebom.xml, test/utf16bebom.xml, result/utf16?ebom*:
+	  added regression tests for above.
+	  
+Thu Nov 27 19:25:10 CET 2003 Igor Zlatkovic <igor@zlatkovic.com>
+
+	* win32/Makefile.* win32/configure.js: Modified to allow coexistent 
+	  build with all compilers. Added C-Runtime option for MSVC. Included
+	  xmlWriter.
+	* xmlwriter.c: Added IN_LIBXML macro
+
+Wed Nov 26 21:54:01 CET 2003 Igor Zlatkovic <igor@zlatkovic.com>
+
+	* win32/Makefile.bcb: applied patch from Eric
+
+Wed Nov 26 21:33:14 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/tree.h: stefan on IRC pointed out that XML_GET_LINE
+	  is broken on 2.6.x
+
+Tue Nov 25 18:39:44 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* entities.c: fixed #127877, never output &quot; in element content
+	* result/isolat3 result/slashdot16.xml result/noent/isolat3
+	  result/noent/slashdot16.xml result/valid/REC-xml-19980210.xml
+	  result/valid/index.xml result/valid/xlink.xml: this changes the
+	  output of a few tests
+
+Tue Nov 25 16:36:21 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/schemasInternals.h include/libxml/xmlerror.h
+	  testSchemas.c xmlschemas.c: added xsd:include support, fixed
+	  testSchemas behaviour when a schemas failed to parse.
+	* test/schemas/vdv-* result/schemas/vdv-first5_0_0*: added one
+	  test for xsd:include from Eric Van der Vlist
+
+Tue Nov 25 08:18:12 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: swapped the attribute defaulting and attribute checking
+	  parts of parsing a new element start, fixes bug #127772
+	* result/valid/127772.* test/valid/127772.xml
+	  test/valid/dtds/127772.dtd: added the example in the regression tests
+
+Tue Nov 25 08:00:15 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: moved xmlCleanupThreads() to the end of xmlCleanupParser()
+	  to avoid bug #127851
+
+Mon Nov 24 15:26:21 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmlregexp.c: fixing some Negative Character Group and
+	  Character Class Subtraction handling.
+
+Mon Nov 24 14:01:57 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmlregexp.c xmlschemas.c: more XML Schemas fixes based
+	  on Eric van der Vlist examples
+	* result/schemas/vdv-first4* test/schemas/vdv-first4*:
+	  added regression tests
+	* doc/examples/Makefile.am doc/examples/index.py: do not
+	  regenerate the index on make all target, but only on
+	  make rebuild to avoid troubles.
+
+Sat Nov 22 21:35:42 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmlschemas.c xmlschemastypes.c include/libxml/xmlerror.h
+	  include/libxml/schemasInternals.h: lot of bug fixes, cleanup,
+	  starting to add proper namespace support too.
+	* test/schemas/* result/schemas/*: added a number of tests
+	  fixed the result from some regression tests too.
+
+Fri Nov 21 20:50:59 MST 2003 John Fleck <jfleck@inkstain.net>
+
+	* doc/xml.html, docs.html: remove reference to gtk-doc now that
+	Daniel has removed it, fix link to George's IBM article, other
+	minor edits
+
+Fri Nov 21 01:26:00 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmlschemas.c: applied patch from Robert Stepanek to start 
+	  import os schemas support, cleaned up stuff and the patch.
+	* test/schemas/import0_0.* result/schemas/import0_0_0*: added test
+	  to regression, fixed a few regressions too.
+
+Thu Nov 20 22:58:00 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLparser.c: applied two parsing fixes from James Bursa
+
+Thu Nov 20 19:20:46 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* doc/examples/*: added two xmlReader examples
+	* xmlreader.c: cleaned up some bugs in the process
+
+Thu Nov 20 12:54:30 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmlwriter.c include/libxml/xmlwriter.h: applied patch from
+	  Alfred Mickautsch, bugfixes and comments
+	* doc/examples/*: added his test as the xmlWriter example
+	* doc/html/ doc/*.html: this resulted in some improvements
+	* include/libxml/hash.h: fixed an inclusion problem when
+	  <libxml/hash.h> wasn't preceeded by <xml/parser.h>
+
+Wed Nov 19 17:19:35 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xinclude.c: fix an error message
+	* doc/examples/*: added tree2 example from Lucas Brasilino
+
+Wed Nov 19 17:50:47 HKT 2003 William Brack <wbrack@mmm.com.hk>
+
+	* doc/newapi.xsl: improve the sort sequence for page content
+	* doc/html/*.html: regenerate the web pages
+
+Wed Nov 19 00:48:56 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am: do not package cvs versioning temp files.
+	* doc/apibuild.py doc/libxml2-api.xml doc/newapi.xsl: more cleanup,
+	  slightly improved the API xml format, fixed a lot of small
+	  rendering problems
+	* doc/html/libxml*.html: rebuilt
+
+Tue Nov 18 21:51:15 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/*.h include/libxml/*.h.in: modified the file
+	  header to add more informations, painful...
+	* genChRanges.py genUnicode.py: updated to generate said changes
+	  in headers
+	* doc/apibuild.py: extract headers, add them to libxml2-api.xml
+	* *.html *.xsl *.xml: updated the stylesheets to flag geprecated
+	  APIs modules. Updated the stylesheets, some cleanups, regenerated
+	* doc/html/*.html: regenerated added back book1 and libxml-lib.html
+
+Tue Nov 18 14:43:16 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* doc/Makefile.am doc/*.xsl doc/*.html doc/apibuild.py: cleaned up
+	  the build process to remove all remains from the old gtk-doc
+	  inherited, libxml2-refs.xml is now generated by apibuild.py, the
+	  stylesheets have been improved, and the API*html now generated
+	  are XHTML1 valid too
+
+Tue Nov 18 14:28:32 HKT 2003 William Brack <mmm.com.hk>
+
+	* genChRanges.py, chvalid.c, include/libxml/chvalid.h: minor
+	  enhancement to prevent comment with unreferenced variable.
+	* threads.c xmlreader.c xmlwriter.c: edited some comments to
+	  improve auto-generation of documentation
+	* apibuild.py: minor change to an error message
+
+Mon Nov 17 17:55:51 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* doc/apibuild.py doc/libxml2-api.xml doc/newapi.xsl: more cleanup,
+	  improving navigation
+	* doc/html/*.html: updated the result
+
+Mon Nov 17 14:54:38 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* doc/Makefile.am doc/apibuild.py doc/libxml2-api.xml doc/newapi.xsl:
+	  improvement of the stylesheets, fixed a API generation problem,
+	  switched the stylesheet and Makefile to build the HTML output.
+	* doc/html/*.html: complete update, ditched some old files, might
+	  introduce some breakage...
+
+Mon Nov 17 12:50:28 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* doc/newapi.xsl: lot of improvements, this starts looking good
+	  enough to be usable.
+
+Mon Nov 17 00:58:09 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* doc/newapi.xsl: stylesheet to build HTML pages from the
+	  API XML description, Work in Progress
+
+Sun Nov 16 16:03:24 HKT 2003 William Brack <wbrack@mmm.com.hk>
+
+	* xpath.c: fixed bug 126976 (string != empty nodeset
+	  should be false)
+
+Sun Nov 16 14:00:08 HKT 2003 William Brack <wbrack@mmm.com.hk>
+
+	* doc/html/*.html: Finally - found the problem with the
+	  page generation (XMLPUBFUN not recognized by gtkdoc).
+	  Re-created the pages using a temporary version of
+	  include/libxml/*.h.
+	* testOOMlib.c,include/libxml/encoding.h,
+	  include/libxml/schemasInternals.h,include/libxml/valid.h,
+	  include/libxml/xlink.h,include/libxml/xmlwin32version.h,
+	  include/libxml/xmlwin32version.h.in,
+	  include/libxml/xpathInternals.h: minor edit of comments
+	  to help automatic documentation generation
+	* doc/docdescr.doc: small elaboration
+	* doc/examples/test1.c,doc/examples/Makefile.am: re-commit
+	  (messed up on last try)
+	* xmlreader.c: minor change to clear warning.
+
+Sat Nov 15 19:20:32 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* Copyright: fixed some wording
+	* libxml.spec.in: make sure doc/examples is packaged
+	* include/libxml/tree.h valid.c xmlreader.c: fixed the really
+	  annoying problem about xmlRemoveID and xmlReader streaming.
+	  Thing looks fixed now, had to add a doc reference to the
+	  xmlID structure though...
+
+Sat Nov 15 09:53:36 MST 2003 John Fleck <jfleck@inkstain.net>
+
+	* doc/docdescr.doc: added description of man page building
+
+Sat Nov 15 19:08:22 HKT 2003 William Brack <wbrack@mmm.com.hk>
+
+	* doc/html/libxml-chvalid.html, doc/html/libxml-dict.html,
+	  doc/html/libxml-list.html, doc/html/libxml-testOOMlib.html,
+	  doc/html/libxml-wincecompat, doc/html/winsockcompat.html,
+	  doc/html/libxml-xmlexports.html, doc/html/libxml-xmlversion.html,
+	  doc/html/libxml-xmlwin32version.html, doc/html/libxml-xmlwriter.html:
+	  added missing pages for the website.
+
+Sat Nov 15 18:23:48 HKT 2003 William Brack <wbrack@mmm.com.hk>
+
+	* doc/Makefile.am doc/*.html doc/html/*.html: rebuilt the
+	  generated pages (again), manually restored doc/html/index.html
+	  and manually edited generated file doc/gnome-xml.xml to put
+	  in appropriate headings.
+	* doc/docdescr.doc: new file to describe details of the
+	  document generation (helps my memory for the next time)
+	* genChRanges.py,chvalid.c,include/libxml/chvalid.h: minor
+	  enhancement to please the automatic documentation generation.
+
+Fri Nov 14 23:47:31 HKT 2003 William Brack <wbrack@mmm.com.hk>
+
+	* catalog.c,relaxng.c,testAutomata.c,xpointer.c,genChRanges.py,
+	  chvalid.c,include/libxml/chvalid.h,doc/examples/test1.c:
+	  minor error cleanup for gcc-3.3.[12] compilation warnings.
+
+Fri Nov 14 15:08:13 HKT 2003 William Brack <wbrack@mmm.com.hk>
+
+	* tree.c: minor changes to some comments
+	* doc/*.html: rebuilt the generated HTML pages for changes
+	  from jfleck (bug 126945)
+	  
+Thu Nov 13 12:44:14 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* doc/examples/*: added Dodji's example, added output handling
+
+Thu Nov 13 11:35:35 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* doc/examples/*: added Aleksey XPath example, fixed bugs
+	  in the indexer
+
+Wed Nov 12 23:48:26 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* doc/*: integrating the examples in the navigation menus
+	* doc/examples/*: added make tests, updated the navigation,
+	  added a new test, cleanups, updates.
+
+Wed Nov 12 17:50:36 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* doc/*.html: rebuilt the generated HTML pages
+	* doc/examples/*: updated the stylesheets, added a synopsis,
+	  Makefile.am is now generated by index.py
+
+Wed Nov 12 01:38:16 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* doc/site.xsl doc/examples/Makefile.am doc/examples/index.html:
+	  added autogeneration of a web page for the examples
+	* doc/examples/example1.c doc/examples/.cvsignore
+	  doc/examples/examples.xml doc/examples/index.py: updated the
+	  informations extracted, improved the format and indexing.
+
+Tue Nov 11 22:08:59 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* check-xinclude-test-suite.py: less verbose on difference
+	* libxml.spec.in: cleanup
+	* parser.c: fixed xmlCleanupParser() doc
+	* doc/Makefile.am doc/apibuild.py doc/libxml2-api.xml
+	  doc/examples/Makefile.am doc/examples/example1.c 
+	  doc/examples/examples.xml doc/examples/index.py
+	  doc/examples/test1.xml: work on adding C examples and
+	  generating automated information about those. examples.xml
+	  is autogenerated describing the examples.
+	* example/Makefile.am: cleanup
+
+Mon Nov 10 23:47:03 HKT 2003 William Brack <wbrack@mmm.com.hk>
+
+	* genUnicode.py, xmlunicode.c, include/libxml/xmlunicode.h:
+	  fixed missing '-' in block names, enhanced the hack for
+	  ABI aliasing.
+
+Sun Nov  9 20:28:21 HKT 2003 William Brack <wbrack@mmm.com.hk>
+
+	* genUnicode.py, xmlunicode.c, include/libxml/xmlunicode.h,
+	  python/libxml2class.txt: enhanced for range checking,
+	  updated to Unicode version 4.0.1 (API docs also updated)
+	* python/generator.py: minor change to fix a warning
+	
+Wed Nov  5 23:46:36 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am: apply fix from Karl Eichwalder for script path
+
+Wed Nov  5 10:49:20 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* win32/configure.js: applied patch from Mark Vakoc to simplify
+	  his work from CVS checkouts.
+
+Tue Nov  4 21:16:47 MST 2003 John Fleck <jfleck@inkstain.net>
+
+	* doc/xmlreader.html: minor cleanups
+
+Tue Nov  4 15:52:28 PST 2003 William Brack <wbrack@mmm.com.hk>
+
+	* include/libxml/xmlversion.h.in: changed macro ATTRIBUTE_UNUSED
+	  for gcc so that, if undefined, it's defined as
+	  __attribute__((unused))
+
+Tue Nov  4 15:28:07 PST 2003 William Brack <wbrack@mmm.com.hk>
+
+	* python/generator.py: small enhancement to assure ATTRIBUTE_UNUSED
+	  appears after the variable declaration.
+	* valid.c: trivial change to eliminate a warning message
+
+Tue Nov  4 11:24:04 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in NEWS doc/*: preparing release 2.6.2, updated and
+	  rebuilt the docs
+
+Tue Nov  4 09:38:46 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmllint.c: change --html to make sure we use the HTML serialization
+	  rule by default when HTML parser is used, add --xmlout to allow to
+	  force the XML serializer on HTML.
+	* HTMLtree.c: ugly tweak to fix the output on <p> element and 
+	  solve #125093
+	* result/HTML/*: this changes the output of some tests
+
+Mon Nov  3 17:51:28 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xinclude.c: fixed bug #125812, about XPointer in XInclude 
+	  failing but not returning an error.
+
+Mon Nov  3 17:18:22 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* valid.c: fixed bug #125811 related to DTD post validation
+	  where the DTD doesn't pertain to a document.
+
+Mon Nov  3 15:25:58 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c xmlIO.c include/libxml/parserInternals.h: implemented
+	  the XML_PARSE_NONET parser option.
+	* xmllint.c: converted xmllint.c to use the option instead of 
+	  relying on the global resolver variable.
+
+Mon Nov  3 13:26:32 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xinclude.c xmlreader.c include/libxml/xinclude.h: adding XInclude
+	  support to the reader interface. Lot of testing of the walker,
+	  various bug fixes.
+	* xmllint.c: added --walker and made sure --xinclude --stream --debug
+	  works as expected
+	* Makefile.am result/dtd11.rdr result/ent6.rdr test/dtd11 test/ent6
+	  result/XInclude/*.rdr: added regression tests for the walker and
+	  XInclude xmlReader support, had to slightly change a couple of tests
+	  because the walker can't distinguish <foo/> from <foo></foo>
+
+Sat Nov  1 17:42:27 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c nanohttp.c threads.c: second BeOS patch from 
+	  Marcin 'Shard' Konicki
+
+Fri Oct 31 15:35:20 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: always generate line numbers
+
+Fri Oct 31 11:53:46 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: fixed another regression introduced in fixing #125823
+
+Fri Oct 31 11:33:18 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* python/libxml.c: previous fix for #124044 was broken, correct
+	  fix provided.
+	* HTMLparser.c parser.c parserInternals.c xmlIO.c: fix xmlStopParser()
+	  and the error handlers to address #125877
+
+Thu Oct 30 23:10:46 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: side effect of #123105 patch, namespace resolution
+	  would fail when defined in internal entities, fixes #125823
+
+Thu Oct 30 14:10:42 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* python/libxml.c: be more defensive in the xmlReader python bindings
+	  fixing bug #124044
+
+Thu Oct 30 11:14:31 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* valid.c: the a-posteriori DTD validation code was not validating
+	  the namespace declarations, this fixes #124110
+
+Wed Oct 29 14:13:03 PDT 2003 William Brack <wbrack@mmm.com.hk>
+
+	* xmlIO.c: enhanced to bypass compression detection code
+	  when input file is stdin (bug 125801)
+
+Wed Oct 29 18:21:00 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmlIO.c: fix needed when HTTP is not compiled in by Mark Vakoc
+
+Wed Oct 29 18:05:53 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: more fixes about unregistering objects
+	* include/libxml/relaxng.h: applied patch from Mark Vakoc
+	  missing _cplusplus processing clause
+
+Wed Oct 29 07:49:52 2003  Aleksey Sanin  <aleksey@aleksey.com>
+
+	* include/libxml/parser.h parser.c: added xmlStrVPrintf function
+
+Wed Oct 29 14:37:40 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* nanoftp.c nanohttp.c testThreads.c threads.c: applied patch from
+	  Marcin 'Shard' Konicki to provide BeOS thread support.
+
+Wed Oct 29 14:20:14 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmlschemas.c include/libxml/xmlschemas.h: applied patch
+	  from Steve Ball to make a schema parser from a preparsed document.
+
+Wed Oct 29 13:52:25 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: applied a couple of patches from Mark Lilback about text
+	  nodes coalescing
+
+Wed Oct 29 12:16:52 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: change suggested by Anthony Carrico when unregistering
+	  a namespace prefix to a context
+	* hash.c: be more careful about calling callbacks with NULL payloads.
+
+Wed Oct 29 00:04:26 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in NEWS doc/*: preparing release 2.6.1, updated and
+	  regenerated docs and APIs
+	* parser.c: cleanup and last change to fix #123105
+
+Tue Oct 28 23:02:29 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLparser.c: Fix #124907 by simply backporting the same
+	  fix as for the XML parser
+	* result/HTML/doc3.htm.err: change to ID detecting modified one
+	  test result.
+
+Tue Oct 28 22:28:50 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c include/libxml/parser.h: included a new function
+	  to reuse a Push parser context, based on Graham Bennett original
+	  code
+	* valid.c: in HTML, a name in an input is not an ID
+	* TODO: bug list update
+
+Tue Oct 28 19:54:37 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: applied patch from nico@xtradyne.com for #125030
+
+Tue Oct 28 16:42:16 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am: cleanup
+	* error.c valid.c include/libxml/xmlerror.h: fixing bug #125653
+	  sometimes the error handlers can get a parser context on DTD
+	  errors, and sometime they don't. So be very careful when trying
+	  to grab those informations.
+
+Tue Oct 28 15:26:18 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: applied patch from Kasimier Buchcik which fixes a 
+	  problem in xmlSearchNs introduced in 2.6.0
+
+Tue Oct 28 14:57:03 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: fixed #123263, the encoding is mandatory in a textdecl.
+
+Tue Oct 28 13:48:52 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: fix bug #125047 about serializing when finding a 
+	  document fragment node.
+
+Mon Oct 27 11:11:29 EST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* testSAX.c: fix bug #125592 need a NULL check
+	* include/libxml/chvalid.h: rename a parameter
+
+Mon Oct 27 09:43:48 EST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: applied patch from #123105 about defaulted attributes
+	  from element coming from an entity
+
+Mon Oct 27 21:12:27 HKT 2003 William Brack <wbrack@mmm.com.hk>
+
+	* xmllint.c: fixed warning message from IRIX (bug 125182)
+	* python/libxml.py: removed tabs, replaced with spaces
+	  (bug 125572)
+
+Mon Oct 27 06:17:30 EST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* libxml.h parserInternals.c xmlIO.c: make sure we report errors
+	  if xmlNewInputFromFile() fails.
+	* xmlreader.c: avoid using _private for the node or document
+	  elements.
+
+Sat Oct 25 17:33:59 CEST 2003 Igor Zlatkovic <igor@zlatkovic.com>
+
+	* win32/configure.js: added declaration for verMicroSuffix
+
+Fri Oct 24 23:08:17 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* libxml.m4: applied patch from Patrick Welche provided in
+	  bug #125432 , future proofing the .m4 file.
+	* parser.c: resetting the context should also reset the error
+	* TODO: problem of conformance w.r.t. E20 was raised in the
+	  XML Core telconf and libxml2 isn't conformant there.
+
+Wed Oct 22 14:33:05 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmlwriter.c: applied patch from Alfred Mickautsch fixing #125180
+
+Wed Oct 22 10:50:31 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* chvalid.c genChRanges.py: Stephane Bidoul pointed out another
+	  small glitch missing a const
+
+Wed Oct 22 10:43:21 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* chvalid.c genChRanges.py: Stephane Bidoul pointed out that
+	  it doesn't define IN_LIBXML
+
+Tue Oct 21 21:14:55 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* win32/Makefile.mingw: typo pointed out by Stephane Bidoul
+
+Tue Oct 21 11:26:36 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* win32/Makefile.bcb win32/Makefile.mingw win32/Makefile.msvc
+	  win32/configure.js: set of Win32 patches for 2.6.0 by Joachim Bauch
+
+Tue Oct 21 02:07:22 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: last minute patch from Eric Zurcher making it into 2.6.0
+
+Tue Oct 21 02:03:03 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in NEWS doc/libxml2.xsa: preparing libxml2-2.6.0
+	* doc/*: updated and regenerated the docs and API
+
+Tue Oct 21 01:01:55 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* SAX2.c error.c tree.c: moved the line number to their proper
+	  field in elements now.
+
+Tue Oct 21 00:28:20 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in xmlwriter.c Makefile.am include/libxml/xmlwriter.h
+	  include/libxml/Makefile.am include/libxml/xmlversion.h.in:
+	  added the xmlWriter module contributed by Alfred Mickautsch
+	* include/libxml/tree.h: added room for line and extra information
+	* xmlreader.c python/tests/reader6.py: bugfixing some problem some
+	  of them introduced in September
+	* win32/libxml2.def.src doc/libxml2-api.xml: regenerated the API
+
+Mon Oct 20 19:02:53 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am configure.in xmldwalk.c xmlreader.c
+	  include/libxml/Makefile.am include/libxml/xmldwalk.h
+	  include/libxml/xmlversion.h.in: removing xmldwalk module
+	  since it got merged with the xmlreader.
+	* parser.c: cleanup
+	* win32/libxml2.def.src python/libxml2class.txt doc/libxml2-api.xml:
+	  rebuilt the API
+	* python/tests/Makefile.am python/tests/reader7.py
+	  python/tests/walker.py: adding regression testing for the
+	  new xmlreader APIs, new APIs for reader creation, including
+	  makeing reader "walker" operating on preparsed document trees.
+
+Sun Oct 20 22:37:03 HKT 2003 William Brack <wbrack@mmm.com.hk>
+
+	* entities.c, valid.c: fixed problem reported on the mailing
+	  list by Melvyn Sopacua - wrong argument order on functions
+	  called through xmlHashScan.
+
+Sun Oct 19 23:57:45 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* valid.c xmlIO.c: fixes for compiling using --with-minimum
+
+Sun Oct 19 23:46:04 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: cleanup xmlNodeGetContent() reusing xmlNodeBufGetContent(),
+	  tested it through the xslt regression suite.
+
+Sun Oct 19 22:42:16 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c include/libxml/tree.h: adding xmlNodeBufGetContent()
+	  allowing to grab the content without forcing allocations.
+	* python/libxml2class.txt doc/libxml2-api.xml: rebuilt the API
+	* xpath.c xmldwalk.c: removed a couple of comment errors.
+
+Sun Oct 19 16:39:36 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: applied patch from Chris Anderson to change back
+	  memcmp with CMPx()
+
+Sun Oct 19 16:24:19 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLparser.c: fixed to not send NULL to %s printing
+	* python/tests/error.py result/HTML/doc3.htm.err
+	  result/HTML/test3.html.err result/HTML/wired.html.err
+	  result/valid/t8.xml.err result/valid/t8a.xml.err: cleaning
+	  up some of the regression tests error
+
+Sun Oct 19 15:31:43 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/nanohttp.h include/libxml/parserInternals.h 
+	  include/libxml/xmlIO.h nanohttp.c parserInternals.c xmlIO.c:
+	  Fixed the HTTP<->parser interraction, which should fix 2 long
+	  standing bugs #104790 and #124054 , this also fix the fact that
+	  HTTP error code (> 400) should not generate data, we usually
+	  don't want to parse the HTML error information instead of the
+	  resource looked at.
+
+Sun Oct 19 19:20:48 HKT 2003 William Brack <wbrack@mmm.com.hk>
+
+	* doc/Makefile.am: enhanced the installation of tutorial files
+	  to avoid installing CVS subdirectories (bug 122943)
+
+Sun Oct 19 17:33:27 HKT 2003 William Brack <wbrack@mmm.com.hk>
+
+	* xmlIO.c: fixed segfault when input file not present
+	* tree.c: changed output formatting of XML_CDATA_SECTION
+	  (bug 120917)
+	
+Sun Oct 19 00:15:38 HKT 2003 William Brack <wbrack@mmm.com.hk>
+
+	* include/libxml/parserInternals.h HTMLparser.c HTMLtree.c
+	  SAX2.c catalog.c debugXML.c entities.c parser.c relaxng.c
+	  testSAX.c tree.c valid.c xmlschemas.c xmlschemastypes.c
+	  xpath.c: Changed all (?) occurences where validation macros
+	  (IS_xxx) had single-byte arguments to use IS_xxx_CH instead
+	  (e.g. IS_BLANK changed to IS_BLANK_CH).  This gets rid of
+	  many warning messages on certain platforms, and also high-
+	  lights places in the library which may need to be enhanced
+	  for proper UTF8 handling.
+
+Sat Oct 18 20:34:18 HKT 2003 William Brack <wbrack@mmm.com.hk>
+
+	* genChRanges.py, chvalid.c, include/libxml/chvalid.h,
+	  doc/apibuild.py: enhanced to include enough comments to
+	  make the api doc generation happy.
+
+Sat Oct 18 07:28:25 EDT 2003 Daniel Veillard <daniel@veillard.com>
+
+	* nanohttp.c xmlIO.c include/libxml/nanohttp.h: starting work
+	  to fix the HTTP/XML parser integration.
+
+Sat Oct 18 11:04:32 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmlreader.c include/libxml/xmlreader.h: added new APIs
+	  for creating reader from sources or reusing a reader with
+	  a new source, like the xmlReadxx and xmlCtxtReadxxx
+	* win32/libxml2.def.src doc/libxml2-api.xml doc/apibuild.py
+	  doc/Makefile.am: regenerated the APIs
+	* doc/xml.html: applied a patch from Stefan Kost for namesapce docs
+
+Sat Oct 18 12:46:02 HKT 2003 William Brack <wbrack@mmm.com.hk>
+
+	* genChRanges.py, chvalid.c, include/libxml/chvalid.h,
+	  include/libxml/parserInternals.h: enhanced macros to avoid
+	  breaking ABI from previous versions.
+	* catalog.c, parser.c, tree.c: modified to use IS_* macros
+	  defined in parserInternals.h.  Makes maintenance much easier.
+	* testHTML.c, testSAX.c, python/libxml.c: minor fixes to avoid
+	  compilation warnings
+	* configuration.in: fixed pushHTML test error; enhanced for
+	  better devel (me) testing
+
+Fri Oct 17 14:38:54 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* legacy.c: remove the warning for startDocument(), as it is used by
+	  glade (or glade-python)
+	* parser.c relaxng.c xmlschemastypes.c: fixed an assorted set of
+	  invalid accesses found by running some Python based regression
+	  tests under valgrind. There is still a few leaks reported by the
+	  relaxng regressions which need some attention.
+	* doc/Makefile.am: fixed a make install problem c.f. #124539
+	* include/libxml/parserInternals.h: addition of xmlParserMaxDepth
+	  patch from crutcher
+
+Wed Oct 15 12:47:33 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: Marc Liyanage pointed out that xmlCleanupParser()
+	  was missing xmlCleanupInputCallbacks and xmlCleanupOutputCallbacks
+	  calls.
+
+Wed Oct 15 10:16:47 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* vms/build_libxml.com trionan.c: VMS patch from Craig A. Berry
+
+Mon Oct 13 21:46:25 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am: small fix from Bjorn Reese
+
+Mon Oct 13 15:59:25 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* valid.c: fix a call missing arguments
+
+Sun Oct 12 18:42:18 HKT 2003 William Brack <wbrack@mmm.com.hk>
+
+	* genChRanges.py, chvalid.c, include/libxml/chvalid.h: fixed
+	  a bug in the range search; enhanced range generation (inline code
+	  if a small number of intervals); enhanced the readability of the
+	  output files.
+
+Sun Oct 12 00:52:14 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* chvalid.def chvalid.c include/libxml/chvalid.h: rebuilt 
+	  chvalid.def from scratch based on XML 2nd edition REC
+	  and regenerated the code.
+
+Sat Oct 11 22:54:13 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* check-xml-test-suite.py: removed some annoying warnings
+	* chvalid.def chvalid.c include/libxml/chvalid.h: fixed a bug
+	  in the PubidChars definition, regenerated, there is still
+	  a bug left somewhere
+	* genChRanges.py: save the header directly in include/libxml/
+	* configure.in: I generated a 2.6.0beta6 earlier today
+
+Sat Oct 11 23:32:47 HKT 2003 William Brack <wbrack@mmm.com.hk>
+
+	* fixed small error on previous commit (chvalid.h in
+	  base dir instead of include directory)
+
+Sat Oct 11 23:11:22 HKT 2003 William Brack <wbrack@mmm.com.hk>
+
+	* genChRange.py, chvalid.def, chvalid.c, include/libxml/chvalid.h:
+	  new files for a different method for doing range validation
+	  of character data.
+	* Makefile.am, parserInternals.c, include/libxml/Makefile.am,
+	  include/libxml/parserInternals.h: modified for new range method.
+	* catalog.c: small enhance for warning message (using one
+	  of the new range routines)
+
+Sat Oct 11 13:24:57 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* valid.c include/libxml/valid.h: adding an serror field to
+	  the validation context breaks the ABI for the xmlParserCtxt
+	  structure since it's embedded by content and not by reference
+
+Sat Oct 11 12:46:49 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in: patch from Mike Hommey
+	* threads.c: applied Windows patch from Jesse Pelton and Stephane
+	  Bidoul
+	* parser.c: fix the potentially nasty access to ctxt->serror
+	  without checking first that the SAX block is version 2
+
+Fri Oct 10 21:34:01 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* SAX2.c: fixed a nasty bug with interning some text strings
+	* configure.in: prepare for beta5 of 2.6.0
+	* libxml.h nanoftp.c nanohttp.c xmlIO.c include/libxml/xmlerror.h:
+	  better error handling for I/O and converted FTP and HTTP
+	* parser.c: fixed another bug
+
+Fri Oct 10 16:45:20 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* SAX2.c: fixed uninitialized new field.
+	* result/VC/OneID2 result/relaxng/*.err: fixed a typo updating
+	  all messages
+
+Fri Oct 10 16:19:17 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/tree.h: make room in Doc, Element, Attributes
+	  for PSVI type informations.
+
+Fri Oct 10 16:08:02 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLparser.c c14n.c catalog.c error.c globals.c parser.c
+	  parserInternals.c relaxng.c valid.c xinclude.c xmlIO.c xmlregexp.c
+	  xmlschemas.c xpath.c xpointer.c include/libxml/globals.h
+	  include/libxml/parser.h include/libxml/valid.h 
+	  include/libxml/xmlerror.h: Setting up the framework for structured
+	  error reporting, touches a lot of modules, but little code now
+	  the error handling trail has been cleaned up.
+
+Fri Oct 10 14:29:42 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* c14n.c include/libxml/xmlerror.h: converted the C14N module too
+
+Fri Oct 10 13:40:51 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: cleanup
+	* xpointer.c include/libxml/xmlerror.h: migrated XPointer module
+	  to the new error mechanism
+
+Fri Oct 10 12:49:53 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* error.c xmlschemas.c: a bit of cleanup
+	* result/schemas/*.err: updated with the new result strings
+
+Fri Oct 10 03:58:39 PDT 2003 William Brack <wbrack@mmm.com.hk>
+
+	* xpath.c: fixed bug 124061
+
+Fri Oct 10 02:47:22 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am: cleanup
+	* encoding.c: fix a funny typo
+	* error.c xmlschemas.c xmlschemastypes.c include/libxml/xmlerror.h:
+	  converted the Schemas code to the new error handling. PITA,
+	  still need to check output from regression tests.
+
+Thu Oct  9 15:13:53 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLtree.c include/libxml/xmlerror.h: converted too
+	* tree.c: small cleanup
+
+Thu Oct  9 13:44:57 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xinclude.c: comment fix
+	* catalog.c include/libxml/xmlerror.h: migrating the catalog code
+	  to the new infrastructure
+
+Thu Oct  9 00:36:03 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmlIO.c: final error handling cleanup
+	* xinclude.c error.c: converted XInclude to the new error handling
+	* include/libxml/xmlerror.h: added XInclude errors
+
+Wed Oct  8 23:31:23 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: bug in compression saving was crashing galeon
+	  reported by teuf
+	  
+Wed Oct  8 21:18:12 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* error.c tree.c xmlIO.c xmllint.c: more cleanup through the
+	  I/O error path
+
+Wed Oct  8 20:57:27 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmlIO.c: better handling of error cases
+
+Wed Oct  8 13:51:14 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmlIO.c xmllint.c include/libxml/xmlerror.h: first pass at
+	  cleaning up error handling in the I/O module.
+
+Wed Oct  8 10:52:05 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmlregexp.c include/libxml/xmlerror.h: error handling
+	  cleanup of the Regexp module.
+
+Wed Oct  8 01:09:05 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: converting the tree module too
+	* error.c include/libxml/xmlerror.h: created a simpler internal
+	  error reporting function.
+
+Tue Oct  7 23:19:39 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* error.c include/libxml/xmlerror.h include/libxml/xpath.h
+	  include/libxml/xpathInternals.h xpath.c: cleaning up XPath
+	  error reporting that time. 
+	* threads.c: applied the two patches for TLS threads
+	  on Windows from Jesse Pelton
+	* parser.c: tiny safety patch for xmlStrPrintf() make sure the
+	  return is always zero terminated. Should also help detecting
+	  passing wrong buffer size easilly.
+	* result/VC/* result/valid/rss.xml.err result/valid/xlink.xml.err:
+	  updated the results to follow the errors string generated by
+	  last commit.
+
+Tue Oct  7 14:16:45 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* relaxng.c include/libxml/xmlerror.h: last cleanup of error
+	  handling in the Relax-NG module.
+
+Tue Oct  7 13:30:39 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* error.c relaxng.c include/libxml/xmlerror.h: switched Relax-NG
+	  module to teh new error reporting. Better default report, adds
+	  the element associated if found, context and node are included
+	  in the xmlError
+	* python/tests/reader2.py: the error messages changed.
+	* result/relaxng/*: error message changed too.
+
+Mon Oct  6 10:46:35 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* win32/Makefile.bcb win32/Makefile.mingw win32/Makefile.msvc
+	  win32/configure.js: applied patch from Stéphane Bidoul to
+	  fix the compilation of 2.6.0 code on Win32
+
+Mon Oct  6 10:16:30 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* check-xml-test-suite.py: fixing the script
+	* parser.c: replace sequences of RAW && NXT(.) == '.' with
+	  memcmp calls, seems to not break conformance, slightly inflate
+	  the size of the gcc generated code though.
+
+Sun Oct  5 23:30:48 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* parserInternals.c parser.c valid.c include/libxml/parserInternals.h:
+	  more cleanup of error handling in parserInternals, sharing the
+	  routine for memory errors.
+
+Sun Oct  5 15:49:14 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLparser.c Makefile.am legacy.c parser.c parserInternals.c
+	  include/libxml/xmlerror.h: more code cleanup, especially around
+	  error messages, the HTML parser has now been upgraded to the new
+	  handling.
+	* result/HTML/*: a few changes in the resulting error messages
+
+Sat Oct  4 23:06:41 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c include/libxml/xmlerror.h: more error/warning
+	  handling cleanups, the XML parser module should be okay now.
+
+Sat Oct  4 01:58:27 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am configure.in xmldwalk.c include/libxml/Makefile.am
+	  include/libxml/xmldwalk.h include/libxml/xmlversion.h.in:
+	  integrated the xmlDocWalker API given by Alfred Mickautsch,
+	  and providing an xmlReader like API but working on a xmlDocPtr.
+
+Sat Oct  4 00:18:29 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am: more cleanup in make tests
+	* error.c valid.c parser.c include/libxml/xmlerror.h: more work
+	  in the transition to the new error reporting strategy.
+	* python/tests/reader2.py  result/VC/* result/valid/*:
+	  few changes in the strings generated by the validation output
+
+Fri Oct  3 00:19:02 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am: changed 'make tests' to use a concise output,
+	  scrolling to see where thing broke wasn't pleasant
+	* configure.in: some beta4 preparation, but not ready yet
+	* error.c globals.c include/libxml/globals.h include/libxml/xmlerror.h:
+	  new error handling code, last error informations are stored
+	  in the parsing context or a global variable, new APIs to
+	  handle the xmlErrorPtr type.
+	* parser.c parserInternals.c valid.c : started migrating to the
+	  new error handling code, it's a royal pain.
+	* include/libxml/parser.h include/libxml/parserInternals.h:
+	  moved the definition of xmlNewParserCtxt()
+	* parser.c: small potential buffer access problem in push code
+	  provided by Justin Fletcher
+	* result/*.sax result/VC/PENesting* result/namespaces/*
+	  result/valid/*.err: some error messages were sligthly changed.
+
+Thu Oct  2 13:01:13 2003  Aleksey Sanin  <aleksey@aleksey.com>
+
+	* include/libxml/parser.h parser.c: introduced xmlStrPrintf
+	function (wrapper around snprintf)
+
+Wed Oct  1 21:12:06 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* entities.c: Fix error on output of high codepoint charref like
+	  &#x10FFFF; , reported by Eric Hanchrow
+
+Wed Oct  1 14:20:10 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* DOCBparser.c include/libxml/DOCBparser.h: let's see how much
+	  of a pain murrayc is really gonna be.
+
+Wed Oct  1 11:03:40 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmlreader.c: Applied fix for bug #123481 reported by Peter Derr
+
+Tue Sep 30 15:34:31 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* entities.c legacy.c parser.c: made the predefined entities
+	  static predefined structures to avoid the work, memory and
+	  hazards associated to initialization/cleanup.
+
+Tue Sep 30 14:30:47 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLparser.c Makefile.am configure.in legacy.c parser.c
+	  parserInternals.c testHTML.c xmllint.c include/libxml/HTMLparser.h
+	  include/libxml/parser.h include/libxml/parserInternals.h
+	  include/libxml/xmlversion.h.in: added a new configure
+	  option --with-push, some cleanups, chased code size anomalies.
+	  Now a library configured --with-minimum is around 150KB,
+	  sounds good enough.
+
+Tue Sep 30 12:31:00 AEST 2003 Malcolm Tredinnick <malcolm@commsecure.com.au>
+
+	* libxml-2.0-uninstalled.pc.in: New file for building against
+	uninstalled libxml2 builds.
+	* configure.in, Makefile.am: Support the *-uninstalled.pc file.
+	* .cvsignore: Ignore the new generated *.pc file.
+
+Tue Sep 30 02:38:16 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am SAX.c SAX2.c configure.in globals.c parser.c
+	  parserInternals.c testReader.c testSAX.c xmlIO.c xmllint.c
+	  xmlreader.c example/gjobread.c include/libxml/xmlversion.h.in:
+	  added 2 new configure option: --with-reader --with-sax1
+	  to allow removing the reader or non-xmlReadxxx() interfaces.
+
+Mon Sep 29 19:58:26 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in entities.c tree.c valid.c xmllint.c
+	  include/libxml/tree.h include/libxml/xmlversion.h.in:
+	  Adding a configure option to remove tree manipulation
+	  code which is not strictly needed by the parser.
+
+Mon Sep 29 15:23:41 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* nanoftp.c nanohttp.c: last finishing touch to the BeOS
+	  patch from Marcin 'Shard' Konicki
+
+Mon Sep 29 15:15:08 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLtree.c SAX2.c c14n.c catalog.c configure.in debugXML.c
+	  encoding.c entities.c nanoftp.c nanohttp.c parser.c relaxng.c
+          testAutomata.c testC14N.c testHTML.c testRegexp.c testRelax.c
+          testSchemas.c testXPath.c threads.c tree.c valid.c xmlIO.c
+	  xmlcatalog.c xmllint.c xmlmemory.c xmlreader.c xmlschemas.c
+	  example/gjobread.c include/libxml/HTMLtree.h include/libxml/c14n.h
+	  include/libxml/catalog.h include/libxml/debugXML.h
+	  include/libxml/entities.h include/libxml/nanohttp.h
+	  include/libxml/relaxng.h include/libxml/tree.h
+	  include/libxml/valid.h include/libxml/xmlIO.h
+	  include/libxml/xmlschemas.h include/libxml/xmlversion.h.in
+	  include/libxml/xpathInternals.h python/libxml.c:
+	  Okay this is scary but it is just adding a configure option
+	  to disable output, this touches most of the files.
+
+Mon Sep 29 12:53:56 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmlmemory.c: better fix, avoids breaking the python bindings
+
+Mon Sep 29 11:21:33 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmlmemory.c: fix a compilation problem when configuring
+	  with debug but without mem-debug
+
+Sun Sep 28 20:53:17 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am: cleanup, creating a new legacy.c module,
+	  made sure make tests ran in reduced conditions
+	* SAX.c SAX2.c configure.in entities.c globals.c parser.c
+	  parserInternals.c tree.c valid.c xlink.c xmlIO.c xmlcatalog.c
+	  xmlmemory.c xpath.c xmlmemory.c include/libxml/xmlversion.h.in:
+	  increased the modularization, allow to configure out 
+	  validation code and legacy code, added a configuration
+	  option --with-minimum compiling only the mandatory code
+	  which then shrink to 200KB.
+
+Sun Sep 28 02:15:07 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: fix a bug raised by the Mips compiler.
+	* include/libxml/SAX.h include/libxml/parser.h: move the 
+	  SAXv1 block definitions to parser.h fixes bug #123380
+	* xmlreader.c include/libxml/xmlreader.h: reinstanciate
+	  the attribute and element pool borken 2 commits ago.
+	  Start playing with an entry point to preserve a subtree.
+	* entities.c: remove a warning.
+
+Sat Sep 27 12:19:38 PDT 2003 William Brack <wbrack@mmm.com.hk>
+
+	* encoding.c, parser.c, relaxng.c: further (final?) minor
+	  changes for compilation warnings. No change to logic.
+
+Fri Sep 26 18:03:42 PDT 2003 William Brack <wbrack@mmm.com.hk>
+
+	* parser.c: fixed small problem with missing entities (test/ent2)
+
+Sat Sep 27 01:25:39 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: William's change allowed to spot a nasty bug in xmlDoRead
+	  if the result is not well formed that ctxt->myDoc is not NULL
+	  and uses the context dictionnary.
+
+Fri Sep 26 21:09:34 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: other patches from William Brack to avoid
+	  compilation warnings on AIX.
+
+Fri Sep 26 11:03:08 PDT 2003 William Brack <wbrack@mmm.com.hk>
+
+	* HTMLparser.c, entities.c, xmlreader.c: minor change to
+	  avoid compilation warnings on some (e.g. AIX) systems
+
+Fri Sep 26 16:49:25 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* parserInternals.c: fixed a backward compatibility problem
+	  when formatting "deprecated SAXv1 function ignorableWhitespace"
+	  could be reproduced by xmllint --format
+
+Fri Sep 26 15:50:44 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* doc/libxml2-api.xml: rebuilt the API
+	* xmllint.c doc/xmllint.1 doc/xmllint.xml: added the new options
+	  --nocdata and --nsclean to remove CDATA section and surperfluous
+	  namespace declarations
+	* parser.c SAX2.c: implementation of the 2 new options
+
+Fri Sep 26 14:41:53 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLparser.c testHTML.c xmllint.c include/libxml/HTMLparser.h:
+	  added the same htmlRead APIs than their XML counterparts
+	* include/libxml/parser.h: new parser options, not yet implemented,
+	  added an options field to the context.
+	* tree.c: patch from Shaun McCance to fix bug #123238 when ]]>
+	  is found within a cdata section.
+	* result/noent/cdata2 result/cdata2 result/cdata2.rdr
+	  result/cdata2.sax test/cdata2: add one more cdata test
+	  
+Thu Sep 25 23:03:23 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c xmllint.c doc/libxml2-api.xml include/libxml/parser.h:
+	  Changed the new xmlRead/xmlCtxtRead APIs to have an extra
+	  base URL parameter when not loading from a file or URL.
+
+Thu Sep 25 16:23:58 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in: preparing a beta3 solving the ABI problems
+	* globals.c parser.c parserInternals.c testHTML.c HTMLparser.c SAX.c
+	  include/libxml/globals.h include/libxml/SAX.h: make sure the
+	  global variables for the default SAX handler are V1 ones to
+	  avoid ABI compat problems.
+	* xmlreader.c: cleanup of uneeded code
+	* hash.c: fix a comment
+
+Thu Sep 25 14:16:51 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* SAX2.c hash.c parser.c include/libxml/xmlexports.h 
+	  include/libxml/xmlmemory.h include/libxml/xmlversion.h.in:
+	  fixing some comments to avoid warnings from apibuild.py
+
+Wed Sep 24 23:42:08 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* win32/configure.js: patch from Stephane Bidoul for configuring
+	  the beta2 version #123104
+
+Wed Sep 24 23:17:59 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am: adding repeated parsing and validating tests
+	* SAX2.c parser.c tree.c include/libxml/parser.h: make the new
+	  DOM tree building interfaces use the dictionary from the 
+	  parsing context to build the element and attributes names
+	  as well as formatting spaces and short text nodes
+	* include/libxml/dict.h dict.c: added some reference counting
+	  for xmlDictPtr because they can be shared by documents and
+	  a parser context.
+	* xmlreader.c: a bit of cleanup, remove the specific tree freeing
+	  functions and use the standard ones now.
+	* xmllint.c: add --nodict
+	* python/libxml.c: fix a stupid bug so that ns() works on 
+	  attribute nodes.
+
+Tue Sep 23 23:07:45 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c include/libxml/parser.h: adding a new set of
+	  API for parsing xmlReadDoc() xmlReadFile() ... xmlReadIO()
+	  and xmlCtxtReadDoc() ... xmlCtxtReadIO(). That with
+	  a clear define of xmlParserOption, xmlCtxtUseOptions()
+	  should simplify custom parsing without being tempted to
+	  use global variables, and xmlCtxtReset() should allow reuse
+	  of a context for multiple parsing.
+	* xmllint.c: switched to use xmlReadXXX, allow options to
+	  be used simultaneously with less troubles.
+	* tree.c: simple warning removal
+	* doc/apibuild.py: small fix
+	* doc/libxml2-api.xml win32/libxml2.def.src: updated
+
+Tue Sep 23 11:15:23 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: revert xmlCreateDocParserCtxt() since this break
+	  the parseDoc() python bindings
+
+Tue Sep 23 11:00:18 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: make sure xmlDetectSAX2() is called only at 
+	  parsing time to avoid breaking apps changing the SAX
+	  callbacks after context allocation, change xmlCreateDocParserCtxt()
+	  to use an immutable buffer instead of a copy
+
+Tue Sep 23 09:40:33 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmlIO.c: applied patch from Markus Keim fixing a problem
+	  with I/O callback registration.
+	* include/libxml/xmlerror.h: fixed #122994 comment numbering
+	  for xmlParserErrors
+
+Mon Sep 22 12:21:11 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c include/libxml/tree.h: the uri arg to xmlNodeSetBase is
+	  really a const xmlChar*
+	* xmlreader.c include/libxml/xmlreader.h: addin the
+	  xmlTextReaderConstString() to get an interned string from
+	  the reader
+
+Sun Sep 20 17:22:20 PDT 2003 William Brack <wbrack@mmm.com.hk>
+
+	* error.c: fixed a warning message (trivial)
+	* doc/search.php: removed incorrect warning message when word
+	  search not found in last of multiple tables (bug 119535)
+
+Fri Sep 19 14:26:28 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in: preparing a 2.6.0-beta2 release
+	* xmlIO.c: avoid a warning
+	* tree.c: avoid duplicate code in xmlReplaceNode as pointed out
+	  by Chris Ryland
+	* include/libxml/dict.h: add a QName access lookup to the
+	  dictionary.
+	* xmlreader.c include/libxml/xmlreader.h: adding const access
+	  based on the dictionary interface for string read from the
+	  reader, the node content access is still TODO, it's too different
+
+Fri Sep 19 00:01:08 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* SAX2.c: fixing namespace DTD validations
+	* result/valid/ns2.xml result/valid/ns.xml: the output of defaulted
+	  namespaces is slightly different now.
+	* Makefile.am: report the memory used in Timingtests (as well as time)
+
+Thu Sep 18 15:29:46 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am: add streaming on memory regression tests, found
+	  bad bugs in the reader interface
+	* xmlreader.c: fixing bugs w.r.t. very large names, and special
+	  condition in end of file.
+	* xmlIO.c tree.c include/libxml/tree.h include/libxml/xmlIO.h:
+	  adding immutable buffers, and parser input based on those,
+	  but this should not be used (yet) for general parsing
+	* parser.c: added a comment about using immutable buffers for
+	  general parsing.
+	* result/bigname.xml.rdr result/bigname2.xml.rdr: fixing the
+	  output of the regression tests
+	* xmllint.c: using the immutable buffers when streaming on
+	  mmaped file (--stream --memory)
+
+Thu Sep 18 12:04:50 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* dict.c: the last patch broke unicity of returned strings, removed
+
+Thu Sep 18 00:31:02 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am: add a Timingtests target to check bad behaviour
+	  from the streaming engine
+	* dbgen.pl dbgenattr.pl: perl script to generate big instances
+	* xmlreader.c: fix a bad behaviour on large buffer inputs
+
+Wed Sep 17 23:25:47 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* dict.c xmlreader.c: two small improvements
+
+Wed Sep 17 22:53:32 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* parserInternals.c: avoid a leak with previous patch
+
+Wed Sep 17 22:06:11 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* python/libxml.c: use stderr and not stdout for default errors
+	  in python environment bug #122552
+
+Wed Sep 17 21:33:57 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* parserInternals.c: small fix from Rob Richards for input filename
+	* xmllint.c: fixes for --repeat and --memory/--stream for speed tests
+	* xmlIO: adding a guard in one function
+
+Wed Sep 17 15:57:44 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* SAX2.c xmlreader.c include/libxml/parser.h: more performance hunting
+	  reducing memory allocation and free and avoiding expensive routines
+
+Wed Sep 17 12:23:41 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* SAX2.c parser.c parserInternals.c xmlreader.c: started messing
+	  seriously with per-document dict and element and attribute nodes
+	  reuse in the xmlReader. This seems to lead to an interesting
+	  speedup of the xmlReader already.
+
+Wed Sep 17 01:07:56 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* dict.c include/libxml/dict.h: do string allocations in large
+	  pools, allowing to find if a string pertain to a dict quickly
+	* xmllint.c: fix --stream --repeat --timing
+	* Makefile.am: the testThreads run output should be seen.
+
+Mon Sep 15 16:46:28 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* SAX2.c include/libxml/parser.h: starting work on reusing the
+	  parser dictionary for the element and attribute tag names.
+	  Add pools for Element and Attributes in the parser context,
+	  which should help speeding up the reader.
+	* Makefile.am result/*.rdr : adding non-python reader regression
+	  tests.
+
+Mon Sep 15 14:54:42 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* SAX2.c parser.c valid.c: starting to cleanup some of the
+	  problems exposed by the W3C/NIST regression suite.
+	* result/ent7.sax result/xml2.sax: small fixes.
+
+Mon Sep 15 11:46:47 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: more parser error factoring
+
+Sun Sep 14 21:53:39 PDT 2003 William Brack <wbrack@mmm.com.hk>
+
+	* HTMLtree.c: Fixed bug 121394 - missing ns on attributes
+
+Sun Sep 14 21:43:32 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c include/libxml/xmlerror.h: factoring of more 
+	  error handling code, serious size reduction and more lisibility
+	  of the resulting code.
+	* parserInternals.c parser.c include/libxml/parserInternals.h
+	  include/libxml/parser.h: changing the way VC:Proper Group/PE Nesting
+	  checks are done, use a counter for entities. Entities where freed and
+	  reallocated at the same address failing the check.
+	* tree.c: avoid a warning
+	* result/valid/* result/VC/*: this slightly changes some validation
+	  error messages.
+
+Sun Sep 14 11:03:27 PDT 2003 William Brack <wbrack@mmm.com.hk>
+
+	* valid.c: fixed bug 121759 - early declaration of
+	  attribute-list in external DTD
+
+Sat Sep 13 14:42:11 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c include/libxml/xmlerror.h: starting cleaning up
+	  error handling, factorize error processing
+	* doc/xmllint.html: update of the page, remove --sgml
+
+Sat Sep 13 02:13:50 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am DOCBparser.c parserInternals.c testDocbook.c
+	  xmllint.c doc/xmllint.xml doc/xmllint.1: removing the 
+	  broken pseudo SGML DocBook parser code.
+
+Fri Sep 12 17:24:11 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: fix a problem with strcpy() in xmlXPathFormatNumber()
+	  valgrind pointed out the strings overlapped. cleanup .
+
+Fri Sep 12 11:43:12 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: applied speedup to xmlSearchNs() as suggested by
+	  Luca Padovani. Cleaned up xmlSearchNsByHref() in the process
+	  applying the same trick.
+
+Fri Sep 12 01:36:20 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c parserInternals.c tree.c include/libxml/parser.h
+	  include/libxml/xmlerror.h: adding namespace checkings
+	  while making sure they still parse as wellformed documents.
+	  Add an nsWellFormed status report to the context, and 
+	  provide new appropriate error codes.
+	* Makefile.am result/namespaces/* test/namespaces/*: add 
+	  specific regression testing for the new namespace support
+	* test/att5 result/noent/att5 result/att5 result/att5.sax:
+	  add more coverage for the attribute parsing and normalization
+	  code.
+
+Fri Sep 12 01:34:19 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* threads.c: backport of a thread bugfix from 2_5_X branch
+
+Thu Sep 11 18:29:18 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: fixed a bug in one corner case of attribute parsing.
+
+Thu Sep 11 16:21:53 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in doc/* : 2.6.0beta1 changes
+	* SAX2.c hash.c parser.c parserInternals.c: Fixing attribute
+	  normalization, might not be totally fixed but this should 
+	  make sure SAX event provide the right strings for attributes
+	  except entities for which libxml2 is different by default
+	  This should fix #109564
+	* result/attrib.xml.sax result/ent3.sax result/p3p.sax: minor changes
+	  in attribute callback values
+	* result/c14n/with-comments/example-4
+	  result/c14n/without-comments/example-4: this also fixes a subtle
+	  bug in the canonicalization tests.
+
+Wed Sep 10 12:38:44 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	Time to commit 3 days of work rewriting the parser internal,
+	fixing bugs and migrating to SAX2 interface by default. There
+	is some work letf TODO, like namespace validation and attributes
+	normalization (this break C14N right now)
+	* Makefile.am: fixed the test rules
+	* include/libxml/SAX2.h include/libxml/parser.h
+	  include/libxml/parserInternals.h SAX2.c parser.c
+	  parserInternals.c: changing the parser, migrating to SAX2,
+	  adding new interface to switch back to SAX1 or initialize a
+	  SAX block for v1 or v2. Most of the namespace work is done
+	  below SAX, as well as attribute defaulting
+	* globals.c: changed initialization of the default SAX handlers
+	* hash.c tree.c include/libxml/hash.h: added QName specific handling
+	* xmlIO.c: small fix
+	* xmllint.c testSAX.c: provide a --sax1 switch to test the old
+	  version code path
+	* result/p3p result/p3p.sax result/noent/p3p test/p3p: the new code
+	  pointed out a typo in a very old test namespace
+
+Sun Sep  7 19:58:33 PTD 2003 William Brack <wbrack@mmm.com.hk>
+
+	* xmlIO.c include/libxml/xmlIO.h parser.c: Implemented detection
+	  of compressed files, setting doc->compressed appropriately
+	  (bug #120503).
+
+Sun Sep  7 22:53:06 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: try to cope with the fact that apps may still
+          have allocated smaller SAX callbak block
+
+Sun Sep  7 11:11:45 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* dict.c: allow to give -1 for undefined length in lookups
+	* include/libxml/parser.h parser.c parserInternals.c testSAX.c:
+	  first round of work on the new SAX2 interfaces, the API
+	  will change but commiting before changing for historical
+	  reference.
+
+Sat Sep  6 10:55:01 PTD 2003 William Brack <wbrack@mmm.com.hk>
+
+	* SAX2.c, xmlIO.c: fixed bug #121210 (callback to sax->error,
+	  sax->warning with wrong params).
+
+Fri Sep  5 10:33:42 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/globals.h: patch from Stéphane Bidoul to export
+	  globals entry points to the python bindings
+
+Wed Sep  3 15:24:41 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLparser.c: when creating a DOCTYPE use "html" lowercase
+	  by default instead of "HTML"
+	* parser.c xmlreader.c: optimization, gain a few % parsing speed by
+	  avoiding calls to "areBlanks" when not needed.
+	* include/libxml/parser.h include/libxml/tree.h: some structure
+	  extensions for future work on using per-document dictionaries.
+
+Wed Sep  3 15:08:06 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am results/*.sax SAXResult/*: removing the SAXresults
+	  tree, keeping result in the same tree, added SAXtests to the
+	  default "make tests"
+
+Tue Sep  2 15:59:04 CEST 2003 Igor Zlatkovic <igor@zlatkovic.com>
+
+	* include/libxml/xmlexports.h: defined additional macros which
+	  affect exports and added mingw section
+
+Mon Sep  1 15:15:18 PDT 2003 William Brack <wbrack@mmm.com.hk>
+
+	* doc/index.py: fixed problem parsing xhtml docs
+	* doc/xmlreader.html,doc/guidelines.html: small modification
+	  to avoid problem in python parsing.
+	* doc/search.php: fixed upper case filename problem for XSLT docs
+
+Mon Sep  1 22:55:09 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xinclude.c: patch from Mark Vakoc that allows compiling 
+	  with XInclude but without XPointer support.
+
+Mon Sep  1 22:31:38 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in xml2-config.in: Applied a patch from Kevin P. Fleming
+	  to add --libtool-libs option to xml2-config script.
+
+Sun Aug 31 21:52:12 PDT 2003 William Brack <wbrack@mmm.com.hk>
+
+	* doc/README.docs, doc/Makefile.am: new file added,
+	  giving some description of the documentation generation process
+	* doc/search.php: fixed problem with upper case on filenames
+
+Fri Aug 29 12:25:01 CEST 2003 Igor Zlatkovic <igor@zlatkovic.com>
+
+	* win32/Makefile.bcb: updates by Eric Zurcher
+
+Thu Aug 28 22:58:38 PDT 2003 William Brack <wbrack@mmm.com.hk>
+
+	* doc/apibuild.py, doc/libxml2-api.xml: enhanced code
+	  to compensate for pollution from Igor's header taint
+	  (quick before Daniel notices)
+
+Thu Aug 28 23:01:36 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* SAX2.c: fixed a namespace error on attribute reporting bug
+	  pointed out by Tobias Reif
+	* test/p3p result/p3p result/noent/p3p: this test case was wrong
+	  using xmlsn instead of xmlns...
+
+Thu Aug 28 18:25:07 CEST 2003 Igor Zlatkovic <igor@zlatkovic.com>
+
+	* include/libxml/globals.h include/libxml/xmlexports.h: fixed
+	  typos reported by Mark Vakoc
+
+Thu Aug 28 08:59:51 MDT 2003 John Fleck <jfleck@inkstain.net>
+
+	add:
+	* doc/tutorial/api.html
+	* doc/tutorial/ar01s09.html
+	* doc/tutorial/includexpath.c
+	updated
+	* doc/tutorial/*.html
+	fix my bad - forgot to check in new files when I last
+	updated
+
+
+Thu Aug 28 14:31:13 CEST 2003 Igor Zlatkovic <igor@zlatkovic.com>
+
+	* win32/Makefile.bcb: new file, support for Borland C++
+	* xmllint.c: fixed time inclusion for various compilers
+
+Thu Aug 28 12:32:59 CEST 2003 Igor Zlatkovic <igor@zlatkovic.com>
+
+	* parser.c parserInternals.c DOCBparser.c HTMLparser.c: added
+	  few casts to shut the compiler warnings
+
+Thu Aug 28 12:23:51 CEST 2003 Igor Zlatkovic <igor@zlatkovic.com>
+
+	* win32/Makefile.* win32/configure.js: fixed for mingw
+
+Thu Aug 28 10:01:44 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* globals.c threads.c: fixing bug #120870 try to avoid problem
+	  with uninitialized mutexes
+
+Wed Aug 27 16:12:41 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* relaxng.c: fixed an error reporting bug in Relax-NG when we end
+	  up with multiple states, select the "best" one. Fix #120682
+	* result/relaxng/tutor11_2_3.err: small change resulting 
+
+Wed Aug 27 11:25:25 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmlschemastypes.c: applied base64 support patch from Anthony Carrico
+
+Wed Aug 27 10:58:51 CEST 2003 Igor Zlatkovic <igor@zlatkovic.com>
+
+	* include/libxml/[threads-xpointer].h: realigned parameters
+	  after taint
+
+Wed Aug 27 09:59:54 CEST 2003 Igor Zlatkovic <igor@zlatkovic.com>
+
+	* include/libxml/xmlexports.h: fixed defs for Borland compiler,
+	  as reported by Eric Zurcher
+
+Tue Aug 26 15:54:04 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* relaxng.c: fixed bug #120386 again a problem introduced when
+	  trying to reuse automata for content validation. Fix a bug report
+          problem on zeroOrMore
+	* result/relaxng/tutor3_7_err: change slightly error reporting.
+
+Mon Aug 25 13:24:57 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/Makefile.am: make sure the new header will
+	  be included when generating a new distribution.
+
+Mon Aug 25 12:37:05 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* relaxng.c: fixed a couple of stupid bugs in the state allocation
+	  routines which led to bug #120040 and the ones reported by
+	  Martijn Faassen
+
+Mon Aug 25 12:37:23 CEST 2003 Igor Zlatkovic <igor@zlatkovic.com>
+
+	* include/libxml/parserInternals.h include/libxml/relaxng.h
+	  include/libxml/SAX.h include/libxml/SAX2.h: realigned the
+	  parameters after taint.
+	
+Mon Aug 25 11:16:01 CEST 2003 Igor Zlatkovic <igor@zlatkovic.com>
+
+	* include/libxml/xmlversion.h.in: moved export defs to a separate
+	  file for consistency.
+	* include/libxml/xmlexports.h: new file, contains export defs.
+	  
+Mon Aug 25 11:01:49 CEST 2003 Igor Zlatkovic <igor@zlatkovic.com>
+
+	* include/libxml/*.h genUnicode.py: exportability taint
+	  of the headers.
+
+Thu Aug 21 12:37:46 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* SAX.c: make the deprecated interfaces log an error message
+	  to be sure it won't get used.
+
+Thu Aug 21 00:50:32 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am SAX2.c include/libxml/Makefile.am include/libxml/SAX2.h:
+	  Adding new version of the SAX interface, it's not there yet,
+	  currently just preparing the work
+	* globals.c parser.c SAX.c include/libxml/SAX.h 
+	  include/libxml/globals.h include/libxml/parser.h: doing some
+	  refactoring of the SAXv1 interfaces, obsoleting a bunch of them
+	  while keeping functionalities, preparing SAX2 integration.
+	* dict.c: small cleanup.
+
+Wed Aug 20 00:20:01 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: fixes a small bug introduced in last commit and detected
+	  by valgrind.
+
+Tue Aug 19 16:54:18 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* dict.c hash.c: optimization when freeing hash tables.
+	* parser.c xmlIO.c include/libxml/tree.h: some tuning of buffer
+	  allocations
+	* parser.c parserInternals.c include/libxml/parser.h: keep a
+	  single allocated block for all the attributes callbacks,
+	  avoid useless malloc()/free()
+	* tree.c: do not realloc() when growing a buffer if the buffer
+	  ain't full, malloc/memcpy/free avoid copying memory.
+
+Mon Aug 18 18:37:01 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmllint.c doc/xmllint.xml doc/xmllint.1: added option
+	  --dtdvalidfpi for Tobias Reif
+
+Mon Aug 18 14:03:03 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* dict.c include/libxml/dict.h Makefile.am include/libxml/Makefile.am:
+	  new dictionary module to keep a single instance of the names used
+	  by the parser
+	* DOCBparser.c HTMLparser.c parser.c parserInternals.c valid.c:
+	  switched all parsers to use the dictionary internally
+	* include/libxml/HTMLparser.h include/libxml/parser.h
+	  include/libxml/parserInternals.h include/libxml/valid.h:
+	  Some of the interfaces changed as a result to receive or return
+	  "const xmlChar *" instead of "xmlChar *", this is either
+	  insignificant from an user point of view or when the returning
+	  value changed, those function are really parser internal methods
+	  that no user code should really change
+	* doc/libxml2-api.xml doc/html/*: the API interface changed and
+	  the docs were regenerated
+
+Sun Aug 17 23:05:38 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: applied patch to xmlCleanupParser from Dave Beckett
+
+Sat Aug 16 22:53:42 HKT 2003 William Brack <wbrack@mmm.com.hk>
+
+	* doc/parsedecl.py, doc/libxml2-refs.xml, doc/API*.html:
+	  fixed part (2) of bug 119535 (wrong alpha case on filenames)
+	  
+Sat Aug 16 20:35:28 HKT 2003 William Brack <wbrack@mmm.com.hk>
+
+	* doc/API*.html, doc/html/*: regenerated API documentation
+	  for xmlsoft.org (part of Bug 119535)
+
+Fri Aug 15 14:58:37 HKT 2003 William Brack <wbrack@mmm.com.hk>
+
+	* encoding.c, threads.c, include/libxml/HTMLparser.h,
+	  doc/libxml2-api.xml: Minor changes to comments, etc. for
+	  improving documentation generation
+	* doc/Makefile.am: further adjustment to auto-generation of
+	  win32/libxml2.def.src
+	  
+Fri Aug 15 02:24:20 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* News configure.in: preparing libxml2-2.5.10 release
+	* doc/* : updated the doc and rebuilt
+
+Fri Aug 15 01:55:53 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: fixing the xmlSAXParseDTD bug #119536 raised by
+	  Malcolm Tredinnick with the patch he suggested.
+
+Fri Aug 15 01:37:10 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLparser.c: allocation error #119784 raised by Oliver Stoeneberg
+
+Fri Aug 15 00:41:58 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* uri.c: fixing an use of strcpy() where both strings overlap
+	  pointed out by valgrind.
+
+Thu Aug 14 17:10:39 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* DOCBparser.c globals.c include/libxml/xmlmemory.h: get rid of
+	  some compilation warnings.
+	* xinclude.c: fix the performance problem reported by Kevin Ruscoe
+	  plus some cleanup and better error reporting.
+
+Thu Aug 14 14:13:43 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* encoding.c: applied UTF-16 encoding handling patch provided by
+	  Mark Itzcovitz
+	* encoding.c parser.c: more cleanup and fixes for UTF-16 when 
+	  not having iconv support.
+
+Thu Aug 14 03:19:08 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am configure.in example/Makefile.am libxml.h nanoftp.c
+	  nanohttp.c xmllint.c: Applied patch from Mikhail Grushinskiy for
+	  mingw compiler on Windows.
+
+Thu Aug 14 02:28:36 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: fixed the serious CPU usage problem reported by
+	  Grant Goodale
+	* HTMLparser.c: applied patch from Oliver Stoeneberg about a free
+	  missing in htmlSAXParseDoc
+
+Tue Aug 12 22:48:10 HKT 2003 William Brack <wbrack@mmm.com.hk>
+
+	* doc/Makefile.am: Removed dependency from libxml2.def.src
+
+Tue Aug 12 18:55:08 HKT 2003 William Brack <wbrack@mmm.com.hk>
+
+	* autogen.sh: took away the requirement for automake-1.4,
+	  changed the messages for getting auto* tools to current
+	  gnu pages.
+	* configure.in: added check for Linux Dec alpha requiring
+	  -ieee flag, fixed test for ipv6
+	* trionan.c: fixed problem for compiling on Linux Dec alpha
+	  using native compiler
+	* doc/Makefile.am: implemented regeneration of win32/libxml2.def.src
+	  whenever libxml2-api.xml is changed.
+	  
+Mon Aug 11 17:02:23 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: cleaning up a problem when parsing UTF-16 and libiconv
+	  is not used.
+
+Sun Aug 10 08:13:22 HKT 2003 William Brack <wbrack@mmm.com.hk>
+
+	* win32/libxml2.def.src: renerated with fixed libxml2-api.xml
+
+Sun Aug 10 00:22:55 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* News configure.in: preparing libxml2-2.5.9 release
+	* doc/* : updated the doc and rebuilt
+
+Sat Aug  9 20:00:13 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/xmlreader.h doc/libxml2-api.xml: changing an enum
+	  definition to get a correct API XML description. This was apparently
+	  breaking Windows build.
+
+Sat Aug  9 13:41:21 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLparser.c: fixed a nasty bug #119387, bad heuristic from
+	  the progressive HTML parser front-end on large character data
+	  island leading to an erroneous end of data detection by the
+	  parser. Some cleanup too to get closer from the XML progressive
+	  parser.
+
+Sat Aug  9 00:42:47 HKT 2003 William Brack <wbrack@mmm.com.hk>
+
+	* win32/configure.js: Added in support for the ISO8859X
+	  module (patch provided by Jesse Pelton)
+
+Fri Aug  8 15:56:32 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLtree.c tree.c threads.c: hum try to avoid some troubles
+	  when the library is not initialized and one try to save, the 
+	  locks in threaded env might not been initialized, playing safe
+	* xmlschemastypes.c: apply patch for hexBinary from Charles Bozeman
+	* test/schemas/hexbinary_* result/schemas/hexbinary_*: also added
+	  his tests to the regression suite.
+
+Fri Aug  8 18:47:38 HKT 2003 William Brack <wbrack@mmm.com.hk>
+
+	* win32/defgen.xsl, win32/libxml2.def.src: Bug 119343
+	  (with apologies to Igor) - Enhanced handling of docb and
+	  nanohttp.
+	  
+Thu Aug  7 21:13:22 HKT 2003 William Brack <wbrack@mmm.com.hk>
+
+	* encoding.c: further small changes for warnings when
+	  configured with --with-iconv=no
+
+Wed Aug  6 12:32:11 HKT 2003 William Brack <wbrack@mmm.com.hk>
+
+	* error.c trionan.[ch] testThreads.c python/generator.py:
+	  further small changes to elminate most of the remaining
+	  warnings.
+
+Tue Aug  5 23:51:21 HKT 2003 William Brack <wbrack@mmm.com.hk>
+
+	* error.c HTMLparser.c testC14N.c testHTML.c testURI.c
+	  xmlcatalog.c xmlmemory.c xmlreader.c xmlschemastypes.c
+	  python/libxml.c include/libxml/xmlmemory.h: small changes
+	  to syntax to get rid of compiler warnings.  No changes
+	  to logic.
+
+Mon Aug  4 22:40:54 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* doc/libxml2-api.xml doc/html/*: rebuilt the API and docs.
+
+Mon Aug  4 21:40:34 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: fixed a small problem in the patch for #118763
+	* result/HTML/doc3.htm*: this reverts back to the previous result
+
+Sun Aug  3 21:41:49 EDT 2003 Daniel Veillard <daniel@veillard.com>
+
+	* doc/FAQ.html doc/xml.html: applied doc patch to xml.html
+	  and rebuilt, apparently some C++ wrappers are not available,
+	  c.f. bug #118943
+
+Sun Aug  3 21:30:31 EDT 2003 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: fixing HTML attribute serialization bug #118763
+	  applying a modified version of the patch from Bacek
+	* result/HTML/doc3.htm*: this modifies the output from one test
+
+Sun Aug  3 21:02:30 EDT 2003 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c include/libxml/tree.h: added a new API to split a
+	  QName without generating any memory allocation
+	* valid.c: fixed another problem with namespaces on element
+	  in mixed content case
+	* python/tests/reader2.py: updated the testcase with 
+	  Bjorn Reese fix to reader for unsignificant white space
+	* parser.c HTMLparser.c: cleanup.
+
+Sun Aug  3 20:55:40 EDT 2003 Daniel Veillard <daniel@veillard.com>
+
+	* catalog.c: trying to fix #118754 of possible recursion in the
+	  catalogs. Not fantastically happy about the current fix since
+	  it's likely to break under very thread intensive concurrent
+	  access to the catalog. Better solution might to keep the depth
+	  an extra argument to the resolution functions.
+
+Sun Aug  3 18:56:54 EDT 2003 Daniel Veillard <daniel@veillard.com>
+
+	* valid.c: fixed bug #118712 about mixed content, and namespaced
+	  element names.
+	* test/valid/mixed_ns.xml result/valid/mixed_ns*: added a check
+	  in the regression tests
+
+Fri Aug 1 23:55:23 HKT 2003 William Brack <wbrack@mmm.com.hk>
+
+	Coninuing work on bug 118559
+	* DOCBparser.c: removed 2 unsed vars
+	* xmlregexp.c: changed some numeric const to their enum symbols
+	* xmlreader.c: changed one var define from int to enum
+	  (a little more to be done, awaiting co-ordination)
+	* relaxng.c: deleted one unused var
+	* xmllint.c: deleted some unused vars, changed one arg
+	  val from int to enum
+	* testHTML.c, testDocbook.c: changed some arg vals to enum const
+	* xmlIO.c: fixed typo from last night (small warning msg)
+
+Thu Jul 31 22:44:33 HKT 2003 William Brack <wbrack@mmm.com.hk>
+
+	Working on bug 118559
+	* error.c: deleted unused variable
+	* parserInternals.c: deleted unneeded 'const' qualifier
+	* parser.c: changed variable type for enum temp storage
+	* xmlIO.c: changed debugging var to be inside #ifdef
+	* valid.c: removed unused variable
+	* HTMLparser.c: removed some unneeded 'const' qualifiers
+	* xpath.c: added some type casts, removed some unused vars
+	* xinclude.c: added one type cast
+	* nanohttp.c: repositioned some #ifdef to avoid unused var
+	* nanoftp.c: removed unused var
+
+Wed Jul 30 14:57:55 EDT 2003 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLparser.c: applied a patch from William Brack about
+	  the problem of parsing very large HTML instance with comments
+	  as raised by Nick Kew
+
+Wed Jul 30 12:29:38 EDT 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmlreader.c include/libxml/xmlreader.h: applying cleanup
+	  patch from Bjorn Reese for xmlTextReaderNodeType() and 
+	  significant whitespace. There is an enum for node type
+	  values now.
+
+Wed Jul 30 11:08:21 EDT 2003 Daniel Veillard <daniel@veillard.com>
+
+	* encoding.c: applying patch from Peter Jacobi to added 
+	  ISO-8859-x encoding support when iconv is not available
+	* configure.in include/libxml/xmlversion.h.in
+	  include/libxml/xmlwin32version.h.in: added the glue needed
+	  at the configure level and made it the default for Windows
+
+Tue Jul 29 16:43:48 EDT 2003 Daniel Veillard <daniel@veillard.com>
+
+	* python/generator.py python/libxml.c python/libxml2class.txt:
+	  patch from Joachim Bauch + cleanup for Relax NG error callbacks
+	  in python
+
+Tue Jul 29 12:46:08 EDT 2003 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c parserInternals.c tree.c: applied Peter Jacobi encoding
+	  cleanup patch, and also avoided a possible memory leak
+
+Tue Jul 29 09:28:09 EDT 2003 Daniel Veillard <daniel@veillard.com>
+
+	* encoding.c: fix the previous commit
+
+Tue Jul 29 12:28:17 HKT 2003 William Brack <wbrack@mmm.com.hk>
+
+	* HTMLparser.c: fixed problem with comments reported by Nick Kew
+	* encoding.c: added routines xmlUTF8Size and xmlUTF8Charcmp for
+	  some future cleanup of UTF8 handling
+
+Mon Jul 28 16:39:14 EDT 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: applied a change suggested by Sean Griffin in bug
+	  #118494 about a memory leak in EXSLT
+
+Sun Jul 27 14:30:56 EDT 2003 Daniel Veillard <daniel@veillard.com>
+
+	* relaxng.c: fixed a Relax-NG compilation/streaming bug introduced
+	  when fixing the previous Relax-NG bugs
+	* result/relaxng/*: This slightly changes the output messages of
+	  some regression tests.
+	* configure.in: added support of -with-fexceptions for nested C++
+	  support.
+
+Thu Jul 24 15:46:02 MDT 2003 John Fleck <jfleck@inkstain.net>
+
+	* doc/tutorial/apa.html
+	* doc/tutorial/apb.html
+	* doc/tutorial/apc.html
+	* doc/tutorial/apd.html
+	* doc/tutorial/ape.html
+	* doc/tutorial/apf.html
+	* doc/tutorial/apg.html
+	* doc/tutorial/aph.html
+	* doc/tutorial/ar01s02.html
+	* doc/tutorial/ar01s03.html
+	* doc/tutorial/ar01s04.html
+	* doc/tutorial/ar01s05.html
+	* doc/tutorial/ar01s06.html
+	* doc/tutorial/ar01s07.html
+	* doc/tutorial/ar01s08.html
+	* doc/tutorial/index.html
+	* doc/tutorial/ix01.html
+	* doc/tutorial/xmltutorial.pdf
+	* doc/tutorial/xmltutorial.xml
+	update tutorial with XPath example
+
+
+Thu Jul 24 17:07:06 IST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* SAX.c parser.c: fixing a bug about a special case of namespace
+	  handling, this closes bug #116841
+
+Wed Jul 23 20:52:36 IST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* relaxng.c result/relaxng/*: checked and fixed the compilation
+	  of RNG schemas, fixes a couple of bugs #117097 and #117001 .
+	  This slightly changes the output messages of some regression tests.
+
+Wed Jul 23 15:15:08 IST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmlreader.c: fixed an out of bound error #118052 , the good
+	  part if that base64 code was not in use yet ...
+
+Tue Jul 22 19:42:15 MDT 2003 John Fleck <jfleck@inkstain.net>
+
+	* doc/xmllint.html
+	include html version of the xmllint man page, so an
+	up-to-date version is visible on the Web
+
+Mon Jul 21 21:53:43 IST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xinclude.c include/libxml/xinclude.h: added a new API
+	  xmlXIncludeProcessTree() to process XInclude only on a subtree
+	  this should fix bug #115385
+
+Fri Jul 18 17:11:42 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* relaxng.c include/libxml/relaxng.h: adding Get interface for
+	  the error callback and parameters of parsing and validation
+	  contexts
+	* xmlreader.c: patch to fix bug #117702 about incomplete Read()
+	  on text nodes.
+
+Wed Jul 16 23:15:53 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* parserInternals.c: patch from Dodji Seketeli about UTF16 BOM
+	  when using the push XML parser.
+	* result/utf16bom.xml result/noent/utf16bom.xml test/utf16bom.xml:
+	  added the test to the regression suite.
+
+Tue Jul 15 22:03:13 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* globals.c: add xmlThrDefMutex = NULL in xmlCleanupGlobals() 
+	  as suggested by Rob Richards
+
+Tue Jul 15 15:30:55 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* DOCBparser.c HTMLparser.c entities.c parser.c relaxng.c 
+	  xmlschemas.c xpath.c: removed some warnings by casting xmlChar
+	  to unsigned int and a couple of others.
+
+Fri Jul 11 16:44:22 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmlschemastypes.c: fixes a segfault on empty hexBinary strings
+
+Thu Jul 10 16:02:47 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* nanoftp.c nanohttp.c: cleanup patches from Peter Breitenlohner
+
+Tue Jul  8 16:02:19 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* globals.c threads.c: fixes some problem when freeing unititialized
+	  mutexes
+
+Tue Jul  8 14:15:07 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* nanoftp.c nanohttp.c: the modules should not import <config.h>
+	  directly, some cleanups
+	* xmlschemas.c: Peter Sobisch found a nasty bug in the Schemas
+	  validation code.
+
+Mon Jul  7 18:00:51 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* win32/configure.js: Jesse Pelton pointed out a problem in the
+	  javascript code.
+
+Mon Jul  7 16:39:31 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* NEWS doc/*: regenerated
+	* nanoftp.c nanohttp.c: might fix includes problems with the
+	  Ipv6 support on solaris
+	* tree.c: patch from Markus Keim about xmlHasNsProp() on attributes
+	  defined as #IMPLIED
+
+Sun Jul  6 23:09:13 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in doc/*: preparing release 2.5.8
+	* nanohttp.c: changed some preprocessor block
+	* xmlschemastypes.c: applied patch from Charles Bozeman adding
+	  hexBinary schema datatype and adding support for totalDigits and
+	  fractionDigits facets.
+
+Sun Jul  6 19:56:18 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* debugXML.c xpath.c: fixed 2 bugs pointed in #116448
+
+Sun Jul  6 19:34:17 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xinclude.c: fixed bug #116095 removing the error message when
+	  reapplying XInclude to a document.
+
+Sat Jul  5 22:40:23 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmlIO.c: applied small changes to portability layer for 
+	  compilation on DJGPP Ms-DOS compiler.
+
+Sat Jul  5 22:30:25 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c HTMLparser.c: use the character() SAX callback
+	  if the cdataBlock ain't defined.
+	* xpath.c: fix bug #115349 allowing compilation when configured
+	  with --without-xpath since the Schemas code needs NAN and co.
+
+Sat Jul 5 00:51:30 HKT 2003 William Brack <wbrack@mmm.com.hk>
+
+	Fixed problem with multi-threading, shown by the test program
+	testThreads.  After fix, ran mutiple tests on various speed
+	machines (single and dual processor X86), which all seem okay.
+
+	* catalog.c: added missing xmlRMutexUnlock in xmlLoadCatalog
+
+	* threads.c: added missing initialisation for condition variable
+	  in xmlNewRMutex.
+
+Sat Jun 21 16:10:24 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+        Applying IPv6 patch from Archana Shah <archana.shah@wipro.com>
+	closing bug #114837
+
+	* configure.in: Added checks for IPv6 support and getaddrinfo().
+
+	* acconfig.h: Defined HAVE_GETADDRINFO and SUPPORT_IP6.
+
+	* config.h.in: Defined HAVE_GETADDRINFO and SUPPORT_IP6.
+
+	* nanoftp.c: Structure xmlNanoFTPCtxt contains either sockaddr_storage
+	  field or sockaddr_in field, depending upon the availability of IPv6
+	  support.
+	  have_ipv6(): Added to check for run-time IPv6 support.
+	  (xmlNanoFTPScanURL), (xmlNanoFTPUpdateURL), (xmlNanoFTPScanProxy):
+	  Modified to parse a URI with IPv6 address given in [].
+	  (xmlNanoFTPConnect): Changed to use getaddrinfo for address
+	  resolution, if it is available on the system, as gethostbyname
+	  does not return IPv6 addresses on some platforms.
+	  (xmlNanoFTPGetConnection): Modified type of dataAddr variable to
+	  sockaddr_storage or sockaddr_in depending upon the IPv6 support.
+	  Sending EPSV, EPRT or PASV, PORT depending upon the type of address
+	  we are dealing with.
+
+	* nanohttp.c: (have_ipv6): Added to check for run-time IPv6 support.
+	  (xmlNanoHTTPScanURL), (xmlNanoHTTPScanProxy): Modified to parse
+	  a URI with IPv6 address given in [].
+	  (xmlNanoHTTPConnectHost): Modified to use getaddrinfo if it is
+	  available on the system. Also IPv6 addresses will be resolved by
+	  gethostbyname only if IPv6 run-time support is available.
+	  (xmlNanoHTTPConnectAttempt): Modified to deal with IPv6 address.
+
+Sat Jun 14 18:46:51 CEST 2003 Igor Zlatkovic <igor@zlatkovic.com>
+
+	* win32/configure.js include/win32config.h 
+	  include/libxml/xmlversion.h.in: Applied the patch for BCB
+	  by Eric Zurcher.
+
+Fri Jun 13 14:27:19 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* doc/Makefile.am doc/html/*: reverted back patch for #113521,
+	  due to #115104 and while fixing #115101 . HTML URLs must not
+	  be version dependant.
+
+Fri Jun 13 12:03:30 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* entities.c: do not generate &quot; for " outside of attributes
+	* result//*: this changes the output of some tests
+
+Mon Jun  9 12:28:58 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c xmlIO.c: trying to fix #114277 about when file
+	  remapping and escaping should really be attempted.
+
+Mon Jun  9 11:06:09 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* doc/*: applied a patch from Gman for building docs
+	* valid.c xmllint.c include/libxml/valid.h: applied a patch from
+	  Gary Pennington to provide an allocator for xmlValidCtxt
+	* xmlreader.c: applied patch from Jacek Konieczny fixing bug
+	  #113580 about data not being passed immediately.
+
+Thu Jun  5 11:31:02 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: applied a couple of patches from Mark Itzcovitz
+	  to handle saving back "UTF-16" documents.
+
+Mon Jun  2 21:56:15 MVT 2003 Daniel Veillard <daniel@veillard.com>
+
+	* relaxng.c xmlschemas.c include/libxml/schemasInternals.h: commiting
+	  some work done while in the Maldives (hence the timezone on the
+	  laptop !)
+	* result/schemas/length3* test/schemas/deter0_*
+	  test/schemas/group0_*: some tests added too
+
+Mon Jun  2 15:34:17 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* encoding.c: small fix
+	* xmlIO.c: fixed an error message
+
+Tue May 20 14:21:23 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* parserInternals.c: fixing Red Hat bug #91013 where xmllint was
+	  accepting an improper UTF8 sequence
+
+Sat May 17 12:53:11 CEST 2003 Igor Zlatkovic <igor@zlatkovic.com>
+
+	* threads.c: applied the patch from Stéphane Bidoul for getting
+	  rid of extra threads in a dynamic library.
+	* win32/configure.js: threads default to 'native' now.
+	  
+Fri May 16 13:17:52 EDT 2003 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLtree.c: fixing  bug #112904: html output method escaped
+	  plus sign character in URI attribute.
+
+Thu May 15 18:06:18 EDT 2003 Daniel Veillard <daniel@veillard.com>
+
+	* build_glob.py global.data globals.c parser.c
+	  include/libxml/globals.h: patch from Stéphane Bidoul for setting
+	  up threads global defaults.
+	* doc/libxml2-api.xml: this extends the API with new functions
+	* python/tests/Makefile.am python/tests/reader2.py
+	  python/tests/thread2.py: integrated the associated testcase and
+	  fixed the error string used in reader2
+
+Wed May 14 14:56:46 EDT 2003 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in libxml.spec.in python/Makefile.am: trying
+	  to conciliate --with-python= requirements and RPM builds,
+	  a PITA really...
+
+Tue May 13 18:30:34 EDT 2003 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLparser.c: oops last commit introduced a memory leak.
+
+Tue May 13 18:10:38 EDT 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmllint.c doc/xmllint.xml: added --nonet option
+	* doc/Makefile.am: fixing #112803 by adding --nonet when calling
+	  xsltproc or xmllint
+	* doc/xmllint.xml doc/xmllint.1: also added --schema doc and
+	  rebuilt
+	* HTMLparser.c: cleaned up the HTML parser context build when 
+	  using an URL
+
+Tue May 13 16:35:04 EDT 2003 Daniel Veillard <daniel@veillard.com>
+
+	* libxml.spec.in: added a comment about bug #112902 
+
+Mon May 12 21:58:00 EDT 2003 William Brack <wbrack@mmm.com.hk>
+
+	* minor cleanup of configure '--help' display
+	* error.c: enhanced xmlParserPrintFileContext to fix bug #109942
+
+Mon May 12 17:53:30 EDT 2003 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: PI nodes in external subset were not freed :-\
+	  fixes bug #112842
+
+Mon May 12 11:23:27 EDT 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmllint.c: added --schema option to run WXS schema validation
+	* xmlschemas.c xmlschemastypes.c include/libxml/schemasInternals.h:
+	  tried to improve error reporting in the Schema code, some cleanup
+	  too.
+
+Sun May 11 16:13:20 EDT 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmlschemas.c: fixed some problems in the handling of errors,
+	  and attributes addressed by references.
+	* test/schemas/* result/schemas/*: dropped the verbosity level
+	  and added a couple of new tests
+
+Sat May 10 16:01:21 EDT 2003 Daniel Veillard <daniel@veillard.com>
+
+	* relaxng.c: Stéphane Bidoul found an off by one addressing
+	  error on the error handling.
+
+Fri May  9 19:08:20 EDT 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmlschemastypes.c: trying to fix #112673
+
+Fri May  9 18:14:16 EDT 2003 Daniel Veillard <daniel@veillard.com>
+
+	* DOCBparser.c catalog.c parser.c relaxng.c: removed multiple
+	  warning, this fixed a bug and should close #111574
+
+Fri May  9 15:34:32 EDT 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmlschemas.c: fixing bug #104081 with xs:all with an element
+	  holding minOccurs="0"
+	* test/schemas/all_* result/schemas/all_*: added some regression
+	  tests for that bug
+	* xmllint.c xmlreader.c: patches from Joerg Schmitz-Linneweber and
+	  Garry Pennington to compile without schemas support.
+
+Thu May  1 10:02:35 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: fixed a problem with xmlUnlinkNode() for DTDs.
+
+Wed Apr 30 14:16:08 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xml2-config.in: try to fix Red hat bug #89957, do not
+	  output -L/usr/lib64
+	* xmlreader.c: fixed a typo in a comment
+
+Tue Apr 29 07:32:02 MDT 2003 John Fleck <jfleck@inkstain.ent>
+
+	* doc/tutorial/aph.html, ix01.html
+	forgot to cvs add the new files. Thanks to Roland van Laar
+	for pointing this out
+
+Tue Apr 29 14:36:49 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmlschemas.c doc/libxml2-api.xml: fixing a function comment
+	* doc/Makefile.am doc/apibuild.py doc/gnome-xml.sgml: switching
+	  to the XML/XSLT doc generation closing #111799
+	* doc/html/*: complete update of the HTML results
+
+Mon Apr 28 14:51:41 CEST 2003 Igor Zlatkovic <igor@zlatkovic.com>
+
+	* win32/defgen.xsl: fixed the conditional for unicode map,
+	  removed hardcoded schema entries
+	  
+Mon Apr 28 02:19:00 CEST 2003 Igor Zlatkovic <igor@zlatkovic.com>
+
+	* win32/defgen.xsl: new file, stylesheet for generating 
+	  win32/libxml2.def.src from doc/libxml2-api.xml
+	* win32/libxml2.def.src: is autogenerated from now on, changes
+	  to this file will not appear here anymore
+	  
+Mon Apr 28 00:12:11 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* win32/configure.js python/setup.py.in: applied patch
+	  from Stéphane Bidoul for the Python bindings on the new
+	  release.
+
+Sun Apr 27 17:56:21 CEST 2003 Igor Zlatkovic <igor@zlatkovic.com>
+
+	* debugXML.c: included libxml/uri.h for xmlCanonicPath
+	  declaration
+	* win32/configure.js: thread-enabled build is now default
+	* win32/libxml2.def.src: added more exports
+
+Sun Apr 27 00:23:05 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* NEWS doc/*.xsl doc/*.html: updated the web site separated
+	  developers from common pages, made the transition to XHTML1,
+	  added validity checking to the makefile rules.
+
+Sat Apr 26 23:17:51 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: fix for xmlIOParseDTD same as previous and reported
+	  by Petr Pajas
+
+Sat Apr 26 15:26:04 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: applied fix to xmlSAXParseDTD from Malcolm Tredinnick
+	  closing #111638
+
+Sat Apr 26 14:00:58 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* python/generator.py: fixed a problem in the generator where
+	  the way functions are remapped as methods on classes was
+	  not symetric and dependant on python internal hash order,
+	  as reported by Stéphane Bidoul
+
+Fri Apr 25 21:52:33 MDT 2003 John Fleck <jfleck@inkstain.net>
+
+	* doc/tutorial:
+	xmltutorial.xml
+	xmltutorial.pdf
+	*.html
+	add appendix on generating compiler flags, more indexing
+
+Sat Apr 26 01:10:48 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* triodef.h vms/build_libxml.com: applied patch from Craig A. Berry
+	  to get libxml-2.5.7 to compile on OpenVMS
+
+Fri Apr 25 18:42:35 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: fixing an xmlParseDTD bug raised by Petr Pajas
+
+Fri Apr 25 15:20:29 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* doc/Makefile.am doc/xmlcatalog.1 doc/xmlcatalog_man.xml
+	  doc/xmllint.1 doc/xmllint.xml: automated the generation of the
+	  man page based on xsltproc and a stylesheet PI in the XML.
+
+Fri Apr 25 12:37:33 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* doc/xmllint.*: trying to fix #110541 where &nbsp; generated
+	  character preventing rendering by the man command.
+
+Fri Apr 25 01:09:23 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* NEWS configure.in: preparing release 2.5.7
+	* doc/*: updated and rebuilt the docs
+	* doc/apibuild.py: fixed the script
+
+Thu Apr 24 19:11:12 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am doc/apibuild.py: make sure the OOM code don't
+	  get in the way of the builds
+	* doc/libxml2-api.xml python/libxml2class.txt: automatic update
+
+Thu Apr 24 18:01:46 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am testOOM.c testOOMlib.[ch] : integrated the Out Of
+	  Memory test from Havoc Pennington #109368
+	* SAX.c parser.c parserInternals.c tree.c uri.c valid.c
+	  xmlmemory.c xmlreader.c xmlregexp.c include/libxml/tree.h
+	  include/libxml/parser.h: a lot of memory allocation cleanups
+	  based on the results of the OOM testing
+	* check-relaxng-test-suite2.py: seems I forgot to commit the
+	  script.
+
+Wed Apr 23 17:16:41 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmlschemastypes.c: trivial fix for 109774 removing a warning
+
+Wed Apr 23 15:49:32 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* DOCBparser.c SAX.c catalog.c debugXML.c parser.c: try to find
+	  more places where xmlCanonicPath() must be used to convert
+	  filenames to URLs, trying to fix #111088
+
+Wed Apr 23 09:35:12 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* python/libxml.c python/libxml.py: applied patch from 
+	  Brent M Hendricks adding binding for xmlCatalogAddLocal
+
+Tue Apr 22 15:18:01 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLparser.c: tried to fix #98879 again in a more solid
+	  way.
+	 
+Tue Apr 22 13:58:43 CEST 2003 Igor Zlatkovic <igor@zlatkovic.com>
+
+	* win32/libxml2.def.src: added more exports from the relaxng and
+	  xmlreader clan
+
+Tue Apr 22 10:35:13 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* SAX.c test/valid/ns* test/result/ns*: applied the patch
+	  provided by Brent Hendricks fixing #105992 and integrated the
+	  examples in the testsuite.
+
+Tue Apr 22 01:06:09 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* TODO: updated a bit
+	* configure.in: fixed the comment, threads now default to on
+	* parserInternals.c: fixed an erroneous xmlMallocAtomic() call
+
+Mon Apr 21 23:33:38 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* globals.c libxml.h parser.c parserInternals.c tree.c xmllint.c
+	  xmlreader.c include/libxml/parser.h: a lot of performance work
+	  especially the speed of streaming through the reader and push
+	  interface. Some thread related optimizations. Nearly doubled the
+	  speed of parsing through the reader.
+
+Sun Apr 20 10:36:05 MDT 2003 John Fleck <jfleck@inkstain.net>
+
+	* doc/xmllint.xml
+	* doc/xmllint.1
+	update man page to explain use of --stream
+
+Sat Apr 19 02:03:24 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* DOCBparser.c HTMLparser.c c14n.c catalog.c encoding.c globals.c
+	  nanohttp.c parser.c parserInternals.c relaxng.c tree.c uri.c
+	  xmlmemory.c xmlreader.c xmlregexp.c xpath.c xpointer.c
+	  include/libxml/globals.h include/libxml/xmlmemory.h: added
+	  xmlMallocAtomic() to be used when allocating blocks which
+	  do not contains pointers, add xmlGcMemSetup() and xmlGcMemGet()
+	  to allow registering the full set of functions needed by
+	  a garbage collecting allocator like libgc, ref #109944
+
+Fri Apr 18 16:37:41 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in: switched to have thread support enabled by default,
+	  didn't got troubles with ABI compatibility on Linux, hope it
+	  won't break on strange OSes, if yes, report the system ID
+	* doc/libxml2-api.xml: just rebuilt the API
+
+Fri Apr 18 14:31:15 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* libxml.h include/libxml/parser.h parser.c xmlIO.c DOCBparser.c: 
+	  added support for large file, tested with a 3+GB instance,
+	  and some cleanup.
+	* catalog.c: added a TODO
+	* Makefile.am: added some "make tests" comments
+
+Thu Apr 17 14:51:57 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* relaxng.c: some cleanups
+	* doc/xmlreader.html: extended the document to cover RelaxNG and
+	  tree operations
+	* python/tests/Makefile.am python/tests/reader[46].py: added some
+	  xmlReader example/regression tests
+	* result/relaxng/tutor*.err: updated the output of a number of tests
+
+Thu Apr 17 11:35:37 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* relaxng.c: valgrind pointed out an uninitialized variable error.
+
+Thu Apr 17 11:06:28 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/relaxng.h relaxng.c include/libxml/xmlreader.h
+	  xmlreader.c: augnemting the APIs, cleanups.
+	* parser.c: cleanup bug #111005
+	* xmlIO.c: added some missing comments
+
+Wed Apr 16 17:46:50 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* relaxng.c xmllint.c: more work on RelaxNG streaming validation
+	  trying to improve the subset compiled, and more testing.
+	* doc/downloads.html doc/xml.html doc/xmlmem.html: some updates on the
+	  documentation
+	* test/relaxng/tutor11_1_3.xml: fixes the DTD path
+	* result/relaxng/*.err: fix some of the outputs
+
+Wed Apr 16 01:28:15 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* relaxng.c xmlreader.c xmllint.c include/libxml/relaxng.h
+	  include/libxml/xmlreader.h: implemented streaming of
+	  RelaxNG (when possible) on top of the xmlReader interface,
+	  provided it as xmllint --stream --relaxng .rng .xml
+	  This seems to mostly work.
+	* Makefile.am: updated to test RelaxNG streaming
+
+Mon Apr 14 18:08:33 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* relaxng.c include/libxml/relaxng.h: integrated the regexp
+	  based validity checking of fragments of the document for
+	  which the RNG can be compiled to regexps. Works on all regression
+	  tests, only fix needed is related to error messages.
+
+Sun Apr 13 21:51:00 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* relaxng.c xmlregexp.c include/libxml/xmlautomata.h
+	  include/libxml/xmlregexp.h: Starting work precompiling
+	  parts of RelaxNG schemas. Not plugged onto validity checking
+	  yet, just the regexp building part. Needed to extend some
+	  of the automata and regexp APIs.
+
+Fri Apr 11 21:36:21 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmllint.c xmlreader.c include/libxml/xmlreader.h: make sure
+	  xmllint --stream and xmllint --stream --valid returns errors
+	  code appropriately
+
+Fri Apr 11 10:59:24 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmlreader.c include/libxml/xmlreader.h: Added the Expand()
+	  and Next() operation to work on subtrees within the reader
+	  framework.
+	* doc/libxml2-api.xml python/libxml2class.txt: resulting updates
+	* python/tests/reader5.py: added an example for those new
+	  functions of the reader.
+
+Thu Apr 10 23:38:13 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLtree.c: patch from Vasily Tchekalkin to fix #109865
+
+Thu Apr 10 15:32:44 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmlreader.c: fixing HasValue for namespace as raised by 
+	  Denys Duchier
+
+Wed Apr  9 14:07:18 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLparser.c include/libxml/HTMLparser.h:  exported
+	  htmlCreateMemoryParserCtxt() it was static
+
+Wed Apr  9 13:21:48 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmlschemas.c xmlschemastypes.c include/libxml/xmlschemas.h:
+	  update from Charles Bozeman for date and duration types
+	* test/schemas/date_0.* test/schemas/dur_0.*
+	  result/schemas/date_0.* result/schemas/dur_0.*: updated too
+
+Mon Apr  7 12:19:26 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c valid.c xpath.c include/libxml/tree.h include/libxml/valid.h:
+	  fixing bug #107129, removing excessive allocation and calls
+	  to *printf in the code to build QName strings.
+
+Sat Apr  5 11:41:36 CEST 2003 Igoe Zlatkovic <igor@zlatkovic.com>
+
+	* win32/libxml2.def.src: fixed conditional exports, reported by
+	  Luke Murray.
+
+Fri Apr  4 18:08:00 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: fixed a possible problem with xmlRecoverMemory()
+
+Thu Apr  3 17:24:44 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* trio.c trio.h triodef.h trionan.c trionan.h triop.h triostr.c
+	  triostr.h: Bjorn sent an update for the TRIO portability layer.
+
+Tue Apr  1 21:57:26 CEST 2003 Igor Zlatkovic <igor@zlatkovic.com>
+
+	* win32/libxml2.def.src: exported new functions
+
+Tue Apr  1 13:09:46 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in NEWS: preparing release 2.5.6
+	* doc/*: updated and rebuilt the docs
+
+Tue Apr  1 11:52:15 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* SAX.c: fixed an uninitialized memory access pointed by valgrind
+	  on C14Ntests
+
+Tue Apr  1 00:12:28 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* relaxng.c: one more fixup of error message reporting
+
+Mon Mar 31 18:36:32 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* relaxng.c: more work on bug #109225, and fixed an uninitialized
+	  variable pointed out by valgrind
+
+Mon Mar 31 18:05:22 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* relaxng.c: try to work on bug #109225 and provide better
+	  error reports.
+	* result/relaxng/* : this change the output of a number of tests
+	* xinclude.c: fixing the parsed entity redefinition problem
+	  raised on the list.
+	* test/schemas/date_0.xsd: updated the date test c.f. E2-12
+
+Mon Mar 31 13:19:04 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmlschemastypes.c: fixed date comparison to handle the tzo
+	  The only failures left are disagreements on Notations and
+	  '+1' not being allowed for ulong, uint, ushort and ubyte.
+
+Mon Mar 31 12:11:47 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmlschemastypes.c: fixed gMonth parsing routine accordingly
+	  to the XML Schemas errata
+	  http://www.w3.org/2001/05/xmlschema-errata#e2-12
+
+Sun Mar 30 23:04:18 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* relaxng.c xmlschemastypes.c: more work on XML Schemas datatypes
+	  and facets support. Currently only schemas with binHex or
+	  base64 don't compile. A few error left in the test suite:
+	  found 1035 test instances: 919 success 23 failures
+	  most are gdate or gdateyear failing check, and a few cases where
+	  James clark tests results are strange.
+	* valid.c: allow to reuse the Notation checking routine without
+	  having a validation context.
+	* SAX.c: removed a #if 0
+
+Sat Mar 29 17:35:05 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xinclude.c: forgot to apply one check from #106931 patch
+	* xmlschemastypes.c: more work on XML Schemas datatypes
+
+Sat Mar 29 11:49:25 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* relaxng.c include/libxml/relaxng.h xmlschemastypes.c: more work
+	  on cleaning up XML Schemas datatypes based on James Clark tests
+	  test/xsdtest/xsdtest.xml
+
+Fri Mar 28 14:24:08 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* relaxng.c: implemented comparisons for Schemas values.
+	* xmlschemastypes.c include/libxml/xmlschemastypes.h: fixed
+	  some bugs in duration handling, comparisons for durations
+	  and decimals, removed all memory leaks pointed out by James
+	  testsuite. Current status is now
+	  found 238 test schemas: 197 success 41 failures
+	  found 1035 test instances: 803 success 130 failures
+
+Fri Mar 28 00:41:55 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmlschemas.c include/libxml/xmlschemas.h: fixed bugs and memory
+	  leaks in the W3C XML Schemas code
+	* xmlschemastypes.c: implemented nonPositiveInteger
+	* test/schemas/length2_0.xsd result/schemas/length2_0_0.err:
+	  fixed the test and result.
+
+Thu Mar 27 22:23:07 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLparser.c tree.c: two patches from James Bursa on the HTML
+	  parser and a typo
+	* xmlschemastypes.c: reindenting, fixing a memory access
+	  problem with dates.
+
+Thu Mar 27 15:53:35 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: fixing #109227 providing more context in case of 
+	  start/end tag mismatch
+	* python/tests/ctxterror.py python/tests/readererr.py: update the
+	  tests accordingly
+
+Thu Mar 27 15:22:41 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xinclude.c: should fix #109327 errors on memory accesses
+
+Thu Mar 27 15:06:13 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLtree.c: Fixed reopening of #78662 <form action="...">
+	  is an URI reference
+
+Wed Mar 26 22:38:39 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: fixed bug #109160 on non-ASCII IDs
+
+Wed Mar 26 17:30:37 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: Norm suggested a nicer error message for xml:space values
+	  errors
+
+Wed Mar 26 01:34:19 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c include/libxml/xpath.h: first part of the fix to
+	  performance bug #108905, adds xmlXPathOrderDocElems() providing
+	  document order for nodes.
+	* python/libxml.c: Python may require TRIO as Albert Chin pointed out
+
+Tue Mar 25 16:07:00 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmlschemastypes.c: removing a warning with Sun compiler
+	  bug #109154
+
+Tue Mar 25 07:02:56 MST 2003 John Fleck <jfleck@inkstain.net>
+
+	* doc/xmllint.xml
+	* doc/xmllint.1
+	update xmllint man page with --relaxng option
+
+Tue Mar 25 12:07:03 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* python/setup.py.in : was missing "drv_libxml2.py"
+
+Mon Mar 24 19:38:05 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c xpath.c: some changes related to the new way of 
+	  handling Result Value Tree, before 2.5.5
+
+Mon Mar 24 16:36:23 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in NEWS: preparing release 2.5.5
+	* doc/* : updated the documentation and regenerated it.
+
+Mon Mar 24 14:56:01 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: fixed some problems related to #75813 about handling
+	  of Result Value Trees
+
+Sun Mar 23 22:57:20 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* uri.c: applied a set of patches from Lorenzo Viali correcting
+	  URI parsing errors.
+
+Sun Mar 23 22:00:14 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: validity status was not passed back when validating in
+	  entities, but raised by Oliver Fischer
+
+Sun Mar 23 21:30:50 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLtree.c: avoid escaping ',' in URIs
+
+Sun Mar 23 12:57:00 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: fixing bug #108976 get the ID/REFs to reference 
+	  the ID in the document content and not in the entity copy
+	* SAX.c include/libxml/parser.h: more checking of the ID/REF
+	  stuff, better solution for #107208
+	* xmlregexp.c: removed a direct printf, dohhh
+        * xmlreader.c: fixed a bug on streaming validation of empty 
+	  elements in entities
+	* result/VC/ElementValid8 test/VCM/v20.xml result/valid/xhtml1.xhtml:
+	  cleanup of the validation tests
+	* test/valid/id* test/valid/dtds/destfoo.ent result/valid/id*:
+	  added more ID/IDREF tests to the suite
+
+Sat Mar 22 23:38:08 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmlreader.c: fixed #107043 removing 2 warnings with Sun One
+	  compiler.
+
+Sat Mar 22 18:50:45 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* relaxng.c: valgrind'ed and cleaned up a couple of memory issues.
+
+Sat Mar 22 16:15:50 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* SAX.c: fix bug #107208 avoid false duplicates when ID/REFs are
+	  defined in entities content
+
+Sat Mar 22 15:53:27 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* SAX.c: Fixed validation bug #108858 on namespace names using
+	  entities and reported by Brent Hendricks
+	* xmllint.c: report xmlTextReaderHasValue() result in --stream
+	  --debug output.
+
+Sat Mar 22 13:32:39 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmlreader.c: fixed bug #108801 reported by Malcolm Tredinnick
+	  about the DocType node not being reported sometimes.
+	* python/tests/reader.py: added to test to the regression checks
+
+Sat Mar 22 01:57:40 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmlreader.c: fixed bug #108546 on long CDATA (or text nodes)
+	  reported by Edd Dumbill
+
+Sat Mar 23 01:00:24 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLparser.c parser.c parserInternals.c: patch from
+	  johan@evenhuis.nl for #107937 fixing some line counting
+	  problems, and some other cleanups.
+	* result/HTML/: this result in some line number changes
+
+Fri Mar 21 22:19:14 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in Makefile.am: fixed Red Hat bug #86118 use libxml2.spec
+	  instead of libxml.spec
+	* relaxng.c: fixed some of the error reporting excessive
+	  verbosity
+	* catalog.c debugXML.c valid.c xmlreader.c xmlschemas.c xpath.c
+	  xmlschemastypes.c: removed some warnings from gcc
+	* doc/libxml2-api.xml: rebuilt
+
+Fri Mar 21 17:25:23 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* relaxng.c: another optimization, for choice this time
+	* result/relaxng/spec1* result/relaxng/tutor12_1* 
+	  result/relaxng/tutor3_7: cleanups.
+
+Fri Mar 21 13:41:23 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* relaxng.c: fixed xmlRelaxNGNodeMatchesList
+	* test/relaxng/testsuite.xml: augmented the test suite
+	* result/relaxng/spec1* result/relaxng/tutor12_1*: this fixes
+	  some schemas validation tests in the presence of foreign 
+	  namespaces.
+
+Fri Mar 21 02:23:34 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* relaxng.c: added another interleave speedup.
+
+Thu Mar 20 17:22:00 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmlschemastypes.c: added integer and fixed one of the
+	  IDREFS regression tests pbm
+	* result/relaxng/docbook_0.err: updated
+
+Wed Mar 19 21:58:47 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* valid.c xmlschemastypes.c: attempt to cope with ID/IDREF(S)
+	  declared both in the DTD and in the Schemas <grin/>
+	* relaxng.c: more debug, added a big optimization for <mixed>
+	* test/relaxng/testsuite.xml: augmented the testsuite
+	* test/relaxng/ result/relaxng: added the RelaxNG spec and a 
+	  DocBook example to the regression tests
+
+Wed Mar 19 11:34:10 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* check-xsddata-test-suite.py: cosmetic change for output
+	* relaxng.c: try to minimize calls to malloc/free for states.
+
+Tue Mar 18 17:50:31 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: removed a warning
+	* xmlschemastypes.c: more cleanup, added ENTITY and ENTITIES
+	  support
+	* check-relaxng-test-suite.py check-xsddata-test-suite.py:
+	  cleanup/improvements of the regression tests batch
+	* test/relaxng/testsuite.xml: augmented libxml2 own testsuite
+
+Tue Mar 18 12:36:22 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* relaxng.c: fixed error msg cleanup deallocation
+	* xmlschemastypes.c: added a function to handle lists of
+	  atomic types, added support for IDREFS
+
+Tue Mar 18 01:28:15 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* relaxng.c valid.c xmlschemastypes.c: added Datatype ID
+	  and IDREF, usable from RelaxNG now
+	* include/libxml/xmlschemastypes.h: need to add a new interface
+	  because the validation modifies the infoset
+	* test/relaxng/testsuite.xml: extended the testsuite
+
+Mon Mar 17 16:34:07 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* relaxng.c: fixed the last core RelaxNG bug known #107083,
+	  shemas datatype ID/IDREF support still missing though.
+	* xmlreader.c: fix a crashing bug with prefix raised by
+	  Merijn Broeren
+	* test/relaxng/testsuite.xml: augmented the testsuite with
+	  complex inheritance tests
+
+Sun Mar 16 18:45:50 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* relaxng.c: switched back to the previous Relax-NG code base,
+	  the derivation algorithm need severe constraining code to avoid
+	  combinatorial explosion. Fixed the problem with Sebastian Rahtz
+	  TEI based example and other bugs
+	* result/relaxng/*err: updated the results
+	* test/relaxng/testsuite.xml: started a new test suite 
+
+Sat Mar 15 22:26:46 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* relaxng.c include/libxml/relaxng.h: After coming to the conclusion
+	  that the original RelaxNG validation code was un-fixeable, it got
+	  rewritten to use the derivation algorithm from James Clark and
+	  redebugged it (nearly) from scratch:
+	  found 373 test schemas: 372 success 1 failures
+	  found 529 test instances: 529 success 0 failures
+
+Tue Mar 11 12:08:23 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* SAX.c parser.c: fix some recursion problems introduced in the
+	  last release.
+	* relaxng.c: more debugging of the RNG validation engine, still
+	  problems though.
+
+Mon Mar 10 14:10:47 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am: stop generating wrong result file with * in name
+	* relaxng.c: fixing the include bug raised by Sebastian Rahtz
+	* result/relaxng/demo* test/relaxng/demo: added the tests from
+	  Sebastian reproducing the problem.
+
+Sun Mar  9 18:02:31 MST 2003 John Fleck <jfleck@inkstain.net>
+
+	* doc/xmllint.1: regenerating man page from xmllint.xml to pick
+	  up Aleksey's change
+
+Sun Mar  9 13:53:16 2003  Aleksey Sanin  <aleksey@aleksey.com>
+
+	* xmllint.c doc/xmllint.xml: use $XMLLINT_INDENT environment
+	variable to control the indentation for the xmllint "--format" 
+	option
+
+Sat Mar  8 14:27:43 CET 2003 Igor Zlatkovic <igor@zlatkovic.com>
+
+	* encoding.c: applied Gennady's patch against buffer overrun
+
+Fri Mar  7 19:29:40 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* test/xsdtest/xsdtest.xml uri.c: after and exchange with James
+	  Clark it appeared I had bug in URI parsing code ...
+	* relaxng.c include/libxml/relaxng.h: completely revamped error
+	  reporting to not loose message from optional parts.
+	* xmllint.c: added timing for RNG validation steps
+	* result/relaxng/*: updated the result, all error messages changed
+
+Fri Mar  7 15:18:32 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: fix bug #107804, the algorithm used for document order
+	  computation was failing on attributes.
+
+Thu Mar  6 22:35:50 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* valid.c: fix bug #107764 , possibility of buffer overflow
+	  in xmlValidDebug()
+
+Wed Mar  5 17:41:37 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* nanoftp.c include/libxml/nanoftp.h: adding xmlNanoFTPDele()
+	  from Philipp Dunkel
+
+Wed Mar  5 10:57:09 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmlschemastype.c: made powten array static it should not be exported
+	* HTMLparser.c: fix bug #107361 by reusing the code from the XML 
+	  parser function.
+	* testHTML.c: get rid of valgrind messages on the HTML SAX tests
+
+Fri Feb 28 00:23:00 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: fixed a node dump crash on attributes
+	* test/xsdtest/xsdtest.xml test/xsdtest/xsdtest.xsl: fixed
+	  an URI test bug and get better output.
+
+Thu Feb 27 22:28:40 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* check-xsddata-test-suite.py: give more infos
+	* relaxng.c: fix a bug reported by Sebastian Rahtz and
+	  REF->DEF in attribute values.
+
+Thu Feb 27 21:09:32 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* check-xsddata-test-suite.py test/xsdtest/xsdtest.xml
+	  test/xsdtest/xsdtest.xsl: import of the XSD Datatype
+	  regression tests from James Clark.
+
+Thu Feb 27 18:40:04 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* relaxng.c xmlschemas.c xmlschemastypes.c
+	  include/libxml/xmlschemastypes.h: added param support for relaxng
+	  type checking, started to increment the pool of simple types
+	  registered, still much work to be done on simple types and
+	  facets checkings.
+
+Wed Feb 26 16:45:39 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* entities.c: fixes again one of the problem raised by
+	  James Clark in #106788
+
+Wed Feb 26 15:46:48 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* relaxng.c: Fixed a couple of problem raised by James Clark
+	  in bug #107083, the support for ID/IDREF/IDREFS at the WXS
+	  datatype level still not fixed though.
+
+Mon Feb 24 21:09:19 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in: preparing release 2.5.4
+	* doc/*: updated and rebuilt the docs
+	* relaxng.c: removed warnings
+	* result/relaxng/*: updated the results
+
+Mon Feb 24 20:53:17 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* valid.c: fixes a DTD regexp generation problem.
+
+Mon Feb 24 20:12:57 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: fixes bug #105998 about false detection of
+	  attribute consumption loop.
+
+Mon Feb 24 19:14:57 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xinclude.c: Fixes bug #106931 in XInclude entities merging.
+
+Mon Feb 24 18:50:35 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* SAX.c: fixed bug #105992
+
+Mon Feb 24 18:14:16 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: fixed xmlSetProp and al. when the node passed is not an
+	  element.
+	* relaxng.c: fixed bugs 7.3 (though not complete) and memory leaks
+	  found 373 test schemas: 369 success 4 failures
+	  found 529 test instances: 525 success 4 failures
+	* check-relaxng-test-suite.py: added memory debug reporting
+	  
+Mon Feb 24 12:41:54 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* uri.c parser.c: some warning removal on Igor's patch
+	* tree.c: seems I messed up with #106788 fix
+	* python/libxml.c: fixed some base problems when Python provides
+	  the resolver.
+	* relaxng.c: fixed the interleave algorithm 
+	  found 373 test schemas: 364 success 9 failures
+	  found 529 test instances: 525 success 4 failures
+	  the resulting failures are bug in the algorithm from 7.3 and
+	  lack of support for params
+
+Sun Feb 23 14:49:39 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: another fix for nodeinfo in entities problem
+	* tree.c entities.c: fixed bug #106788 from James Clark
+	  some spaces need to be serialized as character references.
+
+Sat Feb 22 18:28:16 CET 2003 Igor Zlatkovic <igor@zlatkovic.com>
+
+	* parser.c uri.c: fixed the bug I introduced in the path
+	  handling, reported by Sebastian Bergmann
+
+Sat Feb 22 00:19:48 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: fixing some nodeinfo in entities problem raised
+	  by Glenn W. Bach
+	* relaxng.c: implemented the first section 7.3 check
+	* result/relaxng/*: updated the results
+
+Fri Feb 21 18:12:19 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* relaxng.c: fixed some problems in the previous commit
+	  and finished implementing 4.16 rules checking
+	  found 373 test schemas: 353 success 20 failures
+	  found 529 test instances: 519 success 6 failures
+	* result/relaxng/*: updated the results
+
+Fri Feb 21 16:37:39 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* relaxng.c: implemented checks from section 7.2
+
+Thu Feb 20 16:00:31 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* relaxng.c: implemented the checks from section 7.1, fixed
+	  some of the 4.20 and 4.21 problems.
+	  found 373 test schemas: 338 success 35 failures
+	  found 529 test instances: 519 success 6 failures
+	* result/relaxng/*: updated the results
+
+Thu Feb 20 01:09:24 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* relaxng.c: implemented the 4.20 and 4.21 simplification rules.
+	* result/relaxng/*: updated the results
+
+Wed Feb 19 18:30:30 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* relaxng.c: more bugfixes
+	* result/relaxng/*: updated the results
+
+Wed Feb 19 15:39:56 CET 2003 Igor Zlatkovic <igor@zlatkovic.com>
+
+	* DOCBparser.c: obsoleted xmlNormalizeWindowsPath
+	* HTMLparser.c: obsoleted xmlNormalizeWindowsPath
+	* SAX.c: ensured xmlDoc.URL is always canonic
+	* parser.c: obsoleted xmlNormalizeWindowsPath
+	* uri.c include/libxml/uri.h: introduced xmlCanonicPath
+	* xmlIO.c include/libxml/xmlIO.h: obsoleted xmlNormalizeWindowsPath
+	* win32/libxml2.def.src: added few exports
+	
+	
+Wed Feb 19 14:26:51 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am configure.in: patched to have shared libraries
+	  for Python regression tests and static binaries for gdb debug
+	  in my development environment
+	* relaxng.c: more bugfixes 
+	  found 373 test schemas: 296 success 77 failures
+	  found 529 test instances: 516 success 8 failures
+	* result/relaxng/*: updated the results
+
+Wed Feb 19 01:17:48 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* relaxng.c: guess what ! Relax-NG bugfixing, what a surprize...
+
+Tue Feb 18 22:09:50 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmlschemastypes.c: float/double check bugfix
+	* tree.c include/libxml/tree.h: exported a function for NMTOKEN
+	  validation
+	* xmlreader.c: add a TODO for Jody
+	* relaxng.c: bugfix bugfix bugfix
+	  found 373 test schemas: 300 success 73 failures
+	  found 529 test instances: 507 success 10 failures
+	* result/relaxng/*: updated the results
+
+Tue Feb 18 00:33:17 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* relaxng.c check-relaxng-test-suite.py: more RelaxNG bug hunting
+
+Mon Feb 17 18:23:32 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* relaxng.c check-relaxng-test-suite.py: more work on the
+	  RelaxNG implementation conformance testing.
+	  found 373 test schemas: 284 success 89 failures
+	  found 529 test instances: 448 success 47 failures
+	* result/relaxng/*: updated the results
+
+Sun Feb 16 16:48:38 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* ChangeLog tree.c doc/libxml-doc.el doc/libxml2-api.xml: applied
+	  a patch from Kjartan Maraas to fix some typos
+
+Sun Feb 16 16:40:52 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* relaxng.c: more bug-hunting
+	* testRelax.c include/libxml/relaxng.h: added --tree to dump the
+	  intermediate rng tree
+	* python/generator.py: patch from Stephane Bidoul to fix the generator
+	  on python < 2.2
+
+Fri Feb 14 17:49:26 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* check-relaxng-test-suite.py relaxng.c: more testing on the
+	  Relax-NG front, cleaning up the regression tests failures
+	  current state and I forgot support for "mixed":
+	  found 373 test schemas: 280 success 93 failures
+	  found 529 test instances: 401 success 68 failures
+	* tree.c include/libxml/tree.h xmlschemastypes.c: finished and
+	  moved the Name, NCName and QName validation routine in tree.c
+	* uri.c: fixed handling of URI ending up with #, i.e. having
+	  an empty fragment ID.
+	* result/relaxng/*: updated the results
+
+Thu Feb 13 16:49:24 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* check-xinclude-test-suite.py: improved the script accordingly
+	  to the XInclude regression tests updates
+	* xpointer.c: Implemented XPointer element() Scheme W3C PR of 13
+	  November 2002
+	* result/XPath/xptr/chapterschildseq result/XPath/xptr/vidchildseq
+	  test/XPath/xptr/chapterschildseq test/XPath/xptr/vidchildseq:
+	  augmented the Xpointer testsuite for the element() scheme
+
+Thu Feb 13 12:00:30 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* relaxng.c: added TODO for the DTD compatibility spec
+	* xinclude.c: more bug fixes driven by the testsuite 
+
+Tue Feb 11 19:01:02 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* check-xinclude-test-suite.py xinclude.c: Work on the W3C/NIST
+	  regression tests for XInclude, improved the script, improving
+	  XInclude error reporting mechanism
+
+Mon Feb 10 17:19:14 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* NEWS doc/* configure.in: preparing release 2.5.3
+
+Mon Feb 10 17:11:22 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: trying to fix #104934 about some XHTML1 serialization
+	  issues.
+
+Mon Feb 10 16:41:13 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* encoding.c xmlIO.c: fixing bug #104646 about iconv based
+	  encoding conversion when the input buffer stops in the
+	  middle of a multibyte char
+
+Mon Feb 10 15:24:47 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* test/relaxng/OASIS/spectest.xml: OASIS RelaxNG testsuite
+	* check-relaxng-test-suite.py: python script to run regression
+	  against OASIS RelaxNG testsuite
+	* relaxng.c: some cleanup tweaks
+	* HTMLparser.c globals.c: cleanups in comments
+	* doc/libxml2-api.xml: updated the API
+	* result/relaxng/*: errors moved files, so large diffs but
+	  no changes at the semantic level.
+
+Mon Feb 10 01:00:31 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: fixing #105678 problem when dumping a namespace node.
+
+Mon Feb 10 00:30:01 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: fixed doc comment problems
+	* python/generator.py python/libxml_wrap.h python/types.c: adding
+	  RelaxNG wrappers
+	* python/tests/Makefile.am python/tests/relaxng.py: added a specific
+	  test of those early Python RelaxNG bindings
+
+Sun Feb  9 15:18:43 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* libxml.spec.in: fixes a libtool problem on AMD 64bits builds
+	* relaxng.c: found the validation problem I had with interleave
+	  when not covering all remaining siblings
+	* Makefile.am test.relaxng/* result/relaxng/*: augmented the
+	  testsuite and check the RNG schemas against the RNG schemas
+	  given in appendix A
+
+Sat Feb  8 18:55:43 CET 2003 Igor Zlatkovic <igor@zlatkovic.com>
+
+	* win32/Makefile.msvc: updates for RelaxNG
+	* win32/Makefile.mingw: updates for RelaxNG
+	* win32/libxml2.def.src: added RelaxNG exports
+	
+Fri Feb  7 14:00:53 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xinclude.c: applied another bug fix from Sean Chittenden
+
+Fri Feb  7 13:34:08 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in xmllint.c: I f...ed up the default configuration
+	  of schemas and --relaxng option display in xmllint, pointed by
+	  Morus Walter.
+	* xlink.c: Sean Chittenden pointed a couple of errors in the XLink
+	  detection module, fixes bug #105374.
+
+Fri Feb  7 01:43:38 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmlschemastypes.c: added the boolean base type.
+
+Thu Feb  6 10:23:52 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmlschemastypes.c: started implementing some of the missing
+	  default simple types
+	* result/relaxng/*: updated the results
+
+Wed Feb  5 15:28:04 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* NEWS doc/*: updated the docs, ready for 2.5.2 release
+
+Wed Feb  5 14:15:59 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLparser.c tree.c xmlIO.c: comments cleanups
+	* Makefile.am: use xmllint for doing the RelaxNG tests
+	* configure.in: preparing 2.5.2 made schemas support default to
+	  on instead of off
+	* relaxng.c: removed the verbosity
+	* xmllint.c: added --relaxng option
+	* python/generator.py python/libxml_wrap.h: prepared the integration
+	  of the new RelaxNG module and schemas
+	* result/relaxng/*: less verbose output
+
+Wed Feb  5 12:00:36 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* valid.c: do not run content model validation if the
+	  content is not determinist
+
+Wed Feb  5 11:43:58 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* SAX.c: added the redefinition of namespaced attribute
+	  check that was missing as Fabrice Desré pointed out.
+
+Wed Feb  5 11:09:29 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLparser.c include/libxml/HTMLparser.h: applied HTML
+	  improvements from Nick Kew, allowing to do more checking
+	  to HTML elements and attributes.
+
+Tue Feb  4 23:47:06 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xinclude.c: fixing bug #105137 about entities declaration
+	  needing to be copied to the including document.
+
+Tue Feb  4 20:26:22 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* catalog.c: fixed bug #104817 with delegateURI
+	* xpath.c: fixing bugs #104123 and #104125
+
+Tue Feb  4 17:12:56 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in valid.c xmlreader.c python/libxml_wrap.h 
+	  python/types.c: fixing #104096 to compile without regexps
+
+Tue Feb  4 16:31:55 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* valid.c: fixing bug #103969 forgot to add an epsilon transition
+	  when building the automata for elem*
+
+Tue Feb  4 16:21:07 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLparser.c: applied patch from Arne de Bruijn fixing 
+	  bug #103827
+
+Tue Feb  4 16:17:09 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLparser.c: updating a comment, fixing #103776
+
+Tue Feb  4 16:05:53 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: fixing bug 105049 for validity checking of content
+	  within recursive entities.
+
+Tue Feb  4 15:40:54 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLparser.c: try to fix # 105049
+	* relaxng.c xmlschemastypes.c: a couple of changes and extensions
+	* tree.c: updated a function comment
+
+Tue Feb  4 00:20:58 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* relaxng: more work on grammars and refs/defs
+	* test/relaxng/* result/relaxng/*: augmented/updated the
+	  regression tests
+
+Mon Feb  3 14:16:59 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* relaxng: more work on name classes, except support
+	* test/relaxng/* result/relaxng/*: augmented/updated the
+	  regression tests
+
+Mon Feb  3 11:56:05 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* relaxng: more work on name classes, the "validate all" schemas
+	  seems to work now.
+	* test/relaxng/* result/relaxng/*: augmented/updated the
+	  regression tests
+
+Mon Feb  3 09:50:26 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* python/libxml.c: removed an unprotedted debug message Aleksi Suhonen
+	* parser.c: put a guard against infinite document depth, basically
+	  trying to avoid another kind of DoS attack.
+	* relaxng.c: some code w.r.t. nameClasses
+
+Sun Feb  2 17:01:43 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* test/relaxng/* result/relaxng/*: check all the namespace support
+	  was actually correct based on tutorial section 10.
+
+Sun Feb  2 15:33:38 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* relaxng: include seems to work okay now
+	* test/relaxng/* result/relaxng/*: augmented/updated the
+	  regression tests
+
+Sat Feb  1 19:44:58 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* relaxng.c: a bit of work done in the train back.
+	* test/relaxng/*: added one of the include tests
+
+Thu Jan 30 14:06:55 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* relaxng: more work done in the train
+	* test/relaxng/* result/relaxng/*: augmented/updated the
+	  regression tests
+
+Wed Jan 29 23:44:58 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* relaxng.c: debugging of externalRef
+	* test/relaxng/* result/relaxng/*: augmented/updated the
+	  regression tests
+
+Wed Jan 29 22:06:04 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* relaxng.c: more work on Relax-NG, implementing externalRef
+	* test/relaxng/* result/relaxng/*: augmented/updated the 
+	  regression tests
+	* Makefile.am: cleanup to Relaxtests target
+
+Wed Jan 29 00:08:38 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* relaxng.c: more work on Relax-NG, implementing interleave
+	* test/relaxng/* result/relaxng/*: augmented/updated the 
+	  regression tests
+
+Tue Jan 28 21:56:49 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* relaxng.c: more work on Relax-NG, implementing interleave
+	* test/relaxng/* result/relaxng/*: augmented/updated the 
+	  regression tests
+
+Mon Jan 27 07:35:29 MST 2003 John Fleck <jfleck@inkstain.net>
+
+	* doc/tutorial/customfo.xsl
+	* doc/tutorial/customhtml.xsl
+	adding stylesheet customizations used to generate fo
+	for pdf and html
+
+Mon Jan 27 13:29:43 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* relaxng.c: more work on Relax-NG
+	* test/relaxng/* result/relaxng/*: augmented/updated the 
+	  regression tests
+	* xmlschemastypes.c: added a number of base type definition but not
+	  the associated checks, those are still TODOs
+
+Sun Jan 26 17:37:06 MST 2003 John Fleck <jfleck@inkstain.net>
+
+	in docs/tutorial:
+	* apa.html
+	* apb.html
+	* apc.html
+	* apd.html
+	* ape.html
+	* apf.html
+	* apg.html
+	* ar01s02.html
+	* ar01s03.html
+	* ar01s04.html
+	* ar01s05.html
+	* ar01s06.html
+	* ar01s07.html
+	* ar01s08.html
+	* index.html
+	* xmltutorial.pdf
+	* xmltutorial.xml
+	add index to tutorial
+
+Sun Jan 26 17:02:29 MST 2003 John Fleck <jfleck@inkstain.net>
+
+	* doc/xmlcatalog.1
+	* doc/xmlcatalog_man.html
+	* doc/xmlcatalog_man.xml
+	belatedly fixing bug #93622 (adds rewriteURI type to
+	"--add" option in xmlcatalog man page
+
+Sun Jan 26 20:47:26 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmlcatalog.c xmllint.c: applied patch for NetBSD by
+	  Julio Merino, closing #104475
+
+Sun Jan 26 20:38:43 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* relaxng.c: more work on Relax-NG
+	* test/relaxng/* result/relaxng/*: augmented/updated the 
+	  regression tests
+
+Sun Jan 26 01:49:58 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* relaxng.c: more work on Relax-NG
+	* test/relaxng/* result/relaxng/*: augmented/updated the 
+	  regression tests
+
+Sat Jan 25 18:59:54 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* README: updated the policy on private mail answers
+	* relaxng.c: more work on Relax-NG
+	* test/relaxng/* result/relaxng/*: augmented/updated the 
+	  regression tests
+
+Fri Jan 24 15:12:44 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* error.c parser.c tree.c: applied a documentation patch from
+	  Stefan Kost
+
+Fri Jan 24 02:00:50 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* relaxng.c: more work on Relax-NG
+	* doc/*: regenerated the docs
+	* test/relaxng/* result/relaxng/*: updated and augmented the
+	  Relax-NG regression tests and results
+
+Thu Jan 23 19:26:20 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am configure.in relaxng.c include/libxml/relaxng.h:
+	  First commit of the new Relax-NG validation code, not generally
+	  useful yet.
+	* test/relaxng/* result/relaxng/*: current state of the regression
+	  tests
+
+Thu Jan 23 19:22:54 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: minimized the memory allocated for GetContent
+	  and a bit of cleanup.
+
+Thu Jan 23 17:41:37 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* python/generator.py: seems there is no good reasons to
+	  not generate bindings for XPointer
+
+Tue Jan 21 13:19:35 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmlreader.c doc/apibuild.py: applied a new patch from
+	  Stéphane Bidoul for cleanups
+	* doc/libxml2-api.xml: rebuilt the API description with
+	  new entry points
+
+Mon Jan 20 23:25:00 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmlreader.c python/drv_libxml2.py python/generator.py
+	  python/libxml.c python/libxml.py python/libxml_wrap.h
+	  python/types.c: patch from Stéphane Bidoul for better per
+	  context error message APIs
+	* python/tests/ctxterror.py python/tests/readererr.py:
+	  update of the tests
+
+Sun Jan 19 17:09:28 MST 2003 John Fleck <jfleck@inkstain.net>
+
+	* doc/guidelines.html
+	grammar and spelling cleanup
+
+Fri Jan 17 00:31:30 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmlreader.c include/libxml/xmlreader.h python/generator.py
+	  python/libxml.c python/libxml.py win32/libxml2.def.src: applied
+	  a patch from Stéphane Bidoul to allow per XMLtextReader error
+	  and warning handling
+	* python/tests/Makefile.am python/tests/readererr.py: adding the
+	  specific regression test
+
+Tue Jan 14 17:00:08 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: Alexey Efimov pointed out that concat('a', 'b', )
+	  should raise a syntax error
+
+Tue Jan 14 15:39:14 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* python/libxml.c: cleanup patch from Stéphane Bidoul
+
+Tue Jan 14 14:41:18 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* encoding.c: fixing bug #103100 with a dummy UTF8ToUTF8 copy
+
+Tue Jan 14 12:40:29 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* python/generator.py python/libxml.c python/libxml.py
+	  python/libxml_wrap.h python/types.c: applied and fixed a patch
+	  from Stéphane Bidoul to provide per parser error handlers at the
+	  Python level.
+	* python/tests/Makefile.am python/tests/ctxterror.py: added a
+	  regression test for it.
+
+Tue Jan 14 01:15:04 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmlreader.c: fixed the streaming property of the reader,
+	  it was generating tree faster than consuming it. Pointed out
+	  by Nate Myers
+	* tree.c: fixed a bug in xmlSaveFormatFileEnc if passed a NULL doc
+
+Sun Jan 12 22:18:02 CET 2003 Igor Zlatkovic <igor@stud.fh-frankfurt.de>
+
+	* win32/libxml2.def.src: added more xmlreader and other exports
+	
+Fri Jan 10 18:04:32 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: fix to the XPath implementation for parent and
+	  ancestors axis when operating on a Result Value Tree.
+	  Fixes bug #100271
+
+Fri Jan 10 17:07:01 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* nanoftp.c nanohttp.c xmlIO.c: patch from Stefano Zacchiroli
+	  to fix some URI/file escaping problems
+
+Fri Jan 10 16:20:34 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* python/generator.py: fixed a bug raised by Raymond Wiker, 
+	  docSetRootElement() should not raise an exception if the
+	  return is None
+
+Fri Jan 10 14:13:03 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* python/libxml.py python/libxml.c python/libxml2-python-api.xml:
+	  fixed bug #102181 by applying the suggested change and fixing
+	  the generation/registration problem.
+
+Fri Jan 10 13:47:55 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLparser.c: fixed bug #102960 by reusing the XML name parsing
+	  routines.
+
+Fri Jan 10 00:16:49 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: one more IsEmptyElement crazyness, that time in
+	  external parsed entities if substitution is asked.
+	* python/tests/reader3.py: added a specific test.
+
+Thu Jan  9 22:35:31 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* python/drv_libxml2.py: update from Stéphane Bidoul: python 2.1
+	  support and improved error handler registration
+
+Thu Jan  9 14:16:38 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLtree.c tree.c: fixes #102920 about namespace handling in
+	  HTML output and section 16.2 "HTML Output Method" of XSLT-1.0
+	* README: fixed a link
+
+Wed Jan  8 18:32:25 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in doc/* NEWS: preparing 2.5.1 release
+	* SAX.c parser.c: fixing XmlTextReader bug
+
+Wed Jan  8 00:13:01 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* SAX.c: fuck, I introduced a memory leak on external parsed
+	  entities in 2.5.0 :-(
+
+Tue Jan  7 12:12:45 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmllint.c: another fix needed as pointed by Christophe Merlet
+	  for --stream --debug if compiled without debug support.
+
+Mon Jan  6 20:53:08 MST 2003 John Fleck <jfleck@inkstain.net>
+
+	* doc/xmllint.xml
+	* doc/xmllint.1:
+	update man page with --stream and --chkregister
+
+Tue Jan  7 01:17:26 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* globals.c: fixed --with-threads compile
+	* xmllint.c: fixed --without-debug compile
+	* include/libxml/globals.h: cleanup
+	* include/libxml/schemasInternals.h: add a missing include
+
+Mon Jan  6 14:06:07 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in NEWS: preparing 2.5.0 release
+	* SAX.c: only warn in pedantic mode about namespace name 
+	  brokeness
+	* globals.c: fix a doc generation problem
+	* uri.c: fix #101520
+	* doc/*: updated and rebuilt the doc for the release, includuding
+	  stylesheet update
+	* python/Makefile.am: fix a filename bug
+
+Mon Jan  6 12:05:12 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* doc/tutorial/* : fixed #101894 if doc == NULL xmlFreeDoc 
+	  should not be called.
+
+Mon Jan  6 11:59:09 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* libxml-2.0.pc.in: applied the patch to fix #101894
+
+Sun Jan  5 23:35:47 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c : applied patch from Lukas Schroeder for register callbacks
+	* valid.c: modified patch from Lukas Schroeder to test
+	  register callbacks with --chkregister
+
+Sun Jan  5 02:23:20 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmlreader.c: seriously changed the way data are pushed to
+	  the underlying parser, go by block of 512 bytes instead of
+	  tryng to detect tag boundaries at that level. Changed the
+	  way empty element are detected and tagged.
+	* python/tests/reader.py python/tests/reader2.py
+	  python/tests/reader3.py: small changes mostly due to context
+	  reporting being different and DTD node being reported. Some
+	  errors previously undetected are now caught and fixed.
+	* doc/xmlreader.html: flagged last section as TODO
+
+Sat Jan  4 20:40:28 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* python/libxml.py: integrated the Python 2.2 optimizations
+	  from Hannu Krosing, while maintaining compatibility with 
+	  1.5 and 2.1
+
+Sat Jan  4 17:33:17 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmllint.c: a bit of cleanup
+	* xmlreader.c: small fix
+	* doc/xmlreader.html: more work on the XmlTextReader tutorial
+	* python/libxml.py: a few fixes pointed out by Hannu Krosing
+
+Sat Jan  4 13:46:14 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* python/setup.py.in: patch from Stéphane Bidoul to include
+	  drv_libxml2.py in setup.py
+
+Sat Jan  4 01:43:06 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* doc/xmlreader.html: starting documenting the new XmlTextReader
+	  interface.
+
+Fri Jan  3 17:18:32 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmllint.c: added the --stream flag to use the TextReader API
+	* xmlreader.c: small performance tweak
+
+Fri Jan  3 13:50:55 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmlreader.c python/tests/reader2py: okay the DTD validation
+	  code on top of the XMLTextParser API should be solid now.
+
+Fri Jan  3 02:17:18 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmlreader.c python/tests/reader2py: Fixing some more mess
+	  with validation and recursive entities while using the
+	  reader interface, it's getting a bit messy...
+
+Thu Jan  2 15:15:26 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmlreader.c python/tests/reader.py: another couple of problem
+	  related to IsEmptyElement reported by Stéphane Bidoul needed 
+	  some fixes.
+
+Thu Jan  2 13:57:07 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* libxml.spec.in python/Makefile.am python/drv_libxml2.py:
+	  integrated drv_libxml2.py Python xml.sax driver from Stéphane Bidoul
+	  based on the python XmlTextReader interface.
+
+Wed Jan  1 22:05:40 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: backing out one change in the last patch which broke the
+	  regression tests
+
+Wed Jan  1 21:57:28 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* global.data globals.c tree.c include/libxml/globals.h: applied
+	  an old patch from Lukas Schroeder to track node creation and
+	  destruction. Probably missing a lot of references at the moment
+	  and not usable reliably.
+
+Wed Jan  1 20:12:07 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* NEWS doc/Makefile.am doc/news.xsl: generate the NEWS file
+	  from doc/news.html and a stylesheet
+
+Wed Jan  1 16:09:57 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmlreader.c python/tests/reader.py: fixed another couple of
+	  xmlreader bugs reported by Stéphane Bidoul and added tests.
+
+Wed Jan  1 15:42:54 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmlreader.c python/tests/reader2.py: fixed another validity
+	  checking in external parsed entities raised by Stéphane Bidoul
+	  and added a specific regression test.
+	* python/tests/reader3.py: cleanup
+
+Tue Dec 31 15:44:02 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlreader.c python/tests/reader2.py: fixed a problem with
+	  validation within entities pointed by Stéphane Bidoul, augmented
+	  the tests to catch those.
+
+Tue Dec 31 12:15:37 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/generator.py: modified the generator to allow keeping
+	  class references when creating new classes, needed to fix a bug
+	  pointed by Stéphane Bidoul where the input buffer of the
+	  xmlTextReader instance gets destroyed if the python wrapper for
+	  the input is not referenced anymore.
+
+Mon Dec 30 19:39:36 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlreader.c python/tests/reader.py: fixed another pair of problem
+	  pointed by Stéphane Bidoul: depth start at 0 and a parse problem.
+
+Mon Dec 30 13:36:50 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlreader.c python/tests/reader.py: fixed another problem
+	  pointed by Stéphane Bidoul
+
+Mon Dec 30 12:39:55 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlreader.c python/tests/reader.py: fixed a limit case problem
+	  with "<a/>"
+
+Mon Dec 30 11:53:44 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* SAX.c: warn on xmlns:prefix="foo"
+	* xmlreader.c python/tests/reader.py: fixed a couple of problem
+	  for namespace attributes handling.
+
+Mon Dec 30 00:59:07 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* entities.c parser.c tree.c include/libxml/entities.h: Fixed
+	  a really nasty problem raised by a DocBook XSLT transform
+	  provided by Sebastian Bergmann
+
+Sun Dec 29 12:13:18 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlreader.c python/tests/reader.py: fixed a bug pointed out
+	  by Stéphane Bidoul and integrated it into the tests
+
+Sat Dec 28 23:49:12 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlreader.c include/libxml/xmlreader.h doc/libxml2-api.xml:
+	  extended the XmlTextReader API a bit, addding accessors for
+	  the current doc and node, and an entity substitution mode for
+	  the parser.
+	* python/libxml.py python/libxml2class.txt: related updates
+	* python/tests/Makefile.am python/tests/reader.py 
+	  python/tests/reader2.py python/tests/reader3.py: updated a bit
+	  the old tests and added a new one to test the entities handling
+
+Sat Dec 28 22:11:57 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/generator.py python/libxml2class.txt 
+	  python/tests/reader.py python/tests/reader2.py: changed the
+	  generator to provide casing for the XmlTextReader similar to
+	  C# so that examples and documentation are more directly transposable.
+	  Fixed the couple of tests in the suite.
+
+Sat Dec 28 15:55:32 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* doc/guidelines.html: added a document on guildeline for
+	  publishing and deploying XML
+
+Fri Dec 27 20:35:15 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* valid.c xmlreader.c: final touch running DTD validation
+	  on the XmlTextReader
+	* python/tests/Makefile.am python/tests/reader2.py: added a
+	  specific run based on the examples from test/valid/*.xml
+
+Fri Dec 27 15:17:20 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/libxml.py: added a few predefined xmlTextReader parser
+	  configuration values.
+
+Fri Dec 27 12:57:22 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/libxml_wrap.h: trying to fix #102037
+
+Fri Dec 27 12:18:14 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* SAX.c: fixing bug #95296, when the predefined entities
+	  are redefined in the DTD the default one must be used
+	  instead anyway.
+
+Wed Dec 25 19:22:06 MST 2002 John Fleck <jfleck@inkstain.net>
+
+	* doc/xmllint.xml
+	* doc/xmllint.1
+	Add discussion of XML_DEBUG_CATALOG to xmllint man
+	page - bug #100907
+
+
+Mon Dec 23 16:54:22 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlreader.c: Fixed the empty node detection to avoid reporting
+	  an inexistant close tag.
+
+Mon Dec 23 15:42:24 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/libxml.c python/setup.py.in: patch from Stéphane Bidoul
+	  for Python 2.1
+
+Sun Dec 22 11:24:06 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* testC14N.c vms/config.vms: applied Craig A. Berry patches for VMS
+
+Fri Dec 20 11:27:49 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* doc/libxml2-api.xml python/tests/reader.py: one really need
+	  to provide the base URI information when creating a reader parser
+	  from an input stream. Updated the API and the example using it.
+
+Fri Dec 20 01:11:30 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* testReader.c xmlreader.c valid.c include/libxml/tree.h
+	  include/libxml/valid.h include/libxml/xmlreader.h: working on
+	  DTD validation on top of xml reader interfaces. Allows to
+	  validate arbitrary large instances. This required some extensions
+	  to the valid module interface and augmenting the size of xmlID
+	  and xmlRef structs a bit.
+	* uri.c xmlregexp.c: simple cleanup.
+
+Wed Dec 18 15:51:22 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlreader.c include/libxml/xmlreader.h doc/libxml2-api.xml: more
+	  work on the xml reader interfaces.
+	* AUTHORS MAINTAINERS doc/* win32/*: updated Igor's mail and the
+	  Web page for the Windows binaries.
+
+Tue Dec 17 19:31:07 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlIO.c: applied a patch for VMS following the report by
+	  Nigel Hall
+
+Tue Dec 17 11:29:41 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: the parseStartTag bug fix wasn't complete.
+	
+Mon Dec 16 23:00:05 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: Vyacheslav Pindyura managed to trigger a bug in
+	  parseStartTag, fixing it.
+	* test/att4 result/att4 result/noent/att4: adding the test
+	* xmlreader.c include/libxml/xmlreader.h doc/libxml2-api.xml: added
+	  more methods to XmlTextReader.
+
+Mon Dec 16 19:31:16 CET 2002 Igor Zlatkovic <igor@stud.fh-frankfurt.de>
+
+	* win32/libxml2.def.src: added more xml reader exports
+	* win32/Makefile.msvc win32/Makefile.mingw: added xml reader interface
+	  to the build
+	
+Mon Dec 16 06:36:54 MST 2002 John Fleck <jfleck@inkstain.net>
+
+	* doc/tutorial/xmltutorial.xml
+	plus generated html and pdf
+	Updating tutorial again based on further comments from Niraj
+	Tolia on the last iteration
+
+Sun Dec 15 21:27:30 MST 2002 John Fleck <jfleck@inkstain.net>
+
+	* doc/tutorial/xmltutorial.xml
+	* doc/tutorial/includekeyword.c
+	* doc/tutorial/includegetattribute.c
+	plus generated html and pdf
+	Adding fix from Niraj Tolia to tutorial to properly free memory.
+	
+
+Mon Dec 16 00:34:25 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlreader.c include/libxml/xmlreader.h doc/libxml2-api.xml: added
+	  more methods of XmlTextReader.
+	* python/libxml2class.txt python/tests/reader.py: this increased the
+	  methods in the bndings, augmented the test to check those new
+	  functions.
+
+Sat Dec 14 23:57:39 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlreader.c doc/libxml2-api.xml: added the close and getattribute
+	  methods of XmlTextReader.
+	* python/generator.py python/libxml_wrap.h python/types.c 
+	  python/libxml2class.txt: added the reader to the Python bindings
+	* python/tests/Makefile.am python/tests/reader.py: added a specific
+	  test for the Python bindings of the Reader APIs
+	* parser.c: small cleanup.
+
+Fri Dec 13 11:39:44 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xinclude.c: fallback was only copying the first child not the
+	  full child list of the fallback element, closes #89684 as reopened
+	  by Bernd Kuemmerlen
+
+Thu Dec 12 13:34:59 CET 2002 Igor Zlatkovic <igor@stud.fh-frankfurt.de>
+
+	* win32/libxml2.def.src: exported htmlNodeDumpOutput
+
+Thu Dec 12 10:59:11 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in: preparing release of 2.4.30
+	* doc/apibuild.py doc/libxml2-api.xml: fixups to the api builder,
+	  gives enum values, fix functype return type, put back fields in
+	  structs 
+	* doc/*: updated the docs rebuilt
+
+Thu Dec 12 01:09:34 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLtree.c include/libxml/HTMLtree.h: patch from Mark Vadok
+	  about htmlNodeDumpOutput location.
+	* xpath.c: removed an undefined function signature
+	* doc/apibuild.py doc/libxml2-api.xml: the script was exporting
+	  too many symbols in the API breaking the python bindings.
+	  Updated with the libxslt/libexslt changes.
+
+Wed Dec 11 20:26:15 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in: preparing release of 2.4.29
+	* doc/*: rebuilt the docs and API
+	* xmlreader.c: a few more fixes for the XmlTextReader API
+
+Wed Dec 11 18:01:15 CET 2002 Igor Zlatkovic <igor@stud.fh-frankfurt.de>
+
+	* include/win32config.h: applied mingw patch from Magnus Henoch
+
+Wed Dec 11 16:58:48 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* catalog.c doc/libxml2-api.xml: a bit more cleanup
+
+Wed Dec 11 14:54:47 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* doc/apibuild.py doc/libxml2-api.xml doc/Makefile.am: new API
+	  building Python script, does the C parsing directly, generates
+	  a better API description including structure fieds defs and
+	  enums. Still a couple of bugs, but good enough for the python
+	  wrappers now.
+	* DOCBparser.c SAX.c nanohttp.c parser.c parserInternals.c tree.c
+	  valid.c xmlIO.c xmlmemory.c xmlreader.c xmlregexp.c xmlschemas.c
+	  include/libxml/schemasInternals.h include/libxml/tree.h: more
+	  cleanup based on the python analysis script reports.
+	* libxml.spec.in: make sure the API XML description is part of the
+	  devel package.
+
+Tue Dec 10 16:16:34 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* DOCBparser.c HTMLparser.c c14n.c debugXML.c encoding.c hash.c
+	  nanoftp.c nanohttp.c parser.c parserInternals.c testC14N.c
+	  testDocbook.c threads.c tree.c valid.c xmlIO.c xmllint.c xmlmemory.c
+	  xmlreader.c xmlregexp.c xmlschemas.c xmlschemastypes.c xpath.c:
+	  code cleanup, especially the function comments.
+	* tree.c: fixed a small bug when freeing nodes which are XInclude ones.
+
+Mon Dec  9 15:08:17 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am xmlreader.c include/libxml/Makefile.am
+	  include/libxml/xmlreader.h:  Adding a new set of APIs based on
+	  the C# TextXmlReader API but converted to C. Allow to parse
+	  in constant memory usage, far simpler to program and explain
+	  than the SAX like APIs, unfinished but working.
+	* testReader.c: test program
+
+Sun Dec  8 18:36:01 CET 2002 Igor Zlatkovic <igor@stud.fh-frankfurt.de>
+
+	* win32/libxml2.def.src: applied YALDSP from Mark Vakoc
+
+Wed Dec  4 16:08:49 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: Chip turner indicated that XHTML1 serialization
+	  rule for style actually break on both IE and Mozilla, 
+	  try to avoid the rule if escaping ain't necessary
+
+Wed Dec  4 12:43:28 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* nanhttp.c: handle HTTP URL escaping, problem reported by
+	  Glen Nakamura and Stefano Zacchiroli
+
+Sat Nov 30 12:19:17 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* DOCBparser.c HTMLparser.c parser.c valid.c xpath.c: code cleanup
+
+Thu Nov 28 12:53:22 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* uri.c: Johann Richard pointed out some XPointer problems for
+	  URN based URI references in XInclude. Modified the URI parsing
+	  and saving routines to allow correct parsing and saving of 
+	  XPointers, especially when attached to "opaque" scheme accordingly
+	  to RFC 2396
+
+Wed Nov 27 20:36:08 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLtree.c include/libxml/HTMLtree.h: applied the same kind
+	  of refactoring to the HTML saving code.
+	* doc/libxml2-*.xml doc/API*.html: slight API changes got reflected
+	  in the doc.
+
+Wed Nov 27 12:40:16 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c include/libxml/tree.h: refactored the XML dump of a node
+	  to a buffer API to reuse the generic dump to an OutputIO layer,
+	  this reduces code, fixes xmlNodeDump() for XHTML, also made
+	  xmlNodeDump() now return the number of byte written.
+
+Wed Nov 27 09:00:00 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/setup.py.in: another patch from Stéphane Bidoul for 
+	  Python bindings on Windows
+	* doc/parsedecl.py: small cleanup
+
+Mon Nov 25 17:28:53 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* libxml.spec.in configure.in: add a line in %changelog for releases
+
+Mon Nov 25 14:18:27 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: patch from Marcus Clarke fixing a problem in entities
+	  parsing that was detected in KDe documentations environment.
+
+Mon Nov 24 14:13:21 CET 2002 ERDI Gergo <cactus@cactus.rulez.org>
+
+	* python/libxml.c (libxml_prev): Return the previous as opposed to
+	the next node (I guess this is the result of some cut & paste programming:)
+
+Sat Nov 23 17:22:22 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* doc/Makefile.am: Jan Rafaj pointed a bug in the Makefile.
+
+Sat Nov 23 12:21:24 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/generator.py python/libxml.c python/setup.py.in: trying
+	  to fix the Python bindings build on Windows (Stéphane Bidoul)
+
+Fri Nov 22 22:41:34 CEST 2002 Igor Zlatkovic <igor@stud.fh-frankfurt.de>
+
+	* win32/configure.js: added option for python bindings
+	* win32/libxml2.def.src: added more exports
+
+Fri Nov 22 18:50:34 CET 2002 Igor Zlatkovic <igor@stud.fh-frankfurt.de>
+
+	* win32/Makefile.mingw: fixed unresolved symbols when linking with
+	  pthreads
+	* win32/wince/*: applied updates to Windows CE port from Javier
+
+Fri Nov 22 15:51:22 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in: preparing 2.4.28
+	* libxml.spec.in doc/Makefile.am: some cleanup
+	* doc/*: updated the news and regenerated.
+
+Fri Nov 22 14:15:14 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLparser.c: final touch at closing #87235 </p> end tags
+	  need to be generated.
+	* result/HTML/cf_128.html result/HTML/test2.html result/HTML/test3.html:
+	  this change slightly the output of a few tests
+	* doc/*: regenerated
+
+Fri Nov 22 13:26:19 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* parserInternals.c: fixing bug #99190 when UTF8 document are
+	  parsed using the progressive parser and the end of the chunk
+	  is in the middle of an UTF8 multibyte character.
+
+Fri Nov 22 13:13:00 HKT 2002 William Brack <wbrack@mmm.com.hk>
+
+	* threads.c: fixed initialization problem in xmlNewGlobalState
+	  which was causing crash.
+	* globals.c: removed duplicate call to initxmlDefaultSAXHandler
+	  in xmlInitializeGlobalState.
+	* parserInternals.c: cleaned up ctxt->sax initialisation.
+	
+Thu Nov 21 15:05:45 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c include/libxml/tree.h: modified the existing APIs
+	  to handle XHTML1 serialization rules automatically, also add
+	  xmlIsXHTML() to libxml2 API. Some tweaking to make sure
+	  libxslt serialization uses it when needed without changing
+	  the library API.
+	* test/xhtml1 result/noent/xhtml1 result/valid/xhtml1.xhtml
+	  result/xhtml1: added a new test specifically for xhtml1 output
+	  and updated the result of one XHTML1 test
+
+Wed Nov 20 14:24:56 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xinclude.c parserInternals.c encoding.c: fixed #99082
+	  for xi:include encoding="..." support on text includes.
+	* result/XInclude/tstencoding.xml test/XInclude/docs/tstencoding.xml
+	  test/XInclude/ents/isolatin.txt : added a specific regression test
+	* python/generator.py python/libxml2class.txt: fixed the generator
+	  the new set of comments generated for doc/libxml2-api.xml were
+	  breaking the python generation.
+
+Tue Nov 19 23:25:47 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* doc/Makefile.am: repair some problem if gtk-doc fail or such
+	* configure.in: patch for Solaris on new autoconf closes #98880 
+	* doc/parsedecl.py: repair the frigging API building script,
+	  did I say that python xmllib sucks ?
+	* doc/libxml2-api.xml doc/libxml2-refs.xml: regenerated, reordering
+	  and some comment are no more truncated.
+
+Tue Nov 19 09:09:04 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: Martin Stoilov pointed out a potential leak in
+	  xmlCreateMemoryParserCtxt
+
+Mon Nov 18 16:05:51 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLparser.c: fixed bug #98879 a corner case when 0 is
+	  included in HTML documents and using the push parser.
+
+Mon Nov 18 00:11:24 CET 2002 ERDI Gergo <cactus@cactus.rulez.org>
+
+	* configure.in (PYTHON_SITE_PACKAGES): If --with-python is
+	  specified, look for the Python interpreter not just in the
+	  specified root but also in the specified location. Fixes #98825
+
+Sun Nov 17 23:36:06 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/libxml.c: fixing bug #98792 , node may have no doc
+	  and dereferencing without checking ain't good ...
+
+Sun Nov 17 10:25:43 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in: preparing release 2.4.27
+	* doc/* : updated and rebuilt the docs
+	* doc/Makefile.am libxml.spec.in: try to make sure the tutorial
+	  and all the docs are actually packaged and in the final RPMs
+	* parser.c parserInternals.c include/libxml/parser.h: restore
+	  xmllint --recover feature.
+
+Sat Nov 16 16:30:25 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c xpath.c: fixing #96925 wich was also dependent on the
+	  processing of parsed entities, and XPath computation on sustitued
+	  entities.
+	* testXPath.c: make sure entities are substitued.
+
+Fri Nov 15 16:22:54 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: fixed #96594, which was totally dependent on the 
+	  processing of internal parsed entities, which had to be changed.
+
+Fri Nov 15 12:16:07 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am python/Makefile.am python/tests/Makefile.am:
+	  trying to fix bug #98517 about building outside the source tree
+	* doc/xml.html doc/FAQ.html: fixed the link to libiconv #94585
+
+Thu Nov 14 18:41:55 CEST 2002 Igor Zlatkovic <igor@stud.fh-frankfurt.de>
+
+	* include/win32config.h: cleanup
+	* win32/Makefile.mingw: integrated mingw in JScript configure
+	* win32/Makefile.msvc: modified to allow mingw coexistence
+	* win32/configure.js: integrated mingw
+	* win32/Readme.txt: cleanup
+
+Tue Nov 12 22:06:45 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLparser.c: strengthen the guard in the Pop macros,
+	  like in the XML parser, closes bug #97315
+
+Tue Nov 12 21:56:39 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/parser.h: fixed bug #98338 , fatalError SAX
+	  callback is never used.
+
+Tue Nov 12 13:32:50 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* parserInternals.c: fixed the initialization of the SAX structure
+	  which was breaking xsltproc
+	* xpath.c: patch from Petr Pajas for CDATA nodes
+	* tree.c: patch from Petr Pajas improving xmlGetNodePath()
+	* parser.c include/libxml/parser.h: patch from Peter Jones
+	  removing a leak in xmlSAXParseMemory() and adding the
+	  function xmlSAXParseMemoryWithData()
+
+Mon Nov 11 20:47:03 MST 2002 John Fleck <jfleck@inkstain.net>
+
+	adding pdf of tutorial, changing web page to link to it
+	* doc/tutorial/xmltutorial.pdf
+	* doc/xml.html
+	* doc/docs.html
+
+Sun Nov 10 20:48:57 MST 2002 John Fleck <jfleck@inkstain.net>
+
+	* doc/tutorial/ar01s08.html
+	adding file what I forgot for tutorial
+
+
+Sun Nov 10 20:33:13 MST 2002 John Fleck  <jfleck@inkstain.net>
+
+	Adding encoding discussion to tutorial
+	Added:
+	* doc/tutorial/images/*.png: DocBook admonition image files
+	* doc/tutorial/apf.html, apg.html: new generated html
+	* doc/tutorial/includeconvert.c: conversion code entity file
+	changed:
+	* doc/tutorial/xmltutorial.xml: DocBook original
+	* doc/tutorial/*.html: generated html
+
+Fri Nov  8 17:59:32 CEST 2002 Igor Zlatkovic <igor@stud.fh-frankfurt.de>
+
+	* include/libxml/*.h: retired xmlwin32version.h
+	* doc/Makefile.am: retired xmlwin32version.h
+	* win32/configure.js: retired xmlwin32version.h
+
+Fri Nov  8 16:55:47 CEST 2002 Igor Zlatkovic <igor@stud.fh-frankfurt.de>
+
+	* win32/libxml2.def.src: exported additional symbols
+	* include/libxml/xmlmemory.h: exported the rest of the xmlMem* 
+	  sisterhood
+
+Fri Nov  8 16:08:13 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* globals.c: fixed a typo pointed out by Igor
+	* xpath.c: try to speed up node compare using line numbers
+	  if available.
+
+Thu Nov  7 15:16:02 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: make xmlFreeNode() handle attributes correctly.
+
+Wed Nov  6 23:51:11 CET 2002 Igor Zlatkovic <igor@stud.fh-frankfurt.de>
+
+	* catalog.c: completed the #96963 fix, as reported by Karl
+	  Eichwalder
+
+Wed Nov  6 16:48:44 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xpointer.c: tried to fix bug #97852 reported by Nicolas Noffke
+
+Sun Nov  3 10:43:44 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am: switched the order of a couple of includes
+	  to fix bugs #97100
+
+Thu Oct 31 17:11:46 CEST 2002 Igor Zlatkovic <igor@stud.fh-frankfurt.de>
+
+	* catalog.c: fixed bug #96963, reverted to the old behaviour of
+	  xmlLoadCatalogs that used to separate directories with a ':'.
+
+Thu Oct 31 16:55:21 CEST 2002 Igor Zlatkovic <igor@stud.fh-frankfurt.de>
+
+	* threads.c: improvements to the Windows-side of thread handling
+	* testThreads.c: conditionally excluded unistd.h
+	* testThradsWin32.c: broke overlong lines
+	* include/win32config.h: adapted thread-related macros to the new
+	  scheme and for pthreads on Windows
+	* win32/Makefile.msvc: introduced a more flexible thread build, 
+	  added testThreads[Win32].c to the build
+	* win32/configure.js: introduced a more flexible thread config
+
+2002-10-31  John Fleck  <jfleck@inkstain.net>
+
+	* doc/xml.html (and, by implication, FAQ.html)
+	added UTF-8 conversaion FAQ from Marcus Labib Iskander
+
+Tue Oct 29 18:32:33 CET 2002 Igor Zlatkovic <igor@stud.fh-frankfurt.de>
+
+	* configure.in: removed xmlwin32version.h
+	* include/libxml/Makefile.am: removed xmlwin32version.h
+
+Mon Oct 28 14:01:29 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: applied patch from Brian Stafford to fix a bug
+	  in xmlReconciliateNs()
+
+Mon Oct 28 13:51:55 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: applied patch from Christian Glahn to allow
+	  xmlNewChild() on document fragment nodes
+
+Sat Oct 26 15:27:00 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: Christian Glahn found a problem with a recent
+	  patch to xmlParseBalancedChunkMemoryRecover()
+	* xmlschemas.c: Charles Bozeman fixed some Schemas validation
+	  problems
+	* result/schemas/elem* result/schemas/seq* test/schemas.elem*
+	  test/schemas/seq*: added the test cases from Charles
+
+Wed Oct 23 16:42:29 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am config.h.in libxml.spec.in doc/Makefile.am:
+	  serious cleanup of the spec file and associated changes
+	  in the Makefiles.
+	* valid.c: try to remove some warnings on x86_64
+
+Wed Oct 23 10:53:42 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* include/Makefile.am: added winsockcompat.h to EXTRA_DIST to
+	  fix bug #96586
+
+Tue Oct 22 21:13:06 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLparser.c: Mikhail Sogrine pointed out a bug in HTML
+	  parsing, applied his patch
+	* result/HTML/attrents.html result/HTML/attrents.html.err
+	  result/HTML/attrents.html.sax test/HTML/attrents.html:
+	  added the test and result case provided by Mikhail Sogrine
+
+Tue Oct 22 19:33:20 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* vms/build_libxml.com vms/config.vms vms/readme.vms
+	  include/libxml/parser.h include/libxml/parserInternals.h
+	  include/libxml/tree.h include/libxml/xmlIO.h
+	  HTMLparser.c catalog.c debugXML.c parser.c parserInternals.c
+	  tree.c triodef.h trionan.c uri.c xmlIO.c xpath.c:
+	  Applied the VMS update patch from Craig A. Berry
+	* doc/*.html: update
+
+Tue Oct 22 16:27:31 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/encoding.h encoding.c: made xmlGetUTF8Char public
+
+Tue Oct 22 16:25:18 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* debugXML.c: adding a grep command to --shell in xmllint
+	  for T.V. Raman
+
+Tue Oct 22 16:23:57 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlcatalog.c: tried to fix some of the problem with --sgml
+
+Mon Oct 21 09:57:10 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: tried to fix bug #91500 where doc->children may
+	  be overriden by a call to xmlParseBalancedChunkMemory()
+
+Mon Oct 21 09:04:32 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* catalog.c: tried to fix bug #90945 w.r.t. parsing of system
+	  identifiers in SGML catalogs containing '&'
+
+Sun Oct 20 23:31:47 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/types.c: fixed bugs when passing result value tree
+	  to Python functions.
+
+Fri Oct 18 13:18:53 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in: preparing the release of 2.4.26
+	* doc/*: updated and rebuilt the documentation
+
+Wed Oct 16 20:01:46 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: fixed a XML Namespace compliance bug reported by
+	  Alexander Grimalovsky
+
+Wed Oct 16 17:18:42 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLtree.c: fixed serialization of script and style when
+	  they are not lowercase (i.e. added using the API to the tree).
+
+Wed Oct 16 16:31:05 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* valid.c: make xmlValidateDocument emit a warning msg if there
+	  is no DTD, pointed by Christian Glahn
+
+Wed Oct 16 16:05:38 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlregexp.c xmlschemas.c: fixed the validation of sequences
+	  content model when some of the blocks have min or max, and a couple
+	  of bugs found in the process.
+	* result/schemas/list0* test/schemas/list0*: added some specific
+	  regression tests
+
+Tue Oct 15 12:41:01 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* README: updated the contact informations
+
+Tue Oct 15 10:35:57 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am: use test -f instead of test -e since Solaris /bin/sh
+	  misses it, reported by Peter Bray.
+
+Mon Oct 14 17:37:32 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: investigating xmlNodeGetContent() on namespace nodes
+	  and removed a few warnings
+
+Mon Oct 14 13:12:55 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: Christian Glahn found a small bug in the push parser.
+	* xmlIO.c include/libxml/xmlIO.h: cleaned up and made xmlCheckFilename
+	  public
+
+Wed Oct  9 23:11:02 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlschemas.c include/libxml/xmlschemas.h: added
+	  xmlSchemaNewMemParserCtxt to parse a schemas from a memory area
+	* testSchemas.c: added --memory to test the new interface
+
+Wed Oct  9 16:22:54 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* doc/index.py doc/search.php: integrated the XSLT indexing,
+	  a few fixed in the indexer, added a scope selection at the
+	  search level.
+
+Wed Oct  9 12:18:37 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* valid.c: Joe Marcus Clarke reported a segfault on FBsd 
+	  this was due to uninitialized parts of the validation context
+
+Tue Oct  8 23:24:20 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* debugXML.c: applied patch from Mark Vakoc except the API
+	  change, preserved it.
+	* doc/*: updated the docs to point to the search engine for
+	  information lookup or before bug/help reports.
+
+Tue Oct  8 18:53:31 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* doc/index.py doc/search.php: added mailing-list archives
+	  indexing and lookup
+
+Tue Oct  8 10:25:07 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: patch from Mark Vakoc to fix xmlNodeGetPath()
+
+Mon Oct  7 13:12:03 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* doc/index.py: improved HTML indexing
+	* doc/search.php: make the queries also lookup the HTML based indexes
+
+Sun Oct  6 23:50:29 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* doc/index.py: added HTML page indexing 
+
+Fri Oct  4 15:33:55 CEST 2002 Igor Zlatkovic <igor@stud.fh-frankfurt.de>
+
+	* xmlIO.c: extended Windows path normalisation to fix the base
+	  problem in libxslt.
+	* catalog.c: fixed list handling in XML_CATALOG_FILES
+
+Fri Oct  4 13:43:02 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* valid.c: typo/bug found by Christian Glahn
+
+Sun Sep 29 19:44:10 CEST 2002 Igor Zlatkovic <igor@stud.fh-frankfurt.de>
+
+	* xmlIO.c: applied Windows CE patch from Javier.
+	* win32/wince: new directory, contains support for the PocketPC
+	  with Windows CE from Javier.
+	* include/win32config.h: reorganised, removed duplicate 
+	  definitions and applied WinCE patch from Javier.
+	* include/wsockcompat.h: new file, now contains WinSock
+	  compatibility macros.
+	* win32/Makefile.msvc: introduced double-run compilation.
+
+Thu Sep 26 19:48:06 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in include/libxml/xmlwin32version.h: preparing release
+	  of 2.4.25
+	* doc/*: updated and regenerated teh docs and web pages.
+
+Thu Sep 26 17:33:46 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* SAX.c valid.c include/libxml/valid.h: fixed bug #92518 validation
+	  error were not covering namespace declarations.
+	* result/valid/dia.xml test/valid/dia.xml: the test wasn't valid,
+	  it was missing the attribute declaration for the namespace
+	* result/VC/NS3: the fix now report breakages in that test
+
+Thu Sep 26 14:39:07 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLtree.c: fixing bug #94241 on HTML boolean attributes
+
+Thu Sep 26 14:25:33 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* doc/*: added the 3 new modules xmlregexp xmlautomata and xmlunicode
+	  and regenerated the docs and web site
+
+Thu Sep 26 11:45:42 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xinclude.c xmlschemas.c xmlschemastypes.c xpath.c: make sure
+	  ATTRIBUTE_UNUSED is always put after the attribute declaration,
+	  not before
+
+Thu Sep 26 11:33:28 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/generator.py python/libxml2class.txt: fixed a stupid error
+	  breaking the python API
+
+Thu Sep 26 00:31:46 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* trio.c trio.h triodef.h trionan.c trionan.h triop.h
+	  triostr.c triostr.h: applied a trio update patch from 
+	  Bjorn Reese which should work with MinGW
+
+Thu Sep 26 00:21:18 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: improving some documentation comments
+	* xmlregexp.c: found and fixed a mem leak with python regression tests
+	* doc/*: rebuilt the doc and the API XML file including the 
+	  xmlregexp.h xmlautomata.h and xmlunicode.h headers
+	* python/generator.py python/libxml2class.txt python/libxml_wrap.h
+	  python/types.c: added access to the XML Schemas regexps from
+	  python
+	* python/tests/Makefile.am python/tests/regexp.py: added a 
+	  simple regexp bindings test
+
+Tue Sep 24 08:10:48 MDT 2002 John Fleck <jfleck@inkstain.net>
+
+	* doc/xml.html:
+	  fixing ftp links - thanks to Vitaly Ostanin
+
+Tue Sep 24 16:08:17 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlregexp.c: fixed the data callback on transition functionality
+	  which was broken when using the compact form
+	* result/schemas/*: updated the results, less verbose, all tests
+	  pass like before
+	* DOCBparser.c testAutomata.c testC14N.c testSchemas.c testThreads.c
+	  testXPath.c valid.c xinclude.c xmllint.c xmlregexp.c xmlschemas.c
+	  xmlschemastypes.c xpath.c python/libxml.c: removed a bunch of
+	  annoying warnings
+	* xpath.c: try to provide better error report when possible
+
+Sat Sep 21 14:56:37 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am: fixed a breakage raised by Jacob
+
+Fri Sep 20 20:08:18 CEST 2002 Igor Zlatkovic <igor@stud.fh-frankfurt.de>
+
+	* include/win32config.h: added HAVE_ERRNO_H definition for parts
+	  which don't use sockets
+
+Fri Sep 20 18:40:50 CEST 2002 Igor Zlatkovic <igor@stud.fh-frankfurt.de>
+
+	* win32/Makefile.msvc: applied zlib patch from Daniel Gehriger
+	* win32/configure.js: applied zlib patch from Daniel Gehriger
+
+Fri Sep 20 15:40:14 CEST 2002 Igor Zlatkovic <igor@stud.fh-frankfurt.de>
+
+	* win32/configure.js: applied the patch from Mark Vakoc for 
+	  regexp support
+	* win32/libxml2.def.src: applied the patch from Mark Vakoc
+	  for regexp support
+	
+Fri Sep 20 15:35:33 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlschemastypes.c: as pointed by Igor Float and Double
+	  parsing ain't finished yet
+
+Fri Sep 20 14:00:16 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am configure.in: trying to fix #88412 by bypassing
+	  all the python subdir if python ain't detected
+
+Thu Sep 19 21:46:53 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am configure.in include/libxml/xmlversion.h.in:
+	  made configuring with regexps/automata/unicode the default
+	  but without schemas ATM
+	* testRegexp.c valid.c xmlregexp.c include/libxml/xmlregexp.h:
+	  fixed the regexp based DTD validation performance and memory
+	  problem by switching to a compact form for determinist regexps
+	  and detecting the determinism property in the process. Seems
+	  as fast as the old DTD validation specific engine :-) despite
+	  the regexp built and compaction process.
+
+Wed Sep 18 18:27:26 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* valid.c: determinism is debugged, new DTD checking code now works
+	  but xmlFAComputesDeterminism takes far too much CPU and the whole
+	  set usues too much memory to be really usable as-is
+
+Wed Sep 18 00:54:30 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: fixed another stupid bug in xmlGetNodePath()
+	* xmllint.c: --version now report the options compiled in
+
+Tue Sep 17 23:48:07 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLparser.c: small cleanup
+	* valid.c xmlregexp.c: switched DTD validation to use only regexp
+	  when configured with them. A bit of debugging around the determinism
+	  checks is still needed
+
+Tue Sep 17 21:22:25 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/libxml_wrap.h: stupid bug found by mattam@netcourrier.com
+
+Tue Sep 17 19:58:26 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlIO.c: small portability glitch fixed.
+
+Mon Sep 17 12:38:08 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlschemastypes.c: incomplete steps for real/double support
+	* testAutomata.c include/libxml/xmlautomata.h
+	  include/libxml/xmlregexp.h: avoiding a compilation problem
+	* valid.c include/libxml/valid.h: starting the work toward using
+	  the regexps for actual DTD validation
+
+Fri Sep 13 16:46:14 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* hash.c: cosmetic cleanup
+	* valid.c include/libxml/tree.h include/libxml/valid.h: started 
+	  integrating a DTD validation layer based on the regexps
+
+Thu Sep 12 18:01:29 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlregexp.c xmlschemas.c: fixed a bug reported by Jeff Goff,
+	  the determinism was tested before eliminating the epsilon
+	  transitions :-(
+
+Thu Sep 12 16:57:45 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/generator.py python/libxml.c python/libxml.py
+	  python/libxml2-python-api.xml python/libxml2class.txt
+	  python/libxml_wrap.h python/types.c: updated the python
+	  bindings, added code for easier File I/O, and the ability to
+	  define a resolver from Python fixing bug #91635
+	* python/tests/Makefile.am python/tests/inbuf.py
+	  python/tests/outbuf.py python/tests/pushSAXhtml.py
+	  python/tests/resolver.py python/tests/serialize.py: updated
+	  and augmented the set of Python tests.
+
+Tue Sep 10 21:05:28 CEST 2002 Igor Zlatkovic <igor@stud.fh-frankfurt.de>
+
+	* win32/configure.js: added more readme info for the binary
+	  package.
+	
+Tue Sep 10 14:15:18 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlIO.c: fixed a stupid out of bound array error
+
+Tue Sep 10 13:09:14 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/xmlIO.h xmlIO.c parser.c HTMLparser.c DOCBparser.c:
+	  messing around with support for Windows path, cleanups,
+	  trying to identify and fix the various code path to the
+	  filename access. Added xmlNormalizeWindowsPath()
+
+Thu Sep  5 16:19:18 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* error.c valid.c: working on better error reporting of validity
+	  errors, especially providing an accurate context.
+	* result/valid/xlink.xml.err result/valid/rss.xml.err: better
+	  error reports in those cases.
+
+Thu Sep  5 13:29:47 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* DOCBparser.c HTMLparser.c c14n.c entities.c list.c
+	  parser.c parserInternals.c xmlIO.c: get rid of all the 
+	  perror() calls made in the library execution paths. This
+	  should fix both #92059 and #92385
+
+Thu Sep  5 13:13:17 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmllint.c: memory leak reporting was broken after a change
+	  of the preprocessor symbol used to activate it.
+
+Thu Sep  5 13:10:57 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: try to make the copy function work for node of
+	  type XML_DOCUMENT_FRAG_NODE, they are only created by the
+	  DOM layers though, not libxml2 itself.
+
+Thu Sep  5 12:57:38 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* valid.c: try to provide file and line informations, not all
+	  messages are covered, but it's a (good) start
+
+Thu Sep  5 12:49:35 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xinclude.c: reimplemented a large part of the XInclude
+	  processor, trying to minimize resources used, James Henstridge
+	  provided a huge test case which was exhibiting severe memory
+	  consumption problems.
+
+Thu Sep  5 10:07:13 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/Makefile.am: applied patch from Christophe Merlet to
+	  reestablish DESTDIR
+
+Wed Sep  4 14:13:34 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* libxml.spec.in: fixes libary path for x86_64 AMD
+
+Tue Sep  3 21:14:19 MDT 2002 John Fleck <jfleck@inkstain.net>
+
+	* doc/tutorial/includekeyword.c
+	* doc/tutorial/xmltutorial.xml:
+	(plus resulting generated html files)
+	fixing one spot I missed in the tutorial where I hadn't freed
+	memory properly
+
+Sat Aug 31 19:31:17 MDT 2002 John Fleck <jfleck@inkstain.net>
+
+	* doc/tutorial/includeaddattribute.c
+	* doc/tutorial/includeaddkeyword.c
+	* doc/tutorial/includegetattribute.c
+	* doc/tutorial/includekeyword.c
+	* doc/tutorial/xmltutorial.xml
+	* doc/tutorial/*.html:
+	update tutorial to properly free memory (thanks to Christopher
+	R. Harris for pointing out that this needs to be done)
+	* doc/tutorial/images/callouts/*.png:
+	added image files so the callouts are graphical, making it
+	easier to read ( use "--param callout.graphics 1" to generate
+	html with graphical callouts)
+	
+Wed Aug 28 13:44:54 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* doc/Libxml2-Logo-180x168.gif doc/Libxml2-Logo-90x34.gif:
+	  nice logos generated by Marc Liyanage
+	* doc/site.xsl *.html: changed the stylesheet to show the new
+	  logo and regenerated the pages
+
+Sun Aug 25 16:38:05 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlIO.c: handle Windows sepecific file://localhost/ semantic ...
+
+Thu Aug 22 22:03:19 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: possible mem leak patch from Jason Adams
+
+Thu Aug 22 17:27:30 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: integrated xf:escape-uri() from Wesley Terpstra
+	  in the XQuery namespace
+	* configure.in: preparing 2.4.24
+	* doc/*.html: updated the web pages
+
+Thu Aug 22 16:19:42 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/generator.py: closing bug #85258 by generating conditional
+	  compile check to avoid linking to routines not configured in.
+
+2002-08-22  Havoc Pennington  <hp@pobox.com>
+
+	* autogen.sh: update error message for missing automake
+
+Thu Aug 22 11:45:50 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/Makefile.am: typo in target name resulted in libxml2.py
+	  to not be rebuilt. fixed DESTDIR similary to the libxslt one.
+
+Thu Aug 22 09:15:00 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* win32/win32/Makefile.mingw: updated with version from 
+	  Elizabeth Barham at http://soggytrousers.net/repository/
+
+Tue Aug 20 16:40:48 CEST 2002 Igor Zlatkovic <igor@stud.fh-frankfurt.de>
+
+	* win32/Makefile.msvc: added the prefix location to the include
+	and lib search path.
+	
+2002-08-18  Havoc Pennington  <hp@pobox.com>
+
+	* autogen.sh: hardcode aclocal-1.4/automake-1.4 so that users with
+	both automake 1.6 and 1.4 installed get the right automake. Means
+	compilation from CVS will now require the latest automake 1.4
+	release, or manually creating symlinks called "automake-1.4" and
+	"aclocal-1.4"
+
+Wed Aug 14 18:54:19 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in python/Makefile.am: more AMD 64 induced changes from
+	  Frederic Crozat
+
+Wed Aug 14 16:43:53 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xinclude.c: oops I was missing the xml:base fixup too
+	* result/XInclude/*.xml: this adds xml:base attributes to most
+	  results of the tests
+
+Wed Aug 14 16:05:37 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xinclude.c: quick but apparently working implementation of
+	  xi:fallback, should close bug #89684
+	* Makefile.am test/XInclude/docs/fallback.xml 
+	  result/XInclude/fallback.xml: added a basic test for fallback,
+	  and run with --nowarning to avoid a spurious warning
+	* configure.in: applied patch from Frederic Crozat for python
+	  bindings on AMD 64bits machines.
+
+Wed Aug 14 10:47:46 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: xmlSAXUserParseMemory() really ought to fail if
+	  the caller don't pass a SAX callback block.
+
+Wed Aug 14 10:29:02 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: applied the same fix for the XML-1.0 namespace to
+	  xmlSearchNsByHref() as was done for xmlSearchNs()
+
+Mon Aug 12 16:52:08 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* libxml.3: small cleanup of the man page
+	* HTMLtree.c: fixed a potential problem raised by Petr Vandrovec
+	  when serializing HREF attributes generated by XSLT.
+
+Mon Aug 12 15:24:05 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLtree.c include/libxml/HTMLtree.h: integrated a cleaned up
+	  version of Marc Liyanage' patch for boolean attributes in HTML
+	  output
+
+Mon Aug 12 14:11:59 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/tests/serialize.py: fixed the test results, indenting
+	  behaviour changed slightly
+
+Thu Aug  8 11:00:26 2002  Aleksey Sanin  <aleksey@aleksey.com>
+
+	* win32/dsp/libxml2.def.src win32/libxml2.def.src: added
+	new c14n function to Windows def files
+	
+Fri Aug  2 16:46:46 2002  Aleksey Sanin  <aleksey@aleksey.com>
+
+	* c14n.c: fixed a memory leak in c14n code
+
+Sat Aug  3 00:15:06 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c include/libxml/parser.h: adding a new API for Christian
+	  Glahn: xmlParseBalancedChunkMemoryRecover
+	* valid.c: patch from Rick Jones for some grammar cleanup in
+	  validation messages
+	* result/VC/* result/valid/*: this slightly change some of the
+	  regression tests outputs
+
+Thu Aug  1 14:50:28 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: trying to fix a problem in namespaced attribute handling
+	  raised by Christian Glahn
+
+Thu Aug  1 12:17:30 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* encoding.c include/libxml/encoding.h: Opening the interface
+	  xmlNewCharEncodingHandler as requested in #89415
+	* python/generator.py python/setup.py.in: applied cleanup
+	  patches from Marc-Andre Lemburg
+	* tree.c: fixing bug #89332 on a specific case of loosing 
+	  the XML-1.0 namespace on xml:xxx attributes
+
+Wed Jul 31 23:27:42 2002  Aleksey Sanin  <aleksey@aleksey.com>
+
+	* c14n.c include/libxml/c14n.h: fixed one more c14n + namespaces
+	corner case from new Merlin's test suite and added a callback
+	that will be used to improve xmlsec performance
+	
+
+Mon Jul 29 18:22:00 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLtree.c: trying to fix the <style> escaping problem in
+	  HTML serialization bug #89342
+
+Thu Jul 25 01:33:47 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* doc/xml.html doc/*.html: applied syntax patch from Rick Jones
+	  and rebuilt the web site.
+
+Mon Jul 22 11:04:48 PDT 2002  Aleksey Sanin <aleksey@aleksey.com>
+
+	* include/libxml/tree.h: added _private member to xmlNs struct
+
+Sun Jul 21 17:48:47 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLparser.c: fixing bug #84876 based on the xml working
+	  code.
+
+Sun Jul 21 19:15:00 HKT 2002 William Brack <wbrack@mmm.com.hk>
+
+	* python/Makefile.am: enhanced to fix bug 72012 (errors
+	  when using '-jX' make parameter)
+
+Fri Jul 19 16:35:00 HKT 2002 William Brack <wbrack@mmm.com.hk>
+
+	* xpath.c: small additional enhancement for booleans
+	  compared to nodesets
+
+Wed Jul 17 19:48:14 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLtree.c: changed the order of the encoding declaration
+	  attributes in the meta tags due to a bug in IE/Mac
+
+Fri Jul 12 08:45:00 HKT 2002 William Brack <wbrack@mmm.com.hk>
+
+	* xpath.c: enhanced handling of booleans (especially '='
+	  and '!=' for nodesets) - fixes bug 85256.  Added new
+	  routine xmlXPathNotEqualValues for more proper handling
+	  of '!=' when nodesets are involved.
+
+Thu Jul 11 21:45:52 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* doc/Makefile.am: fixing Red Hat bug #68614 by adding the
+	  doc/xmlcatalog_man.xml to the source distribution
+
+Wed Jul 10 21:26:13 CEST 2002 Igor Zlatkovic <igor@stud.fh-frankfurt.de>
+	
+	* win32/Makefile.msvc: Added a copy *.pdb to install, few have
+	  asked for this.
+	
+Sat Jul  6 21:55:59 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in: preparing 2.4.23
+	* doc/*: rebuilt the docs
+
+Sat Jul  6 21:11:20 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: fixing bug #84169 by fixing the
+	  comment of xmlCreatePushParserCtxt to describe the 
+	  encoding detection parameters better.
+
+Sat Jul  6 19:44:56 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* valid.c: fixing bug #79331 in one path the lookup for
+	  ID attributes on a namespaced node wasn't handled correctly :-\
+
+Fri Jul  5 20:07:43 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLparser.c: trying to fix 87235 about discarded white
+	  spaces in the HTML parser.
+	* result/HTML/*: this changes the output of a number of HTML
+	  regression tests
+
+Mon Jul  1 23:23:41 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: applied patch from Richard Jinks for the namespace
+	  axis + fixed a memory error.
+	* parser.c parserInternals.c: applied patches from Peter Jacobi
+	  removing ctxt->token for good.
+	* xmlschemas.c xmlschemastypes.c: fixed a few memory leaks
+	  popped out by the regression tests.
+	* Makefile.am: patch for threads makefile from Gary Pennington
+
+Fri Jun 28 19:38:00 HKT 2002 William Brack <wbrack@mmm.com.hk>
+
+	* xpath.c: enhanced behaviour of position() after usage of
+	  expressions involving preceding-sibling (et al).
+
+Tue Jun 18 09:58:48 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* hash.c: applied a patch from Peter Jacobi to solve a problem
+	  when compiling with the Watcom C on Win32 
+	* result/schemas/*.err: the change of hashing algo generated
+	  permutations in the output
+
+Mon Jun 17 19:02:49 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* hash.c: applied patch from Sander Vesik improving the quality of
+	  the hash function.
+
+2002-06-14  Aleksey Sanin  <aleksey@aleksey.com>
+
+	* DOCBparser.c HTMLparser.c debugXML.c encoding.c
+	nanoftp.c nanohttp.c parser.c tree.c uri.c xmlIO.c
+	xmllint.c xpath.c: replaced sprintf() with snprintf()
+	to prevent possible buffer overflow (the bug was pointed
+	out by Anju Premachandran) 
+
+Thu Jun 13 17:30:25 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: removed an uninitialized data error popped by valgrind
+	  on PE references
+
+Wed Jun 12 21:38:46 MDT 2002 John Fleck <jfleck@inkstain.net>
+
+	* doc/xml.html
+	adding tutorial reference to the web page
+
+Wed Jun 12 21:26:08 MDT 2002 John Fleck <jfleck@inkstain.net>
+
+	* doc/tutorial/xmltutorial.xml
+	* doc/tutorial/ar01s07.html
+	* doc/tutorial/ape.html
+	* doc/tutorial/includegetattribute.c
+	adding section to tutorial about retrieving an attribute
+	value
+
+Tue Jun 11 12:07:04 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: applied a couple of patches from Peter Jacobi to start
+	  to get rid of ctxt->token, with a possible significant speed
+	  improvement to be gained once done. Better compliance with PE
+	  references constructs in DTDs too.
+	* test/valid/t[0-9]* result/valid/t[0-9]*: added a set of tests
+	  from Peter too
+
+Tue Jun 11 09:25:12 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: Babak Vahedipour-Kunze reported that openTag in 
+	  xmlParseElement was likely to have been deallocated at the
+	  time of the report, possibly leading to segfault. Just report
+	  the tag name now.
+
+Mon Jun 10 18:00:02 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: patch from Richard Jinks for XPath substring() function
+	* result/XPath/expr/strings test/XPath/expr/strings: new set of tests
+
+2002-06-06  Aleksey Sanin  <aleksey@aleksey.com>
+
+	* xmlIO.c: patch from Rachel Hestilow to fix bug #84340
+
+Wed Jun  5 19:14:49 MDT 2002 John Fleck <jfleck@inkstain.net>
+
+	*doc/FAQ.html
+	fixing typos in FAQ, thanks to Robert Funnell for the
+	editing help
+
+Wed Jun  5 14:50:24 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* NEWS: got complaints from rpmlint that it was empty
+
+Tue Jun  4 09:09:18 MDT 2002 John Fleck <jfleck@inkstain.net>
+
+	* added doc/tutorial, including:
+	apa.html
+	apb.html
+	apc.html
+	apd.html
+	ar01s02.html
+	ar01s03.html
+	ar01s04.html
+	ar01s05.html
+	ar01s06.html
+	includeaddattribute.c
+	includeaddkeyword.c
+	includekeyword.c
+	includestory.xml
+	index.html
+	xmltutorial.xml
+	libxml tutorial, including generated html
+
+Mon Jun  3 21:21:26 2002  Aleksey Sanin  <aleksey@aleksey.com>
+
+	* result/c14n/exc-without-comments/merlin-c14n-two-*
+	  result/c14n/without-comments/merlin-c14n-two-*
+	  test/c14n/exc-without-comments/merlin-c14n-two-*
+	  test/c14n/without-comments/merlin-c14n-two-*
+	  testC14N.c Makefile.am: added merlin-c14n-two.tar.gz tests for 
+	c14n/exc-c14n and slightly modified test script to handle
+	these test cases
+	* c14n.c: fixed bugs for complicated nodes set (namespace
+	without node and others from merlin-c14n-two.tar.gz)
+	* include/libxml/xpathInternals.h win32/dsp/libxml2.def.src
+	win32/libxml2.def.src: "opened" xmlXPathNodeSetFreeNs() function
+	for xmlsec performance patch
+	* xpath.c: fixed self::node() for namespaces and attributes
+
+Mon Jun 03 00:04:21 2002 Chema Celorio <chema@ximian.com>
+
+	* tree.h: added xmlDocFormatDump which is just as xmlDocDump
+	  but with the format parameter
+	* tree.c: made xmlDocDump a wrapper arround xmlDocFormatDump
+
+Fri May 31 12:16:48 2002  Aleksey Sanin  <aleksey@aleksey.com>
+
+	* Makefile.am: updated c14n tests suite
+	* c14n.c: performance improvement for previous c14n patch
+
+Fri May 31 11:47:12 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: another peroformance patch from Peter Jacobi, that
+	  time on parsing attribute values.
+
+Thu May 30 23:34:27 2002  Aleksey Sanin  <aleksey@aleksey.com>
+
+	* Makefile.am result/c14n/* test/c14n/*: C14N tests integrated
+	into LibXML2 test suite
+
+Thu May 30 21:23:06 2002  Aleksey Sanin  <aleksey@aleksey.com>
+
+	* c14n.c: propagating xpath ancesstors node fix to c14n
+	plus small performance improvement to reduce number of
+	mallocs
+	* xpath.c: fixed ancestors axis processing for namespace nodes
+
+Wed May 29 10:21:39 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* SAX.c parser.c tree.c include/libxml/tree.h: performance patch from
+	  Peter Jacobi
+
+Mon May 27 23:18:33 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in: preparing 2.4.22
+
+Mon May 27 16:44:04 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLparser.c win32/libxml2.def.src win32/dsp/libxml2.def.src
+	  include/libxml/HTMLparser.h: fixing #79334 making htmlParseDocument
+	  a public entry point.
+	* doc/*: rebuilt the API and docs
+
+Mon May 27 14:16:28 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: patch from Richard Jinks to fix a problem introduced
+	  in the previous patch and pointed by Norm
+
+Fri May 24 13:10:22 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* libxml.spec.in: fixing bug #81112
+
+Fri May 24 13:03:24 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* uri.c: fixing bug #82848
+
+Fri May 24 09:54:49 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* result/catalogs/mycatalog.full: Aleksey's commit changed the
+	  output of one catalog test
+
+Fri 24 May 2002 12:17:45 AM PDT Aleksey Sanin <aleksey@aleksey.com>
+
+	* global.data globals.c tree.c include/libxml/globals.h 
+	win32/libxml2.def.src win32/dsp/libxml2.def.src: changed
+	default value for global parameter xmlIndentTreeOutput to 1 and
+	introduced new global parameter xmlTreeIndentString (the string
+	used to do one-level indent) with default value "  " (as it was
+	in tree.c)
+
+Thu May 23 13:55:57 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am: Merijn Broeren pointed out a problem when compiling
+	  with trio and schemas.
+
+Wed May 22 11:57:49 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: patch from Richard Jinks to fix the problem raised in
+	  http://mail.gnome.org/archives/xml/2002-April/msg00246.htm
+
+Wed May 22 08:38:19 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlschemas.c: a bit of work on import.
+	* xmlschemastypes.c: Charles Bozeman provided a compare function
+	  for date/time types so min/max facet restrictions should work,
+	  indeterminate comparisons return an error instead of equal.
+	* test/schemas/date_0* result/schemas/date_0_0: specific test
+	  from Charles Bozeman too
+
+Sat May 18 09:54:12 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* libxml.3 doc/buildDocBookCatalog: apply a couple of patches
+	  from Christian Cornelssen fixing the man pages and the Catalog
+	  building script.
+	* xmlschemas.c include/libxml/schemasInternals.h: nothing new yet
+	  next step is <xs:import> I now have a reasonable understanding
+	  of how it works.
+
+Thu May 16 10:43:26 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlIO.c: applied a small buffer performance patch from Gary Pennington
+
+Wed May 15 00:25:34 CEST 2002 Igor Zlatkovic <igor@stud.fh-frankfurt.de>
+
+	* win32/libxml2.def.src: exported xmlXPathNodeSetAddNs()
+
+Tue May 14 13:00:48 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: fixing an XPath function evalutation bug pointed out
+	  by Alexey Efimov where the context was lost when evaluating
+	  the function arguments
+
+Mon 13 May 2002 11:37:39 PM PDT Aleksey Sanin <aleksey@aleksey.com>
+
+	* xpath.c include/libxml/xpathInternals.h: maked xmlXPathNodeSetAddNs() 
+	  function public for XMLSec performance optimizations
+
+Mon May 13 12:32:22 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/generator.py python/libxml2class.txt : fixed a problem
+	  with the HTML parser pointed by Gary Benson
+	* python/tests/Makefile.am python/tests/pushSAXhtml.py: sdding the
+	  example
+
+Thu 09 May 2002 11:19:00 AM PDT Aleksey Sanin <aleksey@aleksey.com>
+	* parser.c: fixed bug #81159 (memory growth in SAX)
+	
+Tue 07 May 2002 09:20:21 AM PDT Aleksey Sanin <aleksey@aleksey.com>
+	* xpath.c: fixed bug #78858 (the real fix)
+
+Sat 04 May 2002 11:56:31 PM PDT Aleksey Sanin <aleksey@aleksey.com>
+	* xpath.c: fixed bug #78858 (quick and durty fix to hide the problem)
+	
+Sun May  5 08:57:08 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: modified xmlNodeSetBase to allow changing the
+	  base of a document.
+
+Fri May  3 09:20:41 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlschemastypes.c: patch Charles Bozeman for validation of
+	  all the date, time, and duration types
+	* test/schemas/dur_0* result/schemas/dur_0*: associated tests
+	* configure.in: fixed an error pointed by an user
+	* xml2-config.in: fixed an error pointed by an user
+
+Wed 01 May 2002 11:29:27 AM PDT Aleksey Sanin <aleksey@aleksey.com>
+
+	* include/libxml/xmlIO.h win32/dsp/libxml2.def.src
+	win32/libxml2.def.src xmlIO.c: exported default
+	'file:', 'http:' and 'ftp:' protocols input handlers 
+	and maked protocols comparisson case insensitive
+
+Tue Apr 30 16:29:05 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in: Neven Has detected a typo
+
+Tue Apr 30 08:48:11 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* AUTHORS HACKING: added Aleksey Sanin <aleksey@aleksey.com>
+	  as one of the persons allowed to commit directly to the
+	  module.
+
+Mon Apr 29 17:48:26 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in include/libxml/xmlwin32version.h: preparing 2.4.21
+	* valid.c: raised a too low limit
+	* doc/*: rebuilt the docs 
+
+Wed Apr 24 13:41:03 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* test/XPath/expr/floats test/XPath/expr/functions
+	  result/XPath/expr/floats result/XPath/expr/functions
+	  xpath.c: another XPath conformance patch from Richard Jinks
+
+Tue Apr 23 19:50:40 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlschemas.c: fixed validation of attribute groups.
+	* test/schemas result/schemas: added an example from the primer
+
+Tue Apr 23 09:11:37 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am xmlschemas.c xmlschemastypes.c: more work on Schemas
+	* test/schemas result/schemas: updated the test list
+
+Mon Apr 22 17:59:14 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* TODO: updated a bit
+	* parser.c: made a comment more specific
+	* xmlregexp.c xmlschemas.c xmlschemastypes.c: more work on the
+	  Schemas conformance.
+	* test/schemas result/schemas: updated the test list
+
+Sat Apr 20 19:36:39 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlregexp.c xmlschemas.c include/libxml/xmlautomata.h:
+	  implementing xs:all with minOccurs = 0
+	* tes/schemas/* result/schemas/*: added more tests covering
+	  xs:all
+
+Sat Apr 20 09:22:50 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlregexp.c: first implementation of the all particle, this
+	  may need to be revisited for case where not all transitions
+	  must be crossed.
+
+Fri Apr 19 18:26:04 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: another entity processing update from Markus Henke
+
+Fri Apr 19 17:14:24 CEST 2002 Bjorn Reese <breese@users.sourceforge.net>
+
+	* trionan.c: fixed crash on OSF/1
+
+Fri Apr 19 09:00:56 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlschemas.c: more Schemas work
+	* test/schemas/* result/schemas/*: added more tests coming
+	  from the spec.
+
+Thu Apr 18 23:00:02 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* c14n.c: patch from Aleksey Sanin reflecting a change in the
+	  ExcC14N specification
+
+Thu Apr 18 18:38:30 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: patch from Markus Henke, fix for recursive entities.
+
+Thu Apr 18 17:49:24 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: fix a problem with string() on a document node.
+
+Thu Apr 18 16:40:42 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am xmlschemas.c: more Schemas work
+	* test/schemas/* result/schemas/*: added more tests coming
+	  from the spec.
+
+Thu Apr 18 13:52:52 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLtree.c: fixed & serialization bug introduced in 2.4.20
+	* result/HTML/*: this changes a few things in the results
+
+Wed Apr 17 20:34:37 CEST 2002 Igor Zlatkovic <igor@stud.fh-frankfurt.de>
+
+	* include/libxml/tree.h: eliminated 'declaration different than
+	 prototype' warning
+	* include/win32config.h: "resolved" conflicts with errno.h
+
+Wed Apr 17 18:26:07 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlregexp.c xmlschemas.c include/libxml/xmlautomata.h: more work
+	  on the automata interfaces and debug of counted choices
+	* test/schemas/* result/schemas/*: added a number of tests
+
+Wed Apr 17 11:03:03 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlschemas.c xmlschemastypes.c include/libxml/xmlschemas.h:
+	  a bit of work on Schemas
+	* testSchemas.c: try to make it more useful
+	* test/schemas/* result/schemas/* Makefile.am: changed the
+	  Schemas regression test procedure, started adding a few samples
+
+Tue Apr 16 19:52:01 CEST 2002 Igor Zlatkovic <izlatkovic@stud.fh-frankfurt.de>
+
+	* include/libxml/encoding.h: Patch for the Borland C++ builder
+	* include/libxml/tree.h: Patch for the Borland C++ builder
+	* threads.c: Patch for the Borland C++ builder
+	* win32/bcb5: New directory for the Borland C++ builder
+	 project files       
+
+Tue Apr 16 19:46:55 CEST 2002 Igor Zlatkovic <izlatkovic@stud.fh-frankfurt.de>
+
+	* win32/Makefile.msvc: Update for XML Schema support
+	* win32/configure.js: Update for XML Schema support
+	* win32/libxml2.def.src: Update for XML Schema support
+
+Tue Apr 16 17:46:43 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am TODO_SCHEMAS configure.in genUnicode.py testAutomata.c
+	 testRegexp.c testSchemas.c xmlregexp.c xmlschemas.c xmlschemastypes.c
+	 xmlunicode.c include/libxml/Makefile.am
+	 include/libxml/schemasInternals.h include/libxml/xmlautomata.h
+	 include/libxml/xmlregexp.h include/libxml/xmlschemas.h
+	 include/libxml/xmlschemastypes.h include/libxml/xmlunicode.h
+	 include/libxml/xmlversion.h.in : merged the current state of
+	 XML Schemas implementation, it is not configured in by default,
+	 a specific --schemas configure option has been added.
+	* test/automata test/regexp test/schemas Makefile.am
+	  result/automata result/regexp result/schemas:
+	  merged automata/regexp/schemas regression tests
+
+Tue Apr 16 09:48:44 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: Gary found a compile time problem, fixes #78823
+
+Mon Apr 15 19:11:36 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in: release of 2.4.20
+	* doc/*: updated and rebuilt the docs
+
+Mon Apr 15 14:55:53 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/Makefile.am: patch from Cristian Gafton to build on
+	  Red Hat 6.2, should also fix #75779
+
+Mon Apr 15 12:14:49 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* valid.c: first part of fixing #78729
+
+Sun Apr 14 23:44:58 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLtree.c uri.c: fixing bug #78662 i.e. add proper
+	  escaping of URI when saving HTML files.
+	* result/HTML/*: this impacted some tests
+
+Sun Apr 14 14:55:15 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in: trying to fix #77441
+
+Fri Apr 12 23:02:16 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/xmlIO.h: Hallski complained it could not be
+	  included by itself.
+
+Thu Apr 11 10:23:36 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in: applied an IEEE flag patch for OSF/1 #77825
+
+Wed Apr 10 23:31:34 CEST 2002 Igor Zlatkovic <igor@stud.fh-frankfurt.de>
+
+	* win32/configure.js: patch from Nilo for the c14n option
+	* win32/Makefile.msvc: fixed libxml2.def generation with threads
+
+Wed Apr 10 21:24:16 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c include/libxml/xmlwin32version.h.in: Silvan Minghetti
+	  pointed erroneous use of LIBXML_THREADS_ENABLED instead of
+	   LIBXML_THREAD_ENABLED
+
+Wed Apr 10 18:12:52 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: another patch from Richard Jinks for substring conformance
+	* test/XPath/expr/floats test/XPath/expr/strings
+	  result/XPath/expr/floats result/XPath/expr/strings: update of the
+	  test suite to check those.
+
+Wed Apr 10 13:29:49 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: patch from Richard Jinks for .x float parsing.
+
+Tue Apr  9 18:09:31 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: patch from Markus Henke when an encoding ain't recognized
+
+Tue Apr  9 15:47:14 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* libxml.m4: got a report that #include <string.h> was needed
+
+Tue Apr  9 11:51:25 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmllint.c: applied a fix from Anthony Jones for -o /--output
+
+Tue Apr  2 20:27:11 MST 2002 John Fleck <jfleck@inkstain.net>
+
+	* doc/example.html: fixing typo
+
+Mon Apr  1 10:02:57 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: fixed a bug in the nodeset to boolean comparison code
+	  pointed out by Melvyn Sopacua.
+
+Fri Mar 29 23:41:53 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* libxml.m4: Frédéric Crozat gave a patch related to the change
+	  of Include paths breaking the libxml.m4
+
+Fri Mar 29 18:25:54 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: Fix bug #76927 forgot to save some context
+	  when evaluating binary expressions
+
+Thu Mar 28 19:22:48 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in: fixed configure for MPE/iX from Markus Henke
+	* xmlmemory.c: fixed initialization problems
+	* xpath.c: another set of patches from Richard Jinks this
+	  fixes "make XPathtests" on linux
+
+Wed Mar 27 17:09:43 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* trionan.c trionan.h xpath.c: more patches from Richard Jinks
+	* test/XPath/expr/compare test/XPath/expr/equality
+	  test/XPath/expr/floats test/XPath/expr/functions
+	  test/XPath/expr/strings result/XPath/expr/compare
+	  result/XPath/expr/equality result/XPath/expr/floats
+	  result/XPath/expr/functions result/XPath/expr/strings: Updated
+	  tests though they show a divergence on Linux
+
+Wed Mar 27 10:06:53 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c trionan.c: previous commit also included patches
+	  from Richard Jinks on some IEEE support corner case
+
+Wed Mar 27 10:03:11 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* AUTHORS HACKING: Added Igor Zlatkovic as official maintainer
+	* python/Makefile.am python/tests/Makefile.am: Albert Chin pointed
+	  that $(datadir) should be used for docs
+
+Tue Mar 26 13:43:16 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlIO.c: Thomas Steinborn pointed out #76404 that libxml2
+	  could leak filedescriptors
+
+Tue Mar 26 08:55:53 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in nanohttp.c: applied patch from Allan Clark for
+	  UnixWare/OpenServer
+
+Mon Mar 25 17:45:44 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in: preparing 2.4.19
+	* doc/*: rebuilt the docs
+
+Mon Mar 25 17:34:06 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* nanohttp.c: fixing #76043, got fed up with non-portability
+	  of that piece of code.
+
+Mon Mar 25 13:08:21 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* valid.c SAX.c: Never commit without running "make tests" :-(
+	  fix a couple of stupidities in the previous commit
+	* result/*: a few changes in some attribute order result of previous
+	  commit.
+
+Mon Mar 25 11:46:05 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* valid.c SAX.c: fixed bug #76168, attribute redeclared in
+	  the internal subset should not raise duplicate ID errors,
+	  also there was a small bug in conjunction to namespace
+	  declarations defaulted and xml:xxx attributes DTD definitions.
+	  
+Fri Mar 22 15:13:49 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: Richard Jinks also raised some rounding problems
+	  this tries to fix them
+
+Fri Mar 22 13:22:09 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: Richard Jinks spotted an incoherent memory allocation
+	  behaviour in xmlXPathCastToString()
+
+Thu Mar 21 14:25:29 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* encoding.c: fixed a bug in the ISO-Latin 1 to UTF8 encoder
+	  raised by Morus Walter
+
+Thu Mar 21 14:07:13 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlcatalog.c include/libxml/xmlversion.h.in: applied 2 fixups
+	  from Igor
+
+Thu Mar 21 13:30:06 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: fixing #75619, related to a problem when trying
+	  to evaluate condition when the current node set resulting
+	  from that sub-step evaluation is empty. Also fixes 2 potential
+	  problem with previous-sibling and next-siblings axis.
+
+Thu Mar 21 09:03:59 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* c14n.c: patch from Mark Vakoc to build C14N if DocBook and
+	  HTML support is not configured in.
+
+Wed Mar 20 22:42:42 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLparser.c error.c parser.c parserInternals.c tree.c xmlIO.c
+	  include/libxml/tree.h: dohh I really didn't intended to commit
+	  this test version :-(
+
+Wed Mar 20 20:20:57 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* testSAX.c: I wanted to see the real speed at the SAX interface
+	  after a little too many Ximianer started complaining about the
+	  parser speed.
+	  added a --quiet option:
+	  paphio:~/XML -> ls -l db100000.xml 
+	  -rw-rw-r--    1 veillard www      20182040 Mar 20 10:30 db100000.xml
+	  paphio:~/XML -> time ./testSAX --quiet db100000.xml 
+	  3200006 callbacks generated
+	  real	0m1.270s
+	  Which means 16MBytes/s and 3Mcallback/s
+
+Tue Mar 19 19:33:57 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: valgrind spotted another error that time when running
+	  on libxslt regression tests
+
+Tue Mar 19 15:24:49 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am: adding "make valgrind" running the full regression
+	  tests (except python ones) under Valgrind (using valgrind -q
+	  which was kindly added by the author).
+	* valid.c: stupid bug pinpointed by Valgrind, the regression tests
+	  passes cleanly now except an obcure floating point initialization
+	  raised in log10() in one XPath regression test ???
+	* tree.c: edited some comments to close #75244
+
+Tue Mar 19 12:15:20 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: pretty insane thing, the xmlXPathFormatNumber()
+	  was not serializing 1 as "1" if LC_ALL=sv_SE :-( and in the
+	  context of ScrollKeeper, made sure that if the number is
+	  an integer, the serialization follows the description at
+	  http://www.w3.org/TR/xpath#section-String-Functions
+
+Mon Mar 18 19:18:13 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in: preparing 2.4.18
+	* doc/*: updated and rebuilt the web site
+	* *.c libxml.h: implement the new IN_LIBXML scheme discussed with
+	  the Windows and Cygwin maintainers.
+	* parser.c: humm, changed the way the SAX parser work when
+	  xmlSubstituteEntitiesDefault(1) is set, it will then 
+	  do the entity registration and loading by itself in case the
+	  user provided SAX getEntity() returns NULL.
+	* testSAX.c: added --noent to test the behaviour.
+
+Mon Mar 18 12:44:23 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: Wilfried Teiken provided a hackish but working
+	  way to get context reported back on entities when parsing
+	  with SAX and without breaking the DOM build.
+
+Sun Mar 17 11:31:55 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* c14n.c: applied a new patch from Aleksey Sanin
+	* doc/site.xsl doc/xml.html doc/*.html: updated the documentation
+	  to reference Aleksey implementation of XML digital Signatures
+
+Sat Mar 16 23:01:42 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: small fix to avoid potential problem due to
+	  ordering of freeing data
+	* python/Makefile.am: people were complaining about 
+	  the generated file in python dir not being built
+
+Fri Mar 15 23:21:40 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* libxml.spec.in python/Makefile.am python/tests/Makefile.am
+	  python/generator.py python/libxml.c python/types.c: Cleanup
+	  of the python Makefiles based on Jacob and James feedback,
+	  fixed the spec file accordingly, fixed the number of warning
+	  that passing my pedantic CFLAGS was generating. Conclusion
+	  is that Python includes are real crap.
+
+Fri Mar 15 19:41:25 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* configure,in: it was reported quite a few times that
+	  xml2-config --cflags should not output
+	  -I$includeprefix/libxml2/libxml because libxml2 header names
+	  clashes with existing names like list.h from C++ stl.
+	  Includes should be #include<libxml/xxx.h> so ...
+
+Fri Mar 15 10:41:50 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* c14n.c: another patch from Aleksey Sanin
+
+Fri Mar 15 08:55:55 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* c14n.c: applied patch from Aleksey Sanin fixing a problem in the
+	  canonicalization algorithm
+	* doc/xml.html doc/index.html: added the C14N references on the 
+	  index page.
+
+2002-03-13  jacob berkman  <jacob@ximian.com>
+
+	* python/Makefile.am: remove LDADD and CFLAGS as this is broken
+	usage, redundant, and gcc specific
+
+Wed Mar 13 11:00:59 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: speedup some node selection operations, this can
+	  have a significant impact on DocBook Norm's stylesheets
+	* nanohttp.c: someone reported that SOCKLEN_T may not be defined
+	  make sure it's always the case
+	* debugXML.c: distinguish CDATA and comments in ls operations
+
+Tue Mar 12 19:45:24 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/*.h: Heiko W. Rupp fixed a lot of comments
+	  to generate better API descriptions etc...
+
+Mon Mar 11 10:10:30 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* c14n.c: Fixing #74186, made sure all boolean expressions
+	  get fully parenthesized, ran indent on the output
+	* configure.in HTMLtree.c SAX.c c14n.c debugXML.c tree.c xpointer.c
+	  include/libxml/tree.h: also #74186 related, removed the
+	  --with-buffers option, and all the preprocessor conditional
+	  sections that were resulting from it.
+
+Sun Mar 10 17:47:58 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* valid.c: applied patch from Dodji Seketeli fixing an
+	  uninitailized variable in xmlValidGetValidElements()
+
+Sat Mar  9 15:10:49 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* c14n.c: fixed a few comments
+	* doc/*.html doc/*/*.html: regenerated the docs and added
+	  the C14N API
+	* doc/api.xsl doc/gnome-xml.sgml: fixups and added IDs
+
+Sat Mar  9 11:16:11 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* check-xml-test-suite.py: fix to adapt varaiations in the
+	  bindings
+	* configure.in python/setup.py python/setup.py.in: fixed to
+	  have the version of the python scripts automatically updated
+
+Fri Mar  8 16:45:55 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: fixed a bug newly introduced and pointed by Uwe Fechner
+	  in xmlCopyProp()
+
+Fri Mar  8 15:49:10 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in: preparing 2.4.17 release
+	* doc/*: updated and rebuilt the docs
+	* xpath.c: fixed a comment
+	* python/libxml.c: fixed a possible reentrancy problem
+
+Thu Mar  7 23:19:28 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c python/tests/Makefile.am python/tests/attribs.py:
+	  fixed xmlHasNsProp() bugs for defaulted from DTD attribs,
+	  added a specific regression test
+	* python/generator.py: xmlHasNsProp() and xmlHasProp() shall
+	  not raise exceptions when failing to find the attribute.
+
+Thu Mar  7 16:11:35 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in xmllint.c: owen pointed out a problem with the
+	  ftme fix, gettimeofday() was not detected by configure and
+	  the ftime header wasn't included, dohhh
+
+Thu Mar  7 12:19:36 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in xmllint.c: trying to fix #71457 for timing
+	  precision when gettimeofday() is not availble but ftime() is
+
+Thu Mar  7 11:24:02 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* libxml.spec.in doc/Makefile.am: Fixed #73408 missing images
+	  are now copied on install and part of the -devel RPM
+
+Thu Mar  7 09:34:16 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: trying to avoid bug #72150 which was apparently
+	  caused by a gcc bug (or a processor problem) as detailed
+	  at http://veillard.com/gcc.bug
+
+Thu Mar  7 01:02:37 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c python/tests/Makefile.am python/tests/cutnpaste.py:
+	  fixed xmlReconciliateNs(), added a Python test/example for
+	  inter-document cut'n paste
+	* python/libxml.py: fixed node.doc on document nodes and added
+	  xpathEval() onto node objects
+
+Wed Mar  6 22:38:03 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLtree.c: fixed some htmlSetMetaEncoding() problems
+	* python/libxml.c python/tests/Makefile.am python/tests/serialize.py:
+	  fixup and integrated tests for the serialization stuff
+
+Wed Mar  6 19:40:57 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am libxml.3 libxml.4 libxml.spec.in: Fixed bug #72570
+	  moved the libxml man page to section 3
+
+Wed Mar  6 18:34:07 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: fix bug #72490
+	* python/libxml.c python/libxml.py: added methods serialize()
+	  and saveTo() to all node elements.
+
+Tue Mar  5 21:27:03 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlIO.c: closed #73430, don't read from an input source
+	  which indicated an end-of-file or an error.
+
+Tue Mar  5 16:33:42 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: make sure SAX endDocument is always called as
+	  this could result in a Python memory leak otherwise (it's
+	  used to decrement ref-counting)
+	* python/generator.py python/libxml.c python/libxml.py
+	  python/libxml2-python-api.xml python/libxml2class.txt
+	  python/tests/error.py python/tests/xpath.py: implemented
+	  the suggestions made by Gary Benson and extended the tests
+	  to match it.
+
+Tue Mar  5 10:35:24 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/generator.py: applied patch fixing #73450
+
+Mon Mar  4 17:59:29 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: fixing #61290 "namespace nodes have no parent"
+	  long standing divergence from the XPath REC. NodeSets
+	  simply hold a copy of namespace nodes and those node ->next
+	  points to the parent (which may not be the node carrying the
+	  definition).
+	* include/libxml/xpath.h: flagged but didn't added a possible
+	  speedup
+	* DOCBparser.c HTMLparser.c: removed some warnings from push
+	  parser due to new state being added.
+	* tree.c: new fix from Boris Erdmann
+	* configure.in c14n.c include/libxml/c14n.h testC14N.c: added
+	  the XML Canonalization support from Aleksey Sanin
+
+Sun Mar  3 15:12:42 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: patch from Boris Erdmann fixing some namespace odities
+	  with xmlCopyNode()
+
+Sat Mar  2 10:33:04 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlIO.c: fix bug #72706 when loading a NULL entity
+
+Fri Mar  1 17:14:42 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* SAX.c: Fixed #72346, about handling of xmlns:foo="", this could
+	  actually change in a future XML Namespace revision.
+
+Fri Mar  1 17:12:15 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/types.c python/tests/Makefile.am python/tests/xpathret.py:
+	  added the possibility of returning nodesets from XPath extension
+	  functions written in Python
+
+Fri Mar  1 13:56:12 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/*: commiting some Python bindings work done while travelling
+
+Fri Mar  1 10:11:15 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmllint.c: close #72663 and #72658, don't memdump unless compiled
+	  explicitely with memory debugging switched on
+
+Sat Feb 23 11:08:09 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/generator.py python/libxml.c python/libxml2-python-api.xml
+	  python/libxml2class.txt python/libxml_wrap.h python/types.c:
+	  Added wrapper for the xmlURIPtr type, provided accessors, fixed
+	  the accessor generator for strings
+	* python/tests/Makefile.am python/tests/tstURI.py: added a specific
+	  regression test.
+
+Fri Feb 22 23:44:57 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/README python/generator.py python/libxml.c python/setup.py:
+	  added the 'usual' setup.py to allow building a libxml2-python
+	  module based on the same code. The initialization is however
+	  different the 2 .so files fo libxml2 and libxslt are identical and
+	  they entry point initialize both libraries. this is done to avoid
+	  some possible nasty problem since the Python don't merge the maps
+	  of all shared modules.
+
+Wed Feb 20 23:16:08 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: fixed a push/encoding bug reported by Michael
+	  on librsvg
+
+Wed Feb 20 19:54:05 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/parserInternals.h: fixes a misplaced #endif
+
+Wed Feb 20 17:47:55 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c valid.c: found and fixed a couple of allocation bugs
+
+Wed Feb 20 15:36:03 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* doc/xml.html doc/python.html doc/*: added a Python and binding
+	  page describing the current state of the Python bindings and 
+	  giving pointers to the other languages wrappers.
+
+Wed Feb 20 11:16:15 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in include/libxml/xmlwin32version.h: preparing 2.4.16
+	* doc/* python/libxml2class.txt: updated and rebuilt the docs,
+	  rebuilt the API and web site
+	* xpath.c: fixed #71978 portability bugs
+
+Tue Feb 19 22:49:36 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* SAX.c: oops broke automatic defaulting of namespaces attributes.
+
+Tue Feb 19 22:01:35 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/parserInternals.h parser.c: had to change
+	  2 internal parsing API when processing document content
+	  to check the start and end of element content are defined
+	  in the same entity
+	* valid.c include/libxml/valid.h: attribute normalization can
+	  generate a validity error added xmlValidCtxtNormalizeAttributeValue()
+	  with the context to report it.
+	* SAX.c: fixed the last known bugs, crazy validation constraints
+	  when a document is standalone seems correctly handled. There
+	  is a couple of open issues left which need consideration especially
+	  PE93 on external unparsed entities and standalone status. 
+	  Ran 1819 tests: 1817 suceeded, 2 failed and 0 generated an error in 8.26 s.
+	  The 2 tests left failing are actually in error. Cleanup done.
+
+Tue Feb 19 15:17:02 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* valid.c: implemented E59 spaces in CDATA does not match the
+	  nonterminal S
+
+Tue Feb 19 14:44:53 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* SAX.c parser.c valid.c: more validation test fixups
+	* check-xml-test-suite.py: added duration info for the tests
+
+Mon Feb 18 23:25:08 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c valid.c: a couple of errors were reported but not
+	  saved back as such in the parsing context. Down to 1% failure rate
+	  Ran 1819 tests: 1801 suceeded, 18 failed and 0 generated an error
+
+Mon Feb 18 20:16:15 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlInternald.c: isExtender was missing a char 
+	* parser.c include/libxml/parser.h: % are acceptable in the
+	  internal subset if within a PUBLIC ID
+
+Mon Feb 18 19:27:32 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* SAX.c parserInternals.c valid.c: more work on the conformance
+	  suite. Took the step to finally block documents with encoding
+	  errors. It's a fatal error per the spec, people should have fixed
+	  their documents by now.
+
+Mon Feb 18 15:30:14 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* check-xml-test-suite.py: fixed the test script after some discussion
+	  on the semantic of TYPE="error"
+	* Makefile.am: added the script to the distrib
+
+Mon Feb 18 12:17:41 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* SAX.c entities.c: fixed a couple of conformances issues deep
+	  into the validation code (standalone and undeclared Notations)
+
+Mon Feb 18 00:17:24 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: fixed #71741 supid typo an a bug about encoding parsing
+	  stayed there for years !
+
+Mon Feb 18 00:06:42 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* valid.c SAX.c: fixed #71740 NotationDecl with a required field
+	  missing
+
+Sun Feb 17 23:45:40 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* check-xml-test-suite.py: improved the behaviour a bit as
+	  well as the logs
+	* parser.c valid.c SAX.c: fixed a few more bugs 
+	  "Ran 1819 tests: 1778 suceeded, 41 failed, and 0 generated an error"
+
+Sun Feb 17 20:41:37 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* check-xml-test-suite.py: python script to run regression tests
+	  against the XML Test suite of W3C/OASis
+	* SAX.c: fixed a validation bug
+	* parser.c: fixed 3 errors pointed by the test suite
+	* doc/buildDocBookCatalog: fixed a typo pointed by drake
+	* python/Makefile.am: fixed a dependendy
+
+Fri Feb 15 21:47:13 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlmemory.c: avoid a warning bug #71594
+
+Wed Feb 13 22:13:33 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlmemory.c: Jesse Perry provided a patch to remove a few
+	  warning on alpha/Tru64
+
+Wed Feb 13 14:30:49 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/entities.h: fixing a comment
+	* valid.c: fixing some troubles with validity check on namespaces
+	* result/VC/NS3 test/VC/NS3: added a specific regression test
+
+Wed Feb 13 14:05:24 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: Fixing #71342 serializing '\n' in attribute values
+	* result/noent/att3 result/att3 test/att3: added a specific
+	  test.
+
+Tue Feb 12 14:45:32 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/libxml.c: couple of bug fixes
+
+Mon Feb 11 19:41:29 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/*.py: removed tabs and used spaces.
+
+Mon Feb 11 19:25:44 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in include/libxml/xmlwin32version.h: preparing 2.4.15
+	* doc/news.html doc/xml.html doc/xmlio.html: rebuilt some docs
+
+Mon Feb 11 14:53:24 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* doc/xmlcatalog_man.xml: trying to close Red Hat bug #58707
+	  https://bugzilla.redhat.com/bugzilla/show_bug.cgi?id=58707
+
+Mon Feb 11 09:53:02 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/encoding.h include/libxml/entities.h
+	  include/libxml/globals.h include/libxml/parser.h
+	  include/libxml/threads.h include/libxml/tree.h
+	  include/libxml/xmlmemory.h: trying to fix the include mess
+
+Mon Feb 11 08:53:33 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/xmlmemory.h: reverted part of the previous
+	  attempt to provide #69655, this was breaking the build.
+
+Sun Feb 10 14:13:34 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLtree.c Makefile.am build_glob.py configure.in debugXML.c
+	  globals.c parser.c threads.c tree.c valid.c xmlmemory.c
+	  xpath.c xpointer.c include/libxml/globals.h include/libxml/parser.h
+	  include/libxml/parserInternals.h include/libxml/tree.h
+	  include/libxml/xmlmemory.h include/libxml/xpathInternals.h:
+	  Tentatively fixed #69655 , make compiling with -Wredundant-decls
+	  clean.
+        * python/libxml.c: fixed a warning.
+
+Sun Feb 10 12:02:59 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c valid.c xinclude.c: fix #68882, cleanup the XInclude
+	  copying of node, merge back IDs in the target document.
+	* result/XInclude/docids.xml test/XInclude/docs/docids.xml
+	  test/XInclude/ents/ids.xml: test case
+	* result/VC/ElementValid4: output changed due to a typo fix
+
+Sat Feb  9 23:15:04 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/Makefile.am: seems some version of automake didn't
+	  generate the dependencies right as Jacob found out. Add
+	  an extra dependency rule.
+
+Sat Feb  9 18:59:23 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* parserInternals.c valid.c: Justin Fletcher found some parts
+	  of the code needing cleanup
+	* libxml.spec.in python/Makefile.am python/generator.py
+	  python/libxml.c python/libxml.py: Fixed the python Makefiles
+	  corrected a bug showing up on ia64, changed the name of the
+	  python internal module too
+
+Fri Feb  8 15:19:28 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am: applied patch from Andris Pavenis for binary
+	  name suffixes
+
+Fri Feb  8 14:43:17 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmllint.c win32/win32config.h: fixing #68748
+
+Fri Feb  8 14:37:05 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* valid.c: fixing #70166
+
+Fri Feb  8 14:31:24 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* valid.c: fixing #70077
+
+Fri Feb  8 14:24:02 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* Copyright Makefile.am README configure.in libxml.spec.in:
+	  Changed to the MIT Licence
+	* doc/FAQ.html doc/catalog.html doc/intro.html doc/xml.html
+	  doc/xmlio.html: updated the doc accordingly
+	* include/libxml/xmlwin32version.h configure.in: preparing
+	  2.4.14 release
+	* python/generator.py python/libxml.c python/libxml2-python-api.xml
+	  python/libxml2class.txt python/libxml_wrap.h python/types.c:
+	  fixed the const xmlChar * wrapper and generator, XPath extension
+	  functions now use the context as first argument
+	* python/tests/tstxpath.py python/tests/xpath.py
+	  python/tests/xpathext.py: Updated the tests accordingly
+	* tree.c: fixed bug #70067
+
+Thu Feb  7 17:33:58 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am: cleanup
+	* debugXML.c: always use stdout if output is NULL
+	* xmlIO.c: don't close filedescriptors passed to outputBuffers
+	* python/Makefile.am python/generator.py python/libxml2class.txt
+	  python/libxml_wrap.h python/types.c: augmented the number of bindings
+	  handling FILE * and XPath contexts
+	* python/tests/Makefile.am: avoid a stupid problem due to the
+	  use of TEST.
+
+Wed Feb  6 23:37:07 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in: fixed stupid bug #70738 found by alfons hoogervorst
+
+Wed Feb  6 17:04:51 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/TODO python/libxml.c: cleanup the extension function lookup
+	* xmlmemory.c include/libxml/xmlmemory.h: always compile the list
+
+Tue Feb  5 17:33:30 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in python/Makefile.am: do not install outside
+	  of prefix
+
+Mon Feb  4 15:05:55 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/TODO python/libxml.c: started adding SAX interfaces
+	* python/tests/Makefile.am python/tests/pushSAX.py: added a basic
+	  SAX test
+
+Mon Feb  4 01:12:42 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: hardened the addChild function
+	* python/generator.py python/libxml.c python/libxml2-python-api.xml
+	  python/libxml2class.txt python/libxml_wrap.h python/TODO:
+	  added accessors needed for xmlNode, a bit more testing and
+	  extension of interfaces
+	* python/tests/Makefile.am python/tests/build.py: added a test
+	  build from scratch/save/load/check
+
+Sun Feb  3 21:10:39 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* parserInternals.c: change a small bit in the way valididy
+	  error messages get initialized
+	* python/TODO python/libxml.c python/libxml2-python-api.xml
+	  python/libxml2class.txt python/libxml_wrap.h python/types.c:
+	  added some memory debugging to track leaks at the libxml2 level
+	* python/tests/*.py: changed all tests to check for leaks,
+	  there is just one left in XPath extension registrations.
+
+Sun Feb  3 17:50:46 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/TODO python/generator.py python/libxml2-python-api.xml
+	  python/libxml2class.txt: more accessor classes for the parser
+	  context, allow to switch on and check validity
+	* python/tests/Makefile.am python/tests/error.py
+	  python/tests/invalid.xml python/tests/valid.xml
+	  python/tests/validate.py: attded more test and and added error.py
+	  which I forgot to commit in the last step
+
+Sun Feb  3 16:03:55 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/Makefile.am python/types.c: cleanup
+	* python/libxml.c python/libxml.py python/libxml_wrap.h
+	  python/generator.py python/libxml2-python-api.xml 
+	  python/libxml2class.txt: added class for parser context, added
+	  first cut for push mode support. Added a framework to generate
+	  accessors functions.
+	* python/tests/Makefile.am python/tests/push.py: added a push
+	  test
+
+Sun Feb  3 00:17:26 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/Makefile.am python/TODO python/libxml.py: fixed a small
+	  bug a bit of cleanup.
+
+Sat Feb  2 22:47:10 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/Makefile.am python/libxml.c python/libxml2-python-api.xml
+	  python/libxml2class.txt: adding error redirections and preformat
+	  to a python handler
+	* python/tests/Makefile.am python/tests/*.py: cleanup made all
+	  tests self checking
+
+Sat Feb  2 13:18:54 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/libxml.c python/libxml.py: fixed a stupid bug when renaming
+	  a function
+
+Sat Feb  2 11:25:51 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* libxml.spec.in python/Makefile.am python/TODO python/generator.py
+	  python/libxml.c python/libxml2-python-api.xml
+	  python/libxml2class.txt: Progressing through the TODOs, class
+	  description output, extra XML API, RPM now builds the wrappers
+	  for all python installed versions
+
+Sat Feb  2 10:13:52 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in libxml.spec.in python/Makefile.am python/TODO
+	  python/generator.py python/libxml2class.txt: added more informations
+	  in the libxml2-python package including docs. Slightly changed
+	  the class hierarchy
+	* python/tests/*: added basic regression tests infrastructure too
+
+Fri Feb  1 23:11:58 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in libxml.spec.in example/Makefile.am python/Makefile.am:
+	  added libxml2-python as part of the packages installed
+
+Fri Feb  1 18:48:19 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/Makefile.am python/generator.py python/libxml.c
+	  python/libxml.py: more work, now able to extend the
+	  XPath interpreter with functions written in python.
+
+Fri Feb  1 10:28:51 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/Makefile.am: Jacob sent a patch to allow building from
+	  tarfile.
+
+Fri Feb  1 00:40:48 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/Makefile.am python/libxml.c configure.in Makefile.am:
+	  inserted the python wrappers build, I hope this won't be too
+	  unportable
+
+Thu Jan 31 21:27:37 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: minor optimization
+	* python/generator.py python/libxml.c python/libxml.py
+	  python/libxml_wrap.h: more work on the python bindings,
+	  they now support XPath and there is no evident leak
+
+Thu Jan 31 00:48:06 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/generator.py python/libxml.c python/libxml.py:
+	  more work on the python bindings generator.
+
+Wed Jan 30 21:51:26 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/generator.py python/libxml.c python/libxml_wrap.h:
+	  more work on the python bindings.
+
+Wed Jan 30 17:35:33 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/generator.py python/libxml.c python/libxml.py
+	  python/libxml_wrap.h: commited early version of a python binding
+	  for private use only ATM
+
+Sat Jan 26 22:41:13 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* entities.c tree.c include/libxml/entities.h: applied patch
+	  from Anthony Jones to implement copy of DTD subtree too. Had
+	  just to keep 2 function private which really ought to become
+	  public ones.
+
+Fri Jan 25 15:14:55 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmllint.c: added pointers to the web pages in the usage()
+
+Thu Jan 24 17:04:04 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: more fixes from Petr Kozelka for attribute handling
+	  in the tree API to align the semantic with DOM.
+
+Thu Jan 24 16:00:53 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* valid.c tree.c entities.c: another set of patches from
+	  Anthony Jones for copy operations cleanup and robustness
+
+Wed Jan 23 18:53:55 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* doc/APIchunk*.html doc/parsedecl.py doc/api.xsl: generated
+	  an alphabetic index based on comments content
+	* doc/*: rebuilt the web site with the new references
+
+Wed Jan 23 15:14:22 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* parserInternals.h: Greg Sjaardema suggested to use an
+	  eponential buffer groth policy in xmlParserAddNodeInfo()
+
+Wed Jan 23 13:32:40 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* doc/api.xsl doc/APIconstructors.html doc/APIfiles.html
+	  doc/APIfunctions.html doc/APIsymbols.html doc/libxml2-refs.xml
+	  doc/parsedecl.py doc/Makefile.am: updated the python extractor
+	  to generate cross-references, and added/updated the stylesheets
+	  to generate and link API indexes. The generic keyword index
+	  is not done yet.
+	* doc/*.html: regenerated all the usual docs too
+
+Tue Jan 22 23:11:26 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* debugXML.c: added an xpath function to the shell for T. V. Raman
+
+Tue Jan 22 22:42:23 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* debugXML.c: patch from Anthony Jones to catch NULL nodes in
+	  debug routines.
+
+Tue Jan 22 22:38:42 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: apply an patch from Petr Kozelka for unlink and replace 
+	  support of attribute nodes
+
+Tue Jan 22 19:12:06 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* doc/libxml2-api.xml doc/parsedecl.py: Build a new version
+	  hopefully near complete and fully documented of the API in XML
+	* HTMLtree.c SAX.c debugXML.c error.c globals.c parser.c tree.c
+	 xmlIO.c xmlmemory.c include/libxml/catalog.h include/libxml/hash.h
+	 include/libxml/list.h include/libxml/parser.h include/libxml/tree.h
+	 include/libxml/parserInternals.h include/libxml/valid.hi
+	 include/libxml/xmlIO.h include/libxml/xmlerror.hi
+	 include/libxml/xmlmemory.h include/libxml/xmlversion.h.ini
+	 include/libxml/xpath.h include/libxml/xpathInternals.h:
+	  Cleaned up the doc comments a lot in the process, the interface
+	  coverage is now 100%
+
+Tue Jan 22 00:12:58 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* doc/libxml2-api.xml doc/parsedecl.py: improved the script to
+	  extracts comments from the gtk-doc DocBook output (a bit
+	  convoluted but seems to work).
+
+Mon Jan 21 18:29:19 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am doc/Makefile.am doc/libxml2-api.xml doc/parsedecl.py:
+	  added an XML description of the API, moved the script generating
+	  it here. Added a "make api" target
+
+Mon Jan 21 14:34:37 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: Adam Lounds pointed out a bug in xmlSearchNs()
+	  
+Mon Jan 21 09:55:21 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c include/libxml/xpathInternals.h: the change made to
+	  xmlXPathFuncLookupFunc was incompatible roll it back
+
+Sun Jan 20 23:03:41 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* SAX.c: cleanup patch from Anthony Jones
+	* doc/Makefile.am: fix the headers to avoid in make scan
+	* parserInternals.c xpath.c include/libxml/*.h: cleanup of the
+	  includes, * vs Ptr and general cleanup
+	* parsedecl.py: first version of a script to extract the
+	  module interfaces, the goal will be to provide .decl or XML
+	  specification of the interfaces to build wrappers.
+
+Sun Jan 20 13:38:22 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* doc/xmlcatalog_man.xml xmlcatalog.c: Fixed bug #68830, xmlcatalog
+	  now provides return codes in case of errors
+
+Sat Jan 19 16:36:21 CET 2002 Bjorn Reese <breese@users.sourceforge.net>
+
+	* trio.h trio.c triodef.h triop.h trionan.h trionan.c Makefile.am:
+	  Upgraded to trio baseline 1.6
+	* strio.h strio.c: Replaced by triostr.h and triostr.c
+
+Fri Jan 18 17:22:50 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* globals.c xmlIO.c xmlcatalog.c: removed the last occurences
+	  of strdup usage in the code
+
+Fri Jan 18 12:47:15 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c error.c: Keith Isdale complained rightly that 
+	  xmlInitParser() did not preserve value set by xmlSetGenericErrorFunc
+
+Thu Jan 17 09:44:44 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: fixed the funxtion to set the xml: attributes
+	* debugXML.c: added "setbase" to test it.
+
+Wed Jan 16 16:36:08 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: update xmlNodeSetContent() and xmlNodeSetContentLen()
+	  to allow updating an attribute content
+
+Tue Jan 15 18:09:23 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* libxml.h: try to avoid problems when compiling on Windows
+
+Mon Jan 14 18:56:25 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* hash.c: patch from Anthony Jones for hash.c allocation size
+	* Makefile.am: trying to work around Yet Another Libtool Madness
+	  and build the 2.4.13 release finally ...
+
+Mon Jan 14 18:27:19 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in include/libxml/xmlwin32version.h: updated to 2.4.13
+	* doc/* : update of the documentation
+
+Mon Jan 14 17:53:41 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* debugXML.c tree.c: some cleanup after an unsuccessful attempt
+	  at fixing #61290 :-(
+
+Sun Jan 13 21:30:54 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: fixed xmlSaveFormatFileEnc() when encoding == NULL
+	  Fixes bug #67229
+
+Sun Jan 13 17:14:06 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: trying to avoid troubles when a subtree is copied
+	  and coalesced in part with the target tree. Should fix 
+	  bug #67407
+
+Sun Jan 13 16:37:15 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* valid.c: fixed validation of attributes content of type
+	  NAME NAMES NMTOKEN and NMTOKENS to accept internationalized
+	  values, very old bug. Fixes #67671
+
+Sun Jan 13 15:07:49 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c include/libxml/parserInternals.h tree.c: integrated
+	  a couple of fixes and a new API function xmlSetEntityReferenceFunc()
+	  from Keith Isdale and dedicated to xsldbg the XSLT debugger.
+
+Sun Jan 13 14:23:21 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* threads.c: applied Serguei Narojnyi's patch to add native
+	  thread support on the Win32 platform
+	* testThreadsWin32.c Makefile.am: added the test program also
+	  from Serguei, Win32 specific
+	* include/win32config.h include/libxml/xmlwin32version.h.in:
+	  added patch from Igor for the Windows thread specific defines.
+
+Wed Jan  9 12:50:39 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* entities.c: Anthony Jones pointed a bug in xmlCopyEntity()
+
+Tue Jan  8 14:23:22 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* doc/*.html doc/site.xsl doc/Makefile: renamed XML.html
+	  output page into XMLinfo.html. Close bug #66951 and
+	  raised by Robert Collins too.
+
+Tue Jan  8 14:13:18 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* encoding.c: Paul Keogh pointed out a possibility of segfault
+	  on repeted xmlAddEncodingAlias() / xmlCleanupEncodingAlias().
+	  Closes bug # 68238
+
+Tue Jan  8 12:48:27 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* doc/*.html: updated the Gdome2 links
+
+Tue Jan  8 11:32:30 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* libxml.h: Applied following patches from Robert Collins
+	  and make sure IN_LIBXML is defined when compiling it
+	-------
+	* include/libxml/xmlversion.h.in (LIBXML_DLL_IMPORT): Use on Cygwin
+	  as well as Visual C.
+	* parser.c (XML_DIR_SEP): Don't use '\\' for Cygwin.
+	* parserInternals.c (XML_DIR_SEP): Don't use '\\' for Cygwin.
+	* strio.c (PLATFORM_UNIX): Define for Cygwin.
+	* triodef.h (TRIO_PLATFORM_UNIX): Define for Cygwin.
+	* xmlIO.c (xmlFileOpen): Use unix behaviour for Cygwin.
+	  Use binary mode opens for Cygwin (xmlFileOpenW xmlParserGetDirectory
+	  xmlSysIDExists xmlNoNetExists).
+	* xmllint.c: Don't include winsock2.h for Cygwin.
+
+Mon Jan  7 17:52:48 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: Jirka Kosek pointer out a bug in xmlParseTextDecl()
+	  when the version info is not present.
+
+Mon Jan  7 00:03:58 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: Anthony Jones  pointed out a problem in
+	  xmlStringGetNodeList() and provided a fix for it
+
+Sun Jan  6 13:45:49 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: patch from Frank J Franklin to remove a bug in
+	  xmlCreatePushParserCtxt() when the initial buffer passed
+	  is large.
+
+Sat Jan  5 19:24:23 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* win32/*: big cleanup of the Windows/MSVC project files
+	  from Igor Zlatkovic
+
+Wed Jan  2 14:11:35 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* doc/Makefile.am: should fix #67674 and avoid troubles if 
+	  xsltproc is not available or fails in the prefix provided
+
+Tue Jan  1 17:48:56 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlmemory.c: one more doc patch from Charlie Bozeman.
+
+Mon Dec 31 17:35:40 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* DOCBparser.c parser.c valid.c include/libxml/parserInternals.h
+	  include/libxml/xmlerror.h include/libxml/xpathInternals.h:
+	  Fixed a few other problems raised by Charlie Bozeman.
+	* result/VC/ElementValid[5-7]: fixed the output
+
+Mon Dec 31 17:13:34 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* *.c include/libxml/*.h doc/html/*: applied 42 documentation
+	  patches from Charlie Bozeman. Regenerated the HTML docs.
+
+Thu Dec 20 14:59:52 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/debugXML.h win32/dsp/libxml2.def.src: fixes
+	  for Windows from Igor
+
+Tue Dec 18 12:13:33 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* xmllint.c: applied Justin Fletcher patch for --output or -o
+
+Tue Dec 18 08:52:32 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* win32/libxml2/libxml2.def.src: close #67019
+
+Tue Dec 18 08:08:51 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* xmllint.c: applied Justin Fletcher generic timing patch
+	  similar to the one already applied to xsltproc.
+
+Mon Dec 17 16:29:08 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/tree.h tree.c: applied documentation patches
+	  from Charlie Bozeman
+
+Thu Dec 13 21:24:16 MST 2001 John Fleck <jfleck@inkstain.net>
+
+	*doc/xmllint.xml, xmllint.1 - document --dropdtd
+	
+Thu Dec 13 23:19:50 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* valid.c: fix the xmlStrdup() used in the previous patch.
+	* valid.c: added --dropdtd
+	* tree.c: fixed xmlUnlinkNode so it also removes the references
+	  from the document if the node is a DTD
+
+Thu Dec 13 15:54:35 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLtree.c valid.c: cleanup some static declarations
+
+Thu Dec 13 15:23:04 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* xmllint.c: removed another strdup()
+	* doc/FAQ: removed the HP/UX entry
+
+Thu Dec 13 09:44:58 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* valid.c: fix bug #66816 when validating.
+	* xmllint.c: don't use sys/time.h if configure did not found it
+
+Mon Dec 10 21:39:55 MST 2001 John Fleck <jfleck@inkstain.net>
+
+	* docs/xmllint.1, xmllint.xml, xmlcatalog.1, xmlcatalog_man.html,
+	xmlcatalog_man.xml
+
+Mon Dec 10 22:06:16 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/xmlmemory.h: Hietaniemi Jarkko pointed out that
+	  xmlInitMemory() was declared twice
+
+Sun Dec  9 14:59:23 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* globals.c: do not reference strdup() !
+	* configure.in libxml-2.0.pc.in: trying to fix the libs
+	  of the various config extraction modules
+
+Fri Dec  7 15:21:33 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in : preparing 2.4.12
+	* doc/* : updated and rebuilt the docs
+
+Fri Dec  7 12:32:00 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* uri.c: closed bug #66159
+	* testURI.c: added --escape option
+	* configure.in: some cleanup for xml2-config --cflags
+
+Thu Dec  6 15:31:30 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* globals.c testThreads.c: removed some misplaced includes
+	  of xmlversion.h
+
+Thu Dec  6 09:06:08 EST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* threads.c: patch from Gary Pennington fixing a possible
+	  problem at initialization time.
+
+Wed Dec  5 13:01:37 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in libxml.h parser.c testThreads.c macos/: integrated
+	  Eric Lavigne contribution to build libxml2 on MacOS using
+	  CodeWarrior.
+
+Tue Dec  4 14:13:44 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* xmllint.c: applied Geert Kloosterman's patch to fix
+	  --repeat --timing output
+
+Thu Nov 29 17:10:22 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: Robin Berjon <robin@knowscape.com> found a case
+	  where non-wellformed XML declaractions were not detected.
+
+Wed Nov 28 15:41:40 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* xpointer.c: fixed a compilation bug pointed by Danny Jamshy
+
+Wed Nov 28 10:09:51 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* xmlIO.c: as robert pointed again, xmlInputCallbackInitialized
+	  gets reset by xmlCleanupInputCallbacks() and this makes the
+	  function useless. Same for output.
+
+Tue Nov 27 17:22:36 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* xmlIO.c: robert pointed out a loop error in callback cleanups
+
+Mon Nov 26 16:56:00 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c debugXML.c include/libxml/tree.h include/libxml/debugXML.h:
+	  moved xmlGetLineNo() and xmlGetNodePath() into the main tree module,
+	  they are not really tied to debugging
+
+Mon Nov 26 11:31:36 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in include/libxml/xmlwin32version.h: preparing 2.4.11
+	* xmllint.c: better --catalogs description
+
+Sun Nov 25 11:34:24 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: fixed a couple of problems in xmlSetProp()
+
+Thu Nov 22 19:19:10 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* debugXML.c tree.c xmlIO.c xmlmemory.c: some cleanups when chasing
+	  unappropriate stdout output.
+
+Thu Nov 22 13:58:14 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/tree.h: Fixed a couple of macro errors pointed out
+	  by Denis Beurive, closes #65111
+
+Tue Nov 20 10:34:01 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* valid.c: in case of content model validity error, don't
+	  print it if validity warnings were not requested.
+
+Tue Nov 20 09:30:02 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* nanoftp.c: applied a couple of patches from Brian D Ripley.
+	* parserInternals.c: removed the last exit() call. Print an
+	  unmaskable error on stderr instead (library mismatch detection)
+
+Sat Nov 17 17:16:51 MST 2001 John Fleck <jfleck@inkstain.net>
+
+	* doc/xmllint.xml, doc/xmllint.1 - update xmllint man page with
+	shell instructions from Heiko Rupp
+
+Thu Nov 15 14:53:42 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* catalog.c: use the URL notation file:// for default catalog paths
+
+Wed Nov 14 16:03:02 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/tree.h: better comments for _private fields
+	* tree.c: removed a problem when copying an entity reference.
+
+Tue Nov 13 16:23:04 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* vms/*: updated instructions and diffs from John A Fotheringham
+
+Mon Nov 12 23:43:22 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/xmlerror.h: avoid an include problem if
+	  #include <libxml/xmlerror.h> happens first in code
+	  seems to be the case in KDE libs
+
+Mon Nov 12 22:32:41 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* win32/dsp/* include/libxml/xmlwin32version.h.in: update
+	  from Igor for Windows
+
+Mon Nov 12 10:19:41 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am: Gary Pennington pointed out a missing prefix
+
+Sat Nov 10 12:55:42 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in include/libxml/xmlwin32version.h: preparing 2.4.10
+	* doc/*: upgraded and rebuilt the docs
+
+Sat Nov 10 12:33:38 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLparser.c: fix comment in scripts element parsing.
+	* result/HTML/doc3*: updated the results.
+
+Sat Nov 10 11:18:18 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* uri.c: another URI bug fix #63336, using Joel Young patch.
+
+Sat Nov 10 11:07:26 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* debugXML.c include/libxml/debugXML.h: add xmlGetNodePath()
+	  a cleaned up version of the Pwd shell string generation.
+
+Fri Nov  9 00:34:13 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* valid.c include/libxml/tree.h: trying to fix namespaces +
+	  validation problems for good, closing #63619 in the process
+	* result/valid/dia.xml test/valid/dia.xml: the Dia test was
+	  wrong in this respect, fixed it.
+
+Thu Nov  8 18:31:40 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* xmllint.c: Morus Walter patch to allow --format and --encode
+
+Thu Nov  8 14:52:18 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* debugXML.c: Stefan Kost provided an help command for the shell
+
+Wed Nov  7 14:32:55 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* debugXML.c: Heiko Rupp pointed that the shell would crash
+	  on empty nodesets returns.
+
+Wed Nov  7 13:52:36 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am: Weiqi Gao pointed out that xmlcatalog
+	  migh need the history libraries
+
+Tue Nov  6 23:49:09 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLparser.c test/HTML/lt.html result/HTML/lt.html*:
+	  handle the case of < in quoted attributes, Bastian Kleineidam
+
+Tue Nov  6 16:21:33 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in include/libxml/xmlwin32version.h: releasing 2.4.9
+	  fixing catalog breakages
+	* Makefile.am catalog.c result/catalogs/catal 
+	  result/catalogs/mycatalog.* test/catalogs/catal*:
+	  fixed more problems in catalog support, added more regression tests
+	  for both XML and SGML catalog handling
+
+Mon Nov  5 20:26:41 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* debugXML.c: applied an improvement to xmlGetLineNo() from
+	  Keith Isdale
+
+Mon Nov  5 15:20:16 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* catalog.c: dohhhh XML catalog add and remove ops were broken too.
+	  Side effect of the progressive catalog loading
+
+Mon Nov  5 12:40:54 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am: confexecdir and confexec_DATA were defined twice
+	  pointed out by Karl Eichwalder
+	  
+Sun Nov  4 23:18:34 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* xmlcatalog.c: avoid unlink() and use remove() instead.
+
+Sun Nov  4 23:12:38 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* libxml.spec.in: cleanup
+	* include/libxml/xmlwin32version.h: updated with 2.4.8
+
+Sun Nov  4 21:17:24 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* encoding.c global.data globals.c testThreads.c: fix bug #63752
+	  of compiling libxml with a non standard set of options
+
+Sun Nov  4 13:11:41 MST 2001 John Fleck <jfleck@inkstain.net
+
+	* doc/xmllint.xml, xmllint.1 - updating xmllint man page to
+	document --sgml option, fixing gnome bugzilla #63382
+
+Sun Nov  4 20:56:53 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/catalog.h catalog.c: Fixed SGML catalogs
+	  breakage of 2.4.7, added a couple of really needed APIs
+	  like xmlCatalogIsEmpty() and xmlNewCatalog()
+	* xmlcatalog.c: updated --sgml --noout to be a suitable replacement
+	  for install-catalog
+	* configure.in: preparing 2.4.8
+
+Thu Nov  1 15:29:31 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLtree.c tree.c include/libxml/HTMLtree.h
+	  include/libxml/tree.h include/libxml/xmlIO.h: more include
+	  cleanups, export cleanly one html output + format function.
+
+Thu Nov  1 14:12:12 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: removed initGenericErrorDefaultFunc call from
+	  xmlInitParser() since it could destroy previous calls to
+	  xsltSetGenericErrorFunc() effects
+
+Thu Nov  1 09:37:13 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* debugXML.c include/libxml/debugXML.h: bool can be a reserved
+	  keyword.
+
+Wed Oct 31 18:50:08 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am: cleanup
+	* threads.c: cleanup too
+	* xmlIO.c include/libxml/xmlIO.h: added xmlNoNetExternalEntityLoader()
+	  from xsltproc
+	* include/libxml/tree.h include/libxml/parser.h: trying to break a
+	  dependency loop.
+
+Tue Oct 30 18:38:53 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* catalog.c: Justin Fletcher pointed out that xmlParseXMLCatalog
+	  was not used anymore !
+
+Tue Oct 30 13:33:13 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in: preparing 2.4.7
+	* Makefile.am doc/Makefile.am: switched to the latest xmllint
+	  manual page from John
+	* doc/*: updated the doc and rebuilt the generated pages
+
+Tue Oct 30 11:31:19 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* xmlIO.c: closing bug #62711, the library should never
+	  close stdin or stdout.
+
+Tue Oct 30 10:46:12 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* uri.c: second pass at fixing #63336, using Joel Young
+	  final patch. looks okay.
+
+Tue Oct 30 00:56:05 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* uri.c include/libxml/uri.h: trying to clear #63336
+	  allowing the escaping routine to parse unconformant
+	  URI-References.
+
+Mon Oct 29 19:09:46 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* vms/readme.vms vms/build_libxml.com nanoftp.c 
+	  include/libxml/xmlversion.h.in: a few VMS updates from
+	  John A Fotheringham
+	* include/libxml/xmlIO.h xmlIO.c: added xmlCleanupInputCallbacks()
+	  and xmlCleanupOutputCallbacks() for the Perl binding people.
+
+Mon Oct 29 12:44:17 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c globals.c DOCBparser.c HTMLparser.c error.c:
+	  apply fixes to close #63271 and avoid segfaults when
+	  the error routine gets callbed before xmlInitParser()
+	  get called.
+	* nanoftp.c error.c: Applied patches from Justin Fletcher
+	  correcting some xmlGenericError misuses.
+
+Sat Oct 27 14:04:45 MDT 2001 John Fleck <jfleck@inkstain.net>
+
+	*doc/xmllint.xml, doc/xmllint.1
+	New and improved man page for xmllint - .xml is the original, .1
+	is the generated man page
+
+Wed Oct 24 14:34:25 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* doc/site.xsl doc/*.html doc/Makefile.am: now autogenerate
+	  the web site from the main HTML document.
+
+Tue Oct 23 14:32:04 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: fixed an erroneous validation bug when PE refs
+	  occurs in external parsed entities referenced from the
+	  internals subset
+	* test/valid/index.xml test/valid/dtds/nitf-2-5.dtd
+	  test/valid/dtds/NewsMLv1.0.dtd result/valid/index.xml*:
+	  added the associated testcase, it's a nice one.
+	* HTMLparser.c: generate the DTD node as HTML still ...
+	* HTMLtree.c: fixed errors in Set/GetMetaEncoding 
+
+Mon Oct 22 14:20:17 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLparser.c: fixed a bug in htmlNewDoc()
+
+Mon Oct 22 11:32:36 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* test/threads/*: added entities testing to the Thread test
+	* testThreads.c: make the test reasonable
+	* DOCBparser.c: fix the DTD public and system ID
+	* xmllint.c: added --sgml for SGML DocBook importing
+	* Makefile.am: added Docbtests target
+
+Fri Oct 19 11:47:13 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* nanoftp.c: use only "anonymous@" string for anonymous passwds
+	* testThreads.c: removed bogus include
+
+Thu Oct 18 16:56:23 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c valid.c result/valid/rss.xml result/valid/rss.xml.err:
+	  fixed a very serious (looping) validation bug
+
+Wed Oct 17 11:56:25 EDT 2001 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/globals.h include/libxml/threads.h threads.c
+	  testThreads.c: far more testing, cleaning up bugs
+	* *.c : make sure globals.h is always included.
+
+Wed Oct 17 17:41:41 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLparser.c: try to get rid of parser loops for good.
+
+Wed Oct 17 13:29:02 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in: fixed some bugs in CFLAGS passing.
+	* test/threads Makefile.am testThreads.c: added a specific
+	  threaded test case (really nasty, guaranteed).
+
+Tue Oct 16 23:01:49 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* catalog.c: serious cleanup on the management of the
+	  XML catalog tree, more tests done, especially with
+	  the catalog PI.
+
+Tue Oct 16 08:43:43 EDT 2001 Daniel Veillard <daniel@veillard.com>
+
+	* catalog.c: avoid a problem in catalog cleanup on SMP if
+	  catalogs were not initialized.
+
+Tue Oct 16 14:33:19 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* catalog.c xpath.c: trying to cleanup the not thread safe
+	  parts of the library.
+
+Mon Oct 15 14:30:11 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/globals.h configure.in global.data: make
+	  the allocation be per-thread a configure option
+	* encoding.c include/libxml/parser.h: fixed compilation
+	  errors
+
+Mon Oct 15 12:45:03 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/parser.h: Norm reported that a few lines
+	  added were breaking libxslt compile, removed them for now
+
+Sun Oct 14 05:55:01 EDT 2001 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c parserInternals.c threads.c: debugged and fixed
+	  initialization problems which were giving troubles on SMP
+	  boxes.
+
+Sat Oct 13 16:17:13 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/Makefile.am: missing globals.h
+
+Sat Oct 13 14:15:00 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* globals.c: added a couple of standard includes.
+
+Sat Oct 13 11:08:20 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/SAX.h include/libxml/globals.h include/libxml/parser.h
+	  include/libxml/parserInternals.h include/libxml/tree.h
+	  include/libxml/xmlerror.h HTMLparser.c SAX.c error.c globals.c
+	  nanoftp.c nanohttp.c parser.c parserInternals.c testDocbook.c
+	  testHTML.c testSAX.c tree.c uri.c xlink.c xmlmemory.c:
+	  Applied the last patches from Gary, cleanup, activated threading
+	  all user accessible global variables are now handled in globals.[ch]
+	  Still a bit rought but make tests passes with either 
+	  --with-threads defined at configure time or not.
+	* Makefile.am example/Makefile.am: added globals.[ch] and threads
+	  linking options
+
+Fri Oct 12 19:25:55 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am include/libxml/Makefile.am
+	  include/libxml/globals.h globals.c  include/libxml/threads.h
+	  threads.c build_glob.py global.data xmlcatalog.c acconfig.h
+	  configure.in: started integrating the core of the thread support
+	  not activated yet but half integrated. The code should still
+	  compile and work anyway.
+
+Fri Oct 12 00:53:03 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLtree.c catalog.c debugXML.c entities.c nanoftp.c
+	  parser.c valid.c xmlmemory.c xpath.c xpointer.c: started
+	  integrating the non-controversial parts of Gary Pennington
+	  multithread patches
+	* catalog.c: corrected a small bug introduced
+
+Thu Oct 11 20:58:15 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* catalog.c include/libxml/catalog.h: very serious cleanup,
+	  isolating unportable code and as much as possible the accesses
+	  to the global shared catalog. May need more testing !
+
+Thu Oct 11 11:10:31 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/debugXML.h debugXML.c tree.c: integrating
+	  Keith Isdale patches for the XSLT debugger interfaces. Some
+	  cleanup
+
+Thu Oct 11 08:44:01 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* win32/Makefile.mingw: update from Tobias Peters for 2.4.5
+	* DOCBparser.c: generate line nubers in elements
+
+Wed Oct 10 11:35:45 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in: preparing 2.4.6 release
+	* doc/xml.html doc/html/*: updated and rebuilt the docs
+	* include/libxml/*.h *.c: fixed a number of teh/the widht/width typos
+
+Mon Oct  8 20:38:27 MDT 2001 John Fleck <jfleck@inkstain.net>
+
+	* doc/xmlcatalog_man.xml, xmlcatalog.1, xmlcatalog_man.html
+	adding documentation for DV's supercatalog support
+
+Mon Oct  8 17:00:16 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/catalog.h catalog.c xmlcatalog.c: adding SGML
+	  super catalog support adding one API and one flag --sgml to
+	  xmlcatalog
+
+Sun Oct  7 16:43:57 MDT 2001 John Fleck <jfleck@inkstain.net>
+
+	* doc/xmlcatalog_man.xml, xmlcatalog.1
+	One more crack at
+	https://bugzilla.redhat.com/bugzilla/show_bug.cgi?id=54392 
+	
+
+Sun Oct  7 18:47:02 CEST 2001 Thomas Broyer <tbroyer@ltgt.net>
+
+	* xpath.c: implemented xmlXPathObjectCopy for external objects
+	* include/libxml/xpathInternals.h: added xmlXPathStackIsExternal
+
+Sat Oct  6 16:25:52 MDT 2001 John Fleck <jfleck@inkstain.net>
+
+	*doc/xmlcatalog_man.xml, xmlcatalog_man.html, xmlcatalog.1
+	finishing up fix to
+	https://bugzilla.redhat.com/bugzilla/show_bug.cgi?id=54392, making
+	the xmlcatalog man page display more elegantly
+
+Sat Oct  6 15:27:12 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in: closing bug #61832
+	* HTMLparser.c: removed a warning
+
+Sat Oct  6 15:07:14 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: fixing #61673 part I, do not loose doc information
+	  when copying result value trees.
+
+Sat Oct  6 11:58:58 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: trying to harden the XPath interpreter
+
+Fri Oct  5 20:37:51 MDT 2001 John Fleck <jfleck@inkstain.net>
+
+	* doc/xmlcatalog.1 updated using a new stylesheet to address, in
+	part, https://bugzilla.redhat.com/bugzilla/show_bug.cgi?id=54392
+
+Fri Oct  5 23:35:00 HKT 2001 William Brack <wbrack@mmm.com.hk>
+
+	* HTMLparser: repaired another loop problem
+
+Fri Oct  5 11:16:21 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* uri.c: applied fix from Mathias Hasselmann about a bug in URI
+	  parsing.
+	* xpath.c: fix bug #61291 the default XML namespace node is
+	  missing from the namespace axis.
+	* tree.c: refuse to create namespaces nodes with prefix "xml"
+
+Thu Oct  4 16:47:44 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* SAX.c: ouch a non-defined namespace could lead to a crash,
+	  fixed #61215
+
+Thu Oct  4 16:24:26 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* parserInternals.c: closed bug #61054
+
+Wed Oct  3 15:19:04 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/Makefile.am: closing #60708
+
+Tue Oct  2 15:52:05 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* win32/dsp/libxml2.def.src include/libxml/parser.h parser.c:
+	  adding xmlSAXParseFileWithData following Marco Stipek suggestion
+
+Tue Oct  2 11:27:58 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* valid.c: close bug #61550 when xml: wasn't considered a namespace
+
+Tue Oct  2 11:18:32 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* win32/dsp/libxml2.def.src: Igor Zlatkovic patches
+	* DOCBparser.c HTMLparser.c parser.c: fixed typos
+
+Mon Oct  1 09:34:51 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* catalog.c: Justin Fletcher provided cleaup code in case
+	  HAVE_STAT is not defined
+	* include/win32config.h: Igor Zlatkovic suggested to have
+	  HAVE_STAT defined there
+
+Sat Sep 29 00:15:00 HKT 2001 William Brack <wbrack@mmm.com.hk>
+
+	* catalog.c - fixed typing error reported by M. Barros
+
+Sun Sep 23 21:02:39 MDT 2001 John Fleck <jfleck@inkstain.net>
+
+	* xmllint.c - fixing typo
+
+Sat Sep 22 10:00:00 HKT 2001 William Brack <wbrack@mmm.com.hk>
+
+	* HTMLparser.c: small enhancement to prevent loop on
+	  unrecognizable data
+
+Fri Sep 21 11:45:53 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* parserInternals.c: applying patch from bug #60757 this
+	  should close it
+
+Thu Sep 20 15:54:29 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* catalog.c xmlcatalog.c: removed a couple of warning
+	* xpath.c: try to solve the linking problem on platforms
+	  needing trio to compile
+
+Wed Sep 19 10:01:37 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am libxml.spec.in: backing up non-documented changes
+	  commited without review or aproval by Jens Finke <jens@gnome.org>
+	* HACKING: made 100% clear that no commit should be done directly
+
+Mon Sep 17 18:52:37 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in: Joe Orton provided a patch fixing a problem
+	  when iconv is specified to be in a non-standard directory
+	  but wasn't exported in xml2-config --cflags
+
+Fri Sep 14 19:32:43 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in: let's ship 2.4.5 before getting too much
+	  troubles with 2.4.4 errors.
+
+Fri Sep 14 12:26:58 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* encoding.c entities.c: do not output hexadecimal charrefs
+	  when serializing HTML since some version of Netscape can't
+	  grok it, generate decimal ones.
+	* result/HTML/doc3.htm: output changed due to previous test
+	* parserInternals.c: repair xmlKeepBlanksDefault() broken in 2.4.4
+
+Thu Sep 13 13:34:27 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* libxml-2.0.pc.in: dohh generated the wrong include path :-(
+	* doc/Makefile.am libxml.spec.in: re-dohh forgot the new manpage :-(
+
+Wed Sep 12 22:14:55 CEST 2001 Daniel Veillard <daniel@veillard.com>
+        Released 2.4.4
+
+	* config.h.in configure.in libxml.spec.in include/libxml/Makefile.am
+	  libxml-2.0.pc.in: moved includes to includedir/libxml2/libxml,
+	  updated the configuration scripts systems accordingly
+
+Wed Sep 12 20:49:32 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in: preparing for 2.4.4
+	* doc/xml.html doc/html/*: updated and rebuilt the docs
+
+Wed Sep 12 16:58:16 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* win32/dsp/libxml2.def.src: tried to incorporate comments
+	  from bug #59220
+
+Tue Sep 11 11:25:36 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c result/noent/wml.xml: fixed bug #59981 related
+	  to handling of '&' in attributes when entities are substitued
+
+Mon Sep 10 22:14:42 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* libxml.h include/libxml/xmlversion.h.in
+	  include/libxml/xmlwin32version.h include/libxml/xmlwin32version.h.in:
+	  Tried to close bug #60131
+
+Mon Sep 10 20:46:03 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* SAX.c: fixed a bug in the HTML parser introduced Sep  9
+
+Mon Sep 10 20:13:09 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* SAX.c: fixing bug #59946 on xmlns=""
+
+Mon Sep 10 16:39:42 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/xmlerror.h SAX.c: fixing bug 59732, simple
+	  but allocates a new error code.
+
+Sun Sep  9 10:33:15 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* xmllint.c: John Fleck fixed typos in the options output
+	* parser.c SAX.c: fix ignorable white space SAX selection
+
+Sat Sep  8 11:43:53 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* entities.c: Steve Underwood found the possibility of an
+	  ininite loop in case of error.
+
+Fri Sep  7 11:35:00 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am: Need $(ICONV_LIBS) in libxml2_la_LIBADD
+
+Wed Sep  5 17:47:43 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: warn if version is not 1.0 but it's not
+	  strictly speaking an error after analyzing the spec
+
+Mon Sep  3 10:07:03 MDT 2001 John Fleck <jfleck@inkstain.net>
+
+	*doc/catalog.html - add link to the html version of the
+	man page, other linguistic cleanups
+
+Mon Sep  3 09:10:08 MDT 2001 John Fleck <jfleck@inkstain.net>
+
+	* doc/xmlcatalog_man.xml, xmlcatalog_man.html, xmlcatalog.1
+	adding documentation for xmlcatalog. Note: xmlcatalog.1, the man
+	file, has not yet been included in the build.
+
+Sat Sep  1 18:17:47 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* catalog.c: removed a duplicate affectation Justin Fletcher
+
+Fri Aug 31 22:02:10 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: Armin Sander pointed a possible text coalescing 
+	  problem, completed his patch.
+
+Fri Aug 31 18:30:28 CEST 2001 Bjorn Reese <breese@users.sourceforge.net>
+
+	* trionan.c: Fixed const and volatile re-definition problem
+	
+Fri Aug 31 16:51:28 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* libxml.4 parser.c: doc updates from Heiko Rupp
+	* parserInternals.c: 2 sanity checks from Heiko Rupp
+
+Tue Aug 28 22:38:45 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: applied patch from Armin Sander to make some pointers
+	  const in xmlCopyNode()
+	* include/libxml/tree.h: added fix to the header
+
+Mon Aug 27 16:24:47 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: hum, restrict the integer usage gcc bug workaround
+	  to only gcc compilers so that other architecture don't get
+	  penalized by this limitation.
+	* include/libxml/xpath.h: small typo fix from Heiko W. Rupp
+
+Sun Aug 26 20:45:04 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* valid.c: fixed a Windows compiler warning (Chris Poblete)
+	* xpath.c: fix for mod when dividend is 0 (Chris Poblete)
+
+Sat Aug 25 15:30:17 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/catalog.h catalog.c xmlcatalog.c: added a 
+	  --convert option to xmlcatalog to convert SGML ones to
+	  the XML syntax.
+	* xmllint.c: small cleanup for $SGML_CATALOG_FILES support.
+
+        2.4.3 got released at that point
+Thu Aug 23 23:16:32 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* catalog.c xmlIO.c: started some serious testing and fixed
+	  a few bug and optmization needs.
+
+Thu Aug 23 17:26:58 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am configure.in include/libxml/xmlwin32version.h:
+	  preparing for a 2.4.3 release even if it may not be ready yet
+	* catalog.c parser.c xmlIO.c include/libxml/catalog.h: redirected
+	  all file parsing lookup to go through the entity resolver, add
+	  to add an API to bypass it (needed to load catalogs themselves),
+	  some cleanup on the catalog code too.
+	* nanoftp.c: small cleanup
+	* doc/catalog.html: small update
+
+Thu Aug 23 12:22:26 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* catalog.c: fixed bugi #59406 in SGML catalog parsing reported by
+	  Jun Kuriyama
+	  
+Thu Aug 23 02:51:29 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* doc/catalog.html: finished the catalog documentation
+
+Thu Aug 23 01:38:42 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* doc/catalog.html doc/xml.html: added documentation about
+	  Catalog support, misses an API description 
+	* doc/html/*: reextracted the API pages
+
+Wed Aug 22 18:27:47 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/catalog.h catalog.c xmlIO.c HTMLparser.c:
+	  Added the part about section 7.2 on URI resolution,
+	  fixed a side effect in the HTML parser, look complete
+	  and ready to rock except the URI/SystemID part!
+
+Wed Aug 22 16:27:03 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/catalog.h include/libxml/parser.h
+	  include/libxml/xmlerror.h catalog.c parser.c parserInternals.c
+	  xmlIO.c: added support and APIs needed for the catalog PI
+	* include/libxml/xmlIO.h: cleanup
+
+Wed Aug 22 02:03:31 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* catalog.c parser.c xmlIO.c xmlcatalog.c xmllint.c 
+	  include/libxml/catalog.h: starts to look okay, really
+	  plugged the new framework, cleaned a lot of stuff,
+	  added some APIs, except the PI's support missing this
+	  should be mostly complete
+	* result/catalogs/* test/catalogs/*: added new test, enriched
+	  the existing one with URN ID tests
+
+Tue Aug 21 14:56:18 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* catalog.c: fixed nextCatalog
+	* result/catalogs/docbook test/catalogs/*: started adding
+	  a small regression test
+
+Tue Aug 21 12:52:38 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am catalog.c xmlcatalog.c include/libxml/catalog.h:
+	  more work on the XML catalog support.
+	* parser.c include/libxml/parser.h: small cleanup seems using
+	  list as a public parameter name can give portability troubles
+	* trionan.c trionan.h xpath.c include/libxml/trionan.h
+	  include/libxml/xpath.h include/libxml/Makefile.am: removed
+	  trionan from the libxml API, added xmlXPathIsInf and xmlXPathIsNaN
+	  wrappers
+
+Tue Aug 21 11:18:45 CEST 2001 Bjorn Reese <breese@users.sourceforge.net>
+
+	* Makefile.am trio.c triodef.h trionan.c xpath.c
+	  include/libxml/Makefile.am include/libxml/trionan.h:
+	  Re-worked Not-A-Number and Infinity support.
+	* xmlcatalog.c: added readline include files
+
+Mon Aug 20 02:04:13 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am xmlcatalog.c libxml.spec.in: renaming 
+	  testCatalog as xmlcatalog, making it an installed app
+	  adding a shell, and preparing it to be a /etc/xml/catalog
+	  management tool, though not ready yet
+	* catalog.c include/libxml/catalog.h: adding support for
+	  XML Catalogs http://www.oasis-open.org/committees/entity/
+	  not finished, there is some interesting tradeoffs and a
+	  few open questions left.
+
+Sun Aug 19 14:59:56 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* xmllint.c: fixed a line formatting problem
+
+Fri Aug 17 11:35:31 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* SAX.c: removed a couple of unused variable (Albert Chin)
+
+Fri Aug 17 01:25:21 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLparser.c HTMLtree.c include/libxml/HTMLparser.h:
+	  trying to fix some troubles w.r.t. function returning
+	  const xxxPtr.
+
+Thu Aug 16 21:33:20 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* win32/dsp/libxml2.def.src: another set of symbols conditionally
+	  defined
+
+Thu Aug 16 21:31:14 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* xpointer.c: removed unused var
+
+Thu Aug 16 18:26:40 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* testXPath.c: another small cleanup closing bug #59110
+
+Thu Aug 16 17:59:18 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* win32/dsp/libxml2.def.src: small cleanup closing bug
+	  #59108
+
+Wed Aug 15 22:46:01 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* example/gjobread.c: add xmlCleanupParser() before leaving
+
+Wed Aug 15 14:57:08 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* config.h.in configure.in include/libxml/xmlwin32version.h:
+	  released 2.4.2
+
+Wed Aug 15 13:56:22 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/valid.h debugXML.c valid.c: deprecate
+	  the non-boundchecking Sprintf functions, add Snprintf
+	  this should close bug #57984
+
+Wed Aug 15 10:46:07 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* xmlIO.c: xmlOutputBufferCreateFilename() didn't unescaped
+	  URIs before doing the lookups (pointed by Mark Vakoc)
+
+Tue Aug 14 18:37:23 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: serious changes on Result Value Trees and NodeSets
+	  w.r.t. deallocation and collect operations. Probably not
+	  100% clean (merge of allocated trees smells like a problem).
+	  Seems sufficient to close #58943
+
+Tue Aug 14 16:12:00 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* xmllint.c: adding a --format option
+
+Tue Aug 14 14:16:24 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: count() was broken on Result Value Tree
+	* xmlIO.c: fixed file:/// accesses on _WIN32
+
+Mon Aug 13 13:22:53 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* libxml.m4: s/LIBXML_VERSION_NUMBER/LIBXML_VERSION/ seems the
+	  macro was renamed, this should close bug #58683
+
+Mon Aug 13 12:33:40 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* SAX.c: small fix fixing bug #58539 reported by coolo, in
+	  entity substitution mode text at the end of the entity might
+	  be added due to text coalescing.
+	* nanoftp.c parser.c: small cleanup
+
+Wed Aug  8 22:57:05 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+        * HACKING: added John Fleck right to commit in the doc subdir
+
+Tue Aug  7 03:05:58 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* SAX.c testXPath.c valid.c xmllint.c include/libxml/valid.h:
+	  allow to inherit attributes from the DTD directly in the
+	  tree, this is needed for XPath and can be a useful feature.
+	  Inherited namespaces are always provided at the tree level now
+	* test/defattr* result/defattr* result/noent/defattr*: added a couple
+	  of tests for this feature (XSLT being the prime user).
+
+Fri Aug  3 14:02:20 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* DOCBparser.c Makefile.am nanohttp.c parser.c testHTML.c
+	  testSAX.c xmlIO.c xmllint.c include/win32config.h
+	  include/libxml/xmlversion.h.in include/libxml/xmlwin32version.h
+	  include/libxml/xmlwin32version.h.in win32/README.MSDev
+	  win32/dsp/*: applied Win32 Facelift No.2 patches from 
+	  Igor Zlatkovic for Windows/MSC
+
+Wed Aug  1 23:21:06 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* SAX.c: unparsedEntityDecl() the URI computation of the
+	  entity wasn't done breaking XSLT unparsed-entity-uri()
+
+Wed Aug  1 17:44:57 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: fixed a bug when walking the descendants and
+	  the current node has no children
+	* debugXML.c: show up when a text node is supposed to not be escaped
+
+Wed Aug  1 01:33:35 CEST 2001 Thomas Broyer <tbroyer@ltgt.net>
+
+	* xpath.c: fixed a bug in xmlXPathNodeTrailingSorted (for now it
+	  worked like the set:leading() function)
+	* include/libxml/xpathInternals.h: added xmlXPathNodeSetContains
+
+Tue Jul 31 18:24:34 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* nanohttp.c: protected an use of EAGAIN, Brian Stafford
+
+Tue Jul 31 17:48:44 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* include/libxml/xmlIO.h: apply change to close #58141 
+	* win32/libxml2/*: update of the MSC projects from Igor  Zlatkovic
+
+Tue Jul 31 17:09:31 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* parser.c: when the internal subset uses a PE, then the
+	  included entity can use conditional sections.
+
+Mon Jul 30 12:58:39 EDT 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c include/libxml/xpath.h: fixed a serious memory problen
+	  when walking the namespace axis showing up in
+	  libxst/tests/general/bug-12
+	* xmlmemory.c: added the possibility to trace a given block
+	  defined by its address
+
+Sun Jul 29 07:18:53 EDT 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* parser.c: don't override existing encoding specified before
+	  starting xmlParseDocument()
+
+Sat Jul 28 13:33:10 EDT 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* include/libxml/xmlwin32version.h: reinserted, needed for
+	  Windows users of CVS
+
+2001-07-27  Darin Adler  <darin@bentspoon.com>
+
+	* encoding.c: (xmlIconvWrapper): Add cast to fix warning.
+	* testCatalog.c: Add include of <libxml/parser.h>.
+
+2001-07-27  Darin Adler  <darin@bentspoon.com>
+
+	* include/libxml/.cvsignore:
+	* include/libxml/xmlwin32version.h:
+	Remove this file from CVS because it's generated.
+
+Fri Jul 27 10:03:56 EDT 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* parser.c include/libxml/parser.h: applied const patches from
+	  Tom Moog #58002
+
+Thu Jul 26 18:55:52 CEST 2001 Thomas Broyer <tbroyer@ltgt.net>
+
+	* xpath.c include/libxml/xpath{,Internals}.h: added a function
+	  lookup framework
+
+Fri Jul 27 01:50:20 EDT 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* tree.c: fixed xmlCopyNode() for documents
+
+Thu Jul 26 12:40:35 EDT 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* parser.c: fixed bugs #58073 reported by Greg Shtilman
+
+Thu Jul 26 11:38:37 EDT 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* parser.c: fixes bug #57652 reported by Morus Walter
+
+Thu Jul 26 10:24:34 EDT 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* nanohttp.c: John Kroll provided a small fix to xmlNanoHTTPSave
+
+Thu Jul 26 07:16:04 EDT 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* parser.c parserInternals.c: fixed the xmlLineNumbersDefault()
+	  errors, lesson don't add new functions at 1am before a release
+	* xpath.c: integrated fix from Bjorn to avoid divide by zero
+	  from XPath initialization when possible.
+
+Tue Jul 24 15:39:11 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* result/scripts/base*: removing history/readline changed
+	  this slightly
+	* include/libxml/parser.h SAX.c parser.c parserInternals.c
+	  xmllint.c: make element content line number generation
+	  optionnal to avoid breaking old apps added interface to switch
+
+Tue Jul 24 15:06:58 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* configure.in: get rid of the readline and libhistory
+	  dependencies by default, release 2.4.1 with IA64 fix
+	* nanohttp.c tree.c xmlIO.c include/libxml/nanohttp.h
+	  include/libxml/tree.h include/libxml/xmlIO.h: incorporated
+	  John Kroll fixes to allow saving to HTTP via PUT (or
+	  POST of needed).
+	* doc/html/*.html: regenerated the docs
+
+Sun Jul 22 05:56:16 CEST 2001 Thomas Broyer <tbroyer@ltgt.net>
+
+	* hash.c include/libxml/hash.h: added xmlHashScannerFull,
+	  xmlHashScanFull and xmlHashScannFull3 to get passed the
+	  three keys as arguments to the callback function
+
+Thu Jul 19 15:29:26 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* configure.in Makefile.am: removed libxml softlink for good
+	* include/libxml/*.h *.c doc/Makefile.am: cleanup to get
+	  100% coverage by gtk-doc
+
+Tue Jul 17 17:36:46 EDT 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xmlmemory.c include/libxml/xmlmemory.h: debugging on IA64,
+	  fixed serious troubles due to size_t vs. int mismatch
+
+Tue Jul 17 16:04:36 EDT 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* SAX.c xmlIO.c: cleaned up some warning on the Alpha
+
+Mon Jul 16 06:32:44 CEST 2001 Thomas Broyer <tbroyer@ltgt.net>
+
+	* include/libxml/xpath{,Internals}.h xpath.c: added a more
+	  convenient extension API for value and context managing
+	  Now handles external objects through xmlXPathPopExternal,
+	  xmlXPathWrapExternal and xmlXPathReturnExternal.
+	  Added functions for sets operations (intersection, etc.)
+
+Mon Jul 16 20:05:27 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* include/libxml/parserInternals.h include/libxml/HTMLparser.h
+	  xmlIO.c tree.c parserInternals.c entities.c encoding.c
+	  HTMLparser.c: cleanup of global variables, marking some
+	  const or private.
+
+Mon Jul 16 00:17:15 CEST 2001 Thomas Broyer <tbroyer@ltgt.net>
+
+	* include/libxml/xpath.h: exported xmlXPath{NAN,PINF,NINF}
+	  fixed xmlXPathNodeSetItem when passing index=0
+
+Sun Jul 15 17:58:44 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* include/libxml/xmlwin32version.h.in: added xmlCheckVersion()
+
+Sat Jul 14 19:31:21 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xmllint.c: fixed compilation under Cygwin #57503
+	* TODO: update
+
+2001-07-13  Peter Williams  <peterw@ximian.com>
+
+	* config.h.in: add #undef HAVE_DLFCN_H
+
+	* example/Makefile.am (INCLUDES): Compile fix when srcdir !=
+	builddir.
+
+Fri Jul 13 11:09:56 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* win32/libxml2/libxml2.def.src: added a couple of exported entries
+	  raised by #57348 and #57381
+
+Thu Jul 12 21:20:17 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* DOCBparser.c HTMLparser.c HTMLtree.c SAX.c debugXML.c parser.c
+	  tree.c xpointer.c: store the line numbder in element->content,
+	  may break some software, need a configuration mechanism
+
+2001-07-10  Darin Adler  <darin@bentspoon.com>
+
+	* .cvsignore:
+	* example/.cvsignore:
+	* include/.cvsignore:
+	* include/libxml/.cvsignore:
+	Various things that are generated and should be ignored.
+
+Tue Jul 10 17:47:09 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* configure.in include/libxml/xmlwin32version.h: release of 2.4.0
+	* doc/xml.html doc/html/*:  updated the docs
+
+Mon Jul  9 22:06:53 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* valid.c: fixed "Internal: MIXED struct bad" when #CDATA elements
+	  validation occured on content with element child
+
+Mon Jul  9 17:59:08 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* tree.c: fixed XML Base computation which was broken
+	* debugXML.c: added a base function to the shell
+	* Makefile.am result/scripts/* test/scripts/*: added scripts
+	  based regression tests, and adding 2 XML Base tests
+
+Mon Jul  9 12:31:05 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* tree.c: set properties doc and call xmlSetListDoc for properties
+	  content when grafting them in a different tree.
+	* aclocal.m4: remove from CVS
+
+Sun Jul  8 23:09:07 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* win32/libxml2/libxml2.def.src: added some missing entry point
+	  for XPath (Mark Vakoc)
+
+Sun Jul  8 20:34:35 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xmlIO.c: fixed an old bug raised by Bernhard Zwisch, the I/O
+	  layer should URI-Unescape before trying to open resources.
+
+Sun Jul  8 16:26:00 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: fix the name() bug for elements in the default 
+	  namespace reported by Charlie Bozeman
+
+Sun Jul  8 15:11:05 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* SAX.c parser.c testXPath.c xpath.c: trying to fix #56948, this
+	  led to an XPath fix, improvements of SAX initialization, and
+	  an added option --nocdata to testXPath
+
+Sat Jul  7 21:09:55 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* doc/libxml-doc.el: Felix Natter provided anew version working
+	  with XEmacs too
+
+Sat Jul  7 02:16:00 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* include/libxml/xpath.h: small cleanup
+	* doc/xml.html: update
+
+Fri Jul  6 01:40:23 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* Makefile.am configure.in include/libxml/xmlwin32version.h:
+	  released 2.3.14
+
+Fri Jul  6 00:47:41 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* doc/html/*: rebuilt the docs for the release
+	* doc/xml.html: added 2.3.14 release.
+
+Thu Jul  5 22:01:31 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: a bug reported by Stephan Kulow empty nodesets
+	  were not equal to empty strings
+
+Thu Jul  5 00:52:25 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* SAX.c: fixed a URI-Reference computation problem when validating
+	* xmlIO.c: small cleanup
+
+Thu Jul  5 00:04:58 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* parser.c: improved the description of a couple of interfaces
+	  upon Larry Stamper suggestion
+
+Wed Jul  4 21:42:24 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* SAX.c entities.c parser.c: changed completely the way entities
+	  are handled when running the parser in entity substitution mode.
+	  This fixes a bug reported by Stephan Kulow and nearly divides
+	  by 3 the amount of memory required by libxslt to load and process
+	  DocBook TDG.
+
+Wed Jul  4 18:02:58 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* HTMLparser.c: fixing a too early root closing problem raised
+	  byt Prashanth Naidu
+
+Wed Jul  4 01:42:01 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: fixed a missing copy in xmlXPathVariableLookupNS() 
+	  raised by Mark Vakoc.
+
+Tue Jul  3 18:35:48 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* example/Makefile.am: fixed the include path to add srcdir/include
+	* Makefile.am configure.in: fix from Albert Chin for iconv detection
+	  and some cleanup
+
+Tue Jul  3 10:12:03 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c include/libxml/xpath.h include/libxml/xpathInternals.h:
+	  lot of optimization work, results in significant improvements
+	  when handling really complex XPath queries. Add a small optimizer
+	  for unions, improve [n] and [last()], avoid some costly ops.
+
+Fri Jun 29 23:26:54 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* include/libxml/parser.h parser.c: xmlStrstr args are both const
+	* xpath.c: small cleanup
+	* xmlGetNsList: reformated, fixed problems if used on Entities
+
+Thu Jun 28 18:19:44 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* doc/xml.html: added 1.8.14 and 2.3.13 releases
+
+Thu Jun 28 18:16:28 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* configure.in include/libxml/xmlwin32version.h: released 2.3.13
+	* Makefile.am example/Makefile.am: workaround automake generating
+	  erroneous deps
+
+Thu Jun 28 15:08:22 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* include/win32config.h: bug #56801 Yon Derek provided a patch
+	  to the windows config file.
+
+Thu Jun 28 14:51:44 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpointer.c include/win32config.h win32/libxml2/libxml2.def.src
+	  libxml.h : Yon Derek provided a set of changes to compile from
+	  CVS on Windows/MSC
+
+Thu Jun 28 14:11:28 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* parser.c: fixed UTF8 BOM support in push mode
+	* test/utf8bom.xml result/utf8bom.xml result/noent/utf8bom.xml:
+	  added a specific testcase
+
+Wed Jun 27 18:33:13 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* Makefile.am: added --push regression tests
+	* parserInternals.c: the XML parser segfaulted in --push mode
+
+Wed Jun 27 13:09:51 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* configure.in: moved the symlinks detection within a CVS
+	  check, this is not portable and will be removed soon.
+	* xpath.c: small cleanup/speedup
+
+Tue Jun 26 18:05:26 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* configure.in doc/xml.html include/libxml/xmlwin32version.h:
+	  release of 2.3.12
+	* parser.c: make an error message if unknow entities in all cases
+
+Tue Jun 26 09:46:29 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* uri.c: fixed 2 uri normalization bugs on '//' reduction
+
+Mon Jun 25 18:06:23 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* include/libxml/Makefile.am: Laszlo Peter pointed out that
+	  includes were installed in the wrong dir
+
+Mon Jun 25 17:07:37 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* doc/html.xml: warn against sending code to exhibit bugs.
+
+Sun Jun 24 23:31:56 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: patch to xmlXPathFormatNumber for the optimizer on
+	  Tru64 from Thomas Leitner
+
+Sun Jun 24 14:05:54 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* AUTHORS: added William and Bjorn
+	* include/libxml/*.h *.c README doc/*.html etc.: changed old email to
+	  daniel@veillard.com hopefully I won't have to do this again
+	* doc/Makefile.am doc/html/*.html: cleanup makefile, checked that
+	  docs can be rebuilt cleanly now
+	* include/libxml/xml*version.h*: removed include/libxml/xmlversion.h
+	  from CVs it's generated, added include/libxml/xmlwin32version.h
+	  also generated but which should change far less frequently.
+	* catalog.c nanoftp.c: made sure to include libxml.h not
+	  libxml/xmlversion.h directly
+	* include/libxml/*.h: include xmlwin32version.h instead of xmlversion.h
+	  when compiling on WIN32 and MSC
+
+Sat Jun 23 23:54:12 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* include/Makefile.am include/libxml/Makefile.am configure.in:
+	  fixed make distcheck and rebuilding the rpms
+
+Sat Jun 23 20:50:53 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* configure.in: should finish the migration of exported includes
+	  into a real include/libxml in CVS, at least for CVS users.
+	* removed the exported headers, added in include/libxml (as well
+	  as xmlversion.h.in).
+
+Sat Jun 23 20:37:19 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* configure.in: fixed the way to detect symlink
+
+Sat Jun 23 20:30:11 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* configure.in: updated, include/libxml is now a real CVS dir
+
+Sat Jun 23 19:36:31 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* doc/libxml-doc.el: a new version of libxml-doc.el. This new
+	  version works with both libxml1 and libxml2 (it autodetects
+	  the prefix of the html-files) from Felix Natter.
+	* doc/xml.html: updated doc accordingly
+
+Sat Jun 23 18:30:28 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: fixed the bug generating a template loop in libxslt
+	  when using docbook-xsl-1.4, * should filter out document nodes
+	* HACKING: added William
+	* TODO: updated
+
+Fri Jun 22 18:02:37 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* doc/FAQ.html: added a warning about gcc-3.0
+	* doc/xml.html: added reference to gdome2 and removed a confusing
+	  sentence
+
+Fri Jun 22 17:02:16 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xmlversion.h: okay this is a generated file, but Windows
+	  users need it and they can't generate it, and I want CVS
+	  Windows users ...
+	* win32/libxml2/libxml2_so.dsp: Windows project file for 
+	  the shared lib version of libxml2
+	* win32/libxml2/libxml2.def.src: bug #56527 set of exported
+	  resources needed for libxslt/xsltproc by Yon Derek
+
+Fri Jun 22 16:39:36 CEST 2001 Bjorn Reese <breese@users.sourceforge.net>
+
+	* trio.c: MSVC fix (provided by Igor Zlatkovic)
+	
+Fri Jun 22 12:42:16 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* include/win32config.h: another small fix for ATTRIBUTE_UNUSED
+
+Fri Jun 22 12:42:16 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* include/win32config.h: Yon Derek provided a first fix
+	  to be able to compile libxslt/xsltproc on Windows
+
+Fri Jun 22 00:04:36 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: attempt to work around what seemed a gcc optimizer
+	  bug when handling floats on i386 http://veillard.com/gcc.bug
+	* tree.c entities.c encoding.c: doing some cleanups while
+	  chasing it
+
+Thu Jun 21 13:13:36 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* Makefile.am: cleanup when --without-debug is specified
+	* xinclude.c xpath.c xpathInternals.h xpointer.c: cleanup
+	  w.r.t. --without-debug and other include points
+	* catalog.h testCatalog.c: a bit of cleanup and prepare for XML
+	  Catalogs
+	* configure.in entities.h tree.h HTMLparser.c: removed
+	  --without-corba, made the _private field mandatory
+
+Wed Jun 20 19:37:25 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* parser.c parserInternals.c encoding.c: Since Notepad on Win2k
+	  outputs a BOM in UTF8, an errata has been issued to avoid the
+	  problem, that was the most reasonable solution... Add support
+	  for a leading UTF8 BOM in entities.
+
+Wed Jun 20 15:38:59 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* valid.c: fixed a bug found when post validating an entity ref
+	* xmllint.c: added --loaddtd and sligly changed --postvalid to
+	  activate it too
+
+Tue Jun 19 20:03:40 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* tree.c xinclude.c xpointer.c: bug #56402 exposed a number of
+	  weakness in the node copy the XPointer and the XInclude
+	  implementations. Serious cleanup.
+
+Tue Jun 19 14:50:18 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* Makefile.am: Kjartan Maraas provided a small patch to
+	  add xml2-config.in to EXTRA_DIST
+
+Tue Jun 19 13:04:10 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* valid.c tree.c parserInternals.c parser.c: Stephan Kulow
+	  provided another failing case found in KDE, the way the
+	  ctxt->vctxt.nodeTab was allocated and freed changed over
+	  time but it wasn't completely cleaned up. This should fix it.
+
+Sun Jun 17 19:56:33 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* parser.c: Stephan Kulow also raised the fact that line number
+	  could get miscounted making debug harder, fixed the problem
+	  in xmlParseCharData()
+
+Sun Jun 17 19:17:26 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* valid.c: Stephan Kulow pointed out a problem when validating
+	  and using an empty entity, forgot a 'break' in a case.
+
+Sun Jun 17 16:47:40 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* tree.c: fixed xmlHasNsProp() accordingly to bug #55683
+	* doc/xml.html: updated with 2.3.11
+
+Sun Jun 17 12:24:11 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* TODO: updated adding cleanup of generated doc
+	* configure.in: prepared to release 2.3.11
+	* xmllint.c: added --version for bug reporting
+	* doc/html/*.html: rebuilt the doc
+
+Sat Jun 16 23:23:33 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: first part of the work on selecting namespace to
+	  fix bug #56115 
+
+Sat Jun 16 00:20:46 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* Makefile.am example/Makefile.am: Laszlo PETER provided a fix
+	  when using -liconv
+	* TODO: updated
+
+Fri Jun 15 07:08:57 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* HTMLtree.[ch]: more work on the HTML serialization routnes,
+	  cleanup, encoding support.
+
+Thu Jun 14 10:31:17 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: Thomas Broyer suggested a better patch for the / arg
+
+Thu Jun 14 01:01:30 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: bug detected by Ankh when / is used as a function arg
+
+Wed Jun 13 23:08:46 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* HTMLparser.[ch] HTMLtree.c: stored the inline/block property
+	  of element and use it to avoid outputting formatting spaces at
+	  the wrong place. Implemented the format parameter for HTML save.
+	* result/HTML/doc2.htm result/HTML/doc3.htm result/HTML/fp40.htm
+	  result/HTML/script.html result/HTML/test2.html result/HTML/test3.html
+	  result/HTML/wired.html: of course this impact the result of a
+	  number of HTML tests
+
+Thu Jun 14 09:49:09 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* HTMLtree.[ch]: started augmenting the HTML save API with
+	  encoding and formatting parameters
+
+Wed Jun 13 09:44:15 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* HTMLtree.h: cleanup and started evaluating the work needed on
+	  revamping the HTML output code
+
+Mon Jun 11 19:29:40 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* DOCBparser.c: handling of PIs and <?sgml-declaration in entities.
+
+Tue Jun 12 08:46:28 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* valid.c: fixed bug #56049, forgot one check in the
+	  validation routine
+
+Tue Jun 12 08:09:46 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* tree.[ch]: grrr ... namespace is a C++ reserved keyword
+
+Tue Jun 12 06:29:39 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* libxml.h: fixed an error in last commit
+	* doc/FAQ.html: added an entry for compilation from CVS
+
+Mon Jun 11 10:07:29 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xmlversion.h.in libxml.h: Cygwin patches
+	* tree.c: xmlFreeNodeList patch similar to xmlFreeNode one
+	* tree.h: cleanup
+
+Sat Jun  9 19:16:00 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* tree.c: patched xmlFreeNode() to avoid freeing() a static
+	  memory block in a strange case where libxml is linked twice
+	  in the binary.
+
+Sat Jun  9 18:39:03 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* valid.c: (a? , b? , c? , ... , z?) was storing/restauring
+	  state far too often, simple fix used to avoid it.
+
+Sat Jun  9 16:10:36 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xinclude.c: Raphael Hertzog had a trouble with DTD nodes
+	  being processed, applied his patch
+	* tree.c: fixed a bug raised in xmlStaticCopyNodeList()
+
+Sat Jun  9 15:50:11 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* nanoftp.c nanohttp.c uri.c include/win32config.h: Igor  Zlatkovic
+	  provided fixes to compile on MSCC again
+	* win32/libxml2/libxml2.def.src win32/libxml2/libxml2*.dsp: he
+	  also provided an update for the project files.
+
+Thu Jun  7 21:52:10 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* tree.c: applied Steve Tinney patch to xmlNewNsProp to fix
+	  bug #55810
+
+Thu Jun  7 21:29:39 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* tree.c: fixed xmlGetNsProp() to close bug #55683
+	  Note this requires libxslt to use it's own function instead.
+
+Thu Jun  7 18:06:34 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* HTMLtree.c: when in a pre element no formatting space should
+	  be added.
+	* test/HTML/pre.html result/HTML/pre.html*: added a regression test
+
+Thu Jun  7 17:29:38 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* configure.in: added tests for signal() and signal.h
+
+Fri Jun  8 10:17:15 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: robert pointed out xmlXPathNINF was not initialized
+
+Fri Jun  8 10:01:45 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* doc/libxml-doc.el: Felix Natter provided a new version for
+	  libxml2
+
+Fri Jun  8 07:20:46 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* HTMLtree.c: when in a pre element no formatting space should
+	  be added.
+
+Wed Jun  6 18:07:36 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* configure.in: add -mieee to CFLAGS when compiling on Linux/alpha
+
+Thu Jun  7 06:44:01 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* DOCBparser.c: implemented the <?sgml-declaration encoding="xxx"?>
+	  hack
+	* tree.[ch]: added xmlHasNsProp as suggested in bug report #55653 
+	* uri.c: fixed a warning
+
+Tue Jun  5 22:54:21 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* HTMLtree.c: trying to close bug #55772 escaping in script
+	  elements
+	* doc/xml.html: suggest to send mail to the list
+
+Tue Jun  5 19:11:02 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* error.c: attempt to fix the xmlGetVarStr breakage once and for
+	  good. Use a macro and based on the solution provided in 
+	  vsnprintf manual page from GNU.
+
+Tue Jun  5 14:46:10 CEST 2001 Bjorn Reese <breese@users.sourceforge.net>
+
+	* error.c: Workaround for non-preserving variadic list.
+	* trio.c trio.h triop.h strio.c strio.h: Upgraded to trio baseline 1.4
+	
+Sat Jun  2 06:12:33 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* doc/xml.html: added 2.3.10 release
+
+Fri Jun  1 11:27:11 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* configure.in: releasing 2.3.10
+
+Thu May 31 20:42:39 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xmlIO.c: Gary Pennington spotted a few troubles with file:///
+
+Thu May 31 20:18:59 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* encoding.c: Robert Collins provided a patch to add the
+	  "US-ASCII" encoding alias
+
+Wed May 30 21:12:45 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c encoding.[ch]: William M. Brack provided a set of UTF8
+	  string oriented functions and started cleaning the related areas
+	  in xpath.c which needed fixing in this respect
+
+Wed May 30 20:30:47 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* HTMLtree.c: applied patch from Jaroslaw Kolakowski to close bug
+	  #55380
+	* tree.c: patch to xmlNodeGetContent() to get CDATA section content
+
+Mon May 28 12:56:29 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* TODO: updated
+	* nanohttp.[ch] : started adding APIs to get the redirected URL
+	  when this occurs (needed for further base computation
+	* tree.h: cleanup
+	* encoding.c: cleanup
+	* SAX.c: minor change around ctxt->loadsubset
+
+Fri May 25 09:36:26 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* Makefile.am include/Makefile.am: small change to have
+	  include/libxml rebuilt if working from CVS.
+	* uri.c: applied another patch from Carl Douglas for URI escaping,
+	  this should close bug #51876
+
+Wed May 23 15:40:27 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xinclude.c: fixed XInclude recursive behaviour bug #54678
+	* result/XInclude/recursive.xml test/XInclude/docs/recursive.xml
+	  test/XInclude/ents/inc.txt test/XInclude/ents/sub-inc.ent:
+	  added specific regression test
+	* parser.h: preparing for the XSLT mode where DTD inherited
+	  attributes are added to the tree.
+
+Wed May 23 13:59:19 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xinclude.[ch]: Updated the namespace for the Last Call version
+	* result/XInclude/include test/XInclude/include: updated the
+	  testsuite accordingly
+
+Wed May 23 12:27:44 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* uri.[ch]: applied a patch from Carl Douglas for URI escaping,
+	  related to bug #51876
+
+Tue May 22 18:46:56 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* tree.c: fixed a gross mistake in base computation, xml:base is
+	  not completely correct yet (need cascade).
+	* xpath.[ch]: added the few things needed to find a function name
+	  and URI from the XPath context when it is called.
+
+Tue May 22 17:00:36 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* catalog.[ch]: fixes and add xmlLoadCatalogs()
+	* DOCBparser.c: small cleanup
+	* xmllint.c: added a --catalogs option to load catalogs from
+	  $SGML_CATALOG_FILES
+	* tree.c: cleanup
+	* configure.in: iconv library fixup, ICONV_LIBS 
+
+Mon May 21 16:05:22 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* catalog.c: handling of CATALOG entries. detection of recursion,
+	  and a few bugfixes
+	* xpath.c: fixing bug #54951 QNAME with no prefix should not match
+	  against the default namespace
+
+Mon May 21 10:14:07 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: Joe Orton reported a bug found with IRIx compiler.
+
+Sun May 20 15:15:46 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* parser.c: fixed propagation context info when parsing an
+	  external entity.
+	* doc/html/*.html: regenerated a couple of docs
+
+Sat May 19 17:11:15 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* doc/xml.html: update with 2.3.9 informations
+
+Sat May 19 16:50:47 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* HTMLtree.h debugXML.h parserInternals.h tree.h valid.c
+	  xmlversion.h.in xpathInternals.h xpath.h: some cleanup for gtk-doc
+	* doc/html/* : rebuilt the docs
+	* valid.c: small patch which may improve some case when
+	  validating.
+
+Sat May 19 15:20:03 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* HTMLparser.c: Closed bug #54891
+	* result/HTML/cf_128.html* test/HTML/cf_128.html: added the test
+	  to the suite
+
+Thu May 17 14:15:07 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* encoding.h hash.c nanoftp.h parser.h tree.h uri.h xlink.h xpointer.c:
+	  applied a documentation patch from LotR and filled in a few missing
+	  descriptions
+
+Wed May 16 23:02:41 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c tree.c parser.c: speed optimizations at the parser level
+	  document tree freeing and xpath evaluation
+
+Wed May 16 12:55:48 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* parser.c parser.h parserInternals.h: fixed a couple of
+	  interfaces for handling memory buffer input to const char *
+	  upon suggestion of JamesH.
+
+Tue May 15 17:22:27 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* configure.in: LoTR sent a patch fixing the previous commit 
+
+Tue May 15 14:40:04 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* configure.in: trying to deal again with the stoopid -R linking
+	  flag of Solaris
+
+Tue May 15 12:49:50 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.h: two nodeset access macros from Thomas Broyer
+
+Tue May 15 11:42:39 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c xpath.h xpathInternals.h: apply an XPath API cleanup
+	  patch from Thomas Broyer
+
+Tue May 15 10:52:19 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* valid.c test/VCM/v2[34].xml: Fixed bug #54631 added specific test
+	  case
+	* INSTALL: was empty added stuff from the FAQ
+
+Fri May 11 19:37:30 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* tree.[ch]: fixing bug #54446, by cleaning some bugs in the
+	  attributes handling and #54433 by adding xmlUnsetProp()
+	  and xmlUnsetNsProp()
+
+Fri May 11 16:07:13 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* HTMLparser.c: Patch from Jonas Borgström
+	(htmlGetEndPriority): New function, returns 
+	the priority of a certain element.
+	(htmlAutoCloseOnClose): Only close inline elements if they 
+	all have lower or equal priority.
+	* result/HTML: this of course changed a number of tests results.
+
+Thu May 10 17:30:22 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xmlIO.c catalog.c: plugged in the default catalog resolution
+	* doc/gnome-xml.sgml: linked in the Docbook parser and catalog
+	  documentations
+	* doc/html/libxml-*.html: rebuild added the missing ones to CVS
+
+Thu May 10 16:14:36 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* Makefile.am xmlversion.h.in configure.in include/Makefile.am:
+	  integrating catalogs
+	* catalog.[ch] testCatalog.c: adding a small catalo API
+	  (only SGML catalog support).
+	* parser.c: restaured xmlKeepBlanksDefault(0) API
+
+Wed May  9 12:50:15 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* tree.c: zb@bisp.com reported an error in xmlNodeGetLang()
+
+Tue May  8 12:31:40 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* parser.c: added xmlParseExternalEntityPrivate() to allow
+	  propagation of ctxt->_private when parsing external entities
+
+Tue May  8 10:26:22 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* HTMLtree.c: fixed the bug reported by Bjorn in htmlNodeDump
+
+Tue May  8 09:30:12 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* configure.in: fixed a small portability problem with AM_CONDITIONAL
+
+Mon May  7 22:44:45 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* valid.c: warn when indeterminist content model is detected
+	* result/VC/ElementValid8: this adds a message
+	* Makefile.am: add --novalid for VCM tests
+	* parserInternals.c: added a call to Init memory 
+
+Fri May  4 19:51:15 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* HTMLparser.c: fixed htmlNewDoc SYSTEM and PUBLIC ID inversion
+	  when both parameters are NULL.
+
+Fri May  4 17:19:39 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* valid.c: applied small patch from Gary Pennington, reindented
+	  some part of the code.
+
+Thu May  3 13:10:43 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* configure.in doc/xml.html doc/html/*: preparing for 2.3.8
+	  release, updated and regenerated the docs
+
+Thu May  3 12:47:46 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c result/XPath/expr/floats : clarified and cleanup
+	  printing of abnormal floats in tests.
+
+Thu May  3 10:25:19 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* HTMLparser.c: trying to fix the problem reported by Jonas Borgström
+	* results/HTML/ : a few changes in the output of the HTML tests as
+	  a result.
+	* configure.in: tying to fix -liconv where needed
+
+Wed May  2 19:10:26 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* Makefile.am: fixed a stupid error
+
+Wed May  2 18:39:39 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* configure.in Makefile.am: make the inclusion of the trio
+	  modules in the library conditional
+
+Wed May  2 14:39:57 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* DOCBparser.c: patche from  László Kovács, fixed entities refs
+	  in attributes handling
+
+Wed May  2 12:56:04 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xmlIO.c: Bjorn Reese provided a fix for a problem on buffer
+	 flushing
+
+Mon Apr 30 22:29:34 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: fix of an XSLT namespace bug reported on the list
+	  general/bug-8-
+
+Mon Apr 30 19:42:58 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* strio.h trio.c: Dan McNichol suggested a couple of small
+	  fixes for AIX 4.3.3 using Visual Age 5.0.2 compiler
+
+Mon Apr 30 13:44:48 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* tree.c parser.c encoding.c: spent a bit more time looking
+	  at the parsing speed and DOM handling. Added a few more
+	  speedups.
+
+Sun Apr 29 21:53:47 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* parser.c: small but effective parsing speed improvement
+
+Sun Apr 29 19:02:13 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* configure.in: default on the DocBook parser inclusion (for Gnome)
+	* DOCBparser.h: fixed a header reference
+
+Sat Apr 28 19:00:39 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* configure.in xpath.c: applied Bjorn patches for FPE on the
+	  alpha
+
+Sat Apr 28 18:54:28 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* tree.[ch] xmlIO.h: applied patch from Joe McAlerney to add
+	  xmlSaveFormatFileTo()
+
+Sat Apr 28 16:33:05 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: simple and efficient optimization, XPath functions
+	  aways bind to the same code, cache this
+	* TODO: updated (by saying some is obsolete)
+
+Sat Apr 28 14:23:30 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: more cleanup work on XPath name parsing routines
+
+Fri Apr 27 19:06:13 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* parserInternals.c xpath.[ch]: some UTF8 cleanup on
+	  xmlXPathParseName
+	* xpath.c: Igor Zlatkovic suggested a change for NAN and MSC
+	* debugXML.c: avoid compilation problems if compiling without
+	  HTML support, Igor Zlatkovic
+	* win32/libxml2/libxml2.def.src: being able to compile without
+	  XPath on Windows
+
+Thu Apr 26 22:53:03 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* libxml.m4: yet another patch from Toshio Kuratomi
+
+Thu Apr 26 21:27:43 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* libxml.m4 libxml2-spec.in: new patches from Toshio Kuratomi
+
+Thu Apr 26 20:53:48 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* tree.[ch]: added xmlSaveFormatFile interface for saving
+	  and indenting a file.
+
+Thu Apr 26 16:35:53 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: fixed bug #53689 related to processing-instruction()
+
+Thu Apr 26 12:57:58 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* DOCBparser.c: patche from  László Kovács
+
+Thu Apr 26 11:31:54 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* parser.c: applied fixes from Christian Glahn bug report #53391
+
+Thu Apr 26 11:14:56 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* error.c: Jean François Lecomte provided a complete description
+	  and a fix to bug #53537
+
+Thu Apr 26 09:42:58 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* libxml.m4: added AM_PATH_XML2 provided by Toshio Kuratomi
+
+Wed Apr 25 21:05:31 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* DOCBparser.c SAX.c: a bit more work on entities processing.
+	  Still Need to cleanup XML output and references in attributes
+
+Wed Apr 25 17:52:27 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* DOCBparser.c include/Makefile.am: two patches from  László Kovács
+
+Wed Apr 25 14:56:26 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* tree.c: trying to fix #53574, not completely complete,
+	  I would like xmllint --copy --debug test/ent1 and
+	  xmllint --debug test/ent1 to show the same result.
+	* xpath.c: fix a bug when trying to sort namespace nodes
+
+Wed Apr 25 12:28:57 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* HTMLtree.c: real fix for  #53402
+
+Tue Apr 24 17:36:35 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* HTMLtree.c HTMLtree.h : closing #53402 i.e. output of
+	  PIs when using xsl:output
+	* valid.c: closing #53537 some case generate segfaults if there
+	  is validity errors
+
+Tue Apr 24 15:19:53 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* SAX.c testDocbook.c DOCBparser.c: more work on the support
+	  of external parsed entities, added --noent to testDocbook
+	* valid.c: Garry Pennington found an uninitialized variable
+	  access in xmlValidateElementContent()
+
+Tue Apr 24 14:41:25 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* HTMLparser.c : HTML parsing still sucks ... trying to deal
+	  with madness
+	* result/HTML/ : this modified the result of the regression tests
+	  a lot.
+
+Tue Apr 24 14:10:38 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* entities.c: xmlEncodeEntitiesReentrant fixed a few accesses
+	  to doc where it wasn't checked against NULL reported by
+	  Jens Laas
+
+Tue Apr 24 13:21:36 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* HTMLparser.c: Jonas Borgström patch, the <td>, and <th> elements
+	  now means the end of any open <span>,<font>,<a>,<b>,<i>,<u>.
+
+Mon Apr 23 15:40:04 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* DOCBparser.c DOCBparser.h testDocbook.c configure.in Makefile.am
+	  xmlversion.h.in: started (re)integrating the DocBook SGML parser.
+	* SAX.[ch]: cleanup and updates for DocBook
+	* debugXML.c parser.h tree.[ch] valid.c xpath.c: small macro or
+	  ex SGML identifier changes
+	* valid.c: removed a static unused function.
+
+Mon Apr 23 11:05:56 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* HTMLtree.c: applied change for Paul Sponagl on script saving
+	* Makefile.am: the warning about entity title.xml are normal.
+
+Sun Apr 22 22:09:35 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* configure.in: release of 2.3.7
+	* Makefile.am: fixing make distcheck
+
+Sun Apr 22 21:29:52 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* doc/html/* doc/xml.html: updated and regenerated the docs
+
+Sun Apr 22 21:11:45 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: fixed the XPointer problem introduced in 2.3.6
+
+Sun Apr 22 14:11:58 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* tree.c: fixed #53388 with the provided patch
+
+Sun Apr 22 12:34:41 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* valid.c: Bjorn detected an invalid memory access. Fixed
+	  vstateVPush()
+
+Sun Apr 22 10:49:23 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: fixed xmlXPathCompile to detected unproperly ended expr
+
+Sat Apr 21 18:27:51 CEST 2001 Bjorn Reese <breese@users.sourceforge.net>
+
+	* libxml.h: new header used only for the compilation of libxml
+	* HTMLparser.c HTMLtree.c SAX.c debugXML.c encoding.c entities.c
+	  error.c hash.c list.c nanoftp.c nanohttp.c parser.c
+	  parserInternals.c testHTML.c testSAX.c testURI.c testXPath.c
+	  tree.c uri.c valid.c xinclude.c xlink.c xmlIO.c xmllint.c
+	  xmlmemory.c xpath.c xpointer.c: libxml.h integration
+	* trio.[ch] triop.h strio.[ch]: upgraded to the latest trio
+	  baseline (version 1.2 plus a single patch).
+	* xpath.c result/XPath/expr/floats test/XPath/expr/floats: parses
+	  scientific notation for numbers. Tests added.
+	* xpath.c: formatting of numbers changed to use sprintf
+	  (contribution from William Brack)
+
+Sat Apr 21 16:12:59 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* valid.c: cleanup, more useful debugging
+	* parserInternals.c: cleanup vctxt.nodeTab (de)allocation
+	* xmlIO.c: entity loading is printed as an error when validating
+
+Sat Apr 21 12:25:49 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* valid.c: fixed to validate within entities
+	* test/VCM/v22.xml: added a specific testcase
+
+Fri Apr 20 17:45:47 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* valid.c: forgot an epsilon transition in for ()+
+	* test/VCM/v21.xml : added a specific test case
+
+Fri Apr 20 15:46:04 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* valid.c: removed a state explosion exhibited by RSS
+	* test/valid/rss.xml result/valid/rss.xml*: added the testcase
+	  from bug #51872
+
+Fri Apr 20 14:52:44 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* valid.[ch] tree.h: worked *hard* to get non-determinist content
+	  validation without using an ugly NFA -> DFA algo in the source.
+	  Made a specific algorithm easier to maintain, using a single
+	  stack and without recursion.
+	* Makefile.am test/VCM/*.xml: added more tests to "make Validtests"
+	* hash.c: made the growing routine static
+	* tree.h parser.c: added the parent information to an
+	  xmlElementContent node.
+
+Wed Apr 18 23:33:11 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* SAX.c parser.c xpath.c: generating IDs when not validating
+	  from an external parsed entity was poisoning the ID has table
+	  with removed values. This was killing XSLT on the KDE help
+	  browser.
+
+Wed Apr 18 17:09:15 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* entities.h: andrew@ugh.net.au detected a double declaration
+
+Wed Apr 18 15:06:30 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* debugXML.c hash.c tree.h valid.c : some changes related to
+	  the validation suport to improve speed with DocBook
+	* result/VC/OneID2 result/VC/OneID3 : this slightly changes
+	  the way validation errors get reported
+
+Wed Apr 18 11:42:47 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* HTMLparser.c HTMLtree.c: applied part of the patches provided
+	  by P C Chow and William M. Brack for XSLT HTML output
+
+Mon Apr 16 19:44:36 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xmlversion.h.in win32config.h win32/libxml2/*: applied 
+	  Igor Zlatkovic patches for MSC compilation and added his
+	  updates
+
+Tue Apr 17 10:08:19 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: fixed xmlXPathNodeCollectAndTest() to do proper
+	  prefix lookup.
+	* parserInternals.c: fixed the bug reported by Morus Walter
+	  due to an off by one typo in xmlStringCurrentChar()
+	
+Thu Apr 12 17:41:09 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* HTMLparser.c result/HTML/*: revamped the way the HTML
+	  parser handles end of tags or end of input
+
+Thu Apr 12 10:50:34 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* tree.[ch] : added xmlDocCopyNode for gdome2 support
+
+Wed Apr 11 16:37:50 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* tree.h: include xmlmemory.h this seems to havoid a nasty glibc
+	  bug where the linktime verions of free() won't work ...
+
+Wed Apr 11 14:21:31 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* config.h.in configure.in xmlversion.h.in: added ansidecl.h test
+
+Wed Apr 11 13:50:42 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* doc/xml.html: added 2.3.6 release
+
+Wed Apr 11 13:26:34 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* tree.c: fixed xmlStringGetNodeList() to handle charrefs
+	* result/wml.xml: resulted in a small output change
+
+Wed Apr 11 09:47:55 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* tree.c: xmlNewDoc was missing the charset initialization
+	* xmllint.c: added --auto to autogenerate a doc, allow to
+	  reproduce the problem fixed on xmlNewDoc
+
+Tue Apr 10 18:13:10 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: trying to get 52979 solved
+	* tree.c result/ result/noent/: trying to get 52712 solved, this
+	  also made me clean up the fact that XML output in general should
+	  not add formating blanks by default, this changed the output of
+	  a few tests
+
+Tue Apr 10 16:30:20 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: Bill Brack pointer an error in detecting a null nodeset
+
+Sun Apr  8 15:07:16 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* configure.in: finally released 2.3.6
+
+Sun Apr  8 11:39:21 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: checking for null pointer generated by new code
+
+Fri Apr  6 12:53:05 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: fixed a [] evaluation problem reported
+	* test/XPath/tests/simpleaddr: extended test
+	* result/XPath/simpleaddr: updated result
+
+Wed Apr  4 02:07:53 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xmllint.c: Dan Timis reported a portability problem
+	  on Macs without mmap, fixed it.
+
+Tue Apr  3 20:20:51 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* testXPath.c : added a --tree option allowing to display the
+	  tree dump of the XPath expression
+
+Mon Apr  2 17:13:51 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: fixed a memleak when comparing nodesets
+	* HTMLtree.c: don't invent the HTML doctype if not available (XSLT)
+	* tree.c: added a TODO
+
+Tue Mar 27 14:32:06 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* configure.in Makefile.am config.h.in xmlversion.h.in: detect if
+	  we need string functions
+	* trio.[ch] strio.[ch]: embedded the Trio-0.23 string functions
+	  to be able to use them where needed. Applied some changes
+	  to reduce name linking pollution and compile in only what's
+	  needed.
+	* HTMLtree.c debugXML.c entities.c error.c nanoftp.c valid.c
+	  xlink.c xmlversion.h.in xpath.c: got rid of the #ifdef 
+	  for the string manipulation functions
+	* xmlmemory.[ch]: removed DEBUG_MEMORY_FREED and added it automatically
+	  to the free() function of xmlmemory.c
+	* entities.c HTMLtree.c parserInternals.c tree.c uri.c valid.c
+	  xinclude.c xmlIO.c xpath.c xpointer.c: removed the MEM_CLEANUP
+	  usage.
+
+
+Tue Mar 27 02:30:23 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* error.c: applied the context output patch of the error
+	  handling submitted by Chuck Griffith
+	* error/VC/*: this slightly change some error logs
+
+Tue Mar 27 00:51:27 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* parser.c: fixed line number reporting on error
+
+Mon Mar 26 23:21:41 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* parser.c: Sullivan and Darin found a parser bug,
+	  applied the patch.
+
+Mon Mar 26 18:24:52 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* HTMLparser.c HTMLtree.c SAX.c debugXML.c error.c parserInternals.c
+	  testHTML.c testSAX.c tree.c valid.c xmlIO.c xmlmemory.c
+	  xmlversion.h.in xpointer.c: of course the way I defined
+	  UNUSED breaks on old gcc version. Try to be smart and
+	  also define it directly in xmlversion.h
+	* configure.in: removed -ansi flag from the pedantic set
+
+Sat Mar 24 17:45:36 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+        Huge cleanup, I switched to compile with
+	-Wall -g -O -ansi -pedantic -W -Wunused -Wimplicit
+	-Wreturn-type -Wswitch -Wcomment -Wtrigraphs -Wformat
+	-Wchar-subscripts -Wuninitialized -Wparentheses -Wshadow
+	-Wpointer-arith -Wcast-align -Wwrite-strings -Waggregate-return
+	-Wstrict-prototypes -Wmissing-prototypes -Wnested-externs -Winline
+	* HTMLparser.[ch] HTMLtree.c SAX.c debugXML.c encoding.[ch]
+	  encoding.h entities.c error.c list.[ch] nanoftp.c
+	  nanohttp.c parser.[ch] parserInternals.[ch] testHTML.c
+	  testSAX.c testURI.c testXPath.c tree.[ch] uri.c
+	  valid.[ch] xinclude.c xmlIO.[ch] xmllint.c xmlmemory.c
+	  xpath.c xpathInternals.h xpointer.[ch] example/gjobread.c:
+	  Cleanup, staticfied a number of non-exported functions,
+	  detected and cleaned up a dozen of problem found this way,
+	  avoided a lot of public function name/typedef/system names clashes
+	* doc/xml.html: updated
+	* configure.in: switched private flags to the really pedantic ones.
+
+Thu Mar 22 22:44:15 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* configure.in: 2.3.5
+	* doc/html/*: rebuilt the docs
+
+Thu Mar 22 15:36:45 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* parser.c: fixed a reported bug in NOTATION parsing
+	* uri.c: accepted but not fixed bug 51876, added TODO 
+	* Makefile.am: fixed bug 51876
+
+Thu Mar 22 13:41:22 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* config.h.in configure.in error.c: fix a compilation problem
+	  on platforms without vsnprintf (xml@thewrittenword.com)
+
+Wed Mar 21 19:04:34 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* parser.c: fixed a function name header typo
+	* SAX.c: notations can also occur in external subset.
+
+Tue Mar 20 14:21:28 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* error.c: removed a C++ like comment
+
+Tue Mar 20 12:22:36 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* parser.c: fixing bug 52299 strange condition leading
+	  to a parser crash due to a buffer overflow
+	* result/noent/attrib.xml result/attrib.xml test/attrib.xml:
+	  added the specific test case
+
+Mon Mar 19 16:50:52 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.[ch]: still a lot of cleanup based on XSLT, added
+	  xmlXPathConvert{String,Number,Boolean} to be able to make
+	  type casts without a context stack, fixed some implementation
+	  problems related to the absence of context at parse-time,
+	  added xmlXPathEvalPredicate() and xmlXPathFreeCompExpr()
+	  in the public API too
+	* xpointer.c xpathInternals.h: we need to know at parse time
+	  whether we are compiling an XPointer
+
+Mon Mar 19 11:54:31 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.[ch] xpointer.c: restaured the Binary and API compatibility
+	  cleaned up the parser internals, refactored XPath code, added
+	  new compilation based APIs and cleanly separated public and
+	  private APIs.
+
+Mon Mar 19 00:59:25 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.h: the comp field must be added at the end to avoid
+	  killing binary compat.
+
+Mon Mar 19 00:11:18 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* Makefile.am: detect XPath memleaks in regreson tests
+	* error.c: fixed and error w.r.t. error reporting still using
+	  stderr
+	* hash.c: added new line at end of file
+	* tree.h: minor cleanup
+	* xpath.[ch] xpointer.[ch]: Major changes ! Separated XPath
+	  expression parsing from evaluation, resulted in a number of
+	  changes internally, and in XPointer. Likely to break stuff
+	  using xpathInternals.h but should remain binary compatible,
+	  new interfaces will be added.
+
+Wed Mar 14 20:34:02 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* configure.in: fixed a couple of problems reported by 
+	  okiddle@yahoo.co.uk and allanc@chickenandporn.com when compiling
+	  without gcc on non linux platforms.
+
+Wed Mar 14 20:13:54 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* doc/Makefile.am configure.in: yearke@eng.buffalo.edu suggested
+	  a fix for --with-html-dir= configure support. I hope it won't
+	  break rpm generation
+
+Wed Mar 14 17:28:49 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xmlIO.c: one function comment cleanup.
+
+Wed Mar 14 14:55:46 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* SAX.c: external subset notations were improperly registered
+	  in the internal subset.
+
+Tue Mar 13 10:28:49 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* README.cvs-commits: added, pointing to HACKING
+	* HACKING: updated
+
+Mon Mar 12 22:09:40 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* parser.c: and Matt Sergeant found one in the XML push
+	  parser (erroneous check I forgot to remove when I fixed the
+	  main parser).
+
+Mon Mar 12 19:19:04 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: ptittom found a small bug in UnaryExpr
+
+Sat Mar 10 13:09:53 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* configure.in: bumped to 2.3.4
+	* error.c: fixed bug #51860
+	* tree.c: fixed bug #51861
+	* valid.c: cleanup, more debug, failed to fix one bug crap ...
+	* tree.[ch] : added xmlDefaultBufferSize
+	* nanoftp.c: typo in function name header block
+	* doc/xml.html : updated, added link to XML::LibXSLT
+	* doc/html/* : rebuilt the docs
+
+Wed Mar  7 20:43:47 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* parser.c SAX.c: the new content parsing code raised an
+	  ugly bug in the characters() SAX callback. Found it
+	  just because of strangeness in XSLT XML Rec ouptut :-(
+
+Wed Mar  7 16:50:22 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* Makefile.am: Martin Baulig suggested to add -lm
+	* tree.c: found another bug in xmlNodeGetContent()
+
+Tue Mar  6 09:21:30 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: Bjorn found the error related to strictness of comparison.
+
+Mon Mar  5 21:47:31 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* parser.c: trying to fix the Dtd parsing problem reported
+	  by Gary, side effect of last week speed optimizations.
+
+Sat Mar  3 19:45:59 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xml2Conf.sh.in: fixes pointed out by Fredrik Hallenberg
+	* parserInternals.c: removed unneeded test raised by Stric
+
+Sat Mar  3 13:04:37 CET 2001 Bjorn Reese <breese@users.sourceforge.net>
+
+	* xpath.c: Fixed xmlXPathNodeCollectAndTest (problem reported
+	  and fixed by William Brack). Added xmlXPathFormatNumber.
+	  Changed the sorting slightly.
+	* configure.in Makefile.am example/Makefile.am: Added -lm.
+	  Please note that applications linking with libxml2, must
+	  also like with the math library from now on.
+
+Sat Mar  3 07:38:58 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* HTMLparser.c: fixed loop reported by Marc Sanfacon
+
+Sat Mar  3 02:10:24 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* parser.c: one must report spaces even if the Dtd element
+	  content proves that this is not part of the element content.
+	* result/valid/*.xml: this changed the ouptu slightly
+
+Thu Mar  1 17:53:39 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* configure.in: bumped to 2.3.3
+	* doc/xml.html: updated
+
+Wed Feb 28 00:43:58 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* tree.c: minor doc fix
+	* xpath.c: deallocation issues when a result tree has been
+	  converted to a node-set
+
+Mon Feb 26 22:09:45 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* doc/xml.html: oops corrected dates s/2000/2001
+
+Mon Feb 26 12:48:35 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* valid.c: new patch from Gary Pennington
+
+Mon Feb 26 09:30:23 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* doc/xml.html: applied patch from Ankh
+
+Mon Feb 26 03:34:43 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xinclude.c: fixed a problem building on Mac
+
+Sun Feb 25 21:52:30 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* parser.c: more work on increasing parsing ferformances
+
+Sun Feb 25 18:03:42 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xmlmemory.h HTMLparser.c HTMLtree.c entities.c parser.c
+	  xpath.c xpointer.c tree.c uri.c valid.c xinclude.c xmlIO.c:
+	  avoiding memcpy in production builds MEM_CLEANUP macro use
+	* parser.[ch] parserInternals.c: optimizations of the tightest
+	  internal loops inside the parser. Better checking of I/O
+	  flushing/loading conditions
+	* xmllint.c : added --timing
+
+Sun Feb 25 05:48:51 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* configure.in: bumped to 2.3.2
+	* doc/xml.html: updated for release
+
+Sat Feb 24 14:07:52 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: found a memleak and fixed a nasty bug
+
+Sat Feb 24 03:35:48 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xmllint.[c1] : added return code errors for xmllint
+	* xpath.c: specific debug dump function for result value trees
+
+Thu Feb 22 07:52:27 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: finally implemented xmlXPathCompareNodeSets
+	* test/XPath/expr/floats results/XPath/expr/floats: added 
+	  a test for float expressions
+
+Tue Feb 20 18:57:54 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* tree.c: fixed xmlNodeGetContent, it was not recursing on child
+	* parserInternals.[ch]: trying to speed up parsing
+	* xpath.c : speeded up node set equality op
+
+Mon Feb 19 19:01:57 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* Makefile.am valid.c list.[ch]: Gary Pennington provided a
+	  better handling of ID/IDREF and the list modules associated
+	* configure.in: small CFLAGS cleanup
+
+Mon Feb 19 16:13:22 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* configure.in: fixed iconv detection on AIX (stric)
+
+Mon Feb 19 10:59:41 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: fixed "*" (unbelievable !) and a couple of warnings
+
+Sun Feb 18 17:52:37 MET 2001 Bjorn Reese <breese@users.sourceforge.net>
+
+	* xpath.c: fixed whitespace handling in xmlXPathStringEvalNumber,
+	  and optimized xmlXPathNodeSetSort
+
+Sat Feb 17 14:18:42 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: bug fix when context size is 0
+	* parser.c: I like Norm's Dtd because they still manage to break
+	  the parser occasionally
+
+Fri Feb 16 14:20:35 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: xmlXPathEqualNodeSetFloat the arg is really a double now
+
+Fri Feb 16 01:10:06 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* tree.[ch] parser.c xpath.c: fixed the problem of addressing
+	  attributes within the XML-1.0 namespace
+
+Thu Feb 15 16:53:20 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpathInternals.h: exported a few axis functions
+	* doc/xml.html: updated the doc
+
+Thu Feb 15 15:57:14 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* configure.in: applied patch from Daniel van Balen for OpenBSD
+	  and bumped version to 2.3.1
+	* HTMLtree.c result/HTML/doc3.htm result/HTML/wired.html: the
+	  attempt to find autoclosing was simply broken, removed it,
+	  updated the examples, this is better
+
+Wed Feb 14 11:35:39 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* hash.[ch]: added Paolo Casarini patch to provide Delete from
+	  hash functionnalities.
+	* doc/html/* : rebuild the doc
+
+Tue Feb 13 18:01:48 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c result/XPath/tests/chaptersprefol: bugfixes on order and
+	  on predicate
+	* HTMLparser.[ch] HTMLtree.c result/HTML/doc3.htm.err
+	  result/HTML/doc3.htm.sax result/HTML/wired.html: sometimes one
+	  really want to have tags closed on output even if we accept
+	  unclosed ones on input
+
+Mon Feb 12 18:33:20 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: ouch don't free NULL, rare case fixed
+	* tree.c: don't coalesce text nodes if they don't have the
+	  same behaviour wrt escaping on output
+
+Sun Feb 11 21:15:41 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: small fixup
+	* SAX.c: don't warn on empty namespaces.
+
+Thu Feb  8 11:28:58 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* README: a bit of cleanup
+	* configure.in: preparing for 2.3.0 release
+
+Thu Feb  8 10:37:00 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* hash.[ch]: added a first version of xmlHashSize()
+	* valid.c: another bug fix from Gary Pennington
+
+Wed Feb  7 19:22:37 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* valid.c: couple of bug fixes pointed by Gary Pennington
+	* HTMLtree.c: #if 0 cleanup
+
+Tue Feb  6 14:02:56 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: started profiling XSLT, added xmlXPathNodeSetAddUnique()
+	  which removes a time consuming check of xmlXPathNodeSetAdd()
+	  and use it in places where we are sure to not break unicity
+
+Mon Feb  5 18:51:36 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: bug fixes found from XSLT
+	* tree.c: preserve node->name special values when copying nodes.
+	* parserInternals.[ch] parser.[ch] SAX.c : added a mode where
+	  external subset are fetched when available but without full
+	  validation. Added xmlLoadExtDtdDefaultValue, need a function.
+	* HTMLtree.c: add support for xmlStringTextNoenc for XSLt HTML
+	  output with encoding disabled.
+
+Sat Feb  3 09:50:29 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xmliO.c: Harry Blundell pointed out that xmlCheckFilename
+	  xmlCheckFilename should not be called from xmlFileOpenW
+	  and xmlGzfileOpenW
+
+Fri Feb  2 18:04:35 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* uri.c: rewrite of xmlNormalizeURIPath from Paul D. Smith
+	* test/URI/smith.uri result/URI/smith.uri Makefile.am:
+	  added the new tests for URI normalization
+	* testURI.c: fixed stoopid bugs
+	* result/VC/OneID3 result/VC/UniqueElementTypeDeclaration:
+	  the URI in the error messages are now properly normalized
+
+Fri Feb  2 09:18:53 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* uri.c: applied Marc Sanfacon's patch for xmlNormalizeURIPath
+
+Thu Feb  1 05:28:55 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: fixed a number of problems in XPATH_XSLT_TREE processing
+
+Wed Jan 31 21:45:37 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: fixed mod operator
+
+Wed Jan 31 16:50:42 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* parser.c: fixed xmlStrcat doc
+	* tree.c: 2 fixes form Anders Carlson for copying nodes and
+	  trees.
+
+Wed Jan 31 14:19:16 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c result/XPath/tests/chaptersbase
+	  result/XPath/tests/simplebase: fixed XPath node() 
+	* tree.c: small fix in xmlNewNs()
+	* Makefile.am: removed extraneous xml2Conf.sh rule
+
+Sun Jan 28 08:37:03 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* Makefile.am configure.in libxml.spec.in example/Makefile.am:
+	  Changed the library name, in order to get libxml-devel and
+	  libxml2-devel to coexist on a single system
+	* xml-config.1 xml-config.in xmlConf.sh.in: renamed
+	* xml2-config.1 xml2-config.in xml2Conf.sh.in: new files
+
+Sat Jan 27 19:58:22 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* Makefile.am configure.in libxml-2.0.pc.in: started working on getting
+	  libxml2-devel installable in // as libxml-devel.
+
+Sat Jan 27 18:49:02 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* doc/Makefile.am: fixed make rebuild in doc
+	* doc/html/*.html: rebuilt the docs
+
+Fri Jan 26 10:30:58 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* tree.c: patch from Bjorn Reese on xmlBufferCCat
+
+Thu Jan 25 19:22:25 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* Makefile.am doc/Makefile.am libxml.spec.in: painful work to get
+	  the HTML doc to go into the -devel RPM ...
+	* aclocal.m4 config.h.in: some updates due to auto* magic
+
+Thu Jan 25 19:11:49 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.h: added a hook in the context structure allowing to
+	  link to extra support, needed for XSLT
+
+Thu Jan 25 13:34:11 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.[ch] xpointer.c: added xmlXPathCmpNodes, changed
+	  xmlXPtrCmpPoints to use it.
+	* propagated the following patch from Alejandro Forero
+	* include/win32config.h xmlIO.c: applied further suggestions
+	  from Igor Zlatkovic <igorz@dialup.nacamar.de> and cleanup
+	* example/gjobread.c: fixed warnings, now that it builds
+
+Wed Jan 24 20:27:28 COT 2001 Alejandro Forero <bachue@bachue.com>
+
+        * xmlIO.c (xmlFileOpen, xmlFileOpenW): Removed unnecesary checks.
+
+        * xmlIO.c (xmlCheckFilename): Function added to know whether a given
+          filename points to a valid file (not a directory).
+        * xmlIO.c (xmlFileOpen, xmlFileOpenW, xmlGzfileOpen, xmlGzfileOpenW):
+          Added calls to xmlCheckFilenameDir.
+
+        * xmlIO.c (xmlGzfileOpen, xmlGzfileOpenW, xmlFdOpen, xmlFdOpenW): Pass
+          `path' (rather than `filename') as the parameter to gzopen and open.
+
+Tue Jan 23 16:26:30 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* Makefile.am: fixed a problem with EXTRA_DIST
+
+Mon Jan 22 23:42:17 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* Makefile.am example/Makefile.am: finally found the trick
+	  to build the example, i.e. add "." in SUBDIRS before example
+	  in the list <grin/>
+
+Mon Jan 22 16:30:37 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* doc/xml.html: updated with an XSLT section, removed pointer to
+	  W3C CVS base.
+
+Mon Jan 22 11:43:21 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: when copying a XSLT tree object teh tree need to be copied
+	  too, and deallocation need to occur the same way.
+
+Mon Jan 22 10:35:40 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpathInternals.h xpath.[ch] debugXML.c: added the XPATH_XSLT_TREE
+	  type correponding to an XSLT result tree fragment. Share most
+	  of the data format with node set, as well as operators.
+	* HTMLtree.c: added a newline at the end of the doctype output
+	  whe this one is not present initially.
+	* tree.c: make sure taht the parent and doc pointers are properly
+	  set when copying attributes (lists).
+
+Sun Jan 21 10:47:38 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* htmlTree.[ch] xmlIO.h: exported htmlDocContentDumpOutput
+
+Fri Jan 19 18:15:50 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: seems I finally killed that ugly path evaluation
+	  context bug (tagged 9999 in case is is wrong)
+
+Fri Jan 19 06:30:38 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.[ch] xpathInternals.h: added xmlXPathRegisterVariableLookup()
+	  for XSLT
+
+Thu Jan 18 16:19:47 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xmlIO.c: Gary Pennington <Gary.Pennington@uk.sun.com> fix
+	  for xmlGzfileOpen() bug
+
+Thu Jan 18 13:11:50 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: removed an error found by XSLT usage
+	* tree.c parserInternals.h: use a predefined static string
+	  for text and comment nodes, avoid freeing them in xmlFreeNode,
+	  exported the string name in parserInternals.h and added
+	  another value to disable encoding at output (for XSLT),
+	  gain memory, time.
+
+Wed Jan 17 09:15:16 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* win32/README.MSDev win32/libxml2/libxml2_a.dsp
+	  win32/libxml2/libxml2_so.dsp: new makefiles and update
+	  provided by Igor Zlatkovic <igor@stud.fh-frankfurt.de>
+
+Tue Jan 16 18:24:46 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* tree.c : xmlSaveFile, xmlSaveFileEnc, applied patch from 
+	  Gary Pennington
+
+Mon Jan 15 20:24:18 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: fixed the comaprision of values and nodelists,
+	  need to compare nodelist still ...
+	* debugXML.c: avoided a possible core dump
+	* HTMLparser.c: cleanup
+	* nanohttp.c: contributed fix.
+	* tree.c: fixes in properties handling added xmlSetNsProp
+	  needed by libxslt
+	* xpathInternals.h: exported xmlXPathBooleanFunction, added a 
+	  comment
+	* TODO: updated
+
+Sat Jan  6 22:05:09 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* parser.c parserInternals.c: applied Bjorn Reese optimization
+	  patch
+
+Sat Jan  6 19:13:27 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* Makefile.am: applied patch fro make check from Martin Vidner
+
+Thu Jan  4 19:07:49 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* configure.in: preparing 2.2.11
+	* doc/html/*: rebuild the HTML files
+	* doc/xml.html : updated
+
+Thu Jan  4 14:09:58 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* tree.c: fixed a stupid bug
+	* valid.c: applied "Paul D. Smith" <pausmith@nortelnetworks.com>
+	  patches related to validation of an XInclude processing result
+	* TODO: updated
+
+Thu Jan  4 11:46:40 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* encoding.c xmlIO.c: Fixing the problem reported by Marc Sanfacon
+	  on large files
+
+Wed Jan  3 21:51:13 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xmlIO.c: fixed xmlParserInputBufferCreateMem doc
+
+Wed Jan  3 18:56:00 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* HTMLparser.c: htmlCheckParagraph to check htmlOmittedDefaultValue,
+	  reported by Jonas Borgström
+	* nanohttp.c: Applied Bjorn Reese' IPV6 first patch
+
+Wed Jan  3 16:19:39 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* testXPath.c xpath.c: fixing the XPath union expressions problem
+	  reported by  Martin Vidner <martin@artax.karlin.mff.cuni.cz>
+
+Wed Jan  3 14:22:33 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xmllint.c: Made is so if the file name is "-" is will read form
+	  standard input. Sven Heinicke  <sven@zen.org>
+	* tree.c: fixed a problem when growing buffer
+	* tree.h: fixed the comment of the node types following andersca
+	  comment
+	* TODO: updated
+
+Wed Dec 27 12:35:49 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* HTMLparser.[ch]: added a way to avoid adding automatically
+	  omitted tags. htmlHandleOmittedElem() allows to change the
+	  default handling.
+	* tree.[ch] xmllint.c: added xmlDocDumpFormatMemory() and 
+	  xmlDocDumpFormatMemoryEnc(), uses memory functions for output
+	  of xmllint too when using --memory flag, added a memory test
+	  suite at the Makefile level.
+	* xpathInternals.h xpath.[ch] xpointer.c: fixed problems
+	  with namespace use when encountering QNames in XPath evalation,
+	  added xmlns() scheme in XPointer.
+	* nanoftp.c : incorporated a fix
+	* parser.c xmlIO.c: fixed problems raised with encoding when using
+	  the memory I/O
+	* parserInternals.c: closed bug 25934 reported by 
+	  torsten.landschoff@innominate.de
+	* TODO: updated
+
+Sat Nov 25 11:46:27 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* configure.in doc/html/* doc/xml.html: made a 2.2.9 release
+	  on a non-updated tree :-(, made a 2.2.10 release to correct the
+	  situation
+
+Sat Nov 25 10:41:37 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* nanohttp.c parser.[ch] tree.[ch] xmlIO.[ch] xmllint.c xpath.c
+	  parserInternals.h vms/build_libxml.com vms/config.vms Makefile.am:
+	  integrated a set of OpenVMS changes from Howard Taylor
+	  <Howard.Taylor@pacoast.com>
+
+Sat Nov 25 01:21:01 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* tree.[ch] xmlIO.c: added xmlDocDumpMemoryEnc() from John Kroll
+	* error.c: applied fix suggested by "Leo Davidson" <leo@ox.compsoc.net>
+
+Sat Nov 25 00:24:49 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* HTMLparser.c: some fixes on auto-open of html/head/body
+	* encoding.c: fixed a compilation error on some gcc env
+	* xpath.c xpointer.[ch] xpathInternals.h: improved the
+	  XPointer implementation
+	* test/XPath/xptr/strpoint test/XPath/xptr/strrange3: added
+	  related XPointer tests and associated results
+
+Fri Nov 24 14:01:44 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* doc/xmldtd.html doc/xml.html: following a short step by step
+	  guidance on IRC to help maciej with DTDs I started a small
+	  page on the subject.
+
+Fri Nov 17 17:28:06 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* HTMLparser.c: fixed handling of broken charrefs
+	* xmlmemory.h libxml2.dsp include/win32config.h: reporting Windows
+	  patches
+
+Mon Nov 13 19:17:20 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* doc/xml.html doc/html/* : rebuilt the docs after adding
+	  xinclude and updated page for 2.2.7 and 2.2.8
+	* configure.in: releasing 2.2.8
+
+Mon Nov 13 12:39:38 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.[ch] parserInternals.c: applied the conditional
+	  section processing fix from Jonathan P Springer
+	  <jonathan.springer2@gte.net>
+	* xmlversion.h.in win32/libxml2/libxml2.dsp : Updated MS
+	  project file, fixed iconv default non support
+	* xpath.c: fixed the problem of evaluating relative expressions
+	  when a node context is provided.
+
+Sun Nov 12 16:31:19 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* nanoftp.c: fixed gcc 2.95 new warnings
+	* SAX.c: fixed a stupid bug
+	* tree.c: fixed a formatting problem when round-tripping
+	  from/to memory
+	* xinclude.c: chased memleak, fixed a base problem
+	* xpointer.c: added xmlXPtrBuildRangeNodeList(), finished ? 
+	  xmlXPtrBuildNodeList()
+	* TODO: updated
+	* Makefile.am test/XInclude/docs test/XInclude/ents result/XInclude:
+	  adding a first small set of regression tests for XInclude
+
+Tue Nov  7 15:11:34 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* nanohttp.[ch]: applied Wayne Davison patches to access
+	  the WWW-Authorization header.
+	* parser.c: Closed Bug#30847: Problems when switching encoding
+	  in short files by applying Simon Berg's patch.
+	* valid.c: fixed a validation problem
+	* hash.c parser.h parserInternals.h testHTML.c testSAX.c tree.h
+	  xmlerror.h xmlmemory.h xmlversion.h.in: applied a DLL patch from
+	  Wayne Davison
+	* xpointer.[ch]: added first version of xmlXPtrBuildNodeList()
+	  need to be extended to non full nodes selections.
+	* xinclude.c: starts to work decently
+
+Mon Nov  6 17:22:46 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* tree.[ch] xinclude.[ch] xmllint.c configure.in valid.c
+	  debugXML.c xmlversion.h.in: Started adding XInclude support,
+	  this is a new xmllint option
+	* tree.c xpath.c: applied TOM patches for XPath
+	* xpointer.c: fixed a couple of errors.
+	* uri.c: added an escaping function needed for xinclude
+	* testXPath.c hash.c HTMLtree.c: minor cleanups raised by
+	  new warning from RH70 gcc's version
+
+Tue Oct 31 14:14:13 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* HTMLparser.c: fixed loop on invalid char in scripts
+	* parser.c: update to description of xmlIOParseDTD()
+	* libxml.m4 xmlversion.h.in: changes contributed by
+	  Michael Schmeing <m.schmeing@internet-factory.de>
+	* configure.in: preparing for 2.2.7
+	* Makefile.am: trying to avoid  config.h and acconfig.h
+	  being included in the distrib
+	* configure.in: released 2.2.7
+
+Mon Oct 30 17:08:10 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* tree.[ch] debugXML.c parserInternals.c xpath.c: Deprecated Pi's
+	  like namespaces for good. Unified xmlNs and xmlNode somewhat.
+
+Mon Oct 30 16:26:49 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.[ch]: added xmlIOParseDTD()
+	* xpointer.c: added support for the 2 extra parameters of
+	  string-range, fixed a stoopid error when '0' was present
+	  in XPointer expressions
+	* test/XPath/xptr/strrange2 result/XPath/xptr/strrange2: added
+	  testsuite for the above
+
+Mon Oct 30 10:26:43 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* libxml.spec.in: improved package descriptions
+
+Sun Oct 29 19:03:11 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* xpath.c xpathInternals.h: applied a large cleaning patch
+	  from TOM <ptittom@free.fr>, it also add namespace support
+	  for function and variables registration.
+
+Sun Oct 29 18:51:46 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* uri.c: Wayne Davison's patch fixing xmlBuildURI()
+	* Makefile.mingw: Wayne Davison's update adding hash.c
+
+Sun Oct 29 18:38:12 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* xpath.c: fixed the root evaluation problems
+	* HTMLparser.c result/HTML/doc3.htm: fixed the problem of non
+	  ignorable spaces with <b> <bold> <em>
+	* tree.c: fixed a loop in xmlSearchNsByHref()
+
+Fri Oct 27 18:57:32 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* xpath.c: applied another XPath patch from TOM 
+	* xpath.c include/makefile.am: applied another patch from 
+	  china@thewrittenword.com (cleanup on IRIX).
+
+Fri Oct 27 13:45:28 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* xml-config.1: received a fixed version from Fredrik Hallenberg
+	  <hallon@lysator.liu.se>
+
+Thu Oct 26 16:05:25 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* xpath.c textXPath.c xpathInternals.h: applied TOM <ptittom@free.fr>
+	  cleanup patch for XPath
+
+Wed Oct 25 21:31:10 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* patched to redirrect all "out of context" error messages to
+	  a reconfigurable routine. The changes are:
+	* xmlerror.h : added the export of an error context type (void *)
+	  an error handler type xmlGenericErrorFunc there is an interface
+	  xmlSetGenericErrorFunc(void *ctx, xmlGenericErrorFunc handler);
+	  to reset the error handling routine and its argument
+	  (by default it's equivalent to respectively fprintf and stderr.
+        * all the c files: all wild accesses to stderr or stdout within
+	  the library have been replaced to calls to the handler.
+
+Wed Oct 25 15:27:19 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* configure.in: release 2.2.6
+	* xpath.[ch] xpointer.c xpathInternals.h: added xpathInternals.h
+	  exporting the inner functions of xpath for extension modules
+	* doc/*: updated and rebuilt the doc
+
+Wed Oct 25 12:48:55 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* nanohttp.c : applied Wayne HTTP cleanup patch
+	* tree.[ch]: applied TOM <ptittom@free.fr> for xmlNodeSetBase()
+	  and xmlNodeSetSpacePreserve()
+
+Wed Oct 25 12:11:03 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* xpath.c: closing bug #29260
+
+Tue Oct 24 18:49:34 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* hash.[ch] debugXML.c: expanded/enhanced the API, added
+	  multikey tuples, made hash structure opaque
+	* valid.[ch]: moved elements, attributes, notations decalarations
+	  as well as ID and refs to hash tables.
+	* entities.c: hash cleanup
+	* xmlmemory.c: fixed a dump problem in debug mode
+	* include/Makefile.am: problem passing in DESTDIR= values patch
+	  from Marc Christensen <marc@calderasystems.com>
+	* nanohttp.c: removed debugging remains
+	* HTMLparser.c: the bogus tag should be ignored (Wayne)
+	* HTMLparser.c parser.c: fixing a number of problems with the
+	  macros in the *parser.c files (Wayne).
+	* HTMLparser.c: close the previous option when opening a new one
+	  (Marc Sanfacon).
+	* result/HTML/*: updated the HTML results accordingly
+
+Sun Oct 22 18:39:19 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* entities.[ch] xpath.[ch] hash.[ch] debugXML.c tree.h: added/hacked
+	  hash tables from Bjorn Reese <breese@mail1.stofanet.dk>. Switched
+	  XPath functions and XML entities table to them. More to come...
+	* xmlIO.c: fixed libxml closing FILEs it didn't open.
+
+Sun Oct 22 13:59:50 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* tree.c: coalesce adjacent text nodes
+	* valid.c: handling of blank nodes in DTd validation (raised
+	  by problems with a posteriori validation).
+	* nanohttp.c: changing behaviour on HTTP write stuff.
+	* HTMLtree.c: forced body and html to be explicitely closed.
+	* xpath.h: exported more XPath functions.
+
+Sun Oct 15 22:28:32 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+        * Release of 2.2.5
+	* xpointer.c: range() range-inside and other helper functions
+	* parserInternals.c: fixed perf problem raised by rolf@pointsman.de
+
+Sun Oct 15 16:21:27 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* SAX.c: HTML attributes need normalization too (Bjorn Reese)
+	* HTMLparser.[ch]: addded htmlIsScriptAttribute()
+
+Sun Oct 15 13:18:36 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* doc/*: rebuilt docs preparing for 2.2.5 release, added URI
+	  and XPointer modules
+
+Sun Oct 15 12:13:30 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* SAX.h: closed #25107
+
+Sun Oct 15 12:06:16 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* testSAX.c: fixed problem with cdata reporting
+	* SAXresult/* : updated
+
+Sun Oct 15 12:00:24 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.c test/wap.xml result/noent/wap.xml result/wap.xml:
+	  Closed bug #27499, added to regression tests
+	* TODO: updated
+
+Sun Oct 15 01:34:37 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* HTMLparser.c HTMLtree.[ch] SAX.c testHTML.c tree.c: fixed HTML
+	  support for SCRIPT and STYLE with help from Bjorn Reese
+	* test/HTML/* result/HTML/*: added simple testcase and updated
+	  the existing ones.
+	  
+Fri Oct 13 18:24:31 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* xpath.c xpointer.c: XPointer reorder of ranges start/end and
+	  string-range for empty strings
+	* test/XPath/docs/str test/XPath/xptr/chaptersrange
+	  test/XPath/xptr/strrange: augmented the XPointer testsuite
+
+Fri Oct 13 12:21:48 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* doc/xml.html doc/xmlmem.html: added a module describing memory
+	  interfaces and use, updated the main page.
+
+Fri Oct 13 01:23:48 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* nanoftp.c nanohttp.c xmlIO.c: Wayne Davison Win32 patch
+	  nanoftp code work on Windows too now
+
+Fri Oct 13 00:54:37 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* testXPath.c xpath.[ch]: moved some debug functions to xpath core
+	* xpointer.c: implemented string-range() at least a good first version
+	* test/XPath/docs/str test/XPath/xptr/strrange
+	  result/XPath/xptr/strrange: the string-range() tests
+
+Thu Oct 12 10:02:59 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* Makefile.am include/Makefile.am include/win32config.h
+	  win32/Makefile.mingw: fixed problems reported by Wayne Davison
+	  and make distcheck
+
+Thu Oct 12 01:44:08 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* nanohttp.c: added xmlNanoHTTPTimeout(int delay), removed a bug
+	  xmlNanoHTTPMethod on input MimeType Tony Lam <Tony.Lam@eng.sun.com>
+	* xpointer.c: slight extension of xmlXPtrLocationSetMerge
+
+Thu Oct 12 01:37:53 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* config.h.in configure.in nanoftp.c nanohttp.c xmlversion.h.in :
+	  patch for socklen_t detection by
+	  Albert Chin-A-Young <china@thewrittenword.com>
+
+Wed Oct 11 17:53:57 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* tree.c valid.c xmllint.c: Fixed a few postvalidation bugs
+	  and added a --dtdvalid option to xmllint used to test it
+
+Wed Oct 11 15:01:29 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* xml-config.1 Makefile.am libxml.spec.in: adding a man page for
+	  xml-config by Fredrik Hallenberg <hallon@lysator.liu.se>
+
+Wed Oct 11 12:41:30 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* xpath.[ch] xpointer.[ch]: worked on XPath functions and variable
+	  handlings (registration, lookup, cleanup)
+
+Wed Oct 11 01:46:44 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* configure.in Makefile.am include/makefile.am: adding XPointer
+	  and XPtrtests target
+	* xpointer.[ch] : new files for XPointer support
+	* test/XPath/xptr result/XPath/xptr: added XPointer testsuite and
+	  more XPath tests
+
+Wed Oct 11 01:23:25 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* configure.in: fixed, very broken, make distcheck works again
+
+Wed Oct 11 02:53:10 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* More work toward 2.2.5, integrated a number of patches
+	* configure.in Makefile.am win32config.h.in: trying to cleanup
+	  make distcheck .... huh ...
+	* include/Makefile.am include/win32config.h: new directory
+	  for includes
+	* win32/Makefile.mingw win32/README.MSDev win32/libxml2/libxml2.dsp
+	  updated teh makefiles and instructions for WIN32
+	* xpath.c: small fixes
+	* test/XPath/ results/XPath: updated the testcases and results
+	* HTMLparser.c nanohttp.c testXPath.c: incorporated provided or
+	  suggested patches
+	* valid.c: fixed an ID bug
+
+Mon Oct  9 14:28:56 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* moved xml-error.h to xmlerror.h: seems this allowed to bypass
+	  the automake bug where wrong dependencies were generated.
+	* xpath.[ch]: worked on XPointer
+
+Fri Oct  6 12:58:04 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* configure.in Makefile.am: 2.2.5, ship the include in an
+	  include/libxml subdirectory, use symlinks when using CVS
+	* testSAX.c: fixed small bug
+	* testXPath.c: changed the way testfiles are parsed
+	* debugXML.c: same kind of cleanup when parsing an argument expression
+	  XPath/XPointers can have blanks embedded
+	* xpath.[ch]: more cleanup, reorgs for XPointer work
+	* parserInternals.c parser.c HTMLparser.c: fixed wrong include
+	* win32/README.MSDev win32/libxml2/libxml2.dsp: Windows stuff
+
+Thu Oct  5 18:13:15 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* debugXML.c testXPath.c xpath.[ch]: got pissed by some nastyness
+	  in the XPath engine, rewrote large parts of it, now it's far
+	  cleaner and in sync with the REC not an old WD. Fixed a parsing
+	  problem in the interactive XML shell found when testing XPath.
+
+Wed Oct  4 15:25:53 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* debugXML.c testXPath.c xpath.[ch]: More work on XPath/Xpointer,
+	  incorporated "(TOM)" <ptittom@free.fr> patches rebuilt the XPath
+	  examples with the extra test
+
+Wed Oct  4 14:39:01 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.c xmlIO.c xmlIO.h: fixed bug 26650, and improved
+	  the global init function.
+
+Tue Oct  3 11:28:52 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* HTMLparser.c: Doohhh, attribute name parsing was still case
+	  sensitive ! Fixed this ...
+	* result/HTML/* : updated the tests results accordingly
+
+Mon Oct  2 23:47:32 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* xpath.[ch] debugXML.c testXPath.c: fixed the XPath evaluation
+	  engine, should be far more stable, incorporated a new version of
+	  preceding/following axis, need testing
+        * uri.c: fixed file:///c:/a/b/c problem
+	* test/XPath/tests/idsimple: augmented the XPath tests
+
+Sun Oct  1 22:33:00 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* doc/* rebuilding docs for 2.2.4 release
+
+Sun Oct  1 22:16:33 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* configure.in: releasing 2.2.4
+	* parser.[ch]: added xmlStrEqual()
+	* HTMLparser.c HTMLtree.c SAX.c debugXML.c entities.c parser.c
+	  tree.c valid.c xlink.c xpath.c: converted all !xmlStrcmp to
+	  use xmlStrEqual instead
+	* TODO: updated
+	* added an XPath test
+
+Sun Oct  1 20:19:39 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* HTMLparser.c: fixed htmlStartCloseIndexinitialized init
+	* entities.h: exported xmlInitializePredefinedEntities
+	* parser.[ch] : added xmlInitParser()
+	* parserInternals.h : had to export htmlInitAutoClose()
+
+Sun Oct  1 16:28:22 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* xpath.[ch] : fixed some serious XPath Predicate evaluation
+	  problems
+	* Makefile.am : added XPath regression tests to normal tests
+	* uri.c: fixed a problem with local paths, cleanup
+	* parser.c: fixed a problem with large CData sections
+
+Sat Sep 30 16:35:54 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* configure.in xml-config.in: patch from "Ben Taylor"
+	  <sol7x86@hotmail.com> for solaris shared libs lookup
+
+2000-09-30  Martin Baulig  <baulig@suse.de>
+
+	* libxml-2.0.pc.in: Provide pkg-config script.
+
+	* configure.in: Create the libxml-2.0.pc script from the
+	libxml-2.0.pc.in templates.
+	* Makefile.am (pkgconfig_DATA): Install the libxml-2.0.pc
+	script in `$(libdir)/pkgconfig'.
+
+Mon Sep 25 16:23:41 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* HTMLparser.c parser.c tree.c tree.h: Avoiding a few warning
+	  when compiling with MSC
+
+Sun Sep 24 20:32:52 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* xpath.c: patch for normalize-string() substring-before(),
+	  substring-after() and translate() functions from Bjorn Reese
+	  <breese@mail1.stofanet.dk>
+	* libxml.m4 Makefile.am: added libxml.m4 from Debian ?
+	  Fredrik Hallenberg <hallon@lysator.liu.se>
+	* TODO: updated
+
+Sun Sep 24 10:00:49 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* xmlversion.h.in nanoftp.c nanohttp.c: traying to work out the
+	  problem of socklen_t being undefined on a number of platforms
+	* debugXML.c: fixed a compilation problem when without snprintf
+
+Sat Sep 23 12:19:45 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* HTMLparser.c uri.c: Another patch from Wayne Davison, correcting
+	  an URI bug and a fix for the control-character-induced infinite loop
+	* nanohttp.c: preventive fix for compiling on WIN32
+
+Fri Sep 22 18:06:08 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* xmlint.c: closing bug #25000
+
+Fri Sep 22 14:17:53 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* xmlIO.h tree.h: made xmlNodeDump() and xmlNodeDumpOutput() public
+	* parser.[ch] nanohttp.c HTMLtree.c HTMLparser.c tree.c: applied and
+	  modified slightly Wayne Davison patch adding xmlStrcasecmp and
+	  related function, fixing xmlStrncmp(), and associated cleanup
+	* result/HTML/entities.html.sax: updating result
+
+Tue Sep 19 14:20:10 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* uri.c: applied patch for URI escaping from Wayne Davison
+	  <wayned@blorf.net>
+	* tree.c parserInternals.c HTMLparser.c: memset checks patches
+	  from Denis Barbier <barbier@imacs.polytechnique.fr>
+	* HTMLparser.c: UTF8 characters in HTML tag-attribute values
+	  patch from Wayne Davison
+
+Sun Sep 17 18:37:03 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* doc/xml.html : updated with new releases, adding "how to help"
+
+Sun Sep 17 17:58:37 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* SAX.c debugXML.c parser.c parserInternals.c tree.c valid.c xpath.c:
+	  removed a few warnings in pedantic mode ...
+	* parserInternals.c parser.c: moved encoding switching function
+	  to parserInternals.c
+	* configure.in, doc/Makefile.am libxml.spec.in: released 2.2.3
+
+Sat Sep 16 20:12:41 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* HTMLparser.c parser.c: set ctxt->errNo before calling the
+	  error or warning handlers
+
+Wed Sep 13 22:03:18 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parserInternals.c parserInternals.h parser.c Makefile.am:
+	  created a new module parserInternals.c, moved most of the
+	  code shared by the various parsers there, as well as
+	  deprecated  code from parser.c. More cleanup of parser.c
+	* uri.c: fixed a problem when URI is NULL
+	* valid.c: speedup when looking for an attribute declaration
+
+Sun Sep 10 17:53:48 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* uri.c tree.c SAX.c parser.c entities.c debugXML.c: finished
+	  the cleanup of the computation of URI references when seeking
+	  external entities. The URI reference string and the resulting
+	  URI are both stored now.
+	* parser.c HTMLparser.c valid.c nanoftp.c nanohttp.c xpath.c:
+	  large s(n)printf checks and cleanup from Denis Barbier
+	  <barbier@imacs.polytechnique.fr>
+	* xmlversion.h.in tree.h: couple of SGML declarations for a
+	  possible docbook module.
+	* result/VC/ : a couple of test output changed due to the change
+	  of the entities URI
+
+Sun Sep 10 15:59:58 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.h: added a _private field for linking user's data
+
+Sun Sep 10 15:14:43 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.c parserInternals.h: demacroified most of the IS_XXX
+	  the gain in size is significant so ...
+
+Fri Sep  8 20:48:29 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* entities.c: cases where looking up entities with doc==NULL
+	  covered
+
+Tue Sep  5 12:41:15 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* uri.c: applied Wayne Davison patch
+	* Makefile.in test/URI/uri.data result/URI/uri.data: updated URI tests
+
+Mon Sep  4 13:01:45 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* uri.c testUri.c: applied Wayne Davison patches
+	* test/URI/uri.data result/URI/uri.data: first set of tests/results
+	* Makefile.in: added URItest and included thenin "make tests"
+
+Sun Sep  3 19:19:29 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* xmlversion.h.in: closed bug 22941
+
+Thu Aug 31 16:55:55 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* doc/xmlio.html: added doc and example for entity loader
+	  redefinition.
+
+Thu Aug 31 14:59:28 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* doc/xmlio.html doc/xml.html: added a doc on the I/O mechanism
+	  used by libxml
+
+Tue Aug 29 20:22:53 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.c: Fixed bug on invalid ontent characters and when using
+	  push.
+	* xmllint.c: fixed xmllint endling of errors in push mode
+
+Tue Aug 29 11:24:48 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* HTMLparser.c testHTML.c: applied two new patches from
+	  Wayne Davison <wayned@users.sourceforge.net>
+	* result/HTML/*.sax: regenerated HTML SAX output
+	* parser.c: more cleanup.
+
+Mon Aug 28 11:58:12 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* HTMLparser.[ch] testHTML.c: applied the second set of
+	  patches from Wayne Davison <wayned@users.sourceforge.net>,
+	  adding htmlEncodeEntities()
+	* HTMLparser.c: fixed an ignorable white space detection bug
+	  occuring when parsing with SAX only
+	* result/HTML/*.sax: updated since the output is now HTML
+	  encoded...
+
+Mon Aug 28 00:38:31 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* HTMLparser.[ch]: applied some of Wayne Davison
+	  <wayned@users.sourceforge.net> patches
+
+Sun Aug 27 22:14:01 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* SAX.c tree.c debugXML.c: fixed bogus behaviour when an
+	  undeclared namespace prefix was used, added a warning.
+	  Cleaned up support w.r.t. entities, spilling out a warning
+	  and being pedantic on lookups.
+	* test/warning/ent9 : added testcase for previous example.
+	* TODO: updated
+	* parserInternals.h parser.c: changed the way names are parsed
+	  now allow infinite size and decrease penalty for normal use
+	* parser.c: Started a big cleanup/check of the parser code,
+	  fixed some of the most tortuous entity code, spotted code
+	  unused anymore
+	* test/*: added tests for very long names and related nasty
+	  things.
+
+Sat Aug 26 23:31:04 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* doc/encoding.html: added encoding aliases doc
+	* doc/xml.html: updates
+	* encoding.[ch]: added EncodingAliases functions
+	* entities.[ch] valid.[ch] debugXML.c: removed two serious
+	  bottleneck affecting large DTDs like Docbook
+	* parser.[ch] xmllint.c: added a pedantic option, will be
+	  useful
+	* SAX.c: redefinition of entities is reported in pedantic mode
+	* testHTML.c: uninitialized warning from gcc
+	* uri.c: fixed a couple of bugs
+	* TODO: added issue raised by Michael
+
+Wed Aug 23 01:50:51 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* doc/encoding.html: propagated Martin Duerst suggestions
+
+Wed Aug 23 00:23:41 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.c: Fixed Bug#21552: libxml fails to decode &amp;
+	* uri.c testUri.c patches, by Marc Sanfacon (1 left)
+	* parser.c HTMLparser.c: HTML/encoding push problems reportedi
+	  by Wayne Davison
+
+Sun Aug 20 17:03:38 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* nanoftp.c nanohttp.c: small cleanup
+	* TODO: updated
+
+Sat Aug 19 22:57:02 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* added an old VC testcase and updated title.xml entity
+
+Sat Aug 19 21:02:08 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* HTMLparser.c SAX.c tree.c HTMLtree.h result/HTML/*: work
+	  done on auto-opening of <p> tags and cleanup of SAX output
+
+Sat Aug 19 18:45:40 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* libxml.4  xmllint.1 Makefile.am libxml.spec.in: added man pages
+
+Sat Aug 19 18:38:53 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* doc/xml.html libxml.* structure.*: updated the doc a bit
+
+Thu Aug 17 15:50:00 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* testSAX.c testHTML.c result/HTML/: cleanup of the output
+	  of SAX tests
+
+Mon Aug 14 13:56:33 EDT 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* Patch from Albert Chin-A-Young <china@thewrittenword.com>:
+	* xmllint.c: workaround a MAP_FAILEd definition bug in DU-4.0
+
+Mon Aug 14 11:10:20 EDT 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* Patch from Dave Yearke <yearke@eng.buffalo.edu>:
+	* testHTML.c: fix core dump on Solaris 2.x systems
+	* HTMLparser.c: fix segfault if ctxt->sax->characters() is NULL
+	* result/HTML/*.sax: previous bug fix lead to new results
+
+Mon Aug 14 10:26:09 EDT 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* Patch from Albert Chin-A-Young <china@thewrittenword.com>:
+	* configure.in: added --with-readline=DIR to accept alternate
+	  path for readline include/library
+	* configure.in: added AM_C_PROTOTYPES to add -Aa -D_HPUX_SOURCE
+	  for ANSI under HP-UX
+	* config.in: Removed @LIBS@ from xml-config because @XML_LIBS@
+	  includes @LIBS@
+
+Sat Aug 12 23:19:42 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* doc/* : rebuilt the docs
+	* getting ready for 2.2.2 release
+
+Sat Aug 12 16:42:37 EDT 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.[ch]: added xmlGetFeaturesList() xmlGetFeature()
+	  and xmlAddFeature()
+	* tree.[ch]: added xmlAddChildList()
+	* xmllint.c: MAP_FAILED macro test
+	* parser.h: added xmlParseCtxtExternalEntity()
+	* valid.c: applied bug fixes removed warning
+	* tree.c: added CDATA block to elements content
+	* testSAX.c: cleanup of output
+	* testHTML.c: added SAX testing
+	* encoding.c: better error recovery
+	* SAX.c, parser.c: fixed one of the external entity processing
+	  of the OASis testsuite
+	* Makefile.am: added HTML SAX regression tests
+	* configure.in: bumped to 2.2.2
+	* test/HTML/ result/HTML: added a few of HTML tests, and added the
+	  SAX results
+
+Fri Aug  4 11:21:50 PDT 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* configure.in: patch for HP compiler
+
+2000-08-04  Sven Heinicke  <sven@zen.org>
+
+	* xmllint.c: Was coredumping sometimes when the file given didn't
+	exist.
+
+Sat Jul 22 05:59:05 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.c xmlIO.[ch]: fixed the problem of encoding support
+
+	  when using in memory parsing. Need some cleanup.
+	* xmllint.c configure.in: added a --memory flag to test memory
+	  parsing
+	
+Fri Jul 21 17:09:57 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* nanohttp.c: fixed socklen_t replacement to unsigned int
+	* parser.c: fixed a space handdling missing at the end of
+	  production 28 DOCTYPE.
+	* xmlmemory.c: fixed a stupid bug on the routine to override
+	  allocation functions
+	* TODO: updated
+
+Fri Jul 14 17:01:14 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* doc/ regenerated the docs
+
+Fri Jul 14 16:12:20 MEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* doc/encoding.html doc/xml.html: added I18N doc
+	* encoding.[ch] HTMLtree.[ch] parser.c HTMLparser.c: I18N encoding
+	  improvements, both parser and filters, added ASCII & HTML,
+	  fixed the ISO-Latin-1 one
+	* xmllint.c testHTML.c: added/made visible --encode
+	* debugXML.c : cleanup
+	* most .c files: applied patches due to warning on Windows and
+	  when using Sun Pro cc compiler
+	* xpath.c : cleanup memleaks
+	* nanoftp.c : added a TESTING preprocessor flag for standalong
+	  compile so that people can report bugs more easilly
+	* nanohttp.c : ditched socklen_t which was a portability mess
+	  and replaced it with unsigned int.
+	* tree.[ch]: added xmlHasProp()
+	* TODO: updated
+	* test/ : added more test for entities, NS, encoding, HTML, wap
+	* configure.in: preparing for 2.2.0 release
+
+Mon Jul 10 16:17:18 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* nanoftp.c: fixed the way the control connection is handled
+	* libxml.spec.in: fixed the dependencies and cleanup
+
+Mon Jul  3 14:37:07 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* doc/xml.html: changed the xmlsoft.org structure, updated the
+	  examples w.r.t. root and childs
+
+Sun Jul  2 20:51:43 MEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* libxml.spec.in: fixed bug #7419, dependencies fouled for libxml-devel
+
+Sun Jul  2 09:52:45 MEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* HTMLparser.c: Work on character encoding support for the HTML parser
+	* HTMLparser.c: Fixed some autoopen/autoclose probs for the HTML parser
+	* encoding.c: Fixed a potential memleak in the encoding stuff
+
+Sat Jul  1 13:44:22 MEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* doc/FAQ.html doc/Makefile.am : added a FAQ
+
+Fri Jun 30 20:29:08 MEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* HTMLparser.c HTMLtree.c SAX.c valid.c tree.h : more cleanup
+	  of the HTML parser to force it to not bypass SAX
+
+Fri Jun 30 11:19:59 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* win32config.h.in: updated
+	* xmlversion.h.in: crap forgot to update this, this mean 2.1.0
+	  lacks iconv support :-( need to release 2.1.1
+	* configure.in: release 2.1.1
+	* HTMLparser: fixed bug #14784
+	* xpath.c HTMLparser.c encoding.c parser.c: fix warning raised
+	  by Windows compiler
+	* HTMLparser.c SAX.c HTMLtree.h tree.h: create HTML document in
+	  the SAX startDocument() callback.
+	* TODO: updated
+
+Thu Jun 29 12:06:48 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* added xmlStopParser()
+
+Wed Jun 28 23:10:26 MEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* configure.in: 2.1.0 prerelease
+	* Large resync between W3C and Gnome tree
+	* nanoftp, nanohttp.c: fixed stalled connections probs
+	* HTMLtree.c SAX.c : support for attribute without values in
+	  HTML for andersca
+	* valid.c: Fixed most validation + namespace problems
+	* HTMLparser.c: start document callback for andersca
+	* debugXML.c xpath.c: lots of XPath fixups from Picdar Technology
+	* parser.h, SAX.c: serious speed improvement for large
+	  CDATA blocks
+	* encoding.[ch] xmlIO.[ch]: Improved seriously saving to
+	  different encoding
+	* example/Makefile.am example/gjobread.c tree.h: work on 
+	  libxml1 libxml2 convergence.
+	* config.h.in parser.c xmllint.c: added xmlCheckVersion()
+	  and the LIBXML_TEST_VERSION macro
+
+Fri Jun 23 22:26:07 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* doc/xml.html: various patches and improvements typo fixed by
+	  Felix Natter
+	* doc/libxml-doc.el: Emacs module to lookup the libxml documentation
+	  from Felix Natter <fnatter@gmx.net>
+
+Sat May  6 10:09:45 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* doc/upgrade.html: updated with instructions for support of both
+	  libxml-1.x and libxml-2.x
+	* doc/gjobread.c : applied Todd Dukes <tdukes@ibmoto.com> patch
+	  for 2.x support and also fixed includes
+
+
+Wed May  3 14:21:25 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* encoding.[ch], xmlIO.[ch], parser.c, configure.in : revamped
+	  the encoding support, added iconv support, so now libxml if
+	  compiled with iconv automatically support japanese encodings
+	  among others. Work based on initial patch from Yuan-Chen Cheng
+	  I may have broken binary compat in the encoding handler
+	  registration scheme, but that was so utterly broken I don't
+	  expect anybody to have used this feature until now.
+	* parserInternals.h: fixup on the CHAR range macro
+	* xml-error.h, parser.c: catch URL/URI errors using the uri.c
+	  code.
+	* tree.[ch]: added xmlBufferGrow(), was needed for iconv
+	* uri.c: added xmlParseURI() I can't believe I forgot to
+	  implement this one in 2.0 !!!
+	* SAX.c: moved doc->encoding update in the endDocument() call.
+	* TODO: updated.
+
+Mon Apr 24 13:30:13 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* tree.h: removed extraneous xmlRemoveProp definition
+	* TODO: added item about --disable-corba configure switch
+	* tree.c parser.c: fixed problems for xmlCopyDoc and postvalidation
+	* nanoftp.c: fixed include problems giving troubles on AIX and 
+	  slowlaris
+	* xmlIO.[ch] valid.h tree.[ch] xlink.c xmlmemory.c uri.c 
+	  parser.c nanoftp.c nanohttp.c SAX.c testSAX.c :
+	  comment and headers changes to lower gtk-doc number of warnings
+	* doc/html/*: rebuilt docs
+
+Sun Apr 16 11:23:29 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* HACKING: documented the tag for 1.x and instructions
+
+Wed Apr 12 15:47:22 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* xmlIO.[ch] parser.[ch]: More interfaces for new I/O functions
+	  xmlNewIOInputStream, xmlParserInputBufferCreateIO,
+	  xmlCreateIOParserCtxt
+	* parser.c parserInternals.h: speedup of IS_CHAR like macros,
+	  significant overall improvement
+	* xmllint.c: added I/O test to xmllint
+	* testSAX.c: added a speed test
+	* doc/* : updated/regenerated
+
+Sat Apr  8 14:54:54 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* xpath.c uri.h parserInternals.h: cosmetic changes from
+	  "Timur I. Bakeyev" <timur@bat.ru>, including making 
+	  xmlCreateURI() public
+
+Fri Apr  7 18:35:02 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* xmlIO.[ch] parser.c: cleane up the xmlParserInputBuffer mess
+	  and the code at the same time. Added a clean mechanism for
+	  overload or added input methods: xmlRegisterInputCallbacks()
+	* tree.c: fixed xmlPrevSibling and xmlNextSibling per 
+	  Christophe Le Gal (Christophe.Le-Gal@imag.fr) input
+	* TODO: updated
+	* doc/* : updated/regenerated
+	* doc/Makefile.am: tweaks to avoid problem with libxml link in the
+	  source dir
+
+Wed Apr  5 21:11:35 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* testURI.c: yet another forgotten commit, I should get some sleep !
+
+Wed Apr  5 20:36:46 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* xmllint.c: forgot to commit this too ?
+
+Wed Apr  5 16:22:44 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* xmlversion.h.in : forgot to commit this previously
+
+Mon Apr  3 21:47:10 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* configure.in: preparing libxml-2.0.0 version looks Ok so far
+	* README TODO: updated for release
+	* uri.c uri.h: added authority parsing/saving
+	* uri.c testURI.c Makefile.am: moved the testing code to testURI.c
+	* xmlversion.h.in configure.in nanoftp.[ch] nanohttp.[ch] encoding.h
+	  debugXML.[ch] xpath.[ch] xmlIO.c tester.c testXPath.c testHTML.c
+	  tree.c HTMLtree.c HTMLparser.c tree.c tree.h parser.c
+	  Makefile.am : added compile-time customization of libxml
+	  --with-ftp --with-http --with-html --with-xpath --with-debug
+	  --with-mem-debug
+	* *.[ch] autoconf.sh : moved to an absolute adressing of includes : 
+	  #include <libxml/xxx.h> I hope it won't break too much stuff
+	  and will be manageable in the future...
+	* xmllint.c Makefile.am libxml.spec.in : renamed tester.c to xmllint.c
+	  and added xmllint to the installed programs
+	* uri.h: added xmlFreeURI()
+	  
+Fri Mar 24 14:35:21 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* uri.c uri.h: finished the escaping handling, the base support
+	  and the URI path normalization. Looks good just lacks the
+	  authority content parsing code.
+	* Makefile.am: added instructions to generate testURI
+	* TODO: updated
+	* doc/xml.html, doc/smallfootonly.gif doc/w3c.png: updated,
+	  added links and icons for W3C and Gnome
+
+Mon Mar 20 14:05:26 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* xmlmemory.[ch] : seems I forgot to actually update the files in
+	  the last commit :-)
+	* doc/xml.html doc/html/* : updated and uploaded the docs
+
+Mon Mar 20 12:33:51 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* test/valid/dtds/xhtml*: removed RCS infos (pain with CVS)
+	* TODO: updated
+	* xmlmemory.[ch] : added xmlMemSetup() and xmlMemGet() to override
+	  libxml default allocation function with another set (like gmalloc/
+	  gfree).
+	* Makefile.am, uri.c, uri.h: added a set of functions to do
+	  exact (litteraly copied from the RFC 2396 productions) parsing
+	  and handling of URI. Will be needed for XLink, one XML WFC, 
+	  XML Base and reused in the nano[ftp/http] modules. Still work
+	  to be done.
+
+Tue Mar 14 20:52:35 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* configure.in, libxml.spec.in : libxml2
+	* doc/* : updated the doc page, rebuilt the docs
+
+Tue Mar 14 19:11:29 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* all: tagged LIB_XML_1_X
+	* *.c *.h : updated from W3C CVS tree
+	* configure.in : 2.0.0-beta
+	* libxml.spec.in : libxml2 package nam
+	* result/* : new version of the tests output
+
+Mon Mar  6 09:34:52 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* doc/xml.html, doc/update.html: updated docs, 1.8.7
+
+Sat Mar  4 16:14:42 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* doc/* : rebuilt the docs
+	* parser.c: final patch on #6766
+	* valid.c: small patch on validity checks.
+
+Sat Mar  4 12:38:41 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* doc/upgrade.html: instruction on how to upgrade from 1.x to 2.x
+	  added
+	* parser.c: adding xmlKeepBlanksDefault() as a way to manage
+	  compatibility w.r.t. XML spec and existing code.
+
+Thu Mar  2 04:45:15 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.c: seems a better solution to <a>   </a> exists,
+	  will try it for a while
+
+Thu Mar  2 02:26:13 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.c: tried to remove the <a>   </a> generating <a/>
+	  this is hard. Left a flag for that purpose. Fixed bug #6766
+	* configure.in: prepared 1.8.7 not released, due to previous
+	  problem
+
+Thu Mar  2 03:03:50 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* doc/xml.html : applied second patch from Paul DuBois
+
+Tue Feb 29 23:55:13 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* doc/xml.html : applied patch from Paul DuBois
+
+Thu Feb  3 16:36:39 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.c HTMLparser.c: do a bit of bufferization in push mode.
+
+Thu Feb  3 15:59:37 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* nanoftp.c nanohttp.c tree.c HTMLtree.[ch] debugXML.c xpath.c: Fixed
+	  compilation warnings on various platforms.
+	* parser.c: Fixed #5281 validity error callbacks are now desactived
+	  by default if not validating.
+
+Thu Feb  3 13:46:14 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* nanoftp.c, win32config.h.in: patches to compile on WIN32
+
+Wed Feb  2 22:51:16 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* nanoftp.c: snprintf/sprintf patch courtesy George Katsirelos
+	  <gkatsi@cs.toronto.edu>
+
+Mon Jan 31 18:58:21 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* nanoftp.c nanohttp.c: Fixed '#' and '?' stripping when
+	  processing URLs
+
+Mon Jan 31 14:25:57 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* nanoftp.[ch]: cleanup, bug fixes, integration in rpmfind, added
+	  xmlNanoFTPUpdateURL for persistent control connections.
+	* configure.in: 1.8.6
+
+Thu Jan 27 17:52:29 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* nanohttp.[ch], nanoftp.[ch]: cleanup, added proxy support
+	* tree.[ch] : added xmlSaveNoEmptyTags
+
+2000-01-29  James Henstridge <james@daa.com.au>
+
+	* nanoftp.c: include <netinet/in.h> for IPPROTO_TCP.
+
+	* Makefile.am: added nanoftp.[ch] to the build.
+
+Wed Jan 26 18:14:55 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* nanoftp.[ch]: cleanup, comments, API
+	* debugXML.c : fixed a bug in the cat command
+	* doc/*: regenerated the docs
+
+Wed Jan 26 16:52:50 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* nanoftp.[ch] parser.c xmlIO.[ch]: added a Nano FTP implementation
+	* debugXML.c : fixed a bug in the cat command
+	* valid.c: fixing some small probs
+	* libxml.spec.in: get rid of the SNAP suffix
+	* doc/xml.html: updated the status
+
+Mon Jan 24 14:31:09 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* xml-config.in: xml-config --version to just return the
+	  version number
+	* xpath.c: some cleanup w.r.t. axis when the current node is
+	  an attribute.
+	* TODO: updated
+
+Tue Jan 18 18:46:06 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* configure.in: prepared for libxml-1.8.5
+	* doc/* recompiled the documentation
+
+2000-01-17  Jody Goldberg <jgoldberg@home.com>
+
+	* configure.in : WARNING autoconf subtlety alert :
+	  Use AC_CHECK_HEADERS rather than AC_CHECK_HEADER
+	  when looking for zlib.h so that HAVE_ZLIB_H is defined.
+	* config.h.in : Have a #undef for HAVE_ZLIB_H so that it will
+	  get defined by AC_CHECK_HEADERS.
+
+Mon Jan 17 17:04:12 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* tree.c: fixed a hideous bug in xmlGetProp() thanks to
+	  Rune.Djurhuus@fast.no
+
+Sat Jan 15 15:09:06 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* TODO: updated
+	* tree.c, parser.c: made sure that only memory alloc problems
+	  and internal parser errors are allowed to write to stdout or
+	  stderr.
+
+Thu Jan 13 11:49:11 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* tree.c : restored xmlNewGlobalNs since this seems used by
+	  a lot of existing code :-(, fixed a bug in xmlNewNs
+	* nanohttp.c: fixed a problem with INCLUDE_WINSOCK
+	* HTMLparser.c, parser.c, entities.c, valid.c : removed all calls
+	  to exit() from the library code.
+	* xpath.c, parser.c: removed bugs or unused code detected by 
+	  Windows compilers
+	* parser.c: started adding interfaces for parsing well balanced
+	  XML fragments
+	* configure.in: releasing 1.8.4
+	* doc/* : rebuilt the docs
+
+Sun Jan  9 23:03:20 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* tree.[ch] : added xmlNewDocFragment() for DOM
+	* testHTML.c: uninitialized variable.
+
+Wed Jan  5 17:29:17 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* doc/* : rebuild the docs
+
+Wed Jan  5 17:08:43 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* acconfig.h: readline and history patch
+	* valid.[ch]: added xmlRemoveID() and xmlRemoveRef()
+	* tree.c: added check and handling when possibly removing an ID
+	* tree.c, HTMLparser.h, HTMLtree.h: fixed entities parsing
+	     and saving.
+	* test/HTML/entities.html result/HTML/entities.html* : test for
+	     various entities reference cases
+	* result/HTML/* : as a result output of some testcase have
+	     changed
+	* HTMLparser.c, parser.c: fixed a bug in the push mode triggered
+	     by previous example. added xmlParseTryOrFinish().
+	* xpath.h tree.h parser.h valid.h xmlIO.h xlink.h encoding.h
+	  entities.h debugXML.h HTMLparser.h: changed the way struct are 
+	  declared to allow gtk-doc to expose those
+	* parser.c: closed bug #4960  
+	* Makefile.am configure.in: Applied patch from 
+	  Albert Chin-A-Young <china@thewrittenword.com> for better zlib
+	  and math/socket libs detection
+
+Mon Jan  3 18:29:43 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* configure.in, Makefile.am: link tester against readline
+	* doc/xml.html doc/*/*: updated and rebuilt the documentation pages
+
+Mon Jan  3 11:58:05 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* tree.[ch]: added xmlRemoveProp
+	* win32config.h.in nanohttp.c: avoid including the Windows
+	    socket stuff in every C files
+	* parser.c: removed an indetermination xmLDecl/PI(xml...) in
+	    the XmL parser(s)
+	* test/ns4 result/ns4 etc...: added test case for previous prob    
+	* tree.c: xmlNewNs wasn't checking for double definition
+	* Makefile.in: fixed a problem with dist-hook duplicates
+	* parser.[hc], xmlIO.c: fixed the loading of external entities
+	    APIs, now xmlLoadExternalEntity() is used everywhere and
+	    setting up an app specific front-end using the 
+	* SAX.c parser.c: some fixes, now the xhtml spec validates
+	    with the xhtml DTD.
+	* error.c: fixed crashes in case of no input stream    
+	* test/valid/[dtds/]/xhtml* : added the xhtml spec and dtds
+	    to the validation tests and results
+
+Wed Dec 29 15:29:52 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* HTMLparser.[ch] testHTML.c: added push mode for the HTML parser
+	  too htmlCreatePushParserCtxt() and htmlParseChunk()
+	* parser.c: a bit of cleanup.
+	* SAX.c, HTMLparser.c: some attributes may not have values (contrary
+	  to XML) removed the last mem leak known
+	* HTMLtree.c: output message cleanup
+	* xmlmemory.c: display content info about memory blocks
+	* result/HTML/wired.* : missing att value warning change
+
+Tue Dec 28 17:42:41 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* doc/* : rebuilt the documentation
+
+Tue Dec 28 18:44:22 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.[ch] parserInternals.h: Push parser for XML,
+	     seems to work fine now
+	* tester.c debugXML.[ch]: Added an XML shell debug facility and
+	     --push for push testing
+	* xpath.[ch] : cleaned up for Shell usage, added missing APIs
+	* testSAX.c: added --push
+	* HTMLtree.[ch] tree.[ch]: new functions for dumping parts of the
+	     subtree
+	* xmlIO.[ch] : enriched API + fixes for push mode     
+	* entities.[ch]: added the entity content length to the struct.
+	* xmlmemory.[ch]: new API to show the last entries for the shell
+	* valid.c: added required attribute testing
+	* SAX.c: the cdata callback now merge contiguous fragments
+	* HTMLparser.c: cleanup of some macros
+
+Wed Dec 22 12:20:53 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.c: fix for PIs name starting with xml
+	* tree.c: fixed a potential problem with || and && ops
+	* *.c, configure.in win32config.h.in : generate win32config.h for
+	  those on the Other Side !
+
+Tue Dec 21 17:22:17 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.c: fixed a stupid = vs. == bug :-(
+	* doc/gnome-xml.sgml: s/glade/xml/
+
+Tue Dec 21 14:29:34 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* configure.in, doc/xml.html : bug fix release 1.8.2
+	* debugXML.h nanohttp.h xml-error.h xmlmemory.h xpath.h : 
+	  Hopefully the end of that silly C++ include problem
+	* tree.[ch]: Added a few functions: xmlReplaceNode, xmlAddPrevSibling,
+	      xmlAddNextSibling, xmlNodeSetName and xmlDocSetRootElement
+	* HTMLparser.c HTMLparser.h HTMLtree.c: When saving HTML try to avoid 
+	      troubles with autoclosed elements when the stree shape doesn't
+	      follow the DtD specs. Added htmlIsAutoClosed() and
+	      htmlAutoCloseTag()
+	* result/HTML/*.htm*: Updated the HTML examples regression tests output
+	* SAX.c tree.c: fixed bug on defaulting namespaces on attributes
+	* debugXML.c: fixed a bug on printing default namespaces.
+	* HTMLtree.c: fixed a problem when outputing XML parsed docs as HTML
+
+Mon Dec 20 16:20:55 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* result/HTML/*.htm[l] : updated the HTML regression tests according
+	  to the new output
+	* xpath.h xml-error.h valid.h tree.h parser.h entities.h SAX.h
+	  HTMLtree.h tree.c entities.c: headers tweakings to avoid a nasty
+	  problem due to intermix of extern "C" { ... } declarations for C++
+	  and recursive includes in the headers
+
+1999-12-20  Chris Lahey  <clahey@umich.edu>
+
+	* HTMLtree.c: Made it so that html nodes with a single child do
+	not insert a carriage return before or after the child node.
+
+Sat Dec 18 16:07:03 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* configure.in, doc/xml.html : bug fix release 1.8.1
+	* parser.c: fixed bug #4344
+	* xpath.h xml-error.h xlink.h nanohttp.h debugXML.h SAX.h HTMLparser.h
+	  added the glue to avoid C++ problems
+	* doc/* : regenerated the documentation
+
+Thu Dec 16 16:19:29 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* tree.c: fixed a bug introduced in 1.8.0 and breaking default
+	  namespace recognition, and Dia as a resul :-(
+	* encoding.c: closed bug #3950
+
+Wed Dec 15 19:22:23 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* valid.c: debugging a posteriori validation, except URI expansion
+	  stuff this should be fixed now
+	* parserInternals.h: fixed a bug in IS_BASECHAR reported by
+	  Carl Nygard <cnygard@bellatlantic.net>
+	* tester.c: added --postvalid, cleaning of the code
+	* tree.[ch]: added xmlDocGetRootElement()
+	  
+Tue Dec 14 20:30:34 PST 1999 Ramiro Estrugo <ramiro@eazel.com>
+
+	* SAX.h, tree.h : changed 'namespace' to 'nameSpace' to workaround
+	c++ losage.
+
+Sun Dec 12 13:08:15 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* configure.in, doc/xml.html : bumped to 1.8.0
+	* xlink.[ch], Makefile.am : added framework for link detection
+	* parser.h: added nbChars to parser context, needed for cleanup.
+	* xmlmemory.c: removed a nasty bug when out of mem
+	* valid.[ch]: adding namespace support for attribute decl
+	* tester.c: added --debugent option
+	* debugXML.[ch]: added xmlDebugDumpEntities()
+	* parser.c: cleanup, avoiding use of CUR_PTR like plague, using
+	  buffers instead, this was really needed, validation was breaking
+	  in strange ways due to that. Added xmlParseStringPEReference()
+	  and other parsing from strings functions. Entities processing
+	  modified again, but PERef are still not handled correcly but
+	  unless you're Eve Maller you won't notice :-)
+	* HTMLparser.c: large changes toward reliability, and switched to
+	  lowercase internal tags, XHTML is lowercase, so it will help
+	  that output is closer to next version.
+	* doc/* : regenerated the documentation, it is now hosted at
+	  http://xmlsoft.org/ (same bits I just bought the domain :-)
+	
+	
+Fri Dec  3 13:46:32 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* SAX.h, SAX.c, makefile.am: added SAX.h mostly useful for the
+	         doc generation
+	* parser.c: fixed bugs #3908 and #3937 and a memory leak
+	         in the SAX API
+	* doc/*: rebuilt the doc making sure everything appears in the
+	         HTML files
+
+Wed Dec  1 10:27:47 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* tree.[ch] HTMLtree.c, debugXML.c, configure.in, xml-config.in:
+	     added the patch from Carl Nygard <cnygard@bellatlantic.net>
+	     which allow impressive speed improvement on dataset with
+	     large text pieces, but at the cost of broken binary
+	     compatibility and slightly bigger memory usage.
+	     Configure with --with-buffers to activate them, they
+	     are protected with XML_USE_BUFFER_CONTENT define.
+	* entities.[ch], parser.c: added xmlCleanupPredefinedEntities(),
+	     goal is 0 memory left allocated once parser is no more used
+	* testDAV.c, testHTML.c, testSAX.c, testXPath.c: make sure we
+	     call xmlCleanupParser() and xmlMemoryDump()
+
+Wed Nov 24 19:00:06 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* tree.[ch] xmlIO.[ch] parser.c valid.c: code cleanup with -pedantic
+	* parser.[ch] encoding.[ch]: added memory cleanup routines
+	* parser.c: closing bug #3788
+	* doc/*: rebuilt the doc
+
+Tue Nov 23 11:23:55 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* tree.[ch]: closing bug 3748, added xmlNewDocRawNode(), 
+	             xmlNewTextChild() and xmlSetCompressMode() behaviour.
+	* tester.c: added --compress option
+	* doc/*: rebuilt the documentation
+
+Fri Nov 19 18:41:28 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* HTMLparser.c: bugfixing, the damn thing MUST not crash even
+	                if given /proc/kcore as input !
+	* doc/xml.html doc/*: updated and rebuilt the documentation
+
+Thu Nov 18 14:57:18 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.c: Fixed some wrongly space collapsing code due to
+	            a misreading of the spec.
+	* result/*: fixed the output accordingly	    
+
+Wed Nov 17 18:28:06 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* encoding.c: bug fix and typos
+	* xmlIO.[ch] parser.c: first bits toward real progressive parsing
+	* parser.c: added attribute normalization closing bug #3597
+	* test/att* result/att* SAXresult/att*: testcase for attribute
+	    normalization
+
+Mon Nov 15 18:50:56 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* configure.in: closing bug #3163 by adding extra flags for the
+	                cc compiler on HP-UX
+
+Fri Nov 12 17:41:20 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* valid.[ch] : removed a typo and an enumerated type bug in the
+	               xmlAddElementDecl() function
+	* tree.c : I changed xmlSetProp() and xmlNewProp() to do the
+	    call to xmlEncodeEntitiesReentrant() so that the functions 
+	    New, Set and Get are at the same level.
+	* parser.c HTMLparser.c: extra memory allocation bug for
+	    attributes detected by someone using libxml in embedded systems :-)
+
+Thu Oct 28 17:49:26 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* xmlmemory.h: turned off mem debug :-\
+
+Mon Oct 25 12:13:25 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.c: closed bug #2784 a one line fix, but worth pushing
+	            a new release out
+        * HTMLparser.c: fixed auto-close bugs on list items, zeroing
+	            some structures, comments before and after the
+		    main element, and other nastyness
+	* HTMLtree.c tree.c: accomodate the extended HTML supported	    
+	* configure.in: pushing 1.7.4
+	* test/ent8 and related outputs : added a new test for bug #2784
+	* test/HTML/wired.html and related output: a nasty HTML example
+	* Makefile.am: improved the test scripts
+	* docs/* : reran the documentation extractor, updated xml.html
+
+Thu Oct 14 10:29:56 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* HTMLparser.c, HTMLtree.c, tree.h: completely revamped the
+	     HTMLparser and debugged the HTML related code. HTML documents
+	     now have their own type
+	* entities.c: do not dump &apos; for HTML output
+	* xmlmemory.c: improvement, breakpoint mechanism
+	* testHTML.c: added --sax --repeat ...
+	* Makefile.am: improved the HTML tests
+	* valid.[ch]: added xmlValidGetValidElements and
+	              xmlValidGetPotentialChildren
+	* tester.c: added --insert to test the 2 new functions
+	* test//* result//* SAXresult//* : regression test cleanup
+	               and extension.
+	* doc/html : added doc for new modules gnome-xml-xmlmemory.html and
+	             gnome-xml-nanohttp.html
+
+Mon Oct 11 14:31:58 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* HTMLparser.c: fixed problems with some autoclose tags
+	* tree.c: fixed XML output problems. 
+	* result/* SAXresult/*: update of the tests output
+
+Sat Oct  9 11:02:57 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* Makefile.am: Arturo patch for xmlConf.sh version info
+	* parser.c: Tim Josling patch for single quoted items
+	* tester.c: Tim Josling patch for tester options usage
+	* tree.h: indent cleanup
+
+Fri Oct  8 16:35:37 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* HTMLparser.c parser.h : Fixed problems with HTML parsing
+	    reported by Kristian Hogsberg Kristensen <hogsberg@daimi.au.dk>
+
+Fri Oct  8 11:37:11 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* tree.c : Raph patch for initialization of CORBA fields
+	* parser.c, xpath.c, ...: modification of doc comments
+	* xpath.c : allow spaces in xpath expressions
+
+Mon Sep 27 10:16:43 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* xmlmemory.h: turning off memory debug :-(
+
+Sun Sep 26 13:16:54 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.[ch] : added xmlSAXUserParseFile() and xmlSAXUserParseMemory()
+	                better SAX interfaces.
+	* testSAX.c: uses the new SAX routine, avoid fetching any remote
+	             entity.
+	* configure.in: 1.7.2
+
+Fri Sep 24 16:01:01 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* libxml.spec.in: fixed the URL
+	* doc/xml.html: improved the documentation front-end
+
+Fri Sep 24 01:06:36 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* nanohttp.c: conditionned references to snprintf with HAVE_SNPRINTF
+
+Fri Sep 24 00:15:58 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* libxml.spec.in: fixed the alpha compile problem
+	* parser.[ch]: changed errno to errNo in the parser context :-(
+	* *.[ch]: changed CHAR to xmlChar to avoid problem on WIN32
+	* doc/xml.html: changed CHAR to xmlChar
+	* doc/html/*: recompiled the documentation
+	* configure.in: 1.7.1
+
+Wed Sep 22 11:40:31 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.h: modified the parser context struct to regain 1.4.0
+	            binary compatibility
+	* parser.c, xml-error.h: added errno ot teh context and defined
+	            a set of errors values with update of errno
+	* nanohttp.[ch]: minimalist HTTP front-end for fetching remote
+	            DTDs and entities
+	* *.h, *.c: complete cleanup of the use of config.h and include
+	            protection depending on the current setup.
+	* overalll debugging, maintenance and bug-fixing on all modules
+	* updated the documentation
+	* ready for 1.7.0
+
+Wed Sep  8 22:46:14 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* HTMLparser.c : cleanup
+	* SAX.c valid.c valid.h: added ID/IDREF checking
+	* tree.c tree.h: extended doc structure for refs
+	* configure.in: 1.6.2
+	* parser.c: patched bug in SAX user arg call
+	* parserInternals.h: patched missing close in C++ wrapping
+	* testXPath.c xpath.c xpath.h: prepared for extensibility,
+	  especially upcoming XPointer implementation.
+	* doc/xml.html: augmented, typo
+
+Sat Sep  4 22:48:05 CEST 1999 Timur Bakeyev <mc@bat.ru>
+
+	* doc/Makefile.am: replaced "install -d " with "mkinstalldirs" -
+	not all invocations of install understand -d.
+
+Sat Sep  4 22:20:07 CEST 1999 Timur Bakeyev <mc@bat.ru>
+
+	* Makefile.am: prepend all the test* calls with $(top_builddir) -
+	to make 'check' works, when builddir != srcdir.
+
+Sat Sep  4 20:25:46 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* doc/xml.html : updated the documentation
+
+Fri Sep  3 00:01:08 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* xmlmemory.[ch] Makefile.am  :added a memory wrapper to chase
+	      not deallocated memory blocks
+	* *.c : replaces all calls to malloc() free() and realloc() to
+	      the wrapper functions/macros
+	* tree.c : removed memory leaks dues to calling xmlFreeNode()
+	      instead of xmlFreeNodeList()
+
+Wed Sep  1 14:15:09 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* HTMLparser.c: corrected a stupid bug leading to core dump at
+	                tree deallocation. Removed warnings indicated by
+			Stephane.Conversy@lri.fr
+	* entities.c: Fixes Yet Another Stupid Bug, entities were not
+	              looked for in the external subset
+
+Mon Aug 30 13:22:26 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.c valid.[ch] xpath.c: patched compilation warnings reported
+	  on SGI by Stephane.Conversy@lri.fr
+
+Sun Aug 29 22:27:29 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* all .h : changed the prototype declaration indent as in gtk
+	* most .c : working on reducing the TODOs in the code
+	* most .c : cleanup though -pedantic and Insure++
+	* improvements on validation ID checkings.
+	* tree.[ch] SAX.c: added support for namespace on attributes #2022
+	* xml-config.in: closed #1810
+
+Mon Aug 16 03:27:38 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* tree.h, valid.c, valid.h: more work on validity, IDs
+	* xpath.c: added/fixed comparidon and equlity, added a new isinf
+	  definition for AIX
+
+Sun Aug 15 21:15:17 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* Makefile.am libxml.spec.in: corrected missing xmlConf.sh in
+	  the distribution due to a cut'n paste error at last commit
+
+Tue Aug 10 20:28:09 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* configure.in: upgraded to version 1.4.0
+	* valid.[ch], SAX.c, parser.[ch] parserInternals.h ...
+	  Big update, added a large part of the validation process,
+	  it should be usable, but some parts are missing
+	* xpath.c: improved the implementation w.r.t. root.
+	* Makefile.am: added more tests
+	* test and result trees: added a lot of tests
+	* libxml.spec.in: export libxml.so.0 and libxml.so.1
+
+Tue Aug 10 11:33:41 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* Added an HACKING file
+
+Tue Jul 27 21:43:00 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+        * xpath.[ch] : improvements and debug of the XPath implementation
+        * parser.c, HTMLparser.c : modified the parsers to be progressive
+	* tree.[ch] : extended the Buffer promitives
+	* xmlIO.[ch] : added basic I/O routines providing progressive
+	  parsing and ready for I18N conversion plugins
+	* SAXresult/* : the SAX callback sequence maybe slightly different
+	  now
+	* test*.c : improved/updated the tests programs
+	* doc/* : recompiled the docs.
+
+1999-07-26  Michael Meeks  <michael@edenproject.org>
+
+	* tree.h: Add const to 'content' in xmlNewDocNode, xmlNewChild
+
+	* tree.c: Ditto.
+
+Thu Jul 15 16:17:16 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* configure.in: upgraded to version 1.4.0
+	* xpath.c, xpath.h, testXPath.c, makefile.am: added code for the XPath
+	  draft from W3C. Will be used by XPointer, Xlink, XSL, and possibly
+	  XML query language, see http://www.w3.org/TR/xpath for more details.
+	* parser.c, parser.h: added CHAR* related string functions for XPath
+	* HTMLparser.[ch], HTMLtree.c: a bit of cleanup on entities.
+	* doc/gnome-xml.sgml, doc/html/* : added XPath and HTML documentation,
+	  rebuild the docs.
+	* Makefile.am, test/XPath/*, result/XPath/*: added an XPathtests target
+	  and regression testing capabilities for XPath.
+
+Mon Jul 12 12:36:39 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.c, HTMLparser.c: applied patch from John Ellson <ellson@lucent.com>
+	  closing bug #1646
+
+Mon Jul 12 11:04:44 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* Makefile.am, example/Makefile.am: closed bug #1683
+
+Sun Jul 11 18:16:34 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* example/Makefile.am, configure.in: added the makefile for the
+	  gjobread example
+
+Sat Jul 10 14:19:11 CEST 1999 Tomasz K³oczko  <kloczek@pld.org.pl>
+
+        * doc/Makefile.am:
+        - fix which allow "make install DESTDIR=</install/prefix>".
+
+Fri Jul  9 12:10:24 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* HTMLparser.c parser.c: applied patch from John Ellson <ellson@lucent.com>
+	  which fixed a problem on the file reading-code.
+
+Wed Jul  7 09:28:43 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* HTMLparser.[ch], HTMLtree.[ch]: more work for HTML parsing and
+	  output.
+        * Makefile.am, test/HTML/*, result/HTML/*: added HTMLtests targetestHTMLt
+
+Wed Jul  7 00:25:42 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.h : Oops removed the binary compatibility problem
+	* HTMLparser.[ch], HTMLtree.h : More work on the HTML parse/dump
+	* parser.c, HTMLparser.c: applied patches for reading from stdin
+
+Mon Jul  5 18:45:31 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.c, entities.c, valid.c: cleanup bug #1591
+	* configure.in: cleanup bug #1592
+	* HTMLparser.[ch], testHTML.c: started adding an HTML parser using
+	  the same tree back-end. Hence gdome will be available for it.
+	* doc/Makefile.am: close bug #617
+
+Sat Jun 26 23:36:38 EDT 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.c: alloctate a per parser context SAX interface block
+
+Tue Jun 22 23:46:32 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* released 1.3.0 with xmlEncodeEntities restoring old behaviour
+	  and xmlEncodeEntitiesReentrant with the correct one :-\
+
+Mon Jun 21 14:07:53 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* commit of my internal XML base changes, quite a lot of
+	  changes, cleanups, better entities support, framework for
+	  new I/O and charset detection and handling
+	* Fixed the configure/Makefile stuff to generate shared libs
+	  with the proper version info, so we jumped on rev from
+	  0.0.0 to 1.2.0 ! The binary interfaces have been broken,
+	  xmlEncodeEntities() result need to be freed now, and a string
+	  xmlParserVersion provide the current library version.
+
+Tue Jun 15 14:24:19 1999  Raph Levien  <raph@acm.org>
+
+	* parser.c: fixed a buffer overrun for when you have a very long
+	attribute with no entities in it.
+
+Mon Jun 14 00:17:50 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* added example directory
+	* added example/gjobs.xml gjobread.c, still need a Makefile.in
+
+Wed Jun  2 19:40:58 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* Release of libxml-1.1, nearly everything has been touched for
+	  this.
+	* Added more regression tests
+	* Updated the documentation
+
+Sat May 29 13:34:42 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* tree.[ch]: unified the XML_NO_CORBA defines.
+	* parser.c encoding.[ch]: started plugging in char encoding detection
+
+Fri May 28 22:58:42 EDT 1999 Manish Vachharajani <mvachhar@vger.rutgers.edu>
+
+	* tree.c: (xmlSaveFile) - removed double call of xmlContentDump.  
+	  Also freed allocated buffer.
+
+Wed Apr 21 22:07:35 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+	* parser.[ch] tree.[ch] entities.[ch] valid.[ch] : removed the main
+	  reentrancy problem at printing. One is left in entities.c, to
+	  remove ASAP
+	* testSAX.c : added a test example showing the use of the SAX 
+	  interface if one doesn't want to build the DOM tree.
+	* html/gnome-xml-*.html html/index.sgml: regenerated the documentation
+
+Mon Apr  5 14:14:40 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.[ch] tree.[ch] SAX.c, parserInternals.h valid.[ch]:
+	  large revamping of the parser to use SAX callbacks
+	  http://www.megginson.com/SAX/ (or at least a C like interface
+	  a la Expat). It's now possible to set up your own callbacks
+	  and the parser will not build a DOM tree.
+	* test/* result/*: updated the test suite, I finally removed
+	  the old Namespace draft support (PI based).
+
+Fri Apr  2 17:57:32 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* Makefile.am: added test result to EXTRA_DIST for make tests
+
+Wed Mar 24 21:37:02 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.c, parserInternals.h: moved the chars macro definitions
+	  to parserInternals.h
+	* parser.c, error.c: applied patches from "Knut Åkesson"
+	  <ka@s2.chalmers.se> for clean compilation under MSVC 6 :-o
+
+Tue Mar 23 11:10:15 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* xml-config.in : applied patch to make --version work
+
+1999-03-05  Raja R Harinath  <harinath@cs.umn.edu>
+
+	* Makefile.am (check-local): Alias for `tests' target.  This will
+	cause `make check' to do the right thing.
+	(tests): Don't run tests in srcdir.  Also, replaced calls to
+	basename with a `sed' "equivalent".
+
+Fri Mar  5 07:23:53 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* Renamed error.h to xml-error.h, corrected Makefile.am to list
+	  it in the header and not the sources, updated the doc.
+	  Thanks to Tim Mooney <mooney@dogbert.cc.ndsu.nodak.edu> for
+	  pointing this out.
+
+Mon Mar  1 13:27:17 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.c, parser.h, parserInternals.h: memory leak hunting,
+	  exported the inputStream routines.
+	* doc/html/* : updated accordingly
+
+Sun Feb 28 22:51:33 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.c, parser.h, parserInternals.h: added a few extra
+	  internal calls to allocate and free parser contexts ...
+	* doc/html/* : updated accordingly
+
+Thu Feb 25 11:52:24 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* configure.in, Makefile.am, doc/makefile.am : General changes for
+	  1.0.0 release and including the generated HTML documentation.
+
+Thu Feb 25 09:44:52 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* makefile.am : added parserInternals.h, oops.
+
+Mon Feb 22 11:24:56 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parserInternals.h: added this header giving access to the parser
+	  internal functions.
+	* doc/Makefile.am : added a rebuild target which rebuilds the full
+	  set of documentations
+	* parser.[ch] tree.[ch] valid.[ch]: serious updates w.r.t. parsing
+	  the internal subset. 
+	* *.c *.h: modifications needed to generate the documentation using
+	  gtk-doc, cleanup of functions blocks, reorganisation of struct
+	  declarations.
+
+Tue Feb 16 17:27:29 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* Makefile.am, spec, doc/Makefile.am : upgrading to 0.99.8, fixing
+	  the tar and spec file to include the beginning of the doc.
+
+1999-02-13  Nuno Ferreira  <nmrf@rnl.ist.utl.pt>
+
+	* doc/.cvsignore: Added this file.
+
+Mon Feb  8 19:27:56 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* tree.c: fixed xmlGetProp to return "" when the attribute
+	  exists, even if the node-list is NULL.
+
+Mon Feb  8 16:10:15 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* tree.c: patched an error outputting empty attribute values.
+	* Makefile.am and doc/makefile.am: have been updated during the
+	  week-end. Sorry for an empty CVS log, I got a shell problem.
+
+Mon Feb  1 12:10:13 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* tree.h: cleaned up using enums instead of defines
+	* parser.c, valid.[ch]: more work on parsing/output of element
+	  declarations
+
+Sun Jan 31 22:06:48 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* valid.[ch], tree.c, parser.c : more work toward full parsing
+	  of XML DTDs.
+	* README: added informations about mailing-list and on-line
+	  documentation
+
+1999-01-27  Raja R Harinath  <harinath@cs.umn.edu>
+
+	* configure.in (XML_INCLUDEDIR): Use -I not -L for includes.
+
+Sun Jan 17 20:06:36 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.c, tree.[ch] : more work toward conformance testing,
+	  added a last element to accelerate parsing of very flat structures
+	  started working on internal subset Element content declaration.
+	* valid.[ch] : first cut at adding code toward validation.
+	* previous changes had also small impact on most files, especially
+	  the conformance testing using James Clark test suite.
+
+Sun Jan 17 14:45:06 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* test/* : updated the examples, most of them were not well
+	           formed (humm), and added rdf2.
+	* result/* : resulting changes in the output.
+
+Sun Dec  6 13:06:58 EST 1998 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* tree.c: changed the behaviour of xmlGetProp on NULL values.
+
+Sat Dec  5 12:25:09 EST 1998 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* tree.c: patched a bug in the generation of empty attributes
+
+Fri Nov 27 01:36:54 EST 1998 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* entities.[ch], tree.[ch], tester.c: added copy interfaces
+	  for node/trees/documents/... Biggest problem is namespace
+	  support when copying subtrees.
+
+Sun Nov 15 19:59:47 EST 1998 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.c, entities.c: improve entities and char ref encoding,
+	  and cleanups of error messages.
+
+Fri Nov 13 13:03:10 EST 1998 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.c, entities.c: simple bug hunting done during rpm2html and
+	  rpmfind integration.
+
+Sun Nov  8 13:11:07 EST 1998 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.[ch]: Added interfaces allowing to specify a SAX
+	  handler before parsing.
+
+Sun Nov  8 09:39:17 EST 1998 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.c: redirrect all errors reporting through the SAX
+	  error function
+
+Wed Nov  4 14:21:54 EST 1998 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* entities.c: rather use HAVE_SNPRINTF and not depend on glib
+	* libtool, tlmain ...: update of the libtool files
+
+1998-11-04  Miguel de Icaza  <miguel@nuclecu.unam.mx>
+
+	* entities.c: Use g_snprintf insteda of snprintf.
+
+Sun Nov  1 14:31:06 EST 1998 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* entities.c, parser.c: debug and cleanup of CharRef handling/saving.
+	  added ent5 test for this purpose.
+	* parser.c, parser.h: formatting, comments and UTF-8 planning.
+
+Fri Oct 30 01:36:52 EST 1998 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.c: fixed? a strange error due to compression on a GWP
+	  document.
+
+Thu Oct 29 00:48:45 EST 1998 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* tree.[ch]: bug fixing
+	* entities.[ch]: defined a specific type for predefined entities
+	* doc/xml.html: more documentation on the library, how to use it,
+	  overview of the interfaces.
+
+Wed Oct 28 17:56:35 EST 1998 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* tree.[ch]: more cleanup on the API, made the tree mor conformant.
+
+Tue Oct 27 17:54:00 EST 1998 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* tree.c: corrected a small bug
+	* doc/xml.html: continuing writing documentation.
+
+Tue Oct 27 17:54:00 EST 1998 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* debugXML.h debugXML.c: added debugging utilities.
+	* tester.c: added --debug switch.
+	* tree.c: patched an incorrect node->type assignment.
+	* parser.c: formatting, ensure that node->doc != NULL in attributes
+
+Tue Oct 27 01:15:39 EST 1998 Daniel Veillard <Daniel.Veillard@w3.org>
+
+        * parser.[ch] SAX.c tree.[ch]: large amount of changes to improve
+          entity support and provide an internal representation close to
+          DOM one (entity ref nodes, and attribute value as tree). I tried
+          to preserve the interface but this will surely break some apps
+          (I have to change rpm2html/rpmfind for example). I had to change
+	  two interfaces, and the generated tree is somewhat different.
+	* doc/* : started documenting the XML library, the tree and
+	  DOM/Corba. This is a first step.
+
+Sat Oct 24 14:23:51 EDT 1998 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.c: Set up the fonctions comment block, boring but useful.
+	* parser.h, SAX.c, parser.c: now attributes are processed through
+	  the SAX interface. The problem is that my SAX interface diverged
+	  quite a bit from the original one, well this is not an official
+	  spec, and translating it from Java to C is hairy anyway...
+
+Tue Oct 20 02:11:21 EDT 1998 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* SAX.c, entities.c, tree.c, encoding.c, error.c: Set up the
+	  fonctions comment block, boring but useful.
+
+Sun Oct 18 20:40:58 EDT 1998 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* encoding.[ch], Makefile.am: Added the UTF-8, UTF-16 and ISO Latin 1
+	  conversion routines. However they are not yet used to convert the
+	  inputs. The core will run with UTF-8.
+
+Sun Oct 18 15:08:19 EDT 1998 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* tree.c : make sure that the type id is properly set-up when
+	  a new object is allocated, needed for DOM.
+
+Sat Oct 17 02:43:21 EDT 1998 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* tree.h, tree.c: Ok, the main objects in the tree will be native
+	  corba objects, it costs 8 bytes per Node, Attribute and Document
+	  but it simplifies the Corba integration a lot (no extra interface
+	  objects to allocate/free).
+
+Tue Oct 13 21:46:57 EDT 1998 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* tree.h, tree.c, parser.c: added prev and doc pointers to Node,
+	  and changed NODEs contants for conformity with DOM Level 1
+
+Wed Oct  7 23:42:46 EDT 1998 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* added hooks to keep track of servants when creating objects
+	  xmlDoc and xmlNode (for Corba export).
+
+Sun Oct  4 03:18:09 EDT 1998 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* added xml-config script.
+
+Thu Oct  1 16:22:37 EDT 1998 Daniel Veillard <Daniel.Veillard@w3.org>
+
+        * autogen.sh : applied patch from Frederic Devernay <devernay@istar.fr>
+	  to autoupdate libtool and automake conf files.
+
+1998-09-30  Miguel de Icaza  <miguel@nuclecu.unam.mx>
+
+	* Makefile.am: Use '?' to separate the sed
+	commands as ',' is used when people pass -Wl,something.
+
+
+Thu Sep 24 15:13:29 EDT 1998 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* tree.c, tree.h: added a per-document compression interface.
+
+Tue Sep 22 20:47:38 EDT 1998
+
+	* tree.c, tree.h: added saving with compression and added interfaces
+	  to control the compression level (xmlGetCompressMode,
+	  xmlSetCompressMode) and a new save to filename function (xmlSaveFile).
+
+Mon Sep 21 20:11:13 EDT 1998 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.c: corrected a loop for files of size 0
+
+1998-08-20  Raja R Harinath  <harinath@cs.umn.edu>
+
+	* error.h: New file.  Contains prototyes from `error.c'.
+
+Thu Aug 13 19:02:34 1998  Tom Tromey  <tromey@cygnus.com>
+
+	* Makefile.am (xmlincdir): New macro.
+	(xmlinc_HEADERS): Renamed from include_HEADERS.
+
+Thu Aug 13 00:40:14 EDT 1998  Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* applied small patch on numeric entities from
+	  Christopher Blizzard <blizzard@appliedtheory.com>
+
+Wed Aug 12 23:12:58 EDT 1998  Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* New release 0.2, removed the old xml_* files so that it's
+	    coherent with the other CVS base (W3C), far better conformance
+	    to standard, new namespaces, decent entities support, beginning
+	    of a SAX-like interface. Nearly nothing left intact, even the
+	    test examples ...
+
+1998-07-30  Christopher Blizzard  <blizzard@appliedtheory.com>
+
+	* .cvsignore: Add .deps dir
+
+Sun Jul 26 17:29:52 EDT 1998  Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* xml_tree: changed the memory allocation scheme for name in xmlNewNode
+
+Sun Jul 26 00:17:51 EDT 1998  Daniel Veillard <Daniel.Veillard@w3.org>
+
+        * configure.in: added test for CPP
+	* AUTHORS, Changelog: the original ones didn't get commited but the
+	    glib ones instead, fixed.
+	* Makefile.am: corrected an error in library naming
+
+Fri Jul 24 16:47:14 1998  Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* integrated code developped at W3C
+	* changed the original Copyright
+	* migrated to automake
+	* prefixed the filenames by xml_ to avoid filename clashes
+
+Mon Jan  6 12:05:12 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* doc/tutorial/* : fixed #101894 if doc == NULL xmlFreeDoc 
+	  should not be called.
+
+Mon Jan  6 11:59:09 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* libxml-2.0.pc.in: applied the patch to fix #101894
+
+Sun Jan  5 23:35:47 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c : applied patch from Lukas Schroeder for register callbacks
+	* valid.c: modified patch from Lukas Schroeder to test
+	  register callbacks with --chkregister
+
+Sun Jan  5 02:23:20 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmlreader.c: seriously changed the way data are pushed to
+	  the underlying parser, go by block of 512 bytes instead of
+	  tryng to detect tag boundaries at that level. Changed the
+	  way empty element are detected and tagged.
+	* python/tests/reader.py python/tests/reader2.py
+	  python/tests/reader3.py: small changes mostly due to context
+	  reporting being different and DTD node being reported. Some
+	  errors previously undetected are now caught and fixed.
+	* doc/xmlreader.html: flagged last section as TODO
+
+Sat Jan  4 20:40:28 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* python/libxml.py: integrated the Python 2.2 optimizations
+	  from Hannu Krosing, while maintaining compatibility with 
+	  1.5 and 2.1
+
+Sat Jan  4 17:33:17 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmllint.c: a bit of cleanup
+	* xmlreader.c: small fix
+	* doc/xmlreader.html: more work on the XmlTextReader tutorial
+	* python/libxml.py: a few fixes pointed out by Hannu Krosing
+
+Sat Jan  4 13:46:14 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* python/setup.py.in: patch from Stéphane Bidoul to include
+	  drv_libxml2.py in setup.py
+
+Sat Jan  4 01:43:06 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* doc/xmlreader.html: starting documenting the new XmlTextReader
+	  interface.
+
+Fri Jan  3 17:18:32 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmllint.c: added the --stream flag to use the TextReader API
+	* xmlreader.c: small performance tweak
+
+Fri Jan  3 13:50:55 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmlreader.c python/tests/reader2py: okay the DTD validation
+	  code on top of the XMLTextParser API should be solid now.
+
+Fri Jan  3 02:17:18 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmlreader.c python/tests/reader2py: Fixing some more mess
+	  with validation and recursive entities while using the
+	  reader interface, it's getting a bit messy...
+
+Thu Jan  2 15:15:26 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmlreader.c python/tests/reader.py: another couple of problem
+	  related to IsEmptyElement reported by Stéphane Bidoul needed 
+	  some fixes.
+
+Thu Jan  2 13:57:07 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* libxml.spec.in python/Makefile.am python/drv_libxml2.py:
+	  integrated drv_libxml2.py Python xml.sax driver from Stéphane Bidoul
+	  based on the python XmlTextReader interface.
+
+Wed Jan  1 22:05:40 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: backing out one change in the last patch which broke the
+	  regression tests
+
+Wed Jan  1 21:57:28 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* global.data globals.c tree.c include/libxml/globals.h: applied
+	  an old patch from Lukas Schroeder to track node creation and
+	  destruction. Probably missing a lot of references at the moment
+	  and not usable reliably.
+
+Wed Jan  1 20:12:07 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* NEWS doc/Makefile.am doc/news.xsl: generate the NEWS file
+	  from doc/news.html and a stylesheet
+
+Wed Jan  1 16:09:57 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmlreader.c python/tests/reader.py: fixed another couple of
+	  xmlreader bugs reported by Stéphane Bidoul and added tests.
+
+Wed Jan  1 15:42:54 CET 2003 Daniel Veillard <daniel@veillard.com>
+
+	* xmlreader.c python/tests/reader2.py: fixed another validity
+	  checking in external parsed entities raised by Stéphane Bidoul
+	  and added a specific regression test.
+	* python/tests/reader3.py: cleanup
+
+Tue Dec 31 15:44:02 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlreader.c python/tests/reader2.py: fixed a problem with
+	  validation within entities pointed by Stéphane Bidoul, augmented
+	  the tests to catch those.
+
+Tue Dec 31 12:15:37 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/generator.py: modified the generator to allow keeping
+	  class references when creating new classes, needed to fix a bug
+	  pointed by Stéphane Bidoul where the input buffer of the
+	  xmlTextReader instance gets destroyed if the python wrapper for
+	  the input is not referenced anymore.
+
+Mon Dec 30 19:39:36 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlreader.c python/tests/reader.py: fixed another pair of problem
+	  pointed by Stéphane Bidoul: depth start at 0 and a parse problem.
+
+Mon Dec 30 13:36:50 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlreader.c python/tests/reader.py: fixed another problem
+	  pointed by Stéphane Bidoul
+
+Mon Dec 30 12:39:55 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlreader.c python/tests/reader.py: fixed a limit case problem
+	  with "<a/>"
+
+Mon Dec 30 11:53:44 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* SAX.c: warn on xmlns:prefix="foo"
+	* xmlreader.c python/tests/reader.py: fixed a couple of problem
+	  for namespace attributes handling.
+
+Mon Dec 30 00:59:07 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* entities.c parser.c tree.c include/libxml/entities.h: Fixed
+	  a really nasty problem raised by a DocBook XSLT transform
+	  provided by Sebastian Bergmann
+
+Sun Dec 29 12:13:18 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlreader.c python/tests/reader.py: fixed a bug pointed out
+	  by Stéphane Bidoul and integrated it into the tests
+
+Sat Dec 28 23:49:12 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlreader.c include/libxml/xmlreader.h doc/libxml2-api.xml:
+	  extended the XmlTextReader API a bit, addding accessors for
+	  the current doc and node, and an entity substitution mode for
+	  the parser.
+	* python/libxml.py python/libxml2class.txt: related updates
+	* python/tests/Makefile.am python/tests/reader.py 
+	  python/tests/reader2.py python/tests/reader3.py: updated a bit
+	  the old tests and added a new one to test the entities handling
+
+Sat Dec 28 22:11:57 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/generator.py python/libxml2class.txt 
+	  python/tests/reader.py python/tests/reader2.py: changed the
+	  generator to provide casing for the XmlTextReader similar to
+	  C# so that examples and documentation are more directly transposable.
+	  Fixed the couple of tests in the suite.
+
+Sat Dec 28 15:55:32 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* doc/guidelines.html: added a document on guildeline for
+	  publishing and deploying XML
+
+Fri Dec 27 20:35:15 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* valid.c xmlreader.c: final touch running DTD validation
+	  on the XmlTextReader
+	* python/tests/Makefile.am python/tests/reader2.py: added a
+	  specific run based on the examples from test/valid/*.xml
+
+Fri Dec 27 15:17:20 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/libxml.py: added a few predefined xmlTextReader parser
+	  configuration values.
+
+Fri Dec 27 12:57:22 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/libxml_wrap.h: trying to fix #102037
+
+Fri Dec 27 12:18:14 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* SAX.c: fixing bug #95296, when the predefined entities
+	  are redefined in the DTD the default one must be used
+	  instead anyway.
+
+Wed Dec 25 19:22:06 MST 2002 John Fleck <jfleck@inkstain.net>
+
+	* doc/xmllint.xml
+	* doc/xmllint.1
+	Add discussion of XML_DEBUG_CATALOG to xmllint man
+	page - bug #100907
+
+
+Mon Dec 23 16:54:22 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlreader.c: Fixed the empty node detection to avoid reporting
+	  an inexistant close tag.
+
+Mon Dec 23 15:42:24 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/libxml.c python/setup.py.in: patch from Stéphane Bidoul
+	  for Python 2.1
+
+Sun Dec 22 11:24:06 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* testC14N.c vms/config.vms: applied Craig A. Berry patches for VMS
+
+Fri Dec 20 11:27:49 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* doc/libxml2-api.xml python/tests/reader.py: one really need
+	  to provide the base URI information when creating a reader parser
+	  from an input stream. Updated the API and the example using it.
+
+Fri Dec 20 01:11:30 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* testReader.c xmlreader.c valid.c include/libxml/tree.h
+	  include/libxml/valid.h include/libxml/xmlreader.h: working on
+	  DTD validation on top of xml reader interfaces. Allows to
+	  validate arbitrary large instances. This required some extensions
+	  to the valid module interface and augmenting the size of xmlID
+	  and xmlRef structs a bit.
+	* uri.c xmlregexp.c: simple cleanup.
+
+Wed Dec 18 15:51:22 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlreader.c include/libxml/xmlreader.h doc/libxml2-api.xml: more
+	  work on the xml reader interfaces.
+	* AUTHORS MAINTAINERS doc/* win32/*: updated Igor's mail and the
+	  Web page for the Windows binaries.
+
+Tue Dec 17 19:31:07 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlIO.c: applied a patch for VMS following the report by
+	  Nigel Hall
+
+Tue Dec 17 11:29:41 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: the parseStartTag bug fix wasn't complete.
+	
+Mon Dec 16 23:00:05 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: Vyacheslav Pindyura managed to trigger a bug in
+	  parseStartTag, fixing it.
+	* test/att4 result/att4 result/noent/att4: adding the test
+	* xmlreader.c include/libxml/xmlreader.h doc/libxml2-api.xml: added
+	  more methods to XmlTextReader.
+
+Mon Dec 16 19:31:16 CET 2002 Igor Zlatkovic <igor@stud.fh-frankfurt.de>
+
+	* win32/libxml2.def.src: added more xml reader exports
+	* win32/Makefile.msvc win32/Makefile.mingw: added xml reader interface
+	  to the build
+	
+Mon Dec 16 06:36:54 MST 2002 John Fleck <jfleck@inkstain.net>
+
+	* doc/tutorial/xmltutorial.xml
+	plus generated html and pdf
+	Updating tutorial again based on further comments from Niraj
+	Tolia on the last iteration
+
+Sun Dec 15 21:27:30 MST 2002 John Fleck <jfleck@inkstain.net>
+
+	* doc/tutorial/xmltutorial.xml
+	* doc/tutorial/includekeyword.c
+	* doc/tutorial/includegetattribute.c
+	plus generated html and pdf
+	Adding fix from Niraj Tolia to tutorial to properly free memory.
+	
+
+Mon Dec 16 00:34:25 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlreader.c include/libxml/xmlreader.h doc/libxml2-api.xml: added
+	  more methods of XmlTextReader.
+	* python/libxml2class.txt python/tests/reader.py: this increased the
+	  methods in the bndings, augmented the test to check those new
+	  functions.
+
+Sat Dec 14 23:57:39 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlreader.c doc/libxml2-api.xml: added the close and getattribute
+	  methods of XmlTextReader.
+	* python/generator.py python/libxml_wrap.h python/types.c 
+	  python/libxml2class.txt: added the reader to the Python bindings
+	* python/tests/Makefile.am python/tests/reader.py: added a specific
+	  test for the Python bindings of the Reader APIs
+	* parser.c: small cleanup.
+
+Fri Dec 13 11:39:44 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xinclude.c: fallback was only copying the first child not the
+	  full child list of the fallback element, closes #89684 as reopened
+	  by Bernd Kuemmerlen
+
+Thu Dec 12 13:34:59 CET 2002 Igor Zlatkovic <igor@stud.fh-frankfurt.de>
+
+	* win32/libxml2.def.src: exported htmlNodeDumpOutput
+
+Thu Dec 12 10:59:11 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in: preparing release of 2.4.30
+	* doc/apibuild.py doc/libxml2-api.xml: fixups to the api builder,
+	  gives enum values, fix functype return type, put back fields in
+	  structs 
+	* doc/*: updated the docs rebuilt
+
+Thu Dec 12 01:09:34 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLtree.c include/libxml/HTMLtree.h: patch from Mark Vadok
+	  about htmlNodeDumpOutput location.
+	* xpath.c: removed an undefined function signature
+	* doc/apibuild.py doc/libxml2-api.xml: the script was exporting
+	  too many symbols in the API breaking the python bindings.
+	  Updated with the libxslt/libexslt changes.
+
+Wed Dec 11 20:26:15 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in: preparing release of 2.4.29
+	* doc/*: rebuilt the docs and API
+	* xmlreader.c: a few more fixes for the XmlTextReader API
+
+Wed Dec 11 18:01:15 CET 2002 Igor Zlatkovic <igor@stud.fh-frankfurt.de>
+
+	* include/win32config.h: applied mingw patch from Magnus Henoch
+
+Wed Dec 11 16:58:48 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* catalog.c doc/libxml2-api.xml: a bit more cleanup
+
+Wed Dec 11 14:54:47 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* doc/apibuild.py doc/libxml2-api.xml doc/Makefile.am: new API
+	  building Python script, does the C parsing directly, generates
+	  a better API description including structure fieds defs and
+	  enums. Still a couple of bugs, but good enough for the python
+	  wrappers now.
+	* DOCBparser.c SAX.c nanohttp.c parser.c parserInternals.c tree.c
+	  valid.c xmlIO.c xmlmemory.c xmlreader.c xmlregexp.c xmlschemas.c
+	  include/libxml/schemasInternals.h include/libxml/tree.h: more
+	  cleanup based on the python analysis script reports.
+	* libxml.spec.in: make sure the API XML description is part of the
+	  devel package.
+
+Tue Dec 10 16:16:34 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* DOCBparser.c HTMLparser.c c14n.c debugXML.c encoding.c hash.c
+	  nanoftp.c nanohttp.c parser.c parserInternals.c testC14N.c
+	  testDocbook.c threads.c tree.c valid.c xmlIO.c xmllint.c xmlmemory.c
+	  xmlreader.c xmlregexp.c xmlschemas.c xmlschemastypes.c xpath.c:
+	  code cleanup, especially the function comments.
+	* tree.c: fixed a small bug when freeing nodes which are XInclude ones.
+
+Mon Dec  9 15:08:17 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am xmlreader.c include/libxml/Makefile.am
+	  include/libxml/xmlreader.h:  Adding a new set of APIs based on
+	  the C# TextXmlReader API but converted to C. Allow to parse
+	  in constant memory usage, far simpler to program and explain
+	  than the SAX like APIs, unfinished but working.
+	* testReader.c: test program
+
+Sun Dec  8 18:36:01 CET 2002 Igor Zlatkovic <igor@stud.fh-frankfurt.de>
+
+	* win32/libxml2.def.src: applied YALDSP from Mark Vakoc
+
+Wed Dec  4 16:08:49 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: Chip turner indicated that XHTML1 serialization
+	  rule for style actually break on both IE and Mozilla, 
+	  try to avoid the rule if escaping ain't necessary
+
+Wed Dec  4 12:43:28 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* nanhttp.c: handle HTTP URL escaping, problem reported by
+	  Glen Nakamura and Stefano Zacchiroli
+
+Sat Nov 30 12:19:17 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* DOCBparser.c HTMLparser.c parser.c valid.c xpath.c: code cleanup
+
+Thu Nov 28 12:53:22 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* uri.c: Johann Richard pointed out some XPointer problems for
+	  URN based URI references in XInclude. Modified the URI parsing
+	  and saving routines to allow correct parsing and saving of 
+	  XPointers, especially when attached to "opaque" scheme accordingly
+	  to RFC 2396
+
+Wed Nov 27 20:36:08 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLtree.c include/libxml/HTMLtree.h: applied the same kind
+	  of refactoring to the HTML saving code.
+	* doc/libxml2-*.xml doc/API*.html: slight API changes got reflected
+	  in the doc.
+
+Wed Nov 27 12:40:16 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c include/libxml/tree.h: refactored the XML dump of a node
+	  to a buffer API to reuse the generic dump to an OutputIO layer,
+	  this reduces code, fixes xmlNodeDump() for XHTML, also made
+	  xmlNodeDump() now return the number of byte written.
+
+Wed Nov 27 09:00:00 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/setup.py.in: another patch from Stéphane Bidoul for 
+	  Python bindings on Windows
+	* doc/parsedecl.py: small cleanup
+
+Mon Nov 25 17:28:53 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* libxml.spec.in configure.in: add a line in %changelog for releases
+
+Mon Nov 25 14:18:27 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: patch from Marcus Clarke fixing a problem in entities
+	  parsing that was detected in KDe documentations environment.
+
+Mon Nov 24 14:13:21 CET 2002 ERDI Gergo <cactus@cactus.rulez.org>
+
+	* python/libxml.c (libxml_prev): Return the previous as opposed to
+	the next node (I guess this is the result of some cut & paste programming:)
+
+Sat Nov 23 17:22:22 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* doc/Makefile.am: Jan Rafaj pointed a bug in the Makefile.
+
+Sat Nov 23 12:21:24 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/generator.py python/libxml.c python/setup.py.in: trying
+	  to fix the Python bindings build on Windows (Stéphane Bidoul)
+
+Fri Nov 22 22:41:34 CEST 2002 Igor Zlatkovic <igor@stud.fh-frankfurt.de>
+
+	* win32/configure.js: added option for python bindings
+	* win32/libxml2.def.src: added more exports
+
+Fri Nov 22 18:50:34 CET 2002 Igor Zlatkovic <igor@stud.fh-frankfurt.de>
+
+	* win32/Makefile.mingw: fixed unresolved symbols when linking with
+	  pthreads
+	* win32/wince/*: applied updates to Windows CE port from Javier
+
+Fri Nov 22 15:51:22 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in: preparing 2.4.28
+	* libxml.spec.in doc/Makefile.am: some cleanup
+	* doc/*: updated the news and regenerated.
+
+Fri Nov 22 14:15:14 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLparser.c: final touch at closing #87235 </p> end tags
+	  need to be generated.
+	* result/HTML/cf_128.html result/HTML/test2.html result/HTML/test3.html:
+	  this change slightly the output of a few tests
+	* doc/*: regenerated
+
+Fri Nov 22 13:26:19 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* parserInternals.c: fixing bug #99190 when UTF8 document are
+	  parsed using the progressive parser and the end of the chunk
+	  is in the middle of an UTF8 multibyte character.
+
+Fri Nov 22 13:13:00 HKT 2002 William Brack <wbrack@mmm.com.hk>
+
+	* threads.c: fixed initialization problem in xmlNewGlobalState
+	  which was causing crash.
+	* globals.c: removed duplicate call to initxmlDefaultSAXHandler
+	  in xmlInitializeGlobalState.
+	* parserInternals.c: cleaned up ctxt->sax initialisation.
+	
+Thu Nov 21 15:05:45 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c include/libxml/tree.h: modified the existing APIs
+	  to handle XHTML1 serialization rules automatically, also add
+	  xmlIsXHTML() to libxml2 API. Some tweaking to make sure
+	  libxslt serialization uses it when needed without changing
+	  the library API.
+	* test/xhtml1 result/noent/xhtml1 result/valid/xhtml1.xhtml
+	  result/xhtml1: added a new test specifically for xhtml1 output
+	  and updated the result of one XHTML1 test
+
+Wed Nov 20 14:24:56 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xinclude.c parserInternals.c encoding.c: fixed #99082
+	  for xi:include encoding="..." support on text includes.
+	* result/XInclude/tstencoding.xml test/XInclude/docs/tstencoding.xml
+	  test/XInclude/ents/isolatin.txt : added a specific regression test
+	* python/generator.py python/libxml2class.txt: fixed the generator
+	  the new set of comments generated for doc/libxml2-api.xml were
+	  breaking the python generation.
+
+Tue Nov 19 23:25:47 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* doc/Makefile.am: repair some problem if gtk-doc fail or such
+	* configure.in: patch for Solaris on new autoconf closes #98880 
+	* doc/parsedecl.py: repair the frigging API building script,
+	  did I say that python xmllib sucks ?
+	* doc/libxml2-api.xml doc/libxml2-refs.xml: regenerated, reordering
+	  and some comment are no more truncated.
+
+Tue Nov 19 09:09:04 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: Martin Stoilov pointed out a potential leak in
+	  xmlCreateMemoryParserCtxt
+
+Mon Nov 18 16:05:51 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLparser.c: fixed bug #98879 a corner case when 0 is
+	  included in HTML documents and using the push parser.
+
+Mon Nov 18 00:11:24 CET 2002 ERDI Gergo <cactus@cactus.rulez.org>
+
+	* configure.in (PYTHON_SITE_PACKAGES): If --with-python is
+	  specified, look for the Python interpreter not just in the
+	  specified root but also in the specified location. Fixes #98825
+
+Sun Nov 17 23:36:06 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/libxml.c: fixing bug #98792 , node may have no doc
+	  and dereferencing without checking ain't good ...
+
+Sun Nov 17 10:25:43 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in: preparing release 2.4.27
+	* doc/* : updated and rebuilt the docs
+	* doc/Makefile.am libxml.spec.in: try to make sure the tutorial
+	  and all the docs are actually packaged and in the final RPMs
+	* parser.c parserInternals.c include/libxml/parser.h: restore
+	  xmllint --recover feature.
+
+Sat Nov 16 16:30:25 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c xpath.c: fixing #96925 wich was also dependent on the
+	  processing of parsed entities, and XPath computation on sustitued
+	  entities.
+	* testXPath.c: make sure entities are substitued.
+
+Fri Nov 15 16:22:54 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: fixed #96594, which was totally dependent on the 
+	  processing of internal parsed entities, which had to be changed.
+
+Fri Nov 15 12:16:07 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am python/Makefile.am python/tests/Makefile.am:
+	  trying to fix bug #98517 about building outside the source tree
+	* doc/xml.html doc/FAQ.html: fixed the link to libiconv #94585
+
+Thu Nov 14 18:41:55 CEST 2002 Igor Zlatkovic <igor@stud.fh-frankfurt.de>
+
+	* include/win32config.h: cleanup
+	* win32/Makefile.mingw: integrated mingw in JScript configure
+	* win32/Makefile.msvc: modified to allow mingw coexistence
+	* win32/configure.js: integrated mingw
+	* win32/Readme.txt: cleanup
+
+Tue Nov 12 22:06:45 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLparser.c: strengthen the guard in the Pop macros,
+	  like in the XML parser, closes bug #97315
+
+Tue Nov 12 21:56:39 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/parser.h: fixed bug #98338 , fatalError SAX
+	  callback is never used.
+
+Tue Nov 12 13:32:50 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* parserInternals.c: fixed the initialization of the SAX structure
+	  which was breaking xsltproc
+	* xpath.c: patch from Petr Pajas for CDATA nodes
+	* tree.c: patch from Petr Pajas improving xmlGetNodePath()
+	* parser.c include/libxml/parser.h: patch from Peter Jones
+	  removing a leak in xmlSAXParseMemory() and adding the
+	  function xmlSAXParseMemoryWithData()
+
+Mon Nov 11 20:47:03 MST 2002 John Fleck <jfleck@inkstain.net>
+
+	adding pdf of tutorial, changing web page to link to it
+	* doc/tutorial/xmltutorial.pdf
+	* doc/xml.html
+	* doc/docs.html
+
+Sun Nov 10 20:48:57 MST 2002 John Fleck <jfleck@inkstain.net>
+
+	* doc/tutorial/ar01s08.html
+	adding file what I forgot for tutorial
+
+
+Sun Nov 10 20:33:13 MST 2002 John Fleck  <jfleck@inkstain.net>
+
+	Adding encoding discussion to tutorial
+	Added:
+	* doc/tutorial/images/*.png: DocBook admonition image files
+	* doc/tutorial/apf.html, apg.html: new generated html
+	* doc/tutorial/includeconvert.c: conversion code entity file
+	changed:
+	* doc/tutorial/xmltutorial.xml: DocBook original
+	* doc/tutorial/*.html: generated html
+
+Fri Nov  8 17:59:32 CEST 2002 Igor Zlatkovic <igor@stud.fh-frankfurt.de>
+
+	* include/libxml/*.h: retired xmlwin32version.h
+	* doc/Makefile.am: retired xmlwin32version.h
+	* win32/configure.js: retired xmlwin32version.h
+
+Fri Nov  8 16:55:47 CEST 2002 Igor Zlatkovic <igor@stud.fh-frankfurt.de>
+
+	* win32/libxml2.def.src: exported additional symbols
+	* include/libxml/xmlmemory.h: exported the rest of the xmlMem* 
+	  sisterhood
+
+Fri Nov  8 16:08:13 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* globals.c: fixed a typo pointed out by Igor
+	* xpath.c: try to speed up node compare using line numbers
+	  if available.
+
+Thu Nov  7 15:16:02 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: make xmlFreeNode() handle attributes correctly.
+
+Wed Nov  6 23:51:11 CET 2002 Igor Zlatkovic <igor@stud.fh-frankfurt.de>
+
+	* catalog.c: completed the #96963 fix, as reported by Karl
+	  Eichwalder
+
+Wed Nov  6 16:48:44 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xpointer.c: tried to fix bug #97852 reported by Nicolas Noffke
+
+Sun Nov  3 10:43:44 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am: switched the order of a couple of includes
+	  to fix bugs #97100
+
+Thu Oct 31 17:11:46 CEST 2002 Igor Zlatkovic <igor@stud.fh-frankfurt.de>
+
+	* catalog.c: fixed bug #96963, reverted to the old behaviour of
+	  xmlLoadCatalogs that used to separate directories with a ':'.
+
+Thu Oct 31 16:55:21 CEST 2002 Igor Zlatkovic <igor@stud.fh-frankfurt.de>
+
+	* threads.c: improvements to the Windows-side of thread handling
+	* testThreads.c: conditionally excluded unistd.h
+	* testThradsWin32.c: broke overlong lines
+	* include/win32config.h: adapted thread-related macros to the new
+	  scheme and for pthreads on Windows
+	* win32/Makefile.msvc: introduced a more flexible thread build, 
+	  added testThreads[Win32].c to the build
+	* win32/configure.js: introduced a more flexible thread config
+
+2002-10-31  John Fleck  <jfleck@inkstain.net>
+
+	* doc/xml.html (and, by implication, FAQ.html)
+	added UTF-8 conversaion FAQ from Marcus Labib Iskander
+
+Tue Oct 29 18:32:33 CET 2002 Igor Zlatkovic <igor@stud.fh-frankfurt.de>
+
+	* configure.in: removed xmlwin32version.h
+	* include/libxml/Makefile.am: removed xmlwin32version.h
+
+Mon Oct 28 14:01:29 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: applied patch from Brian Stafford to fix a bug
+	  in xmlReconciliateNs()
+
+Mon Oct 28 13:51:55 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: applied patch from Christian Glahn to allow
+	  xmlNewChild() on document fragment nodes
+
+Sat Oct 26 15:27:00 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: Christian Glahn found a problem with a recent
+	  patch to xmlParseBalancedChunkMemoryRecover()
+	* xmlschemas.c: Charles Bozeman fixed some Schemas validation
+	  problems
+	* result/schemas/elem* result/schemas/seq* test/schemas.elem*
+	  test/schemas/seq*: added the test cases from Charles
+
+Wed Oct 23 16:42:29 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am config.h.in libxml.spec.in doc/Makefile.am:
+	  serious cleanup of the spec file and associated changes
+	  in the Makefiles.
+	* valid.c: try to remove some warnings on x86_64
+
+Wed Oct 23 10:53:42 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* include/Makefile.am: added winsockcompat.h to EXTRA_DIST to
+	  fix bug #96586
+
+Tue Oct 22 21:13:06 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLparser.c: Mikhail Sogrine pointed out a bug in HTML
+	  parsing, applied his patch
+	* result/HTML/attrents.html result/HTML/attrents.html.err
+	  result/HTML/attrents.html.sax test/HTML/attrents.html:
+	  added the test and result case provided by Mikhail Sogrine
+
+Tue Oct 22 19:33:20 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* vms/build_libxml.com vms/config.vms vms/readme.vms
+	  include/libxml/parser.h include/libxml/parserInternals.h
+	  include/libxml/tree.h include/libxml/xmlIO.h
+	  HTMLparser.c catalog.c debugXML.c parser.c parserInternals.c
+	  tree.c triodef.h trionan.c uri.c xmlIO.c xpath.c:
+	  Applied the VMS update patch from Craig A. Berry
+	* doc/*.html: update
+
+Tue Oct 22 16:27:31 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/encoding.h encoding.c: made xmlGetUTF8Char public
+
+Tue Oct 22 16:25:18 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* debugXML.c: adding a grep command to --shell in xmllint
+	  for T.V. Raman
+
+Tue Oct 22 16:23:57 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlcatalog.c: tried to fix some of the problem with --sgml
+
+Mon Oct 21 09:57:10 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: tried to fix bug #91500 where doc->children may
+	  be overriden by a call to xmlParseBalancedChunkMemory()
+
+Mon Oct 21 09:04:32 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* catalog.c: tried to fix bug #90945 w.r.t. parsing of system
+	  identifiers in SGML catalogs containing '&'
+
+Sun Oct 20 23:31:47 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/types.c: fixed bugs when passing result value tree
+	  to Python functions.
+
+Fri Oct 18 13:18:53 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in: preparing the release of 2.4.26
+	* doc/*: updated and rebuilt the documentation
+
+Wed Oct 16 20:01:46 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: fixed a XML Namespace compliance bug reported by
+	  Alexander Grimalovsky
+
+Wed Oct 16 17:18:42 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLtree.c: fixed serialization of script and style when
+	  they are not lowercase (i.e. added using the API to the tree).
+
+Wed Oct 16 16:31:05 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* valid.c: make xmlValidateDocument emit a warning msg if there
+	  is no DTD, pointed by Christian Glahn
+
+Wed Oct 16 16:05:38 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlregexp.c xmlschemas.c: fixed the validation of sequences
+	  content model when some of the blocks have min or max, and a couple
+	  of bugs found in the process.
+	* result/schemas/list0* test/schemas/list0*: added some specific
+	  regression tests
+
+Tue Oct 15 12:41:01 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* README: updated the contact informations
+
+Tue Oct 15 10:35:57 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am: use test -f instead of test -e since Solaris /bin/sh
+	  misses it, reported by Peter Bray.
+
+Mon Oct 14 17:37:32 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: investigating xmlNodeGetContent() on namespace nodes
+	  and removed a few warnings
+
+Mon Oct 14 13:12:55 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: Christian Glahn found a small bug in the push parser.
+	* xmlIO.c include/libxml/xmlIO.h: cleaned up and made xmlCheckFilename
+	  public
+
+Wed Oct  9 23:11:02 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlschemas.c include/libxml/xmlschemas.h: added
+	  xmlSchemaNewMemParserCtxt to parse a schemas from a memory area
+	* testSchemas.c: added --memory to test the new interface
+
+Wed Oct  9 16:22:54 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* doc/index.py doc/search.php: integrated the XSLT indexing,
+	  a few fixed in the indexer, added a scope selection at the
+	  search level.
+
+Wed Oct  9 12:18:37 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* valid.c: Joe Marcus Clarke reported a segfault on FBsd 
+	  this was due to uninitialized parts of the validation context
+
+Tue Oct  8 23:24:20 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* debugXML.c: applied patch from Mark Vakoc except the API
+	  change, preserved it.
+	* doc/*: updated the docs to point to the search engine for
+	  information lookup or before bug/help reports.
+
+Tue Oct  8 18:53:31 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* doc/index.py doc/search.php: added mailing-list archives
+	  indexing and lookup
+
+Tue Oct  8 10:25:07 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: patch from Mark Vakoc to fix xmlNodeGetPath()
+
+Mon Oct  7 13:12:03 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* doc/index.py: improved HTML indexing
+	* doc/search.php: make the queries also lookup the HTML based indexes
+
+Sun Oct  6 23:50:29 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* doc/index.py: added HTML page indexing 
+
+Fri Oct  4 15:33:55 CEST 2002 Igor Zlatkovic <igor@stud.fh-frankfurt.de>
+
+	* xmlIO.c: extended Windows path normalisation to fix the base
+	  problem in libxslt.
+	* catalog.c: fixed list handling in XML_CATALOG_FILES
+
+Fri Oct  4 13:43:02 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* valid.c: typo/bug found by Christian Glahn
+
+Sun Sep 29 19:44:10 CEST 2002 Igor Zlatkovic <igor@stud.fh-frankfurt.de>
+
+	* xmlIO.c: applied Windows CE patch from Javier.
+	* win32/wince: new directory, contains support for the PocketPC
+	  with Windows CE from Javier.
+	* include/win32config.h: reorganised, removed duplicate 
+	  definitions and applied WinCE patch from Javier.
+	* include/wsockcompat.h: new file, now contains WinSock
+	  compatibility macros.
+	* win32/Makefile.msvc: introduced double-run compilation.
+
+Thu Sep 26 19:48:06 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in include/libxml/xmlwin32version.h: preparing release
+	  of 2.4.25
+	* doc/*: updated and regenerated teh docs and web pages.
+
+Thu Sep 26 17:33:46 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* SAX.c valid.c include/libxml/valid.h: fixed bug #92518 validation
+	  error were not covering namespace declarations.
+	* result/valid/dia.xml test/valid/dia.xml: the test wasn't valid,
+	  it was missing the attribute declaration for the namespace
+	* result/VC/NS3: the fix now report breakages in that test
+
+Thu Sep 26 14:39:07 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLtree.c: fixing bug #94241 on HTML boolean attributes
+
+Thu Sep 26 14:25:33 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* doc/*: added the 3 new modules xmlregexp xmlautomata and xmlunicode
+	  and regenerated the docs and web site
+
+Thu Sep 26 11:45:42 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xinclude.c xmlschemas.c xmlschemastypes.c xpath.c: make sure
+	  ATTRIBUTE_UNUSED is always put after the attribute declaration,
+	  not before
+
+Thu Sep 26 11:33:28 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/generator.py python/libxml2class.txt: fixed a stupid error
+	  breaking the python API
+
+Thu Sep 26 00:31:46 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* trio.c trio.h triodef.h trionan.c trionan.h triop.h
+	  triostr.c triostr.h: applied a trio update patch from 
+	  Bjorn Reese which should work with MinGW
+
+Thu Sep 26 00:21:18 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: improving some documentation comments
+	* xmlregexp.c: found and fixed a mem leak with python regression tests
+	* doc/*: rebuilt the doc and the API XML file including the 
+	  xmlregexp.h xmlautomata.h and xmlunicode.h headers
+	* python/generator.py python/libxml2class.txt python/libxml_wrap.h
+	  python/types.c: added access to the XML Schemas regexps from
+	  python
+	* python/tests/Makefile.am python/tests/regexp.py: added a 
+	  simple regexp bindings test
+
+Tue Sep 24 08:10:48 MDT 2002 John Fleck <jfleck@inkstain.net>
+
+	* doc/xml.html:
+	  fixing ftp links - thanks to Vitaly Ostanin
+
+Tue Sep 24 16:08:17 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlregexp.c: fixed the data callback on transition functionality
+	  which was broken when using the compact form
+	* result/schemas/*: updated the results, less verbose, all tests
+	  pass like before
+	* DOCBparser.c testAutomata.c testC14N.c testSchemas.c testThreads.c
+	  testXPath.c valid.c xinclude.c xmllint.c xmlregexp.c xmlschemas.c
+	  xmlschemastypes.c xpath.c python/libxml.c: removed a bunch of
+	  annoying warnings
+	* xpath.c: try to provide better error report when possible
+
+Sat Sep 21 14:56:37 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am: fixed a breakage raised by Jacob
+
+Fri Sep 20 20:08:18 CEST 2002 Igor Zlatkovic <igor@stud.fh-frankfurt.de>
+
+	* include/win32config.h: added HAVE_ERRNO_H definition for parts
+	  which don't use sockets
+
+Fri Sep 20 18:40:50 CEST 2002 Igor Zlatkovic <igor@stud.fh-frankfurt.de>
+
+	* win32/Makefile.msvc: applied zlib patch from Daniel Gehriger
+	* win32/configure.js: applied zlib patch from Daniel Gehriger
+
+Fri Sep 20 15:40:14 CEST 2002 Igor Zlatkovic <igor@stud.fh-frankfurt.de>
+
+	* win32/configure.js: applied the patch from Mark Vakoc for 
+	  regexp support
+	* win32/libxml2.def.src: applied the patch from Mark Vakoc
+	  for regexp support
+	
+Fri Sep 20 15:35:33 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlschemastypes.c: as pointed by Igor Float and Double
+	  parsing ain't finished yet
+
+Fri Sep 20 14:00:16 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am configure.in: trying to fix #88412 by bypassing
+	  all the python subdir if python ain't detected
+
+Thu Sep 19 21:46:53 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am configure.in include/libxml/xmlversion.h.in:
+	  made configuring with regexps/automata/unicode the default
+	  but without schemas ATM
+	* testRegexp.c valid.c xmlregexp.c include/libxml/xmlregexp.h:
+	  fixed the regexp based DTD validation performance and memory
+	  problem by switching to a compact form for determinist regexps
+	  and detecting the determinism property in the process. Seems
+	  as fast as the old DTD validation specific engine :-) despite
+	  the regexp built and compaction process.
+
+Wed Sep 18 18:27:26 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* valid.c: determinism is debugged, new DTD checking code now works
+	  but xmlFAComputesDeterminism takes far too much CPU and the whole
+	  set usues too much memory to be really usable as-is
+
+Wed Sep 18 00:54:30 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: fixed another stupid bug in xmlGetNodePath()
+	* xmllint.c: --version now report the options compiled in
+
+Tue Sep 17 23:48:07 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLparser.c: small cleanup
+	* valid.c xmlregexp.c: switched DTD validation to use only regexp
+	  when configured with them. A bit of debugging around the determinism
+	  checks is still needed
+
+Tue Sep 17 21:22:25 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/libxml_wrap.h: stupid bug found by mattam@netcourrier.com
+
+Tue Sep 17 19:58:26 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlIO.c: small portability glitch fixed.
+
+Mon Sep 17 12:38:08 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlschemastypes.c: incomplete steps for real/double support
+	* testAutomata.c include/libxml/xmlautomata.h
+	  include/libxml/xmlregexp.h: avoiding a compilation problem
+	* valid.c include/libxml/valid.h: starting the work toward using
+	  the regexps for actual DTD validation
+
+Fri Sep 13 16:46:14 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* hash.c: cosmetic cleanup
+	* valid.c include/libxml/tree.h include/libxml/valid.h: started 
+	  integrating a DTD validation layer based on the regexps
+
+Thu Sep 12 18:01:29 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlregexp.c xmlschemas.c: fixed a bug reported by Jeff Goff,
+	  the determinism was tested before eliminating the epsilon
+	  transitions :-(
+
+Thu Sep 12 16:57:45 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/generator.py python/libxml.c python/libxml.py
+	  python/libxml2-python-api.xml python/libxml2class.txt
+	  python/libxml_wrap.h python/types.c: updated the python
+	  bindings, added code for easier File I/O, and the ability to
+	  define a resolver from Python fixing bug #91635
+	* python/tests/Makefile.am python/tests/inbuf.py
+	  python/tests/outbuf.py python/tests/pushSAXhtml.py
+	  python/tests/resolver.py python/tests/serialize.py: updated
+	  and augmented the set of Python tests.
+
+Tue Sep 10 21:05:28 CEST 2002 Igor Zlatkovic <igor@stud.fh-frankfurt.de>
+
+	* win32/configure.js: added more readme info for the binary
+	  package.
+	
+Tue Sep 10 14:15:18 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlIO.c: fixed a stupid out of bound array error
+
+Tue Sep 10 13:09:14 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/xmlIO.h xmlIO.c parser.c HTMLparser.c DOCBparser.c:
+	  messing around with support for Windows path, cleanups,
+	  trying to identify and fix the various code path to the
+	  filename access. Added xmlNormalizeWindowsPath()
+
+Thu Sep  5 16:19:18 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* error.c valid.c: working on better error reporting of validity
+	  errors, especially providing an accurate context.
+	* result/valid/xlink.xml.err result/valid/rss.xml.err: better
+	  error reports in those cases.
+
+Thu Sep  5 13:29:47 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* DOCBparser.c HTMLparser.c c14n.c entities.c list.c
+	  parser.c parserInternals.c xmlIO.c: get rid of all the 
+	  perror() calls made in the library execution paths. This
+	  should fix both #92059 and #92385
+
+Thu Sep  5 13:13:17 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmllint.c: memory leak reporting was broken after a change
+	  of the preprocessor symbol used to activate it.
+
+Thu Sep  5 13:10:57 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: try to make the copy function work for node of
+	  type XML_DOCUMENT_FRAG_NODE, they are only created by the
+	  DOM layers though, not libxml2 itself.
+
+Thu Sep  5 12:57:38 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* valid.c: try to provide file and line informations, not all
+	  messages are covered, but it's a (good) start
+
+Thu Sep  5 12:49:35 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xinclude.c: reimplemented a large part of the XInclude
+	  processor, trying to minimize resources used, James Henstridge
+	  provided a huge test case which was exhibiting severe memory
+	  consumption problems.
+
+Thu Sep  5 10:07:13 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/Makefile.am: applied patch from Christophe Merlet to
+	  reestablish DESTDIR
+
+Wed Sep  4 14:13:34 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* libxml.spec.in: fixes libary path for x86_64 AMD
+
+Tue Sep  3 21:14:19 MDT 2002 John Fleck <jfleck@inkstain.net>
+
+	* doc/tutorial/includekeyword.c
+	* doc/tutorial/xmltutorial.xml:
+	(plus resulting generated html files)
+	fixing one spot I missed in the tutorial where I hadn't freed
+	memory properly
+
+Sat Aug 31 19:31:17 MDT 2002 John Fleck <jfleck@inkstain.net>
+
+	* doc/tutorial/includeaddattribute.c
+	* doc/tutorial/includeaddkeyword.c
+	* doc/tutorial/includegetattribute.c
+	* doc/tutorial/includekeyword.c
+	* doc/tutorial/xmltutorial.xml
+	* doc/tutorial/*.html:
+	update tutorial to properly free memory (thanks to Christopher
+	R. Harris for pointing out that this needs to be done)
+	* doc/tutorial/images/callouts/*.png:
+	added image files so the callouts are graphical, making it
+	easier to read ( use "--param callout.graphics 1" to generate
+	html with graphical callouts)
+	
+Wed Aug 28 13:44:54 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* doc/Libxml2-Logo-180x168.gif doc/Libxml2-Logo-90x34.gif:
+	  nice logos generated by Marc Liyanage
+	* doc/site.xsl *.html: changed the stylesheet to show the new
+	  logo and regenerated the pages
+
+Sun Aug 25 16:38:05 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlIO.c: handle Windows sepecific file://localhost/ semantic ...
+
+Thu Aug 22 22:03:19 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: possible mem leak patch from Jason Adams
+
+Thu Aug 22 17:27:30 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: integrated xf:escape-uri() from Wesley Terpstra
+	  in the XQuery namespace
+	* configure.in: preparing 2.4.24
+	* doc/*.html: updated the web pages
+
+Thu Aug 22 16:19:42 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/generator.py: closing bug #85258 by generating conditional
+	  compile check to avoid linking to routines not configured in.
+
+2002-08-22  Havoc Pennington  <hp@pobox.com>
+
+	* autogen.sh: update error message for missing automake
+
+Thu Aug 22 11:45:50 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/Makefile.am: typo in target name resulted in libxml2.py
+	  to not be rebuilt. fixed DESTDIR similary to the libxslt one.
+
+Thu Aug 22 09:15:00 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* win32/win32/Makefile.mingw: updated with version from 
+	  Elizabeth Barham at http://soggytrousers.net/repository/
+
+Tue Aug 20 16:40:48 CEST 2002 Igor Zlatkovic <igor@stud.fh-frankfurt.de>
+
+	* win32/Makefile.msvc: added the prefix location to the include
+	and lib search path.
+	
+2002-08-18  Havoc Pennington  <hp@pobox.com>
+
+	* autogen.sh: hardcode aclocal-1.4/automake-1.4 so that users with
+	both automake 1.6 and 1.4 installed get the right automake. Means
+	compilation from CVS will now require the latest automake 1.4
+	release, or manually creating symlinks called "automake-1.4" and
+	"aclocal-1.4"
+
+Wed Aug 14 18:54:19 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in python/Makefile.am: more AMD 64 induced changes from
+	  Frederic Crozat
+
+Wed Aug 14 16:43:53 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xinclude.c: oops I was missing the xml:base fixup too
+	* result/XInclude/*.xml: this adds xml:base attributes to most
+	  results of the tests
+
+Wed Aug 14 16:05:37 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xinclude.c: quick but apparently working implementation of
+	  xi:fallback, should close bug #89684
+	* Makefile.am test/XInclude/docs/fallback.xml 
+	  result/XInclude/fallback.xml: added a basic test for fallback,
+	  and run with --nowarning to avoid a spurious warning
+	* configure.in: applied patch from Frederic Crozat for python
+	  bindings on AMD 64bits machines.
+
+Wed Aug 14 10:47:46 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: xmlSAXUserParseMemory() really ought to fail if
+	  the caller don't pass a SAX callback block.
+
+Wed Aug 14 10:29:02 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: applied the same fix for the XML-1.0 namespace to
+	  xmlSearchNsByHref() as was done for xmlSearchNs()
+
+Mon Aug 12 16:52:08 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* libxml.3: small cleanup of the man page
+	* HTMLtree.c: fixed a potential problem raised by Petr Vandrovec
+	  when serializing HREF attributes generated by XSLT.
+
+Mon Aug 12 15:24:05 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLtree.c include/libxml/HTMLtree.h: integrated a cleaned up
+	  version of Marc Liyanage' patch for boolean attributes in HTML
+	  output
+
+Mon Aug 12 14:11:59 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/tests/serialize.py: fixed the test results, indenting
+	  behaviour changed slightly
+
+Thu Aug  8 11:00:26 2002  Aleksey Sanin  <aleksey@aleksey.com>
+
+	* win32/dsp/libxml2.def.src win32/libxml2.def.src: added
+	new c14n function to Windows def files
+	
+Fri Aug  2 16:46:46 2002  Aleksey Sanin  <aleksey@aleksey.com>
+
+	* c14n.c: fixed a memory leak in c14n code
+
+Sat Aug  3 00:15:06 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c include/libxml/parser.h: adding a new API for Christian
+	  Glahn: xmlParseBalancedChunkMemoryRecover
+	* valid.c: patch from Rick Jones for some grammar cleanup in
+	  validation messages
+	* result/VC/* result/valid/*: this slightly change some of the
+	  regression tests outputs
+
+Thu Aug  1 14:50:28 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: trying to fix a problem in namespaced attribute handling
+	  raised by Christian Glahn
+
+Thu Aug  1 12:17:30 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* encoding.c include/libxml/encoding.h: Opening the interface
+	  xmlNewCharEncodingHandler as requested in #89415
+	* python/generator.py python/setup.py.in: applied cleanup
+	  patches from Marc-Andre Lemburg
+	* tree.c: fixing bug #89332 on a specific case of loosing 
+	  the XML-1.0 namespace on xml:xxx attributes
+
+Wed Jul 31 23:27:42 2002  Aleksey Sanin  <aleksey@aleksey.com>
+
+	* c14n.c include/libxml/c14n.h: fixed one more c14n + namespaces
+	corner case from new Merlin's test suite and added a callback
+	that will be used to improve xmlsec performance
+	
+
+Mon Jul 29 18:22:00 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLtree.c: trying to fix the <style> escaping problem in
+	  HTML serialization bug #89342
+
+Thu Jul 25 01:33:47 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* doc/xml.html doc/*.html: applied syntax patch from Rick Jones
+	  and rebuilt the web site.
+
+Mon Jul 22 11:04:48 PDT 2002  Aleksey Sanin <aleksey@aleksey.com>
+
+	* include/libxml/tree.h: added _private member to xmlNs struct
+
+Sun Jul 21 17:48:47 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLparser.c: fixing bug #84876 based on the xml working
+	  code.
+
+Sun Jul 21 19:15:00 HKT 2002 William Brack <wbrack@mmm.com.hk>
+
+	* python/Makefile.am: enhanced to fix bug 72012 (errors
+	  when using '-jX' make parameter)
+
+Fri Jul 19 16:35:00 HKT 2002 William Brack <wbrack@mmm.com.hk>
+
+	* xpath.c: small additional enhancement for booleans
+	  compared to nodesets
+
+Wed Jul 17 19:48:14 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLtree.c: changed the order of the encoding declaration
+	  attributes in the meta tags due to a bug in IE/Mac
+
+Fri Jul 12 08:45:00 HKT 2002 William Brack <wbrack@mmm.com.hk>
+
+	* xpath.c: enhanced handling of booleans (especially '='
+	  and '!=' for nodesets) - fixes bug 85256.  Added new
+	  routine xmlXPathNotEqualValues for more proper handling
+	  of '!=' when nodesets are involved.
+
+Thu Jul 11 21:45:52 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* doc/Makefile.am: fixing Red Hat bug #68614 by adding the
+	  doc/xmlcatalog_man.xml to the source distribution
+
+Wed Jul 10 21:26:13 CEST 2002 Igor Zlatkovic <igor@stud.fh-frankfurt.de>
+	
+	* win32/Makefile.msvc: Added a copy *.pdb to install, few have
+	  asked for this.
+	
+Sat Jul  6 21:55:59 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in: preparing 2.4.23
+	* doc/*: rebuilt the docs
+
+Sat Jul  6 21:11:20 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: fixing bug #84169 by fixing the
+	  comment of xmlCreatePushParserCtxt to describe the 
+	  encoding detection parameters better.
+
+Sat Jul  6 19:44:56 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* valid.c: fixing bug #79331 in one path the lookup for
+	  ID attributes on a namespaced node wasn't handled correctly :-\
+
+Fri Jul  5 20:07:43 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLparser.c: trying to fix 87235 about discarded white
+	  spaces in the HTML parser.
+	* result/HTML/*: this changes the output of a number of HTML
+	  regression tests
+
+Mon Jul  1 23:23:41 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: applied patch from Richard Jinks for the namespace
+	  axis + fixed a memory error.
+	* parser.c parserInternals.c: applied patches from Peter Jacobi
+	  removing ctxt->token for good.
+	* xmlschemas.c xmlschemastypes.c: fixed a few memory leaks
+	  popped out by the regression tests.
+	* Makefile.am: patch for threads makefile from Gary Pennington
+
+Fri Jun 28 19:38:00 HKT 2002 William Brack <wbrack@mmm.com.hk>
+
+	* xpath.c: enhanced behaviour of position() after usage of
+	  expressions involving preceding-sibling (et al).
+
+Tue Jun 18 09:58:48 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* hash.c: applied a patch from Peter Jacobi to solve a problem
+	  when compiling with the Watcom C on Win32 
+	* result/schemas/*.err: the change of hashing algo generated
+	  permutations in the output
+
+Mon Jun 17 19:02:49 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* hash.c: applied patch from Sander Vesik improving the quality of
+	  the hash function.
+
+2002-06-14  Aleksey Sanin  <aleksey@aleksey.com>
+
+	* DOCBparser.c HTMLparser.c debugXML.c encoding.c
+	nanoftp.c nanohttp.c parser.c tree.c uri.c xmlIO.c
+	xmllint.c xpath.c: replaced sprintf() with snprintf()
+	to prevent possible buffer overflow (the bug was pointed
+	out by Anju Premachandran) 
+
+Thu Jun 13 17:30:25 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: removed an uninitialized data error popped by valgrind
+	  on PE references
+
+Wed Jun 12 21:38:46 MDT 2002 John Fleck <jfleck@inkstain.net>
+
+	* doc/xml.html
+	adding tutorial reference to the web page
+
+Wed Jun 12 21:26:08 MDT 2002 John Fleck <jfleck@inkstain.net>
+
+	* doc/tutorial/xmltutorial.xml
+	* doc/tutorial/ar01s07.html
+	* doc/tutorial/ape.html
+	* doc/tutorial/includegetattribute.c
+	adding section to tutorial about retrieving an attribute
+	value
+
+Tue Jun 11 12:07:04 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: applied a couple of patches from Peter Jacobi to start
+	  to get rid of ctxt->token, with a possible significant speed
+	  improvement to be gained once done. Better compliance with PE
+	  references constructs in DTDs too.
+	* test/valid/t[0-9]* result/valid/t[0-9]*: added a set of tests
+	  from Peter too
+
+Tue Jun 11 09:25:12 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: Babak Vahedipour-Kunze reported that openTag in 
+	  xmlParseElement was likely to have been deallocated at the
+	  time of the report, possibly leading to segfault. Just report
+	  the tag name now.
+
+Mon Jun 10 18:00:02 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: patch from Richard Jinks for XPath substring() function
+	* result/XPath/expr/strings test/XPath/expr/strings: new set of tests
+
+2002-06-06  Aleksey Sanin  <aleksey@aleksey.com>
+
+	* xmlIO.c: patch from Rachel Hestilow to fix bug #84340
+
+Wed Jun  5 19:14:49 MDT 2002 John Fleck <jfleck@inkstain.net>
+
+	*doc/FAQ.html
+	fixing typos in FAQ, thanks to Robert Funnell for the
+	editing help
+
+Wed Jun  5 14:50:24 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* NEWS: got complaints from rpmlint that it was empty
+
+Tue Jun  4 09:09:18 MDT 2002 John Fleck <jfleck@inkstain.net>
+
+	* added doc/tutorial, including:
+	apa.html
+	apb.html
+	apc.html
+	apd.html
+	ar01s02.html
+	ar01s03.html
+	ar01s04.html
+	ar01s05.html
+	ar01s06.html
+	includeaddattribute.c
+	includeaddkeyword.c
+	includekeyword.c
+	includestory.xml
+	index.html
+	xmltutorial.xml
+	libxml tutorial, including generated html
+
+Mon Jun  3 21:21:26 2002  Aleksey Sanin  <aleksey@aleksey.com>
+
+	* result/c14n/exc-without-comments/merlin-c14n-two-*
+	  result/c14n/without-comments/merlin-c14n-two-*
+	  test/c14n/exc-without-comments/merlin-c14n-two-*
+	  test/c14n/without-comments/merlin-c14n-two-*
+	  testC14N.c Makefile.am: added merlin-c14n-two.tar.gz tests for 
+	c14n/exc-c14n and slightly modified test script to handle
+	these test cases
+	* c14n.c: fixed bugs for complicated nodes set (namespace
+	without node and others from merlin-c14n-two.tar.gz)
+	* include/libxml/xpathInternals.h win32/dsp/libxml2.def.src
+	win32/libxml2.def.src: "opened" xmlXPathNodeSetFreeNs() function
+	for xmlsec performance patch
+	* xpath.c: fixed self::node() for namespaces and attributes
+
+Mon Jun 03 00:04:21 2002 Chema Celorio <chema@ximian.com>
+
+	* tree.h: added xmlDocFormatDump which is just as xmlDocDump
+	  but with the format parameter
+	* tree.c: made xmlDocDump a wrapper arround xmlDocFormatDump
+
+Fri May 31 12:16:48 2002  Aleksey Sanin  <aleksey@aleksey.com>
+
+	* Makefile.am: updated c14n tests suite
+	* c14n.c: performance improvement for previous c14n patch
+
+Fri May 31 11:47:12 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: another peroformance patch from Peter Jacobi, that
+	  time on parsing attribute values.
+
+Thu May 30 23:34:27 2002  Aleksey Sanin  <aleksey@aleksey.com>
+
+	* Makefile.am result/c14n/* test/c14n/*: C14N tests integrated
+	into LibXML2 test suite
+
+Thu May 30 21:23:06 2002  Aleksey Sanin  <aleksey@aleksey.com>
+
+	* c14n.c: propagating xpath ancesstors node fix to c14n
+	plus small performance improvement to reduce number of
+	mallocs
+	* xpath.c: fixed ancestors axis processing for namespace nodes
+
+Wed May 29 10:21:39 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* SAX.c parser.c tree.c include/libxml/tree.h: performance patch from
+	  Peter Jacobi
+
+Mon May 27 23:18:33 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in: preparing 2.4.22
+
+Mon May 27 16:44:04 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLparser.c win32/libxml2.def.src win32/dsp/libxml2.def.src
+	  include/libxml/HTMLparser.h: fixing #79334 making htmlParseDocument
+	  a public entry point.
+	* doc/*: rebuilt the API and docs
+
+Mon May 27 14:16:28 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: patch from Richard Jinks to fix a problem introduced
+	  in the previous patch and pointed by Norm
+
+Fri May 24 13:10:22 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* libxml.spec.in: fixing bug #81112
+
+Fri May 24 13:03:24 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* uri.c: fixing bug #82848
+
+Fri May 24 09:54:49 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* result/catalogs/mycatalog.full: Aleksey's commit changed the
+	  output of one catalog test
+
+Fri 24 May 2002 12:17:45 AM PDT Aleksey Sanin <aleksey@aleksey.com>
+
+	* global.data globals.c tree.c include/libxml/globals.h 
+	win32/libxml2.def.src win32/dsp/libxml2.def.src: changed
+	default value for global parameter xmlIndentTreeOutput to 1 and
+	introduced new global parameter xmlTreeIndentString (the string
+	used to do one-level indent) with default value "  " (as it was
+	in tree.c)
+
+Thu May 23 13:55:57 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am: Merijn Broeren pointed out a problem when compiling
+	  with trio and schemas.
+
+Wed May 22 11:57:49 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: patch from Richard Jinks to fix the problem raised in
+	  http://mail.gnome.org/archives/xml/2002-April/msg00246.htm
+
+Wed May 22 08:38:19 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlschemas.c: a bit of work on import.
+	* xmlschemastypes.c: Charles Bozeman provided a compare function
+	  for date/time types so min/max facet restrictions should work,
+	  indeterminate comparisons return an error instead of equal.
+	* test/schemas/date_0* result/schemas/date_0_0: specific test
+	  from Charles Bozeman too
+
+Sat May 18 09:54:12 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* libxml.3 doc/buildDocBookCatalog: apply a couple of patches
+	  from Christian Cornelssen fixing the man pages and the Catalog
+	  building script.
+	* xmlschemas.c include/libxml/schemasInternals.h: nothing new yet
+	  next step is <xs:import> I now have a reasonable understanding
+	  of how it works.
+
+Thu May 16 10:43:26 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlIO.c: applied a small buffer performance patch from Gary Pennington
+
+Wed May 15 00:25:34 CEST 2002 Igor Zlatkovic <igor@stud.fh-frankfurt.de>
+
+	* win32/libxml2.def.src: exported xmlXPathNodeSetAddNs()
+
+Tue May 14 13:00:48 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: fixing an XPath function evalutation bug pointed out
+	  by Alexey Efimov where the context was lost when evaluating
+	  the function arguments
+
+Mon 13 May 2002 11:37:39 PM PDT Aleksey Sanin <aleksey@aleksey.com>
+
+	* xpath.c include/libxml/xpathInternals.h: maked xmlXPathNodeSetAddNs() 
+	  function public for XMLSec performance optimizations
+
+Mon May 13 12:32:22 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/generator.py python/libxml2class.txt : fixed a problem
+	  with the HTML parser pointed by Gary Benson
+	* python/tests/Makefile.am python/tests/pushSAXhtml.py: sdding the
+	  example
+
+Thu 09 May 2002 11:19:00 AM PDT Aleksey Sanin <aleksey@aleksey.com>
+	* parser.c: fixed bug #81159 (memory growth in SAX)
+	
+Tue 07 May 2002 09:20:21 AM PDT Aleksey Sanin <aleksey@aleksey.com>
+	* xpath.c: fixed bug #78858 (the real fix)
+
+Sat 04 May 2002 11:56:31 PM PDT Aleksey Sanin <aleksey@aleksey.com>
+	* xpath.c: fixed bug #78858 (quick and durty fix to hide the problem)
+	
+Sun May  5 08:57:08 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: modified xmlNodeSetBase to allow changing the
+	  base of a document.
+
+Fri May  3 09:20:41 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlschemastypes.c: patch Charles Bozeman for validation of
+	  all the date, time, and duration types
+	* test/schemas/dur_0* result/schemas/dur_0*: associated tests
+	* configure.in: fixed an error pointed by an user
+	* xml2-config.in: fixed an error pointed by an user
+
+Wed 01 May 2002 11:29:27 AM PDT Aleksey Sanin <aleksey@aleksey.com>
+
+	* include/libxml/xmlIO.h win32/dsp/libxml2.def.src
+	win32/libxml2.def.src xmlIO.c: exported default
+	'file:', 'http:' and 'ftp:' protocols input handlers 
+	and maked protocols comparisson case insensitive
+
+Tue Apr 30 16:29:05 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in: Neven Has detected a typo
+
+Tue Apr 30 08:48:11 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* AUTHORS HACKING: added Aleksey Sanin <aleksey@aleksey.com>
+	  as one of the persons allowed to commit directly to the
+	  module.
+
+Mon Apr 29 17:48:26 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in include/libxml/xmlwin32version.h: preparing 2.4.21
+	* valid.c: raised a too low limit
+	* doc/*: rebuilt the docs 
+
+Wed Apr 24 13:41:03 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* test/XPath/expr/floats test/XPath/expr/functions
+	  result/XPath/expr/floats result/XPath/expr/functions
+	  xpath.c: another XPath conformance patch from Richard Jinks
+
+Tue Apr 23 19:50:40 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlschemas.c: fixed validation of attribute groups.
+	* test/schemas result/schemas: added an example from the primer
+
+Tue Apr 23 09:11:37 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am xmlschemas.c xmlschemastypes.c: more work on Schemas
+	* test/schemas result/schemas: updated the test list
+
+Mon Apr 22 17:59:14 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* TODO: updated a bit
+	* parser.c: made a comment more specific
+	* xmlregexp.c xmlschemas.c xmlschemastypes.c: more work on the
+	  Schemas conformance.
+	* test/schemas result/schemas: updated the test list
+
+Sat Apr 20 19:36:39 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlregexp.c xmlschemas.c include/libxml/xmlautomata.h:
+	  implementing xs:all with minOccurs = 0
+	* tes/schemas/* result/schemas/*: added more tests covering
+	  xs:all
+
+Sat Apr 20 09:22:50 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlregexp.c: first implementation of the all particle, this
+	  may need to be revisited for case where not all transitions
+	  must be crossed.
+
+Fri Apr 19 18:26:04 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: another entity processing update from Markus Henke
+
+Fri Apr 19 17:14:24 CEST 2002 Bjorn Reese <breese@users.sourceforge.net>
+
+	* trionan.c: fixed crash on OSF/1
+
+Fri Apr 19 09:00:56 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlschemas.c: more Schemas work
+	* test/schemas/* result/schemas/*: added more tests coming
+	  from the spec.
+
+Thu Apr 18 23:00:02 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* c14n.c: patch from Aleksey Sanin reflecting a change in the
+	  ExcC14N specification
+
+Thu Apr 18 18:38:30 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: patch from Markus Henke, fix for recursive entities.
+
+Thu Apr 18 17:49:24 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: fix a problem with string() on a document node.
+
+Thu Apr 18 16:40:42 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am xmlschemas.c: more Schemas work
+	* test/schemas/* result/schemas/*: added more tests coming
+	  from the spec.
+
+Thu Apr 18 13:52:52 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLtree.c: fixed & serialization bug introduced in 2.4.20
+	* result/HTML/*: this changes a few things in the results
+
+Wed Apr 17 20:34:37 CEST 2002 Igor Zlatkovic <igor@stud.fh-frankfurt.de>
+
+	* include/libxml/tree.h: eliminated 'declaration different than
+	 prototype' warning
+	* include/win32config.h: "resolved" conflicts with errno.h
+
+Wed Apr 17 18:26:07 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlregexp.c xmlschemas.c include/libxml/xmlautomata.h: more work
+	  on the automata interfaces and debug of counted choices
+	* test/schemas/* result/schemas/*: added a number of tests
+
+Wed Apr 17 11:03:03 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlschemas.c xmlschemastypes.c include/libxml/xmlschemas.h:
+	  a bit of work on Schemas
+	* testSchemas.c: try to make it more useful
+	* test/schemas/* result/schemas/* Makefile.am: changed the
+	  Schemas regression test procedure, started adding a few samples
+
+Tue Apr 16 19:52:01 CEST 2002 Igor Zlatkovic <izlatkovic@stud.fh-frankfurt.de>
+
+	* include/libxml/encoding.h: Patch for the Borland C++ builder
+	* include/libxml/tree.h: Patch for the Borland C++ builder
+	* threads.c: Patch for the Borland C++ builder
+	* win32/bcb5: New directory for the Borland C++ builder
+	 project files       
+
+Tue Apr 16 19:46:55 CEST 2002 Igor Zlatkovic <izlatkovic@stud.fh-frankfurt.de>
+
+	* win32/Makefile.msvc: Update for XML Schema support
+	* win32/configure.js: Update for XML Schema support
+	* win32/libxml2.def.src: Update for XML Schema support
+
+Tue Apr 16 17:46:43 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am TODO_SCHEMAS configure.in genUnicode.py testAutomata.c
+	 testRegexp.c testSchemas.c xmlregexp.c xmlschemas.c xmlschemastypes.c
+	 xmlunicode.c include/libxml/Makefile.am
+	 include/libxml/schemasInternals.h include/libxml/xmlautomata.h
+	 include/libxml/xmlregexp.h include/libxml/xmlschemas.h
+	 include/libxml/xmlschemastypes.h include/libxml/xmlunicode.h
+	 include/libxml/xmlversion.h.in : merged the current state of
+	 XML Schemas implementation, it is not configured in by default,
+	 a specific --schemas configure option has been added.
+	* test/automata test/regexp test/schemas Makefile.am
+	  result/automata result/regexp result/schemas:
+	  merged automata/regexp/schemas regression tests
+
+Tue Apr 16 09:48:44 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: Gary found a compile time problem, fixes #78823
+
+Mon Apr 15 19:11:36 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in: release of 2.4.20
+	* doc/*: updated and rebuilt the docs
+
+Mon Apr 15 14:55:53 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/Makefile.am: patch from Cristian Gafton to build on
+	  Red Hat 6.2, should also fix #75779
+
+Mon Apr 15 12:14:49 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* valid.c: first part of fixing #78729
+
+Sun Apr 14 23:44:58 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLtree.c uri.c: fixing bug #78662 i.e. add proper
+	  escaping of URI when saving HTML files.
+	* result/HTML/*: this impacted some tests
+
+Sun Apr 14 14:55:15 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in: trying to fix #77441
+
+Fri Apr 12 23:02:16 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/xmlIO.h: Hallski complained it could not be
+	  included by itself.
+
+Thu Apr 11 10:23:36 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in: applied an IEEE flag patch for OSF/1 #77825
+
+Wed Apr 10 23:31:34 CEST 2002 Igor Zlatkovic <igor@stud.fh-frankfurt.de>
+
+	* win32/configure.js: patch from Nilo for the c14n option
+	* win32/Makefile.msvc: fixed libxml2.def generation with threads
+
+Wed Apr 10 21:24:16 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c include/libxml/xmlwin32version.h.in: Silvan Minghetti
+	  pointed erroneous use of LIBXML_THREADS_ENABLED instead of
+	   LIBXML_THREAD_ENABLED
+
+Wed Apr 10 18:12:52 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: another patch from Richard Jinks for substring conformance
+	* test/XPath/expr/floats test/XPath/expr/strings
+	  result/XPath/expr/floats result/XPath/expr/strings: update of the
+	  test suite to check those.
+
+Wed Apr 10 13:29:49 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: patch from Richard Jinks for .x float parsing.
+
+Tue Apr  9 18:09:31 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: patch from Markus Henke when an encoding ain't recognized
+
+Tue Apr  9 15:47:14 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* libxml.m4: got a report that #include <string.h> was needed
+
+Tue Apr  9 11:51:25 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmllint.c: applied a fix from Anthony Jones for -o /--output
+
+Tue Apr  2 20:27:11 MST 2002 John Fleck <jfleck@inkstain.net>
+
+	* doc/example.html: fixing typo
+
+Mon Apr  1 10:02:57 CEST 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: fixed a bug in the nodeset to boolean comparison code
+	  pointed out by Melvyn Sopacua.
+
+Fri Mar 29 23:41:53 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* libxml.m4: Frédéric Crozat gave a patch related to the change
+	  of Include paths breaking the libxml.m4
+
+Fri Mar 29 18:25:54 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: Fix bug #76927 forgot to save some context
+	  when evaluating binary expressions
+
+Thu Mar 28 19:22:48 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in: fixed configure for MPE/iX from Markus Henke
+	* xmlmemory.c: fixed initialization problems
+	* xpath.c: another set of patches from Richard Jinks this
+	  fixes "make XPathtests" on linux
+
+Wed Mar 27 17:09:43 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* trionan.c trionan.h xpath.c: more patches from Richard Jinks
+	* test/XPath/expr/compare test/XPath/expr/equality
+	  test/XPath/expr/floats test/XPath/expr/functions
+	  test/XPath/expr/strings result/XPath/expr/compare
+	  result/XPath/expr/equality result/XPath/expr/floats
+	  result/XPath/expr/functions result/XPath/expr/strings: Updated
+	  tests though they show a divergence on Linux
+
+Wed Mar 27 10:06:53 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c trionan.c: previous commit also included patches
+	  from Richard Jinks on some IEEE support corner case
+
+Wed Mar 27 10:03:11 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* AUTHORS HACKING: Added Igor Zlatkovic as official maintainer
+	* python/Makefile.am python/tests/Makefile.am: Albert Chin pointed
+	  that $(datadir) should be used for docs
+
+Tue Mar 26 13:43:16 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlIO.c: Thomas Steinborn pointed out #76404 that libxml2
+	  could leak filedescriptors
+
+Tue Mar 26 08:55:53 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in nanohttp.c: applied patch from Allan Clark for
+	  UnixWare/OpenServer
+
+Mon Mar 25 17:45:44 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in: preparing 2.4.19
+	* doc/*: rebuilt the docs
+
+Mon Mar 25 17:34:06 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* nanohttp.c: fixing #76043, got fed up with non-portability
+	  of that piece of code.
+
+Mon Mar 25 13:08:21 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* valid.c SAX.c: Never commit without running "make tests" :-(
+	  fix a couple of stupidities in the previous commit
+	* result/*: a few changes in some attribute order result of previous
+	  commit.
+
+Mon Mar 25 11:46:05 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* valid.c SAX.c: fixed bug #76168, attribute redeclared in
+	  the internal subset should not raise duplicate ID errors,
+	  also there was a small bug in conjunction to namespace
+	  declarations defaulted and xml:xxx attributes DTD definitions.
+	  
+Fri Mar 22 15:13:49 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: Richard Jinks also raised some rounding problems
+	  this tries to fix them
+
+Fri Mar 22 13:22:09 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: Richard Jinks spotted an incoherent memory allocation
+	  behaviour in xmlXPathCastToString()
+
+Thu Mar 21 14:25:29 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* encoding.c: fixed a bug in the ISO-Latin 1 to UTF8 encoder
+	  raised by Morus Walter
+
+Thu Mar 21 14:07:13 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlcatalog.c include/libxml/xmlversion.h.in: applied 2 fixups
+	  from Igor
+
+Thu Mar 21 13:30:06 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: fixing #75619, related to a problem when trying
+	  to evaluate condition when the current node set resulting
+	  from that sub-step evaluation is empty. Also fixes 2 potential
+	  problem with previous-sibling and next-siblings axis.
+
+Thu Mar 21 09:03:59 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* c14n.c: patch from Mark Vakoc to build C14N if DocBook and
+	  HTML support is not configured in.
+
+Wed Mar 20 22:42:42 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLparser.c error.c parser.c parserInternals.c tree.c xmlIO.c
+	  include/libxml/tree.h: dohh I really didn't intended to commit
+	  this test version :-(
+
+Wed Mar 20 20:20:57 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* testSAX.c: I wanted to see the real speed at the SAX interface
+	  after a little too many Ximianer started complaining about the
+	  parser speed.
+	  added a --quiet option:
+	  paphio:~/XML -> ls -l db100000.xml 
+	  -rw-rw-r--    1 veillard www      20182040 Mar 20 10:30 db100000.xml
+	  paphio:~/XML -> time ./testSAX --quiet db100000.xml 
+	  3200006 callbacks generated
+	  real	0m1.270s
+	  Which means 16MBytes/s and 3Mcallback/s
+
+Tue Mar 19 19:33:57 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: valgrind spotted another error that time when running
+	  on libxslt regression tests
+
+Tue Mar 19 15:24:49 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am: adding "make valgrind" running the full regression
+	  tests (except python ones) under Valgrind (using valgrind -q
+	  which was kindly added by the author).
+	* valid.c: stupid bug pinpointed by Valgrind, the regression tests
+	  passes cleanly now except an obcure floating point initialization
+	  raised in log10() in one XPath regression test ???
+	* tree.c: edited some comments to close #75244
+
+Tue Mar 19 12:15:20 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: pretty insane thing, the xmlXPathFormatNumber()
+	  was not serializing 1 as "1" if LC_ALL=sv_SE :-( and in the
+	  context of ScrollKeeper, made sure that if the number is
+	  an integer, the serialization follows the description at
+	  http://www.w3.org/TR/xpath#section-String-Functions
+
+Mon Mar 18 19:18:13 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in: preparing 2.4.18
+	* doc/*: updated and rebuilt the web site
+	* *.c libxml.h: implement the new IN_LIBXML scheme discussed with
+	  the Windows and Cygwin maintainers.
+	* parser.c: humm, changed the way the SAX parser work when
+	  xmlSubstituteEntitiesDefault(1) is set, it will then 
+	  do the entity registration and loading by itself in case the
+	  user provided SAX getEntity() returns NULL.
+	* testSAX.c: added --noent to test the behaviour.
+
+Mon Mar 18 12:44:23 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: Wilfried Teiken provided a hackish but working
+	  way to get context reported back on entities when parsing
+	  with SAX and without breaking the DOM build.
+
+Sun Mar 17 11:31:55 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* c14n.c: applied a new patch from Aleksey Sanin
+	* doc/site.xsl doc/xml.html doc/*.html: updated the documentation
+	  to reference Aleksey implementation of XML digital Signatures
+
+Sat Mar 16 23:01:42 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: small fix to avoid potential problem due to
+	  ordering of freeing data
+	* python/Makefile.am: people were complaining about 
+	  the generated file in python dir not being built
+
+Fri Mar 15 23:21:40 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* libxml.spec.in python/Makefile.am python/tests/Makefile.am
+	  python/generator.py python/libxml.c python/types.c: Cleanup
+	  of the python Makefiles based on Jacob and James feedback,
+	  fixed the spec file accordingly, fixed the number of warning
+	  that passing my pedantic CFLAGS was generating. Conclusion
+	  is that Python includes are real crap.
+
+Fri Mar 15 19:41:25 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* configure,in: it was reported quite a few times that
+	  xml2-config --cflags should not output
+	  -I$includeprefix/libxml2/libxml because libxml2 header names
+	  clashes with existing names like list.h from C++ stl.
+	  Includes should be #include<libxml/xxx.h> so ...
+
+Fri Mar 15 10:41:50 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* c14n.c: another patch from Aleksey Sanin
+
+Fri Mar 15 08:55:55 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* c14n.c: applied patch from Aleksey Sanin fixing a problem in the
+	  canonicalization algorithm
+	* doc/xml.html doc/index.html: added the C14N references on the 
+	  index page.
+
+2002-03-13  jacob berkman  <jacob@ximian.com>
+
+	* python/Makefile.am: remove LDADD and CFLAGS as this is broken
+	usage, redundant, and gcc specific
+
+Wed Mar 13 11:00:59 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: speedup some node selection operations, this can
+	  have a significant impact on DocBook Norm's stylesheets
+	* nanohttp.c: someone reported that SOCKLEN_T may not be defined
+	  make sure it's always the case
+	* debugXML.c: distinguish CDATA and comments in ls operations
+
+Tue Mar 12 19:45:24 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/*.h: Heiko W. Rupp fixed a lot of comments
+	  to generate better API descriptions etc...
+
+Mon Mar 11 10:10:30 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* c14n.c: Fixing #74186, made sure all boolean expressions
+	  get fully parenthesized, ran indent on the output
+	* configure.in HTMLtree.c SAX.c c14n.c debugXML.c tree.c xpointer.c
+	  include/libxml/tree.h: also #74186 related, removed the
+	  --with-buffers option, and all the preprocessor conditional
+	  sections that were resulting from it.
+
+Sun Mar 10 17:47:58 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* valid.c: applied patch from Dodji Seketeli fixing an
+	  uninitailized variable in xmlValidGetValidElements()
+
+Sat Mar  9 15:10:49 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* c14n.c: fixed a few comments
+	* doc/*.html doc/*/*.html: regenerated the docs and added
+	  the C14N API
+	* doc/api.xsl doc/gnome-xml.sgml: fixups and added IDs
+
+Sat Mar  9 11:16:11 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* check-xml-test-suite.py: fix to adapt varaiations in the
+	  bindings
+	* configure.in python/setup.py python/setup.py.in: fixed to
+	  have the version of the python scripts automatically updated
+
+Fri Mar  8 16:45:55 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: fixed a bug newly introduced and pointed by Uwe Fechner
+	  in xmlCopyProp()
+
+Fri Mar  8 15:49:10 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in: preparing 2.4.17 release
+	* doc/*: updated and rebuilt the docs
+	* xpath.c: fixed a comment
+	* python/libxml.c: fixed a possible reentrancy problem
+
+Thu Mar  7 23:19:28 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c python/tests/Makefile.am python/tests/attribs.py:
+	  fixed xmlHasNsProp() bugs for defaulted from DTD attribs,
+	  added a specific regression test
+	* python/generator.py: xmlHasNsProp() and xmlHasProp() shall
+	  not raise exceptions when failing to find the attribute.
+
+Thu Mar  7 16:11:35 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in xmllint.c: owen pointed out a problem with the
+	  ftme fix, gettimeofday() was not detected by configure and
+	  the ftime header wasn't included, dohhh
+
+Thu Mar  7 12:19:36 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in xmllint.c: trying to fix #71457 for timing
+	  precision when gettimeofday() is not availble but ftime() is
+
+Thu Mar  7 11:24:02 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* libxml.spec.in doc/Makefile.am: Fixed #73408 missing images
+	  are now copied on install and part of the -devel RPM
+
+Thu Mar  7 09:34:16 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: trying to avoid bug #72150 which was apparently
+	  caused by a gcc bug (or a processor problem) as detailed
+	  at http://veillard.com/gcc.bug
+
+Thu Mar  7 01:02:37 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c python/tests/Makefile.am python/tests/cutnpaste.py:
+	  fixed xmlReconciliateNs(), added a Python test/example for
+	  inter-document cut'n paste
+	* python/libxml.py: fixed node.doc on document nodes and added
+	  xpathEval() onto node objects
+
+Wed Mar  6 22:38:03 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLtree.c: fixed some htmlSetMetaEncoding() problems
+	* python/libxml.c python/tests/Makefile.am python/tests/serialize.py:
+	  fixup and integrated tests for the serialization stuff
+
+Wed Mar  6 19:40:57 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am libxml.3 libxml.4 libxml.spec.in: Fixed bug #72570
+	  moved the libxml man page to section 3
+
+Wed Mar  6 18:34:07 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: fix bug #72490
+	* python/libxml.c python/libxml.py: added methods serialize()
+	  and saveTo() to all node elements.
+
+Tue Mar  5 21:27:03 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlIO.c: closed #73430, don't read from an input source
+	  which indicated an end-of-file or an error.
+
+Tue Mar  5 16:33:42 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: make sure SAX endDocument is always called as
+	  this could result in a Python memory leak otherwise (it's
+	  used to decrement ref-counting)
+	* python/generator.py python/libxml.c python/libxml.py
+	  python/libxml2-python-api.xml python/libxml2class.txt
+	  python/tests/error.py python/tests/xpath.py: implemented
+	  the suggestions made by Gary Benson and extended the tests
+	  to match it.
+
+Tue Mar  5 10:35:24 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/generator.py: applied patch fixing #73450
+
+Mon Mar  4 17:59:29 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: fixing #61290 "namespace nodes have no parent"
+	  long standing divergence from the XPath REC. NodeSets
+	  simply hold a copy of namespace nodes and those node ->next
+	  points to the parent (which may not be the node carrying the
+	  definition).
+	* include/libxml/xpath.h: flagged but didn't added a possible
+	  speedup
+	* DOCBparser.c HTMLparser.c: removed some warnings from push
+	  parser due to new state being added.
+	* tree.c: new fix from Boris Erdmann
+	* configure.in c14n.c include/libxml/c14n.h testC14N.c: added
+	  the XML Canonalization support from Aleksey Sanin
+
+Sun Mar  3 15:12:42 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: patch from Boris Erdmann fixing some namespace odities
+	  with xmlCopyNode()
+
+Sat Mar  2 10:33:04 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlIO.c: fix bug #72706 when loading a NULL entity
+
+Fri Mar  1 17:14:42 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* SAX.c: Fixed #72346, about handling of xmlns:foo="", this could
+	  actually change in a future XML Namespace revision.
+
+Fri Mar  1 17:12:15 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/types.c python/tests/Makefile.am python/tests/xpathret.py:
+	  added the possibility of returning nodesets from XPath extension
+	  functions written in Python
+
+Fri Mar  1 13:56:12 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/*: commiting some Python bindings work done while travelling
+
+Fri Mar  1 10:11:15 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmllint.c: close #72663 and #72658, don't memdump unless compiled
+	  explicitely with memory debugging switched on
+
+Sat Feb 23 11:08:09 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/generator.py python/libxml.c python/libxml2-python-api.xml
+	  python/libxml2class.txt python/libxml_wrap.h python/types.c:
+	  Added wrapper for the xmlURIPtr type, provided accessors, fixed
+	  the accessor generator for strings
+	* python/tests/Makefile.am python/tests/tstURI.py: added a specific
+	  regression test.
+
+Fri Feb 22 23:44:57 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/README python/generator.py python/libxml.c python/setup.py:
+	  added the 'usual' setup.py to allow building a libxml2-python
+	  module based on the same code. The initialization is however
+	  different the 2 .so files fo libxml2 and libxslt are identical and
+	  they entry point initialize both libraries. this is done to avoid
+	  some possible nasty problem since the Python don't merge the maps
+	  of all shared modules.
+
+Wed Feb 20 23:16:08 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: fixed a push/encoding bug reported by Michael
+	  on librsvg
+
+Wed Feb 20 19:54:05 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/parserInternals.h: fixes a misplaced #endif
+
+Wed Feb 20 17:47:55 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c valid.c: found and fixed a couple of allocation bugs
+
+Wed Feb 20 15:36:03 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* doc/xml.html doc/python.html doc/*: added a Python and binding
+	  page describing the current state of the Python bindings and 
+	  giving pointers to the other languages wrappers.
+
+Wed Feb 20 11:16:15 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in include/libxml/xmlwin32version.h: preparing 2.4.16
+	* doc/* python/libxml2class.txt: updated and rebuilt the docs,
+	  rebuilt the API and web site
+	* xpath.c: fixed #71978 portability bugs
+
+Tue Feb 19 22:49:36 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* SAX.c: oops broke automatic defaulting of namespaces attributes.
+
+Tue Feb 19 22:01:35 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/parserInternals.h parser.c: had to change
+	  2 internal parsing API when processing document content
+	  to check the start and end of element content are defined
+	  in the same entity
+	* valid.c include/libxml/valid.h: attribute normalization can
+	  generate a validity error added xmlValidCtxtNormalizeAttributeValue()
+	  with the context to report it.
+	* SAX.c: fixed the last known bugs, crazy validation constraints
+	  when a document is standalone seems correctly handled. There
+	  is a couple of open issues left which need consideration especially
+	  PE93 on external unparsed entities and standalone status. 
+	  Ran 1819 tests: 1817 suceeded, 2 failed and 0 generated an error in 8.26 s.
+	  The 2 tests left failing are actually in error. Cleanup done.
+
+Tue Feb 19 15:17:02 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* valid.c: implemented E59 spaces in CDATA does not match the
+	  nonterminal S
+
+Tue Feb 19 14:44:53 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* SAX.c parser.c valid.c: more validation test fixups
+	* check-xml-test-suite.py: added duration info for the tests
+
+Mon Feb 18 23:25:08 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c valid.c: a couple of errors were reported but not
+	  saved back as such in the parsing context. Down to 1% failure rate
+	  Ran 1819 tests: 1801 suceeded, 18 failed and 0 generated an error
+
+Mon Feb 18 20:16:15 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlInternald.c: isExtender was missing a char 
+	* parser.c include/libxml/parser.h: % are acceptable in the
+	  internal subset if within a PUBLIC ID
+
+Mon Feb 18 19:27:32 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* SAX.c parserInternals.c valid.c: more work on the conformance
+	  suite. Took the step to finally block documents with encoding
+	  errors. It's a fatal error per the spec, people should have fixed
+	  their documents by now.
+
+Mon Feb 18 15:30:14 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* check-xml-test-suite.py: fixed the test script after some discussion
+	  on the semantic of TYPE="error"
+	* Makefile.am: added the script to the distrib
+
+Mon Feb 18 12:17:41 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* SAX.c entities.c: fixed a couple of conformances issues deep
+	  into the validation code (standalone and undeclared Notations)
+
+Mon Feb 18 00:17:24 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: fixed #71741 supid typo an a bug about encoding parsing
+	  stayed there for years !
+
+Mon Feb 18 00:06:42 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* valid.c SAX.c: fixed #71740 NotationDecl with a required field
+	  missing
+
+Sun Feb 17 23:45:40 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* check-xml-test-suite.py: improved the behaviour a bit as
+	  well as the logs
+	* parser.c valid.c SAX.c: fixed a few more bugs 
+	  "Ran 1819 tests: 1778 suceeded, 41 failed, and 0 generated an error"
+
+Sun Feb 17 20:41:37 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* check-xml-test-suite.py: python script to run regression tests
+	  against the XML Test suite of W3C/OASis
+	* SAX.c: fixed a validation bug
+	* parser.c: fixed 3 errors pointed by the test suite
+	* doc/buildDocBookCatalog: fixed a typo pointed by drake
+	* python/Makefile.am: fixed a dependendy
+
+Fri Feb 15 21:47:13 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlmemory.c: avoid a warning bug #71594
+
+Wed Feb 13 22:13:33 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlmemory.c: Jesse Perry provided a patch to remove a few
+	  warning on alpha/Tru64
+
+Wed Feb 13 14:30:49 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/entities.h: fixing a comment
+	* valid.c: fixing some troubles with validity check on namespaces
+	* result/VC/NS3 test/VC/NS3: added a specific regression test
+
+Wed Feb 13 14:05:24 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: Fixing #71342 serializing '\n' in attribute values
+	* result/noent/att3 result/att3 test/att3: added a specific
+	  test.
+
+Tue Feb 12 14:45:32 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/libxml.c: couple of bug fixes
+
+Mon Feb 11 19:41:29 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/*.py: removed tabs and used spaces.
+
+Mon Feb 11 19:25:44 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in include/libxml/xmlwin32version.h: preparing 2.4.15
+	* doc/news.html doc/xml.html doc/xmlio.html: rebuilt some docs
+
+Mon Feb 11 14:53:24 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* doc/xmlcatalog_man.xml: trying to close Red Hat bug #58707
+	  https://bugzilla.redhat.com/bugzilla/show_bug.cgi?id=58707
+
+Mon Feb 11 09:53:02 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/encoding.h include/libxml/entities.h
+	  include/libxml/globals.h include/libxml/parser.h
+	  include/libxml/threads.h include/libxml/tree.h
+	  include/libxml/xmlmemory.h: trying to fix the include mess
+
+Mon Feb 11 08:53:33 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/xmlmemory.h: reverted part of the previous
+	  attempt to provide #69655, this was breaking the build.
+
+Sun Feb 10 14:13:34 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLtree.c Makefile.am build_glob.py configure.in debugXML.c
+	  globals.c parser.c threads.c tree.c valid.c xmlmemory.c
+	  xpath.c xpointer.c include/libxml/globals.h include/libxml/parser.h
+	  include/libxml/parserInternals.h include/libxml/tree.h
+	  include/libxml/xmlmemory.h include/libxml/xpathInternals.h:
+	  Tentatively fixed #69655 , make compiling with -Wredundant-decls
+	  clean.
+        * python/libxml.c: fixed a warning.
+
+Sun Feb 10 12:02:59 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c valid.c xinclude.c: fix #68882, cleanup the XInclude
+	  copying of node, merge back IDs in the target document.
+	* result/XInclude/docids.xml test/XInclude/docs/docids.xml
+	  test/XInclude/ents/ids.xml: test case
+	* result/VC/ElementValid4: output changed due to a typo fix
+
+Sat Feb  9 23:15:04 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/Makefile.am: seems some version of automake didn't
+	  generate the dependencies right as Jacob found out. Add
+	  an extra dependency rule.
+
+Sat Feb  9 18:59:23 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* parserInternals.c valid.c: Justin Fletcher found some parts
+	  of the code needing cleanup
+	* libxml.spec.in python/Makefile.am python/generator.py
+	  python/libxml.c python/libxml.py: Fixed the python Makefiles
+	  corrected a bug showing up on ia64, changed the name of the
+	  python internal module too
+
+Fri Feb  8 15:19:28 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am: applied patch from Andris Pavenis for binary
+	  name suffixes
+
+Fri Feb  8 14:43:17 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmllint.c win32/win32config.h: fixing #68748
+
+Fri Feb  8 14:37:05 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* valid.c: fixing #70166
+
+Fri Feb  8 14:31:24 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* valid.c: fixing #70077
+
+Fri Feb  8 14:24:02 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* Copyright Makefile.am README configure.in libxml.spec.in:
+	  Changed to the MIT Licence
+	* doc/FAQ.html doc/catalog.html doc/intro.html doc/xml.html
+	  doc/xmlio.html: updated the doc accordingly
+	* include/libxml/xmlwin32version.h configure.in: preparing
+	  2.4.14 release
+	* python/generator.py python/libxml.c python/libxml2-python-api.xml
+	  python/libxml2class.txt python/libxml_wrap.h python/types.c:
+	  fixed the const xmlChar * wrapper and generator, XPath extension
+	  functions now use the context as first argument
+	* python/tests/tstxpath.py python/tests/xpath.py
+	  python/tests/xpathext.py: Updated the tests accordingly
+	* tree.c: fixed bug #70067
+
+Thu Feb  7 17:33:58 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am: cleanup
+	* debugXML.c: always use stdout if output is NULL
+	* xmlIO.c: don't close filedescriptors passed to outputBuffers
+	* python/Makefile.am python/generator.py python/libxml2class.txt
+	  python/libxml_wrap.h python/types.c: augmented the number of bindings
+	  handling FILE * and XPath contexts
+	* python/tests/Makefile.am: avoid a stupid problem due to the
+	  use of TEST.
+
+Wed Feb  6 23:37:07 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in: fixed stupid bug #70738 found by alfons hoogervorst
+
+Wed Feb  6 17:04:51 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/TODO python/libxml.c: cleanup the extension function lookup
+	* xmlmemory.c include/libxml/xmlmemory.h: always compile the list
+
+Tue Feb  5 17:33:30 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in python/Makefile.am: do not install outside
+	  of prefix
+
+Mon Feb  4 15:05:55 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/TODO python/libxml.c: started adding SAX interfaces
+	* python/tests/Makefile.am python/tests/pushSAX.py: added a basic
+	  SAX test
+
+Mon Feb  4 01:12:42 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: hardened the addChild function
+	* python/generator.py python/libxml.c python/libxml2-python-api.xml
+	  python/libxml2class.txt python/libxml_wrap.h python/TODO:
+	  added accessors needed for xmlNode, a bit more testing and
+	  extension of interfaces
+	* python/tests/Makefile.am python/tests/build.py: added a test
+	  build from scratch/save/load/check
+
+Sun Feb  3 21:10:39 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* parserInternals.c: change a small bit in the way valididy
+	  error messages get initialized
+	* python/TODO python/libxml.c python/libxml2-python-api.xml
+	  python/libxml2class.txt python/libxml_wrap.h python/types.c:
+	  added some memory debugging to track leaks at the libxml2 level
+	* python/tests/*.py: changed all tests to check for leaks,
+	  there is just one left in XPath extension registrations.
+
+Sun Feb  3 17:50:46 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/TODO python/generator.py python/libxml2-python-api.xml
+	  python/libxml2class.txt: more accessor classes for the parser
+	  context, allow to switch on and check validity
+	* python/tests/Makefile.am python/tests/error.py
+	  python/tests/invalid.xml python/tests/valid.xml
+	  python/tests/validate.py: attded more test and and added error.py
+	  which I forgot to commit in the last step
+
+Sun Feb  3 16:03:55 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/Makefile.am python/types.c: cleanup
+	* python/libxml.c python/libxml.py python/libxml_wrap.h
+	  python/generator.py python/libxml2-python-api.xml 
+	  python/libxml2class.txt: added class for parser context, added
+	  first cut for push mode support. Added a framework to generate
+	  accessors functions.
+	* python/tests/Makefile.am python/tests/push.py: added a push
+	  test
+
+Sun Feb  3 00:17:26 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/Makefile.am python/TODO python/libxml.py: fixed a small
+	  bug a bit of cleanup.
+
+Sat Feb  2 22:47:10 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/Makefile.am python/libxml.c python/libxml2-python-api.xml
+	  python/libxml2class.txt: adding error redirections and preformat
+	  to a python handler
+	* python/tests/Makefile.am python/tests/*.py: cleanup made all
+	  tests self checking
+
+Sat Feb  2 13:18:54 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/libxml.c python/libxml.py: fixed a stupid bug when renaming
+	  a function
+
+Sat Feb  2 11:25:51 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* libxml.spec.in python/Makefile.am python/TODO python/generator.py
+	  python/libxml.c python/libxml2-python-api.xml
+	  python/libxml2class.txt: Progressing through the TODOs, class
+	  description output, extra XML API, RPM now builds the wrappers
+	  for all python installed versions
+
+Sat Feb  2 10:13:52 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in libxml.spec.in python/Makefile.am python/TODO
+	  python/generator.py python/libxml2class.txt: added more informations
+	  in the libxml2-python package including docs. Slightly changed
+	  the class hierarchy
+	* python/tests/*: added basic regression tests infrastructure too
+
+Fri Feb  1 23:11:58 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in libxml.spec.in example/Makefile.am python/Makefile.am:
+	  added libxml2-python as part of the packages installed
+
+Fri Feb  1 18:48:19 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/Makefile.am python/generator.py python/libxml.c
+	  python/libxml.py: more work, now able to extend the
+	  XPath interpreter with functions written in python.
+
+Fri Feb  1 10:28:51 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/Makefile.am: Jacob sent a patch to allow building from
+	  tarfile.
+
+Fri Feb  1 00:40:48 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/Makefile.am python/libxml.c configure.in Makefile.am:
+	  inserted the python wrappers build, I hope this won't be too
+	  unportable
+
+Thu Jan 31 21:27:37 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: minor optimization
+	* python/generator.py python/libxml.c python/libxml.py
+	  python/libxml_wrap.h: more work on the python bindings,
+	  they now support XPath and there is no evident leak
+
+Thu Jan 31 00:48:06 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/generator.py python/libxml.c python/libxml.py:
+	  more work on the python bindings generator.
+
+Wed Jan 30 21:51:26 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/generator.py python/libxml.c python/libxml_wrap.h:
+	  more work on the python bindings.
+
+Wed Jan 30 17:35:33 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* python/generator.py python/libxml.c python/libxml.py
+	  python/libxml_wrap.h: commited early version of a python binding
+	  for private use only ATM
+
+Sat Jan 26 22:41:13 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* entities.c tree.c include/libxml/entities.h: applied patch
+	  from Anthony Jones to implement copy of DTD subtree too. Had
+	  just to keep 2 function private which really ought to become
+	  public ones.
+
+Fri Jan 25 15:14:55 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmllint.c: added pointers to the web pages in the usage()
+
+Thu Jan 24 17:04:04 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: more fixes from Petr Kozelka for attribute handling
+	  in the tree API to align the semantic with DOM.
+
+Thu Jan 24 16:00:53 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* valid.c tree.c entities.c: another set of patches from
+	  Anthony Jones for copy operations cleanup and robustness
+
+Wed Jan 23 18:53:55 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* doc/APIchunk*.html doc/parsedecl.py doc/api.xsl: generated
+	  an alphabetic index based on comments content
+	* doc/*: rebuilt the web site with the new references
+
+Wed Jan 23 15:14:22 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* parserInternals.h: Greg Sjaardema suggested to use an
+	  eponential buffer groth policy in xmlParserAddNodeInfo()
+
+Wed Jan 23 13:32:40 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* doc/api.xsl doc/APIconstructors.html doc/APIfiles.html
+	  doc/APIfunctions.html doc/APIsymbols.html doc/libxml2-refs.xml
+	  doc/parsedecl.py doc/Makefile.am: updated the python extractor
+	  to generate cross-references, and added/updated the stylesheets
+	  to generate and link API indexes. The generic keyword index
+	  is not done yet.
+	* doc/*.html: regenerated all the usual docs too
+
+Tue Jan 22 23:11:26 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* debugXML.c: added an xpath function to the shell for T. V. Raman
+
+Tue Jan 22 22:42:23 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* debugXML.c: patch from Anthony Jones to catch NULL nodes in
+	  debug routines.
+
+Tue Jan 22 22:38:42 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: apply an patch from Petr Kozelka for unlink and replace 
+	  support of attribute nodes
+
+Tue Jan 22 19:12:06 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* doc/libxml2-api.xml doc/parsedecl.py: Build a new version
+	  hopefully near complete and fully documented of the API in XML
+	* HTMLtree.c SAX.c debugXML.c error.c globals.c parser.c tree.c
+	 xmlIO.c xmlmemory.c include/libxml/catalog.h include/libxml/hash.h
+	 include/libxml/list.h include/libxml/parser.h include/libxml/tree.h
+	 include/libxml/parserInternals.h include/libxml/valid.hi
+	 include/libxml/xmlIO.h include/libxml/xmlerror.hi
+	 include/libxml/xmlmemory.h include/libxml/xmlversion.h.ini
+	 include/libxml/xpath.h include/libxml/xpathInternals.h:
+	  Cleaned up the doc comments a lot in the process, the interface
+	  coverage is now 100%
+
+Tue Jan 22 00:12:58 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* doc/libxml2-api.xml doc/parsedecl.py: improved the script to
+	  extracts comments from the gtk-doc DocBook output (a bit
+	  convoluted but seems to work).
+
+Mon Jan 21 18:29:19 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am doc/Makefile.am doc/libxml2-api.xml doc/parsedecl.py:
+	  added an XML description of the API, moved the script generating
+	  it here. Added a "make api" target
+
+Mon Jan 21 14:34:37 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: Adam Lounds pointed out a bug in xmlSearchNs()
+	  
+Mon Jan 21 09:55:21 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c include/libxml/xpathInternals.h: the change made to
+	  xmlXPathFuncLookupFunc was incompatible roll it back
+
+Sun Jan 20 23:03:41 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* SAX.c: cleanup patch from Anthony Jones
+	* doc/Makefile.am: fix the headers to avoid in make scan
+	* parserInternals.c xpath.c include/libxml/*.h: cleanup of the
+	  includes, * vs Ptr and general cleanup
+	* parsedecl.py: first version of a script to extract the
+	  module interfaces, the goal will be to provide .decl or XML
+	  specification of the interfaces to build wrappers.
+
+Sun Jan 20 13:38:22 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* doc/xmlcatalog_man.xml xmlcatalog.c: Fixed bug #68830, xmlcatalog
+	  now provides return codes in case of errors
+
+Sat Jan 19 16:36:21 CET 2002 Bjorn Reese <breese@users.sourceforge.net>
+
+	* trio.h trio.c triodef.h triop.h trionan.h trionan.c Makefile.am:
+	  Upgraded to trio baseline 1.6
+	* strio.h strio.c: Replaced by triostr.h and triostr.c
+
+Fri Jan 18 17:22:50 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* globals.c xmlIO.c xmlcatalog.c: removed the last occurences
+	  of strdup usage in the code
+
+Fri Jan 18 12:47:15 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c error.c: Keith Isdale complained rightly that 
+	  xmlInitParser() did not preserve value set by xmlSetGenericErrorFunc
+
+Thu Jan 17 09:44:44 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: fixed the funxtion to set the xml: attributes
+	* debugXML.c: added "setbase" to test it.
+
+Wed Jan 16 16:36:08 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: update xmlNodeSetContent() and xmlNodeSetContentLen()
+	  to allow updating an attribute content
+
+Tue Jan 15 18:09:23 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* libxml.h: try to avoid problems when compiling on Windows
+
+Mon Jan 14 18:56:25 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* hash.c: patch from Anthony Jones for hash.c allocation size
+	* Makefile.am: trying to work around Yet Another Libtool Madness
+	  and build the 2.4.13 release finally ...
+
+Mon Jan 14 18:27:19 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in include/libxml/xmlwin32version.h: updated to 2.4.13
+	* doc/* : update of the documentation
+
+Mon Jan 14 17:53:41 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* debugXML.c tree.c: some cleanup after an unsuccessful attempt
+	  at fixing #61290 :-(
+
+Sun Jan 13 21:30:54 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: fixed xmlSaveFormatFileEnc() when encoding == NULL
+	  Fixes bug #67229
+
+Sun Jan 13 17:14:06 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: trying to avoid troubles when a subtree is copied
+	  and coalesced in part with the target tree. Should fix 
+	  bug #67407
+
+Sun Jan 13 16:37:15 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* valid.c: fixed validation of attributes content of type
+	  NAME NAMES NMTOKEN and NMTOKENS to accept internationalized
+	  values, very old bug. Fixes #67671
+
+Sun Jan 13 15:07:49 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c include/libxml/parserInternals.h tree.c: integrated
+	  a couple of fixes and a new API function xmlSetEntityReferenceFunc()
+	  from Keith Isdale and dedicated to xsldbg the XSLT debugger.
+
+Sun Jan 13 14:23:21 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* threads.c: applied Serguei Narojnyi's patch to add native
+	  thread support on the Win32 platform
+	* testThreadsWin32.c Makefile.am: added the test program also
+	  from Serguei, Win32 specific
+	* include/win32config.h include/libxml/xmlwin32version.h.in:
+	  added patch from Igor for the Windows thread specific defines.
+
+Wed Jan  9 12:50:39 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* entities.c: Anthony Jones pointed a bug in xmlCopyEntity()
+
+Tue Jan  8 14:23:22 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* doc/*.html doc/site.xsl doc/Makefile: renamed XML.html
+	  output page into XMLinfo.html. Close bug #66951 and
+	  raised by Robert Collins too.
+
+Tue Jan  8 14:13:18 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* encoding.c: Paul Keogh pointed out a possibility of segfault
+	  on repeted xmlAddEncodingAlias() / xmlCleanupEncodingAlias().
+	  Closes bug # 68238
+
+Tue Jan  8 12:48:27 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* doc/*.html: updated the Gdome2 links
+
+Tue Jan  8 11:32:30 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* libxml.h: Applied following patches from Robert Collins
+	  and make sure IN_LIBXML is defined when compiling it
+	-------
+	* include/libxml/xmlversion.h.in (LIBXML_DLL_IMPORT): Use on Cygwin
+	  as well as Visual C.
+	* parser.c (XML_DIR_SEP): Don't use '\\' for Cygwin.
+	* parserInternals.c (XML_DIR_SEP): Don't use '\\' for Cygwin.
+	* strio.c (PLATFORM_UNIX): Define for Cygwin.
+	* triodef.h (TRIO_PLATFORM_UNIX): Define for Cygwin.
+	* xmlIO.c (xmlFileOpen): Use unix behaviour for Cygwin.
+	  Use binary mode opens for Cygwin (xmlFileOpenW xmlParserGetDirectory
+	  xmlSysIDExists xmlNoNetExists).
+	* xmllint.c: Don't include winsock2.h for Cygwin.
+
+Mon Jan  7 17:52:48 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: Jirka Kosek pointer out a bug in xmlParseTextDecl()
+	  when the version info is not present.
+
+Mon Jan  7 00:03:58 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: Anthony Jones  pointed out a problem in
+	  xmlStringGetNodeList() and provided a fix for it
+
+Sun Jan  6 13:45:49 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: patch from Frank J Franklin to remove a bug in
+	  xmlCreatePushParserCtxt() when the initial buffer passed
+	  is large.
+
+Sat Jan  5 19:24:23 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* win32/*: big cleanup of the Windows/MSVC project files
+	  from Igor Zlatkovic
+
+Wed Jan  2 14:11:35 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* doc/Makefile.am: should fix #67674 and avoid troubles if 
+	  xsltproc is not available or fails in the prefix provided
+
+Tue Jan  1 17:48:56 CET 2002 Daniel Veillard <daniel@veillard.com>
+
+	* xmlmemory.c: one more doc patch from Charlie Bozeman.
+
+Mon Dec 31 17:35:40 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* DOCBparser.c parser.c valid.c include/libxml/parserInternals.h
+	  include/libxml/xmlerror.h include/libxml/xpathInternals.h:
+	  Fixed a few other problems raised by Charlie Bozeman.
+	* result/VC/ElementValid[5-7]: fixed the output
+
+Mon Dec 31 17:13:34 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* *.c include/libxml/*.h doc/html/*: applied 42 documentation
+	  patches from Charlie Bozeman. Regenerated the HTML docs.
+
+Thu Dec 20 14:59:52 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/debugXML.h win32/dsp/libxml2.def.src: fixes
+	  for Windows from Igor
+
+Tue Dec 18 12:13:33 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* xmllint.c: applied Justin Fletcher patch for --output or -o
+
+Tue Dec 18 08:52:32 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* win32/libxml2/libxml2.def.src: close #67019
+
+Tue Dec 18 08:08:51 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* xmllint.c: applied Justin Fletcher generic timing patch
+	  similar to the one already applied to xsltproc.
+
+Mon Dec 17 16:29:08 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/tree.h tree.c: applied documentation patches
+	  from Charlie Bozeman
+
+Thu Dec 13 21:24:16 MST 2001 John Fleck <jfleck@inkstain.net>
+
+	*doc/xmllint.xml, xmllint.1 - document --dropdtd
+	
+Thu Dec 13 23:19:50 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* valid.c: fix the xmlStrdup() used in the previous patch.
+	* valid.c: added --dropdtd
+	* tree.c: fixed xmlUnlinkNode so it also removes the references
+	  from the document if the node is a DTD
+
+Thu Dec 13 15:54:35 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLtree.c valid.c: cleanup some static declarations
+
+Thu Dec 13 15:23:04 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* xmllint.c: removed another strdup()
+	* doc/FAQ: removed the HP/UX entry
+
+Thu Dec 13 09:44:58 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* valid.c: fix bug #66816 when validating.
+	* xmllint.c: don't use sys/time.h if configure did not found it
+
+Mon Dec 10 21:39:55 MST 2001 John Fleck <jfleck@inkstain.net>
+
+	* docs/xmllint.1, xmllint.xml, xmlcatalog.1, xmlcatalog_man.html,
+	xmlcatalog_man.xml
+
+Mon Dec 10 22:06:16 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/xmlmemory.h: Hietaniemi Jarkko pointed out that
+	  xmlInitMemory() was declared twice
+
+Sun Dec  9 14:59:23 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* globals.c: do not reference strdup() !
+	* configure.in libxml-2.0.pc.in: trying to fix the libs
+	  of the various config extraction modules
+
+Fri Dec  7 15:21:33 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in : preparing 2.4.12
+	* doc/* : updated and rebuilt the docs
+
+Fri Dec  7 12:32:00 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* uri.c: closed bug #66159
+	* testURI.c: added --escape option
+	* configure.in: some cleanup for xml2-config --cflags
+
+Thu Dec  6 15:31:30 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* globals.c testThreads.c: removed some misplaced includes
+	  of xmlversion.h
+
+Thu Dec  6 09:06:08 EST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* threads.c: patch from Gary Pennington fixing a possible
+	  problem at initialization time.
+
+Wed Dec  5 13:01:37 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in libxml.h parser.c testThreads.c macos/: integrated
+	  Eric Lavigne contribution to build libxml2 on MacOS using
+	  CodeWarrior.
+
+Tue Dec  4 14:13:44 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* xmllint.c: applied Geert Kloosterman's patch to fix
+	  --repeat --timing output
+
+Thu Nov 29 17:10:22 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: Robin Berjon <robin@knowscape.com> found a case
+	  where non-wellformed XML declaractions were not detected.
+
+Wed Nov 28 15:41:40 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* xpointer.c: fixed a compilation bug pointed by Danny Jamshy
+
+Wed Nov 28 10:09:51 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* xmlIO.c: as robert pointed again, xmlInputCallbackInitialized
+	  gets reset by xmlCleanupInputCallbacks() and this makes the
+	  function useless. Same for output.
+
+Tue Nov 27 17:22:36 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* xmlIO.c: robert pointed out a loop error in callback cleanups
+
+Mon Nov 26 16:56:00 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c debugXML.c include/libxml/tree.h include/libxml/debugXML.h:
+	  moved xmlGetLineNo() and xmlGetNodePath() into the main tree module,
+	  they are not really tied to debugging
+
+Mon Nov 26 11:31:36 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in include/libxml/xmlwin32version.h: preparing 2.4.11
+	* xmllint.c: better --catalogs description
+
+Sun Nov 25 11:34:24 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: fixed a couple of problems in xmlSetProp()
+
+Thu Nov 22 19:19:10 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* debugXML.c tree.c xmlIO.c xmlmemory.c: some cleanups when chasing
+	  unappropriate stdout output.
+
+Thu Nov 22 13:58:14 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/tree.h: Fixed a couple of macro errors pointed out
+	  by Denis Beurive, closes #65111
+
+Tue Nov 20 10:34:01 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* valid.c: in case of content model validity error, don't
+	  print it if validity warnings were not requested.
+
+Tue Nov 20 09:30:02 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* nanoftp.c: applied a couple of patches from Brian D Ripley.
+	* parserInternals.c: removed the last exit() call. Print an
+	  unmaskable error on stderr instead (library mismatch detection)
+
+Sat Nov 17 17:16:51 MST 2001 John Fleck <jfleck@inkstain.net>
+
+	* doc/xmllint.xml, doc/xmllint.1 - update xmllint man page with
+	shell instructions from Heiko Rupp
+
+Thu Nov 15 14:53:42 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* catalog.c: use the URL notation file:// for default catalog paths
+
+Wed Nov 14 16:03:02 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/tree.h: better comments for _private fields
+	* tree.c: removed a problem when copying an entity reference.
+
+Tue Nov 13 16:23:04 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* vms/*: updated instructions and diffs from John A Fotheringham
+
+Mon Nov 12 23:43:22 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/xmlerror.h: avoid an include problem if
+	  #include <libxml/xmlerror.h> happens first in code
+	  seems to be the case in KDE libs
+
+Mon Nov 12 22:32:41 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* win32/dsp/* include/libxml/xmlwin32version.h.in: update
+	  from Igor for Windows
+
+Mon Nov 12 10:19:41 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am: Gary Pennington pointed out a missing prefix
+
+Sat Nov 10 12:55:42 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in include/libxml/xmlwin32version.h: preparing 2.4.10
+	* doc/*: upgraded and rebuilt the docs
+
+Sat Nov 10 12:33:38 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLparser.c: fix comment in scripts element parsing.
+	* result/HTML/doc3*: updated the results.
+
+Sat Nov 10 11:18:18 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* uri.c: another URI bug fix #63336, using Joel Young patch.
+
+Sat Nov 10 11:07:26 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* debugXML.c include/libxml/debugXML.h: add xmlGetNodePath()
+	  a cleaned up version of the Pwd shell string generation.
+
+Fri Nov  9 00:34:13 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* valid.c include/libxml/tree.h: trying to fix namespaces +
+	  validation problems for good, closing #63619 in the process
+	* result/valid/dia.xml test/valid/dia.xml: the Dia test was
+	  wrong in this respect, fixed it.
+
+Thu Nov  8 18:31:40 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* xmllint.c: Morus Walter patch to allow --format and --encode
+
+Thu Nov  8 14:52:18 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* debugXML.c: Stefan Kost provided an help command for the shell
+
+Wed Nov  7 14:32:55 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* debugXML.c: Heiko Rupp pointed that the shell would crash
+	  on empty nodesets returns.
+
+Wed Nov  7 13:52:36 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am: Weiqi Gao pointed out that xmlcatalog
+	  migh need the history libraries
+
+Tue Nov  6 23:49:09 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLparser.c test/HTML/lt.html result/HTML/lt.html*:
+	  handle the case of < in quoted attributes, Bastian Kleineidam
+
+Tue Nov  6 16:21:33 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in include/libxml/xmlwin32version.h: releasing 2.4.9
+	  fixing catalog breakages
+	* Makefile.am catalog.c result/catalogs/catal 
+	  result/catalogs/mycatalog.* test/catalogs/catal*:
+	  fixed more problems in catalog support, added more regression tests
+	  for both XML and SGML catalog handling
+
+Mon Nov  5 20:26:41 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* debugXML.c: applied an improvement to xmlGetLineNo() from
+	  Keith Isdale
+
+Mon Nov  5 15:20:16 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* catalog.c: dohhhh XML catalog add and remove ops were broken too.
+	  Side effect of the progressive catalog loading
+
+Mon Nov  5 12:40:54 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am: confexecdir and confexec_DATA were defined twice
+	  pointed out by Karl Eichwalder
+	  
+Sun Nov  4 23:18:34 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* xmlcatalog.c: avoid unlink() and use remove() instead.
+
+Sun Nov  4 23:12:38 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* libxml.spec.in: cleanup
+	* include/libxml/xmlwin32version.h: updated with 2.4.8
+
+Sun Nov  4 21:17:24 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* encoding.c global.data globals.c testThreads.c: fix bug #63752
+	  of compiling libxml with a non standard set of options
+
+Sun Nov  4 13:11:41 MST 2001 John Fleck <jfleck@inkstain.net
+
+	* doc/xmllint.xml, xmllint.1 - updating xmllint man page to
+	document --sgml option, fixing gnome bugzilla #63382
+
+Sun Nov  4 20:56:53 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/catalog.h catalog.c: Fixed SGML catalogs
+	  breakage of 2.4.7, added a couple of really needed APIs
+	  like xmlCatalogIsEmpty() and xmlNewCatalog()
+	* xmlcatalog.c: updated --sgml --noout to be a suitable replacement
+	  for install-catalog
+	* configure.in: preparing 2.4.8
+
+Thu Nov  1 15:29:31 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLtree.c tree.c include/libxml/HTMLtree.h
+	  include/libxml/tree.h include/libxml/xmlIO.h: more include
+	  cleanups, export cleanly one html output + format function.
+
+Thu Nov  1 14:12:12 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: removed initGenericErrorDefaultFunc call from
+	  xmlInitParser() since it could destroy previous calls to
+	  xsltSetGenericErrorFunc() effects
+
+Thu Nov  1 09:37:13 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* debugXML.c include/libxml/debugXML.h: bool can be a reserved
+	  keyword.
+
+Wed Oct 31 18:50:08 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am: cleanup
+	* threads.c: cleanup too
+	* xmlIO.c include/libxml/xmlIO.h: added xmlNoNetExternalEntityLoader()
+	  from xsltproc
+	* include/libxml/tree.h include/libxml/parser.h: trying to break a
+	  dependency loop.
+
+Tue Oct 30 18:38:53 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* catalog.c: Justin Fletcher pointed out that xmlParseXMLCatalog
+	  was not used anymore !
+
+Tue Oct 30 13:33:13 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in: preparing 2.4.7
+	* Makefile.am doc/Makefile.am: switched to the latest xmllint
+	  manual page from John
+	* doc/*: updated the doc and rebuilt the generated pages
+
+Tue Oct 30 11:31:19 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* xmlIO.c: closing bug #62711, the library should never
+	  close stdin or stdout.
+
+Tue Oct 30 10:46:12 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* uri.c: second pass at fixing #63336, using Joel Young
+	  final patch. looks okay.
+
+Tue Oct 30 00:56:05 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* uri.c include/libxml/uri.h: trying to clear #63336
+	  allowing the escaping routine to parse unconformant
+	  URI-References.
+
+Mon Oct 29 19:09:46 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* vms/readme.vms vms/build_libxml.com nanoftp.c 
+	  include/libxml/xmlversion.h.in: a few VMS updates from
+	  John A Fotheringham
+	* include/libxml/xmlIO.h xmlIO.c: added xmlCleanupInputCallbacks()
+	  and xmlCleanupOutputCallbacks() for the Perl binding people.
+
+Mon Oct 29 12:44:17 CET 2001 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c globals.c DOCBparser.c HTMLparser.c error.c:
+	  apply fixes to close #63271 and avoid segfaults when
+	  the error routine gets callbed before xmlInitParser()
+	  get called.
+	* nanoftp.c error.c: Applied patches from Justin Fletcher
+	  correcting some xmlGenericError misuses.
+
+Sat Oct 27 14:04:45 MDT 2001 John Fleck <jfleck@inkstain.net>
+
+	*doc/xmllint.xml, doc/xmllint.1
+	New and improved man page for xmllint - .xml is the original, .1
+	is the generated man page
+
+Wed Oct 24 14:34:25 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* doc/site.xsl doc/*.html doc/Makefile.am: now autogenerate
+	  the web site from the main HTML document.
+
+Tue Oct 23 14:32:04 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: fixed an erroneous validation bug when PE refs
+	  occurs in external parsed entities referenced from the
+	  internals subset
+	* test/valid/index.xml test/valid/dtds/nitf-2-5.dtd
+	  test/valid/dtds/NewsMLv1.0.dtd result/valid/index.xml*:
+	  added the associated testcase, it's a nice one.
+	* HTMLparser.c: generate the DTD node as HTML still ...
+	* HTMLtree.c: fixed errors in Set/GetMetaEncoding 
+
+Mon Oct 22 14:20:17 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLparser.c: fixed a bug in htmlNewDoc()
+
+Mon Oct 22 11:32:36 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* test/threads/*: added entities testing to the Thread test
+	* testThreads.c: make the test reasonable
+	* DOCBparser.c: fix the DTD public and system ID
+	* xmllint.c: added --sgml for SGML DocBook importing
+	* Makefile.am: added Docbtests target
+
+Fri Oct 19 11:47:13 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* nanoftp.c: use only "anonymous@" string for anonymous passwds
+	* testThreads.c: removed bogus include
+
+Thu Oct 18 16:56:23 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c valid.c result/valid/rss.xml result/valid/rss.xml.err:
+	  fixed a very serious (looping) validation bug
+
+Wed Oct 17 11:56:25 EDT 2001 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/globals.h include/libxml/threads.h threads.c
+	  testThreads.c: far more testing, cleaning up bugs
+	* *.c : make sure globals.h is always included.
+
+Wed Oct 17 17:41:41 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLparser.c: try to get rid of parser loops for good.
+
+Wed Oct 17 13:29:02 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in: fixed some bugs in CFLAGS passing.
+	* test/threads Makefile.am testThreads.c: added a specific
+	  threaded test case (really nasty, guaranteed).
+
+Tue Oct 16 23:01:49 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* catalog.c: serious cleanup on the management of the
+	  XML catalog tree, more tests done, especially with
+	  the catalog PI.
+
+Tue Oct 16 08:43:43 EDT 2001 Daniel Veillard <daniel@veillard.com>
+
+	* catalog.c: avoid a problem in catalog cleanup on SMP if
+	  catalogs were not initialized.
+
+Tue Oct 16 14:33:19 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* catalog.c xpath.c: trying to cleanup the not thread safe
+	  parts of the library.
+
+Mon Oct 15 14:30:11 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/globals.h configure.in global.data: make
+	  the allocation be per-thread a configure option
+	* encoding.c include/libxml/parser.h: fixed compilation
+	  errors
+
+Mon Oct 15 12:45:03 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/parser.h: Norm reported that a few lines
+	  added were breaking libxslt compile, removed them for now
+
+Sun Oct 14 05:55:01 EDT 2001 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c parserInternals.c threads.c: debugged and fixed
+	  initialization problems which were giving troubles on SMP
+	  boxes.
+
+Sat Oct 13 16:17:13 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/Makefile.am: missing globals.h
+
+Sat Oct 13 14:15:00 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* globals.c: added a couple of standard includes.
+
+Sat Oct 13 11:08:20 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/SAX.h include/libxml/globals.h include/libxml/parser.h
+	  include/libxml/parserInternals.h include/libxml/tree.h
+	  include/libxml/xmlerror.h HTMLparser.c SAX.c error.c globals.c
+	  nanoftp.c nanohttp.c parser.c parserInternals.c testDocbook.c
+	  testHTML.c testSAX.c tree.c uri.c xlink.c xmlmemory.c:
+	  Applied the last patches from Gary, cleanup, activated threading
+	  all user accessible global variables are now handled in globals.[ch]
+	  Still a bit rought but make tests passes with either 
+	  --with-threads defined at configure time or not.
+	* Makefile.am example/Makefile.am: added globals.[ch] and threads
+	  linking options
+
+Fri Oct 12 19:25:55 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am include/libxml/Makefile.am
+	  include/libxml/globals.h globals.c  include/libxml/threads.h
+	  threads.c build_glob.py global.data xmlcatalog.c acconfig.h
+	  configure.in: started integrating the core of the thread support
+	  not activated yet but half integrated. The code should still
+	  compile and work anyway.
+
+Fri Oct 12 00:53:03 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLtree.c catalog.c debugXML.c entities.c nanoftp.c
+	  parser.c valid.c xmlmemory.c xpath.c xpointer.c: started
+	  integrating the non-controversial parts of Gary Pennington
+	  multithread patches
+	* catalog.c: corrected a small bug introduced
+
+Thu Oct 11 20:58:15 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* catalog.c include/libxml/catalog.h: very serious cleanup,
+	  isolating unportable code and as much as possible the accesses
+	  to the global shared catalog. May need more testing !
+
+Thu Oct 11 11:10:31 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/debugXML.h debugXML.c tree.c: integrating
+	  Keith Isdale patches for the XSLT debugger interfaces. Some
+	  cleanup
+
+Thu Oct 11 08:44:01 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* win32/Makefile.mingw: update from Tobias Peters for 2.4.5
+	* DOCBparser.c: generate line nubers in elements
+
+Wed Oct 10 11:35:45 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in: preparing 2.4.6 release
+	* doc/xml.html doc/html/*: updated and rebuilt the docs
+	* include/libxml/*.h *.c: fixed a number of teh/the widht/width typos
+
+Mon Oct  8 20:38:27 MDT 2001 John Fleck <jfleck@inkstain.net>
+
+	* doc/xmlcatalog_man.xml, xmlcatalog.1, xmlcatalog_man.html
+	adding documentation for DV's supercatalog support
+
+Mon Oct  8 17:00:16 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/catalog.h catalog.c xmlcatalog.c: adding SGML
+	  super catalog support adding one API and one flag --sgml to
+	  xmlcatalog
+
+Sun Oct  7 16:43:57 MDT 2001 John Fleck <jfleck@inkstain.net>
+
+	* doc/xmlcatalog_man.xml, xmlcatalog.1
+	One more crack at
+	https://bugzilla.redhat.com/bugzilla/show_bug.cgi?id=54392 
+	
+
+Sun Oct  7 18:47:02 CEST 2001 Thomas Broyer <tbroyer@ltgt.net>
+
+	* xpath.c: implemented xmlXPathObjectCopy for external objects
+	* include/libxml/xpathInternals.h: added xmlXPathStackIsExternal
+
+Sat Oct  6 16:25:52 MDT 2001 John Fleck <jfleck@inkstain.net>
+
+	*doc/xmlcatalog_man.xml, xmlcatalog_man.html, xmlcatalog.1
+	finishing up fix to
+	https://bugzilla.redhat.com/bugzilla/show_bug.cgi?id=54392, making
+	the xmlcatalog man page display more elegantly
+
+Sat Oct  6 15:27:12 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in: closing bug #61832
+	* HTMLparser.c: removed a warning
+
+Sat Oct  6 15:07:14 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: fixing #61673 part I, do not loose doc information
+	  when copying result value trees.
+
+Sat Oct  6 11:58:58 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: trying to harden the XPath interpreter
+
+Fri Oct  5 20:37:51 MDT 2001 John Fleck <jfleck@inkstain.net>
+
+	* doc/xmlcatalog.1 updated using a new stylesheet to address, in
+	part, https://bugzilla.redhat.com/bugzilla/show_bug.cgi?id=54392
+
+Fri Oct  5 23:35:00 HKT 2001 William Brack <wbrack@mmm.com.hk>
+
+	* HTMLparser: repaired another loop problem
+
+Fri Oct  5 11:16:21 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* uri.c: applied fix from Mathias Hasselmann about a bug in URI
+	  parsing.
+	* xpath.c: fix bug #61291 the default XML namespace node is
+	  missing from the namespace axis.
+	* tree.c: refuse to create namespaces nodes with prefix "xml"
+
+Thu Oct  4 16:47:44 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* SAX.c: ouch a non-defined namespace could lead to a crash,
+	  fixed #61215
+
+Thu Oct  4 16:24:26 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* parserInternals.c: closed bug #61054
+
+Wed Oct  3 15:19:04 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/Makefile.am: closing #60708
+
+Tue Oct  2 15:52:05 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* win32/dsp/libxml2.def.src include/libxml/parser.h parser.c:
+	  adding xmlSAXParseFileWithData following Marco Stipek suggestion
+
+Tue Oct  2 11:27:58 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* valid.c: close bug #61550 when xml: wasn't considered a namespace
+
+Tue Oct  2 11:18:32 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* win32/dsp/libxml2.def.src: Igor Zlatkovic patches
+	* DOCBparser.c HTMLparser.c parser.c: fixed typos
+
+Mon Oct  1 09:34:51 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* catalog.c: Justin Fletcher provided cleaup code in case
+	  HAVE_STAT is not defined
+	* include/win32config.h: Igor Zlatkovic suggested to have
+	  HAVE_STAT defined there
+
+Sat Sep 29 00:15:00 HKT 2001 William Brack <wbrack@mmm.com.hk>
+
+	* catalog.c - fixed typing error reported by M. Barros
+
+Sun Sep 23 21:02:39 MDT 2001 John Fleck <jfleck@inkstain.net>
+
+	* xmllint.c - fixing typo
+
+Sat Sep 22 10:00:00 HKT 2001 William Brack <wbrack@mmm.com.hk>
+
+	* HTMLparser.c: small enhancement to prevent loop on
+	  unrecognizable data
+
+Fri Sep 21 11:45:53 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* parserInternals.c: applying patch from bug #60757 this
+	  should close it
+
+Thu Sep 20 15:54:29 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* catalog.c xmlcatalog.c: removed a couple of warning
+	* xpath.c: try to solve the linking problem on platforms
+	  needing trio to compile
+
+Wed Sep 19 10:01:37 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am libxml.spec.in: backing up non-documented changes
+	  commited without review or aproval by Jens Finke <jens@gnome.org>
+	* HACKING: made 100% clear that no commit should be done directly
+
+Mon Sep 17 18:52:37 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in: Joe Orton provided a patch fixing a problem
+	  when iconv is specified to be in a non-standard directory
+	  but wasn't exported in xml2-config --cflags
+
+Fri Sep 14 19:32:43 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in: let's ship 2.4.5 before getting too much
+	  troubles with 2.4.4 errors.
+
+Fri Sep 14 12:26:58 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* encoding.c entities.c: do not output hexadecimal charrefs
+	  when serializing HTML since some version of Netscape can't
+	  grok it, generate decimal ones.
+	* result/HTML/doc3.htm: output changed due to previous test
+	* parserInternals.c: repair xmlKeepBlanksDefault() broken in 2.4.4
+
+Thu Sep 13 13:34:27 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* libxml-2.0.pc.in: dohh generated the wrong include path :-(
+	* doc/Makefile.am libxml.spec.in: re-dohh forgot the new manpage :-(
+
+Wed Sep 12 22:14:55 CEST 2001 Daniel Veillard <daniel@veillard.com>
+        Released 2.4.4
+
+	* config.h.in configure.in libxml.spec.in include/libxml/Makefile.am
+	  libxml-2.0.pc.in: moved includes to includedir/libxml2/libxml,
+	  updated the configuration scripts systems accordingly
+
+Wed Sep 12 20:49:32 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* configure.in: preparing for 2.4.4
+	* doc/xml.html doc/html/*: updated and rebuilt the docs
+
+Wed Sep 12 16:58:16 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* win32/dsp/libxml2.def.src: tried to incorporate comments
+	  from bug #59220
+
+Tue Sep 11 11:25:36 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c result/noent/wml.xml: fixed bug #59981 related
+	  to handling of '&' in attributes when entities are substitued
+
+Mon Sep 10 22:14:42 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* libxml.h include/libxml/xmlversion.h.in
+	  include/libxml/xmlwin32version.h include/libxml/xmlwin32version.h.in:
+	  Tried to close bug #60131
+
+Mon Sep 10 20:46:03 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* SAX.c: fixed a bug in the HTML parser introduced Sep  9
+
+Mon Sep 10 20:13:09 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* SAX.c: fixing bug #59946 on xmlns=""
+
+Mon Sep 10 16:39:42 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/xmlerror.h SAX.c: fixing bug 59732, simple
+	  but allocates a new error code.
+
+Sun Sep  9 10:33:15 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* xmllint.c: John Fleck fixed typos in the options output
+	* parser.c SAX.c: fix ignorable white space SAX selection
+
+Sat Sep  8 11:43:53 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* entities.c: Steve Underwood found the possibility of an
+	  ininite loop in case of error.
+
+Fri Sep  7 11:35:00 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am: Need $(ICONV_LIBS) in libxml2_la_LIBADD
+
+Wed Sep  5 17:47:43 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* parser.c: warn if version is not 1.0 but it's not
+	  strictly speaking an error after analyzing the spec
+
+Mon Sep  3 10:07:03 MDT 2001 John Fleck <jfleck@inkstain.net>
+
+	*doc/catalog.html - add link to the html version of the
+	man page, other linguistic cleanups
+
+Mon Sep  3 09:10:08 MDT 2001 John Fleck <jfleck@inkstain.net>
+
+	* doc/xmlcatalog_man.xml, xmlcatalog_man.html, xmlcatalog.1
+	adding documentation for xmlcatalog. Note: xmlcatalog.1, the man
+	file, has not yet been included in the build.
+
+Sat Sep  1 18:17:47 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* catalog.c: removed a duplicate affectation Justin Fletcher
+
+Fri Aug 31 22:02:10 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: Armin Sander pointed a possible text coalescing 
+	  problem, completed his patch.
+
+Fri Aug 31 18:30:28 CEST 2001 Bjorn Reese <breese@users.sourceforge.net>
+
+	* trionan.c: Fixed const and volatile re-definition problem
+	
+Fri Aug 31 16:51:28 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* libxml.4 parser.c: doc updates from Heiko Rupp
+	* parserInternals.c: 2 sanity checks from Heiko Rupp
+
+Tue Aug 28 22:38:45 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* tree.c: applied patch from Armin Sander to make some pointers
+	  const in xmlCopyNode()
+	* include/libxml/tree.h: added fix to the header
+
+Mon Aug 27 16:24:47 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: hum, restrict the integer usage gcc bug workaround
+	  to only gcc compilers so that other architecture don't get
+	  penalized by this limitation.
+	* include/libxml/xpath.h: small typo fix from Heiko W. Rupp
+
+Sun Aug 26 20:45:04 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* valid.c: fixed a Windows compiler warning (Chris Poblete)
+	* xpath.c: fix for mod when dividend is 0 (Chris Poblete)
+
+Sat Aug 25 15:30:17 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/catalog.h catalog.c xmlcatalog.c: added a 
+	  --convert option to xmlcatalog to convert SGML ones to
+	  the XML syntax.
+	* xmllint.c: small cleanup for $SGML_CATALOG_FILES support.
+
+        2.4.3 got released at that point
+Thu Aug 23 23:16:32 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* catalog.c xmlIO.c: started some serious testing and fixed
+	  a few bug and optmization needs.
+
+Thu Aug 23 17:26:58 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am configure.in include/libxml/xmlwin32version.h:
+	  preparing for a 2.4.3 release even if it may not be ready yet
+	* catalog.c parser.c xmlIO.c include/libxml/catalog.h: redirected
+	  all file parsing lookup to go through the entity resolver, add
+	  to add an API to bypass it (needed to load catalogs themselves),
+	  some cleanup on the catalog code too.
+	* nanoftp.c: small cleanup
+	* doc/catalog.html: small update
+
+Thu Aug 23 12:22:26 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* catalog.c: fixed bugi #59406 in SGML catalog parsing reported by
+	  Jun Kuriyama
+	  
+Thu Aug 23 02:51:29 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* doc/catalog.html: finished the catalog documentation
+
+Thu Aug 23 01:38:42 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* doc/catalog.html doc/xml.html: added documentation about
+	  Catalog support, misses an API description 
+	* doc/html/*: reextracted the API pages
+
+Wed Aug 22 18:27:47 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/catalog.h catalog.c xmlIO.c HTMLparser.c:
+	  Added the part about section 7.2 on URI resolution,
+	  fixed a side effect in the HTML parser, look complete
+	  and ready to rock except the URI/SystemID part!
+
+Wed Aug 22 16:27:03 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/catalog.h include/libxml/parser.h
+	  include/libxml/xmlerror.h catalog.c parser.c parserInternals.c
+	  xmlIO.c: added support and APIs needed for the catalog PI
+	* include/libxml/xmlIO.h: cleanup
+
+Wed Aug 22 02:03:31 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* catalog.c parser.c xmlIO.c xmlcatalog.c xmllint.c 
+	  include/libxml/catalog.h: starts to look okay, really
+	  plugged the new framework, cleaned a lot of stuff,
+	  added some APIs, except the PI's support missing this
+	  should be mostly complete
+	* result/catalogs/* test/catalogs/*: added new test, enriched
+	  the existing one with URN ID tests
+
+Tue Aug 21 14:56:18 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* catalog.c: fixed nextCatalog
+	* result/catalogs/docbook test/catalogs/*: started adding
+	  a small regression test
+
+Tue Aug 21 12:52:38 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am catalog.c xmlcatalog.c include/libxml/catalog.h:
+	  more work on the XML catalog support.
+	* parser.c include/libxml/parser.h: small cleanup seems using
+	  list as a public parameter name can give portability troubles
+	* trionan.c trionan.h xpath.c include/libxml/trionan.h
+	  include/libxml/xpath.h include/libxml/Makefile.am: removed
+	  trionan from the libxml API, added xmlXPathIsInf and xmlXPathIsNaN
+	  wrappers
+
+Tue Aug 21 11:18:45 CEST 2001 Bjorn Reese <breese@users.sourceforge.net>
+
+	* Makefile.am trio.c triodef.h trionan.c xpath.c
+	  include/libxml/Makefile.am include/libxml/trionan.h:
+	  Re-worked Not-A-Number and Infinity support.
+	* xmlcatalog.c: added readline include files
+
+Mon Aug 20 02:04:13 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* Makefile.am xmlcatalog.c libxml.spec.in: renaming 
+	  testCatalog as xmlcatalog, making it an installed app
+	  adding a shell, and preparing it to be a /etc/xml/catalog
+	  management tool, though not ready yet
+	* catalog.c include/libxml/catalog.h: adding support for
+	  XML Catalogs http://www.oasis-open.org/committees/entity/
+	  not finished, there is some interesting tradeoffs and a
+	  few open questions left.
+
+Sun Aug 19 14:59:56 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* xmllint.c: fixed a line formatting problem
+
+Fri Aug 17 11:35:31 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* SAX.c: removed a couple of unused variable (Albert Chin)
+
+Fri Aug 17 01:25:21 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* HTMLparser.c HTMLtree.c include/libxml/HTMLparser.h:
+	  trying to fix some troubles w.r.t. function returning
+	  const xxxPtr.
+
+Thu Aug 16 21:33:20 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* win32/dsp/libxml2.def.src: another set of symbols conditionally
+	  defined
+
+Thu Aug 16 21:31:14 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* xpointer.c: removed unused var
+
+Thu Aug 16 18:26:40 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* testXPath.c: another small cleanup closing bug #59110
+
+Thu Aug 16 17:59:18 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* win32/dsp/libxml2.def.src: small cleanup closing bug
+	  #59108
+
+Wed Aug 15 22:46:01 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* example/gjobread.c: add xmlCleanupParser() before leaving
+
+Wed Aug 15 14:57:08 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* config.h.in configure.in include/libxml/xmlwin32version.h:
+	  released 2.4.2
+
+Wed Aug 15 13:56:22 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* include/libxml/valid.h debugXML.c valid.c: deprecate
+	  the non-boundchecking Sprintf functions, add Snprintf
+	  this should close bug #57984
+
+Wed Aug 15 10:46:07 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* xmlIO.c: xmlOutputBufferCreateFilename() didn't unescaped
+	  URIs before doing the lookups (pointed by Mark Vakoc)
+
+Tue Aug 14 18:37:23 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: serious changes on Result Value Trees and NodeSets
+	  w.r.t. deallocation and collect operations. Probably not
+	  100% clean (merge of allocated trees smells like a problem).
+	  Seems sufficient to close #58943
+
+Tue Aug 14 16:12:00 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* xmllint.c: adding a --format option
+
+Tue Aug 14 14:16:24 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: count() was broken on Result Value Tree
+	* xmlIO.c: fixed file:/// accesses on _WIN32
+
+Mon Aug 13 13:22:53 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* libxml.m4: s/LIBXML_VERSION_NUMBER/LIBXML_VERSION/ seems the
+	  macro was renamed, this should close bug #58683
+
+Mon Aug 13 12:33:40 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* SAX.c: small fix fixing bug #58539 reported by coolo, in
+	  entity substitution mode text at the end of the entity might
+	  be added due to text coalescing.
+	* nanoftp.c parser.c: small cleanup
+
+Wed Aug  8 22:57:05 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+        * HACKING: added John Fleck right to commit in the doc subdir
+
+Tue Aug  7 03:05:58 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* SAX.c testXPath.c valid.c xmllint.c include/libxml/valid.h:
+	  allow to inherit attributes from the DTD directly in the
+	  tree, this is needed for XPath and can be a useful feature.
+	  Inherited namespaces are always provided at the tree level now
+	* test/defattr* result/defattr* result/noent/defattr*: added a couple
+	  of tests for this feature (XSLT being the prime user).
+
+Fri Aug  3 14:02:20 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* DOCBparser.c Makefile.am nanohttp.c parser.c testHTML.c
+	  testSAX.c xmlIO.c xmllint.c include/win32config.h
+	  include/libxml/xmlversion.h.in include/libxml/xmlwin32version.h
+	  include/libxml/xmlwin32version.h.in win32/README.MSDev
+	  win32/dsp/*: applied Win32 Facelift No.2 patches from 
+	  Igor Zlatkovic for Windows/MSC
+
+Wed Aug  1 23:21:06 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* SAX.c: unparsedEntityDecl() the URI computation of the
+	  entity wasn't done breaking XSLT unparsed-entity-uri()
+
+Wed Aug  1 17:44:57 CEST 2001 Daniel Veillard <daniel@veillard.com>
+
+	* xpath.c: fixed a bug when walking the descendants and
+	  the current node has no children
+	* debugXML.c: show up when a text node is supposed to not be escaped
+
+Wed Aug  1 01:33:35 CEST 2001 Thomas Broyer <tbroyer@ltgt.net>
+
+	* xpath.c: fixed a bug in xmlXPathNodeTrailingSorted (for now it
+	  worked like the set:leading() function)
+	* include/libxml/xpathInternals.h: added xmlXPathNodeSetContains
+
+Tue Jul 31 18:24:34 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* nanohttp.c: protected an use of EAGAIN, Brian Stafford
+
+Tue Jul 31 17:48:44 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* include/libxml/xmlIO.h: apply change to close #58141 
+	* win32/libxml2/*: update of the MSC projects from Igor  Zlatkovic
+
+Tue Jul 31 17:09:31 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* parser.c: when the internal subset uses a PE, then the
+	  included entity can use conditional sections.
+
+Mon Jul 30 12:58:39 EDT 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c include/libxml/xpath.h: fixed a serious memory problen
+	  when walking the namespace axis showing up in
+	  libxst/tests/general/bug-12
+	* xmlmemory.c: added the possibility to trace a given block
+	  defined by its address
+
+Sun Jul 29 07:18:53 EDT 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* parser.c: don't override existing encoding specified before
+	  starting xmlParseDocument()
+
+Sat Jul 28 13:33:10 EDT 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* include/libxml/xmlwin32version.h: reinserted, needed for
+	  Windows users of CVS
+
+2001-07-27  Darin Adler  <darin@bentspoon.com>
+
+	* encoding.c: (xmlIconvWrapper): Add cast to fix warning.
+	* testCatalog.c: Add include of <libxml/parser.h>.
+
+2001-07-27  Darin Adler  <darin@bentspoon.com>
+
+	* include/libxml/.cvsignore:
+	* include/libxml/xmlwin32version.h:
+	Remove this file from CVS because it's generated.
+
+Fri Jul 27 10:03:56 EDT 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* parser.c include/libxml/parser.h: applied const patches from
+	  Tom Moog #58002
+
+Thu Jul 26 18:55:52 CEST 2001 Thomas Broyer <tbroyer@ltgt.net>
+
+	* xpath.c include/libxml/xpath{,Internals}.h: added a function
+	  lookup framework
+
+Fri Jul 27 01:50:20 EDT 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* tree.c: fixed xmlCopyNode() for documents
+
+Thu Jul 26 12:40:35 EDT 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* parser.c: fixed bugs #58073 reported by Greg Shtilman
+
+Thu Jul 26 11:38:37 EDT 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* parser.c: fixes bug #57652 reported by Morus Walter
+
+Thu Jul 26 10:24:34 EDT 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* nanohttp.c: John Kroll provided a small fix to xmlNanoHTTPSave
+
+Thu Jul 26 07:16:04 EDT 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* parser.c parserInternals.c: fixed the xmlLineNumbersDefault()
+	  errors, lesson don't add new functions at 1am before a release
+	* xpath.c: integrated fix from Bjorn to avoid divide by zero
+	  from XPath initialization when possible.
+
+Tue Jul 24 15:39:11 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* result/scripts/base*: removing history/readline changed
+	  this slightly
+	* include/libxml/parser.h SAX.c parser.c parserInternals.c
+	  xmllint.c: make element content line number generation
+	  optionnal to avoid breaking old apps added interface to switch
+
+Tue Jul 24 15:06:58 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* configure.in: get rid of the readline and libhistory
+	  dependencies by default, release 2.4.1 with IA64 fix
+	* nanohttp.c tree.c xmlIO.c include/libxml/nanohttp.h
+	  include/libxml/tree.h include/libxml/xmlIO.h: incorporated
+	  John Kroll fixes to allow saving to HTTP via PUT (or
+	  POST of needed).
+	* doc/html/*.html: regenerated the docs
+
+Sun Jul 22 05:56:16 CEST 2001 Thomas Broyer <tbroyer@ltgt.net>
+
+	* hash.c include/libxml/hash.h: added xmlHashScannerFull,
+	  xmlHashScanFull and xmlHashScannFull3 to get passed the
+	  three keys as arguments to the callback function
+
+Thu Jul 19 15:29:26 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* configure.in Makefile.am: removed libxml softlink for good
+	* include/libxml/*.h *.c doc/Makefile.am: cleanup to get
+	  100% coverage by gtk-doc
+
+Tue Jul 17 17:36:46 EDT 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xmlmemory.c include/libxml/xmlmemory.h: debugging on IA64,
+	  fixed serious troubles due to size_t vs. int mismatch
+
+Tue Jul 17 16:04:36 EDT 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* SAX.c xmlIO.c: cleaned up some warning on the Alpha
+
+Mon Jul 16 06:32:44 CEST 2001 Thomas Broyer <tbroyer@ltgt.net>
+
+	* include/libxml/xpath{,Internals}.h xpath.c: added a more
+	  convenient extension API for value and context managing
+	  Now handles external objects through xmlXPathPopExternal,
+	  xmlXPathWrapExternal and xmlXPathReturnExternal.
+	  Added functions for sets operations (intersection, etc.)
+
+Mon Jul 16 20:05:27 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* include/libxml/parserInternals.h include/libxml/HTMLparser.h
+	  xmlIO.c tree.c parserInternals.c entities.c encoding.c
+	  HTMLparser.c: cleanup of global variables, marking some
+	  const or private.
+
+Mon Jul 16 00:17:15 CEST 2001 Thomas Broyer <tbroyer@ltgt.net>
+
+	* include/libxml/xpath.h: exported xmlXPath{NAN,PINF,NINF}
+	  fixed xmlXPathNodeSetItem when passing index=0
+
+Sun Jul 15 17:58:44 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* include/libxml/xmlwin32version.h.in: added xmlCheckVersion()
+
+Sat Jul 14 19:31:21 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xmllint.c: fixed compilation under Cygwin #57503
+	* TODO: update
+
+2001-07-13  Peter Williams  <peterw@ximian.com>
+
+	* config.h.in: add #undef HAVE_DLFCN_H
+
+	* example/Makefile.am (INCLUDES): Compile fix when srcdir !=
+	builddir.
+
+Fri Jul 13 11:09:56 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* win32/libxml2/libxml2.def.src: added a couple of exported entries
+	  raised by #57348 and #57381
+
+Thu Jul 12 21:20:17 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* DOCBparser.c HTMLparser.c HTMLtree.c SAX.c debugXML.c parser.c
+	  tree.c xpointer.c: store the line numbder in element->content,
+	  may break some software, need a configuration mechanism
+
+2001-07-10  Darin Adler  <darin@bentspoon.com>
+
+	* .cvsignore:
+	* example/.cvsignore:
+	* include/.cvsignore:
+	* include/libxml/.cvsignore:
+	Various things that are generated and should be ignored.
+
+Tue Jul 10 17:47:09 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* configure.in include/libxml/xmlwin32version.h: release of 2.4.0
+	* doc/xml.html doc/html/*:  updated the docs
+
+Mon Jul  9 22:06:53 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* valid.c: fixed "Internal: MIXED struct bad" when #CDATA elements
+	  validation occured on content with element child
+
+Mon Jul  9 17:59:08 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* tree.c: fixed XML Base computation which was broken
+	* debugXML.c: added a base function to the shell
+	* Makefile.am result/scripts/* test/scripts/*: added scripts
+	  based regression tests, and adding 2 XML Base tests
+
+Mon Jul  9 12:31:05 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* tree.c: set properties doc and call xmlSetListDoc for properties
+	  content when grafting them in a different tree.
+	* aclocal.m4: remove from CVS
+
+Sun Jul  8 23:09:07 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* win32/libxml2/libxml2.def.src: added some missing entry point
+	  for XPath (Mark Vakoc)
+
+Sun Jul  8 20:34:35 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xmlIO.c: fixed an old bug raised by Bernhard Zwisch, the I/O
+	  layer should URI-Unescape before trying to open resources.
+
+Sun Jul  8 16:26:00 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: fix the name() bug for elements in the default 
+	  namespace reported by Charlie Bozeman
+
+Sun Jul  8 15:11:05 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* SAX.c parser.c testXPath.c xpath.c: trying to fix #56948, this
+	  led to an XPath fix, improvements of SAX initialization, and
+	  an added option --nocdata to testXPath
+
+Sat Jul  7 21:09:55 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* doc/libxml-doc.el: Felix Natter provided anew version working
+	  with XEmacs too
+
+Sat Jul  7 02:16:00 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* include/libxml/xpath.h: small cleanup
+	* doc/xml.html: update
+
+Fri Jul  6 01:40:23 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* Makefile.am configure.in include/libxml/xmlwin32version.h:
+	  released 2.3.14
+
+Fri Jul  6 00:47:41 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* doc/html/*: rebuilt the docs for the release
+	* doc/xml.html: added 2.3.14 release.
+
+Thu Jul  5 22:01:31 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: a bug reported by Stephan Kulow empty nodesets
+	  were not equal to empty strings
+
+Thu Jul  5 00:52:25 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* SAX.c: fixed a URI-Reference computation problem when validating
+	* xmlIO.c: small cleanup
+
+Thu Jul  5 00:04:58 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* parser.c: improved the description of a couple of interfaces
+	  upon Larry Stamper suggestion
+
+Wed Jul  4 21:42:24 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* SAX.c entities.c parser.c: changed completely the way entities
+	  are handled when running the parser in entity substitution mode.
+	  This fixes a bug reported by Stephan Kulow and nearly divides
+	  by 3 the amount of memory required by libxslt to load and process
+	  DocBook TDG.
+
+Wed Jul  4 18:02:58 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* HTMLparser.c: fixing a too early root closing problem raised
+	  byt Prashanth Naidu
+
+Wed Jul  4 01:42:01 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: fixed a missing copy in xmlXPathVariableLookupNS() 
+	  raised by Mark Vakoc.
+
+Tue Jul  3 18:35:48 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* example/Makefile.am: fixed the include path to add srcdir/include
+	* Makefile.am configure.in: fix from Albert Chin for iconv detection
+	  and some cleanup
+
+Tue Jul  3 10:12:03 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c include/libxml/xpath.h include/libxml/xpathInternals.h:
+	  lot of optimization work, results in significant improvements
+	  when handling really complex XPath queries. Add a small optimizer
+	  for unions, improve [n] and [last()], avoid some costly ops.
+
+Fri Jun 29 23:26:54 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* include/libxml/parser.h parser.c: xmlStrstr args are both const
+	* xpath.c: small cleanup
+	* xmlGetNsList: reformated, fixed problems if used on Entities
+
+Thu Jun 28 18:19:44 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* doc/xml.html: added 1.8.14 and 2.3.13 releases
+
+Thu Jun 28 18:16:28 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* configure.in include/libxml/xmlwin32version.h: released 2.3.13
+	* Makefile.am example/Makefile.am: workaround automake generating
+	  erroneous deps
+
+Thu Jun 28 15:08:22 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* include/win32config.h: bug #56801 Yon Derek provided a patch
+	  to the windows config file.
+
+Thu Jun 28 14:51:44 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpointer.c include/win32config.h win32/libxml2/libxml2.def.src
+	  libxml.h : Yon Derek provided a set of changes to compile from
+	  CVS on Windows/MSC
+
+Thu Jun 28 14:11:28 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* parser.c: fixed UTF8 BOM support in push mode
+	* test/utf8bom.xml result/utf8bom.xml result/noent/utf8bom.xml:
+	  added a specific testcase
+
+Wed Jun 27 18:33:13 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* Makefile.am: added --push regression tests
+	* parserInternals.c: the XML parser segfaulted in --push mode
+
+Wed Jun 27 13:09:51 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* configure.in: moved the symlinks detection within a CVS
+	  check, this is not portable and will be removed soon.
+	* xpath.c: small cleanup/speedup
+
+Tue Jun 26 18:05:26 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* configure.in doc/xml.html include/libxml/xmlwin32version.h:
+	  release of 2.3.12
+	* parser.c: make an error message if unknow entities in all cases
+
+Tue Jun 26 09:46:29 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* uri.c: fixed 2 uri normalization bugs on '//' reduction
+
+Mon Jun 25 18:06:23 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* include/libxml/Makefile.am: Laszlo Peter pointed out that
+	  includes were installed in the wrong dir
+
+Mon Jun 25 17:07:37 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* doc/html.xml: warn against sending code to exhibit bugs.
+
+Sun Jun 24 23:31:56 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: patch to xmlXPathFormatNumber for the optimizer on
+	  Tru64 from Thomas Leitner
+
+Sun Jun 24 14:05:54 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* AUTHORS: added William and Bjorn
+	* include/libxml/*.h *.c README doc/*.html etc.: changed old email to
+	  daniel@veillard.com hopefully I won't have to do this again
+	* doc/Makefile.am doc/html/*.html: cleanup makefile, checked that
+	  docs can be rebuilt cleanly now
+	* include/libxml/xml*version.h*: removed include/libxml/xmlversion.h
+	  from CVs it's generated, added include/libxml/xmlwin32version.h
+	  also generated but which should change far less frequently.
+	* catalog.c nanoftp.c: made sure to include libxml.h not
+	  libxml/xmlversion.h directly
+	* include/libxml/*.h: include xmlwin32version.h instead of xmlversion.h
+	  when compiling on WIN32 and MSC
+
+Sat Jun 23 23:54:12 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* include/Makefile.am include/libxml/Makefile.am configure.in:
+	  fixed make distcheck and rebuilding the rpms
+
+Sat Jun 23 20:50:53 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* configure.in: should finish the migration of exported includes
+	  into a real include/libxml in CVS, at least for CVS users.
+	* removed the exported headers, added in include/libxml (as well
+	  as xmlversion.h.in).
+
+Sat Jun 23 20:37:19 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* configure.in: fixed the way to detect symlink
+
+Sat Jun 23 20:30:11 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* configure.in: updated, include/libxml is now a real CVS dir
+
+Sat Jun 23 19:36:31 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* doc/libxml-doc.el: a new version of libxml-doc.el. This new
+	  version works with both libxml1 and libxml2 (it autodetects
+	  the prefix of the html-files) from Felix Natter.
+	* doc/xml.html: updated doc accordingly
+
+Sat Jun 23 18:30:28 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: fixed the bug generating a template loop in libxslt
+	  when using docbook-xsl-1.4, * should filter out document nodes
+	* HACKING: added William
+	* TODO: updated
+
+Fri Jun 22 18:02:37 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* doc/FAQ.html: added a warning about gcc-3.0
+	* doc/xml.html: added reference to gdome2 and removed a confusing
+	  sentence
+
+Fri Jun 22 17:02:16 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xmlversion.h: okay this is a generated file, but Windows
+	  users need it and they can't generate it, and I want CVS
+	  Windows users ...
+	* win32/libxml2/libxml2_so.dsp: Windows project file for 
+	  the shared lib version of libxml2
+	* win32/libxml2/libxml2.def.src: bug #56527 set of exported
+	  resources needed for libxslt/xsltproc by Yon Derek
+
+Fri Jun 22 16:39:36 CEST 2001 Bjorn Reese <breese@users.sourceforge.net>
+
+	* trio.c: MSVC fix (provided by Igor Zlatkovic)
+	
+Fri Jun 22 12:42:16 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* include/win32config.h: another small fix for ATTRIBUTE_UNUSED
+
+Fri Jun 22 12:42:16 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* include/win32config.h: Yon Derek provided a first fix
+	  to be able to compile libxslt/xsltproc on Windows
+
+Fri Jun 22 00:04:36 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: attempt to work around what seemed a gcc optimizer
+	  bug when handling floats on i386 http://veillard.com/gcc.bug
+	* tree.c entities.c encoding.c: doing some cleanups while
+	  chasing it
+
+Thu Jun 21 13:13:36 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* Makefile.am: cleanup when --without-debug is specified
+	* xinclude.c xpath.c xpathInternals.h xpointer.c: cleanup
+	  w.r.t. --without-debug and other include points
+	* catalog.h testCatalog.c: a bit of cleanup and prepare for XML
+	  Catalogs
+	* configure.in entities.h tree.h HTMLparser.c: removed
+	  --without-corba, made the _private field mandatory
+
+Wed Jun 20 19:37:25 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* parser.c parserInternals.c encoding.c: Since Notepad on Win2k
+	  outputs a BOM in UTF8, an errata has been issued to avoid the
+	  problem, that was the most reasonable solution... Add support
+	  for a leading UTF8 BOM in entities.
+
+Wed Jun 20 15:38:59 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* valid.c: fixed a bug found when post validating an entity ref
+	* xmllint.c: added --loaddtd and sligly changed --postvalid to
+	  activate it too
+
+Tue Jun 19 20:03:40 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* tree.c xinclude.c xpointer.c: bug #56402 exposed a number of
+	  weakness in the node copy the XPointer and the XInclude
+	  implementations. Serious cleanup.
+
+Tue Jun 19 14:50:18 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* Makefile.am: Kjartan Maraas provided a small patch to
+	  add xml2-config.in to EXTRA_DIST
+
+Tue Jun 19 13:04:10 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* valid.c tree.c parserInternals.c parser.c: Stephan Kulow
+	  provided another failing case found in KDE, the way the
+	  ctxt->vctxt.nodeTab was allocated and freed changed over
+	  time but it wasn't completely cleaned up. This should fix it.
+
+Sun Jun 17 19:56:33 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* parser.c: Stephan Kulow also raised the fact that line number
+	  could get miscounted making debug harder, fixed the problem
+	  in xmlParseCharData()
+
+Sun Jun 17 19:17:26 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* valid.c: Stephan Kulow pointed out a problem when validating
+	  and using an empty entity, forgot a 'break' in a case.
+
+Sun Jun 17 16:47:40 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* tree.c: fixed xmlHasNsProp() accordingly to bug #55683
+	* doc/xml.html: updated with 2.3.11
+
+Sun Jun 17 12:24:11 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* TODO: updated adding cleanup of generated doc
+	* configure.in: prepared to release 2.3.11
+	* xmllint.c: added --version for bug reporting
+	* doc/html/*.html: rebuilt the doc
+
+Sat Jun 16 23:23:33 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: first part of the work on selecting namespace to
+	  fix bug #56115 
+
+Sat Jun 16 00:20:46 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* Makefile.am example/Makefile.am: Laszlo PETER provided a fix
+	  when using -liconv
+	* TODO: updated
+
+Fri Jun 15 07:08:57 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* HTMLtree.[ch]: more work on the HTML serialization routnes,
+	  cleanup, encoding support.
+
+Thu Jun 14 10:31:17 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: Thomas Broyer suggested a better patch for the / arg
+
+Thu Jun 14 01:01:30 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: bug detected by Ankh when / is used as a function arg
+
+Wed Jun 13 23:08:46 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* HTMLparser.[ch] HTMLtree.c: stored the inline/block property
+	  of element and use it to avoid outputting formatting spaces at
+	  the wrong place. Implemented the format parameter for HTML save.
+	* result/HTML/doc2.htm result/HTML/doc3.htm result/HTML/fp40.htm
+	  result/HTML/script.html result/HTML/test2.html result/HTML/test3.html
+	  result/HTML/wired.html: of course this impact the result of a
+	  number of HTML tests
+
+Thu Jun 14 09:49:09 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* HTMLtree.[ch]: started augmenting the HTML save API with
+	  encoding and formatting parameters
+
+Wed Jun 13 09:44:15 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* HTMLtree.h: cleanup and started evaluating the work needed on
+	  revamping the HTML output code
+
+Mon Jun 11 19:29:40 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* DOCBparser.c: handling of PIs and <?sgml-declaration in entities.
+
+Tue Jun 12 08:46:28 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* valid.c: fixed bug #56049, forgot one check in the
+	  validation routine
+
+Tue Jun 12 08:09:46 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* tree.[ch]: grrr ... namespace is a C++ reserved keyword
+
+Tue Jun 12 06:29:39 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* libxml.h: fixed an error in last commit
+	* doc/FAQ.html: added an entry for compilation from CVS
+
+Mon Jun 11 10:07:29 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xmlversion.h.in libxml.h: Cygwin patches
+	* tree.c: xmlFreeNodeList patch similar to xmlFreeNode one
+	* tree.h: cleanup
+
+Sat Jun  9 19:16:00 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* tree.c: patched xmlFreeNode() to avoid freeing() a static
+	  memory block in a strange case where libxml is linked twice
+	  in the binary.
+
+Sat Jun  9 18:39:03 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* valid.c: (a? , b? , c? , ... , z?) was storing/restauring
+	  state far too often, simple fix used to avoid it.
+
+Sat Jun  9 16:10:36 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xinclude.c: Raphael Hertzog had a trouble with DTD nodes
+	  being processed, applied his patch
+	* tree.c: fixed a bug raised in xmlStaticCopyNodeList()
+
+Sat Jun  9 15:50:11 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* nanoftp.c nanohttp.c uri.c include/win32config.h: Igor  Zlatkovic
+	  provided fixes to compile on MSCC again
+	* win32/libxml2/libxml2.def.src win32/libxml2/libxml2*.dsp: he
+	  also provided an update for the project files.
+
+Thu Jun  7 21:52:10 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* tree.c: applied Steve Tinney patch to xmlNewNsProp to fix
+	  bug #55810
+
+Thu Jun  7 21:29:39 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* tree.c: fixed xmlGetNsProp() to close bug #55683
+	  Note this requires libxslt to use it's own function instead.
+
+Thu Jun  7 18:06:34 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* HTMLtree.c: when in a pre element no formatting space should
+	  be added.
+	* test/HTML/pre.html result/HTML/pre.html*: added a regression test
+
+Thu Jun  7 17:29:38 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* configure.in: added tests for signal() and signal.h
+
+Fri Jun  8 10:17:15 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: robert pointed out xmlXPathNINF was not initialized
+
+Fri Jun  8 10:01:45 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* doc/libxml-doc.el: Felix Natter provided a new version for
+	  libxml2
+
+Fri Jun  8 07:20:46 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* HTMLtree.c: when in a pre element no formatting space should
+	  be added.
+
+Wed Jun  6 18:07:36 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* configure.in: add -mieee to CFLAGS when compiling on Linux/alpha
+
+Thu Jun  7 06:44:01 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* DOCBparser.c: implemented the <?sgml-declaration encoding="xxx"?>
+	  hack
+	* tree.[ch]: added xmlHasNsProp as suggested in bug report #55653 
+	* uri.c: fixed a warning
+
+Tue Jun  5 22:54:21 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* HTMLtree.c: trying to close bug #55772 escaping in script
+	  elements
+	* doc/xml.html: suggest to send mail to the list
+
+Tue Jun  5 19:11:02 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* error.c: attempt to fix the xmlGetVarStr breakage once and for
+	  good. Use a macro and based on the solution provided in 
+	  vsnprintf manual page from GNU.
+
+Tue Jun  5 14:46:10 CEST 2001 Bjorn Reese <breese@users.sourceforge.net>
+
+	* error.c: Workaround for non-preserving variadic list.
+	* trio.c trio.h triop.h strio.c strio.h: Upgraded to trio baseline 1.4
+	
+Sat Jun  2 06:12:33 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* doc/xml.html: added 2.3.10 release
+
+Fri Jun  1 11:27:11 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* configure.in: releasing 2.3.10
+
+Thu May 31 20:42:39 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xmlIO.c: Gary Pennington spotted a few troubles with file:///
+
+Thu May 31 20:18:59 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* encoding.c: Robert Collins provided a patch to add the
+	  "US-ASCII" encoding alias
+
+Wed May 30 21:12:45 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c encoding.[ch]: William M. Brack provided a set of UTF8
+	  string oriented functions and started cleaning the related areas
+	  in xpath.c which needed fixing in this respect
+
+Wed May 30 20:30:47 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* HTMLtree.c: applied patch from Jaroslaw Kolakowski to close bug
+	  #55380
+	* tree.c: patch to xmlNodeGetContent() to get CDATA section content
+
+Mon May 28 12:56:29 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* TODO: updated
+	* nanohttp.[ch] : started adding APIs to get the redirected URL
+	  when this occurs (needed for further base computation
+	* tree.h: cleanup
+	* encoding.c: cleanup
+	* SAX.c: minor change around ctxt->loadsubset
+
+Fri May 25 09:36:26 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* Makefile.am include/Makefile.am: small change to have
+	  include/libxml rebuilt if working from CVS.
+	* uri.c: applied another patch from Carl Douglas for URI escaping,
+	  this should close bug #51876
+
+Wed May 23 15:40:27 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xinclude.c: fixed XInclude recursive behaviour bug #54678
+	* result/XInclude/recursive.xml test/XInclude/docs/recursive.xml
+	  test/XInclude/ents/inc.txt test/XInclude/ents/sub-inc.ent:
+	  added specific regression test
+	* parser.h: preparing for the XSLT mode where DTD inherited
+	  attributes are added to the tree.
+
+Wed May 23 13:59:19 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xinclude.[ch]: Updated the namespace for the Last Call version
+	* result/XInclude/include test/XInclude/include: updated the
+	  testsuite accordingly
+
+Wed May 23 12:27:44 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* uri.[ch]: applied a patch from Carl Douglas for URI escaping,
+	  related to bug #51876
+
+Tue May 22 18:46:56 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* tree.c: fixed a gross mistake in base computation, xml:base is
+	  not completely correct yet (need cascade).
+	* xpath.[ch]: added the few things needed to find a function name
+	  and URI from the XPath context when it is called.
+
+Tue May 22 17:00:36 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* catalog.[ch]: fixes and add xmlLoadCatalogs()
+	* DOCBparser.c: small cleanup
+	* xmllint.c: added a --catalogs option to load catalogs from
+	  $SGML_CATALOG_FILES
+	* tree.c: cleanup
+	* configure.in: iconv library fixup, ICONV_LIBS 
+
+Mon May 21 16:05:22 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* catalog.c: handling of CATALOG entries. detection of recursion,
+	  and a few bugfixes
+	* xpath.c: fixing bug #54951 QNAME with no prefix should not match
+	  against the default namespace
+
+Mon May 21 10:14:07 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: Joe Orton reported a bug found with IRIx compiler.
+
+Sun May 20 15:15:46 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* parser.c: fixed propagation context info when parsing an
+	  external entity.
+	* doc/html/*.html: regenerated a couple of docs
+
+Sat May 19 17:11:15 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* doc/xml.html: update with 2.3.9 informations
+
+Sat May 19 16:50:47 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* HTMLtree.h debugXML.h parserInternals.h tree.h valid.c
+	  xmlversion.h.in xpathInternals.h xpath.h: some cleanup for gtk-doc
+	* doc/html/* : rebuilt the docs
+	* valid.c: small patch which may improve some case when
+	  validating.
+
+Sat May 19 15:20:03 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* HTMLparser.c: Closed bug #54891
+	* result/HTML/cf_128.html* test/HTML/cf_128.html: added the test
+	  to the suite
+
+Thu May 17 14:15:07 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* encoding.h hash.c nanoftp.h parser.h tree.h uri.h xlink.h xpointer.c:
+	  applied a documentation patch from LotR and filled in a few missing
+	  descriptions
+
+Wed May 16 23:02:41 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c tree.c parser.c: speed optimizations at the parser level
+	  document tree freeing and xpath evaluation
+
+Wed May 16 12:55:48 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* parser.c parser.h parserInternals.h: fixed a couple of
+	  interfaces for handling memory buffer input to const char *
+	  upon suggestion of JamesH.
+
+Tue May 15 17:22:27 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* configure.in: LoTR sent a patch fixing the previous commit 
+
+Tue May 15 14:40:04 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* configure.in: trying to deal again with the stoopid -R linking
+	  flag of Solaris
+
+Tue May 15 12:49:50 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.h: two nodeset access macros from Thomas Broyer
+
+Tue May 15 11:42:39 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c xpath.h xpathInternals.h: apply an XPath API cleanup
+	  patch from Thomas Broyer
+
+Tue May 15 10:52:19 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* valid.c test/VCM/v2[34].xml: Fixed bug #54631 added specific test
+	  case
+	* INSTALL: was empty added stuff from the FAQ
+
+Fri May 11 19:37:30 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* tree.[ch]: fixing bug #54446, by cleaning some bugs in the
+	  attributes handling and #54433 by adding xmlUnsetProp()
+	  and xmlUnsetNsProp()
+
+Fri May 11 16:07:13 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* HTMLparser.c: Patch from Jonas Borgström
+	(htmlGetEndPriority): New function, returns 
+	the priority of a certain element.
+	(htmlAutoCloseOnClose): Only close inline elements if they 
+	all have lower or equal priority.
+	* result/HTML: this of course changed a number of tests results.
+
+Thu May 10 17:30:22 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xmlIO.c catalog.c: plugged in the default catalog resolution
+	* doc/gnome-xml.sgml: linked in the Docbook parser and catalog
+	  documentations
+	* doc/html/libxml-*.html: rebuild added the missing ones to CVS
+
+Thu May 10 16:14:36 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* Makefile.am xmlversion.h.in configure.in include/Makefile.am:
+	  integrating catalogs
+	* catalog.[ch] testCatalog.c: adding a small catalo API
+	  (only SGML catalog support).
+	* parser.c: restaured xmlKeepBlanksDefault(0) API
+
+Wed May  9 12:50:15 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* tree.c: zb@bisp.com reported an error in xmlNodeGetLang()
+
+Tue May  8 12:31:40 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* parser.c: added xmlParseExternalEntityPrivate() to allow
+	  propagation of ctxt->_private when parsing external entities
+
+Tue May  8 10:26:22 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* HTMLtree.c: fixed the bug reported by Bjorn in htmlNodeDump
+
+Tue May  8 09:30:12 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* configure.in: fixed a small portability problem with AM_CONDITIONAL
+
+Mon May  7 22:44:45 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* valid.c: warn when indeterminist content model is detected
+	* result/VC/ElementValid8: this adds a message
+	* Makefile.am: add --novalid for VCM tests
+	* parserInternals.c: added a call to Init memory 
+
+Fri May  4 19:51:15 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* HTMLparser.c: fixed htmlNewDoc SYSTEM and PUBLIC ID inversion
+	  when both parameters are NULL.
+
+Fri May  4 17:19:39 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* valid.c: applied small patch from Gary Pennington, reindented
+	  some part of the code.
+
+Thu May  3 13:10:43 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* configure.in doc/xml.html doc/html/*: preparing for 2.3.8
+	  release, updated and regenerated the docs
+
+Thu May  3 12:47:46 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c result/XPath/expr/floats : clarified and cleanup
+	  printing of abnormal floats in tests.
+
+Thu May  3 10:25:19 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* HTMLparser.c: trying to fix the problem reported by Jonas Borgström
+	* results/HTML/ : a few changes in the output of the HTML tests as
+	  a result.
+	* configure.in: tying to fix -liconv where needed
+
+Wed May  2 19:10:26 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* Makefile.am: fixed a stupid error
+
+Wed May  2 18:39:39 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* configure.in Makefile.am: make the inclusion of the trio
+	  modules in the library conditional
+
+Wed May  2 14:39:57 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* DOCBparser.c: patche from  László Kovács, fixed entities refs
+	  in attributes handling
+
+Wed May  2 12:56:04 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xmlIO.c: Bjorn Reese provided a fix for a problem on buffer
+	 flushing
+
+Mon Apr 30 22:29:34 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: fix of an XSLT namespace bug reported on the list
+	  general/bug-8-
+
+Mon Apr 30 19:42:58 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* strio.h trio.c: Dan McNichol suggested a couple of small
+	  fixes for AIX 4.3.3 using Visual Age 5.0.2 compiler
+
+Mon Apr 30 13:44:48 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* tree.c parser.c encoding.c: spent a bit more time looking
+	  at the parsing speed and DOM handling. Added a few more
+	  speedups.
+
+Sun Apr 29 21:53:47 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* parser.c: small but effective parsing speed improvement
+
+Sun Apr 29 19:02:13 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* configure.in: default on the DocBook parser inclusion (for Gnome)
+	* DOCBparser.h: fixed a header reference
+
+Sat Apr 28 19:00:39 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* configure.in xpath.c: applied Bjorn patches for FPE on the
+	  alpha
+
+Sat Apr 28 18:54:28 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* tree.[ch] xmlIO.h: applied patch from Joe McAlerney to add
+	  xmlSaveFormatFileTo()
+
+Sat Apr 28 16:33:05 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: simple and efficient optimization, XPath functions
+	  aways bind to the same code, cache this
+	* TODO: updated (by saying some is obsolete)
+
+Sat Apr 28 14:23:30 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: more cleanup work on XPath name parsing routines
+
+Fri Apr 27 19:06:13 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* parserInternals.c xpath.[ch]: some UTF8 cleanup on
+	  xmlXPathParseName
+	* xpath.c: Igor Zlatkovic suggested a change for NAN and MSC
+	* debugXML.c: avoid compilation problems if compiling without
+	  HTML support, Igor Zlatkovic
+	* win32/libxml2/libxml2.def.src: being able to compile without
+	  XPath on Windows
+
+Thu Apr 26 22:53:03 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* libxml.m4: yet another patch from Toshio Kuratomi
+
+Thu Apr 26 21:27:43 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* libxml.m4 libxml2-spec.in: new patches from Toshio Kuratomi
+
+Thu Apr 26 20:53:48 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* tree.[ch]: added xmlSaveFormatFile interface for saving
+	  and indenting a file.
+
+Thu Apr 26 16:35:53 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: fixed bug #53689 related to processing-instruction()
+
+Thu Apr 26 12:57:58 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* DOCBparser.c: patche from  László Kovács
+
+Thu Apr 26 11:31:54 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* parser.c: applied fixes from Christian Glahn bug report #53391
+
+Thu Apr 26 11:14:56 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* error.c: Jean François Lecomte provided a complete description
+	  and a fix to bug #53537
+
+Thu Apr 26 09:42:58 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* libxml.m4: added AM_PATH_XML2 provided by Toshio Kuratomi
+
+Wed Apr 25 21:05:31 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* DOCBparser.c SAX.c: a bit more work on entities processing.
+	  Still Need to cleanup XML output and references in attributes
+
+Wed Apr 25 17:52:27 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* DOCBparser.c include/Makefile.am: two patches from  László Kovács
+
+Wed Apr 25 14:56:26 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* tree.c: trying to fix #53574, not completely complete,
+	  I would like xmllint --copy --debug test/ent1 and
+	  xmllint --debug test/ent1 to show the same result.
+	* xpath.c: fix a bug when trying to sort namespace nodes
+
+Wed Apr 25 12:28:57 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* HTMLtree.c: real fix for  #53402
+
+Tue Apr 24 17:36:35 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* HTMLtree.c HTMLtree.h : closing #53402 i.e. output of
+	  PIs when using xsl:output
+	* valid.c: closing #53537 some case generate segfaults if there
+	  is validity errors
+
+Tue Apr 24 15:19:53 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* SAX.c testDocbook.c DOCBparser.c: more work on the support
+	  of external parsed entities, added --noent to testDocbook
+	* valid.c: Garry Pennington found an uninitialized variable
+	  access in xmlValidateElementContent()
+
+Tue Apr 24 14:41:25 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* HTMLparser.c : HTML parsing still sucks ... trying to deal
+	  with madness
+	* result/HTML/ : this modified the result of the regression tests
+	  a lot.
+
+Tue Apr 24 14:10:38 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* entities.c: xmlEncodeEntitiesReentrant fixed a few accesses
+	  to doc where it wasn't checked against NULL reported by
+	  Jens Laas
+
+Tue Apr 24 13:21:36 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* HTMLparser.c: Jonas Borgström patch, the <td>, and <th> elements
+	  now means the end of any open <span>,<font>,<a>,<b>,<i>,<u>.
+
+Mon Apr 23 15:40:04 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* DOCBparser.c DOCBparser.h testDocbook.c configure.in Makefile.am
+	  xmlversion.h.in: started (re)integrating the DocBook SGML parser.
+	* SAX.[ch]: cleanup and updates for DocBook
+	* debugXML.c parser.h tree.[ch] valid.c xpath.c: small macro or
+	  ex SGML identifier changes
+	* valid.c: removed a static unused function.
+
+Mon Apr 23 11:05:56 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* HTMLtree.c: applied change for Paul Sponagl on script saving
+	* Makefile.am: the warning about entity title.xml are normal.
+
+Sun Apr 22 22:09:35 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* configure.in: release of 2.3.7
+	* Makefile.am: fixing make distcheck
+
+Sun Apr 22 21:29:52 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* doc/html/* doc/xml.html: updated and regenerated the docs
+
+Sun Apr 22 21:11:45 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: fixed the XPointer problem introduced in 2.3.6
+
+Sun Apr 22 14:11:58 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* tree.c: fixed #53388 with the provided patch
+
+Sun Apr 22 12:34:41 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* valid.c: Bjorn detected an invalid memory access. Fixed
+	  vstateVPush()
+
+Sun Apr 22 10:49:23 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: fixed xmlXPathCompile to detected unproperly ended expr
+
+Sat Apr 21 18:27:51 CEST 2001 Bjorn Reese <breese@users.sourceforge.net>
+
+	* libxml.h: new header used only for the compilation of libxml
+	* HTMLparser.c HTMLtree.c SAX.c debugXML.c encoding.c entities.c
+	  error.c hash.c list.c nanoftp.c nanohttp.c parser.c
+	  parserInternals.c testHTML.c testSAX.c testURI.c testXPath.c
+	  tree.c uri.c valid.c xinclude.c xlink.c xmlIO.c xmllint.c
+	  xmlmemory.c xpath.c xpointer.c: libxml.h integration
+	* trio.[ch] triop.h strio.[ch]: upgraded to the latest trio
+	  baseline (version 1.2 plus a single patch).
+	* xpath.c result/XPath/expr/floats test/XPath/expr/floats: parses
+	  scientific notation for numbers. Tests added.
+	* xpath.c: formatting of numbers changed to use sprintf
+	  (contribution from William Brack)
+
+Sat Apr 21 16:12:59 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* valid.c: cleanup, more useful debugging
+	* parserInternals.c: cleanup vctxt.nodeTab (de)allocation
+	* xmlIO.c: entity loading is printed as an error when validating
+
+Sat Apr 21 12:25:49 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* valid.c: fixed to validate within entities
+	* test/VCM/v22.xml: added a specific testcase
+
+Fri Apr 20 17:45:47 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* valid.c: forgot an epsilon transition in for ()+
+	* test/VCM/v21.xml : added a specific test case
+
+Fri Apr 20 15:46:04 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* valid.c: removed a state explosion exhibited by RSS
+	* test/valid/rss.xml result/valid/rss.xml*: added the testcase
+	  from bug #51872
+
+Fri Apr 20 14:52:44 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* valid.[ch] tree.h: worked *hard* to get non-determinist content
+	  validation without using an ugly NFA -> DFA algo in the source.
+	  Made a specific algorithm easier to maintain, using a single
+	  stack and without recursion.
+	* Makefile.am test/VCM/*.xml: added more tests to "make Validtests"
+	* hash.c: made the growing routine static
+	* tree.h parser.c: added the parent information to an
+	  xmlElementContent node.
+
+Wed Apr 18 23:33:11 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* SAX.c parser.c xpath.c: generating IDs when not validating
+	  from an external parsed entity was poisoning the ID has table
+	  with removed values. This was killing XSLT on the KDE help
+	  browser.
+
+Wed Apr 18 17:09:15 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* entities.h: andrew@ugh.net.au detected a double declaration
+
+Wed Apr 18 15:06:30 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* debugXML.c hash.c tree.h valid.c : some changes related to
+	  the validation suport to improve speed with DocBook
+	* result/VC/OneID2 result/VC/OneID3 : this slightly changes
+	  the way validation errors get reported
+
+Wed Apr 18 11:42:47 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* HTMLparser.c HTMLtree.c: applied part of the patches provided
+	  by P C Chow and William M. Brack for XSLT HTML output
+
+Mon Apr 16 19:44:36 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xmlversion.h.in win32config.h win32/libxml2/*: applied 
+	  Igor Zlatkovic patches for MSC compilation and added his
+	  updates
+
+Tue Apr 17 10:08:19 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: fixed xmlXPathNodeCollectAndTest() to do proper
+	  prefix lookup.
+	* parserInternals.c: fixed the bug reported by Morus Walter
+	  due to an off by one typo in xmlStringCurrentChar()
+	
+Thu Apr 12 17:41:09 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* HTMLparser.c result/HTML/*: revamped the way the HTML
+	  parser handles end of tags or end of input
+
+Thu Apr 12 10:50:34 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* tree.[ch] : added xmlDocCopyNode for gdome2 support
+
+Wed Apr 11 16:37:50 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* tree.h: include xmlmemory.h this seems to havoid a nasty glibc
+	  bug where the linktime verions of free() won't work ...
+
+Wed Apr 11 14:21:31 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* config.h.in configure.in xmlversion.h.in: added ansidecl.h test
+
+Wed Apr 11 13:50:42 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* doc/xml.html: added 2.3.6 release
+
+Wed Apr 11 13:26:34 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* tree.c: fixed xmlStringGetNodeList() to handle charrefs
+	* result/wml.xml: resulted in a small output change
+
+Wed Apr 11 09:47:55 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* tree.c: xmlNewDoc was missing the charset initialization
+	* xmllint.c: added --auto to autogenerate a doc, allow to
+	  reproduce the problem fixed on xmlNewDoc
+
+Tue Apr 10 18:13:10 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: trying to get 52979 solved
+	* tree.c result/ result/noent/: trying to get 52712 solved, this
+	  also made me clean up the fact that XML output in general should
+	  not add formating blanks by default, this changed the output of
+	  a few tests
+
+Tue Apr 10 16:30:20 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: Bill Brack pointer an error in detecting a null nodeset
+
+Sun Apr  8 15:07:16 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* configure.in: finally released 2.3.6
+
+Sun Apr  8 11:39:21 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: checking for null pointer generated by new code
+
+Fri Apr  6 12:53:05 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: fixed a [] evaluation problem reported
+	* test/XPath/tests/simpleaddr: extended test
+	* result/XPath/simpleaddr: updated result
+
+Wed Apr  4 02:07:53 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xmllint.c: Dan Timis reported a portability problem
+	  on Macs without mmap, fixed it.
+
+Tue Apr  3 20:20:51 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* testXPath.c : added a --tree option allowing to display the
+	  tree dump of the XPath expression
+
+Mon Apr  2 17:13:51 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: fixed a memleak when comparing nodesets
+	* HTMLtree.c: don't invent the HTML doctype if not available (XSLT)
+	* tree.c: added a TODO
+
+Tue Mar 27 14:32:06 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* configure.in Makefile.am config.h.in xmlversion.h.in: detect if
+	  we need string functions
+	* trio.[ch] strio.[ch]: embedded the Trio-0.23 string functions
+	  to be able to use them where needed. Applied some changes
+	  to reduce name linking pollution and compile in only what's
+	  needed.
+	* HTMLtree.c debugXML.c entities.c error.c nanoftp.c valid.c
+	  xlink.c xmlversion.h.in xpath.c: got rid of the #ifdef 
+	  for the string manipulation functions
+	* xmlmemory.[ch]: removed DEBUG_MEMORY_FREED and added it automatically
+	  to the free() function of xmlmemory.c
+	* entities.c HTMLtree.c parserInternals.c tree.c uri.c valid.c
+	  xinclude.c xmlIO.c xpath.c xpointer.c: removed the MEM_CLEANUP
+	  usage.
+
+
+Tue Mar 27 02:30:23 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* error.c: applied the context output patch of the error
+	  handling submitted by Chuck Griffith
+	* error/VC/*: this slightly change some error logs
+
+Tue Mar 27 00:51:27 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* parser.c: fixed line number reporting on error
+
+Mon Mar 26 23:21:41 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* parser.c: Sullivan and Darin found a parser bug,
+	  applied the patch.
+
+Mon Mar 26 18:24:52 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* HTMLparser.c HTMLtree.c SAX.c debugXML.c error.c parserInternals.c
+	  testHTML.c testSAX.c tree.c valid.c xmlIO.c xmlmemory.c
+	  xmlversion.h.in xpointer.c: of course the way I defined
+	  UNUSED breaks on old gcc version. Try to be smart and
+	  also define it directly in xmlversion.h
+	* configure.in: removed -ansi flag from the pedantic set
+
+Sat Mar 24 17:45:36 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+        Huge cleanup, I switched to compile with
+	-Wall -g -O -ansi -pedantic -W -Wunused -Wimplicit
+	-Wreturn-type -Wswitch -Wcomment -Wtrigraphs -Wformat
+	-Wchar-subscripts -Wuninitialized -Wparentheses -Wshadow
+	-Wpointer-arith -Wcast-align -Wwrite-strings -Waggregate-return
+	-Wstrict-prototypes -Wmissing-prototypes -Wnested-externs -Winline
+	* HTMLparser.[ch] HTMLtree.c SAX.c debugXML.c encoding.[ch]
+	  encoding.h entities.c error.c list.[ch] nanoftp.c
+	  nanohttp.c parser.[ch] parserInternals.[ch] testHTML.c
+	  testSAX.c testURI.c testXPath.c tree.[ch] uri.c
+	  valid.[ch] xinclude.c xmlIO.[ch] xmllint.c xmlmemory.c
+	  xpath.c xpathInternals.h xpointer.[ch] example/gjobread.c:
+	  Cleanup, staticfied a number of non-exported functions,
+	  detected and cleaned up a dozen of problem found this way,
+	  avoided a lot of public function name/typedef/system names clashes
+	* doc/xml.html: updated
+	* configure.in: switched private flags to the really pedantic ones.
+
+Thu Mar 22 22:44:15 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* configure.in: 2.3.5
+	* doc/html/*: rebuilt the docs
+
+Thu Mar 22 15:36:45 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* parser.c: fixed a reported bug in NOTATION parsing
+	* uri.c: accepted but not fixed bug 51876, added TODO 
+	* Makefile.am: fixed bug 51876
+
+Thu Mar 22 13:41:22 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* config.h.in configure.in error.c: fix a compilation problem
+	  on platforms without vsnprintf (xml@thewrittenword.com)
+
+Wed Mar 21 19:04:34 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* parser.c: fixed a function name header typo
+	* SAX.c: notations can also occur in external subset.
+
+Tue Mar 20 14:21:28 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* error.c: removed a C++ like comment
+
+Tue Mar 20 12:22:36 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* parser.c: fixing bug 52299 strange condition leading
+	  to a parser crash due to a buffer overflow
+	* result/noent/attrib.xml result/attrib.xml test/attrib.xml:
+	  added the specific test case
+
+Mon Mar 19 16:50:52 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.[ch]: still a lot of cleanup based on XSLT, added
+	  xmlXPathConvert{String,Number,Boolean} to be able to make
+	  type casts without a context stack, fixed some implementation
+	  problems related to the absence of context at parse-time,
+	  added xmlXPathEvalPredicate() and xmlXPathFreeCompExpr()
+	  in the public API too
+	* xpointer.c xpathInternals.h: we need to know at parse time
+	  whether we are compiling an XPointer
+
+Mon Mar 19 11:54:31 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.[ch] xpointer.c: restaured the Binary and API compatibility
+	  cleaned up the parser internals, refactored XPath code, added
+	  new compilation based APIs and cleanly separated public and
+	  private APIs.
+
+Mon Mar 19 00:59:25 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.h: the comp field must be added at the end to avoid
+	  killing binary compat.
+
+Mon Mar 19 00:11:18 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* Makefile.am: detect XPath memleaks in regreson tests
+	* error.c: fixed and error w.r.t. error reporting still using
+	  stderr
+	* hash.c: added new line at end of file
+	* tree.h: minor cleanup
+	* xpath.[ch] xpointer.[ch]: Major changes ! Separated XPath
+	  expression parsing from evaluation, resulted in a number of
+	  changes internally, and in XPointer. Likely to break stuff
+	  using xpathInternals.h but should remain binary compatible,
+	  new interfaces will be added.
+
+Wed Mar 14 20:34:02 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* configure.in: fixed a couple of problems reported by 
+	  okiddle@yahoo.co.uk and allanc@chickenandporn.com when compiling
+	  without gcc on non linux platforms.
+
+Wed Mar 14 20:13:54 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* doc/Makefile.am configure.in: yearke@eng.buffalo.edu suggested
+	  a fix for --with-html-dir= configure support. I hope it won't
+	  break rpm generation
+
+Wed Mar 14 17:28:49 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xmlIO.c: one function comment cleanup.
+
+Wed Mar 14 14:55:46 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* SAX.c: external subset notations were improperly registered
+	  in the internal subset.
+
+Tue Mar 13 10:28:49 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* README.cvs-commits: added, pointing to HACKING
+	* HACKING: updated
+
+Mon Mar 12 22:09:40 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* parser.c: and Matt Sergeant found one in the XML push
+	  parser (erroneous check I forgot to remove when I fixed the
+	  main parser).
+
+Mon Mar 12 19:19:04 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: ptittom found a small bug in UnaryExpr
+
+Sat Mar 10 13:09:53 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* configure.in: bumped to 2.3.4
+	* error.c: fixed bug #51860
+	* tree.c: fixed bug #51861
+	* valid.c: cleanup, more debug, failed to fix one bug crap ...
+	* tree.[ch] : added xmlDefaultBufferSize
+	* nanoftp.c: typo in function name header block
+	* doc/xml.html : updated, added link to XML::LibXSLT
+	* doc/html/* : rebuilt the docs
+
+Wed Mar  7 20:43:47 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* parser.c SAX.c: the new content parsing code raised an
+	  ugly bug in the characters() SAX callback. Found it
+	  just because of strangeness in XSLT XML Rec ouptut :-(
+
+Wed Mar  7 16:50:22 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* Makefile.am: Martin Baulig suggested to add -lm
+	* tree.c: found another bug in xmlNodeGetContent()
+
+Tue Mar  6 09:21:30 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: Bjorn found the error related to strictness of comparison.
+
+Mon Mar  5 21:47:31 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* parser.c: trying to fix the Dtd parsing problem reported
+	  by Gary, side effect of last week speed optimizations.
+
+Sat Mar  3 19:45:59 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xml2Conf.sh.in: fixes pointed out by Fredrik Hallenberg
+	* parserInternals.c: removed unneeded test raised by Stric
+
+Sat Mar  3 13:04:37 CET 2001 Bjorn Reese <breese@users.sourceforge.net>
+
+	* xpath.c: Fixed xmlXPathNodeCollectAndTest (problem reported
+	  and fixed by William Brack). Added xmlXPathFormatNumber.
+	  Changed the sorting slightly.
+	* configure.in Makefile.am example/Makefile.am: Added -lm.
+	  Please note that applications linking with libxml2, must
+	  also like with the math library from now on.
+
+Sat Mar  3 07:38:58 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* HTMLparser.c: fixed loop reported by Marc Sanfacon
+
+Sat Mar  3 02:10:24 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* parser.c: one must report spaces even if the Dtd element
+	  content proves that this is not part of the element content.
+	* result/valid/*.xml: this changed the ouptu slightly
+
+Thu Mar  1 17:53:39 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* configure.in: bumped to 2.3.3
+	* doc/xml.html: updated
+
+Wed Feb 28 00:43:58 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* tree.c: minor doc fix
+	* xpath.c: deallocation issues when a result tree has been
+	  converted to a node-set
+
+Mon Feb 26 22:09:45 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* doc/xml.html: oops corrected dates s/2000/2001
+
+Mon Feb 26 12:48:35 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* valid.c: new patch from Gary Pennington
+
+Mon Feb 26 09:30:23 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* doc/xml.html: applied patch from Ankh
+
+Mon Feb 26 03:34:43 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xinclude.c: fixed a problem building on Mac
+
+Sun Feb 25 21:52:30 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* parser.c: more work on increasing parsing ferformances
+
+Sun Feb 25 18:03:42 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xmlmemory.h HTMLparser.c HTMLtree.c entities.c parser.c
+	  xpath.c xpointer.c tree.c uri.c valid.c xinclude.c xmlIO.c:
+	  avoiding memcpy in production builds MEM_CLEANUP macro use
+	* parser.[ch] parserInternals.c: optimizations of the tightest
+	  internal loops inside the parser. Better checking of I/O
+	  flushing/loading conditions
+	* xmllint.c : added --timing
+
+Sun Feb 25 05:48:51 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* configure.in: bumped to 2.3.2
+	* doc/xml.html: updated for release
+
+Sat Feb 24 14:07:52 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: found a memleak and fixed a nasty bug
+
+Sat Feb 24 03:35:48 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xmllint.[c1] : added return code errors for xmllint
+	* xpath.c: specific debug dump function for result value trees
+
+Thu Feb 22 07:52:27 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: finally implemented xmlXPathCompareNodeSets
+	* test/XPath/expr/floats results/XPath/expr/floats: added 
+	  a test for float expressions
+
+Tue Feb 20 18:57:54 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* tree.c: fixed xmlNodeGetContent, it was not recursing on child
+	* parserInternals.[ch]: trying to speed up parsing
+	* xpath.c : speeded up node set equality op
+
+Mon Feb 19 19:01:57 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* Makefile.am valid.c list.[ch]: Gary Pennington provided a
+	  better handling of ID/IDREF and the list modules associated
+	* configure.in: small CFLAGS cleanup
+
+Mon Feb 19 16:13:22 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* configure.in: fixed iconv detection on AIX (stric)
+
+Mon Feb 19 10:59:41 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: fixed "*" (unbelievable !) and a couple of warnings
+
+Sun Feb 18 17:52:37 MET 2001 Bjorn Reese <breese@users.sourceforge.net>
+
+	* xpath.c: fixed whitespace handling in xmlXPathStringEvalNumber,
+	  and optimized xmlXPathNodeSetSort
+
+Sat Feb 17 14:18:42 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: bug fix when context size is 0
+	* parser.c: I like Norm's Dtd because they still manage to break
+	  the parser occasionally
+
+Fri Feb 16 14:20:35 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: xmlXPathEqualNodeSetFloat the arg is really a double now
+
+Fri Feb 16 01:10:06 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* tree.[ch] parser.c xpath.c: fixed the problem of addressing
+	  attributes within the XML-1.0 namespace
+
+Thu Feb 15 16:53:20 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpathInternals.h: exported a few axis functions
+	* doc/xml.html: updated the doc
+
+Thu Feb 15 15:57:14 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* configure.in: applied patch from Daniel van Balen for OpenBSD
+	  and bumped version to 2.3.1
+	* HTMLtree.c result/HTML/doc3.htm result/HTML/wired.html: the
+	  attempt to find autoclosing was simply broken, removed it,
+	  updated the examples, this is better
+
+Wed Feb 14 11:35:39 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* hash.[ch]: added Paolo Casarini patch to provide Delete from
+	  hash functionnalities.
+	* doc/html/* : rebuild the doc
+
+Tue Feb 13 18:01:48 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c result/XPath/tests/chaptersprefol: bugfixes on order and
+	  on predicate
+	* HTMLparser.[ch] HTMLtree.c result/HTML/doc3.htm.err
+	  result/HTML/doc3.htm.sax result/HTML/wired.html: sometimes one
+	  really want to have tags closed on output even if we accept
+	  unclosed ones on input
+
+Mon Feb 12 18:33:20 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: ouch don't free NULL, rare case fixed
+	* tree.c: don't coalesce text nodes if they don't have the
+	  same behaviour wrt escaping on output
+
+Sun Feb 11 21:15:41 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: small fixup
+	* SAX.c: don't warn on empty namespaces.
+
+Thu Feb  8 11:28:58 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* README: a bit of cleanup
+	* configure.in: preparing for 2.3.0 release
+
+Thu Feb  8 10:37:00 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* hash.[ch]: added a first version of xmlHashSize()
+	* valid.c: another bug fix from Gary Pennington
+
+Wed Feb  7 19:22:37 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* valid.c: couple of bug fixes pointed by Gary Pennington
+	* HTMLtree.c: #if 0 cleanup
+
+Tue Feb  6 14:02:56 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: started profiling XSLT, added xmlXPathNodeSetAddUnique()
+	  which removes a time consuming check of xmlXPathNodeSetAdd()
+	  and use it in places where we are sure to not break unicity
+
+Mon Feb  5 18:51:36 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: bug fixes found from XSLT
+	* tree.c: preserve node->name special values when copying nodes.
+	* parserInternals.[ch] parser.[ch] SAX.c : added a mode where
+	  external subset are fetched when available but without full
+	  validation. Added xmlLoadExtDtdDefaultValue, need a function.
+	* HTMLtree.c: add support for xmlStringTextNoenc for XSLt HTML
+	  output with encoding disabled.
+
+Sat Feb  3 09:50:29 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xmliO.c: Harry Blundell pointed out that xmlCheckFilename
+	  xmlCheckFilename should not be called from xmlFileOpenW
+	  and xmlGzfileOpenW
+
+Fri Feb  2 18:04:35 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* uri.c: rewrite of xmlNormalizeURIPath from Paul D. Smith
+	* test/URI/smith.uri result/URI/smith.uri Makefile.am:
+	  added the new tests for URI normalization
+	* testURI.c: fixed stoopid bugs
+	* result/VC/OneID3 result/VC/UniqueElementTypeDeclaration:
+	  the URI in the error messages are now properly normalized
+
+Fri Feb  2 09:18:53 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* uri.c: applied Marc Sanfacon's patch for xmlNormalizeURIPath
+
+Thu Feb  1 05:28:55 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: fixed a number of problems in XPATH_XSLT_TREE processing
+
+Wed Jan 31 21:45:37 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: fixed mod operator
+
+Wed Jan 31 16:50:42 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* parser.c: fixed xmlStrcat doc
+	* tree.c: 2 fixes form Anders Carlson for copying nodes and
+	  trees.
+
+Wed Jan 31 14:19:16 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c result/XPath/tests/chaptersbase
+	  result/XPath/tests/simplebase: fixed XPath node() 
+	* tree.c: small fix in xmlNewNs()
+	* Makefile.am: removed extraneous xml2Conf.sh rule
+
+Sun Jan 28 08:37:03 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* Makefile.am configure.in libxml.spec.in example/Makefile.am:
+	  Changed the library name, in order to get libxml-devel and
+	  libxml2-devel to coexist on a single system
+	* xml-config.1 xml-config.in xmlConf.sh.in: renamed
+	* xml2-config.1 xml2-config.in xml2Conf.sh.in: new files
+
+Sat Jan 27 19:58:22 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* Makefile.am configure.in libxml-2.0.pc.in: started working on getting
+	  libxml2-devel installable in // as libxml-devel.
+
+Sat Jan 27 18:49:02 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* doc/Makefile.am: fixed make rebuild in doc
+	* doc/html/*.html: rebuilt the docs
+
+Fri Jan 26 10:30:58 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* tree.c: patch from Bjorn Reese on xmlBufferCCat
+
+Thu Jan 25 19:22:25 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* Makefile.am doc/Makefile.am libxml.spec.in: painful work to get
+	  the HTML doc to go into the -devel RPM ...
+	* aclocal.m4 config.h.in: some updates due to auto* magic
+
+Thu Jan 25 19:11:49 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.h: added a hook in the context structure allowing to
+	  link to extra support, needed for XSLT
+
+Thu Jan 25 13:34:11 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.[ch] xpointer.c: added xmlXPathCmpNodes, changed
+	  xmlXPtrCmpPoints to use it.
+	* propagated the following patch from Alejandro Forero
+	* include/win32config.h xmlIO.c: applied further suggestions
+	  from Igor Zlatkovic <igorz@dialup.nacamar.de> and cleanup
+	* example/gjobread.c: fixed warnings, now that it builds
+
+Wed Jan 24 20:27:28 COT 2001 Alejandro Forero <bachue@bachue.com>
+
+        * xmlIO.c (xmlFileOpen, xmlFileOpenW): Removed unnecesary checks.
+
+        * xmlIO.c (xmlCheckFilename): Function added to know whether a given
+          filename points to a valid file (not a directory).
+        * xmlIO.c (xmlFileOpen, xmlFileOpenW, xmlGzfileOpen, xmlGzfileOpenW):
+          Added calls to xmlCheckFilenameDir.
+
+        * xmlIO.c (xmlGzfileOpen, xmlGzfileOpenW, xmlFdOpen, xmlFdOpenW): Pass
+          `path' (rather than `filename') as the parameter to gzopen and open.
+
+Tue Jan 23 16:26:30 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* Makefile.am: fixed a problem with EXTRA_DIST
+
+Mon Jan 22 23:42:17 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* Makefile.am example/Makefile.am: finally found the trick
+	  to build the example, i.e. add "." in SUBDIRS before example
+	  in the list <grin/>
+
+Mon Jan 22 16:30:37 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* doc/xml.html: updated with an XSLT section, removed pointer to
+	  W3C CVS base.
+
+Mon Jan 22 11:43:21 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: when copying a XSLT tree object teh tree need to be copied
+	  too, and deallocation need to occur the same way.
+
+Mon Jan 22 10:35:40 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpathInternals.h xpath.[ch] debugXML.c: added the XPATH_XSLT_TREE
+	  type correponding to an XSLT result tree fragment. Share most
+	  of the data format with node set, as well as operators.
+	* HTMLtree.c: added a newline at the end of the doctype output
+	  whe this one is not present initially.
+	* tree.c: make sure taht the parent and doc pointers are properly
+	  set when copying attributes (lists).
+
+Sun Jan 21 10:47:38 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* htmlTree.[ch] xmlIO.h: exported htmlDocContentDumpOutput
+
+Fri Jan 19 18:15:50 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: seems I finally killed that ugly path evaluation
+	  context bug (tagged 9999 in case is is wrong)
+
+Fri Jan 19 06:30:38 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.[ch] xpathInternals.h: added xmlXPathRegisterVariableLookup()
+	  for XSLT
+
+Thu Jan 18 16:19:47 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xmlIO.c: Gary Pennington <Gary.Pennington@uk.sun.com> fix
+	  for xmlGzfileOpen() bug
+
+Thu Jan 18 13:11:50 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: removed an error found by XSLT usage
+	* tree.c parserInternals.h: use a predefined static string
+	  for text and comment nodes, avoid freeing them in xmlFreeNode,
+	  exported the string name in parserInternals.h and added
+	  another value to disable encoding at output (for XSLT),
+	  gain memory, time.
+
+Wed Jan 17 09:15:16 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* win32/README.MSDev win32/libxml2/libxml2_a.dsp
+	  win32/libxml2/libxml2_so.dsp: new makefiles and update
+	  provided by Igor Zlatkovic <igor@stud.fh-frankfurt.de>
+
+Tue Jan 16 18:24:46 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* tree.c : xmlSaveFile, xmlSaveFileEnc, applied patch from 
+	  Gary Pennington
+
+Mon Jan 15 20:24:18 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xpath.c: fixed the comaprision of values and nodelists,
+	  need to compare nodelist still ...
+	* debugXML.c: avoided a possible core dump
+	* HTMLparser.c: cleanup
+	* nanohttp.c: contributed fix.
+	* tree.c: fixes in properties handling added xmlSetNsProp
+	  needed by libxslt
+	* xpathInternals.h: exported xmlXPathBooleanFunction, added a 
+	  comment
+	* TODO: updated
+
+Sat Jan  6 22:05:09 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* parser.c parserInternals.c: applied Bjorn Reese optimization
+	  patch
+
+Sat Jan  6 19:13:27 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* Makefile.am: applied patch fro make check from Martin Vidner
+
+Thu Jan  4 19:07:49 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* configure.in: preparing 2.2.11
+	* doc/html/*: rebuild the HTML files
+	* doc/xml.html : updated
+
+Thu Jan  4 14:09:58 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* tree.c: fixed a stupid bug
+	* valid.c: applied "Paul D. Smith" <pausmith@nortelnetworks.com>
+	  patches related to validation of an XInclude processing result
+	* TODO: updated
+
+Thu Jan  4 11:46:40 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* encoding.c xmlIO.c: Fixing the problem reported by Marc Sanfacon
+	  on large files
+
+Wed Jan  3 21:51:13 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xmlIO.c: fixed xmlParserInputBufferCreateMem doc
+
+Wed Jan  3 18:56:00 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* HTMLparser.c: htmlCheckParagraph to check htmlOmittedDefaultValue,
+	  reported by Jonas Borgström
+	* nanohttp.c: Applied Bjorn Reese' IPV6 first patch
+
+Wed Jan  3 16:19:39 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* testXPath.c xpath.c: fixing the XPath union expressions problem
+	  reported by  Martin Vidner <martin@artax.karlin.mff.cuni.cz>
+
+Wed Jan  3 14:22:33 CET 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+	* xmllint.c: Made is so if the file name is "-" is will read form
+	  standard input. Sven Heinicke  <sven@zen.org>
+	* tree.c: fixed a problem when growing buffer
+	* tree.h: fixed the comment of the node types following andersca
+	  comment
+	* TODO: updated
+
+Wed Dec 27 12:35:49 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* HTMLparser.[ch]: added a way to avoid adding automatically
+	  omitted tags. htmlHandleOmittedElem() allows to change the
+	  default handling.
+	* tree.[ch] xmllint.c: added xmlDocDumpFormatMemory() and 
+	  xmlDocDumpFormatMemoryEnc(), uses memory functions for output
+	  of xmllint too when using --memory flag, added a memory test
+	  suite at the Makefile level.
+	* xpathInternals.h xpath.[ch] xpointer.c: fixed problems
+	  with namespace use when encountering QNames in XPath evalation,
+	  added xmlns() scheme in XPointer.
+	* nanoftp.c : incorporated a fix
+	* parser.c xmlIO.c: fixed problems raised with encoding when using
+	  the memory I/O
+	* parserInternals.c: closed bug 25934 reported by 
+	  torsten.landschoff@innominate.de
+	* TODO: updated
+
+Sat Nov 25 11:46:27 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* configure.in doc/html/* doc/xml.html: made a 2.2.9 release
+	  on a non-updated tree :-(, made a 2.2.10 release to correct the
+	  situation
+
+Sat Nov 25 10:41:37 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* nanohttp.c parser.[ch] tree.[ch] xmlIO.[ch] xmllint.c xpath.c
+	  parserInternals.h vms/build_libxml.com vms/config.vms Makefile.am:
+	  integrated a set of OpenVMS changes from Howard Taylor
+	  <Howard.Taylor@pacoast.com>
+
+Sat Nov 25 01:21:01 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* tree.[ch] xmlIO.c: added xmlDocDumpMemoryEnc() from John Kroll
+	* error.c: applied fix suggested by "Leo Davidson" <leo@ox.compsoc.net>
+
+Sat Nov 25 00:24:49 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* HTMLparser.c: some fixes on auto-open of html/head/body
+	* encoding.c: fixed a compilation error on some gcc env
+	* xpath.c xpointer.[ch] xpathInternals.h: improved the
+	  XPointer implementation
+	* test/XPath/xptr/strpoint test/XPath/xptr/strrange3: added
+	  related XPointer tests and associated results
+
+Fri Nov 24 14:01:44 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* doc/xmldtd.html doc/xml.html: following a short step by step
+	  guidance on IRC to help maciej with DTDs I started a small
+	  page on the subject.
+
+Fri Nov 17 17:28:06 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* HTMLparser.c: fixed handling of broken charrefs
+	* xmlmemory.h libxml2.dsp include/win32config.h: reporting Windows
+	  patches
+
+Mon Nov 13 19:17:20 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* doc/xml.html doc/html/* : rebuilt the docs after adding
+	  xinclude and updated page for 2.2.7 and 2.2.8
+	* configure.in: releasing 2.2.8
+
+Mon Nov 13 12:39:38 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.[ch] parserInternals.c: applied the conditional
+	  section processing fix from Jonathan P Springer
+	  <jonathan.springer2@gte.net>
+	* xmlversion.h.in win32/libxml2/libxml2.dsp : Updated MS
+	  project file, fixed iconv default non support
+	* xpath.c: fixed the problem of evaluating relative expressions
+	  when a node context is provided.
+
+Sun Nov 12 16:31:19 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* nanoftp.c: fixed gcc 2.95 new warnings
+	* SAX.c: fixed a stupid bug
+	* tree.c: fixed a formatting problem when round-tripping
+	  from/to memory
+	* xinclude.c: chased memleak, fixed a base problem
+	* xpointer.c: added xmlXPtrBuildRangeNodeList(), finished ? 
+	  xmlXPtrBuildNodeList()
+	* TODO: updated
+	* Makefile.am test/XInclude/docs test/XInclude/ents result/XInclude:
+	  adding a first small set of regression tests for XInclude
+
+Tue Nov  7 15:11:34 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* nanohttp.[ch]: applied Wayne Davison patches to access
+	  the WWW-Authorization header.
+	* parser.c: Closed Bug#30847: Problems when switching encoding
+	  in short files by applying Simon Berg's patch.
+	* valid.c: fixed a validation problem
+	* hash.c parser.h parserInternals.h testHTML.c testSAX.c tree.h
+	  xmlerror.h xmlmemory.h xmlversion.h.in: applied a DLL patch from
+	  Wayne Davison
+	* xpointer.[ch]: added first version of xmlXPtrBuildNodeList()
+	  need to be extended to non full nodes selections.
+	* xinclude.c: starts to work decently
+
+Mon Nov  6 17:22:46 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* tree.[ch] xinclude.[ch] xmllint.c configure.in valid.c
+	  debugXML.c xmlversion.h.in: Started adding XInclude support,
+	  this is a new xmllint option
+	* tree.c xpath.c: applied TOM patches for XPath
+	* xpointer.c: fixed a couple of errors.
+	* uri.c: added an escaping function needed for xinclude
+	* testXPath.c hash.c HTMLtree.c: minor cleanups raised by
+	  new warning from RH70 gcc's version
+
+Tue Oct 31 14:14:13 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* HTMLparser.c: fixed loop on invalid char in scripts
+	* parser.c: update to description of xmlIOParseDTD()
+	* libxml.m4 xmlversion.h.in: changes contributed by
+	  Michael Schmeing <m.schmeing@internet-factory.de>
+	* configure.in: preparing for 2.2.7
+	* Makefile.am: trying to avoid  config.h and acconfig.h
+	  being included in the distrib
+	* configure.in: released 2.2.7
+
+Mon Oct 30 17:08:10 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* tree.[ch] debugXML.c parserInternals.c xpath.c: Deprecated Pi's
+	  like namespaces for good. Unified xmlNs and xmlNode somewhat.
+
+Mon Oct 30 16:26:49 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.[ch]: added xmlIOParseDTD()
+	* xpointer.c: added support for the 2 extra parameters of
+	  string-range, fixed a stoopid error when '0' was present
+	  in XPointer expressions
+	* test/XPath/xptr/strrange2 result/XPath/xptr/strrange2: added
+	  testsuite for the above
+
+Mon Oct 30 10:26:43 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* libxml.spec.in: improved package descriptions
+
+Sun Oct 29 19:03:11 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* xpath.c xpathInternals.h: applied a large cleaning patch
+	  from TOM <ptittom@free.fr>, it also add namespace support
+	  for function and variables registration.
+
+Sun Oct 29 18:51:46 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* uri.c: Wayne Davison's patch fixing xmlBuildURI()
+	* Makefile.mingw: Wayne Davison's update adding hash.c
+
+Sun Oct 29 18:38:12 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* xpath.c: fixed the root evaluation problems
+	* HTMLparser.c result/HTML/doc3.htm: fixed the problem of non
+	  ignorable spaces with <b> <bold> <em>
+	* tree.c: fixed a loop in xmlSearchNsByHref()
+
+Fri Oct 27 18:57:32 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* xpath.c: applied another XPath patch from TOM 
+	* xpath.c include/makefile.am: applied another patch from 
+	  china@thewrittenword.com (cleanup on IRIX).
+
+Fri Oct 27 13:45:28 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* xml-config.1: received a fixed version from Fredrik Hallenberg
+	  <hallon@lysator.liu.se>
+
+Thu Oct 26 16:05:25 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* xpath.c textXPath.c xpathInternals.h: applied TOM <ptittom@free.fr>
+	  cleanup patch for XPath
+
+Wed Oct 25 21:31:10 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* patched to redirrect all "out of context" error messages to
+	  a reconfigurable routine. The changes are:
+	* xmlerror.h : added the export of an error context type (void *)
+	  an error handler type xmlGenericErrorFunc there is an interface
+	  xmlSetGenericErrorFunc(void *ctx, xmlGenericErrorFunc handler);
+	  to reset the error handling routine and its argument
+	  (by default it's equivalent to respectively fprintf and stderr.
+        * all the c files: all wild accesses to stderr or stdout within
+	  the library have been replaced to calls to the handler.
+
+Wed Oct 25 15:27:19 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* configure.in: release 2.2.6
+	* xpath.[ch] xpointer.c xpathInternals.h: added xpathInternals.h
+	  exporting the inner functions of xpath for extension modules
+	* doc/*: updated and rebuilt the doc
+
+Wed Oct 25 12:48:55 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* nanohttp.c : applied Wayne HTTP cleanup patch
+	* tree.[ch]: applied TOM <ptittom@free.fr> for xmlNodeSetBase()
+	  and xmlNodeSetSpacePreserve()
+
+Wed Oct 25 12:11:03 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* xpath.c: closing bug #29260
+
+Tue Oct 24 18:49:34 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* hash.[ch] debugXML.c: expanded/enhanced the API, added
+	  multikey tuples, made hash structure opaque
+	* valid.[ch]: moved elements, attributes, notations decalarations
+	  as well as ID and refs to hash tables.
+	* entities.c: hash cleanup
+	* xmlmemory.c: fixed a dump problem in debug mode
+	* include/Makefile.am: problem passing in DESTDIR= values patch
+	  from Marc Christensen <marc@calderasystems.com>
+	* nanohttp.c: removed debugging remains
+	* HTMLparser.c: the bogus tag should be ignored (Wayne)
+	* HTMLparser.c parser.c: fixing a number of problems with the
+	  macros in the *parser.c files (Wayne).
+	* HTMLparser.c: close the previous option when opening a new one
+	  (Marc Sanfacon).
+	* result/HTML/*: updated the HTML results accordingly
+
+Sun Oct 22 18:39:19 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* entities.[ch] xpath.[ch] hash.[ch] debugXML.c tree.h: added/hacked
+	  hash tables from Bjorn Reese <breese@mail1.stofanet.dk>. Switched
+	  XPath functions and XML entities table to them. More to come...
+	* xmlIO.c: fixed libxml closing FILEs it didn't open.
+
+Sun Oct 22 13:59:50 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* tree.c: coalesce adjacent text nodes
+	* valid.c: handling of blank nodes in DTd validation (raised
+	  by problems with a posteriori validation).
+	* nanohttp.c: changing behaviour on HTTP write stuff.
+	* HTMLtree.c: forced body and html to be explicitely closed.
+	* xpath.h: exported more XPath functions.
+
+Sun Oct 15 22:28:32 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+        * Release of 2.2.5
+	* xpointer.c: range() range-inside and other helper functions
+	* parserInternals.c: fixed perf problem raised by rolf@pointsman.de
+
+Sun Oct 15 16:21:27 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* SAX.c: HTML attributes need normalization too (Bjorn Reese)
+	* HTMLparser.[ch]: addded htmlIsScriptAttribute()
+
+Sun Oct 15 13:18:36 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* doc/*: rebuilt docs preparing for 2.2.5 release, added URI
+	  and XPointer modules
+
+Sun Oct 15 12:13:30 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* SAX.h: closed #25107
+
+Sun Oct 15 12:06:16 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* testSAX.c: fixed problem with cdata reporting
+	* SAXresult/* : updated
+
+Sun Oct 15 12:00:24 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.c test/wap.xml result/noent/wap.xml result/wap.xml:
+	  Closed bug #27499, added to regression tests
+	* TODO: updated
+
+Sun Oct 15 01:34:37 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* HTMLparser.c HTMLtree.[ch] SAX.c testHTML.c tree.c: fixed HTML
+	  support for SCRIPT and STYLE with help from Bjorn Reese
+	* test/HTML/* result/HTML/*: added simple testcase and updated
+	  the existing ones.
+	  
+Fri Oct 13 18:24:31 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* xpath.c xpointer.c: XPointer reorder of ranges start/end and
+	  string-range for empty strings
+	* test/XPath/docs/str test/XPath/xptr/chaptersrange
+	  test/XPath/xptr/strrange: augmented the XPointer testsuite
+
+Fri Oct 13 12:21:48 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* doc/xml.html doc/xmlmem.html: added a module describing memory
+	  interfaces and use, updated the main page.
+
+Fri Oct 13 01:23:48 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* nanoftp.c nanohttp.c xmlIO.c: Wayne Davison Win32 patch
+	  nanoftp code work on Windows too now
+
+Fri Oct 13 00:54:37 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* testXPath.c xpath.[ch]: moved some debug functions to xpath core
+	* xpointer.c: implemented string-range() at least a good first version
+	* test/XPath/docs/str test/XPath/xptr/strrange
+	  result/XPath/xptr/strrange: the string-range() tests
+
+Thu Oct 12 10:02:59 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* Makefile.am include/Makefile.am include/win32config.h
+	  win32/Makefile.mingw: fixed problems reported by Wayne Davison
+	  and make distcheck
+
+Thu Oct 12 01:44:08 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* nanohttp.c: added xmlNanoHTTPTimeout(int delay), removed a bug
+	  xmlNanoHTTPMethod on input MimeType Tony Lam <Tony.Lam@eng.sun.com>
+	* xpointer.c: slight extension of xmlXPtrLocationSetMerge
+
+Thu Oct 12 01:37:53 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* config.h.in configure.in nanoftp.c nanohttp.c xmlversion.h.in :
+	  patch for socklen_t detection by
+	  Albert Chin-A-Young <china@thewrittenword.com>
+
+Wed Oct 11 17:53:57 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* tree.c valid.c xmllint.c: Fixed a few postvalidation bugs
+	  and added a --dtdvalid option to xmllint used to test it
+
+Wed Oct 11 15:01:29 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* xml-config.1 Makefile.am libxml.spec.in: adding a man page for
+	  xml-config by Fredrik Hallenberg <hallon@lysator.liu.se>
+
+Wed Oct 11 12:41:30 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* xpath.[ch] xpointer.[ch]: worked on XPath functions and variable
+	  handlings (registration, lookup, cleanup)
+
+Wed Oct 11 01:46:44 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* configure.in Makefile.am include/makefile.am: adding XPointer
+	  and XPtrtests target
+	* xpointer.[ch] : new files for XPointer support
+	* test/XPath/xptr result/XPath/xptr: added XPointer testsuite and
+	  more XPath tests
+
+Wed Oct 11 01:23:25 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* configure.in: fixed, very broken, make distcheck works again
+
+Wed Oct 11 02:53:10 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* More work toward 2.2.5, integrated a number of patches
+	* configure.in Makefile.am win32config.h.in: trying to cleanup
+	  make distcheck .... huh ...
+	* include/Makefile.am include/win32config.h: new directory
+	  for includes
+	* win32/Makefile.mingw win32/README.MSDev win32/libxml2/libxml2.dsp
+	  updated teh makefiles and instructions for WIN32
+	* xpath.c: small fixes
+	* test/XPath/ results/XPath: updated the testcases and results
+	* HTMLparser.c nanohttp.c testXPath.c: incorporated provided or
+	  suggested patches
+	* valid.c: fixed an ID bug
+
+Mon Oct  9 14:28:56 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* moved xml-error.h to xmlerror.h: seems this allowed to bypass
+	  the automake bug where wrong dependencies were generated.
+	* xpath.[ch]: worked on XPointer
+
+Fri Oct  6 12:58:04 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* configure.in Makefile.am: 2.2.5, ship the include in an
+	  include/libxml subdirectory, use symlinks when using CVS
+	* testSAX.c: fixed small bug
+	* testXPath.c: changed the way testfiles are parsed
+	* debugXML.c: same kind of cleanup when parsing an argument expression
+	  XPath/XPointers can have blanks embedded
+	* xpath.[ch]: more cleanup, reorgs for XPointer work
+	* parserInternals.c parser.c HTMLparser.c: fixed wrong include
+	* win32/README.MSDev win32/libxml2/libxml2.dsp: Windows stuff
+
+Thu Oct  5 18:13:15 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* debugXML.c testXPath.c xpath.[ch]: got pissed by some nastyness
+	  in the XPath engine, rewrote large parts of it, now it's far
+	  cleaner and in sync with the REC not an old WD. Fixed a parsing
+	  problem in the interactive XML shell found when testing XPath.
+
+Wed Oct  4 15:25:53 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* debugXML.c testXPath.c xpath.[ch]: More work on XPath/Xpointer,
+	  incorporated "(TOM)" <ptittom@free.fr> patches rebuilt the XPath
+	  examples with the extra test
+
+Wed Oct  4 14:39:01 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.c xmlIO.c xmlIO.h: fixed bug 26650, and improved
+	  the global init function.
+
+Tue Oct  3 11:28:52 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* HTMLparser.c: Doohhh, attribute name parsing was still case
+	  sensitive ! Fixed this ...
+	* result/HTML/* : updated the tests results accordingly
+
+Mon Oct  2 23:47:32 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* xpath.[ch] debugXML.c testXPath.c: fixed the XPath evaluation
+	  engine, should be far more stable, incorporated a new version of
+	  preceding/following axis, need testing
+        * uri.c: fixed file:///c:/a/b/c problem
+	* test/XPath/tests/idsimple: augmented the XPath tests
+
+Sun Oct  1 22:33:00 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* doc/* rebuilding docs for 2.2.4 release
+
+Sun Oct  1 22:16:33 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* configure.in: releasing 2.2.4
+	* parser.[ch]: added xmlStrEqual()
+	* HTMLparser.c HTMLtree.c SAX.c debugXML.c entities.c parser.c
+	  tree.c valid.c xlink.c xpath.c: converted all !xmlStrcmp to
+	  use xmlStrEqual instead
+	* TODO: updated
+	* added an XPath test
+
+Sun Oct  1 20:19:39 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* HTMLparser.c: fixed htmlStartCloseIndexinitialized init
+	* entities.h: exported xmlInitializePredefinedEntities
+	* parser.[ch] : added xmlInitParser()
+	* parserInternals.h : had to export htmlInitAutoClose()
+
+Sun Oct  1 16:28:22 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* xpath.[ch] : fixed some serious XPath Predicate evaluation
+	  problems
+	* Makefile.am : added XPath regression tests to normal tests
+	* uri.c: fixed a problem with local paths, cleanup
+	* parser.c: fixed a problem with large CData sections
+
+Sat Sep 30 16:35:54 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* configure.in xml-config.in: patch from "Ben Taylor"
+	  <sol7x86@hotmail.com> for solaris shared libs lookup
+
+2000-09-30  Martin Baulig  <baulig@suse.de>
+
+	* libxml-2.0.pc.in: Provide pkg-config script.
+
+	* configure.in: Create the libxml-2.0.pc script from the
+	libxml-2.0.pc.in templates.
+	* Makefile.am (pkgconfig_DATA): Install the libxml-2.0.pc
+	script in `$(libdir)/pkgconfig'.
+
+Mon Sep 25 16:23:41 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* HTMLparser.c parser.c tree.c tree.h: Avoiding a few warning
+	  when compiling with MSC
+
+Sun Sep 24 20:32:52 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* xpath.c: patch for normalize-string() substring-before(),
+	  substring-after() and translate() functions from Bjorn Reese
+	  <breese@mail1.stofanet.dk>
+	* libxml.m4 Makefile.am: added libxml.m4 from Debian ?
+	  Fredrik Hallenberg <hallon@lysator.liu.se>
+	* TODO: updated
+
+Sun Sep 24 10:00:49 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* xmlversion.h.in nanoftp.c nanohttp.c: traying to work out the
+	  problem of socklen_t being undefined on a number of platforms
+	* debugXML.c: fixed a compilation problem when without snprintf
+
+Sat Sep 23 12:19:45 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* HTMLparser.c uri.c: Another patch from Wayne Davison, correcting
+	  an URI bug and a fix for the control-character-induced infinite loop
+	* nanohttp.c: preventive fix for compiling on WIN32
+
+Fri Sep 22 18:06:08 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* xmlint.c: closing bug #25000
+
+Fri Sep 22 14:17:53 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* xmlIO.h tree.h: made xmlNodeDump() and xmlNodeDumpOutput() public
+	* parser.[ch] nanohttp.c HTMLtree.c HTMLparser.c tree.c: applied and
+	  modified slightly Wayne Davison patch adding xmlStrcasecmp and
+	  related function, fixing xmlStrncmp(), and associated cleanup
+	* result/HTML/entities.html.sax: updating result
+
+Tue Sep 19 14:20:10 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* uri.c: applied patch for URI escaping from Wayne Davison
+	  <wayned@blorf.net>
+	* tree.c parserInternals.c HTMLparser.c: memset checks patches
+	  from Denis Barbier <barbier@imacs.polytechnique.fr>
+	* HTMLparser.c: UTF8 characters in HTML tag-attribute values
+	  patch from Wayne Davison
+
+Sun Sep 17 18:37:03 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* doc/xml.html : updated with new releases, adding "how to help"
+
+Sun Sep 17 17:58:37 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* SAX.c debugXML.c parser.c parserInternals.c tree.c valid.c xpath.c:
+	  removed a few warnings in pedantic mode ...
+	* parserInternals.c parser.c: moved encoding switching function
+	  to parserInternals.c
+	* configure.in, doc/Makefile.am libxml.spec.in: released 2.2.3
+
+Sat Sep 16 20:12:41 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* HTMLparser.c parser.c: set ctxt->errNo before calling the
+	  error or warning handlers
+
+Wed Sep 13 22:03:18 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parserInternals.c parserInternals.h parser.c Makefile.am:
+	  created a new module parserInternals.c, moved most of the
+	  code shared by the various parsers there, as well as
+	  deprecated  code from parser.c. More cleanup of parser.c
+	* uri.c: fixed a problem when URI is NULL
+	* valid.c: speedup when looking for an attribute declaration
+
+Sun Sep 10 17:53:48 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* uri.c tree.c SAX.c parser.c entities.c debugXML.c: finished
+	  the cleanup of the computation of URI references when seeking
+	  external entities. The URI reference string and the resulting
+	  URI are both stored now.
+	* parser.c HTMLparser.c valid.c nanoftp.c nanohttp.c xpath.c:
+	  large s(n)printf checks and cleanup from Denis Barbier
+	  <barbier@imacs.polytechnique.fr>
+	* xmlversion.h.in tree.h: couple of SGML declarations for a
+	  possible docbook module.
+	* result/VC/ : a couple of test output changed due to the change
+	  of the entities URI
+
+Sun Sep 10 15:59:58 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.h: added a _private field for linking user's data
+
+Sun Sep 10 15:14:43 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.c parserInternals.h: demacroified most of the IS_XXX
+	  the gain in size is significant so ...
+
+Fri Sep  8 20:48:29 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* entities.c: cases where looking up entities with doc==NULL
+	  covered
+
+Tue Sep  5 12:41:15 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* uri.c: applied Wayne Davison patch
+	* Makefile.in test/URI/uri.data result/URI/uri.data: updated URI tests
+
+Mon Sep  4 13:01:45 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* uri.c testUri.c: applied Wayne Davison patches
+	* test/URI/uri.data result/URI/uri.data: first set of tests/results
+	* Makefile.in: added URItest and included thenin "make tests"
+
+Sun Sep  3 19:19:29 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* xmlversion.h.in: closed bug 22941
+
+Thu Aug 31 16:55:55 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* doc/xmlio.html: added doc and example for entity loader
+	  redefinition.
+
+Thu Aug 31 14:59:28 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* doc/xmlio.html doc/xml.html: added a doc on the I/O mechanism
+	  used by libxml
+
+Tue Aug 29 20:22:53 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.c: Fixed bug on invalid ontent characters and when using
+	  push.
+	* xmllint.c: fixed xmllint endling of errors in push mode
+
+Tue Aug 29 11:24:48 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* HTMLparser.c testHTML.c: applied two new patches from
+	  Wayne Davison <wayned@users.sourceforge.net>
+	* result/HTML/*.sax: regenerated HTML SAX output
+	* parser.c: more cleanup.
+
+Mon Aug 28 11:58:12 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* HTMLparser.[ch] testHTML.c: applied the second set of
+	  patches from Wayne Davison <wayned@users.sourceforge.net>,
+	  adding htmlEncodeEntities()
+	* HTMLparser.c: fixed an ignorable white space detection bug
+	  occuring when parsing with SAX only
+	* result/HTML/*.sax: updated since the output is now HTML
+	  encoded...
+
+Mon Aug 28 00:38:31 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* HTMLparser.[ch]: applied some of Wayne Davison
+	  <wayned@users.sourceforge.net> patches
+
+Sun Aug 27 22:14:01 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* SAX.c tree.c debugXML.c: fixed bogus behaviour when an
+	  undeclared namespace prefix was used, added a warning.
+	  Cleaned up support w.r.t. entities, spilling out a warning
+	  and being pedantic on lookups.
+	* test/warning/ent9 : added testcase for previous example.
+	* TODO: updated
+	* parserInternals.h parser.c: changed the way names are parsed
+	  now allow infinite size and decrease penalty for normal use
+	* parser.c: Started a big cleanup/check of the parser code,
+	  fixed some of the most tortuous entity code, spotted code
+	  unused anymore
+	* test/*: added tests for very long names and related nasty
+	  things.
+
+Sat Aug 26 23:31:04 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* doc/encoding.html: added encoding aliases doc
+	* doc/xml.html: updates
+	* encoding.[ch]: added EncodingAliases functions
+	* entities.[ch] valid.[ch] debugXML.c: removed two serious
+	  bottleneck affecting large DTDs like Docbook
+	* parser.[ch] xmllint.c: added a pedantic option, will be
+	  useful
+	* SAX.c: redefinition of entities is reported in pedantic mode
+	* testHTML.c: uninitialized warning from gcc
+	* uri.c: fixed a couple of bugs
+	* TODO: added issue raised by Michael
+
+Wed Aug 23 01:50:51 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* doc/encoding.html: propagated Martin Duerst suggestions
+
+Wed Aug 23 00:23:41 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.c: Fixed Bug#21552: libxml fails to decode &amp;
+	* uri.c testUri.c patches, by Marc Sanfacon (1 left)
+	* parser.c HTMLparser.c: HTML/encoding push problems reportedi
+	  by Wayne Davison
+
+Sun Aug 20 17:03:38 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* nanoftp.c nanohttp.c: small cleanup
+	* TODO: updated
+
+Sat Aug 19 22:57:02 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* added an old VC testcase and updated title.xml entity
+
+Sat Aug 19 21:02:08 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* HTMLparser.c SAX.c tree.c HTMLtree.h result/HTML/*: work
+	  done on auto-opening of <p> tags and cleanup of SAX output
+
+Sat Aug 19 18:45:40 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* libxml.4  xmllint.1 Makefile.am libxml.spec.in: added man pages
+
+Sat Aug 19 18:38:53 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* doc/xml.html libxml.* structure.*: updated the doc a bit
+
+Thu Aug 17 15:50:00 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* testSAX.c testHTML.c result/HTML/: cleanup of the output
+	  of SAX tests
+
+Mon Aug 14 13:56:33 EDT 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* Patch from Albert Chin-A-Young <china@thewrittenword.com>:
+	* xmllint.c: workaround a MAP_FAILEd definition bug in DU-4.0
+
+Mon Aug 14 11:10:20 EDT 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* Patch from Dave Yearke <yearke@eng.buffalo.edu>:
+	* testHTML.c: fix core dump on Solaris 2.x systems
+	* HTMLparser.c: fix segfault if ctxt->sax->characters() is NULL
+	* result/HTML/*.sax: previous bug fix lead to new results
+
+Mon Aug 14 10:26:09 EDT 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* Patch from Albert Chin-A-Young <china@thewrittenword.com>:
+	* configure.in: added --with-readline=DIR to accept alternate
+	  path for readline include/library
+	* configure.in: added AM_C_PROTOTYPES to add -Aa -D_HPUX_SOURCE
+	  for ANSI under HP-UX
+	* config.in: Removed @LIBS@ from xml-config because @XML_LIBS@
+	  includes @LIBS@
+
+Sat Aug 12 23:19:42 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* doc/* : rebuilt the docs
+	* getting ready for 2.2.2 release
+
+Sat Aug 12 16:42:37 EDT 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.[ch]: added xmlGetFeaturesList() xmlGetFeature()
+	  and xmlAddFeature()
+	* tree.[ch]: added xmlAddChildList()
+	* xmllint.c: MAP_FAILED macro test
+	* parser.h: added xmlParseCtxtExternalEntity()
+	* valid.c: applied bug fixes removed warning
+	* tree.c: added CDATA block to elements content
+	* testSAX.c: cleanup of output
+	* testHTML.c: added SAX testing
+	* encoding.c: better error recovery
+	* SAX.c, parser.c: fixed one of the external entity processing
+	  of the OASis testsuite
+	* Makefile.am: added HTML SAX regression tests
+	* configure.in: bumped to 2.2.2
+	* test/HTML/ result/HTML: added a few of HTML tests, and added the
+	  SAX results
+
+Fri Aug  4 11:21:50 PDT 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* configure.in: patch for HP compiler
+
+2000-08-04  Sven Heinicke  <sven@zen.org>
+
+	* xmllint.c: Was coredumping sometimes when the file given didn't
+	exist.
+
+Sat Jul 22 05:59:05 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.c xmlIO.[ch]: fixed the problem of encoding support
+
+	  when using in memory parsing. Need some cleanup.
+	* xmllint.c configure.in: added a --memory flag to test memory
+	  parsing
+	
+Fri Jul 21 17:09:57 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* nanohttp.c: fixed socklen_t replacement to unsigned int
+	* parser.c: fixed a space handdling missing at the end of
+	  production 28 DOCTYPE.
+	* xmlmemory.c: fixed a stupid bug on the routine to override
+	  allocation functions
+	* TODO: updated
+
+Fri Jul 14 17:01:14 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* doc/ regenerated the docs
+
+Fri Jul 14 16:12:20 MEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* doc/encoding.html doc/xml.html: added I18N doc
+	* encoding.[ch] HTMLtree.[ch] parser.c HTMLparser.c: I18N encoding
+	  improvements, both parser and filters, added ASCII & HTML,
+	  fixed the ISO-Latin-1 one
+	* xmllint.c testHTML.c: added/made visible --encode
+	* debugXML.c : cleanup
+	* most .c files: applied patches due to warning on Windows and
+	  when using Sun Pro cc compiler
+	* xpath.c : cleanup memleaks
+	* nanoftp.c : added a TESTING preprocessor flag for standalong
+	  compile so that people can report bugs more easilly
+	* nanohttp.c : ditched socklen_t which was a portability mess
+	  and replaced it with unsigned int.
+	* tree.[ch]: added xmlHasProp()
+	* TODO: updated
+	* test/ : added more test for entities, NS, encoding, HTML, wap
+	* configure.in: preparing for 2.2.0 release
+
+Mon Jul 10 16:17:18 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* nanoftp.c: fixed the way the control connection is handled
+	* libxml.spec.in: fixed the dependencies and cleanup
+
+Mon Jul  3 14:37:07 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* doc/xml.html: changed the xmlsoft.org structure, updated the
+	  examples w.r.t. root and childs
+
+Sun Jul  2 20:51:43 MEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* libxml.spec.in: fixed bug #7419, dependencies fouled for libxml-devel
+
+Sun Jul  2 09:52:45 MEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* HTMLparser.c: Work on character encoding support for the HTML parser
+	* HTMLparser.c: Fixed some autoopen/autoclose probs for the HTML parser
+	* encoding.c: Fixed a potential memleak in the encoding stuff
+
+Sat Jul  1 13:44:22 MEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* doc/FAQ.html doc/Makefile.am : added a FAQ
+
+Fri Jun 30 20:29:08 MEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* HTMLparser.c HTMLtree.c SAX.c valid.c tree.h : more cleanup
+	  of the HTML parser to force it to not bypass SAX
+
+Fri Jun 30 11:19:59 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* win32config.h.in: updated
+	* xmlversion.h.in: crap forgot to update this, this mean 2.1.0
+	  lacks iconv support :-( need to release 2.1.1
+	* configure.in: release 2.1.1
+	* HTMLparser: fixed bug #14784
+	* xpath.c HTMLparser.c encoding.c parser.c: fix warning raised
+	  by Windows compiler
+	* HTMLparser.c SAX.c HTMLtree.h tree.h: create HTML document in
+	  the SAX startDocument() callback.
+	* TODO: updated
+
+Thu Jun 29 12:06:48 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* added xmlStopParser()
+
+Wed Jun 28 23:10:26 MEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* configure.in: 2.1.0 prerelease
+	* Large resync between W3C and Gnome tree
+	* nanoftp, nanohttp.c: fixed stalled connections probs
+	* HTMLtree.c SAX.c : support for attribute without values in
+	  HTML for andersca
+	* valid.c: Fixed most validation + namespace problems
+	* HTMLparser.c: start document callback for andersca
+	* debugXML.c xpath.c: lots of XPath fixups from Picdar Technology
+	* parser.h, SAX.c: serious speed improvement for large
+	  CDATA blocks
+	* encoding.[ch] xmlIO.[ch]: Improved seriously saving to
+	  different encoding
+	* example/Makefile.am example/gjobread.c tree.h: work on 
+	  libxml1 libxml2 convergence.
+	* config.h.in parser.c xmllint.c: added xmlCheckVersion()
+	  and the LIBXML_TEST_VERSION macro
+
+Fri Jun 23 22:26:07 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* doc/xml.html: various patches and improvements typo fixed by
+	  Felix Natter
+	* doc/libxml-doc.el: Emacs module to lookup the libxml documentation
+	  from Felix Natter <fnatter@gmx.net>
+
+Sat May  6 10:09:45 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* doc/upgrade.html: updated with instructions for support of both
+	  libxml-1.x and libxml-2.x
+	* doc/gjobread.c : applied Todd Dukes <tdukes@ibmoto.com> patch
+	  for 2.x support and also fixed includes
+
+
+Wed May  3 14:21:25 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* encoding.[ch], xmlIO.[ch], parser.c, configure.in : revamped
+	  the encoding support, added iconv support, so now libxml if
+	  compiled with iconv automatically support japanese encodings
+	  among others. Work based on initial patch from Yuan-Chen Cheng
+	  I may have broken binary compat in the encoding handler
+	  registration scheme, but that was so utterly broken I don't
+	  expect anybody to have used this feature until now.
+	* parserInternals.h: fixup on the CHAR range macro
+	* xml-error.h, parser.c: catch URL/URI errors using the uri.c
+	  code.
+	* tree.[ch]: added xmlBufferGrow(), was needed for iconv
+	* uri.c: added xmlParseURI() I can't believe I forgot to
+	  implement this one in 2.0 !!!
+	* SAX.c: moved doc->encoding update in the endDocument() call.
+	* TODO: updated.
+
+Mon Apr 24 13:30:13 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* tree.h: removed extraneous xmlRemoveProp definition
+	* TODO: added item about --disable-corba configure switch
+	* tree.c parser.c: fixed problems for xmlCopyDoc and postvalidation
+	* nanoftp.c: fixed include problems giving troubles on AIX and 
+	  slowlaris
+	* xmlIO.[ch] valid.h tree.[ch] xlink.c xmlmemory.c uri.c 
+	  parser.c nanoftp.c nanohttp.c SAX.c testSAX.c :
+	  comment and headers changes to lower gtk-doc number of warnings
+	* doc/html/*: rebuilt docs
+
+Sun Apr 16 11:23:29 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* HACKING: documented the tag for 1.x and instructions
+
+Wed Apr 12 15:47:22 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* xmlIO.[ch] parser.[ch]: More interfaces for new I/O functions
+	  xmlNewIOInputStream, xmlParserInputBufferCreateIO,
+	  xmlCreateIOParserCtxt
+	* parser.c parserInternals.h: speedup of IS_CHAR like macros,
+	  significant overall improvement
+	* xmllint.c: added I/O test to xmllint
+	* testSAX.c: added a speed test
+	* doc/* : updated/regenerated
+
+Sat Apr  8 14:54:54 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* xpath.c uri.h parserInternals.h: cosmetic changes from
+	  "Timur I. Bakeyev" <timur@bat.ru>, including making 
+	  xmlCreateURI() public
+
+Fri Apr  7 18:35:02 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* xmlIO.[ch] parser.c: cleane up the xmlParserInputBuffer mess
+	  and the code at the same time. Added a clean mechanism for
+	  overload or added input methods: xmlRegisterInputCallbacks()
+	* tree.c: fixed xmlPrevSibling and xmlNextSibling per 
+	  Christophe Le Gal (Christophe.Le-Gal@imag.fr) input
+	* TODO: updated
+	* doc/* : updated/regenerated
+	* doc/Makefile.am: tweaks to avoid problem with libxml link in the
+	  source dir
+
+Wed Apr  5 21:11:35 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* testURI.c: yet another forgotten commit, I should get some sleep !
+
+Wed Apr  5 20:36:46 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* xmllint.c: forgot to commit this too ?
+
+Wed Apr  5 16:22:44 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* xmlversion.h.in : forgot to commit this previously
+
+Mon Apr  3 21:47:10 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* configure.in: preparing libxml-2.0.0 version looks Ok so far
+	* README TODO: updated for release
+	* uri.c uri.h: added authority parsing/saving
+	* uri.c testURI.c Makefile.am: moved the testing code to testURI.c
+	* xmlversion.h.in configure.in nanoftp.[ch] nanohttp.[ch] encoding.h
+	  debugXML.[ch] xpath.[ch] xmlIO.c tester.c testXPath.c testHTML.c
+	  tree.c HTMLtree.c HTMLparser.c tree.c tree.h parser.c
+	  Makefile.am : added compile-time customization of libxml
+	  --with-ftp --with-http --with-html --with-xpath --with-debug
+	  --with-mem-debug
+	* *.[ch] autoconf.sh : moved to an absolute adressing of includes : 
+	  #include <libxml/xxx.h> I hope it won't break too much stuff
+	  and will be manageable in the future...
+	* xmllint.c Makefile.am libxml.spec.in : renamed tester.c to xmllint.c
+	  and added xmllint to the installed programs
+	* uri.h: added xmlFreeURI()
+	  
+Fri Mar 24 14:35:21 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* uri.c uri.h: finished the escaping handling, the base support
+	  and the URI path normalization. Looks good just lacks the
+	  authority content parsing code.
+	* Makefile.am: added instructions to generate testURI
+	* TODO: updated
+	* doc/xml.html, doc/smallfootonly.gif doc/w3c.png: updated,
+	  added links and icons for W3C and Gnome
+
+Mon Mar 20 14:05:26 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* xmlmemory.[ch] : seems I forgot to actually update the files in
+	  the last commit :-)
+	* doc/xml.html doc/html/* : updated and uploaded the docs
+
+Mon Mar 20 12:33:51 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* test/valid/dtds/xhtml*: removed RCS infos (pain with CVS)
+	* TODO: updated
+	* xmlmemory.[ch] : added xmlMemSetup() and xmlMemGet() to override
+	  libxml default allocation function with another set (like gmalloc/
+	  gfree).
+	* Makefile.am, uri.c, uri.h: added a set of functions to do
+	  exact (litteraly copied from the RFC 2396 productions) parsing
+	  and handling of URI. Will be needed for XLink, one XML WFC, 
+	  XML Base and reused in the nano[ftp/http] modules. Still work
+	  to be done.
+
+Tue Mar 14 20:52:35 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* configure.in, libxml.spec.in : libxml2
+	* doc/* : updated the doc page, rebuilt the docs
+
+Tue Mar 14 19:11:29 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* all: tagged LIB_XML_1_X
+	* *.c *.h : updated from W3C CVS tree
+	* configure.in : 2.0.0-beta
+	* libxml.spec.in : libxml2 package nam
+	* result/* : new version of the tests output
+
+Mon Mar  6 09:34:52 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* doc/xml.html, doc/update.html: updated docs, 1.8.7
+
+Sat Mar  4 16:14:42 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* doc/* : rebuilt the docs
+	* parser.c: final patch on #6766
+	* valid.c: small patch on validity checks.
+
+Sat Mar  4 12:38:41 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* doc/upgrade.html: instruction on how to upgrade from 1.x to 2.x
+	  added
+	* parser.c: adding xmlKeepBlanksDefault() as a way to manage
+	  compatibility w.r.t. XML spec and existing code.
+
+Thu Mar  2 04:45:15 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.c: seems a better solution to <a>   </a> exists,
+	  will try it for a while
+
+Thu Mar  2 02:26:13 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.c: tried to remove the <a>   </a> generating <a/>
+	  this is hard. Left a flag for that purpose. Fixed bug #6766
+	* configure.in: prepared 1.8.7 not released, due to previous
+	  problem
+
+Thu Mar  2 03:03:50 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* doc/xml.html : applied second patch from Paul DuBois
+
+Tue Feb 29 23:55:13 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* doc/xml.html : applied patch from Paul DuBois
+
+Thu Feb  3 16:36:39 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.c HTMLparser.c: do a bit of bufferization in push mode.
+
+Thu Feb  3 15:59:37 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* nanoftp.c nanohttp.c tree.c HTMLtree.[ch] debugXML.c xpath.c: Fixed
+	  compilation warnings on various platforms.
+	* parser.c: Fixed #5281 validity error callbacks are now desactived
+	  by default if not validating.
+
+Thu Feb  3 13:46:14 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* nanoftp.c, win32config.h.in: patches to compile on WIN32
+
+Wed Feb  2 22:51:16 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* nanoftp.c: snprintf/sprintf patch courtesy George Katsirelos
+	  <gkatsi@cs.toronto.edu>
+
+Mon Jan 31 18:58:21 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* nanoftp.c nanohttp.c: Fixed '#' and '?' stripping when
+	  processing URLs
+
+Mon Jan 31 14:25:57 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* nanoftp.[ch]: cleanup, bug fixes, integration in rpmfind, added
+	  xmlNanoFTPUpdateURL for persistent control connections.
+	* configure.in: 1.8.6
+
+Thu Jan 27 17:52:29 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* nanohttp.[ch], nanoftp.[ch]: cleanup, added proxy support
+	* tree.[ch] : added xmlSaveNoEmptyTags
+
+2000-01-29  James Henstridge <james@daa.com.au>
+
+	* nanoftp.c: include <netinet/in.h> for IPPROTO_TCP.
+
+	* Makefile.am: added nanoftp.[ch] to the build.
+
+Wed Jan 26 18:14:55 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* nanoftp.[ch]: cleanup, comments, API
+	* debugXML.c : fixed a bug in the cat command
+	* doc/*: regenerated the docs
+
+Wed Jan 26 16:52:50 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* nanoftp.[ch] parser.c xmlIO.[ch]: added a Nano FTP implementation
+	* debugXML.c : fixed a bug in the cat command
+	* valid.c: fixing some small probs
+	* libxml.spec.in: get rid of the SNAP suffix
+	* doc/xml.html: updated the status
+
+Mon Jan 24 14:31:09 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* xml-config.in: xml-config --version to just return the
+	  version number
+	* xpath.c: some cleanup w.r.t. axis when the current node is
+	  an attribute.
+	* TODO: updated
+
+Tue Jan 18 18:46:06 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* configure.in: prepared for libxml-1.8.5
+	* doc/* recompiled the documentation
+
+2000-01-17  Jody Goldberg <jgoldberg@home.com>
+
+	* configure.in : WARNING autoconf subtlety alert :
+	  Use AC_CHECK_HEADERS rather than AC_CHECK_HEADER
+	  when looking for zlib.h so that HAVE_ZLIB_H is defined.
+	* config.h.in : Have a #undef for HAVE_ZLIB_H so that it will
+	  get defined by AC_CHECK_HEADERS.
+
+Mon Jan 17 17:04:12 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* tree.c: fixed a hideous bug in xmlGetProp() thanks to
+	  Rune.Djurhuus@fast.no
+
+Sat Jan 15 15:09:06 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* TODO: updated
+	* tree.c, parser.c: made sure that only memory alloc problems
+	  and internal parser errors are allowed to write to stdout or
+	  stderr.
+
+Thu Jan 13 11:49:11 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* tree.c : restored xmlNewGlobalNs since this seems used by
+	  a lot of existing code :-(, fixed a bug in xmlNewNs
+	* nanohttp.c: fixed a problem with INCLUDE_WINSOCK
+	* HTMLparser.c, parser.c, entities.c, valid.c : removed all calls
+	  to exit() from the library code.
+	* xpath.c, parser.c: removed bugs or unused code detected by 
+	  Windows compilers
+	* parser.c: started adding interfaces for parsing well balanced
+	  XML fragments
+	* configure.in: releasing 1.8.4
+	* doc/* : rebuilt the docs
+
+Sun Jan  9 23:03:20 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* tree.[ch] : added xmlNewDocFragment() for DOM
+	* testHTML.c: uninitialized variable.
+
+Wed Jan  5 17:29:17 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* doc/* : rebuild the docs
+
+Wed Jan  5 17:08:43 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* acconfig.h: readline and history patch
+	* valid.[ch]: added xmlRemoveID() and xmlRemoveRef()
+	* tree.c: added check and handling when possibly removing an ID
+	* tree.c, HTMLparser.h, HTMLtree.h: fixed entities parsing
+	     and saving.
+	* test/HTML/entities.html result/HTML/entities.html* : test for
+	     various entities reference cases
+	* result/HTML/* : as a result output of some testcase have
+	     changed
+	* HTMLparser.c, parser.c: fixed a bug in the push mode triggered
+	     by previous example. added xmlParseTryOrFinish().
+	* xpath.h tree.h parser.h valid.h xmlIO.h xlink.h encoding.h
+	  entities.h debugXML.h HTMLparser.h: changed the way struct are 
+	  declared to allow gtk-doc to expose those
+	* parser.c: closed bug #4960  
+	* Makefile.am configure.in: Applied patch from 
+	  Albert Chin-A-Young <china@thewrittenword.com> for better zlib
+	  and math/socket libs detection
+
+Mon Jan  3 18:29:43 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* configure.in, Makefile.am: link tester against readline
+	* doc/xml.html doc/*/*: updated and rebuilt the documentation pages
+
+Mon Jan  3 11:58:05 CET 2000 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* tree.[ch]: added xmlRemoveProp
+	* win32config.h.in nanohttp.c: avoid including the Windows
+	    socket stuff in every C files
+	* parser.c: removed an indetermination xmLDecl/PI(xml...) in
+	    the XmL parser(s)
+	* test/ns4 result/ns4 etc...: added test case for previous prob    
+	* tree.c: xmlNewNs wasn't checking for double definition
+	* Makefile.in: fixed a problem with dist-hook duplicates
+	* parser.[hc], xmlIO.c: fixed the loading of external entities
+	    APIs, now xmlLoadExternalEntity() is used everywhere and
+	    setting up an app specific front-end using the 
+	* SAX.c parser.c: some fixes, now the xhtml spec validates
+	    with the xhtml DTD.
+	* error.c: fixed crashes in case of no input stream    
+	* test/valid/[dtds/]/xhtml* : added the xhtml spec and dtds
+	    to the validation tests and results
+
+Wed Dec 29 15:29:52 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* HTMLparser.[ch] testHTML.c: added push mode for the HTML parser
+	  too htmlCreatePushParserCtxt() and htmlParseChunk()
+	* parser.c: a bit of cleanup.
+	* SAX.c, HTMLparser.c: some attributes may not have values (contrary
+	  to XML) removed the last mem leak known
+	* HTMLtree.c: output message cleanup
+	* xmlmemory.c: display content info about memory blocks
+	* result/HTML/wired.* : missing att value warning change
+
+Tue Dec 28 17:42:41 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* doc/* : rebuilt the documentation
+
+Tue Dec 28 18:44:22 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.[ch] parserInternals.h: Push parser for XML,
+	     seems to work fine now
+	* tester.c debugXML.[ch]: Added an XML shell debug facility and
+	     --push for push testing
+	* xpath.[ch] : cleaned up for Shell usage, added missing APIs
+	* testSAX.c: added --push
+	* HTMLtree.[ch] tree.[ch]: new functions for dumping parts of the
+	     subtree
+	* xmlIO.[ch] : enriched API + fixes for push mode     
+	* entities.[ch]: added the entity content length to the struct.
+	* xmlmemory.[ch]: new API to show the last entries for the shell
+	* valid.c: added required attribute testing
+	* SAX.c: the cdata callback now merge contiguous fragments
+	* HTMLparser.c: cleanup of some macros
+
+Wed Dec 22 12:20:53 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.c: fix for PIs name starting with xml
+	* tree.c: fixed a potential problem with || and && ops
+	* *.c, configure.in win32config.h.in : generate win32config.h for
+	  those on the Other Side !
+
+Tue Dec 21 17:22:17 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.c: fixed a stupid = vs. == bug :-(
+	* doc/gnome-xml.sgml: s/glade/xml/
+
+Tue Dec 21 14:29:34 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* configure.in, doc/xml.html : bug fix release 1.8.2
+	* debugXML.h nanohttp.h xml-error.h xmlmemory.h xpath.h : 
+	  Hopefully the end of that silly C++ include problem
+	* tree.[ch]: Added a few functions: xmlReplaceNode, xmlAddPrevSibling,
+	      xmlAddNextSibling, xmlNodeSetName and xmlDocSetRootElement
+	* HTMLparser.c HTMLparser.h HTMLtree.c: When saving HTML try to avoid 
+	      troubles with autoclosed elements when the stree shape doesn't
+	      follow the DtD specs. Added htmlIsAutoClosed() and
+	      htmlAutoCloseTag()
+	* result/HTML/*.htm*: Updated the HTML examples regression tests output
+	* SAX.c tree.c: fixed bug on defaulting namespaces on attributes
+	* debugXML.c: fixed a bug on printing default namespaces.
+	* HTMLtree.c: fixed a problem when outputing XML parsed docs as HTML
+
+Mon Dec 20 16:20:55 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* result/HTML/*.htm[l] : updated the HTML regression tests according
+	  to the new output
+	* xpath.h xml-error.h valid.h tree.h parser.h entities.h SAX.h
+	  HTMLtree.h tree.c entities.c: headers tweakings to avoid a nasty
+	  problem due to intermix of extern "C" { ... } declarations for C++
+	  and recursive includes in the headers
+
+1999-12-20  Chris Lahey  <clahey@umich.edu>
+
+	* HTMLtree.c: Made it so that html nodes with a single child do
+	not insert a carriage return before or after the child node.
+
+Sat Dec 18 16:07:03 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* configure.in, doc/xml.html : bug fix release 1.8.1
+	* parser.c: fixed bug #4344
+	* xpath.h xml-error.h xlink.h nanohttp.h debugXML.h SAX.h HTMLparser.h
+	  added the glue to avoid C++ problems
+	* doc/* : regenerated the documentation
+
+Thu Dec 16 16:19:29 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* tree.c: fixed a bug introduced in 1.8.0 and breaking default
+	  namespace recognition, and Dia as a resul :-(
+	* encoding.c: closed bug #3950
+
+Wed Dec 15 19:22:23 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* valid.c: debugging a posteriori validation, except URI expansion
+	  stuff this should be fixed now
+	* parserInternals.h: fixed a bug in IS_BASECHAR reported by
+	  Carl Nygard <cnygard@bellatlantic.net>
+	* tester.c: added --postvalid, cleaning of the code
+	* tree.[ch]: added xmlDocGetRootElement()
+	  
+Tue Dec 14 20:30:34 PST 1999 Ramiro Estrugo <ramiro@eazel.com>
+
+	* SAX.h, tree.h : changed 'namespace' to 'nameSpace' to workaround
+	c++ losage.
+
+Sun Dec 12 13:08:15 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* configure.in, doc/xml.html : bumped to 1.8.0
+	* xlink.[ch], Makefile.am : added framework for link detection
+	* parser.h: added nbChars to parser context, needed for cleanup.
+	* xmlmemory.c: removed a nasty bug when out of mem
+	* valid.[ch]: adding namespace support for attribute decl
+	* tester.c: added --debugent option
+	* debugXML.[ch]: added xmlDebugDumpEntities()
+	* parser.c: cleanup, avoiding use of CUR_PTR like plague, using
+	  buffers instead, this was really needed, validation was breaking
+	  in strange ways due to that. Added xmlParseStringPEReference()
+	  and other parsing from strings functions. Entities processing
+	  modified again, but PERef are still not handled correcly but
+	  unless you're Eve Maller you won't notice :-)
+	* HTMLparser.c: large changes toward reliability, and switched to
+	  lowercase internal tags, XHTML is lowercase, so it will help
+	  that output is closer to next version.
+	* doc/* : regenerated the documentation, it is now hosted at
+	  http://xmlsoft.org/ (same bits I just bought the domain :-)
+	
+	
+Fri Dec  3 13:46:32 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* SAX.h, SAX.c, makefile.am: added SAX.h mostly useful for the
+	         doc generation
+	* parser.c: fixed bugs #3908 and #3937 and a memory leak
+	         in the SAX API
+	* doc/*: rebuilt the doc making sure everything appears in the
+	         HTML files
+
+Wed Dec  1 10:27:47 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* tree.[ch] HTMLtree.c, debugXML.c, configure.in, xml-config.in:
+	     added the patch from Carl Nygard <cnygard@bellatlantic.net>
+	     which allow impressive speed improvement on dataset with
+	     large text pieces, but at the cost of broken binary
+	     compatibility and slightly bigger memory usage.
+	     Configure with --with-buffers to activate them, they
+	     are protected with XML_USE_BUFFER_CONTENT define.
+	* entities.[ch], parser.c: added xmlCleanupPredefinedEntities(),
+	     goal is 0 memory left allocated once parser is no more used
+	* testDAV.c, testHTML.c, testSAX.c, testXPath.c: make sure we
+	     call xmlCleanupParser() and xmlMemoryDump()
+
+Wed Nov 24 19:00:06 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* tree.[ch] xmlIO.[ch] parser.c valid.c: code cleanup with -pedantic
+	* parser.[ch] encoding.[ch]: added memory cleanup routines
+	* parser.c: closing bug #3788
+	* doc/*: rebuilt the doc
+
+Tue Nov 23 11:23:55 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* tree.[ch]: closing bug 3748, added xmlNewDocRawNode(), 
+	             xmlNewTextChild() and xmlSetCompressMode() behaviour.
+	* tester.c: added --compress option
+	* doc/*: rebuilt the documentation
+
+Fri Nov 19 18:41:28 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* HTMLparser.c: bugfixing, the damn thing MUST not crash even
+	                if given /proc/kcore as input !
+	* doc/xml.html doc/*: updated and rebuilt the documentation
+
+Thu Nov 18 14:57:18 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.c: Fixed some wrongly space collapsing code due to
+	            a misreading of the spec.
+	* result/*: fixed the output accordingly	    
+
+Wed Nov 17 18:28:06 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* encoding.c: bug fix and typos
+	* xmlIO.[ch] parser.c: first bits toward real progressive parsing
+	* parser.c: added attribute normalization closing bug #3597
+	* test/att* result/att* SAXresult/att*: testcase for attribute
+	    normalization
+
+Mon Nov 15 18:50:56 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* configure.in: closing bug #3163 by adding extra flags for the
+	                cc compiler on HP-UX
+
+Fri Nov 12 17:41:20 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* valid.[ch] : removed a typo and an enumerated type bug in the
+	               xmlAddElementDecl() function
+	* tree.c : I changed xmlSetProp() and xmlNewProp() to do the
+	    call to xmlEncodeEntitiesReentrant() so that the functions 
+	    New, Set and Get are at the same level.
+	* parser.c HTMLparser.c: extra memory allocation bug for
+	    attributes detected by someone using libxml in embedded systems :-)
+
+Thu Oct 28 17:49:26 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* xmlmemory.h: turned off mem debug :-\
+
+Mon Oct 25 12:13:25 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.c: closed bug #2784 a one line fix, but worth pushing
+	            a new release out
+        * HTMLparser.c: fixed auto-close bugs on list items, zeroing
+	            some structures, comments before and after the
+		    main element, and other nastyness
+	* HTMLtree.c tree.c: accomodate the extended HTML supported	    
+	* configure.in: pushing 1.7.4
+	* test/ent8 and related outputs : added a new test for bug #2784
+	* test/HTML/wired.html and related output: a nasty HTML example
+	* Makefile.am: improved the test scripts
+	* docs/* : reran the documentation extractor, updated xml.html
+
+Thu Oct 14 10:29:56 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* HTMLparser.c, HTMLtree.c, tree.h: completely revamped the
+	     HTMLparser and debugged the HTML related code. HTML documents
+	     now have their own type
+	* entities.c: do not dump &apos; for HTML output
+	* xmlmemory.c: improvement, breakpoint mechanism
+	* testHTML.c: added --sax --repeat ...
+	* Makefile.am: improved the HTML tests
+	* valid.[ch]: added xmlValidGetValidElements and
+	              xmlValidGetPotentialChildren
+	* tester.c: added --insert to test the 2 new functions
+	* test//* result//* SAXresult//* : regression test cleanup
+	               and extension.
+	* doc/html : added doc for new modules gnome-xml-xmlmemory.html and
+	             gnome-xml-nanohttp.html
+
+Mon Oct 11 14:31:58 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* HTMLparser.c: fixed problems with some autoclose tags
+	* tree.c: fixed XML output problems. 
+	* result/* SAXresult/*: update of the tests output
+
+Sat Oct  9 11:02:57 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* Makefile.am: Arturo patch for xmlConf.sh version info
+	* parser.c: Tim Josling patch for single quoted items
+	* tester.c: Tim Josling patch for tester options usage
+	* tree.h: indent cleanup
+
+Fri Oct  8 16:35:37 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* HTMLparser.c parser.h : Fixed problems with HTML parsing
+	    reported by Kristian Hogsberg Kristensen <hogsberg@daimi.au.dk>
+
+Fri Oct  8 11:37:11 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* tree.c : Raph patch for initialization of CORBA fields
+	* parser.c, xpath.c, ...: modification of doc comments
+	* xpath.c : allow spaces in xpath expressions
+
+Mon Sep 27 10:16:43 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* xmlmemory.h: turning off memory debug :-(
+
+Sun Sep 26 13:16:54 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.[ch] : added xmlSAXUserParseFile() and xmlSAXUserParseMemory()
+	                better SAX interfaces.
+	* testSAX.c: uses the new SAX routine, avoid fetching any remote
+	             entity.
+	* configure.in: 1.7.2
+
+Fri Sep 24 16:01:01 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* libxml.spec.in: fixed the URL
+	* doc/xml.html: improved the documentation front-end
+
+Fri Sep 24 01:06:36 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* nanohttp.c: conditionned references to snprintf with HAVE_SNPRINTF
+
+Fri Sep 24 00:15:58 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* libxml.spec.in: fixed the alpha compile problem
+	* parser.[ch]: changed errno to errNo in the parser context :-(
+	* *.[ch]: changed CHAR to xmlChar to avoid problem on WIN32
+	* doc/xml.html: changed CHAR to xmlChar
+	* doc/html/*: recompiled the documentation
+	* configure.in: 1.7.1
+
+Wed Sep 22 11:40:31 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.h: modified the parser context struct to regain 1.4.0
+	            binary compatibility
+	* parser.c, xml-error.h: added errno ot teh context and defined
+	            a set of errors values with update of errno
+	* nanohttp.[ch]: minimalist HTTP front-end for fetching remote
+	            DTDs and entities
+	* *.h, *.c: complete cleanup of the use of config.h and include
+	            protection depending on the current setup.
+	* overalll debugging, maintenance and bug-fixing on all modules
+	* updated the documentation
+	* ready for 1.7.0
+
+Wed Sep  8 22:46:14 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* HTMLparser.c : cleanup
+	* SAX.c valid.c valid.h: added ID/IDREF checking
+	* tree.c tree.h: extended doc structure for refs
+	* configure.in: 1.6.2
+	* parser.c: patched bug in SAX user arg call
+	* parserInternals.h: patched missing close in C++ wrapping
+	* testXPath.c xpath.c xpath.h: prepared for extensibility,
+	  especially upcoming XPointer implementation.
+	* doc/xml.html: augmented, typo
+
+Sat Sep  4 22:48:05 CEST 1999 Timur Bakeyev <mc@bat.ru>
+
+	* doc/Makefile.am: replaced "install -d " with "mkinstalldirs" -
+	not all invocations of install understand -d.
+
+Sat Sep  4 22:20:07 CEST 1999 Timur Bakeyev <mc@bat.ru>
+
+	* Makefile.am: prepend all the test* calls with $(top_builddir) -
+	to make 'check' works, when builddir != srcdir.
+
+Sat Sep  4 20:25:46 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* doc/xml.html : updated the documentation
+
+Fri Sep  3 00:01:08 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* xmlmemory.[ch] Makefile.am  :added a memory wrapper to chase
+	      not deallocated memory blocks
+	* *.c : replaces all calls to malloc() free() and realloc() to
+	      the wrapper functions/macros
+	* tree.c : removed memory leaks dues to calling xmlFreeNode()
+	      instead of xmlFreeNodeList()
+
+Wed Sep  1 14:15:09 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* HTMLparser.c: corrected a stupid bug leading to core dump at
+	                tree deallocation. Removed warnings indicated by
+			Stephane.Conversy@lri.fr
+	* entities.c: Fixes Yet Another Stupid Bug, entities were not
+	              looked for in the external subset
+
+Mon Aug 30 13:22:26 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.c valid.[ch] xpath.c: patched compilation warnings reported
+	  on SGI by Stephane.Conversy@lri.fr
+
+Sun Aug 29 22:27:29 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* all .h : changed the prototype declaration indent as in gtk
+	* most .c : working on reducing the TODOs in the code
+	* most .c : cleanup though -pedantic and Insure++
+	* improvements on validation ID checkings.
+	* tree.[ch] SAX.c: added support for namespace on attributes #2022
+	* xml-config.in: closed #1810
+
+Mon Aug 16 03:27:38 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* tree.h, valid.c, valid.h: more work on validity, IDs
+	* xpath.c: added/fixed comparidon and equlity, added a new isinf
+	  definition for AIX
+
+Sun Aug 15 21:15:17 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* Makefile.am libxml.spec.in: corrected missing xmlConf.sh in
+	  the distribution due to a cut'n paste error at last commit
+
+Tue Aug 10 20:28:09 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* configure.in: upgraded to version 1.4.0
+	* valid.[ch], SAX.c, parser.[ch] parserInternals.h ...
+	  Big update, added a large part of the validation process,
+	  it should be usable, but some parts are missing
+	* xpath.c: improved the implementation w.r.t. root.
+	* Makefile.am: added more tests
+	* test and result trees: added a lot of tests
+	* libxml.spec.in: export libxml.so.0 and libxml.so.1
+
+Tue Aug 10 11:33:41 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* Added an HACKING file
+
+Tue Jul 27 21:43:00 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+        * xpath.[ch] : improvements and debug of the XPath implementation
+        * parser.c, HTMLparser.c : modified the parsers to be progressive
+	* tree.[ch] : extended the Buffer promitives
+	* xmlIO.[ch] : added basic I/O routines providing progressive
+	  parsing and ready for I18N conversion plugins
+	* SAXresult/* : the SAX callback sequence maybe slightly different
+	  now
+	* test*.c : improved/updated the tests programs
+	* doc/* : recompiled the docs.
+
+1999-07-26  Michael Meeks  <michael@edenproject.org>
+
+	* tree.h: Add const to 'content' in xmlNewDocNode, xmlNewChild
+
+	* tree.c: Ditto.
+
+Thu Jul 15 16:17:16 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* configure.in: upgraded to version 1.4.0
+	* xpath.c, xpath.h, testXPath.c, makefile.am: added code for the XPath
+	  draft from W3C. Will be used by XPointer, Xlink, XSL, and possibly
+	  XML query language, see http://www.w3.org/TR/xpath for more details.
+	* parser.c, parser.h: added CHAR* related string functions for XPath
+	* HTMLparser.[ch], HTMLtree.c: a bit of cleanup on entities.
+	* doc/gnome-xml.sgml, doc/html/* : added XPath and HTML documentation,
+	  rebuild the docs.
+	* Makefile.am, test/XPath/*, result/XPath/*: added an XPathtests target
+	  and regression testing capabilities for XPath.
+
+Mon Jul 12 12:36:39 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.c, HTMLparser.c: applied patch from John Ellson <ellson@lucent.com>
+	  closing bug #1646
+
+Mon Jul 12 11:04:44 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* Makefile.am, example/Makefile.am: closed bug #1683
+
+Sun Jul 11 18:16:34 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* example/Makefile.am, configure.in: added the makefile for the
+	  gjobread example
+
+Sat Jul 10 14:19:11 CEST 1999 Tomasz K³oczko  <kloczek@pld.org.pl>
+
+        * doc/Makefile.am:
+        - fix which allow "make install DESTDIR=</install/prefix>".
+
+Fri Jul  9 12:10:24 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* HTMLparser.c parser.c: applied patch from John Ellson <ellson@lucent.com>
+	  which fixed a problem on the file reading-code.
+
+Wed Jul  7 09:28:43 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* HTMLparser.[ch], HTMLtree.[ch]: more work for HTML parsing and
+	  output.
+        * Makefile.am, test/HTML/*, result/HTML/*: added HTMLtests targetestHTMLt
+
+Wed Jul  7 00:25:42 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.h : Oops removed the binary compatibility problem
+	* HTMLparser.[ch], HTMLtree.h : More work on the HTML parse/dump
+	* parser.c, HTMLparser.c: applied patches for reading from stdin
+
+Mon Jul  5 18:45:31 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.c, entities.c, valid.c: cleanup bug #1591
+	* configure.in: cleanup bug #1592
+	* HTMLparser.[ch], testHTML.c: started adding an HTML parser using
+	  the same tree back-end. Hence gdome will be available for it.
+	* doc/Makefile.am: close bug #617
+
+Sat Jun 26 23:36:38 EDT 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.c: alloctate a per parser context SAX interface block
+
+Tue Jun 22 23:46:32 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* released 1.3.0 with xmlEncodeEntities restoring old behaviour
+	  and xmlEncodeEntitiesReentrant with the correct one :-\
+
+Mon Jun 21 14:07:53 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* commit of my internal XML base changes, quite a lot of
+	  changes, cleanups, better entities support, framework for
+	  new I/O and charset detection and handling
+	* Fixed the configure/Makefile stuff to generate shared libs
+	  with the proper version info, so we jumped on rev from
+	  0.0.0 to 1.2.0 ! The binary interfaces have been broken,
+	  xmlEncodeEntities() result need to be freed now, and a string
+	  xmlParserVersion provide the current library version.
+
+Tue Jun 15 14:24:19 1999  Raph Levien  <raph@acm.org>
+
+	* parser.c: fixed a buffer overrun for when you have a very long
+	attribute with no entities in it.
+
+Mon Jun 14 00:17:50 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* added example directory
+	* added example/gjobs.xml gjobread.c, still need a Makefile.in
+
+Wed Jun  2 19:40:58 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* Release of libxml-1.1, nearly everything has been touched for
+	  this.
+	* Added more regression tests
+	* Updated the documentation
+
+Sat May 29 13:34:42 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* tree.[ch]: unified the XML_NO_CORBA defines.
+	* parser.c encoding.[ch]: started plugging in char encoding detection
+
+Fri May 28 22:58:42 EDT 1999 Manish Vachharajani <mvachhar@vger.rutgers.edu>
+
+	* tree.c: (xmlSaveFile) - removed double call of xmlContentDump.  
+	  Also freed allocated buffer.
+
+Wed Apr 21 22:07:35 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+	* parser.[ch] tree.[ch] entities.[ch] valid.[ch] : removed the main
+	  reentrancy problem at printing. One is left in entities.c, to
+	  remove ASAP
+	* testSAX.c : added a test example showing the use of the SAX 
+	  interface if one doesn't want to build the DOM tree.
+	* html/gnome-xml-*.html html/index.sgml: regenerated the documentation
+
+Mon Apr  5 14:14:40 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.[ch] tree.[ch] SAX.c, parserInternals.h valid.[ch]:
+	  large revamping of the parser to use SAX callbacks
+	  http://www.megginson.com/SAX/ (or at least a C like interface
+	  a la Expat). It's now possible to set up your own callbacks
+	  and the parser will not build a DOM tree.
+	* test/* result/*: updated the test suite, I finally removed
+	  the old Namespace draft support (PI based).
+
+Fri Apr  2 17:57:32 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* Makefile.am: added test result to EXTRA_DIST for make tests
+
+Wed Mar 24 21:37:02 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.c, parserInternals.h: moved the chars macro definitions
+	  to parserInternals.h
+	* parser.c, error.c: applied patches from "Knut Åkesson"
+	  <ka@s2.chalmers.se> for clean compilation under MSVC 6 :-o
+
+Tue Mar 23 11:10:15 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* xml-config.in : applied patch to make --version work
+
+1999-03-05  Raja R Harinath  <harinath@cs.umn.edu>
+
+	* Makefile.am (check-local): Alias for `tests' target.  This will
+	cause `make check' to do the right thing.
+	(tests): Don't run tests in srcdir.  Also, replaced calls to
+	basename with a `sed' "equivalent".
+
+Fri Mar  5 07:23:53 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* Renamed error.h to xml-error.h, corrected Makefile.am to list
+	  it in the header and not the sources, updated the doc.
+	  Thanks to Tim Mooney <mooney@dogbert.cc.ndsu.nodak.edu> for
+	  pointing this out.
+
+Mon Mar  1 13:27:17 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.c, parser.h, parserInternals.h: memory leak hunting,
+	  exported the inputStream routines.
+	* doc/html/* : updated accordingly
+
+Sun Feb 28 22:51:33 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.c, parser.h, parserInternals.h: added a few extra
+	  internal calls to allocate and free parser contexts ...
+	* doc/html/* : updated accordingly
+
+Thu Feb 25 11:52:24 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* configure.in, Makefile.am, doc/makefile.am : General changes for
+	  1.0.0 release and including the generated HTML documentation.
+
+Thu Feb 25 09:44:52 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* makefile.am : added parserInternals.h, oops.
+
+Mon Feb 22 11:24:56 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parserInternals.h: added this header giving access to the parser
+	  internal functions.
+	* doc/Makefile.am : added a rebuild target which rebuilds the full
+	  set of documentations
+	* parser.[ch] tree.[ch] valid.[ch]: serious updates w.r.t. parsing
+	  the internal subset. 
+	* *.c *.h: modifications needed to generate the documentation using
+	  gtk-doc, cleanup of functions blocks, reorganisation of struct
+	  declarations.
+
+Tue Feb 16 17:27:29 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* Makefile.am, spec, doc/Makefile.am : upgrading to 0.99.8, fixing
+	  the tar and spec file to include the beginning of the doc.
+
+1999-02-13  Nuno Ferreira  <nmrf@rnl.ist.utl.pt>
+
+	* doc/.cvsignore: Added this file.
+
+Mon Feb  8 19:27:56 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* tree.c: fixed xmlGetProp to return "" when the attribute
+	  exists, even if the node-list is NULL.
+
+Mon Feb  8 16:10:15 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* tree.c: patched an error outputting empty attribute values.
+	* Makefile.am and doc/makefile.am: have been updated during the
+	  week-end. Sorry for an empty CVS log, I got a shell problem.
+
+Mon Feb  1 12:10:13 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* tree.h: cleaned up using enums instead of defines
+	* parser.c, valid.[ch]: more work on parsing/output of element
+	  declarations
+
+Sun Jan 31 22:06:48 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* valid.[ch], tree.c, parser.c : more work toward full parsing
+	  of XML DTDs.
+	* README: added informations about mailing-list and on-line
+	  documentation
+
+1999-01-27  Raja R Harinath  <harinath@cs.umn.edu>
+
+	* configure.in (XML_INCLUDEDIR): Use -I not -L for includes.
+
+Sun Jan 17 20:06:36 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.c, tree.[ch] : more work toward conformance testing,
+	  added a last element to accelerate parsing of very flat structures
+	  started working on internal subset Element content declaration.
+	* valid.[ch] : first cut at adding code toward validation.
+	* previous changes had also small impact on most files, especially
+	  the conformance testing using James Clark test suite.
+
+Sun Jan 17 14:45:06 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* test/* : updated the examples, most of them were not well
+	           formed (humm), and added rdf2.
+	* result/* : resulting changes in the output.
+
+Sun Dec  6 13:06:58 EST 1998 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* tree.c: changed the behaviour of xmlGetProp on NULL values.
+
+Sat Dec  5 12:25:09 EST 1998 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* tree.c: patched a bug in the generation of empty attributes
+
+Fri Nov 27 01:36:54 EST 1998 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* entities.[ch], tree.[ch], tester.c: added copy interfaces
+	  for node/trees/documents/... Biggest problem is namespace
+	  support when copying subtrees.
+
+Sun Nov 15 19:59:47 EST 1998 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.c, entities.c: improve entities and char ref encoding,
+	  and cleanups of error messages.
+
+Fri Nov 13 13:03:10 EST 1998 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.c, entities.c: simple bug hunting done during rpm2html and
+	  rpmfind integration.
+
+Sun Nov  8 13:11:07 EST 1998 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.[ch]: Added interfaces allowing to specify a SAX
+	  handler before parsing.
+
+Sun Nov  8 09:39:17 EST 1998 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.c: redirrect all errors reporting through the SAX
+	  error function
+
+Wed Nov  4 14:21:54 EST 1998 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* entities.c: rather use HAVE_SNPRINTF and not depend on glib
+	* libtool, tlmain ...: update of the libtool files
+
+1998-11-04  Miguel de Icaza  <miguel@nuclecu.unam.mx>
+
+	* entities.c: Use g_snprintf insteda of snprintf.
+
+Sun Nov  1 14:31:06 EST 1998 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* entities.c, parser.c: debug and cleanup of CharRef handling/saving.
+	  added ent5 test for this purpose.
+	* parser.c, parser.h: formatting, comments and UTF-8 planning.
+
+Fri Oct 30 01:36:52 EST 1998 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.c: fixed? a strange error due to compression on a GWP
+	  document.
+
+Thu Oct 29 00:48:45 EST 1998 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* tree.[ch]: bug fixing
+	* entities.[ch]: defined a specific type for predefined entities
+	* doc/xml.html: more documentation on the library, how to use it,
+	  overview of the interfaces.
+
+Wed Oct 28 17:56:35 EST 1998 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* tree.[ch]: more cleanup on the API, made the tree mor conformant.
+
+Tue Oct 27 17:54:00 EST 1998 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* tree.c: corrected a small bug
+	* doc/xml.html: continuing writing documentation.
+
+Tue Oct 27 17:54:00 EST 1998 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* debugXML.h debugXML.c: added debugging utilities.
+	* tester.c: added --debug switch.
+	* tree.c: patched an incorrect node->type assignment.
+	* parser.c: formatting, ensure that node->doc != NULL in attributes
+
+Tue Oct 27 01:15:39 EST 1998 Daniel Veillard <Daniel.Veillard@w3.org>
+
+        * parser.[ch] SAX.c tree.[ch]: large amount of changes to improve
+          entity support and provide an internal representation close to
+          DOM one (entity ref nodes, and attribute value as tree). I tried
+          to preserve the interface but this will surely break some apps
+          (I have to change rpm2html/rpmfind for example). I had to change
+	  two interfaces, and the generated tree is somewhat different.
+	* doc/* : started documenting the XML library, the tree and
+	  DOM/Corba. This is a first step.
+
+Sat Oct 24 14:23:51 EDT 1998 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.c: Set up the fonctions comment block, boring but useful.
+	* parser.h, SAX.c, parser.c: now attributes are processed through
+	  the SAX interface. The problem is that my SAX interface diverged
+	  quite a bit from the original one, well this is not an official
+	  spec, and translating it from Java to C is hairy anyway...
+
+Tue Oct 20 02:11:21 EDT 1998 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* SAX.c, entities.c, tree.c, encoding.c, error.c: Set up the
+	  fonctions comment block, boring but useful.
+
+Sun Oct 18 20:40:58 EDT 1998 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* encoding.[ch], Makefile.am: Added the UTF-8, UTF-16 and ISO Latin 1
+	  conversion routines. However they are not yet used to convert the
+	  inputs. The core will run with UTF-8.
+
+Sun Oct 18 15:08:19 EDT 1998 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* tree.c : make sure that the type id is properly set-up when
+	  a new object is allocated, needed for DOM.
+
+Sat Oct 17 02:43:21 EDT 1998 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* tree.h, tree.c: Ok, the main objects in the tree will be native
+	  corba objects, it costs 8 bytes per Node, Attribute and Document
+	  but it simplifies the Corba integration a lot (no extra interface
+	  objects to allocate/free).
+
+Tue Oct 13 21:46:57 EDT 1998 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* tree.h, tree.c, parser.c: added prev and doc pointers to Node,
+	  and changed NODEs contants for conformity with DOM Level 1
+
+Wed Oct  7 23:42:46 EDT 1998 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* added hooks to keep track of servants when creating objects
+	  xmlDoc and xmlNode (for Corba export).
+
+Sun Oct  4 03:18:09 EDT 1998 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* added xml-config script.
+
+Thu Oct  1 16:22:37 EDT 1998 Daniel Veillard <Daniel.Veillard@w3.org>
+
+        * autogen.sh : applied patch from Frederic Devernay <devernay@istar.fr>
+	  to autoupdate libtool and automake conf files.
+
+1998-09-30  Miguel de Icaza  <miguel@nuclecu.unam.mx>
+
+	* Makefile.am: Use '?' to separate the sed
+	commands as ',' is used when people pass -Wl,something.
+
+
+Thu Sep 24 15:13:29 EDT 1998 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* tree.c, tree.h: added a per-document compression interface.
+
+Tue Sep 22 20:47:38 EDT 1998
+
+	* tree.c, tree.h: added saving with compression and added interfaces
+	  to control the compression level (xmlGetCompressMode,
+	  xmlSetCompressMode) and a new save to filename function (xmlSaveFile).
+
+Mon Sep 21 20:11:13 EDT 1998 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* parser.c: corrected a loop for files of size 0
+
+1998-08-20  Raja R Harinath  <harinath@cs.umn.edu>
+
+	* error.h: New file.  Contains prototyes from `error.c'.
+
+Thu Aug 13 19:02:34 1998  Tom Tromey  <tromey@cygnus.com>
+
+	* Makefile.am (xmlincdir): New macro.
+	(xmlinc_HEADERS): Renamed from include_HEADERS.
+
+Thu Aug 13 00:40:14 EDT 1998  Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* applied small patch on numeric entities from
+	  Christopher Blizzard <blizzard@appliedtheory.com>
+
+Wed Aug 12 23:12:58 EDT 1998  Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* New release 0.2, removed the old xml_* files so that it's
+	    coherent with the other CVS base (W3C), far better conformance
+	    to standard, new namespaces, decent entities support, beginning
+	    of a SAX-like interface. Nearly nothing left intact, even the
+	    test examples ...
+
+1998-07-30  Christopher Blizzard  <blizzard@appliedtheory.com>
+
+	* .cvsignore: Add .deps dir
+
+Sun Jul 26 17:29:52 EDT 1998  Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* xml_tree: changed the memory allocation scheme for name in xmlNewNode
+
+Sun Jul 26 00:17:51 EDT 1998  Daniel Veillard <Daniel.Veillard@w3.org>
+
+        * configure.in: added test for CPP
+	* AUTHORS, Changelog: the original ones didn't get commited but the
+	    glib ones instead, fixed.
+	* Makefile.am: corrected an error in library naming
+
+Fri Jul 24 16:47:14 1998  Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* integrated code developped at W3C
+	* changed the original Copyright
+	* migrated to automake
+	* prefixed the filenames by xml_ to avoid filename clashes
+
diff --git a/src/libxml/Copyright b/src/libxml/Copyright
new file mode 100644
index 0000000..417e955
--- /dev/null
+++ b/src/libxml/Copyright
@@ -0,0 +1,27 @@
+Except where otherwise noted in the source code (e.g. the files hash.c,
+list.c and the trio files, which are covered by a similar licence but
+with different Copyright notices) all the files are:
+
+ Copyright (C) 1998-2003 Daniel Veillard.  All Rights Reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is fur-
+nished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FIT-
+NESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+DANIEL VEILLARD BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CON-
+NECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of Daniel Veillard shall not
+be used in advertising or otherwise to promote the sale, use or other deal-
+ings in this Software without prior written authorization from him.
+
diff --git a/src/libxml/INSTALL b/src/libxml/INSTALL
new file mode 100644
index 0000000..1b2e0d0
--- /dev/null
+++ b/src/libxml/INSTALL
@@ -0,0 +1,69 @@
+Extracted from the documentation:
+   http://xmlsoft.org/FAQ.html#Compilatio
+
+Compilation
+
+   1.What is the process to compile libxml ? 
+
+     As most UNIX libraries libxml follows the "standard":
+
+     gunzip -c xxx.tar.gz | tar xvf -
+
+     cd libxml-xxxx
+
+     ./configure --help
+
+     to see the options, then the compilation/installation proper
+
+     ./configure [possible options]
+
+     make
+
+     make install
+
+     At that point you may have to rerun ldconfig or similar utility to
+     update your list of installed shared libs.
+
+     At this point you can check that the library is properly functionning
+     by running
+
+     make tests
+
+   2.What other libraries are needed to compile/install libxml ? 
+
+     Libxml does not requires any other library, the normal C ANSI API
+     should be sufficient (please report any violation to this rule you
+     may find).
+
+     However if found at configuration time libxml will detect and use
+     the following libs:
+
+         libz: a highly portable and available widely compression library 
+             http://www.info-zip.org/pub/infozip/zlib/
+         iconv: a powerful character encoding conversion library. It's
+	     included by default on recent glibc libraries, so it doesn't
+	     need to be installed specifically on linux. It seems it's
+	     now part of the official UNIX specification. Here is one
+	     implementation of the library which source can be found here.
+             http://clisp.cons.org/~haible/packages-libiconv.html
+             ftp://ftp.ilog.fr/pub/Users/haible/gnu/
+
+   3.libxml does not compile with HP-UX's optional ANSI-C compiler 
+
+     this is due to macro limitations. Try to add " -Wp,-H16800 -Ae"
+     to the CFLAGS
+
+     you can also install and use gcc instead or use a precompiled version
+     of libxml, both available from the HP-UX Porting and Archive Centre
+
+   4.make tests fails on some platforms 
+
+     Sometime 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
+
+Daniel
+veillard@redhat.com
+
+$Id: INSTALL,v 1.1 2008/11/12 02:25:23 agibert Exp $
diff --git a/src/libxml/NEWS b/src/libxml/NEWS
new file mode 100644
index 0000000..37c8b35
--- /dev/null
+++ b/src/libxml/NEWS
@@ -0,0 +1,1227 @@
+
+        NEWS file for libxml2
+
+  Note that this is automatically generated from the news webpage at:
+       http://xmlsoft.org/news.html
+
+Items not finished and worked on, get in touch with the list if you want
+to help those   - More testing on RelaxNG
+   - Finishing up XML
+  Schemas
+
+There is the list of public releases:
+2.6.9: Apr 18 2004:
+   - implement xml:id Working Draft, relaxed XPath id() checking
+   - bugfixes: xmlCtxtReset (Brent Hendricks), line number and CDATA (Dave
+    Beckett), Relax-NG compilation (William Brack), Regexp patches (with
+    William), xmlUriEscape (Mark Vakoc), a Relax-NG notAllowed problem (with
+    William), Relax-NG name classes compares (William), XInclude duplicate
+    fallback (William), external DTD encoding detection (William), a DTD
+    validation bug (William), xmlReader Close() fix, recusive extention
+    schemas
+   - improvements: use xmlRead* APIs in test tools (Mark Vakoc), indenting
+    save optimization, better handle IIS broken HTTP redirect  behaviour (Ian
+    Hummel), HTML parser frameset (James Bursa), libxml2-python RPM
+    dependancy, XML Schemas union support (Kasimier Buchcik), warning removal
+    clanup (William), keep ChangeLog compressed when installing from RPMs
+   - documentation: examples and xmlDocDumpMemory docs (John Fleck), new
+    example (load, xpath, modify, save), xmlCatalogDump() comments, 
+   - Windows: Borland C++ builder (Eric Zurcher), work around Microsoft
+    compiler NaN handling bug (Mark Vakoc)
+
+
+2.6.8: Mar 23 2004:
+   - First step of the cleanup of the serialization code and APIs
+   - XML Schemas: mixed content (Adam Dickmeiss), QName handling fixes (Adam
+    Dickmeiss), anyURI for "" (John Belmonte)
+   - Python: Canonicalization C14N support added (Anthony Carrico)
+   - xmlDocCopyNode() extension (William)
+   - Relax-NG: fix when processing XInclude results (William), external
+    reference in interleave (William), missing error on <choice>
+    failure (William), memory leak in schemas datatype facets.
+   - xmlWriter: patch for better DTD support (Alfred Mickautsch)
+   - bug fixes: xmlXPathLangFunction memory leak (Mike Hommey and William
+    Brack), no ID errors if using HTML_PARSE_NOERROR, xmlcatalog fallbacks to
+    URI on SYSTEM lookup failure, XInclude parse flags inheritance (William),
+    XInclude and XPointer fixes for entities (William), XML parser bug
+    reported by Holger Rauch, nanohttp fd leak (William),  regexps char
+    groups '-' handling (William), dictionnary reference counting problems,
+    do not close stderr.
+   - performance patches from Petr Pajas
+   - Documentation fixes: XML_CATALOG_FILES in man pages (Mike Hommey)
+   - compilation and portability fixes: --without-valid, catalog cleanups
+    (Peter Breitenlohner), MingW patch (Roland Schwingel), cross-compilation
+    to Windows (Christophe de Vienne),  --with-html-dir fixup (Julio Merino
+    Vidal), Windows build (Eric Zurcher)
+
+
+2.6.7: Feb 23 2004:
+   - documentation: tutorial updates (John Fleck), benchmark results
+   - xmlWriter: updates and fixes (Alfred Mickautsch, Lucas Brasilino)
+   - XPath optimization (Petr Pajas)
+   - DTD ID handling optimization
+   - bugfixes: xpath number with  > 19 fractional (William Brack), push
+    mode with unescaped '>' characters, fix xmllint --stream --timing, fix
+    xmllint --memory --stream memory usage, xmlAttrSerializeTxtContent
+    handling NULL, trying to fix Relax-NG/Perl interface.
+   - python: 2.3 compatibility, whitespace fixes (Malcolm Tredinnick)
+   - Added relaxng option to xmllint --shell
+
+
+2.6.6: Feb 12 2004:
+   - nanohttp and nanoftp: buffer overflow error on URI parsing (Igor and
+    William) reported by Yuuichi Teranishi
+   - bugfixes: make test and path issues, xmlWriter attribute serialization
+    (William Brack), xmlWriter indentation (William), schemas validation
+    (Eric Haszlakiewicz), XInclude dictionnaries issues (William and Oleg
+    Paraschenko), XInclude empty fallback (William), HTML warnings (William),
+    XPointer in XInclude (William), Python namespace serialization,
+    isolat1ToUTF8 bound error (Alfred Mickautsch), output of parameter
+    entities in internal subset (William), internal subset bug in push mode,
+    <xs:all> fix (Alexey Sarytchev)
+   - Build: fix for automake-1.8 (Alexander Winston), warnings removal
+    (Philip Ludlam), SOCKLEN_T detection fixes (Daniel Richard), fix
+    --with-minimum configuration.
+   - XInclude: allow the 2001 namespace without warning.
+   - Documentation: missing example/index.html (John Fleck), version
+    dependancies (John Fleck)
+   - reader API: structured error reporting (Steve Ball)
+   - Windows compilation: mingw, msys (Mikhail Grushinskiy), function
+    prototype (Cameron Johnson), MSVC6 compiler warnings, _WINSOCKAPI_
+  patch
+   - Parsers: added xmlByteConsumed(ctxt) API to get the byte offest in
+    input.
+
+
+2.6.5: Jan 25 2004:
+   - Bugfixes: dictionnaries for schemas (William Brack), regexp segfault
+    (William), xs:all problem (William), a number of XPointer bugfixes
+    (William), xmllint error go to stderr, DTD validation problem with
+    namespace, memory leak (William), SAX1 cleanup and minimal options fixes
+    (Mark Vadoc), parser context reset on error (Shaun McCance), XPath union
+    evaluation problem (William) , xmlReallocLoc with NULL (Aleksey Sanin),
+    XML Schemas double free (Steve Ball), XInclude with no href, argument
+    callbacks order for XPath callbacks (Frederic Peters)
+   - Documentation: python scripts (William Brack), xslt stylesheets (John
+    Fleck), doc (Sven Zimmerman), I/O example.
+   - Python bindings: fixes (William), enum support (Stéphane Bidoul),
+    structured error reporting (Stéphane Bidoul)
+   - XInclude: various fixes for conformance, problem related to dictionnary
+    references (William & me), recursion (William)
+   - xmlWriter: indentation (Lucas Brasilino), memory leaks (Alfred
+    Mickautsch),
+   - xmlSchemas: normalizedString datatype (John Belmonte)
+   - code cleanup for strings functions (William)
+   - Windows: compiler patches (Mark Vakoc)
+   - Parser optimizations, a few new XPath and dictionnary APIs for future
+    XSLT optimizations.
+
+
+2.6.4: Dec 24 2003:
+   - Windows build fixes (Igor Zlatkovic)
+   - Some serious XInclude problems reported by Oleg Paraschenko and
+   - Unix and Makefile packaging fixes (me, William Brack,
+   - Documentation improvements (John Fleck, William Brack), example fix
+    (Lucas Brasilino)
+   - bugfixes: xmlTextReaderExpand() with xmlReaderWalker, XPath handling of
+    NULL strings (William Brack) , API building reader or parser from
+    filedescriptor should not close it, changed XPath sorting to be stable
+    again (William Brack), xmlGetNodePath() generating '(null)' (William
+    Brack), DTD validation and namespace bug (William Brack), XML Schemas
+    double inclusion behaviour
+
+
+2.6.3: Dec 10 2003:
+   - documentation updates and cleanup (DV, William Brack, John Fleck)
+   - added a repository of examples, examples from Aleksey Sanin, Dodji
+    Seketeli, Alfred Mickautsch
+   - Windows updates: Mark Vakoc, Igor Zlatkovic, Eric Zurcher, Mingw
+    (Kenneth Haley)
+   - Unicode range checking (William Brack)
+   - code cleanup (William Brack)
+   - Python bindings: doc (John Fleck),  bug fixes
+   - UTF-16 cleanup and BOM issues (William Brack)
+   - bug fixes: ID and xmlReader validation, XPath (William Brack),
+    xmlWriter (Alfred Mickautsch), hash.h inclusion problem, HTML parser
+    (James Bursa), attribute defaulting and validation, some serialization
+    cleanups, XML_GET_LINE macro, memory debug when using threads (William
+    Brack), serialization of attributes and entities content, xmlWriter
+    (Daniel Schulman)
+   - XInclude bugfix, new APIs and update to the last version including the
+    namespace change.
+   - XML Schemas improvements: include (Robert Stepanek), import and
+    namespace handling, fixed the regression tests troubles, added examples
+    based on Eric van der Vlist book, regexp fixes
+   - preliminary pattern support for streaming (needed for schemas
+    constraints), added xmlTextReaderPreservePattern() to collect subdocument
+    when streaming.
+   - various fixes in the structured error handling
+
+
+2.6.2: Nov 4 2003:
+   - XPath context unregistration fixes
+   - text node coalescing fixes (Mark Lilback)
+   - API to screate a W3C Schemas from an existing document (Steve Ball)
+   - BeOS patches (Marcin 'Shard' Konicki)
+   - xmlStrVPrintf function added (Aleksey Sanin)
+   - compilation fixes (Mark Vakoc)
+   - stdin parsing fix (William Brack)
+   - a posteriori DTD validation fixes
+   - xmlReader bug fixes: Walker fixes, python bindings
+   - fixed xmlStopParser() to really stop the parser and errors
+   - always generate line numbers when using the new xmlReadxxx
+  functions
+   - added XInclude support to the xmlReader interface
+   - implemented XML_PARSE_NONET parser option
+   - DocBook XSLT processing bug fixed
+   - HTML serialization for <p> elements (William Brack and me)
+   - XPointer failure in XInclude are now handled as resource errors
+   - fixed xmllint --html to use the HTML serializer on output (added
+    --xmlout to implement the previous behaviour of saving it using the XML
+    serializer)
+
+
+2.6.1: Oct 28 2003:
+   - Mostly bugfixes after the big 2.6.0 changes
+   - Unix compilation patches: libxml.m4 (Patrick Welche), warnings cleanup
+    (William Brack)
+   - Windows compilation patches (Joachim Bauch, Stephane Bidoul, Igor
+    Zlatkovic)
+   - xmlWriter bugfix (Alfred Mickautsch)
+   - chvalid.[ch]: couple of fixes from Stephane Bidoul
+   - context reset: error state reset, push parser reset (Graham
+  Bennett)
+   - context reuse: generate errors if file is not readable
+   - defaulted attributes for element coming from internal entities
+    (Stephane Bidoul)
+   - Python: tab and spaces mix (William Brack)
+   - Error handler could crash in DTD validation in 2.6.0
+   - xmlReader: do not use the document or element _private field
+   - testSAX.c: avoid a problem with some PIs (Massimo Morara)
+   - general bug fixes: mandatory encoding in text decl, serializing
+    Document Fragment nodes, xmlSearchNs 2.6.0 problem (Kasimier Buchcik),
+    XPath errors not reported,  slow HTML parsing of large documents.
+
+
+2.6.0: Oct 20 2003:
+   - Major revision release: should be API and ABI compatible but got a lot
+    of change
+   - Increased the library modularity, far more options can be stripped out,
+    a --with-minimum configuration will weight around 160KBytes
+   - Use per parser and per document dictionnary, allocate names and small
+    text nodes from the dictionnary
+   - Switch to a SAX2 like parser rewrote most of the XML parser core,
+    provides namespace resolution and defaulted attributes, minimize memory
+    allocations and copies, namespace checking and specific error handling,
+    immutable buffers, make predefined entities static structures, etc...
+   - rewrote all the error handling in the library, all errors can be
+    intercepted at a structured level, with precise information
+  available.
+   - New simpler and more generic XML and HTML parser APIs, allowing to
+    easilly modify the parsing options and reuse parser context for multiple
+    consecutive documents.
+   - Similar new APIs for the xmlReader, for options and reuse, provided new
+    functions to access content as const strings, use them for Python
+  bindings
+   - a  lot of other smaller API improvements: xmlStrPrintf (Aleksey Sanin),
+    Walker i.e. reader on a document tree based on Alfred Mickautsch code,
+    make room in nodes for line numbers, reference counting and future PSVI
+    extensions, generation of character ranges to be checked with faster
+    algorithm (William),  xmlParserMaxDepth (Crutcher Dunnavant), buffer
+    access
+   - New xmlWriter API provided by Alfred Mickautsch
+   - Schemas: base64 support by Anthony Carrico
+   - Parser<->HTTP integration fix, proper processing of the Mime-Type
+    and charset informations if available.
+   - Relax-NG: bug fixes including the one reported by Martijn Faassen and
+    zeroOrMore, better error reporting.
+   - Python bindings (Stéphane Bidoul), never use stdout for errors
+  output
+   - Portability: all the headers have macros for export and calling
+    convention definitions (Igor Zlatkovic), VMS update (Craig A. Berry),
+    Windows: threads (Jesse Pelton), Borland compiler (Eric Zurcher,  Igor),
+    Mingw (Igor), typos (Mark Vakoc),  beta version (Stephane Bidoul),
+    warning cleanups on AIX and MIPS compilers (William Brack), BeOS (Marcin
+    'Shard' Konicki)
+   - Documentation fixes and README (William Brack), search fix (William),
+    tutorial updates (John Fleck), namespace docs (Stefan Kost)
+   - Bug fixes: xmlCleanupParser (Dave Beckett), threading uninitialized
+    mutexes, HTML doctype lowercase,  SAX/IO (William), compression detection
+    and restore (William), attribute declaration in DTDs (William), namespace
+    on attribute in HTML output (William), input filename (Rob Richards),
+    namespace DTD validation, xmlReplaceNode (Chris Ryland), I/O callbacks
+    (Markus Keim), CDATA serialization (Shaun McCance), xmlReader (Peter
+    Derr), high codepoint charref like &#x10FFFF;, buffer access in push
+    mode (Justin Fletcher), TLS threads on Windows (Jesse Pelton), XPath bug
+    (William), xmlCleanupParser (Marc Liyanage), CDATA output (William), HTTP
+    error handling.
+   - xmllint options: --dtdvalidfpi for Tobias Reif, --sax1 for compat
+    testing,  --nodict for building without tree dictionnary, --nocdata to
+    replace CDATA by text, --nsclean to remove surperfluous  namespace
+    declarations
+   - added xml2-config --libtool-libs option from Kevin P. Fleming
+   - a lot of profiling and tuning of the code, speedup patch for
+    xmlSearchNs() by Luca Padovani. The xmlReader should do far less
+    allocation and it speed should get closer to SAX. Chris Anderson worked
+    on speeding and cleaning up repetitive checking code.
+   - cleanup of "make tests"
+   - libxml-2.0-uninstalled.pc from Malcolm Tredinnick
+   - deactivated the broken docBook SGML parser code and plugged the XML
+    parser instead.
+
+
+2.5.11: Sep 9 2003:
+A bugfix only release:   - risk of crash in Relax-NG
+   - risk of crash when using multithreaded programs
+
+
+2.5.10: Aug 15 2003:
+A bugfixes only release   - Windows Makefiles (William Brack)
+   - UTF-16 support fixes (Mark Itzcovitz)
+   - Makefile and portability (William Brack) automake, Linux alpha, Mingw
+    on Windows (Mikhail Grushinskiy)
+   - HTML parser (Oliver Stoeneberg)
+   - XInclude performance problem reported by Kevin Ruscoe
+   - XML parser performance problem reported by Grant Goodale
+   - xmlSAXParseDTD() bug fix from Malcolm Tredinnick
+   - and a couple other cleanup
+
+
+2.5.9: Aug 9 2003:
+   - bugfixes: IPv6 portability, xmlHasNsProp (Markus Keim), Windows build
+    (Wiliam Brake, Jesse Pelton, Igor), Schemas (Peter Sobisch), threading
+    (Rob Richards), hexBinary type (), UTF-16 BOM (Dodji Seketeli),
+    xmlReader, Relax-NG schemas compilation, namespace handling,  EXSLT (Sean
+    Griffin), HTML parsing problem (William Brack), DTD validation for mixed
+    content + namespaces, HTML serialization, library initialization,
+    progressive HTML parser
+   - better interfaces for Relax-NG error handling (Joachim Bauch, )
+   - adding xmlXIncludeProcessTree() for XInclud'ing in a subtree
+   - doc fixes and improvements (John Fleck)
+   - configure flag for -with-fexceptions when embedding in C++
+   - couple of new UTF-8 helper functions (William Brack)
+   - general encoding cleanup + ISO-8859-x without iconv (Peter Jacobi)
+   - xmlTextReader cleanup + enum for node types (Bjorn Reese)
+   - general compilation/warning cleanup Solaris/HP-UX/... (William
+  Brack)
+
+
+2.5.8: Jul 6 2003:
+   - bugfixes: XPath, XInclude, file/URI mapping, UTF-16 save (Mark
+    Itzcovitz), UTF-8 checking, URI saving, error printing (William Brack),
+    PI related memleak, compilation without schemas or without xpath (Joerg
+    Schmitz-Linneweber/Garry Pennington), xmlUnlinkNode problem with DTDs,
+    rpm problem on , i86_64, removed a few compilation problems from 2.5.7,
+    xmlIOParseDTD, and xmlSAXParseDTD (Malcolm Tredinnick)
+   - portability: DJGPP (MsDos) , OpenVMS (Craig A. Berry)
+   - William Brack fixed multithreading lock problems
+   - IPv6 patch for FTP and HTTP accesses (Archana Shah/Wipro)
+   - Windows fixes (Igor Zlatkovic,  Eric Zurcher), threading (Stéphane
+    Bidoul)
+   - A few W3C Schemas Structure improvements
+   - W3C Schemas Datatype improvements (Charlie Bozeman)
+   - Python bindings for thread globals (Stéphane Bidoul), and method/class
+    generator
+   - added --nonet option to xmllint
+   - documentation improvements (John Fleck)
+
+
+2.5.7: Apr 25 2003:
+   - Relax-NG: Compiling to regexp and streaming validation on top of the
+    xmlReader interface, added to xmllint --stream
+   - xmlReader: Expand(), Next() and DOM access glue, bug fixes
+   - Support for large files: RGN validated a 4.5GB instance
+   - Thread support is now configured in by default
+   - Fixes: update of the Trio code (Bjorn), WXS Date and Duration fixes
+    (Charles Bozeman), DTD and namespaces (Brent Hendricks), HTML push parser
+    and zero bytes handling, some missing Windows file path conversions,
+    behaviour of the parser and validator in the presence of "out of memory"
+    error conditions
+   - extended the API to be able to plug a garbage collecting memory
+    allocator, added xmlMallocAtomic() and modified the allocations
+    accordingly.
+   - Performances: removed excessive malloc() calls, speedup of the push and
+    xmlReader interfaces, removed excessive thread locking
+   - Documentation: man page (John Fleck), xmlReader documentation
+   - Python: adding binding for xmlCatalogAddLocal (Brent M Hendricks)
+
+
+2.5.6: Apr 1 2003:
+   - Fixed W3C XML Schemas datatype, should be compliant now except for
+    binHex and base64 which are not supported yet.
+   - bug fixes: non-ASCII IDs, HTML output, XInclude on large docs and
+    XInclude entities handling, encoding detection on external subsets, XML
+    Schemas bugs and memory leaks, HTML parser (James Bursa)
+   - portability: python/trio (Albert Chin), Sun compiler warnings
+   - documentation: added --relaxng option to xmllint man page (John)
+   - improved error reporting: xml:space, start/end tag mismatches, Relax NG
+    errors
+
+
+2.5.5: Mar 24 2003:
+   - Lot of fixes on the Relax NG implementation. More testing including
+    DocBook and TEI examples.
+   - Increased the support for W3C XML Schemas datatype
+   - Several bug fixes in the URI handling layer
+   - Bug fixes: HTML parser, xmlReader, DTD validation, XPath, encoding
+    conversion, line counting in the parser.
+   - Added support for $XMLLINT_INDENT environment variable, FTP delete
+   - Fixed the RPM spec file name
+
+
+2.5.4: Feb 20 2003:
+   - Conformance testing and lot of fixes on Relax NG and XInclude
+    implementation
+   - Implementation of XPointer element() scheme
+   - Bug fixes: XML parser, XInclude entities merge, validity checking on
+    namespaces,
+    2 serialization bugs, node info generation problems, a DTD regexp
+    generation problem.
+  
+   - Portability: windows updates and path canonicalization (Igor)
+   - A few typo fixes (Kjartan Maraas)
+   - Python bindings generator fixes (Stephane Bidoul)
+
+
+2.5.3: Feb 10 2003:
+   - RelaxNG and XML Schemas datatypes improvements, and added a first
+    version of RelaxNG Python bindings
+   - Fixes: XLink (Sean Chittenden), XInclude (Sean Chittenden), API fix for
+    serializing namespace nodes, encoding conversion bug, XHTML1
+  serialization
+   - Portability fixes: Windows (Igor), AMD 64bits RPM spec file
+
+
+2.5.2: Feb 5 2003:
+   - First implementation of RelaxNG, added --relaxng flag to xmllint
+   - Schemas support now compiled in by default.
+   - Bug fixes: DTD validation, namespace checking, XInclude and entities,
+    delegateURI in XML Catalogs, HTML parser, XML reader (Stéphane Bidoul),
+    XPath parser and evaluation,  UTF8ToUTF8 serialization, XML reader memory
+    consumption, HTML parser, HTML serialization in the presence of
+  namespaces
+   - added an HTML API to check elements and attributes.
+   - Documentation improvement, PDF for the tutorial (John Fleck), doc
+    patches (Stefan Kost)
+   - Portability fixes: NetBSD (Julio Merino), Windows (Igor Zlatkovic)
+   - Added python bindings for XPointer, contextual error reporting
+    (Stéphane Bidoul)
+   - URI/file escaping problems (Stefano Zacchiroli)
+
+
+2.5.1: Jan 8 2003:
+   - Fixes a memory leak and configuration/compilation problems in 2.5.0
+   - documentation updates (John)
+   - a couple of XmlTextReader fixes
+
+
+2.5.0: Jan 6 2003:
+   - New XmltextReader interface based on C#
+    API (with help of Stéphane Bidoul)
+   - Windows: more exports, including the new API (Igor)
+   - XInclude fallback fix
+   - Python: bindings for the new API, packaging (Stéphane Bidoul),
+    drv_libxml2.py Python xml.sax driver (Stéphane Bidoul), fixes, speedup
+    and iterators for Python-2.2 (Hannu Krosing)
+   - Tutorial fixes (john Fleck and Niraj Tolia) xmllint man update
+  (John)
+   - Fix an XML parser bug raised by Vyacheslav Pindyura
+   - Fix for VMS serialization (Nigel Hall) and config (Craig A. Berry)
+   - Entities handling fixes
+   - new API to optionally track node creation and deletion (Lukas
+  Schroeder)
+   - Added documentation for the XmltextReader interface and some XML guidelines
+
+
+2.4.30: Dec 12 2002:
+   - 2.4.29 broke the python bindings, rereleasing
+   - Improvement/fixes of the XML API generator, and couple of minor code
+    fixes.
+
+
+2.4.29: Dec 11 2002:
+   - Windows fixes (Igor): Windows CE port, pthread linking, python bindings
+    (Stéphane Bidoul), Mingw (Magnus Henoch), and export list updates
+   - Fix for prev in python bindings (ERDI Gergo)
+   - Fix for entities handling (Marcus Clarke)
+   - Refactored the XML and HTML dumps to a single code path, fixed XHTML1
+    dump
+   - Fix for URI parsing when handling URNs with fragment identifiers
+   - Fix for HTTP URL escaping problem
+   - added an TextXmlReader (C#) like API (work in progress)
+   - Rewrote the API in XML generation script, includes a C parser and saves
+    more informations needed for C# bindings
+
+
+2.4.28: Nov 22 2002:
+   - a couple of python binding fixes
+   - 2 bug fixes in the XML push parser
+   - potential memory leak removed (Martin Stoilov)
+   - fix to the configure script for Unix (Dimitri Papadopoulos)
+   - added encoding support for XInclude parse="text"
+   - autodetection of XHTML1 and specific serialization rules added
+   - nasty threading bug fixed (William Brack)
+
+
+2.4.27: Nov 17 2002:
+   - fixes for the Python bindings
+   - a number of bug fixes: SGML catalogs, xmlParseBalancedChunkMemory(),
+    HTML parser,  Schemas (Charles Bozeman), document fragment support
+    (Christian Glahn), xmlReconciliateNs (Brian Stafford), XPointer,
+    xmlFreeNode(), xmlSAXParseMemory (Peter Jones), xmlGetNodePath (Petr
+    Pajas), entities processing
+   - added grep to xmllint --shell
+   - VMS update patch from Craig A. Berry
+   - cleanup of the Windows build with support for more compilers (Igor),
+    better thread support on Windows
+   - cleanup of Unix Makefiles and spec file
+   - Improvements to the documentation (John Fleck)
+
+
+2.4.26: Oct 18 2002:
+   - Patches for Windows CE port, improvements on Windows paths handling
+   - Fixes to the validation  code (DTD and Schemas), xmlNodeGetPath() ,
+    HTML serialization, Namespace compliance,  and a number of small
+  problems
+
+
+2.4.25: Sep 26 2002:
+   - A number of bug fixes: XPath, validation, Python bindings, DOM and
+    tree, xmlI/O,  Html
+   - Serious rewrite of XInclude
+   - Made XML Schemas regexp part of the default build and APIs, small fix
+    and improvement of the regexp core
+   - Changed the validation code to reuse XML Schemas regexp APIs
+   - Better handling of Windows file paths, improvement of Makefiles (Igor,
+    Daniel Gehriger, Mark Vakoc)
+   - Improved the python I/O bindings, the tests, added resolver and regexp
+    APIs
+   - New logos from Marc Liyanage
+   - Tutorial improvements: John Fleck, Christopher Harris
+   - Makefile: Fixes for AMD x86_64 (Mandrake), DESTDIR (Christophe
+  Merlet)
+   - removal of all stderr/perror use for error reporting
+   - Better error reporting: XPath and DTD validation
+   - update of the trio portability layer (Bjorn Reese)
+
+2.4.24: Aug 22 2002   - XPath fixes (William), xf:escape-uri() (Wesley Terpstra)
+   - Python binding fixes: makefiles (William), generator, rpm build, x86-64
+    (fcrozat)
+   - HTML <style> and boolean attributes serializer fixes
+   - C14N improvements by Aleksey
+   - doc cleanups: Rick Jones
+   - Windows compiler makefile updates: Igor and Elizabeth Barham
+   - XInclude: implementation of fallback and xml:base fixup added
+
+
+2.4.23: July 6 2002:
+   - performances patches: Peter Jacobi
+   - c14n fixes, testsuite and performances: Aleksey Sanin
+   - added xmlDocFormatDump: Chema Celorio
+   - new tutorial: John Fleck
+   - new hash functions and performances: Sander Vesik, portability fix from
+    Peter Jacobi
+   - a number of bug fixes: XPath (William Brack, Richard Jinks), XML and
+    HTML parsers, ID lookup function
+   - removal of all remaining sprintf: Aleksey Sanin
+
+
+2.4.22: May 27 2002:
+   - a number of bug fixes: configure scripts, base handling, parser, memory
+    usage, HTML parser, XPath, documentation (Christian Cornelssen),
+    indentation, URI parsing
+   - Optimizations for XMLSec, fixing and making public some of the network
+    protocol handlers (Aleksey)
+   - performance patch from Gary Pennington
+   - Charles Bozeman provided date and time support for XML Schemas
+  datatypes
+
+
+2.4.21: Apr 29 2002:
+This release is both a bug fix release and also contains the early XML
+Schemas structures at 
+http://www.w3.org/TR/xmlschema-1/
+ and datatypes at 
+http://www.w3.org/TR/xmlschema-2/
+ code, beware, all
+interfaces are likely to change, there is huge holes, it is clearly a work in
+progress and don't even think of putting this code in a production system,
+it's actually not compiled in by default. The real fixes are:   - a couple of bugs or limitations introduced in 2.4.20
+   - patches for Borland C++ and MSC by Igor
+   - some fixes on XPath strings and conformance patches by Richard
+  Jinks
+   - patch from Aleksey for the ExcC14N specification
+   - OSF/1 bug fix by Bjorn
+
+
+2.4.20: Apr 15 2002:
+   - bug fixes: file descriptor leak, XPath, HTML output, DTD validation
+   - XPath conformance testing by Richard Jinks
+   - Portability fixes: Solaris, MPE/iX, Windows, OSF/1, python bindings,
+    libxml.m4
+
+
+2.4.19: Mar 25 2002:
+   - bug fixes: half a dozen XPath bugs, Validation, ISO-Latin to UTF8
+    encoder
+   - portability fixes in the HTTP code
+   - memory allocation checks using valgrind, and profiling tests
+   - revamp of the Windows build and Makefiles
+
+
+2.4.18: Mar 18 2002:
+   - bug fixes: tree, SAX, canonicalization, validation, portability,
+  XPath
+   - removed the --with-buffer option it was becoming unmaintainable
+   - serious cleanup of the Python makefiles
+   - speedup patch to XPath very effective for DocBook stylesheets
+   - Fixes for Windows build, cleanup of the documentation
+
+
+2.4.17: Mar 8 2002:
+   - a lot of bug fixes, including "namespace nodes have no parents in
+  XPath"
+   - fixed/improved the Python wrappers, added more examples and more
+    regression tests, XPath extension functions can now return node-sets
+   - added the XML Canonicalization support from Aleksey Sanin
+
+
+2.4.16: Feb 20 2002:
+   - a lot of bug fixes, most of them were triggered by the XML Testsuite
+    from OASIS and W3C. Compliance has been significantly improved.
+   - a couple of portability fixes too.
+
+
+2.4.15: Feb 11 2002:
+   - Fixed the Makefiles, especially the python module ones
+   - A few bug fixes and cleanup
+   - Includes cleanup
+
+
+2.4.14: Feb 8 2002:
+   - Change of License to the MIT
+    License basically for integration in XFree86 codebase, and removing
+    confusion around the previous dual-licensing
+   - added Python bindings, beta software but should already be quite
+    complete
+   - a large number of fixes and cleanups, especially for all tree
+    manipulations
+   - cleanup of the headers, generation of a reference API definition in
+  XML
+
+
+2.4.13: Jan 14 2002:
+   - update of the documentation: John Fleck and Charlie Bozeman
+   - cleanup of timing code from Justin Fletcher
+   - fixes for Windows and initial thread support on Win32: Igor and Serguei
+    Narojnyi
+   - Cygwin patch from Robert Collins
+   - added xmlSetEntityReferenceFunc() for Keith Isdale work on xsldbg
+
+
+2.4.12: Dec 7 2001:
+   - a few bug fixes: thread (Gary Pennington), xmllint (Geert Kloosterman),
+    XML parser (Robin Berjon), XPointer (Danny Jamshy), I/O cleanups
+  (robert)
+   - Eric Lavigne contributed project files for MacOS
+   - some makefiles cleanups
+
+
+2.4.11: Nov 26 2001:
+   - fixed a couple of errors in the includes, fixed a few bugs, some code
+    cleanups
+   - xmllint man pages improvement by Heiko Rupp
+   - updated VMS build instructions from John A Fotheringham
+   - Windows Makefiles updates from Igor
+
+
+2.4.10: Nov 10 2001:
+   - URI escaping fix (Joel Young)
+   - added xmlGetNodePath() (for paths or XPointers generation)
+   - Fixes namespace handling problems when using DTD and validation
+   - improvements on xmllint: Morus Walter patches for --format and
+    --encode, Stefan Kost and Heiko Rupp improvements on the --shell
+   - fixes for xmlcatalog linking pointed by Weiqi Gao
+   - fixes to the HTML parser
+
+
+2.4.9: Nov 6 2001:
+   - fixes more catalog bugs
+   - avoid a compilation problem, improve xmlGetLineNo()
+
+
+2.4.8: Nov 4 2001:
+   - fixed SGML catalogs broken in previous release, updated xmlcatalog
+  tool
+   - fixed a compile errors and some includes troubles.
+
+
+2.4.7: Oct 30 2001:
+   - exported some debugging interfaces
+   - serious rewrite of the catalog code
+   - integrated Gary Pennington thread safety patch, added configure option
+    and regression tests
+   - removed an HTML parser bug
+   - fixed a couple of potentially serious validation bugs
+   - integrated the SGML DocBook support in xmllint
+   - changed the nanoftp anonymous login passwd
+   - some I/O cleanup and a couple of interfaces for Perl wrapper
+   - general bug fixes
+   - updated xmllint man page by John Fleck
+   - some VMS and Windows updates
+
+
+2.4.6: Oct 10 2001:
+   - added an updated man pages by John Fleck
+   - portability and configure fixes
+   - an infinite loop on the HTML parser was removed (William)
+   - Windows makefile patches from Igor
+   - fixed half a dozen bugs reported for libxml or libxslt
+   - updated xmlcatalog to be able to modify SGML super catalogs
+
+
+2.4.5: Sep 14 2001:
+   - Remove a few annoying bugs in 2.4.4
+   - forces the HTML serializer to output decimal charrefs since some
+    version of Netscape can't handle hexadecimal ones
+
+
+1.8.16: Sep 14 2001:
+   - maintenance release of the old libxml1 branch, couple of bug and
+    portability fixes
+
+
+2.4.4: Sep 12 2001:
+   - added --convert to xmlcatalog, bug fixes and cleanups of XML
+  Catalog
+   - a few bug fixes and some portability changes
+   - some documentation cleanups
+
+
+2.4.3:  Aug 23 2001:
+   - XML Catalog support see the doc
+   - New NaN/Infinity floating point code
+   - A few bug fixes
+
+
+2.4.2:  Aug 15 2001:
+   - adds xmlLineNumbersDefault() to control line number generation
+   - lot of bug fixes
+   - the Microsoft MSC projects files should now be up to date
+   - inheritance of namespaces from DTD defaulted attributes
+   - fixes a serious potential security bug
+   - added a --format option to xmllint
+
+
+2.4.1:  July 24 2001:
+   - possibility to keep line numbers in the tree
+   - some computation NaN fixes
+   - extension of the XPath API
+   - cleanup for alpha and ia64 targets
+   - patch to allow saving through HTTP PUT or POST
+
+
+2.4.0: July 10 2001:
+   - Fixed a few bugs in XPath, validation, and tree handling.
+   - Fixed XML Base implementation, added a couple of examples to the
+    regression tests
+   - A bit of cleanup
+
+
+2.3.14: July 5 2001:
+   - fixed some entities problems and reduce memory requirement when
+    substituting them
+   - lots of improvements in the XPath queries interpreter can be
+    substantially faster
+   - Makefiles and configure cleanups
+   - Fixes to XPath variable eval, and compare on empty node set
+   - HTML tag closing bug fixed
+   - Fixed an URI reference computation problem when validating
+
+
+2.3.13: June 28 2001:
+   - 2.3.12 configure.in was broken as well as the push mode XML parser
+   - a few more fixes for compilation on Windows MSC by Yon Derek
+
+
+1.8.14: June 28 2001:
+   - Zbigniew Chyla gave a patch to use the old XML parser in push mode
+   - Small Makefile fix
+
+
+2.3.12: June 26 2001:
+   - lots of cleanup
+   - a couple of validation fix
+   - fixed line number counting
+   - fixed serious problems in the XInclude processing
+   - added support for UTF8 BOM at beginning of entities
+   - fixed a strange gcc optimizer bugs in xpath handling of float, gcc-3.0
+    miscompile uri.c (William), Thomas Leitner provided a fix for the
+    optimizer on Tru64
+   - incorporated Yon Derek and Igor Zlatkovic  fixes and improvements for
+    compilation on Windows MSC
+   - update of libxml-doc.el (Felix Natter)
+   - fixed 2 bugs in URI normalization code
+
+
+2.3.11: June 17 2001:
+   - updates to trio, Makefiles and configure should fix some portability
+    problems (alpha)
+   - fixed some HTML serialization problems (pre, script, and block/inline
+    handling), added encoding aware APIs, cleanup of this code
+   - added xmlHasNsProp()
+   - implemented a specific PI for encoding support in the DocBook SGML
+    parser
+   - some XPath fixes (-Infinity, / as a function parameter and namespaces
+    node selection)
+   - fixed a performance problem and an error in the validation code
+   - fixed XInclude routine to implement the recursive behaviour
+   - fixed xmlFreeNode problem when libxml is included statically twice
+   - added --version to xmllint for bug reports
+
+
+2.3.10: June 1 2001:
+   - fixed the SGML catalog support
+   - a number of reported bugs got fixed, in XPath, iconv detection,
+    XInclude processing
+   - XPath string function should now handle unicode correctly
+
+
+2.3.9: May 19 2001:
+Lots of bugfixes, and added a basic SGML catalog support:   - HTML push bugfix #54891 and another patch from Jonas Borgström
+   - some serious speed optimization again
+   - some documentation cleanups
+   - trying to get better linking on Solaris (-R)
+   - XPath API cleanup from Thomas Broyer
+   - Validation bug fixed #54631, added a patch from Gary Pennington, fixed
+    xmlValidGetValidElements()
+   - Added an INSTALL file
+   - Attribute removal added to API: #54433
+   - added a basic support for SGML catalogs
+   - fixed xmlKeepBlanksDefault(0) API
+   - bugfix in xmlNodeGetLang()
+   - fixed a small configure portability problem
+   - fixed an inversion of SYSTEM and PUBLIC identifier in HTML document
+
+
+1.8.13: May 14 2001:
+   - bugfixes release of the old libxml1 branch used by Gnome
+
+
+2.3.8: May 3 2001:
+   - Integrated an SGML DocBook parser for the Gnome project
+   - Fixed a few things in the HTML parser
+   - Fixed some XPath bugs raised by XSLT use, tried to fix the floating
+    point portability issue
+   - Speed improvement (8M/s for SAX, 3M/s for DOM, 1.5M/s for
+    DOM+validation using the XML REC as input and a 700MHz celeron).
+   - incorporated more Windows cleanup
+   - added xmlSaveFormatFile()
+   - fixed problems in copying nodes with entities references (gdome)
+   - removed some troubles surrounding the new validation module
+
+
+2.3.7: April 22 2001:
+   - lots of small bug fixes, corrected XPointer
+   - Non deterministic content model validation support
+   - added xmlDocCopyNode for gdome2
+   - revamped the way the HTML parser handles end of tags
+   - XPath: corrections of namespaces support and number formatting
+   - Windows: Igor Zlatkovic patches for MSC compilation
+   - HTML output fixes from P C Chow and William M. Brack
+   - Improved validation speed sensible for DocBook
+   - fixed a big bug with ID declared in external parsed entities
+   - portability fixes, update of Trio from Bjorn Reese
+
+
+2.3.6: April 8 2001:
+   - Code cleanup using extreme gcc compiler warning options, found and
+    cleared half a dozen potential problem
+   - the Eazel team found an XML parser bug
+   - cleaned up the user of some of the string formatting function. used the
+    trio library code to provide the one needed when the platform is missing
+    them
+   - xpath: removed a memory leak and fixed the predicate evaluation
+    problem, extended the testsuite and cleaned up the result. XPointer seems
+    broken ...
+
+
+2.3.5: Mar 23 2001:
+   - Biggest change is separate parsing and evaluation of XPath expressions,
+    there is some new APIs for this too
+   - included a number of bug fixes(XML push parser, 51876, notations,
+  52299)
+   - Fixed some portability issues
+
+
+2.3.4: Mar 10 2001:
+   - Fixed bugs #51860 and #51861
+   - Added a global variable xmlDefaultBufferSize to allow default buffer
+    size to be application tunable.
+   - Some cleanup in the validation code, still a bug left and this part
+    should probably be rewritten to support ambiguous content model :-\
+   - Fix a couple of serious bugs introduced or raised by changes in 2.3.3
+    parser
+   - Fixed another bug in xmlNodeGetContent()
+   - Bjorn fixed XPath node collection and Number formatting
+   - Fixed a loop reported in the HTML parsing
+   - blank space are reported even if the Dtd content model proves that they
+    are formatting spaces, this is for XML conformance
+
+
+2.3.3: Mar 1 2001:
+   - small change in XPath for XSLT
+   - documentation cleanups
+   - fix in validation by Gary Pennington
+   - serious parsing performances improvements
+
+
+2.3.2: Feb 24 2001:
+   - chasing XPath bugs, found a bunch, completed some TODO
+   - fixed a Dtd parsing bug
+   - fixed a bug in xmlNodeGetContent
+   - ID/IDREF support partly rewritten by Gary Pennington
+
+
+2.3.1: Feb 15 2001:
+   - some XPath and HTML bug fixes for XSLT
+   - small extension of the hash table interfaces for DOM gdome2
+    implementation
+   - A few bug fixes
+
+
+2.3.0: Feb 8 2001 (2.2.12 was on 25 Jan but I didn't kept track):
+   - Lots of XPath bug fixes
+   - Add a mode with Dtd lookup but without validation error reporting for
+    XSLT
+   - Add support for text node without escaping (XSLT)
+   - bug fixes for xmlCheckFilename
+   - validation code bug fixes from Gary Pennington
+   - Patch from Paul D. Smith correcting URI path normalization
+   - Patch to allow simultaneous install of libxml-devel and
+  libxml2-devel
+   - the example Makefile is now fixed
+   - added HTML to the RPM packages
+   - tree copying bugfixes
+   - updates to Windows makefiles
+   - optimization patch from Bjorn Reese
+
+
+2.2.11: Jan 4 2001:
+   - bunch of bug fixes (memory I/O, xpath, ftp/http, ...)
+   - added htmlHandleOmittedElem()
+   - Applied Bjorn Reese's IPV6 first patch
+   - Applied Paul D. Smith patches for validation of XInclude results
+   - added XPointer xmlns() new scheme support
+
+
+2.2.10: Nov 25 2000:
+   - Fix the Windows problems of 2.2.8
+   - integrate OpenVMS patches
+   - better handling of some nasty HTML input
+   - Improved the XPointer implementation
+   - integrate a number of provided patches
+
+
+2.2.9: Nov 25 2000:
+   - erroneous release :-(
+
+
+2.2.8: Nov 13 2000:
+   - First version of XInclude
+    support
+   - Patch in conditional section handling
+   - updated MS compiler project
+   - fixed some XPath problems
+   - added an URI escaping function
+   - some other bug fixes
+
+
+2.2.7: Oct 31 2000:
+   - added message redirection
+   - XPath improvements (thanks TOM !)
+   - xmlIOParseDTD() added
+   - various small fixes in the HTML, URI, HTTP and XPointer support
+   - some cleanup of the Makefile, autoconf and the distribution content
+
+
+2.2.6: Oct 25 2000::
+   - Added an hash table module, migrated a number of internal structure to
+    those
+   - Fixed a posteriori validation problems
+   - HTTP module cleanups
+   - HTML parser improvements (tag errors, script/style handling, attribute
+    normalization)
+   - coalescing of adjacent text nodes
+   - couple of XPath bug fixes, exported the internal API
+
+
+2.2.5: Oct 15 2000::
+   - XPointer implementation and testsuite
+   - Lot of XPath fixes, added variable and functions registration, more
+    tests
+   - Portability fixes, lots of enhancements toward an easy Windows build
+    and release
+   - Late validation fixes
+   - Integrated a lot of contributed patches
+   - added memory management docs
+   - a performance problem when using large buffer seems fixed
+
+
+2.2.4: Oct 1 2000::
+   - main XPath problem fixed
+   - Integrated portability patches for Windows
+   - Serious bug fixes on the URI and HTML code
+
+
+2.2.3: Sep 17 2000:
+   - bug fixes
+   - cleanup of entity handling code
+   - overall review of all loops in the parsers, all sprintf usage has been
+    checked too
+   - Far better handling of larges Dtd. Validating against DocBook XML Dtd
+    works smoothly now.
+
+
+1.8.10: Sep 6 2000:
+   - bug fix release for some Gnome projects
+
+
+2.2.2: August 12 2000:
+   - mostly bug fixes
+   - started adding routines to access xml parser context options
+
+
+2.2.1: July 21 2000:
+   - a purely bug fixes release
+   - fixed an encoding support problem when parsing from a memory block
+   - fixed a DOCTYPE parsing problem
+   - removed a bug in the function allowing to override the memory
+    allocation routines
+
+
+2.2.0: July 14 2000:
+   - applied a lot of portability fixes
+   - better encoding support/cleanup and saving (content is now always
+    encoded in UTF-8)
+   - the HTML parser now correctly handles encodings
+   - added xmlHasProp()
+   - fixed a serious problem with &#38;
+   - propagated the fix to FTP client
+   - cleanup, bugfixes, etc ...
+   - Added a page about libxml Internationalization
+    support
+
+
+1.8.9:  July 9 2000:
+   - fixed the spec the RPMs should be better
+   - fixed a serious bug in the FTP implementation, released 1.8.9 to solve
+    rpmfind users problem
+
+
+2.1.1: July 1 2000:
+   - fixes a couple of bugs in the 2.1.0 packaging
+   - improvements on the HTML parser
+
+
+2.1.0 and 1.8.8: June 29 2000:
+   - 1.8.8 is mostly a commodity package for upgrading to libxml2 according
+    to new instructions. It fixes a nasty problem
+    about &#38; charref parsing
+   - 2.1.0 also ease the upgrade from libxml v1 to the recent version. it
+    also contains numerous fixes and enhancements:
+    added xmlStopParser() to stop parsing
+      improved a lot parsing speed when there is large CDATA blocs
+      includes XPath patches provided by Picdar Technology
+      tried to fix as much as possible DTD validation and namespace
+        related problems
+      output to a given encoding has been added/tested
+      lot of various fixes
+    
+   - added xmlStopParser() to stop parsing
+   - improved a lot parsing speed when there is large CDATA blocs
+   - includes XPath patches provided by Picdar Technology
+   - tried to fix as much as possible DTD validation and namespace
+        related problems
+   - output to a given encoding has been added/tested
+   - lot of various fixes
+
+
+2.0.0: Apr 12 2000:
+   - First public release of libxml2. If you are using libxml, it's a good
+    idea to check the 1.x to 2.x upgrade instructions. NOTE: while initially
+    scheduled for Apr 3 the release occurred only on Apr 12 due to massive
+    workload.
+   - The include are now located under $prefix/include/libxml (instead of
+    $prefix/include/gnome-xml), they also are referenced by
+    #include <libxml/xxx.h>
+    instead of
+    #include "xxx.h"
+  
+   - a new URI module for parsing URIs and following strictly RFC 2396
+   - the memory allocation routines used by libxml can now be overloaded
+    dynamically by using xmlMemSetup()
+   - The previously CVS only tool tester has been renamed
+    xmllint and is now installed as part of the libxml2
+    package
+   - The I/O interface has been revamped. There is now ways to plug in
+    specific I/O modules, either at the URI scheme detection level using
+    xmlRegisterInputCallbacks()  or by passing I/O functions when creating a
+    parser context using xmlCreateIOParserCtxt()
+   - there is a C preprocessor macro LIBXML_VERSION providing the version
+    number of the libxml module in use
+   - a number of optional features of libxml can now be excluded at
+    configure time (FTP/HTTP/HTML/XPath/Debug)
+
+
+2.0.0beta: Mar 14 2000:
+   - This is a first Beta release of libxml version 2
+   - It's available only fromxmlsoft.org
+    FTP, it's packaged as libxml2-2.0.0beta and available as tar and
+  RPMs
+   - This version is now the head in the Gnome CVS base, the old one is
+    available under the tag LIB_XML_1_X
+   - This includes a very large set of changes. From a  programmatic point
+    of view applications should not have to be modified too much, check the
+    upgrade page
+   - Some interfaces may changes (especially a bit about encoding).
+   - the updates includes:
+    fix I18N support. ISO-Latin-x/UTF-8/UTF-16 (nearly) seems correctly
+        handled now
+      Better handling of entities, especially well-formedness checking
+        and proper PEref extensions in external subsets
+      DTD conditional sections
+      Validation now correctly handle entities content
+      change
+        structures to accommodate DOM
+    
+   - fix I18N support. ISO-Latin-x/UTF-8/UTF-16 (nearly) seems correctly
+        handled now
+   - Better handling of entities, especially well-formedness checking
+        and proper PEref extensions in external subsets
+   - DTD conditional sections
+   - Validation now correctly handle entities content
+   - change
+        structures to accommodate DOM
+   - Serious progress were made toward compliance, here are the result of the test against the
+    OASIS testsuite (except the Japanese tests since I don't support that
+    encoding yet). This URL is rebuilt every couple of hours using the CVS
+    head version.
+
+
+1.8.7: Mar 6 2000:
+   - This is a bug fix release:
+   - It is possible to disable the ignorable blanks heuristic used by
+    libxml-1.x, a new function  xmlKeepBlanksDefault(0) will allow this. Note
+    that for adherence to XML spec, this behaviour will be disabled by
+    default in 2.x . The same function will allow to keep compatibility for
+    old code.
+   - Blanks in <a>  </a> constructs are not ignored anymore,
+    avoiding heuristic is really the Right Way :-\
+   - The unchecked use of snprintf which was breaking libxml-1.8.6
+    compilation on some platforms has been fixed
+   - nanoftp.c nanohttp.c: Fixed '#' and '?' stripping when processing
+  URIs
+
+
+1.8.6: Jan 31 2000:
+   - added a nanoFTP transport module, debugged until the new version of rpmfind can use
+    it without troubles
+
+
+1.8.5: Jan 21 2000:
+   - adding APIs to parse a well balanced chunk of XML (production [43] content of the
+    XML spec)
+   - fixed a hideous bug in xmlGetProp pointed by Rune.Djurhuus@fast.no
+   - Jody Goldberg <jgoldberg@home.com> provided another patch trying
+    to solve the zlib checks problems
+   - The current state in gnome CVS base is expected to ship as 1.8.5 with
+    gnumeric soon
+
+
+1.8.4: Jan 13 2000:
+   - bug fixes, reintroduced xmlNewGlobalNs(), fixed xmlNewNs()
+   - all exit() call should have been removed from libxml
+   - fixed a problem with INCLUDE_WINSOCK on WIN32 platform
+   - added newDocFragment()
+
+
+1.8.3: Jan 5 2000:
+   - a Push interface for the XML and HTML parsers
+   - a shell-like interface to the document tree (try tester --shell :-)
+   - lots of bug fixes and improvement added over XMas holidays
+   - fixed the DTD parsing code to work with the xhtml DTD
+   - added xmlRemoveProp(), xmlRemoveID() and xmlRemoveRef()
+   - Fixed bugs in xmlNewNs()
+   - External entity loading code has been revamped, now it uses
+    xmlLoadExternalEntity(), some fix on entities processing were added
+   - cleaned up WIN32 includes of socket stuff
+
+
+1.8.2: Dec 21 1999:
+   - I got another problem with includes and C++, I hope this issue is fixed
+    for good this time
+   - Added a few tree modification functions: xmlReplaceNode,
+    xmlAddPrevSibling, xmlAddNextSibling, xmlNodeSetName and
+    xmlDocSetRootElement
+   - Tried to improve the HTML output with help from Chris Lahey
+
+
+1.8.1: Dec 18 1999:
+   - various patches to avoid troubles when using libxml with C++ compilers
+    the "namespace" keyword and C escaping in include files
+   - a problem in one of the core macros IS_CHAR was corrected
+   - fixed a bug introduced in 1.8.0 breaking default namespace processing,
+    and more specifically the Dia application
+   - fixed a posteriori validation (validation after parsing, or by using a
+    Dtd not specified in the original document)
+   - fixed a bug in
+
+
+1.8.0: Dec 12 1999:
+   - cleanup, especially memory wise
+   - the parser should be more reliable, especially the HTML one, it should
+    not crash, whatever the input !
+   - Integrated various patches, especially a speedup improvement for large
+    dataset from Carl Nygard,
+    configure with --with-buffers to enable them.
+   - attribute normalization, oops should have been added long ago !
+   - attributes defaulted from DTDs should be available, xmlSetProp() now
+    does entities escaping by default.
+
+
+1.7.4: Oct 25 1999:
+   - Lots of HTML improvement
+   - Fixed some errors when saving both XML and HTML
+   - More examples, the regression tests should now look clean
+   - Fixed a bug with contiguous charref
+
+
+1.7.3: Sep 29 1999:
+   - portability problems fixed
+   - snprintf was used unconditionally, leading to link problems on system
+    were it's not available, fixed
+
+
+1.7.1: Sep 24 1999:
+   - The basic type for strings manipulated by libxml has been renamed in
+    1.7.1 from CHAR to xmlChar. The reason
+    is that CHAR was conflicting with a predefined type on Windows. However
+    on non WIN32 environment, compatibility is provided by the way of  a
+    #define .
+   - Changed another error : the use of a structure field called errno, and
+    leading to troubles on platforms where it's a macro
+
+
+1.7.0: Sep 23 1999:
+   - Added the ability to fetch remote DTD or parsed entities, see the nanohttp module.
+   - Added an errno to report errors by another mean than a simple printf
+    like callback
+   - Finished ID/IDREF support and checking when validation
+   - Serious memory leaks fixed (there is now a memory wrapper module)
+   - Improvement of XPath
+    implementation
+   - Added an HTML parser front-end
+
+Daniel Veillard at 
+bugs.html
diff --git a/src/libxml/README b/src/libxml/README
new file mode 100644
index 0000000..2b18903
--- /dev/null
+++ b/src/libxml/README
@@ -0,0 +1,24 @@
+
+                  XML toolkit from the GNOME project
+
+Full documentation is available on-line at
+    http://xmlsoft.org/
+
+This code is released under the MIT Licence see the Copyright file.
+
+To report bugs, follow the instructions at: 
+  http://xmlsoft.org/bugs.html
+
+A mailing-list xml@gnome.org is available, to subscribe:
+    http://mail.gnome.org/mailman/listinfo/xml
+
+The list archive is at:
+    http://mail.gnome.org/archives/xml/
+
+All technical answers asked privately will be automatically answered on
+the list and archived for public access unless pricacy is explicitely
+required and justified.
+
+Daniel Veillard
+
+$Id: README,v 1.1 2008/11/12 02:25:23 agibert Exp $
diff --git a/src/libxml/TODO b/src/libxml/TODO
new file mode 100644
index 0000000..664ef0c
--- /dev/null
+++ b/src/libxml/TODO
@@ -0,0 +1,327 @@
+124907 HTML parse buffer problem when parsing larse in-memory docs
+124110 DTD validation && wrong namespace
+123564 xmllint --html --format
+
+           TODO for the XML parser and stuff:
+	   ==================================
+
+      $Id: TODO,v 1.1 2008/11/12 02:25:23 agibert Exp $
+
+    this tend to be outdated :-\ ...
+
+DOCS:
+=====
+
+- use case of using XInclude to load for example a description.
+  order document + product base -(XSLT)-> quote with XIncludes 
+                                                   |
+  HTML output with description of parts <---(XSLT)--
+
+TODO:
+=====
+
+- E20
+[17:21:38] <PGrosso> DV, you have an action to Check what your parser does on E20. Have you done this?
+[17:22:42] <PGrosso> DV, ref: http://www.w3.org/XML/xml-V10-2e-errata#E20
+[17:39:07] <DV> paphio:~/XML -> cat tst.xml
+[17:39:07] <DV> <!DOCTYPE test [
+[17:39:07] <DV> <!ELEMENT test EMPTY>
+[17:39:07] <DV> <!ATTLIST test attr1 NMTOKENS #IMPLIED>
+[17:39:07] <DV> <!ATTLIST test attr2 NMTOKENS #IMPLIED>
+[17:39:07] <DV> <!ATTLIST test attr3 NMTOKENS #IMPLIED>
+[17:39:07] <DV> ]>
+[17:39:07] <DV> <test
+[17:39:07] <DV>    attr1=" a b "
+[17:39:07] <DV>    attr2=" a&#x20;b "
+[17:39:07] <DV>    attr3=" a&#x9;b "
+[17:39:07] <DV>    />
+[17:39:07] <DV> paphio:~/XML -> xmllint --valid tst.xml
+[17:39:07] <DV> <?xml version="1.0"?>
+[17:39:07] <DV> <!DOCTYPE test [
+[17:39:07] <DV> <!ELEMENT test EMPTY>
+[17:39:07] <DV> <!ATTLIST test attr1 NMTOKENS #IMPLIED>
+[17:39:07] <DV> <!ATTLIST test attr2 NMTOKENS #IMPLIED>
+[17:39:07] <DV> <!ATTLIST test attr3 NMTOKENS #IMPLIED>
+[17:39:07] <DV> ]>
+[17:39:07] <DV> <test attr1="a b" attr2="a b" attr3="a&#9;b"/>
+[17:39:07] <DV> paphio:~/XML ->
+[17:39:16] <DV> I think it's okay
+[17:40:28] <PGrosso> DV, so you're saying that your parser implements E20 correctly, right?
+[17:40:48] <DV> assuming I understood E20 point correctly, yes
+[17:41:15] <DV> and that's because I'm unsure taht I pasted the est document and result
+[17:41:25] <DV> s/ est/ test/
+[17:48:56] <richard> does your parser say that document is invalid?
+[17:49:03] <DV> richard: did I understood it ?
+[17:49:11] <DV> richard: no it considers it valid
+[17:49:16] <richard> that document is invalid
+[17:49:47] <DV> ah , well it's unclear 
+[17:50:03] <richard> the normalized value is a-tab-b, which you are correctly serializing as a&#9;b, but it is invalid
+[17:50:11] <DV> richard: okay
+[17:50:23] <DV> that should be really easy to fix
+[17:50:39] <richard> the validity check should require a single space between tokens
+[17:51:03] <DV> no leading and no trailing either
+[17:51:07] <richard> right
+[17:51:18] <DV> which makes sense
+[17:52:42] <richard> a&#32;b is valid, because it turns into a-space-b anyway without any normalization
+[17:54:31] <DV> okay that's attr2 attr2=" a&#x20;b "
+[17:54:44] * DV tends to still think in hexa
+[17:55:59] <DV> richard: and attr2="a&#x20; b" would lead to a validity error too then, if I understand correctly
+[17:56:37] <richard> attr2 is valid
+[17:57:11] <richard> the normalized value is a space b
+- XInclude at the SAX level (libSRVG)
+- fix the C code prototype to bring back doc/libxml-undocumented.txt
+  to a reasonable level
+- Computation of base when HTTP redirect occurs, might affect HTTP
+  interfaces.
+- Computation of base in XInclude. Relativization of URIs.
+- listing all attributes in a node.
+- Better checking of external parsed entities TAG 1234
+- Go through erratas and do the cleanup.
+  http://www.w3.org/XML/xml-19980210-errata ... started ...
+- jamesh suggestion: SAX like functions to save a document ie. call a
+  function to open a new element with given attributes, write character
+  data, close last element, etc
+  + inversted SAX, initial patch in April 2002 archives.
+- htmlParseDoc has parameter encoding which is not used.
+  Function htmlCreateDocParserCtxt ignore it.
+- fix realloc() usage.
+- Stricten the UTF8 conformance (Martin Duerst):
+  http://www.w3.org/2001/06/utf-8-test/.
+  The bad files are in http://www.w3.org/2001/06/utf-8-wrong/.
+  
+
+TODO:
+=====
+
+- move all string manipulation functions (xmlStrdup, xmlStrlen, etc.) to
+  global.c. Bjorn noted that the following files depends on parser.o solely
+  because of these string functions: entities.o, global.o, hash.o, tree.o,
+  xmlIO.o, and xpath.o.
+
+- Optimization of tag strings allocation ?
+
+- maintain coherency of namespace when doing cut'n paste operations
+  => the functions are coded, but need testing
+
+- function to rebuild the ID table
+- functions to rebuild the DTD hash tables (after DTD changes).
+   
+
+EXTENSIONS:
+===========
+
+- Tools to produce man pages from the SGML docs.
+
+- Add Xpointer recognition/API
+
+- Add Xlink recognition/API
+  => started adding an xlink.[ch] with a unified API for XML and HTML.
+     it's crap :-(
+
+- Implement XSchemas
+  => Really need to be done <grin/>
+  - datatype are complete, but structure support is very limited.
+
+- extend the shell with:
+   - edit
+   - load/save
+   - mv (yum, yum, but it's harder because directories are ordered in
+     our case, mvup and mvdown would be required)
+
+
+Done:
+=====
+
+- Add HTML validation using the XHTML DTD
+  - problem: do we want to keep and maintain the code for handling
+    DTD/System ID cache directly in libxml ?
+  => not really done that way, but there are new APIs to check elements
+     or attributes. Otherwise XHTML validation directly ...
+
+- XML Schemas datatypes except Base64 and BinHex
+
+- Relax NG validation
+
+- XmlTextReader streaming API + validation
+
+- Add a DTD cache prefilled with xhtml DTDs and entities and a program to
+  manage them -> like the /usr/bin/install-catalog from SGML
+  right place seems $datadir/xmldtds
+  Maybe this is better left to user apps
+  => use a catalog instead , and xhtml1-dtd package
+
+- Add output to XHTML
+  => XML serializer automatically recognize the DTd and apply the specific
+     rules.
+
+- Fix output of <tst val="x&#xA;y"/>
+
+- compliance to XML-Namespace checking, see section 6 of
+  http://www.w3.org/TR/REC-xml-names/
+
+- Correct standalone checking/emitting (hard)
+  2.9 Standalone Document Declaration
+
+- Implement OASIS XML Catalog support
+  http://www.oasis-open.org/committees/entity/
+
+- Get OASIS testsuite to a more friendly result, check all the results
+  once stable. the check-xml-test-suite.py script does this
+
+- Implement XSLT
+  => libxslt
+
+- Finish XPath
+  => attributes addressing troubles
+  => defaulted attributes handling
+  => namespace axis ?
+  done as XSLT got debugged
+
+- bug reported by Michael Meallin on validation problems
+  => Actually means I need to add support (and warn) for non-deterministic
+     content model.
+- Handle undefined namespaces in entity contents better ... at least
+  issue a warning
+- DOM needs
+  int xmlPruneProp(xmlNodePtr node, xmlAtttrPtr attr);
+  => done it's actually xmlRemoveProp xmlUnsetProp xmlUnsetNsProp
+
+- HTML: handling of Script and style data elements, need special code in
+  the parser and saving functions (handling of < > " ' ...):
+  http://www.w3.org/TR/html4/types.html#type-script
+  Attributes are no problems since entities are accepted.
+- DOM needs
+  xmlAttrPtr xmlNewDocProp(xmlDocPtr doc, const xmlChar *name, const xmlChar *value)
+- problem when parsing hrefs with & with the HTML parser (IRC ac)
+- If the internal encoding is not UTF8 saving to a given encoding doesn't
+  work => fix to force UTF8 encoding ...
+  done, added documentation too
+- Add an ASCII I/O encoder (asciiToUTF8 and UTF8Toascii)
+- Issue warning when using non-absolute namespaces URI.
+- the html parser should add <head> and <body> if they don't exist
+  started, not finished.
+  Done, the automatic closing is added and 3 testcases were inserted
+- Command to force the parser to stop parsing and ignore the rest of the file.
+  xmlStopParser() should allow this, mostly untested
+- support for HTML empty attributes like <hr noshade>
+- plugged iconv() in for support of a large set of encodings.
+- xmlSwitchToEncoding() rewrite done
+- URI checkings (no fragments) rfc2396.txt
+- Added a clean mechanism for overload or added input methods:
+  xmlRegisterInputCallbacks()
+- dynamically adapt the alloc entry point to use g_alloc()/g_free()
+  if the programmer wants it: 
+    - use xmlMemSetup() to reset the routines used.
+- Check attribute normalization especially xmlGetProp()
+- Validity checking problems for NOTATIONS attributes
+- Validity checking problems for ENTITY ENTITIES attributes
+- Parsing of a well balanced chunk xmlParseBalancedChunkMemory()
+- URI module: validation, base, etc ... see uri.[ch]
+- turn tester into a generic program xmllint installed with libxml
+- extend validity checks to go through entities content instead of
+  just labelling them PCDATA
+- Save Dtds using the children list instead of dumping the tables,
+  order is preserved as well as comments and PIs
+- Wrote a notice of changes requires to go from 1.x to 2.x
+- make sure that all SAX callbacks are disabled if a WF error is detected
+- checking/handling of newline normalization
+  http://localhost/www.xml.com/axml/target.html#sec-line-ends
+- correct checking of '&' '%' on entities content.
+- checking of PE/Nesting on entities declaration
+- checking/handling of xml:space
+   - checking done.
+   - handling done, not well tested
+- Language identification code, productions [33] to [38]
+  => done, the check has been added and report WFness errors
+- Conditional sections in DTDs [61] to [65]
+  => should this crap be really implemented ???
+  => Yep OASIS testsuite uses them
+- Allow parsed entities defined in the internal subset to override
+  the ones defined in the external subset (DtD customization).
+  => This mean that the entity content should be computed only at
+     use time, i.e. keep the orig string only at parse time and expand
+     only when referenced from the external subset :-(
+     Needed for complete use of most DTD from Eve Maler
+- Add regression tests for all WFC errors
+  => did some in test/WFC
+  => added OASIS testsuite routines
+     http://xmlsoft.org/conf/result.html
+
+- I18N: http://wap.trondheim.com/vaer/index.phtml is not XML and accepted
+  by the XML parser, UTF-8 should be checked when there is no "encoding"
+  declared !
+- Support for UTF-8 and UTF-16 encoding
+  => added some convertion routines provided by Martin Durst
+     patched them, got fixes from @@@
+     I plan to keep everything internally as UTF-8 (or ISO-Latin-X)
+     this is slightly more costly but more compact, and recent processors
+     efficiency is cache related. The key for good performances is keeping
+     the data set small, so will I.
+  => the new progressive reading routines call the detection code
+     is enabled, tested the ISO->UTF-8 stuff
+- External entities loading: 
+   - allow override by client code
+   - make sure it is alled for all external entities referenced
+  Done, client code should use xmlSetExternalEntityLoader() to set
+  the default loading routine. It will be called each time an external
+  entity entity resolution is triggered.
+- maintain ID coherency when removing/changing attributes
+  The function used to deallocate attributes now check for it being an
+  ID and removes it from the table.
+- push mode parsing i.e. non-blocking state based parser
+  done, both for XML and HTML parsers. Use xmlCreatePushParserCtxt()
+  and xmlParseChunk() and html counterparts.
+  The tester program now has a --push option to select that parser 
+  front-end. Douplicated tests to use both and check results are similar.
+
+- Most of XPath, still see some troubles and occasionnal memleaks.
+- an XML shell, allowing to traverse/manipulate an XML document with
+  a shell like interface, and using XPath for the anming syntax
+  - use of readline and history added when available
+  - the shell interface has been cleanly separated and moved to debugXML.c
+- HTML parser, should be fairly stable now
+- API to search the lang of an attribute
+- Collect IDs at parsing and maintain a table. 
+   PBM: maintain the table coherency
+   PBM: how to detect ID types in absence of DtD !
+- Use it for XPath ID support
+- Add validity checking
+  Should be finished now !
+- Add regression tests with entity substitutions
+
+- External Parsed entities, either XML or external Subset [78] and [79]
+  parsing the xmllang DtD now works, so it should be sufficient for
+  most cases !
+
+- progressive reading. The entity support is a first step toward
+  asbtraction of an input stream. A large part of the context is still
+  located on the stack, moving to a state machine and putting everyting
+  in the parsing context should provide an adequate solution.
+  => Rather than progressive parsing, give more power to the SAX-like
+     interface. Currently the DOM-like representation is built but
+     => it should be possible to define that only as a set of SAX callbacks
+	and remove the tree creation from the parser code.
+	DONE
+
+- DOM support, instead of using a proprietary in memory
+  format for the document representation, the parser should
+  call a DOM API to actually build the resulting document.
+  Then the parser becomes independent of the in-memory
+  representation of the document. Even better using RPC's
+  the parser can actually build the document in another
+  program.
+  => Work started, now the internal representation is by default
+     very near a direct DOM implementation. The DOM glue is implemented
+     as a separate module. See the GNOME gdome module.
+
+- C++ support : John Ehresman <jehresma@dsg.harvard.edu>
+- Updated code to follow more recent specs, added compatibility flag
+- Better error handling, use a dedicated, overridable error
+  handling function.
+- Support for CDATA.
+- Keep track of line numbers for better error reporting.
+- Support for PI (SAX one).
+- Support for Comments (bad, should be in ASAP, they are parsed
+  but not stored), should be configurable.
+- Improve the support of entities on save (+SAX).
+
diff --git a/src/libxml/TODO_SCHEMAS b/src/libxml/TODO_SCHEMAS
new file mode 100644
index 0000000..145a4ed
--- /dev/null
+++ b/src/libxml/TODO_SCHEMAS
@@ -0,0 +1,31 @@
+- implement counted transitions at the automata level
+
+- Unicode:
+  + upgrade to 3.2
+  + improve the python script to generate better test
+    expressions to check the list of ranges.
+
+- Implement the interface at the SAX level
+
+- Implement the missing parts in the Structure part
+   + all content model
+   + enumerations
+   + countless others c.f. the TODO scattered in the code
+
+- Complete the Built-In datatype collections and Facets implementations
+
+- Regression tests based on
+  + the primer:
+    http://www.w3.org/TR/xmlschema-0/
+  + the Schemas Test Collection:
+    http://www.w3.org/2001/05/xmlschema-test-collection/
+  + archives of the schemas-dev list
+
+- Integrity constraints:
+  + what's that ? How need to read about it
+
+- "formal" checking, i.e. go through the full Structure spec and
+  bind code and associated parts of the Schemas spec
+
+- go though the erratas
+  http://www.w3.org/2001/05/xmlschema-errata
diff --git a/src/libxml/include/Makefile b/src/libxml/include/Makefile
new file mode 100644
index 0000000..dbe0542
--- /dev/null
+++ b/src/libxml/include/Makefile
@@ -0,0 +1,530 @@
+# Makefile.in generated by automake 1.8.2 from Makefile.am.
+# include/libxml/Makefile.  Generated from Makefile.in by configure.
+
+# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
+# 2003, 2004  Free Software Foundation, Inc.
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+
+
+srcdir = .
+top_srcdir = ../..
+
+pkgdatadir = $(datadir)/libxml2
+pkglibdir = $(libdir)/libxml2
+pkgincludedir = $(includedir)/libxml2
+top_builddir = ../..
+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
+INSTALL = /home/dtarget/local/bin/install -c
+install_sh_DATA = $(install_sh) -c -m 644
+install_sh_PROGRAM = $(install_sh) -c
+install_sh_SCRIPT = $(install_sh) -c
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = $(program_transform_name)
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+host_triplet = hppa64-hp-hpux11.00
+subdir = include/libxml
+DIST_COMMON = $(srcdir)/Makefile.am $(srcdir)/Makefile.in \
+	$(srcdir)/xmlversion.h.in $(xmlinc_HEADERS)
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+am__aclocal_m4_deps = $(top_srcdir)/acinclude.m4 \
+	$(top_srcdir)/configure.in
+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
+	$(ACLOCAL_M4)
+mkinstalldirs = $(SHELL) $(top_srcdir)/mkinstalldirs
+CONFIG_HEADER = $(top_builddir)/config.h
+CONFIG_CLEAN_FILES = xmlversion.h
+SOURCES =
+DIST_SOURCES =
+am__installdirs = $(DESTDIR)$(xmlincdir)
+xmlincHEADERS_INSTALL = $(INSTALL_HEADER)
+HEADERS = $(xmlinc_HEADERS)
+ETAGS = etags
+CTAGS = ctags
+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
+ACLOCAL = ${SHELL} /home/dtarget/appli/connexion/i2112d7/dvp/libxml2-2.6.9/missing --run aclocal-1.8
+AMDEP_FALSE = #
+AMDEP_TRUE = 
+AMTAR = ${SHELL} /home/dtarget/appli/connexion/i2112d7/dvp/libxml2-2.6.9/missing --run tar
+AR = ar
+AS = as
+AUTOCONF = ${SHELL} /home/dtarget/appli/connexion/i2112d7/dvp/libxml2-2.6.9/missing --run autoconf
+AUTOHEADER = ${SHELL} /home/dtarget/appli/connexion/i2112d7/dvp/libxml2-2.6.9/missing --run autoheader
+AUTOMAKE = ${SHELL} /home/dtarget/appli/connexion/i2112d7/dvp/libxml2-2.6.9/missing --run automake-1.8
+AWK = awk
+C14N_OBJ = c14n.c
+CATALOG_OBJ = catalog.o
+CC = cc -Aa +DD64
+CCDEPMODE = depmode=hp
+CFLAGS = -Wp,-H16800 -Ae -g -Wp,-H30000
+CPP = cc -Aa +DD64 -E
+CPPFLAGS =  -I/home/dtarget/local/include -I/home/dtarget/local/include
+CXX = g++
+CXXCPP = g++ -E
+CXXDEPMODE = depmode=gcc3
+CXXFLAGS = -g -O2
+CYGPATH_W = echo
+DEBUG_OBJ = debugXML.o
+DEFS = -DHAVE_CONFIG_H
+DEPDIR = .deps
+DLLTOOL = dlltool
+DOCB_OBJ = DOCBparser.o
+ECHO = /home/dtarget/local/bin/echo
+ECHO_C = \c
+ECHO_N = 
+ECHO_T = 
+EGREP = grep -E
+EXEEXT = 
+F77 = 
+FFLAGS = 
+FTP_OBJ = nanoftp.o
+HAVE_ISINF = 
+HAVE_ISNAN = 
+HTML_DIR = $(datadir)/doc/$(PACKAGE)-$(VERSION)/html
+HTML_OBJ = HTMLparser.o HTMLtree.o
+HTTP_OBJ = nanohttp.o
+ICONV_LIBS = 
+INSTALL_DATA = ${INSTALL} -m 644
+INSTALL_PROGRAM = ${INSTALL}
+INSTALL_SCRIPT = ${INSTALL}
+INSTALL_STRIP_PROGRAM = ${SHELL} $(install_sh) -c -s
+LDFLAGS = 
+LIBOBJS = 
+LIBS = 
+LIBTOOL = $(SHELL) $(top_builddir)/libtool
+LIBXML_MAJOR_VERSION = 2
+LIBXML_MICRO_VERSION = 9
+LIBXML_MINOR_VERSION = 6
+LIBXML_VERSION = 2.6.9
+LIBXML_VERSION_INFO = 8:9:6
+LIBXML_VERSION_NUMBER = 20609
+LN_S = ln -s
+LTLIBOBJS = 
+MAKEINFO = ${SHELL} /home/dtarget/appli/connexion/i2112d7/dvp/libxml2-2.6.9/missing --run makeinfo
+MV = /home/dtarget/local/bin/mv
+M_LIBS = -lm
+OBJDUMP = objdump
+OBJEXT = o
+PACKAGE = libxml2
+PACKAGE_BUGREPORT = 
+PACKAGE_NAME = 
+PACKAGE_STRING = 
+PACKAGE_TARNAME = 
+PACKAGE_VERSION = 
+PATH_SEPARATOR = :
+PATTERN_TEST = Patterntests
+PYTHON = 
+PYTHON_INCLUDES = 
+PYTHON_SITE_PACKAGES = 
+PYTHON_SUBDIR = 
+PYTHON_TESTS = 
+PYTHON_VERSION = 
+RANLIB = ranlib
+RDL_LIBS = -L/home/dtarget/local/lib -lreadline -lhistory -lcurses
+READER_TEST = Readertests
+RELDATE = Mon May 24 2004
+RM = /home/dtarget/local/bin/rm
+SET_MAKE = 
+SHELL = /bin/sh
+STATIC_BINARIES = 
+STRIP = strip
+TAR = /home/dtarget/local/bin/tar
+TEST_C14N = C14Ntests
+TEST_CATALOG = Catatests
+TEST_DEBUG = Scripttests
+TEST_HTML = HTMLtests
+TEST_PHTML = HTMLPushtests
+TEST_PUSH = XMLPushtests
+TEST_REGEXPS = Regexptests Automatatests
+TEST_SAX = SAXtests
+TEST_SCHEMAS = Schemastests Relaxtests
+TEST_THREADS = Threadtests
+TEST_VALID = Validtests
+TEST_VTIME = VTimingtests
+TEST_XINCLUDE = XIncludetests
+TEST_XPATH = XPathtests
+TEST_XPTR = XPtrtests
+THREADS_W32 = 
+THREAD_CFLAGS =  -D_REENTRANT
+THREAD_LIBS = -lpthread
+U = 
+VERSION = 2.6.9
+WIN32_EXTRA_LDFLAGS = 
+WIN32_EXTRA_LIBADD = 
+WITH_C14N = 1
+WITH_CATALOG = 1
+WITH_DEBUG = 1
+WITH_DOCB = 1
+WITH_FTP = 1
+WITH_HTML = 1
+WITH_HTTP = 1
+WITH_ICONV = 1
+WITH_ISO8859X = 1
+WITH_LEGACY = 1
+WITH_MEM_DEBUG = 0
+WITH_OUTPUT = 1
+WITH_PATTERN = 1
+WITH_PUSH = 1
+WITH_PYTHON_FALSE = 
+WITH_PYTHON_TRUE = #
+WITH_READER = 1
+WITH_REGEXPS = 1
+WITH_SAX1 = 1
+WITH_SCHEMAS = 1
+WITH_THREADS = 1
+WITH_TREE = 1
+WITH_TRIO = 0
+WITH_TRIO_SOURCES_FALSE = 
+WITH_TRIO_SOURCES_TRUE = #
+WITH_VALID = 1
+WITH_WRITER = 1
+WITH_XINCLUDE = 1
+WITH_XPATH = 1
+WITH_XPTR = 1
+XINCLUDE_OBJ = xinclude.o
+XML_CFLAGS = 
+XML_INCLUDEDIR = -I${includedir}/libxml2
+XML_LIBDIR = -L${libdir}
+XML_LIBS = -lxml2 -L/home/dtarget/local/lib -lz -lpthread  -lm 
+XML_LIBTOOLLIBS = libxml2.la
+XPATH_OBJ = xpath.o
+XPTR_OBJ = xpointer.o
+Z_CFLAGS = -I/home/dtarget/local/include
+Z_LIBS = -L/home/dtarget/local/lib -lz
+ac_ct_AR = ar
+ac_ct_AS = 
+ac_ct_CC = cc -Aa +DD64
+ac_ct_CXX = g++
+ac_ct_DLLTOOL = 
+ac_ct_F77 = 
+ac_ct_OBJDUMP = 
+ac_ct_RANLIB = ranlib
+ac_ct_STRIP = strip
+am__fastdepCC_FALSE = 
+am__fastdepCC_TRUE = #
+am__fastdepCXX_FALSE = #
+am__fastdepCXX_TRUE = 
+am__include = include
+am__leading_dot = .
+am__quote = 
+bindir = ${exec_prefix}/bin
+build = hppa64-hp-hpux11.00
+build_alias = 
+build_cpu = hppa64
+build_os = hpux11.00
+build_vendor = hp
+datadir = ${prefix}/share
+exec_prefix = ${prefix}
+host = hppa64-hp-hpux11.00
+host_alias = 
+host_cpu = hppa64
+host_os = hpux11.00
+host_vendor = hp
+includedir = ${prefix}/include
+infodir = ${prefix}/info
+install_sh = /home/dtarget/appli/connexion/i2112d7/dvp/libxml2-2.6.9/install-sh
+libdir = ${exec_prefix}/lib
+libexecdir = ${exec_prefix}/libexec
+localstatedir = ${prefix}/var
+mandir = ${prefix}/man
+mkdir_p = mkdir -p -- .
+oldincludedir = /usr/include
+prefix = /home/dtarget/local
+program_transform_name = s,x,x,
+pythondir = $(libdir)/python${PYTHON_VERSION}/site-packages
+sbindir = ${exec_prefix}/sbin
+sharedstatedir = ${prefix}/com
+sysconfdir = ${prefix}/etc
+target_alias = 
+xmlincdir = $(includedir)/libxml2/libxml
+xmlinc_HEADERS = \
+		SAX.h \
+		entities.h \
+		encoding.h \
+		parser.h \
+		parserInternals.h \
+		xmlerror.h \
+		HTMLparser.h \
+		HTMLtree.h \
+		debugXML.h \
+		tree.h \
+		list.h \
+		hash.h \
+		xpath.h \
+		xpathInternals.h \
+		xpointer.h \
+		xinclude.h \
+		xmlIO.h \
+		xmlmemory.h \
+		nanohttp.h \
+		nanoftp.h \
+		uri.h \
+		valid.h \
+		xlink.h \
+		xmlversion.h \
+		DOCBparser.h \
+		catalog.h \
+		threads.h \
+		globals.h \
+		c14n.h \
+		xmlautomata.h \
+		xmlregexp.h \
+		xmlschemas.h \
+		schemasInternals.h \
+		xmlschemastypes.h \
+		xmlstring.h \
+		xmlunicode.h \
+		xmlreader.h \
+		relaxng.h \
+		dict.h \
+		SAX2.h \
+		xmlexports.h \
+		xmlwriter.h \
+		chvalid.h \
+		pattern.h \
+		xmlsave.h
+
+EXTRA_DIST = xmlversion.h.in
+all: all-am
+
+.SUFFIXES:
+$(srcdir)/Makefile.in:  $(srcdir)/Makefile.am  $(am__configure_deps)
+	@for dep in $?; do \
+	  case '$(am__configure_deps)' in \
+	    *$$dep*) \
+	      cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh \
+		&& exit 0; \
+	      exit 1;; \
+	  esac; \
+	done; \
+	echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu  include/libxml/Makefile'; \
+	cd $(top_srcdir) && \
+	  $(AUTOMAKE) --gnu  include/libxml/Makefile
+.PRECIOUS: Makefile
+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
+	@case '$?' in \
+	  *config.status*) \
+	    cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
+	  *) \
+	    echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
+	    cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
+	esac;
+
+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+
+$(top_srcdir)/configure:  $(am__configure_deps)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(ACLOCAL_M4):  $(am__aclocal_m4_deps)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+xmlversion.h: $(top_builddir)/config.status $(srcdir)/xmlversion.h.in
+	cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@
+
+mostlyclean-libtool:
+	-rm -f *.lo
+
+clean-libtool:
+	-rm -rf .libs _libs
+
+distclean-libtool:
+	-rm -f libtool
+uninstall-info-am:
+install-xmlincHEADERS: $(xmlinc_HEADERS)
+	@$(NORMAL_INSTALL)
+	$(mkdir_p) $(DESTDIR)$(xmlincdir)
+	@list='$(xmlinc_HEADERS)'; for p in $$list; do \
+	  if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \
+	  f="`echo $$p | sed -e 's|^.*/||'`"; \
+	  echo " $(xmlincHEADERS_INSTALL) $$d$$p $(DESTDIR)$(xmlincdir)/$$f"; \
+	  $(xmlincHEADERS_INSTALL) $$d$$p $(DESTDIR)$(xmlincdir)/$$f; \
+	done
+
+uninstall-xmlincHEADERS:
+	@$(NORMAL_UNINSTALL)
+	@list='$(xmlinc_HEADERS)'; for p in $$list; do \
+	  f="`echo $$p | sed -e 's|^.*/||'`"; \
+	  echo " rm -f $(DESTDIR)$(xmlincdir)/$$f"; \
+	  rm -f $(DESTDIR)$(xmlincdir)/$$f; \
+	done
+
+ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
+	list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '    { files[$$0] = 1; } \
+	       END { for (i in files) print i; }'`; \
+	mkid -fID $$unique
+tags: TAGS
+
+TAGS:  $(HEADERS) $(SOURCES)  $(TAGS_DEPENDENCIES) \
+		$(TAGS_FILES) $(LISP)
+	tags=; \
+	here=`pwd`; \
+	list='$(SOURCES) $(HEADERS)  $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '    { files[$$0] = 1; } \
+	       END { for (i in files) print i; }'`; \
+	test -z "$(ETAGS_ARGS)$$tags$$unique" \
+	  || $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+	     $$tags $$unique
+ctags: CTAGS
+CTAGS:  $(HEADERS) $(SOURCES)  $(TAGS_DEPENDENCIES) \
+		$(TAGS_FILES) $(LISP)
+	tags=; \
+	here=`pwd`; \
+	list='$(SOURCES) $(HEADERS)  $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '    { files[$$0] = 1; } \
+	       END { for (i in files) print i; }'`; \
+	test -z "$(CTAGS_ARGS)$$tags$$unique" \
+	  || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
+	     $$tags $$unique
+
+GTAGS:
+	here=`$(am__cd) $(top_builddir) && pwd` \
+	  && cd $(top_srcdir) \
+	  && gtags -i $(GTAGS_ARGS) $$here
+
+distclean-tags:
+	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
+
+distdir: $(DISTFILES)
+	@srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; \
+	topsrcdirstrip=`echo "$(top_srcdir)" | sed 's|.|.|g'`; \
+	list='$(DISTFILES)'; for file in $$list; do \
+	  case $$file in \
+	    $(srcdir)/*) file=`echo "$$file" | sed "s|^$$srcdirstrip/||"`;; \
+	    $(top_srcdir)/*) file=`echo "$$file" | sed "s|^$$topsrcdirstrip/|$(top_builddir)/|"`;; \
+	  esac; \
+	  if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
+	  dir=`echo "$$file" | sed -e 's,/[^/]*$$,,'`; \
+	  if test "$$dir" != "$$file" && test "$$dir" != "."; then \
+	    dir="/$$dir"; \
+	    $(mkdir_p) "$(distdir)$$dir"; \
+	  else \
+	    dir=''; \
+	  fi; \
+	  if test -d $$d/$$file; then \
+	    if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
+	      cp -pR $(srcdir)/$$file $(distdir)$$dir || exit 1; \
+	    fi; \
+	    cp -pR $$d/$$file $(distdir)$$dir || exit 1; \
+	  else \
+	    test -f $(distdir)/$$file \
+	    || cp -p $$d/$$file $(distdir)/$$file \
+	    || exit 1; \
+	  fi; \
+	done
+check-am: all-am
+check: check-am
+all-am: Makefile $(HEADERS)
+installdirs:
+	$(mkdir_p) $(DESTDIR)$(xmlincdir)
+install: install-am
+install-exec: install-exec-am
+install-data: install-data-am
+uninstall: uninstall-am
+
+install-am: all-am
+	@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-am
+install-strip:
+	$(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+	  install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+	  `test -z '$(STRIP)' || \
+	    echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install
+mostlyclean-generic:
+
+clean-generic:
+
+distclean-generic:
+	-rm -f $(CONFIG_CLEAN_FILES)
+
+maintainer-clean-generic:
+	@echo "This command is intended for maintainers to use"
+	@echo "it deletes files that may require special tools to rebuild."
+clean: clean-am
+
+clean-am: clean-generic clean-libtool mostlyclean-am
+
+distclean: distclean-am
+	-rm -f Makefile
+distclean-am: clean-am distclean-generic distclean-libtool \
+	distclean-tags
+
+dvi: dvi-am
+
+dvi-am:
+
+html: html-am
+
+info: info-am
+
+info-am:
+
+install-data-am: install-xmlincHEADERS
+
+install-exec-am:
+	@$(NORMAL_INSTALL)
+	$(MAKE) $(AM_MAKEFLAGS) install-exec-hook
+
+install-info: install-info-am
+
+install-man:
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-am
+	-rm -f Makefile
+maintainer-clean-am: distclean-am maintainer-clean-generic
+
+mostlyclean: mostlyclean-am
+
+mostlyclean-am: mostlyclean-generic mostlyclean-libtool
+
+pdf: pdf-am
+
+pdf-am:
+
+ps: ps-am
+
+ps-am:
+
+uninstall-am: uninstall-info-am uninstall-xmlincHEADERS
+
+.PHONY: CTAGS GTAGS all all-am check check-am clean clean-generic \
+	clean-libtool ctags distclean distclean-generic \
+	distclean-libtool distclean-tags distdir dvi dvi-am html \
+	html-am info info-am install install-am install-data \
+	install-data-am install-exec install-exec-am install-info \
+	install-info-am install-man install-strip \
+	install-xmlincHEADERS installcheck installcheck-am installdirs \
+	maintainer-clean maintainer-clean-generic mostlyclean \
+	mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \
+	tags uninstall uninstall-am uninstall-info-am \
+	uninstall-xmlincHEADERS
+
+
+install-exec-hook:
+	$(mkinstalldirs) $(DESTDIR)$(xmlincdir)
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:
diff --git a/src/libxml/include/Makefile.am b/src/libxml/include/Makefile.am
new file mode 100644
index 0000000..70bf5f3
--- /dev/null
+++ b/src/libxml/include/Makefile.am
@@ -0,0 +1,55 @@
+## Process this file with automake to produce Makefile.in
+
+xmlincdir = $(includedir)/libxml2/libxml
+
+xmlinc_HEADERS = \
+		SAX.h \
+		entities.h \
+		encoding.h \
+		parser.h \
+		parserInternals.h \
+		xmlerror.h \
+		HTMLparser.h \
+		HTMLtree.h \
+		debugXML.h \
+		tree.h \
+		list.h \
+		hash.h \
+		xpath.h \
+		xpathInternals.h \
+		xpointer.h \
+		xinclude.h \
+		xmlIO.h \
+		xmlmemory.h \
+		nanohttp.h \
+		nanoftp.h \
+		uri.h \
+		valid.h \
+		xlink.h \
+		xmlversion.h \
+		DOCBparser.h \
+		catalog.h \
+		threads.h \
+		globals.h \
+		c14n.h \
+		xmlautomata.h \
+		xmlregexp.h \
+		xmlschemas.h \
+		schemasInternals.h \
+		xmlschemastypes.h \
+		xmlstring.h \
+		xmlunicode.h \
+		xmlreader.h \
+		relaxng.h \
+		dict.h \
+		SAX2.h \
+		xmlexports.h \
+		xmlwriter.h \
+		chvalid.h \
+		pattern.h \
+		xmlsave.h
+
+install-exec-hook:
+	$(mkinstalldirs) $(DESTDIR)$(xmlincdir)
+
+EXTRA_DIST = xmlversion.h.in
diff --git a/src/libxml/include/Makefile.in b/src/libxml/include/Makefile.in
new file mode 100644
index 0000000..416fa98
--- /dev/null
+++ b/src/libxml/include/Makefile.in
@@ -0,0 +1,530 @@
+# Makefile.in generated by automake 1.8.2 from Makefile.am.
+# @configure_input@
+
+# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
+# 2003, 2004  Free Software Foundation, Inc.
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+@SET_MAKE@
+
+srcdir = @srcdir@
+top_srcdir = @top_srcdir@
+VPATH = @srcdir@
+pkgdatadir = $(datadir)/@PACKAGE@
+pkglibdir = $(libdir)/@PACKAGE@
+pkgincludedir = $(includedir)/@PACKAGE@
+top_builddir = ../..
+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
+INSTALL = @INSTALL@
+install_sh_DATA = $(install_sh) -c -m 644
+install_sh_PROGRAM = $(install_sh) -c
+install_sh_SCRIPT = $(install_sh) -c
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = $(program_transform_name)
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+host_triplet = @host@
+subdir = include/libxml
+DIST_COMMON = $(srcdir)/Makefile.am $(srcdir)/Makefile.in \
+	$(srcdir)/xmlversion.h.in $(xmlinc_HEADERS)
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+am__aclocal_m4_deps = $(top_srcdir)/acinclude.m4 \
+	$(top_srcdir)/configure.in
+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
+	$(ACLOCAL_M4)
+mkinstalldirs = $(SHELL) $(top_srcdir)/mkinstalldirs
+CONFIG_HEADER = $(top_builddir)/config.h
+CONFIG_CLEAN_FILES = xmlversion.h
+SOURCES =
+DIST_SOURCES =
+am__installdirs = $(DESTDIR)$(xmlincdir)
+xmlincHEADERS_INSTALL = $(INSTALL_HEADER)
+HEADERS = $(xmlinc_HEADERS)
+ETAGS = etags
+CTAGS = ctags
+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
+ACLOCAL = @ACLOCAL@
+AMDEP_FALSE = @AMDEP_FALSE@
+AMDEP_TRUE = @AMDEP_TRUE@
+AMTAR = @AMTAR@
+AR = @AR@
+AS = @AS@
+AUTOCONF = @AUTOCONF@
+AUTOHEADER = @AUTOHEADER@
+AUTOMAKE = @AUTOMAKE@
+AWK = @AWK@
+C14N_OBJ = @C14N_OBJ@
+CATALOG_OBJ = @CATALOG_OBJ@
+CC = @CC@
+CCDEPMODE = @CCDEPMODE@
+CFLAGS = @CFLAGS@
+CPP = @CPP@
+CPPFLAGS = @CPPFLAGS@
+CXX = @CXX@
+CXXCPP = @CXXCPP@
+CXXDEPMODE = @CXXDEPMODE@
+CXXFLAGS = @CXXFLAGS@
+CYGPATH_W = @CYGPATH_W@
+DEBUG_OBJ = @DEBUG_OBJ@
+DEFS = @DEFS@
+DEPDIR = @DEPDIR@
+DLLTOOL = @DLLTOOL@
+DOCB_OBJ = @DOCB_OBJ@
+ECHO = @ECHO@
+ECHO_C = @ECHO_C@
+ECHO_N = @ECHO_N@
+ECHO_T = @ECHO_T@
+EGREP = @EGREP@
+EXEEXT = @EXEEXT@
+F77 = @F77@
+FFLAGS = @FFLAGS@
+FTP_OBJ = @FTP_OBJ@
+HAVE_ISINF = @HAVE_ISINF@
+HAVE_ISNAN = @HAVE_ISNAN@
+HTML_DIR = @HTML_DIR@
+HTML_OBJ = @HTML_OBJ@
+HTTP_OBJ = @HTTP_OBJ@
+ICONV_LIBS = @ICONV_LIBS@
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+LDFLAGS = @LDFLAGS@
+LIBOBJS = @LIBOBJS@
+LIBS = @LIBS@
+LIBTOOL = @LIBTOOL@
+LIBXML_MAJOR_VERSION = @LIBXML_MAJOR_VERSION@
+LIBXML_MICRO_VERSION = @LIBXML_MICRO_VERSION@
+LIBXML_MINOR_VERSION = @LIBXML_MINOR_VERSION@
+LIBXML_VERSION = @LIBXML_VERSION@
+LIBXML_VERSION_INFO = @LIBXML_VERSION_INFO@
+LIBXML_VERSION_NUMBER = @LIBXML_VERSION_NUMBER@
+LN_S = @LN_S@
+LTLIBOBJS = @LTLIBOBJS@
+MAKEINFO = @MAKEINFO@
+MV = @MV@
+M_LIBS = @M_LIBS@
+OBJDUMP = @OBJDUMP@
+OBJEXT = @OBJEXT@
+PACKAGE = @PACKAGE@
+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
+PACKAGE_NAME = @PACKAGE_NAME@
+PACKAGE_STRING = @PACKAGE_STRING@
+PACKAGE_TARNAME = @PACKAGE_TARNAME@
+PACKAGE_VERSION = @PACKAGE_VERSION@
+PATH_SEPARATOR = @PATH_SEPARATOR@
+PATTERN_TEST = @PATTERN_TEST@
+PYTHON = @PYTHON@
+PYTHON_INCLUDES = @PYTHON_INCLUDES@
+PYTHON_SITE_PACKAGES = @PYTHON_SITE_PACKAGES@
+PYTHON_SUBDIR = @PYTHON_SUBDIR@
+PYTHON_TESTS = @PYTHON_TESTS@
+PYTHON_VERSION = @PYTHON_VERSION@
+RANLIB = @RANLIB@
+RDL_LIBS = @RDL_LIBS@
+READER_TEST = @READER_TEST@
+RELDATE = @RELDATE@
+RM = @RM@
+SET_MAKE = @SET_MAKE@
+SHELL = @SHELL@
+STATIC_BINARIES = @STATIC_BINARIES@
+STRIP = @STRIP@
+TAR = @TAR@
+TEST_C14N = @TEST_C14N@
+TEST_CATALOG = @TEST_CATALOG@
+TEST_DEBUG = @TEST_DEBUG@
+TEST_HTML = @TEST_HTML@
+TEST_PHTML = @TEST_PHTML@
+TEST_PUSH = @TEST_PUSH@
+TEST_REGEXPS = @TEST_REGEXPS@
+TEST_SAX = @TEST_SAX@
+TEST_SCHEMAS = @TEST_SCHEMAS@
+TEST_THREADS = @TEST_THREADS@
+TEST_VALID = @TEST_VALID@
+TEST_VTIME = @TEST_VTIME@
+TEST_XINCLUDE = @TEST_XINCLUDE@
+TEST_XPATH = @TEST_XPATH@
+TEST_XPTR = @TEST_XPTR@
+THREADS_W32 = @THREADS_W32@
+THREAD_CFLAGS = @THREAD_CFLAGS@
+THREAD_LIBS = @THREAD_LIBS@
+U = @U@
+VERSION = @VERSION@
+WIN32_EXTRA_LDFLAGS = @WIN32_EXTRA_LDFLAGS@
+WIN32_EXTRA_LIBADD = @WIN32_EXTRA_LIBADD@
+WITH_C14N = @WITH_C14N@
+WITH_CATALOG = @WITH_CATALOG@
+WITH_DEBUG = @WITH_DEBUG@
+WITH_DOCB = @WITH_DOCB@
+WITH_FTP = @WITH_FTP@
+WITH_HTML = @WITH_HTML@
+WITH_HTTP = @WITH_HTTP@
+WITH_ICONV = @WITH_ICONV@
+WITH_ISO8859X = @WITH_ISO8859X@
+WITH_LEGACY = @WITH_LEGACY@
+WITH_MEM_DEBUG = @WITH_MEM_DEBUG@
+WITH_OUTPUT = @WITH_OUTPUT@
+WITH_PATTERN = @WITH_PATTERN@
+WITH_PUSH = @WITH_PUSH@
+WITH_PYTHON_FALSE = @WITH_PYTHON_FALSE@
+WITH_PYTHON_TRUE = @WITH_PYTHON_TRUE@
+WITH_READER = @WITH_READER@
+WITH_REGEXPS = @WITH_REGEXPS@
+WITH_SAX1 = @WITH_SAX1@
+WITH_SCHEMAS = @WITH_SCHEMAS@
+WITH_THREADS = @WITH_THREADS@
+WITH_TREE = @WITH_TREE@
+WITH_TRIO = @WITH_TRIO@
+WITH_TRIO_SOURCES_FALSE = @WITH_TRIO_SOURCES_FALSE@
+WITH_TRIO_SOURCES_TRUE = @WITH_TRIO_SOURCES_TRUE@
+WITH_VALID = @WITH_VALID@
+WITH_WRITER = @WITH_WRITER@
+WITH_XINCLUDE = @WITH_XINCLUDE@
+WITH_XPATH = @WITH_XPATH@
+WITH_XPTR = @WITH_XPTR@
+XINCLUDE_OBJ = @XINCLUDE_OBJ@
+XML_CFLAGS = @XML_CFLAGS@
+XML_INCLUDEDIR = @XML_INCLUDEDIR@
+XML_LIBDIR = @XML_LIBDIR@
+XML_LIBS = @XML_LIBS@
+XML_LIBTOOLLIBS = @XML_LIBTOOLLIBS@
+XPATH_OBJ = @XPATH_OBJ@
+XPTR_OBJ = @XPTR_OBJ@
+Z_CFLAGS = @Z_CFLAGS@
+Z_LIBS = @Z_LIBS@
+ac_ct_AR = @ac_ct_AR@
+ac_ct_AS = @ac_ct_AS@
+ac_ct_CC = @ac_ct_CC@
+ac_ct_CXX = @ac_ct_CXX@
+ac_ct_DLLTOOL = @ac_ct_DLLTOOL@
+ac_ct_F77 = @ac_ct_F77@
+ac_ct_OBJDUMP = @ac_ct_OBJDUMP@
+ac_ct_RANLIB = @ac_ct_RANLIB@
+ac_ct_STRIP = @ac_ct_STRIP@
+am__fastdepCC_FALSE = @am__fastdepCC_FALSE@
+am__fastdepCC_TRUE = @am__fastdepCC_TRUE@
+am__fastdepCXX_FALSE = @am__fastdepCXX_FALSE@
+am__fastdepCXX_TRUE = @am__fastdepCXX_TRUE@
+am__include = @am__include@
+am__leading_dot = @am__leading_dot@
+am__quote = @am__quote@
+bindir = @bindir@
+build = @build@
+build_alias = @build_alias@
+build_cpu = @build_cpu@
+build_os = @build_os@
+build_vendor = @build_vendor@
+datadir = @datadir@
+exec_prefix = @exec_prefix@
+host = @host@
+host_alias = @host_alias@
+host_cpu = @host_cpu@
+host_os = @host_os@
+host_vendor = @host_vendor@
+includedir = @includedir@
+infodir = @infodir@
+install_sh = @install_sh@
+libdir = @libdir@
+libexecdir = @libexecdir@
+localstatedir = @localstatedir@
+mandir = @mandir@
+mkdir_p = @mkdir_p@
+oldincludedir = @oldincludedir@
+prefix = @prefix@
+program_transform_name = @program_transform_name@
+pythondir = @pythondir@
+sbindir = @sbindir@
+sharedstatedir = @sharedstatedir@
+sysconfdir = @sysconfdir@
+target_alias = @target_alias@
+xmlincdir = $(includedir)/libxml2/libxml
+xmlinc_HEADERS = \
+		SAX.h \
+		entities.h \
+		encoding.h \
+		parser.h \
+		parserInternals.h \
+		xmlerror.h \
+		HTMLparser.h \
+		HTMLtree.h \
+		debugXML.h \
+		tree.h \
+		list.h \
+		hash.h \
+		xpath.h \
+		xpathInternals.h \
+		xpointer.h \
+		xinclude.h \
+		xmlIO.h \
+		xmlmemory.h \
+		nanohttp.h \
+		nanoftp.h \
+		uri.h \
+		valid.h \
+		xlink.h \
+		xmlversion.h \
+		DOCBparser.h \
+		catalog.h \
+		threads.h \
+		globals.h \
+		c14n.h \
+		xmlautomata.h \
+		xmlregexp.h \
+		xmlschemas.h \
+		schemasInternals.h \
+		xmlschemastypes.h \
+		xmlstring.h \
+		xmlunicode.h \
+		xmlreader.h \
+		relaxng.h \
+		dict.h \
+		SAX2.h \
+		xmlexports.h \
+		xmlwriter.h \
+		chvalid.h \
+		pattern.h \
+		xmlsave.h
+
+EXTRA_DIST = xmlversion.h.in
+all: all-am
+
+.SUFFIXES:
+$(srcdir)/Makefile.in:  $(srcdir)/Makefile.am  $(am__configure_deps)
+	@for dep in $?; do \
+	  case '$(am__configure_deps)' in \
+	    *$$dep*) \
+	      cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh \
+		&& exit 0; \
+	      exit 1;; \
+	  esac; \
+	done; \
+	echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu  include/libxml/Makefile'; \
+	cd $(top_srcdir) && \
+	  $(AUTOMAKE) --gnu  include/libxml/Makefile
+.PRECIOUS: Makefile
+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
+	@case '$?' in \
+	  *config.status*) \
+	    cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
+	  *) \
+	    echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
+	    cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
+	esac;
+
+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+
+$(top_srcdir)/configure:  $(am__configure_deps)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(ACLOCAL_M4):  $(am__aclocal_m4_deps)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+xmlversion.h: $(top_builddir)/config.status $(srcdir)/xmlversion.h.in
+	cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@
+
+mostlyclean-libtool:
+	-rm -f *.lo
+
+clean-libtool:
+	-rm -rf .libs _libs
+
+distclean-libtool:
+	-rm -f libtool
+uninstall-info-am:
+install-xmlincHEADERS: $(xmlinc_HEADERS)
+	@$(NORMAL_INSTALL)
+	$(mkdir_p) $(DESTDIR)$(xmlincdir)
+	@list='$(xmlinc_HEADERS)'; for p in $$list; do \
+	  if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \
+	  f="`echo $$p | sed -e 's|^.*/||'`"; \
+	  echo " $(xmlincHEADERS_INSTALL) $$d$$p $(DESTDIR)$(xmlincdir)/$$f"; \
+	  $(xmlincHEADERS_INSTALL) $$d$$p $(DESTDIR)$(xmlincdir)/$$f; \
+	done
+
+uninstall-xmlincHEADERS:
+	@$(NORMAL_UNINSTALL)
+	@list='$(xmlinc_HEADERS)'; for p in $$list; do \
+	  f="`echo $$p | sed -e 's|^.*/||'`"; \
+	  echo " rm -f $(DESTDIR)$(xmlincdir)/$$f"; \
+	  rm -f $(DESTDIR)$(xmlincdir)/$$f; \
+	done
+
+ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
+	list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '    { files[$$0] = 1; } \
+	       END { for (i in files) print i; }'`; \
+	mkid -fID $$unique
+tags: TAGS
+
+TAGS:  $(HEADERS) $(SOURCES)  $(TAGS_DEPENDENCIES) \
+		$(TAGS_FILES) $(LISP)
+	tags=; \
+	here=`pwd`; \
+	list='$(SOURCES) $(HEADERS)  $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '    { files[$$0] = 1; } \
+	       END { for (i in files) print i; }'`; \
+	test -z "$(ETAGS_ARGS)$$tags$$unique" \
+	  || $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+	     $$tags $$unique
+ctags: CTAGS
+CTAGS:  $(HEADERS) $(SOURCES)  $(TAGS_DEPENDENCIES) \
+		$(TAGS_FILES) $(LISP)
+	tags=; \
+	here=`pwd`; \
+	list='$(SOURCES) $(HEADERS)  $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '    { files[$$0] = 1; } \
+	       END { for (i in files) print i; }'`; \
+	test -z "$(CTAGS_ARGS)$$tags$$unique" \
+	  || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
+	     $$tags $$unique
+
+GTAGS:
+	here=`$(am__cd) $(top_builddir) && pwd` \
+	  && cd $(top_srcdir) \
+	  && gtags -i $(GTAGS_ARGS) $$here
+
+distclean-tags:
+	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
+
+distdir: $(DISTFILES)
+	@srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; \
+	topsrcdirstrip=`echo "$(top_srcdir)" | sed 's|.|.|g'`; \
+	list='$(DISTFILES)'; for file in $$list; do \
+	  case $$file in \
+	    $(srcdir)/*) file=`echo "$$file" | sed "s|^$$srcdirstrip/||"`;; \
+	    $(top_srcdir)/*) file=`echo "$$file" | sed "s|^$$topsrcdirstrip/|$(top_builddir)/|"`;; \
+	  esac; \
+	  if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
+	  dir=`echo "$$file" | sed -e 's,/[^/]*$$,,'`; \
+	  if test "$$dir" != "$$file" && test "$$dir" != "."; then \
+	    dir="/$$dir"; \
+	    $(mkdir_p) "$(distdir)$$dir"; \
+	  else \
+	    dir=''; \
+	  fi; \
+	  if test -d $$d/$$file; then \
+	    if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
+	      cp -pR $(srcdir)/$$file $(distdir)$$dir || exit 1; \
+	    fi; \
+	    cp -pR $$d/$$file $(distdir)$$dir || exit 1; \
+	  else \
+	    test -f $(distdir)/$$file \
+	    || cp -p $$d/$$file $(distdir)/$$file \
+	    || exit 1; \
+	  fi; \
+	done
+check-am: all-am
+check: check-am
+all-am: Makefile $(HEADERS)
+installdirs:
+	$(mkdir_p) $(DESTDIR)$(xmlincdir)
+install: install-am
+install-exec: install-exec-am
+install-data: install-data-am
+uninstall: uninstall-am
+
+install-am: all-am
+	@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-am
+install-strip:
+	$(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+	  install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+	  `test -z '$(STRIP)' || \
+	    echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install
+mostlyclean-generic:
+
+clean-generic:
+
+distclean-generic:
+	-rm -f $(CONFIG_CLEAN_FILES)
+
+maintainer-clean-generic:
+	@echo "This command is intended for maintainers to use"
+	@echo "it deletes files that may require special tools to rebuild."
+clean: clean-am
+
+clean-am: clean-generic clean-libtool mostlyclean-am
+
+distclean: distclean-am
+	-rm -f Makefile
+distclean-am: clean-am distclean-generic distclean-libtool \
+	distclean-tags
+
+dvi: dvi-am
+
+dvi-am:
+
+html: html-am
+
+info: info-am
+
+info-am:
+
+install-data-am: install-xmlincHEADERS
+
+install-exec-am:
+	@$(NORMAL_INSTALL)
+	$(MAKE) $(AM_MAKEFLAGS) install-exec-hook
+
+install-info: install-info-am
+
+install-man:
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-am
+	-rm -f Makefile
+maintainer-clean-am: distclean-am maintainer-clean-generic
+
+mostlyclean: mostlyclean-am
+
+mostlyclean-am: mostlyclean-generic mostlyclean-libtool
+
+pdf: pdf-am
+
+pdf-am:
+
+ps: ps-am
+
+ps-am:
+
+uninstall-am: uninstall-info-am uninstall-xmlincHEADERS
+
+.PHONY: CTAGS GTAGS all all-am check check-am clean clean-generic \
+	clean-libtool ctags distclean distclean-generic \
+	distclean-libtool distclean-tags distdir dvi dvi-am html \
+	html-am info info-am install install-am install-data \
+	install-data-am install-exec install-exec-am install-info \
+	install-info-am install-man install-strip \
+	install-xmlincHEADERS installcheck installcheck-am installdirs \
+	maintainer-clean maintainer-clean-generic mostlyclean \
+	mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \
+	tags uninstall uninstall-am uninstall-info-am \
+	uninstall-xmlincHEADERS
+
+
+install-exec-hook:
+	$(mkinstalldirs) $(DESTDIR)$(xmlincdir)
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:
diff --git a/src/libxml/include/libxml/DOCBparser.h b/src/libxml/include/libxml/DOCBparser.h
new file mode 100644
index 0000000..d30aaea
--- /dev/null
+++ b/src/libxml/include/libxml/DOCBparser.h
@@ -0,0 +1,90 @@
+/*
+ * Summary: old DocBook SGML parser
+ * Description: interface for a DocBook SGML non-verifying parser
+ * This code is DEPRECATED, and should not be used anymore.
+ *
+ * Copy: See Copyright for the status of this software.
+ *
+ * Author: Daniel Veillard
+ */
+
+#ifndef __DOCB_PARSER_H__
+#define __DOCB_PARSER_H__
+#include <libxml/xmlversion.h>
+#include <libxml/parser.h>
+#include <libxml/parserInternals.h>
+
+#ifndef IN_LIBXML
+#ifdef __GNUC__
+#warning "The DOCBparser module has been deprecated in libxml2-2.6.0"
+#endif
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * Most of the back-end structures from XML and SGML are shared.
+ */
+typedef xmlParserCtxt docbParserCtxt;
+typedef xmlParserCtxtPtr docbParserCtxtPtr;
+typedef xmlSAXHandler docbSAXHandler;
+typedef xmlSAXHandlerPtr docbSAXHandlerPtr;
+typedef xmlParserInput docbParserInput;
+typedef xmlParserInputPtr docbParserInputPtr;
+typedef xmlDocPtr docbDocPtr;
+
+/*
+ * There is only few public functions.
+ */
+XMLPUBFUN int XMLCALL
+		     docbEncodeEntities(unsigned char *out,
+                                        int *outlen,
+                                        const unsigned char *in,
+                                        int *inlen, int quoteChar);
+
+XMLPUBFUN docbDocPtr XMLCALL             
+		     docbSAXParseDoc   (xmlChar *cur,
+                                        const char *encoding,
+                                        docbSAXHandlerPtr sax,
+                                        void *userData);
+XMLPUBFUN docbDocPtr XMLCALL             
+		     docbParseDoc      (xmlChar *cur,
+                                        const char *encoding);
+XMLPUBFUN docbDocPtr XMLCALL             
+		     docbSAXParseFile  (const char *filename,
+                                        const char *encoding,
+                                        docbSAXHandlerPtr sax,
+                                        void *userData);
+XMLPUBFUN docbDocPtr XMLCALL             
+		     docbParseFile     (const char *filename,
+                                        const char *encoding);
+
+/**
+ * Interfaces for the Push mode.
+ */
+XMLPUBFUN void XMLCALL                  
+		     docbFreeParserCtxt      (docbParserCtxtPtr ctxt);
+XMLPUBFUN docbParserCtxtPtr XMLCALL     
+		     docbCreatePushParserCtxt(docbSAXHandlerPtr sax,
+                                              void *user_data,
+                                              const char *chunk,
+                                              int size,
+                                              const char *filename,
+                                              xmlCharEncoding enc);
+XMLPUBFUN int XMLCALL                   
+		     docbParseChunk          (docbParserCtxtPtr ctxt,
+                                              const char *chunk,
+                                              int size,
+                                              int terminate);
+XMLPUBFUN docbParserCtxtPtr XMLCALL       
+		     docbCreateFileParserCtxt(const char *filename,
+                                              const char *encoding);
+XMLPUBFUN int XMLCALL                   
+		     docbParseDocument       (docbParserCtxtPtr ctxt);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* __DOCB_PARSER_H__ */
diff --git a/src/libxml/include/libxml/HTMLparser.h b/src/libxml/include/libxml/HTMLparser.h
new file mode 100644
index 0000000..f39f0bb
--- /dev/null
+++ b/src/libxml/include/libxml/HTMLparser.h
@@ -0,0 +1,295 @@
+/*
+ * Summary: interface for an HTML 4.0 non-verifying parser
+ * Description: this module implements an HTML 4.0 non-verifying parser
+ *              with API compatible with the XML parser ones. It should
+ *              be able to parse "real world" HTML, even if severely
+ *              broken from a specification point of view.
+ *
+ * Copy: See Copyright for the status of this software.
+ *
+ * Author: Daniel Veillard
+ */
+
+#ifndef __HTML_PARSER_H__
+#define __HTML_PARSER_H__
+#include <libxml/xmlversion.h>
+#include <libxml/parser.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * Most of the back-end structures from XML and HTML are shared.
+ */
+typedef xmlParserCtxt htmlParserCtxt;
+typedef xmlParserCtxtPtr htmlParserCtxtPtr;
+typedef xmlParserNodeInfo htmlParserNodeInfo;
+typedef xmlSAXHandler htmlSAXHandler;
+typedef xmlSAXHandlerPtr htmlSAXHandlerPtr;
+typedef xmlParserInput htmlParserInput;
+typedef xmlParserInputPtr htmlParserInputPtr;
+typedef xmlDocPtr htmlDocPtr;
+typedef xmlNodePtr htmlNodePtr;
+
+/*
+ * Internal description of an HTML element, representing HTML 4.01
+ * and XHTML 1.0 (which share the same structure).
+ */
+typedef struct _htmlElemDesc htmlElemDesc;
+typedef htmlElemDesc *htmlElemDescPtr;
+struct _htmlElemDesc {
+    const char *name;	/* The tag name */
+    char startTag;      /* Whether the start tag can be implied */
+    char endTag;        /* Whether the end tag can be implied */
+    char saveEndTag;    /* Whether the end tag should be saved */
+    char empty;         /* Is this an empty element ? */
+    char depr;          /* Is this a deprecated element ? */
+    char dtd;           /* 1: only in Loose DTD, 2: only Frameset one */
+    char isinline;      /* is this a block 0 or inline 1 element */
+    const char *desc;   /* the description */
+
+/* NRK Jan.2003
+ * New fields encapsulating HTML structure
+ *
+ * Bugs:
+ *	This is a very limited representation.  It fails to tell us when
+ *	an element *requires* subelements (we only have whether they're
+ *	allowed or not), and it doesn't tell us where CDATA and PCDATA
+ *	are allowed.  Some element relationships are not fully represented:
+ *	these are flagged with the word MODIFIER
+ */
+    const char** subelts;		/* allowed sub-elements of this element */
+    const char* defaultsubelt;	/* subelement for suggested auto-repair
+					   if necessary or NULL */
+    const char** attrs_opt;		/* Optional Attributes */
+    const char** attrs_depr;		/* Additional deprecated attributes */
+    const char** attrs_req;		/* Required attributes */
+};
+
+/*
+ * Internal description of an HTML entity.
+ */
+typedef struct _htmlEntityDesc htmlEntityDesc;
+typedef htmlEntityDesc *htmlEntityDescPtr;
+struct _htmlEntityDesc {
+    unsigned int value;	/* the UNICODE value for the character */
+    const char *name;	/* The entity name */
+    const char *desc;   /* the description */
+};
+
+/*
+ * There is only few public functions.
+ */
+XMLPUBFUN const htmlElemDesc * XMLCALL 	
+			htmlTagLookup	(const xmlChar *tag);
+XMLPUBFUN const htmlEntityDesc * XMLCALL 	
+			htmlEntityLookup(const xmlChar *name);
+XMLPUBFUN const htmlEntityDesc * XMLCALL 	
+			htmlEntityValueLookup(unsigned int value);
+
+XMLPUBFUN int XMLCALL			
+			htmlIsAutoClosed(htmlDocPtr doc,
+					 htmlNodePtr elem);
+XMLPUBFUN int XMLCALL			
+			htmlAutoCloseTag(htmlDocPtr doc,
+					 const xmlChar *name,
+					 htmlNodePtr elem);
+XMLPUBFUN const htmlEntityDesc * XMLCALL	
+			htmlParseEntityRef(htmlParserCtxtPtr ctxt,
+					 const xmlChar **str);
+XMLPUBFUN int XMLCALL			
+			htmlParseCharRef(htmlParserCtxtPtr ctxt);
+XMLPUBFUN void XMLCALL			
+			htmlParseElement(htmlParserCtxtPtr ctxt);
+
+XMLPUBFUN htmlParserCtxtPtr XMLCALL	
+			htmlCreateMemoryParserCtxt(const char *buffer,
+						   int size);
+
+XMLPUBFUN int XMLCALL			
+			htmlParseDocument(htmlParserCtxtPtr ctxt);
+XMLPUBFUN htmlDocPtr XMLCALL		
+			htmlSAXParseDoc	(xmlChar *cur,
+					 const char *encoding,
+					 htmlSAXHandlerPtr sax,
+					 void *userData);
+XMLPUBFUN htmlDocPtr XMLCALL		
+			htmlParseDoc	(xmlChar *cur,
+					 const char *encoding);
+XMLPUBFUN htmlDocPtr XMLCALL		
+			htmlSAXParseFile(const char *filename,
+					 const char *encoding,
+					 htmlSAXHandlerPtr sax,
+					 void *userData);
+XMLPUBFUN htmlDocPtr XMLCALL		
+			htmlParseFile	(const char *filename,
+					 const char *encoding);
+XMLPUBFUN int XMLCALL			
+			UTF8ToHtml	(unsigned char *out,
+					 int *outlen,
+					 const unsigned char *in,
+					 int *inlen);
+XMLPUBFUN int XMLCALL			
+			htmlEncodeEntities(unsigned char *out,
+					 int *outlen,
+					 const unsigned char *in,
+					 int *inlen, int quoteChar);
+XMLPUBFUN int XMLCALL			
+			htmlIsScriptAttribute(const xmlChar *name);
+XMLPUBFUN int XMLCALL			
+			htmlHandleOmittedElem(int val);
+
+#ifdef LIBXML_PUSH_ENABLED
+/**
+ * Interfaces for the Push mode.
+ */
+XMLPUBFUN htmlParserCtxtPtr XMLCALL	
+			htmlCreatePushParserCtxt(htmlSAXHandlerPtr sax,
+						 void *user_data,
+						 const char *chunk,
+						 int size,
+						 const char *filename,
+						 xmlCharEncoding enc);
+XMLPUBFUN int XMLCALL			
+			htmlParseChunk		(htmlParserCtxtPtr ctxt,
+						 const char *chunk,
+						 int size,
+						 int terminate);
+#endif /* LIBXML_PUSH_ENABLED */
+
+XMLPUBFUN void XMLCALL			
+			htmlFreeParserCtxt	(htmlParserCtxtPtr ctxt);
+
+/*
+ * New set of simpler/more flexible APIs
+ */
+/**
+ * xmlParserOption:
+ *
+ * This is the set of XML parser options that can be passed down
+ * to the xmlReadDoc() and similar calls.
+ */
+typedef enum {
+    HTML_PARSE_NOERROR	= 1<<5,	/* suppress error reports */
+    HTML_PARSE_NOWARNING= 1<<6,	/* suppress warning reports */
+    HTML_PARSE_PEDANTIC	= 1<<7,	/* pedantic error reporting */
+    HTML_PARSE_NOBLANKS	= 1<<8,	/* remove blank nodes */
+    HTML_PARSE_NONET	= 1<<11 /* Forbid network access */
+} htmlParserOption;
+
+XMLPUBFUN void XMLCALL
+		htmlCtxtReset		(htmlParserCtxtPtr ctxt);
+XMLPUBFUN int XMLCALL
+		htmlCtxtUseOptions	(htmlParserCtxtPtr ctxt,
+					 int options);
+XMLPUBFUN htmlDocPtr XMLCALL
+		htmlReadDoc		(const xmlChar *cur,
+					 const char *URL,
+					 const char *encoding,
+					 int options);
+XMLPUBFUN htmlDocPtr XMLCALL
+		htmlReadFile		(const char *URL,
+					 const char *encoding,
+					 int options);
+XMLPUBFUN htmlDocPtr XMLCALL
+		htmlReadMemory		(const char *buffer,
+					 int size,
+					 const char *URL,
+					 const char *encoding,
+					 int options);
+XMLPUBFUN htmlDocPtr XMLCALL
+		htmlReadFd		(int fd,
+					 const char *URL,
+					 const char *encoding,
+					 int options);
+XMLPUBFUN htmlDocPtr XMLCALL
+		htmlReadIO		(xmlInputReadCallback ioread,
+					 xmlInputCloseCallback ioclose,
+					 void *ioctx,
+					 const char *URL,
+					 const char *encoding,
+					 int options);
+XMLPUBFUN htmlDocPtr XMLCALL
+		htmlCtxtReadDoc		(xmlParserCtxtPtr ctxt,
+					 const xmlChar *cur,
+					 const char *URL,
+					 const char *encoding,
+					 int options);
+XMLPUBFUN htmlDocPtr XMLCALL
+		htmlCtxtReadFile		(xmlParserCtxtPtr ctxt,
+					 const char *filename,
+					 const char *encoding,
+					 int options);
+XMLPUBFUN htmlDocPtr XMLCALL
+		htmlCtxtReadMemory		(xmlParserCtxtPtr ctxt,
+					 const char *buffer,
+					 int size,
+					 const char *URL,
+					 const char *encoding,
+					 int options);
+XMLPUBFUN htmlDocPtr XMLCALL
+		htmlCtxtReadFd		(xmlParserCtxtPtr ctxt,
+					 int fd,
+					 const char *URL,
+					 const char *encoding,
+					 int options);
+XMLPUBFUN htmlDocPtr XMLCALL
+		htmlCtxtReadIO		(xmlParserCtxtPtr ctxt,
+					 xmlInputReadCallback ioread,
+					 xmlInputCloseCallback ioclose,
+					 void *ioctx,
+					 const char *URL,
+					 const char *encoding,
+					 int options);
+
+/* NRK/Jan2003: further knowledge of HTML structure
+ */
+typedef enum {
+  HTML_NA = 0 ,		/* something we don't check at all */
+  HTML_INVALID = 0x1 ,
+  HTML_DEPRECATED = 0x2 ,
+  HTML_VALID = 0x4 ,
+  HTML_REQUIRED = 0xc /* VALID bit set so ( & HTML_VALID ) is TRUE */
+} htmlStatus ;
+
+/* Using htmlElemDesc rather than name here, to emphasise the fact
+   that otherwise there's a lookup overhead
+*/
+XMLPUBFUN htmlStatus XMLCALL htmlAttrAllowed(const htmlElemDesc*, const xmlChar*, int) ;
+XMLPUBFUN int XMLCALL htmlElementAllowedHere(const htmlElemDesc*, const xmlChar*) ;
+XMLPUBFUN htmlStatus XMLCALL htmlElementStatusHere(const htmlElemDesc*, const htmlElemDesc*) ;
+XMLPUBFUN htmlStatus XMLCALL htmlNodeStatus(const htmlNodePtr, int) ;
+/**
+ * htmlDefaultSubelement:
+ * @elt: HTML element
+ *
+ * Returns the default subelement for this element
+ */
+#define htmlDefaultSubelement(elt) elt->defaultsubelt
+/**
+ * htmlElementAllowedHereDesc:
+ * @parent: HTML parent element
+ * @elt: HTML element
+ *
+ * Checks whether an HTML element description may be a
+ * direct child of the specified element.
+ *
+ * Returns 1 if allowed; 0 otherwise.
+ */
+#define htmlElementAllowedHereDesc(parent,elt) \
+	htmlElementAllowedHere((parent), (elt)->name)
+/**
+ * htmlRequiredAttrs:
+ * @elt: HTML element
+ *
+ * Returns the attributes required for the specified element.
+ */
+#define htmlRequiredAttrs(elt) (elt)->attrs_req
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __HTML_PARSER_H__ */
diff --git a/src/libxml/include/libxml/HTMLtree.h b/src/libxml/include/libxml/HTMLtree.h
new file mode 100644
index 0000000..157aa67
--- /dev/null
+++ b/src/libxml/include/libxml/HTMLtree.h
@@ -0,0 +1,139 @@
+/*
+ * Summary: specific APIs to process HTML tree, especially serialization
+ * Description: this module implements a few function needed to process
+ *              tree in an HTML specific way.
+ *
+ * Copy: See Copyright for the status of this software.
+ *
+ * Author: Daniel Veillard
+ */
+
+#ifndef __HTML_TREE_H__
+#define __HTML_TREE_H__
+
+#include <stdio.h>
+#include <libxml/xmlversion.h>
+#include <libxml/tree.h>
+#include <libxml/HTMLparser.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/**
+ * HTML_TEXT_NODE:
+ *
+ * Macro. A text node in a HTML document is really implemented
+ * the same way as a text node in an XML document.
+ */
+#define HTML_TEXT_NODE		XML_TEXT_NODE
+/**
+ * HTML_ENTITY_REF_NODE:
+ *
+ * Macro. An entity reference in a HTML document is really implemented
+ * the same way as an entity reference in an XML document.
+ */
+#define HTML_ENTITY_REF_NODE	XML_ENTITY_REF_NODE
+/**
+ * HTML_COMMENT_NODE:
+ *
+ * Macro. A comment in a HTML document is really implemented
+ * the same way as a comment in an XML document.
+ */
+#define HTML_COMMENT_NODE	XML_COMMENT_NODE
+/**
+ * HTML_PRESERVE_NODE:
+ *
+ * Macro. A preserved node in a HTML document is really implemented
+ * the same way as a CDATA section in an XML document.
+ */
+#define HTML_PRESERVE_NODE	XML_CDATA_SECTION_NODE
+/**
+ * HTML_PI_NODE:
+ *
+ * Macro. A processing instruction in a HTML document is really implemented
+ * the same way as a processing instruction in an XML document.
+ */
+#define HTML_PI_NODE		XML_PI_NODE
+
+XMLPUBFUN htmlDocPtr XMLCALL
+		htmlNewDoc		(const xmlChar *URI,
+					 const xmlChar *ExternalID);
+XMLPUBFUN htmlDocPtr XMLCALL	
+		htmlNewDocNoDtD		(const xmlChar *URI,
+					 const xmlChar *ExternalID);
+XMLPUBFUN const xmlChar * XMLCALL	
+		htmlGetMetaEncoding	(htmlDocPtr doc);
+XMLPUBFUN int XMLCALL		
+		htmlSetMetaEncoding	(htmlDocPtr doc,
+					 const xmlChar *encoding);
+#ifdef LIBXML_OUTPUT_ENABLED
+XMLPUBFUN void XMLCALL	    
+		htmlDocDumpMemory	(xmlDocPtr cur,
+					 xmlChar **mem,
+					 int *size);
+XMLPUBFUN int XMLCALL		
+		htmlDocDump		(FILE *f,
+					 xmlDocPtr cur);
+XMLPUBFUN int XMLCALL		
+		htmlSaveFile		(const char *filename,
+					 xmlDocPtr cur);
+XMLPUBFUN int XMLCALL		
+		htmlNodeDump		(xmlBufferPtr buf,
+					 xmlDocPtr doc,
+					 xmlNodePtr cur);
+XMLPUBFUN void XMLCALL		
+		htmlNodeDumpFile	(FILE *out,
+					 xmlDocPtr doc,
+					 xmlNodePtr cur);
+XMLPUBFUN int XMLCALL		
+		htmlNodeDumpFileFormat	(FILE *out,
+					 xmlDocPtr doc,
+					 xmlNodePtr cur,
+					 const char *encoding,
+					 int format);
+XMLPUBFUN int XMLCALL		
+		htmlSaveFileEnc		(const char *filename,
+					 xmlDocPtr cur,
+					 const char *encoding);
+XMLPUBFUN int XMLCALL		
+		htmlSaveFileFormat	(const char *filename,
+					 xmlDocPtr cur,
+					 const char *encoding,
+					 int format);
+
+XMLPUBFUN void XMLCALL		
+		htmlNodeDumpFormatOutput(xmlOutputBufferPtr buf,
+					 xmlDocPtr doc,
+					 xmlNodePtr cur,
+					 const char *encoding,
+					 int format);
+XMLPUBFUN void XMLCALL		
+		htmlDocContentDumpOutput(xmlOutputBufferPtr buf,
+					 xmlDocPtr cur,
+					 const char *encoding);
+XMLPUBFUN void XMLCALL		
+		htmlDocContentDumpFormatOutput(xmlOutputBufferPtr buf,
+					 xmlDocPtr cur,
+					 const char *encoding,
+					 int format);
+XMLPUBFUN void XMLCALL 
+		htmlNodeDumpOutput	(xmlOutputBufferPtr buf, 
+					 xmlDocPtr doc,
+					 xmlNodePtr cur, 
+					 const char *encoding);
+
+#endif /* LIBXML_OUTPUT_ENABLED */
+
+XMLPUBFUN int XMLCALL		
+		htmlIsBooleanAttr	(const xmlChar *name);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __HTML_TREE_H__ */
+
diff --git a/src/libxml/include/libxml/SAX.h b/src/libxml/include/libxml/SAX.h
new file mode 100644
index 0000000..a305b69
--- /dev/null
+++ b/src/libxml/include/libxml/SAX.h
@@ -0,0 +1,165 @@
+/*
+ * Summary: Old SAX version 1 handler, deprecated
+ * Description: DEPRECATED set of SAX version 1 interfaces used to
+ *              build the DOM tree.
+ *
+ * Copy: See Copyright for the status of this software.
+ *
+ * Author: Daniel Veillard
+ */
+
+
+#ifndef __XML_SAX_H__
+#define __XML_SAX_H__
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <libxml/xmlversion.h>
+#include <libxml/parser.h>
+#include <libxml/xlink.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+XMLPUBFUN const xmlChar * XMLCALL
+		getPublicId			(void *ctx);
+XMLPUBFUN const xmlChar * XMLCALL	
+		getSystemId			(void *ctx);
+XMLPUBFUN void XMLCALL		
+		setDocumentLocator		(void *ctx,
+						 xmlSAXLocatorPtr loc);
+    
+XMLPUBFUN int XMLCALL		
+		getLineNumber			(void *ctx);
+XMLPUBFUN int XMLCALL		
+		getColumnNumber			(void *ctx);
+
+XMLPUBFUN int XMLCALL		
+		isStandalone			(void *ctx);
+XMLPUBFUN int XMLCALL		
+		hasInternalSubset		(void *ctx);
+XMLPUBFUN int XMLCALL		
+		hasExternalSubset		(void *ctx);
+
+XMLPUBFUN void XMLCALL		
+		internalSubset			(void *ctx,
+						 const xmlChar *name,
+						 const xmlChar *ExternalID,
+						 const xmlChar *SystemID);
+XMLPUBFUN void XMLCALL		
+		externalSubset			(void *ctx,
+						 const xmlChar *name,
+						 const xmlChar *ExternalID,
+						 const xmlChar *SystemID);
+XMLPUBFUN xmlEntityPtr XMLCALL	
+		getEntity			(void *ctx,
+						 const xmlChar *name);
+XMLPUBFUN xmlEntityPtr XMLCALL	
+		getParameterEntity		(void *ctx,
+						 const xmlChar *name);
+XMLPUBFUN xmlParserInputPtr XMLCALL 
+		resolveEntity			(void *ctx,
+						 const xmlChar *publicId,
+						 const xmlChar *systemId);
+
+XMLPUBFUN void XMLCALL		
+		entityDecl			(void *ctx,
+						 const xmlChar *name,
+						 int type,
+						 const xmlChar *publicId,
+						 const xmlChar *systemId,
+						 xmlChar *content);
+XMLPUBFUN void XMLCALL		
+		attributeDecl			(void *ctx,
+						 const xmlChar *elem,
+						 const xmlChar *fullname,
+						 int type,
+						 int def,
+						 const xmlChar *defaultValue,
+						 xmlEnumerationPtr tree);
+XMLPUBFUN void XMLCALL		
+		elementDecl			(void *ctx,
+						 const xmlChar *name,
+						 int type,
+						 xmlElementContentPtr content);
+XMLPUBFUN void XMLCALL		
+		notationDecl			(void *ctx,
+						 const xmlChar *name,
+						 const xmlChar *publicId,
+						 const xmlChar *systemId);
+XMLPUBFUN void XMLCALL		
+		unparsedEntityDecl		(void *ctx,
+						 const xmlChar *name,
+						 const xmlChar *publicId,
+						 const xmlChar *systemId,
+						 const xmlChar *notationName);
+
+XMLPUBFUN void XMLCALL		
+		startDocument			(void *ctx);
+XMLPUBFUN void XMLCALL		
+		endDocument			(void *ctx);
+XMLPUBFUN void XMLCALL		
+		attribute			(void *ctx,
+						 const xmlChar *fullname,
+						 const xmlChar *value);
+XMLPUBFUN void XMLCALL		
+		startElement			(void *ctx,
+						 const xmlChar *fullname,
+						 const xmlChar **atts);
+XMLPUBFUN void XMLCALL		
+		endElement			(void *ctx,
+						 const xmlChar *name);
+XMLPUBFUN void XMLCALL		
+		reference			(void *ctx,
+						 const xmlChar *name);
+XMLPUBFUN void XMLCALL		
+		characters			(void *ctx,
+						 const xmlChar *ch,
+						 int len);
+XMLPUBFUN void XMLCALL		
+		ignorableWhitespace		(void *ctx,
+						 const xmlChar *ch,
+						 int len);
+XMLPUBFUN void XMLCALL		
+		processingInstruction		(void *ctx,
+						 const xmlChar *target,
+						 const xmlChar *data);
+XMLPUBFUN void XMLCALL		
+		globalNamespace			(void *ctx,
+						 const xmlChar *href,
+						 const xmlChar *prefix);
+XMLPUBFUN void XMLCALL		
+		setNamespace			(void *ctx,
+						 const xmlChar *name);
+XMLPUBFUN xmlNsPtr XMLCALL	
+		getNamespace			(void *ctx);
+XMLPUBFUN int XMLCALL		
+		checkNamespace			(void *ctx,
+						 xmlChar *nameSpace);
+XMLPUBFUN void XMLCALL		
+		namespaceDecl			(void *ctx,
+						 const xmlChar *href,
+						 const xmlChar *prefix);
+XMLPUBFUN void XMLCALL		
+		comment				(void *ctx,
+						 const xmlChar *value);
+XMLPUBFUN void XMLCALL		
+		cdataBlock			(void *ctx,
+						 const xmlChar *value,
+						 int len);
+
+XMLPUBFUN void XMLCALL		
+		initxmlDefaultSAXHandler	(xmlSAXHandlerV1 *hdlr,
+						 int warning);
+#ifdef LIBXML_HTML_ENABLED
+XMLPUBFUN void XMLCALL		
+		inithtmlDefaultSAXHandler	(xmlSAXHandlerV1 *hdlr);
+#endif
+#ifdef LIBXML_DOCB_ENABLED
+XMLPUBFUN void XMLCALL		
+		initdocbDefaultSAXHandler	(xmlSAXHandlerV1 *hdlr);
+#endif
+#ifdef __cplusplus
+}
+#endif
+#endif /* __XML_SAX_H__ */
diff --git a/src/libxml/include/libxml/SAX2.h b/src/libxml/include/libxml/SAX2.h
new file mode 100644
index 0000000..f5cc53c
--- /dev/null
+++ b/src/libxml/include/libxml/SAX2.h
@@ -0,0 +1,188 @@
+/*
+ * Summary: SAX2 parser interface used to build the DOM tree
+ * Description: those are the default SAX2 interfaces used by
+ *              the library when building DOM tree.
+ *
+ * Copy: See Copyright for the status of this software.
+ *
+ * Author: Daniel Veillard
+ */
+
+
+#ifndef __XML_SAX2_H__
+#define __XML_SAX2_H__
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <libxml/xmlversion.h>
+#include <libxml/parser.h>
+#include <libxml/xlink.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+XMLPUBFUN const xmlChar * XMLCALL
+		xmlSAX2GetPublicId		(void *ctx);
+XMLPUBFUN const xmlChar * XMLCALL	
+		xmlSAX2GetSystemId		(void *ctx);
+XMLPUBFUN void XMLCALL		
+		xmlSAX2SetDocumentLocator	(void *ctx,
+						 xmlSAXLocatorPtr loc);
+    
+XMLPUBFUN int XMLCALL		
+		xmlSAX2GetLineNumber		(void *ctx);
+XMLPUBFUN int XMLCALL		
+		xmlSAX2GetColumnNumber		(void *ctx);
+
+XMLPUBFUN int XMLCALL		
+		xmlSAX2IsStandalone		(void *ctx);
+XMLPUBFUN int XMLCALL		
+		xmlSAX2HasInternalSubset	(void *ctx);
+XMLPUBFUN int XMLCALL		
+		xmlSAX2HasExternalSubset	(void *ctx);
+
+XMLPUBFUN void XMLCALL		
+		xmlSAX2InternalSubset		(void *ctx,
+						 const xmlChar *name,
+						 const xmlChar *ExternalID,
+						 const xmlChar *SystemID);
+XMLPUBFUN void XMLCALL		
+		xmlSAX2ExternalSubset		(void *ctx,
+						 const xmlChar *name,
+						 const xmlChar *ExternalID,
+						 const xmlChar *SystemID);
+XMLPUBFUN xmlEntityPtr XMLCALL	
+		xmlSAX2GetEntity		(void *ctx,
+						 const xmlChar *name);
+XMLPUBFUN xmlEntityPtr XMLCALL	
+		xmlSAX2GetParameterEntity	(void *ctx,
+						 const xmlChar *name);
+XMLPUBFUN xmlParserInputPtr XMLCALL 
+		xmlSAX2ResolveEntity		(void *ctx,
+						 const xmlChar *publicId,
+						 const xmlChar *systemId);
+
+XMLPUBFUN void XMLCALL		
+		xmlSAX2EntityDecl		(void *ctx,
+						 const xmlChar *name,
+						 int type,
+						 const xmlChar *publicId,
+						 const xmlChar *systemId,
+						 xmlChar *content);
+XMLPUBFUN void XMLCALL		
+		xmlSAX2AttributeDecl		(void *ctx,
+						 const xmlChar *elem,
+						 const xmlChar *fullname,
+						 int type,
+						 int def,
+						 const xmlChar *defaultValue,
+						 xmlEnumerationPtr tree);
+XMLPUBFUN void XMLCALL		
+		xmlSAX2ElementDecl		(void *ctx,
+						 const xmlChar *name,
+						 int type,
+						 xmlElementContentPtr content);
+XMLPUBFUN void XMLCALL		
+		xmlSAX2NotationDecl		(void *ctx,
+						 const xmlChar *name,
+						 const xmlChar *publicId,
+						 const xmlChar *systemId);
+XMLPUBFUN void XMLCALL		
+		xmlSAX2UnparsedEntityDecl	(void *ctx,
+						 const xmlChar *name,
+						 const xmlChar *publicId,
+						 const xmlChar *systemId,
+						 const xmlChar *notationName);
+
+XMLPUBFUN void XMLCALL		
+		xmlSAX2StartDocument		(void *ctx);
+XMLPUBFUN void XMLCALL		
+		xmlSAX2EndDocument		(void *ctx);
+XMLPUBFUN void XMLCALL		
+		xmlSAX2StartElement		(void *ctx,
+						 const xmlChar *fullname,
+						 const xmlChar **atts);
+XMLPUBFUN void XMLCALL		
+		xmlSAX2EndElement		(void *ctx,
+						 const xmlChar *name);
+XMLPUBFUN void XMLCALL
+		xmlSAX2StartElementNs		(void *ctx,
+						 const xmlChar *localname,
+						 const xmlChar *prefix,
+						 const xmlChar *URI,
+						 int nb_namespaces,
+						 const xmlChar **namespaces,
+						 int nb_attributes,
+						 int nb_defaulted,
+						 const xmlChar **attributes);
+XMLPUBFUN void XMLCALL
+		xmlSAX2EndElementNs		(void *ctx,
+						 const xmlChar *localname,
+						 const xmlChar *prefix,
+						 const xmlChar *URI);
+XMLPUBFUN void XMLCALL		
+		xmlSAX2Reference		(void *ctx,
+						 const xmlChar *name);
+XMLPUBFUN void XMLCALL		
+		xmlSAX2Characters		(void *ctx,
+						 const xmlChar *ch,
+						 int len);
+XMLPUBFUN void XMLCALL		
+		xmlSAX2IgnorableWhitespace	(void *ctx,
+						 const xmlChar *ch,
+						 int len);
+XMLPUBFUN void XMLCALL		
+		xmlSAX2ProcessingInstruction	(void *ctx,
+						 const xmlChar *target,
+						 const xmlChar *data);
+XMLPUBFUN void XMLCALL		
+		xmlSAX2GlobalNamespace		(void *ctx,
+						 const xmlChar *href,
+						 const xmlChar *prefix);
+XMLPUBFUN void XMLCALL		
+		xmlSAX2SetNamespace		(void *ctx,
+						 const xmlChar *name);
+XMLPUBFUN xmlNsPtr XMLCALL	
+		xmlSAX2GetNamespace		(void *ctx);
+XMLPUBFUN int XMLCALL		
+		xmlSAX2CheckNamespace		(void *ctx,
+						 xmlChar *nameSpace);
+XMLPUBFUN void XMLCALL		
+		xmlSAX2NamespaceDecl		(void *ctx,
+						 const xmlChar *href,
+						 const xmlChar *prefix);
+XMLPUBFUN void XMLCALL		
+		xmlSAX2Comment			(void *ctx,
+						 const xmlChar *value);
+XMLPUBFUN void XMLCALL		
+		xmlSAX2CDataBlock		(void *ctx,
+						 const xmlChar *value,
+						 int len);
+
+XMLPUBFUN int XMLCALL
+		xmlSAXDefaultVersion		(int version);
+
+XMLPUBFUN int XMLCALL
+		xmlSAXVersion			(xmlSAXHandler *hdlr,
+						 int version);
+XMLPUBFUN void XMLCALL		
+		xmlSAX2InitDefaultSAXHandler    (xmlSAXHandler *hdlr,
+						 int warning);
+#ifdef LIBXML_HTML_ENABLED
+XMLPUBFUN void XMLCALL		
+		xmlSAX2InitHtmlDefaultSAXHandler(xmlSAXHandler *hdlr);
+#endif
+#ifdef LIBXML_DOCB_ENABLED
+XMLPUBFUN void XMLCALL		
+		xmlSAX2InitDocbDefaultSAXHandler(xmlSAXHandler *hdlr);
+#endif
+XMLPUBFUN void XMLCALL		
+		xmlDefaultSAXHandlerInit	(void);
+XMLPUBFUN void XMLCALL		
+		htmlDefaultSAXHandlerInit	(void);
+XMLPUBFUN void XMLCALL		
+		docbDefaultSAXHandlerInit	(void);
+#ifdef __cplusplus
+}
+#endif
+#endif /* __XML_SAX2_H__ */
diff --git a/src/libxml/include/libxml/c14n.h b/src/libxml/include/libxml/c14n.h
new file mode 100644
index 0000000..4bc441c
--- /dev/null
+++ b/src/libxml/include/libxml/c14n.h
@@ -0,0 +1,103 @@
+/*
+ * Summary: Provide Canonical XML and Exclusive XML Canonicalization
+ * Description: the c14n modules provides a
+ *
+ * "Canonical XML" implementation 
+ * http://www.w3.org/TR/xml-c14n
+ * 
+ * and an
+ *
+ * "Exclusive XML Canonicalization" implementation
+ * http://www.w3.org/TR/xml-exc-c14n
+ 
+ * Copy: See Copyright for the status of this software.
+ * 
+ * Author: Aleksey Sanin <aleksey@aleksey.com>
+ */
+#ifndef __XML_C14N_H__
+#define __XML_C14N_H__    
+#ifdef LIBXML_OUTPUT_ENABLED
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */ 
+
+#include <libxml/xmlversion.h>
+#include <libxml/tree.h>
+#include <libxml/xpath.h> 
+
+/*
+ * XML Canonicazation
+ * http://www.w3.org/TR/xml-c14n
+ *
+ * Exclusive XML Canonicazation
+ * http://www.w3.org/TR/xml-exc-c14n
+ *
+ * Canonical form of an XML document could be created if and only if
+ *  a) default attributes (if any) are added to all nodes
+ *  b) all character and parsed entity references are resolved
+ * In order to achive this in libxml2 the document MUST be loaded with 
+ * following global setings:
+ *    
+ *    xmlLoadExtDtdDefaultValue = XML_DETECT_IDS | XML_COMPLETE_ATTRS;
+ *    xmlSubstituteEntitiesDefault(1);
+ *
+ * or corresponding parser context setting:
+ *    xmlParserCtxtPtr ctxt;
+ *    
+ *    ... 
+ *    ctxt->loadsubset = XML_DETECT_IDS | XML_COMPLETE_ATTRS;
+ *    ctxt->replaceEntities = 1;
+ *    ...
+ */
+
+
+XMLPUBFUN int XMLCALL 		
+		xmlC14NDocSaveTo	(xmlDocPtr doc,
+					 xmlNodeSetPtr nodes,
+					 int exclusive,
+					 xmlChar **inclusive_ns_prefixes,
+					 int with_comments, 
+					 xmlOutputBufferPtr buf);
+
+XMLPUBFUN int XMLCALL
+		xmlC14NDocDumpMemory	(xmlDocPtr doc,
+					 xmlNodeSetPtr nodes,
+					 int exclusive,
+					 xmlChar **inclusive_ns_prefixes,
+					 int with_comments, 
+					 xmlChar **doc_txt_ptr);
+
+XMLPUBFUN int XMLCALL
+		xmlC14NDocSave		(xmlDocPtr doc,
+					 xmlNodeSetPtr nodes,
+					 int exclusive,
+					 xmlChar **inclusive_ns_prefixes,
+					 int with_comments, 
+					 const char* filename,
+					 int compression);
+
+
+/**
+ * This is the core C14N function
+ */
+typedef int (*xmlC14NIsVisibleCallback)	(void* user_data, 
+					 xmlNodePtr node,
+					 xmlNodePtr parent);
+
+XMLPUBFUN int XMLCALL
+		xmlC14NExecute		(xmlDocPtr doc,
+					 xmlC14NIsVisibleCallback is_visible_callback,
+					 void* user_data,				 
+					 int exclusive,
+					 xmlChar **inclusive_ns_prefixes,
+					 int with_comments, 
+					 xmlOutputBufferPtr buf);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* LIBXML_OUTPUT_ENABLED */
+#endif /* __XML_C14N_H__ */
+
diff --git a/src/libxml/include/libxml/catalog.h b/src/libxml/include/libxml/catalog.h
new file mode 100644
index 0000000..2996330
--- /dev/null
+++ b/src/libxml/include/libxml/catalog.h
@@ -0,0 +1,181 @@
+/**
+ * Summary: interfaces to the Catalog handling system
+ * Description: the catalog module implements the support for
+ * XML Catalogs and SGML catalogs
+ *
+ * SGML Open Technical Resolution TR9401:1997.
+ * http://www.jclark.com/sp/catalog.htm
+ *
+ * XML Catalogs Working Draft 06 August 2001
+ * http://www.oasis-open.org/committees/entity/spec-2001-08-06.html
+ *
+ * Copy: See Copyright for the status of this software.
+ *
+ * Author: Daniel Veillard
+ */
+
+#ifndef __XML_CATALOG_H__
+#define __XML_CATALOG_H__
+
+#include <stdio.h>
+
+#include <libxml/xmlversion.h>
+#include <libxml/xmlstring.h>
+
+#ifdef LIBXML_CATALOG_ENABLED
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * XML_CATALOGS_NAMESPACE:
+ *
+ * The namespace for the XML Catalogs elements.
+ */
+#define XML_CATALOGS_NAMESPACE					\
+    (const xmlChar *) "urn:oasis:names:tc:entity:xmlns:xml:catalog"
+/**
+ * XML_CATALOG_PI:
+ *
+ * The specific XML Catalog Processing Instuction name.
+ */
+#define XML_CATALOG_PI						\
+    (const xmlChar *) "oasis-xml-catalog"
+
+/*
+ * The API is voluntarily limited to general cataloging.
+ */
+typedef enum {
+    XML_CATA_PREFER_NONE = 0,
+    XML_CATA_PREFER_PUBLIC = 1,
+    XML_CATA_PREFER_SYSTEM
+} xmlCatalogPrefer;
+
+typedef enum {
+    XML_CATA_ALLOW_NONE = 0,
+    XML_CATA_ALLOW_GLOBAL = 1,
+    XML_CATA_ALLOW_DOCUMENT = 2,
+    XML_CATA_ALLOW_ALL = 3
+} xmlCatalogAllow;
+
+typedef struct _xmlCatalog xmlCatalog;
+typedef xmlCatalog *xmlCatalogPtr;
+
+/*
+ * Operations on a given catalog.
+ */
+XMLPUBFUN xmlCatalogPtr XMLCALL
+		xmlNewCatalog		(int sgml);
+XMLPUBFUN xmlCatalogPtr XMLCALL	
+		xmlLoadACatalog		(const char *filename);
+XMLPUBFUN xmlCatalogPtr XMLCALL	
+		xmlLoadSGMLSuperCatalog	(const char *filename);
+XMLPUBFUN int XMLCALL		
+		xmlConvertSGMLCatalog	(xmlCatalogPtr catal);
+XMLPUBFUN int XMLCALL		
+		xmlACatalogAdd		(xmlCatalogPtr catal,
+					 const xmlChar *type,
+					 const xmlChar *orig,
+					 const xmlChar *replace);
+XMLPUBFUN int XMLCALL		
+		xmlACatalogRemove	(xmlCatalogPtr catal,
+					 const xmlChar *value);
+XMLPUBFUN xmlChar * XMLCALL	
+		xmlACatalogResolve	(xmlCatalogPtr catal,
+					 const xmlChar *pubID,
+	                                 const xmlChar *sysID);
+XMLPUBFUN xmlChar * XMLCALL	
+		xmlACatalogResolveSystem(xmlCatalogPtr catal,
+					 const xmlChar *sysID);
+XMLPUBFUN xmlChar * XMLCALL	
+		xmlACatalogResolvePublic(xmlCatalogPtr catal,
+					 const xmlChar *pubID);
+XMLPUBFUN xmlChar * XMLCALL	
+		xmlACatalogResolveURI	(xmlCatalogPtr catal,
+					 const xmlChar *URI);
+#ifdef LIBXML_OUTPUT_ENABLED
+XMLPUBFUN void XMLCALL		
+		xmlACatalogDump		(xmlCatalogPtr catal,
+					 FILE *out);
+#endif /* LIBXML_OUTPUT_ENABLED */
+XMLPUBFUN void XMLCALL		
+		xmlFreeCatalog		(xmlCatalogPtr catal);
+XMLPUBFUN int XMLCALL		
+		xmlCatalogIsEmpty	(xmlCatalogPtr catal);
+
+/*
+ * Global operations.
+ */
+XMLPUBFUN void XMLCALL		
+		xmlInitializeCatalog	(void);
+XMLPUBFUN int XMLCALL		
+		xmlLoadCatalog		(const char *filename);
+XMLPUBFUN void XMLCALL		
+		xmlLoadCatalogs		(const char *paths);
+XMLPUBFUN void XMLCALL		
+		xmlCatalogCleanup	(void);
+#ifdef LIBXML_OUTPUT_ENABLED
+XMLPUBFUN void XMLCALL		
+		xmlCatalogDump		(FILE *out);
+#endif /* LIBXML_OUTPUT_ENABLED */
+XMLPUBFUN xmlChar * XMLCALL	
+		xmlCatalogResolve	(const xmlChar *pubID,
+	                                 const xmlChar *sysID);
+XMLPUBFUN xmlChar * XMLCALL	
+		xmlCatalogResolveSystem	(const xmlChar *sysID);
+XMLPUBFUN xmlChar * XMLCALL	
+		xmlCatalogResolvePublic	(const xmlChar *pubID);
+XMLPUBFUN xmlChar * XMLCALL	
+		xmlCatalogResolveURI	(const xmlChar *URI);
+XMLPUBFUN int XMLCALL		
+		xmlCatalogAdd		(const xmlChar *type,
+					 const xmlChar *orig,
+					 const xmlChar *replace);
+XMLPUBFUN int XMLCALL		
+		xmlCatalogRemove	(const xmlChar *value);
+XMLPUBFUN xmlDocPtr XMLCALL	
+		xmlParseCatalogFile	(const char *filename);
+XMLPUBFUN int XMLCALL		
+		xmlCatalogConvert	(void);
+
+/*
+ * Strictly minimal interfaces for per-document catalogs used
+ * by the parser.
+ */
+XMLPUBFUN void XMLCALL		
+		xmlCatalogFreeLocal	(void *catalogs);
+XMLPUBFUN void * XMLCALL		
+		xmlCatalogAddLocal	(void *catalogs,
+					 const xmlChar *URL);
+XMLPUBFUN xmlChar * XMLCALL	
+		xmlCatalogLocalResolve	(void *catalogs,
+					 const xmlChar *pubID,
+	                                 const xmlChar *sysID);
+XMLPUBFUN xmlChar * XMLCALL	
+		xmlCatalogLocalResolveURI(void *catalogs,
+					 const xmlChar *URI);
+/*
+ * Preference settings.
+ */
+XMLPUBFUN int XMLCALL		
+		xmlCatalogSetDebug	(int level);
+XMLPUBFUN xmlCatalogPrefer XMLCALL 
+		xmlCatalogSetDefaultPrefer(xmlCatalogPrefer prefer);
+XMLPUBFUN void XMLCALL		
+		xmlCatalogSetDefaults	(xmlCatalogAllow allow);
+XMLPUBFUN xmlCatalogAllow XMLCALL	
+		xmlCatalogGetDefaults	(void);
+
+
+/* DEPRECATED interfaces */
+XMLPUBFUN const xmlChar * XMLCALL	
+		xmlCatalogGetSystem	(const xmlChar *sysID);
+XMLPUBFUN const xmlChar * XMLCALL	
+		xmlCatalogGetPublic	(const xmlChar *pubID);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* LIBXML_CATALOG_ENABLED */
+#endif /* __XML_CATALOG_H__ */
diff --git a/src/libxml/include/libxml/chvalid.h b/src/libxml/include/libxml/chvalid.h
new file mode 100644
index 0000000..6301a91
--- /dev/null
+++ b/src/libxml/include/libxml/chvalid.h
@@ -0,0 +1,230 @@
+/*
+ * Summary: Unicode character range checking
+ * Description: this module exports interfaces for the character
+ *		 range validation APIs
+ *
+ * This file is automatically generated from the cvs source
+ * definition files using the genChRanges.py Python script
+ *
+ * Generation date: Tue Nov 18 08:14:21 2003
+ * Sources: chvalid.def
+ * Author: William Brack <wbrack@mmm.com.hk>
+ */
+
+#ifndef __XML_CHVALID_H__
+#define __XML_CHVALID_H__
+
+#include <libxml/xmlversion.h>
+#include <libxml/xmlstring.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * Define our typedefs and structures
+ *
+ */
+typedef struct _xmlChSRange xmlChSRange;
+typedef xmlChSRange *xmlChSRangePtr;
+struct _xmlChSRange {
+    unsigned short	low;
+    unsigned short	high;
+};
+
+typedef struct _xmlChLRange xmlChLRange;
+typedef xmlChLRange *xmlChLRangePtr;
+struct _xmlChLRange {
+    unsigned int	low;
+    unsigned int	high;
+};
+
+typedef struct _xmlChRangeGroup xmlChRangeGroup;
+typedef xmlChRangeGroup *xmlChRangeGroupPtr;
+struct _xmlChRangeGroup {
+    int			nbShortRange;
+    int			nbLongRange;
+    xmlChSRangePtr	shortRange;	/* points to an array of ranges */
+    xmlChLRangePtr	longRange;
+};
+
+/**
+ * Range checking routine
+ */
+XMLPUBFUN int XMLCALL
+		xmlCharInRange(unsigned int val, const xmlChRangeGroupPtr group);
+
+
+/**
+ * xmlIsBaseChar_ch:
+ * @c: char to validate
+ *
+ * Automatically generated by genChRanges.py
+ */
+#define xmlIsBaseChar_ch(c)	(((0x41 <= (c)) && ((c) <= 0x5a)) || \
+				 ((0x61 <= (c)) && ((c) <= 0x7a)) || \
+				 ((0xc0 <= (c)) && ((c) <= 0xd6)) || \
+				 ((0xd8 <= (c)) && ((c) <= 0xf6)) || \
+				  (0xf8 <= (c)))
+
+/**
+ * xmlIsBaseCharQ:
+ * @c: char to validate
+ *
+ * Automatically generated by genChRanges.py
+ */
+#define xmlIsBaseCharQ(c)	(((c) < 0x100) ? \
+				 xmlIsBaseChar_ch((c)) : \
+				 xmlCharInRange((c), &xmlIsBaseCharGroup))
+
+XMLPUBVAR xmlChRangeGroup xmlIsBaseCharGroup;
+
+/**
+ * xmlIsBlank_ch:
+ * @c: char to validate
+ *
+ * Automatically generated by genChRanges.py
+ */
+#define xmlIsBlank_ch(c)	(((c) == 0x20) || \
+				 ((0x9 <= (c)) && ((c) <= 0xa)) || \
+				 ((c) == 0xd))
+
+/**
+ * xmlIsBlankQ:
+ * @c: char to validate
+ *
+ * Automatically generated by genChRanges.py
+ */
+#define xmlIsBlankQ(c)		(((c) < 0x100) ? \
+				 xmlIsBlank_ch((c)) : 0)
+
+
+/**
+ * xmlIsChar_ch:
+ * @c: char to validate
+ *
+ * Automatically generated by genChRanges.py
+ */
+#define xmlIsChar_ch(c)		(((0x9 <= (c)) && ((c) <= 0xa)) || \
+				 ((c) == 0xd) || \
+				  (0x20 <= (c)))
+
+/**
+ * xmlIsCharQ:
+ * @c: char to validate
+ *
+ * Automatically generated by genChRanges.py
+ */
+#define xmlIsCharQ(c)		(((c) < 0x100) ? \
+				 xmlIsChar_ch((c)) :\
+				(((0x100 <= (c)) && ((c) <= 0xd7ff)) || \
+				 ((0xe000 <= (c)) && ((c) <= 0xfffd)) || \
+				 ((0x10000 <= (c)) && ((c) <= 0x10ffff))))
+
+XMLPUBVAR xmlChRangeGroup xmlIsCharGroup;
+
+/**
+ * xmlIsCombiningQ:
+ * @c: char to validate
+ *
+ * Automatically generated by genChRanges.py
+ */
+#define xmlIsCombiningQ(c)	(((c) < 0x100) ? \
+				 0 : \
+				 xmlCharInRange((c), &xmlIsCombiningGroup))
+
+XMLPUBVAR xmlChRangeGroup xmlIsCombiningGroup;
+
+/**
+ * xmlIsDigit_ch:
+ * @c: char to validate
+ *
+ * Automatically generated by genChRanges.py
+ */
+#define xmlIsDigit_ch(c)	(((0x30 <= (c)) && ((c) <= 0x39)))
+
+/**
+ * xmlIsDigitQ:
+ * @c: char to validate
+ *
+ * Automatically generated by genChRanges.py
+ */
+#define xmlIsDigitQ(c)		(((c) < 0x100) ? \
+				 xmlIsDigit_ch((c)) : \
+				 xmlCharInRange((c), &xmlIsDigitGroup))
+
+XMLPUBVAR xmlChRangeGroup xmlIsDigitGroup;
+
+/**
+ * xmlIsExtender_ch:
+ * @c: char to validate
+ *
+ * Automatically generated by genChRanges.py
+ */
+#define xmlIsExtender_ch(c)	(((c) == 0xb7))
+
+/**
+ * xmlIsExtenderQ:
+ * @c: char to validate
+ *
+ * Automatically generated by genChRanges.py
+ */
+#define xmlIsExtenderQ(c)	(((c) < 0x100) ? \
+				 xmlIsExtender_ch((c)) : \
+				 xmlCharInRange((c), &xmlIsExtenderGroup))
+
+XMLPUBVAR xmlChRangeGroup xmlIsExtenderGroup;
+
+/**
+ * xmlIsIdeographicQ:
+ * @c: char to validate
+ *
+ * Automatically generated by genChRanges.py
+ */
+#define xmlIsIdeographicQ(c)	(((c) < 0x100) ? \
+				 0 :\
+				(((0x4e00 <= (c)) && ((c) <= 0x9fa5)) || \
+				 ((c) == 0x3007) || \
+				 ((0x3021 <= (c)) && ((c) <= 0x3029))))
+
+XMLPUBVAR xmlChRangeGroup xmlIsIdeographicGroup;
+XMLPUBVAR unsigned char xmlIsPubidChar_tab[256];
+
+/**
+ * xmlIsPubidChar_ch:
+ * @c: char to validate
+ *
+ * Automatically generated by genChRanges.py
+ */
+#define xmlIsPubidChar_ch(c)	(xmlIsPubidChar_tab[(c)])
+
+/**
+ * xmlIsPubidCharQ:
+ * @c: char to validate
+ *
+ * Automatically generated by genChRanges.py
+ */
+#define xmlIsPubidCharQ(c)	(((c) < 0x100) ? \
+				 xmlIsPubidChar_ch((c)) : 0)
+
+XMLPUBFUN int XMLCALL
+		xmlIsBaseChar(unsigned int ch);
+XMLPUBFUN int XMLCALL
+		xmlIsBlank(unsigned int ch);
+XMLPUBFUN int XMLCALL
+		xmlIsChar(unsigned int ch);
+XMLPUBFUN int XMLCALL
+		xmlIsCombining(unsigned int ch);
+XMLPUBFUN int XMLCALL
+		xmlIsDigit(unsigned int ch);
+XMLPUBFUN int XMLCALL
+		xmlIsExtender(unsigned int ch);
+XMLPUBFUN int XMLCALL
+		xmlIsIdeographic(unsigned int ch);
+XMLPUBFUN int XMLCALL
+		xmlIsPubidChar(unsigned int ch);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* __XML_CHVALID_H__ */
diff --git a/src/libxml/include/libxml/debugXML.h b/src/libxml/include/libxml/debugXML.h
new file mode 100644
index 0000000..85966e5
--- /dev/null
+++ b/src/libxml/include/libxml/debugXML.h
@@ -0,0 +1,196 @@
+/*
+ * Summary: Tree debugging APIs
+ * Description: Interfaces to a set of routines used for debugging the tree
+ *              produced by the XML parser.
+ *
+ * Copy: See Copyright for the status of this software.
+ *
+ * Author: Daniel Veillard
+ */
+
+#ifndef __DEBUG_XML__
+#define __DEBUG_XML__
+#include <stdio.h>
+#include <libxml/xmlversion.h>
+#include <libxml/tree.h>
+
+#ifdef LIBXML_DEBUG_ENABLED
+
+#include <libxml/xpath.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * The standard Dump routines.
+ */
+XMLPUBFUN void XMLCALL	
+	xmlDebugDumpString	(FILE *output,
+				 const xmlChar *str);
+XMLPUBFUN void XMLCALL	
+	xmlDebugDumpAttr	(FILE *output,
+				 xmlAttrPtr attr,
+				 int depth);
+XMLPUBFUN void XMLCALL	
+	xmlDebugDumpAttrList	(FILE *output,
+				 xmlAttrPtr attr,
+				 int depth);
+XMLPUBFUN void XMLCALL	
+	xmlDebugDumpOneNode	(FILE *output,
+				 xmlNodePtr node,
+				 int depth);
+XMLPUBFUN void XMLCALL
+	xmlDebugDumpNode	(FILE *output,
+				 xmlNodePtr node,
+				 int depth);
+XMLPUBFUN void XMLCALL
+	xmlDebugDumpNodeList	(FILE *output,
+				 xmlNodePtr node,
+				 int depth);
+XMLPUBFUN void XMLCALL
+	xmlDebugDumpDocumentHead(FILE *output,
+				 xmlDocPtr doc);
+XMLPUBFUN void XMLCALL
+	xmlDebugDumpDocument	(FILE *output,
+				 xmlDocPtr doc);
+XMLPUBFUN void XMLCALL	
+	xmlDebugDumpDTD		(FILE *output,
+				 xmlDtdPtr dtd);
+XMLPUBFUN void XMLCALL	
+	xmlDebugDumpEntities	(FILE *output,
+				 xmlDocPtr doc);
+
+XMLPUBFUN void XMLCALL	
+	xmlLsOneNode		(FILE *output, xmlNodePtr node);
+XMLPUBFUN int XMLCALL	
+	xmlLsCountNode		(xmlNodePtr node);
+
+XMLPUBFUN const char * XMLCALL 
+	xmlBoolToText		(int boolval);
+
+/****************************************************************
+ *								*
+ *	 The XML shell related structures and functions		*
+ *								*
+ ****************************************************************/
+
+/**
+ * xmlShellReadlineFunc:
+ * @prompt:  a string prompt
+ *
+ * This is a generic signature for the XML shell input function.
+ *
+ * Returns a string which will be freed by the Shell.
+ */
+typedef char * (* xmlShellReadlineFunc)(char *prompt);
+
+/**
+ * xmlShellCtxt:
+ *
+ * A debugging shell context.
+ * TODO: add the defined function tables.
+ */
+typedef struct _xmlShellCtxt xmlShellCtxt;
+typedef xmlShellCtxt *xmlShellCtxtPtr;
+struct _xmlShellCtxt {
+    char *filename;
+    xmlDocPtr doc;
+    xmlNodePtr node;
+    xmlXPathContextPtr pctxt;
+    int loaded;
+    FILE *output;
+    xmlShellReadlineFunc input;
+};
+
+/**
+ * xmlShellCmd:
+ * @ctxt:  a shell context
+ * @arg:  a string argument
+ * @node:  a first node
+ * @node2:  a second node
+ *
+ * This is a generic signature for the XML shell functions.
+ *
+ * Returns an int, negative returns indicating errors.
+ */
+typedef int (* xmlShellCmd) (xmlShellCtxtPtr ctxt,
+                             char *arg,
+			     xmlNodePtr node,
+			     xmlNodePtr node2);
+
+XMLPUBFUN void XMLCALL	
+	xmlShellPrintXPathError	(int errorType,
+				 const char *arg);
+XMLPUBFUN void XMLCALL	
+	xmlShellPrintNode	(xmlNodePtr node);
+XMLPUBFUN void XMLCALL	
+	xmlShellPrintXPathResult(xmlXPathObjectPtr list);
+XMLPUBFUN int XMLCALL	
+	xmlShellList		(xmlShellCtxtPtr ctxt,
+				 char *arg,
+				 xmlNodePtr node,
+				 xmlNodePtr node2);
+XMLPUBFUN int XMLCALL	
+	xmlShellBase		(xmlShellCtxtPtr ctxt,
+				 char *arg,
+				 xmlNodePtr node,
+				 xmlNodePtr node2);
+XMLPUBFUN int XMLCALL	
+	xmlShellDir		(xmlShellCtxtPtr ctxt,
+				 char *arg,
+				 xmlNodePtr node,
+				 xmlNodePtr node2);
+XMLPUBFUN int XMLCALL	
+	xmlShellCat		(xmlShellCtxtPtr ctxt,
+				 char *arg,
+				 xmlNodePtr node,
+				 xmlNodePtr node2);
+XMLPUBFUN int XMLCALL	
+	xmlShellLoad		(xmlShellCtxtPtr ctxt,
+				 char *filename,
+				 xmlNodePtr node,
+				 xmlNodePtr node2);
+#ifdef LIBXML_OUTPUT_ENABLED
+XMLPUBFUN int XMLCALL	
+	xmlShellWrite		(xmlShellCtxtPtr ctxt,
+				 char *filename,
+				 xmlNodePtr node,
+				 xmlNodePtr node2);
+XMLPUBFUN int XMLCALL	
+	xmlShellSave		(xmlShellCtxtPtr ctxt,
+				 char *filename,
+				 xmlNodePtr node,
+				 xmlNodePtr node2);
+#endif /* LIBXML_OUTPUT_ENABLED */
+XMLPUBFUN int XMLCALL	
+	xmlShellValidate	(xmlShellCtxtPtr ctxt,
+				 char *dtd,
+				 xmlNodePtr node,
+				 xmlNodePtr node2);
+XMLPUBFUN int XMLCALL	
+	xmlShellDu		(xmlShellCtxtPtr ctxt,
+				 char *arg,
+				 xmlNodePtr tree,
+				 xmlNodePtr node2);
+XMLPUBFUN int XMLCALL	
+	xmlShellPwd		(xmlShellCtxtPtr ctxt,
+				 char *buffer,
+				 xmlNodePtr node,
+				 xmlNodePtr node2);
+
+/*
+ * The Shell interface.
+ */
+XMLPUBFUN void XMLCALL	
+	xmlShell		(xmlDocPtr doc,
+				 char *filename,
+				 xmlShellReadlineFunc input,
+				 FILE *output);
+			 
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* LIBXML_DEBUG_ENABLED */
+#endif /* __DEBUG_XML__ */
diff --git a/src/libxml/include/libxml/dict.h b/src/libxml/include/libxml/dict.h
new file mode 100644
index 0000000..874ba3d
--- /dev/null
+++ b/src/libxml/include/libxml/dict.h
@@ -0,0 +1,58 @@
+/*
+ * Summary: string dictionnary
+ * Description: dictionary of reusable strings, just used to avoid allocation
+ *         and freeing operations.
+ *
+ * Copy: See Copyright for the status of this software.
+ *
+ * Author: Daniel Veillard
+ */
+
+#ifndef __XML_DICT_H__
+#define __XML_DICT_H__
+
+#include <libxml/xmlversion.h>
+#include <libxml/tree.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * The dictionnary.
+ */
+typedef struct _xmlDict xmlDict;
+typedef xmlDict *xmlDictPtr;
+
+/*
+ * Constructor and destructor.
+ */
+XMLPUBFUN xmlDictPtr XMLCALL
+			xmlDictCreate	(void);
+XMLPUBFUN xmlDictPtr XMLCALL
+			xmlDictCreateSub(xmlDictPtr sub);
+XMLPUBFUN int XMLCALL
+			xmlDictReference(xmlDictPtr dict);
+XMLPUBFUN void XMLCALL			
+			xmlDictFree	(xmlDictPtr dict);
+
+/*
+ * Lookup of entry in the dictionnary.
+ */
+XMLPUBFUN const xmlChar * XMLCALL		
+			xmlDictLookup	(xmlDictPtr dict,
+		                         const xmlChar *name,
+		                         int len);
+XMLPUBFUN const xmlChar * XMLCALL		
+			xmlDictQLookup	(xmlDictPtr dict,
+		                         const xmlChar *prefix,
+		                         const xmlChar *name);
+XMLPUBFUN int XMLCALL
+			xmlDictOwns	(xmlDictPtr dict,
+					 const xmlChar *str);
+XMLPUBFUN int XMLCALL			
+			xmlDictSize	(xmlDictPtr dict);
+#ifdef __cplusplus
+}
+#endif
+#endif /* ! __XML_DICT_H__ */
diff --git a/src/libxml/include/libxml/encoding.h b/src/libxml/include/libxml/encoding.h
new file mode 100644
index 0000000..76c5bbc
--- /dev/null
+++ b/src/libxml/include/libxml/encoding.h
@@ -0,0 +1,224 @@
+/*
+ * Summary: interface for the encoding conversion functions
+ * Description: interface for the encoding conversion functions needed for
+ *              XML basic encoding and iconv() support.
+ *
+ * Related specs are
+ * rfc2044        (UTF-8 and UTF-16) F. Yergeau Alis Technologies
+ * [ISO-10646]    UTF-8 and UTF-16 in Annexes
+ * [ISO-8859-1]   ISO Latin-1 characters codes.
+ * [UNICODE]      The Unicode Consortium, "The Unicode Standard --
+ *                Worldwide Character Encoding -- Version 1.0", Addison-
+ *                Wesley, Volume 1, 1991, Volume 2, 1992.  UTF-8 is
+ *                described in Unicode Technical Report #4.
+ * [US-ASCII]     Coded Character Set--7-bit American Standard Code for
+ *                Information Interchange, ANSI X3.4-1986.
+ *
+ * Copy: See Copyright for the status of this software.
+ *
+ * Author: Daniel Veillard
+ */
+
+#ifndef __XML_CHAR_ENCODING_H__
+#define __XML_CHAR_ENCODING_H__
+
+#include <libxml/xmlversion.h>
+
+#ifdef LIBXML_ICONV_ENABLED
+#include <iconv.h>
+#endif
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * xmlCharEncoding:
+ *
+ * Predefined values for some standard encodings.
+ * Libxml does not do beforehand translation on UTF8 and ISOLatinX.
+ * It also supports ASCII, ISO-8859-1, and UTF16 (LE and BE) by default.
+ *
+ * Anything else would have to be translated to UTF8 before being
+ * given to the parser itself. The BOM for UTF16 and the encoding
+ * declaration are looked at and a converter is looked for at that
+ * point. If not found the parser stops here as asked by the XML REC. A
+ * converter can be registered by the user using xmlRegisterCharEncodingHandler
+ * but the current form doesn't allow stateful transcoding (a serious
+ * problem agreed !). If iconv has been found it will be used
+ * automatically and allow stateful transcoding, the simplest is then
+ * to be sure to enable iconv and to provide iconv libs for the encoding
+ * support needed.
+ *
+ * Note that the generic "UTF-16" is not a predefined value.  Instead, only
+ * the specific UTF-16LE and UTF-16BE are present.
+ */
+typedef enum {
+    XML_CHAR_ENCODING_ERROR=   -1, /* No char encoding detected */
+    XML_CHAR_ENCODING_NONE=	0, /* No char encoding detected */
+    XML_CHAR_ENCODING_UTF8=	1, /* UTF-8 */
+    XML_CHAR_ENCODING_UTF16LE=	2, /* UTF-16 little endian */
+    XML_CHAR_ENCODING_UTF16BE=	3, /* UTF-16 big endian */
+    XML_CHAR_ENCODING_UCS4LE=	4, /* UCS-4 little endian */
+    XML_CHAR_ENCODING_UCS4BE=	5, /* UCS-4 big endian */
+    XML_CHAR_ENCODING_EBCDIC=	6, /* EBCDIC uh! */
+    XML_CHAR_ENCODING_UCS4_2143=7, /* UCS-4 unusual ordering */
+    XML_CHAR_ENCODING_UCS4_3412=8, /* UCS-4 unusual ordering */
+    XML_CHAR_ENCODING_UCS2=	9, /* UCS-2 */
+    XML_CHAR_ENCODING_8859_1=	10,/* ISO-8859-1 ISO Latin 1 */
+    XML_CHAR_ENCODING_8859_2=	11,/* ISO-8859-2 ISO Latin 2 */
+    XML_CHAR_ENCODING_8859_3=	12,/* ISO-8859-3 */
+    XML_CHAR_ENCODING_8859_4=	13,/* ISO-8859-4 */
+    XML_CHAR_ENCODING_8859_5=	14,/* ISO-8859-5 */
+    XML_CHAR_ENCODING_8859_6=	15,/* ISO-8859-6 */
+    XML_CHAR_ENCODING_8859_7=	16,/* ISO-8859-7 */
+    XML_CHAR_ENCODING_8859_8=	17,/* ISO-8859-8 */
+    XML_CHAR_ENCODING_8859_9=	18,/* ISO-8859-9 */
+    XML_CHAR_ENCODING_2022_JP=  19,/* ISO-2022-JP */
+    XML_CHAR_ENCODING_SHIFT_JIS=20,/* Shift_JIS */
+    XML_CHAR_ENCODING_EUC_JP=   21,/* EUC-JP */
+    XML_CHAR_ENCODING_ASCII=    22 /* pure ASCII */
+} xmlCharEncoding;
+
+/**
+ * xmlCharEncodingInputFunc:
+ * @out:  a pointer to an array of bytes to store the UTF-8 result
+ * @outlen:  the length of @out
+ * @in:  a pointer to an array of chars in the original encoding
+ * @inlen:  the length of @in
+ *
+ * Take a block of chars in the original encoding and try to convert
+ * it to an UTF-8 block of chars out.
+ *
+ * Returns the number of bytes written, -1 if lack of space, or -2
+ *     if the transcoding failed.
+ * The value of @inlen after return is the number of octets consumed
+ *     if the return value is positive, else unpredictiable.
+ * The value of @outlen after return is the number of octets consumed.
+ */
+typedef int (* xmlCharEncodingInputFunc)(unsigned char *out, int *outlen,
+                                         const unsigned char *in, int *inlen);
+
+
+/**
+ * xmlCharEncodingOutputFunc:
+ * @out:  a pointer to an array of bytes to store the result
+ * @outlen:  the length of @out
+ * @in:  a pointer to an array of UTF-8 chars
+ * @inlen:  the length of @in
+ *
+ * Take a block of UTF-8 chars in and try to convert it to another
+ * encoding.
+ * Note: a first call designed to produce heading info is called with
+ * in = NULL. If stateful this should also initialize the encoder state.
+ *
+ * Returns the number of bytes written, -1 if lack of space, or -2
+ *     if the transcoding failed.
+ * The value of @inlen after return is the number of octets consumed
+ *     if the return value is positive, else unpredictiable.
+ * The value of @outlen after return is the number of octets produced.
+ */
+typedef int (* xmlCharEncodingOutputFunc)(unsigned char *out, int *outlen,
+                                          const unsigned char *in, int *inlen);
+
+
+/*
+ * Block defining the handlers for non UTF-8 encodings.
+ * If iconv is supported, there are two extra fields.
+ */
+
+typedef struct _xmlCharEncodingHandler xmlCharEncodingHandler;
+typedef xmlCharEncodingHandler *xmlCharEncodingHandlerPtr;
+struct _xmlCharEncodingHandler {
+    char                       *name;
+    xmlCharEncodingInputFunc   input;
+    xmlCharEncodingOutputFunc  output;
+#ifdef LIBXML_ICONV_ENABLED
+    iconv_t                    iconv_in;
+    iconv_t                    iconv_out;
+#endif /* LIBXML_ICONV_ENABLED */
+};
+
+#ifdef __cplusplus
+}
+#endif
+#include <libxml/tree.h>
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * Interfaces for encoding handlers.
+ */
+XMLPUBFUN void XMLCALL	
+	xmlInitCharEncodingHandlers	(void);
+XMLPUBFUN void XMLCALL	
+	xmlCleanupCharEncodingHandlers	(void);
+XMLPUBFUN void XMLCALL	
+	xmlRegisterCharEncodingHandler	(xmlCharEncodingHandlerPtr handler);
+XMLPUBFUN xmlCharEncodingHandlerPtr XMLCALL
+	xmlGetCharEncodingHandler	(xmlCharEncoding enc);
+XMLPUBFUN xmlCharEncodingHandlerPtr XMLCALL
+	xmlFindCharEncodingHandler	(const char *name);
+XMLPUBFUN xmlCharEncodingHandlerPtr XMLCALL
+	xmlNewCharEncodingHandler	(const char *name, 
+                          		 xmlCharEncodingInputFunc input,
+                          		 xmlCharEncodingOutputFunc output);
+
+/*
+ * Interfaces for encoding names and aliases.
+ */
+XMLPUBFUN int XMLCALL	
+	xmlAddEncodingAlias		(const char *name,
+					 const char *alias);
+XMLPUBFUN int XMLCALL	
+	xmlDelEncodingAlias		(const char *alias);
+XMLPUBFUN const char * XMLCALL
+	xmlGetEncodingAlias		(const char *alias);
+XMLPUBFUN void XMLCALL	
+	xmlCleanupEncodingAliases	(void);
+XMLPUBFUN xmlCharEncoding XMLCALL
+	xmlParseCharEncoding		(const char *name);
+XMLPUBFUN const char * XMLCALL
+	xmlGetCharEncodingName		(xmlCharEncoding enc);
+
+/*
+ * Interfaces directly used by the parsers.
+ */
+XMLPUBFUN xmlCharEncoding XMLCALL
+	xmlDetectCharEncoding		(const unsigned char *in,
+					 int len);
+
+XMLPUBFUN int XMLCALL	
+	xmlCharEncOutFunc		(xmlCharEncodingHandler *handler,
+					 xmlBufferPtr out,
+					 xmlBufferPtr in);
+
+XMLPUBFUN int XMLCALL	
+	xmlCharEncInFunc		(xmlCharEncodingHandler *handler,
+					 xmlBufferPtr out,
+					 xmlBufferPtr in);
+XMLPUBFUN int XMLCALL
+	xmlCharEncFirstLine		(xmlCharEncodingHandler *handler,
+					 xmlBufferPtr out,
+					 xmlBufferPtr in);
+XMLPUBFUN int XMLCALL	
+	xmlCharEncCloseFunc		(xmlCharEncodingHandler *handler);
+
+/*
+ * Export a few useful functions
+ */
+XMLPUBFUN int XMLCALL	
+	UTF8Toisolat1			(unsigned char *out,
+					 int *outlen,
+					 const unsigned char *in,
+					 int *inlen);
+XMLPUBFUN int XMLCALL	
+	isolat1ToUTF8			(unsigned char *out,
+					 int *outlen,
+					 const unsigned char *in,
+					 int *inlen);
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __XML_CHAR_ENCODING_H__ */
diff --git a/src/libxml/include/libxml/entities.h b/src/libxml/include/libxml/entities.h
new file mode 100644
index 0000000..2dc1217
--- /dev/null
+++ b/src/libxml/include/libxml/entities.h
@@ -0,0 +1,131 @@
+/*
+ * Summary: interface for the XML entities handling
+ * Description: this module provides some of the entity API needed
+ *              for the parser and applications.
+ *
+ * Copy: See Copyright for the status of this software.
+ *
+ * Author: Daniel Veillard
+ */
+
+#ifndef __XML_ENTITIES_H__
+#define __XML_ENTITIES_H__
+
+#include <libxml/xmlversion.h>
+#include <libxml/tree.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * The different valid entity types.
+ */
+typedef enum {
+    XML_INTERNAL_GENERAL_ENTITY = 1,
+    XML_EXTERNAL_GENERAL_PARSED_ENTITY = 2,
+    XML_EXTERNAL_GENERAL_UNPARSED_ENTITY = 3,
+    XML_INTERNAL_PARAMETER_ENTITY = 4,
+    XML_EXTERNAL_PARAMETER_ENTITY = 5,
+    XML_INTERNAL_PREDEFINED_ENTITY = 6
+} xmlEntityType;
+
+/*
+ * An unit of storage for an entity, contains the string, the value
+ * and the linkind data needed for the linking in the hash table.
+ */
+
+struct _xmlEntity {
+    void           *_private;	        /* application data */
+    xmlElementType          type;       /* XML_ENTITY_DECL, must be second ! */
+    const xmlChar          *name;	/* Entity name */
+    struct _xmlNode    *children;	/* First child link */
+    struct _xmlNode        *last;	/* Last child link */
+    struct _xmlDtd       *parent;	/* -> DTD */
+    struct _xmlNode        *next;	/* next sibling link  */
+    struct _xmlNode        *prev;	/* previous sibling link  */
+    struct _xmlDoc          *doc;       /* the containing document */
+
+    xmlChar                *orig;	/* content without ref substitution */
+    xmlChar             *content;	/* content or ndata if unparsed */
+    int                   length;	/* the content length */
+    xmlEntityType          etype;	/* The entity type */
+    const xmlChar    *ExternalID;	/* External identifier for PUBLIC */
+    const xmlChar      *SystemID;	/* URI for a SYSTEM or PUBLIC Entity */
+
+    struct _xmlEntity     *nexte;	/* unused */
+    const xmlChar           *URI;	/* the full URI as computed */
+    int                    owner;	/* does the entity own the childrens */
+};
+
+/*
+ * All entities are stored in an hash table.
+ * There is 2 separate hash tables for global and parameter entities.
+ */
+
+typedef struct _xmlHashTable xmlEntitiesTable;
+typedef xmlEntitiesTable *xmlEntitiesTablePtr;
+
+/*
+ * External functions:
+ */
+
+XMLPUBFUN void XMLCALL		
+		xmlInitializePredefinedEntities	(void);
+XMLPUBFUN xmlEntityPtr XMLCALL
+			xmlAddDocEntity		(xmlDocPtr doc,
+						 const xmlChar *name,
+						 int type,
+						 const xmlChar *ExternalID,
+						 const xmlChar *SystemID,
+						 const xmlChar *content);
+XMLPUBFUN xmlEntityPtr XMLCALL		
+			xmlAddDtdEntity		(xmlDocPtr doc,
+						 const xmlChar *name,
+						 int type,
+						 const xmlChar *ExternalID,
+						 const xmlChar *SystemID,
+						 const xmlChar *content);
+XMLPUBFUN xmlEntityPtr XMLCALL		
+			xmlGetPredefinedEntity	(const xmlChar *name);
+XMLPUBFUN xmlEntityPtr XMLCALL		
+			xmlGetDocEntity		(xmlDocPtr doc,
+						 const xmlChar *name);
+XMLPUBFUN xmlEntityPtr XMLCALL		
+			xmlGetDtdEntity		(xmlDocPtr doc,
+						 const xmlChar *name);
+XMLPUBFUN xmlEntityPtr XMLCALL		
+			xmlGetParameterEntity	(xmlDocPtr doc,
+						 const xmlChar *name);
+XMLPUBFUN const xmlChar * XMLCALL		
+			xmlEncodeEntities	(xmlDocPtr doc,
+						 const xmlChar *input);
+XMLPUBFUN xmlChar * XMLCALL		
+			xmlEncodeEntitiesReentrant(xmlDocPtr doc,
+						 const xmlChar *input);
+XMLPUBFUN xmlChar * XMLCALL		
+			xmlEncodeSpecialChars	(xmlDocPtr doc,
+						 const xmlChar *input);
+XMLPUBFUN xmlEntitiesTablePtr XMLCALL	
+			xmlCreateEntitiesTable	(void);
+XMLPUBFUN xmlEntitiesTablePtr XMLCALL	
+			xmlCopyEntitiesTable	(xmlEntitiesTablePtr table);
+XMLPUBFUN void XMLCALL			
+			xmlFreeEntitiesTable	(xmlEntitiesTablePtr table);
+#ifdef LIBXML_OUTPUT_ENABLED
+XMLPUBFUN void XMLCALL			
+			xmlDumpEntitiesTable	(xmlBufferPtr buf,
+						 xmlEntitiesTablePtr table);
+XMLPUBFUN void XMLCALL			
+			xmlDumpEntityDecl	(xmlBufferPtr buf,
+						 xmlEntityPtr ent);
+#endif /* LIBXML_OUTPUT_ENABLED */
+XMLPUBFUN void XMLCALL			
+			xmlCleanupPredefinedEntities(void);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+# endif /* __XML_ENTITIES_H__ */
diff --git a/src/libxml/include/libxml/globals.h b/src/libxml/include/libxml/globals.h
new file mode 100644
index 0000000..1be2d1f
--- /dev/null
+++ b/src/libxml/include/libxml/globals.h
@@ -0,0 +1,422 @@
+/*
+ * Summary: interface for all global variables of the library
+ * Description: all the global variables and thread handling for
+ *              those variables is handled by this module.
+ *
+ * The bottom of this file is automatically generated by build_glob.py
+ * based on the description file global.data
+ *
+ * Copy: See Copyright for the status of this software.
+ *
+ * Author: Gary Pennington <Gary.Pennington@uk.sun.com>, Daniel Veillard
+ */
+
+#ifndef __XML_GLOBALS_H
+#define __XML_GLOBALS_H
+
+#include <libxml/xmlversion.h>
+#include <libxml/parser.h>
+#include <libxml/xmlerror.h>
+#include <libxml/SAX.h>
+#include <libxml/SAX2.h>
+#include <libxml/xmlmemory.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+XMLPUBFUN void XMLCALL xmlInitGlobals(void);
+XMLPUBFUN void XMLCALL xmlCleanupGlobals(void);
+
+/*
+ * Externally global symbols which need to be protected for backwards
+ * compatibility support.
+ */
+
+#undef	docbDefaultSAXHandler
+#undef	htmlDefaultSAXHandler
+#undef	oldXMLWDcompatibility
+#undef	xmlBufferAllocScheme
+#undef	xmlDefaultBufferSize
+#undef	xmlDefaultSAXHandler
+#undef	xmlDefaultSAXLocator
+#undef	xmlDoValidityCheckingDefaultValue
+#undef	xmlFree
+#undef	xmlGenericError
+#undef	xmlStructuredError
+#undef	xmlGenericErrorContext
+#undef	xmlGetWarningsDefaultValue
+#undef	xmlIndentTreeOutput
+#undef  xmlTreeIndentString
+#undef	xmlKeepBlanksDefaultValue
+#undef	xmlLineNumbersDefaultValue
+#undef	xmlLoadExtDtdDefaultValue
+#undef	xmlMalloc
+#undef	xmlMallocAtomic
+#undef	xmlMemStrdup
+#undef	xmlParserDebugEntities
+#undef	xmlParserVersion
+#undef	xmlPedanticParserDefaultValue
+#undef	xmlRealloc
+#undef	xmlSaveNoEmptyTags
+#undef	xmlSubstituteEntitiesDefaultValue
+#undef  xmlRegisterNodeDefaultValue
+#undef  xmlDeregisterNodeDefaultValue
+#undef  xmlLastError
+
+typedef void (*xmlRegisterNodeFunc) (xmlNodePtr node);
+typedef void (*xmlDeregisterNodeFunc) (xmlNodePtr node);
+
+typedef struct _xmlGlobalState xmlGlobalState;
+typedef xmlGlobalState *xmlGlobalStatePtr;
+struct _xmlGlobalState 
+{
+	const char *xmlParserVersion;
+
+	xmlSAXLocator xmlDefaultSAXLocator;
+	xmlSAXHandlerV1 xmlDefaultSAXHandler;
+	xmlSAXHandlerV1 docbDefaultSAXHandler;
+	xmlSAXHandlerV1 htmlDefaultSAXHandler;
+
+	xmlFreeFunc xmlFree;
+	xmlMallocFunc xmlMalloc;
+	xmlStrdupFunc xmlMemStrdup;
+	xmlReallocFunc xmlRealloc;
+
+	xmlGenericErrorFunc xmlGenericError;
+	xmlStructuredErrorFunc xmlStructuredError;
+	void *xmlGenericErrorContext;
+
+	int oldXMLWDcompatibility;
+
+	xmlBufferAllocationScheme xmlBufferAllocScheme;
+	int xmlDefaultBufferSize;
+
+	int xmlSubstituteEntitiesDefaultValue;
+	int xmlDoValidityCheckingDefaultValue;
+	int xmlGetWarningsDefaultValue;
+	int xmlKeepBlanksDefaultValue;
+	int xmlLineNumbersDefaultValue;
+	int xmlLoadExtDtdDefaultValue;
+	int xmlParserDebugEntities;
+	int xmlPedanticParserDefaultValue;
+
+	int xmlSaveNoEmptyTags;
+	int xmlIndentTreeOutput;
+	const char *xmlTreeIndentString;
+
+  	xmlRegisterNodeFunc xmlRegisterNodeDefaultValue;
+  	xmlDeregisterNodeFunc xmlDeregisterNodeDefaultValue;
+
+	xmlMallocFunc xmlMallocAtomic;
+	xmlError xmlLastError;
+};
+
+#ifdef __cplusplus
+}
+#endif
+#include <libxml/threads.h>
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+XMLPUBFUN void XMLCALL	xmlInitializeGlobalState(xmlGlobalStatePtr gs);
+
+XMLPUBFUN void XMLCALL xmlThrDefSetGenericErrorFunc(void *ctx, xmlGenericErrorFunc handler);
+
+XMLPUBFUN void XMLCALL xmlThrDefSetStructuredErrorFunc(void *ctx, xmlStructuredErrorFunc handler);
+
+XMLPUBFUN xmlRegisterNodeFunc XMLCALL xmlRegisterNodeDefault(xmlRegisterNodeFunc func);
+XMLPUBFUN xmlRegisterNodeFunc XMLCALL xmlThrDefRegisterNodeDefault(xmlRegisterNodeFunc func);
+XMLPUBFUN xmlDeregisterNodeFunc XMLCALL xmlDeregisterNodeDefault(xmlDeregisterNodeFunc func);
+XMLPUBFUN xmlDeregisterNodeFunc XMLCALL xmlThrDefDeregisterNodeDefault(xmlDeregisterNodeFunc func);
+
+/** DOC_DISABLE */
+/*
+ * In general the memory allocation entry points are not kept
+ * thread specific but this can be overridden by LIBXML_THREAD_ALLOC_ENABLED
+ *    - xmlMalloc
+ *    - xmlMallocAtomic
+ *    - xmlRealloc
+ *    - xmlMemStrdup
+ *    - xmlFree
+ */
+
+#ifdef LIBXML_THREAD_ALLOC_ENABLED
+#ifdef LIBXML_THREAD_ENABLED
+XMLPUBFUN  xmlMallocFunc * XMLCALL __xmlMalloc(void);
+#define xmlMalloc \
+(*(__xmlMalloc()))
+#else
+XMLPUBVAR xmlMallocFunc xmlMalloc;
+#endif
+
+#ifdef LIBXML_THREAD_ENABLED
+XMLPUBFUN  xmlMallocFunc * XMLCALL __xmlMallocAtomic(void);
+#define xmlMallocAtomic \
+(*(__xmlMallocAtomic()))
+#else
+XMLPUBVAR xmlMallocFunc xmlMallocAtomic;
+#endif
+
+#ifdef LIBXML_THREAD_ENABLED
+XMLPUBFUN  xmlReallocFunc * XMLCALL __xmlRealloc(void);
+#define xmlRealloc \
+(*(__xmlRealloc()))
+#else
+XMLPUBVAR xmlReallocFunc xmlRealloc;
+#endif
+
+#ifdef LIBXML_THREAD_ENABLED
+XMLPUBFUN  xmlFreeFunc * XMLCALL __xmlFree(void);
+#define xmlFree \
+(*(__xmlFree()))
+#else
+XMLPUBVAR xmlFreeFunc xmlFree;
+#endif
+
+#ifdef LIBXML_THREAD_ENABLED
+XMLPUBFUN  xmlStrdupFunc * XMLCALL __xmlMemStrdup(void);
+#define xmlMemStrdup \
+(*(__xmlMemStrdup()))
+#else
+XMLPUBVAR xmlStrdupFunc xmlMemStrdup;
+#endif
+
+#else /* !LIBXML_THREAD_ALLOC_ENABLED */
+XMLPUBVAR xmlMallocFunc xmlMalloc;
+XMLPUBVAR xmlMallocFunc xmlMallocAtomic;
+XMLPUBVAR xmlReallocFunc xmlRealloc;
+XMLPUBVAR xmlFreeFunc xmlFree;
+XMLPUBVAR xmlStrdupFunc xmlMemStrdup;
+#endif /* LIBXML_THREAD_ALLOC_ENABLED */
+
+#ifdef LIBXML_DOCB_ENABLED
+XMLPUBFUN  xmlSAXHandlerV1 * XMLCALL __docbDefaultSAXHandler(void);
+#ifdef LIBXML_THREAD_ENABLED
+#define docbDefaultSAXHandler \
+(*(__docbDefaultSAXHandler()))
+#else
+XMLPUBVAR xmlSAXHandlerV1 docbDefaultSAXHandler;
+#endif
+#endif
+
+#ifdef LIBXML_HTML_ENABLED
+XMLPUBFUN xmlSAXHandlerV1 * XMLCALL __htmlDefaultSAXHandler(void);
+#ifdef LIBXML_THREAD_ENABLED
+#define htmlDefaultSAXHandler \
+(*(__htmlDefaultSAXHandler()))
+#else
+XMLPUBVAR xmlSAXHandlerV1 htmlDefaultSAXHandler;
+#endif
+#endif
+
+XMLPUBFUN xmlError * XMLCALL __xmlLastError(void);
+#ifdef LIBXML_THREAD_ENABLED
+#define xmlLastError \
+(*(__xmlLastError()))
+#else
+XMLPUBVAR xmlError xmlLastError;
+#endif
+
+/*
+ * Everything starting from the line below is
+ * Automatically generated by build_glob.py.
+ * Do not modify the previous line.
+ */
+
+
+XMLPUBFUN int * XMLCALL __oldXMLWDcompatibility(void);
+#ifdef LIBXML_THREAD_ENABLED
+#define oldXMLWDcompatibility \
+(*(__oldXMLWDcompatibility()))
+#else
+XMLPUBVAR int oldXMLWDcompatibility;
+#endif
+
+XMLPUBFUN xmlBufferAllocationScheme * XMLCALL __xmlBufferAllocScheme(void);
+#ifdef LIBXML_THREAD_ENABLED
+#define xmlBufferAllocScheme \
+(*(__xmlBufferAllocScheme()))
+#else
+XMLPUBVAR xmlBufferAllocationScheme xmlBufferAllocScheme;
+#endif
+XMLPUBFUN xmlBufferAllocationScheme XMLCALL xmlThrDefBufferAllocScheme(xmlBufferAllocationScheme v);
+
+XMLPUBFUN int * XMLCALL __xmlDefaultBufferSize(void);
+#ifdef LIBXML_THREAD_ENABLED
+#define xmlDefaultBufferSize \
+(*(__xmlDefaultBufferSize()))
+#else
+XMLPUBVAR int xmlDefaultBufferSize;
+#endif
+XMLPUBFUN int XMLCALL xmlThrDefDefaultBufferSize(int v);
+
+XMLPUBFUN xmlSAXHandlerV1 * XMLCALL __xmlDefaultSAXHandler(void);
+#ifdef LIBXML_THREAD_ENABLED
+#define xmlDefaultSAXHandler \
+(*(__xmlDefaultSAXHandler()))
+#else
+XMLPUBVAR xmlSAXHandlerV1 xmlDefaultSAXHandler;
+#endif
+
+XMLPUBFUN xmlSAXLocator * XMLCALL __xmlDefaultSAXLocator(void);
+#ifdef LIBXML_THREAD_ENABLED
+#define xmlDefaultSAXLocator \
+(*(__xmlDefaultSAXLocator()))
+#else
+XMLPUBVAR xmlSAXLocator xmlDefaultSAXLocator;
+#endif
+
+XMLPUBFUN int * XMLCALL __xmlDoValidityCheckingDefaultValue(void);
+#ifdef LIBXML_THREAD_ENABLED
+#define xmlDoValidityCheckingDefaultValue \
+(*(__xmlDoValidityCheckingDefaultValue()))
+#else
+XMLPUBVAR int xmlDoValidityCheckingDefaultValue;
+#endif
+XMLPUBFUN int XMLCALL xmlThrDefDoValidityCheckingDefaultValue(int v);
+
+XMLPUBFUN xmlGenericErrorFunc * XMLCALL __xmlGenericError(void);
+#ifdef LIBXML_THREAD_ENABLED
+#define xmlGenericError \
+(*(__xmlGenericError()))
+#else
+XMLPUBVAR xmlGenericErrorFunc xmlGenericError;
+#endif
+
+XMLPUBFUN xmlStructuredErrorFunc * XMLCALL __xmlStructuredError(void);
+#ifdef LIBXML_THREAD_ENABLED
+#define xmlStructuredError \
+(*(__xmlStructuredError()))
+#else
+XMLPUBVAR xmlStructuredErrorFunc xmlStructuredError;
+#endif
+
+XMLPUBFUN void * * XMLCALL __xmlGenericErrorContext(void);
+#ifdef LIBXML_THREAD_ENABLED
+#define xmlGenericErrorContext \
+(*(__xmlGenericErrorContext()))
+#else
+XMLPUBVAR void * xmlGenericErrorContext;
+#endif
+
+XMLPUBFUN int * XMLCALL __xmlGetWarningsDefaultValue(void);
+#ifdef LIBXML_THREAD_ENABLED
+#define xmlGetWarningsDefaultValue \
+(*(__xmlGetWarningsDefaultValue()))
+#else
+XMLPUBVAR int xmlGetWarningsDefaultValue;
+#endif
+XMLPUBFUN int XMLCALL xmlThrDefGetWarningsDefaultValue(int v);
+
+XMLPUBFUN int * XMLCALL __xmlIndentTreeOutput(void);
+#ifdef LIBXML_THREAD_ENABLED
+#define xmlIndentTreeOutput \
+(*(__xmlIndentTreeOutput()))
+#else
+XMLPUBVAR int xmlIndentTreeOutput;
+#endif
+XMLPUBFUN int XMLCALL xmlThrDefIndentTreeOutput(int v);
+
+XMLPUBFUN const char * * XMLCALL __xmlTreeIndentString(void);
+#ifdef LIBXML_THREAD_ENABLED
+#define xmlTreeIndentString \
+(*(__xmlTreeIndentString()))
+#else
+XMLPUBVAR const char * xmlTreeIndentString;
+#endif
+XMLPUBFUN const char * XMLCALL xmlThrDefTreeIndentString(const char * v);
+
+XMLPUBFUN int * XMLCALL __xmlKeepBlanksDefaultValue(void);
+#ifdef LIBXML_THREAD_ENABLED
+#define xmlKeepBlanksDefaultValue \
+(*(__xmlKeepBlanksDefaultValue()))
+#else
+XMLPUBVAR int xmlKeepBlanksDefaultValue;
+#endif
+XMLPUBFUN int XMLCALL xmlThrDefKeepBlanksDefaultValue(int v);
+
+XMLPUBFUN int * XMLCALL __xmlLineNumbersDefaultValue(void);
+#ifdef LIBXML_THREAD_ENABLED
+#define xmlLineNumbersDefaultValue \
+(*(__xmlLineNumbersDefaultValue()))
+#else
+XMLPUBVAR int xmlLineNumbersDefaultValue;
+#endif
+XMLPUBFUN int XMLCALL xmlThrDefLineNumbersDefaultValue(int v);
+
+XMLPUBFUN int * XMLCALL __xmlLoadExtDtdDefaultValue(void);
+#ifdef LIBXML_THREAD_ENABLED
+#define xmlLoadExtDtdDefaultValue \
+(*(__xmlLoadExtDtdDefaultValue()))
+#else
+XMLPUBVAR int xmlLoadExtDtdDefaultValue;
+#endif
+XMLPUBFUN int XMLCALL xmlThrDefLoadExtDtdDefaultValue(int v);
+
+XMLPUBFUN int * XMLCALL __xmlParserDebugEntities(void);
+#ifdef LIBXML_THREAD_ENABLED
+#define xmlParserDebugEntities \
+(*(__xmlParserDebugEntities()))
+#else
+XMLPUBVAR int xmlParserDebugEntities;
+#endif
+XMLPUBFUN int XMLCALL xmlThrDefParserDebugEntities(int v);
+
+XMLPUBFUN const char * * XMLCALL __xmlParserVersion(void);
+#ifdef LIBXML_THREAD_ENABLED
+#define xmlParserVersion \
+(*(__xmlParserVersion()))
+#else
+XMLPUBVAR const char * xmlParserVersion;
+#endif
+
+XMLPUBFUN int * XMLCALL __xmlPedanticParserDefaultValue(void);
+#ifdef LIBXML_THREAD_ENABLED
+#define xmlPedanticParserDefaultValue \
+(*(__xmlPedanticParserDefaultValue()))
+#else
+XMLPUBVAR int xmlPedanticParserDefaultValue;
+#endif
+XMLPUBFUN int XMLCALL xmlThrDefPedanticParserDefaultValue(int v);
+
+XMLPUBFUN int * XMLCALL __xmlSaveNoEmptyTags(void);
+#ifdef LIBXML_THREAD_ENABLED
+#define xmlSaveNoEmptyTags \
+(*(__xmlSaveNoEmptyTags()))
+#else
+XMLPUBVAR int xmlSaveNoEmptyTags;
+#endif
+XMLPUBFUN int XMLCALL xmlThrDefSaveNoEmptyTags(int v);
+
+XMLPUBFUN int * XMLCALL __xmlSubstituteEntitiesDefaultValue(void);
+#ifdef LIBXML_THREAD_ENABLED
+#define xmlSubstituteEntitiesDefaultValue \
+(*(__xmlSubstituteEntitiesDefaultValue()))
+#else
+XMLPUBVAR int xmlSubstituteEntitiesDefaultValue;
+#endif
+XMLPUBFUN int XMLCALL xmlThrDefSubstituteEntitiesDefaultValue(int v);
+
+XMLPUBFUN xmlRegisterNodeFunc * XMLCALL __xmlRegisterNodeDefaultValue(void);
+#ifdef LIBXML_THREAD_ENABLED
+#define xmlRegisterNodeDefaultValue \
+(*(__xmlRegisterNodeDefaultValue()))
+#else
+XMLPUBVAR xmlRegisterNodeFunc xmlRegisterNodeDefaultValue;
+#endif
+
+XMLPUBFUN xmlDeregisterNodeFunc * XMLCALL __xmlDeregisterNodeDefaultValue(void);
+#ifdef LIBXML_THREAD_ENABLED
+#define xmlDeregisterNodeDefaultValue \
+(*(__xmlDeregisterNodeDefaultValue()))
+#else
+XMLPUBVAR xmlDeregisterNodeFunc xmlDeregisterNodeDefaultValue;
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __XML_GLOBALS_H */
diff --git a/src/libxml/include/libxml/hash.h b/src/libxml/include/libxml/hash.h
new file mode 100644
index 0000000..039ed5d
--- /dev/null
+++ b/src/libxml/include/libxml/hash.h
@@ -0,0 +1,206 @@
+/*
+ * Summary: chained hash tables
+ * description: this module implement the hash table support used in 
+ * various place in the library.
+ *
+ * Copy: See Copyright for the status of this software.
+ *
+ * Author: Bjorn Reese <bjorn.reese@systematic.dk>
+ */
+
+#ifndef __XML_HASH_H__
+#define __XML_HASH_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * The hash table.
+ */
+typedef struct _xmlHashTable xmlHashTable;
+typedef xmlHashTable *xmlHashTablePtr;
+
+#ifdef __cplusplus
+}
+#endif
+
+#include <libxml/xmlversion.h>
+#include <libxml/parser.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * function types:
+ */
+/**
+ * xmlHashDeallocator:
+ * @payload:  the data in the hash
+ * @name:  the name associated
+ *
+ * Callback to free data from a hash.
+ */
+typedef void (*xmlHashDeallocator)(void *payload, xmlChar *name);
+/**
+ * xmlHashCopier:
+ * @payload:  the data in the hash
+ * @name:  the name associated
+ *
+ * Callback to copy data from a hash.
+ *
+ * Returns a copy of the data or NULL in case of error.
+ */
+typedef void *(*xmlHashCopier)(void *payload, xmlChar *name);
+/**
+ * xmlHashScanner:
+ * @payload:  the data in the hash
+ * @data:  extra scannner data
+ * @name:  the name associated
+ *
+ * Callback when scanning data in a hash with the simple scanner.
+ */
+typedef void (*xmlHashScanner)(void *payload, void *data, xmlChar *name);
+/**
+ * xmlHashScannerFull:
+ * @payload:  the data in the hash
+ * @data:  extra scannner data
+ * @name:  the name associated
+ * @name2:  the second name associated
+ * @name3:  the third name associated
+ *
+ * Callback when scanning data in a hash with the full scanner.
+ */
+typedef void (*xmlHashScannerFull)(void *payload, void *data,
+				   const xmlChar *name, const xmlChar *name2,
+				   const xmlChar *name3);
+
+/*
+ * Constructor and destructor.
+ */
+XMLPUBFUN xmlHashTablePtr XMLCALL
+			xmlHashCreate	(int size);
+XMLPUBFUN void XMLCALL			
+			xmlHashFree	(xmlHashTablePtr table,
+					 xmlHashDeallocator f);
+
+/*
+ * Add a new entry to the hash table.
+ */
+XMLPUBFUN int XMLCALL			
+			xmlHashAddEntry	(xmlHashTablePtr table,
+		                         const xmlChar *name,
+		                         void *userdata);
+XMLPUBFUN int XMLCALL			
+			xmlHashUpdateEntry(xmlHashTablePtr table,
+		                         const xmlChar *name,
+		                         void *userdata,
+					 xmlHashDeallocator f);
+XMLPUBFUN int XMLCALL		    
+			xmlHashAddEntry2(xmlHashTablePtr table,
+		                         const xmlChar *name,
+		                         const xmlChar *name2,
+		                         void *userdata);
+XMLPUBFUN int XMLCALL			
+			xmlHashUpdateEntry2(xmlHashTablePtr table,
+		                         const xmlChar *name,
+		                         const xmlChar *name2,
+		                         void *userdata,
+					 xmlHashDeallocator f);
+XMLPUBFUN int XMLCALL			
+			xmlHashAddEntry3(xmlHashTablePtr table,
+		                         const xmlChar *name,
+		                         const xmlChar *name2,
+		                         const xmlChar *name3,
+		                         void *userdata);
+XMLPUBFUN int XMLCALL			
+			xmlHashUpdateEntry3(xmlHashTablePtr table,
+		                         const xmlChar *name,
+		                         const xmlChar *name2,
+		                         const xmlChar *name3,
+		                         void *userdata,
+					 xmlHashDeallocator f);
+
+/*
+ * Remove an entry from the hash table.
+ */
+XMLPUBFUN int XMLCALL     
+			xmlHashRemoveEntry(xmlHashTablePtr table, const xmlChar *name,
+                           xmlHashDeallocator f);
+XMLPUBFUN int XMLCALL     
+			xmlHashRemoveEntry2(xmlHashTablePtr table, const xmlChar *name,
+                            const xmlChar *name2, xmlHashDeallocator f);
+XMLPUBFUN int  XMLCALL    
+			xmlHashRemoveEntry3(xmlHashTablePtr table, const xmlChar *name,
+                            const xmlChar *name2, const xmlChar *name3,
+                            xmlHashDeallocator f);
+
+/*
+ * Retrieve the userdata.
+ */
+XMLPUBFUN void * XMLCALL			
+			xmlHashLookup	(xmlHashTablePtr table,
+					 const xmlChar *name);
+XMLPUBFUN void * XMLCALL			
+			xmlHashLookup2	(xmlHashTablePtr table,
+					 const xmlChar *name,
+					 const xmlChar *name2);
+XMLPUBFUN void * XMLCALL			
+			xmlHashLookup3	(xmlHashTablePtr table,
+					 const xmlChar *name,
+					 const xmlChar *name2,
+					 const xmlChar *name3);
+XMLPUBFUN void * XMLCALL			
+			xmlHashQLookup	(xmlHashTablePtr table,
+					 const xmlChar *name,
+					 const xmlChar *prefix);
+XMLPUBFUN void * XMLCALL			
+			xmlHashQLookup2	(xmlHashTablePtr table,
+					 const xmlChar *name,
+					 const xmlChar *prefix,
+					 const xmlChar *name2,
+					 const xmlChar *prefix2);
+XMLPUBFUN void * XMLCALL			
+			xmlHashQLookup3	(xmlHashTablePtr table,
+					 const xmlChar *name,
+					 const xmlChar *prefix,
+					 const xmlChar *name2,
+					 const xmlChar *prefix2,
+					 const xmlChar *name3,
+					 const xmlChar *prefix3);
+
+/*
+ * Helpers.
+ */
+XMLPUBFUN xmlHashTablePtr XMLCALL		
+			xmlHashCopy	(xmlHashTablePtr table,
+					 xmlHashCopier f);
+XMLPUBFUN int XMLCALL			
+			xmlHashSize	(xmlHashTablePtr table);
+XMLPUBFUN void XMLCALL			
+			xmlHashScan	(xmlHashTablePtr table,
+					 xmlHashScanner f,
+					 void *data);
+XMLPUBFUN void XMLCALL			
+			xmlHashScan3	(xmlHashTablePtr table,
+					 const xmlChar *name,
+					 const xmlChar *name2,
+					 const xmlChar *name3,
+					 xmlHashScanner f,
+					 void *data);
+XMLPUBFUN void XMLCALL			
+			xmlHashScanFull	(xmlHashTablePtr table,
+					 xmlHashScannerFull f,
+					 void *data);
+XMLPUBFUN void XMLCALL			
+			xmlHashScanFull3(xmlHashTablePtr table,
+					 const xmlChar *name,
+					 const xmlChar *name2,
+					 const xmlChar *name3,
+					 xmlHashScannerFull f,
+					 void *data);
+#ifdef __cplusplus
+}
+#endif
+#endif /* ! __XML_HASH_H__ */
diff --git a/src/libxml/include/libxml/list.h b/src/libxml/include/libxml/list.h
new file mode 100644
index 0000000..1d83482
--- /dev/null
+++ b/src/libxml/include/libxml/list.h
@@ -0,0 +1,137 @@
+/*
+ * Summary: lists interfaces
+ * Description: this module implement the list support used in 
+ * various place in the library.
+ *
+ * Copy: See Copyright for the status of this software.
+ *
+ * Author: Gary Pennington <Gary.Pennington@uk.sun.com>
+ */
+
+#ifndef __XML_LINK_INCLUDE__
+#define __XML_LINK_INCLUDE__
+
+#include <libxml/xmlversion.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct _xmlLink xmlLink;
+typedef xmlLink *xmlLinkPtr;
+
+typedef struct _xmlList xmlList;
+typedef xmlList *xmlListPtr;
+
+/**
+ * xmlListDeallocator:
+ * @lk:  the data to deallocate
+ *
+ * Callback function used to free data from a list.
+ */
+typedef void (*xmlListDeallocator) (xmlLinkPtr lk);
+/**
+ * xmlListDataCompare:
+ * @data0: the first data
+ * @data1: the second data
+ *
+ * Callback function used to compare 2 data.
+ *
+ * Returns 0 is equality, -1 or 1 otherwise depending on the ordering.
+ */
+typedef int  (*xmlListDataCompare) (const void *data0, const void *data1);
+/**
+ * xmlListWalker:
+ * @data: the data found in the list
+ * @user: extra user provided data to the walker
+ *
+ * Callback function used when walking a list with xmlListWalk().
+ *
+ * Returns 0 to stop walking the list, 1 otherwise.
+ */
+typedef int (*xmlListWalker) (const void *data, const void *user);
+
+/* Creation/Deletion */
+XMLPUBFUN xmlListPtr XMLCALL
+		xmlListCreate		(xmlListDeallocator deallocator,
+	                                 xmlListDataCompare compare);
+XMLPUBFUN void XMLCALL		
+		xmlListDelete		(xmlListPtr l);
+
+/* Basic Operators */
+XMLPUBFUN void * XMLCALL		
+		xmlListSearch		(xmlListPtr l,
+					 void *data);
+XMLPUBFUN void * XMLCALL		
+		xmlListReverseSearch	(xmlListPtr l,
+					 void *data);
+XMLPUBFUN int XMLCALL		
+		xmlListInsert		(xmlListPtr l,
+					 void *data) ;
+XMLPUBFUN int XMLCALL		
+		xmlListAppend		(xmlListPtr l,
+					 void *data) ;
+XMLPUBFUN int XMLCALL		
+		xmlListRemoveFirst	(xmlListPtr l,
+					 void *data);
+XMLPUBFUN int XMLCALL		
+		xmlListRemoveLast	(xmlListPtr l,
+					 void *data);
+XMLPUBFUN int XMLCALL		
+		xmlListRemoveAll	(xmlListPtr l,
+					 void *data);
+XMLPUBFUN void XMLCALL		
+		xmlListClear		(xmlListPtr l);
+XMLPUBFUN int XMLCALL		
+		xmlListEmpty		(xmlListPtr l);
+XMLPUBFUN xmlLinkPtr XMLCALL	
+		xmlListFront		(xmlListPtr l);
+XMLPUBFUN xmlLinkPtr XMLCALL	
+		xmlListEnd		(xmlListPtr l);
+XMLPUBFUN int XMLCALL		
+		xmlListSize		(xmlListPtr l);
+
+XMLPUBFUN void XMLCALL		
+		xmlListPopFront		(xmlListPtr l);
+XMLPUBFUN void XMLCALL		
+		xmlListPopBack		(xmlListPtr l);
+XMLPUBFUN int XMLCALL		
+		xmlListPushFront	(xmlListPtr l,
+					 void *data);
+XMLPUBFUN int XMLCALL		
+		xmlListPushBack		(xmlListPtr l,
+					 void *data);
+
+/* Advanced Operators */
+XMLPUBFUN void XMLCALL		
+		xmlListReverse		(xmlListPtr l);
+XMLPUBFUN void XMLCALL		
+		xmlListSort		(xmlListPtr l);
+XMLPUBFUN void XMLCALL		
+		xmlListWalk		(xmlListPtr l,
+					 xmlListWalker walker,
+					 const void *user);
+XMLPUBFUN void XMLCALL		
+		xmlListReverseWalk	(xmlListPtr l,
+					 xmlListWalker walker,
+					 const void *user);
+XMLPUBFUN void XMLCALL		
+		xmlListMerge		(xmlListPtr l1,
+					 xmlListPtr l2);
+XMLPUBFUN xmlListPtr XMLCALL	
+		xmlListDup		(const xmlListPtr old);
+XMLPUBFUN int XMLCALL		
+		xmlListCopy		(xmlListPtr cur,
+					 const xmlListPtr old);
+/* Link operators */
+XMLPUBFUN void * XMLCALL          
+		xmlLinkGetData          (xmlLinkPtr lk);
+
+/* xmlListUnique() */
+/* xmlListSwap */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __XML_LINK_INCLUDE__ */
diff --git a/src/libxml/include/libxml/nanoftp.h b/src/libxml/include/libxml/nanoftp.h
new file mode 100644
index 0000000..01fadb8
--- /dev/null
+++ b/src/libxml/include/libxml/nanoftp.h
@@ -0,0 +1,143 @@
+/*
+ * Summary: minimal FTP implementation
+ * Description: minimal FTP implementation allowing to fetch resources
+ *              like external subset.
+ *
+ * Copy: See Copyright for the status of this software.
+ *
+ * Author: Daniel Veillard
+ */
+ 
+#ifndef __NANO_FTP_H__
+#define __NANO_FTP_H__
+
+#include <libxml/xmlversion.h>
+
+#ifdef LIBXML_FTP_ENABLED
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * ftpListCallback: 
+ * @userData:  user provided data for the callback
+ * @filename:  the file name (including "->" when links are shown)
+ * @attrib:  the attribute string
+ * @owner:  the owner string
+ * @group:  the group string
+ * @size:  the file size
+ * @links:  the link count
+ * @year:  the year
+ * @month:  the month
+ * @day:  the day
+ * @hour:  the hour
+ * @minute:  the minute
+ *
+ * A callback for the xmlNanoFTPList command.
+ * Note that only one of year and day:minute are specified.
+ */
+typedef void (*ftpListCallback) (void *userData,
+	                         const char *filename, const char *attrib,
+	                         const char *owner, const char *group,
+				 unsigned long size, int links, int year,
+				 const char *month, int day, int hour,
+				 int minute);
+/**
+ * ftpDataCallback: 
+ * @userData: the user provided context
+ * @data: the data received
+ * @len: its size in bytes
+ *
+ * A callback for the xmlNanoFTPGet command.
+ */
+typedef void (*ftpDataCallback) (void *userData,
+				 const char *data,
+				 int len);
+
+/*
+ * Init
+ */
+XMLPUBFUN void XMLCALL
+	xmlNanoFTPInit		(void);
+XMLPUBFUN void XMLCALL	
+	xmlNanoFTPCleanup	(void);
+
+/*
+ * Creating/freeing contexts.
+ */
+XMLPUBFUN void * XMLCALL	
+	xmlNanoFTPNewCtxt	(const char *URL);
+XMLPUBFUN void XMLCALL	
+	xmlNanoFTPFreeCtxt	(void * ctx);
+XMLPUBFUN void * XMLCALL 	
+	xmlNanoFTPConnectTo	(const char *server,
+				 int port);
+/*
+ * Opening/closing session connections.
+ */
+XMLPUBFUN void * XMLCALL 	
+	xmlNanoFTPOpen		(const char *URL);
+XMLPUBFUN int XMLCALL	
+	xmlNanoFTPConnect	(void *ctx);
+XMLPUBFUN int XMLCALL	
+	xmlNanoFTPClose		(void *ctx);
+XMLPUBFUN int XMLCALL	
+	xmlNanoFTPQuit		(void *ctx);
+XMLPUBFUN void XMLCALL	
+	xmlNanoFTPScanProxy	(const char *URL);
+XMLPUBFUN void XMLCALL	
+	xmlNanoFTPProxy		(const char *host,
+				 int port,
+				 const char *user,
+				 const char *passwd,
+				 int type);
+XMLPUBFUN int XMLCALL	
+	xmlNanoFTPUpdateURL	(void *ctx,
+				 const char *URL);
+
+/*
+ * Rather internal commands.
+ */
+XMLPUBFUN int XMLCALL	
+	xmlNanoFTPGetResponse	(void *ctx);
+XMLPUBFUN int XMLCALL	
+	xmlNanoFTPCheckResponse	(void *ctx);
+
+/*
+ * CD/DIR/GET handlers.
+ */
+XMLPUBFUN int XMLCALL	
+	xmlNanoFTPCwd		(void *ctx,
+				 char *directory);
+XMLPUBFUN int XMLCALL	
+	xmlNanoFTPDele		(void *ctx,
+				 char *file);
+
+XMLPUBFUN int XMLCALL	
+	xmlNanoFTPGetConnection	(void *ctx);
+XMLPUBFUN int XMLCALL	
+	xmlNanoFTPCloseConnection(void *ctx);
+XMLPUBFUN int XMLCALL	
+	xmlNanoFTPList		(void *ctx,
+				 ftpListCallback callback,
+				 void *userData,
+				 char *filename);
+XMLPUBFUN int XMLCALL	
+	xmlNanoFTPGetSocket	(void *ctx,
+				 const char *filename);
+XMLPUBFUN int XMLCALL	
+	xmlNanoFTPGet		(void *ctx,
+				 ftpDataCallback callback,
+				 void *userData,
+				 const char *filename);
+XMLPUBFUN int XMLCALL	
+	xmlNanoFTPRead		(void *ctx,
+				 void *dest,
+				 int len);
+
+#ifdef __cplusplus
+}
+#endif /* LIBXML_FTP_ENABLED */
+#endif
+#endif /* __NANO_FTP_H__ */
diff --git a/src/libxml/include/libxml/nanohttp.h b/src/libxml/include/libxml/nanohttp.h
new file mode 100644
index 0000000..2853184
--- /dev/null
+++ b/src/libxml/include/libxml/nanohttp.h
@@ -0,0 +1,79 @@
+/*
+ * Summary: minimal HTTP implementation
+ * Description: minimal HTTP implementation allowing to fetch resources
+ *              like external subset.
+ *
+ * Copy: See Copyright for the status of this software.
+ *
+ * Author: Daniel Veillard
+ */
+ 
+#ifndef __NANO_HTTP_H__
+#define __NANO_HTTP_H__
+
+#include <libxml/xmlversion.h>
+
+#ifdef LIBXML_HTTP_ENABLED
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+XMLPUBFUN void XMLCALL
+	xmlNanoHTTPInit		(void);
+XMLPUBFUN void XMLCALL	
+	xmlNanoHTTPCleanup	(void);
+XMLPUBFUN void XMLCALL	
+	xmlNanoHTTPScanProxy	(const char *URL);
+XMLPUBFUN int XMLCALL	
+	xmlNanoHTTPFetch	(const char *URL,
+				 const char *filename,
+				 char **contentType);
+XMLPUBFUN void * XMLCALL	
+	xmlNanoHTTPMethod	(const char *URL,
+				 const char *method,
+				 const char *input,
+				 char **contentType,
+				 const char *headers,
+				 int   ilen);
+XMLPUBFUN void * XMLCALL	
+	xmlNanoHTTPMethodRedir	(const char *URL,
+				 const char *method,
+				 const char *input,
+				 char **contentType,
+				 char **redir,
+				 const char *headers,
+				 int   ilen);
+XMLPUBFUN void * XMLCALL	
+	xmlNanoHTTPOpen		(const char *URL,
+				 char **contentType);
+XMLPUBFUN void * XMLCALL	
+	xmlNanoHTTPOpenRedir	(const char *URL,
+				 char **contentType,
+				 char **redir);
+XMLPUBFUN int XMLCALL	
+	xmlNanoHTTPReturnCode	(void *ctx);
+XMLPUBFUN const char * XMLCALL 
+	xmlNanoHTTPAuthHeader	(void *ctx);
+XMLPUBFUN const char * XMLCALL
+	xmlNanoHTTPRedir	(void *ctx);
+XMLPUBFUN const char * XMLCALL
+	xmlNanoHTTPEncoding	(void *ctx);
+XMLPUBFUN const char * XMLCALL
+	xmlNanoHTTPMimeType	(void *ctx);
+XMLPUBFUN int XMLCALL	
+	xmlNanoHTTPRead		(void *ctx,
+				 void *dest,
+				 int len);
+#ifdef LIBXML_OUTPUT_ENABLED
+XMLPUBFUN int XMLCALL	
+	xmlNanoHTTPSave		(void *ctxt,
+				 const char *filename);
+#endif /* LIBXML_OUTPUT_ENABLED */
+XMLPUBFUN void XMLCALL	
+	xmlNanoHTTPClose	(void *ctx);
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* LIBXML_HTTP_ENABLED */
+#endif /* __NANO_HTTP_H__ */
diff --git a/src/libxml/include/libxml/parser.h b/src/libxml/include/libxml/parser.h
new file mode 100644
index 0000000..2cecb20
--- /dev/null
+++ b/src/libxml/include/libxml/parser.h
@@ -0,0 +1,1131 @@
+/*
+ * Summary: the core parser module
+ * Description: Interfaces, constants and types related to the XML parser
+ *
+ * Copy: See Copyright for the status of this software.
+ *
+ * Author: Daniel Veillard
+ */
+
+#ifndef __XML_PARSER_H__
+#define __XML_PARSER_H__
+
+#include <stdarg.h>
+
+#include <libxml/xmlversion.h>
+#include <libxml/tree.h>
+#include <libxml/dict.h>
+#include <libxml/hash.h>
+#include <libxml/valid.h>
+#include <libxml/entities.h>
+#include <libxml/xmlerror.h>
+#include <libxml/xmlstring.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * XML_DEFAULT_VERSION:
+ *
+ * The default version of XML used: 1.0
+ */
+#define XML_DEFAULT_VERSION	"1.0"
+
+/**
+ * xmlParserInput:
+ *
+ * An xmlParserInput is an input flow for the XML processor.
+ * Each entity parsed is associated an xmlParserInput (except the
+ * few predefined ones). This is the case both for internal entities
+ * - in which case the flow is already completely in memory - or
+ * external entities - in which case we use the buf structure for
+ * progressive reading and I18N conversions to the internal UTF-8 format.
+ */
+
+/**
+ * xmlParserInputDeallocate:
+ * @str:  the string to deallocate
+ *
+ * Callback for freeing some parser input allocations.
+ */
+typedef void (* xmlParserInputDeallocate)(xmlChar *str);
+
+struct _xmlParserInput {
+    /* Input buffer */
+    xmlParserInputBufferPtr buf;      /* UTF-8 encoded buffer */
+
+    const char *filename;             /* The file analyzed, if any */
+    const char *directory;            /* the directory/base of the file */
+    const xmlChar *base;              /* Base of the array to parse */
+    const xmlChar *cur;               /* Current char being parsed */
+    const xmlChar *end;               /* end of the array to parse */
+    int length;                       /* length if known */
+    int line;                         /* Current line */
+    int col;                          /* Current column */
+    /*
+     * NOTE: consumed is only tested for equality in the parser code,
+     *       so even if there is an overflow this should not give troubles
+     *       for parsing very large instances.
+     */
+    unsigned long consumed;           /* How many xmlChars already consumed */
+    xmlParserInputDeallocate free;    /* function to deallocate the base */
+    const xmlChar *encoding;          /* the encoding string for entity */
+    const xmlChar *version;           /* the version string for entity */
+    int standalone;                   /* Was that entity marked standalone */
+    int id;                           /* an unique identifier for the entity */
+};
+
+/**
+ * xmlParserNodeInfo:
+ *
+ * The parser can be asked to collect Node informations, i.e. at what
+ * place in the file they were detected. 
+ * NOTE: This is off by default and not very well tested.
+ */
+typedef struct _xmlParserNodeInfo xmlParserNodeInfo;
+typedef xmlParserNodeInfo *xmlParserNodeInfoPtr;
+
+struct _xmlParserNodeInfo {
+  const struct _xmlNode* node;
+  /* Position & line # that text that created the node begins & ends on */
+  unsigned long begin_pos;
+  unsigned long begin_line;
+  unsigned long end_pos;
+  unsigned long end_line;
+};
+
+typedef struct _xmlParserNodeInfoSeq xmlParserNodeInfoSeq;
+typedef xmlParserNodeInfoSeq *xmlParserNodeInfoSeqPtr;
+struct _xmlParserNodeInfoSeq {
+  unsigned long maximum;
+  unsigned long length;
+  xmlParserNodeInfo* buffer;
+};
+
+/**
+ * xmlParserInputState:
+ *
+ * The parser is now working also as a state based parser.
+ * The recursive one use the state info for entities processing.
+ */
+typedef enum {
+    XML_PARSER_EOF = -1,	/* nothing is to be parsed */
+    XML_PARSER_START = 0,	/* nothing has been parsed */
+    XML_PARSER_MISC,		/* Misc* before int subset */
+    XML_PARSER_PI,		/* Within a processing instruction */
+    XML_PARSER_DTD,		/* within some DTD content */
+    XML_PARSER_PROLOG,		/* Misc* after internal subset */
+    XML_PARSER_COMMENT,		/* within a comment */
+    XML_PARSER_START_TAG,	/* within a start tag */
+    XML_PARSER_CONTENT,		/* within the content */
+    XML_PARSER_CDATA_SECTION,	/* within a CDATA section */
+    XML_PARSER_END_TAG,		/* within a closing tag */
+    XML_PARSER_ENTITY_DECL,	/* within an entity declaration */
+    XML_PARSER_ENTITY_VALUE,	/* within an entity value in a decl */
+    XML_PARSER_ATTRIBUTE_VALUE,	/* within an attribute value */
+    XML_PARSER_SYSTEM_LITERAL,	/* within a SYSTEM value */
+    XML_PARSER_EPILOG, 		/* the Misc* after the last end tag */
+    XML_PARSER_IGNORE,		/* within an IGNORED section */
+    XML_PARSER_PUBLIC_LITERAL 	/* within a PUBLIC value */
+} xmlParserInputState;
+
+/**
+ * XML_DETECT_IDS:
+ *
+ * Bit in the loadsubset context field to tell to do ID/REFs lookups.
+ * Use it to initialize xmlLoadExtDtdDefaultValue.
+ */
+#define XML_DETECT_IDS		2
+
+/**
+ * XML_COMPLETE_ATTRS:
+ *
+ * Bit in the loadsubset context field to tell to do complete the
+ * elements attributes lists with the ones defaulted from the DTDs.
+ * Use it to initialize xmlLoadExtDtdDefaultValue.
+ */
+#define XML_COMPLETE_ATTRS	4
+
+/**
+ * XML_SKIP_IDS:
+ *
+ * Bit in the loadsubset context field to tell to not do ID/REFs registration.
+ * Used to initialize xmlLoadExtDtdDefaultValue in some special cases.
+ */
+#define XML_SKIP_IDS		8
+
+/**
+ * xmlParserCtxt:
+ *
+ * The parser context.
+ * NOTE This doesn't completely define the parser state, the (current ?)
+ *      design of the parser uses recursive function calls since this allow
+ *      and easy mapping from the production rules of the specification
+ *      to the actual code. The drawback is that the actual function call
+ *      also reflect the parser state. However most of the parsing routines
+ *      takes as the only argument the parser context pointer, so migrating
+ *      to a state based parser for progressive parsing shouldn't be too hard.
+ */
+struct _xmlParserCtxt {
+    struct _xmlSAXHandler *sax;       /* The SAX handler */
+    void            *userData;        /* For SAX interface only, used by DOM build */
+    xmlDocPtr           myDoc;        /* the document being built */
+    int            wellFormed;        /* is the document well formed */
+    int       replaceEntities;        /* shall we replace entities ? */
+    const xmlChar    *version;        /* the XML version string */
+    const xmlChar   *encoding;        /* the declared encoding, if any */
+    int            standalone;        /* standalone document */
+    int                  html;        /* an HTML(1)/Docbook(2) document */
+
+    /* Input stream stack */
+    xmlParserInputPtr  input;         /* Current input stream */
+    int                inputNr;       /* Number of current input streams */
+    int                inputMax;      /* Max number of input streams */
+    xmlParserInputPtr *inputTab;      /* stack of inputs */
+
+    /* Node analysis stack only used for DOM building */
+    xmlNodePtr         node;          /* Current parsed Node */
+    int                nodeNr;        /* Depth of the parsing stack */
+    int                nodeMax;       /* Max depth of the parsing stack */
+    xmlNodePtr        *nodeTab;       /* array of nodes */
+
+    int record_info;                  /* Whether node info should be kept */
+    xmlParserNodeInfoSeq node_seq;    /* info about each node parsed */
+
+    int errNo;                        /* error code */
+
+    int     hasExternalSubset;        /* reference and external subset */
+    int             hasPErefs;        /* the internal subset has PE refs */
+    int              external;        /* are we parsing an external entity */
+
+    int                 valid;        /* is the document valid */
+    int              validate;        /* shall we try to validate ? */
+    xmlValidCtxt        vctxt;        /* The validity context */
+
+    xmlParserInputState instate;      /* current type of input */
+    int                 token;        /* next char look-ahead */    
+
+    char           *directory;        /* the data directory */
+
+    /* Node name stack */
+    const xmlChar     *name;          /* Current parsed Node */
+    int                nameNr;        /* Depth of the parsing stack */
+    int                nameMax;       /* Max depth of the parsing stack */
+    const xmlChar *   *nameTab;       /* array of nodes */
+
+    long               nbChars;       /* number of xmlChar processed */
+    long            checkIndex;       /* used by progressive parsing lookup */
+    int             keepBlanks;       /* ugly but ... */
+    int             disableSAX;       /* SAX callbacks are disabled */
+    int               inSubset;       /* Parsing is in int 1/ext 2 subset */
+    const xmlChar *    intSubName;    /* name of subset */
+    xmlChar *          extSubURI;     /* URI of external subset */
+    xmlChar *          extSubSystem;  /* SYSTEM ID of external subset */
+
+    /* xml:space values */
+    int *              space;         /* Should the parser preserve spaces */
+    int                spaceNr;       /* Depth of the parsing stack */
+    int                spaceMax;      /* Max depth of the parsing stack */
+    int *              spaceTab;      /* array of space infos */
+
+    int                depth;         /* to prevent entity substitution loops */
+    xmlParserInputPtr  entity;        /* used to check entities boundaries */
+    int                charset;       /* encoding of the in-memory content
+				         actually an xmlCharEncoding */
+    int                nodelen;       /* Those two fields are there to */
+    int                nodemem;       /* Speed up large node parsing */
+    int                pedantic;      /* signal pedantic warnings */
+    void              *_private;      /* For user data, libxml won't touch it */
+
+    int                loadsubset;    /* should the external subset be loaded */
+    int                linenumbers;   /* set line number in element content */
+    void              *catalogs;       /* document's own catalog */
+    int                recovery;      /* run in recovery mode */
+    int                progressive;   /* is this a progressive parsing */
+    xmlDictPtr         dict;          /* dictionnary for the parser */
+    const xmlChar *   *atts;          /* array for the attributes callbacks */
+    int                maxatts;       /* the size of the array */
+    int                docdict;       /* use strings from dict to build tree */
+
+    /*
+     * pre-interned strings
+     */
+    const xmlChar *str_xml;
+    const xmlChar *str_xmlns;
+    const xmlChar *str_xml_ns;
+
+    /*
+     * Everything below is used only by the new SAX mode
+     */
+    int                sax2;          /* operating in the new SAX mode */
+    int                nsNr;          /* the number of inherited namespaces */
+    int                nsMax;         /* the size of the arrays */
+    const xmlChar *   *nsTab;         /* the array of prefix/namespace name */
+    int               *attallocs;     /* which attribute were allocated */
+    void *            *pushTab;       /* array of data for push */
+    xmlHashTablePtr    attsDefault;   /* defaulted attributes if any */
+    xmlHashTablePtr    attsSpecial;   /* non-CDATA attributes if any */
+    int                nsWellFormed;  /* is the document XML Nanespace okay */
+    int                options;       /* Extra options */
+
+    /*
+     * Those fields are needed only for treaming parsing so far
+     */
+    int               dictNames;    /* Use dictionary names for the tree */
+    int               freeElemsNr;  /* number of freed element nodes */
+    xmlNodePtr        freeElems;    /* List of freed element nodes */
+    int               freeAttrsNr;  /* number of freed attributes nodes */
+    xmlAttrPtr        freeAttrs;    /* List of freed attributes nodes */
+
+    /*
+     * the complete error informations for the last error.
+     */
+    xmlError          lastError;
+};
+
+/**
+ * xmlSAXLocator:
+ *
+ * A SAX Locator.
+ */
+struct _xmlSAXLocator {
+    const xmlChar *(*getPublicId)(void *ctx);
+    const xmlChar *(*getSystemId)(void *ctx);
+    int (*getLineNumber)(void *ctx);
+    int (*getColumnNumber)(void *ctx);
+};
+
+/**
+ * xmlSAXHandler:
+ *
+ * A SAX handler is bunch of callbacks called by the parser when processing
+ * of the input generate data or structure informations.
+ */
+
+/**
+ * resolveEntitySAXFunc:
+ * @ctx:  the user data (XML parser context)
+ * @publicId: The public ID of the entity
+ * @systemId: The system ID of the entity
+ *
+ * Callback:
+ * The entity loader, to control the loading of external entities,
+ * the application can either:
+ *    - override this resolveEntity() callback in the SAX block
+ *    - or better use the xmlSetExternalEntityLoader() function to
+ *      set up it's own entity resolution routine
+ *
+ * Returns the xmlParserInputPtr if inlined or NULL for DOM behaviour.
+ */
+typedef xmlParserInputPtr (*resolveEntitySAXFunc) (void *ctx,
+				const xmlChar *publicId,
+				const xmlChar *systemId);
+/**
+ * internalSubsetSAXFunc:
+ * @ctx:  the user data (XML parser context)
+ * @name:  the root element name
+ * @ExternalID:  the external ID
+ * @SystemID:  the SYSTEM ID (e.g. filename or URL)
+ *
+ * Callback on internal subset declaration.
+ */
+typedef void (*internalSubsetSAXFunc) (void *ctx,
+				const xmlChar *name,
+				const xmlChar *ExternalID,
+				const xmlChar *SystemID);
+/**
+ * externalSubsetSAXFunc:
+ * @ctx:  the user data (XML parser context)
+ * @name:  the root element name
+ * @ExternalID:  the external ID
+ * @SystemID:  the SYSTEM ID (e.g. filename or URL)
+ *
+ * Callback on external subset declaration.
+ */
+typedef void (*externalSubsetSAXFunc) (void *ctx,
+				const xmlChar *name,
+				const xmlChar *ExternalID,
+				const xmlChar *SystemID);
+/**
+ * getEntitySAXFunc:
+ * @ctx:  the user data (XML parser context)
+ * @name: The entity name
+ *
+ * Get an entity by name.
+ *
+ * Returns the xmlEntityPtr if found.
+ */
+typedef xmlEntityPtr (*getEntitySAXFunc) (void *ctx,
+				const xmlChar *name);
+/**
+ * getParameterEntitySAXFunc:
+ * @ctx:  the user data (XML parser context)
+ * @name: The entity name
+ *
+ * Get a parameter entity by name.
+ *
+ * Returns the xmlEntityPtr if found.
+ */
+typedef xmlEntityPtr (*getParameterEntitySAXFunc) (void *ctx,
+				const xmlChar *name);
+/**
+ * entityDeclSAXFunc:
+ * @ctx:  the user data (XML parser context)
+ * @name:  the entity name 
+ * @type:  the entity type 
+ * @publicId: The public ID of the entity
+ * @systemId: The system ID of the entity
+ * @content: the entity value (without processing).
+ *
+ * An entity definition has been parsed.
+ */
+typedef void (*entityDeclSAXFunc) (void *ctx,
+				const xmlChar *name,
+				int type,
+				const xmlChar *publicId,
+				const xmlChar *systemId,
+				xmlChar *content);
+/**
+ * notationDeclSAXFunc:
+ * @ctx:  the user data (XML parser context)
+ * @name: The name of the notation
+ * @publicId: The public ID of the entity
+ * @systemId: The system ID of the entity
+ *
+ * What to do when a notation declaration has been parsed.
+ */
+typedef void (*notationDeclSAXFunc)(void *ctx,
+				const xmlChar *name,
+				const xmlChar *publicId,
+				const xmlChar *systemId);
+/**
+ * attributeDeclSAXFunc:
+ * @ctx:  the user data (XML parser context)
+ * @elem:  the name of the element
+ * @fullname:  the attribute name 
+ * @type:  the attribute type 
+ * @def:  the type of default value
+ * @defaultValue: the attribute default value
+ * @tree:  the tree of enumerated value set
+ *
+ * An attribute definition has been parsed.
+ */
+typedef void (*attributeDeclSAXFunc)(void *ctx,
+				const xmlChar *elem,
+				const xmlChar *fullname,
+				int type,
+				int def,
+				const xmlChar *defaultValue,
+				xmlEnumerationPtr tree);
+/**
+ * elementDeclSAXFunc:
+ * @ctx:  the user data (XML parser context)
+ * @name:  the element name 
+ * @type:  the element type 
+ * @content: the element value tree
+ *
+ * An element definition has been parsed.
+ */
+typedef void (*elementDeclSAXFunc)(void *ctx,
+				const xmlChar *name,
+				int type,
+				xmlElementContentPtr content);
+/**
+ * unparsedEntityDeclSAXFunc:
+ * @ctx:  the user data (XML parser context)
+ * @name: The name of the entity
+ * @publicId: The public ID of the entity
+ * @systemId: The system ID of the entity
+ * @notationName: the name of the notation
+ *
+ * What to do when an unparsed entity declaration is parsed.
+ */
+typedef void (*unparsedEntityDeclSAXFunc)(void *ctx,
+				const xmlChar *name,
+				const xmlChar *publicId,
+				const xmlChar *systemId,
+				const xmlChar *notationName);
+/**
+ * setDocumentLocatorSAXFunc:
+ * @ctx:  the user data (XML parser context)
+ * @loc: A SAX Locator
+ *
+ * Receive the document locator at startup, actually xmlDefaultSAXLocator.
+ * Everything is available on the context, so this is useless in our case.
+ */
+typedef void (*setDocumentLocatorSAXFunc) (void *ctx,
+				xmlSAXLocatorPtr loc);
+/**
+ * startDocumentSAXFunc:
+ * @ctx:  the user data (XML parser context)
+ *
+ * Called when the document start being processed.
+ */
+typedef void (*startDocumentSAXFunc) (void *ctx);
+/**
+ * endDocumentSAXFunc:
+ * @ctx:  the user data (XML parser context)
+ *
+ * Called when the document end has been detected.
+ */
+typedef void (*endDocumentSAXFunc) (void *ctx);
+/**
+ * startElementSAXFunc:
+ * @ctx:  the user data (XML parser context)
+ * @name:  The element name, including namespace prefix
+ * @atts:  An array of name/value attributes pairs, NULL terminated
+ *
+ * Called when an opening tag has been processed.
+ */
+typedef void (*startElementSAXFunc) (void *ctx,
+				const xmlChar *name,
+				const xmlChar **atts);
+/**
+ * endElementSAXFunc:
+ * @ctx:  the user data (XML parser context)
+ * @name:  The element name
+ *
+ * Called when the end of an element has been detected.
+ */
+typedef void (*endElementSAXFunc) (void *ctx,
+				const xmlChar *name);
+/**
+ * attributeSAXFunc:
+ * @ctx:  the user data (XML parser context)
+ * @name:  The attribute name, including namespace prefix
+ * @value:  The attribute value
+ *
+ * Handle an attribute that has been read by the parser.
+ * The default handling is to convert the attribute into an
+ * DOM subtree and past it in a new xmlAttr element added to
+ * the element.
+ */
+typedef void (*attributeSAXFunc) (void *ctx,
+				const xmlChar *name,
+				const xmlChar *value);
+/**
+ * referenceSAXFunc:
+ * @ctx:  the user data (XML parser context)
+ * @name:  The entity name
+ *
+ * Called when an entity reference is detected. 
+ */
+typedef void (*referenceSAXFunc) (void *ctx,
+				const xmlChar *name);
+/**
+ * charactersSAXFunc:
+ * @ctx:  the user data (XML parser context)
+ * @ch:  a xmlChar string
+ * @len: the number of xmlChar
+ *
+ * Receiving some chars from the parser.
+ */
+typedef void (*charactersSAXFunc) (void *ctx,
+				const xmlChar *ch,
+				int len);
+/**
+ * ignorableWhitespaceSAXFunc:
+ * @ctx:  the user data (XML parser context)
+ * @ch:  a xmlChar string
+ * @len: the number of xmlChar
+ *
+ * Receiving some ignorable whitespaces from the parser.
+ * UNUSED: by default the DOM building will use characters.
+ */
+typedef void (*ignorableWhitespaceSAXFunc) (void *ctx,
+				const xmlChar *ch,
+				int len);
+/**
+ * processingInstructionSAXFunc:
+ * @ctx:  the user data (XML parser context)
+ * @target:  the target name
+ * @data: the PI data's
+ *
+ * A processing instruction has been parsed.
+ */
+typedef void (*processingInstructionSAXFunc) (void *ctx,
+				const xmlChar *target,
+				const xmlChar *data);
+/**
+ * commentSAXFunc:
+ * @ctx:  the user data (XML parser context)
+ * @value:  the comment content
+ *
+ * A comment has been parsed.
+ */
+typedef void (*commentSAXFunc) (void *ctx,
+				const xmlChar *value);
+/**
+ * cdataBlockSAXFunc:
+ * @ctx:  the user data (XML parser context)
+ * @value:  The pcdata content
+ * @len:  the block length
+ *
+ * Called when a pcdata block has been parsed.
+ */
+typedef void (*cdataBlockSAXFunc) (
+	                        void *ctx,
+				const xmlChar *value,
+				int len);
+/**
+ * warningSAXFunc:
+ * @ctx:  an XML parser context
+ * @msg:  the message to display/transmit
+ * @...:  extra parameters for the message display
+ * 
+ * Display and format a warning messages, callback.
+ */
+typedef void (*warningSAXFunc) (void *ctx,
+				const char *msg, ...);
+/**
+ * errorSAXFunc:
+ * @ctx:  an XML parser context
+ * @msg:  the message to display/transmit
+ * @...:  extra parameters for the message display
+ * 
+ * Display and format an error messages, callback.
+ */
+typedef void (*errorSAXFunc) (void *ctx,
+				const char *msg, ...);
+/**
+ * fatalErrorSAXFunc:
+ * @ctx:  an XML parser context
+ * @msg:  the message to display/transmit
+ * @...:  extra parameters for the message display
+ * 
+ * Display and format fatal error messages, callback.
+ * Note: so far fatalError() SAX callbacks are not used, error()
+ *       get all the callbacks for errors.
+ */
+typedef void (*fatalErrorSAXFunc) (void *ctx,
+				const char *msg, ...);
+/**
+ * isStandaloneSAXFunc:
+ * @ctx:  the user data (XML parser context)
+ *
+ * Is this document tagged standalone?
+ *
+ * Returns 1 if true
+ */
+typedef int (*isStandaloneSAXFunc) (void *ctx);
+/**
+ * hasInternalSubsetSAXFunc:
+ * @ctx:  the user data (XML parser context)
+ *
+ * Does this document has an internal subset.
+ *
+ * Returns 1 if true
+ */
+typedef int (*hasInternalSubsetSAXFunc) (void *ctx);
+
+/**
+ * hasExternalSubsetSAXFunc:
+ * @ctx:  the user data (XML parser context)
+ *
+ * Does this document has an external subset?
+ *
+ * Returns 1 if true
+ */
+typedef int (*hasExternalSubsetSAXFunc) (void *ctx);
+
+/************************************************************************
+ *									*
+ *			The SAX version 2 API extensions		*
+ *									*
+ ************************************************************************/
+/**
+ * XML_SAX2_MAGIC:
+ *
+ * Special constant found in SAX2 blocks initialized fields
+ */
+#define XML_SAX2_MAGIC 0xDEEDBEAF
+
+/**
+ * startElementNsSAX2Func:
+ * @ctx:  the user data (XML parser context)
+ * @localname:  the local name of the element
+ * @prefix:  the element namespace prefix if available
+ * @URI:  the element namespace name if available
+ * @nb_namespaces:  number of namespace definitions on that node
+ * @namespaces:  pointer to the array of prefix/URI pairs namespace definitions
+ * @nb_attributes:  the number of attributes on that node
+ * @nb_defaulted:  the number of defaulted attributes. The defaulted
+ *                  ones are at the end of the array
+ * @attributes:  pointer to the array of (localname/prefix/URI/value/end)
+ *               attribute values.
+ *
+ * SAX2 callback when an element start has been detected by the parser.
+ * It provides the namespace informations for the element, as well as
+ * the new namespace declarations on the element.
+ */
+
+typedef void (*startElementNsSAX2Func) (void *ctx,
+					const xmlChar *localname,
+					const xmlChar *prefix,
+					const xmlChar *URI,
+					int nb_namespaces,
+					const xmlChar **namespaces,
+					int nb_attributes,
+					int nb_defaulted,
+					const xmlChar **attributes);
+ 
+/**
+ * endElementNsSAX2Func:
+ * @ctx:  the user data (XML parser context)
+ * @localname:  the local name of the element
+ * @prefix:  the element namespace prefix if available
+ * @URI:  the element namespace name if available
+ *
+ * SAX2 callback when an element end has been detected by the parser.
+ * It provides the namespace informations for the element.
+ */
+
+typedef void (*endElementNsSAX2Func)   (void *ctx,
+					const xmlChar *localname,
+					const xmlChar *prefix,
+					const xmlChar *URI);
+
+
+struct _xmlSAXHandler {
+    internalSubsetSAXFunc internalSubset;
+    isStandaloneSAXFunc isStandalone;
+    hasInternalSubsetSAXFunc hasInternalSubset;
+    hasExternalSubsetSAXFunc hasExternalSubset;
+    resolveEntitySAXFunc resolveEntity;
+    getEntitySAXFunc getEntity;
+    entityDeclSAXFunc entityDecl;
+    notationDeclSAXFunc notationDecl;
+    attributeDeclSAXFunc attributeDecl;
+    elementDeclSAXFunc elementDecl;
+    unparsedEntityDeclSAXFunc unparsedEntityDecl;
+    setDocumentLocatorSAXFunc setDocumentLocator;
+    startDocumentSAXFunc startDocument;
+    endDocumentSAXFunc endDocument;
+    startElementSAXFunc startElement;
+    endElementSAXFunc endElement;
+    referenceSAXFunc reference;
+    charactersSAXFunc characters;
+    ignorableWhitespaceSAXFunc ignorableWhitespace;
+    processingInstructionSAXFunc processingInstruction;
+    commentSAXFunc comment;
+    warningSAXFunc warning;
+    errorSAXFunc error;
+    fatalErrorSAXFunc fatalError; /* unused error() get all the errors */
+    getParameterEntitySAXFunc getParameterEntity;
+    cdataBlockSAXFunc cdataBlock;
+    externalSubsetSAXFunc externalSubset;
+    unsigned int initialized;
+    /* The following fields are extensions available only on version 2 */
+    void *_private;
+    startElementNsSAX2Func startElementNs;
+    endElementNsSAX2Func endElementNs;
+    xmlStructuredErrorFunc serror;
+};
+
+/*
+ * SAX Version 1
+ */
+typedef struct _xmlSAXHandlerV1 xmlSAXHandlerV1;
+typedef xmlSAXHandlerV1 *xmlSAXHandlerV1Ptr;
+struct _xmlSAXHandlerV1 {
+    internalSubsetSAXFunc internalSubset;
+    isStandaloneSAXFunc isStandalone;
+    hasInternalSubsetSAXFunc hasInternalSubset;
+    hasExternalSubsetSAXFunc hasExternalSubset;
+    resolveEntitySAXFunc resolveEntity;
+    getEntitySAXFunc getEntity;
+    entityDeclSAXFunc entityDecl;
+    notationDeclSAXFunc notationDecl;
+    attributeDeclSAXFunc attributeDecl;
+    elementDeclSAXFunc elementDecl;
+    unparsedEntityDeclSAXFunc unparsedEntityDecl;
+    setDocumentLocatorSAXFunc setDocumentLocator;
+    startDocumentSAXFunc startDocument;
+    endDocumentSAXFunc endDocument;
+    startElementSAXFunc startElement;
+    endElementSAXFunc endElement;
+    referenceSAXFunc reference;
+    charactersSAXFunc characters;
+    ignorableWhitespaceSAXFunc ignorableWhitespace;
+    processingInstructionSAXFunc processingInstruction;
+    commentSAXFunc comment;
+    warningSAXFunc warning;
+    errorSAXFunc error;
+    fatalErrorSAXFunc fatalError; /* unused error() get all the errors */
+    getParameterEntitySAXFunc getParameterEntity;
+    cdataBlockSAXFunc cdataBlock;
+    externalSubsetSAXFunc externalSubset;
+    unsigned int initialized;
+};
+
+
+/**
+ * xmlExternalEntityLoader:
+ * @URL: The System ID of the resource requested
+ * @ID: The Public ID of the resource requested
+ * @context: the XML parser context 
+ *
+ * External entity loaders types.
+ *
+ * Returns the entity input parser.
+ */
+typedef xmlParserInputPtr (*xmlExternalEntityLoader) (const char *URL,
+					 const char *ID,
+					 xmlParserCtxtPtr context);
+
+#ifdef __cplusplus
+}
+#endif
+
+#include <libxml/encoding.h>
+#include <libxml/xmlIO.h>
+#include <libxml/globals.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/*
+ * Init/Cleanup
+ */
+XMLPUBFUN void XMLCALL		
+		xmlInitParser		(void);
+XMLPUBFUN void XMLCALL		
+		xmlCleanupParser	(void);
+
+/*
+ * Input functions
+ */
+XMLPUBFUN int XMLCALL		
+		xmlParserInputRead	(xmlParserInputPtr in,
+					 int len);
+XMLPUBFUN int XMLCALL		
+		xmlParserInputGrow	(xmlParserInputPtr in,
+					 int len);
+
+/*
+ * Basic parsing Interfaces
+ */
+XMLPUBFUN xmlDocPtr XMLCALL	
+		xmlParseDoc		(xmlChar *cur);
+XMLPUBFUN xmlDocPtr XMLCALL	
+		xmlParseMemory		(const char *buffer,
+					 int size);
+XMLPUBFUN xmlDocPtr XMLCALL	
+		xmlParseFile		(const char *filename);
+XMLPUBFUN int XMLCALL		
+		xmlSubstituteEntitiesDefault(int val);
+XMLPUBFUN int XMLCALL		
+		xmlKeepBlanksDefault	(int val);
+XMLPUBFUN void XMLCALL		
+		xmlStopParser		(xmlParserCtxtPtr ctxt);
+XMLPUBFUN int XMLCALL		
+		xmlPedanticParserDefault(int val);
+XMLPUBFUN int XMLCALL		
+		xmlLineNumbersDefault	(int val);
+
+/*
+ * Recovery mode 
+ */
+XMLPUBFUN xmlDocPtr XMLCALL	
+		xmlRecoverDoc		(xmlChar *cur);
+XMLPUBFUN xmlDocPtr XMLCALL	
+		xmlRecoverMemory	(const char *buffer,
+					 int size);
+XMLPUBFUN xmlDocPtr XMLCALL	
+		xmlRecoverFile		(const char *filename);
+
+/*
+ * Less common routines and SAX interfaces
+ */
+XMLPUBFUN int XMLCALL		
+		xmlParseDocument	(xmlParserCtxtPtr ctxt);
+XMLPUBFUN int XMLCALL		
+		xmlParseExtParsedEnt	(xmlParserCtxtPtr ctxt);
+XMLPUBFUN xmlDocPtr XMLCALL	
+		xmlSAXParseDoc		(xmlSAXHandlerPtr sax,
+					 xmlChar *cur,
+					 int recovery);
+XMLPUBFUN int XMLCALL		
+		xmlSAXUserParseFile	(xmlSAXHandlerPtr sax,
+					 void *user_data,
+					 const char *filename);
+XMLPUBFUN int XMLCALL		
+		xmlSAXUserParseMemory	(xmlSAXHandlerPtr sax,
+					 void *user_data,
+					 const char *buffer,
+					 int size);
+XMLPUBFUN xmlDocPtr XMLCALL	
+		xmlSAXParseMemory	(xmlSAXHandlerPtr sax,
+					 const char *buffer,
+                                   	 int size,
+					 int recovery);
+XMLPUBFUN xmlDocPtr XMLCALL	
+		xmlSAXParseMemoryWithData (xmlSAXHandlerPtr sax,
+					 const char *buffer,
+                                   	 int size,
+					 int recovery,
+					 void *data);
+XMLPUBFUN xmlDocPtr XMLCALL	
+		xmlSAXParseFile		(xmlSAXHandlerPtr sax,
+					 const char *filename,
+					 int recovery);
+XMLPUBFUN xmlDocPtr XMLCALL	
+		xmlSAXParseFileWithData	(xmlSAXHandlerPtr sax,
+					 const char *filename,
+					 int recovery,
+					 void *data);
+XMLPUBFUN xmlDocPtr XMLCALL	
+		xmlSAXParseEntity	(xmlSAXHandlerPtr sax,
+					 const char *filename);
+XMLPUBFUN xmlDocPtr XMLCALL	
+		xmlParseEntity		(const char *filename);
+XMLPUBFUN xmlDtdPtr XMLCALL	
+		xmlParseDTD		(const xmlChar *ExternalID,
+					 const xmlChar *SystemID);
+XMLPUBFUN xmlDtdPtr XMLCALL	
+		xmlSAXParseDTD		(xmlSAXHandlerPtr sax,
+					 const xmlChar *ExternalID,
+					 const xmlChar *SystemID);
+XMLPUBFUN xmlDtdPtr XMLCALL	
+		xmlIOParseDTD		(xmlSAXHandlerPtr sax,
+					 xmlParserInputBufferPtr input,
+					 xmlCharEncoding enc);
+XMLPUBFUN int XMLCALL	
+		xmlParseBalancedChunkMemory(xmlDocPtr doc,
+					 xmlSAXHandlerPtr sax,
+					 void *user_data,
+					 int depth,
+					 const xmlChar *string,
+					 xmlNodePtr *lst);
+XMLPUBFUN int XMLCALL          
+		xmlParseBalancedChunkMemoryRecover(xmlDocPtr doc,
+                     xmlSAXHandlerPtr sax,
+                     void *user_data,
+                     int depth,
+                     const xmlChar *string,
+                     xmlNodePtr *lst,
+                     int recover);
+XMLPUBFUN int XMLCALL		
+		xmlParseExternalEntity	(xmlDocPtr doc,
+					 xmlSAXHandlerPtr sax,
+					 void *user_data,
+					 int depth,
+					 const xmlChar *URL,
+					 const xmlChar *ID,
+					 xmlNodePtr *lst);
+XMLPUBFUN int XMLCALL		
+		xmlParseCtxtExternalEntity(xmlParserCtxtPtr ctx,
+					 const xmlChar *URL,
+					 const xmlChar *ID,
+					 xmlNodePtr *lst);
+
+/*
+ * Parser contexts handling.
+ */
+XMLPUBFUN xmlParserCtxtPtr XMLCALL	
+		xmlNewParserCtxt	(void);
+XMLPUBFUN int XMLCALL		
+		xmlInitParserCtxt	(xmlParserCtxtPtr ctxt);
+XMLPUBFUN void XMLCALL		
+		xmlClearParserCtxt	(xmlParserCtxtPtr ctxt);
+XMLPUBFUN void XMLCALL		
+		xmlFreeParserCtxt	(xmlParserCtxtPtr ctxt);
+XMLPUBFUN void XMLCALL		
+		xmlSetupParserForBuffer	(xmlParserCtxtPtr ctxt,
+					 const xmlChar* buffer,
+					 const char *filename);
+XMLPUBFUN xmlParserCtxtPtr XMLCALL 
+		xmlCreateDocParserCtxt	(const xmlChar *cur);
+
+/*
+ * Reading/setting optional parsing features.
+ */
+
+XMLPUBFUN int XMLCALL		
+		xmlGetFeaturesList	(int *len,
+					 const char **result);
+XMLPUBFUN int XMLCALL		
+		xmlGetFeature		(xmlParserCtxtPtr ctxt,
+					 const char *name,
+					 void *result);
+XMLPUBFUN int XMLCALL		
+		xmlSetFeature		(xmlParserCtxtPtr ctxt,
+					 const char *name,
+					 void *value);
+
+#ifdef LIBXML_PUSH_ENABLED
+/*
+ * Interfaces for the Push mode.
+ */
+XMLPUBFUN xmlParserCtxtPtr XMLCALL 
+		xmlCreatePushParserCtxt(xmlSAXHandlerPtr sax,
+					 void *user_data,
+					 const char *chunk,
+					 int size,
+					 const char *filename);
+XMLPUBFUN int XMLCALL		 
+		xmlParseChunk		(xmlParserCtxtPtr ctxt,
+					 const char *chunk,
+					 int size,
+					 int terminate);
+#endif /* LIBXML_PUSH_ENABLED */
+
+/*
+ * Special I/O mode.
+ */
+
+XMLPUBFUN xmlParserCtxtPtr XMLCALL 
+		xmlCreateIOParserCtxt	(xmlSAXHandlerPtr sax,
+					 void *user_data,
+					 xmlInputReadCallback   ioread,
+					 xmlInputCloseCallback  ioclose,
+					 void *ioctx,
+					 xmlCharEncoding enc);
+
+XMLPUBFUN xmlParserInputPtr XMLCALL 
+		xmlNewIOInputStream	(xmlParserCtxtPtr ctxt,
+					 xmlParserInputBufferPtr input,
+					 xmlCharEncoding enc);
+
+/*
+ * Node infos.
+ */
+XMLPUBFUN const xmlParserNodeInfo* XMLCALL
+		xmlParserFindNodeInfo	(const xmlParserCtxtPtr ctxt,
+				         const xmlNodePtr node);
+XMLPUBFUN void XMLCALL		
+		xmlInitNodeInfoSeq	(xmlParserNodeInfoSeqPtr seq);
+XMLPUBFUN void XMLCALL		
+		xmlClearNodeInfoSeq	(xmlParserNodeInfoSeqPtr seq);
+XMLPUBFUN unsigned long XMLCALL 
+		xmlParserFindNodeInfoIndex(const xmlParserNodeInfoSeqPtr seq,
+                                         const xmlNodePtr node);
+XMLPUBFUN void XMLCALL		
+		xmlParserAddNodeInfo	(xmlParserCtxtPtr ctxt,
+					 const xmlParserNodeInfoPtr info);
+
+/*
+ * External entities handling actually implemented in xmlIO.
+ */
+
+XMLPUBFUN void XMLCALL		
+		xmlSetExternalEntityLoader(xmlExternalEntityLoader f);
+XMLPUBFUN xmlExternalEntityLoader XMLCALL
+		xmlGetExternalEntityLoader(void);
+XMLPUBFUN xmlParserInputPtr XMLCALL
+		xmlLoadExternalEntity	(const char *URL,
+					 const char *ID,
+					 xmlParserCtxtPtr ctxt);
+
+/*
+ * Index lookup, actually implemented in the encoding module
+ */
+XMLPUBFUN long XMLCALL
+		xmlByteConsumed		(xmlParserCtxtPtr ctxt);
+
+/*
+ * New set of simpler/more flexible APIs
+ */
+/**
+ * xmlParserOption:
+ *
+ * This is the set of XML parser options that can be passed down
+ * to the xmlReadDoc() and similar calls.
+ */
+typedef enum {
+    XML_PARSE_RECOVER	= 1<<0,	/* recover on errors */
+    XML_PARSE_NOENT	= 1<<1,	/* substitute entities */
+    XML_PARSE_DTDLOAD	= 1<<2,	/* load the external subset */
+    XML_PARSE_DTDATTR	= 1<<3,	/* default DTD attributes */
+    XML_PARSE_DTDVALID	= 1<<4,	/* validate with the DTD */
+    XML_PARSE_NOERROR	= 1<<5,	/* suppress error reports */
+    XML_PARSE_NOWARNING	= 1<<6,	/* suppress warning reports */
+    XML_PARSE_PEDANTIC	= 1<<7,	/* pedantic error reporting */
+    XML_PARSE_NOBLANKS	= 1<<8,	/* remove blank nodes */
+    XML_PARSE_SAX1	= 1<<9,	/* use the SAX1 interface internally */
+    XML_PARSE_XINCLUDE	= 1<<10,/* Implement XInclude substitition  */
+    XML_PARSE_NONET	= 1<<11,/* Forbid network access */
+    XML_PARSE_NODICT	= 1<<12,/* Do not reuse the context dictionnary */
+    XML_PARSE_NSCLEAN	= 1<<13,/* remove redundant namespaces declarations */
+    XML_PARSE_NOCDATA	= 1<<14 /* merge CDATA as text nodes */
+} xmlParserOption;
+
+XMLPUBFUN void XMLCALL
+		xmlCtxtReset		(xmlParserCtxtPtr ctxt);
+XMLPUBFUN int XMLCALL
+		xmlCtxtResetPush	(xmlParserCtxtPtr ctxt,
+					 const char *chunk,
+					 int size,
+					 const char *filename,
+					 const char *encoding);
+XMLPUBFUN int XMLCALL
+		xmlCtxtUseOptions	(xmlParserCtxtPtr ctxt,
+					 int options);
+XMLPUBFUN xmlDocPtr XMLCALL
+		xmlReadDoc		(const xmlChar *cur,
+					 const char *URL,
+					 const char *encoding,
+					 int options);
+XMLPUBFUN xmlDocPtr XMLCALL
+		xmlReadFile		(const char *URL,
+					 const char *encoding,
+					 int options);
+XMLPUBFUN xmlDocPtr XMLCALL
+		xmlReadMemory		(const char *buffer,
+					 int size,
+					 const char *URL,
+					 const char *encoding,
+					 int options);
+XMLPUBFUN xmlDocPtr XMLCALL
+		xmlReadFd		(int fd,
+					 const char *URL,
+					 const char *encoding,
+					 int options);
+XMLPUBFUN xmlDocPtr XMLCALL
+		xmlReadIO		(xmlInputReadCallback ioread,
+					 xmlInputCloseCallback ioclose,
+					 void *ioctx,
+					 const char *URL,
+					 const char *encoding,
+					 int options);
+XMLPUBFUN xmlDocPtr XMLCALL
+		xmlCtxtReadDoc		(xmlParserCtxtPtr ctxt,
+					 const xmlChar *cur,
+					 const char *URL,
+					 const char *encoding,
+					 int options);
+XMLPUBFUN xmlDocPtr XMLCALL
+		xmlCtxtReadFile		(xmlParserCtxtPtr ctxt,
+					 const char *filename,
+					 const char *encoding,
+					 int options);
+XMLPUBFUN xmlDocPtr XMLCALL
+		xmlCtxtReadMemory		(xmlParserCtxtPtr ctxt,
+					 const char *buffer,
+					 int size,
+					 const char *URL,
+					 const char *encoding,
+					 int options);
+XMLPUBFUN xmlDocPtr XMLCALL
+		xmlCtxtReadFd		(xmlParserCtxtPtr ctxt,
+					 int fd,
+					 const char *URL,
+					 const char *encoding,
+					 int options);
+XMLPUBFUN xmlDocPtr XMLCALL
+		xmlCtxtReadIO		(xmlParserCtxtPtr ctxt,
+					 xmlInputReadCallback ioread,
+					 xmlInputCloseCallback ioclose,
+					 void *ioctx,
+					 const char *URL,
+					 const char *encoding,
+					 int options);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* __XML_PARSER_H__ */
+
diff --git a/src/libxml/include/libxml/parserInternals.h b/src/libxml/include/libxml/parserInternals.h
new file mode 100644
index 0000000..7e4503d
--- /dev/null
+++ b/src/libxml/include/libxml/parserInternals.h
@@ -0,0 +1,576 @@
+/*
+ * Summary: internals routines exported by the parser.
+ * Description: this module exports a number of internal parsing routines
+ *              they are not really all intended for applications but
+ *              can prove useful doing low level processing.
+ *
+ * Copy: See Copyright for the status of this software.
+ *
+ * Author: Daniel Veillard
+ */
+
+#ifndef __XML_PARSER_INTERNALS_H__
+#define __XML_PARSER_INTERNALS_H__
+
+#include <libxml/xmlversion.h>
+#include <libxml/parser.h>
+#include <libxml/HTMLparser.h>
+#include <libxml/chvalid.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * xmlParserMaxDepth:
+ *
+ * arbitrary depth limit for the XML documents that we allow to 
+ * process. This is not a limitation of the parser but a safety 
+ * boundary feature.
+ */
+XMLPUBVAR unsigned int xmlParserMaxDepth;
+
+ /**
+  * XML_MAX_NAMELEN:
+  *
+  * Identifiers can be longer, but this will be more costly
+  * at runtime.
+  */
+#define XML_MAX_NAMELEN 100
+
+/**
+ * INPUT_CHUNK:
+ *
+ * The parser tries to always have that amount of input ready.
+ * One of the point is providing context when reporting errors.
+ */
+#define INPUT_CHUNK	250
+
+/************************************************************************
+ *									*
+ * UNICODE version of the macros.      					*
+ *									*
+ ************************************************************************/
+/**
+ * IS_BYTE_CHAR:
+ * @c:  an byte value (int)
+ *
+ * Macro to check the following production in the XML spec:
+ *
+ * [2] Char ::= #x9 | #xA | #xD | [#x20...]
+ * any byte character in the accepted range
+ */
+#define IS_BYTE_CHAR(c)	 xmlIsChar_ch(c)
+
+/**
+ * IS_CHAR:
+ * @c:  an UNICODE value (int)
+ *
+ * Macro to check the following production in the XML spec:
+ *
+ * [2] Char ::= #x9 | #xA | #xD | [#x20-#xD7FF] | [#xE000-#xFFFD]
+ *                  | [#x10000-#x10FFFF]
+ * any Unicode character, excluding the surrogate blocks, FFFE, and FFFF.
+ */
+#define IS_CHAR(c)   xmlIsCharQ(c)
+
+/**
+ * IS_CHAR_CH:
+ * @c: an xmlChar (usually an unsigned char)
+ *
+ * Behaves like IS_CHAR on single-byte value
+ */
+#define IS_CHAR_CH(c)  xmlIsChar_ch(c)
+
+/**
+ * IS_BLANK:
+ * @c:  an UNICODE value (int)
+ *
+ * Macro to check the following production in the XML spec:
+ *
+ * [3] S ::= (#x20 | #x9 | #xD | #xA)+
+ */
+#define IS_BLANK(c)  xmlIsBlankQ(c)
+
+/**
+ * IS_BLANK_CH:
+ * @c:  an xmlChar value (normally unsigned char)
+ *
+ * Behaviour same as IS_BLANK
+ */
+#define IS_BLANK_CH(c)  xmlIsBlank_ch(c)
+
+/**
+ * IS_BASECHAR:
+ * @c:  an UNICODE value (int)
+ *
+ * Macro to check the following production in the XML spec:
+ *
+ * [85] BaseChar ::= ... long list see REC ...
+ */
+#define IS_BASECHAR(c) xmlIsBaseCharQ(c)
+
+/**
+ * IS_DIGIT:
+ * @c:  an UNICODE value (int)
+ *
+ * Macro to check the following production in the XML spec:
+ *
+ * [88] Digit ::= ... long list see REC ...
+ */
+#define IS_DIGIT(c) xmlIsDigitQ(c)
+
+/**
+ * IS_DIGIT_CH:
+ * @c:  an xmlChar value (usually an unsigned char)
+ *
+ * Behaves like IS_DIGIT but with a single byte argument
+ */
+#define IS_DIGIT_CH(c)  xmlIsDigit_ch(c)
+
+/**
+ * IS_COMBINING:
+ * @c:  an UNICODE value (int)
+ *
+ * Macro to check the following production in the XML spec:
+ *
+ * [87] CombiningChar ::= ... long list see REC ...
+ */
+#define IS_COMBINING(c) xmlIsCombiningQ(c)
+
+/**
+ * IS_COMBINING_CH:
+ * @c:  an xmlChar (usually an unsigned char)
+ *
+ * Always false (all combining chars > 0xff)
+ */
+#define IS_COMBINING_CH(c) 0 
+
+/**
+ * IS_EXTENDER:
+ * @c:  an UNICODE value (int)
+ *
+ * Macro to check the following production in the XML spec:
+ *
+ *
+ * [89] Extender ::= #x00B7 | #x02D0 | #x02D1 | #x0387 | #x0640 |
+ *                   #x0E46 | #x0EC6 | #x3005 | [#x3031-#x3035] |
+ *                   [#x309D-#x309E] | [#x30FC-#x30FE]
+ */
+#define IS_EXTENDER(c) xmlIsExtenderQ(c)
+
+/**
+ * IS_EXTENDER_CH:
+ * @c:  an xmlChar value (usually an unsigned char)
+ *
+ * Behaves like IS_EXTENDER but with a single-byte argument
+ */
+#define IS_EXTENDER_CH(c)  xmlIsExtender_ch(c)
+
+/**
+ * IS_IDEOGRAPHIC:
+ * @c:  an UNICODE value (int)
+ *
+ * Macro to check the following production in the XML spec:
+ *
+ *
+ * [86] Ideographic ::= [#x4E00-#x9FA5] | #x3007 | [#x3021-#x3029]
+ */
+#define IS_IDEOGRAPHIC(c) xmlIsIdeographicQ(c)
+
+/**
+ * IS_LETTER:
+ * @c:  an UNICODE value (int)
+ *
+ * Macro to check the following production in the XML spec:
+ *
+ *
+ * [84] Letter ::= BaseChar | Ideographic 
+ */
+#define IS_LETTER(c) (IS_BASECHAR(c) || IS_IDEOGRAPHIC(c))
+
+/**
+ * IS_LETTER_CH:
+ * @c:  an xmlChar value (normally unsigned char)
+ *
+ * Macro behaves like IS_LETTER, but only check base chars
+ *
+ */
+#define IS_LETTER_CH(c) xmlIsBaseChar_ch(c)
+/**
+ * IS_PUBIDCHAR:
+ * @c:  an UNICODE value (int)
+ *
+ * Macro to check the following production in the XML spec:
+ *
+ *
+ * [13] PubidChar ::= #x20 | #xD | #xA | [a-zA-Z0-9] | [-'()+,./:=?;!*#@$_%]
+ */
+#define IS_PUBIDCHAR(c)	xmlIsPubidCharQ(c)
+
+/**
+ * IS_PUBIDCHAR_CH:
+ * @c:  an xmlChar value (normally unsigned char)
+ *
+ * Same as IS_PUBIDCHAR but for single-byte value
+ */
+#define IS_PUBIDCHAR_CH(c) xmlIsPubidChar_ch(c)
+
+/**
+ * SKIP_EOL:
+ * @p:  and UTF8 string pointer
+ *
+ * Skips the end of line chars.
+ */
+#define SKIP_EOL(p) 							\
+    if (*(p) == 0x13) { p++ ; if (*(p) == 0x10) p++; }			\
+    if (*(p) == 0x10) { p++ ; if (*(p) == 0x13) p++; }
+
+/**
+ * MOVETO_ENDTAG:
+ * @p:  and UTF8 string pointer
+ *
+ * Skips to the next '>' char.
+ */
+#define MOVETO_ENDTAG(p)						\
+    while ((*p) && (*(p) != '>')) (p)++
+
+/**
+ * MOVETO_STARTTAG:
+ * @p:  and UTF8 string pointer
+ *
+ * Skips to the next '<' char.
+ */
+#define MOVETO_STARTTAG(p)						\
+    while ((*p) && (*(p) != '<')) (p)++
+
+/**
+ * Global variables used for predefined strings.
+ */
+XMLPUBVAR const xmlChar xmlStringText[];
+XMLPUBVAR const xmlChar xmlStringTextNoenc[];
+XMLPUBVAR const xmlChar xmlStringComment[];
+
+/*
+ * Function to finish the work of the macros where needed.
+ */
+XMLPUBFUN int XMLCALL                   xmlIsLetter     (int c);
+
+/**
+ * Parser context.
+ */
+XMLPUBFUN xmlParserCtxtPtr XMLCALL	
+			xmlCreateFileParserCtxt	(const char *filename);
+XMLPUBFUN xmlParserCtxtPtr XMLCALL	
+			xmlCreateURLParserCtxt	(const char *filename,
+						 int options);
+XMLPUBFUN xmlParserCtxtPtr XMLCALL	
+			xmlCreateMemoryParserCtxt(const char *buffer,
+						 int size);
+XMLPUBFUN xmlParserCtxtPtr XMLCALL	
+			xmlCreateEntityParserCtxt(const xmlChar *URL,
+						 const xmlChar *ID,
+						 const xmlChar *base);
+XMLPUBFUN int XMLCALL			
+			xmlSwitchEncoding	(xmlParserCtxtPtr ctxt,
+						 xmlCharEncoding enc);
+XMLPUBFUN int XMLCALL			
+			xmlSwitchToEncoding	(xmlParserCtxtPtr ctxt,
+					 xmlCharEncodingHandlerPtr handler);
+XMLPUBFUN int XMLCALL			
+			xmlSwitchInputEncoding	(xmlParserCtxtPtr ctxt,
+						 xmlParserInputPtr input,
+					 xmlCharEncodingHandlerPtr handler);
+
+#ifdef IN_LIBXML
+/* internal error reporting */
+XMLPUBFUN void XMLCALL
+			__xmlErrEncoding	(xmlParserCtxtPtr ctxt,
+						 xmlParserErrors error,
+						 const char *msg,
+						 const xmlChar * str1,
+						 const xmlChar * str2);
+#endif
+/**
+ * Entities
+ */
+XMLPUBFUN void XMLCALL			
+			xmlHandleEntity		(xmlParserCtxtPtr ctxt,
+						 xmlEntityPtr entity);
+
+/**
+ * Input Streams.
+ */
+XMLPUBFUN xmlParserInputPtr XMLCALL	
+			xmlNewStringInputStream	(xmlParserCtxtPtr ctxt,
+						 const xmlChar *buffer);
+XMLPUBFUN xmlParserInputPtr XMLCALL	
+			xmlNewEntityInputStream	(xmlParserCtxtPtr ctxt,
+						 xmlEntityPtr entity);
+XMLPUBFUN void XMLCALL			
+			xmlPushInput		(xmlParserCtxtPtr ctxt,
+						 xmlParserInputPtr input);
+XMLPUBFUN xmlChar XMLCALL			
+			xmlPopInput		(xmlParserCtxtPtr ctxt);
+XMLPUBFUN void XMLCALL			
+			xmlFreeInputStream	(xmlParserInputPtr input);
+XMLPUBFUN xmlParserInputPtr XMLCALL	
+			xmlNewInputFromFile	(xmlParserCtxtPtr ctxt,
+						 const char *filename);
+XMLPUBFUN xmlParserInputPtr XMLCALL	
+			xmlNewInputStream	(xmlParserCtxtPtr ctxt);
+
+/**
+ * Namespaces.
+ */
+XMLPUBFUN xmlChar * XMLCALL		
+			xmlSplitQName		(xmlParserCtxtPtr ctxt,
+						 const xmlChar *name,
+						 xmlChar **prefix);
+XMLPUBFUN xmlChar * XMLCALL		
+			xmlNamespaceParseNCName	(xmlParserCtxtPtr ctxt);
+XMLPUBFUN xmlChar * XMLCALL		
+			xmlNamespaceParseQName	(xmlParserCtxtPtr ctxt,
+						 xmlChar **prefix);
+XMLPUBFUN xmlChar * XMLCALL		
+			xmlNamespaceParseNSDef	(xmlParserCtxtPtr ctxt);
+XMLPUBFUN xmlChar * XMLCALL		
+			xmlParseQuotedString	(xmlParserCtxtPtr ctxt);
+XMLPUBFUN void XMLCALL			
+			xmlParseNamespace	(xmlParserCtxtPtr ctxt);
+
+/**
+ * Generic production rules.
+ */
+XMLPUBFUN xmlChar * XMLCALL		
+			xmlScanName		(xmlParserCtxtPtr ctxt);
+XMLPUBFUN const xmlChar * XMLCALL		
+			xmlParseName		(xmlParserCtxtPtr ctxt);
+XMLPUBFUN xmlChar * XMLCALL		
+			xmlParseNmtoken		(xmlParserCtxtPtr ctxt);
+XMLPUBFUN xmlChar * XMLCALL		
+			xmlParseEntityValue	(xmlParserCtxtPtr ctxt,
+						 xmlChar **orig);
+XMLPUBFUN xmlChar * XMLCALL		
+			xmlParseAttValue	(xmlParserCtxtPtr ctxt);
+XMLPUBFUN xmlChar * XMLCALL		
+			xmlParseSystemLiteral	(xmlParserCtxtPtr ctxt);
+XMLPUBFUN xmlChar * XMLCALL		
+			xmlParsePubidLiteral	(xmlParserCtxtPtr ctxt);
+XMLPUBFUN void XMLCALL			
+			xmlParseCharData	(xmlParserCtxtPtr ctxt,
+						 int cdata);
+XMLPUBFUN xmlChar * XMLCALL		
+			xmlParseExternalID	(xmlParserCtxtPtr ctxt,
+						 xmlChar **publicID,
+						 int strict);
+XMLPUBFUN void XMLCALL			
+			xmlParseComment		(xmlParserCtxtPtr ctxt);
+XMLPUBFUN const xmlChar * XMLCALL		
+			xmlParsePITarget	(xmlParserCtxtPtr ctxt);
+XMLPUBFUN void XMLCALL			
+			xmlParsePI		(xmlParserCtxtPtr ctxt);
+XMLPUBFUN void XMLCALL			
+			xmlParseNotationDecl	(xmlParserCtxtPtr ctxt);
+XMLPUBFUN void XMLCALL			
+			xmlParseEntityDecl	(xmlParserCtxtPtr ctxt);
+XMLPUBFUN int XMLCALL			
+			xmlParseDefaultDecl	(xmlParserCtxtPtr ctxt,
+						 xmlChar **value);
+XMLPUBFUN xmlEnumerationPtr XMLCALL	
+			xmlParseNotationType	(xmlParserCtxtPtr ctxt);
+XMLPUBFUN xmlEnumerationPtr XMLCALL	
+			xmlParseEnumerationType	(xmlParserCtxtPtr ctxt);
+XMLPUBFUN int XMLCALL			
+			xmlParseEnumeratedType	(xmlParserCtxtPtr ctxt,
+						 xmlEnumerationPtr *tree);
+XMLPUBFUN int XMLCALL			
+			xmlParseAttributeType	(xmlParserCtxtPtr ctxt,
+						 xmlEnumerationPtr *tree);
+XMLPUBFUN void XMLCALL			
+			xmlParseAttributeListDecl(xmlParserCtxtPtr ctxt);
+XMLPUBFUN xmlElementContentPtr XMLCALL	
+			xmlParseElementMixedContentDecl
+						(xmlParserCtxtPtr ctxt,
+						 int inputchk);
+XMLPUBFUN xmlElementContentPtr XMLCALL	
+			xmlParseElementChildrenContentDecl
+						(xmlParserCtxtPtr ctxt,
+						 int inputchk);
+XMLPUBFUN int XMLCALL			
+			xmlParseElementContentDecl(xmlParserCtxtPtr ctxt,
+						 const xmlChar *name,
+						 xmlElementContentPtr *result);
+XMLPUBFUN int XMLCALL			
+			xmlParseElementDecl	(xmlParserCtxtPtr ctxt);
+XMLPUBFUN void XMLCALL			
+			xmlParseMarkupDecl	(xmlParserCtxtPtr ctxt);
+XMLPUBFUN int XMLCALL			
+			xmlParseCharRef		(xmlParserCtxtPtr ctxt);
+XMLPUBFUN xmlEntityPtr XMLCALL		
+			xmlParseEntityRef	(xmlParserCtxtPtr ctxt);
+XMLPUBFUN void XMLCALL			
+			xmlParseReference	(xmlParserCtxtPtr ctxt);
+XMLPUBFUN void XMLCALL			
+			xmlParsePEReference	(xmlParserCtxtPtr ctxt);
+XMLPUBFUN void XMLCALL			
+			xmlParseDocTypeDecl	(xmlParserCtxtPtr ctxt);
+XMLPUBFUN const xmlChar * XMLCALL		
+			xmlParseAttribute	(xmlParserCtxtPtr ctxt,
+						 xmlChar **value);
+XMLPUBFUN const xmlChar * XMLCALL		
+			xmlParseStartTag	(xmlParserCtxtPtr ctxt);
+XMLPUBFUN void XMLCALL			
+			xmlParseEndTag		(xmlParserCtxtPtr ctxt);
+XMLPUBFUN void XMLCALL			
+			xmlParseCDSect		(xmlParserCtxtPtr ctxt);
+XMLPUBFUN void XMLCALL			
+			xmlParseContent		(xmlParserCtxtPtr ctxt);
+XMLPUBFUN void XMLCALL			
+			xmlParseElement		(xmlParserCtxtPtr ctxt);
+XMLPUBFUN xmlChar * XMLCALL		
+			xmlParseVersionNum	(xmlParserCtxtPtr ctxt);
+XMLPUBFUN xmlChar * XMLCALL		
+			xmlParseVersionInfo	(xmlParserCtxtPtr ctxt);
+XMLPUBFUN xmlChar * XMLCALL		
+			xmlParseEncName		(xmlParserCtxtPtr ctxt);
+XMLPUBFUN const xmlChar * XMLCALL		
+			xmlParseEncodingDecl	(xmlParserCtxtPtr ctxt);
+XMLPUBFUN int XMLCALL			
+			xmlParseSDDecl		(xmlParserCtxtPtr ctxt);
+XMLPUBFUN void XMLCALL			
+			xmlParseXMLDecl		(xmlParserCtxtPtr ctxt);
+XMLPUBFUN void XMLCALL			
+			xmlParseTextDecl	(xmlParserCtxtPtr ctxt);
+XMLPUBFUN void XMLCALL			
+			xmlParseMisc		(xmlParserCtxtPtr ctxt);
+XMLPUBFUN void XMLCALL			
+			xmlParseExternalSubset	(xmlParserCtxtPtr ctxt,
+						 const xmlChar *ExternalID,
+						 const xmlChar *SystemID); 
+/**
+ * XML_SUBSTITUTE_NONE:
+ *
+ * If no entities need to be substituted.
+ */
+#define XML_SUBSTITUTE_NONE	0
+/**
+ * XML_SUBSTITUTE_REF:
+ *
+ * Whether general entities need to be substituted.
+ */
+#define XML_SUBSTITUTE_REF	1
+/**
+ * XML_SUBSTITUTE_PEREF:
+ *
+ * Whether parameter entities need to be substituted.
+ */
+#define XML_SUBSTITUTE_PEREF	2
+/**
+ * XML_SUBSTITUTE_BOTH:
+ *
+ * Both general and parameter entities need to be substituted.
+ */
+#define XML_SUBSTITUTE_BOTH 	3
+
+XMLPUBFUN xmlChar * XMLCALL
+		xmlDecodeEntities		(xmlParserCtxtPtr ctxt,
+						 int len,
+						 int what,
+						 xmlChar end,
+						 xmlChar  end2,
+						 xmlChar end3);
+XMLPUBFUN xmlChar * XMLCALL
+		xmlStringDecodeEntities		(xmlParserCtxtPtr ctxt,
+						 const xmlChar *str,
+						 int what,
+						 xmlChar end,
+						 xmlChar  end2,
+						 xmlChar end3);
+XMLPUBFUN xmlChar * XMLCALL
+		xmlStringLenDecodeEntities	(xmlParserCtxtPtr ctxt,
+						 const xmlChar *str,
+						 int len,
+						 int what,
+						 xmlChar end,
+						 xmlChar  end2,
+						 xmlChar end3);
+
+/*
+ * Generated by MACROS on top of parser.c c.f. PUSH_AND_POP.
+ */
+XMLPUBFUN int XMLCALL			nodePush		(xmlParserCtxtPtr ctxt,
+						 xmlNodePtr value);
+XMLPUBFUN xmlNodePtr XMLCALL		nodePop			(xmlParserCtxtPtr ctxt);
+XMLPUBFUN int XMLCALL			inputPush		(xmlParserCtxtPtr ctxt,
+						 xmlParserInputPtr value);
+XMLPUBFUN xmlParserInputPtr XMLCALL	inputPop		(xmlParserCtxtPtr ctxt);
+XMLPUBFUN const xmlChar * XMLCALL	namePop			(xmlParserCtxtPtr ctxt);
+XMLPUBFUN int XMLCALL			namePush		(xmlParserCtxtPtr ctxt,
+						 const xmlChar *value);
+
+/*
+ * other commodities shared between parser.c and parserInternals.
+ */
+XMLPUBFUN int XMLCALL			xmlSkipBlankChars	(xmlParserCtxtPtr ctxt);
+XMLPUBFUN int XMLCALL			xmlStringCurrentChar	(xmlParserCtxtPtr ctxt,
+						 const xmlChar *cur,
+						 int *len);
+XMLPUBFUN void XMLCALL			xmlParserHandlePEReference(xmlParserCtxtPtr ctxt);
+XMLPUBFUN void XMLCALL			xmlParserHandleReference(xmlParserCtxtPtr ctxt);
+XMLPUBFUN int XMLCALL			xmlCheckLanguageID	(const xmlChar *lang);
+
+/*
+ * Really core function shared with HTML parser.
+ */
+XMLPUBFUN int XMLCALL			xmlCurrentChar		(xmlParserCtxtPtr ctxt,
+						 int *len);
+XMLPUBFUN int XMLCALL		xmlCopyCharMultiByte	(xmlChar *out,
+						 int val);
+XMLPUBFUN int XMLCALL			xmlCopyChar		(int len,
+						 xmlChar *out,
+						 int val);
+XMLPUBFUN void XMLCALL			xmlNextChar		(xmlParserCtxtPtr ctxt);
+XMLPUBFUN void XMLCALL			xmlParserInputShrink	(xmlParserInputPtr in);
+
+#ifdef LIBXML_HTML_ENABLED
+/*
+ * Actually comes from the HTML parser but launched from the init stuff.
+ */
+XMLPUBFUN void XMLCALL			htmlInitAutoClose	(void);
+XMLPUBFUN htmlParserCtxtPtr XMLCALL	htmlCreateFileParserCtxt(const char *filename,
+	                                         const char *encoding);
+#endif
+
+/*
+ * Specific function to keep track of entities references
+ * and used by the XSLT debugger.
+ */
+/**
+ * xmlEntityReferenceFunc:
+ * @ent: the entity
+ * @firstNode:  the fist node in the chunk
+ * @lastNode:  the last nod in the chunk
+ *
+ * Callback function used when one needs to be able to track back the
+ * provenance of a chunk of nodes inherited from an entity replacement.
+ */
+typedef	void	(*xmlEntityReferenceFunc)	(xmlEntityPtr ent,
+						 xmlNodePtr firstNode,
+						 xmlNodePtr lastNode);
+  
+XMLPUBFUN void XMLCALL		xmlSetEntityReferenceFunc	(xmlEntityReferenceFunc func);
+
+#ifdef IN_LIBXML
+/*
+ * internal only
+ */
+XMLPUBFUN void XMLCALL
+	xmlErrMemory		(xmlParserCtxtPtr ctxt,
+				 const char *extra);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* __XML_PARSER_INTERNALS_H__ */
diff --git a/src/libxml/include/libxml/pattern.h b/src/libxml/include/libxml/pattern.h
new file mode 100644
index 0000000..9db9c4e
--- /dev/null
+++ b/src/libxml/include/libxml/pattern.h
@@ -0,0 +1,48 @@
+/*
+ * Summary: pattern expression handling
+ * Description: allows to compile and test pattern expressions for nodes
+ *              either in a tree or based on a parser state.
+ *
+ * Copy: See Copyright for the status of this software.
+ *
+ * Author: Daniel Veillard
+ */
+
+#ifndef __XML_PATTERN_H__
+#define __XML_PATTERN_H__
+
+#include <libxml/xmlversion.h>
+#include <libxml/tree.h>
+#include <libxml/dict.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * xmlPattern:
+ *
+ * A compiled (XPath based) pattern to select nodes
+ */
+typedef struct _xmlPattern xmlPattern;
+typedef xmlPattern *xmlPatternPtr;
+
+XMLPUBFUN void XMLCALL
+			xmlFreePattern		(xmlPatternPtr comp);
+
+XMLPUBFUN void XMLCALL
+			xmlFreePatternList	(xmlPatternPtr comp);
+
+XMLPUBFUN xmlPatternPtr XMLCALL
+			xmlPatterncompile	(const xmlChar *pattern,
+						 xmlDict *dict,
+						 int flags,
+						 const xmlChar **namespaces);
+XMLPUBFUN int XMLCALL
+			xmlPatternMatch		(xmlPatternPtr comp,
+						 xmlNodePtr node);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* __XML_PATTERN_H__ */
diff --git a/src/libxml/include/libxml/relaxng.h b/src/libxml/include/libxml/relaxng.h
new file mode 100644
index 0000000..e970289
--- /dev/null
+++ b/src/libxml/include/libxml/relaxng.h
@@ -0,0 +1,179 @@
+/*
+ * Summary: implementation of the Relax-NG validation
+ * Description: implementation of the Relax-NG validation
+ *
+ * Copy: See Copyright for the status of this software.
+ *
+ * Author: Daniel Veillard
+ */
+
+#ifndef __XML_RELAX_NG__
+#define __XML_RELAX_NG__
+
+#include <libxml/xmlversion.h>
+#include <libxml/hash.h>
+#include <libxml/xmlstring.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct _xmlRelaxNG xmlRelaxNG;
+typedef xmlRelaxNG *xmlRelaxNGPtr;
+
+
+/**
+ * A schemas validation context
+ */
+typedef void (*xmlRelaxNGValidityErrorFunc) (void *ctx, const char *msg, ...);
+typedef void (*xmlRelaxNGValidityWarningFunc) (void *ctx, const char *msg, ...);
+
+typedef struct _xmlRelaxNGParserCtxt xmlRelaxNGParserCtxt;
+typedef xmlRelaxNGParserCtxt *xmlRelaxNGParserCtxtPtr;
+
+typedef struct _xmlRelaxNGValidCtxt xmlRelaxNGValidCtxt;
+typedef xmlRelaxNGValidCtxt *xmlRelaxNGValidCtxtPtr;
+
+/*
+ * xmlRelaxNGValidErr:
+ *
+ * List of possible Relax NG validation errors
+ */
+typedef enum {
+    XML_RELAXNG_OK = 0,
+    XML_RELAXNG_ERR_MEMORY,
+    XML_RELAXNG_ERR_TYPE,
+    XML_RELAXNG_ERR_TYPEVAL,
+    XML_RELAXNG_ERR_DUPID,
+    XML_RELAXNG_ERR_TYPECMP,
+    XML_RELAXNG_ERR_NOSTATE,
+    XML_RELAXNG_ERR_NODEFINE,
+    XML_RELAXNG_ERR_LISTEXTRA,
+    XML_RELAXNG_ERR_LISTEMPTY,
+    XML_RELAXNG_ERR_INTERNODATA,
+    XML_RELAXNG_ERR_INTERSEQ,
+    XML_RELAXNG_ERR_INTEREXTRA,
+    XML_RELAXNG_ERR_ELEMNAME,
+    XML_RELAXNG_ERR_ATTRNAME,
+    XML_RELAXNG_ERR_ELEMNONS,
+    XML_RELAXNG_ERR_ATTRNONS,
+    XML_RELAXNG_ERR_ELEMWRONGNS,
+    XML_RELAXNG_ERR_ATTRWRONGNS,
+    XML_RELAXNG_ERR_ELEMEXTRANS,
+    XML_RELAXNG_ERR_ATTREXTRANS,
+    XML_RELAXNG_ERR_ELEMNOTEMPTY,
+    XML_RELAXNG_ERR_NOELEM,
+    XML_RELAXNG_ERR_NOTELEM,
+    XML_RELAXNG_ERR_ATTRVALID,
+    XML_RELAXNG_ERR_CONTENTVALID,
+    XML_RELAXNG_ERR_EXTRACONTENT,
+    XML_RELAXNG_ERR_INVALIDATTR,
+    XML_RELAXNG_ERR_DATAELEM,
+    XML_RELAXNG_ERR_VALELEM,
+    XML_RELAXNG_ERR_LISTELEM,
+    XML_RELAXNG_ERR_DATATYPE,
+    XML_RELAXNG_ERR_VALUE,
+    XML_RELAXNG_ERR_LIST,
+    XML_RELAXNG_ERR_NOGRAMMAR,
+    XML_RELAXNG_ERR_EXTRADATA,
+    XML_RELAXNG_ERR_LACKDATA,
+    XML_RELAXNG_ERR_INTERNAL,
+    XML_RELAXNG_ERR_ELEMWRONG,
+    XML_RELAXNG_ERR_TEXTWRONG
+} xmlRelaxNGValidErr;
+
+/*
+ * xmlRelaxNGParserFlags:
+ *
+ * List of possible Relax NG Parser flags
+ */
+typedef enum {
+    XML_RELAXNGP_NONE = 0,
+    XML_RELAXNGP_FREE_DOC = 1,
+    XML_RELAXNGP_CRNG = 2
+} xmlRelaxNGParserFlag;
+/*
+ * Interfaces for parsing.
+ */
+XMLPUBFUN xmlRelaxNGParserCtxtPtr XMLCALL 
+		    xmlRelaxNGNewParserCtxt	(const char *URL);
+XMLPUBFUN xmlRelaxNGParserCtxtPtr XMLCALL 
+		    xmlRelaxNGNewMemParserCtxt	(const char *buffer,
+						 int size);
+XMLPUBFUN xmlRelaxNGParserCtxtPtr XMLCALL   
+		    xmlRelaxNGNewDocParserCtxt	(xmlDocPtr doc);
+
+XMLPUBFUN int XMLCALL
+		    xmlRelaxParserSetFlag	(xmlRelaxNGParserCtxtPtr ctxt,
+		    				 int flag);
+
+XMLPUBFUN void XMLCALL		
+		    xmlRelaxNGFreeParserCtxt	(xmlRelaxNGParserCtxtPtr ctxt);
+XMLPUBFUN void XMLCALL			
+		    xmlRelaxNGSetParserErrors(xmlRelaxNGParserCtxtPtr ctxt,
+					 xmlRelaxNGValidityErrorFunc err,
+					 xmlRelaxNGValidityWarningFunc warn,
+					 void *ctx);
+XMLPUBFUN int XMLCALL
+		    xmlRelaxNGGetParserErrors(xmlRelaxNGParserCtxtPtr ctxt,
+					 xmlRelaxNGValidityErrorFunc *err,
+					 xmlRelaxNGValidityWarningFunc *warn,
+					 void **ctx);
+XMLPUBFUN xmlRelaxNGPtr XMLCALL	
+		    xmlRelaxNGParse		(xmlRelaxNGParserCtxtPtr ctxt);
+XMLPUBFUN void XMLCALL		
+		    xmlRelaxNGFree		(xmlRelaxNGPtr schema);
+#ifdef LIBXML_OUTPUT_ENABLED
+XMLPUBFUN void XMLCALL		
+		    xmlRelaxNGDump		(FILE *output,
+					 xmlRelaxNGPtr schema);
+XMLPUBFUN void XMLCALL
+		    xmlRelaxNGDumpTree	(FILE * output,
+					 xmlRelaxNGPtr schema);
+#endif /* LIBXML_OUTPUT_ENABLED */
+/*
+ * Interfaces for validating
+ */
+XMLPUBFUN void XMLCALL		
+		    xmlRelaxNGSetValidErrors(xmlRelaxNGValidCtxtPtr ctxt,
+					 xmlRelaxNGValidityErrorFunc err,
+					 xmlRelaxNGValidityWarningFunc warn,
+					 void *ctx);
+XMLPUBFUN int XMLCALL	
+		    xmlRelaxNGGetValidErrors(xmlRelaxNGValidCtxtPtr ctxt,
+					 xmlRelaxNGValidityErrorFunc *err,
+					 xmlRelaxNGValidityWarningFunc *warn,
+					 void **ctx);
+XMLPUBFUN xmlRelaxNGValidCtxtPtr XMLCALL	
+		    xmlRelaxNGNewValidCtxt	(xmlRelaxNGPtr schema);
+XMLPUBFUN void XMLCALL			
+		    xmlRelaxNGFreeValidCtxt	(xmlRelaxNGValidCtxtPtr ctxt);
+XMLPUBFUN int XMLCALL			
+		    xmlRelaxNGValidateDoc	(xmlRelaxNGValidCtxtPtr ctxt,
+					 	 xmlDocPtr doc);
+XMLPUBFUN void XMLCALL			
+		    xmlRelaxNGCleanupTypes	(void);
+/*
+ * Interfaces for progressive validation when possible
+ */
+XMLPUBFUN int XMLCALL	
+		    xmlRelaxNGValidatePushElement	(xmlRelaxNGValidCtxtPtr ctxt,
+					 xmlDocPtr doc,
+					 xmlNodePtr elem);
+XMLPUBFUN int XMLCALL	
+		    xmlRelaxNGValidatePushCData	(xmlRelaxNGValidCtxtPtr ctxt,
+					 const xmlChar *data,
+					 int len);
+XMLPUBFUN int XMLCALL	
+		    xmlRelaxNGValidatePopElement	(xmlRelaxNGValidCtxtPtr ctxt,
+					 xmlDocPtr doc,
+					 xmlNodePtr elem);
+XMLPUBFUN int XMLCALL	
+		    xmlRelaxNGValidateFullElement	(xmlRelaxNGValidCtxtPtr ctxt,
+					 xmlDocPtr doc,
+					 xmlNodePtr elem);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* __XML_RELAX_NG__ */
diff --git a/src/libxml/include/libxml/schemasInternals.h b/src/libxml/include/libxml/schemasInternals.h
new file mode 100644
index 0000000..740747b
--- /dev/null
+++ b/src/libxml/include/libxml/schemasInternals.h
@@ -0,0 +1,416 @@
+/*
+ * Summary: internal interfaces for XML Schemas
+ * Description: internal interfaces for the XML Schemas handling
+ *              and schema validity checking
+ *
+ * Copy: See Copyright for the status of this software.
+ *
+ * Author: Daniel Veillard
+ */
+
+
+#ifndef __XML_SCHEMA_INTERNALS_H__
+#define __XML_SCHEMA_INTERNALS_H__
+
+#include <libxml/xmlversion.h>
+
+#ifdef LIBXML_SCHEMAS_ENABLED
+
+#include <libxml/xmlregexp.h>
+#include <libxml/hash.h>
+#include <libxml/dict.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/*
+ * XML Schemas defines multiple type of types.
+ */
+typedef enum {
+    XML_SCHEMA_TYPE_BASIC = 1,
+    XML_SCHEMA_TYPE_ANY,
+    XML_SCHEMA_TYPE_FACET,
+    XML_SCHEMA_TYPE_SIMPLE,
+    XML_SCHEMA_TYPE_COMPLEX,
+    XML_SCHEMA_TYPE_SEQUENCE,
+    XML_SCHEMA_TYPE_CHOICE,
+    XML_SCHEMA_TYPE_ALL,
+    XML_SCHEMA_TYPE_SIMPLE_CONTENT,
+    XML_SCHEMA_TYPE_COMPLEX_CONTENT,
+    XML_SCHEMA_TYPE_UR,
+    XML_SCHEMA_TYPE_RESTRICTION,
+    XML_SCHEMA_TYPE_EXTENSION,
+    XML_SCHEMA_TYPE_ELEMENT,
+    XML_SCHEMA_TYPE_ATTRIBUTE,
+    XML_SCHEMA_TYPE_ATTRIBUTEGROUP,
+    XML_SCHEMA_TYPE_GROUP,
+    XML_SCHEMA_TYPE_NOTATION,
+    XML_SCHEMA_TYPE_LIST,
+    XML_SCHEMA_TYPE_UNION,
+    XML_SCHEMA_FACET_MININCLUSIVE = 1000,
+    XML_SCHEMA_FACET_MINEXCLUSIVE,
+    XML_SCHEMA_FACET_MAXINCLUSIVE,
+    XML_SCHEMA_FACET_MAXEXCLUSIVE,
+    XML_SCHEMA_FACET_TOTALDIGITS,
+    XML_SCHEMA_FACET_FRACTIONDIGITS,
+    XML_SCHEMA_FACET_PATTERN,
+    XML_SCHEMA_FACET_ENUMERATION,
+    XML_SCHEMA_FACET_WHITESPACE,
+    XML_SCHEMA_FACET_LENGTH,
+    XML_SCHEMA_FACET_MAXLENGTH,
+    XML_SCHEMA_FACET_MINLENGTH
+} xmlSchemaTypeType;
+
+typedef enum {
+    XML_SCHEMA_CONTENT_UNKNOWN = 0,
+    XML_SCHEMA_CONTENT_EMPTY = 1,
+    XML_SCHEMA_CONTENT_ELEMENTS,
+    XML_SCHEMA_CONTENT_MIXED,
+    XML_SCHEMA_CONTENT_SIMPLE,
+    XML_SCHEMA_CONTENT_MIXED_OR_ELEMENTS,
+    XML_SCHEMA_CONTENT_BASIC,
+    XML_SCHEMA_CONTENT_ANY
+} xmlSchemaContentType;
+
+typedef struct _xmlSchemaVal xmlSchemaVal;
+typedef xmlSchemaVal *xmlSchemaValPtr;
+
+typedef struct _xmlSchemaType xmlSchemaType;
+typedef xmlSchemaType *xmlSchemaTypePtr;
+
+typedef struct _xmlSchemaFacet xmlSchemaFacet;
+typedef xmlSchemaFacet *xmlSchemaFacetPtr;
+
+/**
+ * Annotation
+ */
+typedef struct _xmlSchemaAnnot xmlSchemaAnnot;
+typedef xmlSchemaAnnot *xmlSchemaAnnotPtr;
+struct _xmlSchemaAnnot {
+    struct _xmlSchemaAnnot *next;
+    xmlNodePtr content;         /* the annotation */
+};
+
+/**
+ * XML_SCHEMAS_ANYATTR_SKIP:
+ *
+ * Skip unknown attribute from validation
+ */
+#define XML_SCHEMAS_ANYATTR_SKIP	1
+/**
+ * XML_SCHEMAS_ANYATTR_LAX:
+ *
+ * Ignore validation non definition on attributes
+ */
+#define XML_SCHEMAS_ANYATTR_LAX		2
+/**
+ * XML_SCHEMAS_ANYATTR_STRICT:
+ *
+ * Apply strict validation rules on attributes
+ */
+#define XML_SCHEMAS_ANYATTR_STRICT	3
+
+/**
+ * XML_SCHEMAS_ATTR_USE_PROHIBITED:
+ *
+ * The attribute is prohibited.
+ */
+#define XML_SCHEMAS_ATTR_USE_PROHIBITED 0
+
+/**
+ * XML_SCHEMAS_ATTR_USE_REQUIRED:
+ *
+ * The attribute is required.
+ */
+#define XML_SCHEMAS_ATTR_USE_REQUIRED 1
+
+/**
+ * XML_SCHEMAS_ATTR_USE_OPTIONAL:
+ *
+ * The attribute is optional.
+ */
+#define XML_SCHEMAS_ATTR_USE_OPTIONAL 2
+
+/**
+ * XML_SCHEMAS_ATTR_NSDEFAULT:
+ *
+ * allow elements in no namespace
+ */
+#define XML_SCHEMAS_ATTR_NSDEFAULT	1 << 7
+
+/**
+ * xmlSchemaAttribute:
+ * An attribute definition.
+ */
+
+typedef struct _xmlSchemaAttribute xmlSchemaAttribute;
+typedef xmlSchemaAttribute *xmlSchemaAttributePtr;
+struct _xmlSchemaAttribute {
+    xmlSchemaTypeType type;	/* The kind of type */
+    struct _xmlSchemaAttribute *next;/* the next attribute if in a group ... */
+    const xmlChar *name;
+    const xmlChar *id;
+    const xmlChar *ref;
+    const xmlChar *refNs;
+    const xmlChar *typeName;
+    const xmlChar *typeNs;
+    xmlSchemaAnnotPtr annot;
+
+    xmlSchemaTypePtr base;
+    int occurs;
+    const xmlChar *defValue;
+    xmlSchemaTypePtr subtypes;
+    xmlNodePtr node;
+    const xmlChar *targetNamespace;
+    int flags;
+};
+
+/**
+ * An attribute group definition.
+ *
+ * xmlSchemaAttribute and xmlSchemaAttributeGroup start of structures
+ * must be kept similar
+ */
+typedef struct _xmlSchemaAttributeGroup xmlSchemaAttributeGroup;
+typedef xmlSchemaAttributeGroup *xmlSchemaAttributeGroupPtr;
+struct _xmlSchemaAttributeGroup {
+    xmlSchemaTypeType type;	/* The kind of type */
+    struct _xmlSchemaAttribute *next;/* the next attribute if in a group ... */
+    const xmlChar *name;
+    const xmlChar *id;
+    const xmlChar *ref;
+    const xmlChar *refNs;
+    xmlSchemaAnnotPtr annot;
+
+    xmlSchemaAttributePtr attributes;
+    xmlNodePtr node;
+};
+
+
+/**
+ * XML_SCHEMAS_TYPE_MIXED:
+ *
+ * the element content type is mixed
+ */
+#define XML_SCHEMAS_TYPE_MIXED		1 << 0
+
+/**
+ * _xmlSchemaType:
+ *
+ * Schemas type definition.
+ */
+struct _xmlSchemaType {
+    xmlSchemaTypeType type;	/* The kind of type */
+    struct _xmlSchemaType *next;/* the next type if in a sequence ... */
+    const xmlChar *name;
+    const xmlChar *id;
+    const xmlChar *ref;
+    const xmlChar *refNs;
+    xmlSchemaAnnotPtr annot;
+    xmlSchemaTypePtr subtypes;
+    xmlSchemaAttributePtr attributes;
+    xmlNodePtr node;
+    int minOccurs;
+    int maxOccurs;
+
+    int flags;
+    xmlSchemaContentType contentType;
+    const xmlChar *base;
+    const xmlChar *baseNs;
+    xmlSchemaTypePtr baseType;
+    xmlSchemaFacetPtr facets;
+    struct _xmlSchemaType *redef;/* possible redefinitions for the type */
+    int recurse;
+};
+
+/*
+ * xmlSchemaElement:
+ * An element definition.
+ *
+ * xmlSchemaType, xmlSchemaFacet and xmlSchemaElement start of
+ * structures must be kept similar
+ */
+/**
+ * XML_SCHEMAS_ELEM_NILLABLE:
+ *
+ * the element is nillable
+ */
+#define XML_SCHEMAS_ELEM_NILLABLE	1 << 0
+/**
+ * XML_SCHEMAS_ELEM_GLOBAL:
+ *
+ * the element is global
+ */
+#define XML_SCHEMAS_ELEM_GLOBAL		1 << 1
+/**
+ * XML_SCHEMAS_ELEM_DEFAULT:
+ *
+ * the element has a default value
+ */
+#define XML_SCHEMAS_ELEM_DEFAULT	1 << 2
+/**
+ * XML_SCHEMAS_ELEM_FIXED:
+ *
+ * the element has a fixed value
+ */
+#define XML_SCHEMAS_ELEM_FIXED		1 << 3
+/**
+ * XML_SCHEMAS_ELEM_ABSTRACT:
+ *
+ * the element is abstract
+ */
+#define XML_SCHEMAS_ELEM_ABSTRACT	1 << 4
+/**
+ * XML_SCHEMAS_ELEM_TOPLEVEL:
+ *
+ * the element is top level
+ */
+#define XML_SCHEMAS_ELEM_TOPLEVEL	1 << 5
+/**
+ * XML_SCHEMAS_ELEM_REF:
+ *
+ * the element is a reference to a type
+ */
+#define XML_SCHEMAS_ELEM_REF		1 << 6
+/**
+ * XML_SCHEMAS_ELEM_NSDEFAULT:
+ *
+ * allow elements in no namespace
+ */
+#define XML_SCHEMAS_ELEM_NSDEFAULT	1 << 7
+
+typedef struct _xmlSchemaElement xmlSchemaElement;
+typedef xmlSchemaElement *xmlSchemaElementPtr;
+struct _xmlSchemaElement {
+    xmlSchemaTypeType type;	/* The kind of type */
+    struct _xmlSchemaType *next;/* the next type if in a sequence ... */
+    const xmlChar *name;
+    const xmlChar *id;
+    const xmlChar *ref;
+    const xmlChar *refNs;
+    xmlSchemaAnnotPtr annot;
+    xmlSchemaTypePtr subtypes;
+    xmlSchemaAttributePtr attributes;
+    xmlNodePtr node;
+    int minOccurs;
+    int maxOccurs;
+
+    int flags;
+    const xmlChar *targetNamespace;
+    const xmlChar *namedType;
+    const xmlChar *namedTypeNs;
+    const xmlChar *substGroup;
+    const xmlChar *substGroupNs;
+    const xmlChar *scope;
+    const xmlChar *value;
+    struct _xmlSchemaElement *refDecl;
+    xmlRegexpPtr contModel;
+    xmlSchemaContentType contentType;
+};
+
+/*
+ * XML_SCHEMAS_FACET_UNKNOWN:
+ *
+ * unknown facet handling
+ */
+#define XML_SCHEMAS_FACET_UNKNOWN	0
+/*
+ * XML_SCHEMAS_FACET_PRESERVE:
+ *
+ * preserve the type of the facet
+ */
+#define XML_SCHEMAS_FACET_PRESERVE	1
+/*
+ * XML_SCHEMAS_FACET_REPLACE:
+ *
+ * replace the type of the facet
+ */
+#define XML_SCHEMAS_FACET_REPLACE	2
+/*
+ * XML_SCHEMAS_FACET_COLLAPSE:
+ *
+ * collapse the types of the facet
+ */
+#define XML_SCHEMAS_FACET_COLLAPSE	3
+
+/**
+ * A facet definition.
+ */
+struct _xmlSchemaFacet {
+    xmlSchemaTypeType type;	/* The kind of type */
+    struct _xmlSchemaFacet *next;/* the next type if in a sequence ... */
+    const xmlChar *value;
+    const xmlChar *id;
+    xmlSchemaAnnotPtr annot;
+    xmlNodePtr node;
+    int fixed;
+    int whitespace;
+    xmlSchemaValPtr val;
+    xmlRegexpPtr    regexp;
+};
+
+/**
+ * A notation definition.
+ */
+typedef struct _xmlSchemaNotation xmlSchemaNotation;
+typedef xmlSchemaNotation *xmlSchemaNotationPtr;
+struct _xmlSchemaNotation {
+    xmlSchemaTypeType type;	/* The kind of type */
+    const xmlChar *name;
+    xmlSchemaAnnotPtr annot;
+    const xmlChar *identifier;
+};
+
+/**
+ * XML_SCHEMAS_QUALIF_ELEM:
+ *
+ * the shemas requires qualified elements
+ */
+#define XML_SCHEMAS_QUALIF_ELEM		1 << 0
+/**
+ * XML_SCHEMAS_QUALIF_ATTR:
+ *
+ * the shemas requires qualified attributes
+ */
+#define XML_SCHEMAS_QUALIF_ATTR		1 << 1
+/**
+ * _xmlSchema:
+ *
+ * A Schemas definition
+ */
+struct _xmlSchema {
+    const xmlChar *name;        /* schema name */
+    const xmlChar *targetNamespace;     /* the target namespace */
+    const xmlChar *version;
+    const xmlChar *id;
+    xmlDocPtr doc;
+    xmlSchemaAnnotPtr annot;
+    int flags;
+
+    xmlHashTablePtr typeDecl;
+    xmlHashTablePtr attrDecl;
+    xmlHashTablePtr attrgrpDecl;
+    xmlHashTablePtr elemDecl;
+    xmlHashTablePtr notaDecl;
+
+    xmlHashTablePtr schemasImports;
+
+    void *_private;	/* unused by the library for users or bindings */
+    xmlHashTablePtr groupDecl;
+    xmlDictPtr      dict;
+    void *includes;     /* the includes, this is opaque for now */
+    int preserve;	/* whether to free the document */
+};
+
+XMLPUBFUN void XMLCALL 	xmlSchemaFreeType	(xmlSchemaTypePtr type);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* LIBXML_SCHEMAS_ENABLED */
+#endif /* __XML_SCHEMA_INTERNALS_H__ */
+
+
diff --git a/src/libxml/include/libxml/threads.h b/src/libxml/include/libxml/threads.h
new file mode 100644
index 0000000..fb6b704
--- /dev/null
+++ b/src/libxml/include/libxml/threads.h
@@ -0,0 +1,81 @@
+/**
+ * Summary: interfaces for thread handling
+ * Description: set of generic threading related routines
+ *              should work with pthreads, Windows native or TLS threads
+ *
+ * Copy: See Copyright for the status of this software.
+ *
+ * Author: Daniel Veillard
+ */
+
+#ifndef __XML_THREADS_H__
+#define __XML_THREADS_H__
+
+#include <libxml/xmlversion.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * xmlMutex are a simple mutual exception locks.
+ */
+typedef struct _xmlMutex xmlMutex;
+typedef xmlMutex *xmlMutexPtr;
+
+/*
+ * xmlRMutex are reentrant mutual exception locks.
+ */
+typedef struct _xmlRMutex xmlRMutex;
+typedef xmlRMutex *xmlRMutexPtr;
+
+#ifdef __cplusplus
+}
+#endif
+#include <libxml/globals.h>
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+XMLPUBFUN xmlMutexPtr XMLCALL		
+			xmlNewMutex	(void);
+XMLPUBFUN void XMLCALL			
+			xmlMutexLock	(xmlMutexPtr tok);
+XMLPUBFUN void XMLCALL			
+			xmlMutexUnlock	(xmlMutexPtr tok);
+XMLPUBFUN void XMLCALL			
+			xmlFreeMutex	(xmlMutexPtr tok);
+
+XMLPUBFUN xmlRMutexPtr XMLCALL		
+			xmlNewRMutex	(void);
+XMLPUBFUN void XMLCALL			
+			xmlRMutexLock	(xmlRMutexPtr tok);
+XMLPUBFUN void XMLCALL			
+			xmlRMutexUnlock	(xmlRMutexPtr tok);
+XMLPUBFUN void XMLCALL			
+			xmlFreeRMutex	(xmlRMutexPtr tok);
+
+/*
+ * Library wide APIs.
+ */
+XMLPUBFUN void XMLCALL			
+			xmlInitThreads	(void);
+XMLPUBFUN void XMLCALL			
+			xmlLockLibrary	(void);
+XMLPUBFUN void XMLCALL			
+			xmlUnlockLibrary(void);
+XMLPUBFUN int XMLCALL			
+			xmlGetThreadId	(void);
+XMLPUBFUN int XMLCALL			
+			xmlIsMainThread	(void);
+XMLPUBFUN void XMLCALL			
+			xmlCleanupThreads(void);
+XMLPUBFUN xmlGlobalStatePtr XMLCALL	
+			xmlGetGlobalState(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif /* __XML_THREADS_H__ */
diff --git a/src/libxml/include/libxml/tree.h b/src/libxml/include/libxml/tree.h
new file mode 100644
index 0000000..470151d
--- /dev/null
+++ b/src/libxml/include/libxml/tree.h
@@ -0,0 +1,1094 @@
+/*
+ * Summary: interfaces for tree manipulation
+ * Description: this module describes the structures found in an tree resulting
+ *              from an XML or HTML parsing, as well as the API provided for
+ *              various processing on that tree
+ *
+ * Copy: See Copyright for the status of this software.
+ *
+ * Author: Daniel Veillard
+ */
+
+#ifndef __XML_TREE_H__
+#define __XML_TREE_H__
+
+#include <stdio.h>
+#include <libxml/xmlversion.h>
+#include <libxml/xmlstring.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * Some of the basic types pointer to structures:
+ */
+/* xmlIO.h */
+typedef struct _xmlParserInputBuffer xmlParserInputBuffer;
+typedef xmlParserInputBuffer *xmlParserInputBufferPtr;
+
+typedef struct _xmlOutputBuffer xmlOutputBuffer;
+typedef xmlOutputBuffer *xmlOutputBufferPtr;
+
+/* parser.h */
+typedef struct _xmlParserInput xmlParserInput;
+typedef xmlParserInput *xmlParserInputPtr;
+
+typedef struct _xmlParserCtxt xmlParserCtxt;
+typedef xmlParserCtxt *xmlParserCtxtPtr;
+
+typedef struct _xmlSAXLocator xmlSAXLocator;
+typedef xmlSAXLocator *xmlSAXLocatorPtr;
+
+typedef struct _xmlSAXHandler xmlSAXHandler;
+typedef xmlSAXHandler *xmlSAXHandlerPtr;
+
+/* entities.h */
+typedef struct _xmlEntity xmlEntity;
+typedef xmlEntity *xmlEntityPtr;
+
+/**
+ * BASE_BUFFER_SIZE:
+ *
+ * default buffer size 4000.
+ */
+#define BASE_BUFFER_SIZE 4096
+
+/**
+ * XML_XML_NAMESPACE:
+ *
+ * This is the namespace for the special xml: prefix predefined in the
+ * XML Namespace specification.
+ */
+#define XML_XML_NAMESPACE \
+    (const xmlChar *) "http://www.w3.org/XML/1998/namespace"
+
+/**
+ * XML_XML_ID:
+ *
+ * This is the name for the special xml:id attribute
+ */
+#define XML_XML_ID (const xmlChar *) "xml:id"
+
+/*
+ * The different element types carried by an XML tree.
+ *
+ * NOTE: This is synchronized with DOM Level1 values
+ *       See http://www.w3.org/TR/REC-DOM-Level-1/
+ *
+ * Actually this had diverged a bit, and now XML_DOCUMENT_TYPE_NODE should
+ * be deprecated to use an XML_DTD_NODE.
+ */
+typedef enum {
+    XML_ELEMENT_NODE=		1,
+    XML_ATTRIBUTE_NODE=		2,
+    XML_TEXT_NODE=		3,
+    XML_CDATA_SECTION_NODE=	4,
+    XML_ENTITY_REF_NODE=	5,
+    XML_ENTITY_NODE=		6,
+    XML_PI_NODE=		7,
+    XML_COMMENT_NODE=		8,
+    XML_DOCUMENT_NODE=		9,
+    XML_DOCUMENT_TYPE_NODE=	10,
+    XML_DOCUMENT_FRAG_NODE=	11,
+    XML_NOTATION_NODE=		12,
+    XML_HTML_DOCUMENT_NODE=	13,
+    XML_DTD_NODE=		14,
+    XML_ELEMENT_DECL=		15,
+    XML_ATTRIBUTE_DECL=		16,
+    XML_ENTITY_DECL=		17,
+    XML_NAMESPACE_DECL=		18,
+    XML_XINCLUDE_START=		19,
+    XML_XINCLUDE_END=		20
+#ifdef LIBXML_DOCB_ENABLED
+   ,XML_DOCB_DOCUMENT_NODE=	21
+#endif
+} xmlElementType;
+
+
+/**
+ * xmlNotation:
+ *
+ * A DTD Notation definition.
+ */
+
+typedef struct _xmlNotation xmlNotation;
+typedef xmlNotation *xmlNotationPtr;
+struct _xmlNotation {
+    const xmlChar               *name;	        /* Notation name */
+    const xmlChar               *PublicID;	/* Public identifier, if any */
+    const xmlChar               *SystemID;	/* System identifier, if any */
+};
+
+/**
+ * xmlAttributeType:
+ *
+ * A DTD Attribute type definition.
+ */
+
+typedef enum {
+    XML_ATTRIBUTE_CDATA = 1,
+    XML_ATTRIBUTE_ID,
+    XML_ATTRIBUTE_IDREF	,
+    XML_ATTRIBUTE_IDREFS,
+    XML_ATTRIBUTE_ENTITY,
+    XML_ATTRIBUTE_ENTITIES,
+    XML_ATTRIBUTE_NMTOKEN,
+    XML_ATTRIBUTE_NMTOKENS,
+    XML_ATTRIBUTE_ENUMERATION,
+    XML_ATTRIBUTE_NOTATION
+} xmlAttributeType;
+
+/**
+ * xmlAttributeDefault:
+ *
+ * A DTD Attribute default definition.
+ */
+
+typedef enum {
+    XML_ATTRIBUTE_NONE = 1,
+    XML_ATTRIBUTE_REQUIRED,
+    XML_ATTRIBUTE_IMPLIED,
+    XML_ATTRIBUTE_FIXED
+} xmlAttributeDefault;
+
+/**
+ * xmlEnumeration:
+ *
+ * List structure used when there is an enumeration in DTDs.
+ */
+
+typedef struct _xmlEnumeration xmlEnumeration;
+typedef xmlEnumeration *xmlEnumerationPtr;
+struct _xmlEnumeration {
+    struct _xmlEnumeration    *next;	/* next one */
+    const xmlChar            *name;	/* Enumeration name */
+};
+
+/**
+ * xmlAttribute:
+ *
+ * An Attribute declaration in a DTD.
+ */
+
+typedef struct _xmlAttribute xmlAttribute;
+typedef xmlAttribute *xmlAttributePtr;
+struct _xmlAttribute {
+    void           *_private;	        /* application data */
+    xmlElementType          type;       /* XML_ATTRIBUTE_DECL, must be second ! */
+    const xmlChar          *name;	/* Attribute name */
+    struct _xmlNode    *children;	/* NULL */
+    struct _xmlNode        *last;	/* NULL */
+    struct _xmlDtd       *parent;	/* -> DTD */
+    struct _xmlNode        *next;	/* next sibling link  */
+    struct _xmlNode        *prev;	/* previous sibling link  */
+    struct _xmlDoc          *doc;       /* the containing document */
+
+    struct _xmlAttribute  *nexth;	/* next in hash table */
+    xmlAttributeType       atype;	/* The attribute type */
+    xmlAttributeDefault      def;	/* the default */
+    const xmlChar  *defaultValue;	/* or the default value */
+    xmlEnumerationPtr       tree;       /* or the enumeration tree if any */
+    const xmlChar        *prefix;	/* the namespace prefix if any */
+    const xmlChar          *elem;	/* Element holding the attribute */
+};
+
+/**
+ * xmlElementContentType:
+ *
+ * Possible definitions of element content types.
+ */
+typedef enum {
+    XML_ELEMENT_CONTENT_PCDATA = 1,
+    XML_ELEMENT_CONTENT_ELEMENT,
+    XML_ELEMENT_CONTENT_SEQ,
+    XML_ELEMENT_CONTENT_OR
+} xmlElementContentType;
+
+/**
+ * xmlElementContentOccur:
+ *
+ * Possible definitions of element content occurrences.
+ */
+typedef enum {
+    XML_ELEMENT_CONTENT_ONCE = 1,
+    XML_ELEMENT_CONTENT_OPT,
+    XML_ELEMENT_CONTENT_MULT,
+    XML_ELEMENT_CONTENT_PLUS
+} xmlElementContentOccur;
+
+/**
+ * xmlElementContent:
+ *
+ * An XML Element content as stored after parsing an element definition
+ * in a DTD.
+ */
+
+typedef struct _xmlElementContent xmlElementContent;
+typedef xmlElementContent *xmlElementContentPtr;
+struct _xmlElementContent {
+    xmlElementContentType     type;	/* PCDATA, ELEMENT, SEQ or OR */
+    xmlElementContentOccur    ocur;	/* ONCE, OPT, MULT or PLUS */
+    const xmlChar             *name;	/* Element name */
+    struct _xmlElementContent *c1;	/* first child */
+    struct _xmlElementContent *c2;	/* second child */
+    struct _xmlElementContent *parent;	/* parent */
+    const xmlChar             *prefix;	/* Namespace prefix */
+};
+
+/**
+ * xmlElementTypeVal:
+ *
+ * The different possibilities for an element content type.
+ */
+
+typedef enum {
+    XML_ELEMENT_TYPE_UNDEFINED = 0,
+    XML_ELEMENT_TYPE_EMPTY = 1,
+    XML_ELEMENT_TYPE_ANY,
+    XML_ELEMENT_TYPE_MIXED,
+    XML_ELEMENT_TYPE_ELEMENT
+} xmlElementTypeVal;
+
+
+#ifdef __cplusplus
+}
+#endif
+#include <libxml/xmlregexp.h>
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * xmlElement:
+ *
+ * An XML Element declaration from a DTD.
+ */
+
+typedef struct _xmlElement xmlElement;
+typedef xmlElement *xmlElementPtr;
+struct _xmlElement {
+    void           *_private;	        /* application data */
+    xmlElementType          type;       /* XML_ELEMENT_DECL, must be second ! */
+    const xmlChar          *name;	/* Element name */
+    struct _xmlNode    *children;	/* NULL */
+    struct _xmlNode        *last;	/* NULL */
+    struct _xmlDtd       *parent;	/* -> DTD */
+    struct _xmlNode        *next;	/* next sibling link  */
+    struct _xmlNode        *prev;	/* previous sibling link  */
+    struct _xmlDoc          *doc;       /* the containing document */
+
+    xmlElementTypeVal      etype;	/* The type */
+    xmlElementContentPtr content;	/* the allowed element content */
+    xmlAttributePtr   attributes;	/* List of the declared attributes */
+    const xmlChar        *prefix;	/* the namespace prefix if any */
+#ifdef LIBXML_REGEXP_ENABLED
+    xmlRegexpPtr       contModel;	/* the validating regexp */
+#else
+    void	      *contModel;
+#endif
+};
+
+
+/**
+ * XML_LOCAL_NAMESPACE:
+ *
+ * A namespace declaration node.
+ */
+#define XML_LOCAL_NAMESPACE XML_NAMESPACE_DECL
+typedef xmlElementType xmlNsType;
+
+/**
+ * xmlNs:
+ *
+ * An XML namespace.
+ * Note that prefix == NULL is valid, it defines the default namespace
+ * within the subtree (until overridden).
+ *
+ * xmlNsType is unified with xmlElementType.
+ */
+
+typedef struct _xmlNs xmlNs;
+typedef xmlNs *xmlNsPtr;
+struct _xmlNs {
+    struct _xmlNs  *next;	/* next Ns link for this node  */
+    xmlNsType      type;	/* global or local */
+    const xmlChar *href;	/* URL for the namespace */
+    const xmlChar *prefix;	/* prefix for the namespace */
+    void           *_private;   /* application data */
+};
+
+/**
+ * xmlDtd:
+ *
+ * An XML DTD, as defined by <!DOCTYPE ... There is actually one for
+ * the internal subset and for the external subset.
+ */
+typedef struct _xmlDtd xmlDtd;
+typedef xmlDtd *xmlDtdPtr;
+struct _xmlDtd {
+    void           *_private;	/* application data */
+    xmlElementType  type;       /* XML_DTD_NODE, must be second ! */
+    const xmlChar *name;	/* Name of the DTD */
+    struct _xmlNode *children;	/* the value of the property link */
+    struct _xmlNode *last;	/* last child link */
+    struct _xmlDoc  *parent;	/* child->parent link */
+    struct _xmlNode *next;	/* next sibling link  */
+    struct _xmlNode *prev;	/* previous sibling link  */
+    struct _xmlDoc  *doc;	/* the containing document */
+
+    /* End of common part */
+    void          *notations;   /* Hash table for notations if any */
+    void          *elements;    /* Hash table for elements if any */
+    void          *attributes;  /* Hash table for attributes if any */
+    void          *entities;    /* Hash table for entities if any */
+    const xmlChar *ExternalID;	/* External identifier for PUBLIC DTD */
+    const xmlChar *SystemID;	/* URI for a SYSTEM or PUBLIC DTD */
+    void          *pentities;   /* Hash table for param entities if any */
+};
+
+/**
+ * xmlAttr:
+ *
+ * An attribute on an XML node.
+ */
+typedef struct _xmlAttr xmlAttr;
+typedef xmlAttr *xmlAttrPtr;
+struct _xmlAttr {
+    void           *_private;	/* application data */
+    xmlElementType   type;      /* XML_ATTRIBUTE_NODE, must be second ! */
+    const xmlChar   *name;      /* the name of the property */
+    struct _xmlNode *children;	/* the value of the property */
+    struct _xmlNode *last;	/* NULL */
+    struct _xmlNode *parent;	/* child->parent link */
+    struct _xmlAttr *next;	/* next sibling link  */
+    struct _xmlAttr *prev;	/* previous sibling link  */
+    struct _xmlDoc  *doc;	/* the containing document */
+    xmlNs           *ns;        /* pointer to the associated namespace */
+    xmlAttributeType atype;     /* the attribute type if validating */
+    void            *psvi;	/* for type/PSVI informations */
+};
+
+/**
+ * xmlID:
+ *
+ * An XML ID instance.
+ */
+
+typedef struct _xmlID xmlID;
+typedef xmlID *xmlIDPtr;
+struct _xmlID {
+    struct _xmlID    *next;	/* next ID */
+    const xmlChar    *value;	/* The ID name */
+    xmlAttrPtr        attr;	/* The attribute holding it */
+    const xmlChar    *name;	/* The attribute if attr is not available */
+    int               lineno;	/* The line number if attr is not available */
+    struct _xmlDoc   *doc;	/* The document holding the ID */
+};
+
+/**
+ * xmlRef:
+ *
+ * An XML IDREF instance.
+ */
+
+typedef struct _xmlRef xmlRef;
+typedef xmlRef *xmlRefPtr;
+struct _xmlRef {
+    struct _xmlRef    *next;	/* next Ref */
+    const xmlChar     *value;	/* The Ref name */
+    xmlAttrPtr        attr;	/* The attribute holding it */
+    const xmlChar    *name;	/* The attribute if attr is not available */
+    int               lineno;	/* The line number if attr is not available */
+};
+
+/**
+ * xmlBufferAllocationScheme:
+ *
+ * A buffer allocation scheme can be defined to either match exactly the
+ * need or double it's allocated size each time it is found too small.
+ */
+
+typedef enum {
+    XML_BUFFER_ALLOC_DOUBLEIT,
+    XML_BUFFER_ALLOC_EXACT,
+    XML_BUFFER_ALLOC_IMMUTABLE
+} xmlBufferAllocationScheme;
+
+/**
+ * xmlBuffer:
+ *
+ * A buffer structure.
+ */
+typedef struct _xmlBuffer xmlBuffer;
+typedef xmlBuffer *xmlBufferPtr;
+struct _xmlBuffer {
+    xmlChar *content;		/* The buffer content UTF8 */
+    unsigned int use;		/* The buffer size used */
+    unsigned int size;		/* The buffer size */
+    xmlBufferAllocationScheme alloc; /* The realloc method */
+};
+
+/**
+ * xmlNode:
+ *
+ * A node in an XML tree.
+ */
+typedef struct _xmlNode xmlNode;
+typedef xmlNode *xmlNodePtr;
+struct _xmlNode {
+    void           *_private;	/* application data */
+    xmlElementType   type;	/* type number, must be second ! */
+    const xmlChar   *name;      /* the name of the node, or the entity */
+    struct _xmlNode *children;	/* parent->childs link */
+    struct _xmlNode *last;	/* last child link */
+    struct _xmlNode *parent;	/* child->parent link */
+    struct _xmlNode *next;	/* next sibling link  */
+    struct _xmlNode *prev;	/* previous sibling link  */
+    struct _xmlDoc  *doc;	/* the containing document */
+
+    /* End of common part */
+    xmlNs           *ns;        /* pointer to the associated namespace */
+    xmlChar         *content;   /* the content */
+    struct _xmlAttr *properties;/* properties list */
+    xmlNs           *nsDef;     /* namespace definitions on this node */
+    void            *psvi;	/* for type/PSVI informations */
+    unsigned short   line;	/* line number */
+    unsigned short   extra;	/* extra data for XPath/XSLT */
+};
+
+/**
+ * XML_GET_CONTENT:
+ *
+ * Macro to extract the content pointer of a node.
+ */
+#define XML_GET_CONTENT(n)					\
+    ((n)->type == XML_ELEMENT_NODE ? NULL : (n)->content)
+
+/**
+ * XML_GET_LINE:
+ *
+ * Macro to extract the line number of an element node. 
+ */
+#define XML_GET_LINE(n)						\
+    (xmlGetLineNo(n))
+
+
+/**
+ * xmlDoc:
+ *
+ * An XML document.
+ */
+typedef struct _xmlDoc xmlDoc;
+typedef xmlDoc *xmlDocPtr;
+struct _xmlDoc {
+    void           *_private;	/* application data */
+    xmlElementType  type;       /* XML_DOCUMENT_NODE, must be second ! */
+    char           *name;	/* name/filename/URI of the document */
+    struct _xmlNode *children;	/* the document tree */
+    struct _xmlNode *last;	/* last child link */
+    struct _xmlNode *parent;	/* child->parent link */
+    struct _xmlNode *next;	/* next sibling link  */
+    struct _xmlNode *prev;	/* previous sibling link  */
+    struct _xmlDoc  *doc;	/* autoreference to itself */
+
+    /* End of common part */
+    int             compression;/* level of zlib compression */
+    int             standalone; /* standalone document (no external refs) */
+    struct _xmlDtd  *intSubset;	/* the document internal subset */
+    struct _xmlDtd  *extSubset;	/* the document external subset */
+    struct _xmlNs   *oldNs;	/* Global namespace, the old way */
+    const xmlChar  *version;	/* the XML version string */
+    const xmlChar  *encoding;   /* external initial encoding, if any */
+    void           *ids;        /* Hash table for ID attributes if any */
+    void           *refs;       /* Hash table for IDREFs attributes if any */
+    const xmlChar  *URL;	/* The URI for that document */
+    int             charset;    /* encoding of the in-memory content
+				   actually an xmlCharEncoding */
+    struct _xmlDict *dict;      /* dict used to allocate names or NULL */
+    void           *psvi;	/* for type/PSVI informations */
+};
+
+/**
+ * xmlChildrenNode:
+ *
+ * Macro for compatibility naming layer with libxml1. Maps
+ * to "children."
+ */
+#ifndef xmlChildrenNode
+#define xmlChildrenNode children
+#endif
+
+/**
+ * xmlRootNode:
+ *
+ * Macro for compatibility naming layer with libxml1. Maps 
+ * to "children".
+ */
+#ifndef xmlRootNode
+#define xmlRootNode children
+#endif
+
+/*
+ * Variables.
+ */
+
+/*
+ * Some helper functions
+ */
+XMLPUBFUN int XMLCALL
+		xmlValidateNCName	(const xmlChar *value,
+					 int space);
+XMLPUBFUN int XMLCALL		
+		xmlValidateQName	(const xmlChar *value,
+					 int space);
+XMLPUBFUN int XMLCALL		
+		xmlValidateName		(const xmlChar *value,
+					 int space);
+XMLPUBFUN int XMLCALL		
+		xmlValidateNMToken	(const xmlChar *value,
+					 int space);
+
+XMLPUBFUN xmlChar * XMLCALL	
+		xmlBuildQName		(const xmlChar *ncname,
+					 const xmlChar *prefix,
+					 xmlChar *memory,
+					 int len);
+XMLPUBFUN xmlChar * XMLCALL	
+		xmlSplitQName2		(const xmlChar *name,
+					 xmlChar **prefix);
+XMLPUBFUN const xmlChar * XMLCALL	
+		xmlSplitQName3		(const xmlChar *name,
+					 int *len);
+
+/*
+ * Handling Buffers.
+ */
+
+XMLPUBFUN void XMLCALL		
+		xmlSetBufferAllocationScheme(xmlBufferAllocationScheme scheme);
+XMLPUBFUN xmlBufferAllocationScheme XMLCALL	 
+		xmlGetBufferAllocationScheme(void);
+
+XMLPUBFUN xmlBufferPtr XMLCALL	
+		xmlBufferCreate		(void);
+XMLPUBFUN xmlBufferPtr XMLCALL	
+		xmlBufferCreateSize	(size_t size);
+XMLPUBFUN xmlBufferPtr XMLCALL	
+		xmlBufferCreateStatic	(void *mem,
+					 size_t size);
+XMLPUBFUN int XMLCALL		
+		xmlBufferResize		(xmlBufferPtr buf,
+					 unsigned int size);
+XMLPUBFUN void XMLCALL		
+		xmlBufferFree		(xmlBufferPtr buf);
+XMLPUBFUN int XMLCALL		
+		xmlBufferDump		(FILE *file,
+					 xmlBufferPtr buf);
+XMLPUBFUN void XMLCALL		
+		xmlBufferAdd		(xmlBufferPtr buf,
+					 const xmlChar *str,
+					 int len);
+XMLPUBFUN void XMLCALL		
+		xmlBufferAddHead	(xmlBufferPtr buf,
+					 const xmlChar *str,
+					 int len);
+XMLPUBFUN void XMLCALL		
+		xmlBufferCat		(xmlBufferPtr buf,
+					 const xmlChar *str);
+XMLPUBFUN void XMLCALL	
+		xmlBufferCCat		(xmlBufferPtr buf,
+					 const char *str);
+XMLPUBFUN int XMLCALL		
+		xmlBufferShrink		(xmlBufferPtr buf,
+					 unsigned int len);
+XMLPUBFUN int XMLCALL		
+		xmlBufferGrow		(xmlBufferPtr buf,
+					 unsigned int len);
+XMLPUBFUN void XMLCALL		
+		xmlBufferEmpty		(xmlBufferPtr buf);
+XMLPUBFUN const xmlChar* XMLCALL	
+		xmlBufferContent	(const xmlBufferPtr buf);
+XMLPUBFUN void XMLCALL		
+		xmlBufferSetAllocationScheme(xmlBufferPtr buf,
+					 xmlBufferAllocationScheme scheme);
+XMLPUBFUN int XMLCALL		
+		xmlBufferLength		(const xmlBufferPtr buf);
+
+/*
+ * Creating/freeing new structures.
+ */
+XMLPUBFUN xmlDtdPtr XMLCALL	
+		xmlCreateIntSubset	(xmlDocPtr doc,
+					 const xmlChar *name,
+					 const xmlChar *ExternalID,
+					 const xmlChar *SystemID);
+XMLPUBFUN xmlDtdPtr XMLCALL	
+		xmlNewDtd		(xmlDocPtr doc,
+					 const xmlChar *name,
+					 const xmlChar *ExternalID,
+					 const xmlChar *SystemID);
+XMLPUBFUN xmlDtdPtr XMLCALL	
+		xmlGetIntSubset		(xmlDocPtr doc);
+XMLPUBFUN void XMLCALL		
+		xmlFreeDtd		(xmlDtdPtr cur);
+XMLPUBFUN xmlNsPtr XMLCALL	
+		xmlNewGlobalNs		(xmlDocPtr doc,
+					 const xmlChar *href,
+					 const xmlChar *prefix);
+XMLPUBFUN xmlNsPtr XMLCALL	
+		xmlNewNs		(xmlNodePtr node,
+					 const xmlChar *href,
+					 const xmlChar *prefix);
+XMLPUBFUN void XMLCALL		
+		xmlFreeNs		(xmlNsPtr cur);
+XMLPUBFUN void XMLCALL		
+		xmlFreeNsList		(xmlNsPtr cur);
+XMLPUBFUN xmlDocPtr XMLCALL 	
+		xmlNewDoc		(const xmlChar *version);
+XMLPUBFUN void XMLCALL		
+		xmlFreeDoc		(xmlDocPtr cur);
+XMLPUBFUN xmlAttrPtr XMLCALL	
+		xmlNewDocProp		(xmlDocPtr doc,
+					 const xmlChar *name,
+					 const xmlChar *value);
+XMLPUBFUN xmlAttrPtr XMLCALL	
+		xmlNewProp		(xmlNodePtr node,
+					 const xmlChar *name,
+					 const xmlChar *value);
+XMLPUBFUN xmlAttrPtr XMLCALL	
+		xmlNewNsProp		(xmlNodePtr node,
+					 xmlNsPtr ns,
+					 const xmlChar *name,
+					 const xmlChar *value);
+XMLPUBFUN xmlAttrPtr XMLCALL	
+		xmlNewNsPropEatName	(xmlNodePtr node,
+					 xmlNsPtr ns,
+					 xmlChar *name,
+					 const xmlChar *value);
+XMLPUBFUN void XMLCALL		
+		xmlFreePropList		(xmlAttrPtr cur);
+XMLPUBFUN void XMLCALL		
+		xmlFreeProp		(xmlAttrPtr cur);
+XMLPUBFUN xmlAttrPtr XMLCALL	
+		xmlCopyProp		(xmlNodePtr target,
+					 xmlAttrPtr cur);
+XMLPUBFUN xmlAttrPtr XMLCALL	
+		xmlCopyPropList		(xmlNodePtr target,
+					 xmlAttrPtr cur);
+#ifdef LIBXML_TREE_ENABLED
+XMLPUBFUN xmlDtdPtr XMLCALL	
+		xmlCopyDtd		(xmlDtdPtr dtd);
+XMLPUBFUN xmlDocPtr XMLCALL	
+		xmlCopyDoc		(xmlDocPtr doc,
+					 int recursive);
+#endif /* LIBXML_TREE_ENABLED */
+
+/*
+ * Creating new nodes.
+ */
+XMLPUBFUN xmlNodePtr XMLCALL	
+		xmlNewDocNode		(xmlDocPtr doc,
+					 xmlNsPtr ns,
+					 const xmlChar *name,
+					 const xmlChar *content);
+XMLPUBFUN xmlNodePtr XMLCALL	
+		xmlNewDocNodeEatName	(xmlDocPtr doc,
+					 xmlNsPtr ns,
+					 xmlChar *name,
+					 const xmlChar *content);
+XMLPUBFUN xmlNodePtr XMLCALL	
+		xmlNewDocRawNode	(xmlDocPtr doc,
+					 xmlNsPtr ns,
+					 const xmlChar *name,
+					 const xmlChar *content);
+XMLPUBFUN xmlNodePtr XMLCALL	
+		xmlNewNode		(xmlNsPtr ns,
+					 const xmlChar *name);
+XMLPUBFUN xmlNodePtr XMLCALL	
+		xmlNewNodeEatName	(xmlNsPtr ns,
+					 xmlChar *name);
+XMLPUBFUN xmlNodePtr XMLCALL	
+		xmlNewChild		(xmlNodePtr parent,
+					 xmlNsPtr ns,
+					 const xmlChar *name,
+					 const xmlChar *content);
+XMLPUBFUN xmlNodePtr XMLCALL	
+		xmlNewTextChild		(xmlNodePtr parent,
+					 xmlNsPtr ns,
+					 const xmlChar *name,
+					 const xmlChar *content);
+XMLPUBFUN xmlNodePtr XMLCALL	
+		xmlNewDocText		(xmlDocPtr doc,
+					 const xmlChar *content);
+XMLPUBFUN xmlNodePtr XMLCALL	
+		xmlNewText		(const xmlChar *content);
+XMLPUBFUN xmlNodePtr XMLCALL	
+		xmlNewPI		(const xmlChar *name,
+					 const xmlChar *content);
+XMLPUBFUN xmlNodePtr XMLCALL	
+		xmlNewDocTextLen	(xmlDocPtr doc,
+					 const xmlChar *content,
+					 int len);
+XMLPUBFUN xmlNodePtr XMLCALL	
+		xmlNewTextLen		(const xmlChar *content,
+					 int len);
+XMLPUBFUN xmlNodePtr XMLCALL	
+		xmlNewDocComment	(xmlDocPtr doc,
+					 const xmlChar *content);
+XMLPUBFUN xmlNodePtr XMLCALL	
+		xmlNewComment		(const xmlChar *content);
+XMLPUBFUN xmlNodePtr XMLCALL	
+		xmlNewCDataBlock	(xmlDocPtr doc,
+					 const xmlChar *content,
+					 int len);
+XMLPUBFUN xmlNodePtr XMLCALL	
+		xmlNewCharRef		(xmlDocPtr doc,
+					 const xmlChar *name);
+XMLPUBFUN xmlNodePtr XMLCALL	
+		xmlNewReference		(xmlDocPtr doc,
+					 const xmlChar *name);
+XMLPUBFUN xmlNodePtr XMLCALL	
+		xmlCopyNode		(const xmlNodePtr node,
+					 int recursive);
+XMLPUBFUN xmlNodePtr XMLCALL	
+		xmlDocCopyNode		(const xmlNodePtr node,
+					 xmlDocPtr doc,
+					 int recursive);
+XMLPUBFUN xmlNodePtr XMLCALL	
+		xmlCopyNodeList		(const xmlNodePtr node);
+#ifdef LIBXML_TREE_ENABLED
+XMLPUBFUN xmlNodePtr XMLCALL	
+		xmlNewDocFragment	(xmlDocPtr doc);
+#endif /* LIBXML_TREE_ENABLED */
+
+/*
+ * Navigating.
+ */
+XMLPUBFUN long XMLCALL		
+		xmlGetLineNo		(xmlNodePtr node);
+#ifdef LIBXML_TREE_ENABLED
+XMLPUBFUN xmlChar * XMLCALL	
+		xmlGetNodePath		(xmlNodePtr node);
+#endif /* LIBXML_TREE_ENABLED */
+XMLPUBFUN xmlNodePtr XMLCALL	
+		xmlDocGetRootElement	(xmlDocPtr doc);
+XMLPUBFUN xmlNodePtr XMLCALL	
+		xmlGetLastChild		(xmlNodePtr parent);
+XMLPUBFUN int XMLCALL		
+		xmlNodeIsText		(xmlNodePtr node);
+XMLPUBFUN int XMLCALL		
+		xmlIsBlankNode		(xmlNodePtr node);
+
+#ifdef LIBXML_TREE_ENABLED
+/*
+ * Changing the structure.
+ */
+XMLPUBFUN xmlNodePtr XMLCALL	
+		xmlDocSetRootElement	(xmlDocPtr doc,
+					 xmlNodePtr root);
+XMLPUBFUN void XMLCALL		
+		xmlNodeSetName		(xmlNodePtr cur,
+					 const xmlChar *name);
+#endif /* LIBXML_TREE_ENABLED */
+XMLPUBFUN xmlNodePtr XMLCALL	
+		xmlAddChild		(xmlNodePtr parent,
+					 xmlNodePtr cur);
+XMLPUBFUN xmlNodePtr XMLCALL	
+		xmlAddChildList		(xmlNodePtr parent,
+					 xmlNodePtr cur);
+#ifdef LIBXML_TREE_ENABLED
+XMLPUBFUN xmlNodePtr XMLCALL	
+		xmlReplaceNode		(xmlNodePtr old,
+					 xmlNodePtr cur);
+XMLPUBFUN xmlNodePtr XMLCALL	
+		xmlAddPrevSibling	(xmlNodePtr cur,
+					 xmlNodePtr elem);
+#endif /* LIBXML_TREE_ENABLED */
+XMLPUBFUN xmlNodePtr XMLCALL	
+		xmlAddSibling		(xmlNodePtr cur,
+					 xmlNodePtr elem);
+XMLPUBFUN xmlNodePtr XMLCALL	
+		xmlAddNextSibling	(xmlNodePtr cur,
+					 xmlNodePtr elem);
+XMLPUBFUN void XMLCALL		
+		xmlUnlinkNode		(xmlNodePtr cur);
+XMLPUBFUN xmlNodePtr XMLCALL	
+		xmlTextMerge		(xmlNodePtr first,
+					 xmlNodePtr second);
+XMLPUBFUN int XMLCALL		
+		xmlTextConcat		(xmlNodePtr node,
+					 const xmlChar *content,
+					 int len);
+XMLPUBFUN void XMLCALL		
+		xmlFreeNodeList		(xmlNodePtr cur);
+XMLPUBFUN void XMLCALL		
+		xmlFreeNode		(xmlNodePtr cur);
+XMLPUBFUN void XMLCALL		
+		xmlSetTreeDoc		(xmlNodePtr tree,
+					 xmlDocPtr doc);
+XMLPUBFUN void XMLCALL		
+		xmlSetListDoc		(xmlNodePtr list,
+					 xmlDocPtr doc);
+/*
+ * Namespaces.
+ */
+XMLPUBFUN xmlNsPtr XMLCALL	
+		xmlSearchNs		(xmlDocPtr doc,
+					 xmlNodePtr node,
+					 const xmlChar *nameSpace);
+XMLPUBFUN xmlNsPtr XMLCALL	
+		xmlSearchNsByHref	(xmlDocPtr doc,
+					 xmlNodePtr node,
+					 const xmlChar *href);
+#ifdef LIBXML_TREE_ENABLED
+XMLPUBFUN xmlNsPtr * XMLCALL	
+		xmlGetNsList		(xmlDocPtr doc,
+					 xmlNodePtr node);
+#endif /* LIBXML_TREE_ENABLED */
+
+XMLPUBFUN void XMLCALL		
+		xmlSetNs		(xmlNodePtr node,
+					 xmlNsPtr ns);
+XMLPUBFUN xmlNsPtr XMLCALL	
+		xmlCopyNamespace	(xmlNsPtr cur);
+XMLPUBFUN xmlNsPtr XMLCALL	
+		xmlCopyNamespaceList	(xmlNsPtr cur);
+
+/*
+ * Changing the content.
+ */
+#ifdef LIBXML_TREE_ENABLED
+XMLPUBFUN xmlAttrPtr XMLCALL	
+		xmlSetProp		(xmlNodePtr node,
+					 const xmlChar *name,
+					 const xmlChar *value);
+#endif /* LIBXML_TREE_ENABLED */
+XMLPUBFUN xmlChar * XMLCALL	
+		xmlGetNoNsProp		(xmlNodePtr node,
+					 const xmlChar *name);
+XMLPUBFUN xmlChar * XMLCALL	
+		xmlGetProp		(xmlNodePtr node,
+					 const xmlChar *name);
+XMLPUBFUN xmlAttrPtr XMLCALL	
+		xmlHasProp		(xmlNodePtr node,
+					 const xmlChar *name);
+XMLPUBFUN xmlAttrPtr XMLCALL	
+		xmlHasNsProp		(xmlNodePtr node,
+					 const xmlChar *name,
+					 const xmlChar *nameSpace);
+#ifdef LIBXML_TREE_ENABLED
+XMLPUBFUN xmlAttrPtr XMLCALL	
+		xmlSetNsProp		(xmlNodePtr node,
+					 xmlNsPtr ns,
+					 const xmlChar *name,
+					 const xmlChar *value);
+#endif /* LIBXML_TREE_ENABLED */
+XMLPUBFUN xmlChar * XMLCALL	
+		xmlGetNsProp		(xmlNodePtr node,
+					 const xmlChar *name,
+					 const xmlChar *nameSpace);
+XMLPUBFUN xmlNodePtr XMLCALL	
+		xmlStringGetNodeList	(xmlDocPtr doc,
+					 const xmlChar *value);
+XMLPUBFUN xmlNodePtr XMLCALL	
+		xmlStringLenGetNodeList	(xmlDocPtr doc,
+					 const xmlChar *value,
+					 int len);
+XMLPUBFUN xmlChar * XMLCALL	
+		xmlNodeListGetString	(xmlDocPtr doc,
+					 xmlNodePtr list,
+					 int inLine);
+#ifdef LIBXML_TREE_ENABLED
+XMLPUBFUN xmlChar * XMLCALL	
+		xmlNodeListGetRawString	(xmlDocPtr doc,
+					 xmlNodePtr list,
+					 int inLine);
+#endif /* LIBXML_TREE_ENABLED */
+XMLPUBFUN void XMLCALL		
+		xmlNodeSetContent	(xmlNodePtr cur,
+					 const xmlChar *content);
+#ifdef LIBXML_TREE_ENABLED
+XMLPUBFUN void XMLCALL		
+		xmlNodeSetContentLen	(xmlNodePtr cur,
+					 const xmlChar *content,
+					 int len);
+#endif /* LIBXML_TREE_ENABLED */
+XMLPUBFUN void XMLCALL		
+		xmlNodeAddContent	(xmlNodePtr cur,
+					 const xmlChar *content);
+XMLPUBFUN void XMLCALL		
+		xmlNodeAddContentLen	(xmlNodePtr cur,
+					 const xmlChar *content,
+					 int len);
+XMLPUBFUN xmlChar * XMLCALL	
+		xmlNodeGetContent	(xmlNodePtr cur);
+XMLPUBFUN int XMLCALL
+		xmlNodeBufGetContent	(xmlBufferPtr buffer,
+					 xmlNodePtr cur);
+XMLPUBFUN xmlChar * XMLCALL	
+		xmlNodeGetLang		(xmlNodePtr cur);
+XMLPUBFUN int XMLCALL		
+		xmlNodeGetSpacePreserve	(xmlNodePtr cur);
+#ifdef LIBXML_TREE_ENABLED
+XMLPUBFUN void XMLCALL		
+		xmlNodeSetLang		(xmlNodePtr cur,
+					 const xmlChar *lang);
+XMLPUBFUN void XMLCALL		
+		xmlNodeSetSpacePreserve (xmlNodePtr cur,
+					 int val);
+#endif /* LIBXML_TREE_ENABLED */
+XMLPUBFUN xmlChar * XMLCALL	
+		xmlNodeGetBase		(xmlDocPtr doc,
+					 xmlNodePtr cur);
+#ifdef LIBXML_TREE_ENABLED
+XMLPUBFUN void XMLCALL		
+		xmlNodeSetBase		(xmlNodePtr cur,
+					 const xmlChar *uri);
+
+/*
+ * Removing content.
+ */
+XMLPUBFUN int XMLCALL		
+		xmlRemoveProp		(xmlAttrPtr cur);
+XMLPUBFUN int XMLCALL		
+		xmlUnsetProp		(xmlNodePtr node,
+					 const xmlChar *name);
+XMLPUBFUN int XMLCALL		
+		xmlUnsetNsProp		(xmlNodePtr node,
+					 xmlNsPtr ns,
+					 const xmlChar *name);
+#endif /* LIBXML_TREE_ENABLED */
+
+/*
+ * Internal, don't use.
+ */
+XMLPUBFUN void XMLCALL		
+		xmlBufferWriteCHAR	(xmlBufferPtr buf,
+					 const xmlChar *string);
+XMLPUBFUN void XMLCALL		
+		xmlBufferWriteChar	(xmlBufferPtr buf,
+					 const char *string);
+XMLPUBFUN void XMLCALL		
+		xmlBufferWriteQuotedString(xmlBufferPtr buf,
+					 const xmlChar *string);
+
+XMLPUBFUN void xmlAttrSerializeTxtContent(xmlBufferPtr buf,
+					 xmlDocPtr doc,
+					 xmlAttrPtr attr,
+					 const xmlChar *string);
+
+/*
+ * Namespace handling.
+ */
+XMLPUBFUN int XMLCALL		
+		xmlReconciliateNs	(xmlDocPtr doc,
+					 xmlNodePtr tree);
+
+#ifdef LIBXML_OUTPUT_ENABLED
+/*
+ * Saving.
+ */
+XMLPUBFUN void XMLCALL		
+		xmlDocDumpFormatMemory	(xmlDocPtr cur,
+					 xmlChar **mem,
+					 int *size,
+					 int format);
+XMLPUBFUN void XMLCALL		
+		xmlDocDumpMemory	(xmlDocPtr cur,
+					 xmlChar **mem,
+					 int *size);
+XMLPUBFUN void XMLCALL		
+		xmlDocDumpMemoryEnc	(xmlDocPtr out_doc,
+					 xmlChar **doc_txt_ptr,
+					 int * doc_txt_len,
+					 const char *txt_encoding);
+XMLPUBFUN void XMLCALL		
+		xmlDocDumpFormatMemoryEnc(xmlDocPtr out_doc,
+					 xmlChar **doc_txt_ptr,
+					 int * doc_txt_len,
+					 const char *txt_encoding,
+					 int format);
+XMLPUBFUN int XMLCALL		
+		xmlDocFormatDump	(FILE *f,
+					 xmlDocPtr cur,
+					 int format);
+XMLPUBFUN int XMLCALL	
+		xmlDocDump		(FILE *f,
+					 xmlDocPtr cur);
+XMLPUBFUN void XMLCALL		
+		xmlElemDump		(FILE *f,
+					 xmlDocPtr doc,
+					 xmlNodePtr cur);
+XMLPUBFUN int XMLCALL		
+		xmlSaveFile		(const char *filename,
+					 xmlDocPtr cur);
+XMLPUBFUN int XMLCALL		
+		xmlSaveFormatFile	(const char *filename,
+					 xmlDocPtr cur,
+					 int format);
+XMLPUBFUN int XMLCALL		
+		xmlNodeDump		(xmlBufferPtr buf,
+					 xmlDocPtr doc,
+					 xmlNodePtr cur,
+					 int level,
+					 int format);
+
+XMLPUBFUN int XMLCALL		
+		xmlSaveFileTo		(xmlOutputBufferPtr buf,
+					 xmlDocPtr cur,
+					 const char *encoding);
+XMLPUBFUN int XMLCALL             
+		xmlSaveFormatFileTo     (xmlOutputBufferPtr buf,
+					 xmlDocPtr cur,
+				         const char *encoding,
+				         int format);
+XMLPUBFUN void XMLCALL		
+		xmlNodeDumpOutput	(xmlOutputBufferPtr buf,
+					 xmlDocPtr doc,
+					 xmlNodePtr cur,
+					 int level,
+					 int format,
+					 const char *encoding);
+
+XMLPUBFUN int XMLCALL		
+		xmlSaveFormatFileEnc    (const char *filename,
+					 xmlDocPtr cur,
+					 const char *encoding,
+					 int format);
+
+XMLPUBFUN int XMLCALL		
+		xmlSaveFileEnc		(const char *filename,
+					 xmlDocPtr cur,
+					 const char *encoding);
+
+#endif /* LIBXML_OUTPUT_ENABLED */
+/*
+ * XHTML
+ */
+XMLPUBFUN int XMLCALL		
+		xmlIsXHTML		(const xmlChar *systemID,
+					 const xmlChar *publicID);
+
+/*
+ * Compression.
+ */
+XMLPUBFUN int XMLCALL		
+		xmlGetDocCompressMode	(xmlDocPtr doc);
+XMLPUBFUN void XMLCALL		
+		xmlSetDocCompressMode	(xmlDocPtr doc,
+					 int mode);
+XMLPUBFUN int XMLCALL		
+		xmlGetCompressMode	(void);
+XMLPUBFUN void XMLCALL		
+		xmlSetCompressMode	(int mode);
+
+#ifdef __cplusplus
+}
+#endif
+#ifndef __XML_PARSER_H__
+#include <libxml/xmlmemory.h>
+#endif
+
+#endif /* __XML_TREE_H__ */
+
diff --git a/src/libxml/include/libxml/uri.h b/src/libxml/include/libxml/uri.h
new file mode 100644
index 0000000..5e29e63
--- /dev/null
+++ b/src/libxml/include/libxml/uri.h
@@ -0,0 +1,81 @@
+/**
+ * Summary: library of generic URI related routines
+ * Description: library of generic URI related routines
+ *              Implements RFC 2396
+ *
+ * Copy: See Copyright for the status of this software.
+ *
+ * Author: Daniel Veillard
+ */
+
+#ifndef __XML_URI_H__
+#define __XML_URI_H__
+
+#include <libxml/xmlversion.h>
+#include <libxml/tree.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * xmlURI:
+ *
+ * A parsed URI reference. This is a struct containing the various fields
+ * as described in RFC 2396 but separated for further processing.
+ */
+typedef struct _xmlURI xmlURI;
+typedef xmlURI *xmlURIPtr;
+struct _xmlURI {
+    char *scheme;	/* the URI scheme */
+    char *opaque;	/* opaque part */
+    char *authority;	/* the authority part */
+    char *server;	/* the server part */
+    char *user;		/* the user part */
+    int port;		/* the port number */
+    char *path;		/* the path string */
+    char *query;	/* the query string */
+    char *fragment;	/* the fragment identifier */
+    int  cleanup;	/* parsing potentially unclean URI */
+};
+
+/*
+ * This function is in tree.h:
+ * xmlChar *	xmlNodeGetBase	(xmlDocPtr doc,
+ *                               xmlNodePtr cur);
+ */
+XMLPUBFUN xmlURIPtr XMLCALL	
+		xmlCreateURI		(void);
+XMLPUBFUN xmlChar * XMLCALL	
+		xmlBuildURI		(const xmlChar *URI,
+	                        	 const xmlChar *base);
+XMLPUBFUN xmlURIPtr XMLCALL	
+		xmlParseURI		(const char *str);
+XMLPUBFUN int XMLCALL		
+		xmlParseURIReference	(xmlURIPtr uri,
+					 const char *str);
+XMLPUBFUN xmlChar * XMLCALL	
+		xmlSaveUri		(xmlURIPtr uri);
+XMLPUBFUN void XMLCALL		
+		xmlPrintURI		(FILE *stream,
+					 xmlURIPtr uri);
+XMLPUBFUN xmlChar * XMLCALL       
+		xmlURIEscapeStr         (const xmlChar *str,
+ 					 const xmlChar *list);
+XMLPUBFUN char * XMLCALL		
+		xmlURIUnescapeString	(const char *str,
+					 int len,
+					 char *target);
+XMLPUBFUN int XMLCALL		
+		xmlNormalizeURIPath	(char *path);
+XMLPUBFUN xmlChar * XMLCALL	
+		xmlURIEscape		(const xmlChar *str);
+XMLPUBFUN void XMLCALL		
+		xmlFreeURI		(xmlURIPtr uri);
+XMLPUBFUN xmlChar* XMLCALL	
+		xmlCanonicPath		(const xmlChar *path);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* __XML_URI_H__ */
diff --git a/src/libxml/include/libxml/valid.h b/src/libxml/include/libxml/valid.h
new file mode 100644
index 0000000..1ff3f0b
--- /dev/null
+++ b/src/libxml/include/libxml/valid.h
@@ -0,0 +1,408 @@
+/*
+ * Summary: The DTD validation
+ * Description: API for the DTD handling and the validity checking
+ *
+ * Copy: See Copyright for the status of this software.
+ *
+ * Author: Daniel Veillard
+ */
+
+
+#ifndef __XML_VALID_H__
+#define __XML_VALID_H__
+
+#include <libxml/xmlversion.h>
+#include <libxml/xmlerror.h>
+#include <libxml/tree.h>
+#include <libxml/list.h>
+#include <libxml/xmlautomata.h>
+#include <libxml/xmlregexp.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * Validation state added for non-determinist content model.
+ */
+typedef struct _xmlValidState xmlValidState;
+typedef xmlValidState *xmlValidStatePtr;
+
+/**
+ * xmlValidityErrorFunc:
+ * @ctx:  an xmlValidCtxtPtr validity error context
+ * @msg:  the string to format *printf like vararg
+ * @...:  remaining arguments to the format
+ *
+ * Callback called when a validity error is found. This is a message
+ * oriented function similar to an *printf function.
+ */
+typedef void (*xmlValidityErrorFunc) (void *ctx,
+			     const char *msg,
+			     ...);
+
+/**
+ * xmlValidityWarningFunc:
+ * @ctx:  an xmlValidCtxtPtr validity error context
+ * @msg:  the string to format *printf like vararg
+ * @...:  remaining arguments to the format
+ *
+ * Callback called when a validity warning is found. This is a message
+ * oriented function similar to an *printf function.
+ */
+typedef void (*xmlValidityWarningFunc) (void *ctx,
+			       const char *msg,
+			       ...);
+
+/*
+ * xmlValidCtxt:
+ * An xmlValidCtxt is used for error reporting when validating.
+ */
+typedef struct _xmlValidCtxt xmlValidCtxt;
+typedef xmlValidCtxt *xmlValidCtxtPtr;
+struct _xmlValidCtxt {
+    void *userData;			/* user specific data block */
+    xmlValidityErrorFunc error;		/* the callback in case of errors */
+    xmlValidityWarningFunc warning;	/* the callback in case of warning */
+
+    /* Node analysis stack used when validating within entities */
+    xmlNodePtr         node;          /* Current parsed Node */
+    int                nodeNr;        /* Depth of the parsing stack */
+    int                nodeMax;       /* Max depth of the parsing stack */
+    xmlNodePtr        *nodeTab;       /* array of nodes */
+
+    int              finishDtd;       /* finished validating the Dtd ? */
+    xmlDocPtr              doc;       /* the document */
+    int                  valid;       /* temporary validity check result */
+
+    /* state state used for non-determinist content validation */
+    xmlValidState     *vstate;        /* current state */
+    int                vstateNr;      /* Depth of the validation stack */
+    int                vstateMax;     /* Max depth of the validation stack */
+    xmlValidState     *vstateTab;     /* array of validation states */
+
+#ifdef LIBXML_REGEXP_ENABLED
+    xmlAutomataPtr            am;     /* the automata */
+    xmlAutomataStatePtr    state;     /* used to build the automata */
+#else
+    void                     *am;
+    void                  *state;
+#endif
+};
+
+/*
+ * ALL notation declarations are stored in a table.
+ * There is one table per DTD.
+ */
+
+typedef struct _xmlHashTable xmlNotationTable;
+typedef xmlNotationTable *xmlNotationTablePtr;
+
+/*
+ * ALL element declarations are stored in a table.
+ * There is one table per DTD.
+ */
+
+typedef struct _xmlHashTable xmlElementTable;
+typedef xmlElementTable *xmlElementTablePtr;
+
+/*
+ * ALL attribute declarations are stored in a table.
+ * There is one table per DTD.
+ */
+
+typedef struct _xmlHashTable xmlAttributeTable;
+typedef xmlAttributeTable *xmlAttributeTablePtr;
+
+/*
+ * ALL IDs attributes are stored in a table.
+ * There is one table per document.
+ */
+
+typedef struct _xmlHashTable xmlIDTable;
+typedef xmlIDTable *xmlIDTablePtr;
+
+/*
+ * ALL Refs attributes are stored in a table.
+ * There is one table per document.
+ */
+
+typedef struct _xmlHashTable xmlRefTable;
+typedef xmlRefTable *xmlRefTablePtr;
+
+/* Allocate/Release Validation Contexts */
+XMLPUBFUN xmlValidCtxtPtr XMLCALL	    
+		xmlNewValidCtxt(void);
+XMLPUBFUN void XMLCALL		    
+		xmlFreeValidCtxt(xmlValidCtxtPtr);
+
+/* Notation */
+XMLPUBFUN xmlNotationPtr XMLCALL	    
+		xmlAddNotationDecl	(xmlValidCtxtPtr ctxt,
+					 xmlDtdPtr dtd,
+					 const xmlChar *name,
+					 const xmlChar *PublicID,
+					 const xmlChar *SystemID);
+XMLPUBFUN xmlNotationTablePtr XMLCALL 
+		xmlCopyNotationTable	(xmlNotationTablePtr table);
+XMLPUBFUN void XMLCALL		    
+		xmlFreeNotationTable	(xmlNotationTablePtr table);
+#ifdef LIBXML_OUTPUT_ENABLED
+XMLPUBFUN void XMLCALL		    
+		xmlDumpNotationDecl	(xmlBufferPtr buf,
+					 xmlNotationPtr nota);
+XMLPUBFUN void XMLCALL		    
+		xmlDumpNotationTable	(xmlBufferPtr buf,
+					 xmlNotationTablePtr table);
+#endif /* LIBXML_OUTPUT_ENABLED */
+
+/* Element Content */
+XMLPUBFUN xmlElementContentPtr XMLCALL 
+		xmlNewElementContent	(const xmlChar *name,
+					 xmlElementContentType type);
+XMLPUBFUN xmlElementContentPtr XMLCALL 
+		xmlCopyElementContent	(xmlElementContentPtr content);
+XMLPUBFUN void XMLCALL		     
+		xmlFreeElementContent	(xmlElementContentPtr cur);
+XMLPUBFUN void XMLCALL		     
+		xmlSnprintfElementContent(char *buf,
+					 int size,
+	                                 xmlElementContentPtr content,
+					 int glob);
+/* DEPRECATED */
+XMLPUBFUN void XMLCALL		     
+		xmlSprintfElementContent(char *buf,
+	                                 xmlElementContentPtr content,
+					 int glob);
+/* DEPRECATED */
+
+/* Element */
+XMLPUBFUN xmlElementPtr XMLCALL	   
+		xmlAddElementDecl	(xmlValidCtxtPtr ctxt,
+					 xmlDtdPtr dtd,
+					 const xmlChar *name,
+					 xmlElementTypeVal type,
+					 xmlElementContentPtr content);
+XMLPUBFUN xmlElementTablePtr XMLCALL 
+		xmlCopyElementTable	(xmlElementTablePtr table);
+XMLPUBFUN void XMLCALL		   
+		xmlFreeElementTable	(xmlElementTablePtr table);
+#ifdef LIBXML_OUTPUT_ENABLED
+XMLPUBFUN void XMLCALL		   
+		xmlDumpElementTable	(xmlBufferPtr buf,
+					 xmlElementTablePtr table);
+XMLPUBFUN void XMLCALL		   
+		xmlDumpElementDecl	(xmlBufferPtr buf,
+					 xmlElementPtr elem);
+#endif /* LIBXML_OUTPUT_ENABLED */
+
+/* Enumeration */
+XMLPUBFUN xmlEnumerationPtr XMLCALL 
+		xmlCreateEnumeration	(const xmlChar *name);
+XMLPUBFUN void XMLCALL		   
+		xmlFreeEnumeration	(xmlEnumerationPtr cur);
+XMLPUBFUN xmlEnumerationPtr XMLCALL  
+		xmlCopyEnumeration	(xmlEnumerationPtr cur);
+
+/* Attribute */
+XMLPUBFUN xmlAttributePtr XMLCALL	    
+		xmlAddAttributeDecl	(xmlValidCtxtPtr ctxt,
+					 xmlDtdPtr dtd,
+					 const xmlChar *elem,
+					 const xmlChar *name,
+					 const xmlChar *ns,
+					 xmlAttributeType type,
+					 xmlAttributeDefault def,
+					 const xmlChar *defaultValue,
+					 xmlEnumerationPtr tree);
+XMLPUBFUN xmlAttributeTablePtr XMLCALL 
+		xmlCopyAttributeTable  (xmlAttributeTablePtr table);
+XMLPUBFUN void XMLCALL		     
+		xmlFreeAttributeTable  (xmlAttributeTablePtr table);
+#ifdef LIBXML_OUTPUT_ENABLED
+XMLPUBFUN void XMLCALL		     
+		xmlDumpAttributeTable  (xmlBufferPtr buf,
+					xmlAttributeTablePtr table);
+XMLPUBFUN void XMLCALL		     
+		xmlDumpAttributeDecl   (xmlBufferPtr buf,
+					xmlAttributePtr attr);
+#endif /* LIBXML_OUTPUT_ENABLED */
+
+/* IDs */
+XMLPUBFUN xmlIDPtr XMLCALL	
+		xmlAddID	       (xmlValidCtxtPtr ctxt,
+					xmlDocPtr doc,
+					const xmlChar *value,
+					xmlAttrPtr attr);
+XMLPUBFUN void XMLCALL		
+		xmlFreeIDTable	       (xmlIDTablePtr table);
+XMLPUBFUN xmlAttrPtr XMLCALL	
+		xmlGetID	       (xmlDocPtr doc,
+					const xmlChar *ID);
+XMLPUBFUN int XMLCALL		
+		xmlIsID		       (xmlDocPtr doc,
+					xmlNodePtr elem,
+					xmlAttrPtr attr);
+XMLPUBFUN int XMLCALL		
+		xmlRemoveID	       (xmlDocPtr doc, 
+					xmlAttrPtr attr);
+
+/* IDREFs */
+XMLPUBFUN xmlRefPtr XMLCALL	
+		xmlAddRef	       (xmlValidCtxtPtr ctxt,
+					xmlDocPtr doc,
+					const xmlChar *value,
+					xmlAttrPtr attr);
+XMLPUBFUN void XMLCALL		
+		xmlFreeRefTable	       (xmlRefTablePtr table);
+XMLPUBFUN int XMLCALL		
+		xmlIsRef	       (xmlDocPtr doc,
+					xmlNodePtr elem,
+					xmlAttrPtr attr);
+XMLPUBFUN int XMLCALL		
+		xmlRemoveRef	       (xmlDocPtr doc, 
+					xmlAttrPtr attr);
+XMLPUBFUN xmlListPtr XMLCALL	
+		xmlGetRefs	       (xmlDocPtr doc,
+					const xmlChar *ID);
+
+/**
+ * The public function calls related to validity checking.
+ */
+
+XMLPUBFUN int XMLCALL		
+		xmlValidateRoot		(xmlValidCtxtPtr ctxt,
+					 xmlDocPtr doc);
+XMLPUBFUN int XMLCALL		
+		xmlValidateElementDecl	(xmlValidCtxtPtr ctxt,
+					 xmlDocPtr doc,
+		                         xmlElementPtr elem);
+XMLPUBFUN xmlChar * XMLCALL	
+		xmlValidNormalizeAttributeValue(xmlDocPtr doc,
+					 xmlNodePtr elem,
+					 const xmlChar *name,
+					 const xmlChar *value);
+XMLPUBFUN xmlChar * XMLCALL	
+		xmlValidCtxtNormalizeAttributeValue(xmlValidCtxtPtr ctxt,
+					 xmlDocPtr doc,
+					 xmlNodePtr elem,
+					 const xmlChar *name,
+					 const xmlChar *value);
+XMLPUBFUN int XMLCALL		
+		xmlValidateAttributeDecl(xmlValidCtxtPtr ctxt,
+					 xmlDocPtr doc,
+		                         xmlAttributePtr attr);
+XMLPUBFUN int XMLCALL		
+		xmlValidateAttributeValue(xmlAttributeType type,
+					 const xmlChar *value);
+XMLPUBFUN int XMLCALL		
+		xmlValidateNotationDecl	(xmlValidCtxtPtr ctxt,
+					 xmlDocPtr doc,
+		                         xmlNotationPtr nota);
+XMLPUBFUN int XMLCALL		
+		xmlValidateDtd		(xmlValidCtxtPtr ctxt,
+					 xmlDocPtr doc,
+					 xmlDtdPtr dtd);
+XMLPUBFUN int XMLCALL		
+		xmlValidateDtdFinal	(xmlValidCtxtPtr ctxt,
+					 xmlDocPtr doc);
+XMLPUBFUN int XMLCALL		
+		xmlValidateDocument	(xmlValidCtxtPtr ctxt,
+					 xmlDocPtr doc);
+XMLPUBFUN int XMLCALL		
+		xmlValidateElement	(xmlValidCtxtPtr ctxt,
+					 xmlDocPtr doc,
+					 xmlNodePtr elem);
+XMLPUBFUN int XMLCALL		
+		xmlValidateOneElement	(xmlValidCtxtPtr ctxt,
+					 xmlDocPtr doc,
+		                         xmlNodePtr elem);
+XMLPUBFUN int XMLCALL	
+		xmlValidateOneAttribute	(xmlValidCtxtPtr ctxt,
+					 xmlDocPtr doc,
+					 xmlNodePtr	elem,
+					 xmlAttrPtr attr,
+					 const xmlChar *value);
+XMLPUBFUN int XMLCALL		
+		xmlValidateOneNamespace	(xmlValidCtxtPtr ctxt,
+					 xmlDocPtr doc,
+					 xmlNodePtr elem,
+					 const xmlChar *prefix,
+					 xmlNsPtr ns,
+					 const xmlChar *value);
+XMLPUBFUN int XMLCALL		
+		xmlValidateDocumentFinal(xmlValidCtxtPtr ctxt,
+					 xmlDocPtr doc);
+XMLPUBFUN int XMLCALL		
+		xmlValidateNotationUse	(xmlValidCtxtPtr ctxt,
+					 xmlDocPtr doc,
+					 const xmlChar *notationName);
+XMLPUBFUN int XMLCALL		
+		xmlIsMixedElement	(xmlDocPtr doc,
+					 const xmlChar *name);
+XMLPUBFUN xmlAttributePtr XMLCALL	
+		xmlGetDtdAttrDesc	(xmlDtdPtr dtd,
+					 const xmlChar *elem,
+					 const xmlChar *name);
+XMLPUBFUN xmlAttributePtr XMLCALL	
+		xmlGetDtdQAttrDesc	(xmlDtdPtr dtd,
+					 const xmlChar *elem,
+					 const xmlChar *name,
+					 const xmlChar *prefix);
+XMLPUBFUN xmlNotationPtr XMLCALL	
+		xmlGetDtdNotationDesc	(xmlDtdPtr dtd,
+					 const xmlChar *name);
+XMLPUBFUN xmlElementPtr XMLCALL	
+		xmlGetDtdQElementDesc	(xmlDtdPtr dtd,
+					 const xmlChar *name,
+					 const xmlChar *prefix);
+XMLPUBFUN xmlElementPtr XMLCALL	
+		xmlGetDtdElementDesc	(xmlDtdPtr dtd,
+					 const xmlChar *name);
+
+XMLPUBFUN int XMLCALL		
+		xmlValidGetValidElements(xmlNode *prev,
+					 xmlNode *next,
+					 const xmlChar **list,
+					 int max);
+XMLPUBFUN int XMLCALL		
+		xmlValidGetPotentialChildren(xmlElementContent *ctree,
+					 const xmlChar **list,
+					 int *len,
+					 int max);
+XMLPUBFUN int XMLCALL		
+		xmlValidateNameValue	(const xmlChar *value);
+XMLPUBFUN int XMLCALL		
+		xmlValidateNamesValue	(const xmlChar *value);
+XMLPUBFUN int XMLCALL		
+		xmlValidateNmtokenValue	(const xmlChar *value);
+XMLPUBFUN int XMLCALL		
+		xmlValidateNmtokensValue(const xmlChar *value);
+
+#ifdef LIBXML_REGEXP_ENABLED
+/*
+ * Validation based on the regexp support
+ */
+XMLPUBFUN int XMLCALL		
+		xmlValidBuildContentModel(xmlValidCtxtPtr ctxt,
+					 xmlElementPtr elem);
+
+XMLPUBFUN int XMLCALL		
+		xmlValidatePushElement	(xmlValidCtxtPtr ctxt,
+					 xmlDocPtr doc,
+					 xmlNodePtr elem,
+					 const xmlChar *qname);
+XMLPUBFUN int XMLCALL		
+		xmlValidatePushCData	(xmlValidCtxtPtr ctxt,
+					 const xmlChar *data,
+					 int len);
+XMLPUBFUN int XMLCALL		
+		xmlValidatePopElement	(xmlValidCtxtPtr ctxt,
+					 xmlDocPtr doc,
+					 xmlNodePtr elem,
+					 const xmlChar *qname);
+#endif /* LIBXML_REGEXP_ENABLED */
+#ifdef __cplusplus
+}
+#endif
+#endif /* __XML_VALID_H__ */
diff --git a/src/libxml/include/libxml/xinclude.h b/src/libxml/include/libxml/xinclude.h
new file mode 100644
index 0000000..880a280
--- /dev/null
+++ b/src/libxml/include/libxml/xinclude.h
@@ -0,0 +1,116 @@
+/*
+ * Summary: implementation of XInclude
+ * Description: API to handle XInclude processing,
+ * implements the
+ * World Wide Web Consortium Last Call Working Draft 10 November 2003
+ * http://www.w3.org/TR/2003/WD-xinclude-20031110
+ *
+ * Copy: See Copyright for the status of this software.
+ *
+ * Author: Daniel Veillard
+ */
+
+#ifndef __XML_XINCLUDE_H__
+#define __XML_XINCLUDE_H__
+
+#include <libxml/xmlversion.h>
+#include <libxml/tree.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * XINCLUDE_NS:
+ *
+ * Macro defining the Xinclude namespace: http://www.w3.org/2003/XInclude
+ */
+#define XINCLUDE_NS (const xmlChar *) "http://www.w3.org/2003/XInclude"
+/**
+ * XINCLUDE_OLD_NS:
+ *
+ * Macro defining the draft Xinclude namespace: http://www.w3.org/2001/XInclude
+ */
+#define XINCLUDE_OLD_NS (const xmlChar *) "http://www.w3.org/2001/XInclude"
+/**
+ * XINCLUDE_NODE:
+ *
+ * Macro defining "include"
+ */
+#define XINCLUDE_NODE (const xmlChar *) "include"
+/**
+ * XINCLUDE_FALLBACK:
+ *
+ * Macro defining "fallback"
+ */
+#define XINCLUDE_FALLBACK (const xmlChar *) "fallback"
+/**
+ * XINCLUDE_HREF:
+ *
+ * Macro defining "href"
+ */
+#define XINCLUDE_HREF (const xmlChar *) "href"
+/**
+ * XINCLUDE_PARSE:
+ *
+ * Macro defining "parse"
+ */
+#define XINCLUDE_PARSE (const xmlChar *) "parse"
+/**
+ * XINCLUDE_PARSE_XML:
+ *
+ * Macro defining "xml"
+ */
+#define XINCLUDE_PARSE_XML (const xmlChar *) "xml"
+/**
+ * XINCLUDE_PARSE_TEXT:
+ *
+ * Macro defining "text"
+ */
+#define XINCLUDE_PARSE_TEXT (const xmlChar *) "text"
+/**
+ * XINCLUDE_PARSE_ENCODING:
+ *
+ * Macro defining "encoding"
+ */
+#define XINCLUDE_PARSE_ENCODING (const xmlChar *) "encoding"
+/**
+ * XINCLUDE_PARSE_XPOINTER:
+ *
+ * Macro defining "xpointer"
+ */
+#define XINCLUDE_PARSE_XPOINTER (const xmlChar *) "xpointer"
+
+typedef struct _xmlXIncludeCtxt xmlXIncludeCtxt;
+typedef xmlXIncludeCtxt *xmlXIncludeCtxtPtr;
+
+/*
+ * standalone processing
+ */
+XMLPUBFUN int XMLCALL	
+		xmlXIncludeProcess	(xmlDocPtr doc);
+XMLPUBFUN int XMLCALL	
+		xmlXIncludeProcessFlags	(xmlDocPtr doc,
+					 int flags);
+XMLPUBFUN int XMLCALL	
+		xmlXIncludeProcessTree	(xmlNodePtr tree);
+XMLPUBFUN int XMLCALL	
+		xmlXIncludeProcessTreeFlags(xmlNodePtr tree,
+					 int flags);
+/*
+ * contextual processing
+ */
+XMLPUBFUN xmlXIncludeCtxtPtr XMLCALL
+		xmlXIncludeNewContext	(xmlDocPtr doc);
+XMLPUBFUN int XMLCALL
+		xmlXIncludeSetFlags	(xmlXIncludeCtxtPtr ctxt,
+					 int flags);
+XMLPUBFUN void XMLCALL
+		xmlXIncludeFreeContext	(xmlXIncludeCtxtPtr ctxt);
+XMLPUBFUN int XMLCALL
+		xmlXIncludeProcessNode	(xmlXIncludeCtxtPtr ctxt,
+					 xmlNodePtr tree);
+#ifdef __cplusplus
+}
+#endif
+#endif /* __XML_XINCLUDE_H__ */
diff --git a/src/libxml/include/libxml/xlink.h b/src/libxml/include/libxml/xlink.h
new file mode 100644
index 0000000..4b99611
--- /dev/null
+++ b/src/libxml/include/libxml/xlink.h
@@ -0,0 +1,183 @@
+/*
+ * Summary: unfinished XLink detection module
+ * Description: unfinished XLink detection module
+ *
+ * Copy: See Copyright for the status of this software.
+ *
+ * Author: Daniel Veillard
+ */
+
+#ifndef __XML_XLINK_H__
+#define __XML_XLINK_H__
+
+#include <libxml/xmlversion.h>
+#include <libxml/tree.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+/**
+ * Various defines for the various Link properties.
+ *
+ * NOTE: the link detection layer will try to resolve QName expansion
+ *       of namespaces. If "foo" is the prefix for "http://foo.com/"
+ *       then the link detection layer will expand role="foo:myrole"
+ *       to "http://foo.com/:myrole".
+ * NOTE: the link detection layer will expand URI-Refences found on
+ *       href attributes by using the base mechanism if found.
+ */
+typedef xmlChar *xlinkHRef;
+typedef xmlChar *xlinkRole;
+typedef xmlChar *xlinkTitle;
+
+typedef enum {
+    XLINK_TYPE_NONE = 0,
+    XLINK_TYPE_SIMPLE,
+    XLINK_TYPE_EXTENDED,
+    XLINK_TYPE_EXTENDED_SET
+} xlinkType;
+
+typedef enum {
+    XLINK_SHOW_NONE = 0,
+    XLINK_SHOW_NEW,
+    XLINK_SHOW_EMBED,
+    XLINK_SHOW_REPLACE
+} xlinkShow;
+
+typedef enum {
+    XLINK_ACTUATE_NONE = 0,
+    XLINK_ACTUATE_AUTO,
+    XLINK_ACTUATE_ONREQUEST
+} xlinkActuate;
+
+/**
+ * xlinkNodeDetectFunc:
+ * @ctx:  user data pointer
+ * @node:  the node to check
+ * 
+ * This is the prototype for the link detection routine.
+ * It calls the default link detection callbacks upon link detection.
+ */
+typedef void (*xlinkNodeDetectFunc) (void *ctx, xmlNodePtr node);
+
+/*
+ * The link detection module interact with the upper layers using
+ * a set of callback registered at parsing time.
+ */
+
+/**
+ * xlinkSimpleLinkFunk:
+ * @ctx:  user data pointer
+ * @node:  the node carrying the link
+ * @href:  the target of the link
+ * @role:  the role string
+ * @title:  the link title
+ *
+ * This is the prototype for a simple link detection callback.
+ */
+typedef void
+(*xlinkSimpleLinkFunk)	(void *ctx,
+			 xmlNodePtr node,
+			 const xlinkHRef href,
+			 const xlinkRole role,
+			 const xlinkTitle title);
+
+/**
+ * xlinkExtendedLinkFunk:
+ * @ctx:  user data pointer
+ * @node:  the node carrying the link
+ * @nbLocators: the number of locators detected on the link
+ * @hrefs:  pointer to the array of locator hrefs
+ * @roles:  pointer to the array of locator roles
+ * @nbArcs: the number of arcs detected on the link
+ * @from:  pointer to the array of source roles found on the arcs
+ * @to:  pointer to the array of target roles found on the arcs
+ * @show:  array of values for the show attributes found on the arcs
+ * @actuate:  array of values for the actuate attributes found on the arcs
+ * @nbTitles: the number of titles detected on the link
+ * @title:  array of titles detected on the link
+ * @langs:  array of xml:lang values for the titles
+ *
+ * This is the prototype for a extended link detection callback.
+ */
+typedef void
+(*xlinkExtendedLinkFunk)(void *ctx,
+			 xmlNodePtr node,
+			 int nbLocators,
+			 const xlinkHRef *hrefs,
+			 const xlinkRole *roles,
+			 int nbArcs,
+			 const xlinkRole *from,
+			 const xlinkRole *to,
+			 xlinkShow *show,
+			 xlinkActuate *actuate,
+			 int nbTitles,
+			 const xlinkTitle *titles,
+			 const xmlChar **langs);
+
+/**
+ * xlinkExtendedLinkSetFunk:
+ * @ctx:  user data pointer
+ * @node:  the node carrying the link
+ * @nbLocators: the number of locators detected on the link
+ * @hrefs:  pointer to the array of locator hrefs
+ * @roles:  pointer to the array of locator roles
+ * @nbTitles: the number of titles detected on the link
+ * @title:  array of titles detected on the link
+ * @langs:  array of xml:lang values for the titles
+ *
+ * This is the prototype for a extended link set detection callback.
+ */
+typedef void
+(*xlinkExtendedLinkSetFunk)	(void *ctx,
+				 xmlNodePtr node,
+				 int nbLocators,
+				 const xlinkHRef *hrefs,
+				 const xlinkRole *roles,
+				 int nbTitles,
+				 const xlinkTitle *titles,
+				 const xmlChar **langs);
+
+/**
+ * This is the structure containing a set of Links detection callbacks.
+ *
+ * There is no default xlink callbacks, if one want to get link
+ * recognition activated, those call backs must be provided before parsing.
+ */
+typedef struct _xlinkHandler xlinkHandler;
+typedef xlinkHandler *xlinkHandlerPtr;
+struct _xlinkHandler {
+    xlinkSimpleLinkFunk simple;
+    xlinkExtendedLinkFunk extended;
+    xlinkExtendedLinkSetFunk set;
+};
+
+/*
+ * The default detection routine, can be overridden, they call the default
+ * detection callbacks. 
+ */
+
+XMLPUBFUN xlinkNodeDetectFunc XMLCALL	
+		xlinkGetDefaultDetect	(void);
+XMLPUBFUN void XMLCALL			
+		xlinkSetDefaultDetect	(xlinkNodeDetectFunc func);
+
+/*
+ * Routines to set/get the default handlers.
+ */
+XMLPUBFUN xlinkHandlerPtr XMLCALL	
+		xlinkGetDefaultHandler	(void);
+XMLPUBFUN void XMLCALL		
+		xlinkSetDefaultHandler	(xlinkHandlerPtr handler);
+
+/*
+ * Link detection module itself.
+ */
+XMLPUBFUN xlinkType XMLCALL	 
+		xlinkIsLink		(xmlDocPtr doc,
+					 xmlNodePtr node);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* __XML_XLINK_H__ */
diff --git a/src/libxml/include/libxml/xmlIO.h b/src/libxml/include/libxml/xmlIO.h
new file mode 100644
index 0000000..58a7bb6
--- /dev/null
+++ b/src/libxml/include/libxml/xmlIO.h
@@ -0,0 +1,335 @@
+/*
+ * Summary: interface for the I/O interfaces used by the parser
+ * Description: interface for the I/O interfaces used by the parser
+ *
+ * Copy: See Copyright for the status of this software.
+ *
+ * Author: Daniel Veillard
+ */
+
+#ifndef __XML_IO_H__
+#define __XML_IO_H__
+
+#include <stdio.h>
+#include <libxml/xmlversion.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * Those are the functions and datatypes for the parser input
+ * I/O structures.
+ */
+
+/**
+ * xmlInputMatchCallback:
+ * @filename: the filename or URI
+ *
+ * Callback used in the I/O Input API to detect if the current handler 
+ * can provide input fonctionnalities for this resource.
+ *
+ * Returns 1 if yes and 0 if another Input module should be used
+ */
+typedef int (*xmlInputMatchCallback) (char const *filename);
+/**
+ * xmlInputOpenCallback:
+ * @filename: the filename or URI
+ *
+ * Callback used in the I/O Input API to open the resource
+ *
+ * Returns an Input context or NULL in case or error
+ */
+typedef void * (*xmlInputOpenCallback) (char const *filename);
+/**
+ * xmlInputReadCallback:
+ * @context:  an Input context
+ * @buffer:  the buffer to store data read
+ * @len:  the length of the buffer in bytes
+ *
+ * Callback used in the I/O Input API to read the resource
+ *
+ * Returns the number of bytes read or -1 in case of error
+ */
+typedef int (*xmlInputReadCallback) (void * context, char * buffer, int len);
+/**
+ * xmlInputCloseCallback:
+ * @context:  an Input context
+ *
+ * Callback used in the I/O Input API to close the resource
+ *
+ * Returns 0 or -1 in case of error
+ */
+typedef int (*xmlInputCloseCallback) (void * context);
+
+#ifdef LIBXML_OUTPUT_ENABLED
+/*
+ * Those are the functions and datatypes for the library output
+ * I/O structures.
+ */
+
+/**
+ * xmlOutputMatchCallback:
+ * @filename: the filename or URI
+ *
+ * Callback used in the I/O Output API to detect if the current handler 
+ * can provide output fonctionnalities for this resource.
+ *
+ * Returns 1 if yes and 0 if another Output module should be used
+ */
+typedef int (*xmlOutputMatchCallback) (char const *filename);
+/**
+ * xmlOutputOpenCallback:
+ * @filename: the filename or URI
+ *
+ * Callback used in the I/O Output API to open the resource
+ *
+ * Returns an Output context or NULL in case or error
+ */
+typedef void * (*xmlOutputOpenCallback) (char const *filename);
+/**
+ * xmlOutputWriteCallback:
+ * @context:  an Output context
+ * @buffer:  the buffer of data to write
+ * @len:  the length of the buffer in bytes
+ *
+ * Callback used in the I/O Output API to write to the resource
+ *
+ * Returns the number of bytes written or -1 in case of error
+ */
+typedef int (*xmlOutputWriteCallback) (void * context, const char * buffer,
+                                       int len);
+/**
+ * xmlOutputCloseCallback:
+ * @context:  an Output context
+ *
+ * Callback used in the I/O Output API to close the resource
+ *
+ * Returns 0 or -1 in case of error
+ */
+typedef int (*xmlOutputCloseCallback) (void * context);
+#endif /* LIBXML_OUTPUT_ENABLED */
+
+#ifdef __cplusplus
+}
+#endif
+
+#include <libxml/globals.h>
+#include <libxml/tree.h>
+#include <libxml/parser.h>
+#include <libxml/encoding.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+struct _xmlParserInputBuffer {
+    void*                  context;
+    xmlInputReadCallback   readcallback;
+    xmlInputCloseCallback  closecallback;
+    
+    xmlCharEncodingHandlerPtr encoder; /* I18N conversions to UTF-8 */
+    
+    xmlBufferPtr buffer;    /* Local buffer encoded in UTF-8 */
+    xmlBufferPtr raw;       /* if encoder != NULL buffer for raw input */
+    int	compressed;	    /* -1=unknown, 0=not compressed, 1=compressed */
+    int error;
+    unsigned long rawconsumed;/* amount consumed from raw */
+};
+
+
+#ifdef LIBXML_OUTPUT_ENABLED
+struct _xmlOutputBuffer {
+    void*                   context;
+    xmlOutputWriteCallback  writecallback;
+    xmlOutputCloseCallback  closecallback;
+    
+    xmlCharEncodingHandlerPtr encoder; /* I18N conversions to UTF-8 */
+    
+    xmlBufferPtr buffer;    /* Local buffer encoded in UTF-8 or ISOLatin */
+    xmlBufferPtr conv;      /* if encoder != NULL buffer for output */
+    int written;            /* total number of byte written */
+    int error;
+};
+#endif /* LIBXML_OUTPUT_ENABLED */
+
+/*
+ * Interfaces for input
+ */
+XMLPUBFUN void XMLCALL	
+	xmlCleanupInputCallbacks		(void);
+
+XMLPUBFUN void XMLCALL	
+	xmlRegisterDefaultInputCallbacks	(void);
+XMLPUBFUN xmlParserInputBufferPtr XMLCALL
+	xmlAllocParserInputBuffer		(xmlCharEncoding enc);
+
+XMLPUBFUN xmlParserInputBufferPtr XMLCALL
+	xmlParserInputBufferCreateFilename	(const char *URI,
+                                                 xmlCharEncoding enc);
+XMLPUBFUN xmlParserInputBufferPtr XMLCALL
+	xmlParserInputBufferCreateFile		(FILE *file,
+                                                 xmlCharEncoding enc);
+XMLPUBFUN xmlParserInputBufferPtr XMLCALL
+	xmlParserInputBufferCreateFd		(int fd,
+	                                         xmlCharEncoding enc);
+XMLPUBFUN xmlParserInputBufferPtr XMLCALL
+	xmlParserInputBufferCreateMem		(const char *mem, int size,
+	                                         xmlCharEncoding enc);
+XMLPUBFUN xmlParserInputBufferPtr XMLCALL
+	xmlParserInputBufferCreateStatic	(const char *mem, int size,
+	                                         xmlCharEncoding enc);
+XMLPUBFUN xmlParserInputBufferPtr XMLCALL
+	xmlParserInputBufferCreateIO		(xmlInputReadCallback   ioread,
+						 xmlInputCloseCallback  ioclose,
+						 void *ioctx,
+	                                         xmlCharEncoding enc);
+XMLPUBFUN int XMLCALL	
+	xmlParserInputBufferRead		(xmlParserInputBufferPtr in,
+						 int len);
+XMLPUBFUN int XMLCALL	
+	xmlParserInputBufferGrow		(xmlParserInputBufferPtr in,
+						 int len);
+XMLPUBFUN int XMLCALL	
+	xmlParserInputBufferPush		(xmlParserInputBufferPtr in,
+						 int len,
+						 const char *buf);
+XMLPUBFUN void XMLCALL	
+	xmlFreeParserInputBuffer		(xmlParserInputBufferPtr in);
+XMLPUBFUN char * XMLCALL	
+	xmlParserGetDirectory			(const char *filename);
+
+XMLPUBFUN int XMLCALL     
+	xmlRegisterInputCallbacks		(xmlInputMatchCallback matchFunc,
+						 xmlInputOpenCallback openFunc,
+						 xmlInputReadCallback readFunc,
+						 xmlInputCloseCallback closeFunc);
+#ifdef LIBXML_OUTPUT_ENABLED
+/*
+ * Interfaces for output
+ */
+XMLPUBFUN void XMLCALL	
+	xmlCleanupOutputCallbacks		(void);
+XMLPUBFUN void XMLCALL	
+	xmlRegisterDefaultOutputCallbacks(void);
+XMLPUBFUN xmlOutputBufferPtr XMLCALL
+	xmlAllocOutputBuffer		(xmlCharEncodingHandlerPtr encoder);
+
+XMLPUBFUN xmlOutputBufferPtr XMLCALL
+	xmlOutputBufferCreateFilename	(const char *URI,
+					 xmlCharEncodingHandlerPtr encoder,
+					 int compression);
+
+XMLPUBFUN xmlOutputBufferPtr XMLCALL
+	xmlOutputBufferCreateFile	(FILE *file,
+					 xmlCharEncodingHandlerPtr encoder);
+
+XMLPUBFUN xmlOutputBufferPtr XMLCALL
+	xmlOutputBufferCreateFd		(int fd,
+					 xmlCharEncodingHandlerPtr encoder);
+
+XMLPUBFUN xmlOutputBufferPtr XMLCALL
+	xmlOutputBufferCreateIO		(xmlOutputWriteCallback   iowrite,
+					 xmlOutputCloseCallback  ioclose,
+					 void *ioctx,
+					 xmlCharEncodingHandlerPtr encoder);
+
+XMLPUBFUN int XMLCALL	
+	xmlOutputBufferWrite		(xmlOutputBufferPtr out,
+					 int len,
+					 const char *buf);
+XMLPUBFUN int XMLCALL	
+	xmlOutputBufferWriteString	(xmlOutputBufferPtr out,
+					 const char *str);
+
+XMLPUBFUN int XMLCALL	
+	xmlOutputBufferFlush		(xmlOutputBufferPtr out);
+XMLPUBFUN int XMLCALL	
+	xmlOutputBufferClose		(xmlOutputBufferPtr out);
+
+XMLPUBFUN int XMLCALL     
+	xmlRegisterOutputCallbacks	(xmlOutputMatchCallback matchFunc,
+					 xmlOutputOpenCallback openFunc,
+					 xmlOutputWriteCallback writeFunc,
+					 xmlOutputCloseCallback closeFunc);
+#endif /* LIBXML_OUTPUT_ENABLED */
+
+/*  This function only exists if HTTP support built into the library  */
+#ifdef LIBXML_HTTP_ENABLED
+XMLPUBFUN void * XMLCALL	
+	xmlIOHTTPOpenW			(const char * post_uri,
+					 int   compression );
+XMLPUBFUN void XMLCALL	
+	xmlRegisterHTTPPostCallbacks	(void );
+#endif
+XMLPUBFUN xmlParserInputPtr XMLCALL
+	xmlCheckHTTPInput		(xmlParserCtxtPtr ctxt,
+					 xmlParserInputPtr ret);
+
+/*
+ * A predefined entity loader disabling network accesses
+ */
+XMLPUBFUN xmlParserInputPtr XMLCALL 
+	xmlNoNetExternalEntityLoader	(const char *URL,
+					 const char *ID,
+					 xmlParserCtxtPtr ctxt);
+
+/* 
+ * xmlNormalizeWindowsPath is obsolete, don't use it. 
+ * Check xmlCanonicPath in uri.h for a better alternative.
+ */
+XMLPUBFUN xmlChar * XMLCALL 
+	xmlNormalizeWindowsPath		(const xmlChar *path);
+
+XMLPUBFUN int XMLCALL	
+	xmlCheckFilename		(const char *path);
+/**
+ * Default 'file://' protocol callbacks 
+ */
+XMLPUBFUN int XMLCALL	
+	xmlFileMatch 			(const char *filename);
+XMLPUBFUN void * XMLCALL	
+	xmlFileOpen 			(const char *filename);
+XMLPUBFUN int XMLCALL	
+	xmlFileRead 			(void * context, 
+					 char * buffer, 
+					 int len);
+XMLPUBFUN int XMLCALL	
+	xmlFileClose 			(void * context);
+
+/**
+ * Default 'http://' protocol callbacks 
+ */
+#ifdef LIBXML_HTTP_ENABLED
+XMLPUBFUN int XMLCALL	
+	xmlIOHTTPMatch 			(const char *filename);
+XMLPUBFUN void * XMLCALL	
+	xmlIOHTTPOpen 			(const char *filename);
+XMLPUBFUN int XMLCALL 	
+	xmlIOHTTPRead			(void * context, 
+					 char * buffer, 
+					 int len);
+XMLPUBFUN int XMLCALL	
+	xmlIOHTTPClose 			(void * context);
+#endif /* LIBXML_HTTP_ENABLED */
+
+/**
+ * Default 'ftp://' protocol callbacks 
+ */
+#ifdef LIBXML_FTP_ENABLED 
+XMLPUBFUN int XMLCALL	
+	xmlIOFTPMatch 			(const char *filename);
+XMLPUBFUN void * XMLCALL	
+	xmlIOFTPOpen 			(const char *filename);
+XMLPUBFUN int XMLCALL 	
+	xmlIOFTPRead			(void * context, 
+					 char * buffer, 
+					 int len);
+XMLPUBFUN int XMLCALL 	
+	xmlIOFTPClose 			(void * context);
+#endif /* LIBXML_FTP_ENABLED */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __XML_IO_H__ */
diff --git a/src/libxml/include/libxml/xmlautomata.h b/src/libxml/include/libxml/xmlautomata.h
new file mode 100644
index 0000000..16a1467
--- /dev/null
+++ b/src/libxml/include/libxml/xmlautomata.h
@@ -0,0 +1,117 @@
+/*
+ * Summary: API to build regexp automata
+ * Description: the API to build regexp automata
+ *
+ * Copy: See Copyright for the status of this software.
+ *
+ * Author: Daniel Veillard
+ */
+
+#ifndef __XML_AUTOMATA_H__
+#define __XML_AUTOMATA_H__
+
+#include <libxml/xmlversion.h>
+#include <libxml/tree.h>
+
+#ifdef LIBXML_AUTOMATA_ENABLED
+#include <libxml/xmlregexp.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * xmlAutomataPtr:
+ *
+ * A libxml automata description, It can be compiled into a regexp
+ */
+typedef struct _xmlAutomata xmlAutomata;
+typedef xmlAutomata *xmlAutomataPtr;
+
+/**
+ * xmlAutomataStatePtr:
+ *
+ * A state int the automata description,
+ */
+typedef struct _xmlAutomataState xmlAutomataState;
+typedef xmlAutomataState *xmlAutomataStatePtr;
+
+/*
+ * Building API
+ */
+XMLPUBFUN xmlAutomataPtr XMLCALL		
+		    xmlNewAutomata		(void);
+XMLPUBFUN void XMLCALL			
+		    xmlFreeAutomata		(xmlAutomataPtr am);
+
+XMLPUBFUN xmlAutomataStatePtr XMLCALL	
+		    xmlAutomataGetInitState	(xmlAutomataPtr am);
+XMLPUBFUN int XMLCALL			
+		    xmlAutomataSetFinalState	(xmlAutomataPtr am,
+						 xmlAutomataStatePtr state);
+XMLPUBFUN xmlAutomataStatePtr XMLCALL	
+		    xmlAutomataNewState		(xmlAutomataPtr am);
+XMLPUBFUN xmlAutomataStatePtr XMLCALL	
+		    xmlAutomataNewTransition	(xmlAutomataPtr am,
+						 xmlAutomataStatePtr from,
+						 xmlAutomataStatePtr to,
+						 const xmlChar *token,
+						 void *data);
+XMLPUBFUN xmlAutomataStatePtr XMLCALL	
+		    xmlAutomataNewTransition2	(xmlAutomataPtr am,
+						 xmlAutomataStatePtr from,
+						 xmlAutomataStatePtr to,
+						 const xmlChar *token,
+						 const xmlChar *token2,
+						 void *data);
+XMLPUBFUN xmlAutomataStatePtr XMLCALL	
+		    xmlAutomataNewCountTrans	(xmlAutomataPtr am,
+						 xmlAutomataStatePtr from,
+						 xmlAutomataStatePtr to,
+						 const xmlChar *token,
+						 int min,
+						 int max,
+						 void *data);
+XMLPUBFUN xmlAutomataStatePtr XMLCALL	
+		    xmlAutomataNewOnceTrans	(xmlAutomataPtr am,
+						 xmlAutomataStatePtr from,
+						 xmlAutomataStatePtr to,
+						 const xmlChar *token,
+						 int min,
+						 int max,
+						 void *data);
+XMLPUBFUN xmlAutomataStatePtr XMLCALL	
+		    xmlAutomataNewAllTrans	(xmlAutomataPtr am,
+						 xmlAutomataStatePtr from,
+						 xmlAutomataStatePtr to,
+						 int lax);
+XMLPUBFUN xmlAutomataStatePtr XMLCALL	
+		    xmlAutomataNewEpsilon	(xmlAutomataPtr am,
+						 xmlAutomataStatePtr from,
+						 xmlAutomataStatePtr to);
+XMLPUBFUN xmlAutomataStatePtr XMLCALL	
+		    xmlAutomataNewCountedTrans	(xmlAutomataPtr am,
+						 xmlAutomataStatePtr from,
+						 xmlAutomataStatePtr to,
+						 int counter);
+XMLPUBFUN xmlAutomataStatePtr XMLCALL	
+		    xmlAutomataNewCounterTrans	(xmlAutomataPtr am,
+						 xmlAutomataStatePtr from,
+						 xmlAutomataStatePtr to,
+						 int counter);
+XMLPUBFUN int XMLCALL			
+		    xmlAutomataNewCounter	(xmlAutomataPtr am,
+						 int min,
+						 int max);
+
+XMLPUBFUN xmlRegexpPtr XMLCALL		
+		    xmlAutomataCompile		(xmlAutomataPtr am);
+XMLPUBFUN int XMLCALL	    		
+		    xmlAutomataIsDeterminist	(xmlAutomataPtr am);
+
+#ifdef __cplusplus
+}
+#endif 
+
+#endif /* LIBXML_AUTOMATA_ENABLED */
+#endif /* __XML_AUTOMATA_H__ */
diff --git a/src/libxml/include/libxml/xmlerror.h b/src/libxml/include/libxml/xmlerror.h
new file mode 100644
index 0000000..777cd0d
--- /dev/null
+++ b/src/libxml/include/libxml/xmlerror.h
@@ -0,0 +1,700 @@
+/*
+ * Summary: error handling
+ * Description: the API used to report errors
+ *
+ * Copy: See Copyright for the status of this software.
+ *
+ * Author: Daniel Veillard
+ */
+
+#include <libxml/parser.h>
+
+#ifndef __XML_ERROR_H__
+#define __XML_ERROR_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * xmlErrorLevel:
+ *
+ * Indicates the level of an error
+ */
+typedef enum {
+    XML_ERR_NONE = 0,
+    XML_ERR_WARNING = 1,	/* A simple warning */
+    XML_ERR_ERROR = 2,		/* A recoverable error */
+    XML_ERR_FATAL = 3		/* A fatal error */
+} xmlErrorLevel;
+
+/**
+ * xmlErrorDomain:
+ *
+ * Indicates where an error may have come from
+ */
+typedef enum {
+    XML_FROM_NONE = 0,
+    XML_FROM_PARSER,	/* The XML parser */
+    XML_FROM_TREE,	/* The tree module */
+    XML_FROM_NAMESPACE,	/* The XML Namespace module */
+    XML_FROM_DTD,	/* The XML DTD validation with parser context*/
+    XML_FROM_HTML,	/* The HTML parser */
+    XML_FROM_MEMORY,	/* The memory allocator */
+    XML_FROM_OUTPUT,	/* The serialization code */
+    XML_FROM_IO,	/* The Input/Output stack */
+    XML_FROM_FTP,	/* The FTP module */
+    XML_FROM_HTTP,	/* The FTP module */
+    XML_FROM_XINCLUDE,	/* The XInclude processing */
+    XML_FROM_XPATH,	/* The XPath module */
+    XML_FROM_XPOINTER,	/* The XPointer module */
+    XML_FROM_REGEXP,	/* The regular expressions module */
+    XML_FROM_DATATYPE,	/* The W3C XML Schemas Datatype module */
+    XML_FROM_SCHEMASP,	/* The W3C XML Schemas parser module */
+    XML_FROM_SCHEMASV,	/* The W3C XML Schemas validation module */
+    XML_FROM_RELAXNGP,	/* The Relax-NG parser module */
+    XML_FROM_RELAXNGV,	/* The Relax-NG validator module */
+    XML_FROM_CATALOG,	/* The Catalog module */
+    XML_FROM_C14N,	/* The Canonicalization module */
+    XML_FROM_XSLT,	/* The XSLT engine from libxslt */
+    XML_FROM_VALID	/* The XML DTD validation with valid context */
+} xmlErrorDomain;
+
+/**
+ * xmlError:
+ *
+ * An XML Error instance.
+ */
+
+typedef struct _xmlError xmlError;
+typedef xmlError *xmlErrorPtr;
+struct _xmlError {
+    int		domain;	/* What part of the library raised this error */
+    int		code;	/* The error code, e.g. an xmlParserError */
+    char       *message;/* human-readable informative error message */
+    xmlErrorLevel level;/* how consequent is the error */
+    char       *file;	/* the filename */
+    int		line;	/* the line number if available */
+    char       *str1;	/* extra string information */
+    char       *str2;	/* extra string information */
+    char       *str3;	/* extra string information */
+    int		int1;	/* extra number information */
+    int		int2;	/* extra number information */
+    void       *ctxt;   /* the parser context if available */
+    void       *node;   /* the node in the tree */
+};
+
+/**
+ * xmlParserError:
+ *
+ * This is an error that the XML (or HTML) parser can generate
+ */
+typedef enum {
+    XML_ERR_OK = 0,
+    XML_ERR_INTERNAL_ERROR, /* 1 */
+    XML_ERR_NO_MEMORY, /* 2 */
+    XML_ERR_DOCUMENT_START, /* 3 */
+    XML_ERR_DOCUMENT_EMPTY, /* 4 */
+    XML_ERR_DOCUMENT_END, /* 5 */
+    XML_ERR_INVALID_HEX_CHARREF, /* 6 */
+    XML_ERR_INVALID_DEC_CHARREF, /* 7 */
+    XML_ERR_INVALID_CHARREF, /* 8 */
+    XML_ERR_INVALID_CHAR, /* 9 */
+    XML_ERR_CHARREF_AT_EOF, /* 10 */
+    XML_ERR_CHARREF_IN_PROLOG, /* 11 */
+    XML_ERR_CHARREF_IN_EPILOG, /* 12 */
+    XML_ERR_CHARREF_IN_DTD, /* 13 */
+    XML_ERR_ENTITYREF_AT_EOF, /* 14 */
+    XML_ERR_ENTITYREF_IN_PROLOG, /* 15 */
+    XML_ERR_ENTITYREF_IN_EPILOG, /* 16 */
+    XML_ERR_ENTITYREF_IN_DTD, /* 17 */
+    XML_ERR_PEREF_AT_EOF, /* 18 */
+    XML_ERR_PEREF_IN_PROLOG, /* 19 */
+    XML_ERR_PEREF_IN_EPILOG, /* 20 */
+    XML_ERR_PEREF_IN_INT_SUBSET, /* 21 */
+    XML_ERR_ENTITYREF_NO_NAME, /* 22 */
+    XML_ERR_ENTITYREF_SEMICOL_MISSING, /* 23 */
+    XML_ERR_PEREF_NO_NAME, /* 24 */
+    XML_ERR_PEREF_SEMICOL_MISSING, /* 25 */
+    XML_ERR_UNDECLARED_ENTITY, /* 26 */
+    XML_WAR_UNDECLARED_ENTITY, /* 27 */
+    XML_ERR_UNPARSED_ENTITY, /* 28 */
+    XML_ERR_ENTITY_IS_EXTERNAL, /* 29 */
+    XML_ERR_ENTITY_IS_PARAMETER, /* 30 */
+    XML_ERR_UNKNOWN_ENCODING, /* 31 */
+    XML_ERR_UNSUPPORTED_ENCODING, /* 32 */
+    XML_ERR_STRING_NOT_STARTED, /* 33 */
+    XML_ERR_STRING_NOT_CLOSED, /* 34 */
+    XML_ERR_NS_DECL_ERROR, /* 35 */
+    XML_ERR_ENTITY_NOT_STARTED, /* 36 */
+    XML_ERR_ENTITY_NOT_FINISHED, /* 37 */
+    XML_ERR_LT_IN_ATTRIBUTE, /* 38 */
+    XML_ERR_ATTRIBUTE_NOT_STARTED, /* 39 */
+    XML_ERR_ATTRIBUTE_NOT_FINISHED, /* 40 */
+    XML_ERR_ATTRIBUTE_WITHOUT_VALUE, /* 41 */
+    XML_ERR_ATTRIBUTE_REDEFINED, /* 42 */
+    XML_ERR_LITERAL_NOT_STARTED, /* 43 */
+    XML_ERR_LITERAL_NOT_FINISHED, /* 44 */
+    XML_ERR_COMMENT_NOT_FINISHED, /* 45 */
+    XML_ERR_PI_NOT_STARTED, /* 46 */
+    XML_ERR_PI_NOT_FINISHED, /* 47 */
+    XML_ERR_NOTATION_NOT_STARTED, /* 48 */
+    XML_ERR_NOTATION_NOT_FINISHED, /* 49 */
+    XML_ERR_ATTLIST_NOT_STARTED, /* 50 */
+    XML_ERR_ATTLIST_NOT_FINISHED, /* 51 */
+    XML_ERR_MIXED_NOT_STARTED, /* 52 */
+    XML_ERR_MIXED_NOT_FINISHED, /* 53 */
+    XML_ERR_ELEMCONTENT_NOT_STARTED, /* 54 */
+    XML_ERR_ELEMCONTENT_NOT_FINISHED, /* 55 */
+    XML_ERR_XMLDECL_NOT_STARTED, /* 56 */
+    XML_ERR_XMLDECL_NOT_FINISHED, /* 57 */
+    XML_ERR_CONDSEC_NOT_STARTED, /* 58 */
+    XML_ERR_CONDSEC_NOT_FINISHED, /* 59 */
+    XML_ERR_EXT_SUBSET_NOT_FINISHED, /* 60 */
+    XML_ERR_DOCTYPE_NOT_FINISHED, /* 61 */
+    XML_ERR_MISPLACED_CDATA_END, /* 62 */
+    XML_ERR_CDATA_NOT_FINISHED, /* 63 */
+    XML_ERR_RESERVED_XML_NAME, /* 64 */
+    XML_ERR_SPACE_REQUIRED, /* 65 */
+    XML_ERR_SEPARATOR_REQUIRED, /* 66 */
+    XML_ERR_NMTOKEN_REQUIRED, /* 67 */
+    XML_ERR_NAME_REQUIRED, /* 68 */
+    XML_ERR_PCDATA_REQUIRED, /* 69 */
+    XML_ERR_URI_REQUIRED, /* 70 */
+    XML_ERR_PUBID_REQUIRED, /* 71 */
+    XML_ERR_LT_REQUIRED, /* 72 */
+    XML_ERR_GT_REQUIRED, /* 73 */
+    XML_ERR_LTSLASH_REQUIRED, /* 74 */
+    XML_ERR_EQUAL_REQUIRED, /* 75 */
+    XML_ERR_TAG_NAME_MISMATCH, /* 76 */
+    XML_ERR_TAG_NOT_FINISHED, /* 77 */
+    XML_ERR_STANDALONE_VALUE, /* 78 */
+    XML_ERR_ENCODING_NAME, /* 79 */
+    XML_ERR_HYPHEN_IN_COMMENT, /* 80 */
+    XML_ERR_INVALID_ENCODING, /* 81 */
+    XML_ERR_EXT_ENTITY_STANDALONE, /* 82 */
+    XML_ERR_CONDSEC_INVALID, /* 83 */
+    XML_ERR_VALUE_REQUIRED, /* 84 */
+    XML_ERR_NOT_WELL_BALANCED, /* 85 */
+    XML_ERR_EXTRA_CONTENT, /* 86 */
+    XML_ERR_ENTITY_CHAR_ERROR, /* 87 */
+    XML_ERR_ENTITY_PE_INTERNAL, /* 88 */
+    XML_ERR_ENTITY_LOOP, /* 89 */
+    XML_ERR_ENTITY_BOUNDARY, /* 90 */
+    XML_ERR_INVALID_URI, /* 91 */
+    XML_ERR_URI_FRAGMENT, /* 92 */
+    XML_WAR_CATALOG_PI, /* 93 */
+    XML_ERR_NO_DTD, /* 94 */
+    XML_ERR_CONDSEC_INVALID_KEYWORD, /* 95 */
+    XML_ERR_VERSION_MISSING, /* 96 */
+    XML_WAR_UNKNOWN_VERSION, /* 97 */
+    XML_WAR_LANG_VALUE, /* 98 */
+    XML_WAR_NS_URI, /* 99 */
+    XML_WAR_NS_URI_RELATIVE, /* 100 */
+    XML_ERR_MISSING_ENCODING, /* 101 */
+    XML_NS_ERR_XML_NAMESPACE = 200,
+    XML_NS_ERR_UNDEFINED_NAMESPACE, /* 201 */
+    XML_NS_ERR_QNAME, /* 202 */
+    XML_NS_ERR_ATTRIBUTE_REDEFINED, /* 203 */
+    XML_DTD_ATTRIBUTE_DEFAULT = 500,
+    XML_DTD_ATTRIBUTE_REDEFINED, /* 501 */
+    XML_DTD_ATTRIBUTE_VALUE, /* 502 */
+    XML_DTD_CONTENT_ERROR, /* 503 */
+    XML_DTD_CONTENT_MODEL, /* 504 */
+    XML_DTD_CONTENT_NOT_DETERMINIST, /* 505 */
+    XML_DTD_DIFFERENT_PREFIX, /* 506 */
+    XML_DTD_ELEM_DEFAULT_NAMESPACE, /* 507 */
+    XML_DTD_ELEM_NAMESPACE, /* 508 */
+    XML_DTD_ELEM_REDEFINED, /* 509 */
+    XML_DTD_EMPTY_NOTATION, /* 510 */
+    XML_DTD_ENTITY_TYPE, /* 511 */
+    XML_DTD_ID_FIXED, /* 512 */
+    XML_DTD_ID_REDEFINED, /* 513 */
+    XML_DTD_ID_SUBSET, /* 514 */
+    XML_DTD_INVALID_CHILD, /* 515 */
+    XML_DTD_INVALID_DEFAULT, /* 516 */
+    XML_DTD_LOAD_ERROR, /* 517 */
+    XML_DTD_MISSING_ATTRIBUTE, /* 518 */
+    XML_DTD_MIXED_CORRUPT, /* 519 */
+    XML_DTD_MULTIPLE_ID, /* 520 */
+    XML_DTD_NO_DOC, /* 521 */
+    XML_DTD_NO_DTD, /* 522 */
+    XML_DTD_NO_ELEM_NAME, /* 523 */
+    XML_DTD_NO_PREFIX, /* 524 */
+    XML_DTD_NO_ROOT, /* 525 */
+    XML_DTD_NOTATION_REDEFINED, /* 526 */
+    XML_DTD_NOTATION_VALUE, /* 527 */
+    XML_DTD_NOT_EMPTY, /* 528 */
+    XML_DTD_NOT_PCDATA, /* 529 */
+    XML_DTD_NOT_STANDALONE, /* 530 */
+    XML_DTD_ROOT_NAME, /* 531 */
+    XML_DTD_STANDALONE_WHITE_SPACE, /* 532 */
+    XML_DTD_UNKNOWN_ATTRIBUTE, /* 533 */
+    XML_DTD_UNKNOWN_ELEM, /* 534 */
+    XML_DTD_UNKNOWN_ENTITY, /* 535 */
+    XML_DTD_UNKNOWN_ID, /* 536 */
+    XML_DTD_UNKNOWN_NOTATION, /* 537 */
+    XML_DTD_STANDALONE_DEFAULTED, /* 538 */
+    XML_DTD_XMLID_VALUE, /* 539 */
+    XML_DTD_XMLID_TYPE, /* 540 */
+    XML_HTML_STRUCURE_ERROR = 800,
+    XML_HTML_UNKNOWN_TAG, /* 801 */
+    XML_RNGP_ANYNAME_ATTR_ANCESTOR = 1000,
+    XML_RNGP_ATTR_CONFLICT, /* 1001 */
+    XML_RNGP_ATTRIBUTE_CHILDREN, /* 1002 */
+    XML_RNGP_ATTRIBUTE_CONTENT, /* 1003 */
+    XML_RNGP_ATTRIBUTE_EMPTY, /* 1004 */
+    XML_RNGP_ATTRIBUTE_NOOP, /* 1005 */
+    XML_RNGP_CHOICE_CONTENT, /* 1006 */
+    XML_RNGP_CHOICE_EMPTY, /* 1007 */
+    XML_RNGP_CREATE_FAILURE, /* 1008 */
+    XML_RNGP_DATA_CONTENT, /* 1009 */
+    XML_RNGP_DEF_CHOICE_AND_INTERLEAVE, /* 1010 */
+    XML_RNGP_DEFINE_CREATE_FAILED, /* 1011 */
+    XML_RNGP_DEFINE_EMPTY, /* 1012 */
+    XML_RNGP_DEFINE_MISSING, /* 1013 */
+    XML_RNGP_DEFINE_NAME_MISSING, /* 1014 */
+    XML_RNGP_ELEM_CONTENT_EMPTY, /* 1015 */
+    XML_RNGP_ELEM_CONTENT_ERROR, /* 1016 */
+    XML_RNGP_ELEMENT_EMPTY, /* 1017 */
+    XML_RNGP_ELEMENT_CONTENT, /* 1018 */
+    XML_RNGP_ELEMENT_NAME, /* 1019 */
+    XML_RNGP_ELEMENT_NO_CONTENT, /* 1020 */
+    XML_RNGP_ELEM_TEXT_CONFLICT, /* 1021 */
+    XML_RNGP_EMPTY, /* 1022 */
+    XML_RNGP_EMPTY_CONSTRUCT, /* 1023 */
+    XML_RNGP_EMPTY_CONTENT, /* 1024 */
+    XML_RNGP_EMPTY_NOT_EMPTY, /* 1025 */
+    XML_RNGP_ERROR_TYPE_LIB, /* 1026 */
+    XML_RNGP_EXCEPT_EMPTY, /* 1027 */
+    XML_RNGP_EXCEPT_MISSING, /* 1028 */
+    XML_RNGP_EXCEPT_MULTIPLE, /* 1029 */
+    XML_RNGP_EXCEPT_NO_CONTENT, /* 1030 */
+    XML_RNGP_EXTERNALREF_EMTPY, /* 1031 */
+    XML_RNGP_EXTERNAL_REF_FAILURE, /* 1032 */
+    XML_RNGP_EXTERNALREF_RECURSE, /* 1033 */
+    XML_RNGP_FORBIDDEN_ATTRIBUTE, /* 1034 */
+    XML_RNGP_FOREIGN_ELEMENT, /* 1035 */
+    XML_RNGP_GRAMMAR_CONTENT, /* 1036 */
+    XML_RNGP_GRAMMAR_EMPTY, /* 1037 */
+    XML_RNGP_GRAMMAR_MISSING, /* 1038 */
+    XML_RNGP_GRAMMAR_NO_START, /* 1039 */
+    XML_RNGP_GROUP_ATTR_CONFLICT, /* 1040 */
+    XML_RNGP_HREF_ERROR, /* 1041 */
+    XML_RNGP_INCLUDE_EMPTY, /* 1042 */
+    XML_RNGP_INCLUDE_FAILURE, /* 1043 */
+    XML_RNGP_INCLUDE_RECURSE, /* 1044 */
+    XML_RNGP_INTERLEAVE_ADD, /* 1045 */
+    XML_RNGP_INTERLEAVE_CREATE_FAILED, /* 1046 */
+    XML_RNGP_INTERLEAVE_EMPTY, /* 1047 */
+    XML_RNGP_INTERLEAVE_NO_CONTENT, /* 1048 */
+    XML_RNGP_INVALID_DEFINE_NAME, /* 1049 */
+    XML_RNGP_INVALID_URI, /* 1050 */
+    XML_RNGP_INVALID_VALUE, /* 1051 */
+    XML_RNGP_MISSING_HREF, /* 1052 */
+    XML_RNGP_NAME_MISSING, /* 1053 */
+    XML_RNGP_NEED_COMBINE, /* 1054 */
+    XML_RNGP_NOTALLOWED_NOT_EMPTY, /* 1055 */
+    XML_RNGP_NSNAME_ATTR_ANCESTOR, /* 1056 */
+    XML_RNGP_NSNAME_NO_NS, /* 1057 */
+    XML_RNGP_PARAM_FORBIDDEN, /* 1058 */
+    XML_RNGP_PARAM_NAME_MISSING, /* 1059 */
+    XML_RNGP_PARENTREF_CREATE_FAILED, /* 1060 */
+    XML_RNGP_PARENTREF_NAME_INVALID, /* 1061 */
+    XML_RNGP_PARENTREF_NO_NAME, /* 1062 */
+    XML_RNGP_PARENTREF_NO_PARENT, /* 1063 */
+    XML_RNGP_PARENTREF_NOT_EMPTY, /* 1064 */
+    XML_RNGP_PARSE_ERROR, /* 1065 */
+    XML_RNGP_PAT_ANYNAME_EXCEPT_ANYNAME, /* 1066 */
+    XML_RNGP_PAT_ATTR_ATTR, /* 1067 */
+    XML_RNGP_PAT_ATTR_ELEM, /* 1068 */
+    XML_RNGP_PAT_DATA_EXCEPT_ATTR, /* 1069 */
+    XML_RNGP_PAT_DATA_EXCEPT_ELEM, /* 1070 */
+    XML_RNGP_PAT_DATA_EXCEPT_EMPTY, /* 1071 */
+    XML_RNGP_PAT_DATA_EXCEPT_GROUP, /* 1072 */
+    XML_RNGP_PAT_DATA_EXCEPT_INTERLEAVE, /* 1073 */
+    XML_RNGP_PAT_DATA_EXCEPT_LIST, /* 1074 */
+    XML_RNGP_PAT_DATA_EXCEPT_ONEMORE, /* 1075 */
+    XML_RNGP_PAT_DATA_EXCEPT_REF, /* 1076 */
+    XML_RNGP_PAT_DATA_EXCEPT_TEXT, /* 1077 */
+    XML_RNGP_PAT_LIST_ATTR, /* 1078 */
+    XML_RNGP_PAT_LIST_ELEM, /* 1079 */
+    XML_RNGP_PAT_LIST_INTERLEAVE, /* 1080 */
+    XML_RNGP_PAT_LIST_LIST, /* 1081 */
+    XML_RNGP_PAT_LIST_REF, /* 1082 */
+    XML_RNGP_PAT_LIST_TEXT, /* 1083 */
+    XML_RNGP_PAT_NSNAME_EXCEPT_ANYNAME, /* 1084 */
+    XML_RNGP_PAT_NSNAME_EXCEPT_NSNAME, /* 1085 */
+    XML_RNGP_PAT_ONEMORE_GROUP_ATTR, /* 1086 */
+    XML_RNGP_PAT_ONEMORE_INTERLEAVE_ATTR, /* 1087 */
+    XML_RNGP_PAT_START_ATTR, /* 1088 */
+    XML_RNGP_PAT_START_DATA, /* 1089 */
+    XML_RNGP_PAT_START_EMPTY, /* 1090 */
+    XML_RNGP_PAT_START_GROUP, /* 1091 */
+    XML_RNGP_PAT_START_INTERLEAVE, /* 1092 */
+    XML_RNGP_PAT_START_LIST, /* 1093 */
+    XML_RNGP_PAT_START_ONEMORE, /* 1094 */
+    XML_RNGP_PAT_START_TEXT, /* 1095 */
+    XML_RNGP_PAT_START_VALUE, /* 1096 */
+    XML_RNGP_PREFIX_UNDEFINED, /* 1097 */
+    XML_RNGP_REF_CREATE_FAILED, /* 1098 */
+    XML_RNGP_REF_CYCLE, /* 1099 */
+    XML_RNGP_REF_NAME_INVALID, /* 1100 */
+    XML_RNGP_REF_NO_DEF, /* 1101 */
+    XML_RNGP_REF_NO_NAME, /* 1102 */
+    XML_RNGP_REF_NOT_EMPTY, /* 1103 */
+    XML_RNGP_START_CHOICE_AND_INTERLEAVE, /* 1104 */
+    XML_RNGP_START_CONTENT, /* 1105 */
+    XML_RNGP_START_EMPTY, /* 1106 */
+    XML_RNGP_START_MISSING, /* 1107 */
+    XML_RNGP_TEXT_EXPECTED, /* 1108 */
+    XML_RNGP_TEXT_HAS_CHILD, /* 1109 */
+    XML_RNGP_TYPE_MISSING, /* 1110 */
+    XML_RNGP_TYPE_NOT_FOUND, /* 1111 */
+    XML_RNGP_TYPE_VALUE, /* 1112 */
+    XML_RNGP_UNKNOWN_ATTRIBUTE, /* 1113 */
+    XML_RNGP_UNKNOWN_COMBINE, /* 1114 */
+    XML_RNGP_UNKNOWN_CONSTRUCT, /* 1115 */
+    XML_RNGP_UNKNOWN_TYPE_LIB, /* 1116 */
+    XML_RNGP_URI_FRAGMENT, /* 1117 */
+    XML_RNGP_URI_NOT_ABSOLUTE, /* 1118 */
+    XML_RNGP_VALUE_EMPTY, /* 1119 */
+    XML_RNGP_VALUE_NO_CONTENT, /* 1120 */
+    XML_RNGP_XMLNS_NAME, /* 1121 */
+    XML_RNGP_XML_NS, /* 1122 */
+    XML_XPATH_EXPRESSION_OK = 1200,
+    XML_XPATH_NUMBER_ERROR, /* 1201 */
+    XML_XPATH_UNFINISHED_LITERAL_ERROR, /* 1202 */
+    XML_XPATH_START_LITERAL_ERROR, /* 1203 */
+    XML_XPATH_VARIABLE_REF_ERROR, /* 1204 */
+    XML_XPATH_UNDEF_VARIABLE_ERROR, /* 1205 */
+    XML_XPATH_INVALID_PREDICATE_ERROR, /* 1206 */
+    XML_XPATH_EXPR_ERROR, /* 1207 */
+    XML_XPATH_UNCLOSED_ERROR, /* 1208 */
+    XML_XPATH_UNKNOWN_FUNC_ERROR, /* 1209 */
+    XML_XPATH_INVALID_OPERAND, /* 1210 */
+    XML_XPATH_INVALID_TYPE, /* 1211 */
+    XML_XPATH_INVALID_ARITY, /* 1212 */
+    XML_XPATH_INVALID_CTXT_SIZE, /* 1213 */
+    XML_XPATH_INVALID_CTXT_POSITION, /* 1214 */
+    XML_XPATH_MEMORY_ERROR, /* 1215 */
+    XML_XPTR_SYNTAX_ERROR, /* 1216 */
+    XML_XPTR_RESOURCE_ERROR, /* 1217 */
+    XML_XPTR_SUB_RESOURCE_ERROR, /* 1218 */
+    XML_XPATH_UNDEF_PREFIX_ERROR, /* 1219 */
+    XML_XPATH_ENCODING_ERROR, /* 1220 */
+    XML_XPATH_INVALID_CHAR_ERROR, /* 1221 */
+    XML_TREE_INVALID_HEX = 1300,
+    XML_TREE_INVALID_DEC, /* 1301 */
+    XML_TREE_UNTERMINATED_ENTITY, /* 1302 */
+    XML_SAVE_NOT_UTF8 = 1400,
+    XML_SAVE_CHAR_INVALID, /* 1401 */
+    XML_SAVE_NO_DOCTYPE, /* 1402 */
+    XML_SAVE_UNKNOWN_ENCODING, /* 1403 */
+    XML_REGEXP_COMPILE_ERROR = 1450,
+    XML_IO_UNKNOWN = 1500,
+    XML_IO_EACCES, /* 1501 */
+    XML_IO_EAGAIN, /* 1502 */
+    XML_IO_EBADF, /* 1503 */
+    XML_IO_EBADMSG, /* 1504 */
+    XML_IO_EBUSY, /* 1505 */
+    XML_IO_ECANCELED, /* 1506 */
+    XML_IO_ECHILD, /* 1507 */
+    XML_IO_EDEADLK, /* 1508 */
+    XML_IO_EDOM, /* 1509 */
+    XML_IO_EEXIST, /* 1510 */
+    XML_IO_EFAULT, /* 1511 */
+    XML_IO_EFBIG, /* 1512 */
+    XML_IO_EINPROGRESS, /* 1513 */
+    XML_IO_EINTR, /* 1514 */
+    XML_IO_EINVAL, /* 1515 */
+    XML_IO_EIO, /* 1516 */
+    XML_IO_EISDIR, /* 1517 */
+    XML_IO_EMFILE, /* 1518 */
+    XML_IO_EMLINK, /* 1519 */
+    XML_IO_EMSGSIZE, /* 1520 */
+    XML_IO_ENAMETOOLONG, /* 1521 */
+    XML_IO_ENFILE, /* 1522 */
+    XML_IO_ENODEV, /* 1523 */
+    XML_IO_ENOENT, /* 1524 */
+    XML_IO_ENOEXEC, /* 1525 */
+    XML_IO_ENOLCK, /* 1526 */
+    XML_IO_ENOMEM, /* 1527 */
+    XML_IO_ENOSPC, /* 1528 */
+    XML_IO_ENOSYS, /* 1529 */
+    XML_IO_ENOTDIR, /* 1530 */
+    XML_IO_ENOTEMPTY, /* 1531 */
+    XML_IO_ENOTSUP, /* 1532 */
+    XML_IO_ENOTTY, /* 1533 */
+    XML_IO_ENXIO, /* 1534 */
+    XML_IO_EPERM, /* 1535 */
+    XML_IO_EPIPE, /* 1536 */
+    XML_IO_ERANGE, /* 1537 */
+    XML_IO_EROFS, /* 1538 */
+    XML_IO_ESPIPE, /* 1539 */
+    XML_IO_ESRCH, /* 1540 */
+    XML_IO_ETIMEDOUT, /* 1541 */
+    XML_IO_EXDEV, /* 1542 */
+    XML_IO_NETWORK_ATTEMPT, /* 1543 */
+    XML_IO_ENCODER, /* 1544 */
+    XML_IO_FLUSH, /* 1545 */
+    XML_IO_WRITE, /* 1546 */
+    XML_IO_NO_INPUT, /* 1547 */
+    XML_IO_BUFFER_FULL, /* 1548 */
+    XML_IO_LOAD_ERROR, /* 1549 */
+    XML_IO_ENOTSOCK, /* 1550 */
+    XML_IO_EISCONN, /* 1551 */
+    XML_IO_ECONNREFUSED, /* 1552 */
+    XML_IO_ENETUNREACH, /* 1553 */
+    XML_IO_EADDRINUSE, /* 1554 */
+    XML_IO_EALREADY, /* 1555 */
+    XML_IO_EAFNOSUPPORT, /* 1556 */
+    XML_XINCLUDE_RECURSION=1600,
+    XML_XINCLUDE_PARSE_VALUE, /* 1601 */
+    XML_XINCLUDE_ENTITY_DEF_MISMATCH, /* 1602 */
+    XML_XINCLUDE_NO_HREF, /* 1603 */
+    XML_XINCLUDE_NO_FALLBACK, /* 1604 */
+    XML_XINCLUDE_HREF_URI, /* 1605 */
+    XML_XINCLUDE_TEXT_FRAGMENT, /* 1606 */
+    XML_XINCLUDE_TEXT_DOCUMENT, /* 1607 */
+    XML_XINCLUDE_INVALID_CHAR, /* 1608 */
+    XML_XINCLUDE_BUILD_FAILED, /* 1609 */
+    XML_XINCLUDE_UNKNOWN_ENCODING, /* 1610 */
+    XML_XINCLUDE_MULTIPLE_ROOT, /* 1611 */
+    XML_XINCLUDE_XPTR_FAILED, /* 1612 */
+    XML_XINCLUDE_XPTR_RESULT, /* 1613 */
+    XML_XINCLUDE_INCLUDE_IN_INCLUDE, /* 1614 */
+    XML_XINCLUDE_FALLBACKS_IN_INCLUDE, /* 1615 */
+    XML_XINCLUDE_FALLBACK_NOT_IN_INCLUDE, /* 1616 */
+    XML_XINCLUDE_DEPRECATED_NS, /* 1617 */
+    XML_XINCLUDE_FRAGMENT_ID, /* 1618 */
+    XML_CATALOG_MISSING_ATTR = 1650,
+    XML_CATALOG_ENTRY_BROKEN, /* 1651 */
+    XML_CATALOG_PREFER_VALUE, /* 1652 */
+    XML_CATALOG_NOT_CATALOG, /* 1653 */
+    XML_CATALOG_RECURSION, /* 1654 */
+    XML_SCHEMAP_PREFIX_UNDEFINED = 1700,
+    XML_SCHEMAP_ATTRFORMDEFAULT_VALUE, /* 1701 */
+    XML_SCHEMAP_ATTRGRP_NONAME_NOREF, /* 1702 */
+    XML_SCHEMAP_ATTR_NONAME_NOREF, /* 1703 */
+    XML_SCHEMAP_COMPLEXTYPE_NONAME_NOREF, /* 1704 */
+    XML_SCHEMAP_ELEMFORMDEFAULT_VALUE, /* 1705 */
+    XML_SCHEMAP_ELEM_NONAME_NOREF, /* 1706 */
+    XML_SCHEMAP_EXTENSION_NO_BASE, /* 1707 */
+    XML_SCHEMAP_FACET_NO_VALUE, /* 1708 */
+    XML_SCHEMAP_FAILED_BUILD_IMPORT, /* 1709 */
+    XML_SCHEMAP_GROUP_NONAME_NOREF, /* 1710 */
+    XML_SCHEMAP_IMPORT_NAMESPACE_NOT_URI, /* 1711 */
+    XML_SCHEMAP_IMPORT_REDEFINE_NSNAME, /* 1712 */
+    XML_SCHEMAP_IMPORT_SCHEMA_NOT_URI, /* 1713 */
+    XML_SCHEMAP_INVALID_BOOLEAN, /* 1714 */
+    XML_SCHEMAP_INVALID_ENUM, /* 1715 */
+    XML_SCHEMAP_INVALID_FACET, /* 1716 */
+    XML_SCHEMAP_INVALID_FACET_VALUE, /* 1717 */
+    XML_SCHEMAP_INVALID_MAXOCCURS, /* 1718 */
+    XML_SCHEMAP_INVALID_MINOCCURS, /* 1719 */
+    XML_SCHEMAP_INVALID_REF_AND_SUBTYPE, /* 1720 */
+    XML_SCHEMAP_INVALID_WHITE_SPACE, /* 1721 */
+    XML_SCHEMAP_NOATTR_NOREF, /* 1722 */
+    XML_SCHEMAP_NOTATION_NO_NAME, /* 1723 */
+    XML_SCHEMAP_NOTYPE_NOREF, /* 1724 */
+    XML_SCHEMAP_REF_AND_SUBTYPE, /* 1725 */
+    XML_SCHEMAP_RESTRICTION_NONAME_NOREF, /* 1726 */
+    XML_SCHEMAP_SIMPLETYPE_NONAME, /* 1727 */
+    XML_SCHEMAP_TYPE_AND_SUBTYPE, /* 1728 */
+    XML_SCHEMAP_UNKNOWN_ALL_CHILD, /* 1729 */
+    XML_SCHEMAP_UNKNOWN_ANYATTRIBUTE_CHILD, /* 1730 */
+    XML_SCHEMAP_UNKNOWN_ATTR_CHILD, /* 1731 */
+    XML_SCHEMAP_UNKNOWN_ATTRGRP_CHILD, /* 1732 */
+    XML_SCHEMAP_UNKNOWN_ATTRIBUTE_GROUP, /* 1733 */
+    XML_SCHEMAP_UNKNOWN_BASE_TYPE, /* 1734 */
+    XML_SCHEMAP_UNKNOWN_CHOICE_CHILD, /* 1735 */
+    XML_SCHEMAP_UNKNOWN_COMPLEXCONTENT_CHILD, /* 1736 */
+    XML_SCHEMAP_UNKNOWN_COMPLEXTYPE_CHILD, /* 1737 */
+    XML_SCHEMAP_UNKNOWN_ELEM_CHILD, /* 1738 */
+    XML_SCHEMAP_UNKNOWN_EXTENSION_CHILD, /* 1739 */
+    XML_SCHEMAP_UNKNOWN_FACET_CHILD, /* 1740 */
+    XML_SCHEMAP_UNKNOWN_FACET_TYPE, /* 1741 */
+    XML_SCHEMAP_UNKNOWN_GROUP_CHILD, /* 1742 */
+    XML_SCHEMAP_UNKNOWN_IMPORT_CHILD, /* 1743 */
+    XML_SCHEMAP_UNKNOWN_LIST_CHILD, /* 1744 */
+    XML_SCHEMAP_UNKNOWN_NOTATION_CHILD, /* 1745 */
+    XML_SCHEMAP_UNKNOWN_PROCESSCONTENT_CHILD, /* 1746 */
+    XML_SCHEMAP_UNKNOWN_REF, /* 1747 */
+    XML_SCHEMAP_UNKNOWN_RESTRICTION_CHILD, /* 1748 */
+    XML_SCHEMAP_UNKNOWN_SCHEMAS_CHILD, /* 1749 */
+    XML_SCHEMAP_UNKNOWN_SEQUENCE_CHILD, /* 1750 */
+    XML_SCHEMAP_UNKNOWN_SIMPLECONTENT_CHILD, /* 1751 */
+    XML_SCHEMAP_UNKNOWN_SIMPLETYPE_CHILD, /* 1752 */
+    XML_SCHEMAP_UNKNOWN_TYPE, /* 1753 */
+    XML_SCHEMAP_UNKNOWN_UNION_CHILD, /* 1754 */
+    XML_SCHEMAP_ELEM_DEFAULT_FIXED, /* 1755 */
+    XML_SCHEMAP_REGEXP_INVALID, /* 1756 */
+    XML_SCHEMAP_FAILED_LOAD, /* 1756 */
+    XML_SCHEMAP_NOTHING_TO_PARSE, /* 1757 */
+    XML_SCHEMAP_NOROOT, /* 1758 */
+    XML_SCHEMAP_REDEFINED_GROUP, /* 1759 */
+    XML_SCHEMAP_REDEFINED_TYPE, /* 1760 */
+    XML_SCHEMAP_REDEFINED_ELEMENT, /* 1761 */
+    XML_SCHEMAP_REDEFINED_ATTRGROUP, /* 1762 */
+    XML_SCHEMAP_REDEFINED_ATTR, /* 1763 */
+    XML_SCHEMAP_REDEFINED_NOTATION, /* 1764 */
+    XML_SCHEMAP_FAILED_PARSE, /* 1765 */
+    XML_SCHEMAP_UNKNOWN_PREFIX, /* 1766 */
+    XML_SCHEMAP_DEF_AND_PREFIX, /* 1767 */
+    XML_SCHEMAP_UNKNOWN_INCLUDE_CHILD, /* 1768 */
+    XML_SCHEMAP_INCLUDE_SCHEMA_NOT_URI, /* 1769 */
+    XML_SCHEMAP_INCLUDE_SCHEMA_NO_URI, /* 1770 */
+    XML_SCHEMAP_NOT_SCHEMA, /* 1771 */
+    XML_SCHEMAP_UNKNOWN_MEMBER_TYPE, /* 1772 */
+    XML_SCHEMAP_INVALID_ATTR_USE, /* 1723 */
+    XML_SCHEMAP_RECURSIVE, /* 1724 */
+    XML_SCHEMAV_NOROOT = 1800,
+    XML_SCHEMAV_UNDECLAREDELEM, /* 1801 */
+    XML_SCHEMAV_NOTTOPLEVEL, /* 1802 */
+    XML_SCHEMAV_MISSING, /* 1803 */
+    XML_SCHEMAV_WRONGELEM, /* 1804 */
+    XML_SCHEMAV_NOTYPE, /* 1805 */
+    XML_SCHEMAV_NOROLLBACK, /* 1806 */
+    XML_SCHEMAV_ISABSTRACT, /* 1807 */
+    XML_SCHEMAV_NOTEMPTY, /* 1808 */
+    XML_SCHEMAV_ELEMCONT, /* 1809 */
+    XML_SCHEMAV_HAVEDEFAULT, /* 1810 */
+    XML_SCHEMAV_NOTNILLABLE, /* 1811 */
+    XML_SCHEMAV_EXTRACONTENT, /* 1812 */
+    XML_SCHEMAV_INVALIDATTR, /* 1813 */
+    XML_SCHEMAV_INVALIDELEM, /* 1814 */
+    XML_SCHEMAV_NOTDETERMINIST, /* 1815 */
+    XML_SCHEMAV_CONSTRUCT, /* 1816 */
+    XML_SCHEMAV_INTERNAL, /* 1817 */
+    XML_SCHEMAV_NOTSIMPLE, /* 1818 */
+    XML_SCHEMAV_ATTRUNKNOWN, /* 1819 */
+    XML_SCHEMAV_ATTRINVALID, /* 1820 */
+    XML_SCHEMAV_VALUE, /* 1821 */
+    XML_SCHEMAV_FACET, /* 1822 */
+    XML_XPTR_UNKNOWN_SCHEME = 1900,
+    XML_XPTR_CHILDSEQ_START, /* 1901 */
+    XML_XPTR_EVAL_FAILED, /* 1902 */
+    XML_XPTR_EXTRA_OBJECTS, /* 1903 */
+    XML_C14N_CREATE_CTXT = 1950,
+    XML_C14N_REQUIRES_UTF8, /* 1951 */
+    XML_C14N_CREATE_STACK, /* 1952 */
+    XML_C14N_INVALID_NODE, /* 1953 */
+    XML_FTP_PASV_ANSWER = 2000,
+    XML_FTP_EPSV_ANSWER, /* 2001 */
+    XML_FTP_ACCNT, /* 2002 */
+    XML_HTTP_URL_SYNTAX = 2020,
+    XML_HTTP_USE_IP, /* 2021 */
+    XML_HTTP_UNKNOWN_HOST /* 2022 */
+} xmlParserErrors;
+
+/**
+ * xmlGenericErrorFunc:
+ * @ctx:  a parsing context
+ * @msg:  the message
+ * @...:  the extra arguments of the varags to format the message
+ *
+ * Signature of the function to use when there is an error and
+ * no parsing or validity context available .
+ */
+typedef void (*xmlGenericErrorFunc) (void *ctx,
+				 const char *msg,
+	 			 ...);
+/**
+ * xmlStructuredErrorFunc:
+ * @userData:  user provided data for the error callback
+ * @error:  the error being raised.
+ *
+ * Signature of the function to use when there is an error and
+ * the module handles the new error reporting mechanism.
+ */
+typedef void (*xmlStructuredErrorFunc) (void *userData, xmlErrorPtr error);
+
+/*
+ * Use the following function to reset the two global variables
+ * xmlGenericError and xmlGenericErrorContext.
+ */
+XMLPUBFUN void XMLCALL	
+    xmlSetGenericErrorFunc	(void *ctx,
+				 xmlGenericErrorFunc handler);
+XMLPUBFUN void XMLCALL	
+    initGenericErrorDefaultFunc	(xmlGenericErrorFunc *handler);
+
+XMLPUBFUN void XMLCALL	
+    xmlSetStructuredErrorFunc	(void *ctx,
+				 xmlStructuredErrorFunc handler);
+/*
+ * Default message routines used by SAX and Valid context for error
+ * and warning reporting.
+ */
+XMLPUBFUN void XMLCALL	
+    xmlParserError		(void *ctx,
+				 const char *msg,
+				 ...);
+XMLPUBFUN void XMLCALL	
+    xmlParserWarning		(void *ctx,
+				 const char *msg,
+				 ...);
+XMLPUBFUN void XMLCALL	
+    xmlParserValidityError	(void *ctx,
+				 const char *msg,
+				 ...);
+XMLPUBFUN void XMLCALL	
+    xmlParserValidityWarning	(void *ctx,
+				 const char *msg,
+				 ...);
+XMLPUBFUN void XMLCALL	
+    xmlParserPrintFileInfo	(xmlParserInputPtr input);
+XMLPUBFUN void XMLCALL	
+    xmlParserPrintFileContext	(xmlParserInputPtr input);
+
+/*
+ * Extended error information routines
+ */
+XMLPUBFUN xmlErrorPtr XMLCALL
+    xmlGetLastError		(void);
+XMLPUBFUN void XMLCALL
+    xmlResetLastError		(void);
+XMLPUBFUN xmlErrorPtr XMLCALL
+    xmlCtxtGetLastError		(void *ctx);
+XMLPUBFUN void XMLCALL
+    xmlCtxtResetLastError	(void *ctx);
+XMLPUBFUN void XMLCALL
+    xmlResetError		(xmlErrorPtr err);
+XMLPUBFUN int XMLCALL
+    xmlCopyError		(xmlErrorPtr from,
+    				 xmlErrorPtr to);
+
+#ifdef IN_LIBXML
+/*
+ * Internal callback reporting routine
+ */
+XMLPUBFUN void XMLCALL 
+    __xmlRaiseError		(xmlStructuredErrorFunc schannel,
+    				 xmlGenericErrorFunc channel,
+    				 void *data,
+                                 void *ctx,
+    				 void *node,
+    				 int domain,
+				 int code,
+				 xmlErrorLevel level,
+				 const char *file,
+				 int line,
+				 const char *str1,
+				 const char *str2,
+				 const char *str3,
+				 int int1,
+				 int int2,
+				 const char *msg,
+				 ...);
+XMLPUBFUN void XMLCALL 
+    __xmlSimpleError		(int domain,
+    				 int code,
+				 xmlNodePtr node,
+				 const char *msg,
+				 const char *extra);
+#endif
+#ifdef __cplusplus
+}
+#endif
+#endif /* __XML_ERROR_H__ */
diff --git a/src/libxml/include/libxml/xmlexports.h b/src/libxml/include/libxml/xmlexports.h
new file mode 100644
index 0000000..be219a2
--- /dev/null
+++ b/src/libxml/include/libxml/xmlexports.h
@@ -0,0 +1,138 @@
+/*
+ * Summary: macros for marking symbols as exportable/importable.
+ * Description: macros for marking symbols as exportable/importable.
+ *
+ * Copy: See Copyright for the status of this software.
+ *
+ * Author: Igor Zlatovic <igor@zlatkovic.com>
+ */
+
+#ifndef __XML_EXPORTS_H__
+#define __XML_EXPORTS_H__
+
+/**
+ * XMLPUBFUN, XMLPUBVAR, XMLCALL
+ *
+ * Macros which declare an exportable function, an exportable variable and
+ * the calling convention used for functions.
+ *
+ * Please use an extra block for every platform/compiler combination when
+ * modifying this, rather than overlong #ifdef lines. This helps
+ * readability as well as the fact that different compilers on the same
+ * platform might need different definitions.
+ */
+
+/**
+ * XMLPUBFUN:
+ *
+ * Macros which declare an exportable function
+ */
+#define XMLPUBFUN
+/**
+ * XMLPUBVAR:
+ *
+ * Macros which declare an exportable variable
+ */
+#define XMLPUBVAR extern
+/**
+ * XMLCALL:
+ *
+ * Macros which declare the called convention for exported functions
+ */
+#define XMLCALL
+
+/** DOC_DISABLE */
+
+/* Windows platform with MS compiler */
+#if defined(_WIN32) && defined(_MSC_VER)
+# undef XMLPUBFUN
+# undef XMLPUBVAR
+# undef XMLCALL
+# if defined(IN_LIBXML) && !defined(LIBXML_STATIC)
+#   define XMLPUBFUN __declspec(dllexport)
+#   define XMLPUBVAR __declspec(dllexport)
+# else
+#   define XMLPUBFUN
+#   if !defined(LIBXML_STATIC)
+#     define XMLPUBVAR __declspec(dllimport) extern
+#   else
+#     define XMLPUBVAR extern
+#   endif
+# endif
+# define XMLCALL __cdecl
+# if !defined _REENTRANT
+#   define _REENTRANT
+# endif
+#endif
+
+/* Windows platform with Borland compiler */
+#if defined(_WIN32) && defined(__BORLANDC__)
+#  undef XMLPUBFUN
+#  undef XMLPUBVAR
+#  undef XMLCALL
+#  if defined(IN_LIBXML) && !defined(LIBXML_STATIC)
+#    define XMLPUBFUN __declspec(dllexport)
+#    define XMLPUBVAR __declspec(dllexport) extern
+#  else
+#    define XMLPUBFUN
+#    if !defined(LIBXML_STATIC)
+#      define XMLPUBVAR __declspec(dllimport) extern
+#    else
+#      define XMLPUBVAR extern
+#    endif
+#  endif
+#  define XMLCALL __cdecl
+#  if !defined _REENTRANT
+#    define _REENTRANT
+#  endif
+#endif
+
+/* Windows platform with GNU compiler (Mingw) */
+#if defined(_WIN32) && defined(__MINGW32__)
+#  undef XMLPUBFUN
+#  undef XMLPUBVAR
+#  undef XMLCALL
+#  if defined(IN_LIBXML) && !defined(LIBXML_STATIC)
+#    define XMLPUBFUN __declspec(dllexport)
+#    define XMLPUBVAR __declspec(dllexport)
+#  else
+#    define XMLPUBFUN
+#    if !defined(LIBXML_STATIC)
+#      define XMLPUBVAR __declspec(dllimport) extern
+#    else
+#      define XMLPUBVAR extern
+#    endif
+#  endif
+#  define XMLCALL __cdecl
+#  if !defined _REENTRANT
+#    define _REENTRANT
+#  endif
+#endif
+
+/* Cygwin platform, GNU compiler */
+#if defined(_WIN32) && defined(__CYGWIN__)
+#  undef XMLPUBFUN
+#  undef XMLPUBVAR
+#  undef XMLCALL
+#  if defined(IN_LIBXML) && !defined(LIBXML_STATIC)
+#    define XMLPUBFUN __declspec(dllexport)
+#    define XMLPUBVAR __declspec(dllexport)
+#  else
+#    define XMLPUBFUN
+#    if !defined(LIBXML_STATIC)
+#      define XMLPUBVAR __declspec(dllimport) extern
+#    else
+#      define XMLPUBVAR
+#    endif
+#  endif
+#  define XMLCALL __cdecl
+#endif
+
+/* Compatibility */
+#if !defined(LIBXML_DLL_IMPORT)
+#define LIBXML_DLL_IMPORT XMLPUBVAR
+#endif
+
+#endif /* __XML_EXPORTS_H__ */
+
+
diff --git a/src/libxml/include/libxml/xmlmemory.h b/src/libxml/include/libxml/xmlmemory.h
new file mode 100644
index 0000000..0e6a767
--- /dev/null
+++ b/src/libxml/include/libxml/xmlmemory.h
@@ -0,0 +1,220 @@
+/*
+ * Summary: interface for the memory allocator
+ * Description: provides interfaces for the memory allocator,
+ *              including debugging capabilities.
+ *
+ * Copy: See Copyright for the status of this software.
+ *
+ * Author: Daniel Veillard
+ */
+
+
+#ifndef __DEBUG_MEMORY_ALLOC__
+#define __DEBUG_MEMORY_ALLOC__
+
+#include <stdio.h>
+#include <libxml/xmlversion.h>
+
+/**
+ * DEBUG_MEMORY:
+ *
+ * DEBUG_MEMORY replaces the allocator with a collect and debug
+ * shell to the libc allocator.
+ * DEBUG_MEMORY should only be activated when debugging 
+ * libxml i.e. if libxml has been configured with --with-debug-mem too.
+ */
+/* #define DEBUG_MEMORY_FREED */
+/* #define DEBUG_MEMORY_LOCATION */
+
+#ifdef DEBUG
+#ifndef DEBUG_MEMORY
+#define DEBUG_MEMORY
+#endif
+#endif
+
+/**
+ * DEBUG_MEMORY_LOCATION:
+ *
+ * DEBUG_MEMORY_LOCATION should be activated only when debugging 
+ * libxml i.e. if libxml has been configured with --with-debug-mem too.
+ */
+#ifdef DEBUG_MEMORY_LOCATION
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * The XML memory wrapper support 4 basic overloadable functions.
+ */
+/**
+ * xmlFreeFunc:
+ * @mem: an already allocated block of memory
+ *
+ * Signature for a free() implementation.
+ */
+typedef void (XMLCALL *xmlFreeFunc)(void *mem);
+/**
+ * xmlMallocFunc:
+ * @size:  the size requested in bytes
+ *
+ * Signature for a malloc() implementation.
+ *
+ * Returns a pointer to the newly allocated block or NULL in case of error.
+ */
+typedef void *(XMLCALL *xmlMallocFunc)(size_t size);
+
+/**
+ * xmlReallocFunc:
+ * @mem: an already allocated block of memory
+ * @size:  the new size requested in bytes
+ *
+ * Signature for a realloc() implementation.
+ *
+ * Returns a pointer to the newly reallocated block or NULL in case of error.
+ */
+typedef void *(XMLCALL *xmlReallocFunc)(void *mem, size_t size);
+
+/**
+ * xmlStrdupFunc:
+ * @str: a zero terminated string
+ *
+ * Signature for an strdup() implementation.
+ *
+ * Returns the copy of the string or NULL in case of error.
+ */
+typedef char *(XMLCALL *xmlStrdupFunc)(const char *str);
+
+/*
+ * The 4 interfaces used for all memory handling within libxml.
+LIBXML_DLL_IMPORT extern xmlFreeFunc xmlFree;
+LIBXML_DLL_IMPORT extern xmlMallocFunc xmlMalloc;
+LIBXML_DLL_IMPORT extern xmlMallocFunc xmlMallocAtomic;
+LIBXML_DLL_IMPORT extern xmlReallocFunc xmlRealloc;
+LIBXML_DLL_IMPORT extern xmlStrdupFunc xmlMemStrdup;
+ */
+
+/*
+ * The way to overload the existing functions.
+ * The xmlGc function have an extra entry for atomic block
+ * allocations useful for garbage collected memory allocators
+ */
+XMLPUBFUN int XMLCALL
+	xmlMemSetup	(xmlFreeFunc freeFunc,
+			 xmlMallocFunc mallocFunc,
+			 xmlReallocFunc reallocFunc,
+			 xmlStrdupFunc strdupFunc);
+XMLPUBFUN int XMLCALL     
+	xmlMemGet	(xmlFreeFunc *freeFunc,
+			 xmlMallocFunc *mallocFunc,
+			 xmlReallocFunc *reallocFunc,
+			 xmlStrdupFunc *strdupFunc);
+XMLPUBFUN int XMLCALL     
+	xmlGcMemSetup	(xmlFreeFunc freeFunc,
+			 xmlMallocFunc mallocFunc,
+			 xmlMallocFunc mallocAtomicFunc,
+			 xmlReallocFunc reallocFunc,
+			 xmlStrdupFunc strdupFunc);
+XMLPUBFUN int XMLCALL     
+	xmlGcMemGet	(xmlFreeFunc *freeFunc,
+			 xmlMallocFunc *mallocFunc,
+			 xmlMallocFunc *mallocAtomicFunc,
+			 xmlReallocFunc *reallocFunc,
+			 xmlStrdupFunc *strdupFunc);
+
+/*
+ * Initialization of the memory layer.
+ */
+XMLPUBFUN int XMLCALL	
+	xmlInitMemory	(void);
+
+/* 
+ * Cleanup of the memory layer.
+ */
+XMLPUBFUN void XMLCALL                
+                xmlCleanupMemory        (void);
+/*
+ * These are specific to the XML debug memory wrapper.
+ */
+XMLPUBFUN int XMLCALL	
+	xmlMemUsed	(void);
+XMLPUBFUN void XMLCALL	
+	xmlMemDisplay	(FILE *fp);
+XMLPUBFUN void XMLCALL	
+	xmlMemShow	(FILE *fp, int nr);
+XMLPUBFUN void XMLCALL	
+	xmlMemoryDump	(void);
+XMLPUBFUN void * XMLCALL	
+	xmlMemMalloc	(size_t size);
+XMLPUBFUN void * XMLCALL	
+	xmlMemRealloc	(void *ptr,size_t size);
+XMLPUBFUN void XMLCALL	
+	xmlMemFree	(void *ptr);
+XMLPUBFUN char * XMLCALL	
+	xmlMemoryStrdup	(const char *str);
+XMLPUBFUN void * XMLCALL  
+	xmlMallocLoc	(size_t size, const char *file, int line);
+XMLPUBFUN void * XMLCALL	
+	xmlReallocLoc	(void *ptr, size_t size, const char *file, int line);
+XMLPUBFUN void * XMLCALL	
+	xmlMallocAtomicLoc (size_t size, const char *file, int line);
+XMLPUBFUN char * XMLCALL	
+	xmlMemStrdupLoc	(const char *str, const char *file, int line);
+
+
+#ifdef DEBUG_MEMORY_LOCATION
+/**
+ * xmlMalloc:
+ * @size:  number of bytes to allocate
+ *
+ * Wrapper for the malloc() function used in the XML library.
+ *
+ * Returns the pointer to the allocated area or NULL in case of error.
+ */
+#define xmlMalloc(size) xmlMallocLoc((size), __FILE__, __LINE__)
+/**
+ * xmlMallocAtomic:
+ * @size:  number of bytes to allocate
+ *
+ * Wrapper for the malloc() function used in the XML library for allocation
+ * of block not containing pointers to other areas.
+ *
+ * Returns the pointer to the allocated area or NULL in case of error.
+ */
+#define xmlMallocAtomic(size) xmlMallocAtomicLoc((size), __FILE__, __LINE__)
+/**
+ * xmlRealloc:
+ * @ptr:  pointer to the existing allocated area
+ * @size:  number of bytes to allocate
+ *
+ * Wrapper for the realloc() function used in the XML library.
+ *
+ * Returns the pointer to the allocated area or NULL in case of error.
+ */
+#define xmlRealloc(ptr, size) xmlReallocLoc((ptr), (size), __FILE__, __LINE__)
+/**
+ * xmlMemStrdup:
+ * @str:  pointer to the existing string
+ *
+ * Wrapper for the strdup() function, xmlStrdup() is usually preferred.
+ *
+ * Returns the pointer to the allocated area or NULL in case of error.
+ */
+#define xmlMemStrdup(str) xmlMemStrdupLoc((str), __FILE__, __LINE__)
+
+#endif /* DEBUG_MEMORY_LOCATION */
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#ifndef __XML_GLOBALS_H
+#ifndef __XML_THREADS_H__
+#include <libxml/threads.h>
+#include <libxml/globals.h>
+#endif
+#endif
+
+#endif  /* __DEBUG_MEMORY_ALLOC__ */
+
diff --git a/src/libxml/include/libxml/xmlreader.h b/src/libxml/include/libxml/xmlreader.h
new file mode 100644
index 0000000..4e45201
--- /dev/null
+++ b/src/libxml/include/libxml/xmlreader.h
@@ -0,0 +1,320 @@
+/*
+ * Summary: the XMLReader implementation
+ * Description: API of the XML streaming API based on C# interfaces.
+ *
+ * Copy: See Copyright for the status of this software.
+ *
+ * Author: Daniel Veillard
+ */
+
+#ifndef __XML_XMLREADER_H__
+#define __XML_XMLREADER_H__
+
+#include <libxml/xmlversion.h>
+#include <libxml/tree.h>
+#include <libxml/xmlIO.h>
+#ifdef LIBXML_SCHEMAS_ENABLED
+#include <libxml/relaxng.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum {
+    XML_PARSER_LOADDTD = 1,
+    XML_PARSER_DEFAULTATTRS = 2,
+    XML_PARSER_VALIDATE = 3,
+    XML_PARSER_SUBST_ENTITIES = 4
+} xmlParserProperties;
+
+typedef enum {
+    XML_PARSER_SEVERITY_VALIDITY_WARNING = 1,
+    XML_PARSER_SEVERITY_VALIDITY_ERROR = 2,
+    XML_PARSER_SEVERITY_WARNING = 3,
+    XML_PARSER_SEVERITY_ERROR = 4
+} xmlParserSeverities;
+
+typedef enum {
+    XML_READER_TYPE_NONE = 0,
+    XML_READER_TYPE_ELEMENT = 1,
+    XML_READER_TYPE_ATTRIBUTE = 2,
+    XML_READER_TYPE_TEXT = 3,
+    XML_READER_TYPE_CDATA = 4,
+    XML_READER_TYPE_ENTITY_REFERENCE = 5,
+    XML_READER_TYPE_ENTITY = 6,
+    XML_READER_TYPE_PROCESSING_INSTRUCTION = 7,
+    XML_READER_TYPE_COMMENT = 8,
+    XML_READER_TYPE_DOCUMENT = 9,
+    XML_READER_TYPE_DOCUMENT_TYPE = 10,
+    XML_READER_TYPE_DOCUMENT_FRAGMENT = 11,
+    XML_READER_TYPE_NOTATION = 12,
+    XML_READER_TYPE_WHITESPACE = 13,
+    XML_READER_TYPE_SIGNIFICANT_WHITESPACE = 14,
+    XML_READER_TYPE_END_ELEMENT = 15,
+    XML_READER_TYPE_END_ENTITY = 16,
+    XML_READER_TYPE_XML_DECLARATION = 17
+} xmlReaderTypes;
+
+typedef struct _xmlTextReader xmlTextReader;
+typedef xmlTextReader *xmlTextReaderPtr;
+
+/*
+ * Constructors & Destructor
+ */
+XMLPUBFUN xmlTextReaderPtr XMLCALL
+			xmlNewTextReader	(xmlParserInputBufferPtr input,
+	                                         const char *URI);
+XMLPUBFUN xmlTextReaderPtr XMLCALL	
+			xmlNewTextReaderFilename(const char *URI);
+XMLPUBFUN void XMLCALL			
+			xmlFreeTextReader	(xmlTextReaderPtr reader);
+
+/*
+ * Iterators
+ */
+XMLPUBFUN int XMLCALL		
+			xmlTextReaderRead	(xmlTextReaderPtr reader);
+XMLPUBFUN xmlChar * XMLCALL	
+			xmlTextReaderReadInnerXml	(xmlTextReaderPtr reader);
+XMLPUBFUN xmlChar * XMLCALL	
+			xmlTextReaderReadOuterXml	(xmlTextReaderPtr reader);
+XMLPUBFUN xmlChar * XMLCALL	
+			xmlTextReaderReadString		(xmlTextReaderPtr reader);
+XMLPUBFUN int XMLCALL		
+			xmlTextReaderReadAttributeValue	(xmlTextReaderPtr reader);
+
+/*
+ * Attributes of the node
+ */
+XMLPUBFUN int XMLCALL		
+			xmlTextReaderAttributeCount(xmlTextReaderPtr reader);
+XMLPUBFUN int XMLCALL		
+			xmlTextReaderDepth	(xmlTextReaderPtr reader);
+XMLPUBFUN int XMLCALL		
+			xmlTextReaderHasAttributes(xmlTextReaderPtr reader);
+XMLPUBFUN int XMLCALL		
+			xmlTextReaderHasValue(xmlTextReaderPtr reader);
+XMLPUBFUN int XMLCALL		
+			xmlTextReaderIsDefault	(xmlTextReaderPtr reader);
+XMLPUBFUN int XMLCALL		
+			xmlTextReaderIsEmptyElement(xmlTextReaderPtr reader);
+XMLPUBFUN int XMLCALL		
+			xmlTextReaderNodeType	(xmlTextReaderPtr reader);
+XMLPUBFUN int XMLCALL		
+			xmlTextReaderQuoteChar	(xmlTextReaderPtr reader);
+XMLPUBFUN int XMLCALL		
+			xmlTextReaderReadState	(xmlTextReaderPtr reader);
+
+XMLPUBFUN const xmlChar * XMLCALL	
+		    xmlTextReaderConstBaseUri	(xmlTextReaderPtr reader);
+XMLPUBFUN const xmlChar * XMLCALL	
+		    xmlTextReaderConstLocalName	(xmlTextReaderPtr reader);
+XMLPUBFUN const xmlChar * XMLCALL	
+		    xmlTextReaderConstName	(xmlTextReaderPtr reader);
+XMLPUBFUN const xmlChar * XMLCALL	
+		    xmlTextReaderConstNamespaceUri(xmlTextReaderPtr reader);
+XMLPUBFUN const xmlChar * XMLCALL	
+		    xmlTextReaderConstPrefix	(xmlTextReaderPtr reader);
+XMLPUBFUN const xmlChar * XMLCALL	
+		    xmlTextReaderConstXmlLang	(xmlTextReaderPtr reader);
+XMLPUBFUN const xmlChar * XMLCALL	
+		    xmlTextReaderConstString	(xmlTextReaderPtr reader,
+		    				 const xmlChar *str);
+XMLPUBFUN const xmlChar * XMLCALL	
+		    xmlTextReaderConstValue	(xmlTextReaderPtr reader);
+
+/*
+ * use the Const version of the routine for
+ * better performance and simpler code
+ */
+XMLPUBFUN xmlChar * XMLCALL	
+			xmlTextReaderBaseUri	(xmlTextReaderPtr reader);
+XMLPUBFUN xmlChar * XMLCALL	
+			xmlTextReaderLocalName	(xmlTextReaderPtr reader);
+XMLPUBFUN xmlChar * XMLCALL	
+			xmlTextReaderName	(xmlTextReaderPtr reader);
+XMLPUBFUN xmlChar * XMLCALL	
+			xmlTextReaderNamespaceUri(xmlTextReaderPtr reader);
+XMLPUBFUN xmlChar * XMLCALL	
+			xmlTextReaderPrefix	(xmlTextReaderPtr reader);
+XMLPUBFUN xmlChar * XMLCALL	
+			xmlTextReaderXmlLang	(xmlTextReaderPtr reader);
+XMLPUBFUN xmlChar * XMLCALL	
+			xmlTextReaderValue	(xmlTextReaderPtr reader);
+
+/*
+ * Methods of the XmlTextReader
+ */
+XMLPUBFUN int XMLCALL		
+		    xmlTextReaderClose		(xmlTextReaderPtr reader);
+XMLPUBFUN xmlChar * XMLCALL	
+		    xmlTextReaderGetAttributeNo	(xmlTextReaderPtr reader,
+						 int no);
+XMLPUBFUN xmlChar * XMLCALL	
+		    xmlTextReaderGetAttribute	(xmlTextReaderPtr reader,
+						 const xmlChar *name);
+XMLPUBFUN xmlChar * XMLCALL	
+		    xmlTextReaderGetAttributeNs	(xmlTextReaderPtr reader,
+						 const xmlChar *localName,
+						 const xmlChar *namespaceURI);
+XMLPUBFUN xmlParserInputBufferPtr XMLCALL 
+		    xmlTextReaderGetRemainder	(xmlTextReaderPtr reader);
+XMLPUBFUN xmlChar * XMLCALL	
+		    xmlTextReaderLookupNamespace(xmlTextReaderPtr reader,
+						 const xmlChar *prefix);
+XMLPUBFUN int XMLCALL		
+		    xmlTextReaderMoveToAttributeNo(xmlTextReaderPtr reader,
+						 int no);
+XMLPUBFUN int XMLCALL		
+		    xmlTextReaderMoveToAttribute(xmlTextReaderPtr reader,
+						 const xmlChar *name);
+XMLPUBFUN int XMLCALL		
+		    xmlTextReaderMoveToAttributeNs(xmlTextReaderPtr reader,
+						 const xmlChar *localName,
+						 const xmlChar *namespaceURI);
+XMLPUBFUN int XMLCALL		
+		    xmlTextReaderMoveToFirstAttribute(xmlTextReaderPtr reader);
+XMLPUBFUN int XMLCALL		
+		    xmlTextReaderMoveToNextAttribute(xmlTextReaderPtr reader);
+XMLPUBFUN int XMLCALL		
+		    xmlTextReaderMoveToElement	(xmlTextReaderPtr reader);
+XMLPUBFUN int XMLCALL		
+		    xmlTextReaderNormalization	(xmlTextReaderPtr reader);
+
+/*
+ * Extensions
+ */
+XMLPUBFUN int XMLCALL		
+		    xmlTextReaderSetParserProp	(xmlTextReaderPtr reader,
+						 int prop,
+						 int value);
+XMLPUBFUN int XMLCALL		
+		    xmlTextReaderGetParserProp	(xmlTextReaderPtr reader,
+						 int prop);
+XMLPUBFUN xmlNodePtr XMLCALL	
+		    xmlTextReaderCurrentNode	(xmlTextReaderPtr reader);
+XMLPUBFUN xmlNodePtr XMLCALL	
+		    xmlTextReaderPreserve	(xmlTextReaderPtr reader);
+XMLPUBFUN int XMLCALL	
+		    xmlTextReaderPreservePattern(xmlTextReaderPtr reader,
+		    				 const xmlChar *pattern,
+						 const xmlChar **namespaces);
+XMLPUBFUN xmlDocPtr XMLCALL	
+		    xmlTextReaderCurrentDoc	(xmlTextReaderPtr reader);
+XMLPUBFUN xmlNodePtr XMLCALL	
+		    xmlTextReaderExpand		(xmlTextReaderPtr reader);
+XMLPUBFUN int XMLCALL		
+		    xmlTextReaderNext		(xmlTextReaderPtr reader);
+XMLPUBFUN int XMLCALL
+		    xmlTextReaderNextSibling	(xmlTextReaderPtr reader);
+XMLPUBFUN int XMLCALL		
+		    xmlTextReaderIsValid	(xmlTextReaderPtr reader);
+#ifdef LIBXML_SCHEMAS_ENABLED
+XMLPUBFUN int XMLCALL		
+		    xmlTextReaderRelaxNGValidate(xmlTextReaderPtr reader,
+						 const char *rng);
+XMLPUBFUN int XMLCALL		
+		    xmlTextReaderRelaxNGSetSchema(xmlTextReaderPtr reader,
+						 xmlRelaxNGPtr schema);
+#endif
+
+/*
+ * New more complete APIs for simpler creation and reuse of readers
+ */
+XMLPUBFUN xmlTextReaderPtr XMLCALL
+		xmlReaderWalker		(xmlDocPtr doc);
+XMLPUBFUN xmlTextReaderPtr XMLCALL
+		xmlReaderForDoc		(const xmlChar * cur,
+					 const char *URL,
+					 const char *encoding,
+					 int options);
+XMLPUBFUN xmlTextReaderPtr XMLCALL
+		xmlReaderForFile	(const char *filename,
+					 const char *encoding,
+					 int options);
+XMLPUBFUN xmlTextReaderPtr XMLCALL
+		xmlReaderForMemory	(const char *buffer,
+					 int size,
+					 const char *URL,
+					 const char *encoding,
+					 int options);
+XMLPUBFUN xmlTextReaderPtr XMLCALL
+		xmlReaderForFd		(int fd,
+					 const char *URL,
+					 const char *encoding,
+					 int options);
+XMLPUBFUN xmlTextReaderPtr XMLCALL
+		xmlReaderForIO		(xmlInputReadCallback ioread,
+					 xmlInputCloseCallback ioclose,
+					 void *ioctx,
+					 const char *URL,
+					 const char *encoding,
+					 int options);
+
+XMLPUBFUN int XMLCALL
+		xmlReaderNewWalker	(xmlTextReaderPtr reader,
+					 xmlDocPtr doc);
+XMLPUBFUN int XMLCALL
+		xmlReaderNewDoc		(xmlTextReaderPtr reader,
+					 const xmlChar * cur,
+					 const char *URL,
+					 const char *encoding,
+					 int options);
+XMLPUBFUN int XMLCALL
+		xmlReaderNewFile	(xmlTextReaderPtr reader,
+					 const char *filename,
+					 const char *encoding,
+					 int options);
+XMLPUBFUN int XMLCALL
+		xmlReaderNewMemory	(xmlTextReaderPtr reader,
+					 const char *buffer,
+					 int size,
+					 const char *URL,
+					 const char *encoding,
+					 int options);
+XMLPUBFUN int XMLCALL
+		xmlReaderNewFd		(xmlTextReaderPtr reader,
+					 int fd,
+					 const char *URL,
+					 const char *encoding,
+					 int options);
+XMLPUBFUN int XMLCALL
+		xmlReaderNewIO		(xmlTextReaderPtr reader,
+					 xmlInputReadCallback ioread,
+					 xmlInputCloseCallback ioclose,
+					 void *ioctx,
+					 const char *URL,
+					 const char *encoding,
+					 int options);
+/*
+ * Error handling extensions
+ */
+typedef void *  xmlTextReaderLocatorPtr;
+typedef void   (XMLCALL *xmlTextReaderErrorFunc)        (void *arg, 
+						 const char *msg,
+						 xmlParserSeverities severity,
+						 xmlTextReaderLocatorPtr locator);
+XMLPUBFUN int XMLCALL             
+		    xmlTextReaderLocatorLineNumber(xmlTextReaderLocatorPtr locator);
+/*int             xmlTextReaderLocatorLinePosition(xmlTextReaderLocatorPtr locator);*/
+XMLPUBFUN xmlChar * XMLCALL       
+		    xmlTextReaderLocatorBaseURI (xmlTextReaderLocatorPtr locator);
+XMLPUBFUN void XMLCALL            
+		    xmlTextReaderSetErrorHandler(xmlTextReaderPtr reader, 
+						 xmlTextReaderErrorFunc f, 
+						 void *arg);
+XMLPUBFUN void XMLCALL
+		    xmlTextReaderSetStructuredErrorHandler(xmlTextReaderPtr reader,
+							   xmlStructuredErrorFunc f,
+							   void *arg);
+XMLPUBFUN void XMLCALL            
+		    xmlTextReaderGetErrorHandler(xmlTextReaderPtr reader, 
+						 xmlTextReaderErrorFunc *f, 
+						 void **arg);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* __XML_XMLREADER_H__ */
+
diff --git a/src/libxml/include/libxml/xmlregexp.h b/src/libxml/include/libxml/xmlregexp.h
new file mode 100644
index 0000000..6a9bcf1
--- /dev/null
+++ b/src/libxml/include/libxml/xmlregexp.h
@@ -0,0 +1,95 @@
+/*
+ * Summary: regular expressions handling
+ * Description: basic API for libxml regular expressions handling used
+ *              for XML Schemas and validation.
+ *
+ * Copy: See Copyright for the status of this software.
+ *
+ * Author: Daniel Veillard
+ */
+
+#ifndef __XML_REGEXP_H__
+#define __XML_REGEXP_H__
+
+#include <libxml/xmlversion.h>
+
+#ifdef LIBXML_REGEXP_ENABLED
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * xmlRegexpPtr:
+ *
+ * A libxml regular expression, they can actually be far more complex
+ * thank the POSIX regex expressions.
+ */
+typedef struct _xmlRegexp xmlRegexp;
+typedef xmlRegexp *xmlRegexpPtr;
+
+/**
+ * xmlRegExecCtxtPtr:
+ *
+ * A libxml progressive regular expression evaluation context
+ */
+typedef struct _xmlRegExecCtxt xmlRegExecCtxt;
+typedef xmlRegExecCtxt *xmlRegExecCtxtPtr;
+
+#ifdef __cplusplus
+}
+#endif 
+#include <libxml/tree.h>
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * The POSIX like API
+ */
+XMLPUBFUN xmlRegexpPtr XMLCALL
+		    xmlRegexpCompile	(const xmlChar *regexp);
+XMLPUBFUN void XMLCALL			 xmlRegFreeRegexp(xmlRegexpPtr regexp);
+XMLPUBFUN int XMLCALL			
+		    xmlRegexpExec	(xmlRegexpPtr comp,
+					 const xmlChar *value);
+XMLPUBFUN void XMLCALL			
+    		    xmlRegexpPrint	(FILE *output,
+					 xmlRegexpPtr regexp);
+XMLPUBFUN int XMLCALL			
+		    xmlRegexpIsDeterminist(xmlRegexpPtr comp);
+
+/*
+ * Callback function when doing a transition in the automata
+ */
+typedef void (*xmlRegExecCallbacks) (xmlRegExecCtxtPtr exec,
+	                             const xmlChar *token,
+				     void *transdata,
+				     void *inputdata);
+
+/*
+ * The progressive API
+ */
+XMLPUBFUN xmlRegExecCtxtPtr XMLCALL	
+    		    xmlRegNewExecCtxt	(xmlRegexpPtr comp,
+					 xmlRegExecCallbacks callback,
+					 void *data);
+XMLPUBFUN void XMLCALL			
+		    xmlRegFreeExecCtxt	(xmlRegExecCtxtPtr exec);
+XMLPUBFUN int XMLCALL			
+    		    xmlRegExecPushString(xmlRegExecCtxtPtr exec,
+					 const xmlChar *value,
+					 void *data);
+XMLPUBFUN int XMLCALL			
+		    xmlRegExecPushString2(xmlRegExecCtxtPtr exec,
+					 const xmlChar *value,
+					 const xmlChar *value2,
+					 void *data);
+
+#ifdef __cplusplus
+}
+#endif 
+
+#endif /* LIBXML_REGEXP_ENABLED */
+
+#endif /*__XML_REGEXP_H__ */
diff --git a/src/libxml/include/libxml/xmlsave.h b/src/libxml/include/libxml/xmlsave.h
new file mode 100644
index 0000000..1d43a71
--- /dev/null
+++ b/src/libxml/include/libxml/xmlsave.h
@@ -0,0 +1,61 @@
+/*
+ * Summary: the XML document serializer
+ * Description: API to save document or subtree of document
+ *
+ * Copy: See Copyright for the status of this software.
+ *
+ * Author: Daniel Veillard
+ */
+
+#ifndef __XML_XMLSAVE_H__
+#define __XML_XMLSAVE_H__
+
+#include <libxml/xmlversion.h>
+#include <libxml/tree.h>
+#include <libxml/xmlIO.h>
+
+#ifdef LIBXML_OUTPUT_ENABLED
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct _xmlSaveCtxt xmlSaveCtxt;
+typedef xmlSaveCtxt *xmlSaveCtxtPtr;
+
+XMLPUBFUN xmlSaveCtxtPtr XMLCALL
+		xmlSaveToFd		(int fd,
+					 const char *encoding,
+					 int options);
+XMLPUBFUN xmlSaveCtxtPtr XMLCALL
+		xmlSaveToFilename	(const char *filename,
+					 const char *encoding,
+					 int options);
+XMLPUBFUN xmlSaveCtxtPtr XMLCALL
+		xmlSaveToBuffer		(xmlBufferPtr buffer,
+					 const char *encoding,
+					 int options);
+XMLPUBFUN xmlSaveCtxtPtr XMLCALL
+		xmlSaveToIO		(xmlOutputWriteCallback iowrite,
+					 xmlOutputCloseCallback ioclose,
+					 void *ioctx,
+					 const char *encoding,
+					 int options);
+
+XMLPUBFUN long XMLCALL
+		xmlSaveDoc		(xmlSaveCtxtPtr ctxt,
+					 xmlDocPtr doc);
+XMLPUBFUN long XMLCALL
+		xmlSaveTree		(xmlSaveCtxtPtr ctxt,
+					 xmlNodePtr node);
+
+XMLPUBFUN int XMLCALL
+		xmlSaveFlush		(xmlSaveCtxtPtr ctxt);
+XMLPUBFUN int XMLCALL
+		xmlSaveClose		(xmlSaveCtxtPtr ctxt);
+#ifdef __cplusplus
+}
+#endif
+#endif /* LIBXML_OUTPUT_ENABLED */
+#endif /* __XML_XMLSAVE_H__ */
+
+
diff --git a/src/libxml/include/libxml/xmlschemas.h b/src/libxml/include/libxml/xmlschemas.h
new file mode 100644
index 0000000..49bf3b4
--- /dev/null
+++ b/src/libxml/include/libxml/xmlschemas.h
@@ -0,0 +1,125 @@
+/*
+ * Summary: incomplete XML Schemas structure implementation
+ * Description: interface to the XML Schemas handling and schema validity
+ *              checking, it is incomplete right now.
+ *
+ * Copy: See Copyright for the status of this software.
+ *
+ * Author: Daniel Veillard
+ */
+
+
+#ifndef __XML_SCHEMA_H__
+#define __XML_SCHEMA_H__
+
+#include <libxml/xmlversion.h>
+
+#ifdef LIBXML_SCHEMAS_ENABLED
+
+#include <libxml/tree.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum {
+    XML_SCHEMAS_ERR_OK		= 0,
+    XML_SCHEMAS_ERR_NOROOT	= 1,
+    XML_SCHEMAS_ERR_UNDECLAREDELEM,
+    XML_SCHEMAS_ERR_NOTTOPLEVEL,
+    XML_SCHEMAS_ERR_MISSING,
+    XML_SCHEMAS_ERR_WRONGELEM,
+    XML_SCHEMAS_ERR_NOTYPE,
+    XML_SCHEMAS_ERR_NOROLLBACK,
+    XML_SCHEMAS_ERR_ISABSTRACT,
+    XML_SCHEMAS_ERR_NOTEMPTY,
+    XML_SCHEMAS_ERR_ELEMCONT,
+    XML_SCHEMAS_ERR_HAVEDEFAULT,
+    XML_SCHEMAS_ERR_NOTNILLABLE,
+    XML_SCHEMAS_ERR_EXTRACONTENT,
+    XML_SCHEMAS_ERR_INVALIDATTR,
+    XML_SCHEMAS_ERR_INVALIDELEM,
+    XML_SCHEMAS_ERR_NOTDETERMINIST,
+    XML_SCHEMAS_ERR_CONSTRUCT,
+    XML_SCHEMAS_ERR_INTERNAL,
+    XML_SCHEMAS_ERR_NOTSIMPLE,
+    XML_SCHEMAS_ERR_ATTRUNKNOWN,
+    XML_SCHEMAS_ERR_ATTRINVALID,
+    XML_SCHEMAS_ERR_VALUE,
+    XML_SCHEMAS_ERR_FACET,
+    XML_SCHEMAS_ERR_,
+    XML_SCHEMAS_ERR_XXX
+} xmlSchemaValidError;
+
+
+/**
+ * The schemas related types are kept internal
+ */
+typedef struct _xmlSchema xmlSchema;
+typedef xmlSchema *xmlSchemaPtr;
+
+/**
+ * A schemas validation context
+ */
+typedef void (*xmlSchemaValidityErrorFunc) (void *ctx, const char *msg, ...);
+typedef void (*xmlSchemaValidityWarningFunc) (void *ctx, const char *msg, ...);
+
+typedef struct _xmlSchemaParserCtxt xmlSchemaParserCtxt;
+typedef xmlSchemaParserCtxt *xmlSchemaParserCtxtPtr;
+
+typedef struct _xmlSchemaValidCtxt xmlSchemaValidCtxt;
+typedef xmlSchemaValidCtxt *xmlSchemaValidCtxtPtr;
+
+/*
+ * Interfaces for parsing.
+ */
+XMLPUBFUN xmlSchemaParserCtxtPtr XMLCALL 
+	    xmlSchemaNewParserCtxt	(const char *URL);
+XMLPUBFUN xmlSchemaParserCtxtPtr XMLCALL 
+	    xmlSchemaNewMemParserCtxt	(const char *buffer,
+					 int size);
+XMLPUBFUN xmlSchemaParserCtxtPtr XMLCALL
+	    xmlSchemaNewDocParserCtxt	(xmlDocPtr doc);
+XMLPUBFUN void XMLCALL		
+	    xmlSchemaFreeParserCtxt	(xmlSchemaParserCtxtPtr ctxt);
+XMLPUBFUN void XMLCALL		
+	    xmlSchemaSetParserErrors	(xmlSchemaParserCtxtPtr ctxt,
+					 xmlSchemaValidityErrorFunc err,
+					 xmlSchemaValidityWarningFunc warn,
+					 void *ctx);
+XMLPUBFUN xmlSchemaPtr XMLCALL	
+	    xmlSchemaParse		(xmlSchemaParserCtxtPtr ctxt);
+XMLPUBFUN void XMLCALL		
+	    xmlSchemaFree		(xmlSchemaPtr schema);
+#ifdef LIBXML_OUTPUT_ENABLED
+XMLPUBFUN void XMLCALL		
+	    xmlSchemaDump		(FILE *output,
+					 xmlSchemaPtr schema);
+#endif /* LIBXML_OUTPUT_ENABLED */
+/*
+ * Interfaces for validating
+ */
+XMLPUBFUN void XMLCALL		
+	    xmlSchemaSetValidErrors	(xmlSchemaValidCtxtPtr ctxt,
+					 xmlSchemaValidityErrorFunc err,
+					 xmlSchemaValidityWarningFunc warn,
+					 void *ctx);
+XMLPUBFUN xmlSchemaValidCtxtPtr XMLCALL	
+	    xmlSchemaNewValidCtxt	(xmlSchemaPtr schema);
+XMLPUBFUN void XMLCALL			
+	    xmlSchemaFreeValidCtxt	(xmlSchemaValidCtxtPtr ctxt);
+XMLPUBFUN int XMLCALL			
+	    xmlSchemaValidateDoc	(xmlSchemaValidCtxtPtr ctxt,
+					 xmlDocPtr instance);
+XMLPUBFUN int XMLCALL			
+	    xmlSchemaValidateStream	(xmlSchemaValidCtxtPtr ctxt,
+					 xmlParserInputBufferPtr input,
+					 xmlCharEncoding enc,
+					 xmlSAXHandlerPtr sax,
+					 void *user_data);
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* LIBXML_SCHEMAS_ENABLED */
+#endif /* __XML_SCHEMA_H__ */
diff --git a/src/libxml/include/libxml/xmlschemastypes.h b/src/libxml/include/libxml/xmlschemastypes.h
new file mode 100644
index 0000000..4514c59
--- /dev/null
+++ b/src/libxml/include/libxml/xmlschemastypes.h
@@ -0,0 +1,67 @@
+/*
+ * Summary: implementation of XML Schema Datatypes
+ * Description: module providing the XML Schema Datatypes implementation
+ *              both definition and validity checking
+ *
+ * Copy: See Copyright for the status of this software.
+ *
+ * Author: Daniel Veillard
+ */
+
+
+#ifndef __XML_SCHEMA_TYPES_H__
+#define __XML_SCHEMA_TYPES_H__
+
+#include <libxml/xmlversion.h>
+
+#ifdef LIBXML_SCHEMAS_ENABLED
+
+#include <libxml/schemasInternals.h>
+#include <libxml/xmlschemas.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+XMLPUBFUN void XMLCALL		
+    		xmlSchemaInitTypes		(void);
+XMLPUBFUN void XMLCALL		
+		xmlSchemaCleanupTypes		(void);
+XMLPUBFUN xmlSchemaTypePtr XMLCALL 
+		xmlSchemaGetPredefinedType	(const xmlChar *name,
+						 const xmlChar *ns);
+XMLPUBFUN int XMLCALL		
+		xmlSchemaValidatePredefinedType	(xmlSchemaTypePtr type,
+						 const xmlChar *value,
+						 xmlSchemaValPtr *val);
+XMLPUBFUN int XMLCALL		
+		xmlSchemaValPredefTypeNode	(xmlSchemaTypePtr type,
+						 const xmlChar *value,
+						 xmlSchemaValPtr *val,
+						 xmlNodePtr node);
+XMLPUBFUN int XMLCALL		
+		xmlSchemaValidateFacet		(xmlSchemaTypePtr base,
+						 xmlSchemaFacetPtr facet,
+						 const xmlChar *value,
+						 xmlSchemaValPtr val);
+XMLPUBFUN void XMLCALL		
+		xmlSchemaFreeValue		(xmlSchemaValPtr val);
+XMLPUBFUN xmlSchemaFacetPtr XMLCALL 
+		xmlSchemaNewFacet		(void);
+XMLPUBFUN int XMLCALL		
+		xmlSchemaCheckFacet		(xmlSchemaFacetPtr facet,
+						 xmlSchemaTypePtr typeDecl,
+						 xmlSchemaParserCtxtPtr ctxt,
+						 const xmlChar *name);
+XMLPUBFUN void XMLCALL		
+		xmlSchemaFreeFacet		(xmlSchemaFacetPtr facet);
+XMLPUBFUN int XMLCALL		
+		xmlSchemaCompareValues		(xmlSchemaValPtr x,
+						 xmlSchemaValPtr y);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* LIBXML_SCHEMAS_ENABLED */
+#endif /* __XML_SCHEMA_TYPES_H__ */
diff --git a/src/libxml/include/libxml/xmlstring.h b/src/libxml/include/libxml/xmlstring.h
new file mode 100644
index 0000000..74ae405
--- /dev/null
+++ b/src/libxml/include/libxml/xmlstring.h
@@ -0,0 +1,141 @@
+/*
+ * Summary: set of routines to process strings
+ * Description: type and interfaces needed for the internal string handling
+ *              of the library, especially UTF8 processing.
+ *
+ * Copy: See Copyright for the status of this software.
+ *
+ * Author: Daniel Veillard
+ */
+
+#ifndef __XML_STRING_H__
+#define __XML_STRING_H__
+
+#include <stdarg.h>
+#include <libxml/xmlversion.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * xmlChar:
+ *
+ * This is a basic byte in an UTF-8 encoded string.
+ * It's unsigned allowing to pinpoint case where char * are assigned
+ * to xmlChar * (possibly making serialization back impossible).
+ */
+
+typedef unsigned char xmlChar;
+
+/**
+ * BAD_CAST:
+ *
+ * Macro to cast a string to an xmlChar * when one know its safe.
+ */
+#define BAD_CAST (xmlChar *)
+
+/*
+ * xmlChar handling
+ */
+XMLPUBFUN xmlChar * XMLCALL
+                xmlStrdup                (const xmlChar *cur);
+XMLPUBFUN xmlChar * XMLCALL
+                xmlStrndup               (const xmlChar *cur,
+                                         int len);
+XMLPUBFUN xmlChar * XMLCALL
+                xmlCharStrndup           (const char *cur,
+                                         int len);
+XMLPUBFUN xmlChar * XMLCALL
+                xmlCharStrdup            (const char *cur);
+XMLPUBFUN xmlChar * XMLCALL
+                xmlStrsub                (const xmlChar *str,
+                                         int start,
+                                         int len);
+XMLPUBFUN const xmlChar * XMLCALL
+                xmlStrchr                (const xmlChar *str,
+                                         xmlChar val);
+XMLPUBFUN const xmlChar * XMLCALL
+                xmlStrstr                (const xmlChar *str,
+                                         const xmlChar *val);
+XMLPUBFUN const xmlChar * XMLCALL
+                xmlStrcasestr            (const xmlChar *str,
+                                         xmlChar *val);
+XMLPUBFUN int XMLCALL
+                xmlStrcmp                (const xmlChar *str1,
+                                         const xmlChar *str2);
+XMLPUBFUN int XMLCALL
+                xmlStrncmp               (const xmlChar *str1,
+                                         const xmlChar *str2,
+                                         int len);
+XMLPUBFUN int XMLCALL
+                xmlStrcasecmp            (const xmlChar *str1,
+                                         const xmlChar *str2);
+XMLPUBFUN int XMLCALL
+                xmlStrncasecmp           (const xmlChar *str1,
+                                         const xmlChar *str2,
+                                         int len);
+XMLPUBFUN int XMLCALL
+                xmlStrEqual              (const xmlChar *str1,
+                                         const xmlChar *str2);
+XMLPUBFUN int XMLCALL
+                xmlStrQEqual             (const xmlChar *pref,
+                                         const xmlChar *name,
+                                         const xmlChar *str);
+XMLPUBFUN int XMLCALL
+                xmlStrlen                (const xmlChar *str);
+XMLPUBFUN xmlChar * XMLCALL
+                xmlStrcat                (xmlChar *cur,
+                                         const xmlChar *add);
+XMLPUBFUN xmlChar * XMLCALL
+                xmlStrncat               (xmlChar *cur,
+                                         const xmlChar *add,
+                                         int len);
+XMLPUBFUN xmlChar * XMLCALL
+                xmlStrncatNew            (const xmlChar *str1,
+                                         const xmlChar *str2,
+                                         int len);
+XMLPUBFUN int XMLCALL
+                xmlStrPrintf             (xmlChar *buf,
+                                         int len,
+                                         const xmlChar *msg,
+                                         ...);
+XMLPUBFUN int XMLCALL
+                xmlStrVPrintf                (xmlChar *buf,
+                                         int len,
+                                         const xmlChar *msg,
+                                         va_list ap);
+
+XMLPUBFUN int XMLCALL
+        xmlGetUTF8Char                   (const unsigned char *utf,
+                                         int *len);
+XMLPUBFUN int XMLCALL
+        xmlCheckUTF8                     (const unsigned char *utf);
+XMLPUBFUN int XMLCALL
+        xmlUTF8Strsize                   (const xmlChar *utf,
+                                         int len);
+XMLPUBFUN xmlChar * XMLCALL 
+        xmlUTF8Strndup                   (const xmlChar *utf,
+                                         int len);
+XMLPUBFUN xmlChar * XMLCALL 
+        xmlUTF8Strpos                    (const xmlChar *utf,
+                                         int pos);
+XMLPUBFUN int XMLCALL
+        xmlUTF8Strloc                    (const xmlChar *utf,
+                                         const xmlChar *utfchar);
+XMLPUBFUN xmlChar * XMLCALL 
+        xmlUTF8Strsub                    (const xmlChar *utf,
+                                         int start,
+                                         int len);
+XMLPUBFUN int XMLCALL
+        xmlUTF8Strlen                    (const xmlChar *utf);
+XMLPUBFUN int XMLCALL
+        xmlUTF8Size                      (const xmlChar *utf);
+XMLPUBFUN int XMLCALL
+        xmlUTF8Charcmp                   (const xmlChar *utf1,
+                                         const xmlChar *utf2);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* __XML_STRING_H__ */
diff --git a/src/libxml/include/libxml/xmlunicode.h b/src/libxml/include/libxml/xmlunicode.h
new file mode 100644
index 0000000..b8537dc
--- /dev/null
+++ b/src/libxml/include/libxml/xmlunicode.h
@@ -0,0 +1,197 @@
+/*
+ * Summary: Unicode character APIs
+ * Description: API for the Unicode character APIs
+ *
+ * This file is automatically generated from the
+ * UCS description files of the Unicode Character Database
+ * http://www.unicode.org/Public/4.0-Update1/UCD-4.0.1d5b.html
+ * using the genUnicode.py Python script.
+ *
+ * Generation date: Mon Nov 10 22:35:10 2003
+ * Sources: Blocks-4.0.1d1b.txt UnicodeData-4.0.1d1b.txt
+ * Author: Daniel Veillard
+ */
+
+#ifndef __XML_UNICODE_H__
+#define __XML_UNICODE_H__
+
+#include <libxml/xmlversion.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+XMLPUBFUN int XMLCALL xmlUCSIsAegeanNumbers	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsAlphabeticPresentationForms	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsArabic	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsArabicPresentationFormsA	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsArabicPresentationFormsB	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsArmenian	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsArrows	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsBasicLatin	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsBengali	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsBlockElements	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsBopomofo	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsBopomofoExtended	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsBoxDrawing	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsBraillePatterns	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsBuhid	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsByzantineMusicalSymbols	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCJKCompatibility	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCJKCompatibilityForms	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCJKCompatibilityIdeographs	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCJKCompatibilityIdeographsSupplement	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCJKRadicalsSupplement	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCJKSymbolsandPunctuation	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCJKUnifiedIdeographs	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCJKUnifiedIdeographsExtensionA	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCJKUnifiedIdeographsExtensionB	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCherokee	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCombiningDiacriticalMarks	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCombiningDiacriticalMarksforSymbols	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCombiningHalfMarks	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCombiningMarksforSymbols	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsControlPictures	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCurrencySymbols	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCypriotSyllabary	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCyrillic	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCyrillicSupplement	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsDeseret	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsDevanagari	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsDingbats	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsEnclosedAlphanumerics	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsEnclosedCJKLettersandMonths	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsEthiopic	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsGeneralPunctuation	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsGeometricShapes	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsGeorgian	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsGothic	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsGreek	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsGreekExtended	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsGreekandCoptic	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsGujarati	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsGurmukhi	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsHalfwidthandFullwidthForms	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsHangulCompatibilityJamo	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsHangulJamo	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsHangulSyllables	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsHanunoo	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsHebrew	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsHighPrivateUseSurrogates	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsHighSurrogates	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsHiragana	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsIPAExtensions	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsIdeographicDescriptionCharacters	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsKanbun	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsKangxiRadicals	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsKannada	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsKatakana	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsKatakanaPhoneticExtensions	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsKhmer	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsKhmerSymbols	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsLao	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsLatin1Supplement	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsLatinExtendedA	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsLatinExtendedB	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsLatinExtendedAdditional	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsLetterlikeSymbols	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsLimbu	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsLinearBIdeograms	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsLinearBSyllabary	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsLowSurrogates	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsMalayalam	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsMathematicalAlphanumericSymbols	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsMathematicalOperators	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsMiscellaneousMathematicalSymbolsA	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsMiscellaneousMathematicalSymbolsB	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsMiscellaneousSymbols	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsMiscellaneousSymbolsandArrows	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsMiscellaneousTechnical	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsMongolian	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsMusicalSymbols	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsMyanmar	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsNumberForms	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsOgham	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsOldItalic	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsOpticalCharacterRecognition	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsOriya	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsOsmanya	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsPhoneticExtensions	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsPrivateUse	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsPrivateUseArea	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsRunic	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsShavian	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsSinhala	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsSmallFormVariants	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsSpacingModifierLetters	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsSpecials	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsSuperscriptsandSubscripts	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsSupplementalArrowsA	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsSupplementalArrowsB	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsSupplementalMathematicalOperators	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsSupplementaryPrivateUseAreaA	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsSupplementaryPrivateUseAreaB	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsSyriac	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsTagalog	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsTagbanwa	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsTags	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsTaiLe	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsTaiXuanJingSymbols	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsTamil	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsTelugu	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsThaana	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsThai	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsTibetan	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsUgaritic	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsUnifiedCanadianAboriginalSyllabics	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsVariationSelectors	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsVariationSelectorsSupplement	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsYiRadicals	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsYiSyllables	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsYijingHexagramSymbols	(int code);
+
+XMLPUBFUN int XMLCALL xmlUCSIsBlock	(int code, const char *block);
+
+XMLPUBFUN int XMLCALL xmlUCSIsCatC	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatCc	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatCf	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatCo	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatCs	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatL	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatLl	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatLm	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatLo	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatLt	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatLu	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatM	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatMc	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatMe	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatMn	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatN	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatNd	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatNl	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatNo	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatP	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatPc	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatPd	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatPe	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatPf	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatPi	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatPo	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatPs	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatS	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatSc	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatSk	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatSm	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatSo	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatZ	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatZl	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatZp	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatZs	(int code);
+
+XMLPUBFUN int XMLCALL xmlUCSIsCat	(int code, const char *cat);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* __XML_UNICODE_H__ */
diff --git a/src/libxml/include/libxml/xmlversion.h b/src/libxml/include/libxml/xmlversion.h
new file mode 100644
index 0000000..dc5df08
--- /dev/null
+++ b/src/libxml/include/libxml/xmlversion.h
@@ -0,0 +1,347 @@
+/*
+ * Summary: compile-time version informations
+ * Description: compile-time version informations for the XML library
+ *
+ * Copy: See Copyright for the status of this software.
+ *
+ * Author: Daniel Veillard
+ */
+
+#ifndef __XML_VERSION_H__
+#define __XML_VERSION_H__
+
+#include <libxml/xmlexports.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * use those to be sure nothing nasty will happen if
+ * your library and includes mismatch
+ */
+#ifndef LIBXML2_COMPILING_MSCCDEF
+XMLPUBFUN void XMLCALL xmlCheckVersion(int version);
+#endif /* LIBXML2_COMPILING_MSCCDEF */
+
+/**
+ * LIBXML_DOTTED_VERSION:
+ *
+ * the version string like "1.2.3"
+ */
+#define LIBXML_DOTTED_VERSION "2.6.9"
+
+/**
+ * LIBXML_VERSION:
+ *
+ * the version number: 1.2.3 value is 1002003
+ */
+#define LIBXML_VERSION 20609
+
+/**
+ * LIBXML_VERSION_STRING:
+ *
+ * the version number string, 1.2.3 value is "1002003"
+ */
+#define LIBXML_VERSION_STRING "20609"
+
+/**
+ * LIBXML_TEST_VERSION:
+ *
+ * Macro to check that the libxml version in use is compatible with
+ * the version the software has been compiled against
+ */
+#define LIBXML_TEST_VERSION xmlCheckVersion(20609);
+
+#ifndef VMS
+#if 0
+/**
+ * WITH_TRIO:
+ *
+ * defined if the trio support need to be configured in
+ */
+#define WITH_TRIO
+#else
+/**
+ * WITHOUT_TRIO:
+ *
+ * defined if the trio support should not be configured in
+ */
+#define WITHOUT_TRIO
+#endif
+#else /* VMS */
+/**
+ * WITH_TRIO:
+ *
+ * defined if the trio support need to be configured in
+ */
+#define WITH_TRIO 1
+#endif /* VMS */
+
+/**
+ * LIBXML_THREAD_ENABLED:
+ *
+ * Whether the thread support is configured in
+ */
+#if 1
+#if defined(_REENTRANT) || defined(__MT__) || (_POSIX_C_SOURCE - 0 >= 199506L)
+#define LIBXML_THREAD_ENABLED
+#endif
+#endif
+
+/**
+ * LIBXML_TREE_ENABLED:
+ *
+ * Whether the DOM like tree manipulation API support is configured in
+ */
+#if 1
+#define LIBXML_TREE_ENABLED
+#endif
+
+/**
+ * LIBXML_OUTPUT_ENABLED:
+ *
+ * Whether the serialization/saving support is configured in
+ */
+#if 1
+#define LIBXML_OUTPUT_ENABLED
+#endif
+
+/**
+ * LIBXML_PUSH_ENABLED:
+ *
+ * Whether the push parsing interfaces are configured in
+ */
+#if 1
+#define LIBXML_PUSH_ENABLED
+#endif
+
+/**
+ * LIBXML_READER_ENABLED:
+ *
+ * Whether the xmlReader parsing interface is configured in
+ */
+#if 1
+#define LIBXML_READER_ENABLED
+#endif
+
+/**
+ * LIBXML_PATTERN_ENABLED:
+ *
+ * Whether the xmlPattern node selection interface is configured in
+ */
+#if 1
+#define LIBXML_PATTERN_ENABLED
+#endif
+
+/**
+ * LIBXML_WRITER_ENABLED:
+ *
+ * Whether the xmlWriter saving interface is configured in
+ */
+#if 1
+#define LIBXML_WRITER_ENABLED
+#endif
+
+/**
+ * LIBXML_SAX1_ENABLED:
+ *
+ * Whether the older SAX1 interface is configured in
+ */
+#if 1
+#define LIBXML_SAX1_ENABLED
+#endif
+
+/**
+ * LIBXML_FTP_ENABLED:
+ *
+ * Whether the FTP support is configured in
+ */
+#if 1
+#define LIBXML_FTP_ENABLED
+#endif
+
+/**
+ * LIBXML_HTTP_ENABLED:
+ *
+ * Whether the HTTP support is configured in
+ */
+#if 1
+#define LIBXML_HTTP_ENABLED
+#endif
+
+/**
+ * LIBXML_VALID_ENABLED:
+ *
+ * Whether the DTD validation support is configured in
+ */
+#if 1
+#define LIBXML_VALID_ENABLED
+#endif
+
+/**
+ * LIBXML_HTML_ENABLED:
+ *
+ * Whether the HTML support is configured in
+ */
+#if 1
+#define LIBXML_HTML_ENABLED
+#endif
+
+/**
+ * LIBXML_LEGACY_ENABLED:
+ *
+ * Whether the deprecated APIs are compiled in for compatibility
+ */
+#if 1
+#define LIBXML_LEGACY_ENABLED
+#endif
+
+/**
+ * LIBXML_C14N_ENABLED:
+ *
+ * Whether the Canonicalization support is configured in
+ */
+#if 1
+#define LIBXML_C14N_ENABLED
+#endif
+
+/**
+ * LIBXML_CATALOG_ENABLED:
+ *
+ * Whether the Catalog support is configured in
+ */
+#if 1
+#define LIBXML_CATALOG_ENABLED
+#endif
+
+/**
+ * LIBXML_DOCB_ENABLED:
+ *
+ * Whether the SGML Docbook support is configured in
+ */
+#if 1
+#define LIBXML_DOCB_ENABLED
+#endif
+
+/**
+ * LIBXML_XPATH_ENABLED:
+ *
+ * Whether XPath is configured in
+ */
+#if 1
+#define LIBXML_XPATH_ENABLED
+#endif
+
+/**
+ * LIBXML_XPTR_ENABLED:
+ *
+ * Whether XPointer is configured in
+ */
+#if 1
+#define LIBXML_XPTR_ENABLED
+#endif
+
+/**
+ * LIBXML_XINCLUDE_ENABLED:
+ *
+ * Whether XInclude is configured in
+ */
+#if 1
+#define LIBXML_XINCLUDE_ENABLED
+#endif
+
+/**
+ * LIBXML_ICONV_ENABLED:
+ *
+ * Whether iconv support is available
+ */
+#if 1
+#define LIBXML_ICONV_ENABLED
+#endif
+
+/**
+ * LIBXML_ISO8859X_ENABLED:
+ *
+ * Whether ISO-8859-* support is made available in case iconv is not
+ */
+#if 1
+#define LIBXML_ISO8859X_ENABLED
+#endif
+
+/**
+ * LIBXML_DEBUG_ENABLED:
+ *
+ * Whether Debugging module is configured in
+ */
+#if 1
+#define LIBXML_DEBUG_ENABLED
+#endif
+
+/**
+ * DEBUG_MEMORY_LOCATION:
+ *
+ * Whether the memory debugging is configured in
+ */
+#if 0
+#define DEBUG_MEMORY_LOCATION
+#endif
+
+/**
+ * LIBXML_UNICODE_ENABLED:
+ *
+ * Whether the Unicode related interfaces are compiled in
+ */
+#if 1
+#define LIBXML_UNICODE_ENABLED
+#endif
+
+/**
+ * LIBXML_REGEXP_ENABLED:
+ *
+ * Whether the regular expressions interfaces are compiled in
+ */
+#if 1
+#define LIBXML_REGEXP_ENABLED
+#endif
+
+/**
+ * LIBXML_AUTOMATA_ENABLED:
+ *
+ * Whether the automata interfaces are compiled in
+ */
+#if 1
+#define LIBXML_AUTOMATA_ENABLED
+#endif
+
+/**
+ * LIBXML_SCHEMAS_ENABLED:
+ *
+ * Whether the Schemas validation interfaces are compiled in
+ */
+#if 1
+#define LIBXML_SCHEMAS_ENABLED
+#endif
+
+/**
+ * ATTRIBUTE_UNUSED:
+ *
+ * Macro used to signal to GCC unused function parameters
+ */
+#ifdef __GNUC__
+#ifdef HAVE_ANSIDECL_H
+#include <ansidecl.h>
+#endif
+#ifndef ATTRIBUTE_UNUSED
+#define ATTRIBUTE_UNUSED __attribute__((unused))
+#endif
+#else
+#define ATTRIBUTE_UNUSED
+#endif
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+#endif
+
+
diff --git a/src/libxml/include/libxml/xmlwriter.h b/src/libxml/include/libxml/xmlwriter.h
new file mode 100644
index 0000000..f1e1fd8
--- /dev/null
+++ b/src/libxml/include/libxml/xmlwriter.h
@@ -0,0 +1,452 @@
+
+/*
+ * Summary: text writing API for XML
+ * Description: text writing API for XML
+ *
+ * Copy: See Copyright for the status of this software.
+ *
+ * Author: Alfred Mickautsch <alfred@mickautsch.de>
+ */
+
+#ifndef __XML_XMLWRITER_H__
+#define __XML_XMLWRITER_H__
+
+#include <stdarg.h>
+#include <libxml/xmlIO.h>
+#include <libxml/list.h>
+#include <libxml/xmlstring.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+    typedef struct _xmlTextWriter xmlTextWriter;
+    typedef xmlTextWriter *xmlTextWriterPtr;
+
+/*
+ * Constructors & Destructor
+ */
+    XMLPUBFUN xmlTextWriterPtr XMLCALL
+        xmlNewTextWriter(xmlOutputBufferPtr out);
+    XMLPUBFUN xmlTextWriterPtr XMLCALL
+        xmlNewTextWriterFilename(const char *uri, int compression);
+    XMLPUBFUN xmlTextWriterPtr XMLCALL
+        xmlNewTextWriterMemory(xmlBufferPtr buf, int compression);
+    XMLPUBFUN xmlTextWriterPtr XMLCALL
+        xmlNewTextWriterPushParser(xmlParserCtxtPtr ctxt, int compression);
+    XMLPUBFUN xmlTextWriterPtr XMLCALL
+        xmlNewTextWriterDoc(xmlDocPtr * doc, int compression);
+    XMLPUBFUN xmlTextWriterPtr XMLCALL
+        xmlNewTextWriterTree(xmlDocPtr doc, xmlNodePtr node,
+                             int compression);
+    XMLPUBFUN void XMLCALL xmlFreeTextWriter(xmlTextWriterPtr writer);
+
+/*
+ * Functions
+ */
+
+
+/*
+ * Document
+ */
+    XMLPUBFUN int XMLCALL
+        xmlTextWriterStartDocument(xmlTextWriterPtr writer,
+                                   const char *version,
+                                   const char *encoding,
+                                   const char *standalone);
+    XMLPUBFUN int XMLCALL xmlTextWriterEndDocument(xmlTextWriterPtr
+                                                   writer);
+
+/*
+ * Comments
+ */
+    XMLPUBFUN int XMLCALL xmlTextWriterStartComment(xmlTextWriterPtr
+                                                    writer);
+    XMLPUBFUN int XMLCALL xmlTextWriterEndComment(xmlTextWriterPtr writer);
+    XMLPUBFUN int XMLCALL
+        xmlTextWriterWriteFormatComment(xmlTextWriterPtr writer,
+                                        const char *format, ...);
+    XMLPUBFUN int XMLCALL
+        xmlTextWriterWriteVFormatComment(xmlTextWriterPtr writer,
+                                         const char *format,
+                                         va_list argptr);
+    XMLPUBFUN int XMLCALL xmlTextWriterWriteComment(xmlTextWriterPtr
+                                                    writer,
+                                                    const xmlChar *
+                                                    content);
+
+/*
+ * Elements
+ */
+    XMLPUBFUN int XMLCALL
+        xmlTextWriterStartElement(xmlTextWriterPtr writer,
+                                  const xmlChar * name);
+    XMLPUBFUN int XMLCALL xmlTextWriterStartElementNS(xmlTextWriterPtr
+                                                      writer,
+                                                      const xmlChar *
+                                                      prefix,
+                                                      const xmlChar * name,
+                                                      const xmlChar *
+                                                      namespaceURI);
+    XMLPUBFUN int XMLCALL xmlTextWriterEndElement(xmlTextWriterPtr writer);
+    XMLPUBFUN int XMLCALL xmlTextWriterFullEndElement(xmlTextWriterPtr
+                                                      writer);
+
+/*
+ * Elements conveniency functions
+ */
+    XMLPUBFUN int XMLCALL
+        xmlTextWriterWriteFormatElement(xmlTextWriterPtr writer,
+                                        const xmlChar * name,
+                                        const char *format, ...);
+    XMLPUBFUN int XMLCALL
+        xmlTextWriterWriteVFormatElement(xmlTextWriterPtr writer,
+                                         const xmlChar * name,
+                                         const char *format,
+                                         va_list argptr);
+    XMLPUBFUN int XMLCALL xmlTextWriterWriteElement(xmlTextWriterPtr
+                                                    writer,
+                                                    const xmlChar * name,
+                                                    const xmlChar *
+                                                    content);
+    XMLPUBFUN int XMLCALL
+        xmlTextWriterWriteFormatElementNS(xmlTextWriterPtr writer,
+                                          const xmlChar * prefix,
+                                          const xmlChar * name,
+                                          const xmlChar * namespaceURI,
+                                          const char *format, ...);
+    XMLPUBFUN int XMLCALL
+        xmlTextWriterWriteVFormatElementNS(xmlTextWriterPtr writer,
+                                           const xmlChar * prefix,
+                                           const xmlChar * name,
+                                           const xmlChar * namespaceURI,
+                                           const char *format,
+                                           va_list argptr);
+    XMLPUBFUN int XMLCALL xmlTextWriterWriteElementNS(xmlTextWriterPtr
+                                                      writer,
+                                                      const xmlChar *
+                                                      prefix,
+                                                      const xmlChar * name,
+                                                      const xmlChar *
+                                                      namespaceURI,
+                                                      const xmlChar *
+                                                      content);
+
+/*
+ * Text
+ */
+    XMLPUBFUN int XMLCALL
+        xmlTextWriterWriteFormatRaw(xmlTextWriterPtr writer,
+                                    const char *format, ...);
+    XMLPUBFUN int XMLCALL
+        xmlTextWriterWriteVFormatRaw(xmlTextWriterPtr writer,
+                                     const char *format, va_list argptr);
+    XMLPUBFUN int XMLCALL
+        xmlTextWriterWriteRawLen(xmlTextWriterPtr writer,
+                                 const xmlChar * content, int len);
+    XMLPUBFUN int XMLCALL
+        xmlTextWriterWriteRaw(xmlTextWriterPtr writer,
+                              const xmlChar * content);
+    XMLPUBFUN int XMLCALL xmlTextWriterWriteFormatString(xmlTextWriterPtr
+                                                         writer,
+                                                         const char
+                                                         *format, ...);
+    XMLPUBFUN int XMLCALL xmlTextWriterWriteVFormatString(xmlTextWriterPtr
+                                                          writer,
+                                                          const char
+                                                          *format,
+                                                          va_list argptr);
+    XMLPUBFUN int XMLCALL xmlTextWriterWriteString(xmlTextWriterPtr writer,
+                                                   const xmlChar *
+                                                   content);
+    XMLPUBFUN int XMLCALL xmlTextWriterWriteBase64(xmlTextWriterPtr writer,
+                                                   const char *data,
+                                                   int start, int len);
+    XMLPUBFUN int XMLCALL xmlTextWriterWriteBinHex(xmlTextWriterPtr writer,
+                                                   const char *data,
+                                                   int start, int len);
+
+/*
+ * Attributes
+ */
+    XMLPUBFUN int XMLCALL
+        xmlTextWriterStartAttribute(xmlTextWriterPtr writer,
+                                    const xmlChar * name);
+    XMLPUBFUN int XMLCALL xmlTextWriterStartAttributeNS(xmlTextWriterPtr
+                                                        writer,
+                                                        const xmlChar *
+                                                        prefix,
+                                                        const xmlChar *
+                                                        name,
+                                                        const xmlChar *
+                                                        namespaceURI);
+    XMLPUBFUN int XMLCALL xmlTextWriterEndAttribute(xmlTextWriterPtr
+                                                    writer);
+
+/*
+ * Attributes conveniency functions
+ */
+    XMLPUBFUN int XMLCALL
+        xmlTextWriterWriteFormatAttribute(xmlTextWriterPtr writer,
+                                          const xmlChar * name,
+                                          const char *format, ...);
+    XMLPUBFUN int XMLCALL
+        xmlTextWriterWriteVFormatAttribute(xmlTextWriterPtr writer,
+                                           const xmlChar * name,
+                                           const char *format,
+                                           va_list argptr);
+    XMLPUBFUN int XMLCALL xmlTextWriterWriteAttribute(xmlTextWriterPtr
+                                                      writer,
+                                                      const xmlChar * name,
+                                                      const xmlChar *
+                                                      content);
+    XMLPUBFUN int XMLCALL
+        xmlTextWriterWriteFormatAttributeNS(xmlTextWriterPtr writer,
+                                            const xmlChar * prefix,
+                                            const xmlChar * name,
+                                            const xmlChar * namespaceURI,
+                                            const char *format, ...);
+    XMLPUBFUN int XMLCALL
+        xmlTextWriterWriteVFormatAttributeNS(xmlTextWriterPtr writer,
+                                             const xmlChar * prefix,
+                                             const xmlChar * name,
+                                             const xmlChar * namespaceURI,
+                                             const char *format,
+                                             va_list argptr);
+    XMLPUBFUN int XMLCALL xmlTextWriterWriteAttributeNS(xmlTextWriterPtr
+                                                        writer,
+                                                        const xmlChar *
+                                                        prefix,
+                                                        const xmlChar *
+                                                        name,
+                                                        const xmlChar *
+                                                        namespaceURI,
+                                                        const xmlChar *
+                                                        content);
+
+/*
+ * PI's
+ */
+    XMLPUBFUN int XMLCALL
+        xmlTextWriterStartPI(xmlTextWriterPtr writer,
+                             const xmlChar * target);
+    XMLPUBFUN int XMLCALL xmlTextWriterEndPI(xmlTextWriterPtr writer);
+
+/*
+ * PI conveniency functions
+ */
+    XMLPUBFUN int XMLCALL
+        xmlTextWriterWriteFormatPI(xmlTextWriterPtr writer,
+                                   const xmlChar * target,
+                                   const char *format, ...);
+    XMLPUBFUN int XMLCALL
+        xmlTextWriterWriteVFormatPI(xmlTextWriterPtr writer,
+                                    const xmlChar * target,
+                                    const char *format, va_list argptr);
+    XMLPUBFUN int XMLCALL
+        xmlTextWriterWritePI(xmlTextWriterPtr writer,
+                             const xmlChar * target,
+                             const xmlChar * content);
+
+/**
+ * xmlTextWriterWriteProcessingInstruction:
+ *
+ * This macro maps to xmlTextWriterWritePI
+ */
+#define xmlTextWriterWriteProcessingInstruction xmlTextWriterWritePI
+
+/*
+ * CDATA
+ */
+    XMLPUBFUN int XMLCALL xmlTextWriterStartCDATA(xmlTextWriterPtr writer);
+    XMLPUBFUN int XMLCALL xmlTextWriterEndCDATA(xmlTextWriterPtr writer);
+
+/*
+ * CDATA conveniency functions
+ */
+    XMLPUBFUN int XMLCALL
+        xmlTextWriterWriteFormatCDATA(xmlTextWriterPtr writer,
+                                      const char *format, ...);
+    XMLPUBFUN int XMLCALL
+        xmlTextWriterWriteVFormatCDATA(xmlTextWriterPtr writer,
+                                       const char *format, va_list argptr);
+    XMLPUBFUN int XMLCALL
+        xmlTextWriterWriteCDATA(xmlTextWriterPtr writer,
+                                const xmlChar * content);
+
+/*
+ * DTD
+ */
+    XMLPUBFUN int XMLCALL
+        xmlTextWriterStartDTD(xmlTextWriterPtr writer,
+                              const xmlChar * name,
+                              const xmlChar * pubid,
+                              const xmlChar * sysid);
+    XMLPUBFUN int XMLCALL xmlTextWriterEndDTD(xmlTextWriterPtr writer);
+
+/*
+ * DTD conveniency functions
+ */
+    XMLPUBFUN int XMLCALL
+        xmlTextWriterWriteFormatDTD(xmlTextWriterPtr writer,
+                                    const xmlChar * name,
+                                    const xmlChar * pubid,
+                                    const xmlChar * sysid,
+                                    const char *format, ...);
+    XMLPUBFUN int XMLCALL
+        xmlTextWriterWriteVFormatDTD(xmlTextWriterPtr writer,
+                                     const xmlChar * name,
+                                     const xmlChar * pubid,
+                                     const xmlChar * sysid,
+                                     const char *format, va_list argptr);
+    XMLPUBFUN int XMLCALL
+        xmlTextWriterWriteDTD(xmlTextWriterPtr writer,
+                              const xmlChar * name,
+                              const xmlChar * pubid,
+                              const xmlChar * sysid,
+                              const xmlChar * subset);
+
+/**
+ * xmlTextWriterWriteDocType:
+ *
+ * this macro maps to xmlTextWriterWriteDTD
+ */
+#define xmlTextWriterWriteDocType xmlTextWriterWriteDTD
+
+/*
+ * DTD element definition
+ */
+    XMLPUBFUN int XMLCALL
+        xmlTextWriterStartDTDElement(xmlTextWriterPtr writer,
+                                     const xmlChar * name);
+    XMLPUBFUN int XMLCALL xmlTextWriterEndDTDElement(xmlTextWriterPtr
+                                                     writer);
+
+/*
+ * DTD element definition conveniency functions
+ */
+    XMLPUBFUN int XMLCALL
+        xmlTextWriterWriteFormatDTDElement(xmlTextWriterPtr writer,
+                                           const xmlChar * name,
+                                           const char *format, ...);
+    XMLPUBFUN int XMLCALL
+        xmlTextWriterWriteVFormatDTDElement(xmlTextWriterPtr writer,
+                                            const xmlChar * name,
+                                            const char *format,
+                                            va_list argptr);
+    XMLPUBFUN int XMLCALL xmlTextWriterWriteDTDElement(xmlTextWriterPtr
+                                                       writer,
+                                                       const xmlChar *
+                                                       name,
+                                                       const xmlChar *
+                                                       content);
+
+/*
+ * DTD attribute list definition
+ */
+    XMLPUBFUN int XMLCALL
+        xmlTextWriterStartDTDAttlist(xmlTextWriterPtr writer,
+                                     const xmlChar * name);
+    XMLPUBFUN int XMLCALL xmlTextWriterEndDTDAttlist(xmlTextWriterPtr
+                                                     writer);
+
+/*
+ * DTD attribute list definition conveniency functions
+ */
+    XMLPUBFUN int XMLCALL
+        xmlTextWriterWriteFormatDTDAttlist(xmlTextWriterPtr writer,
+                                           const xmlChar * name,
+                                           const char *format, ...);
+    XMLPUBFUN int XMLCALL
+        xmlTextWriterWriteVFormatDTDAttlist(xmlTextWriterPtr writer,
+                                            const xmlChar * name,
+                                            const char *format,
+                                            va_list argptr);
+    XMLPUBFUN int XMLCALL xmlTextWriterWriteDTDAttlist(xmlTextWriterPtr
+                                                       writer,
+                                                       const xmlChar *
+                                                       name,
+                                                       const xmlChar *
+                                                       content);
+
+/*
+ * DTD entity definition
+ */
+    XMLPUBFUN int XMLCALL
+        xmlTextWriterStartDTDEntity(xmlTextWriterPtr writer,
+                                    int pe, const xmlChar * name);
+    XMLPUBFUN int XMLCALL xmlTextWriterEndDTDEntity(xmlTextWriterPtr
+                                                    writer);
+
+/*
+ * DTD entity definition conveniency functions
+ */
+    XMLPUBFUN int XMLCALL
+        xmlTextWriterWriteFormatDTDInternalEntity(xmlTextWriterPtr writer,
+                                                  int pe,
+                                                  const xmlChar * name,
+                                                  const char *format, ...);
+    XMLPUBFUN int XMLCALL
+        xmlTextWriterWriteVFormatDTDInternalEntity(xmlTextWriterPtr writer,
+                                                   int pe,
+                                                   const xmlChar * name,
+                                                   const char *format,
+                                                   va_list argptr);
+    XMLPUBFUN int XMLCALL
+        xmlTextWriterWriteDTDInternalEntity(xmlTextWriterPtr writer,
+                                            int pe,
+                                            const xmlChar * name,
+                                            const xmlChar * content);
+    XMLPUBFUN int XMLCALL
+        xmlTextWriterWriteDTDExternalEntity(xmlTextWriterPtr writer,
+                                            int pe,
+                                            const xmlChar * name,
+                                            const xmlChar * pubid,
+                                            const xmlChar * sysid,
+                                            const xmlChar * ndataid);
+    XMLPUBFUN int XMLCALL
+        xmlTextWriterWriteDTDExternalEntityContents(xmlTextWriterPtr
+                                                    writer,
+                                                    const xmlChar * pubid,
+                                                    const xmlChar * sysid,
+                                                    const xmlChar *
+                                                    ndataid);
+    XMLPUBFUN int XMLCALL xmlTextWriterWriteDTDEntity(xmlTextWriterPtr
+                                                      writer, int pe,
+                                                      const xmlChar * name,
+                                                      const xmlChar *
+                                                      pubid,
+                                                      const xmlChar *
+                                                      sysid,
+                                                      const xmlChar *
+                                                      ndataid,
+                                                      const xmlChar *
+                                                      content);
+
+/*
+ * DTD notation definition
+ */
+    XMLPUBFUN int XMLCALL
+        xmlTextWriterWriteDTDNotation(xmlTextWriterPtr writer,
+                                      const xmlChar * name,
+                                      const xmlChar * pubid,
+                                      const xmlChar * sysid);
+
+/*
+ * Indentation
+ */
+    XMLPUBFUN int XMLCALL
+        xmlTextWriterSetIndent(xmlTextWriterPtr writer, int indent);
+    XMLPUBFUN int XMLCALL
+        xmlTextWriterSetIndentString(xmlTextWriterPtr writer,
+                                     const xmlChar * str);
+
+/*
+ * misc
+ */
+    XMLPUBFUN int XMLCALL xmlTextWriterFlush(xmlTextWriterPtr writer);
+
+#ifdef __cplusplus
+}
+#endif
+#endif                          /* __XML_XMLWRITER_H__ */
diff --git a/src/libxml/include/libxml/xpath.h b/src/libxml/include/libxml/xpath.h
new file mode 100644
index 0000000..41def0c
--- /dev/null
+++ b/src/libxml/include/libxml/xpath.h
@@ -0,0 +1,467 @@
+/*
+ * Summary: XML Path Language implementation
+ * Description: API for the XML Path Language implementation
+ *
+ * XML Path Language implementation
+ * XPath is a language for addressing parts of an XML document,
+ * designed to be used by both XSLT and XPointer
+ *     http://www.w3.org/TR/xpath
+ *
+ * Implements
+ * W3C Recommendation 16 November 1999
+ *     http://www.w3.org/TR/1999/REC-xpath-19991116
+ *
+ * Copy: See Copyright for the status of this software.
+ *
+ * Author: Daniel Veillard
+ */
+
+#ifndef __XML_XPATH_H__
+#define __XML_XPATH_H__
+
+#include <libxml/xmlversion.h>
+#include <libxml/xmlerror.h>
+#include <libxml/tree.h>
+#include <libxml/hash.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct _xmlXPathContext xmlXPathContext;
+typedef xmlXPathContext *xmlXPathContextPtr;
+typedef struct _xmlXPathParserContext xmlXPathParserContext;
+typedef xmlXPathParserContext *xmlXPathParserContextPtr;
+
+/**
+ * The set of XPath error codes.
+ */
+
+typedef enum {
+    XPATH_EXPRESSION_OK = 0,
+    XPATH_NUMBER_ERROR,
+    XPATH_UNFINISHED_LITERAL_ERROR,
+    XPATH_START_LITERAL_ERROR,
+    XPATH_VARIABLE_REF_ERROR,
+    XPATH_UNDEF_VARIABLE_ERROR,
+    XPATH_INVALID_PREDICATE_ERROR,
+    XPATH_EXPR_ERROR,
+    XPATH_UNCLOSED_ERROR,
+    XPATH_UNKNOWN_FUNC_ERROR,
+    XPATH_INVALID_OPERAND,
+    XPATH_INVALID_TYPE,
+    XPATH_INVALID_ARITY,
+    XPATH_INVALID_CTXT_SIZE,
+    XPATH_INVALID_CTXT_POSITION,
+    XPATH_MEMORY_ERROR,
+    XPTR_SYNTAX_ERROR,
+    XPTR_RESOURCE_ERROR,
+    XPTR_SUB_RESOURCE_ERROR,
+    XPATH_UNDEF_PREFIX_ERROR,
+    XPATH_ENCODING_ERROR,
+    XPATH_INVALID_CHAR_ERROR
+} xmlXPathError;
+
+/*
+ * A node-set (an unordered collection of nodes without duplicates).
+ */
+typedef struct _xmlNodeSet xmlNodeSet;
+typedef xmlNodeSet *xmlNodeSetPtr;
+struct _xmlNodeSet {
+    int nodeNr;			/* number of nodes in the set */
+    int nodeMax;		/* size of the array as allocated */
+    xmlNodePtr *nodeTab;	/* array of nodes in no particular order */
+    /* @@ with_ns to check wether namespace nodes should be looked at @@ */
+};
+
+/*
+ * An expression is evaluated to yield an object, which
+ * has one of the following four basic types:
+ *   - node-set
+ *   - boolean
+ *   - number
+ *   - string
+ *
+ * @@ XPointer will add more types !
+ */
+
+typedef enum {
+    XPATH_UNDEFINED = 0,
+    XPATH_NODESET = 1,
+    XPATH_BOOLEAN = 2,
+    XPATH_NUMBER = 3,
+    XPATH_STRING = 4,
+    XPATH_POINT = 5,
+    XPATH_RANGE = 6,
+    XPATH_LOCATIONSET = 7,
+    XPATH_USERS = 8,
+    XPATH_XSLT_TREE = 9  /* An XSLT value tree, non modifiable */
+} xmlXPathObjectType;
+
+typedef struct _xmlXPathObject xmlXPathObject;
+typedef xmlXPathObject *xmlXPathObjectPtr;
+struct _xmlXPathObject {
+    xmlXPathObjectType type;
+    xmlNodeSetPtr nodesetval;
+    int boolval;
+    double floatval;
+    xmlChar *stringval;
+    void *user;
+    int index;
+    void *user2;
+    int index2;
+};
+
+/**
+ * xmlXPathConvertFunc:
+ * @obj:  an XPath object
+ * @type:  the number of the target type
+ *
+ * A conversion function is associated to a type and used to cast
+ * the new type to primitive values.
+ *
+ * Returns -1 in case of error, 0 otherwise
+ */
+typedef int (*xmlXPathConvertFunc) (xmlXPathObjectPtr obj, int type);
+
+/*
+ * Extra type: a name and a conversion function.
+ */
+
+typedef struct _xmlXPathType xmlXPathType;
+typedef xmlXPathType *xmlXPathTypePtr;
+struct _xmlXPathType {
+    const xmlChar         *name;		/* the type name */
+    xmlXPathConvertFunc func;		/* the conversion function */
+};
+
+/*
+ * Extra variable: a name and a value.
+ */
+
+typedef struct _xmlXPathVariable xmlXPathVariable;
+typedef xmlXPathVariable *xmlXPathVariablePtr;
+struct _xmlXPathVariable {
+    const xmlChar       *name;		/* the variable name */
+    xmlXPathObjectPtr value;		/* the value */
+};
+
+/**
+ * xmlXPathEvalFunc:
+ * @ctxt: an XPath parser context
+ * @nargs: the number of arguments passed to the function
+ *
+ * An XPath evaluation function, the parameters are on the XPath context stack.
+ */
+
+typedef void (*xmlXPathEvalFunc)(xmlXPathParserContextPtr ctxt,
+	                         int nargs);
+
+/*
+ * Extra function: a name and a evaluation function.
+ */
+
+typedef struct _xmlXPathFunct xmlXPathFunct;
+typedef xmlXPathFunct *xmlXPathFuncPtr;
+struct _xmlXPathFunct {
+    const xmlChar      *name;		/* the function name */
+    xmlXPathEvalFunc func;		/* the evaluation function */
+};
+
+/**
+ * xmlXPathAxisFunc:
+ * @ctxt:  the XPath interpreter context
+ * @cur:  the previous node being explored on that axis
+ *
+ * An axis traversal function. To traverse an axis, the engine calls
+ * the first time with cur == NULL and repeat until the function returns
+ * NULL indicating the end of the axis traversal.
+ *
+ * Returns the next node in that axis or NULL if at the end of the axis.
+ */
+
+typedef xmlXPathObjectPtr (*xmlXPathAxisFunc) (xmlXPathParserContextPtr ctxt,
+				 xmlXPathObjectPtr cur);
+
+/*
+ * Extra axis: a name and an axis function.
+ */
+
+typedef struct _xmlXPathAxis xmlXPathAxis;
+typedef xmlXPathAxis *xmlXPathAxisPtr;
+struct _xmlXPathAxis {
+    const xmlChar      *name;		/* the axis name */
+    xmlXPathAxisFunc func;		/* the search function */
+};
+
+/**
+ * xmlXPathContext:
+ *
+ * Expression evaluation occurs with respect to a context.
+ * he context consists of:
+ *    - a node (the context node) 
+ *    - a node list (the context node list) 
+ *    - a set of variable bindings 
+ *    - a function library 
+ *    - the set of namespace declarations in scope for the expression 
+ * Following the switch to hash tables, this need to be trimmed up at
+ * the next binary incompatible release.
+ */
+
+struct _xmlXPathContext {
+    xmlDocPtr doc;			/* The current document */
+    xmlNodePtr node;			/* The current node */
+
+    int nb_variables_unused;		/* unused (hash table) */
+    int max_variables_unused;		/* unused (hash table) */
+    xmlHashTablePtr varHash;		/* Hash table of defined variables */
+
+    int nb_types;			/* number of defined types */
+    int max_types;			/* max number of types */
+    xmlXPathTypePtr types;		/* Array of defined types */
+
+    int nb_funcs_unused;		/* unused (hash table) */
+    int max_funcs_unused;		/* unused (hash table) */
+    xmlHashTablePtr funcHash;		/* Hash table of defined funcs */
+
+    int nb_axis;			/* number of defined axis */
+    int max_axis;			/* max number of axis */
+    xmlXPathAxisPtr axis;		/* Array of defined axis */
+
+    /* the namespace nodes of the context node */
+    xmlNsPtr *namespaces;		/* Array of namespaces */
+    int nsNr;				/* number of namespace in scope */
+    void *user;				/* function to free */
+
+    /* extra variables */
+    int contextSize;			/* the context size */
+    int proximityPosition;		/* the proximity position */
+
+    /* extra stuff for XPointer */
+    int xptr;				/* it this an XPointer context */
+    xmlNodePtr here;			/* for here() */
+    xmlNodePtr origin;			/* for origin() */
+
+    /* the set of namespace declarations in scope for the expression */
+    xmlHashTablePtr nsHash;		/* The namespaces hash table */
+    void *varLookupFunc;		/* variable lookup func */
+    void *varLookupData;		/* variable lookup data */
+
+    /* Possibility to link in an extra item */
+    void *extra;                        /* needed for XSLT */
+
+    /* The function name and URI when calling a function */
+    const xmlChar *function;
+    const xmlChar *functionURI;
+
+    /* function lookup function and data */
+    void *funcLookupFunc;		/* function lookup func */
+    void *funcLookupData;		/* function lookup data */
+
+    /* temporary namespace lists kept for walking the namespace axis */
+    xmlNsPtr *tmpNsList;		/* Array of namespaces */
+    int tmpNsNr;			/* number of namespace in scope */
+
+    /* error reporting mechanism */
+    void *userData;                     /* user specific data block */
+    xmlStructuredErrorFunc error;       /* the callback in case of errors */
+    xmlError lastError;			/* the last error */
+    xmlNodePtr debugNode;		/* the source node XSLT */
+
+    /* dictionnary */
+    xmlDictPtr dict;			/* dictionnary if any */
+};
+
+/*
+ * The structure of a compiled expression form is not public.
+ */
+
+typedef struct _xmlXPathCompExpr xmlXPathCompExpr;
+typedef xmlXPathCompExpr *xmlXPathCompExprPtr;
+
+/**
+ * xmlXPathParserContext:
+ *
+ * An XPath parser context. It contains pure parsing informations,
+ * an xmlXPathContext, and the stack of objects.
+ */
+struct _xmlXPathParserContext {
+    const xmlChar *cur;			/* the current char being parsed */
+    const xmlChar *base;			/* the full expression */
+
+    int error;				/* error code */
+
+    xmlXPathContextPtr  context;	/* the evaluation context */
+    xmlXPathObjectPtr     value;	/* the current value */
+    int                 valueNr;	/* number of values stacked */
+    int                valueMax;	/* max number of values stacked */
+    xmlXPathObjectPtr *valueTab;	/* stack of values */
+
+    xmlXPathCompExprPtr comp;		/* the precompiled expression */
+    int xptr;				/* it this an XPointer expression */
+    xmlNodePtr         ancestor;	/* used for walking preceding axis */
+};
+
+/**
+ * xmlXPathFunction:
+ * @ctxt:  the XPath interprestation context
+ * @nargs:  the number of arguments
+ *
+ * An XPath function.
+ * The arguments (if any) are popped out from the context stack
+ * and the result is pushed on the stack.
+ */
+
+typedef void (*xmlXPathFunction) (xmlXPathParserContextPtr ctxt, int nargs);
+
+/************************************************************************
+ *									*
+ *			Public API					*
+ *									*
+ ************************************************************************/
+
+/**
+ * Objects and Nodesets handling
+ */
+
+XMLPUBVAR double xmlXPathNAN;
+XMLPUBVAR double xmlXPathPINF;
+XMLPUBVAR double xmlXPathNINF;
+
+XMLPUBFUN int XMLCALL
+		xmlXPathIsNaN	(double val);
+XMLPUBFUN int XMLCALL
+		xmlXPathIsInf	(double val);
+
+/* These macros may later turn into functions */
+/**
+ * xmlXPathNodeSetGetLength:
+ * @ns:  a node-set
+ *
+ * Implement a functionality similar to the DOM NodeList.length.
+ *
+ * Returns the number of nodes in the node-set.
+ */
+#define xmlXPathNodeSetGetLength(ns) ((ns) ? (ns)->nodeNr : 0)
+/**
+ * xmlXPathNodeSetItem:
+ * @ns:  a node-set
+ * @index:  index of a node in the set
+ *
+ * Implements a functionality similar to the DOM NodeList.item().
+ *
+ * Returns the xmlNodePtr at the given @index in @ns or NULL if
+ *         @index is out of range (0 to length-1)
+ */
+#define xmlXPathNodeSetItem(ns, index)				\
+		((((ns) != NULL) && 				\
+		  ((index) >= 0) && ((index) < (ns)->nodeNr)) ?	\
+		 (ns)->nodeTab[(index)]				\
+		 : NULL)
+/**
+ * xmlXPathNodeSetIsEmpty:
+ * @ns: a node-set
+ *
+ * Checks whether @ns is empty or not.
+ *
+ * Returns %TRUE if @ns is an empty node-set.
+ */
+#define xmlXPathNodeSetIsEmpty(ns)                                      \
+    (((ns) == NULL) || ((ns)->nodeNr == 0) || ((ns)->nodeTab == NULL))
+
+
+XMLPUBFUN void XMLCALL		   
+		    xmlXPathFreeObject		(xmlXPathObjectPtr obj);
+XMLPUBFUN xmlNodeSetPtr XMLCALL	   
+		    xmlXPathNodeSetCreate	(xmlNodePtr val);
+XMLPUBFUN void XMLCALL		   
+		    xmlXPathFreeNodeSetList	(xmlXPathObjectPtr obj);
+XMLPUBFUN void XMLCALL		   
+		    xmlXPathFreeNodeSet		(xmlNodeSetPtr obj);
+XMLPUBFUN xmlXPathObjectPtr XMLCALL  
+		    xmlXPathObjectCopy		(xmlXPathObjectPtr val);
+XMLPUBFUN int XMLCALL		   
+		    xmlXPathCmpNodes		(xmlNodePtr node1,
+						 xmlNodePtr node2);
+/**
+ * Conversion functions to basic types.
+ */
+XMLPUBFUN int XMLCALL		   
+		    xmlXPathCastNumberToBoolean	(double val);
+XMLPUBFUN int XMLCALL		   
+		    xmlXPathCastStringToBoolean	(const xmlChar * val);
+XMLPUBFUN int XMLCALL		   
+		    xmlXPathCastNodeSetToBoolean(xmlNodeSetPtr ns);
+XMLPUBFUN int XMLCALL		   
+		    xmlXPathCastToBoolean	(xmlXPathObjectPtr val);
+
+XMLPUBFUN double XMLCALL		   
+		    xmlXPathCastBooleanToNumber	(int val);
+XMLPUBFUN double XMLCALL		   
+		    xmlXPathCastStringToNumber	(const xmlChar * val);
+XMLPUBFUN double XMLCALL		   
+		    xmlXPathCastNodeToNumber	(xmlNodePtr node);
+XMLPUBFUN double XMLCALL		   
+		    xmlXPathCastNodeSetToNumber	(xmlNodeSetPtr ns);
+XMLPUBFUN double XMLCALL		   
+		    xmlXPathCastToNumber	(xmlXPathObjectPtr val);
+
+XMLPUBFUN xmlChar * XMLCALL	   
+		    xmlXPathCastBooleanToString	(int val);
+XMLPUBFUN xmlChar * XMLCALL	   
+		    xmlXPathCastNumberToString	(double val);
+XMLPUBFUN xmlChar * XMLCALL	   
+		    xmlXPathCastNodeToString	(xmlNodePtr node);
+XMLPUBFUN xmlChar * XMLCALL	   
+		    xmlXPathCastNodeSetToString	(xmlNodeSetPtr ns);
+XMLPUBFUN xmlChar * XMLCALL	   
+		    xmlXPathCastToString	(xmlXPathObjectPtr val);
+
+XMLPUBFUN xmlXPathObjectPtr XMLCALL  
+		    xmlXPathConvertBoolean	(xmlXPathObjectPtr val);
+XMLPUBFUN xmlXPathObjectPtr XMLCALL  
+		    xmlXPathConvertNumber	(xmlXPathObjectPtr val);
+XMLPUBFUN xmlXPathObjectPtr XMLCALL  
+		    xmlXPathConvertString	(xmlXPathObjectPtr val);
+
+/**
+ * Context handling.
+ */
+XMLPUBFUN void XMLCALL		   
+		    xmlXPathInit		(void);
+XMLPUBFUN xmlXPathContextPtr XMLCALL 
+		    xmlXPathNewContext		(xmlDocPtr doc);
+XMLPUBFUN void XMLCALL		   
+		    xmlXPathFreeContext		(xmlXPathContextPtr ctxt);
+
+/**
+ * Evaluation functions.
+ */
+XMLPUBFUN long XMLCALL               
+		    xmlXPathOrderDocElems	(xmlDocPtr doc);
+XMLPUBFUN xmlXPathObjectPtr XMLCALL  
+		    xmlXPathEval		(const xmlChar *str,
+						 xmlXPathContextPtr ctx);
+XMLPUBFUN xmlXPathObjectPtr XMLCALL  
+		    xmlXPathEvalExpression	(const xmlChar *str,
+						 xmlXPathContextPtr ctxt);
+XMLPUBFUN int XMLCALL                
+		    xmlXPathEvalPredicate	(xmlXPathContextPtr ctxt,
+						 xmlXPathObjectPtr res);
+/**
+ * Separate compilation/evaluation entry points.
+ */
+XMLPUBFUN xmlXPathCompExprPtr XMLCALL 
+		    xmlXPathCompile		(const xmlChar *str);
+XMLPUBFUN xmlXPathCompExprPtr XMLCALL 
+		    xmlXPathCtxtCompile		(xmlXPathContextPtr ctxt,
+		    				 const xmlChar *str);
+XMLPUBFUN xmlXPathObjectPtr XMLCALL   
+		    xmlXPathCompiledEval	(xmlXPathCompExprPtr comp,
+						 xmlXPathContextPtr ctx);
+XMLPUBFUN void XMLCALL                
+		    xmlXPathFreeCompExpr	(xmlXPathCompExprPtr comp);
+#ifdef __cplusplus
+}
+#endif
+#endif /* ! __XML_XPATH_H__ */
diff --git a/src/libxml/include/libxml/xpathInternals.h b/src/libxml/include/libxml/xpathInternals.h
new file mode 100644
index 0000000..75e5d74
--- /dev/null
+++ b/src/libxml/include/libxml/xpathInternals.h
@@ -0,0 +1,653 @@
+/*
+ * Summary: internal interfaces for XML Path Language implementation
+ * Description: internal interfaces for XML Path Language implementation
+ *              used to build new modules on top of XPath like XPointer and
+ *              XSLT
+ *
+ * Copy: See Copyright for the status of this software.
+ *
+ * Author: Daniel Veillard
+ */
+
+#ifndef __XML_XPATH_INTERNALS_H__
+#define __XML_XPATH_INTERNALS_H__
+
+#include <libxml/xmlversion.h>
+#include <libxml/xpath.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/************************************************************************
+ *									*
+ *			Helpers						*
+ *									*
+ ************************************************************************/
+
+/*
+ * Many of these macros may later turn into functions. They
+ * shouldn't be used in #ifdef's preprocessor instructions.
+ */
+/**
+ * xmlXPathSetError:
+ * @ctxt:  an XPath parser context
+ * @err:  an xmlXPathError code
+ *
+ * Raises an error.
+ */
+#define xmlXPathSetError(ctxt, err)					\
+    { xmlXPatherror((ctxt), __FILE__, __LINE__, (err));			\
+      (ctxt)->error = (err); }
+
+/**
+ * xmlXPathSetArityError:
+ * @ctxt:  an XPath parser context
+ *
+ * Raises an XPATH_INVALID_ARITY error.
+ */
+#define xmlXPathSetArityError(ctxt)					\
+    xmlXPathSetError((ctxt), XPATH_INVALID_ARITY)
+
+/**
+ * xmlXPathSetTypeError:
+ * @ctxt:  an XPath parser context
+ *
+ * Raises an XPATH_INVALID_TYPE error.
+ */
+#define xmlXPathSetTypeError(ctxt)					\
+    xmlXPathSetError((ctxt), XPATH_INVALID_TYPE)
+
+/**
+ * xmlXPathGetError:
+ * @ctxt:  an XPath parser context
+ *
+ * Get the error code of an XPath context.
+ *
+ * Returns the context error.
+ */
+#define xmlXPathGetError(ctxt)	  ((ctxt)->error)
+
+/**
+ * xmlXPathCheckError:
+ * @ctxt:  an XPath parser context
+ *
+ * Check if an XPath error was raised.
+ *
+ * Returns true if an error has been raised, false otherwise.
+ */
+#define xmlXPathCheckError(ctxt)  ((ctxt)->error != XPATH_EXPRESSION_OK)
+
+/**
+ * xmlXPathGetDocument:
+ * @ctxt:  an XPath parser context
+ *
+ * Get the document of an XPath context.
+ *
+ * Returns the context document.
+ */
+#define xmlXPathGetDocument(ctxt)	((ctxt)->context->doc)
+
+/**
+ * xmlXPathGetContextNode:
+ * @ctxt: an XPath parser context
+ *
+ * Get the context node of an XPath context.
+ *
+ * Returns the context node.
+ */
+#define xmlXPathGetContextNode(ctxt)	((ctxt)->context->node)
+
+XMLPUBFUN int XMLCALL		
+		xmlXPathPopBoolean	(xmlXPathParserContextPtr ctxt);
+XMLPUBFUN double XMLCALL		
+    		xmlXPathPopNumber	(xmlXPathParserContextPtr ctxt);
+XMLPUBFUN xmlChar * XMLCALL	
+    		xmlXPathPopString	(xmlXPathParserContextPtr ctxt);
+XMLPUBFUN xmlNodeSetPtr XMLCALL	
+    		xmlXPathPopNodeSet	(xmlXPathParserContextPtr ctxt);
+XMLPUBFUN void * XMLCALL		
+    		xmlXPathPopExternal	(xmlXPathParserContextPtr ctxt);
+
+/**
+ * xmlXPathReturnBoolean:
+ * @ctxt:  an XPath parser context
+ * @val:  a boolean
+ *
+ * Pushes the boolean @val on the context stack.
+ */
+#define xmlXPathReturnBoolean(ctxt, val)				\
+    valuePush((ctxt), xmlXPathNewBoolean(val))
+
+/**
+ * xmlXPathReturnTrue:
+ * @ctxt:  an XPath parser context
+ *
+ * Pushes true on the context stack.
+ */
+#define xmlXPathReturnTrue(ctxt)   xmlXPathReturnBoolean((ctxt), 1)
+
+/**
+ * xmlXPathReturnFalse:
+ * @ctxt:  an XPath parser context
+ *
+ * Pushes false on the context stack.
+ */
+#define xmlXPathReturnFalse(ctxt)  xmlXPathReturnBoolean((ctxt), 0)
+
+/**
+ * xmlXPathReturnNumber:
+ * @ctxt:  an XPath parser context
+ * @val:  a double
+ *
+ * Pushes the double @val on the context stack.
+ */
+#define xmlXPathReturnNumber(ctxt, val)					\
+    valuePush((ctxt), xmlXPathNewFloat(val))
+
+/**
+ * xmlXPathReturnString:
+ * @ctxt:  an XPath parser context
+ * @str:  a string
+ *
+ * Pushes the string @str on the context stack.
+ */
+#define xmlXPathReturnString(ctxt, str)					\
+    valuePush((ctxt), xmlXPathWrapString(str))
+
+/**
+ * xmlXPathReturnEmptyString:
+ * @ctxt:  an XPath parser context
+ *
+ * Pushes an empty string on the stack.
+ */
+#define xmlXPathReturnEmptyString(ctxt)					\
+    valuePush((ctxt), xmlXPathNewCString(""))
+
+/**
+ * xmlXPathReturnNodeSet:
+ * @ctxt:  an XPath parser context
+ * @ns:  a node-set
+ *
+ * Pushes the node-set @ns on the context stack.
+ */
+#define xmlXPathReturnNodeSet(ctxt, ns)					\
+    valuePush((ctxt), xmlXPathWrapNodeSet(ns))
+
+/**
+ * xmlXPathReturnEmptyNodeSet:
+ * @ctxt:  an XPath parser context
+ *
+ * Pushes an empty node-set on the context stack.
+ */
+#define xmlXPathReturnEmptyNodeSet(ctxt)				\
+    valuePush((ctxt), xmlXPathNewNodeSet(NULL))
+
+/**
+ * xmlXPathReturnExternal:
+ * @ctxt:  an XPath parser context
+ * @val:  user data
+ *
+ * Pushes user data on the context stack.
+ */
+#define xmlXPathReturnExternal(ctxt, val)				\
+    valuePush((ctxt), xmlXPathWrapExternal(val))
+
+/**
+ * xmlXPathStackIsNodeSet:
+ * @ctxt: an XPath parser context
+ *
+ * Check if the current value on the XPath stack is a node set or
+ * an XSLT value tree.
+ *
+ * Returns true if the current object on the stack is a node-set.
+ */
+#define xmlXPathStackIsNodeSet(ctxt)					\
+    (((ctxt)->value != NULL)						\
+     && (((ctxt)->value->type == XPATH_NODESET)				\
+         || ((ctxt)->value->type == XPATH_XSLT_TREE)))
+
+/**
+ * xmlXPathStackIsExternal:
+ * @ctxt: an XPath parser context
+ *
+ * Checks if the current value on the XPath stack is an external
+ * object.
+ *
+ * Returns true if the current object on the stack is an external
+ * object.
+ */
+#define xmlXPathStackIsExternal(ctxt)					\
+	((ctxt->value != NULL) && (ctxt->value->type == XPATH_USERS))
+
+/**
+ * xmlXPathEmptyNodeSet:
+ * @ns:  a node-set
+ *
+ * Empties a node-set.
+ */
+#define xmlXPathEmptyNodeSet(ns)					\
+    { while ((ns)->nodeNr > 0) (ns)->nodeTab[(ns)->nodeNr--] = NULL; }
+
+/**
+ * CHECK_ERROR:
+ *
+ * Macro to return from the function if an XPath error was detected.
+ */
+#define CHECK_ERROR							\
+    if (ctxt->error != XPATH_EXPRESSION_OK) return
+
+/**
+ * CHECK_ERROR0:
+ *
+ * Macro to return 0 from the function if an XPath error was detected.
+ */
+#define CHECK_ERROR0							\
+    if (ctxt->error != XPATH_EXPRESSION_OK) return(0)
+
+/**
+ * XP_ERROR:
+ * @X:  the error code
+ *
+ * Macro to raise an XPath error and return.
+ */
+#define XP_ERROR(X)							\
+    { xmlXPathErr(ctxt, X); return; }
+
+/**
+ * XP_ERROR0:
+ * @X:  the error code
+ *
+ * Macro to raise an XPath error and return 0.
+ */
+#define XP_ERROR0(X)							\
+    { xmlXPathErr(ctxt, X); return(0); }
+
+/**
+ * CHECK_TYPE:
+ * @typeval:  the XPath type
+ *
+ * Macro to check that the value on top of the XPath stack is of a given
+ * type.
+ */
+#define CHECK_TYPE(typeval)						\
+    if ((ctxt->value == NULL) || (ctxt->value->type != typeval))	\
+        XP_ERROR(XPATH_INVALID_TYPE)
+
+/**
+ * CHECK_TYPE0:
+ * @typeval:  the XPath type
+ *
+ * Macro to check that the value on top of the XPath stack is of a given
+ * type. Return(0) in case of failure
+ */
+#define CHECK_TYPE0(typeval)						\
+    if ((ctxt->value == NULL) || (ctxt->value->type != typeval))	\
+        XP_ERROR0(XPATH_INVALID_TYPE)
+
+/**
+ * CHECK_ARITY:
+ * @x:  the number of expected args
+ *
+ * Macro to check that the number of args passed to an XPath function matches.
+ */
+#define CHECK_ARITY(x)							\
+    if (nargs != (x))							\
+        XP_ERROR(XPATH_INVALID_ARITY);
+
+/**
+ * CAST_TO_STRING:
+ *
+ * Macro to try to cast the value on the top of the XPath stack to a string.
+ */
+#define CAST_TO_STRING							\
+    if ((ctxt->value != NULL) && (ctxt->value->type != XPATH_STRING))	\
+        xmlXPathStringFunction(ctxt, 1);
+
+/**
+ * CAST_TO_NUMBER:
+ *
+ * Macro to try to cast the value on the top of the XPath stack to a number.
+ */
+#define CAST_TO_NUMBER							\
+    if ((ctxt->value != NULL) && (ctxt->value->type != XPATH_NUMBER))	\
+        xmlXPathNumberFunction(ctxt, 1);
+
+/**
+ * CAST_TO_BOOLEAN:
+ *
+ * Macro to try to cast the value on the top of the XPath stack to a boolean.
+ */
+#define CAST_TO_BOOLEAN							\
+    if ((ctxt->value != NULL) && (ctxt->value->type != XPATH_BOOLEAN))	\
+        xmlXPathBooleanFunction(ctxt, 1);
+
+/*
+ * Variable Lookup forwarding.
+ */
+/**
+ * xmlXPathVariableLookupFunc:
+ * @ctxt:  an XPath context
+ * @name:  name of the variable
+ * @ns_uri:  the namespace name hosting this variable
+ *
+ * Prototype for callbacks used to plug variable lookup in the XPath
+ * engine.
+ *
+ * Returns the XPath object value or NULL if not found.
+ */
+typedef xmlXPathObjectPtr (*xmlXPathVariableLookupFunc) (void *ctxt,
+					 const xmlChar *name,
+					 const xmlChar *ns_uri);
+
+XMLPUBFUN void XMLCALL	
+	xmlXPathRegisterVariableLookup	(xmlXPathContextPtr ctxt,
+					 xmlXPathVariableLookupFunc f,
+					 void *data);
+
+/*
+ * Function Lookup forwarding.
+ */
+/**
+ * xmlXPathFuncLookupFunc:
+ * @ctxt:  an XPath context
+ * @name:  name of the function
+ * @ns_uri:  the namespace name hosting this function
+ *
+ * Prototype for callbacks used to plug function lookup in the XPath
+ * engine.
+ *
+ * Returns the XPath function or NULL if not found.
+ */
+typedef xmlXPathFunction (*xmlXPathFuncLookupFunc) (void *ctxt,
+					 const xmlChar *name,
+					 const xmlChar *ns_uri);
+
+XMLPUBFUN void XMLCALL	
+	    xmlXPathRegisterFuncLookup	(xmlXPathContextPtr ctxt,
+					 xmlXPathFuncLookupFunc f,
+					 void *funcCtxt);
+
+/*
+ * Error reporting.
+ */
+XMLPUBFUN void XMLCALL		
+		xmlXPatherror	(xmlXPathParserContextPtr ctxt,
+				 const char *file,
+				 int line,
+				 int no);
+
+XMLPUBFUN void XMLCALL
+		xmlXPathErr	(xmlXPathParserContextPtr ctxt,
+				 int error);
+
+#ifdef LIBXML_DEBUG_ENABLED
+XMLPUBFUN void XMLCALL		
+		xmlXPathDebugDumpObject	(FILE *output,
+					 xmlXPathObjectPtr cur,
+					 int depth);
+XMLPUBFUN void XMLCALL		
+	    xmlXPathDebugDumpCompExpr(FILE *output,
+					 xmlXPathCompExprPtr comp,
+					 int depth);
+#endif
+/**
+ * NodeSet handling.
+ */
+XMLPUBFUN int XMLCALL		
+		xmlXPathNodeSetContains		(xmlNodeSetPtr cur,
+						 xmlNodePtr val);
+XMLPUBFUN xmlNodeSetPtr XMLCALL	
+		xmlXPathDifference		(xmlNodeSetPtr nodes1,
+						 xmlNodeSetPtr nodes2);
+XMLPUBFUN xmlNodeSetPtr XMLCALL	
+		xmlXPathIntersection		(xmlNodeSetPtr nodes1,
+						 xmlNodeSetPtr nodes2);
+
+XMLPUBFUN xmlNodeSetPtr XMLCALL	
+		xmlXPathDistinctSorted		(xmlNodeSetPtr nodes);
+XMLPUBFUN xmlNodeSetPtr XMLCALL	
+		xmlXPathDistinct		(xmlNodeSetPtr nodes);
+
+XMLPUBFUN int XMLCALL		
+		xmlXPathHasSameNodes		(xmlNodeSetPtr nodes1,
+						 xmlNodeSetPtr nodes2);
+
+XMLPUBFUN xmlNodeSetPtr XMLCALL	
+		xmlXPathNodeLeadingSorted	(xmlNodeSetPtr nodes,
+						 xmlNodePtr node);
+XMLPUBFUN xmlNodeSetPtr XMLCALL	
+		xmlXPathLeadingSorted		(xmlNodeSetPtr nodes1,
+						 xmlNodeSetPtr nodes2);
+XMLPUBFUN xmlNodeSetPtr XMLCALL	
+		xmlXPathNodeLeading		(xmlNodeSetPtr nodes,
+						 xmlNodePtr node);
+XMLPUBFUN xmlNodeSetPtr XMLCALL	
+		xmlXPathLeading			(xmlNodeSetPtr nodes1,
+						 xmlNodeSetPtr nodes2);
+
+XMLPUBFUN xmlNodeSetPtr XMLCALL	
+		xmlXPathNodeTrailingSorted	(xmlNodeSetPtr nodes,
+						 xmlNodePtr node);
+XMLPUBFUN xmlNodeSetPtr XMLCALL	
+		xmlXPathTrailingSorted		(xmlNodeSetPtr nodes1,
+						 xmlNodeSetPtr nodes2);
+XMLPUBFUN xmlNodeSetPtr XMLCALL	
+		xmlXPathNodeTrailing		(xmlNodeSetPtr nodes,
+						 xmlNodePtr node);
+XMLPUBFUN xmlNodeSetPtr XMLCALL	
+		xmlXPathTrailing		(xmlNodeSetPtr nodes1,
+						 xmlNodeSetPtr nodes2);
+
+
+/**
+ * Extending a context.
+ */
+
+XMLPUBFUN int XMLCALL		   
+		xmlXPathRegisterNs		(xmlXPathContextPtr ctxt,
+						 const xmlChar *prefix,
+						 const xmlChar *ns_uri);
+XMLPUBFUN const xmlChar * XMLCALL	   
+		xmlXPathNsLookup		(xmlXPathContextPtr ctxt,
+						 const xmlChar *prefix);
+XMLPUBFUN void XMLCALL		   
+		xmlXPathRegisteredNsCleanup	(xmlXPathContextPtr ctxt);
+
+XMLPUBFUN int XMLCALL		   
+		xmlXPathRegisterFunc		(xmlXPathContextPtr ctxt,
+						 const xmlChar *name,
+						 xmlXPathFunction f);
+XMLPUBFUN int XMLCALL		   
+		xmlXPathRegisterFuncNS		(xmlXPathContextPtr ctxt,
+						 const xmlChar *name,
+						 const xmlChar *ns_uri,
+						 xmlXPathFunction f);
+XMLPUBFUN int XMLCALL		   
+		xmlXPathRegisterVariable	(xmlXPathContextPtr ctxt,
+						 const xmlChar *name,
+						 xmlXPathObjectPtr value);
+XMLPUBFUN int XMLCALL		   
+		xmlXPathRegisterVariableNS	(xmlXPathContextPtr ctxt,
+						 const xmlChar *name,
+						 const xmlChar *ns_uri,
+						 xmlXPathObjectPtr value);
+XMLPUBFUN xmlXPathFunction XMLCALL   
+		xmlXPathFunctionLookup		(xmlXPathContextPtr ctxt,
+						 const xmlChar *name);
+XMLPUBFUN xmlXPathFunction XMLCALL   
+		xmlXPathFunctionLookupNS	(xmlXPathContextPtr ctxt,
+						 const xmlChar *name,
+						 const xmlChar *ns_uri);
+XMLPUBFUN void XMLCALL		   
+		xmlXPathRegisteredFuncsCleanup	(xmlXPathContextPtr ctxt);
+XMLPUBFUN xmlXPathObjectPtr XMLCALL  
+		xmlXPathVariableLookup		(xmlXPathContextPtr ctxt,
+						 const xmlChar *name);
+XMLPUBFUN xmlXPathObjectPtr XMLCALL  
+		xmlXPathVariableLookupNS	(xmlXPathContextPtr ctxt,
+						 const xmlChar *name,
+						 const xmlChar *ns_uri);
+XMLPUBFUN void XMLCALL		   
+		xmlXPathRegisteredVariablesCleanup(xmlXPathContextPtr ctxt);
+
+/**
+ * Utilities to extend XPath.
+ */
+XMLPUBFUN xmlXPathParserContextPtr XMLCALL
+		  xmlXPathNewParserContext	(const xmlChar *str,
+			  			 xmlXPathContextPtr ctxt);
+XMLPUBFUN void XMLCALL		  
+		xmlXPathFreeParserContext	(xmlXPathParserContextPtr ctxt);
+
+/* TODO: remap to xmlXPathValuePop and Push. */
+XMLPUBFUN xmlXPathObjectPtr XMLCALL 
+		valuePop			(xmlXPathParserContextPtr ctxt);
+XMLPUBFUN int XMLCALL		  
+		valuePush			(xmlXPathParserContextPtr ctxt,
+					 	 xmlXPathObjectPtr value);
+
+XMLPUBFUN xmlXPathObjectPtr XMLCALL 
+		xmlXPathNewString		(const xmlChar *val);
+XMLPUBFUN xmlXPathObjectPtr XMLCALL 
+		xmlXPathNewCString		(const char *val);
+XMLPUBFUN xmlXPathObjectPtr XMLCALL 
+		xmlXPathWrapString		(xmlChar *val);
+XMLPUBFUN xmlXPathObjectPtr XMLCALL 
+		xmlXPathWrapCString		(char * val);
+XMLPUBFUN xmlXPathObjectPtr XMLCALL 
+		xmlXPathNewFloat		(double val);
+XMLPUBFUN xmlXPathObjectPtr XMLCALL 
+		xmlXPathNewBoolean		(int val);
+XMLPUBFUN xmlXPathObjectPtr XMLCALL 
+		xmlXPathNewNodeSet		(xmlNodePtr val);
+XMLPUBFUN xmlXPathObjectPtr XMLCALL 
+		xmlXPathNewValueTree		(xmlNodePtr val);
+XMLPUBFUN void XMLCALL		  
+		xmlXPathNodeSetAdd		(xmlNodeSetPtr cur,
+						 xmlNodePtr val);
+XMLPUBFUN void XMLCALL              
+		xmlXPathNodeSetAddUnique	(xmlNodeSetPtr cur,
+						 xmlNodePtr val);
+XMLPUBFUN void XMLCALL		  
+		xmlXPathNodeSetAddNs		(xmlNodeSetPtr cur, 
+						 xmlNodePtr node, 
+						 xmlNsPtr ns);
+XMLPUBFUN void XMLCALL              
+		xmlXPathNodeSetSort		(xmlNodeSetPtr set);
+
+XMLPUBFUN void XMLCALL		  
+		xmlXPathRoot			(xmlXPathParserContextPtr ctxt);
+XMLPUBFUN void XMLCALL		  
+		xmlXPathEvalExpr		(xmlXPathParserContextPtr ctxt);
+XMLPUBFUN xmlChar * XMLCALL	  
+		xmlXPathParseName		(xmlXPathParserContextPtr ctxt);
+XMLPUBFUN xmlChar * XMLCALL	  
+		xmlXPathParseNCName		(xmlXPathParserContextPtr ctxt);
+
+/*
+ * Existing functions.
+ */
+XMLPUBFUN double XMLCALL 
+		xmlXPathStringEvalNumber	(const xmlChar *str);
+XMLPUBFUN int XMLCALL 
+		xmlXPathEvaluatePredicateResult (xmlXPathParserContextPtr ctxt, 
+						 xmlXPathObjectPtr res);
+XMLPUBFUN void XMLCALL 
+		xmlXPathRegisterAllFunctions	(xmlXPathContextPtr ctxt);
+XMLPUBFUN xmlNodeSetPtr XMLCALL 
+		xmlXPathNodeSetMerge		(xmlNodeSetPtr val1, 
+						 xmlNodeSetPtr val2);
+XMLPUBFUN void XMLCALL 
+		xmlXPathNodeSetDel		(xmlNodeSetPtr cur, 
+						 xmlNodePtr val);
+XMLPUBFUN void XMLCALL 
+		xmlXPathNodeSetRemove		(xmlNodeSetPtr cur, 
+						 int val);
+XMLPUBFUN xmlXPathObjectPtr XMLCALL 
+		xmlXPathNewNodeSetList		(xmlNodeSetPtr val);
+XMLPUBFUN xmlXPathObjectPtr XMLCALL 
+		xmlXPathWrapNodeSet		(xmlNodeSetPtr val);
+XMLPUBFUN xmlXPathObjectPtr XMLCALL 
+		xmlXPathWrapExternal		(void *val);
+
+XMLPUBFUN int XMLCALL xmlXPathEqualValues(xmlXPathParserContextPtr ctxt);
+XMLPUBFUN int XMLCALL xmlXPathNotEqualValues(xmlXPathParserContextPtr ctxt);
+XMLPUBFUN int XMLCALL xmlXPathCompareValues(xmlXPathParserContextPtr ctxt, int inf, int strict);
+XMLPUBFUN void XMLCALL xmlXPathValueFlipSign(xmlXPathParserContextPtr ctxt);
+XMLPUBFUN void XMLCALL xmlXPathAddValues(xmlXPathParserContextPtr ctxt);
+XMLPUBFUN void XMLCALL xmlXPathSubValues(xmlXPathParserContextPtr ctxt);
+XMLPUBFUN void XMLCALL xmlXPathMultValues(xmlXPathParserContextPtr ctxt);
+XMLPUBFUN void XMLCALL xmlXPathDivValues(xmlXPathParserContextPtr ctxt);
+XMLPUBFUN void XMLCALL xmlXPathModValues(xmlXPathParserContextPtr ctxt);
+
+XMLPUBFUN int XMLCALL xmlXPathIsNodeType(const xmlChar *name);
+
+/*
+ * Some of the axis navigation routines.
+ */
+XMLPUBFUN xmlNodePtr XMLCALL xmlXPathNextSelf(xmlXPathParserContextPtr ctxt,
+			xmlNodePtr cur);
+XMLPUBFUN xmlNodePtr XMLCALL xmlXPathNextChild(xmlXPathParserContextPtr ctxt,
+			xmlNodePtr cur);
+XMLPUBFUN xmlNodePtr XMLCALL xmlXPathNextDescendant(xmlXPathParserContextPtr ctxt,
+			xmlNodePtr cur);
+XMLPUBFUN xmlNodePtr XMLCALL xmlXPathNextDescendantOrSelf(xmlXPathParserContextPtr ctxt,
+			xmlNodePtr cur);
+XMLPUBFUN xmlNodePtr XMLCALL xmlXPathNextParent(xmlXPathParserContextPtr ctxt,
+			xmlNodePtr cur);
+XMLPUBFUN xmlNodePtr XMLCALL xmlXPathNextAncestorOrSelf(xmlXPathParserContextPtr ctxt,
+			xmlNodePtr cur);
+XMLPUBFUN xmlNodePtr XMLCALL xmlXPathNextFollowingSibling(xmlXPathParserContextPtr ctxt,
+			xmlNodePtr cur);
+XMLPUBFUN xmlNodePtr XMLCALL xmlXPathNextFollowing(xmlXPathParserContextPtr ctxt,
+			xmlNodePtr cur);
+XMLPUBFUN xmlNodePtr XMLCALL xmlXPathNextNamespace(xmlXPathParserContextPtr ctxt,
+			xmlNodePtr cur);
+XMLPUBFUN xmlNodePtr XMLCALL xmlXPathNextAttribute(xmlXPathParserContextPtr ctxt,
+			xmlNodePtr cur);
+XMLPUBFUN xmlNodePtr XMLCALL xmlXPathNextPreceding(xmlXPathParserContextPtr ctxt,
+			xmlNodePtr cur);
+XMLPUBFUN xmlNodePtr XMLCALL xmlXPathNextAncestor(xmlXPathParserContextPtr ctxt,
+			xmlNodePtr cur);
+XMLPUBFUN xmlNodePtr XMLCALL xmlXPathNextPrecedingSibling(xmlXPathParserContextPtr ctxt,
+			xmlNodePtr cur);
+/*
+ * The official core of XPath functions.
+ */
+XMLPUBFUN void XMLCALL xmlXPathLastFunction(xmlXPathParserContextPtr ctxt, int nargs);
+XMLPUBFUN void XMLCALL xmlXPathPositionFunction(xmlXPathParserContextPtr ctxt, int nargs);
+XMLPUBFUN void XMLCALL xmlXPathCountFunction(xmlXPathParserContextPtr ctxt, int nargs);
+XMLPUBFUN void XMLCALL xmlXPathIdFunction(xmlXPathParserContextPtr ctxt, int nargs);
+XMLPUBFUN void XMLCALL xmlXPathLocalNameFunction(xmlXPathParserContextPtr ctxt, int nargs);
+XMLPUBFUN void XMLCALL xmlXPathNamespaceURIFunction(xmlXPathParserContextPtr ctxt, int nargs);
+XMLPUBFUN void XMLCALL xmlXPathStringFunction(xmlXPathParserContextPtr ctxt, int nargs);
+XMLPUBFUN void XMLCALL xmlXPathStringLengthFunction(xmlXPathParserContextPtr ctxt, int nargs);
+XMLPUBFUN void XMLCALL xmlXPathConcatFunction(xmlXPathParserContextPtr ctxt, int nargs);
+XMLPUBFUN void XMLCALL xmlXPathContainsFunction(xmlXPathParserContextPtr ctxt, int nargs);
+XMLPUBFUN void XMLCALL xmlXPathStartsWithFunction(xmlXPathParserContextPtr ctxt, int nargs);
+XMLPUBFUN void XMLCALL xmlXPathSubstringFunction(xmlXPathParserContextPtr ctxt, int nargs);
+XMLPUBFUN void XMLCALL xmlXPathSubstringBeforeFunction(xmlXPathParserContextPtr ctxt, int nargs);
+XMLPUBFUN void XMLCALL xmlXPathSubstringAfterFunction(xmlXPathParserContextPtr ctxt, int nargs);
+XMLPUBFUN void XMLCALL xmlXPathNormalizeFunction(xmlXPathParserContextPtr ctxt, int nargs);
+XMLPUBFUN void XMLCALL xmlXPathTranslateFunction(xmlXPathParserContextPtr ctxt, int nargs);
+XMLPUBFUN void XMLCALL xmlXPathNotFunction(xmlXPathParserContextPtr ctxt, int nargs);
+XMLPUBFUN void XMLCALL xmlXPathTrueFunction(xmlXPathParserContextPtr ctxt, int nargs);
+XMLPUBFUN void XMLCALL xmlXPathFalseFunction(xmlXPathParserContextPtr ctxt, int nargs);
+XMLPUBFUN void XMLCALL xmlXPathLangFunction(xmlXPathParserContextPtr ctxt, int nargs);
+XMLPUBFUN void XMLCALL xmlXPathNumberFunction(xmlXPathParserContextPtr ctxt, int nargs);
+XMLPUBFUN void XMLCALL xmlXPathSumFunction(xmlXPathParserContextPtr ctxt, int nargs);
+XMLPUBFUN void XMLCALL xmlXPathFloorFunction(xmlXPathParserContextPtr ctxt, int nargs);
+XMLPUBFUN void XMLCALL xmlXPathCeilingFunction(xmlXPathParserContextPtr ctxt, int nargs);
+XMLPUBFUN void XMLCALL xmlXPathRoundFunction(xmlXPathParserContextPtr ctxt, int nargs);
+XMLPUBFUN void XMLCALL xmlXPathBooleanFunction(xmlXPathParserContextPtr ctxt, int nargs);
+
+/**
+ * Really internal functions
+ */
+XMLPUBFUN void XMLCALL xmlXPathNodeSetFreeNs(xmlNsPtr ns);
+ 
+#ifdef __cplusplus
+}
+#endif
+#endif /* ! __XML_XPATH_INTERNALS_H__ */
diff --git a/src/libxml/include/libxml/xpointer.h b/src/libxml/include/libxml/xpointer.h
new file mode 100644
index 0000000..2285b0e
--- /dev/null
+++ b/src/libxml/include/libxml/xpointer.h
@@ -0,0 +1,109 @@
+/*
+ * Summary: API to handle XML Pointers
+ * Description: API to handle XML Pointers
+ * Base implementation was made accordingly to
+ * W3C Candidate Recommendation 7 June 2000
+ * http://www.w3.org/TR/2000/CR-xptr-20000607
+ *
+ * Added support for the element() scheme described in:
+ * W3C Proposed Recommendation 13 November 2002
+ * http://www.w3.org/TR/2002/PR-xptr-element-20021113/  
+ *
+ * Copy: See Copyright for the status of this software.
+ *
+ * Author: Daniel Veillard
+ */
+
+#ifndef __XML_XPTR_H__
+#define __XML_XPTR_H__
+
+#include <libxml/xmlversion.h>
+#include <libxml/tree.h>
+#include <libxml/xpath.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * A Location Set
+ */
+typedef struct _xmlLocationSet xmlLocationSet;
+typedef xmlLocationSet *xmlLocationSetPtr;
+struct _xmlLocationSet {
+    int locNr;		      /* number of locations in the set */
+    int locMax;		      /* size of the array as allocated */
+    xmlXPathObjectPtr *locTab;/* array of locations */
+};
+
+/*
+ * Handling of location sets.
+ */
+
+XMLPUBFUN xmlLocationSetPtr XMLCALL			
+		    xmlXPtrLocationSetCreate	(xmlXPathObjectPtr val);
+XMLPUBFUN void XMLCALL			
+		    xmlXPtrFreeLocationSet	(xmlLocationSetPtr obj);
+XMLPUBFUN xmlLocationSetPtr XMLCALL	
+		    xmlXPtrLocationSetMerge	(xmlLocationSetPtr val1,
+						 xmlLocationSetPtr val2);
+XMLPUBFUN xmlXPathObjectPtr XMLCALL	
+		    xmlXPtrNewRange		(xmlNodePtr start,
+						 int startindex,
+						 xmlNodePtr end,
+						 int endindex);
+XMLPUBFUN xmlXPathObjectPtr XMLCALL	
+		    xmlXPtrNewRangePoints	(xmlXPathObjectPtr start,
+						 xmlXPathObjectPtr end);
+XMLPUBFUN xmlXPathObjectPtr XMLCALL	
+		    xmlXPtrNewRangeNodePoint	(xmlNodePtr start,
+						 xmlXPathObjectPtr end);
+XMLPUBFUN xmlXPathObjectPtr XMLCALL	
+		    xmlXPtrNewRangePointNode	(xmlXPathObjectPtr start,
+						 xmlNodePtr end);
+XMLPUBFUN xmlXPathObjectPtr XMLCALL			
+		    xmlXPtrNewRangeNodes	(xmlNodePtr start,
+						 xmlNodePtr end);
+XMLPUBFUN xmlXPathObjectPtr XMLCALL	
+		    xmlXPtrNewLocationSetNodes	(xmlNodePtr start,
+						 xmlNodePtr end);
+XMLPUBFUN xmlXPathObjectPtr XMLCALL	
+		    xmlXPtrNewLocationSetNodeSet(xmlNodeSetPtr set);
+XMLPUBFUN xmlXPathObjectPtr XMLCALL	
+		    xmlXPtrNewRangeNodeObject	(xmlNodePtr start,
+						 xmlXPathObjectPtr end);
+XMLPUBFUN xmlXPathObjectPtr XMLCALL	
+		    xmlXPtrNewCollapsedRange	(xmlNodePtr start);
+XMLPUBFUN void XMLCALL			
+		    xmlXPtrLocationSetAdd	(xmlLocationSetPtr cur,
+						 xmlXPathObjectPtr val);
+XMLPUBFUN xmlXPathObjectPtr XMLCALL	
+		    xmlXPtrWrapLocationSet	(xmlLocationSetPtr val);
+XMLPUBFUN void XMLCALL			
+		    xmlXPtrLocationSetDel	(xmlLocationSetPtr cur,
+						 xmlXPathObjectPtr val);
+XMLPUBFUN void XMLCALL			
+		    xmlXPtrLocationSetRemove	(xmlLocationSetPtr cur,
+						 int val);
+
+/*
+ * Functions.
+ */
+XMLPUBFUN xmlXPathContextPtr XMLCALL	
+		    xmlXPtrNewContext		(xmlDocPtr doc,
+						 xmlNodePtr here,
+						 xmlNodePtr origin);
+XMLPUBFUN xmlXPathObjectPtr XMLCALL	
+		    xmlXPtrEval			(const xmlChar *str,
+						 xmlXPathContextPtr ctx);
+XMLPUBFUN void XMLCALL					    
+		    xmlXPtrRangeToFunction	(xmlXPathParserContextPtr ctxt,
+       						 int nargs);
+XMLPUBFUN xmlNodePtr XMLCALL		
+		    xmlXPtrBuildNodeList	(xmlXPathObjectPtr obj);
+XMLPUBFUN void XMLCALL		
+		    xmlXPtrEvalRangePredicate	(xmlXPathParserContextPtr ctxt);
+#ifdef __cplusplus
+}
+#endif
+#endif /* __XML_XPTR_H__ */
diff --git a/src/libxml/include/xmlversion.h.in b/src/libxml/include/xmlversion.h.in
new file mode 100644
index 0000000..6939937
--- /dev/null
+++ b/src/libxml/include/xmlversion.h.in
@@ -0,0 +1,347 @@
+/*
+ * Summary: compile-time version informations
+ * Description: compile-time version informations for the XML library
+ *
+ * Copy: See Copyright for the status of this software.
+ *
+ * Author: Daniel Veillard
+ */
+
+#ifndef __XML_VERSION_H__
+#define __XML_VERSION_H__
+
+#include <libxml/xmlexports.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * use those to be sure nothing nasty will happen if
+ * your library and includes mismatch
+ */
+#ifndef LIBXML2_COMPILING_MSCCDEF
+XMLPUBFUN void XMLCALL xmlCheckVersion(int version);
+#endif /* LIBXML2_COMPILING_MSCCDEF */
+
+/**
+ * LIBXML_DOTTED_VERSION:
+ *
+ * the version string like "1.2.3"
+ */
+#define LIBXML_DOTTED_VERSION "@VERSION@"
+
+/**
+ * LIBXML_VERSION:
+ *
+ * the version number: 1.2.3 value is 1002003
+ */
+#define LIBXML_VERSION @LIBXML_VERSION_NUMBER@
+
+/**
+ * LIBXML_VERSION_STRING:
+ *
+ * the version number string, 1.2.3 value is "1002003"
+ */
+#define LIBXML_VERSION_STRING "@LIBXML_VERSION_NUMBER@"
+
+/**
+ * LIBXML_TEST_VERSION:
+ *
+ * Macro to check that the libxml version in use is compatible with
+ * the version the software has been compiled against
+ */
+#define LIBXML_TEST_VERSION xmlCheckVersion(@LIBXML_VERSION_NUMBER@);
+
+#ifndef VMS
+#if @WITH_TRIO@
+/**
+ * WITH_TRIO:
+ *
+ * defined if the trio support need to be configured in
+ */
+#define WITH_TRIO
+#else
+/**
+ * WITHOUT_TRIO:
+ *
+ * defined if the trio support should not be configured in
+ */
+#define WITHOUT_TRIO
+#endif
+#else /* VMS */
+/**
+ * WITH_TRIO:
+ *
+ * defined if the trio support need to be configured in
+ */
+#define WITH_TRIO 1
+#endif /* VMS */
+
+/**
+ * LIBXML_THREAD_ENABLED:
+ *
+ * Whether the thread support is configured in
+ */
+#if @WITH_THREADS@
+#if defined(_REENTRANT) || defined(__MT__) || (_POSIX_C_SOURCE - 0 >= 199506L)
+#define LIBXML_THREAD_ENABLED
+#endif
+#endif
+
+/**
+ * LIBXML_TREE_ENABLED:
+ *
+ * Whether the DOM like tree manipulation API support is configured in
+ */
+#if @WITH_TREE@
+#define LIBXML_TREE_ENABLED
+#endif
+
+/**
+ * LIBXML_OUTPUT_ENABLED:
+ *
+ * Whether the serialization/saving support is configured in
+ */
+#if @WITH_OUTPUT@
+#define LIBXML_OUTPUT_ENABLED
+#endif
+
+/**
+ * LIBXML_PUSH_ENABLED:
+ *
+ * Whether the push parsing interfaces are configured in
+ */
+#if @WITH_PUSH@
+#define LIBXML_PUSH_ENABLED
+#endif
+
+/**
+ * LIBXML_READER_ENABLED:
+ *
+ * Whether the xmlReader parsing interface is configured in
+ */
+#if @WITH_READER@
+#define LIBXML_READER_ENABLED
+#endif
+
+/**
+ * LIBXML_PATTERN_ENABLED:
+ *
+ * Whether the xmlPattern node selection interface is configured in
+ */
+#if @WITH_PATTERN@
+#define LIBXML_PATTERN_ENABLED
+#endif
+
+/**
+ * LIBXML_WRITER_ENABLED:
+ *
+ * Whether the xmlWriter saving interface is configured in
+ */
+#if @WITH_WRITER@
+#define LIBXML_WRITER_ENABLED
+#endif
+
+/**
+ * LIBXML_SAX1_ENABLED:
+ *
+ * Whether the older SAX1 interface is configured in
+ */
+#if @WITH_SAX1@
+#define LIBXML_SAX1_ENABLED
+#endif
+
+/**
+ * LIBXML_FTP_ENABLED:
+ *
+ * Whether the FTP support is configured in
+ */
+#if @WITH_FTP@
+#define LIBXML_FTP_ENABLED
+#endif
+
+/**
+ * LIBXML_HTTP_ENABLED:
+ *
+ * Whether the HTTP support is configured in
+ */
+#if @WITH_HTTP@
+#define LIBXML_HTTP_ENABLED
+#endif
+
+/**
+ * LIBXML_VALID_ENABLED:
+ *
+ * Whether the DTD validation support is configured in
+ */
+#if @WITH_VALID@
+#define LIBXML_VALID_ENABLED
+#endif
+
+/**
+ * LIBXML_HTML_ENABLED:
+ *
+ * Whether the HTML support is configured in
+ */
+#if @WITH_HTML@
+#define LIBXML_HTML_ENABLED
+#endif
+
+/**
+ * LIBXML_LEGACY_ENABLED:
+ *
+ * Whether the deprecated APIs are compiled in for compatibility
+ */
+#if @WITH_LEGACY@
+#define LIBXML_LEGACY_ENABLED
+#endif
+
+/**
+ * LIBXML_C14N_ENABLED:
+ *
+ * Whether the Canonicalization support is configured in
+ */
+#if @WITH_C14N@
+#define LIBXML_C14N_ENABLED
+#endif
+
+/**
+ * LIBXML_CATALOG_ENABLED:
+ *
+ * Whether the Catalog support is configured in
+ */
+#if @WITH_CATALOG@
+#define LIBXML_CATALOG_ENABLED
+#endif
+
+/**
+ * LIBXML_DOCB_ENABLED:
+ *
+ * Whether the SGML Docbook support is configured in
+ */
+#if @WITH_DOCB@
+#define LIBXML_DOCB_ENABLED
+#endif
+
+/**
+ * LIBXML_XPATH_ENABLED:
+ *
+ * Whether XPath is configured in
+ */
+#if @WITH_XPATH@
+#define LIBXML_XPATH_ENABLED
+#endif
+
+/**
+ * LIBXML_XPTR_ENABLED:
+ *
+ * Whether XPointer is configured in
+ */
+#if @WITH_XPTR@
+#define LIBXML_XPTR_ENABLED
+#endif
+
+/**
+ * LIBXML_XINCLUDE_ENABLED:
+ *
+ * Whether XInclude is configured in
+ */
+#if @WITH_XINCLUDE@
+#define LIBXML_XINCLUDE_ENABLED
+#endif
+
+/**
+ * LIBXML_ICONV_ENABLED:
+ *
+ * Whether iconv support is available
+ */
+#if @WITH_ICONV@
+#define LIBXML_ICONV_ENABLED
+#endif
+
+/**
+ * LIBXML_ISO8859X_ENABLED:
+ *
+ * Whether ISO-8859-* support is made available in case iconv is not
+ */
+#if @WITH_ISO8859X@
+#define LIBXML_ISO8859X_ENABLED
+#endif
+
+/**
+ * LIBXML_DEBUG_ENABLED:
+ *
+ * Whether Debugging module is configured in
+ */
+#if @WITH_DEBUG@
+#define LIBXML_DEBUG_ENABLED
+#endif
+
+/**
+ * DEBUG_MEMORY_LOCATION:
+ *
+ * Whether the memory debugging is configured in
+ */
+#if @WITH_MEM_DEBUG@
+#define DEBUG_MEMORY_LOCATION
+#endif
+
+/**
+ * LIBXML_UNICODE_ENABLED:
+ *
+ * Whether the Unicode related interfaces are compiled in
+ */
+#if @WITH_REGEXPS@
+#define LIBXML_UNICODE_ENABLED
+#endif
+
+/**
+ * LIBXML_REGEXP_ENABLED:
+ *
+ * Whether the regular expressions interfaces are compiled in
+ */
+#if @WITH_REGEXPS@
+#define LIBXML_REGEXP_ENABLED
+#endif
+
+/**
+ * LIBXML_AUTOMATA_ENABLED:
+ *
+ * Whether the automata interfaces are compiled in
+ */
+#if @WITH_REGEXPS@
+#define LIBXML_AUTOMATA_ENABLED
+#endif
+
+/**
+ * LIBXML_SCHEMAS_ENABLED:
+ *
+ * Whether the Schemas validation interfaces are compiled in
+ */
+#if @WITH_SCHEMAS@
+#define LIBXML_SCHEMAS_ENABLED
+#endif
+
+/**
+ * ATTRIBUTE_UNUSED:
+ *
+ * Macro used to signal to GCC unused function parameters
+ */
+#ifdef __GNUC__
+#ifdef HAVE_ANSIDECL_H
+#include <ansidecl.h>
+#endif
+#ifndef ATTRIBUTE_UNUSED
+#define ATTRIBUTE_UNUSED __attribute__((unused))
+#endif
+#else
+#define ATTRIBUTE_UNUSED
+#endif
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+#endif
+
+
diff --git a/src/libxml/src/DOCBparser.c b/src/libxml/src/DOCBparser.c
new file mode 100644
index 0000000..ccb577f
--- /dev/null
+++ b/src/libxml/src/DOCBparser.c
@@ -0,0 +1,303 @@
+/*
+ * DOCBparser.c : an attempt to parse SGML Docbook documents
+ *
+ * This is deprecated !!!
+ * Code removed with release 2.6.0 it was broken.
+ * The doc are expect to be migrated to XML DocBook
+ *
+ * See Copyright for the status of this software.
+ *
+ * daniel@veillard.com
+ */
+
+#define IN_LIBXML
+#include "libxml.h"
+#ifdef LIBXML_DOCB_ENABLED
+
+#include <libxml/xmlerror.h>
+#include <libxml/DOCBparser.h>
+
+/**
+ * docbEncodeEntities:
+ * @out:  a pointer to an array of bytes to store the result
+ * @outlen:  the length of @out
+ * @in:  a pointer to an array of UTF-8 chars
+ * @inlen:  the length of @in
+ * @quoteChar: the quote character to escape (' or ") or zero.
+ *
+ * Take a block of UTF-8 chars in and try to convert it to an ASCII
+ * plus SGML entities block of chars out.
+ *
+ * Returns 0 if success, -2 if the transcoding fails, or -1 otherwise
+ * The value of @inlen after return is the number of octets consumed
+ *     as the return value is positive, else unpredictable.
+ * The value of @outlen after return is the number of octets consumed.
+ */
+int
+docbEncodeEntities(unsigned char *out ATTRIBUTE_UNUSED,
+                   int *outlen ATTRIBUTE_UNUSED,
+                   const unsigned char *in ATTRIBUTE_UNUSED,
+                   int *inlen ATTRIBUTE_UNUSED,
+                   int quoteChar ATTRIBUTE_UNUSED)
+{
+    static int deprecated = 0;
+
+    if (!deprecated) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "docbEncodeEntities() deprecated function reached\n");
+        deprecated = 1;
+    }
+    return(-1);
+}
+
+/**
+ * docbParseDocument:
+ * @ctxt:  an SGML parser context
+ * 
+ * parse an SGML document (and build a tree if using the standard SAX
+ * interface).
+ *
+ * Returns 0, -1 in case of error. the parser context is augmented
+ *                as a result of the parsing.
+ */
+
+int
+docbParseDocument(docbParserCtxtPtr ctxt ATTRIBUTE_UNUSED)
+{
+    static int deprecated = 0;
+
+    if (!deprecated) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "docbParseDocument() deprecated function reached\n");
+        deprecated = 1;
+    }
+    return (xmlParseDocument(ctxt));
+}
+
+/**
+ * docbFreeParserCtxt:
+ * @ctxt:  an SGML parser context
+ *
+ * Free all the memory used by a parser context. However the parsed
+ * document in ctxt->myDoc is not freed.
+ */
+
+void
+docbFreeParserCtxt(docbParserCtxtPtr ctxt ATTRIBUTE_UNUSED)
+{
+    static int deprecated = 0;
+
+    if (!deprecated) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "docbFreeParserCtxt() deprecated function reached\n");
+        deprecated = 1;
+    }
+    xmlFreeParserCtxt(ctxt);
+}
+
+/**
+ * docbParseChunk:
+ * @ctxt:  an XML parser context
+ * @chunk:  an char array
+ * @size:  the size in byte of the chunk
+ * @terminate:  last chunk indicator
+ *
+ * Parse a Chunk of memory
+ *
+ * Returns zero if no error, the xmlParserErrors otherwise.
+ */
+int
+docbParseChunk(docbParserCtxtPtr ctxt ATTRIBUTE_UNUSED,
+               const char *chunk ATTRIBUTE_UNUSED,
+	       int size ATTRIBUTE_UNUSED,
+               int terminate ATTRIBUTE_UNUSED)
+{
+    static int deprecated = 0;
+
+    if (!deprecated) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "docbParseChunk() deprecated function reached\n");
+        deprecated = 1;
+    }
+
+    return (xmlParseChunk(ctxt, chunk, size, terminate));
+}
+
+/**
+ * docbCreatePushParserCtxt:
+ * @sax:  a SAX handler
+ * @user_data:  The user data returned on SAX callbacks
+ * @chunk:  a pointer to an array of chars
+ * @size:  number of chars in the array
+ * @filename:  an optional file name or URI
+ * @enc:  an optional encoding
+ *
+ * Create a parser context for using the DocBook SGML parser in push mode
+ * To allow content encoding detection, @size should be >= 4
+ * The value of @filename is used for fetching external entities
+ * and error/warning reports.
+ *
+ * Returns the new parser context or NULL
+ */
+docbParserCtxtPtr
+docbCreatePushParserCtxt(docbSAXHandlerPtr sax ATTRIBUTE_UNUSED,
+                         void *user_data ATTRIBUTE_UNUSED,
+                         const char *chunk ATTRIBUTE_UNUSED,
+			 int size ATTRIBUTE_UNUSED,
+			 const char *filename ATTRIBUTE_UNUSED,
+                         xmlCharEncoding enc ATTRIBUTE_UNUSED)
+{
+    static int deprecated = 0;
+
+    if (!deprecated) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "docbParseChunk() deprecated function reached\n");
+        deprecated = 1;
+    }
+
+    return(xmlCreatePushParserCtxt(sax, user_data, chunk, size, filename));
+}
+
+/**
+ * docbSAXParseDoc:
+ * @cur:  a pointer to an array of xmlChar
+ * @encoding:  a free form C string describing the SGML document encoding, or NULL
+ * @sax:  the SAX handler block
+ * @userData: if using SAX, this pointer will be provided on callbacks. 
+ *
+ * parse an SGML in-memory document and build a tree.
+ * It use the given SAX function block to handle the parsing callback.
+ * If sax is NULL, fallback to the default DOM tree building routines.
+ * 
+ * Returns the resulting document tree
+ */
+
+docbDocPtr
+docbSAXParseDoc(xmlChar * cur ATTRIBUTE_UNUSED,
+                const char *encoding ATTRIBUTE_UNUSED,
+		docbSAXHandlerPtr sax ATTRIBUTE_UNUSED,
+                void *userData ATTRIBUTE_UNUSED)
+{
+    static int deprecated = 0;
+
+    if (!deprecated) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "docbParseChunk() deprecated function reached\n");
+        deprecated = 1;
+    }
+
+    return (xmlSAXParseMemoryWithData(sax, (const char *)cur,
+			  xmlStrlen((const xmlChar *) cur), 0,  userData));
+}
+
+/**
+ * docbParseDoc:
+ * @cur:  a pointer to an array of xmlChar
+ * @encoding:  a free form C string describing the SGML document encoding, or NULL
+ *
+ * parse an SGML in-memory document and build a tree.
+ * 
+ * Returns the resulting document tree
+ */
+
+docbDocPtr
+docbParseDoc(xmlChar * cur ATTRIBUTE_UNUSED,
+             const char *encoding ATTRIBUTE_UNUSED)
+{
+    static int deprecated = 0;
+
+    if (!deprecated) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "docbParseChunk() deprecated function reached\n");
+        deprecated = 1;
+    }
+
+    return (xmlParseDoc(cur));
+}
+
+
+/**
+ * docbCreateFileParserCtxt:
+ * @filename:  the filename
+ * @encoding:  the SGML document encoding, or NULL
+ *
+ * Create a parser context for a file content. 
+ * Automatic support for ZLIB/Compress compressed document is provided
+ * by default if found at compile-time.
+ *
+ * Returns the new parser context or NULL
+ */
+docbParserCtxtPtr
+docbCreateFileParserCtxt(const char *filename ATTRIBUTE_UNUSED,
+                         const char *encoding ATTRIBUTE_UNUSED)
+{
+    static int deprecated = 0;
+
+    if (!deprecated) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "docbCreateFileParserCtxt() deprecated function reached\n");
+        deprecated = 1;
+    }
+
+    return (xmlCreateFileParserCtxt(filename));
+}
+
+/**
+ * docbSAXParseFile:
+ * @filename:  the filename
+ * @encoding:  a free form C string describing the SGML document encoding, or NULL
+ * @sax:  the SAX handler block
+ * @userData: if using SAX, this pointer will be provided on callbacks. 
+ *
+ * parse an SGML file and build a tree. Automatic support for ZLIB/Compress
+ * compressed document is provided by default if found at compile-time.
+ * It use the given SAX function block to handle the parsing callback.
+ * If sax is NULL, fallback to the default DOM tree building routines.
+ *
+ * Returns the resulting document tree
+ */
+
+docbDocPtr
+docbSAXParseFile(const char *filename ATTRIBUTE_UNUSED,
+                 const char *encoding ATTRIBUTE_UNUSED,
+                 docbSAXHandlerPtr sax ATTRIBUTE_UNUSED,
+		 void *userData ATTRIBUTE_UNUSED)
+{
+    static int deprecated = 0;
+
+    if (!deprecated) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "docbSAXParseFile() deprecated function reached\n");
+        deprecated = 1;
+    }
+
+    return (xmlSAXParseFileWithData(sax, filename, 0, userData));
+}
+
+/**
+ * docbParseFile:
+ * @filename:  the filename
+ * @encoding:  a free form C string describing document encoding, or NULL
+ *
+ * parse a Docbook SGML file and build a tree. Automatic support for
+ * ZLIB/Compress compressed document is provided by default if found
+ * at compile-time.
+ *
+ * Returns the resulting document tree
+ */
+
+docbDocPtr
+docbParseFile(const char *filename ATTRIBUTE_UNUSED,
+              const char *encoding ATTRIBUTE_UNUSED)
+{
+    static int deprecated = 0;
+
+    if (!deprecated) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "docbParseFile() deprecated function reached\n");
+        deprecated = 1;
+    }
+
+    return (xmlParseFile(filename));
+}
+#endif /* LIBXML_DOCB_ENABLED */
diff --git a/src/libxml/src/HTMLparser.c b/src/libxml/src/HTMLparser.c
new file mode 100644
index 0000000..bf671a1
--- /dev/null
+++ b/src/libxml/src/HTMLparser.c
@@ -0,0 +1,5927 @@
+/*
+ * HTMLparser.c : an HTML 4.0 non-verifying parser
+ *
+ * See Copyright for the status of this software.
+ *
+ * daniel@veillard.com
+ */
+
+#define IN_LIBXML
+#include "libxml.h"
+#ifdef LIBXML_HTML_ENABLED
+
+#include <string.h>
+#ifdef HAVE_CTYPE_H
+#include <ctype.h>
+#endif
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+#ifdef HAVE_SYS_STAT_H
+#include <sys/stat.h>
+#endif
+#ifdef HAVE_FCNTL_H
+#include <fcntl.h>
+#endif
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#ifdef HAVE_ZLIB_H
+#include <zlib.h>
+#endif
+
+#include <libxml/xmlmemory.h>
+#include <libxml/tree.h>
+#include <libxml/parser.h>
+#include <libxml/parserInternals.h>
+#include <libxml/xmlerror.h>
+#include <libxml/HTMLparser.h>
+#include <libxml/HTMLtree.h>
+#include <libxml/entities.h>
+#include <libxml/encoding.h>
+#include <libxml/valid.h>
+#include <libxml/xmlIO.h>
+#include <libxml/globals.h>
+#include <libxml/uri.h>
+
+#define HTML_MAX_NAMELEN 1000
+#define HTML_PARSER_BIG_BUFFER_SIZE 1000
+#define HTML_PARSER_BUFFER_SIZE 100
+
+/* #define DEBUG */
+/* #define DEBUG_PUSH */
+
+static int htmlOmittedDefaultValue = 1;
+
+xmlChar * htmlDecodeEntities(htmlParserCtxtPtr ctxt, int len,
+			     xmlChar end, xmlChar  end2, xmlChar end3);
+static void htmlParseComment(htmlParserCtxtPtr ctxt);
+
+/************************************************************************
+ *									*
+ * 		Some factorized error routines				*
+ *									*
+ ************************************************************************/
+
+/**
+ * htmlErrMemory:
+ * @ctxt:  an HTML parser context
+ * @extra:  extra informations
+ *
+ * Handle a redefinition of attribute error
+ */
+static void
+htmlErrMemory(xmlParserCtxtPtr ctxt, const char *extra)
+{
+    if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
+        (ctxt->instate == XML_PARSER_EOF))
+	return;
+    if (ctxt != NULL) {
+        ctxt->errNo = XML_ERR_NO_MEMORY;
+        ctxt->instate = XML_PARSER_EOF;
+        ctxt->disableSAX = 1;
+    }
+    if (extra)
+        __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER,
+                        XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0, extra,
+                        NULL, NULL, 0, 0,
+                        "Memory allocation failed : %s\n", extra);
+    else
+        __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER,
+                        XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0, NULL,
+                        NULL, NULL, 0, 0, "Memory allocation failed\n");
+}
+
+/**
+ * htmlParseErr:
+ * @ctxt:  an HTML parser context
+ * @error:  the error number
+ * @msg:  the error message
+ * @str1:  string infor
+ * @str2:  string infor
+ *
+ * Handle a fatal parser error, i.e. violating Well-Formedness constraints
+ */
+static void
+htmlParseErr(xmlParserCtxtPtr ctxt, xmlParserErrors error,
+             const char *msg, const xmlChar *str1, const xmlChar *str2)
+{
+    if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
+        (ctxt->instate == XML_PARSER_EOF))
+	return;
+    ctxt->errNo = error;
+    __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_HTML, error,
+                    XML_ERR_ERROR, NULL, 0,
+		    (const char *) str1, (const char *) str2,
+		    NULL, 0, 0,
+		    msg, str1, str2);
+    ctxt->wellFormed = 0;
+}
+
+/**
+ * htmlParseErrInt:
+ * @ctxt:  an HTML parser context
+ * @error:  the error number
+ * @msg:  the error message
+ * @val:  integer info
+ *
+ * Handle a fatal parser error, i.e. violating Well-Formedness constraints
+ */
+static void
+htmlParseErrInt(xmlParserCtxtPtr ctxt, xmlParserErrors error,
+             const char *msg, int val)
+{
+    if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
+        (ctxt->instate == XML_PARSER_EOF))
+	return;
+    ctxt->errNo = error;
+    __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_HTML, error,
+                    XML_ERR_ERROR, NULL, 0, NULL, NULL,
+		    NULL, val, 0, msg, val);
+    ctxt->wellFormed = 0;
+}
+
+/************************************************************************
+ *									*
+ * 		Parser stacks related functions and macros		*
+ *									*
+ ************************************************************************/
+
+/**
+ * htmlnamePush:
+ * @ctxt:  an HTML parser context
+ * @value:  the element name
+ *
+ * Pushes a new element name on top of the name stack
+ *
+ * Returns 0 in case of error, the index in the stack otherwise
+ */
+static int
+htmlnamePush(htmlParserCtxtPtr ctxt, const xmlChar * value)
+{
+    if (ctxt->nameNr >= ctxt->nameMax) {
+        ctxt->nameMax *= 2;
+        ctxt->nameTab = (const xmlChar * *)
+                         xmlRealloc((xmlChar * *)ctxt->nameTab,
+                                    ctxt->nameMax *
+                                    sizeof(ctxt->nameTab[0]));
+        if (ctxt->nameTab == NULL) {
+            htmlErrMemory(ctxt, NULL);
+            return (0);
+        }
+    }
+    ctxt->nameTab[ctxt->nameNr] = value;
+    ctxt->name = value;
+    return (ctxt->nameNr++);
+}
+/**
+ * htmlnamePop:
+ * @ctxt: an HTML parser context
+ *
+ * Pops the top element name from the name stack
+ *
+ * Returns the name just removed
+ */
+static const xmlChar *
+htmlnamePop(htmlParserCtxtPtr ctxt)
+{
+    const xmlChar *ret;
+
+    if (ctxt->nameNr <= 0)
+        return (0);
+    ctxt->nameNr--;
+    if (ctxt->nameNr < 0)
+        return (0);
+    if (ctxt->nameNr > 0)
+        ctxt->name = ctxt->nameTab[ctxt->nameNr - 1];
+    else
+        ctxt->name = NULL;
+    ret = ctxt->nameTab[ctxt->nameNr];
+    ctxt->nameTab[ctxt->nameNr] = 0;
+    return (ret);
+}
+
+/*
+ * Macros for accessing the content. Those should be used only by the parser,
+ * and not exported.
+ *
+ * Dirty macros, i.e. one need to make assumption on the context to use them
+ *
+ *   CUR_PTR return the current pointer to the xmlChar to be parsed.
+ *   CUR     returns the current xmlChar value, i.e. a 8 bit value if compiled
+ *           in ISO-Latin or UTF-8, and the current 16 bit value if compiled
+ *           in UNICODE mode. This should be used internally by the parser
+ *           only to compare to ASCII values otherwise it would break when
+ *           running with UTF-8 encoding.
+ *   NXT(n)  returns the n'th next xmlChar. Same as CUR is should be used only
+ *           to compare on ASCII based substring.
+ *   UPP(n)  returns the n'th next xmlChar converted to uppercase. Same as CUR
+ *           it should be used only to compare on ASCII based substring.
+ *   SKIP(n) Skip n xmlChar, and must also be used only to skip ASCII defined
+ *           strings without newlines within the parser.
+ *
+ * Clean macros, not dependent of an ASCII context, expect UTF-8 encoding
+ *
+ *   CURRENT Returns the current char value, with the full decoding of
+ *           UTF-8 if we are using this mode. It returns an int.
+ *   NEXT    Skip to the next character, this does the proper decoding
+ *           in UTF-8 mode. It also pop-up unfinished entities on the fly.
+ *   NEXTL(l) Skip the current unicode character of l xmlChars long.
+ *   COPY(to) copy one char to *to, increment CUR_PTR and to accordingly
+ */
+
+#define UPPER (toupper(*ctxt->input->cur))
+
+#define SKIP(val) ctxt->nbChars += (val),ctxt->input->cur += (val),ctxt->input->col+=(val)
+
+#define NXT(val) ctxt->input->cur[(val)]
+
+#define UPP(val) (toupper(ctxt->input->cur[(val)]))
+
+#define CUR_PTR ctxt->input->cur
+
+#define SHRINK if ((ctxt->input->cur - ctxt->input->base > 2 * INPUT_CHUNK) && \
+		   (ctxt->input->end - ctxt->input->cur < 2 * INPUT_CHUNK)) \
+	xmlParserInputShrink(ctxt->input)
+
+#define GROW if ((ctxt->progressive == 0) &&				\
+		 (ctxt->input->end - ctxt->input->cur < INPUT_CHUNK))	\
+	xmlParserInputGrow(ctxt->input, INPUT_CHUNK)
+
+#define CURRENT ((int) (*ctxt->input->cur))
+
+#define SKIP_BLANKS htmlSkipBlankChars(ctxt)
+
+/* Inported from XML */
+
+/* #define CUR (ctxt->token ? ctxt->token : (int) (*ctxt->input->cur)) */
+#define CUR ((int) (*ctxt->input->cur))
+#define NEXT xmlNextChar(ctxt)
+
+#define RAW (ctxt->token ? -1 : (*ctxt->input->cur))
+#define NXT(val) ctxt->input->cur[(val)]
+#define CUR_PTR ctxt->input->cur
+
+
+#define NEXTL(l) do {							\
+    if (*(ctxt->input->cur) == '\n') {					\
+	ctxt->input->line++; ctxt->input->col = 1;			\
+    } else ctxt->input->col++;						\
+    ctxt->token = 0; ctxt->input->cur += l; ctxt->nbChars++;		\
+  } while (0)
+    
+/************
+    \
+    if (*ctxt->input->cur == '%') xmlParserHandlePEReference(ctxt);	\
+    if (*ctxt->input->cur == '&') xmlParserHandleReference(ctxt);
+ ************/
+
+#define CUR_CHAR(l) htmlCurrentChar(ctxt, &l)
+#define CUR_SCHAR(s, l) xmlStringCurrentChar(ctxt, s, &l)
+
+#define COPY_BUF(l,b,i,v)						\
+    if (l == 1) b[i++] = (xmlChar) v;					\
+    else i += xmlCopyChar(l,&b[i],v)
+
+/**
+ * htmlCurrentChar:
+ * @ctxt:  the HTML parser context
+ * @len:  pointer to the length of the char read
+ *
+ * The current char value, if using UTF-8 this may actually span multiple
+ * bytes in the input buffer. Implement the end of line normalization:
+ * 2.11 End-of-Line Handling
+ * If the encoding is unspecified, in the case we find an ISO-Latin-1
+ * char, then the encoding converter is plugged in automatically.
+ *
+ * Returns the current char value and its length
+ */
+
+static int
+htmlCurrentChar(xmlParserCtxtPtr ctxt, int *len) {
+    if (ctxt->instate == XML_PARSER_EOF)
+	return(0);
+
+    if (ctxt->token != 0) {
+	*len = 0;
+	return(ctxt->token);
+    }	
+    if (ctxt->charset == XML_CHAR_ENCODING_UTF8) {
+	/*
+	 * We are supposed to handle UTF8, check it's valid
+	 * From rfc2044: encoding of the Unicode values on UTF-8:
+	 *
+	 * UCS-4 range (hex.)           UTF-8 octet sequence (binary)
+	 * 0000 0000-0000 007F   0xxxxxxx
+	 * 0000 0080-0000 07FF   110xxxxx 10xxxxxx
+	 * 0000 0800-0000 FFFF   1110xxxx 10xxxxxx 10xxxxxx 
+	 *
+	 * Check for the 0x110000 limit too
+	 */
+	const unsigned char *cur = ctxt->input->cur;
+	unsigned char c;
+	unsigned int val;
+
+	c = *cur;
+	if (c & 0x80) {
+	    if (cur[1] == 0)
+		xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
+	    if ((cur[1] & 0xc0) != 0x80)
+		goto encoding_error;
+	    if ((c & 0xe0) == 0xe0) {
+
+		if (cur[2] == 0)
+		    xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
+		if ((cur[2] & 0xc0) != 0x80)
+		    goto encoding_error;
+		if ((c & 0xf0) == 0xf0) {
+		    if (cur[3] == 0)
+			xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
+		    if (((c & 0xf8) != 0xf0) ||
+			((cur[3] & 0xc0) != 0x80))
+			goto encoding_error;
+		    /* 4-byte code */
+		    *len = 4;
+		    val = (cur[0] & 0x7) << 18;
+		    val |= (cur[1] & 0x3f) << 12;
+		    val |= (cur[2] & 0x3f) << 6;
+		    val |= cur[3] & 0x3f;
+		} else {
+		  /* 3-byte code */
+		    *len = 3;
+		    val = (cur[0] & 0xf) << 12;
+		    val |= (cur[1] & 0x3f) << 6;
+		    val |= cur[2] & 0x3f;
+		}
+	    } else {
+	      /* 2-byte code */
+		*len = 2;
+		val = (cur[0] & 0x1f) << 6;
+		val |= cur[1] & 0x3f;
+	    }
+	    if (!IS_CHAR(val)) {
+	        htmlParseErrInt(ctxt, XML_ERR_INVALID_CHAR,
+				"Char 0x%X out of allowed range\n", val);
+	    }    
+	    return(val);
+	} else {
+	    /* 1-byte code */
+	    *len = 1;
+	    return((int) *ctxt->input->cur);
+	}
+    }
+    /*
+     * Assume it's a fixed length encoding (1) with
+     * a compatible encoding for the ASCII set, since
+     * XML constructs only use < 128 chars
+     */
+    *len = 1;
+    if ((int) *ctxt->input->cur < 0x80)
+	return((int) *ctxt->input->cur);
+
+    /*
+     * Humm this is bad, do an automatic flow conversion
+     */
+    xmlSwitchEncoding(ctxt, XML_CHAR_ENCODING_8859_1);
+    ctxt->charset = XML_CHAR_ENCODING_UTF8;
+    return(xmlCurrentChar(ctxt, len));
+
+encoding_error:
+    /*
+     * If we detect an UTF8 error that probably mean that the
+     * input encoding didn't get properly advertized in the
+     * declaration header. Report the error and switch the encoding
+     * to ISO-Latin-1 (if you don't like this policy, just declare the
+     * encoding !)
+     */
+    htmlParseErr(ctxt, XML_ERR_INVALID_ENCODING,
+		 "Input is not proper UTF-8, indicate encoding !\n",
+		 NULL, NULL);
+    if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL)) {
+	ctxt->sax->error(ctxt->userData, "Bytes: 0x%02X 0x%02X 0x%02X 0x%02X\n",
+			ctxt->input->cur[0], ctxt->input->cur[1],
+			ctxt->input->cur[2], ctxt->input->cur[3]);
+    }
+
+    ctxt->charset = XML_CHAR_ENCODING_8859_1; 
+    *len = 1;
+    return((int) *ctxt->input->cur);
+}
+
+/**
+ * htmlSkipBlankChars:
+ * @ctxt:  the HTML parser context
+ *
+ * skip all blanks character found at that point in the input streams.
+ *
+ * Returns the number of space chars skipped
+ */
+
+static int
+htmlSkipBlankChars(xmlParserCtxtPtr ctxt) {
+    int res = 0;
+
+    while (IS_BLANK_CH(*(ctxt->input->cur))) {
+	if ((*ctxt->input->cur == 0) &&
+	    (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0)) {
+		xmlPopInput(ctxt);
+	} else {
+	    if (*(ctxt->input->cur) == '\n') {
+		ctxt->input->line++; ctxt->input->col = 1;
+	    } else ctxt->input->col++;
+	    ctxt->input->cur++;
+	    ctxt->nbChars++;
+	    if (*ctxt->input->cur == 0)
+		xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
+	}
+	res++;
+    }
+    return(res);
+}
+
+
+
+/************************************************************************
+ *									*
+ * 		The list of HTML elements and their properties		*
+ *									*
+ ************************************************************************/
+
+/*
+ *  Start Tag: 1 means the start tag can be ommited
+ *  End Tag:   1 means the end tag can be ommited
+ *             2 means it's forbidden (empty elements)
+ *             3 means the tag is stylistic and should be closed easily
+ *  Depr:      this element is deprecated
+ *  DTD:       1 means that this element is valid only in the Loose DTD
+ *             2 means that this element is valid only in the Frameset DTD
+ *
+ * Name,Start Tag,End Tag,Save End,Empty,Deprecated,DTD,inline,Description
+	, subElements , impliedsubelt , Attributes, userdata
+ */
+
+/* Definitions and a couple of vars for HTML Elements */
+
+#define FONTSTYLE "tt", "i", "b", "u", "s", "strike", "big", "small"
+#define PHRASE "em", "strong", "dfn", "code", "samp", "kbd", "var", "cite", "abbr", "acronym"
+#define SPECIAL "a", "img", "applet", "object", "font", "basefont", "br", "script", "map", "q", "sub", "sup", "span", "bdo", "iframe"
+#define INLINE PCDATA FONTSTYLE PHRASE SPECIAL FORMCTRL
+#define BLOCK HEADING LIST "pre", "p", "dl", "div", "center", "noscript", "noframes", "blockquote", "form", "isindex", "hr", "table", "fieldset", "address"
+#define FORMCTRL "input", "select", "textarea", "label", "button"
+#define PCDATA
+#define HEADING "h1", "h2", "h3", "h4", "h5", "h6"
+#define LIST "ul", "ol", "dir", "menu"
+#define MODIFIER
+#define FLOW BLOCK,INLINE
+#define EMPTY NULL
+
+
+static const char* html_flow[] = { FLOW, NULL } ;
+static const char* html_inline[] = { INLINE, NULL } ;
+
+/* placeholders: elts with content but no subelements */
+static const char* html_pcdata[] = { NULL } ;
+#define html_cdata html_pcdata
+
+
+/* ... and for HTML Attributes */
+
+#define COREATTRS "id", "class", "style", "title"
+#define I18N "lang", "dir"
+#define EVENTS "onclick", "ondblclick", "onmousedown", "onmouseup", "onmouseover", "onmouseout", "onkeypress", "onkeydown", "onkeyup"
+#define ATTRS COREATTRS,I18N,EVENTS
+#define CELLHALIGN "align", "char", "charoff"
+#define CELLVALIGN "valign"
+
+static const char* html_attrs[] = { ATTRS, NULL } ;
+static const char* core_i18n_attrs[] = { COREATTRS, I18N, NULL } ;
+static const char* core_attrs[] = { COREATTRS, NULL } ;
+static const char* i18n_attrs[] = { I18N, NULL } ;
+
+
+/* Other declarations that should go inline ... */
+static const char* a_attrs[] = { ATTRS, "charset", "type", "name",
+	"href", "hreflang", "rel", "rev", "accesskey", "shape", "coords",
+	"tabindex", "onfocus", "onblur", NULL } ;
+static const char* target_attr[] = { "target", NULL } ;
+static const char* rows_cols_attr[] = { "rows", "cols", NULL } ;
+static const char* alt_attr[] = { "alt", NULL } ;
+static const char* src_alt_attrs[] = { "src", "alt", NULL } ;
+static const char* href_attrs[] = { "href", NULL } ;
+static const char* clear_attrs[] = { "clear", NULL } ;
+static const char* inline_p[] = { INLINE, "p", NULL } ;
+static const char* flow_param[] = { FLOW, "param", NULL } ;
+static const char* applet_attrs[] = { COREATTRS , "codebase",
+		"archive", "alt", "name", "height", "width", "align",
+		"hspace", "vspace", NULL } ;
+static const char* area_attrs[] = { "shape", "coords", "href", "nohref",
+	"tabindex", "accesskey", "onfocus", "onblur", NULL } ;
+static const char* basefont_attrs[] =
+	{ "id", "size", "color", "face", NULL } ;
+static const char* quote_attrs[] = { ATTRS, "cite", NULL } ;
+static const char* body_contents[] = { FLOW, "ins", "del", NULL } ;
+static const char* body_attrs[] = { ATTRS, "onload", "onunload", NULL } ;
+static const char* body_depr[] = { "background", "bgcolor", "text",
+	"link", "vlink", "alink", NULL } ;
+static const char* button_attrs[] = { ATTRS, "name", "value", "type",
+	"disabled", "tabindex", "accesskey", "onfocus", "onblur", NULL } ;
+
+
+static const char* col_attrs[] = { ATTRS, "span", "width", CELLHALIGN, CELLVALIGN, NULL } ;
+static const char* col_elt[] = { "col", NULL } ;
+static const char* edit_attrs[] = { ATTRS, "datetime", "cite", NULL } ;
+static const char* compact_attrs[] = { ATTRS, "compact", NULL } ;
+static const char* dl_contents[] = { "dt", "dd", NULL } ;
+static const char* compact_attr[] = { "compact", NULL } ;
+static const char* label_attr[] = { "label", NULL } ;
+static const char* fieldset_contents[] = { FLOW, "legend" } ;
+static const char* font_attrs[] = { COREATTRS, I18N, "size", "color", "face" , NULL } ;
+static const char* form_contents[] = { HEADING, LIST, INLINE, "pre", "p", "div", "center", "noscript", "noframes", "blockquote", "isindex", "hr", "table", "fieldset", "address", NULL } ;
+static const char* form_attrs[] = { ATTRS, "method", "enctype", "accept", "name", "onsubmit", "onreset", "accept-charset", NULL } ;
+static const char* frame_attrs[] = { COREATTRS, "longdesc", "name", "src", "frameborder", "marginwidth", "marginheight", "noresize", "scrolling" , NULL } ;
+static const char* frameset_attrs[] = { COREATTRS, "rows", "cols", "onload", "onunload", NULL } ;
+static const char* frameset_contents[] = { "frameset", "frame", "noframes", NULL } ;
+static const char* head_attrs[] = { I18N, "profile", NULL } ;
+static const char* head_contents[] = { "title", "isindex", "base", "script", "style", "meta", "link", "object", NULL } ;
+static const char* hr_depr[] = { "align", "noshade", "size", "width", NULL } ;
+static const char* version_attr[] = { "version", NULL } ;
+static const char* html_content[] = { "head", "body", "frameset", NULL } ;
+static const char* iframe_attrs[] = { COREATTRS, "longdesc", "name", "src", "frameborder", "marginwidth", "marginheight", "scrolling", "align", "height", "width", NULL } ;
+static const char* img_attrs[] = { ATTRS, "longdesc", "name", "height", "width", "usemap", "ismap", NULL } ;
+static const char* input_attrs[] = { ATTRS, "type", "name", "value", "checked", "disabled", "readonly", "size", "maxlength", "src", "alt", "usemap", "ismap", "tabindex", "accesskey", "onfocus", "onblur", "onselect", "onchange", "accept", NULL } ;
+static const char* prompt_attrs[] = { COREATTRS, I18N, "prompt", NULL } ;
+static const char* label_attrs[] = { ATTRS, "for", "accesskey", "onfocus", "onblur", NULL } ;
+static const char* legend_attrs[] = { ATTRS, "accesskey", NULL } ;
+static const char* align_attr[] = { "align", NULL } ;
+static const char* link_attrs[] = { ATTRS, "charset", "href", "hreflang", "type", "rel", "rev", "media", NULL } ;
+static const char* map_contents[] = { BLOCK, "area", NULL } ;
+static const char* name_attr[] = { "name", NULL } ;
+static const char* action_attr[] = { "action", NULL } ;
+static const char* blockli_elt[] = { BLOCK, "li", NULL } ;
+static const char* meta_attrs[] = { I18N, "http-equiv", "name", "scheme", NULL } ;
+static const char* content_attr[] = { "content", NULL } ;
+static const char* type_attr[] = { "type", NULL } ;
+static const char* noframes_content[] = { "body", FLOW MODIFIER, NULL } ;
+static const char* object_contents[] = { FLOW, "param", NULL } ;
+static const char* object_attrs[] = { ATTRS, "declare", "classid", "codebase", "data", "type", "codetype", "archive", "standby", "height", "width", "usemap", "name", "tabindex", NULL } ;
+static const char* object_depr[] = { "align", "border", "hspace", "vspace", NULL } ;
+static const char* ol_attrs[] = { "type", "compact", "start", NULL} ;
+static const char* option_elt[] = { "option", NULL } ;
+static const char* optgroup_attrs[] = { ATTRS, "disabled", NULL } ;
+static const char* option_attrs[] = { ATTRS, "disabled", "label", "selected", "value", NULL } ;
+static const char* param_attrs[] = { "id", "value", "valuetype", "type", NULL } ;
+static const char* width_attr[] = { "width", NULL } ;
+static const char* pre_content[] = { PHRASE, "tt", "i", "b", "u", "s", "strike", "a", "br", "script", "map", "q", "span", "bdo", "iframe", NULL } ;
+static const char* script_attrs[] = { "charset", "src", "defer", "event", "for", NULL } ;
+static const char* language_attr[] = { "language", NULL } ;
+static const char* select_content[] = { "optgroup", "option", NULL } ;
+static const char* select_attrs[] = { ATTRS, "name", "size", "multiple", "disabled", "tabindex", "onfocus", "onblur", "onchange", NULL } ;
+static const char* style_attrs[] = { I18N, "media", "title", NULL } ;
+static const char* table_attrs[] = { ATTRS "summary", "width", "border", "frame", "rules", "cellspacing", "cellpadding", "datapagesize", NULL } ;
+static const char* table_depr[] = { "align", "bgcolor", NULL } ;
+static const char* table_contents[] = { "caption", "col", "colgroup", "thead", "tfoot", "tbody", "tr", NULL} ;
+static const char* tr_elt[] = { "tr", NULL } ;
+static const char* talign_attrs[] = { ATTRS, CELLHALIGN, CELLVALIGN, NULL} ;
+static const char* th_td_depr[] = { "nowrap", "bgcolor", "width", "height", NULL } ;
+static const char* th_td_attr[] = { ATTRS, "abbr", "axis", "headers", "scope", "rowspan", "colspan", CELLHALIGN, CELLVALIGN, NULL } ;
+static const char* textarea_attrs[] = { ATTRS, "name", "disabled", "readonly", "tabindex", "accesskey", "onfocus", "onblur", "onselect", "onchange", NULL } ;
+static const char* tr_contents[] = { "th", "td", NULL } ;
+static const char* bgcolor_attr[] = { "bgcolor", NULL } ;
+static const char* li_elt[] = { "li", NULL } ;
+static const char* ul_depr[] = { "type", "compact", NULL} ;
+static const char* dir_attr[] = { "dir", NULL} ;
+
+#define DECL (const char**)
+
+static const htmlElemDesc
+html40ElementTable[] = {
+{ "a",		0, 0, 0, 0, 0, 0, 1, "anchor ",
+	DECL html_inline , NULL , DECL a_attrs , DECL target_attr, NULL
+},
+{ "abbr",	0, 0, 0, 0, 0, 0, 1, "abbreviated form",
+	DECL html_inline , NULL , DECL html_attrs, NULL, NULL
+},
+{ "acronym",	0, 0, 0, 0, 0, 0, 1, "",
+	DECL html_inline , NULL , DECL html_attrs, NULL, NULL
+},
+{ "address",	0, 0, 0, 0, 0, 0, 0, "information on author ",
+	DECL inline_p  , NULL , DECL html_attrs, NULL, NULL
+},
+{ "applet",	0, 0, 0, 0, 1, 1, 2, "java applet ",
+	DECL flow_param , NULL , NULL , DECL applet_attrs, NULL
+},
+{ "area",	0, 2, 2, 1, 0, 0, 0, "client-side image map area ",
+	EMPTY ,  NULL , DECL area_attrs , DECL target_attr, DECL alt_attr
+},
+{ "b",		0, 3, 0, 0, 0, 0, 1, "bold text style",
+	DECL html_inline , NULL , DECL html_attrs, NULL, NULL
+},
+{ "base",	0, 2, 2, 1, 0, 0, 0, "document base uri ",
+	EMPTY , NULL , NULL , DECL target_attr, DECL href_attrs
+},
+{ "basefont",	0, 2, 2, 1, 1, 1, 1, "base font size " ,
+	EMPTY , NULL , NULL, DECL basefont_attrs, NULL
+},
+{ "bdo",	0, 0, 0, 0, 0, 0, 1, "i18n bidi over-ride ",
+	DECL html_inline , NULL , DECL core_i18n_attrs, NULL, DECL dir_attr
+},
+{ "big",	0, 3, 0, 0, 0, 0, 1, "large text style",
+	DECL html_inline , NULL , DECL html_attrs, NULL, NULL
+},
+{ "blockquote",	0, 0, 0, 0, 0, 0, 0, "long quotation ",
+	DECL html_flow , NULL , DECL quote_attrs , NULL, NULL
+},
+{ "body",	1, 1, 0, 0, 0, 0, 0, "document body ",
+	DECL body_contents , "div" , DECL body_attrs, DECL body_depr, NULL
+},
+{ "br",		0, 2, 2, 1, 0, 0, 1, "forced line break ",
+	EMPTY , NULL , DECL core_attrs, DECL clear_attrs , NULL
+},
+{ "button",	0, 0, 0, 0, 0, 0, 2, "push button ",
+	DECL html_flow MODIFIER , NULL , DECL button_attrs, NULL, NULL
+},
+{ "caption",	0, 0, 0, 0, 0, 0, 0, "table caption ",
+	DECL html_inline , NULL , DECL html_attrs, NULL, NULL
+},
+{ "center",	0, 3, 0, 0, 1, 1, 0, "shorthand for div align=center ",
+	DECL html_flow , NULL , NULL, DECL html_attrs, NULL
+},
+{ "cite",	0, 0, 0, 0, 0, 0, 1, "citation",
+	DECL html_inline , NULL , DECL html_attrs, NULL, NULL
+},
+{ "code",	0, 0, 0, 0, 0, 0, 1, "computer code fragment",
+	DECL html_inline , NULL , DECL html_attrs, NULL, NULL
+},
+{ "col",	0, 2, 2, 1, 0, 0, 0, "table column ",
+	EMPTY , NULL , DECL col_attrs , NULL, NULL
+},
+{ "colgroup",	0, 1, 0, 0, 0, 0, 0, "table column group ",
+	DECL col_elt , "col" , DECL col_attrs , NULL, NULL
+},
+{ "dd",		0, 1, 0, 0, 0, 0, 0, "definition description ",
+	DECL html_flow , NULL , DECL html_attrs, NULL, NULL
+},
+{ "del",	0, 0, 0, 0, 0, 0, 2, "deleted text ",
+	DECL html_flow , NULL , DECL edit_attrs , NULL, NULL
+},
+{ "dfn",	0, 0, 0, 0, 0, 0, 1, "instance definition",
+	DECL html_inline , NULL , DECL html_attrs, NULL, NULL
+},
+{ "dir",	0, 0, 0, 0, 1, 1, 0, "directory list",
+	DECL blockli_elt, "li" , NULL, DECL compact_attrs, NULL
+},
+{ "div",	0, 0, 0, 0, 0, 0, 0, "generic language/style container",
+	DECL html_flow, NULL, DECL html_attrs, DECL align_attr, NULL
+},
+{ "dl",		0, 0, 0, 0, 0, 0, 0, "definition list ",
+	DECL dl_contents , "dd" , html_attrs, DECL compact_attr, NULL
+},
+{ "dt",		0, 1, 0, 0, 0, 0, 0, "definition term ",
+	DECL html_inline, NULL, DECL html_attrs, NULL, NULL
+},
+{ "em",		0, 3, 0, 0, 0, 0, 1, "emphasis",
+	DECL html_inline, NULL, DECL html_attrs, NULL, NULL
+},
+{ "fieldset",	0, 0, 0, 0, 0, 0, 0, "form control group ",
+	DECL fieldset_contents , NULL, DECL html_attrs, NULL, NULL
+},
+{ "font",	0, 3, 0, 0, 1, 1, 1, "local change to font ",
+	DECL html_inline, NULL, NULL, DECL font_attrs, NULL
+},
+{ "form",	0, 0, 0, 0, 0, 0, 0, "interactive form ",
+	DECL form_contents, "fieldset", DECL form_attrs , DECL target_attr, DECL action_attr
+},
+{ "frame",	0, 2, 2, 1, 0, 2, 0, "subwindow " ,
+	EMPTY, NULL, NULL, DECL frame_attrs, NULL
+},
+{ "frameset",	0, 0, 0, 0, 0, 2, 0, "window subdivision" ,
+	DECL frameset_contents, "noframes" , NULL , DECL frameset_attrs, NULL
+},
+{ "h1",		0, 0, 0, 0, 0, 0, 0, "heading ",
+	DECL html_inline, NULL, DECL html_attrs, DECL align_attr, NULL
+},
+{ "h2",		0, 0, 0, 0, 0, 0, 0, "heading ",
+	DECL html_inline, NULL, DECL html_attrs, DECL align_attr, NULL
+},
+{ "h3",		0, 0, 0, 0, 0, 0, 0, "heading ",
+	DECL html_inline, NULL, DECL html_attrs, DECL align_attr, NULL
+},
+{ "h4",		0, 0, 0, 0, 0, 0, 0, "heading ",
+	DECL html_inline, NULL, DECL html_attrs, DECL align_attr, NULL
+},
+{ "h5",		0, 0, 0, 0, 0, 0, 0, "heading ",
+	DECL html_inline, NULL, DECL html_attrs, DECL align_attr, NULL
+},
+{ "h6",		0, 0, 0, 0, 0, 0, 0, "heading ",
+	DECL html_inline, NULL, DECL html_attrs, DECL align_attr, NULL
+},
+{ "head",	1, 1, 0, 0, 0, 0, 0, "document head ",
+	DECL head_contents, NULL, DECL head_attrs, NULL, NULL
+},
+{ "hr",		0, 2, 2, 1, 0, 0, 0, "horizontal rule " ,
+	EMPTY, NULL, DECL html_attrs, DECL hr_depr, NULL
+},
+{ "html",	1, 1, 0, 0, 0, 0, 0, "document root element ",
+	DECL html_content , NULL , DECL i18n_attrs, DECL version_attr, NULL
+},
+{ "i",		0, 3, 0, 0, 0, 0, 1, "italic text style",
+	DECL html_inline, NULL, DECL html_attrs, NULL, NULL
+},
+{ "iframe",	0, 0, 0, 0, 0, 1, 2, "inline subwindow ",
+	DECL html_flow, NULL, NULL, DECL iframe_attrs, NULL
+},
+{ "img",	0, 2, 2, 1, 0, 0, 1, "embedded image ",
+	EMPTY, NULL, DECL img_attrs, DECL align_attr, src_alt_attrs
+},
+{ "input",	0, 2, 2, 1, 0, 0, 1, "form control ",
+	EMPTY, NULL, DECL input_attrs , DECL align_attr, NULL
+},
+{ "ins",	0, 0, 0, 0, 0, 0, 2, "inserted text",
+	DECL html_flow, NULL, DECL edit_attrs, NULL, NULL
+},
+{ "isindex",	0, 2, 2, 1, 1, 1, 0, "single line prompt ",
+	EMPTY, NULL, NULL, DECL prompt_attrs, NULL
+},
+{ "kbd",	0, 0, 0, 0, 0, 0, 1, "text to be entered by the user",
+	DECL html_inline, NULL, DECL html_attrs, NULL, NULL
+},
+{ "label",	0, 0, 0, 0, 0, 0, 1, "form field label text ",
+	DECL html_inline MODIFIER, NULL, DECL label_attrs , NULL, NULL
+},
+{ "legend",	0, 0, 0, 0, 0, 0, 0, "fieldset legend ",
+	DECL html_inline, NULL, DECL legend_attrs , DECL align_attr, NULL
+},
+{ "li",		0, 1, 1, 0, 0, 0, 0, "list item ",
+	DECL html_flow, NULL, DECL html_attrs, NULL, NULL
+},
+{ "link",	0, 2, 2, 1, 0, 0, 0, "a media-independent link ",
+	EMPTY, NULL, DECL link_attrs, DECL target_attr, NULL
+},
+{ "map",	0, 0, 0, 0, 0, 0, 2, "client-side image map ",
+	DECL map_contents , NULL, DECL html_attrs , NULL, name_attr
+},
+{ "menu",	0, 0, 0, 0, 1, 1, 0, "menu list ",
+	DECL blockli_elt , NULL, NULL, DECL compact_attrs, NULL
+},
+{ "meta",	0, 2, 2, 1, 0, 0, 0, "generic metainformation ",
+	EMPTY, NULL, DECL meta_attrs , NULL , DECL content_attr
+},
+{ "noframes",	0, 0, 0, 0, 0, 2, 0, "alternate content container for non frame-based rendering ",
+	DECL noframes_content, "body" , DECL html_attrs, NULL, NULL
+},
+{ "noscript",	0, 0, 0, 0, 0, 0, 0, "alternate content container for non script-based rendering ",
+	DECL html_flow, "div", DECL html_attrs, NULL, NULL
+},
+{ "object",	0, 0, 0, 0, 0, 0, 2, "generic embedded object ",
+	DECL object_contents , "div" , DECL object_attrs, DECL object_depr, NULL
+},
+{ "ol",		0, 0, 0, 0, 0, 0, 0, "ordered list ",
+	DECL li_elt , "li" , DECL html_attrs, DECL ol_attrs, NULL
+},
+{ "optgroup",	0, 0, 0, 0, 0, 0, 0, "option group ",
+	option_elt , "option", DECL optgroup_attrs, NULL, DECL label_attr
+},
+{ "option",	0, 1, 0, 0, 0, 0, 0, "selectable choice " ,
+	DECL html_pcdata, NULL, DECL option_attrs, NULL, NULL
+},
+{ "p",		0, 1, 0, 0, 0, 0, 0, "paragraph ",
+	DECL html_inline, NULL, DECL html_attrs, DECL align_attr, NULL
+},
+{ "param",	0, 2, 2, 1, 0, 0, 0, "named property value ",
+	EMPTY, NULL, DECL param_attrs, NULL, name_attr
+},
+{ "pre",	0, 0, 0, 0, 0, 0, 0, "preformatted text ",
+	DECL pre_content, NULL, DECL html_attrs, DECL width_attr, NULL
+},
+{ "q",		0, 0, 0, 0, 0, 0, 1, "short inline quotation ",
+	DECL html_inline, NULL, DECL quote_attrs, NULL, NULL
+},
+{ "s",		0, 3, 0, 0, 1, 1, 1, "strike-through text style",
+	DECL html_inline, NULL, NULL, DECL html_attrs, NULL
+},
+{ "samp",	0, 0, 0, 0, 0, 0, 1, "sample program output, scripts, etc.",
+	DECL html_inline, NULL, DECL html_attrs, NULL, NULL
+},
+{ "script",	0, 0, 0, 0, 0, 0, 2, "script statements ",
+	DECL html_cdata, NULL, DECL script_attrs, DECL language_attr, DECL type_attr
+},
+{ "select",	0, 0, 0, 0, 0, 0, 1, "option selector ",
+	DECL select_content, NULL, DECL select_attrs, NULL, NULL
+},
+{ "small",	0, 3, 0, 0, 0, 0, 1, "small text style",
+	DECL html_inline, NULL, DECL html_attrs, NULL, NULL
+},
+{ "span",	0, 0, 0, 0, 0, 0, 1, "generic language/style container ",
+	DECL html_inline, NULL, DECL html_attrs, NULL, NULL
+},
+{ "strike",	0, 3, 0, 0, 1, 1, 1, "strike-through text",
+	DECL html_inline, NULL, NULL, DECL html_attrs, NULL
+},
+{ "strong",	0, 3, 0, 0, 0, 0, 1, "strong emphasis",
+	DECL html_inline, NULL, DECL html_attrs, NULL, NULL
+},
+{ "style",	0, 0, 0, 0, 0, 0, 0, "style info ",
+	DECL html_cdata, NULL, DECL style_attrs, NULL, DECL type_attr
+},
+{ "sub",	0, 3, 0, 0, 0, 0, 1, "subscript",
+	DECL html_inline, NULL, DECL html_attrs, NULL, NULL
+},
+{ "sup",	0, 3, 0, 0, 0, 0, 1, "superscript ",
+	DECL html_inline, NULL, DECL html_attrs, NULL, NULL
+},
+{ "table",	0, 0, 0, 0, 0, 0, 0, "",
+	DECL table_contents , "tr" , DECL table_attrs , DECL table_depr, NULL
+},
+{ "tbody",	1, 0, 0, 0, 0, 0, 0, "table body ",
+	DECL tr_elt , "tr" , DECL talign_attrs, NULL, NULL
+},
+{ "td",		0, 0, 0, 0, 0, 0, 0, "table data cell",
+	DECL html_flow, NULL, DECL th_td_attr, DECL th_td_depr, NULL
+},
+{ "textarea",	0, 0, 0, 0, 0, 0, 1, "multi-line text field ",
+	DECL html_pcdata, NULL, DECL textarea_attrs, NULL, DECL rows_cols_attr
+},
+{ "tfoot",	0, 1, 0, 0, 0, 0, 0, "table footer ",
+	DECL tr_elt , "tr" , DECL talign_attrs, NULL, NULL
+},
+{ "th",		0, 1, 0, 0, 0, 0, 0, "table header cell",
+	DECL html_flow, NULL, DECL th_td_attr, DECL th_td_depr, NULL
+},
+{ "thead",	0, 1, 0, 0, 0, 0, 0, "table header ",
+	DECL tr_elt , "tr" , DECL talign_attrs, NULL, NULL
+},
+{ "title",	0, 0, 0, 0, 0, 0, 0, "document title ",
+	DECL html_pcdata, NULL, DECL i18n_attrs, NULL, NULL
+},
+{ "tr",		0, 0, 0, 0, 0, 0, 0, "table row ",
+	DECL tr_contents , "td" , DECL talign_attrs, DECL bgcolor_attr, NULL
+},
+{ "tt",		0, 3, 0, 0, 0, 0, 1, "teletype or monospaced text style",
+	DECL html_inline, NULL, DECL html_attrs, NULL, NULL
+},
+{ "u",		0, 3, 0, 0, 1, 1, 1, "underlined text style",
+	DECL html_inline, NULL, NULL, DECL html_attrs, NULL
+},
+{ "ul",		0, 0, 0, 0, 0, 0, 0, "unordered list ",
+	DECL li_elt , "li" , DECL html_attrs, DECL ul_depr, NULL
+},
+{ "var",	0, 0, 0, 0, 0, 0, 1, "instance of a variable or program argument",
+	DECL html_inline, NULL, DECL html_attrs, NULL, NULL
+}
+};
+
+/*
+ * start tags that imply the end of current element
+ */
+static const char *htmlStartClose[] = {
+"form",		"form", "p", "hr", "h1", "h2", "h3", "h4", "h5", "h6",
+		"dl", "ul", "ol", "menu", "dir", "address", "pre",
+		"listing", "xmp", "head", NULL,
+"head",		"p", NULL,
+"title",	"p", NULL,
+"body",		"head", "style", "link", "title", "p", NULL,
+"frameset",	"head", "style", "link", "title", "p", NULL,
+"li",		"p", "h1", "h2", "h3", "h4", "h5", "h6", "dl", "address",
+		"pre", "listing", "xmp", "head", "li", NULL,
+"hr",		"p", "head", NULL,
+"h1",		"p", "head", NULL,
+"h2",		"p", "head", NULL,
+"h3",		"p", "head", NULL,
+"h4",		"p", "head", NULL,
+"h5",		"p", "head", NULL,
+"h6",		"p", "head", NULL,
+"dir",		"p", "head", NULL,
+"address",	"p", "head", "ul", NULL,
+"pre",		"p", "head", "ul", NULL,
+"listing",	"p", "head", NULL,
+"xmp",		"p", "head", NULL,
+"blockquote",	"p", "head", NULL,
+"dl",		"p", "dt", "menu", "dir", "address", "pre", "listing",
+		"xmp", "head", NULL,
+"dt",		"p", "menu", "dir", "address", "pre", "listing", "xmp",
+                "head", "dd", NULL,
+"dd",		"p", "menu", "dir", "address", "pre", "listing", "xmp",
+                "head", "dt", NULL,
+"ul",		"p", "head", "ol", "menu", "dir", "address", "pre",
+		"listing", "xmp", NULL,
+"ol",		"p", "head", "ul", NULL,
+"menu",		"p", "head", "ul", NULL,
+"p",		"p", "head", "h1", "h2", "h3", "h4", "h5", "h6", NULL,
+"div",		"p", "head", NULL,
+"noscript",	"p", "head", NULL,
+"center",	"font", "b", "i", "p", "head", NULL,
+"a",		"a", NULL,
+"caption",	"p", NULL,
+"colgroup",	"caption", "colgroup", "col", "p", NULL,
+"col",		"caption", "col", "p", NULL,
+"table",	"p", "head", "h1", "h2", "h3", "h4", "h5", "h6", "pre",
+		"listing", "xmp", "a", NULL,
+"th",		"th", "td", "p", "span", "font", "a", "b", "i", "u", NULL,
+"td",		"th", "td", "p", "span", "font", "a", "b", "i", "u", NULL,      
+"tr",		"th", "td", "tr", "caption", "col", "colgroup", "p", NULL,
+"thead",	"caption", "col", "colgroup", NULL,
+"tfoot",	"th", "td", "tr", "caption", "col", "colgroup", "thead",
+		"tbody", "p", NULL,
+"tbody",	"th", "td", "tr", "caption", "col", "colgroup", "thead",
+		"tfoot", "tbody", "p", NULL,
+"optgroup",	"option", NULL,
+"option",	"option", NULL,
+"fieldset",	"legend", "p", "head", "h1", "h2", "h3", "h4", "h5", "h6",
+		"pre", "listing", "xmp", "a", NULL,
+NULL
+};
+
+/*
+ * The list of HTML elements which are supposed not to have
+ * CDATA content and where a p element will be implied
+ *
+ * TODO: extend that list by reading the HTML SGML DTD on
+ *       implied paragraph
+ */
+static const char *htmlNoContentElements[] = {
+    "html",
+    "head",
+    "body",
+    NULL
+};
+
+/*
+ * The list of HTML attributes which are of content %Script;
+ * NOTE: when adding ones, check htmlIsScriptAttribute() since
+ *       it assumes the name starts with 'on'
+ */
+static const char *htmlScriptAttributes[] = {
+    "onclick",
+    "ondblclick",
+    "onmousedown",
+    "onmouseup",
+    "onmouseover",
+    "onmousemove",
+    "onmouseout",
+    "onkeypress",
+    "onkeydown",
+    "onkeyup",
+    "onload",
+    "onunload",
+    "onfocus",
+    "onblur",
+    "onsubmit",
+    "onrest",
+    "onchange",
+    "onselect"
+};
+
+/*
+ * This table is used by the htmlparser to know what to do with
+ * broken html pages. By assigning different priorities to different
+ * elements the parser can decide how to handle extra endtags.
+ * Endtags are only allowed to close elements with lower or equal
+ * priority.
+ */ 
+
+typedef struct {
+    const char *name;
+    int priority;
+} elementPriority;
+
+static const elementPriority htmlEndPriority[] = {
+    {"div",   150},
+    {"td",    160},
+    {"th",    160},
+    {"tr",    170},
+    {"thead", 180},
+    {"tbody", 180},
+    {"tfoot", 180},
+    {"table", 190},
+    {"head",  200},
+    {"body",  200},
+    {"html",  220},
+    {NULL,    100} /* Default priority */
+};
+
+static const char** htmlStartCloseIndex[100];
+static int htmlStartCloseIndexinitialized = 0;
+
+/************************************************************************
+ *									*
+ * 		functions to handle HTML specific data			*
+ *									*
+ ************************************************************************/
+
+/**
+ * htmlInitAutoClose:
+ *
+ * Initialize the htmlStartCloseIndex for fast lookup of closing tags names.
+ * This is not reentrant. Call xmlInitParser() once before processing in
+ * case of use in multithreaded programs.
+ */
+void
+htmlInitAutoClose(void) {
+    int indx, i = 0;
+
+    if (htmlStartCloseIndexinitialized) return;
+
+    for (indx = 0;indx < 100;indx ++) htmlStartCloseIndex[indx] = NULL;
+    indx = 0;
+    while ((htmlStartClose[i] != NULL) && (indx < 100 - 1)) {
+        htmlStartCloseIndex[indx++] = &htmlStartClose[i];
+	while (htmlStartClose[i] != NULL) i++;
+	i++;
+    }
+    htmlStartCloseIndexinitialized = 1;
+}
+
+/**
+ * htmlTagLookup:
+ * @tag:  The tag name in lowercase
+ *
+ * Lookup the HTML tag in the ElementTable
+ *
+ * Returns the related htmlElemDescPtr or NULL if not found.
+ */
+const htmlElemDesc *
+htmlTagLookup(const xmlChar *tag) {
+    unsigned int i;
+
+    for (i = 0; i < (sizeof(html40ElementTable) /
+                     sizeof(html40ElementTable[0]));i++) {
+        if (!xmlStrcasecmp(tag, BAD_CAST html40ElementTable[i].name))
+	    return((htmlElemDescPtr) &html40ElementTable[i]);
+    }
+    return(NULL);
+}
+
+/**
+ * htmlGetEndPriority:
+ * @name: The name of the element to look up the priority for.
+ * 
+ * Return value: The "endtag" priority.
+ **/
+static int
+htmlGetEndPriority (const xmlChar *name) {
+    int i = 0;
+
+    while ((htmlEndPriority[i].name != NULL) &&
+	   (!xmlStrEqual((const xmlChar *)htmlEndPriority[i].name, name)))
+	i++;
+
+    return(htmlEndPriority[i].priority);
+}
+
+
+/**
+ * htmlCheckAutoClose:
+ * @newtag:  The new tag name
+ * @oldtag:  The old tag name
+ *
+ * Checks whether the new tag is one of the registered valid tags for
+ * closing old.
+ * Initialize the htmlStartCloseIndex for fast lookup of closing tags names.
+ *
+ * Returns 0 if no, 1 if yes.
+ */
+static int
+htmlCheckAutoClose(const xmlChar * newtag, const xmlChar * oldtag)
+{
+    int i, indx;
+    const char **closed = NULL;
+
+    if (htmlStartCloseIndexinitialized == 0)
+        htmlInitAutoClose();
+
+    /* inefficient, but not a big deal */
+    for (indx = 0; indx < 100; indx++) {
+        closed = htmlStartCloseIndex[indx];
+        if (closed == NULL)
+            return (0);
+        if (xmlStrEqual(BAD_CAST * closed, newtag))
+            break;
+    }
+
+    i = closed - htmlStartClose;
+    i++;
+    while (htmlStartClose[i] != NULL) {
+        if (xmlStrEqual(BAD_CAST htmlStartClose[i], oldtag)) {
+            return (1);
+        }
+        i++;
+    }
+    return (0);
+}
+
+/**
+ * htmlAutoCloseOnClose:
+ * @ctxt:  an HTML parser context
+ * @newtag:  The new tag name
+ * @force:  force the tag closure
+ *
+ * The HTML DTD allows an ending tag to implicitly close other tags.
+ */
+static void
+htmlAutoCloseOnClose(htmlParserCtxtPtr ctxt, const xmlChar * newtag)
+{
+    const htmlElemDesc *info;
+    int i, priority;
+
+    priority = htmlGetEndPriority(newtag);
+
+    for (i = (ctxt->nameNr - 1); i >= 0; i--) {
+
+        if (xmlStrEqual(newtag, ctxt->nameTab[i]))
+            break;
+        /*
+         * A missplaced endtag can only close elements with lower
+         * or equal priority, so if we find an element with higher
+         * priority before we find an element with
+         * matching name, we just ignore this endtag 
+         */
+        if (htmlGetEndPriority(ctxt->nameTab[i]) > priority)
+            return;
+    }
+    if (i < 0)
+        return;
+
+    while (!xmlStrEqual(newtag, ctxt->name)) {
+        info = htmlTagLookup(ctxt->name);
+        if ((info != NULL) && (info->endTag == 3)) {
+            htmlParseErr(ctxt, XML_ERR_TAG_NAME_MISMATCH,
+	                 "Opening and ending tag mismatch: %s and %s\n",
+			 newtag, ctxt->name);
+        }
+        if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL))
+            ctxt->sax->endElement(ctxt->userData, ctxt->name);
+	htmlnamePop(ctxt);
+    }
+}
+
+/**
+ * htmlAutoCloseOnEnd:
+ * @ctxt:  an HTML parser context
+ *
+ * Close all remaining tags at the end of the stream
+ */
+static void
+htmlAutoCloseOnEnd(htmlParserCtxtPtr ctxt)
+{
+    int i;
+
+    if (ctxt->nameNr == 0)
+        return;
+    for (i = (ctxt->nameNr - 1); i >= 0; i--) {
+        if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL))
+            ctxt->sax->endElement(ctxt->userData, ctxt->name);
+	htmlnamePop(ctxt);
+    }
+}
+
+/**
+ * htmlAutoClose:
+ * @ctxt:  an HTML parser context
+ * @newtag:  The new tag name or NULL
+ *
+ * The HTML DTD allows a tag to implicitly close other tags.
+ * The list is kept in htmlStartClose array. This function is
+ * called when a new tag has been detected and generates the
+ * appropriates closes if possible/needed.
+ * If newtag is NULL this mean we are at the end of the resource
+ * and we should check 
+ */
+static void
+htmlAutoClose(htmlParserCtxtPtr ctxt, const xmlChar * newtag)
+{
+    while ((newtag != NULL) && (ctxt->name != NULL) &&
+           (htmlCheckAutoClose(newtag, ctxt->name))) {
+        if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL))
+            ctxt->sax->endElement(ctxt->userData, ctxt->name);
+	htmlnamePop(ctxt);
+    }
+    if (newtag == NULL) {
+        htmlAutoCloseOnEnd(ctxt);
+        return;
+    }
+    while ((newtag == NULL) && (ctxt->name != NULL) &&
+           ((xmlStrEqual(ctxt->name, BAD_CAST "head")) ||
+            (xmlStrEqual(ctxt->name, BAD_CAST "body")) ||
+            (xmlStrEqual(ctxt->name, BAD_CAST "html")))) {
+        if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL))
+            ctxt->sax->endElement(ctxt->userData, ctxt->name);
+	htmlnamePop(ctxt);
+    }
+}
+
+/**
+ * htmlAutoCloseTag:
+ * @doc:  the HTML document
+ * @name:  The tag name
+ * @elem:  the HTML element
+ *
+ * The HTML DTD allows a tag to implicitly close other tags.
+ * The list is kept in htmlStartClose array. This function checks
+ * if the element or one of it's children would autoclose the
+ * given tag.
+ *
+ * Returns 1 if autoclose, 0 otherwise
+ */
+int
+htmlAutoCloseTag(htmlDocPtr doc, const xmlChar *name, htmlNodePtr elem) {
+    htmlNodePtr child;
+
+    if (elem == NULL) return(1);
+    if (xmlStrEqual(name, elem->name)) return(0);
+    if (htmlCheckAutoClose(elem->name, name)) return(1);
+    child = elem->children;
+    while (child != NULL) {
+        if (htmlAutoCloseTag(doc, name, child)) return(1);
+	child = child->next;
+    }
+    return(0);
+}
+
+/**
+ * htmlIsAutoClosed:
+ * @doc:  the HTML document
+ * @elem:  the HTML element
+ *
+ * The HTML DTD allows a tag to implicitly close other tags.
+ * The list is kept in htmlStartClose array. This function checks
+ * if a tag is autoclosed by one of it's child
+ *
+ * Returns 1 if autoclosed, 0 otherwise
+ */
+int
+htmlIsAutoClosed(htmlDocPtr doc, htmlNodePtr elem) {
+    htmlNodePtr child;
+
+    if (elem == NULL) return(1);
+    child = elem->children;
+    while (child != NULL) {
+	if (htmlAutoCloseTag(doc, elem->name, child)) return(1);
+	child = child->next;
+    }
+    return(0);
+}
+
+/**
+ * htmlCheckImplied:
+ * @ctxt:  an HTML parser context
+ * @newtag:  The new tag name
+ *
+ * The HTML DTD allows a tag to exists only implicitly
+ * called when a new tag has been detected and generates the
+ * appropriates implicit tags if missing
+ */
+static void
+htmlCheckImplied(htmlParserCtxtPtr ctxt, const xmlChar *newtag) {
+    if (!htmlOmittedDefaultValue)
+	return;
+    if (xmlStrEqual(newtag, BAD_CAST"html"))
+	return;
+    if (ctxt->nameNr <= 0) {
+	htmlnamePush(ctxt, BAD_CAST"html");
+	if ((ctxt->sax != NULL) && (ctxt->sax->startElement != NULL))
+	    ctxt->sax->startElement(ctxt->userData, BAD_CAST"html", NULL);
+    }
+    if ((xmlStrEqual(newtag, BAD_CAST"body")) || (xmlStrEqual(newtag, BAD_CAST"head")))
+        return;
+    if ((ctxt->nameNr <= 1) && 
+        ((xmlStrEqual(newtag, BAD_CAST"script")) ||
+	 (xmlStrEqual(newtag, BAD_CAST"style")) ||
+	 (xmlStrEqual(newtag, BAD_CAST"meta")) ||
+	 (xmlStrEqual(newtag, BAD_CAST"link")) ||
+	 (xmlStrEqual(newtag, BAD_CAST"title")) ||
+	 (xmlStrEqual(newtag, BAD_CAST"base")))) {
+	    /* 
+	     * dropped OBJECT ... i you put it first BODY will be
+	     * assumed !
+	     */
+	    htmlnamePush(ctxt, BAD_CAST"head");
+	    if ((ctxt->sax != NULL) && (ctxt->sax->startElement != NULL))
+		ctxt->sax->startElement(ctxt->userData, BAD_CAST"head", NULL);
+    } else if ((!xmlStrEqual(newtag, BAD_CAST"noframes")) &&
+	       (!xmlStrEqual(newtag, BAD_CAST"frame")) &&
+	       (!xmlStrEqual(newtag, BAD_CAST"frameset"))) {
+	int i;
+	for (i = 0;i < ctxt->nameNr;i++) {
+	    if (xmlStrEqual(ctxt->nameTab[i], BAD_CAST"body")) {
+		return;
+	    }
+	    if (xmlStrEqual(ctxt->nameTab[i], BAD_CAST"head")) {
+		return;
+	    }
+	}
+	    
+	htmlnamePush(ctxt, BAD_CAST"body");
+	if ((ctxt->sax != NULL) && (ctxt->sax->startElement != NULL))
+	    ctxt->sax->startElement(ctxt->userData, BAD_CAST"body", NULL);
+    }
+}
+
+/**
+ * htmlCheckParagraph
+ * @ctxt:  an HTML parser context
+ *
+ * Check whether a p element need to be implied before inserting
+ * characters in the current element.
+ *
+ * Returns 1 if a paragraph has been inserted, 0 if not and -1
+ *         in case of error.
+ */
+
+static int
+htmlCheckParagraph(htmlParserCtxtPtr ctxt) {
+    const xmlChar *tag;
+    int i;
+
+    if (ctxt == NULL)
+	return(-1);
+    tag = ctxt->name;
+    if (tag == NULL) {
+	htmlAutoClose(ctxt, BAD_CAST"p");
+	htmlCheckImplied(ctxt, BAD_CAST"p");
+	htmlnamePush(ctxt, BAD_CAST"p");
+	if ((ctxt->sax != NULL) && (ctxt->sax->startElement != NULL))
+	    ctxt->sax->startElement(ctxt->userData, BAD_CAST"p", NULL);
+	return(1);
+    }
+    if (!htmlOmittedDefaultValue)
+	return(0);
+    for (i = 0; htmlNoContentElements[i] != NULL; i++) {
+	if (xmlStrEqual(tag, BAD_CAST htmlNoContentElements[i])) {
+	    htmlAutoClose(ctxt, BAD_CAST"p");
+	    htmlCheckImplied(ctxt, BAD_CAST"p");
+	    htmlnamePush(ctxt, BAD_CAST"p");
+	    if ((ctxt->sax != NULL) && (ctxt->sax->startElement != NULL))
+		ctxt->sax->startElement(ctxt->userData, BAD_CAST"p", NULL);
+	    return(1);
+	}
+    }
+    return(0);
+}
+
+/**
+ * htmlIsScriptAttribute:
+ * @name:  an attribute name
+ *
+ * Check if an attribute is of content type Script
+ *
+ * Returns 1 is the attribute is a script 0 otherwise
+ */
+int
+htmlIsScriptAttribute(const xmlChar *name) {
+    unsigned int i;
+
+    if (name == NULL)
+       	return(0);
+    /*
+     * all script attributes start with 'on'
+     */
+    if ((name[0] != 'o') || (name[1] != 'n'))
+       	return(0);
+    for (i = 0;
+	 i < sizeof(htmlScriptAttributes)/sizeof(htmlScriptAttributes[0]);
+	 i++) {
+	if (xmlStrEqual(name, (const xmlChar *) htmlScriptAttributes[i]))
+	    return(1);
+    }
+    return(0);
+}
+
+/************************************************************************
+ *									*
+ * 		The list of HTML predefined entities			*
+ *									*
+ ************************************************************************/
+
+
+static const htmlEntityDesc  html40EntitiesTable[] = {
+/*
+ * the 4 absolute ones, plus apostrophe.
+ */
+{ 34,	"quot",	"quotation mark = APL quote, U+0022 ISOnum" },
+{ 38,	"amp",	"ampersand, U+0026 ISOnum" },
+{ 39,	"apos",	"single quote" },
+{ 60,	"lt",	"less-than sign, U+003C ISOnum" },
+{ 62,	"gt",	"greater-than sign, U+003E ISOnum" },
+
+/*
+ * A bunch still in the 128-255 range
+ * Replacing them depend really on the charset used.
+ */
+{ 160,	"nbsp",	"no-break space = non-breaking space, U+00A0 ISOnum" },
+{ 161,	"iexcl","inverted exclamation mark, U+00A1 ISOnum" },
+{ 162,	"cent",	"cent sign, U+00A2 ISOnum" },
+{ 163,	"pound","pound sign, U+00A3 ISOnum" },
+{ 164,	"curren","currency sign, U+00A4 ISOnum" },
+{ 165,	"yen",	"yen sign = yuan sign, U+00A5 ISOnum" },
+{ 166,	"brvbar","broken bar = broken vertical bar, U+00A6 ISOnum" },
+{ 167,	"sect",	"section sign, U+00A7 ISOnum" },
+{ 168,	"uml",	"diaeresis = spacing diaeresis, U+00A8 ISOdia" },
+{ 169,	"copy",	"copyright sign, U+00A9 ISOnum" },
+{ 170,	"ordf",	"feminine ordinal indicator, U+00AA ISOnum" },
+{ 171,	"laquo","left-pointing double angle quotation mark = left pointing guillemet, U+00AB ISOnum" },
+{ 172,	"not",	"not sign, U+00AC ISOnum" },
+{ 173,	"shy",	"soft hyphen = discretionary hyphen, U+00AD ISOnum" },
+{ 174,	"reg",	"registered sign = registered trade mark sign, U+00AE ISOnum" },
+{ 175,	"macr",	"macron = spacing macron = overline = APL overbar, U+00AF ISOdia" },
+{ 176,	"deg",	"degree sign, U+00B0 ISOnum" },
+{ 177,	"plusmn","plus-minus sign = plus-or-minus sign, U+00B1 ISOnum" },
+{ 178,	"sup2",	"superscript two = superscript digit two = squared, U+00B2 ISOnum" },
+{ 179,	"sup3",	"superscript three = superscript digit three = cubed, U+00B3 ISOnum" },
+{ 180,	"acute","acute accent = spacing acute, U+00B4 ISOdia" },
+{ 181,	"micro","micro sign, U+00B5 ISOnum" },
+{ 182,	"para",	"pilcrow sign = paragraph sign, U+00B6 ISOnum" },
+{ 183,	"middot","middle dot = Georgian comma Greek middle dot, U+00B7 ISOnum" },
+{ 184,	"cedil","cedilla = spacing cedilla, U+00B8 ISOdia" },
+{ 185,	"sup1",	"superscript one = superscript digit one, U+00B9 ISOnum" },
+{ 186,	"ordm",	"masculine ordinal indicator, U+00BA ISOnum" },
+{ 187,	"raquo","right-pointing double angle quotation mark right pointing guillemet, U+00BB ISOnum" },
+{ 188,	"frac14","vulgar fraction one quarter = fraction one quarter, U+00BC ISOnum" },
+{ 189,	"frac12","vulgar fraction one half = fraction one half, U+00BD ISOnum" },
+{ 190,	"frac34","vulgar fraction three quarters = fraction three quarters, U+00BE ISOnum" },
+{ 191,	"iquest","inverted question mark = turned question mark, U+00BF ISOnum" },
+{ 192,	"Agrave","latin capital letter A with grave = latin capital letter A grave, U+00C0 ISOlat1" },
+{ 193,	"Aacute","latin capital letter A with acute, U+00C1 ISOlat1" },
+{ 194,	"Acirc","latin capital letter A with circumflex, U+00C2 ISOlat1" },
+{ 195,	"Atilde","latin capital letter A with tilde, U+00C3 ISOlat1" },
+{ 196,	"Auml",	"latin capital letter A with diaeresis, U+00C4 ISOlat1" },
+{ 197,	"Aring","latin capital letter A with ring above = latin capital letter A ring, U+00C5 ISOlat1" },
+{ 198,	"AElig","latin capital letter AE = latin capital ligature AE, U+00C6 ISOlat1" },
+{ 199,	"Ccedil","latin capital letter C with cedilla, U+00C7 ISOlat1" },
+{ 200,	"Egrave","latin capital letter E with grave, U+00C8 ISOlat1" },
+{ 201,	"Eacute","latin capital letter E with acute, U+00C9 ISOlat1" },
+{ 202,	"Ecirc","latin capital letter E with circumflex, U+00CA ISOlat1" },
+{ 203,	"Euml",	"latin capital letter E with diaeresis, U+00CB ISOlat1" },
+{ 204,	"Igrave","latin capital letter I with grave, U+00CC ISOlat1" },
+{ 205,	"Iacute","latin capital letter I with acute, U+00CD ISOlat1" },
+{ 206,	"Icirc","latin capital letter I with circumflex, U+00CE ISOlat1" },
+{ 207,	"Iuml",	"latin capital letter I with diaeresis, U+00CF ISOlat1" },
+{ 208,	"ETH",	"latin capital letter ETH, U+00D0 ISOlat1" },
+{ 209,	"Ntilde","latin capital letter N with tilde, U+00D1 ISOlat1" },
+{ 210,	"Ograve","latin capital letter O with grave, U+00D2 ISOlat1" },
+{ 211,	"Oacute","latin capital letter O with acute, U+00D3 ISOlat1" },
+{ 212,	"Ocirc","latin capital letter O with circumflex, U+00D4 ISOlat1" },
+{ 213,	"Otilde","latin capital letter O with tilde, U+00D5 ISOlat1" },
+{ 214,	"Ouml",	"latin capital letter O with diaeresis, U+00D6 ISOlat1" },
+{ 215,	"times","multiplication sign, U+00D7 ISOnum" },
+{ 216,	"Oslash","latin capital letter O with stroke latin capital letter O slash, U+00D8 ISOlat1" },
+{ 217,	"Ugrave","latin capital letter U with grave, U+00D9 ISOlat1" },
+{ 218,	"Uacute","latin capital letter U with acute, U+00DA ISOlat1" },
+{ 219,	"Ucirc","latin capital letter U with circumflex, U+00DB ISOlat1" },
+{ 220,	"Uuml",	"latin capital letter U with diaeresis, U+00DC ISOlat1" },
+{ 221,	"Yacute","latin capital letter Y with acute, U+00DD ISOlat1" },
+{ 222,	"THORN","latin capital letter THORN, U+00DE ISOlat1" },
+{ 223,	"szlig","latin small letter sharp s = ess-zed, U+00DF ISOlat1" },
+{ 224,	"agrave","latin small letter a with grave = latin small letter a grave, U+00E0 ISOlat1" },
+{ 225,	"aacute","latin small letter a with acute, U+00E1 ISOlat1" },
+{ 226,	"acirc","latin small letter a with circumflex, U+00E2 ISOlat1" },
+{ 227,	"atilde","latin small letter a with tilde, U+00E3 ISOlat1" },
+{ 228,	"auml",	"latin small letter a with diaeresis, U+00E4 ISOlat1" },
+{ 229,	"aring","latin small letter a with ring above = latin small letter a ring, U+00E5 ISOlat1" },
+{ 230,	"aelig","latin small letter ae = latin small ligature ae, U+00E6 ISOlat1" },
+{ 231,	"ccedil","latin small letter c with cedilla, U+00E7 ISOlat1" },
+{ 232,	"egrave","latin small letter e with grave, U+00E8 ISOlat1" },
+{ 233,	"eacute","latin small letter e with acute, U+00E9 ISOlat1" },
+{ 234,	"ecirc","latin small letter e with circumflex, U+00EA ISOlat1" },
+{ 235,	"euml",	"latin small letter e with diaeresis, U+00EB ISOlat1" },
+{ 236,	"igrave","latin small letter i with grave, U+00EC ISOlat1" },
+{ 237,	"iacute","latin small letter i with acute, U+00ED ISOlat1" },
+{ 238,	"icirc","latin small letter i with circumflex, U+00EE ISOlat1" },
+{ 239,	"iuml",	"latin small letter i with diaeresis, U+00EF ISOlat1" },
+{ 240,	"eth",	"latin small letter eth, U+00F0 ISOlat1" },
+{ 241,	"ntilde","latin small letter n with tilde, U+00F1 ISOlat1" },
+{ 242,	"ograve","latin small letter o with grave, U+00F2 ISOlat1" },
+{ 243,	"oacute","latin small letter o with acute, U+00F3 ISOlat1" },
+{ 244,	"ocirc","latin small letter o with circumflex, U+00F4 ISOlat1" },
+{ 245,	"otilde","latin small letter o with tilde, U+00F5 ISOlat1" },
+{ 246,	"ouml",	"latin small letter o with diaeresis, U+00F6 ISOlat1" },
+{ 247,	"divide","division sign, U+00F7 ISOnum" },
+{ 248,	"oslash","latin small letter o with stroke, = latin small letter o slash, U+00F8 ISOlat1" },
+{ 249,	"ugrave","latin small letter u with grave, U+00F9 ISOlat1" },
+{ 250,	"uacute","latin small letter u with acute, U+00FA ISOlat1" },
+{ 251,	"ucirc","latin small letter u with circumflex, U+00FB ISOlat1" },
+{ 252,	"uuml",	"latin small letter u with diaeresis, U+00FC ISOlat1" },
+{ 253,	"yacute","latin small letter y with acute, U+00FD ISOlat1" },
+{ 254,	"thorn","latin small letter thorn with, U+00FE ISOlat1" },
+{ 255,	"yuml",	"latin small letter y with diaeresis, U+00FF ISOlat1" },
+
+{ 338,	"OElig","latin capital ligature OE, U+0152 ISOlat2" },
+{ 339,	"oelig","latin small ligature oe, U+0153 ISOlat2" },
+{ 352,	"Scaron","latin capital letter S with caron, U+0160 ISOlat2" },
+{ 353,	"scaron","latin small letter s with caron, U+0161 ISOlat2" },
+{ 376,	"Yuml",	"latin capital letter Y with diaeresis, U+0178 ISOlat2" },
+
+/*
+ * Anything below should really be kept as entities references
+ */
+{ 402,	"fnof",	"latin small f with hook = function = florin, U+0192 ISOtech" },
+
+{ 710,	"circ",	"modifier letter circumflex accent, U+02C6 ISOpub" },
+{ 732,	"tilde","small tilde, U+02DC ISOdia" },
+
+{ 913,	"Alpha","greek capital letter alpha, U+0391" },
+{ 914,	"Beta",	"greek capital letter beta, U+0392" },
+{ 915,	"Gamma","greek capital letter gamma, U+0393 ISOgrk3" },
+{ 916,	"Delta","greek capital letter delta, U+0394 ISOgrk3" },
+{ 917,	"Epsilon","greek capital letter epsilon, U+0395" },
+{ 918,	"Zeta",	"greek capital letter zeta, U+0396" },
+{ 919,	"Eta",	"greek capital letter eta, U+0397" },
+{ 920,	"Theta","greek capital letter theta, U+0398 ISOgrk3" },
+{ 921,	"Iota",	"greek capital letter iota, U+0399" },
+{ 922,	"Kappa","greek capital letter kappa, U+039A" },
+{ 923,	"Lambda", "greek capital letter lambda, U+039B ISOgrk3" },
+{ 924,	"Mu",	"greek capital letter mu, U+039C" },
+{ 925,	"Nu",	"greek capital letter nu, U+039D" },
+{ 926,	"Xi",	"greek capital letter xi, U+039E ISOgrk3" },
+{ 927,	"Omicron","greek capital letter omicron, U+039F" },
+{ 928,	"Pi",	"greek capital letter pi, U+03A0 ISOgrk3" },
+{ 929,	"Rho",	"greek capital letter rho, U+03A1" },
+{ 931,	"Sigma","greek capital letter sigma, U+03A3 ISOgrk3" },
+{ 932,	"Tau",	"greek capital letter tau, U+03A4" },
+{ 933,	"Upsilon","greek capital letter upsilon, U+03A5 ISOgrk3" },
+{ 934,	"Phi",	"greek capital letter phi, U+03A6 ISOgrk3" },
+{ 935,	"Chi",	"greek capital letter chi, U+03A7" },
+{ 936,	"Psi",	"greek capital letter psi, U+03A8 ISOgrk3" },
+{ 937,	"Omega","greek capital letter omega, U+03A9 ISOgrk3" },
+
+{ 945,	"alpha","greek small letter alpha, U+03B1 ISOgrk3" },
+{ 946,	"beta",	"greek small letter beta, U+03B2 ISOgrk3" },
+{ 947,	"gamma","greek small letter gamma, U+03B3 ISOgrk3" },
+{ 948,	"delta","greek small letter delta, U+03B4 ISOgrk3" },
+{ 949,	"epsilon","greek small letter epsilon, U+03B5 ISOgrk3" },
+{ 950,	"zeta",	"greek small letter zeta, U+03B6 ISOgrk3" },
+{ 951,	"eta",	"greek small letter eta, U+03B7 ISOgrk3" },
+{ 952,	"theta","greek small letter theta, U+03B8 ISOgrk3" },
+{ 953,	"iota",	"greek small letter iota, U+03B9 ISOgrk3" },
+{ 954,	"kappa","greek small letter kappa, U+03BA ISOgrk3" },
+{ 955,	"lambda","greek small letter lambda, U+03BB ISOgrk3" },
+{ 956,	"mu",	"greek small letter mu, U+03BC ISOgrk3" },
+{ 957,	"nu",	"greek small letter nu, U+03BD ISOgrk3" },
+{ 958,	"xi",	"greek small letter xi, U+03BE ISOgrk3" },
+{ 959,	"omicron","greek small letter omicron, U+03BF NEW" },
+{ 960,	"pi",	"greek small letter pi, U+03C0 ISOgrk3" },
+{ 961,	"rho",	"greek small letter rho, U+03C1 ISOgrk3" },
+{ 962,	"sigmaf","greek small letter final sigma, U+03C2 ISOgrk3" },
+{ 963,	"sigma","greek small letter sigma, U+03C3 ISOgrk3" },
+{ 964,	"tau",	"greek small letter tau, U+03C4 ISOgrk3" },
+{ 965,	"upsilon","greek small letter upsilon, U+03C5 ISOgrk3" },
+{ 966,	"phi",	"greek small letter phi, U+03C6 ISOgrk3" },
+{ 967,	"chi",	"greek small letter chi, U+03C7 ISOgrk3" },
+{ 968,	"psi",	"greek small letter psi, U+03C8 ISOgrk3" },
+{ 969,	"omega","greek small letter omega, U+03C9 ISOgrk3" },
+{ 977,	"thetasym","greek small letter theta symbol, U+03D1 NEW" },
+{ 978,	"upsih","greek upsilon with hook symbol, U+03D2 NEW" },
+{ 982,	"piv",	"greek pi symbol, U+03D6 ISOgrk3" },
+
+{ 8194,	"ensp",	"en space, U+2002 ISOpub" },
+{ 8195,	"emsp",	"em space, U+2003 ISOpub" },
+{ 8201,	"thinsp","thin space, U+2009 ISOpub" },
+{ 8204,	"zwnj",	"zero width non-joiner, U+200C NEW RFC 2070" },
+{ 8205,	"zwj",	"zero width joiner, U+200D NEW RFC 2070" },
+{ 8206,	"lrm",	"left-to-right mark, U+200E NEW RFC 2070" },
+{ 8207,	"rlm",	"right-to-left mark, U+200F NEW RFC 2070" },
+{ 8211,	"ndash","en dash, U+2013 ISOpub" },
+{ 8212,	"mdash","em dash, U+2014 ISOpub" },
+{ 8216,	"lsquo","left single quotation mark, U+2018 ISOnum" },
+{ 8217,	"rsquo","right single quotation mark, U+2019 ISOnum" },
+{ 8218,	"sbquo","single low-9 quotation mark, U+201A NEW" },
+{ 8220,	"ldquo","left double quotation mark, U+201C ISOnum" },
+{ 8221,	"rdquo","right double quotation mark, U+201D ISOnum" },
+{ 8222,	"bdquo","double low-9 quotation mark, U+201E NEW" },
+{ 8224,	"dagger","dagger, U+2020 ISOpub" },
+{ 8225,	"Dagger","double dagger, U+2021 ISOpub" },
+
+{ 8226,	"bull",	"bullet = black small circle, U+2022 ISOpub" },
+{ 8230,	"hellip","horizontal ellipsis = three dot leader, U+2026 ISOpub" },
+
+{ 8240,	"permil","per mille sign, U+2030 ISOtech" },
+
+{ 8242,	"prime","prime = minutes = feet, U+2032 ISOtech" },
+{ 8243,	"Prime","double prime = seconds = inches, U+2033 ISOtech" },
+
+{ 8249,	"lsaquo","single left-pointing angle quotation mark, U+2039 ISO proposed" },
+{ 8250,	"rsaquo","single right-pointing angle quotation mark, U+203A ISO proposed" },
+
+{ 8254,	"oline","overline = spacing overscore, U+203E NEW" },
+{ 8260,	"frasl","fraction slash, U+2044 NEW" },
+
+{ 8364,	"euro",	"euro sign, U+20AC NEW" },
+
+{ 8465,	"image","blackletter capital I = imaginary part, U+2111 ISOamso" },
+{ 8472,	"weierp","script capital P = power set = Weierstrass p, U+2118 ISOamso" },
+{ 8476,	"real",	"blackletter capital R = real part symbol, U+211C ISOamso" },
+{ 8482,	"trade","trade mark sign, U+2122 ISOnum" },
+{ 8501,	"alefsym","alef symbol = first transfinite cardinal, U+2135 NEW" },
+{ 8592,	"larr",	"leftwards arrow, U+2190 ISOnum" },
+{ 8593,	"uarr",	"upwards arrow, U+2191 ISOnum" },
+{ 8594,	"rarr",	"rightwards arrow, U+2192 ISOnum" },
+{ 8595,	"darr",	"downwards arrow, U+2193 ISOnum" },
+{ 8596,	"harr",	"left right arrow, U+2194 ISOamsa" },
+{ 8629,	"crarr","downwards arrow with corner leftwards = carriage return, U+21B5 NEW" },
+{ 8656,	"lArr",	"leftwards double arrow, U+21D0 ISOtech" },
+{ 8657,	"uArr",	"upwards double arrow, U+21D1 ISOamsa" },
+{ 8658,	"rArr",	"rightwards double arrow, U+21D2 ISOtech" },
+{ 8659,	"dArr",	"downwards double arrow, U+21D3 ISOamsa" },
+{ 8660,	"hArr",	"left right double arrow, U+21D4 ISOamsa" },
+
+{ 8704,	"forall","for all, U+2200 ISOtech" },
+{ 8706,	"part",	"partial differential, U+2202 ISOtech" },
+{ 8707,	"exist","there exists, U+2203 ISOtech" },
+{ 8709,	"empty","empty set = null set = diameter, U+2205 ISOamso" },
+{ 8711,	"nabla","nabla = backward difference, U+2207 ISOtech" },
+{ 8712,	"isin",	"element of, U+2208 ISOtech" },
+{ 8713,	"notin","not an element of, U+2209 ISOtech" },
+{ 8715,	"ni",	"contains as member, U+220B ISOtech" },
+{ 8719,	"prod",	"n-ary product = product sign, U+220F ISOamsb" },
+{ 8721,	"sum",	"n-ary summation, U+2211 ISOamsb" },
+{ 8722,	"minus","minus sign, U+2212 ISOtech" },
+{ 8727,	"lowast","asterisk operator, U+2217 ISOtech" },
+{ 8730,	"radic","square root = radical sign, U+221A ISOtech" },
+{ 8733,	"prop",	"proportional to, U+221D ISOtech" },
+{ 8734,	"infin","infinity, U+221E ISOtech" },
+{ 8736,	"ang",	"angle, U+2220 ISOamso" },
+{ 8743,	"and",	"logical and = wedge, U+2227 ISOtech" },
+{ 8744,	"or",	"logical or = vee, U+2228 ISOtech" },
+{ 8745,	"cap",	"intersection = cap, U+2229 ISOtech" },
+{ 8746,	"cup",	"union = cup, U+222A ISOtech" },
+{ 8747,	"int",	"integral, U+222B ISOtech" },
+{ 8756,	"there4","therefore, U+2234 ISOtech" },
+{ 8764,	"sim",	"tilde operator = varies with = similar to, U+223C ISOtech" },
+{ 8773,	"cong",	"approximately equal to, U+2245 ISOtech" },
+{ 8776,	"asymp","almost equal to = asymptotic to, U+2248 ISOamsr" },
+{ 8800,	"ne",	"not equal to, U+2260 ISOtech" },
+{ 8801,	"equiv","identical to, U+2261 ISOtech" },
+{ 8804,	"le",	"less-than or equal to, U+2264 ISOtech" },
+{ 8805,	"ge",	"greater-than or equal to, U+2265 ISOtech" },
+{ 8834,	"sub",	"subset of, U+2282 ISOtech" },
+{ 8835,	"sup",	"superset of, U+2283 ISOtech" },
+{ 8836,	"nsub",	"not a subset of, U+2284 ISOamsn" },
+{ 8838,	"sube",	"subset of or equal to, U+2286 ISOtech" },
+{ 8839,	"supe",	"superset of or equal to, U+2287 ISOtech" },
+{ 8853,	"oplus","circled plus = direct sum, U+2295 ISOamsb" },
+{ 8855,	"otimes","circled times = vector product, U+2297 ISOamsb" },
+{ 8869,	"perp",	"up tack = orthogonal to = perpendicular, U+22A5 ISOtech" },
+{ 8901,	"sdot",	"dot operator, U+22C5 ISOamsb" },
+{ 8968,	"lceil","left ceiling = apl upstile, U+2308 ISOamsc" },
+{ 8969,	"rceil","right ceiling, U+2309 ISOamsc" },
+{ 8970,	"lfloor","left floor = apl downstile, U+230A ISOamsc" },
+{ 8971,	"rfloor","right floor, U+230B ISOamsc" },
+{ 9001,	"lang",	"left-pointing angle bracket = bra, U+2329 ISOtech" },
+{ 9002,	"rang",	"right-pointing angle bracket = ket, U+232A ISOtech" },
+{ 9674,	"loz",	"lozenge, U+25CA ISOpub" },
+
+{ 9824,	"spades","black spade suit, U+2660 ISOpub" },
+{ 9827,	"clubs","black club suit = shamrock, U+2663 ISOpub" },
+{ 9829,	"hearts","black heart suit = valentine, U+2665 ISOpub" },
+{ 9830,	"diams","black diamond suit, U+2666 ISOpub" },
+
+};
+
+/************************************************************************
+ *									*
+ *		Commodity functions to handle entities			*
+ *									*
+ ************************************************************************/
+
+/*
+ * Macro used to grow the current buffer.
+ */
+#define growBuffer(buffer) {						\
+    buffer##_size *= 2;							\
+    buffer = (xmlChar *) xmlRealloc(buffer, buffer##_size * sizeof(xmlChar)); \
+    if (buffer == NULL) {						\
+	htmlErrMemory(ctxt, "growing buffer\n");			\
+	return(NULL);							\
+    }									\
+}
+
+/**
+ * htmlEntityLookup:
+ * @name: the entity name
+ *
+ * Lookup the given entity in EntitiesTable
+ *
+ * TODO: the linear scan is really ugly, an hash table is really needed.
+ *
+ * Returns the associated htmlEntityDescPtr if found, NULL otherwise.
+ */
+const htmlEntityDesc *
+htmlEntityLookup(const xmlChar *name) {
+    unsigned int i;
+
+    for (i = 0;i < (sizeof(html40EntitiesTable)/
+                    sizeof(html40EntitiesTable[0]));i++) {
+        if (xmlStrEqual(name, BAD_CAST html40EntitiesTable[i].name)) {
+            return((htmlEntityDescPtr) &html40EntitiesTable[i]);
+	}
+    }
+    return(NULL);
+}
+
+/**
+ * htmlEntityValueLookup:
+ * @value: the entity's unicode value
+ *
+ * Lookup the given entity in EntitiesTable
+ *
+ * TODO: the linear scan is really ugly, an hash table is really needed.
+ *
+ * Returns the associated htmlEntityDescPtr if found, NULL otherwise.
+ */
+const htmlEntityDesc *
+htmlEntityValueLookup(unsigned int value) {
+    unsigned int i;
+
+    for (i = 0;i < (sizeof(html40EntitiesTable)/
+                    sizeof(html40EntitiesTable[0]));i++) {
+        if (html40EntitiesTable[i].value >= value) {
+	    if (html40EntitiesTable[i].value > value)
+		break;
+            return((htmlEntityDescPtr) &html40EntitiesTable[i]);
+	}
+    }
+    return(NULL);
+}
+
+/**
+ * UTF8ToHtml:
+ * @out:  a pointer to an array of bytes to store the result
+ * @outlen:  the length of @out
+ * @in:  a pointer to an array of UTF-8 chars
+ * @inlen:  the length of @in
+ *
+ * Take a block of UTF-8 chars in and try to convert it to an ASCII
+ * plus HTML entities block of chars out.
+ *
+ * Returns 0 if success, -2 if the transcoding fails, or -1 otherwise
+ * The value of @inlen after return is the number of octets consumed
+ *     as the return value is positive, else unpredictable.
+ * The value of @outlen after return is the number of octets consumed.
+ */
+int
+UTF8ToHtml(unsigned char* out, int *outlen,
+              const unsigned char* in, int *inlen) {
+    const unsigned char* processed = in;
+    const unsigned char* outend;
+    const unsigned char* outstart = out;
+    const unsigned char* instart = in;
+    const unsigned char* inend;
+    unsigned int c, d;
+    int trailing;
+
+    if (in == NULL) {
+        /*
+	 * initialization nothing to do
+	 */
+	*outlen = 0;
+	*inlen = 0;
+	return(0);
+    }
+    inend = in + (*inlen);
+    outend = out + (*outlen);
+    while (in < inend) {
+	d = *in++;
+	if      (d < 0x80)  { c= d; trailing= 0; }
+	else if (d < 0xC0) {
+	    /* trailing byte in leading position */
+	    *outlen = out - outstart;
+	    *inlen = processed - instart;
+	    return(-2);
+        } else if (d < 0xE0)  { c= d & 0x1F; trailing= 1; }
+        else if (d < 0xF0)  { c= d & 0x0F; trailing= 2; }
+        else if (d < 0xF8)  { c= d & 0x07; trailing= 3; }
+	else {
+	    /* no chance for this in Ascii */
+	    *outlen = out - outstart;
+	    *inlen = processed - instart;
+	    return(-2);
+	}
+
+	if (inend - in < trailing) {
+	    break;
+	} 
+
+	for ( ; trailing; trailing--) {
+	    if ((in >= inend) || (((d= *in++) & 0xC0) != 0x80))
+		break;
+	    c <<= 6;
+	    c |= d & 0x3F;
+	}
+
+	/* assertion: c is a single UTF-4 value */
+	if (c < 0x80) {
+	    if (out + 1 >= outend)
+		break;
+	    *out++ = c;
+	} else {
+	    int len;
+	    const htmlEntityDesc * ent;
+
+	    /*
+	     * Try to lookup a predefined HTML entity for it
+	     */
+
+	    ent = htmlEntityValueLookup(c);
+	    if (ent == NULL) {
+		/* no chance for this in Ascii */
+		*outlen = out - outstart;
+		*inlen = processed - instart;
+		return(-2);
+	    }
+	    len = strlen(ent->name);
+	    if (out + 2 + len >= outend)
+		break;
+	    *out++ = '&';
+	    memcpy(out, ent->name, len);
+	    out += len;
+	    *out++ = ';';
+	}
+	processed = in;
+    }
+    *outlen = out - outstart;
+    *inlen = processed - instart;
+    return(0);
+}
+
+/**
+ * htmlEncodeEntities:
+ * @out:  a pointer to an array of bytes to store the result
+ * @outlen:  the length of @out
+ * @in:  a pointer to an array of UTF-8 chars
+ * @inlen:  the length of @in
+ * @quoteChar: the quote character to escape (' or ") or zero.
+ *
+ * Take a block of UTF-8 chars in and try to convert it to an ASCII
+ * plus HTML entities block of chars out.
+ *
+ * Returns 0 if success, -2 if the transcoding fails, or -1 otherwise
+ * The value of @inlen after return is the number of octets consumed
+ *     as the return value is positive, else unpredictable.
+ * The value of @outlen after return is the number of octets consumed.
+ */
+int
+htmlEncodeEntities(unsigned char* out, int *outlen,
+		   const unsigned char* in, int *inlen, int quoteChar) {
+    const unsigned char* processed = in;
+    const unsigned char* outend = out + (*outlen);
+    const unsigned char* outstart = out;
+    const unsigned char* instart = in;
+    const unsigned char* inend = in + (*inlen);
+    unsigned int c, d;
+    int trailing;
+
+    while (in < inend) {
+	d = *in++;
+	if      (d < 0x80)  { c= d; trailing= 0; }
+	else if (d < 0xC0) {
+	    /* trailing byte in leading position */
+	    *outlen = out - outstart;
+	    *inlen = processed - instart;
+	    return(-2);
+        } else if (d < 0xE0)  { c= d & 0x1F; trailing= 1; }
+        else if (d < 0xF0)  { c= d & 0x0F; trailing= 2; }
+        else if (d < 0xF8)  { c= d & 0x07; trailing= 3; }
+	else {
+	    /* no chance for this in Ascii */
+	    *outlen = out - outstart;
+	    *inlen = processed - instart;
+	    return(-2);
+	}
+
+	if (inend - in < trailing)
+	    break;
+
+	while (trailing--) {
+	    if (((d= *in++) & 0xC0) != 0x80) {
+		*outlen = out - outstart;
+		*inlen = processed - instart;
+		return(-2);
+	    }
+	    c <<= 6;
+	    c |= d & 0x3F;
+	}
+
+	/* assertion: c is a single UTF-4 value */
+	if ((c < 0x80) && (c != (unsigned int) quoteChar) &&
+	    (c != '&') && (c != '<') && (c != '>')) {
+	    if (out >= outend)
+		break;
+	    *out++ = c;
+	} else {
+	    const htmlEntityDesc * ent;
+	    const char *cp;
+	    char nbuf[16];
+	    int len;
+
+	    /*
+	     * Try to lookup a predefined HTML entity for it
+	     */
+	    ent = htmlEntityValueLookup(c);
+	    if (ent == NULL) {
+		snprintf(nbuf, sizeof(nbuf), "#%u", c);
+		cp = nbuf;
+	    }
+	    else
+		cp = ent->name;
+	    len = strlen(cp);
+	    if (out + 2 + len > outend)
+		break;
+	    *out++ = '&';
+	    memcpy(out, cp, len);
+	    out += len;
+	    *out++ = ';';
+	}
+	processed = in;
+    }
+    *outlen = out - outstart;
+    *inlen = processed - instart;
+    return(0);
+}
+
+/************************************************************************
+ *									*
+ *		Commodity functions to handle streams			*
+ *									*
+ ************************************************************************/
+
+/**
+ * htmlNewInputStream:
+ * @ctxt:  an HTML parser context
+ *
+ * Create a new input stream structure
+ * Returns the new input stream or NULL
+ */
+static htmlParserInputPtr
+htmlNewInputStream(htmlParserCtxtPtr ctxt) {
+    htmlParserInputPtr input;
+
+    input = (xmlParserInputPtr) xmlMalloc(sizeof(htmlParserInput));
+    if (input == NULL) {
+        htmlErrMemory(ctxt, "couldn't allocate a new input stream\n");
+	return(NULL);
+    }
+    memset(input, 0, sizeof(htmlParserInput));
+    input->filename = NULL;
+    input->directory = NULL;
+    input->base = NULL;
+    input->cur = NULL;
+    input->buf = NULL;
+    input->line = 1;
+    input->col = 1;
+    input->buf = NULL;
+    input->free = NULL;
+    input->version = NULL;
+    input->consumed = 0;
+    input->length = 0;
+    return(input);
+}
+
+
+/************************************************************************
+ *									*
+ *		Commodity functions, cleanup needed ?			*
+ *									*
+ ************************************************************************/
+/*
+ * all tags allowing pc data from the html 4.01 loose dtd 
+ * NOTE: it might be more apropriate to integrate this information
+ * into the html40ElementTable array but I don't want to risk any
+ * binary incomptibility
+ */
+static const char *allowPCData[] = {
+    "a", "abbr", "acronym", "address", "applet", "b", "bdo", "big",
+    "blockquote", "body", "button", "caption", "center", "cite", "code",
+    "dd", "del", "dfn", "div", "dt", "em", "font", "form", "h1", "h2",
+    "h3", "h4", "h5", "h6", "i", "iframe", "ins", "kbd", "label", "legend",
+    "li", "noframes", "noscript", "object", "p", "pre", "q", "s", "samp",
+    "small", "span", "strike", "strong", "td", "th", "tt", "u", "var"
+};
+
+/**
+ * areBlanks:
+ * @ctxt:  an HTML parser context
+ * @str:  a xmlChar *
+ * @len:  the size of @str
+ *
+ * Is this a sequence of blank chars that one can ignore ?
+ *
+ * Returns 1 if ignorable 0 otherwise.
+ */
+
+static int areBlanks(htmlParserCtxtPtr ctxt, const xmlChar *str, int len) {
+    unsigned int i;
+    int j;
+    xmlNodePtr lastChild;
+
+    for (j = 0;j < len;j++)
+        if (!(IS_BLANK_CH(str[j]))) return(0);
+
+    if (CUR == 0) return(1);
+    if (CUR != '<') return(0);
+    if (ctxt->name == NULL)
+	return(1);
+    if (xmlStrEqual(ctxt->name, BAD_CAST"html"))
+	return(1);
+    if (xmlStrEqual(ctxt->name, BAD_CAST"head"))
+	return(1);
+    if (xmlStrEqual(ctxt->name, BAD_CAST"body"))
+	return(1);
+    if (ctxt->node == NULL) return(0);
+    lastChild = xmlGetLastChild(ctxt->node);
+    if (lastChild == NULL) {
+        if ((ctxt->node->type != XML_ELEMENT_NODE) &&
+            (ctxt->node->content != NULL)) return(0);
+	/* keep ws in constructs like ...<b> </b>... 
+	   for all tags "b" allowing PCDATA */
+	for ( i = 0; i < sizeof(allowPCData)/sizeof(allowPCData[0]); i++ ) {
+	    if ( xmlStrEqual(ctxt->name, BAD_CAST allowPCData[i]) ) {
+		return(0);
+	    }
+	}
+    } else if (xmlNodeIsText(lastChild)) {
+        return(0);
+    } else {
+	/* keep ws in constructs like <p><b>xy</b> <i>z</i><p> 
+	   for all tags "p" allowing PCDATA */
+	for ( i = 0; i < sizeof(allowPCData)/sizeof(allowPCData[0]); i++ ) {
+	    if ( xmlStrEqual(lastChild->name, BAD_CAST allowPCData[i]) ) {
+		return(0);
+	    }
+	}
+    }
+    return(1);
+}
+
+/**
+ * htmlNewDocNoDtD:
+ * @URI:  URI for the dtd, or NULL
+ * @ExternalID:  the external ID of the DTD, or NULL
+ *
+ * Creates a new HTML document without a DTD node if @URI and @ExternalID
+ * are NULL
+ *
+ * Returns a new document, do not initialize the DTD if not provided
+ */
+htmlDocPtr
+htmlNewDocNoDtD(const xmlChar *URI, const xmlChar *ExternalID) {
+    xmlDocPtr cur;
+
+    /*
+     * Allocate a new document and fill the fields.
+     */
+    cur = (xmlDocPtr) xmlMalloc(sizeof(xmlDoc));
+    if (cur == NULL) {
+	htmlErrMemory(NULL, "HTML document creation failed\n");
+	return(NULL);
+    }
+    memset(cur, 0, sizeof(xmlDoc));
+
+    cur->type = XML_HTML_DOCUMENT_NODE;
+    cur->version = NULL;
+    cur->intSubset = NULL;
+    cur->doc = cur;
+    cur->name = NULL;
+    cur->children = NULL; 
+    cur->extSubset = NULL;
+    cur->oldNs = NULL;
+    cur->encoding = NULL;
+    cur->standalone = 1;
+    cur->compression = 0;
+    cur->ids = NULL;
+    cur->refs = NULL;
+    cur->_private = NULL;
+    if ((ExternalID != NULL) ||
+	(URI != NULL))
+	xmlCreateIntSubset(cur, BAD_CAST "html", ExternalID, URI);
+    return(cur);
+}
+
+/**
+ * htmlNewDoc:
+ * @URI:  URI for the dtd, or NULL
+ * @ExternalID:  the external ID of the DTD, or NULL
+ *
+ * Creates a new HTML document
+ *
+ * Returns a new document
+ */
+htmlDocPtr
+htmlNewDoc(const xmlChar *URI, const xmlChar *ExternalID) {
+    if ((URI == NULL) && (ExternalID == NULL))
+	return(htmlNewDocNoDtD(
+		    BAD_CAST "http://www.w3.org/TR/REC-html40/loose.dtd",
+		    BAD_CAST "-//W3C//DTD HTML 4.0 Transitional//EN"));
+
+    return(htmlNewDocNoDtD(URI, ExternalID));
+}
+
+
+/************************************************************************
+ *									*
+ *			The parser itself				*
+ *	Relates to http://www.w3.org/TR/html40				*
+ *									*
+ ************************************************************************/
+
+/************************************************************************
+ *									*
+ *			The parser itself				*
+ *									*
+ ************************************************************************/
+
+static const xmlChar * htmlParseNameComplex(xmlParserCtxtPtr ctxt);
+
+/**
+ * htmlParseHTMLName:
+ * @ctxt:  an HTML parser context
+ *
+ * parse an HTML tag or attribute name, note that we convert it to lowercase
+ * since HTML names are not case-sensitive.
+ *
+ * Returns the Tag Name parsed or NULL
+ */
+
+static const xmlChar *
+htmlParseHTMLName(htmlParserCtxtPtr ctxt) {
+    int i = 0;
+    xmlChar loc[HTML_PARSER_BUFFER_SIZE];
+
+    if (!IS_LETTER_CH(CUR) && (CUR != '_') &&
+        (CUR != ':')) return(NULL);
+
+    while ((i < HTML_PARSER_BUFFER_SIZE) &&
+           ((IS_LETTER_CH(CUR)) || (IS_DIGIT_CH(CUR)) ||
+	   (CUR == ':') || (CUR == '-') || (CUR == '_'))) {
+	if ((CUR >= 'A') && (CUR <= 'Z')) loc[i] = CUR + 0x20;
+        else loc[i] = CUR;
+	i++;
+	
+	NEXT;
+    }
+    
+    return(xmlDictLookup(ctxt->dict, loc, i));
+}
+
+/**
+ * htmlParseName:
+ * @ctxt:  an HTML parser context
+ *
+ * parse an HTML name, this routine is case sensitive.
+ *
+ * Returns the Name parsed or NULL
+ */
+
+static const xmlChar *
+htmlParseName(htmlParserCtxtPtr ctxt) {
+    const xmlChar *in;
+    const xmlChar *ret;
+    int count = 0;
+
+    GROW;
+
+    /*
+     * Accelerator for simple ASCII names
+     */
+    in = ctxt->input->cur;
+    if (((*in >= 0x61) && (*in <= 0x7A)) ||
+	((*in >= 0x41) && (*in <= 0x5A)) ||
+	(*in == '_') || (*in == ':')) {
+	in++;
+	while (((*in >= 0x61) && (*in <= 0x7A)) ||
+	       ((*in >= 0x41) && (*in <= 0x5A)) ||
+	       ((*in >= 0x30) && (*in <= 0x39)) ||
+	       (*in == '_') || (*in == '-') ||
+	       (*in == ':') || (*in == '.'))
+	    in++;
+	if ((*in > 0) && (*in < 0x80)) {
+	    count = in - ctxt->input->cur;
+	    ret = xmlDictLookup(ctxt->dict, ctxt->input->cur, count);
+	    ctxt->input->cur = in;
+	    ctxt->nbChars += count;
+	    ctxt->input->col += count;
+	    return(ret);
+	}
+    }
+    return(htmlParseNameComplex(ctxt));
+}
+
+static const xmlChar *
+htmlParseNameComplex(xmlParserCtxtPtr ctxt) {
+    int len = 0, l;
+    int c;
+    int count = 0;
+
+    /*
+     * Handler for more complex cases
+     */
+    GROW;
+    c = CUR_CHAR(l);
+    if ((c == ' ') || (c == '>') || (c == '/') || /* accelerators */
+	(!IS_LETTER(c) && (c != '_') &&
+         (c != ':'))) {
+	return(NULL);
+    }
+
+    while ((c != ' ') && (c != '>') && (c != '/') && /* test bigname.xml */
+	   ((IS_LETTER(c)) || (IS_DIGIT(c)) ||
+            (c == '.') || (c == '-') ||
+	    (c == '_') || (c == ':') || 
+	    (IS_COMBINING(c)) ||
+	    (IS_EXTENDER(c)))) {
+	if (count++ > 100) {
+	    count = 0;
+	    GROW;
+	}
+	len += l;
+	NEXTL(l);
+	c = CUR_CHAR(l);
+    }
+    return(xmlDictLookup(ctxt->dict, ctxt->input->cur - len, len));
+}
+
+
+/**
+ * htmlParseHTMLAttribute:
+ * @ctxt:  an HTML parser context
+ * @stop:  a char stop value
+ * 
+ * parse an HTML attribute value till the stop (quote), if
+ * stop is 0 then it stops at the first space
+ *
+ * Returns the attribute parsed or NULL
+ */
+
+static xmlChar *
+htmlParseHTMLAttribute(htmlParserCtxtPtr ctxt, const xmlChar stop) {
+    xmlChar *buffer = NULL;
+    int buffer_size = 0;
+    xmlChar *out = NULL;
+    const xmlChar *name = NULL;
+    const xmlChar *cur = NULL;
+    const htmlEntityDesc * ent;
+
+    /*
+     * allocate a translation buffer.
+     */
+    buffer_size = HTML_PARSER_BUFFER_SIZE;
+    buffer = (xmlChar *) xmlMallocAtomic(buffer_size * sizeof(xmlChar));
+    if (buffer == NULL) {
+	htmlErrMemory(ctxt, "buffer allocation failed\n");
+	return(NULL);
+    }
+    out = buffer;
+
+    /*
+     * Ok loop until we reach one of the ending chars
+     */
+    while ((CUR != 0) && (CUR != stop)) {
+	if ((stop == 0) && (CUR == '>')) break;
+	if ((stop == 0) && (IS_BLANK_CH(CUR))) break;
+        if (CUR == '&') {
+	    if (NXT(1) == '#') {
+		unsigned int c;
+		int bits;
+
+		c = htmlParseCharRef(ctxt);
+		if      (c <    0x80)
+		        { *out++  = c;                bits= -6; }
+		else if (c <   0x800)
+		        { *out++  =((c >>  6) & 0x1F) | 0xC0;  bits=  0; }
+		else if (c < 0x10000)
+		        { *out++  =((c >> 12) & 0x0F) | 0xE0;  bits=  6; }
+		else                 
+		        { *out++  =((c >> 18) & 0x07) | 0xF0;  bits= 12; }
+	 
+		for ( ; bits >= 0; bits-= 6) {
+		    *out++  = ((c >> bits) & 0x3F) | 0x80;
+		}
+		
+		if (out - buffer > buffer_size - 100) {
+			int indx = out - buffer;
+
+			growBuffer(buffer);
+			out = &buffer[indx];
+		}
+	    } else {
+		ent = htmlParseEntityRef(ctxt, &name);
+		if (name == NULL) {
+		    *out++ = '&';
+		    if (out - buffer > buffer_size - 100) {
+			int indx = out - buffer;
+
+			growBuffer(buffer);
+			out = &buffer[indx];
+		    }
+		} else if (ent == NULL) {
+		    *out++ = '&';
+		    cur = name;
+		    while (*cur != 0) {
+			if (out - buffer > buffer_size - 100) {
+			    int indx = out - buffer;
+
+			    growBuffer(buffer);
+			    out = &buffer[indx];
+			}
+			*out++ = *cur++;
+		    }
+		} else {
+		    unsigned int c;
+		    int bits;
+
+		    if (out - buffer > buffer_size - 100) {
+			int indx = out - buffer;
+
+			growBuffer(buffer);
+			out = &buffer[indx];
+		    }
+		    c = (xmlChar)ent->value;
+		    if      (c <    0x80)
+			{ *out++  = c;                bits= -6; }
+		    else if (c <   0x800)
+			{ *out++  =((c >>  6) & 0x1F) | 0xC0;  bits=  0; }
+		    else if (c < 0x10000)
+			{ *out++  =((c >> 12) & 0x0F) | 0xE0;  bits=  6; }
+		    else                 
+			{ *out++  =((c >> 18) & 0x07) | 0xF0;  bits= 12; }
+	     
+		    for ( ; bits >= 0; bits-= 6) {
+			*out++  = ((c >> bits) & 0x3F) | 0x80;
+		    }
+		}
+	    }
+	} else {
+	    unsigned int c;
+	    int bits, l;
+
+	    if (out - buffer > buffer_size - 100) {
+		int indx = out - buffer;
+
+		growBuffer(buffer);
+		out = &buffer[indx];
+	    }
+	    c = CUR_CHAR(l);
+	    if      (c <    0x80)
+		    { *out++  = c;                bits= -6; }
+	    else if (c <   0x800)
+		    { *out++  =((c >>  6) & 0x1F) | 0xC0;  bits=  0; }
+	    else if (c < 0x10000)
+		    { *out++  =((c >> 12) & 0x0F) | 0xE0;  bits=  6; }
+	    else                 
+		    { *out++  =((c >> 18) & 0x07) | 0xF0;  bits= 12; }
+     
+	    for ( ; bits >= 0; bits-= 6) {
+		*out++  = ((c >> bits) & 0x3F) | 0x80;
+	    }
+	    NEXT;
+	}
+    }
+    *out++ = 0;
+    return(buffer);
+}
+
+/**
+ * htmlParseEntityRef:
+ * @ctxt:  an HTML parser context
+ * @str:  location to store the entity name
+ *
+ * parse an HTML ENTITY references
+ *
+ * [68] EntityRef ::= '&' Name ';'
+ *
+ * Returns the associated htmlEntityDescPtr if found, or NULL otherwise,
+ *         if non-NULL *str will have to be freed by the caller.
+ */
+const htmlEntityDesc *
+htmlParseEntityRef(htmlParserCtxtPtr ctxt, const xmlChar **str) {
+    const xmlChar *name;
+    const htmlEntityDesc * ent = NULL;
+    *str = NULL;
+
+    if (CUR == '&') {
+        NEXT;
+        name = htmlParseName(ctxt);
+	if (name == NULL) {
+	    htmlParseErr(ctxt, XML_ERR_NAME_REQUIRED,
+	                 "htmlParseEntityRef: no name\n", NULL, NULL);
+	} else {
+	    GROW;
+	    if (CUR == ';') {
+		*str = name;
+
+		/*
+		 * Lookup the entity in the table.
+		 */
+		ent = htmlEntityLookup(name);
+		if (ent != NULL) /* OK that's ugly !!! */
+		    NEXT;
+	    } else {
+		htmlParseErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING,
+		             "htmlParseEntityRef: expecting ';'\n",
+			     NULL, NULL);
+		*str = name;
+	    }
+	}
+    }
+    return(ent);
+}
+
+/**
+ * htmlParseAttValue:
+ * @ctxt:  an HTML parser context
+ *
+ * parse a value for an attribute
+ * Note: the parser won't do substitution of entities here, this
+ * will be handled later in xmlStringGetNodeList, unless it was
+ * asked for ctxt->replaceEntities != 0 
+ *
+ * Returns the AttValue parsed or NULL.
+ */
+
+static xmlChar *
+htmlParseAttValue(htmlParserCtxtPtr ctxt) {
+    xmlChar *ret = NULL;
+
+    if (CUR == '"') {
+        NEXT;
+	ret = htmlParseHTMLAttribute(ctxt, '"');
+        if (CUR != '"') {
+	    htmlParseErr(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
+	                 "AttValue: \" expected\n", NULL, NULL);
+	} else
+	    NEXT;
+    } else if (CUR == '\'') {
+        NEXT;
+	ret = htmlParseHTMLAttribute(ctxt, '\'');
+        if (CUR != '\'') {
+	    htmlParseErr(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
+	                 "AttValue: ' expected\n", NULL, NULL);
+	} else
+	    NEXT;
+    } else {
+        /*
+	 * That's an HTMLism, the attribute value may not be quoted
+	 */
+	ret = htmlParseHTMLAttribute(ctxt, 0);
+	if (ret == NULL) {
+	    htmlParseErr(ctxt, XML_ERR_ATTRIBUTE_WITHOUT_VALUE,
+	                 "AttValue: no value found\n", NULL, NULL);
+	}
+    }
+    return(ret);
+}
+
+/**
+ * htmlParseSystemLiteral:
+ * @ctxt:  an HTML parser context
+ * 
+ * parse an HTML Literal
+ *
+ * [11] SystemLiteral ::= ('"' [^"]* '"') | ("'" [^']* "'")
+ *
+ * Returns the SystemLiteral parsed or NULL
+ */
+
+static xmlChar *
+htmlParseSystemLiteral(htmlParserCtxtPtr ctxt) {
+    const xmlChar *q;
+    xmlChar *ret = NULL;
+
+    if (CUR == '"') {
+        NEXT;
+	q = CUR_PTR;
+	while ((IS_CHAR_CH(CUR)) && (CUR != '"'))
+	    NEXT;
+	if (!IS_CHAR_CH(CUR)) {
+	    htmlParseErr(ctxt, XML_ERR_LITERAL_NOT_FINISHED,
+			 "Unfinished SystemLiteral\n", NULL, NULL);
+	} else {
+	    ret = xmlStrndup(q, CUR_PTR - q);
+	    NEXT;
+        }
+    } else if (CUR == '\'') {
+        NEXT;
+	q = CUR_PTR;
+	while ((IS_CHAR_CH(CUR)) && (CUR != '\''))
+	    NEXT;
+	if (!IS_CHAR_CH(CUR)) {
+	    htmlParseErr(ctxt, XML_ERR_LITERAL_NOT_FINISHED,
+			 "Unfinished SystemLiteral\n", NULL, NULL);
+	} else {
+	    ret = xmlStrndup(q, CUR_PTR - q);
+	    NEXT;
+        }
+    } else {
+	htmlParseErr(ctxt, XML_ERR_LITERAL_NOT_STARTED,
+	             " or ' expected\n", NULL, NULL);
+    }
+    
+    return(ret);
+}
+
+/**
+ * htmlParsePubidLiteral:
+ * @ctxt:  an HTML parser context
+ *
+ * parse an HTML public literal
+ *
+ * [12] PubidLiteral ::= '"' PubidChar* '"' | "'" (PubidChar - "'")* "'"
+ *
+ * Returns the PubidLiteral parsed or NULL.
+ */
+
+static xmlChar *
+htmlParsePubidLiteral(htmlParserCtxtPtr ctxt) {
+    const xmlChar *q;
+    xmlChar *ret = NULL;
+    /*
+     * Name ::= (Letter | '_') (NameChar)*
+     */
+    if (CUR == '"') {
+        NEXT;
+	q = CUR_PTR;
+	while (IS_PUBIDCHAR_CH(CUR)) NEXT;
+	if (CUR != '"') {
+	    htmlParseErr(ctxt, XML_ERR_LITERAL_NOT_FINISHED,
+	                 "Unfinished PubidLiteral\n", NULL, NULL);
+	} else {
+	    ret = xmlStrndup(q, CUR_PTR - q);
+	    NEXT;
+	}
+    } else if (CUR == '\'') {
+        NEXT;
+	q = CUR_PTR;
+	while ((IS_PUBIDCHAR_CH(CUR)) && (CUR != '\''))
+	    NEXT;
+	if (CUR != '\'') {
+	    htmlParseErr(ctxt, XML_ERR_LITERAL_NOT_FINISHED,
+	                 "Unfinished PubidLiteral\n", NULL, NULL);
+	} else {
+	    ret = xmlStrndup(q, CUR_PTR - q);
+	    NEXT;
+	}
+    } else {
+	htmlParseErr(ctxt, XML_ERR_LITERAL_NOT_STARTED,
+	             "PubidLiteral \" or ' expected\n", NULL, NULL);
+    }
+    
+    return(ret);
+}
+
+/**
+ * htmlParseScript:
+ * @ctxt:  an HTML parser context
+ *
+ * parse the content of an HTML SCRIPT or STYLE element
+ * http://www.w3.org/TR/html4/sgml/dtd.html#Script
+ * http://www.w3.org/TR/html4/sgml/dtd.html#StyleSheet
+ * http://www.w3.org/TR/html4/types.html#type-script
+ * http://www.w3.org/TR/html4/types.html#h-6.15
+ * http://www.w3.org/TR/html4/appendix/notes.html#h-B.3.2.1
+ *
+ * Script data ( %Script; in the DTD) can be the content of the SCRIPT
+ * element and the value of intrinsic event attributes. User agents must
+ * not evaluate script data as HTML markup but instead must pass it on as
+ * data to a script engine.
+ * NOTES:
+ * - The content is passed like CDATA
+ * - the attributes for style and scripting "onXXX" are also described
+ *   as CDATA but SGML allows entities references in attributes so their
+ *   processing is identical as other attributes
+ */
+static void
+htmlParseScript(htmlParserCtxtPtr ctxt) {
+    xmlChar buf[HTML_PARSER_BIG_BUFFER_SIZE + 1];
+    int nbchar = 0;
+    xmlChar cur;
+
+    SHRINK;
+    cur = CUR;
+    while (IS_CHAR_CH(cur)) {
+	if ((cur == '<') && (NXT(1) == '!') && (NXT(2) == '-') &&
+	    (NXT(3) == '-')) {
+	    if ((nbchar != 0) && (ctxt->sax != NULL) && (!ctxt->disableSAX)) {
+		if (ctxt->sax->cdataBlock!= NULL) {
+		    /*
+		     * Insert as CDATA, which is the same as HTML_PRESERVE_NODE
+		     */
+		    ctxt->sax->cdataBlock(ctxt->userData, buf, nbchar);
+		} else if (ctxt->sax->characters != NULL) {
+		    ctxt->sax->characters(ctxt->userData, buf, nbchar);
+		}
+	    }
+	    nbchar = 0;
+	    htmlParseComment(ctxt);
+	    cur = CUR;
+	    continue;
+	} else if ((cur == '<') && (NXT(1) == '/')) {
+	    /*
+	     * One should break here, the specification is clear:
+	     * Authors should therefore escape "</" within the content.
+	     * Escape mechanisms are specific to each scripting or
+	     * style sheet language.
+	     */
+	    if (((NXT(2) >= 'A') && (NXT(2) <= 'Z')) ||
+	        ((NXT(2) >= 'a') && (NXT(2) <= 'z')))
+		break; /* while */
+	}
+	buf[nbchar++] = cur;
+	if (nbchar >= HTML_PARSER_BIG_BUFFER_SIZE) {
+	    if (ctxt->sax->cdataBlock!= NULL) {
+		/*
+		 * Insert as CDATA, which is the same as HTML_PRESERVE_NODE
+		 */
+		ctxt->sax->cdataBlock(ctxt->userData, buf, nbchar);
+	    } else if (ctxt->sax->characters != NULL) {
+		ctxt->sax->characters(ctxt->userData, buf, nbchar);
+	    }
+	    nbchar = 0;
+	}
+	NEXT;
+	cur = CUR;
+    }
+    if (!(IS_CHAR_CH(cur))) {
+	htmlParseErrInt(ctxt, XML_ERR_INVALID_CHAR,
+	                "Invalid char in CDATA 0x%X\n", cur);
+	NEXT;
+    }
+
+    if ((nbchar != 0) && (ctxt->sax != NULL) && (!ctxt->disableSAX)) {
+	if (ctxt->sax->cdataBlock!= NULL) {
+	    /*
+	     * Insert as CDATA, which is the same as HTML_PRESERVE_NODE
+	     */
+	    ctxt->sax->cdataBlock(ctxt->userData, buf, nbchar);
+	} else if (ctxt->sax->characters != NULL) {
+	    ctxt->sax->characters(ctxt->userData, buf, nbchar);
+	}
+    }
+}
+
+
+/**
+ * htmlParseCharData:
+ * @ctxt:  an HTML parser context
+ *
+ * parse a CharData section.
+ * if we are within a CDATA section ']]>' marks an end of section.
+ *
+ * [14] CharData ::= [^<&]* - ([^<&]* ']]>' [^<&]*)
+ */
+
+static void
+htmlParseCharData(htmlParserCtxtPtr ctxt) {
+    xmlChar buf[HTML_PARSER_BIG_BUFFER_SIZE + 5];
+    int nbchar = 0;
+    int cur, l;
+
+    SHRINK;
+    cur = CUR_CHAR(l);
+    while (((cur != '<') || (ctxt->token == '<')) &&
+           ((cur != '&') || (ctxt->token == '&')) && 
+	   (IS_CHAR(cur))) {
+	COPY_BUF(l,buf,nbchar,cur);
+	if (nbchar >= HTML_PARSER_BIG_BUFFER_SIZE) {
+	    /*
+	     * Ok the segment is to be consumed as chars.
+	     */
+	    if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) {
+		if (areBlanks(ctxt, buf, nbchar)) {
+		    if (ctxt->sax->ignorableWhitespace != NULL)
+			ctxt->sax->ignorableWhitespace(ctxt->userData,
+			                               buf, nbchar);
+		} else {
+		    htmlCheckParagraph(ctxt);
+		    if (ctxt->sax->characters != NULL)
+			ctxt->sax->characters(ctxt->userData, buf, nbchar);
+		}
+	    }
+	    nbchar = 0;
+	}
+	NEXTL(l);
+	cur = CUR_CHAR(l);
+	if (cur == 0) {
+	    SHRINK;
+	    GROW;
+	    cur = CUR_CHAR(l);
+	}
+    }
+    if (nbchar != 0) {
+	/*
+	 * Ok the segment is to be consumed as chars.
+	 */
+	if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) {
+	    if (areBlanks(ctxt, buf, nbchar)) {
+		if (ctxt->sax->ignorableWhitespace != NULL)
+		    ctxt->sax->ignorableWhitespace(ctxt->userData, buf, nbchar);
+	    } else {
+		htmlCheckParagraph(ctxt);
+		if (ctxt->sax->characters != NULL)
+		    ctxt->sax->characters(ctxt->userData, buf, nbchar);
+	    }
+	}
+    } else {
+	/*
+	 * Loop detection
+	 */
+	if (cur == 0)
+	    ctxt->instate = XML_PARSER_EOF;
+    }
+}
+
+/**
+ * htmlParseExternalID:
+ * @ctxt:  an HTML parser context
+ * @publicID:  a xmlChar** receiving PubidLiteral
+ *
+ * Parse an External ID or a Public ID
+ *
+ * [75] ExternalID ::= 'SYSTEM' S SystemLiteral
+ *                   | 'PUBLIC' S PubidLiteral S SystemLiteral
+ *
+ * [83] PublicID ::= 'PUBLIC' S PubidLiteral
+ *
+ * Returns the function returns SystemLiteral and in the second
+ *                case publicID receives PubidLiteral, is strict is off
+ *                it is possible to return NULL and have publicID set.
+ */
+
+static xmlChar *
+htmlParseExternalID(htmlParserCtxtPtr ctxt, xmlChar **publicID) {
+    xmlChar *URI = NULL;
+
+    if ((UPPER == 'S') && (UPP(1) == 'Y') &&
+         (UPP(2) == 'S') && (UPP(3) == 'T') &&
+	 (UPP(4) == 'E') && (UPP(5) == 'M')) {
+        SKIP(6);
+	if (!IS_BLANK_CH(CUR)) {
+	    htmlParseErr(ctxt, XML_ERR_SPACE_REQUIRED,
+	                 "Space required after 'SYSTEM'\n", NULL, NULL);
+	}
+        SKIP_BLANKS;
+	URI = htmlParseSystemLiteral(ctxt);
+	if (URI == NULL) {
+	    htmlParseErr(ctxt, XML_ERR_URI_REQUIRED,
+	                 "htmlParseExternalID: SYSTEM, no URI\n", NULL, NULL);
+        }
+    } else if ((UPPER == 'P') && (UPP(1) == 'U') &&
+	       (UPP(2) == 'B') && (UPP(3) == 'L') &&
+	       (UPP(4) == 'I') && (UPP(5) == 'C')) {
+        SKIP(6);
+	if (!IS_BLANK_CH(CUR)) {
+	    htmlParseErr(ctxt, XML_ERR_SPACE_REQUIRED,
+	                 "Space required after 'PUBLIC'\n", NULL, NULL);
+	}
+        SKIP_BLANKS;
+	*publicID = htmlParsePubidLiteral(ctxt);
+	if (*publicID == NULL) {
+	    htmlParseErr(ctxt, XML_ERR_PUBID_REQUIRED,
+	                 "htmlParseExternalID: PUBLIC, no Public Identifier\n",
+			 NULL, NULL);
+	}
+        SKIP_BLANKS;
+        if ((CUR == '"') || (CUR == '\'')) {
+	    URI = htmlParseSystemLiteral(ctxt);
+	}
+    }
+    return(URI);
+}
+
+/**
+ * htmlParseComment:
+ * @ctxt:  an HTML parser context
+ *
+ * Parse an XML (SGML) comment <!-- .... -->
+ *
+ * [15] Comment ::= '<!--' ((Char - '-') | ('-' (Char - '-')))* '-->'
+ */
+static void
+htmlParseComment(htmlParserCtxtPtr ctxt) {
+    xmlChar *buf = NULL;
+    int len;
+    int size = HTML_PARSER_BUFFER_SIZE;
+    int q, ql;
+    int r, rl;
+    int cur, l;
+    xmlParserInputState state;
+
+    /*
+     * Check that there is a comment right here.
+     */
+    if ((RAW != '<') || (NXT(1) != '!') ||
+        (NXT(2) != '-') || (NXT(3) != '-')) return;
+
+    state = ctxt->instate;
+    ctxt->instate = XML_PARSER_COMMENT;
+    SHRINK;
+    SKIP(4);
+    buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar));
+    if (buf == NULL) {
+        htmlErrMemory(ctxt, "buffer allocation failed\n");
+	ctxt->instate = state;
+	return;
+    }
+    q = CUR_CHAR(ql);
+    NEXTL(ql);
+    r = CUR_CHAR(rl);
+    NEXTL(rl);
+    cur = CUR_CHAR(l);
+    len = 0;
+    while (IS_CHAR(cur) &&
+           ((cur != '>') ||
+	    (r != '-') || (q != '-'))) {
+	if (len + 5 >= size) {
+	    size *= 2;
+	    buf = (xmlChar *) xmlRealloc(buf, size * sizeof(xmlChar));
+	    if (buf == NULL) {
+	        htmlErrMemory(ctxt, "growing buffer failed\n");
+		ctxt->instate = state;
+		return;
+	    }
+	}
+	COPY_BUF(ql,buf,len,q);
+	q = r;
+	ql = rl;
+	r = cur;
+	rl = l;
+	NEXTL(l);
+	cur = CUR_CHAR(l);
+	if (cur == 0) {
+	    SHRINK;
+	    GROW;
+	    cur = CUR_CHAR(l);
+	}
+    }
+    buf[len] = 0;
+    if (!IS_CHAR(cur)) {
+	htmlParseErr(ctxt, XML_ERR_COMMENT_NOT_FINISHED,
+	             "Comment not terminated \n<!--%.50s\n", buf, NULL);
+	xmlFree(buf);
+    } else {
+        NEXT;
+	if ((ctxt->sax != NULL) && (ctxt->sax->comment != NULL) &&
+	    (!ctxt->disableSAX))
+	    ctxt->sax->comment(ctxt->userData, buf);
+	xmlFree(buf);
+    }
+    ctxt->instate = state;
+}
+
+/**
+ * htmlParseCharRef:
+ * @ctxt:  an HTML parser context
+ *
+ * parse Reference declarations
+ *
+ * [66] CharRef ::= '&#' [0-9]+ ';' |
+ *                  '&#x' [0-9a-fA-F]+ ';'
+ *
+ * Returns the value parsed (as an int)
+ */
+int
+htmlParseCharRef(htmlParserCtxtPtr ctxt) {
+    int val = 0;
+
+    if ((CUR == '&') && (NXT(1) == '#') &&
+        ((NXT(2) == 'x') || NXT(2) == 'X')) {
+	SKIP(3);
+	while (CUR != ';') {
+	    if ((CUR >= '0') && (CUR <= '9')) 
+	        val = val * 16 + (CUR - '0');
+	    else if ((CUR >= 'a') && (CUR <= 'f'))
+	        val = val * 16 + (CUR - 'a') + 10;
+	    else if ((CUR >= 'A') && (CUR <= 'F'))
+	        val = val * 16 + (CUR - 'A') + 10;
+	    else {
+	        htmlParseErr(ctxt, XML_ERR_INVALID_HEX_CHARREF,
+		             "htmlParseCharRef: invalid hexadecimal value\n",
+			     NULL, NULL);
+		return(0);
+	    }
+	    NEXT;
+	}
+	if (CUR == ';')
+	    NEXT;
+    } else if  ((CUR == '&') && (NXT(1) == '#')) {
+	SKIP(2);
+	while (CUR != ';') {
+	    if ((CUR >= '0') && (CUR <= '9')) 
+	        val = val * 10 + (CUR - '0');
+	    else {
+	        htmlParseErr(ctxt, XML_ERR_INVALID_DEC_CHARREF,
+		             "htmlParseCharRef: invalid decimal value\n",
+			     NULL, NULL);
+		return(0);
+	    }
+	    NEXT;
+	}
+	if (CUR == ';')
+	    NEXT;
+    } else {
+	htmlParseErr(ctxt, XML_ERR_INVALID_CHARREF,
+	             "htmlParseCharRef: invalid value\n", NULL, NULL);
+    }
+    /*
+     * Check the value IS_CHAR ...
+     */
+    if (IS_CHAR(val)) {
+        return(val);
+    } else {
+	htmlParseErrInt(ctxt, XML_ERR_INVALID_CHAR,
+			"htmlParseCharRef: invalid xmlChar value %d\n",
+			val);
+    }
+    return(0);
+}
+
+
+/**
+ * htmlParseDocTypeDecl:
+ * @ctxt:  an HTML parser context
+ *
+ * parse a DOCTYPE declaration
+ *
+ * [28] doctypedecl ::= '<!DOCTYPE' S Name (S ExternalID)? S? 
+ *                      ('[' (markupdecl | PEReference | S)* ']' S?)? '>'
+ */
+
+static void
+htmlParseDocTypeDecl(htmlParserCtxtPtr ctxt) {
+    const xmlChar *name;
+    xmlChar *ExternalID = NULL;
+    xmlChar *URI = NULL;
+
+    /*
+     * We know that '<!DOCTYPE' has been detected.
+     */
+    SKIP(9);
+
+    SKIP_BLANKS;
+
+    /*
+     * Parse the DOCTYPE name.
+     */
+    name = htmlParseName(ctxt);
+    if (name == NULL) {
+	htmlParseErr(ctxt, XML_ERR_NAME_REQUIRED,
+	             "htmlParseDocTypeDecl : no DOCTYPE name !\n",
+		     NULL, NULL);
+    }
+    /*
+     * Check that upper(name) == "HTML" !!!!!!!!!!!!!
+     */
+
+    SKIP_BLANKS;
+
+    /*
+     * Check for SystemID and ExternalID
+     */
+    URI = htmlParseExternalID(ctxt, &ExternalID);
+    SKIP_BLANKS;
+
+    /*
+     * We should be at the end of the DOCTYPE declaration.
+     */
+    if (CUR != '>') {
+	htmlParseErr(ctxt, XML_ERR_DOCTYPE_NOT_FINISHED,
+	             "DOCTYPE improperly terminated\n", NULL, NULL);
+        /* We shouldn't try to resynchronize ... */
+    }
+    NEXT;
+
+    /*
+     * Create or update the document accordingly to the DOCTYPE
+     */
+    if ((ctxt->sax != NULL) && (ctxt->sax->internalSubset != NULL) &&
+	(!ctxt->disableSAX))
+	ctxt->sax->internalSubset(ctxt->userData, name, ExternalID, URI);
+
+    /*
+     * Cleanup, since we don't use all those identifiers
+     */
+    if (URI != NULL) xmlFree(URI);
+    if (ExternalID != NULL) xmlFree(ExternalID);
+}
+
+/**
+ * htmlParseAttribute:
+ * @ctxt:  an HTML parser context
+ * @value:  a xmlChar ** used to store the value of the attribute
+ *
+ * parse an attribute
+ *
+ * [41] Attribute ::= Name Eq AttValue
+ *
+ * [25] Eq ::= S? '=' S?
+ *
+ * With namespace:
+ *
+ * [NS 11] Attribute ::= QName Eq AttValue
+ *
+ * Also the case QName == xmlns:??? is handled independently as a namespace
+ * definition.
+ *
+ * Returns the attribute name, and the value in *value.
+ */
+
+static const xmlChar *
+htmlParseAttribute(htmlParserCtxtPtr ctxt, xmlChar **value) {
+    const xmlChar *name;
+    xmlChar *val = NULL;
+
+    *value = NULL;
+    name = htmlParseHTMLName(ctxt);
+    if (name == NULL) {
+	htmlParseErr(ctxt, XML_ERR_NAME_REQUIRED,
+	             "error parsing attribute name\n", NULL, NULL);
+        return(NULL);
+    }
+
+    /*
+     * read the value
+     */
+    SKIP_BLANKS;
+    if (CUR == '=') {
+        NEXT;
+	SKIP_BLANKS;
+	val = htmlParseAttValue(ctxt);
+	/******
+    } else {
+        * TODO : some attribute must have values, some may not
+	if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
+	    ctxt->sax->warning(ctxt->userData,
+	       "No value for attribute %s\n", name); */
+    }
+
+    *value = val;
+    return(name);
+}
+
+/**
+ * htmlCheckEncoding:
+ * @ctxt:  an HTML parser context
+ * @attvalue: the attribute value
+ *
+ * Checks an http-equiv attribute from a Meta tag to detect
+ * the encoding
+ * If a new encoding is detected the parser is switched to decode
+ * it and pass UTF8
+ */
+static void
+htmlCheckEncoding(htmlParserCtxtPtr ctxt, const xmlChar *attvalue) {
+    const xmlChar *encoding;
+
+    if ((ctxt == NULL) || (attvalue == NULL))
+	return;
+
+    /* do not change encoding */	
+    if (ctxt->input->encoding != NULL)
+        return;
+
+    encoding = xmlStrcasestr(attvalue, BAD_CAST"charset=");
+    if (encoding != NULL) {
+	encoding += 8;
+    } else {
+	encoding = xmlStrcasestr(attvalue, BAD_CAST"charset =");
+	if (encoding != NULL)
+	    encoding += 9;
+    }
+    if (encoding != NULL) {
+	xmlCharEncoding enc;
+	xmlCharEncodingHandlerPtr handler;
+
+	while ((*encoding == ' ') || (*encoding == '\t')) encoding++;
+
+	if (ctxt->input->encoding != NULL)
+	    xmlFree((xmlChar *) ctxt->input->encoding);
+	ctxt->input->encoding = xmlStrdup(encoding);
+
+	enc = xmlParseCharEncoding((const char *) encoding);
+	/*
+	 * registered set of known encodings
+	 */
+	if (enc != XML_CHAR_ENCODING_ERROR) {
+	    xmlSwitchEncoding(ctxt, enc);
+	    ctxt->charset = XML_CHAR_ENCODING_UTF8;
+	} else {
+	    /*
+	     * fallback for unknown encodings
+	     */
+	    handler = xmlFindCharEncodingHandler((const char *) encoding);
+	    if (handler != NULL) {
+		xmlSwitchToEncoding(ctxt, handler);
+		ctxt->charset = XML_CHAR_ENCODING_UTF8;
+	    } else {
+		ctxt->errNo = XML_ERR_UNSUPPORTED_ENCODING;
+	    }
+	}
+
+	if ((ctxt->input->buf != NULL) &&
+	    (ctxt->input->buf->encoder != NULL) &&
+	    (ctxt->input->buf->raw != NULL) &&
+	    (ctxt->input->buf->buffer != NULL)) {
+	    int nbchars;
+	    int processed;
+
+	    /*
+	     * convert as much as possible to the parser reading buffer.
+	     */
+	    processed = ctxt->input->cur - ctxt->input->base;
+	    xmlBufferShrink(ctxt->input->buf->buffer, processed);
+	    nbchars = xmlCharEncInFunc(ctxt->input->buf->encoder,
+		                       ctxt->input->buf->buffer,
+				       ctxt->input->buf->raw);
+	    if (nbchars < 0) {
+		htmlParseErr(ctxt, XML_ERR_INVALID_ENCODING,
+		             "htmlCheckEncoding: encoder error\n",
+			     NULL, NULL);
+	    }
+	    ctxt->input->base =
+	    ctxt->input->cur = ctxt->input->buf->buffer->content;
+	}
+    }
+}
+
+/**
+ * htmlCheckMeta:
+ * @ctxt:  an HTML parser context
+ * @atts:  the attributes values
+ *
+ * Checks an attributes from a Meta tag
+ */
+static void
+htmlCheckMeta(htmlParserCtxtPtr ctxt, const xmlChar **atts) {
+    int i;
+    const xmlChar *att, *value;
+    int http = 0;
+    const xmlChar *content = NULL;
+
+    if ((ctxt == NULL) || (atts == NULL))
+	return;
+
+    i = 0;
+    att = atts[i++];
+    while (att != NULL) {
+	value = atts[i++];
+	if ((value != NULL) && (!xmlStrcasecmp(att, BAD_CAST"http-equiv"))
+	 && (!xmlStrcasecmp(value, BAD_CAST"Content-Type")))
+	    http = 1;
+	else if ((value != NULL) && (!xmlStrcasecmp(att, BAD_CAST"content")))
+	    content = value;
+	att = atts[i++];
+    }
+    if ((http) && (content != NULL))
+	htmlCheckEncoding(ctxt, content);
+
+}
+
+/**
+ * htmlParseStartTag:
+ * @ctxt:  an HTML parser context
+ * 
+ * parse a start of tag either for rule element or
+ * EmptyElement. In both case we don't parse the tag closing chars.
+ *
+ * [40] STag ::= '<' Name (S Attribute)* S? '>'
+ *
+ * [44] EmptyElemTag ::= '<' Name (S Attribute)* S? '/>'
+ *
+ * With namespace:
+ *
+ * [NS 8] STag ::= '<' QName (S Attribute)* S? '>'
+ *
+ * [NS 10] EmptyElement ::= '<' QName (S Attribute)* S? '/>'
+ *
+ */
+
+static void
+htmlParseStartTag(htmlParserCtxtPtr ctxt) {
+    const xmlChar *name;
+    const xmlChar *attname;
+    xmlChar *attvalue;
+    const xmlChar **atts = ctxt->atts;
+    int nbatts = 0;
+    int maxatts = ctxt->maxatts;
+    int meta = 0;
+    int i;
+
+    if (CUR != '<') return;
+    NEXT;
+
+    GROW;
+    name = htmlParseHTMLName(ctxt);
+    if (name == NULL) {
+	htmlParseErr(ctxt, XML_ERR_NAME_REQUIRED,
+	             "htmlParseStartTag: invalid element name\n",
+		     NULL, NULL);
+	/* Dump the bogus tag like browsers do */
+	while ((IS_CHAR_CH(CUR)) && (CUR != '>'))
+	    NEXT;
+        return;
+    }
+    if (xmlStrEqual(name, BAD_CAST"meta"))
+	meta = 1;
+
+    /*
+     * Check for auto-closure of HTML elements.
+     */
+    htmlAutoClose(ctxt, name);
+
+    /*
+     * Check for implied HTML elements.
+     */
+    htmlCheckImplied(ctxt, name);
+
+    /*
+     * Avoid html at any level > 0, head at any level != 1
+     * or any attempt to recurse body
+     */
+    if ((ctxt->nameNr > 0) && (xmlStrEqual(name, BAD_CAST"html"))) {
+	htmlParseErr(ctxt, XML_HTML_STRUCURE_ERROR,
+	             "htmlParseStartTag: misplaced <html> tag\n",
+		     name, NULL);
+	return;
+    }
+    if ((ctxt->nameNr != 1) && 
+	(xmlStrEqual(name, BAD_CAST"head"))) {
+	htmlParseErr(ctxt, XML_HTML_STRUCURE_ERROR,
+	             "htmlParseStartTag: misplaced <head> tag\n",
+		     name, NULL);
+	return;
+    }
+    if (xmlStrEqual(name, BAD_CAST"body")) {
+	int indx;
+	for (indx = 0;indx < ctxt->nameNr;indx++) {
+	    if (xmlStrEqual(ctxt->nameTab[indx], BAD_CAST"body")) {
+		htmlParseErr(ctxt, XML_HTML_STRUCURE_ERROR,
+		             "htmlParseStartTag: misplaced <body> tag\n",
+			     name, NULL);
+		while ((IS_CHAR_CH(CUR)) && (CUR != '>'))
+		    NEXT;
+		return;
+	    }
+	}
+    }
+
+    /*
+     * Now parse the attributes, it ends up with the ending
+     *
+     * (S Attribute)* S?
+     */
+    SKIP_BLANKS;
+    while ((IS_CHAR_CH(CUR)) &&
+           (CUR != '>') && 
+	   ((CUR != '/') || (NXT(1) != '>'))) {
+	long cons = ctxt->nbChars;
+
+	GROW;
+	attname = htmlParseAttribute(ctxt, &attvalue);
+        if (attname != NULL) {
+
+	    /*
+	     * Well formedness requires at most one declaration of an attribute
+	     */
+	    for (i = 0; i < nbatts;i += 2) {
+	        if (xmlStrEqual(atts[i], attname)) {
+		    htmlParseErr(ctxt, XML_ERR_ATTRIBUTE_REDEFINED,
+		                 "Attribute %s redefined\n", attname, NULL);
+		    if (attvalue != NULL)
+			xmlFree(attvalue);
+		    goto failed;
+		}
+	    }
+
+	    /*
+	     * Add the pair to atts
+	     */
+	    if (atts == NULL) {
+	        maxatts = 22; /* allow for 10 attrs by default */
+	        atts = (const xmlChar **)
+		       xmlMalloc(maxatts * sizeof(xmlChar *));
+		if (atts == NULL) {
+		    htmlErrMemory(ctxt, NULL);
+		    if (attvalue != NULL)
+			xmlFree(attvalue);
+		    goto failed;
+		}
+		ctxt->atts = atts;
+		ctxt->maxatts = maxatts;
+	    } else if (nbatts + 4 > maxatts) {
+	        const xmlChar **n;
+
+	        maxatts *= 2;
+	        n = (const xmlChar **) xmlRealloc((void *) atts,
+					     maxatts * sizeof(const xmlChar *));
+		if (n == NULL) {
+		    htmlErrMemory(ctxt, NULL);
+		    if (attvalue != NULL)
+			xmlFree(attvalue);
+		    goto failed;
+		}
+		atts = n;
+		ctxt->atts = atts;
+		ctxt->maxatts = maxatts;
+	    }
+	    atts[nbatts++] = attname;
+	    atts[nbatts++] = attvalue;
+	    atts[nbatts] = NULL;
+	    atts[nbatts + 1] = NULL;
+	}
+	else {
+	    if (attvalue != NULL)
+	        xmlFree(attvalue);
+	    /* Dump the bogus attribute string up to the next blank or
+	     * the end of the tag. */
+	    while ((IS_CHAR_CH(CUR)) &&
+	           !(IS_BLANK_CH(CUR)) && (CUR != '>') &&
+		   ((CUR != '/') || (NXT(1) != '>')))
+		NEXT;
+	}
+
+failed:
+	SKIP_BLANKS;
+        if (cons == ctxt->nbChars) {
+	    htmlParseErr(ctxt, XML_ERR_INTERNAL_ERROR,
+	                 "htmlParseStartTag: problem parsing attributes\n",
+			 NULL, NULL);
+	    break;
+	}
+    }
+
+    /*
+     * Handle specific association to the META tag
+     */
+    if (meta)
+	htmlCheckMeta(ctxt, atts);
+
+    /*
+     * SAX: Start of Element !
+     */
+    htmlnamePush(ctxt, name);
+    if ((ctxt->sax != NULL) && (ctxt->sax->startElement != NULL)) {
+	if (nbatts != 0)
+            ctxt->sax->startElement(ctxt->userData, name, atts);
+	else
+            ctxt->sax->startElement(ctxt->userData, name, NULL);
+    }
+
+    if (atts != NULL) {
+        for (i = 1;i < nbatts;i += 2) {
+	    if (atts[i] != NULL)
+		xmlFree((xmlChar *) atts[i]);
+	}
+    }
+}
+
+/**
+ * htmlParseEndTag:
+ * @ctxt:  an HTML parser context
+ *
+ * parse an end of tag
+ *
+ * [42] ETag ::= '</' Name S? '>'
+ *
+ * With namespace
+ *
+ * [NS 9] ETag ::= '</' QName S? '>'
+ *
+ * Returns 1 if the current level should be closed.
+ */
+
+static int
+htmlParseEndTag(htmlParserCtxtPtr ctxt)
+{
+    const xmlChar *name;
+    const xmlChar *oldname;
+    int i, ret;
+
+    if ((CUR != '<') || (NXT(1) != '/')) {
+        htmlParseErr(ctxt, XML_ERR_LTSLASH_REQUIRED,
+	             "htmlParseEndTag: '</' not found\n", NULL, NULL);
+        return (0);
+    }
+    SKIP(2);
+
+    name = htmlParseHTMLName(ctxt);
+    if (name == NULL)
+        return (0);
+
+    /*
+     * We should definitely be at the ending "S? '>'" part
+     */
+    SKIP_BLANKS;
+    if ((!IS_CHAR_CH(CUR)) || (CUR != '>')) {
+        htmlParseErr(ctxt, XML_ERR_GT_REQUIRED,
+	             "End tag : expected '>'\n", NULL, NULL);
+    } else
+        NEXT;
+
+    /*
+     * If the name read is not one of the element in the parsing stack
+     * then return, it's just an error.
+     */
+    for (i = (ctxt->nameNr - 1); i >= 0; i--) {
+        if (xmlStrEqual(name, ctxt->nameTab[i]))
+            break;
+    }
+    if (i < 0) {
+        htmlParseErr(ctxt, XML_ERR_TAG_NAME_MISMATCH,
+	             "Unexpected end tag : %s\n", name, NULL);
+        return (0);
+    }
+
+
+    /*
+     * Check for auto-closure of HTML elements.
+     */
+
+    htmlAutoCloseOnClose(ctxt, name);
+
+    /*
+     * Well formedness constraints, opening and closing must match.
+     * With the exception that the autoclose may have popped stuff out
+     * of the stack.
+     */
+    if (!xmlStrEqual(name, ctxt->name)) {
+        if ((ctxt->name != NULL) && (!xmlStrEqual(ctxt->name, name))) {
+            htmlParseErr(ctxt, XML_ERR_TAG_NAME_MISMATCH,
+	                 "Opening and ending tag mismatch: %s and %s\n",
+			 name, ctxt->name);
+        }
+    }
+
+    /*
+     * SAX: End of Tag
+     */
+    oldname = ctxt->name;
+    if ((oldname != NULL) && (xmlStrEqual(oldname, name))) {
+        if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL))
+            ctxt->sax->endElement(ctxt->userData, name);
+        htmlnamePop(ctxt);
+        ret = 1;
+    } else {
+        ret = 0;
+    }
+
+    return (ret);
+}
+
+
+/**
+ * htmlParseReference:
+ * @ctxt:  an HTML parser context
+ * 
+ * parse and handle entity references in content,
+ * this will end-up in a call to character() since this is either a
+ * CharRef, or a predefined entity.
+ */
+static void
+htmlParseReference(htmlParserCtxtPtr ctxt) {
+    const htmlEntityDesc * ent;
+    xmlChar out[6];
+    const xmlChar *name;
+    if (CUR != '&') return;
+
+    if (NXT(1) == '#') {
+	unsigned int c;
+	int bits, i = 0;
+
+	c = htmlParseCharRef(ctxt);
+	if (c == 0)
+	    return;
+
+        if      (c <    0x80) { out[i++]= c;                bits= -6; }
+        else if (c <   0x800) { out[i++]=((c >>  6) & 0x1F) | 0xC0;  bits=  0; }
+        else if (c < 0x10000) { out[i++]=((c >> 12) & 0x0F) | 0xE0;  bits=  6; }
+        else                  { out[i++]=((c >> 18) & 0x07) | 0xF0;  bits= 12; }
+ 
+        for ( ; bits >= 0; bits-= 6) {
+            out[i++]= ((c >> bits) & 0x3F) | 0x80;
+        }
+	out[i] = 0;
+
+	htmlCheckParagraph(ctxt);
+	if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL))
+	    ctxt->sax->characters(ctxt->userData, out, i);
+    } else {
+	ent = htmlParseEntityRef(ctxt, &name);
+	if (name == NULL) {
+	    htmlCheckParagraph(ctxt);
+	    if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL))
+	        ctxt->sax->characters(ctxt->userData, BAD_CAST "&", 1);
+	    return;
+	}
+	if ((ent == NULL) || !(ent->value > 0)) {
+	    htmlCheckParagraph(ctxt);
+	    if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL)) {
+		ctxt->sax->characters(ctxt->userData, BAD_CAST "&", 1);
+		ctxt->sax->characters(ctxt->userData, name, xmlStrlen(name));
+		/* ctxt->sax->characters(ctxt->userData, BAD_CAST ";", 1); */
+	    }
+	} else {
+	    unsigned int c;
+	    int bits, i = 0;
+
+	    c = ent->value;
+	    if      (c <    0x80)
+	            { out[i++]= c;                bits= -6; }
+	    else if (c <   0x800)
+	            { out[i++]=((c >>  6) & 0x1F) | 0xC0;  bits=  0; }
+	    else if (c < 0x10000)
+	            { out[i++]=((c >> 12) & 0x0F) | 0xE0;  bits=  6; }
+	    else                 
+	            { out[i++]=((c >> 18) & 0x07) | 0xF0;  bits= 12; }
+     
+	    for ( ; bits >= 0; bits-= 6) {
+		out[i++]= ((c >> bits) & 0x3F) | 0x80;
+	    }
+	    out[i] = 0;
+
+	    htmlCheckParagraph(ctxt);
+	    if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL))
+		ctxt->sax->characters(ctxt->userData, out, i);
+	}
+    }
+}
+
+/**
+ * htmlParseContent:
+ * @ctxt:  an HTML parser context
+ * @name:  the node name
+ *
+ * Parse a content: comment, sub-element, reference or text.
+ *
+ */
+
+static void
+htmlParseContent(htmlParserCtxtPtr ctxt) {
+    xmlChar *currentNode;
+    int depth;
+
+    currentNode = xmlStrdup(ctxt->name);
+    depth = ctxt->nameNr;
+    while (1) {
+	long cons = ctxt->nbChars;
+
+        GROW;
+	/*
+	 * Our tag or one of it's parent or children is ending.
+	 */
+        if ((CUR == '<') && (NXT(1) == '/')) {
+	    if (htmlParseEndTag(ctxt) &&
+		((currentNode != NULL) || (ctxt->nameNr == 0))) {
+		if (currentNode != NULL)
+		    xmlFree(currentNode);
+		return;
+	    }
+	    continue; /* while */
+        }
+
+	/*
+	 * Has this node been popped out during parsing of
+	 * the next element
+	 */
+        if ((ctxt->nameNr > 0) && (depth >= ctxt->nameNr) &&
+	    (!xmlStrEqual(currentNode, ctxt->name)))
+	     {
+	    if (currentNode != NULL) xmlFree(currentNode);
+	    return;
+	}
+
+	if ((CUR != 0) && ((xmlStrEqual(currentNode, BAD_CAST"script")) ||
+	    (xmlStrEqual(currentNode, BAD_CAST"style")))) {
+	    /*
+	     * Handle SCRIPT/STYLE separately
+	     */
+	    htmlParseScript(ctxt);
+	} else {
+	    /*
+	     * Sometimes DOCTYPE arrives in the middle of the document
+	     */
+	    if ((CUR == '<') && (NXT(1) == '!') &&
+		(UPP(2) == 'D') && (UPP(3) == 'O') &&
+		(UPP(4) == 'C') && (UPP(5) == 'T') &&
+		(UPP(6) == 'Y') && (UPP(7) == 'P') &&
+		(UPP(8) == 'E')) {
+		htmlParseErr(ctxt, XML_HTML_STRUCURE_ERROR,
+		             "Misplaced DOCTYPE declaration\n",
+			     BAD_CAST "DOCTYPE" , NULL);
+		htmlParseDocTypeDecl(ctxt);
+	    }
+
+	    /*
+	     * First case :  a comment
+	     */
+	    if ((CUR == '<') && (NXT(1) == '!') &&
+		(NXT(2) == '-') && (NXT(3) == '-')) {
+		htmlParseComment(ctxt);
+	    }
+
+	    /*
+	     * Second case :  a sub-element.
+	     */
+	    else if (CUR == '<') {
+		htmlParseElement(ctxt);
+	    }
+
+	    /*
+	     * Third case : a reference. If if has not been resolved,
+	     *    parsing returns it's Name, create the node 
+	     */
+	    else if (CUR == '&') {
+		htmlParseReference(ctxt);
+	    }
+
+	    /*
+	     * Fourth : end of the resource
+	     */
+	    else if (CUR == 0) {
+		htmlAutoCloseOnEnd(ctxt);
+		break;
+	    }
+
+	    /*
+	     * Last case, text. Note that References are handled directly.
+	     */
+	    else {
+		htmlParseCharData(ctxt);
+	    }
+
+	    if (cons == ctxt->nbChars) {
+		if (ctxt->node != NULL) {
+		    htmlParseErr(ctxt, XML_ERR_INTERNAL_ERROR,
+		                 "detected an error in element content\n",
+				 NULL, NULL);
+		}
+		break;
+	    }
+	}
+        GROW;
+    }
+    if (currentNode != NULL) xmlFree(currentNode);
+}
+
+/**
+ * htmlParseElement:
+ * @ctxt:  an HTML parser context
+ *
+ * parse an HTML element, this is highly recursive
+ *
+ * [39] element ::= EmptyElemTag | STag content ETag
+ *
+ * [41] Attribute ::= Name Eq AttValue
+ */
+
+void
+htmlParseElement(htmlParserCtxtPtr ctxt) {
+    const xmlChar *name;
+    xmlChar *currentNode = NULL;
+    const htmlElemDesc * info;
+    htmlParserNodeInfo node_info;
+    const xmlChar *oldname;
+    int depth = ctxt->nameNr;
+    const xmlChar *oldptr;
+
+    /* Capture start position */
+    if (ctxt->record_info) {
+        node_info.begin_pos = ctxt->input->consumed +
+                          (CUR_PTR - ctxt->input->base);
+	node_info.begin_line = ctxt->input->line;
+    }
+
+    oldname = ctxt->name;
+    htmlParseStartTag(ctxt);
+    name = ctxt->name;
+    if (((depth == ctxt->nameNr) && (xmlStrEqual(oldname, ctxt->name))) ||
+        (name == NULL)) {
+	if (CUR == '>')
+	    NEXT;
+        return;
+    }
+
+    /*
+     * Lookup the info for that element.
+     */
+    info = htmlTagLookup(name);
+    if (info == NULL) {
+	htmlParseErr(ctxt, XML_HTML_UNKNOWN_TAG,
+	             "Tag %s invalid\n", name, NULL);
+    }
+
+    /*
+     * Check for an Empty Element labeled the XML/SGML way
+     */
+    if ((CUR == '/') && (NXT(1) == '>')) {
+        SKIP(2);
+	if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL))
+	    ctxt->sax->endElement(ctxt->userData, name);
+	htmlnamePop(ctxt);
+	return;
+    }
+
+    if (CUR == '>') {
+        NEXT;
+    } else {
+	htmlParseErr(ctxt, XML_ERR_GT_REQUIRED,
+	             "Couldn't find end of Start Tag %s\n", name, NULL);
+
+	/*
+	 * end of parsing of this node.
+	 */
+	if (xmlStrEqual(name, ctxt->name)) { 
+	    nodePop(ctxt);
+	    htmlnamePop(ctxt);
+	}    
+
+	/*
+	 * Capture end position and add node
+	 */
+	if ( currentNode != NULL && ctxt->record_info ) {
+	   node_info.end_pos = ctxt->input->consumed +
+			      (CUR_PTR - ctxt->input->base);
+	   node_info.end_line = ctxt->input->line;
+	   node_info.node = ctxt->node;
+	   xmlParserAddNodeInfo(ctxt, &node_info);
+	}
+	return;
+    }
+
+    /*
+     * Check for an Empty Element from DTD definition
+     */
+    if ((info != NULL) && (info->empty)) {
+	if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL))
+	    ctxt->sax->endElement(ctxt->userData, name);
+	htmlnamePop(ctxt);
+	return;
+    }
+
+    /*
+     * Parse the content of the element:
+     */
+    currentNode = xmlStrdup(ctxt->name);
+    depth = ctxt->nameNr;
+    while (IS_CHAR_CH(CUR)) {
+	oldptr = ctxt->input->cur;
+	htmlParseContent(ctxt);
+	if (oldptr==ctxt->input->cur) break;
+	if (ctxt->nameNr < depth) break; 
+    }	
+
+    /*
+     * Capture end position and add node
+     */
+    if ( currentNode != NULL && ctxt->record_info ) {
+       node_info.end_pos = ctxt->input->consumed +
+                          (CUR_PTR - ctxt->input->base);
+       node_info.end_line = ctxt->input->line;
+       node_info.node = ctxt->node;
+       xmlParserAddNodeInfo(ctxt, &node_info);
+    }
+    if (!IS_CHAR_CH(CUR)) {
+	htmlAutoCloseOnEnd(ctxt);
+    }
+
+    if (currentNode != NULL)
+	xmlFree(currentNode);
+}
+
+/**
+ * htmlParseDocument:
+ * @ctxt:  an HTML parser context
+ * 
+ * parse an HTML document (and build a tree if using the standard SAX
+ * interface).
+ *
+ * Returns 0, -1 in case of error. the parser context is augmented
+ *                as a result of the parsing.
+ */
+
+int
+htmlParseDocument(htmlParserCtxtPtr ctxt) {
+    xmlDtdPtr dtd;
+
+    xmlInitParser();
+
+    htmlDefaultSAXHandlerInit();
+    ctxt->html = 1;
+
+    GROW;
+    /*
+     * SAX: beginning of the document processing.
+     */
+    if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
+        ctxt->sax->setDocumentLocator(ctxt->userData, &xmlDefaultSAXLocator);
+
+    /*
+     * Wipe out everything which is before the first '<'
+     */
+    SKIP_BLANKS;
+    if (CUR == 0) {
+	htmlParseErr(ctxt, XML_ERR_DOCUMENT_EMPTY, 
+	             "Document is empty\n", NULL, NULL);
+    }
+
+    if ((ctxt->sax) && (ctxt->sax->startDocument) && (!ctxt->disableSAX))
+	ctxt->sax->startDocument(ctxt->userData);
+
+
+    /*
+     * Parse possible comments before any content
+     */
+    while ((CUR == '<') && (NXT(1) == '!') &&
+           (NXT(2) == '-') && (NXT(3) == '-')) {
+        htmlParseComment(ctxt);	   
+	SKIP_BLANKS;
+    }	   
+
+
+    /*
+     * Then possibly doc type declaration(s) and more Misc
+     * (doctypedecl Misc*)?
+     */
+    if ((CUR == '<') && (NXT(1) == '!') &&
+	(UPP(2) == 'D') && (UPP(3) == 'O') &&
+	(UPP(4) == 'C') && (UPP(5) == 'T') &&
+	(UPP(6) == 'Y') && (UPP(7) == 'P') &&
+	(UPP(8) == 'E')) {
+	htmlParseDocTypeDecl(ctxt);
+    }
+    SKIP_BLANKS;
+
+    /*
+     * Parse possible comments before any content
+     */
+    while ((CUR == '<') && (NXT(1) == '!') &&
+           (NXT(2) == '-') && (NXT(3) == '-')) {
+        htmlParseComment(ctxt);	   
+	SKIP_BLANKS;
+    }	   
+
+    /*
+     * Time to start parsing the tree itself
+     */
+    htmlParseContent(ctxt);
+
+    /*
+     * autoclose
+     */
+    if (CUR == 0)
+	htmlAutoCloseOnEnd(ctxt);
+
+
+    /*
+     * SAX: end of the document processing.
+     */
+    if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
+        ctxt->sax->endDocument(ctxt->userData);
+
+    if (ctxt->myDoc != NULL) {
+	dtd = xmlGetIntSubset(ctxt->myDoc);
+	if (dtd == NULL)
+	    ctxt->myDoc->intSubset = 
+		xmlCreateIntSubset(ctxt->myDoc, BAD_CAST "html", 
+		    BAD_CAST "-//W3C//DTD HTML 4.0 Transitional//EN",
+		    BAD_CAST "http://www.w3.org/TR/REC-html40/loose.dtd");
+    }
+    if (! ctxt->wellFormed) return(-1);
+    return(0);
+}
+
+
+/************************************************************************
+ *									*
+ *			Parser contexts handling			*
+ *									*
+ ************************************************************************/
+
+/**
+ * htmlInitParserCtxt:
+ * @ctxt:  an HTML parser context
+ *
+ * Initialize a parser context
+ *
+ * Returns 0 in case of success and -1 in case of error
+ */
+
+static int
+htmlInitParserCtxt(htmlParserCtxtPtr ctxt)
+{
+    htmlSAXHandler *sax;
+
+    if (ctxt == NULL) return(-1);
+    memset(ctxt, 0, sizeof(htmlParserCtxt));
+
+    ctxt->dict = xmlDictCreate();
+    if (ctxt->dict == NULL) {
+        htmlErrMemory(NULL, "htmlInitParserCtxt: out of memory\n");
+	return(-1);
+    }
+    sax = (htmlSAXHandler *) xmlMalloc(sizeof(htmlSAXHandler));
+    if (sax == NULL) {
+        htmlErrMemory(NULL, "htmlInitParserCtxt: out of memory\n");
+	return(-1);
+    }
+    else
+        memset(sax, 0, sizeof(htmlSAXHandler));
+
+    /* Allocate the Input stack */
+    ctxt->inputTab = (htmlParserInputPtr *) 
+                      xmlMalloc(5 * sizeof(htmlParserInputPtr));
+    if (ctxt->inputTab == NULL) {
+        htmlErrMemory(NULL, "htmlInitParserCtxt: out of memory\n");
+	ctxt->inputNr = 0;
+	ctxt->inputMax = 0;
+	ctxt->input = NULL;
+	return(-1);
+    }
+    ctxt->inputNr = 0;
+    ctxt->inputMax = 5;
+    ctxt->input = NULL;
+    ctxt->version = NULL;
+    ctxt->encoding = NULL;
+    ctxt->standalone = -1;
+    ctxt->instate = XML_PARSER_START;
+
+    /* Allocate the Node stack */
+    ctxt->nodeTab = (htmlNodePtr *) xmlMalloc(10 * sizeof(htmlNodePtr));
+    if (ctxt->nodeTab == NULL) {
+        htmlErrMemory(NULL, "htmlInitParserCtxt: out of memory\n");
+	ctxt->nodeNr = 0;
+	ctxt->nodeMax = 0;
+	ctxt->node = NULL;
+	ctxt->inputNr = 0;
+	ctxt->inputMax = 0;
+	ctxt->input = NULL;
+	return(-1);
+    }
+    ctxt->nodeNr = 0;
+    ctxt->nodeMax = 10;
+    ctxt->node = NULL;
+
+    /* Allocate the Name stack */
+    ctxt->nameTab = (const xmlChar **) xmlMalloc(10 * sizeof(xmlChar *));
+    if (ctxt->nameTab == NULL) {
+        htmlErrMemory(NULL, "htmlInitParserCtxt: out of memory\n");
+	ctxt->nameNr = 0;
+	ctxt->nameMax = 10;
+	ctxt->name = NULL;
+	ctxt->nodeNr = 0;
+	ctxt->nodeMax = 0;
+	ctxt->node = NULL;
+	ctxt->inputNr = 0;
+	ctxt->inputMax = 0;
+	ctxt->input = NULL;
+	return(-1);
+    }
+    ctxt->nameNr = 0;
+    ctxt->nameMax = 10;
+    ctxt->name = NULL;
+
+    if (sax == NULL) ctxt->sax = (xmlSAXHandlerPtr) &htmlDefaultSAXHandler;
+    else {
+        ctxt->sax = sax;
+	memcpy(sax, &htmlDefaultSAXHandler, sizeof(xmlSAXHandlerV1));
+    }
+    ctxt->userData = ctxt;
+    ctxt->myDoc = NULL;
+    ctxt->wellFormed = 1;
+    ctxt->replaceEntities = 0;
+    ctxt->linenumbers = xmlLineNumbersDefaultValue;
+    ctxt->html = 1;
+    ctxt->vctxt.userData = ctxt;
+    ctxt->vctxt.error = xmlParserValidityError;
+    ctxt->vctxt.warning = xmlParserValidityWarning;
+    ctxt->record_info = 0;
+    ctxt->validate = 0;
+    ctxt->nbChars = 0;
+    ctxt->checkIndex = 0;
+    ctxt->catalogs = NULL;
+    xmlInitNodeInfoSeq(&ctxt->node_seq);
+    return(0);
+}
+
+/**
+ * htmlFreeParserCtxt:
+ * @ctxt:  an HTML parser context
+ *
+ * Free all the memory used by a parser context. However the parsed
+ * document in ctxt->myDoc is not freed.
+ */
+
+void
+htmlFreeParserCtxt(htmlParserCtxtPtr ctxt)
+{
+    xmlFreeParserCtxt(ctxt);
+}
+
+/**
+ * htmlNewParserCtxt:
+ *
+ * Allocate and initialize a new parser context.
+ *
+ * Returns the xmlParserCtxtPtr or NULL
+ */
+
+static htmlParserCtxtPtr
+htmlNewParserCtxt(void)
+{
+    xmlParserCtxtPtr ctxt;
+
+    ctxt = (xmlParserCtxtPtr) xmlMalloc(sizeof(xmlParserCtxt));
+    if (ctxt == NULL) {
+        htmlErrMemory(NULL, "NewParserCtxt: out of memory\n");
+	return(NULL);
+    }
+    memset(ctxt, 0, sizeof(xmlParserCtxt));
+    if (htmlInitParserCtxt(ctxt) < 0) {
+        htmlFreeParserCtxt(ctxt);
+	return(NULL);
+    }
+    return(ctxt);
+}
+
+/**
+ * htmlCreateMemoryParserCtxt:
+ * @buffer:  a pointer to a char array
+ * @size:  the size of the array
+ *
+ * Create a parser context for an HTML in-memory document.
+ *
+ * Returns the new parser context or NULL
+ */
+htmlParserCtxtPtr
+htmlCreateMemoryParserCtxt(const char *buffer, int size) {
+    xmlParserCtxtPtr ctxt;
+    xmlParserInputPtr input;
+    xmlParserInputBufferPtr buf;
+
+    if (buffer == NULL)
+	return(NULL);
+    if (size <= 0)
+	return(NULL);
+
+    ctxt = htmlNewParserCtxt();
+    if (ctxt == NULL)
+	return(NULL);
+
+    buf = xmlParserInputBufferCreateMem(buffer, size, XML_CHAR_ENCODING_NONE);
+    if (buf == NULL) return(NULL);
+
+    input = xmlNewInputStream(ctxt);
+    if (input == NULL) {
+	xmlFreeParserCtxt(ctxt);
+	return(NULL);
+    }
+
+    input->filename = NULL;
+    input->buf = buf;
+    input->base = input->buf->buffer->content;
+    input->cur = input->buf->buffer->content;
+    input->end = &input->buf->buffer->content[input->buf->buffer->use];
+
+    inputPush(ctxt, input);
+    return(ctxt);
+}
+
+/**
+ * htmlCreateDocParserCtxt:
+ * @cur:  a pointer to an array of xmlChar
+ * @encoding:  a free form C string describing the HTML document encoding, or NULL
+ *
+ * Create a parser context for an HTML document.
+ *
+ * TODO: check the need to add encoding handling there
+ *
+ * Returns the new parser context or NULL
+ */
+static htmlParserCtxtPtr
+htmlCreateDocParserCtxt(xmlChar *cur, const char *encoding ATTRIBUTE_UNUSED) {
+    int len;
+    htmlParserCtxtPtr ctxt;
+
+    if (cur == NULL)
+	return(NULL);
+    len = xmlStrlen(cur);
+    ctxt = htmlCreateMemoryParserCtxt((char *)cur, len);
+
+    if (encoding != NULL) {
+	xmlCharEncoding enc;
+	xmlCharEncodingHandlerPtr handler;
+
+	if (ctxt->input->encoding != NULL)
+	    xmlFree((xmlChar *) ctxt->input->encoding);
+	ctxt->input->encoding = xmlStrdup((const xmlChar *) encoding);
+
+	enc = xmlParseCharEncoding(encoding);
+	/*
+	 * registered set of known encodings
+	 */
+	if (enc != XML_CHAR_ENCODING_ERROR) {
+	    xmlSwitchEncoding(ctxt, enc);
+	    if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
+		htmlParseErr(ctxt, XML_ERR_UNSUPPORTED_ENCODING,
+		             "Unsupported encoding %s\n", 
+			     (const xmlChar *) encoding, NULL);
+	    }
+	} else {
+	    /*
+	     * fallback for unknown encodings
+	     */
+	    handler = xmlFindCharEncodingHandler((const char *) encoding);
+	    if (handler != NULL) {
+		xmlSwitchToEncoding(ctxt, handler);
+	    } else {
+		htmlParseErr(ctxt, XML_ERR_UNSUPPORTED_ENCODING,
+		             "Unsupported encoding %s\n",
+			     (const xmlChar *) encoding, NULL);
+	    }
+	}
+    }
+    return(ctxt);
+}
+
+#ifdef LIBXML_PUSH_ENABLED
+/************************************************************************
+ *									*
+ * 		Progressive parsing interfaces				*
+ *									*
+ ************************************************************************/
+
+/**
+ * htmlParseLookupSequence:
+ * @ctxt:  an HTML parser context
+ * @first:  the first char to lookup
+ * @next:  the next char to lookup or zero
+ * @third:  the next char to lookup or zero
+ * @comment: flag to force checking inside comments
+ *
+ * Try to find if a sequence (first, next, third) or  just (first next) or
+ * (first) is available in the input stream.
+ * This function has a side effect of (possibly) incrementing ctxt->checkIndex
+ * to avoid rescanning sequences of bytes, it DOES change the state of the
+ * parser, do not use liberally.
+ * This is basically similar to xmlParseLookupSequence()
+ *
+ * Returns the index to the current parsing point if the full sequence
+ *      is available, -1 otherwise.
+ */
+static int
+htmlParseLookupSequence(htmlParserCtxtPtr ctxt, xmlChar first,
+                        xmlChar next, xmlChar third, int iscomment) {
+    int base, len;
+    htmlParserInputPtr in;
+    const xmlChar *buf;
+    int incomment = 0;
+
+    in = ctxt->input;
+    if (in == NULL) return(-1);
+    base = in->cur - in->base;
+    if (base < 0) return(-1);
+    if (ctxt->checkIndex > base)
+        base = ctxt->checkIndex;
+    if (in->buf == NULL) {
+	buf = in->base;
+	len = in->length;
+    } else {
+	buf = in->buf->buffer->content;
+	len = in->buf->buffer->use;
+    }
+    /* take into account the sequence length */
+    if (third) len -= 2;
+    else if (next) len --;
+    for (;base < len;base++) {
+	if (!incomment && (base + 4 < len) && !iscomment) {
+	    if ((buf[base] == '<') && (buf[base + 1] == '!') &&
+		(buf[base + 2] == '-') && (buf[base + 3] == '-')) {
+		incomment = 1;
+		/* do not increment past <! - some people use <!--> */
+		base += 2;
+	    }
+	}
+	if (incomment) {
+	    if (base + 3 > len)
+		return(-1);
+	    if ((buf[base] == '-') && (buf[base + 1] == '-') &&
+		(buf[base + 2] == '>')) {
+		incomment = 0;
+		base += 2;
+	    }
+	    continue;
+	}
+        if (buf[base] == first) {
+	    if (third != 0) {
+		if ((buf[base + 1] != next) ||
+		    (buf[base + 2] != third)) continue;
+	    } else if (next != 0) {
+		if (buf[base + 1] != next) continue;
+	    }
+	    ctxt->checkIndex = 0;
+#ifdef DEBUG_PUSH
+	    if (next == 0)
+		xmlGenericError(xmlGenericErrorContext,
+			"HPP: lookup '%c' found at %d\n",
+			first, base);
+	    else if (third == 0)
+		xmlGenericError(xmlGenericErrorContext,
+			"HPP: lookup '%c%c' found at %d\n",
+			first, next, base);
+	    else 
+		xmlGenericError(xmlGenericErrorContext,
+			"HPP: lookup '%c%c%c' found at %d\n",
+			first, next, third, base);
+#endif
+	    return(base - (in->cur - in->base));
+	}
+    }
+    ctxt->checkIndex = base;
+#ifdef DEBUG_PUSH
+    if (next == 0)
+	xmlGenericError(xmlGenericErrorContext,
+		"HPP: lookup '%c' failed\n", first);
+    else if (third == 0)
+	xmlGenericError(xmlGenericErrorContext,
+		"HPP: lookup '%c%c' failed\n", first, next);
+    else	
+	xmlGenericError(xmlGenericErrorContext,
+		"HPP: lookup '%c%c%c' failed\n", first, next, third);
+#endif
+    return(-1);
+}
+
+/**
+ * htmlParseTryOrFinish:
+ * @ctxt:  an HTML parser context
+ * @terminate:  last chunk indicator
+ *
+ * Try to progress on parsing
+ *
+ * Returns zero if no parsing was possible
+ */
+static int
+htmlParseTryOrFinish(htmlParserCtxtPtr ctxt, int terminate) {
+    int ret = 0;
+    htmlParserInputPtr in;
+    int avail = 0;
+    xmlChar cur, next;
+
+#ifdef DEBUG_PUSH
+    switch (ctxt->instate) {
+	case XML_PARSER_EOF:
+	    xmlGenericError(xmlGenericErrorContext,
+		    "HPP: try EOF\n"); break;
+	case XML_PARSER_START:
+	    xmlGenericError(xmlGenericErrorContext,
+		    "HPP: try START\n"); break;
+	case XML_PARSER_MISC:
+	    xmlGenericError(xmlGenericErrorContext,
+		    "HPP: try MISC\n");break;
+	case XML_PARSER_COMMENT:
+	    xmlGenericError(xmlGenericErrorContext,
+		    "HPP: try COMMENT\n");break;
+	case XML_PARSER_PROLOG:
+	    xmlGenericError(xmlGenericErrorContext,
+		    "HPP: try PROLOG\n");break;
+	case XML_PARSER_START_TAG:
+	    xmlGenericError(xmlGenericErrorContext,
+		    "HPP: try START_TAG\n");break;
+	case XML_PARSER_CONTENT:
+	    xmlGenericError(xmlGenericErrorContext,
+		    "HPP: try CONTENT\n");break;
+	case XML_PARSER_CDATA_SECTION:
+	    xmlGenericError(xmlGenericErrorContext,
+		    "HPP: try CDATA_SECTION\n");break;
+	case XML_PARSER_END_TAG:
+	    xmlGenericError(xmlGenericErrorContext,
+		    "HPP: try END_TAG\n");break;
+	case XML_PARSER_ENTITY_DECL:
+	    xmlGenericError(xmlGenericErrorContext,
+		    "HPP: try ENTITY_DECL\n");break;
+	case XML_PARSER_ENTITY_VALUE:
+	    xmlGenericError(xmlGenericErrorContext,
+		    "HPP: try ENTITY_VALUE\n");break;
+	case XML_PARSER_ATTRIBUTE_VALUE:
+	    xmlGenericError(xmlGenericErrorContext,
+		    "HPP: try ATTRIBUTE_VALUE\n");break;
+	case XML_PARSER_DTD:
+	    xmlGenericError(xmlGenericErrorContext,
+		    "HPP: try DTD\n");break;
+	case XML_PARSER_EPILOG:
+	    xmlGenericError(xmlGenericErrorContext,
+		    "HPP: try EPILOG\n");break;
+	case XML_PARSER_PI:
+	    xmlGenericError(xmlGenericErrorContext,
+		    "HPP: try PI\n");break;
+	case XML_PARSER_SYSTEM_LITERAL:
+	    xmlGenericError(xmlGenericErrorContext,
+		    "HPP: try SYSTEM_LITERAL\n");break;
+    }
+#endif
+
+    while (1) {
+
+	in = ctxt->input;
+	if (in == NULL) break;
+	if (in->buf == NULL)
+	    avail = in->length - (in->cur - in->base);
+	else
+	    avail = in->buf->buffer->use - (in->cur - in->base);
+	if ((avail == 0) && (terminate)) {
+	    htmlAutoCloseOnEnd(ctxt);
+	    if ((ctxt->nameNr == 0) && (ctxt->instate != XML_PARSER_EOF)) { 
+		/*
+		 * SAX: end of the document processing.
+		 */
+		ctxt->instate = XML_PARSER_EOF;
+		if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
+		    ctxt->sax->endDocument(ctxt->userData);
+	    }
+	}
+        if (avail < 1)
+	    goto done;
+	cur = in->cur[0];
+	if (cur == 0) {
+	    SKIP(1);
+	    continue;
+	}
+
+        switch (ctxt->instate) {
+            case XML_PARSER_EOF:
+	        /*
+		 * Document parsing is done !
+		 */
+	        goto done;
+            case XML_PARSER_START:
+	        /*
+		 * Very first chars read from the document flow.
+		 */
+		cur = in->cur[0];
+		if (IS_BLANK_CH(cur)) {
+		    SKIP_BLANKS;
+		    if (in->buf == NULL)
+			avail = in->length - (in->cur - in->base);
+		    else
+			avail = in->buf->buffer->use - (in->cur - in->base);
+		}
+		if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
+		    ctxt->sax->setDocumentLocator(ctxt->userData,
+						  &xmlDefaultSAXLocator);
+		if ((ctxt->sax) && (ctxt->sax->startDocument) &&
+	            (!ctxt->disableSAX))
+		    ctxt->sax->startDocument(ctxt->userData);
+
+		cur = in->cur[0];
+		next = in->cur[1];
+		if ((cur == '<') && (next == '!') &&
+		    (UPP(2) == 'D') && (UPP(3) == 'O') &&
+		    (UPP(4) == 'C') && (UPP(5) == 'T') &&
+		    (UPP(6) == 'Y') && (UPP(7) == 'P') &&
+		    (UPP(8) == 'E')) {
+		    if ((!terminate) &&
+		        (htmlParseLookupSequence(ctxt, '>', 0, 0, 0) < 0))
+			goto done;
+#ifdef DEBUG_PUSH
+		    xmlGenericError(xmlGenericErrorContext,
+			    "HPP: Parsing internal subset\n");
+#endif
+		    htmlParseDocTypeDecl(ctxt);
+		    ctxt->instate = XML_PARSER_PROLOG;
+#ifdef DEBUG_PUSH
+		    xmlGenericError(xmlGenericErrorContext,
+			    "HPP: entering PROLOG\n");
+#endif
+                } else {
+		    ctxt->instate = XML_PARSER_MISC;
+		}
+#ifdef DEBUG_PUSH
+		xmlGenericError(xmlGenericErrorContext,
+			"HPP: entering MISC\n");
+#endif
+		break;
+            case XML_PARSER_MISC:
+		SKIP_BLANKS;
+		if (in->buf == NULL)
+		    avail = in->length - (in->cur - in->base);
+		else
+		    avail = in->buf->buffer->use - (in->cur - in->base);
+		if (avail < 2)
+		    goto done;
+		cur = in->cur[0];
+		next = in->cur[1];
+	        if ((cur == '<') && (next == '!') &&
+		    (in->cur[2] == '-') && (in->cur[3] == '-')) {
+		    if ((!terminate) &&
+		        (htmlParseLookupSequence(ctxt, '-', '-', '>', 1) < 0))
+			goto done;
+#ifdef DEBUG_PUSH
+		    xmlGenericError(xmlGenericErrorContext,
+			    "HPP: Parsing Comment\n");
+#endif
+		    htmlParseComment(ctxt);
+		    ctxt->instate = XML_PARSER_MISC;
+		} else if ((cur == '<') && (next == '!') &&
+		    (UPP(2) == 'D') && (UPP(3) == 'O') &&
+		    (UPP(4) == 'C') && (UPP(5) == 'T') &&
+		    (UPP(6) == 'Y') && (UPP(7) == 'P') &&
+		    (UPP(8) == 'E')) {
+		    if ((!terminate) &&
+		        (htmlParseLookupSequence(ctxt, '>', 0, 0, 0) < 0))
+			goto done;
+#ifdef DEBUG_PUSH
+		    xmlGenericError(xmlGenericErrorContext,
+			    "HPP: Parsing internal subset\n");
+#endif
+		    htmlParseDocTypeDecl(ctxt);
+		    ctxt->instate = XML_PARSER_PROLOG;
+#ifdef DEBUG_PUSH
+		    xmlGenericError(xmlGenericErrorContext,
+			    "HPP: entering PROLOG\n");
+#endif
+		} else if ((cur == '<') && (next == '!') &&
+		           (avail < 9)) {
+		    goto done;
+		} else {
+		    ctxt->instate = XML_PARSER_START_TAG;
+#ifdef DEBUG_PUSH
+		    xmlGenericError(xmlGenericErrorContext,
+			    "HPP: entering START_TAG\n");
+#endif
+		}
+		break;
+            case XML_PARSER_PROLOG:
+		SKIP_BLANKS;
+		if (in->buf == NULL)
+		    avail = in->length - (in->cur - in->base);
+		else
+		    avail = in->buf->buffer->use - (in->cur - in->base);
+		if (avail < 2) 
+		    goto done;
+		cur = in->cur[0];
+		next = in->cur[1];
+		if ((cur == '<') && (next == '!') &&
+		    (in->cur[2] == '-') && (in->cur[3] == '-')) {
+		    if ((!terminate) &&
+		        (htmlParseLookupSequence(ctxt, '-', '-', '>', 1) < 0))
+			goto done;
+#ifdef DEBUG_PUSH
+		    xmlGenericError(xmlGenericErrorContext,
+			    "HPP: Parsing Comment\n");
+#endif
+		    htmlParseComment(ctxt);
+		    ctxt->instate = XML_PARSER_PROLOG;
+		} else if ((cur == '<') && (next == '!') &&
+		           (avail < 4)) {
+		    goto done;
+		} else {
+		    ctxt->instate = XML_PARSER_START_TAG;
+#ifdef DEBUG_PUSH
+		    xmlGenericError(xmlGenericErrorContext,
+			    "HPP: entering START_TAG\n");
+#endif
+		}
+		break;
+            case XML_PARSER_EPILOG:
+		if (in->buf == NULL)
+		    avail = in->length - (in->cur - in->base);
+		else
+		    avail = in->buf->buffer->use - (in->cur - in->base);
+		if (avail < 1)
+		    goto done;
+		cur = in->cur[0];
+		if (IS_BLANK_CH(cur)) {
+		    htmlParseCharData(ctxt);
+		    goto done;
+		}
+		if (avail < 2)
+		    goto done;
+		next = in->cur[1];
+	        if ((cur == '<') && (next == '!') &&
+		    (in->cur[2] == '-') && (in->cur[3] == '-')) {
+		    if ((!terminate) &&
+		        (htmlParseLookupSequence(ctxt, '-', '-', '>', 1) < 0))
+			goto done;
+#ifdef DEBUG_PUSH
+		    xmlGenericError(xmlGenericErrorContext,
+			    "HPP: Parsing Comment\n");
+#endif
+		    htmlParseComment(ctxt);
+		    ctxt->instate = XML_PARSER_EPILOG;
+		} else if ((cur == '<') && (next == '!') &&
+		           (avail < 4)) {
+		    goto done;
+		} else {
+		    ctxt->errNo = XML_ERR_DOCUMENT_END;
+		    ctxt->wellFormed = 0;
+		    ctxt->instate = XML_PARSER_EOF;
+#ifdef DEBUG_PUSH
+		    xmlGenericError(xmlGenericErrorContext,
+			    "HPP: entering EOF\n");
+#endif
+		    if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
+			ctxt->sax->endDocument(ctxt->userData);
+		    goto done;
+		}
+		break;
+            case XML_PARSER_START_TAG: {
+	        const xmlChar *name, *oldname;
+		int depth = ctxt->nameNr;
+		const htmlElemDesc * info;
+
+		if (avail < 2)
+		    goto done;
+		cur = in->cur[0];
+	        if (cur != '<') {
+		    ctxt->instate = XML_PARSER_CONTENT;
+#ifdef DEBUG_PUSH
+		    xmlGenericError(xmlGenericErrorContext,
+			    "HPP: entering CONTENT\n");
+#endif
+		    break;
+		}
+		if (in->cur[1] == '/') {
+		    ctxt->instate = XML_PARSER_END_TAG;
+		    ctxt->checkIndex = 0;
+#ifdef DEBUG_PUSH
+		    xmlGenericError(xmlGenericErrorContext,
+			    "HPP: entering END_TAG\n");
+#endif
+		    break;
+		}
+		if ((!terminate) &&
+		    (htmlParseLookupSequence(ctxt, '>', 0, 0, 0) < 0))
+		    goto done;
+
+		oldname = ctxt->name;
+		htmlParseStartTag(ctxt);
+		name = ctxt->name;
+		if (((depth == ctxt->nameNr) &&
+		     (xmlStrEqual(oldname, ctxt->name))) ||
+		    (name == NULL)) {
+		    if (CUR == '>')
+			NEXT;
+		    break;
+		}
+
+		/*
+		 * Lookup the info for that element.
+		 */
+		info = htmlTagLookup(name);
+		if (info == NULL) {
+		    htmlParseErr(ctxt, XML_HTML_UNKNOWN_TAG,
+		                 "Tag %s invalid\n", name, NULL);
+		}
+
+		/*
+		 * Check for an Empty Element labeled the XML/SGML way
+		 */
+		if ((CUR == '/') && (NXT(1) == '>')) {
+		    SKIP(2);
+		    if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL))
+			ctxt->sax->endElement(ctxt->userData, name);
+		    oldname = htmlnamePop(ctxt);
+		    ctxt->instate = XML_PARSER_CONTENT;
+#ifdef DEBUG_PUSH
+		    xmlGenericError(xmlGenericErrorContext,
+			    "HPP: entering CONTENT\n");
+#endif
+		    break;
+		}
+
+		if (CUR == '>') {
+		    NEXT;
+		} else {
+		    htmlParseErr(ctxt, XML_ERR_GT_REQUIRED,
+		                 "Couldn't find end of Start Tag %s\n",
+				 name, NULL);
+
+		    /*
+		     * end of parsing of this node.
+		     */
+		    if (xmlStrEqual(name, ctxt->name)) { 
+			nodePop(ctxt);
+			oldname = htmlnamePop(ctxt);
+		    }    
+
+		    ctxt->instate = XML_PARSER_CONTENT;
+#ifdef DEBUG_PUSH
+		    xmlGenericError(xmlGenericErrorContext,
+			    "HPP: entering CONTENT\n");
+#endif
+		    break;
+		}
+
+		/*
+		 * Check for an Empty Element from DTD definition
+		 */
+		if ((info != NULL) && (info->empty)) {
+		    if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL))
+			ctxt->sax->endElement(ctxt->userData, name);
+		    oldname = htmlnamePop(ctxt);
+		}
+		ctxt->instate = XML_PARSER_CONTENT;
+#ifdef DEBUG_PUSH
+		xmlGenericError(xmlGenericErrorContext,
+			"HPP: entering CONTENT\n");
+#endif
+                break;
+	    }
+            case XML_PARSER_CONTENT: {
+		long cons;
+                /*
+		 * Handle preparsed entities and charRef
+		 */
+		if (ctxt->token != 0) {
+		    xmlChar chr[2] = { 0 , 0 } ;
+
+		    chr[0] = (xmlChar) ctxt->token;
+		    htmlCheckParagraph(ctxt);
+		    if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL))
+			ctxt->sax->characters(ctxt->userData, chr, 1);
+		    ctxt->token = 0;
+		    ctxt->checkIndex = 0;
+		}
+		if ((avail == 1) && (terminate)) {
+		    cur = in->cur[0];
+		    if ((cur != '<') && (cur != '&')) {
+			if (ctxt->sax != NULL) {
+			    if (IS_BLANK_CH(cur)) {
+				if (ctxt->sax->ignorableWhitespace != NULL)
+				    ctxt->sax->ignorableWhitespace(
+					    ctxt->userData, &cur, 1);
+			    } else {
+				htmlCheckParagraph(ctxt);
+				if (ctxt->sax->characters != NULL)
+				    ctxt->sax->characters(
+					    ctxt->userData, &cur, 1);
+			    }
+			}
+			ctxt->token = 0;
+			ctxt->checkIndex = 0;
+			in->cur++;
+			break;
+		    }
+		}
+		if (avail < 2)
+		    goto done;
+		cur = in->cur[0];
+		next = in->cur[1];
+		cons = ctxt->nbChars;
+		if ((xmlStrEqual(ctxt->name, BAD_CAST"script")) ||
+		    (xmlStrEqual(ctxt->name, BAD_CAST"style"))) {
+		    /*
+		     * Handle SCRIPT/STYLE separately
+		     */
+		    if ((!terminate) &&
+		        (htmlParseLookupSequence(ctxt, '<', '/', 0, 0) < 0))
+			goto done;
+		    htmlParseScript(ctxt);
+		    if ((cur == '<') && (next == '/')) {
+			ctxt->instate = XML_PARSER_END_TAG;
+			ctxt->checkIndex = 0;
+#ifdef DEBUG_PUSH
+			xmlGenericError(xmlGenericErrorContext,
+				"HPP: entering END_TAG\n");
+#endif
+			break;
+		    }
+		} else {
+		    /*
+		     * Sometimes DOCTYPE arrives in the middle of the document
+		     */
+		    if ((cur == '<') && (next == '!') &&
+			(UPP(2) == 'D') && (UPP(3) == 'O') &&
+			(UPP(4) == 'C') && (UPP(5) == 'T') &&
+			(UPP(6) == 'Y') && (UPP(7) == 'P') &&
+			(UPP(8) == 'E')) {
+			if ((!terminate) &&
+			    (htmlParseLookupSequence(ctxt, '>', 0, 0, 0) < 0))
+			    goto done;
+			htmlParseErr(ctxt, XML_HTML_STRUCURE_ERROR,
+			             "Misplaced DOCTYPE declaration\n",
+				     BAD_CAST "DOCTYPE" , NULL);
+			htmlParseDocTypeDecl(ctxt);
+		    } else if ((cur == '<') && (next == '!') &&
+			(in->cur[2] == '-') && (in->cur[3] == '-')) {
+			if ((!terminate) &&
+			    (htmlParseLookupSequence(
+			    		ctxt, '-', '-', '>', 1) < 0))
+			    goto done;
+#ifdef DEBUG_PUSH
+			xmlGenericError(xmlGenericErrorContext,
+				"HPP: Parsing Comment\n");
+#endif
+			htmlParseComment(ctxt);
+			ctxt->instate = XML_PARSER_CONTENT;
+		    } else if ((cur == '<') && (next == '!') && (avail < 4)) {
+			goto done;
+		    } else if ((cur == '<') && (next == '/')) {
+			ctxt->instate = XML_PARSER_END_TAG;
+			ctxt->checkIndex = 0;
+#ifdef DEBUG_PUSH
+			xmlGenericError(xmlGenericErrorContext,
+				"HPP: entering END_TAG\n");
+#endif
+			break;
+		    } else if (cur == '<') {
+			ctxt->instate = XML_PARSER_START_TAG;
+			ctxt->checkIndex = 0;
+#ifdef DEBUG_PUSH
+			xmlGenericError(xmlGenericErrorContext,
+				"HPP: entering START_TAG\n");
+#endif
+			break;
+		    } else if (cur == '&') {
+			if ((!terminate) &&
+			    (htmlParseLookupSequence(ctxt, ';', 0, 0, 0) < 0))
+			    goto done;
+#ifdef DEBUG_PUSH
+			xmlGenericError(xmlGenericErrorContext,
+				"HPP: Parsing Reference\n");
+#endif
+			/* TODO: check generation of subtrees if noent !!! */
+			htmlParseReference(ctxt);
+		    } else {
+		        /*
+			 * check that the text sequence is complete
+			 * before handing out the data to the parser
+			 * to avoid problems with erroneous end of
+			 * data detection.
+			 */
+			if ((!terminate) &&
+			    (htmlParseLookupSequence(ctxt, '<', 0, 0, 0) < 0))
+			    goto done;
+			ctxt->checkIndex = 0;
+#ifdef DEBUG_PUSH
+			xmlGenericError(xmlGenericErrorContext,
+				"HPP: Parsing char data\n");
+#endif
+			htmlParseCharData(ctxt);
+		    }
+		}
+		if (cons == ctxt->nbChars) {
+		    if (ctxt->node != NULL) {
+			htmlParseErr(ctxt, XML_ERR_INTERNAL_ERROR,
+			             "detected an error in element content\n",
+				     NULL, NULL);
+		    }
+		    NEXT;
+		    break;
+		}
+
+		break;
+	    }
+            case XML_PARSER_END_TAG:
+		if (avail < 2)
+		    goto done;
+		if ((!terminate) &&
+		    (htmlParseLookupSequence(ctxt, '>', 0, 0, 0) < 0))
+		    goto done;
+		htmlParseEndTag(ctxt);
+		if (ctxt->nameNr == 0) {
+		    ctxt->instate = XML_PARSER_EPILOG;
+		} else {
+		    ctxt->instate = XML_PARSER_CONTENT;
+		}
+		ctxt->checkIndex = 0;
+#ifdef DEBUG_PUSH
+		xmlGenericError(xmlGenericErrorContext,
+			"HPP: entering CONTENT\n");
+#endif
+	        break;
+            case XML_PARSER_CDATA_SECTION:
+		htmlParseErr(ctxt, XML_ERR_INTERNAL_ERROR,
+			"HPP: internal error, state == CDATA\n",
+			     NULL, NULL);
+		ctxt->instate = XML_PARSER_CONTENT;
+		ctxt->checkIndex = 0;
+#ifdef DEBUG_PUSH
+		xmlGenericError(xmlGenericErrorContext,
+			"HPP: entering CONTENT\n");
+#endif
+		break;
+            case XML_PARSER_DTD:
+		htmlParseErr(ctxt, XML_ERR_INTERNAL_ERROR,
+			"HPP: internal error, state == DTD\n",
+			     NULL, NULL);
+		ctxt->instate = XML_PARSER_CONTENT;
+		ctxt->checkIndex = 0;
+#ifdef DEBUG_PUSH
+		xmlGenericError(xmlGenericErrorContext,
+			"HPP: entering CONTENT\n");
+#endif
+		break;
+            case XML_PARSER_COMMENT:
+		htmlParseErr(ctxt, XML_ERR_INTERNAL_ERROR,
+			"HPP: internal error, state == COMMENT\n",
+			     NULL, NULL);
+		ctxt->instate = XML_PARSER_CONTENT;
+		ctxt->checkIndex = 0;
+#ifdef DEBUG_PUSH
+		xmlGenericError(xmlGenericErrorContext,
+			"HPP: entering CONTENT\n");
+#endif
+		break;
+            case XML_PARSER_PI:
+		htmlParseErr(ctxt, XML_ERR_INTERNAL_ERROR,
+			"HPP: internal error, state == PI\n",
+			     NULL, NULL);
+		ctxt->instate = XML_PARSER_CONTENT;
+		ctxt->checkIndex = 0;
+#ifdef DEBUG_PUSH
+		xmlGenericError(xmlGenericErrorContext,
+			"HPP: entering CONTENT\n");
+#endif
+		break;
+            case XML_PARSER_ENTITY_DECL:
+		htmlParseErr(ctxt, XML_ERR_INTERNAL_ERROR,
+			"HPP: internal error, state == ENTITY_DECL\n",
+			     NULL, NULL);
+		ctxt->instate = XML_PARSER_CONTENT;
+		ctxt->checkIndex = 0;
+#ifdef DEBUG_PUSH
+		xmlGenericError(xmlGenericErrorContext,
+			"HPP: entering CONTENT\n");
+#endif
+		break;
+            case XML_PARSER_ENTITY_VALUE:
+		htmlParseErr(ctxt, XML_ERR_INTERNAL_ERROR,
+			"HPP: internal error, state == ENTITY_VALUE\n",
+			     NULL, NULL);
+		ctxt->instate = XML_PARSER_CONTENT;
+		ctxt->checkIndex = 0;
+#ifdef DEBUG_PUSH
+		xmlGenericError(xmlGenericErrorContext,
+			"HPP: entering DTD\n");
+#endif
+		break;
+            case XML_PARSER_ATTRIBUTE_VALUE:
+		htmlParseErr(ctxt, XML_ERR_INTERNAL_ERROR,
+			"HPP: internal error, state == ATTRIBUTE_VALUE\n",
+			     NULL, NULL);
+		ctxt->instate = XML_PARSER_START_TAG;
+		ctxt->checkIndex = 0;
+#ifdef DEBUG_PUSH
+		xmlGenericError(xmlGenericErrorContext,
+			"HPP: entering START_TAG\n");
+#endif
+		break;
+	    case XML_PARSER_SYSTEM_LITERAL:
+		htmlParseErr(ctxt, XML_ERR_INTERNAL_ERROR,
+		    "HPP: internal error, state == XML_PARSER_SYSTEM_LITERAL\n",
+			     NULL, NULL);
+		ctxt->instate = XML_PARSER_CONTENT;
+		ctxt->checkIndex = 0;
+#ifdef DEBUG_PUSH
+		xmlGenericError(xmlGenericErrorContext,
+			"HPP: entering CONTENT\n");
+#endif
+		break;
+	    case XML_PARSER_IGNORE:
+		htmlParseErr(ctxt, XML_ERR_INTERNAL_ERROR,
+			"HPP: internal error, state == XML_PARSER_IGNORE\n",
+			     NULL, NULL);
+		ctxt->instate = XML_PARSER_CONTENT;
+		ctxt->checkIndex = 0;
+#ifdef DEBUG_PUSH
+		xmlGenericError(xmlGenericErrorContext,
+			"HPP: entering CONTENT\n");
+#endif
+		break;
+	    case XML_PARSER_PUBLIC_LITERAL:
+		htmlParseErr(ctxt, XML_ERR_INTERNAL_ERROR,
+			"HPP: internal error, state == XML_PARSER_LITERAL\n",
+			     NULL, NULL);
+		ctxt->instate = XML_PARSER_CONTENT;
+		ctxt->checkIndex = 0;
+#ifdef DEBUG_PUSH
+		xmlGenericError(xmlGenericErrorContext,
+			"HPP: entering CONTENT\n");
+#endif
+		break;
+
+	}
+    }
+done:    
+    if ((avail == 0) && (terminate)) {
+	htmlAutoCloseOnEnd(ctxt);
+	if ((ctxt->nameNr == 0) && (ctxt->instate != XML_PARSER_EOF)) { 
+	    /*
+	     * SAX: end of the document processing.
+	     */
+	    ctxt->instate = XML_PARSER_EOF;
+	    if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
+		ctxt->sax->endDocument(ctxt->userData);
+	}
+    }
+    if ((ctxt->myDoc != NULL) &&
+	((terminate) || (ctxt->instate == XML_PARSER_EOF) ||
+	 (ctxt->instate == XML_PARSER_EPILOG))) {
+	xmlDtdPtr dtd;
+	dtd = xmlGetIntSubset(ctxt->myDoc);
+	if (dtd == NULL)
+	    ctxt->myDoc->intSubset = 
+		xmlCreateIntSubset(ctxt->myDoc, BAD_CAST "html", 
+		    BAD_CAST "-//W3C//DTD HTML 4.0 Transitional//EN",
+		    BAD_CAST "http://www.w3.org/TR/REC-html40/loose.dtd");
+    }
+#ifdef DEBUG_PUSH
+    xmlGenericError(xmlGenericErrorContext, "HPP: done %d\n", ret);
+#endif
+    return(ret);
+}
+
+/**
+ * htmlParseChunk:
+ * @ctxt:  an HTML parser context
+ * @chunk:  an char array
+ * @size:  the size in byte of the chunk
+ * @terminate:  last chunk indicator
+ *
+ * Parse a Chunk of memory
+ *
+ * Returns zero if no error, the xmlParserErrors otherwise.
+ */
+int
+htmlParseChunk(htmlParserCtxtPtr ctxt, const char *chunk, int size,
+              int terminate) {
+    if ((size > 0) && (chunk != NULL) && (ctxt->input != NULL) &&
+        (ctxt->input->buf != NULL) && (ctxt->instate != XML_PARSER_EOF))  {
+	int base = ctxt->input->base - ctxt->input->buf->buffer->content;
+	int cur = ctxt->input->cur - ctxt->input->base;
+	
+	xmlParserInputBufferPush(ctxt->input->buf, size, chunk);	      
+	ctxt->input->base = ctxt->input->buf->buffer->content + base;
+	ctxt->input->cur = ctxt->input->base + cur;
+#ifdef DEBUG_PUSH
+	xmlGenericError(xmlGenericErrorContext, "HPP: pushed %d\n", size);
+#endif
+
+#if 0
+	if ((terminate) || (ctxt->input->buf->buffer->use > 80))
+	    htmlParseTryOrFinish(ctxt, terminate);
+#endif
+    } else if (ctxt->instate != XML_PARSER_EOF) {
+	if ((ctxt->input != NULL) && ctxt->input->buf != NULL) {
+	    xmlParserInputBufferPtr in = ctxt->input->buf;
+	    if ((in->encoder != NULL) && (in->buffer != NULL) &&
+		    (in->raw != NULL)) {
+		int nbchars;
+		    
+		nbchars = xmlCharEncInFunc(in->encoder, in->buffer, in->raw);
+		if (nbchars < 0) {
+		    htmlParseErr(ctxt, XML_ERR_INVALID_ENCODING,
+			         "encoder error\n", NULL, NULL);
+		    return(XML_ERR_INVALID_ENCODING);
+		}
+	    }
+	}
+    }
+    htmlParseTryOrFinish(ctxt, terminate);
+    if (terminate) {
+	if ((ctxt->instate != XML_PARSER_EOF) &&
+	    (ctxt->instate != XML_PARSER_EPILOG) &&
+	    (ctxt->instate != XML_PARSER_MISC)) {
+	    ctxt->errNo = XML_ERR_DOCUMENT_END;
+	    ctxt->wellFormed = 0;
+	} 
+	if (ctxt->instate != XML_PARSER_EOF) {
+	    if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
+		ctxt->sax->endDocument(ctxt->userData);
+	}
+	ctxt->instate = XML_PARSER_EOF;
+    }
+    return((xmlParserErrors) ctxt->errNo);	      
+}
+#endif /* LIBXML_PUSH_ENABLED */
+
+/************************************************************************
+ *									*
+ *			User entry points				*
+ *									*
+ ************************************************************************/
+
+/**
+ * htmlCreatePushParserCtxt:
+ * @sax:  a SAX handler
+ * @user_data:  The user data returned on SAX callbacks
+ * @chunk:  a pointer to an array of chars
+ * @size:  number of chars in the array
+ * @filename:  an optional file name or URI
+ * @enc:  an optional encoding
+ *
+ * Create a parser context for using the HTML parser in push mode
+ * The value of @filename is used for fetching external entities
+ * and error/warning reports.
+ *
+ * Returns the new parser context or NULL
+ */
+htmlParserCtxtPtr
+htmlCreatePushParserCtxt(htmlSAXHandlerPtr sax, void *user_data, 
+                         const char *chunk, int size, const char *filename,
+			 xmlCharEncoding enc) {
+    htmlParserCtxtPtr ctxt;
+    htmlParserInputPtr inputStream;
+    xmlParserInputBufferPtr buf;
+
+    xmlInitParser();
+
+    buf = xmlAllocParserInputBuffer(enc);
+    if (buf == NULL) return(NULL);
+
+    ctxt = htmlNewParserCtxt();
+    if (ctxt == NULL) {
+	xmlFreeParserInputBuffer(buf);
+	return(NULL);
+    }
+    if(enc==XML_CHAR_ENCODING_UTF8 || buf->encoder)
+	ctxt->charset=XML_CHAR_ENCODING_UTF8;
+    if (sax != NULL) {
+	if (ctxt->sax != (xmlSAXHandlerPtr) &htmlDefaultSAXHandler)
+	    xmlFree(ctxt->sax);
+	ctxt->sax = (htmlSAXHandlerPtr) xmlMalloc(sizeof(htmlSAXHandler));
+	if (ctxt->sax == NULL) {
+	    xmlFree(buf);
+	    xmlFree(ctxt);
+	    return(NULL);
+	}
+	memcpy(ctxt->sax, sax, sizeof(htmlSAXHandler));
+	if (user_data != NULL)
+	    ctxt->userData = user_data;
+    }	
+    if (filename == NULL) {
+	ctxt->directory = NULL;
+    } else {
+        ctxt->directory = xmlParserGetDirectory(filename);
+    }
+
+    inputStream = htmlNewInputStream(ctxt);
+    if (inputStream == NULL) {
+	xmlFreeParserCtxt(ctxt);
+	xmlFree(buf);
+	return(NULL);
+    }
+
+    if (filename == NULL)
+	inputStream->filename = NULL;
+    else
+	inputStream->filename = (char *)
+	    xmlCanonicPath((const xmlChar *) filename);
+    inputStream->buf = buf;
+    inputStream->base = inputStream->buf->buffer->content;
+    inputStream->cur = inputStream->buf->buffer->content;
+    inputStream->end = 
+	&inputStream->buf->buffer->content[inputStream->buf->buffer->use];
+
+    inputPush(ctxt, inputStream);
+
+    if ((size > 0) && (chunk != NULL) && (ctxt->input != NULL) &&
+        (ctxt->input->buf != NULL))  {	      
+	int base = ctxt->input->base - ctxt->input->buf->buffer->content;
+	int cur = ctxt->input->cur - ctxt->input->base;
+
+	xmlParserInputBufferPush(ctxt->input->buf, size, chunk);	      
+
+	ctxt->input->base = ctxt->input->buf->buffer->content + base;
+	ctxt->input->cur = ctxt->input->base + cur;
+	ctxt->input->end =
+	    &ctxt->input->buf->buffer->content[ctxt->input->buf->buffer->use];
+#ifdef DEBUG_PUSH
+	xmlGenericError(xmlGenericErrorContext, "HPP: pushed %d\n", size);
+#endif
+    }
+
+    return(ctxt);
+}
+
+/**
+ * htmlSAXParseDoc:
+ * @cur:  a pointer to an array of xmlChar
+ * @encoding:  a free form C string describing the HTML document encoding, or NULL
+ * @sax:  the SAX handler block
+ * @userData: if using SAX, this pointer will be provided on callbacks. 
+ *
+ * Parse an HTML in-memory document. If sax is not NULL, use the SAX callbacks
+ * to handle parse events. If sax is NULL, fallback to the default DOM
+ * behavior and return a tree.
+ * 
+ * Returns the resulting document tree unless SAX is NULL or the document is
+ *     not well formed.
+ */
+
+htmlDocPtr
+htmlSAXParseDoc(xmlChar *cur, const char *encoding, htmlSAXHandlerPtr sax, void *userData) {
+    htmlDocPtr ret;
+    htmlParserCtxtPtr ctxt;
+
+    xmlInitParser();
+
+    if (cur == NULL) return(NULL);
+
+
+    ctxt = htmlCreateDocParserCtxt(cur, encoding);
+    if (ctxt == NULL) return(NULL);
+    if (sax != NULL) { 
+        if (ctxt->sax != NULL) xmlFree (ctxt->sax);
+        ctxt->sax = sax;
+        ctxt->userData = userData;
+    }
+
+    htmlParseDocument(ctxt);
+    ret = ctxt->myDoc;
+    if (sax != NULL) {
+	ctxt->sax = NULL;
+	ctxt->userData = NULL;
+    }
+    htmlFreeParserCtxt(ctxt);
+    
+    return(ret);
+}
+
+/**
+ * htmlParseDoc:
+ * @cur:  a pointer to an array of xmlChar
+ * @encoding:  a free form C string describing the HTML document encoding, or NULL
+ *
+ * parse an HTML in-memory document and build a tree.
+ * 
+ * Returns the resulting document tree
+ */
+
+htmlDocPtr
+htmlParseDoc(xmlChar *cur, const char *encoding) {
+    return(htmlSAXParseDoc(cur, encoding, NULL, NULL));
+}
+
+
+/**
+ * htmlCreateFileParserCtxt:
+ * @filename:  the filename
+ * @encoding:  a free form C string describing the HTML document encoding, or NULL
+ *
+ * Create a parser context for a file content. 
+ * Automatic support for ZLIB/Compress compressed document is provided
+ * by default if found at compile-time.
+ *
+ * Returns the new parser context or NULL
+ */
+htmlParserCtxtPtr
+htmlCreateFileParserCtxt(const char *filename, const char *encoding)
+{
+    htmlParserCtxtPtr ctxt;
+    htmlParserInputPtr inputStream;
+    char *canonicFilename;
+    /* htmlCharEncoding enc; */
+    xmlChar *content, *content_line = (xmlChar *) "charset=";
+
+    ctxt = htmlNewParserCtxt();
+    if (ctxt == NULL) {
+	return(NULL);
+    }
+    canonicFilename = (char *) xmlCanonicPath((const xmlChar *) filename);
+    if (canonicFilename == NULL) {
+#ifdef LIBXML_SAX1_ENABLED
+	if (xmlDefaultSAXHandler.error != NULL) {
+	    xmlDefaultSAXHandler.error(NULL, "out of memory\n");
+	}
+#endif
+	xmlFreeParserCtxt(ctxt);
+	return(NULL);
+    }
+    
+    inputStream = xmlLoadExternalEntity(canonicFilename, NULL, ctxt);
+    xmlFree(canonicFilename);
+    if (inputStream == NULL) {
+	xmlFreeParserCtxt(ctxt);
+	return(NULL);
+    }
+
+    inputPush(ctxt, inputStream);
+
+    /* set encoding */
+    if (encoding) {
+        content = xmlMallocAtomic (xmlStrlen(content_line) + strlen(encoding) + 1);
+	if (content) {  
+	    strcpy ((char *)content, (char *)content_line);
+            strcat ((char *)content, (char *)encoding);
+            htmlCheckEncoding (ctxt, content);
+	    xmlFree (content);
+	}
+    }
+    
+    return(ctxt);
+}
+
+/**
+ * htmlSAXParseFile:
+ * @filename:  the filename
+ * @encoding:  a free form C string describing the HTML document encoding, or NULL
+ * @sax:  the SAX handler block
+ * @userData: if using SAX, this pointer will be provided on callbacks. 
+ *
+ * parse an HTML file and build a tree. Automatic support for ZLIB/Compress
+ * compressed document is provided by default if found at compile-time.
+ * It use the given SAX function block to handle the parsing callback.
+ * If sax is NULL, fallback to the default DOM tree building routines.
+ *
+ * Returns the resulting document tree unless SAX is NULL or the document is
+ *     not well formed.
+ */
+
+htmlDocPtr
+htmlSAXParseFile(const char *filename, const char *encoding, htmlSAXHandlerPtr sax, 
+                 void *userData) {
+    htmlDocPtr ret;
+    htmlParserCtxtPtr ctxt;
+    htmlSAXHandlerPtr oldsax = NULL;
+
+    xmlInitParser();
+
+    ctxt = htmlCreateFileParserCtxt(filename, encoding);
+    if (ctxt == NULL) return(NULL);
+    if (sax != NULL) {
+	oldsax = ctxt->sax;
+        ctxt->sax = sax;
+        ctxt->userData = userData;
+    }
+
+    htmlParseDocument(ctxt);
+
+    ret = ctxt->myDoc;
+    if (sax != NULL) {
+        ctxt->sax = oldsax;
+        ctxt->userData = NULL;
+    }
+    htmlFreeParserCtxt(ctxt);
+    
+    return(ret);
+}
+
+/**
+ * htmlParseFile:
+ * @filename:  the filename
+ * @encoding:  a free form C string describing the HTML document encoding, or NULL
+ *
+ * parse an HTML file and build a tree. Automatic support for ZLIB/Compress
+ * compressed document is provided by default if found at compile-time.
+ *
+ * Returns the resulting document tree
+ */
+
+htmlDocPtr
+htmlParseFile(const char *filename, const char *encoding) {
+    return(htmlSAXParseFile(filename, encoding, NULL, NULL));
+}
+
+/**
+ * htmlHandleOmittedElem:
+ * @val:  int 0 or 1 
+ *
+ * Set and return the previous value for handling HTML omitted tags.
+ *
+ * Returns the last value for 0 for no handling, 1 for auto insertion.
+ */
+
+int
+htmlHandleOmittedElem(int val) {
+    int old = htmlOmittedDefaultValue;
+
+    htmlOmittedDefaultValue = val;
+    return(old);
+}
+
+/**
+ * htmlElementAllowedHere:
+ * @parent: HTML parent element
+ * @elt: HTML element
+ *
+ * Checks whether an HTML element may be a direct child of a parent element.
+ * Note - doesn't check for deprecated elements
+ *
+ * Returns 1 if allowed; 0 otherwise.
+ */
+int
+htmlElementAllowedHere(const htmlElemDesc* parent, const xmlChar* elt) {
+  const char** p ;
+
+  if ( ! elt || ! parent || ! parent->subelts )
+	return 0 ;
+
+  for ( p = parent->subelts; *p; ++p )
+    if ( !xmlStrcmp((const xmlChar *)*p, elt) )
+      return 1 ;
+
+  return 0 ;
+}
+/**
+ * htmlElementStatusHere:
+ * @parent: HTML parent element
+ * @elt: HTML element
+ *
+ * Checks whether an HTML element may be a direct child of a parent element.
+ * and if so whether it is valid or deprecated.
+ *
+ * Returns one of HTML_VALID, HTML_DEPRECATED, HTML_INVALID
+ */
+htmlStatus
+htmlElementStatusHere(const htmlElemDesc* parent, const htmlElemDesc* elt) {
+  if ( ! parent || ! elt )
+    return HTML_INVALID ;
+  if ( ! htmlElementAllowedHere(parent, (const xmlChar*) elt->name ) )
+    return HTML_INVALID ;
+
+  return ( elt->dtd == 0 ) ? HTML_VALID : HTML_DEPRECATED ;
+}
+/**
+ * htmlAttrAllowed:
+ * @elt: HTML element
+ * @attr: HTML attribute
+ * @legacy: whether to allow deprecated attributes
+ *
+ * Checks whether an attribute is valid for an element
+ * Has full knowledge of Required and Deprecated attributes
+ *
+ * Returns one of HTML_REQUIRED, HTML_VALID, HTML_DEPRECATED, HTML_INVALID
+ */
+htmlStatus
+htmlAttrAllowed(const htmlElemDesc* elt, const xmlChar* attr, int legacy) {
+  const char** p ;
+
+  if ( !elt || ! attr )
+	return HTML_INVALID ;
+
+  if ( elt->attrs_req )
+    for ( p = elt->attrs_req; *p; ++p)
+      if ( !xmlStrcmp((const xmlChar*)*p, attr) )
+        return HTML_REQUIRED ;
+
+  if ( elt->attrs_opt )
+    for ( p = elt->attrs_opt; *p; ++p)
+      if ( !xmlStrcmp((const xmlChar*)*p, attr) )
+        return HTML_VALID ;
+
+  if ( legacy && elt->attrs_depr )
+    for ( p = elt->attrs_depr; *p; ++p)
+      if ( !xmlStrcmp((const xmlChar*)*p, attr) )
+        return HTML_DEPRECATED ;
+
+  return HTML_INVALID ;
+}
+/**
+ * htmlNodeStatus:
+ * @node: an htmlNodePtr in a tree
+ * @legacy: whether to allow deprecated elements (YES is faster here
+ *	for Element nodes)
+ *
+ * Checks whether the tree node is valid.  Experimental (the author
+ *     only uses the HTML enhancements in a SAX parser)
+ *
+ * Return: for Element nodes, a return from htmlElementAllowedHere (if
+ *	legacy allowed) or htmlElementStatusHere (otherwise).
+ *	for Attribute nodes, a return from htmlAttrAllowed
+ *	for other nodes, HTML_NA (no checks performed)
+ */
+htmlStatus
+htmlNodeStatus(const htmlNodePtr node, int legacy) {
+  if ( ! node )
+    return HTML_INVALID ;
+
+  switch ( node->type ) {
+    case XML_ELEMENT_NODE:
+      return legacy
+	? ( htmlElementAllowedHere (
+		htmlTagLookup(node->parent->name) , node->name
+		) ? HTML_VALID : HTML_INVALID )
+	: htmlElementStatusHere(
+		htmlTagLookup(node->parent->name) ,
+		htmlTagLookup(node->name) )
+	;
+    case XML_ATTRIBUTE_NODE:
+      return htmlAttrAllowed(
+	htmlTagLookup(node->parent->name) , node->name, legacy) ;
+    default: return HTML_NA ;
+  }
+}
+/************************************************************************
+ *									*
+ *	New set (2.6.0) of simpler and more flexible APIs		*
+ *									*
+ ************************************************************************/
+/**
+ * DICT_FREE:
+ * @str:  a string
+ *
+ * Free a string if it is not owned by the "dict" dictionnary in the
+ * current scope
+ */
+#define DICT_FREE(str)						\
+	if ((str) && ((!dict) || 				\
+	    (xmlDictOwns(dict, (const xmlChar *)(str)) == 0)))	\
+	    xmlFree((char *)(str));
+
+/**
+ * htmlCtxtReset:
+ * @ctxt: an HTML parser context
+ *
+ * Reset a parser context
+ */
+void
+htmlCtxtReset(htmlParserCtxtPtr ctxt)
+{
+    xmlParserInputPtr input;
+    xmlDictPtr dict = ctxt->dict;
+
+    while ((input = inputPop(ctxt)) != NULL) { /* Non consuming */
+        xmlFreeInputStream(input);
+    }
+    ctxt->inputNr = 0;
+    ctxt->input = NULL;
+
+    ctxt->spaceNr = 0;
+    ctxt->spaceTab[0] = -1;
+    ctxt->space = &ctxt->spaceTab[0];
+
+
+    ctxt->nodeNr = 0;
+    ctxt->node = NULL;
+
+    ctxt->nameNr = 0;
+    ctxt->name = NULL;
+
+    DICT_FREE(ctxt->version);
+    ctxt->version = NULL;
+    DICT_FREE(ctxt->encoding);
+    ctxt->encoding = NULL;
+    DICT_FREE(ctxt->directory);
+    ctxt->directory = NULL;
+    DICT_FREE(ctxt->extSubURI);
+    ctxt->extSubURI = NULL;
+    DICT_FREE(ctxt->extSubSystem);
+    ctxt->extSubSystem = NULL;
+    if (ctxt->myDoc != NULL)
+        xmlFreeDoc(ctxt->myDoc);
+    ctxt->myDoc = NULL;
+
+    ctxt->standalone = -1;
+    ctxt->hasExternalSubset = 0;
+    ctxt->hasPErefs = 0;
+    ctxt->html = 1;
+    ctxt->external = 0;
+    ctxt->instate = XML_PARSER_START;
+    ctxt->token = 0;
+
+    ctxt->wellFormed = 1;
+    ctxt->nsWellFormed = 1;
+    ctxt->valid = 1;
+    ctxt->vctxt.userData = ctxt;
+    ctxt->vctxt.error = xmlParserValidityError;
+    ctxt->vctxt.warning = xmlParserValidityWarning;
+    ctxt->record_info = 0;
+    ctxt->nbChars = 0;
+    ctxt->checkIndex = 0;
+    ctxt->inSubset = 0;
+    ctxt->errNo = XML_ERR_OK;
+    ctxt->depth = 0;
+    ctxt->charset = XML_CHAR_ENCODING_UTF8;
+    ctxt->catalogs = NULL;
+    xmlInitNodeInfoSeq(&ctxt->node_seq);
+
+    if (ctxt->attsDefault != NULL) {
+        xmlHashFree(ctxt->attsDefault, (xmlHashDeallocator) xmlFree);
+        ctxt->attsDefault = NULL;
+    }
+    if (ctxt->attsSpecial != NULL) {
+        xmlHashFree(ctxt->attsSpecial, NULL);
+        ctxt->attsSpecial = NULL;
+    }
+}
+
+/**
+ * htmlCtxtUseOptions:
+ * @ctxt: an HTML parser context
+ * @options:  a combination of htmlParserOption(s)
+ *
+ * Applies the options to the parser context
+ *
+ * Returns 0 in case of success, the set of unknown or unimplemented options
+ *         in case of error.
+ */
+int
+htmlCtxtUseOptions(htmlParserCtxtPtr ctxt, int options)
+{
+    if (options & HTML_PARSE_NOWARNING) {
+        ctxt->sax->warning = NULL;
+        ctxt->vctxt.warning = NULL;
+        options -= XML_PARSE_NOWARNING;
+	ctxt->options |= XML_PARSE_NOWARNING;
+    }
+    if (options & HTML_PARSE_NOERROR) {
+        ctxt->sax->error = NULL;
+        ctxt->vctxt.error = NULL;
+        ctxt->sax->fatalError = NULL;
+        options -= XML_PARSE_NOERROR;
+	ctxt->options |= XML_PARSE_NOERROR;
+    }
+    if (options & HTML_PARSE_PEDANTIC) {
+        ctxt->pedantic = 1;
+        options -= XML_PARSE_PEDANTIC;
+	ctxt->options |= XML_PARSE_PEDANTIC;
+    } else
+        ctxt->pedantic = 0;
+    if (options & XML_PARSE_NOBLANKS) {
+        ctxt->keepBlanks = 0;
+        ctxt->sax->ignorableWhitespace = xmlSAX2IgnorableWhitespace;
+        options -= XML_PARSE_NOBLANKS;
+	ctxt->options |= XML_PARSE_NOBLANKS;
+    } else
+        ctxt->keepBlanks = 1;
+    ctxt->dictNames = 0;
+    return (options);
+}
+
+/**
+ * htmlDoRead:
+ * @ctxt:  an HTML parser context
+ * @URL:  the base URL to use for the document
+ * @encoding:  the document encoding, or NULL
+ * @options:  a combination of htmlParserOption(s)
+ * @reuse:  keep the context for reuse
+ *
+ * Common front-end for the htmlRead functions
+ * 
+ * Returns the resulting document tree or NULL
+ */
+static htmlDocPtr
+htmlDoRead(htmlParserCtxtPtr ctxt, const char *URL, const char *encoding,
+          int options, int reuse)
+{
+    htmlDocPtr ret;
+    
+    htmlCtxtUseOptions(ctxt, options);
+    ctxt->html = 1;
+    if (encoding != NULL) {
+        xmlCharEncodingHandlerPtr hdlr;
+
+	hdlr = xmlFindCharEncodingHandler(encoding);
+	if (hdlr != NULL)
+	    xmlSwitchToEncoding(ctxt, hdlr);
+    }
+    if ((URL != NULL) && (ctxt->input != NULL) &&
+        (ctxt->input->filename == NULL))
+        ctxt->input->filename = (char *) xmlStrdup((const xmlChar *) URL);
+    htmlParseDocument(ctxt);
+    ret = ctxt->myDoc;
+    ctxt->myDoc = NULL;
+    if (!reuse) {
+        if ((ctxt->dictNames) &&
+	    (ret != NULL) &&
+	    (ret->dict == ctxt->dict))
+	    ctxt->dict = NULL;
+	xmlFreeParserCtxt(ctxt);
+    }
+    return (ret);
+}
+
+/**
+ * htmlReadDoc:
+ * @cur:  a pointer to a zero terminated string
+ * @URL:  the base URL to use for the document
+ * @encoding:  the document encoding, or NULL
+ * @options:  a combination of htmlParserOption(s)
+ *
+ * parse an XML in-memory document and build a tree.
+ * 
+ * Returns the resulting document tree
+ */
+htmlDocPtr
+htmlReadDoc(const xmlChar * cur, const char *URL, const char *encoding, int options)
+{
+    htmlParserCtxtPtr ctxt;
+
+    if (cur == NULL)
+        return (NULL);
+
+    ctxt = xmlCreateDocParserCtxt(cur);
+    if (ctxt == NULL)
+        return (NULL);
+    return (htmlDoRead(ctxt, URL, encoding, options, 0));
+}
+
+/**
+ * htmlReadFile:
+ * @filename:  a file or URL
+ * @encoding:  the document encoding, or NULL
+ * @options:  a combination of htmlParserOption(s)
+ *
+ * parse an XML file from the filesystem or the network.
+ * 
+ * Returns the resulting document tree
+ */
+htmlDocPtr
+htmlReadFile(const char *filename, const char *encoding, int options)
+{
+    htmlParserCtxtPtr ctxt;
+
+    ctxt = htmlCreateFileParserCtxt(filename, encoding);
+    if (ctxt == NULL)
+        return (NULL);
+    return (htmlDoRead(ctxt, NULL, NULL, options, 0));
+}
+
+/**
+ * htmlReadMemory:
+ * @buffer:  a pointer to a char array
+ * @size:  the size of the array
+ * @URL:  the base URL to use for the document
+ * @encoding:  the document encoding, or NULL
+ * @options:  a combination of htmlParserOption(s)
+ *
+ * parse an XML in-memory document and build a tree.
+ * 
+ * Returns the resulting document tree
+ */
+htmlDocPtr
+htmlReadMemory(const char *buffer, int size, const char *URL, const char *encoding, int options)
+{
+    htmlParserCtxtPtr ctxt;
+
+    ctxt = xmlCreateMemoryParserCtxt(buffer, size);
+    if (ctxt == NULL)
+        return (NULL);
+    return (htmlDoRead(ctxt, URL, encoding, options, 0));
+}
+
+/**
+ * htmlReadFd:
+ * @fd:  an open file descriptor
+ * @URL:  the base URL to use for the document
+ * @encoding:  the document encoding, or NULL
+ * @options:  a combination of htmlParserOption(s)
+ *
+ * parse an XML from a file descriptor and build a tree.
+ * 
+ * Returns the resulting document tree
+ */
+htmlDocPtr
+htmlReadFd(int fd, const char *URL, const char *encoding, int options)
+{
+    htmlParserCtxtPtr ctxt;
+    xmlParserInputBufferPtr input;
+    xmlParserInputPtr stream;
+
+    if (fd < 0)
+        return (NULL);
+
+    input = xmlParserInputBufferCreateFd(fd, XML_CHAR_ENCODING_NONE);
+    if (input == NULL)
+        return (NULL);
+    ctxt = xmlNewParserCtxt();
+    if (ctxt == NULL) {
+        xmlFreeParserInputBuffer(input);
+        return (NULL);
+    }
+    stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
+    if (stream == NULL) {
+        xmlFreeParserInputBuffer(input);
+	xmlFreeParserCtxt(ctxt);
+        return (NULL);
+    }
+    inputPush(ctxt, stream);
+    return (htmlDoRead(ctxt, URL, encoding, options, 0));
+}
+
+/**
+ * htmlReadIO:
+ * @ioread:  an I/O read function
+ * @ioclose:  an I/O close function
+ * @ioctx:  an I/O handler
+ * @URL:  the base URL to use for the document
+ * @encoding:  the document encoding, or NULL
+ * @options:  a combination of htmlParserOption(s)
+ *
+ * parse an HTML document from I/O functions and source and build a tree.
+ * 
+ * Returns the resulting document tree
+ */
+htmlDocPtr
+htmlReadIO(xmlInputReadCallback ioread, xmlInputCloseCallback ioclose,
+          void *ioctx, const char *URL, const char *encoding, int options)
+{
+    htmlParserCtxtPtr ctxt;
+    xmlParserInputBufferPtr input;
+    xmlParserInputPtr stream;
+
+    if (ioread == NULL)
+        return (NULL);
+
+    input = xmlParserInputBufferCreateIO(ioread, ioclose, ioctx,
+                                         XML_CHAR_ENCODING_NONE);
+    if (input == NULL)
+        return (NULL);
+    ctxt = xmlNewParserCtxt();
+    if (ctxt == NULL) {
+        xmlFreeParserInputBuffer(input);
+        return (NULL);
+    }
+    stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
+    if (stream == NULL) {
+        xmlFreeParserInputBuffer(input);
+	xmlFreeParserCtxt(ctxt);
+        return (NULL);
+    }
+    inputPush(ctxt, stream);
+    return (htmlDoRead(ctxt, URL, encoding, options, 0));
+}
+
+/**
+ * htmlCtxtReadDoc:
+ * @ctxt:  an HTML parser context
+ * @cur:  a pointer to a zero terminated string
+ * @URL:  the base URL to use for the document
+ * @encoding:  the document encoding, or NULL
+ * @options:  a combination of htmlParserOption(s)
+ *
+ * parse an XML in-memory document and build a tree.
+ * This reuses the existing @ctxt parser context
+ * 
+ * Returns the resulting document tree
+ */
+htmlDocPtr
+htmlCtxtReadDoc(htmlParserCtxtPtr ctxt, const xmlChar * cur,
+               const char *URL, const char *encoding, int options)
+{
+    xmlParserInputPtr stream;
+
+    if (cur == NULL)
+        return (NULL);
+    if (ctxt == NULL)
+        return (NULL);
+
+    htmlCtxtReset(ctxt);
+
+    stream = xmlNewStringInputStream(ctxt, cur);
+    if (stream == NULL) {
+        return (NULL);
+    }
+    inputPush(ctxt, stream);
+    return (htmlDoRead(ctxt, URL, encoding, options, 1));
+}
+
+/**
+ * htmlCtxtReadFile:
+ * @ctxt:  an HTML parser context
+ * @filename:  a file or URL
+ * @encoding:  the document encoding, or NULL
+ * @options:  a combination of htmlParserOption(s)
+ *
+ * parse an XML file from the filesystem or the network.
+ * This reuses the existing @ctxt parser context
+ * 
+ * Returns the resulting document tree
+ */
+htmlDocPtr
+htmlCtxtReadFile(htmlParserCtxtPtr ctxt, const char *filename,
+                const char *encoding, int options)
+{
+    xmlParserInputPtr stream;
+
+    if (filename == NULL)
+        return (NULL);
+    if (ctxt == NULL)
+        return (NULL);
+
+    htmlCtxtReset(ctxt);
+
+    stream = xmlNewInputFromFile(ctxt, filename);
+    if (stream == NULL) {
+        return (NULL);
+    }
+    inputPush(ctxt, stream);
+    return (htmlDoRead(ctxt, NULL, encoding, options, 1));
+}
+
+/**
+ * htmlCtxtReadMemory:
+ * @ctxt:  an HTML parser context
+ * @buffer:  a pointer to a char array
+ * @size:  the size of the array
+ * @URL:  the base URL to use for the document
+ * @encoding:  the document encoding, or NULL
+ * @options:  a combination of htmlParserOption(s)
+ *
+ * parse an XML in-memory document and build a tree.
+ * This reuses the existing @ctxt parser context
+ * 
+ * Returns the resulting document tree
+ */
+htmlDocPtr
+htmlCtxtReadMemory(htmlParserCtxtPtr ctxt, const char *buffer, int size,
+                  const char *URL, const char *encoding, int options)
+{
+    xmlParserInputBufferPtr input;
+    xmlParserInputPtr stream;
+
+    if (ctxt == NULL)
+        return (NULL);
+    if (buffer == NULL)
+        return (NULL);
+
+    htmlCtxtReset(ctxt);
+
+    input = xmlParserInputBufferCreateMem(buffer, size, XML_CHAR_ENCODING_NONE);
+    if (input == NULL) {
+	return(NULL);
+    }
+
+    stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
+    if (stream == NULL) {
+	xmlFreeParserInputBuffer(input);
+	return(NULL);
+    }
+
+    inputPush(ctxt, stream);
+    return (htmlDoRead(ctxt, URL, encoding, options, 1));
+}
+
+/**
+ * htmlCtxtReadFd:
+ * @ctxt:  an HTML parser context
+ * @fd:  an open file descriptor
+ * @URL:  the base URL to use for the document
+ * @encoding:  the document encoding, or NULL
+ * @options:  a combination of htmlParserOption(s)
+ *
+ * parse an XML from a file descriptor and build a tree.
+ * This reuses the existing @ctxt parser context
+ * 
+ * Returns the resulting document tree
+ */
+htmlDocPtr
+htmlCtxtReadFd(htmlParserCtxtPtr ctxt, int fd,
+              const char *URL, const char *encoding, int options)
+{
+    xmlParserInputBufferPtr input;
+    xmlParserInputPtr stream;
+
+    if (fd < 0)
+        return (NULL);
+    if (ctxt == NULL)
+        return (NULL);
+
+    htmlCtxtReset(ctxt);
+
+
+    input = xmlParserInputBufferCreateFd(fd, XML_CHAR_ENCODING_NONE);
+    if (input == NULL)
+        return (NULL);
+    stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
+    if (stream == NULL) {
+        xmlFreeParserInputBuffer(input);
+        return (NULL);
+    }
+    inputPush(ctxt, stream);
+    return (htmlDoRead(ctxt, URL, encoding, options, 1));
+}
+
+/**
+ * htmlCtxtReadIO:
+ * @ctxt:  an HTML parser context
+ * @ioread:  an I/O read function
+ * @ioclose:  an I/O close function
+ * @ioctx:  an I/O handler
+ * @URL:  the base URL to use for the document
+ * @encoding:  the document encoding, or NULL
+ * @options:  a combination of htmlParserOption(s)
+ *
+ * parse an HTML document from I/O functions and source and build a tree.
+ * This reuses the existing @ctxt parser context
+ * 
+ * Returns the resulting document tree
+ */
+htmlDocPtr
+htmlCtxtReadIO(htmlParserCtxtPtr ctxt, xmlInputReadCallback ioread,
+              xmlInputCloseCallback ioclose, void *ioctx,
+	      const char *URL,
+              const char *encoding, int options)
+{
+    xmlParserInputBufferPtr input;
+    xmlParserInputPtr stream;
+
+    if (ioread == NULL)
+        return (NULL);
+    if (ctxt == NULL)
+        return (NULL);
+
+    htmlCtxtReset(ctxt);
+
+    input = xmlParserInputBufferCreateIO(ioread, ioclose, ioctx,
+                                         XML_CHAR_ENCODING_NONE);
+    if (input == NULL)
+        return (NULL);
+    stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
+    if (stream == NULL) {
+        xmlFreeParserInputBuffer(input);
+        return (NULL);
+    }
+    inputPush(ctxt, stream);
+    return (htmlDoRead(ctxt, URL, encoding, options, 1));
+}
+
+#endif /* LIBXML_HTML_ENABLED */
diff --git a/src/libxml/src/HTMLtree.c b/src/libxml/src/HTMLtree.c
new file mode 100644
index 0000000..5724540
--- /dev/null
+++ b/src/libxml/src/HTMLtree.c
@@ -0,0 +1,1177 @@
+/*
+ * HTMLtree.c : implementation of access function for an HTML tree.
+ *
+ * See Copyright for the status of this software.
+ *
+ * daniel@veillard.com
+ */
+
+
+#define IN_LIBXML
+#include "libxml.h"
+#ifdef LIBXML_HTML_ENABLED
+
+#include <string.h> /* for memset() only ! */
+
+#ifdef HAVE_CTYPE_H
+#include <ctype.h>
+#endif
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+
+#include <libxml/xmlmemory.h>
+#include <libxml/HTMLparser.h>
+#include <libxml/HTMLtree.h>
+#include <libxml/entities.h>
+#include <libxml/valid.h>
+#include <libxml/xmlerror.h>
+#include <libxml/parserInternals.h>
+#include <libxml/globals.h>
+#include <libxml/uri.h>
+
+/************************************************************************
+ *									*
+ *   		Getting/Setting encoding meta tags			*
+ *									*
+ ************************************************************************/
+
+/**
+ * htmlGetMetaEncoding:
+ * @doc:  the document
+ * 
+ * Encoding definition lookup in the Meta tags
+ *
+ * Returns the current encoding as flagged in the HTML source
+ */
+const xmlChar *
+htmlGetMetaEncoding(htmlDocPtr doc) {
+    htmlNodePtr cur;
+    const xmlChar *content;
+    const xmlChar *encoding;
+
+    if (doc == NULL)
+	return(NULL);
+    cur = doc->children;
+
+    /*
+     * Search the html
+     */
+    while (cur != NULL) {
+	if ((cur->type == XML_ELEMENT_NODE) && (cur->name != NULL)) {
+	    if (xmlStrEqual(cur->name, BAD_CAST"html"))
+		break;
+	    if (xmlStrEqual(cur->name, BAD_CAST"head"))
+		goto found_head;
+	    if (xmlStrEqual(cur->name, BAD_CAST"meta"))
+		goto found_meta;
+	}
+	cur = cur->next;
+    }
+    if (cur == NULL)
+	return(NULL);
+    cur = cur->children;
+
+    /*
+     * Search the head
+     */
+    while (cur != NULL) {
+	if ((cur->type == XML_ELEMENT_NODE) && (cur->name != NULL)) {
+	    if (xmlStrEqual(cur->name, BAD_CAST"head"))
+		break;
+	    if (xmlStrEqual(cur->name, BAD_CAST"meta"))
+		goto found_meta;
+	}
+	cur = cur->next;
+    }
+    if (cur == NULL)
+	return(NULL);
+found_head:
+    cur = cur->children;
+
+    /*
+     * Search the meta elements
+     */
+found_meta:
+    while (cur != NULL) {
+	if ((cur->type == XML_ELEMENT_NODE) && (cur->name != NULL)) {
+	    if (xmlStrEqual(cur->name, BAD_CAST"meta")) {
+		xmlAttrPtr attr = cur->properties;
+		int http;
+		const xmlChar *value;
+
+		content = NULL;
+		http = 0;
+		while (attr != NULL) {
+		    if ((attr->children != NULL) &&
+		        (attr->children->type == XML_TEXT_NODE) &&
+		        (attr->children->next == NULL)) {
+			value = attr->children->content;
+			if ((!xmlStrcasecmp(attr->name, BAD_CAST"http-equiv"))
+			 && (!xmlStrcasecmp(value, BAD_CAST"Content-Type")))
+			    http = 1;
+			else if ((value != NULL)
+			 && (!xmlStrcasecmp(attr->name, BAD_CAST"content")))
+			    content = value;
+			if ((http != 0) && (content != NULL))
+			    goto found_content;
+		    }
+		    attr = attr->next;
+		}
+	    }
+	}
+	cur = cur->next;
+    }
+    return(NULL);
+
+found_content:
+    encoding = xmlStrstr(content, BAD_CAST"charset=");
+    if (encoding == NULL) 
+	encoding = xmlStrstr(content, BAD_CAST"Charset=");
+    if (encoding == NULL) 
+	encoding = xmlStrstr(content, BAD_CAST"CHARSET=");
+    if (encoding != NULL) {
+	encoding += 8;
+    } else {
+	encoding = xmlStrstr(content, BAD_CAST"charset =");
+	if (encoding == NULL) 
+	    encoding = xmlStrstr(content, BAD_CAST"Charset =");
+	if (encoding == NULL) 
+	    encoding = xmlStrstr(content, BAD_CAST"CHARSET =");
+	if (encoding != NULL)
+	    encoding += 9;
+    }
+    if (encoding != NULL) {
+	while ((*encoding == ' ') || (*encoding == '\t')) encoding++;
+    }
+    return(encoding);
+}
+
+/**
+ * htmlSetMetaEncoding:
+ * @doc:  the document
+ * @encoding:  the encoding string
+ * 
+ * Sets the current encoding in the Meta tags
+ * NOTE: this will not change the document content encoding, just
+ * the META flag associated.
+ *
+ * Returns 0 in case of success and -1 in case of error
+ */
+int
+htmlSetMetaEncoding(htmlDocPtr doc, const xmlChar *encoding) {
+    htmlNodePtr cur, meta;
+    const xmlChar *content;
+    char newcontent[100];
+
+
+    if (doc == NULL)
+	return(-1);
+
+    if (encoding != NULL) {
+	snprintf(newcontent, sizeof(newcontent), "text/html; charset=%s",
+                encoding);
+	newcontent[sizeof(newcontent) - 1] = 0;
+    }
+
+    cur = doc->children;
+
+    /*
+     * Search the html
+     */
+    while (cur != NULL) {
+	if ((cur->type == XML_ELEMENT_NODE) && (cur->name != NULL)) {
+	    if (xmlStrcasecmp(cur->name, BAD_CAST"html") == 0)
+		break;
+	    if (xmlStrcasecmp(cur->name, BAD_CAST"head") == 0)
+		goto found_head;
+	    if (xmlStrcasecmp(cur->name, BAD_CAST"meta") == 0)
+		goto found_meta;
+	}
+	cur = cur->next;
+    }
+    if (cur == NULL)
+	return(-1);
+    cur = cur->children;
+
+    /*
+     * Search the head
+     */
+    while (cur != NULL) {
+	if ((cur->type == XML_ELEMENT_NODE) && (cur->name != NULL)) {
+	    if (xmlStrcasecmp(cur->name, BAD_CAST"head") == 0)
+		break;
+	    if (xmlStrcasecmp(cur->name, BAD_CAST"meta") == 0)
+		goto found_meta;
+	}
+	cur = cur->next;
+    }
+    if (cur == NULL)
+	return(-1);
+found_head:
+    if (cur->children == NULL) {
+	if (encoding == NULL)
+	    return(0);
+	meta = xmlNewDocNode(doc, NULL, BAD_CAST"meta", NULL);
+	xmlAddChild(cur, meta);
+	xmlNewProp(meta, BAD_CAST"http-equiv", BAD_CAST"Content-Type");
+	xmlNewProp(meta, BAD_CAST"content", BAD_CAST newcontent);
+	return(0);
+    }
+    cur = cur->children;
+
+found_meta:
+    if (encoding != NULL) {
+	/*
+	 * Create a new Meta element with the right attributes
+	 */
+
+	meta = xmlNewDocNode(doc, NULL, BAD_CAST"meta", NULL);
+	xmlAddPrevSibling(cur, meta);
+	xmlNewProp(meta, BAD_CAST"http-equiv", BAD_CAST"Content-Type");
+	xmlNewProp(meta, BAD_CAST"content", BAD_CAST newcontent);
+    }
+
+    /*
+     * Search and destroy all the remaining the meta elements carrying
+     * encoding informations
+     */
+    while (cur != NULL) {
+	if ((cur->type == XML_ELEMENT_NODE) && (cur->name != NULL)) {
+	    if (xmlStrcasecmp(cur->name, BAD_CAST"meta") == 0) {
+		xmlAttrPtr attr = cur->properties;
+		int http;
+		const xmlChar *value;
+
+		content = NULL;
+		http = 0;
+		while (attr != NULL) {
+		    if ((attr->children != NULL) &&
+		        (attr->children->type == XML_TEXT_NODE) &&
+		        (attr->children->next == NULL)) {
+			value = attr->children->content;
+			if ((!xmlStrcasecmp(attr->name, BAD_CAST"http-equiv"))
+			 && (!xmlStrcasecmp(value, BAD_CAST"Content-Type")))
+			    http = 1;
+			else 
+                        {
+                           if ((value != NULL) && 
+				(!xmlStrcasecmp(attr->name, BAD_CAST"content")))
+			      content = value;
+                        }
+		        if ((http != 0) && (content != NULL))
+			    break;
+		    }
+		    attr = attr->next;
+		}
+		if ((http != 0) && (content != NULL)) {
+		    meta = cur;
+		    cur = cur->next;
+		    xmlUnlinkNode(meta);
+                    xmlFreeNode(meta);
+		    continue;
+		}
+
+	    }
+	}
+	cur = cur->next;
+    }
+    return(0);
+}
+
+/**
+ * booleanHTMLAttrs:
+ *
+ * These are the HTML attributes which will be output
+ * in minimized form, i.e. <option selected="selected"> will be
+ * output as <option selected>, as per XSLT 1.0 16.2 "HTML Output Method"
+ *
+ */
+static const char* htmlBooleanAttrs[] = {
+  "checked", "compact", "declare", "defer", "disabled", "ismap",
+  "multiple", "nohref", "noresize", "noshade", "nowrap", "readonly",
+  "selected", NULL
+};
+
+
+/**
+ * htmlIsBooleanAttr:
+ * @name:  the name of the attribute to check
+ *
+ * Determine if a given attribute is a boolean attribute.
+ * 
+ * returns: false if the attribute is not boolean, true otherwise.
+ */
+int
+htmlIsBooleanAttr(const xmlChar *name)
+{
+    int i = 0;
+
+    while (htmlBooleanAttrs[i] != NULL) {
+        if (xmlStrcasecmp((const xmlChar *)htmlBooleanAttrs[i], name) == 0)
+            return 1;
+        i++;
+    }
+    return 0;
+}
+
+#ifdef LIBXML_OUTPUT_ENABLED
+/************************************************************************
+ *									*
+ * 			Output error handlers				*
+ *									*
+ ************************************************************************/
+/**
+ * htmlSaveErrMemory:
+ * @extra:  extra informations
+ *
+ * Handle an out of memory condition
+ */
+static void
+htmlSaveErrMemory(const char *extra)
+{
+    __xmlSimpleError(XML_FROM_OUTPUT, XML_ERR_NO_MEMORY, NULL, NULL, extra);
+}
+
+/**
+ * htmlSaveErr:
+ * @code:  the error number
+ * @node:  the location of the error.
+ * @extra:  extra informations
+ *
+ * Handle an out of memory condition
+ */
+static void
+htmlSaveErr(int code, xmlNodePtr node, const char *extra)
+{
+    const char *msg = NULL;
+
+    switch(code) {
+        case XML_SAVE_NOT_UTF8:
+	    msg = "string is not in UTF-8";
+	    break;
+	case XML_SAVE_CHAR_INVALID:
+	    msg = "invalid character value";
+	    break;
+	case XML_SAVE_UNKNOWN_ENCODING:
+	    msg = "unknown encoding %s";
+	    break;
+	case XML_SAVE_NO_DOCTYPE:
+	    msg = "HTML has no DOCTYPE";
+	    break;
+	default:
+	    msg = "unexpected error number";
+    }
+    __xmlSimpleError(XML_FROM_OUTPUT, code, node, msg, extra);
+}
+
+/************************************************************************
+ *									*
+ *   		Dumping HTML tree content to a simple buffer		*
+ *									*
+ ************************************************************************/
+
+static int
+htmlNodeDumpFormat(xmlBufferPtr buf, xmlDocPtr doc, xmlNodePtr cur,
+	           int format);
+
+/**
+ * htmlNodeDumpFormat:
+ * @buf:  the HTML buffer output
+ * @doc:  the document
+ * @cur:  the current node
+ * @format:  should formatting spaces been added
+ *
+ * Dump an HTML node, recursive behaviour,children are printed too.
+ *
+ * Returns the number of byte written or -1 in case of error
+ */
+static int
+htmlNodeDumpFormat(xmlBufferPtr buf, xmlDocPtr doc, xmlNodePtr cur,
+	           int format) {
+    unsigned int use;
+    int ret;
+    xmlOutputBufferPtr outbuf;
+
+    if (cur == NULL) {
+	return (-1);
+    }
+    if (buf == NULL) {
+	return (-1);
+    }
+    outbuf = (xmlOutputBufferPtr) xmlMalloc(sizeof(xmlOutputBuffer));
+    if (outbuf == NULL) {
+        htmlSaveErrMemory("allocating HTML output buffer");
+	return (-1);
+    }
+    memset(outbuf, 0, (size_t) sizeof(xmlOutputBuffer));
+    outbuf->buffer = buf;
+    outbuf->encoder = NULL;
+    outbuf->writecallback = NULL;
+    outbuf->closecallback = NULL;
+    outbuf->context = NULL;
+    outbuf->written = 0;
+
+    use = buf->use;
+    htmlNodeDumpFormatOutput(outbuf, doc, cur, NULL, format);
+    xmlFree(outbuf);
+    ret = buf->use - use;
+    return (ret);
+}
+
+/**
+ * htmlNodeDump:
+ * @buf:  the HTML buffer output
+ * @doc:  the document
+ * @cur:  the current node
+ *
+ * Dump an HTML node, recursive behaviour,children are printed too,
+ * and formatting returns are added.
+ *
+ * Returns the number of byte written or -1 in case of error
+ */
+int
+htmlNodeDump(xmlBufferPtr buf, xmlDocPtr doc, xmlNodePtr cur) {
+    xmlInitParser();
+
+    return(htmlNodeDumpFormat(buf, doc, cur, 1));
+}
+
+/**
+ * htmlNodeDumpFileFormat:
+ * @out:  the FILE pointer
+ * @doc:  the document
+ * @cur:  the current node
+ * @encoding: the document encoding
+ * @format:  should formatting spaces been added
+ *
+ * Dump an HTML node, recursive behaviour,children are printed too.
+ *
+ * TODO: if encoding == NULL try to save in the doc encoding
+ *
+ * returns: the number of byte written or -1 in case of failure.
+ */
+int
+htmlNodeDumpFileFormat(FILE *out, xmlDocPtr doc,
+	               xmlNodePtr cur, const char *encoding, int format) {
+    xmlOutputBufferPtr buf;
+    xmlCharEncodingHandlerPtr handler = NULL;
+    int ret;
+
+    xmlInitParser();
+
+    if (encoding != NULL) {
+	xmlCharEncoding enc;
+
+	enc = xmlParseCharEncoding(encoding);
+	if (enc != XML_CHAR_ENCODING_UTF8) {
+	    handler = xmlFindCharEncodingHandler(encoding);
+	    if (handler == NULL)
+		return(-1);
+	}
+    }
+
+    /*
+     * Fallback to HTML or ASCII when the encoding is unspecified
+     */
+    if (handler == NULL)
+	handler = xmlFindCharEncodingHandler("HTML");
+    if (handler == NULL)
+	handler = xmlFindCharEncodingHandler("ascii");
+
+    /* 
+     * save the content to a temp buffer.
+     */
+    buf = xmlOutputBufferCreateFile(out, handler);
+    if (buf == NULL) return(0);
+
+    htmlNodeDumpFormatOutput(buf, doc, cur, encoding, format);
+
+    ret = xmlOutputBufferClose(buf);
+    return(ret);
+}
+
+/**
+ * htmlNodeDumpFile:
+ * @out:  the FILE pointer
+ * @doc:  the document
+ * @cur:  the current node
+ *
+ * Dump an HTML node, recursive behaviour,children are printed too,
+ * and formatting returns are added.
+ */
+void
+htmlNodeDumpFile(FILE *out, xmlDocPtr doc, xmlNodePtr cur) {
+    htmlNodeDumpFileFormat(out, doc, cur, NULL, 1);
+}
+
+/**
+ * htmlDocDumpMemory:
+ * @cur:  the document
+ * @mem:  OUT: the memory pointer
+ * @size:  OUT: the memory length
+ *
+ * Dump an HTML document in memory and return the xmlChar * and it's size.
+ * It's up to the caller to free the memory.
+ */
+void
+htmlDocDumpMemory(xmlDocPtr cur, xmlChar**mem, int *size) {
+    xmlOutputBufferPtr buf;
+    xmlCharEncodingHandlerPtr handler = NULL;
+    const char *encoding;
+
+    xmlInitParser();
+
+    if (cur == NULL) {
+	*mem = NULL;
+	*size = 0;
+	return;
+    }
+
+    encoding = (const char *) htmlGetMetaEncoding(cur);
+
+    if (encoding != NULL) {
+	xmlCharEncoding enc;
+
+	enc = xmlParseCharEncoding(encoding);
+	if (enc != cur->charset) {
+	    if (cur->charset != XML_CHAR_ENCODING_UTF8) {
+		/*
+		 * Not supported yet
+		 */
+		*mem = NULL;
+		*size = 0;
+		return;
+	    }
+
+	    handler = xmlFindCharEncodingHandler(encoding);
+	    if (handler == NULL) {
+		*mem = NULL;
+		*size = 0;
+		return;
+	    }
+	}
+    }
+
+    /*
+     * Fallback to HTML or ASCII when the encoding is unspecified
+     */
+    if (handler == NULL)
+	handler = xmlFindCharEncodingHandler("HTML");
+    if (handler == NULL)
+	handler = xmlFindCharEncodingHandler("ascii");
+
+    buf = xmlAllocOutputBuffer(handler);
+    if (buf == NULL) {
+	*mem = NULL;
+	*size = 0;
+	return;
+    }
+
+    htmlDocContentDumpOutput(buf, cur, NULL);
+    xmlOutputBufferFlush(buf);
+    if (buf->conv != NULL) {
+	*size = buf->conv->use;
+	*mem = xmlStrndup(buf->conv->content, *size);
+    } else {
+	*size = buf->buffer->use;
+	*mem = xmlStrndup(buf->buffer->content, *size);
+    }
+    (void)xmlOutputBufferClose(buf);
+}
+
+
+/************************************************************************
+ *									*
+ *   		Dumping HTML tree content to an I/O output buffer	*
+ *									*
+ ************************************************************************/
+
+void xmlNsListDumpOutput(xmlOutputBufferPtr buf, xmlNsPtr cur);
+
+/**
+ * htmlDtdDumpOutput:
+ * @buf:  the HTML buffer output
+ * @doc:  the document
+ * @encoding:  the encoding string
+ * 
+ * TODO: check whether encoding is needed
+ *
+ * Dump the HTML document DTD, if any.
+ */
+static void
+htmlDtdDumpOutput(xmlOutputBufferPtr buf, xmlDocPtr doc,
+	          const char *encoding ATTRIBUTE_UNUSED) {
+    xmlDtdPtr cur = doc->intSubset;
+
+    if (cur == NULL) {
+	htmlSaveErr(XML_SAVE_NO_DOCTYPE, (xmlNodePtr) doc, NULL);
+	return;
+    }
+    xmlOutputBufferWriteString(buf, "<!DOCTYPE ");
+    xmlOutputBufferWriteString(buf, (const char *)cur->name);
+    if (cur->ExternalID != NULL) {
+	xmlOutputBufferWriteString(buf, " PUBLIC ");
+	xmlBufferWriteQuotedString(buf->buffer, cur->ExternalID);
+	if (cur->SystemID != NULL) {
+	    xmlOutputBufferWriteString(buf, " ");
+	    xmlBufferWriteQuotedString(buf->buffer, cur->SystemID);
+	} 
+    }  else if (cur->SystemID != NULL) {
+	xmlOutputBufferWriteString(buf, " SYSTEM ");
+	xmlBufferWriteQuotedString(buf->buffer, cur->SystemID);
+    }
+    xmlOutputBufferWriteString(buf, ">\n");
+}
+
+/**
+ * htmlAttrDumpOutput:
+ * @buf:  the HTML buffer output
+ * @doc:  the document
+ * @cur:  the attribute pointer
+ * @encoding:  the encoding string
+ *
+ * Dump an HTML attribute
+ */
+static void
+htmlAttrDumpOutput(xmlOutputBufferPtr buf, xmlDocPtr doc, xmlAttrPtr cur,
+	           const char *encoding ATTRIBUTE_UNUSED) {
+    xmlChar *value;
+
+    /*
+     * TODO: The html output method should not escape a & character
+     *       occurring in an attribute value immediately followed by
+     *       a { character (see Section B.7.1 of the HTML 4.0 Recommendation).
+     */
+
+    if (cur == NULL) {
+	return;
+    }
+    xmlOutputBufferWriteString(buf, " ");
+    if ((cur->ns != NULL) && (cur->ns->prefix != NULL)) {
+        xmlOutputBufferWriteString(buf, (const char *)cur->ns->prefix);
+	xmlOutputBufferWriteString(buf, ":");
+    }
+    xmlOutputBufferWriteString(buf, (const char *)cur->name);
+    if ((cur->children != NULL) && (!htmlIsBooleanAttr(cur->name))) {
+	value = xmlNodeListGetString(doc, cur->children, 0);
+	if (value) {
+	    xmlOutputBufferWriteString(buf, "=");
+	    if ((cur->ns == NULL) && (cur->parent != NULL) &&
+		(cur->parent->ns == NULL) &&
+		((!xmlStrcasecmp(cur->name, BAD_CAST "href")) ||
+	         (!xmlStrcasecmp(cur->name, BAD_CAST "action")) ||
+		 (!xmlStrcasecmp(cur->name, BAD_CAST "src")))) {
+		xmlChar *escaped;
+		xmlChar *tmp = value;
+
+		while (IS_BLANK_CH(*tmp)) tmp++;
+
+		escaped = xmlURIEscapeStr(tmp, BAD_CAST"@/:=?;#%&,+");
+		if (escaped != NULL) {
+		    xmlBufferWriteQuotedString(buf->buffer, escaped);
+		    xmlFree(escaped);
+		} else {
+		    xmlBufferWriteQuotedString(buf->buffer, value);
+		}
+	    } else {
+		xmlBufferWriteQuotedString(buf->buffer, value);
+	    }
+	    xmlFree(value);
+	} else  {
+	    xmlOutputBufferWriteString(buf, "=\"\"");
+	}
+    }
+}
+
+/**
+ * htmlAttrListDumpOutput:
+ * @buf:  the HTML buffer output
+ * @doc:  the document
+ * @cur:  the first attribute pointer
+ * @encoding:  the encoding string
+ *
+ * Dump a list of HTML attributes
+ */
+static void
+htmlAttrListDumpOutput(xmlOutputBufferPtr buf, xmlDocPtr doc, xmlAttrPtr cur, const char *encoding) {
+    if (cur == NULL) {
+	return;
+    }
+    while (cur != NULL) {
+        htmlAttrDumpOutput(buf, doc, cur, encoding);
+	cur = cur->next;
+    }
+}
+
+
+
+/**
+ * htmlNodeListDumpOutput:
+ * @buf:  the HTML buffer output
+ * @doc:  the document
+ * @cur:  the first node
+ * @encoding:  the encoding string
+ * @format:  should formatting spaces been added
+ *
+ * Dump an HTML node list, recursive behaviour,children are printed too.
+ */
+static void
+htmlNodeListDumpOutput(xmlOutputBufferPtr buf, xmlDocPtr doc,
+	               xmlNodePtr cur, const char *encoding, int format) {
+    if (cur == NULL) {
+	return;
+    }
+    while (cur != NULL) {
+        htmlNodeDumpFormatOutput(buf, doc, cur, encoding, format);
+	cur = cur->next;
+    }
+}
+
+/**
+ * htmlNodeDumpFormatOutput:
+ * @buf:  the HTML buffer output
+ * @doc:  the document
+ * @cur:  the current node
+ * @encoding:  the encoding string
+ * @format:  should formatting spaces been added
+ *
+ * Dump an HTML node, recursive behaviour,children are printed too.
+ */
+void
+htmlNodeDumpFormatOutput(xmlOutputBufferPtr buf, xmlDocPtr doc,
+	                 xmlNodePtr cur, const char *encoding, int format) {
+    const htmlElemDesc * info;
+
+    xmlInitParser();
+
+    if (cur == NULL) {
+	return;
+    }
+    /*
+     * Special cases.
+     */
+    if (cur->type == XML_DTD_NODE)
+	return;
+    if (cur->type == XML_HTML_DOCUMENT_NODE) {
+	htmlDocContentDumpOutput(buf, (xmlDocPtr) cur, encoding);
+	return;
+    }
+    if (cur->type == HTML_TEXT_NODE) {
+	if (cur->content != NULL) {
+	    if (((cur->name == (const xmlChar *)xmlStringText) ||
+		 (cur->name != (const xmlChar *)xmlStringTextNoenc)) &&
+		((cur->parent == NULL) ||
+		 ((xmlStrcasecmp(cur->parent->name, BAD_CAST "script")) &&
+		  (xmlStrcasecmp(cur->parent->name, BAD_CAST "style"))))) {
+		xmlChar *buffer;
+
+		buffer = xmlEncodeEntitiesReentrant(doc, cur->content);
+		if (buffer != NULL) {
+		    xmlOutputBufferWriteString(buf, (const char *)buffer);
+		    xmlFree(buffer);
+		}
+	    } else {
+		xmlOutputBufferWriteString(buf, (const char *)cur->content);
+	    }
+	}
+	return;
+    }
+    if (cur->type == HTML_COMMENT_NODE) {
+	if (cur->content != NULL) {
+	    xmlOutputBufferWriteString(buf, "<!--");
+	    xmlOutputBufferWriteString(buf, (const char *)cur->content);
+	    xmlOutputBufferWriteString(buf, "-->");
+	}
+	return;
+    }
+    if (cur->type == HTML_PI_NODE) {
+	if (cur->name == NULL)
+	    return;
+	xmlOutputBufferWriteString(buf, "<?");
+	xmlOutputBufferWriteString(buf, (const char *)cur->name);
+	if (cur->content != NULL) {
+	    xmlOutputBufferWriteString(buf, " ");
+	    xmlOutputBufferWriteString(buf, (const char *)cur->content);
+	}
+	xmlOutputBufferWriteString(buf, ">");
+	return;
+    }
+    if (cur->type == HTML_ENTITY_REF_NODE) {
+        xmlOutputBufferWriteString(buf, "&");
+	xmlOutputBufferWriteString(buf, (const char *)cur->name);
+        xmlOutputBufferWriteString(buf, ";");
+	return;
+    }
+    if (cur->type == HTML_PRESERVE_NODE) {
+	if (cur->content != NULL) {
+	    xmlOutputBufferWriteString(buf, (const char *)cur->content);
+	}
+	return;
+    }
+
+    /*
+     * Get specific HTML info for that node.
+     */
+    if (cur->ns == NULL)
+	info = htmlTagLookup(cur->name);
+    else
+	info = NULL;
+
+    xmlOutputBufferWriteString(buf, "<");
+    if ((cur->ns != NULL) && (cur->ns->prefix != NULL)) {
+        xmlOutputBufferWriteString(buf, (const char *)cur->ns->prefix);
+	xmlOutputBufferWriteString(buf, ":");
+    }
+    xmlOutputBufferWriteString(buf, (const char *)cur->name);
+    if (cur->nsDef)
+	xmlNsListDumpOutput(buf, cur->nsDef);
+    if (cur->properties != NULL)
+        htmlAttrListDumpOutput(buf, doc, cur->properties, encoding);
+
+    if ((info != NULL) && (info->empty)) {
+        xmlOutputBufferWriteString(buf, ">");
+	if ((format) && (!info->isinline) && (cur->next != NULL)) {
+	    if ((cur->next->type != HTML_TEXT_NODE) &&
+		(cur->next->type != HTML_ENTITY_REF_NODE) &&
+		(cur->parent != NULL) &&
+		(cur->parent->name != NULL) &&
+		(cur->parent->name[0] != 'p')) /* p, pre, param */
+		xmlOutputBufferWriteString(buf, "\n");
+	}
+	return;
+    }
+    if (((cur->type == XML_ELEMENT_NODE) || (cur->content == NULL)) &&
+	(cur->children == NULL)) {
+        if ((info != NULL) && (info->saveEndTag != 0) &&
+	    (xmlStrcmp(BAD_CAST info->name, BAD_CAST "html")) &&
+	    (xmlStrcmp(BAD_CAST info->name, BAD_CAST "body"))) {
+	    xmlOutputBufferWriteString(buf, ">");
+	} else {
+	    xmlOutputBufferWriteString(buf, "></");
+            if ((cur->ns != NULL) && (cur->ns->prefix != NULL)) {
+                xmlOutputBufferWriteString(buf, (const char *)cur->ns->prefix);
+                xmlOutputBufferWriteString(buf, ":");
+            }
+	    xmlOutputBufferWriteString(buf, (const char *)cur->name);
+	    xmlOutputBufferWriteString(buf, ">");
+	}
+	if ((format) && (cur->next != NULL) &&
+            (info != NULL) && (!info->isinline)) {
+	    if ((cur->next->type != HTML_TEXT_NODE) &&
+		(cur->next->type != HTML_ENTITY_REF_NODE) &&
+		(cur->parent != NULL) &&
+		(cur->parent->name != NULL) &&
+		(cur->parent->name[0] != 'p')) /* p, pre, param */
+		xmlOutputBufferWriteString(buf, "\n");
+	}
+	return;
+    }
+    xmlOutputBufferWriteString(buf, ">");
+    if ((cur->type != XML_ELEMENT_NODE) &&
+	(cur->content != NULL)) {
+	    /*
+	     * Uses the OutputBuffer property to automatically convert
+	     * invalids to charrefs
+	     */
+
+            xmlOutputBufferWriteString(buf, (const char *) cur->content);
+    }
+    if (cur->children != NULL) {
+        if ((format) && (info != NULL) && (!info->isinline) &&
+	    (cur->children->type != HTML_TEXT_NODE) &&
+	    (cur->children->type != HTML_ENTITY_REF_NODE) &&
+	    (cur->children != cur->last) &&
+	    (cur->name != NULL) &&
+	    (cur->name[0] != 'p')) /* p, pre, param */
+	    xmlOutputBufferWriteString(buf, "\n");
+	htmlNodeListDumpOutput(buf, doc, cur->children, encoding, format);
+        if ((format) && (info != NULL) && (!info->isinline) &&
+	    (cur->last->type != HTML_TEXT_NODE) &&
+	    (cur->last->type != HTML_ENTITY_REF_NODE) &&
+	    (cur->children != cur->last) &&
+	    (cur->name != NULL) &&
+	    (cur->name[0] != 'p')) /* p, pre, param */
+	    xmlOutputBufferWriteString(buf, "\n");
+    }
+    xmlOutputBufferWriteString(buf, "</");
+    if ((cur->ns != NULL) && (cur->ns->prefix != NULL)) {
+        xmlOutputBufferWriteString(buf, (const char *)cur->ns->prefix);
+	xmlOutputBufferWriteString(buf, ":");
+    }
+    xmlOutputBufferWriteString(buf, (const char *)cur->name);
+    xmlOutputBufferWriteString(buf, ">");
+    if ((format) && (info != NULL) && (!info->isinline) &&
+	(cur->next != NULL)) {
+        if ((cur->next->type != HTML_TEXT_NODE) &&
+	    (cur->next->type != HTML_ENTITY_REF_NODE) &&
+	    (cur->parent != NULL) &&
+	    (cur->parent->name != NULL) &&
+	    (cur->parent->name[0] != 'p')) /* p, pre, param */
+	    xmlOutputBufferWriteString(buf, "\n");
+    }
+}
+
+/**
+ * htmlNodeDumpOutput:
+ * @buf:  the HTML buffer output
+ * @doc:  the document
+ * @cur:  the current node
+ * @encoding:  the encoding string
+ *
+ * Dump an HTML node, recursive behaviour,children are printed too,
+ * and formatting returns/spaces are added.
+ */
+void
+htmlNodeDumpOutput(xmlOutputBufferPtr buf, xmlDocPtr doc,
+	           xmlNodePtr cur, const char *encoding) {
+    htmlNodeDumpFormatOutput(buf, doc, cur, encoding, 1);
+}
+
+/**
+ * htmlDocContentDumpFormatOutput:
+ * @buf:  the HTML buffer output
+ * @cur:  the document
+ * @encoding:  the encoding string
+ * @format:  should formatting spaces been added
+ *
+ * Dump an HTML document.
+ */
+void
+htmlDocContentDumpFormatOutput(xmlOutputBufferPtr buf, xmlDocPtr cur,
+	                       const char *encoding, int format) {
+    int type;
+
+    xmlInitParser();
+
+    /*
+     * force to output the stuff as HTML, especially for entities
+     */
+    type = cur->type;
+    cur->type = XML_HTML_DOCUMENT_NODE;
+    if (cur->intSubset != NULL) {
+        htmlDtdDumpOutput(buf, cur, NULL);
+    }
+    if (cur->children != NULL) {
+        htmlNodeListDumpOutput(buf, cur, cur->children, encoding, format);
+    }
+    xmlOutputBufferWriteString(buf, "\n");
+    cur->type = (xmlElementType) type;
+}
+
+/**
+ * htmlDocContentDumpOutput:
+ * @buf:  the HTML buffer output
+ * @cur:  the document
+ * @encoding:  the encoding string
+ *
+ * Dump an HTML document. Formating return/spaces are added.
+ */
+void
+htmlDocContentDumpOutput(xmlOutputBufferPtr buf, xmlDocPtr cur,
+	                 const char *encoding) {
+    htmlDocContentDumpFormatOutput(buf, cur, encoding, 1);
+}
+
+/************************************************************************
+ *									*
+ *		Saving functions front-ends				*
+ *									*
+ ************************************************************************/
+
+/**
+ * htmlDocDump:
+ * @f:  the FILE*
+ * @cur:  the document
+ *
+ * Dump an HTML document to an open FILE.
+ *
+ * returns: the number of byte written or -1 in case of failure.
+ */
+int
+htmlDocDump(FILE *f, xmlDocPtr cur) {
+    xmlOutputBufferPtr buf;
+    xmlCharEncodingHandlerPtr handler = NULL;
+    const char *encoding;
+    int ret;
+
+    xmlInitParser();
+
+    if (cur == NULL) {
+	return(-1);
+    }
+
+    encoding = (const char *) htmlGetMetaEncoding(cur);
+
+    if (encoding != NULL) {
+	xmlCharEncoding enc;
+
+	enc = xmlParseCharEncoding(encoding);
+	if (enc != cur->charset) {
+	    if (cur->charset != XML_CHAR_ENCODING_UTF8) {
+		/*
+		 * Not supported yet
+		 */
+		return(-1);
+	    }
+
+	    handler = xmlFindCharEncodingHandler(encoding);
+	    if (handler == NULL)
+		return(-1);
+	}
+    }
+
+    /*
+     * Fallback to HTML or ASCII when the encoding is unspecified
+     */
+    if (handler == NULL)
+	handler = xmlFindCharEncodingHandler("HTML");
+    if (handler == NULL)
+	handler = xmlFindCharEncodingHandler("ascii");
+
+    buf = xmlOutputBufferCreateFile(f, handler);
+    if (buf == NULL) return(-1);
+    htmlDocContentDumpOutput(buf, cur, NULL);
+
+    ret = xmlOutputBufferClose(buf);
+    return(ret);
+}
+
+/**
+ * htmlSaveFile:
+ * @filename:  the filename (or URL)
+ * @cur:  the document
+ *
+ * Dump an HTML document to a file. If @filename is "-" the stdout file is
+ * used.
+ * returns: the number of byte written or -1 in case of failure.
+ */
+int
+htmlSaveFile(const char *filename, xmlDocPtr cur) {
+    xmlOutputBufferPtr buf;
+    xmlCharEncodingHandlerPtr handler = NULL;
+    const char *encoding;
+    int ret;
+
+    xmlInitParser();
+
+    encoding = (const char *) htmlGetMetaEncoding(cur);
+
+    if (encoding != NULL) {
+	xmlCharEncoding enc;
+
+	enc = xmlParseCharEncoding(encoding);
+	if (enc != cur->charset) {
+	    if (cur->charset != XML_CHAR_ENCODING_UTF8) {
+		/*
+		 * Not supported yet
+		 */
+		return(-1);
+	    }
+
+	    handler = xmlFindCharEncodingHandler(encoding);
+	    if (handler == NULL)
+		return(-1);
+	}
+    }
+
+    /*
+     * Fallback to HTML or ASCII when the encoding is unspecified
+     */
+    if (handler == NULL)
+	handler = xmlFindCharEncodingHandler("HTML");
+    if (handler == NULL)
+	handler = xmlFindCharEncodingHandler("ascii");
+
+    /* 
+     * save the content to a temp buffer.
+     */
+    buf = xmlOutputBufferCreateFilename(filename, handler, cur->compression);
+    if (buf == NULL) return(0);
+
+    htmlDocContentDumpOutput(buf, cur, NULL);
+
+    ret = xmlOutputBufferClose(buf);
+    return(ret);
+}
+
+/**
+ * htmlSaveFileFormat:
+ * @filename:  the filename
+ * @cur:  the document
+ * @format:  should formatting spaces been added
+ * @encoding: the document encoding
+ *
+ * Dump an HTML document to a file using a given encoding.
+ * 
+ * returns: the number of byte written or -1 in case of failure.
+ */
+int
+htmlSaveFileFormat(const char *filename, xmlDocPtr cur,
+	           const char *encoding, int format) {
+    xmlOutputBufferPtr buf;
+    xmlCharEncodingHandlerPtr handler = NULL;
+    int ret;
+
+    xmlInitParser();
+
+    if (encoding != NULL) {
+	xmlCharEncoding enc;
+
+	enc = xmlParseCharEncoding(encoding);
+	if (enc != cur->charset) {
+	    if (cur->charset != XML_CHAR_ENCODING_UTF8) {
+		/*
+		 * Not supported yet
+		 */
+		return(-1);
+	    }
+
+	    handler = xmlFindCharEncodingHandler(encoding);
+	    if (handler == NULL)
+		return(-1);
+            htmlSetMetaEncoding(cur, (const xmlChar *) encoding);
+	}
+    } else {
+	htmlSetMetaEncoding(cur, (const xmlChar *) "UTF-8");
+    }
+
+    /*
+     * Fallback to HTML or ASCII when the encoding is unspecified
+     */
+    if (handler == NULL)
+	handler = xmlFindCharEncodingHandler("HTML");
+    if (handler == NULL)
+	handler = xmlFindCharEncodingHandler("ascii");
+
+    /* 
+     * save the content to a temp buffer.
+     */
+    buf = xmlOutputBufferCreateFilename(filename, handler, 0);
+    if (buf == NULL) return(0);
+
+    htmlDocContentDumpFormatOutput(buf, cur, encoding, format);
+
+    ret = xmlOutputBufferClose(buf);
+    return(ret);
+}
+
+/**
+ * htmlSaveFileEnc:
+ * @filename:  the filename
+ * @cur:  the document
+ * @encoding: the document encoding
+ *
+ * Dump an HTML document to a file using a given encoding
+ * and formatting returns/spaces are added.
+ * 
+ * returns: the number of byte written or -1 in case of failure.
+ */
+int
+htmlSaveFileEnc(const char *filename, xmlDocPtr cur, const char *encoding) {
+    return(htmlSaveFileFormat(filename, cur, encoding, 1));
+}
+
+#endif /* LIBXML_OUTPUT_ENABLED */
+
+#endif /* LIBXML_HTML_ENABLED */
diff --git a/src/libxml/src/Makefile b/src/libxml/src/Makefile
new file mode 100644
index 0000000..6341ddd
--- /dev/null
+++ b/src/libxml/src/Makefile
@@ -0,0 +1,83 @@
+#------------------------------------------------------------------------------
+# Local Makefile
+#------------------------------------------------------------------------------
+# $Workfile:   Makefile  $                                                     
+#------------------------------------------------------------------------------
+# $Author: agibert $                                                        
+# $Date: 2008/11/12 02:25:23 $                                             
+# $Revision: 1.1 $                                                         
+# $Label:  $                                                           
+#------------------------------------------------------------------------------
+
+
+
+
+
+#------------------------------------------------------------------------------
+# Var include
+#------------------------------------------------------------------------------
+
+include ../../Makefile_var.mk
+
+
+
+#------------------------------------------------------------------------------
+# Variables
+#------------------------------------------------------------------------------
+
+TARGET=		libxml$(SHLIB_SUFFIX)
+
+OBJ=		libxml.o                                                \
+                SAX.o							\
+                entities.o						\
+                encoding.o						\
+                error.o							\
+                parserInternals.o					\
+                parser.o						\
+                tree.o							\
+                hash.o							\
+                list.o							\
+                xmlIO.o							\
+                xmlmemory.o						\
+                uri.o							\
+                valid.o							\
+                xlink.o							\
+                HTMLparser.o						\
+                HTMLtree.o						\
+                debugXML.o						\
+                xpath.o							\
+                xpointer.o						\
+                xinclude.o						\
+                nanohttp.o						\
+                nanoftp.o						\
+                DOCBparser.o						\
+                catalog.o						\
+                globals.o						\
+                threads.o						\
+                c14n.o							\
+                xmlstring.o						\
+                xmlregexp.o						\
+                xmlschemas.o						\
+                xmlschemastypes.o					\
+                xmlunicode.o						\
+                xmlreader.o						\
+                relaxng.o						\
+                dict.o							\
+                SAX2.o							\
+                xmlwriter.o						\
+                legacy.o						\
+                chvalid.o						\
+                pattern.o						\
+                xmlsave.o
+
+EXTRA_MAKEDEP_FLAGS=	-DHAVE_CONFIG_H -D_REENTRANT
+EXTRA_CPPLAGS=	-DHAVE_CONFIG_H -D_REENTRANT
+EXTRA_CFLAGS=	-DHAVE_CONFIG_H -D_REENTRANT
+
+
+
+#------------------------------------------------------------------------------
+# Rule include
+#------------------------------------------------------------------------------
+
+include ../../Makefile_rule.mk
diff --git a/src/libxml/src/SAX.c b/src/libxml/src/SAX.c
new file mode 100644
index 0000000..0ff2017
--- /dev/null
+++ b/src/libxml/src/SAX.c
@@ -0,0 +1,175 @@
+/*
+ * SAX.c : Old SAX v1 handlers to build a tree.
+ *         Deprecated except for compatibility
+ *
+ * See Copyright for the status of this software.
+ *
+ * Daniel Veillard <daniel@veillard.com>
+ */
+
+
+#define IN_LIBXML
+#include "libxml.h"
+#include <stdlib.h>
+#include <string.h>
+#include <libxml/xmlmemory.h>
+#include <libxml/tree.h>
+#include <libxml/parser.h>
+#include <libxml/parserInternals.h>
+#include <libxml/valid.h>
+#include <libxml/entities.h>
+#include <libxml/xmlerror.h>
+#include <libxml/debugXML.h>
+#include <libxml/xmlIO.h>
+#include <libxml/SAX.h>
+#include <libxml/uri.h>
+#include <libxml/valid.h>
+#include <libxml/HTMLtree.h>
+#include <libxml/globals.h>
+#include <libxml/SAX2.h>
+
+#ifdef LIBXML_SAX1_ENABLED
+/**
+ * initxmlDefaultSAXHandler:
+ * @hdlr:  the SAX handler
+ * @warning:  flag if non-zero sets the handler warning procedure
+ *
+ * Initialize the default XML SAX version 1 handler
+ * DEPRECATED: use xmlSAX2InitDefaultSAXHandler() for the new SAX2 blocks
+ */
+void
+initxmlDefaultSAXHandler(xmlSAXHandlerV1 *hdlr, int warning)
+{
+    
+    if(hdlr->initialized == 1)
+	return;
+
+    hdlr->internalSubset = xmlSAX2InternalSubset;
+    hdlr->externalSubset = xmlSAX2ExternalSubset;
+    hdlr->isStandalone = xmlSAX2IsStandalone;
+    hdlr->hasInternalSubset = xmlSAX2HasInternalSubset;
+    hdlr->hasExternalSubset = xmlSAX2HasExternalSubset;
+    hdlr->resolveEntity = xmlSAX2ResolveEntity;
+    hdlr->getEntity = xmlSAX2GetEntity;
+    hdlr->getParameterEntity = xmlSAX2GetParameterEntity;
+    hdlr->entityDecl = xmlSAX2EntityDecl;
+    hdlr->attributeDecl = xmlSAX2AttributeDecl;
+    hdlr->elementDecl = xmlSAX2ElementDecl;
+    hdlr->notationDecl = xmlSAX2NotationDecl;
+    hdlr->unparsedEntityDecl = xmlSAX2UnparsedEntityDecl;
+    hdlr->setDocumentLocator = xmlSAX2SetDocumentLocator;
+    hdlr->startDocument = xmlSAX2StartDocument;
+    hdlr->endDocument = xmlSAX2EndDocument;
+    hdlr->startElement = xmlSAX2StartElement;
+    hdlr->endElement = xmlSAX2EndElement;
+    hdlr->reference = xmlSAX2Reference;
+    hdlr->characters = xmlSAX2Characters;
+    hdlr->cdataBlock = xmlSAX2CDataBlock;
+    hdlr->ignorableWhitespace = xmlSAX2Characters;
+    hdlr->processingInstruction = xmlSAX2ProcessingInstruction;
+    if (warning == 0)
+	hdlr->warning = NULL;
+    else
+	hdlr->warning = xmlParserWarning;
+    hdlr->error = xmlParserError;
+    hdlr->fatalError = xmlParserError;
+
+    hdlr->initialized = 1;
+}
+#endif /* LIBXML_SAX1_ENABLED */
+
+#ifdef LIBXML_HTML_ENABLED
+
+/**
+ * inithtmlDefaultSAXHandler:
+ * @hdlr:  the SAX handler
+ *
+ * Initialize the default HTML SAX version 1 handler
+ * DEPRECATED: use xmlSAX2InitHtmlDefaultSAXHandler() for the new SAX2 blocks
+ */
+void
+inithtmlDefaultSAXHandler(xmlSAXHandlerV1 *hdlr)
+{
+    if(hdlr->initialized == 1)
+	return;
+
+    hdlr->internalSubset = xmlSAX2InternalSubset;
+    hdlr->externalSubset = NULL;
+    hdlr->isStandalone = NULL;
+    hdlr->hasInternalSubset = NULL;
+    hdlr->hasExternalSubset = NULL;
+    hdlr->resolveEntity = NULL;
+    hdlr->getEntity = xmlSAX2GetEntity;
+    hdlr->getParameterEntity = NULL;
+    hdlr->entityDecl = NULL;
+    hdlr->attributeDecl = NULL;
+    hdlr->elementDecl = NULL;
+    hdlr->notationDecl = NULL;
+    hdlr->unparsedEntityDecl = NULL;
+    hdlr->setDocumentLocator = xmlSAX2SetDocumentLocator;
+    hdlr->startDocument = xmlSAX2StartDocument;
+    hdlr->endDocument = xmlSAX2EndDocument;
+    hdlr->startElement = xmlSAX2StartElement;
+    hdlr->endElement = xmlSAX2EndElement;
+    hdlr->reference = NULL;
+    hdlr->characters = xmlSAX2Characters;
+    hdlr->cdataBlock = xmlSAX2CDataBlock;
+    hdlr->ignorableWhitespace = xmlSAX2IgnorableWhitespace;
+    hdlr->processingInstruction = NULL;
+    hdlr->comment = xmlSAX2Comment;
+    hdlr->warning = xmlParserWarning;
+    hdlr->error = xmlParserError;
+    hdlr->fatalError = xmlParserError;
+
+    hdlr->initialized = 1;
+}
+
+#endif /* LIBXML_HTML_ENABLED */
+
+#ifdef LIBXML_DOCB_ENABLED
+
+/**
+ * initdocbDefaultSAXHandler:
+ * @hdlr:  the SAX handler
+ *
+ * Initialize the default DocBook SAX version 1 handler
+ * DEPRECATED: use xmlSAX2InitDocbDefaultSAXHandler() for the new SAX2 blocks
+ */
+void
+initdocbDefaultSAXHandler(xmlSAXHandlerV1 *hdlr)
+{
+    if(hdlr->initialized == 1)
+	return;
+
+    hdlr->internalSubset = xmlSAX2InternalSubset;
+    hdlr->externalSubset = NULL;
+    hdlr->isStandalone = xmlSAX2IsStandalone;
+    hdlr->hasInternalSubset = xmlSAX2HasInternalSubset;
+    hdlr->hasExternalSubset = xmlSAX2HasExternalSubset;
+    hdlr->resolveEntity = xmlSAX2ResolveEntity;
+    hdlr->getEntity = xmlSAX2GetEntity;
+    hdlr->getParameterEntity = NULL;
+    hdlr->entityDecl = xmlSAX2EntityDecl;
+    hdlr->attributeDecl = NULL;
+    hdlr->elementDecl = NULL;
+    hdlr->notationDecl = NULL;
+    hdlr->unparsedEntityDecl = NULL;
+    hdlr->setDocumentLocator = xmlSAX2SetDocumentLocator;
+    hdlr->startDocument = xmlSAX2StartDocument;
+    hdlr->endDocument = xmlSAX2EndDocument;
+    hdlr->startElement = xmlSAX2StartElement;
+    hdlr->endElement = xmlSAX2EndElement;
+    hdlr->reference = xmlSAX2Reference;
+    hdlr->characters = xmlSAX2Characters;
+    hdlr->cdataBlock = NULL;
+    hdlr->ignorableWhitespace = xmlSAX2IgnorableWhitespace;
+    hdlr->processingInstruction = NULL;
+    hdlr->comment = xmlSAX2Comment;
+    hdlr->warning = xmlParserWarning;
+    hdlr->error = xmlParserError;
+    hdlr->fatalError = xmlParserError;
+
+    hdlr->initialized = 1;
+}
+
+#endif /* LIBXML_DOCB_ENABLED */
diff --git a/src/libxml/src/SAX2.c b/src/libxml/src/SAX2.c
new file mode 100644
index 0000000..781a666
--- /dev/null
+++ b/src/libxml/src/SAX2.c
@@ -0,0 +1,2736 @@
+/*
+ * SAX2.c : Default SAX2 handler to build a tree.
+ *
+ * See Copyright for the status of this software.
+ *
+ * Daniel Veillard <daniel@veillard.com>
+ */
+
+
+#define IN_LIBXML
+#include "libxml.h"
+#include <stdlib.h>
+#include <string.h>
+#include <libxml/xmlmemory.h>
+#include <libxml/tree.h>
+#include <libxml/parser.h>
+#include <libxml/parserInternals.h>
+#include <libxml/valid.h>
+#include <libxml/entities.h>
+#include <libxml/xmlerror.h>
+#include <libxml/debugXML.h>
+#include <libxml/xmlIO.h>
+#include <libxml/SAX.h>
+#include <libxml/uri.h>
+#include <libxml/valid.h>
+#include <libxml/HTMLtree.h>
+#include <libxml/globals.h>
+
+/* #define DEBUG_SAX2 */
+/* #define DEBUG_SAX2_TREE */
+
+/**
+ * TODO:
+ *
+ * macro to flag unimplemented blocks
+ * XML_CATALOG_PREFER user env to select between system/public prefered
+ * option. C.f. Richard Tobin <richard@cogsci.ed.ac.uk>
+ *> Just FYI, I am using an environment variable XML_CATALOG_PREFER with
+ *> values "system" and "public".  I have made the default be "system" to
+ *> match yours.
+ */
+#define TODO 								\
+    xmlGenericError(xmlGenericErrorContext,				\
+	    "Unimplemented block at %s:%d\n",				\
+            __FILE__, __LINE__);
+
+/**
+ * xmlValidError:
+ * @ctxt:  an XML validation parser context
+ * @error:  the error number
+ * @msg:  the error message
+ * @str1:  extra data
+ * @str2:  extra data
+ *
+ * Handle a validation error
+ */
+static void
+xmlErrValid(xmlParserCtxtPtr ctxt, xmlParserErrors error,
+            const char *msg, const char *str1, const char *str2)
+{
+    xmlStructuredErrorFunc schannel = NULL;
+
+    if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
+        (ctxt->instate == XML_PARSER_EOF))
+	return;
+    ctxt->errNo = error;
+    if ((ctxt->sax != NULL) && (ctxt->sax->initialized == XML_SAX2_MAGIC))
+        schannel = ctxt->sax->serror;
+    __xmlRaiseError(schannel,
+                    ctxt->vctxt.error, ctxt->vctxt.userData,
+                    ctxt, NULL, XML_FROM_DTD, error,
+                    XML_ERR_ERROR, NULL, 0, (const char *) str1,
+		    (const char *) str2, NULL, 0, 0,
+		    msg, (const char *) str1, (const char *) str2);
+    ctxt->valid = 0;
+}
+
+/**
+ * xmlSAX2GetPublicId:
+ * @ctx: the user data (XML parser context)
+ *
+ * Provides the public ID e.g. "-//SGMLSOURCE//DTD DEMO//EN"
+ *
+ * Returns a xmlChar *
+ */
+const xmlChar *
+xmlSAX2GetPublicId(void *ctx ATTRIBUTE_UNUSED)
+{
+    /* xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx; */
+    return(NULL);
+}
+
+/**
+ * xmlSAX2GetSystemId:
+ * @ctx: the user data (XML parser context)
+ *
+ * Provides the system ID, basically URL or filename e.g.
+ * http://www.sgmlsource.com/dtds/memo.dtd
+ *
+ * Returns a xmlChar *
+ */
+const xmlChar *
+xmlSAX2GetSystemId(void *ctx)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+    return((const xmlChar *) ctxt->input->filename); 
+}
+
+/**
+ * xmlSAX2GetLineNumber:
+ * @ctx: the user data (XML parser context)
+ *
+ * Provide the line number of the current parsing point.
+ *
+ * Returns an int
+ */
+int
+xmlSAX2GetLineNumber(void *ctx)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+    return(ctxt->input->line);
+}
+
+/**
+ * xmlSAX2GetColumnNumber:
+ * @ctx: the user data (XML parser context)
+ *
+ * Provide the column number of the current parsing point.
+ *
+ * Returns an int
+ */
+int
+xmlSAX2GetColumnNumber(void *ctx)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+    return(ctxt->input->col);
+}
+
+/**
+ * xmlSAX2IsStandalone:
+ * @ctx: the user data (XML parser context)
+ *
+ * Is this document tagged standalone ?
+ *
+ * Returns 1 if true
+ */
+int
+xmlSAX2IsStandalone(void *ctx)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+    return(ctxt->myDoc->standalone == 1);
+}
+
+/**
+ * xmlSAX2HasInternalSubset:
+ * @ctx: the user data (XML parser context)
+ *
+ * Does this document has an internal subset
+ *
+ * Returns 1 if true
+ */
+int
+xmlSAX2HasInternalSubset(void *ctx)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+    return(ctxt->myDoc->intSubset != NULL);
+}
+
+/**
+ * xmlSAX2HasExternalSubset:
+ * @ctx: the user data (XML parser context)
+ *
+ * Does this document has an external subset
+ *
+ * Returns 1 if true
+ */
+int
+xmlSAX2HasExternalSubset(void *ctx)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+    return(ctxt->myDoc->extSubset != NULL);
+}
+
+/**
+ * xmlSAX2InternalSubset:
+ * @ctx:  the user data (XML parser context)
+ * @name:  the root element name
+ * @ExternalID:  the external ID
+ * @SystemID:  the SYSTEM ID (e.g. filename or URL)
+ *
+ * Callback on internal subset declaration.
+ */
+void
+xmlSAX2InternalSubset(void *ctx, const xmlChar *name,
+	       const xmlChar *ExternalID, const xmlChar *SystemID)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+    xmlDtdPtr dtd;
+#ifdef DEBUG_SAX
+    xmlGenericError(xmlGenericErrorContext,
+	    "SAX.xmlSAX2InternalSubset(%s, %s, %s)\n",
+            name, ExternalID, SystemID);
+#endif
+
+    if (ctxt->myDoc == NULL)
+	return;
+    dtd = xmlGetIntSubset(ctxt->myDoc);
+    if (dtd != NULL) {
+	if (ctxt->html)
+	    return;
+	xmlUnlinkNode((xmlNodePtr) dtd);
+	xmlFreeDtd(dtd);
+	ctxt->myDoc->intSubset = NULL;
+    }
+    ctxt->myDoc->intSubset = 
+	xmlCreateIntSubset(ctxt->myDoc, name, ExternalID, SystemID);
+}
+
+/**
+ * xmlSAX2ExternalSubset:
+ * @ctx: the user data (XML parser context)
+ * @name:  the root element name
+ * @ExternalID:  the external ID
+ * @SystemID:  the SYSTEM ID (e.g. filename or URL)
+ *
+ * Callback on external subset declaration.
+ */
+void
+xmlSAX2ExternalSubset(void *ctx, const xmlChar *name,
+	       const xmlChar *ExternalID, const xmlChar *SystemID)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+#ifdef DEBUG_SAX
+    xmlGenericError(xmlGenericErrorContext,
+	    "SAX.xmlSAX2ExternalSubset(%s, %s, %s)\n",
+            name, ExternalID, SystemID);
+#endif
+    if (((ExternalID != NULL) || (SystemID != NULL)) &&
+        (((ctxt->validate) || (ctxt->loadsubset != 0)) &&
+	 (ctxt->wellFormed && ctxt->myDoc))) {
+	/*
+	 * Try to fetch and parse the external subset.
+	 */
+	xmlParserInputPtr oldinput;
+	int oldinputNr;
+	int oldinputMax;
+	xmlParserInputPtr *oldinputTab;
+	xmlParserInputPtr input = NULL;
+	xmlCharEncoding enc;
+	int oldcharset;
+
+	/*
+	 * Ask the Entity resolver to load the damn thing
+	 */
+	if ((ctxt->sax != NULL) && (ctxt->sax->resolveEntity != NULL))
+	    input = ctxt->sax->resolveEntity(ctxt->userData, ExternalID,
+	                                        SystemID);
+	if (input == NULL) {
+	    return;
+	}
+
+	xmlNewDtd(ctxt->myDoc, name, ExternalID, SystemID);
+
+	/*
+	 * make sure we won't destroy the main document context
+	 */
+	oldinput = ctxt->input;
+	oldinputNr = ctxt->inputNr;
+	oldinputMax = ctxt->inputMax;
+	oldinputTab = ctxt->inputTab;
+	oldcharset = ctxt->charset;
+
+	ctxt->inputTab = (xmlParserInputPtr *)
+	                 xmlMalloc(5 * sizeof(xmlParserInputPtr));
+	if (ctxt->inputTab == NULL) {
+	    ctxt->errNo = XML_ERR_NO_MEMORY;
+	    if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
+		ctxt->sax->error(ctxt->userData, 
+		     "xmlSAX2ExternalSubset: out of memory\n");
+	    ctxt->errNo = XML_ERR_NO_MEMORY;
+	    ctxt->instate = XML_PARSER_EOF;
+	    ctxt->disableSAX = 1;
+	    ctxt->input = oldinput;
+	    ctxt->inputNr = oldinputNr;
+	    ctxt->inputMax = oldinputMax;
+	    ctxt->inputTab = oldinputTab;
+	    ctxt->charset = oldcharset;
+	    return;
+	}
+	ctxt->inputNr = 0;
+	ctxt->inputMax = 5;
+	ctxt->input = NULL;
+	xmlPushInput(ctxt, input);
+
+	/*
+	 * On the fly encoding conversion if needed
+	 */
+	if (ctxt->input->length >= 4) {
+	    enc = xmlDetectCharEncoding(ctxt->input->cur, 4);
+	    xmlSwitchEncoding(ctxt, enc);
+	}
+
+	if (input->filename == NULL)
+	    input->filename = (char *) xmlCanonicPath(SystemID);
+	input->line = 1;
+	input->col = 1;
+	input->base = ctxt->input->cur;
+	input->cur = ctxt->input->cur;
+	input->free = NULL;
+
+	/*
+	 * let's parse that entity knowing it's an external subset.
+	 */
+	xmlParseExternalSubset(ctxt, ExternalID, SystemID);
+
+        /*
+	 * Free up the external entities
+	 */
+
+	while (ctxt->inputNr > 1)
+	    xmlPopInput(ctxt);
+	xmlFreeInputStream(ctxt->input);
+        xmlFree(ctxt->inputTab);
+
+	/*
+	 * Restore the parsing context of the main entity
+	 */
+	ctxt->input = oldinput;
+	ctxt->inputNr = oldinputNr;
+	ctxt->inputMax = oldinputMax;
+	ctxt->inputTab = oldinputTab;
+	ctxt->charset = oldcharset;
+	/* ctxt->wellFormed = oldwellFormed; */
+    }
+}
+
+/**
+ * xmlSAX2ResolveEntity:
+ * @ctx: the user data (XML parser context)
+ * @publicId: The public ID of the entity
+ * @systemId: The system ID of the entity
+ *
+ * The entity loader, to control the loading of external entities,
+ * the application can either:
+ *    - override this xmlSAX2ResolveEntity() callback in the SAX block
+ *    - or better use the xmlSetExternalEntityLoader() function to
+ *      set up it's own entity resolution routine
+ *
+ * Returns the xmlParserInputPtr if inlined or NULL for DOM behaviour.
+ */
+xmlParserInputPtr
+xmlSAX2ResolveEntity(void *ctx, const xmlChar *publicId, const xmlChar *systemId)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+    xmlParserInputPtr ret;
+    xmlChar *URI;
+    const char *base = NULL;
+
+    if (ctxt->input != NULL)
+	base = ctxt->input->filename;
+    if (base == NULL)
+	base = ctxt->directory;
+
+    URI = xmlBuildURI(systemId, (const xmlChar *) base);
+
+#ifdef DEBUG_SAX
+    xmlGenericError(xmlGenericErrorContext,
+	    "SAX.xmlSAX2ResolveEntity(%s, %s)\n", publicId, systemId);
+#endif
+
+    ret = xmlLoadExternalEntity((const char *) URI,
+				(const char *) publicId, ctxt);
+    if (URI != NULL)
+	xmlFree(URI);
+    return(ret);
+}
+
+/**
+ * xmlSAX2GetEntity:
+ * @ctx: the user data (XML parser context)
+ * @name: The entity name
+ *
+ * Get an entity by name
+ *
+ * Returns the xmlEntityPtr if found.
+ */
+xmlEntityPtr
+xmlSAX2GetEntity(void *ctx, const xmlChar *name)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+    xmlEntityPtr ret = NULL;
+
+#ifdef DEBUG_SAX
+    xmlGenericError(xmlGenericErrorContext,
+	    "SAX.xmlSAX2GetEntity(%s)\n", name);
+#endif
+
+    if (ctxt->inSubset == 0) {
+	ret = xmlGetPredefinedEntity(name);
+	if (ret != NULL)
+	    return(ret);
+    }
+    if ((ctxt->myDoc != NULL) && (ctxt->myDoc->standalone == 1)) {
+	if (ctxt->inSubset == 2) {
+	    ctxt->myDoc->standalone = 0;
+	    ret = xmlGetDocEntity(ctxt->myDoc, name);
+	    ctxt->myDoc->standalone = 1;
+	} else {
+	    ret = xmlGetDocEntity(ctxt->myDoc, name);
+	    if (ret == NULL) {
+		ctxt->myDoc->standalone = 0;
+		ret = xmlGetDocEntity(ctxt->myDoc, name);
+		if (ret != NULL) {
+		    if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
+			ctxt->sax->error(ctxt->userData, 
+		 "Entity(%s) document marked standalone but requires external subset\n",
+					 name);
+		    ctxt->valid = 0;
+		    ctxt->wellFormed = 0;
+		}
+		ctxt->myDoc->standalone = 1;
+	    }
+	}
+    } else {
+	ret = xmlGetDocEntity(ctxt->myDoc, name);
+    }
+    if ((ret != NULL) &&
+	((ctxt->validate) || (ctxt->replaceEntities)) &&
+	(ret->children == NULL) &&
+	(ret->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)) {
+	int val;
+
+	/*
+	 * for validation purposes we really need to fetch and
+	 * parse the external entity
+	 */
+	xmlNodePtr children;
+
+        val = xmlParseCtxtExternalEntity(ctxt, ret->URI,
+		                         ret->ExternalID, &children);
+	if (val == 0) {
+	    xmlAddChildList((xmlNodePtr) ret, children);
+	} else {
+	    if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
+	        ctxt->sax->error(ctxt->userData, 
+		 "Failure to process entity %s\n", name);
+	    ctxt->wellFormed = 0;
+	    ctxt->valid = 0;
+	    ctxt->validate = 0;
+	    return(NULL);
+	}
+	ret->owner = 1;
+    }
+    return(ret);
+}
+
+/**
+ * xmlSAX2GetParameterEntity:
+ * @ctx: the user data (XML parser context)
+ * @name: The entity name
+ *
+ * Get a parameter entity by name
+ *
+ * Returns the xmlEntityPtr if found.
+ */
+xmlEntityPtr
+xmlSAX2GetParameterEntity(void *ctx, const xmlChar *name)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+    xmlEntityPtr ret;
+
+#ifdef DEBUG_SAX
+    xmlGenericError(xmlGenericErrorContext,
+	    "SAX.xmlSAX2GetParameterEntity(%s)\n", name);
+#endif
+
+    ret = xmlGetParameterEntity(ctxt->myDoc, name);
+    return(ret);
+}
+
+
+/**
+ * xmlSAX2EntityDecl:
+ * @ctx: the user data (XML parser context)
+ * @name:  the entity name 
+ * @type:  the entity type 
+ * @publicId: The public ID of the entity
+ * @systemId: The system ID of the entity
+ * @content: the entity value (without processing).
+ *
+ * An entity definition has been parsed
+ */
+void
+xmlSAX2EntityDecl(void *ctx, const xmlChar *name, int type,
+          const xmlChar *publicId, const xmlChar *systemId, xmlChar *content)
+{
+    xmlEntityPtr ent;
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+
+#ifdef DEBUG_SAX
+    xmlGenericError(xmlGenericErrorContext,
+	    "SAX.xmlSAX2EntityDecl(%s, %d, %s, %s, %s)\n",
+            name, type, publicId, systemId, content);
+#endif
+    if (ctxt->inSubset == 1) {
+	ent = xmlAddDocEntity(ctxt->myDoc, name, type, publicId,
+		              systemId, content);
+	if ((ent == NULL) && (ctxt->pedantic) &&
+	    (ctxt->sax != NULL) && (ctxt->sax->warning != NULL))
+	    ctxt->sax->warning(ctxt->userData, 
+	     "Entity(%s) already defined in the internal subset\n", name);
+	if ((ent != NULL) && (ent->URI == NULL) && (systemId != NULL)) {
+	    xmlChar *URI;
+	    const char *base = NULL;
+
+	    if (ctxt->input != NULL)
+		base = ctxt->input->filename;
+	    if (base == NULL)
+		base = ctxt->directory;
+	
+	    URI = xmlBuildURI(systemId, (const xmlChar *) base);
+	    ent->URI = URI;
+	}
+    } else if (ctxt->inSubset == 2) {
+	ent = xmlAddDtdEntity(ctxt->myDoc, name, type, publicId,
+		              systemId, content);
+	if ((ent == NULL) && (ctxt->pedantic) &&
+	    (ctxt->sax != NULL) && (ctxt->sax->warning != NULL))
+	    ctxt->sax->warning(ctxt->userData, 
+	     "Entity(%s) already defined in the external subset\n", name);
+	if ((ent != NULL) && (ent->URI == NULL) && (systemId != NULL)) {
+	    xmlChar *URI;
+	    const char *base = NULL;
+
+	    if (ctxt->input != NULL)
+		base = ctxt->input->filename;
+	    if (base == NULL)
+		base = ctxt->directory;
+	
+	    URI = xmlBuildURI(systemId, (const xmlChar *) base);
+	    ent->URI = URI;
+	}
+    } else {
+	if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
+	    ctxt->sax->error(ctxt->userData, 
+	     "SAX.xmlSAX2EntityDecl(%s) called while not in subset\n", name);
+    }
+}
+
+/**
+ * xmlSAX2AttributeDecl:
+ * @ctx: the user data (XML parser context)
+ * @elem:  the name of the element
+ * @fullname:  the attribute name 
+ * @type:  the attribute type 
+ * @def:  the type of default value
+ * @defaultValue: the attribute default value
+ * @tree:  the tree of enumerated value set
+ *
+ * An attribute definition has been parsed
+ */
+void
+xmlSAX2AttributeDecl(void *ctx, const xmlChar *elem, const xmlChar *fullname,
+              int type, int def, const xmlChar *defaultValue,
+	      xmlEnumerationPtr tree)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+    xmlAttributePtr attr;
+    xmlChar *name = NULL, *prefix = NULL;
+
+#ifdef DEBUG_SAX
+    xmlGenericError(xmlGenericErrorContext,
+	    "SAX.xmlSAX2AttributeDecl(%s, %s, %d, %d, %s, ...)\n",
+            elem, fullname, type, def, defaultValue);
+#endif
+    if ((xmlStrEqual(fullname, BAD_CAST "xml:id")) &&
+        (type != XML_ATTRIBUTE_ID)) {
+	/*
+	 * Raise the error but keep the validity flag
+	 */
+	int tmp = ctxt->valid;
+	xmlErrValid(ctxt, XML_DTD_XMLID_TYPE,
+	      "xml:id : attribute type should be ID\n", NULL, NULL);
+	ctxt->valid = tmp;
+    }
+    /* TODO: optimize name/prefix allocation */
+    name = xmlSplitQName(ctxt, fullname, &prefix);
+    ctxt->vctxt.valid = 1;
+    if (ctxt->inSubset == 1)
+	attr = xmlAddAttributeDecl(&ctxt->vctxt, ctxt->myDoc->intSubset, elem,
+	       name, prefix, (xmlAttributeType) type,
+	       (xmlAttributeDefault) def, defaultValue, tree);
+    else if (ctxt->inSubset == 2)
+	attr = xmlAddAttributeDecl(&ctxt->vctxt, ctxt->myDoc->extSubset, elem,
+	   name, prefix, (xmlAttributeType) type, 
+	   (xmlAttributeDefault) def, defaultValue, tree);
+    else {
+	if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
+	    ctxt->sax->error(ctxt->userData, 
+	     "SAX.xmlSAX2AttributeDecl(%s) called while not in subset\n", name);
+	xmlFreeEnumeration(tree);
+	return;
+    }
+#ifdef LIBXML_VALID_ENABLED
+    if (ctxt->vctxt.valid == 0)
+	ctxt->valid = 0;
+    if ((attr != NULL) && (ctxt->validate) && (ctxt->wellFormed) &&
+        (ctxt->myDoc != NULL) && (ctxt->myDoc->intSubset != NULL))
+	ctxt->valid &= xmlValidateAttributeDecl(&ctxt->vctxt, ctxt->myDoc,
+	                                        attr);
+#endif /* LIBXML_VALID_ENABLED */
+    if (prefix != NULL)
+	xmlFree(prefix);
+    if (name != NULL)
+	xmlFree(name);
+}
+
+/**
+ * xmlSAX2ElementDecl:
+ * @ctx: the user data (XML parser context)
+ * @name:  the element name 
+ * @type:  the element type 
+ * @content: the element value tree
+ *
+ * An element definition has been parsed
+ */
+void
+xmlSAX2ElementDecl(void *ctx, const xmlChar * name, int type,
+            xmlElementContentPtr content)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+    xmlElementPtr elem = NULL;
+
+#ifdef DEBUG_SAX
+    xmlGenericError(xmlGenericErrorContext,
+                    "SAX.xmlSAX2ElementDecl(%s, %d, ...)\n", name, type);
+#endif
+
+    if (ctxt->inSubset == 1)
+        elem = xmlAddElementDecl(&ctxt->vctxt, ctxt->myDoc->intSubset,
+                                 name, (xmlElementTypeVal) type, content);
+    else if (ctxt->inSubset == 2)
+        elem = xmlAddElementDecl(&ctxt->vctxt, ctxt->myDoc->extSubset,
+                                 name, (xmlElementTypeVal) type, content);
+    else {
+        if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
+            ctxt->sax->error(ctxt->userData,
+                             "SAX.xmlSAX2ElementDecl(%s) called while not in subset\n",
+                             name);
+        return;
+    }
+#ifdef LIBXML_VALID_ENABLED
+    if (elem == NULL)
+        ctxt->valid = 0;
+    if (ctxt->validate && ctxt->wellFormed &&
+        ctxt->myDoc && ctxt->myDoc->intSubset)
+        ctxt->valid &=
+            xmlValidateElementDecl(&ctxt->vctxt, ctxt->myDoc, elem);
+#endif /* LIBXML_VALID_ENABLED */
+}
+
+/**
+ * xmlSAX2NotationDecl:
+ * @ctx: the user data (XML parser context)
+ * @name: The name of the notation
+ * @publicId: The public ID of the entity
+ * @systemId: The system ID of the entity
+ *
+ * What to do when a notation declaration has been parsed.
+ */
+void
+xmlSAX2NotationDecl(void *ctx, const xmlChar *name,
+	     const xmlChar *publicId, const xmlChar *systemId)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+    xmlNotationPtr nota = NULL;
+
+#ifdef DEBUG_SAX
+    xmlGenericError(xmlGenericErrorContext,
+	    "SAX.xmlSAX2NotationDecl(%s, %s, %s)\n", name, publicId, systemId);
+#endif
+
+    if ((publicId == NULL) && (systemId == NULL)) {
+	if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
+	    ctxt->sax->error(ctxt->userData, 
+	     "SAX.xmlSAX2NotationDecl(%s) externalID or PublicID missing\n", name);
+	ctxt->valid = 0;
+	ctxt->wellFormed = 0;
+	return;
+    } else if (ctxt->inSubset == 1)
+	nota = xmlAddNotationDecl(&ctxt->vctxt, ctxt->myDoc->intSubset, name,
+                              publicId, systemId);
+    else if (ctxt->inSubset == 2)
+	nota = xmlAddNotationDecl(&ctxt->vctxt, ctxt->myDoc->extSubset, name,
+                              publicId, systemId);
+    else {
+	if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
+	    ctxt->sax->error(ctxt->userData, 
+	     "SAX.xmlSAX2NotationDecl(%s) called while not in subset\n", name);
+	return;
+    }
+#ifdef LIBXML_VALID_ENABLED
+    if (nota == NULL) ctxt->valid = 0;
+    if (ctxt->validate && ctxt->wellFormed &&
+        ctxt->myDoc && ctxt->myDoc->intSubset)
+	ctxt->valid &= xmlValidateNotationDecl(&ctxt->vctxt, ctxt->myDoc,
+	                                       nota);
+#endif /* LIBXML_VALID_ENABLED */
+}
+
+/**
+ * xmlSAX2UnparsedEntityDecl:
+ * @ctx: the user data (XML parser context)
+ * @name: The name of the entity
+ * @publicId: The public ID of the entity
+ * @systemId: The system ID of the entity
+ * @notationName: the name of the notation
+ *
+ * What to do when an unparsed entity declaration is parsed
+ */
+void
+xmlSAX2UnparsedEntityDecl(void *ctx, const xmlChar *name,
+		   const xmlChar *publicId, const xmlChar *systemId,
+		   const xmlChar *notationName)
+{
+    xmlEntityPtr ent;
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+#ifdef DEBUG_SAX
+    xmlGenericError(xmlGenericErrorContext,
+	    "SAX.xmlSAX2UnparsedEntityDecl(%s, %s, %s, %s)\n",
+            name, publicId, systemId, notationName);
+#endif
+    if (ctxt->inSubset == 1) {
+	ent = xmlAddDocEntity(ctxt->myDoc, name,
+			XML_EXTERNAL_GENERAL_UNPARSED_ENTITY,
+			publicId, systemId, notationName);
+	if ((ent == NULL) && (ctxt->pedantic) &&
+	    (ctxt->sax != NULL) && (ctxt->sax->warning != NULL))
+	    ctxt->sax->warning(ctxt->userData, 
+	     "Entity(%s) already defined in the internal subset\n", name);
+	if ((ent != NULL) && (ent->URI == NULL) && (systemId != NULL)) {
+	    xmlChar *URI;
+	    const char *base = NULL;
+
+	    if (ctxt->input != NULL)
+		base = ctxt->input->filename;
+	    if (base == NULL)
+		base = ctxt->directory;
+	
+	    URI = xmlBuildURI(systemId, (const xmlChar *) base);
+	    ent->URI = URI;
+	}
+    } else if (ctxt->inSubset == 2) {
+	ent = xmlAddDtdEntity(ctxt->myDoc, name,
+			XML_EXTERNAL_GENERAL_UNPARSED_ENTITY,
+			publicId, systemId, notationName);
+	if ((ent == NULL) && (ctxt->pedantic) &&
+	    (ctxt->sax != NULL) && (ctxt->sax->warning != NULL))
+	    ctxt->sax->warning(ctxt->userData, 
+	     "Entity(%s) already defined in the external subset\n", name);
+	if ((ent != NULL) && (ent->URI == NULL) && (systemId != NULL)) {
+	    xmlChar *URI;
+	    const char *base = NULL;
+
+	    if (ctxt->input != NULL)
+		base = ctxt->input->filename;
+	    if (base == NULL)
+		base = ctxt->directory;
+	
+	    URI = xmlBuildURI(systemId, (const xmlChar *) base);
+	    ent->URI = URI;
+	}
+    } else {
+	if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
+	    ctxt->sax->error(ctxt->userData, 
+	     "SAX.xmlSAX2UnparsedEntityDecl(%s) called while not in subset\n", name);
+    }
+}
+
+/**
+ * xmlSAX2SetDocumentLocator:
+ * @ctx: the user data (XML parser context)
+ * @loc: A SAX Locator
+ *
+ * Receive the document locator at startup, actually xmlDefaultSAXLocator
+ * Everything is available on the context, so this is useless in our case.
+ */
+void
+xmlSAX2SetDocumentLocator(void *ctx ATTRIBUTE_UNUSED, xmlSAXLocatorPtr loc ATTRIBUTE_UNUSED)
+{
+    /* xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx; */
+#ifdef DEBUG_SAX
+    xmlGenericError(xmlGenericErrorContext,
+	    "SAX.xmlSAX2SetDocumentLocator()\n");
+#endif
+}
+
+/**
+ * xmlSAX2StartDocument:
+ * @ctx: the user data (XML parser context)
+ *
+ * called when the document start being processed.
+ */
+void
+xmlSAX2StartDocument(void *ctx)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+    xmlDocPtr doc;
+
+#ifdef DEBUG_SAX
+    xmlGenericError(xmlGenericErrorContext,
+	    "SAX.xmlSAX2StartDocument()\n");
+#endif
+    if (ctxt->html) {
+#ifdef LIBXML_HTML_ENABLED
+	if (ctxt->myDoc == NULL)
+	    ctxt->myDoc = htmlNewDocNoDtD(NULL, NULL);
+	if (ctxt->myDoc == NULL) {
+	    if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
+		ctxt->sax->error(ctxt->userData, 
+		     "SAX.xmlSAX2StartDocument(): out of memory\n");
+	    ctxt->errNo = XML_ERR_NO_MEMORY;
+	    ctxt->instate = XML_PARSER_EOF;
+	    ctxt->disableSAX = 1;
+	    return;
+	}
+#else
+        xmlGenericError(xmlGenericErrorContext,
+		"libxml2 built without HTML support\n");
+	ctxt->errNo = XML_ERR_INTERNAL_ERROR;
+	ctxt->instate = XML_PARSER_EOF;
+	ctxt->disableSAX = 1;
+	return;
+#endif
+    } else {
+	doc = ctxt->myDoc = xmlNewDoc(ctxt->version);
+	if (doc != NULL) {
+	    if (ctxt->encoding != NULL)
+		doc->encoding = xmlStrdup(ctxt->encoding);
+	    else
+		doc->encoding = NULL;
+	    doc->standalone = ctxt->standalone;
+	} else {
+	    if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
+		ctxt->sax->error(ctxt->userData, 
+		     "SAX.xmlSAX2StartDocument(): out of memory\n");
+	    ctxt->errNo = XML_ERR_NO_MEMORY;
+	    ctxt->instate = XML_PARSER_EOF;
+	    ctxt->disableSAX = 1;
+	    return;
+	}
+	if ((ctxt->dictNames) && (doc != NULL)) {
+	    doc->dict = ctxt->dict;
+	    xmlDictReference(doc->dict);
+	}
+    }
+    if ((ctxt->myDoc != NULL) && (ctxt->myDoc->URL == NULL) &&
+	(ctxt->input != NULL) && (ctxt->input->filename != NULL)) {
+	ctxt->myDoc->URL = xmlCanonicPath((const xmlChar *) ctxt->input->filename);
+	if (ctxt->myDoc->URL == NULL)
+	    ctxt->myDoc->URL = xmlStrdup((const xmlChar *) ctxt->input->filename);
+    }
+}
+
+/**
+ * xmlSAX2EndDocument:
+ * @ctx: the user data (XML parser context)
+ *
+ * called when the document end has been detected.
+ */
+void
+xmlSAX2EndDocument(void *ctx)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+#ifdef DEBUG_SAX
+    xmlGenericError(xmlGenericErrorContext,
+	    "SAX.xmlSAX2EndDocument()\n");
+#endif
+#ifdef LIBXML_VALID_ENABLED
+    if (ctxt->validate && ctxt->wellFormed &&
+        ctxt->myDoc && ctxt->myDoc->intSubset)
+	ctxt->valid &= xmlValidateDocumentFinal(&ctxt->vctxt, ctxt->myDoc);
+#endif /* LIBXML_VALID_ENABLED */
+
+    /*
+     * Grab the encoding if it was added on-the-fly
+     */
+    if ((ctxt->encoding != NULL) && (ctxt->myDoc != NULL) &&
+	(ctxt->myDoc->encoding == NULL)) {
+	ctxt->myDoc->encoding = ctxt->encoding;
+	ctxt->encoding = NULL;
+    }
+    if ((ctxt->inputTab[0]->encoding != NULL) && (ctxt->myDoc != NULL) &&
+	(ctxt->myDoc->encoding == NULL)) {
+	ctxt->myDoc->encoding = xmlStrdup(ctxt->inputTab[0]->encoding);
+    }
+    if ((ctxt->charset != XML_CHAR_ENCODING_NONE) && (ctxt->myDoc != NULL) &&
+	(ctxt->myDoc->charset == XML_CHAR_ENCODING_NONE)) {
+	ctxt->myDoc->charset = ctxt->charset;
+    }
+}
+
+#if defined(LIBXML_SAX1_ENABLED) || defined(LIBXML_HTML_ENABLED)
+/**
+ * xmlSAX2AttributeInternal:
+ * @ctx: the user data (XML parser context)
+ * @fullname:  The attribute name, including namespace prefix
+ * @value:  The attribute value
+ * @prefix: the prefix on the element node
+ *
+ * Handle an attribute that has been read by the parser.
+ * The default handling is to convert the attribute into an
+ * DOM subtree and past it in a new xmlAttr element added to
+ * the element.
+ */
+static void
+xmlSAX2AttributeInternal(void *ctx, const xmlChar *fullname,
+             const xmlChar *value, const xmlChar *prefix ATTRIBUTE_UNUSED)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+    xmlAttrPtr ret;
+    xmlChar *name;
+    xmlChar *ns;
+    xmlChar *nval;
+    xmlNsPtr namespace;
+
+    /*
+     * Split the full name into a namespace prefix and the tag name
+     */
+    name = xmlSplitQName(ctxt, fullname, &ns);
+    if ((name != NULL) && (name[0] == 0)) {
+        if (xmlStrEqual(ns, BAD_CAST "xmlns")) {
+	    if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
+		ctxt->sax->error(ctxt->userData, 
+		     "invalid namespace declaration '%s'\n", fullname);
+	} else {
+	    if ((ctxt->sax != NULL) && (ctxt->sax->warning != NULL))
+		ctxt->sax->warning(ctxt->userData, 
+		     "Avoid attribute ending with ':' like '%s'\n", fullname);
+	}
+	if (ns != NULL)
+	    xmlFree(ns);
+	ns = NULL;
+	xmlFree(name);
+	name = xmlStrdup(fullname);
+    }
+    if (name == NULL) {
+	if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
+	    ctxt->sax->error(ctxt->userData, 
+		 "SAX.xmlSAX2StartElement(): out of memory\n");
+	ctxt->errNo = XML_ERR_NO_MEMORY;
+	ctxt->instate = XML_PARSER_EOF;
+	ctxt->disableSAX = 1;
+	if (ns != NULL)
+	    xmlFree(ns);
+	return;
+    }
+
+#ifdef LIBXML_VALID_ENABLED
+    /*
+     * Do the last stage of the attribute normalization
+     * Needed for HTML too:
+     *   http://www.w3.org/TR/html4/types.html#h-6.2
+     */
+    ctxt->vctxt.valid = 1;
+    nval = xmlValidCtxtNormalizeAttributeValue(&ctxt->vctxt,
+	                                   ctxt->myDoc, ctxt->node,
+					   fullname, value);
+    if (ctxt->vctxt.valid != 1) {
+	ctxt->valid = 0;
+    }
+    if (nval != NULL)
+	value = nval;
+#else
+    nval = NULL;
+#endif /* LIBXML_VALID_ENABLED */
+
+    /*
+     * Check whether it's a namespace definition
+     */
+    if ((!ctxt->html) && (ns == NULL) &&
+        (name[0] == 'x') && (name[1] == 'm') && (name[2] == 'l') &&
+        (name[3] == 'n') && (name[4] == 's') && (name[5] == 0)) {
+	xmlNsPtr nsret;
+	xmlChar *val;
+
+        if (!ctxt->replaceEntities) {
+	    ctxt->depth++;
+	    val = xmlStringDecodeEntities(ctxt, value, XML_SUBSTITUTE_REF,
+		                          0,0,0);
+	    ctxt->depth--;
+	} else {
+	    val = (xmlChar *) value;
+	}
+
+	if (val[0] != 0) {
+	    xmlURIPtr uri;
+
+	    uri = xmlParseURI((const char *)val);
+	    if (uri == NULL) {
+		if ((ctxt->sax != NULL) && (ctxt->sax->warning != NULL))
+		    ctxt->sax->warning(ctxt->userData, 
+			 "xmlns: %s not a valid URI\n", val);
+	    } else {
+		if (uri->scheme == NULL) {
+		    if ((ctxt->sax != NULL) && (ctxt->sax->warning != NULL))
+			ctxt->sax->warning(ctxt->userData, 
+			     "xmlns: URI %s is not absolute\n", val);
+		}
+		xmlFreeURI(uri);
+	    }
+	}
+
+	/* a default namespace definition */
+	nsret = xmlNewNs(ctxt->node, val, NULL);
+
+#ifdef LIBXML_VALID_ENABLED
+	/*
+	 * Validate also for namespace decls, they are attributes from
+	 * an XML-1.0 perspective
+	 */
+        if (nsret != NULL && ctxt->validate && ctxt->wellFormed &&
+	    ctxt->myDoc && ctxt->myDoc->intSubset)
+	    ctxt->valid &= xmlValidateOneNamespace(&ctxt->vctxt, ctxt->myDoc,
+					   ctxt->node, prefix, nsret, val);
+#endif /* LIBXML_VALID_ENABLED */
+	if (name != NULL) 
+	    xmlFree(name);
+	if (nval != NULL)
+	    xmlFree(nval);
+	if (val != value)
+	    xmlFree(val);
+	return;
+    }
+    if ((!ctxt->html) &&
+	(ns != NULL) && (ns[0] == 'x') && (ns[1] == 'm') && (ns[2] == 'l') &&
+        (ns[3] == 'n') && (ns[4] == 's') && (ns[5] == 0)) {
+	xmlNsPtr nsret;
+	xmlChar *val;
+
+        if (!ctxt->replaceEntities) {
+	    ctxt->depth++;
+	    val = xmlStringDecodeEntities(ctxt, value, XML_SUBSTITUTE_REF,
+		                          0,0,0);
+	    ctxt->depth--;
+	    if (val == NULL) {
+		if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
+		    ctxt->sax->error(ctxt->userData, 
+			 "SAX.xmlSAX2StartElement(): out of memory\n");
+		ctxt->errNo = XML_ERR_NO_MEMORY;
+		ctxt->instate = XML_PARSER_EOF;
+		ctxt->disableSAX = 1;
+	        xmlFree(ns);
+		if (name != NULL) 
+		    xmlFree(name);
+		return;
+	    }
+	} else {
+	    val = (xmlChar *) value;
+	}
+
+	if (val[0] == 0) {
+	    if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
+		ctxt->sax->error(ctxt->userData, 
+		     "Empty namespace name for prefix %s\n", name);
+	}
+	if ((ctxt->pedantic != 0) && (val[0] != 0)) {
+	    xmlURIPtr uri;
+
+	    uri = xmlParseURI((const char *)val);
+	    if (uri == NULL) {
+		if ((ctxt->sax != NULL) && (ctxt->sax->warning != NULL))
+		    ctxt->sax->warning(ctxt->userData, 
+			 "xmlns:%s: %s not a valid URI\n", name, value);
+	    } else {
+		if (uri->scheme == NULL) {
+		    if ((ctxt->sax != NULL) && (ctxt->sax->warning != NULL))
+			ctxt->sax->warning(ctxt->userData, 
+			   "xmlns:%s: URI %s is not absolute\n", name, value);
+		}
+		xmlFreeURI(uri);
+	    }
+	}
+
+	/* a standard namespace definition */
+	nsret = xmlNewNs(ctxt->node, val, name);
+	xmlFree(ns);
+#ifdef LIBXML_VALID_ENABLED
+	/*
+	 * Validate also for namespace decls, they are attributes from
+	 * an XML-1.0 perspective
+	 */
+        if (nsret != NULL && ctxt->validate && ctxt->wellFormed &&
+	    ctxt->myDoc && ctxt->myDoc->intSubset)
+	    ctxt->valid &= xmlValidateOneNamespace(&ctxt->vctxt, ctxt->myDoc,
+					   ctxt->node, prefix, nsret, value);
+#endif /* LIBXML_VALID_ENABLED */
+	if (name != NULL) 
+	    xmlFree(name);
+	if (nval != NULL)
+	    xmlFree(nval);
+	if (val != value)
+	    xmlFree(val);
+	return;
+    }
+
+    if (ns != NULL) {
+	xmlAttrPtr prop;
+	namespace = xmlSearchNs(ctxt->myDoc, ctxt->node, ns);
+	if (namespace == NULL) {
+	    if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
+		ctxt->sax->error(ctxt->userData, 
+		    "Namespace prefix %s of attribute %s is not defined\n",
+		             ns, name);
+	}
+
+	prop = ctxt->node->properties;
+	while (prop != NULL) {
+	    if (prop->ns != NULL) {
+		if ((xmlStrEqual(name, prop->name)) &&
+		    ((namespace == prop->ns) ||
+		     (xmlStrEqual(namespace->href, prop->ns->href)))) {
+		    ctxt->errNo = XML_ERR_ATTRIBUTE_REDEFINED;
+		    if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
+			ctxt->sax->error(ctxt->userData,
+			        "Attribute %s in %s redefined\n",
+			                 name, namespace->href);
+		    ctxt->wellFormed = 0;
+		    if (ctxt->recovery == 0) ctxt->disableSAX = 1;
+		    goto error;
+		}
+	    }
+	    prop = prop->next;
+	}
+    } else {
+	namespace = NULL;
+    }
+
+    /* !!!!!! <a toto:arg="" xmlns:toto="http://toto.com"> */
+    ret = xmlNewNsPropEatName(ctxt->node, namespace, name, NULL);
+
+    if (ret != NULL) {
+        if ((ctxt->replaceEntities == 0) && (!ctxt->html)) {
+	    xmlNodePtr tmp;
+
+	    ret->children = xmlStringGetNodeList(ctxt->myDoc, value);
+	    tmp = ret->children;
+	    while (tmp != NULL) {
+		tmp->parent = (xmlNodePtr) ret;
+		if (tmp->next == NULL)
+		    ret->last = tmp;
+		tmp = tmp->next;
+	    }
+	} else if (value != NULL) {
+	    ret->children = xmlNewDocText(ctxt->myDoc, value);
+	    ret->last = ret->children;
+	    if (ret->children != NULL)
+		ret->children->parent = (xmlNodePtr) ret;
+	}
+    }
+
+#ifdef LIBXML_VALID_ENABLED
+    if ((!ctxt->html) && ctxt->validate && ctxt->wellFormed &&
+        ctxt->myDoc && ctxt->myDoc->intSubset) {
+	
+	/*
+	 * If we don't substitute entities, the validation should be
+	 * done on a value with replaced entities anyway.
+	 */
+        if (!ctxt->replaceEntities) {
+	    xmlChar *val;
+
+	    ctxt->depth++;
+	    val = xmlStringDecodeEntities(ctxt, value, XML_SUBSTITUTE_REF,
+		                          0,0,0);
+	    ctxt->depth--;
+	    
+	    if (val == NULL)
+		ctxt->valid &= xmlValidateOneAttribute(&ctxt->vctxt,
+				ctxt->myDoc, ctxt->node, ret, value);
+	    else {
+		xmlChar *nvalnorm;
+
+		/*
+		 * Do the last stage of the attribute normalization
+		 * It need to be done twice ... it's an extra burden related
+		 * to the ability to keep xmlSAX2References in attributes
+		 */
+		nvalnorm = xmlValidNormalizeAttributeValue(ctxt->myDoc,
+					    ctxt->node, fullname, val);
+		if (nvalnorm != NULL) {
+		    xmlFree(val);
+		    val = nvalnorm;
+		}
+
+		ctxt->valid &= xmlValidateOneAttribute(&ctxt->vctxt,
+			        ctxt->myDoc, ctxt->node, ret, val);
+                xmlFree(val);
+	    }
+	} else {
+	    ctxt->valid &= xmlValidateOneAttribute(&ctxt->vctxt, ctxt->myDoc,
+					       ctxt->node, ret, value);
+	}
+    } else
+#endif /* LIBXML_VALID_ENABLED */
+           if (((ctxt->loadsubset & XML_SKIP_IDS) == 0) &&
+	       (((ctxt->replaceEntities == 0) && (ctxt->external != 2)) ||
+	        ((ctxt->replaceEntities != 0) && (ctxt->inSubset == 0)))) {
+        /*
+	 * when validating, the ID registration is done at the attribute
+	 * validation level. Otherwise we have to do specific handling here.
+	 */
+	if (xmlIsID(ctxt->myDoc, ctxt->node, ret))
+	    xmlAddID(&ctxt->vctxt, ctxt->myDoc, value, ret);
+	else if (xmlIsRef(ctxt->myDoc, ctxt->node, ret))
+	    xmlAddRef(&ctxt->vctxt, ctxt->myDoc, value, ret);
+	else if (xmlStrEqual(fullname, BAD_CAST "xml:id")) {
+	    /*
+	     * Add the xml:id value
+	     *
+	     * Open issue: normalization of the value.
+	     */
+	    if (xmlValidateNCName(value, 1) != 0) {
+	        xmlErrValid(ctxt, XML_DTD_XMLID_VALUE,
+		      "xml:id : attribute value %s is not an NCName\n",
+			    (const char *) value, NULL);
+	    }
+	    xmlAddID(&ctxt->vctxt, ctxt->myDoc, value, ret);
+	}
+    }
+
+error:
+    if (nval != NULL)
+	xmlFree(nval);
+    if (ns != NULL) 
+	xmlFree(ns);
+}
+
+/*
+ * xmlCheckDefaultedAttributes:
+ *
+ * Check defaulted attributes from the DTD
+ */
+static void
+xmlCheckDefaultedAttributes(xmlParserCtxtPtr ctxt, const xmlChar *name,
+	const xmlChar *prefix, const xmlChar **atts) {
+    xmlElementPtr elemDecl;
+    const xmlChar *att;
+    int internal = 1;
+    int i;
+
+    elemDecl = xmlGetDtdQElementDesc(ctxt->myDoc->intSubset, name, prefix);
+    if (elemDecl == NULL) {
+	elemDecl = xmlGetDtdQElementDesc(ctxt->myDoc->extSubset, name, prefix);
+	internal = 0;
+    }
+
+process_external_subset:
+
+    if (elemDecl != NULL) {
+	xmlAttributePtr attr = elemDecl->attributes;
+	/*
+	 * Check against defaulted attributes from the external subset
+	 * if the document is stamped as standalone
+	 */
+	if ((ctxt->myDoc->standalone == 1) &&
+	    (ctxt->myDoc->extSubset != NULL) &&
+	    (ctxt->validate)) {
+	    while (attr != NULL) {
+		if ((attr->defaultValue != NULL) &&
+		    (xmlGetDtdQAttrDesc(ctxt->myDoc->extSubset,
+					attr->elem, attr->name,
+					attr->prefix) == attr) &&
+		    (xmlGetDtdQAttrDesc(ctxt->myDoc->intSubset,
+					attr->elem, attr->name,
+					attr->prefix) == NULL)) {
+		    xmlChar *fulln;
+
+		    if (attr->prefix != NULL) {
+			fulln = xmlStrdup(attr->prefix);
+			fulln = xmlStrcat(fulln, BAD_CAST ":");
+			fulln = xmlStrcat(fulln, attr->name);
+		    } else {
+			fulln = xmlStrdup(attr->name);
+		    }
+
+		    /*
+		     * Check that the attribute is not declared in the
+		     * serialization
+		     */
+		    att = NULL;
+		    if (atts != NULL) {
+			i = 0;
+			att = atts[i];
+			while (att != NULL) {
+			    if (xmlStrEqual(att, fulln))
+				break;
+			    i += 2;
+			    att = atts[i];
+			}
+		    }
+		    if (att == NULL) {
+		        xmlErrValid(ctxt, XML_DTD_STANDALONE_DEFAULTED,
+      "standalone: attribute %s on %s defaulted from external subset\n",
+				    (const char *)fulln,
+				    (const char *)attr->elem);
+		    }
+		}
+		attr = attr->nexth;
+	    }
+	}
+
+	/*
+	 * Actually insert defaulted values when needed
+	 */
+	attr = elemDecl->attributes;
+	while (attr != NULL) {
+	    /*
+	     * Make sure that attributes redefinition occuring in the
+	     * internal subset are not overriden by definitions in the
+	     * external subset.
+	     */
+	    if (attr->defaultValue != NULL) {
+		/*
+		 * the element should be instantiated in the tree if:
+		 *  - this is a namespace prefix
+		 *  - the user required for completion in the tree
+		 *    like XSLT
+		 *  - there isn't already an attribute definition 
+		 *    in the internal subset overriding it.
+		 */
+		if (((attr->prefix != NULL) &&
+		     (xmlStrEqual(attr->prefix, BAD_CAST "xmlns"))) ||
+		    ((attr->prefix == NULL) &&
+		     (xmlStrEqual(attr->name, BAD_CAST "xmlns"))) ||
+		    (ctxt->loadsubset & XML_COMPLETE_ATTRS)) {
+		    xmlAttributePtr tst;
+
+		    tst = xmlGetDtdQAttrDesc(ctxt->myDoc->intSubset,
+					     attr->elem, attr->name,
+					     attr->prefix);
+		    if ((tst == attr) || (tst == NULL)) {
+		        xmlChar fn[50];
+			xmlChar *fulln;
+
+                        fulln = xmlBuildQName(attr->name, attr->prefix, fn, 50);
+			if (fulln == NULL) {
+			    if ((ctxt->sax != NULL) &&
+			        (ctxt->sax->error != NULL))
+				ctxt->sax->error(ctxt->userData, 
+				     "SAX.xmlSAX2StartElement(): out of memory\n");
+			    ctxt->errNo = XML_ERR_NO_MEMORY;
+			    ctxt->instate = XML_PARSER_EOF;
+			    ctxt->disableSAX = 1;
+			    return;
+			}
+
+			/*
+			 * Check that the attribute is not declared in the
+			 * serialization
+			 */
+			att = NULL;
+			if (atts != NULL) {
+			    i = 0;
+			    att = atts[i];
+			    while (att != NULL) {
+				if (xmlStrEqual(att, fulln))
+				    break;
+				i += 2;
+				att = atts[i];
+			    }
+			}
+			if (att == NULL) {
+			    xmlSAX2AttributeInternal(ctxt, fulln,
+						 attr->defaultValue, prefix);
+			}
+			if ((fulln != fn) && (fulln != attr->name))
+			    xmlFree(fulln);
+		    }
+		}
+	    }
+	    attr = attr->nexth;
+	}
+	if (internal == 1) {
+	    elemDecl = xmlGetDtdQElementDesc(ctxt->myDoc->extSubset,
+		                             name, prefix);
+	    internal = 0;
+	    goto process_external_subset;
+	}
+    }
+}
+
+/**
+ * xmlSAX2StartElement:
+ * @ctx: the user data (XML parser context)
+ * @fullname:  The element name, including namespace prefix
+ * @atts:  An array of name/value attributes pairs, NULL terminated
+ *
+ * called when an opening tag has been processed.
+ */
+void
+xmlSAX2StartElement(void *ctx, const xmlChar *fullname, const xmlChar **atts)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+    xmlNodePtr ret;
+    xmlNodePtr parent = ctxt->node;
+    xmlNsPtr ns;
+    xmlChar *name;
+    xmlChar *prefix;
+    const xmlChar *att;
+    const xmlChar *value;
+    int i;
+
+#ifdef DEBUG_SAX
+    xmlGenericError(xmlGenericErrorContext,
+	    "SAX.xmlSAX2StartElement(%s)\n", fullname);
+#endif
+
+    /*
+     * First check on validity:
+     */
+    if (ctxt->validate && (ctxt->myDoc->extSubset == NULL) && 
+        ((ctxt->myDoc->intSubset == NULL) ||
+	 ((ctxt->myDoc->intSubset->notations == NULL) && 
+	  (ctxt->myDoc->intSubset->elements == NULL) &&
+	  (ctxt->myDoc->intSubset->attributes == NULL) && 
+	  (ctxt->myDoc->intSubset->entities == NULL)))) {
+	xmlErrValid(ctxt, XML_ERR_NO_DTD,
+	  "Validation failed: no DTD found !", NULL, NULL);
+	ctxt->validate = 0;
+    }
+       
+
+    /*
+     * Split the full name into a namespace prefix and the tag name
+     */
+    name = xmlSplitQName(ctxt, fullname, &prefix);
+
+
+    /*
+     * Note : the namespace resolution is deferred until the end of the
+     *        attributes parsing, since local namespace can be defined as
+     *        an attribute at this level.
+     */
+    ret = xmlNewDocNodeEatName(ctxt->myDoc, NULL, name, NULL);
+    if (ret == NULL) {
+        if (prefix != NULL)
+	    xmlFree(prefix);
+	ctxt->errNo = XML_ERR_NO_MEMORY;
+	ctxt->instate = XML_PARSER_EOF;
+	ctxt->disableSAX = 1;
+        return;
+    }
+    if (ctxt->myDoc->children == NULL) {
+#ifdef DEBUG_SAX_TREE
+	xmlGenericError(xmlGenericErrorContext, "Setting %s as root\n", name);
+#endif
+        xmlAddChild((xmlNodePtr) ctxt->myDoc, (xmlNodePtr) ret);
+    } else if (parent == NULL) {
+        parent = ctxt->myDoc->children;
+    }
+    ctxt->nodemem = -1;
+    if (ctxt->linenumbers) {
+	if (ctxt->input != NULL) {
+	    if (ctxt->input->line < 65535)
+		ret->line = (short) ctxt->input->line;
+	    else
+	        ret->line = 65535;
+	}
+    }
+
+    /*
+     * We are parsing a new node.
+     */
+#ifdef DEBUG_SAX_TREE
+    xmlGenericError(xmlGenericErrorContext, "pushing(%s)\n", name);
+#endif
+    nodePush(ctxt, ret);
+
+    /*
+     * Link the child element
+     */
+    if (parent != NULL) {
+        if (parent->type == XML_ELEMENT_NODE) {
+#ifdef DEBUG_SAX_TREE
+	    xmlGenericError(xmlGenericErrorContext,
+		    "adding child %s to %s\n", name, parent->name);
+#endif
+	    xmlAddChild(parent, ret);
+	} else {
+#ifdef DEBUG_SAX_TREE
+	    xmlGenericError(xmlGenericErrorContext,
+		    "adding sibling %s to ", name);
+	    xmlDebugDumpOneNode(stderr, parent, 0);
+#endif
+	    xmlAddSibling(parent, ret);
+	}
+    }
+
+    /*
+     * Insert all the defaulted attributes from the DTD especially namespaces
+     */
+    if ((!ctxt->html) &&
+	((ctxt->myDoc->intSubset != NULL) ||
+	 (ctxt->myDoc->extSubset != NULL))) {
+	xmlCheckDefaultedAttributes(ctxt, name, prefix, atts);
+    }
+
+    /*
+     * process all the attributes whose name start with "xmlns"
+     */
+    if (atts != NULL) {
+        i = 0;
+	att = atts[i++];
+	value = atts[i++];
+	if (!ctxt->html) {
+	    while ((att != NULL) && (value != NULL)) {
+		if ((att[0] == 'x') && (att[1] == 'm') && (att[2] == 'l') &&
+		    (att[3] == 'n') && (att[4] == 's'))
+		    xmlSAX2AttributeInternal(ctxt, att, value, prefix);
+
+		att = atts[i++];
+		value = atts[i++];
+	    }
+	}
+    }
+
+    /*
+     * Search the namespace, note that since the attributes have been
+     * processed, the local namespaces are available.
+     */
+    ns = xmlSearchNs(ctxt->myDoc, ret, prefix);
+    if ((ns == NULL) && (parent != NULL))
+	ns = xmlSearchNs(ctxt->myDoc, parent, prefix);
+    if ((prefix != NULL) && (ns == NULL)) {
+	ns = xmlNewNs(ret, NULL, prefix);
+	if ((ctxt->sax != NULL) && (ctxt->sax->warning != NULL))
+	    ctxt->sax->warning(ctxt->userData, 
+		 "Namespace prefix %s is not defined\n", prefix);
+    }
+
+    /*
+     * set the namespace node, making sure that if the default namspace
+     * is unbound on a parent we simply kee it NULL
+     */
+    if ((ns != NULL) && (ns->href != NULL) &&
+	((ns->href[0] != 0) || (ns->prefix != NULL)))
+	xmlSetNs(ret, ns);
+
+    /*
+     * process all the other attributes
+     */
+    if (atts != NULL) {
+        i = 0;
+	att = atts[i++];
+	value = atts[i++];
+	if (ctxt->html) {
+	    while (att != NULL) {
+		xmlSAX2AttributeInternal(ctxt, att, value, NULL);
+		att = atts[i++];
+		value = atts[i++];
+	    }
+	} else {
+	    while ((att != NULL) && (value != NULL)) {
+		if ((att[0] != 'x') || (att[1] != 'm') || (att[2] != 'l') ||
+		    (att[3] != 'n') || (att[4] != 's'))
+		    xmlSAX2AttributeInternal(ctxt, att, value, NULL);
+
+		/*
+		 * Next ones
+		 */
+		att = atts[i++];
+		value = atts[i++];
+	    }
+	}
+    }
+
+#ifdef LIBXML_VALID_ENABLED
+    /*
+     * If it's the Document root, finish the DTD validation and
+     * check the document root element for validity
+     */
+    if ((ctxt->validate) && (ctxt->vctxt.finishDtd == 0)) {
+	int chk;
+
+	chk = xmlValidateDtdFinal(&ctxt->vctxt, ctxt->myDoc);
+	if (chk <= 0)
+	    ctxt->valid = 0;
+	if (chk < 0)
+	    ctxt->wellFormed = 0;
+	ctxt->valid &= xmlValidateRoot(&ctxt->vctxt, ctxt->myDoc);
+	ctxt->vctxt.finishDtd = 1;
+    }
+#endif /* LIBXML_VALID_ENABLED */
+
+    if (prefix != NULL)
+	xmlFree(prefix);
+
+}
+
+/**
+ * xmlSAX2EndElement:
+ * @ctx: the user data (XML parser context)
+ * @name:  The element name
+ *
+ * called when the end of an element has been detected.
+ */
+void
+xmlSAX2EndElement(void *ctx, const xmlChar *name ATTRIBUTE_UNUSED)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+    xmlParserNodeInfo node_info;
+    xmlNodePtr cur = ctxt->node;
+
+#ifdef DEBUG_SAX
+    if (name == NULL)
+        xmlGenericError(xmlGenericErrorContext, "SAX.xmlSAX2EndElement(NULL)\n");
+    else
+	xmlGenericError(xmlGenericErrorContext, "SAX.xmlSAX2EndElement(%s)\n", name);
+#endif
+    
+    /* Capture end position and add node */
+    if (cur != NULL && ctxt->record_info) {
+      node_info.end_pos = ctxt->input->cur - ctxt->input->base;
+      node_info.end_line = ctxt->input->line;
+      node_info.node = cur;
+      xmlParserAddNodeInfo(ctxt, &node_info);
+    }
+    ctxt->nodemem = -1;
+
+#ifdef LIBXML_VALID_ENABLED
+    if (ctxt->validate && ctxt->wellFormed &&
+        ctxt->myDoc && ctxt->myDoc->intSubset)
+        ctxt->valid &= xmlValidateOneElement(&ctxt->vctxt, ctxt->myDoc,
+					     cur);
+#endif /* LIBXML_VALID_ENABLED */
+
+    
+    /*
+     * end of parsing of this node.
+     */
+#ifdef DEBUG_SAX_TREE
+    xmlGenericError(xmlGenericErrorContext, "popping(%s)\n", cur->name);
+#endif
+    nodePop(ctxt);
+}
+#endif /* LIBXML_SAX1_ENABLED || LIBXML_HTML_ENABLE */
+
+/*
+ * xmlSAX2TextNode:
+ * @ctxt:  the parser context
+ * @str:  the input string
+ * @len: the string length
+ * 
+ * Remove the entities from an attribute value
+ *
+ * Returns the newly allocated string or NULL if not needed or error
+ */
+static xmlNodePtr
+xmlSAX2TextNode(xmlParserCtxtPtr ctxt, const xmlChar *str, int len) {
+    xmlNodePtr ret;
+    const xmlChar *intern = NULL;
+
+    /*
+     * Allocate
+     */
+    if (ctxt->freeElems != NULL) {
+	ret = ctxt->freeElems;
+	ctxt->freeElems = ret->next;
+	ctxt->freeElemsNr--;
+    } else {
+	ret = (xmlNodePtr) xmlMalloc(sizeof(xmlNode));
+    }
+    if (ret == NULL) {
+	if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
+	    ctxt->sax->error(ctxt->userData, 
+		 "SAX.xmlSAX2Characters(): out of memory\n");
+	ctxt->errNo = XML_ERR_NO_MEMORY;
+	ctxt->instate = XML_PARSER_EOF;
+	ctxt->disableSAX = 1;
+	return(NULL);
+    }
+    /*
+     * intern the formatting blanks found between tags, or the
+     * very short strings
+     */
+    if (ctxt->dictNames) {
+        xmlChar cur = str[len];
+
+	if ((len <= 3) && ((cur == '"') || (cur == '\'') ||
+	    ((cur == '<') && (str[len + 1] != '!')))) {
+	    intern = xmlDictLookup(ctxt->dict, str, len);
+	} else if (IS_BLANK_CH(*str) && (len < 60) && (cur == '<') &&
+	           (str[len + 1] != '!')) {
+	    int i;
+
+	    for (i = 1;i < len;i++) {
+		if (!IS_BLANK_CH(str[i])) goto skip;
+	    }
+	    intern = xmlDictLookup(ctxt->dict, str, len);
+	}
+    }
+skip:
+    memset(ret, 0, sizeof(xmlNode));
+    ret->type = XML_TEXT_NODE;
+
+    ret->name = xmlStringText;
+    if (intern == NULL)
+	ret->content = xmlStrndup(str, len);
+    else
+	ret->content = (xmlChar *) intern;
+
+    if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue))
+	xmlRegisterNodeDefaultValue(ret);
+    return(ret);
+}
+
+#ifdef LIBXML_VALID_ENABLED
+/*
+ * xmlSAX2DecodeAttrEntities:
+ * @ctxt:  the parser context
+ * @str:  the input string
+ * @len: the string length
+ * 
+ * Remove the entities from an attribute value
+ *
+ * Returns the newly allocated string or NULL if not needed or error
+ */
+static xmlChar *
+xmlSAX2DecodeAttrEntities(xmlParserCtxtPtr ctxt, const xmlChar *str,
+                          const xmlChar *end) {
+    const xmlChar *in;
+    xmlChar *ret;
+
+    in = str;
+    while (in < end)
+        if (*in++ == '&')
+	    goto decode;
+    return(NULL);
+decode:
+    ctxt->depth++;
+    ret = xmlStringLenDecodeEntities(ctxt, str, end - str,
+				     XML_SUBSTITUTE_REF, 0,0,0);
+    ctxt->depth--;
+    return(ret);
+}
+#endif /* LIBXML_VALID_ENABLED */
+
+/**
+ * xmlSAX2AttributeNs:
+ * @ctx: the user data (XML parser context)
+ * @localname:  the local name of the attribute
+ * @prefix:  the attribute namespace prefix if available
+ * @URI:  the attribute namespace name if available
+ * @value:  Start of the attribute value
+ * @valueend: end of the attribute value
+ *
+ * Handle an attribute that has been read by the parser.
+ * The default handling is to convert the attribute into an
+ * DOM subtree and past it in a new xmlAttr element added to
+ * the element.
+ */
+static void
+xmlSAX2AttributeNs(xmlParserCtxtPtr ctxt,
+                   const xmlChar * localname,
+                   const xmlChar * prefix,
+		   const xmlChar * value,
+		   const xmlChar * valueend)
+{
+    xmlAttrPtr ret;
+    xmlNsPtr namespace = NULL;
+    xmlChar *dup = NULL;
+
+    /*
+     * Note: if prefix == NULL, the attribute is not in the default namespace
+     */
+    if (prefix != NULL)
+	namespace = xmlSearchNs(ctxt->myDoc, ctxt->node, prefix);
+
+    /*
+     * allocate the node
+     */
+    if (ctxt->freeAttrs != NULL) {
+        ret = ctxt->freeAttrs;
+	ctxt->freeAttrs = ret->next;
+	ctxt->freeAttrsNr--;
+	memset(ret, 0, sizeof(xmlAttr));
+	ret->type = XML_ATTRIBUTE_NODE;
+
+	ret->parent = ctxt->node; 
+	ret->doc = ctxt->myDoc;
+	ret->ns = namespace;
+
+	if (ctxt->dictNames)
+	    ret->name = localname;
+	else
+	    ret->name = xmlStrdup(localname);
+
+        /* link at the end to preserv order, TODO speed up with a last */
+	if (ctxt->node->properties == NULL) {
+	    ctxt->node->properties = ret;
+	} else {
+	    xmlAttrPtr prev = ctxt->node->properties;
+
+	    while (prev->next != NULL) prev = prev->next;
+	    prev->next = ret;
+	    ret->prev = prev;
+	}
+
+	if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue))
+	    xmlRegisterNodeDefaultValue((xmlNodePtr)ret);
+    } else {
+	if (ctxt->dictNames)
+	    ret = xmlNewNsPropEatName(ctxt->node, namespace, 
+	                              (xmlChar *) localname, NULL);
+	else
+	    ret = xmlNewNsProp(ctxt->node, namespace, localname, NULL);
+	if (ret == NULL) {
+	    ctxt->errNo = XML_ERR_NO_MEMORY;
+	    ctxt->instate = XML_PARSER_EOF;
+	    ctxt->disableSAX = 1;
+	    return;
+	}
+    }
+
+    if ((ctxt->replaceEntities == 0) && (!ctxt->html)) {
+	xmlNodePtr tmp;
+
+	/*
+	 * We know that if there is an entity reference, then
+	 * the string has been dup'ed and terminates with 0
+	 * otherwise with ' or "
+	 */
+	if (*valueend != 0) {
+	    tmp = xmlSAX2TextNode(ctxt, value, valueend - value);
+	    ret->children = tmp;
+	    ret->last = tmp;
+	    if (tmp != NULL) {
+		tmp->doc = ret->doc;
+		tmp->parent = (xmlNodePtr) ret;
+	    }
+	} else {
+	    ret->children = xmlStringLenGetNodeList(ctxt->myDoc, value,
+						    valueend - value);
+	    tmp = ret->children;
+	    while (tmp != NULL) {
+		tmp->parent = (xmlNodePtr) ret;
+		if (tmp->next == NULL)
+		    ret->last = tmp;
+		tmp = tmp->next;
+	    }
+	}
+    } else if (value != NULL) {
+	xmlNodePtr tmp;
+
+	tmp = xmlSAX2TextNode(ctxt, value, valueend - value);
+	ret->children = tmp;
+	ret->last = tmp;
+	if (tmp != NULL) {
+	    tmp->doc = ret->doc;
+	    tmp->parent = (xmlNodePtr) ret;
+	}
+    }
+
+#ifdef LIBXML_VALID_ENABLED
+    if ((!ctxt->html) && ctxt->validate && ctxt->wellFormed &&
+        ctxt->myDoc && ctxt->myDoc->intSubset) {
+	/*
+	 * If we don't substitute entities, the validation should be
+	 * done on a value with replaced entities anyway.
+	 */
+        if (!ctxt->replaceEntities) {
+	    dup = xmlSAX2DecodeAttrEntities(ctxt, value, valueend);
+	    if (dup == NULL) {
+	        if (*valueend == 0) {
+		    ctxt->valid &= xmlValidateOneAttribute(&ctxt->vctxt,
+				    ctxt->myDoc, ctxt->node, ret, value);
+		} else {
+		    /*
+		     * That should already be normalized.
+		     * cheaper to finally allocate here than duplicate
+		     * entry points in the full validation code
+		     */
+		    dup = xmlStrndup(value, valueend - value);
+
+		    ctxt->valid &= xmlValidateOneAttribute(&ctxt->vctxt,
+				    ctxt->myDoc, ctxt->node, ret, dup);
+		}
+	    } else {
+	        /*
+		 * dup now contains a string of the flattened attribute
+		 * content with entities substitued. Check if we need to
+		 * apply an extra layer of normalization.
+		 * It need to be done twice ... it's an extra burden related
+		 * to the ability to keep references in attributes
+		 */
+		if (ctxt->attsSpecial != NULL) {
+		    xmlChar *nvalnorm;
+		    xmlChar fn[50];
+		    xmlChar *fullname;
+		    
+		    fullname = xmlBuildQName(localname, prefix, fn, 50);
+		    if (fullname != NULL) {
+			ctxt->vctxt.valid = 1;
+		        nvalnorm = xmlValidCtxtNormalizeAttributeValue(
+			                 &ctxt->vctxt, ctxt->myDoc,
+					 ctxt->node, fullname, dup);
+			if (ctxt->vctxt.valid != 1)
+			    ctxt->valid = 0;
+
+			if ((fullname != fn) && (fullname != localname))
+			    xmlFree(fullname);
+			if (nvalnorm != NULL) {
+			    xmlFree(dup);
+			    dup = nvalnorm;
+			}
+		    }
+		}
+
+		ctxt->valid &= xmlValidateOneAttribute(&ctxt->vctxt,
+			        ctxt->myDoc, ctxt->node, ret, dup);
+	    }
+	} else {
+	    /*
+	     * if entities already have been substitued, then
+	     * the attribute as passed is already normalized
+	     */
+	    dup = xmlStrndup(value, valueend - value);
+
+	    ctxt->valid &= xmlValidateOneAttribute(&ctxt->vctxt,
+	                             ctxt->myDoc, ctxt->node, ret, dup);
+	}
+    } else
+#endif /* LIBXML_VALID_ENABLED */
+           if (((ctxt->loadsubset & XML_SKIP_IDS) == 0) &&
+	       (((ctxt->replaceEntities == 0) && (ctxt->external != 2)) ||
+	        ((ctxt->replaceEntities != 0) && (ctxt->inSubset == 0)))) {
+        /*
+	 * when validating, the ID registration is done at the attribute
+	 * validation level. Otherwise we have to do specific handling here.
+	 */
+	if (xmlIsID(ctxt->myDoc, ctxt->node, ret)) {
+	    /* might be worth duplicate entry points and not copy */
+	    if (dup == NULL)
+	        dup = xmlStrndup(value, valueend - value);
+	    xmlAddID(&ctxt->vctxt, ctxt->myDoc, dup, ret);
+	} else if (xmlIsRef(ctxt->myDoc, ctxt->node, ret)) {
+	    if (dup == NULL)
+	        dup = xmlStrndup(value, valueend - value);
+	    xmlAddRef(&ctxt->vctxt, ctxt->myDoc, dup, ret);
+        } else if ((prefix == ctxt->str_xml) &&
+	           (localname[0] == 'i') && (localname[1] == 'd') &&
+		   (localname[2] == 0)) {
+	    /*
+	     * Add the xml:id value
+	     *
+	     * Open issue: normalization of the value.
+	     */
+	    if (dup == NULL)
+	        dup = xmlStrndup(value, valueend - value);
+	    if (xmlValidateNCName(dup, 1) != 0) {
+	        xmlErrValid(ctxt, XML_DTD_XMLID_VALUE,
+		      "xml:id : attribute value %s is not an NCName\n",
+			    (const char *) dup, NULL);
+	    }
+	    xmlAddID(&ctxt->vctxt, ctxt->myDoc, dup, ret);
+	}
+    }
+    if (dup != NULL)
+	xmlFree(dup);
+}
+
+/**
+ * xmlSAX2StartElementNs:
+ * @ctx:  the user data (XML parser context)
+ * @localname:  the local name of the element
+ * @prefix:  the element namespace prefix if available
+ * @URI:  the element namespace name if available
+ * @nb_namespaces:  number of namespace definitions on that node
+ * @namespaces:  pointer to the array of prefix/URI pairs namespace definitions
+ * @nb_attributes:  the number of attributes on that node
+ * @nb_defaulted:  the number of defaulted attributes.
+ * @attributes:  pointer to the array of (localname/prefix/URI/value/end)
+ *               attribute values.
+ *
+ * SAX2 callback when an element start has been detected by the parser.
+ * It provides the namespace informations for the element, as well as
+ * the new namespace declarations on the element.
+ */
+void
+xmlSAX2StartElementNs(void *ctx,
+                      const xmlChar *localname,
+		      const xmlChar *prefix,
+		      const xmlChar *URI,
+		      int nb_namespaces,
+		      const xmlChar **namespaces,
+		      int nb_attributes,
+		      int nb_defaulted,
+		      const xmlChar **attributes)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+    xmlNodePtr ret;
+    xmlNodePtr parent = ctxt->node;
+    xmlNsPtr last = NULL, ns;
+    const xmlChar *uri, *pref;
+    int i, j;
+
+    /*
+     * First check on validity:
+     */
+    if (ctxt->validate && (ctxt->myDoc->extSubset == NULL) && 
+        ((ctxt->myDoc->intSubset == NULL) ||
+	 ((ctxt->myDoc->intSubset->notations == NULL) && 
+	  (ctxt->myDoc->intSubset->elements == NULL) &&
+	  (ctxt->myDoc->intSubset->attributes == NULL) && 
+	  (ctxt->myDoc->intSubset->entities == NULL)))) {
+	xmlErrValid(ctxt, XML_ERR_NO_DTD,
+	  "Validation failed: no DTD found !", NULL, NULL);
+	ctxt->validate = 0;
+    }
+
+    /*
+     * allocate the node
+     */
+    if (ctxt->freeElems != NULL) {
+        ret = ctxt->freeElems;
+	ctxt->freeElems = ret->next;
+	ctxt->freeElemsNr--;
+	memset(ret, 0, sizeof(xmlNode));
+	ret->type = XML_ELEMENT_NODE;
+
+	if (ctxt->dictNames)
+	    ret->name = localname;
+	else
+	    ret->name = xmlStrdup(localname);
+
+	if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue))
+	    xmlRegisterNodeDefaultValue(ret);
+    } else {
+	if (ctxt->dictNames)
+	    ret = xmlNewDocNodeEatName(ctxt->myDoc, NULL, 
+	                               (xmlChar *) localname, NULL);
+	else
+	    ret = xmlNewDocNode(ctxt->myDoc, NULL, localname, NULL);
+	if (ret == NULL) {
+	    ctxt->errNo = XML_ERR_NO_MEMORY;
+	    ctxt->instate = XML_PARSER_EOF;
+	    ctxt->disableSAX = 1;
+	    return;
+	}
+    }
+    if (ctxt->linenumbers) {
+	if (ctxt->input != NULL) {
+	    if (ctxt->input->line < 65535)
+		ret->line = (short) ctxt->input->line;
+	    else
+	        ret->line = 65535;
+	}
+    }
+
+    if (ctxt->myDoc->children == NULL) {
+        xmlAddChild((xmlNodePtr) ctxt->myDoc, (xmlNodePtr) ret);
+    } else if (parent == NULL) {
+        parent = ctxt->myDoc->children;
+    }
+    /*
+     * Build the namespace list
+     */
+    for (i = 0,j = 0;j < nb_namespaces;j++) {
+        pref = namespaces[i++];
+	uri = namespaces[i++];
+	ns = xmlNewNs(NULL, uri, pref);
+	if (ns != NULL) {
+	    if (last == NULL) {
+	        ret->nsDef = last = ns;
+	    } else {
+	        last->next = ns;
+		last = ns;
+	    }
+	    if ((URI != NULL) && (prefix == pref))
+		ret->ns = ns;
+	} else {
+	    ctxt->errNo = XML_ERR_NO_MEMORY;
+	    ctxt->instate = XML_PARSER_EOF;
+	    ctxt->disableSAX = 1;
+	    return;
+	}
+#ifdef LIBXML_VALID_ENABLED
+	if ((!ctxt->html) && ctxt->validate && ctxt->wellFormed &&
+	    ctxt->myDoc && ctxt->myDoc->intSubset) {
+	    ctxt->valid &= xmlValidateOneNamespace(&ctxt->vctxt, ctxt->myDoc,
+	                                           ret, prefix, ns, uri);
+	}
+#endif /* LIBXML_VALID_ENABLED */
+    }
+    ctxt->nodemem = -1;
+
+    /*
+     * We are parsing a new node.
+     */
+    nodePush(ctxt, ret);
+
+    /*
+     * Link the child element
+     */
+    if (parent != NULL) {
+        if (parent->type == XML_ELEMENT_NODE) {
+	    xmlAddChild(parent, ret);
+	} else {
+	    xmlAddSibling(parent, ret);
+	}
+    }
+
+    /*
+     * Insert the defaulted attributes from the DTD only if requested:
+     */
+    if ((nb_defaulted != 0) &&
+        ((ctxt->loadsubset & XML_COMPLETE_ATTRS) == 0))
+	nb_attributes -= nb_defaulted;
+
+    /*
+     * Search the namespace if it wasn't already found
+     */
+    if ((URI != NULL) && (ret->ns == NULL)) {
+	ret->ns = xmlSearchNs(ctxt->myDoc, parent, prefix);
+	if (ret->ns == NULL) {
+	    ns = xmlNewNs(ret, NULL, prefix);
+	    if ((ctxt->sax != NULL) && (ctxt->sax->warning != NULL))
+		ctxt->sax->warning(ctxt->userData, 
+		     "Namespace prefix %s was not found\n", prefix);
+	}
+    }
+
+    /*
+     * process all the other attributes
+     */
+    if (nb_attributes > 0) {
+        for (j = 0,i = 0;i < nb_attributes;i++,j+=5) {
+	    xmlSAX2AttributeNs(ctxt, attributes[j], attributes[j+1],
+	                       attributes[j+3], attributes[j+4]);
+	}
+    }
+
+#ifdef LIBXML_VALID_ENABLED
+    /*
+     * If it's the Document root, finish the DTD validation and
+     * check the document root element for validity
+     */
+    if ((ctxt->validate) && (ctxt->vctxt.finishDtd == 0)) {
+	int chk;
+
+	chk = xmlValidateDtdFinal(&ctxt->vctxt, ctxt->myDoc);
+	if (chk <= 0)
+	    ctxt->valid = 0;
+	if (chk < 0)
+	    ctxt->wellFormed = 0;
+	ctxt->valid &= xmlValidateRoot(&ctxt->vctxt, ctxt->myDoc);
+	ctxt->vctxt.finishDtd = 1;
+    }
+#endif /* LIBXML_VALID_ENABLED */
+}
+
+/**
+ * xmlSAX2EndElementNs:
+ * @ctx:  the user data (XML parser context)
+ * @localname:  the local name of the element
+ * @prefix:  the element namespace prefix if available
+ * @URI:  the element namespace name if available
+ *
+ * SAX2 callback when an element end has been detected by the parser.
+ * It provides the namespace informations for the element.
+ */
+void
+xmlSAX2EndElementNs(void *ctx,
+                    const xmlChar * localname ATTRIBUTE_UNUSED,
+                    const xmlChar * prefix ATTRIBUTE_UNUSED,
+		    const xmlChar * URI ATTRIBUTE_UNUSED)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+    xmlParserNodeInfo node_info;
+    xmlNodePtr cur = ctxt->node;
+
+    /* Capture end position and add node */
+    if ((ctxt->record_info) && (cur != NULL)) {
+        node_info.end_pos = ctxt->input->cur - ctxt->input->base;
+        node_info.end_line = ctxt->input->line;
+        node_info.node = cur;
+        xmlParserAddNodeInfo(ctxt, &node_info);
+    }
+    ctxt->nodemem = -1;
+
+#ifdef LIBXML_VALID_ENABLED
+    if (ctxt->validate && ctxt->wellFormed &&
+        ctxt->myDoc && ctxt->myDoc->intSubset)
+        ctxt->valid &= xmlValidateOneElement(&ctxt->vctxt, ctxt->myDoc, cur);
+#endif /* LIBXML_VALID_ENABLED */
+
+    /*
+     * end of parsing of this node.
+     */
+    nodePop(ctxt);
+}
+
+/**
+ * xmlSAX2Reference:
+ * @ctx: the user data (XML parser context)
+ * @name:  The entity name
+ *
+ * called when an entity xmlSAX2Reference is detected. 
+ */
+void
+xmlSAX2Reference(void *ctx, const xmlChar *name)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+    xmlNodePtr ret;
+
+#ifdef DEBUG_SAX
+    xmlGenericError(xmlGenericErrorContext,
+	    "SAX.xmlSAX2Reference(%s)\n", name);
+#endif
+    if (name[0] == '#')
+	ret = xmlNewCharRef(ctxt->myDoc, name);
+    else
+	ret = xmlNewReference(ctxt->myDoc, name);
+#ifdef DEBUG_SAX_TREE
+    xmlGenericError(xmlGenericErrorContext,
+	    "add xmlSAX2Reference %s to %s \n", name, ctxt->node->name);
+#endif
+    xmlAddChild(ctxt->node, ret);
+}
+
+/**
+ * xmlSAX2Characters:
+ * @ctx: the user data (XML parser context)
+ * @ch:  a xmlChar string
+ * @len: the number of xmlChar
+ *
+ * receiving some chars from the parser.
+ */
+void
+xmlSAX2Characters(void *ctx, const xmlChar *ch, int len)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+    xmlNodePtr lastChild;
+
+#ifdef DEBUG_SAX
+    xmlGenericError(xmlGenericErrorContext,
+	    "SAX.xmlSAX2Characters(%.30s, %d)\n", ch, len);
+#endif
+    /*
+     * Handle the data if any. If there is no child
+     * add it as content, otherwise if the last child is text,
+     * concatenate it, else create a new node of type text.
+     */
+
+    if (ctxt->node == NULL) {
+#ifdef DEBUG_SAX_TREE
+	xmlGenericError(xmlGenericErrorContext,
+		"add chars: ctxt->node == NULL !\n");
+#endif
+        return;
+    }
+    lastChild = ctxt->node->last;
+#ifdef DEBUG_SAX_TREE
+    xmlGenericError(xmlGenericErrorContext,
+	    "add chars to %s \n", ctxt->node->name);
+#endif
+
+    /*
+     * Here we needed an accelerator mechanism in case of very large
+     * elements. Use an attribute in the structure !!!
+     */
+    if (lastChild == NULL) {
+        lastChild = xmlSAX2TextNode(ctxt, ch, len);
+	if (lastChild != NULL) {
+	    ctxt->node->children = lastChild;
+	    ctxt->node->last = lastChild;
+	    lastChild->parent = ctxt->node;
+	    lastChild->doc = ctxt->node->doc;
+	    ctxt->nodelen = len;
+	    ctxt->nodemem = len + 1;
+	}
+    } else {
+	int coalesceText = (lastChild != NULL) &&
+	    (lastChild->type == XML_TEXT_NODE) &&
+	    (lastChild->name == xmlStringText);
+	if ((coalesceText) && (ctxt->nodemem != 0)) {
+	    /*
+	     * The whole point of maintaining nodelen and nodemem,
+	     * xmlTextConcat is too costly, i.e. compute length,
+	     * reallocate a new buffer, move data, append ch. Here
+	     * We try to minimaze realloc() uses and avoid copying
+	     * and recomputing length over and over.
+	     */
+	    if ((ctxt->nodemem == ctxt->nodelen + 1) &&
+	        (xmlDictOwns(ctxt->dict, lastChild->content))) {
+		lastChild->content = xmlStrdup(lastChild->content);
+	    }
+	    if (ctxt->nodelen + len >= ctxt->nodemem) {
+		xmlChar *newbuf;
+		int size;
+
+		size = ctxt->nodemem + len;
+		size *= 2;
+                newbuf = (xmlChar *) xmlRealloc(lastChild->content,size);
+		if (newbuf == NULL) {
+		    if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
+			ctxt->sax->error(ctxt->userData, 
+			     "SAX.xmlSAX2Characters(): out of memory\n");
+		    ctxt->errNo = XML_ERR_NO_MEMORY;
+		    ctxt->instate = XML_PARSER_EOF;
+		    ctxt->disableSAX = 1;
+		    return;
+		}
+		ctxt->nodemem = size;
+		lastChild->content = newbuf;
+	    }
+	    memcpy(&lastChild->content[ctxt->nodelen], ch, len);
+	    ctxt->nodelen += len;
+	    lastChild->content[ctxt->nodelen] = 0;
+	} else if (coalesceText) {
+	    if (xmlTextConcat(lastChild, ch, len)) {
+		if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
+		    ctxt->sax->error(ctxt->userData, 
+			 "SAX.xmlSAX2Characters(): out of memory\n");
+		ctxt->errNo = XML_ERR_NO_MEMORY;
+		ctxt->instate = XML_PARSER_EOF;
+		ctxt->disableSAX = 1;
+	    }
+	    if (ctxt->node->children != NULL) {
+		ctxt->nodelen = xmlStrlen(lastChild->content);
+		ctxt->nodemem = ctxt->nodelen + 1;
+	    }
+	} else {
+	    /* Mixed content, first time */
+	    lastChild = xmlSAX2TextNode(ctxt, ch, len);
+	    if (lastChild != NULL) {
+		xmlAddChild(ctxt->node, lastChild);
+		if (ctxt->node->children != NULL) {
+		    ctxt->nodelen = len;
+		    ctxt->nodemem = len + 1;
+		}
+	    }
+	}
+    }
+}
+
+/**
+ * xmlSAX2IgnorableWhitespace:
+ * @ctx: the user data (XML parser context)
+ * @ch:  a xmlChar string
+ * @len: the number of xmlChar
+ *
+ * receiving some ignorable whitespaces from the parser.
+ * UNUSED: by default the DOM building will use xmlSAX2Characters
+ */
+void
+xmlSAX2IgnorableWhitespace(void *ctx ATTRIBUTE_UNUSED, const xmlChar *ch ATTRIBUTE_UNUSED, int len ATTRIBUTE_UNUSED)
+{
+    /* xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx; */
+#ifdef DEBUG_SAX
+    xmlGenericError(xmlGenericErrorContext,
+	    "SAX.xmlSAX2IgnorableWhitespace(%.30s, %d)\n", ch, len);
+#endif
+}
+
+/**
+ * xmlSAX2ProcessingInstruction:
+ * @ctx: the user data (XML parser context)
+ * @target:  the target name
+ * @data: the PI data's
+ *
+ * A processing instruction has been parsed.
+ */
+void
+xmlSAX2ProcessingInstruction(void *ctx, const xmlChar *target,
+                      const xmlChar *data)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+    xmlNodePtr ret;
+    xmlNodePtr parent = ctxt->node;
+
+#ifdef DEBUG_SAX
+    xmlGenericError(xmlGenericErrorContext,
+	    "SAX.xmlSAX2ProcessingInstruction(%s, %s)\n", target, data);
+#endif
+
+    ret = xmlNewPI(target, data);
+    if (ret == NULL) return;
+    parent = ctxt->node;
+
+    if (ctxt->inSubset == 1) {
+	xmlAddChild((xmlNodePtr) ctxt->myDoc->intSubset, ret);
+	return;
+    } else if (ctxt->inSubset == 2) {
+	xmlAddChild((xmlNodePtr) ctxt->myDoc->extSubset, ret);
+	return;
+    }
+    if ((ctxt->myDoc->children == NULL) || (parent == NULL)) {
+#ifdef DEBUG_SAX_TREE
+	    xmlGenericError(xmlGenericErrorContext,
+		    "Setting PI %s as root\n", target);
+#endif
+        xmlAddChild((xmlNodePtr) ctxt->myDoc, (xmlNodePtr) ret);
+	return;
+    }
+    if (parent->type == XML_ELEMENT_NODE) {
+#ifdef DEBUG_SAX_TREE
+	xmlGenericError(xmlGenericErrorContext,
+		"adding PI %s child to %s\n", target, parent->name);
+#endif
+	xmlAddChild(parent, ret);
+    } else {
+#ifdef DEBUG_SAX_TREE
+	xmlGenericError(xmlGenericErrorContext,
+		"adding PI %s sibling to ", target);
+	xmlDebugDumpOneNode(stderr, parent, 0);
+#endif
+	xmlAddSibling(parent, ret);
+    }
+}
+
+/**
+ * xmlSAX2Comment:
+ * @ctx: the user data (XML parser context)
+ * @value:  the xmlSAX2Comment content
+ *
+ * A xmlSAX2Comment has been parsed.
+ */
+void
+xmlSAX2Comment(void *ctx, const xmlChar *value)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+    xmlNodePtr ret;
+    xmlNodePtr parent = ctxt->node;
+
+#ifdef DEBUG_SAX
+    xmlGenericError(xmlGenericErrorContext, "SAX.xmlSAX2Comment(%s)\n", value);
+#endif
+    ret = xmlNewDocComment(ctxt->myDoc, value);
+    if (ret == NULL) return;
+
+    if (ctxt->inSubset == 1) {
+	xmlAddChild((xmlNodePtr) ctxt->myDoc->intSubset, ret);
+	return;
+    } else if (ctxt->inSubset == 2) {
+	xmlAddChild((xmlNodePtr) ctxt->myDoc->extSubset, ret);
+	return;
+    }
+    if ((ctxt->myDoc->children == NULL) || (parent == NULL)) {
+#ifdef DEBUG_SAX_TREE
+	    xmlGenericError(xmlGenericErrorContext,
+		    "Setting xmlSAX2Comment as root\n");
+#endif
+        xmlAddChild((xmlNodePtr) ctxt->myDoc, (xmlNodePtr) ret);
+	return;
+    }
+    if (parent->type == XML_ELEMENT_NODE) {
+#ifdef DEBUG_SAX_TREE
+	xmlGenericError(xmlGenericErrorContext,
+		"adding xmlSAX2Comment child to %s\n", parent->name);
+#endif
+	xmlAddChild(parent, ret);
+    } else {
+#ifdef DEBUG_SAX_TREE
+	xmlGenericError(xmlGenericErrorContext,
+		"adding xmlSAX2Comment sibling to ");
+	xmlDebugDumpOneNode(stderr, parent, 0);
+#endif
+	xmlAddSibling(parent, ret);
+    }
+}
+
+/**
+ * xmlSAX2CDataBlock:
+ * @ctx: the user data (XML parser context)
+ * @value:  The pcdata content
+ * @len:  the block length
+ *
+ * called when a pcdata block has been parsed
+ */
+void
+xmlSAX2CDataBlock(void *ctx, const xmlChar *value, int len)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+    xmlNodePtr ret, lastChild;
+
+#ifdef DEBUG_SAX
+    xmlGenericError(xmlGenericErrorContext,
+	    "SAX.pcdata(%.10s, %d)\n", value, len);
+#endif
+    lastChild = xmlGetLastChild(ctxt->node);
+#ifdef DEBUG_SAX_TREE
+    xmlGenericError(xmlGenericErrorContext,
+	    "add chars to %s \n", ctxt->node->name);
+#endif
+    if ((lastChild != NULL) &&
+        (lastChild->type == XML_CDATA_SECTION_NODE)) {
+	xmlTextConcat(lastChild, value, len);
+    } else {
+	ret = xmlNewCDataBlock(ctxt->myDoc, value, len);
+	xmlAddChild(ctxt->node, ret);
+    }
+}
+
+static int xmlSAX2DefaultVersionValue = 2;
+
+#ifdef LIBXML_SAX1_ENABLED
+/**
+ * xmlSAXDefaultVersion:
+ * @version:  the version, 1 or 2
+ *
+ * Set the default version of SAX used globally by the library.
+ * Note that this may not be a good thing to do from a library
+ * it is better to use xmlSAXVersion() to set up specifically the
+ * version for a given parsing context.
+ *
+ * Returns the previous value in case of success and -1 in case of error.
+ */
+int
+xmlSAXDefaultVersion(int version)
+{
+    int ret = xmlSAX2DefaultVersionValue;
+
+    if ((version != 1) && (version != 2))
+        return(-1);
+    xmlSAX2DefaultVersionValue = version;
+    return(ret);
+}
+#endif /* LIBXML_SAX1_ENABLED */
+
+/**
+ * xmlSAXVersion:
+ * @hdlr:  the SAX handler
+ * @version:  the version, 1 or 2
+ *
+ * Initialize the default XML SAX handler according to the version
+ *
+ * Returns 0 in case of success and -1 in case of error.
+ */
+int
+xmlSAXVersion(xmlSAXHandler *hdlr, int version)
+{
+    if (hdlr == NULL) return(-1);
+    if (version == 2) {
+	hdlr->startElement = NULL;
+	hdlr->endElement = NULL;
+	hdlr->startElementNs = xmlSAX2StartElementNs;
+	hdlr->endElementNs = xmlSAX2EndElementNs;
+	hdlr->serror = NULL;
+	hdlr->initialized = XML_SAX2_MAGIC;
+#ifdef LIBXML_SAX1_ENABLED
+    } else if (version == 1) {
+	hdlr->startElement = xmlSAX2StartElement;
+	hdlr->endElement = xmlSAX2EndElement;
+	hdlr->initialized = 1;
+#endif /* LIBXML_SAX1_ENABLED */
+    } else
+        return(-1);
+    hdlr->internalSubset = xmlSAX2InternalSubset;
+    hdlr->externalSubset = xmlSAX2ExternalSubset;
+    hdlr->isStandalone = xmlSAX2IsStandalone;
+    hdlr->hasInternalSubset = xmlSAX2HasInternalSubset;
+    hdlr->hasExternalSubset = xmlSAX2HasExternalSubset;
+    hdlr->resolveEntity = xmlSAX2ResolveEntity;
+    hdlr->getEntity = xmlSAX2GetEntity;
+    hdlr->getParameterEntity = xmlSAX2GetParameterEntity;
+    hdlr->entityDecl = xmlSAX2EntityDecl;
+    hdlr->attributeDecl = xmlSAX2AttributeDecl;
+    hdlr->elementDecl = xmlSAX2ElementDecl;
+    hdlr->notationDecl = xmlSAX2NotationDecl;
+    hdlr->unparsedEntityDecl = xmlSAX2UnparsedEntityDecl;
+    hdlr->setDocumentLocator = xmlSAX2SetDocumentLocator;
+    hdlr->startDocument = xmlSAX2StartDocument;
+    hdlr->endDocument = xmlSAX2EndDocument;
+    hdlr->reference = xmlSAX2Reference;
+    hdlr->characters = xmlSAX2Characters;
+    hdlr->cdataBlock = xmlSAX2CDataBlock;
+    hdlr->ignorableWhitespace = xmlSAX2Characters;
+    hdlr->processingInstruction = xmlSAX2ProcessingInstruction;
+    hdlr->comment = xmlSAX2Comment;
+    hdlr->warning = xmlParserWarning;
+    hdlr->error = xmlParserError;
+    hdlr->fatalError = xmlParserError;
+
+    return(0);
+}
+
+/**
+ * xmlSAX2InitDefaultSAXHandler:
+ * @hdlr:  the SAX handler
+ * @warning:  flag if non-zero sets the handler warning procedure
+ *
+ * Initialize the default XML SAX2 handler
+ */
+void
+xmlSAX2InitDefaultSAXHandler(xmlSAXHandler *hdlr, int warning)
+{
+    if ((hdlr == NULL) || (hdlr->initialized != 0))
+	return;
+
+    xmlSAXVersion(hdlr, xmlSAX2DefaultVersionValue);
+    if (warning == 0)
+	hdlr->warning = NULL;
+    else
+	hdlr->warning = xmlParserWarning;
+}
+
+/**
+ * xmlDefaultSAXHandlerInit:
+ *
+ * Initialize the default SAX2 handler
+ */
+void
+xmlDefaultSAXHandlerInit(void)
+{
+#ifdef LIBXML_SAX1_ENABLED
+    xmlSAXVersion((xmlSAXHandlerPtr) &xmlDefaultSAXHandler, 1);
+#endif /* LIBXML_SAX1_ENABLED */
+}
+
+#ifdef LIBXML_HTML_ENABLED
+
+/**
+ * xmlSAX2InitHtmlDefaultSAXHandler:
+ * @hdlr:  the SAX handler
+ *
+ * Initialize the default HTML SAX2 handler
+ */
+void
+xmlSAX2InitHtmlDefaultSAXHandler(xmlSAXHandler *hdlr)
+{
+    if(hdlr->initialized != 0)
+	return;
+
+    hdlr->internalSubset = xmlSAX2InternalSubset;
+    hdlr->externalSubset = NULL;
+    hdlr->isStandalone = NULL;
+    hdlr->hasInternalSubset = NULL;
+    hdlr->hasExternalSubset = NULL;
+    hdlr->resolveEntity = NULL;
+    hdlr->getEntity = xmlSAX2GetEntity;
+    hdlr->getParameterEntity = NULL;
+    hdlr->entityDecl = NULL;
+    hdlr->attributeDecl = NULL;
+    hdlr->elementDecl = NULL;
+    hdlr->notationDecl = NULL;
+    hdlr->unparsedEntityDecl = NULL;
+    hdlr->setDocumentLocator = xmlSAX2SetDocumentLocator;
+    hdlr->startDocument = xmlSAX2StartDocument;
+    hdlr->endDocument = xmlSAX2EndDocument;
+    hdlr->startElement = xmlSAX2StartElement;
+    hdlr->endElement = xmlSAX2EndElement;
+    hdlr->reference = NULL;
+    hdlr->characters = xmlSAX2Characters;
+    hdlr->cdataBlock = xmlSAX2CDataBlock;
+    hdlr->ignorableWhitespace = xmlSAX2IgnorableWhitespace;
+    hdlr->processingInstruction = NULL;
+    hdlr->comment = xmlSAX2Comment;
+    hdlr->warning = xmlParserWarning;
+    hdlr->error = xmlParserError;
+    hdlr->fatalError = xmlParserError;
+
+    hdlr->initialized = 1;
+}
+
+/**
+ * htmlDefaultSAXHandlerInit:
+ *
+ * Initialize the default SAX handler
+ */
+void
+htmlDefaultSAXHandlerInit(void)
+{
+    xmlSAX2InitHtmlDefaultSAXHandler((xmlSAXHandlerPtr) &htmlDefaultSAXHandler);
+}
+
+#endif /* LIBXML_HTML_ENABLED */
+
+#ifdef LIBXML_DOCB_ENABLED
+
+/**
+ * xmlSAX2InitDocbDefaultSAXHandler:
+ * @hdlr:  the SAX handler
+ *
+ * Initialize the default DocBook SAX2 handler
+ */
+void
+xmlSAX2InitDocbDefaultSAXHandler(xmlSAXHandler *hdlr)
+{
+    if(hdlr->initialized != 0)
+	return;
+
+    hdlr->internalSubset = xmlSAX2InternalSubset;
+    hdlr->externalSubset = NULL;
+    hdlr->isStandalone = xmlSAX2IsStandalone;
+    hdlr->hasInternalSubset = xmlSAX2HasInternalSubset;
+    hdlr->hasExternalSubset = xmlSAX2HasExternalSubset;
+    hdlr->resolveEntity = xmlSAX2ResolveEntity;
+    hdlr->getEntity = xmlSAX2GetEntity;
+    hdlr->getParameterEntity = NULL;
+    hdlr->entityDecl = xmlSAX2EntityDecl;
+    hdlr->attributeDecl = NULL;
+    hdlr->elementDecl = NULL;
+    hdlr->notationDecl = NULL;
+    hdlr->unparsedEntityDecl = NULL;
+    hdlr->setDocumentLocator = xmlSAX2SetDocumentLocator;
+    hdlr->startDocument = xmlSAX2StartDocument;
+    hdlr->endDocument = xmlSAX2EndDocument;
+    hdlr->startElement = xmlSAX2StartElement;
+    hdlr->endElement = xmlSAX2EndElement;
+    hdlr->reference = xmlSAX2Reference;
+    hdlr->characters = xmlSAX2Characters;
+    hdlr->cdataBlock = NULL;
+    hdlr->ignorableWhitespace = xmlSAX2IgnorableWhitespace;
+    hdlr->processingInstruction = NULL;
+    hdlr->comment = xmlSAX2Comment;
+    hdlr->warning = xmlParserWarning;
+    hdlr->error = xmlParserError;
+    hdlr->fatalError = xmlParserError;
+
+    hdlr->initialized = 1;
+}
+
+/**
+ * docbDefaultSAXHandlerInit:
+ *
+ * Initialize the default SAX handler
+ */
+void
+docbDefaultSAXHandlerInit(void)
+{
+    xmlSAX2InitDocbDefaultSAXHandler((xmlSAXHandlerPtr) &docbDefaultSAXHandler);
+}
+
+#endif /* LIBXML_DOCB_ENABLED */
diff --git a/src/libxml/src/acconfig.h b/src/libxml/src/acconfig.h
new file mode 100644
index 0000000..7e4d9b8
--- /dev/null
+++ b/src/libxml/src/acconfig.h
@@ -0,0 +1,17 @@
+#undef PACKAGE
+#undef VERSION
+#undef HAVE_LIBZ
+#undef HAVE_LIBM
+#undef HAVE_ISINF
+#undef HAVE_ISNAN
+#undef HAVE_LIBHISTORY
+#undef HAVE_LIBREADLINE
+#undef SOCKLEN_T
+#undef HAVE_LIBPTHREAD
+#undef HAVE_PTHREAD_H
+
+/* Define if IPV6 support is there */
+#undef SUPPORT_IP6
+
+/* Define if getaddrinfo is there */
+#undef HAVE_GETADDRINFO
diff --git a/src/libxml/src/c14n.c b/src/libxml/src/c14n.c
new file mode 100644
index 0000000..01c46b1
--- /dev/null
+++ b/src/libxml/src/c14n.c
@@ -0,0 +1,1974 @@
+/*
+ * "Canonical XML" implementation 
+ * http://www.w3.org/TR/xml-c14n
+ * 
+ * "Exclusive XML Canonicalization" implementation
+ * http://www.w3.org/TR/xml-exc-c14n
+ *
+ * See Copyright for the status of this software.
+ * 
+ * Author: Aleksey Sanin <aleksey@aleksey.com>
+ */
+#define IN_LIBXML
+#include "libxml.h"
+#ifdef LIBXML_C14N_ENABLED
+#ifdef LIBXML_OUTPUT_ENABLED
+
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+#include <string.h>
+
+#include <libxml/tree.h>
+#include <libxml/parser.h>
+#include <libxml/uri.h>
+#include <libxml/xmlerror.h>
+#include <libxml/globals.h>
+#include <libxml/xpathInternals.h>
+#include <libxml/c14n.h>
+
+/************************************************************************
+ *									*
+ *		Some declaration better left private ATM		*
+ *									*
+ ************************************************************************/
+
+typedef enum {
+    XMLC14N_BEFORE_DOCUMENT_ELEMENT = 0,
+    XMLC14N_INSIDE_DOCUMENT_ELEMENT = 1,
+    XMLC14N_AFTER_DOCUMENT_ELEMENT = 2
+} xmlC14NPosition;
+
+typedef struct _xmlC14NVisibleNsStack {
+    int nsCurEnd;	 /* number of nodes in the set */
+    int nsPrevStart; 	 /* the begginning of the stack for previous visible node */
+    int nsPrevEnd;	 /* the end of the stack for previous visible node */
+    int nsMax;		 /* size of the array as allocated */
+    xmlNsPtr 	*nsTab;	 /* array of ns in no particular order */	      
+    xmlNodePtr	*nodeTab;/* array of nodes in no particular order */
+} xmlC14NVisibleNsStack, *xmlC14NVisibleNsStackPtr;
+
+typedef struct _xmlC14NCtx {
+    /* input parameters */
+    xmlDocPtr doc;
+    xmlC14NIsVisibleCallback is_visible_callback;
+    void* user_data;    
+    int with_comments;
+    xmlOutputBufferPtr buf;
+
+    /* position in the XML document */
+    xmlC14NPosition pos;
+    int parent_is_doc;
+    xmlC14NVisibleNsStackPtr ns_rendered;
+
+    /* exclusive canonicalization */
+    int exclusive;
+    xmlChar **inclusive_ns_prefixes;
+
+    /* error number */
+    int error;
+} xmlC14NCtx, *xmlC14NCtxPtr;
+
+static xmlC14NVisibleNsStackPtr	xmlC14NVisibleNsStackCreate	(void);
+static void			xmlC14NVisibleNsStackDestroy	(xmlC14NVisibleNsStackPtr cur);
+static void 			xmlC14NVisibleNsStackAdd	(xmlC14NVisibleNsStackPtr cur, 
+								 xmlNsPtr ns,
+								 xmlNodePtr node);
+static void 			xmlC14NVisibleNsStackSave	(xmlC14NVisibleNsStackPtr cur,
+								 xmlC14NVisibleNsStackPtr state);
+static void 			xmlC14NVisibleNsStackRestore	(xmlC14NVisibleNsStackPtr cur,
+								 xmlC14NVisibleNsStackPtr state);
+static void 			xmlC14NVisibleNsStackShift	(xmlC14NVisibleNsStackPtr cur);
+static int			xmlC14NVisibleNsStackFind	(xmlC14NVisibleNsStackPtr cur, 
+								 xmlNsPtr ns);
+static int			xmlExcC14NVisibleNsStackFind	(xmlC14NVisibleNsStackPtr cur, 
+								 xmlNsPtr ns,
+								 xmlC14NCtxPtr ctx);
+
+static int			xmlC14NIsNodeInNodeset		(xmlNodeSetPtr nodes,
+								 xmlNodePtr node,
+								 xmlNodePtr parent);
+
+
+
+static int xmlC14NProcessNode(xmlC14NCtxPtr ctx, xmlNodePtr cur);
+static int xmlC14NProcessNodeList(xmlC14NCtxPtr ctx, xmlNodePtr cur);
+typedef enum {
+    XMLC14N_NORMALIZE_ATTR = 0,
+    XMLC14N_NORMALIZE_COMMENT = 1,
+    XMLC14N_NORMALIZE_PI = 2,
+    XMLC14N_NORMALIZE_TEXT = 3
+} xmlC14NNormalizationMode;
+
+static xmlChar *xmlC11NNormalizeString(const xmlChar * input,
+                                       xmlC14NNormalizationMode mode);
+
+#define 	xmlC11NNormalizeAttr( a ) \
+    xmlC11NNormalizeString((a), XMLC14N_NORMALIZE_ATTR)
+#define 	xmlC11NNormalizeComment( a ) \
+    xmlC11NNormalizeString((a), XMLC14N_NORMALIZE_COMMENT)
+#define 	xmlC11NNormalizePI( a )	\
+    xmlC11NNormalizeString((a), XMLC14N_NORMALIZE_PI)
+#define 	xmlC11NNormalizeText( a ) \
+    xmlC11NNormalizeString((a), XMLC14N_NORMALIZE_TEXT)
+
+#define 	xmlC14NIsVisible( ctx, node, parent ) \
+     (((ctx)->is_visible_callback != NULL) ? \
+	(ctx)->is_visible_callback((ctx)->user_data, \
+		(xmlNodePtr)(node), (xmlNodePtr)(parent)) : 1)
+
+/************************************************************************
+ *									*
+ * 		Some factorized error routines				*
+ *									*
+ ************************************************************************/
+
+/**
+ * xmlC14NErrMemory:
+ * @extra:  extra informations
+ *
+ * Handle a redefinition of attribute error
+ */
+static void
+xmlC14NErrMemory(const char *extra)
+{
+    __xmlRaiseError(NULL, NULL, NULL, NULL, NULL, XML_FROM_C14N,
+		    XML_ERR_NO_MEMORY, XML_ERR_ERROR, NULL, 0, extra,
+		    NULL, NULL, 0, 0,
+		    "Memory allocation failed : %s\n", extra);
+}
+
+/**
+ * xmlC14NErr:
+ * @ctxt:  a C14N evaluation context
+ * @node:  the context node
+ * @error:  the erorr code
+ * @msg:  the message
+ * @extra:  extra informations
+ *
+ * Handle a redefinition of attribute error
+ */
+static void
+xmlC14NErr(xmlC14NCtxPtr ctxt, xmlNodePtr node, int error,
+           const char * msg)
+{
+    if (ctxt != NULL)
+        ctxt->error = error;
+    __xmlRaiseError(NULL, NULL, NULL,
+		    ctxt, node, XML_FROM_C14N, error,
+		    XML_ERR_ERROR, NULL, 0,
+		    NULL, NULL, NULL, 0, 0, msg);
+}
+
+/************************************************************************
+ *									*
+ *		The implementation internals				*
+ *									*
+ ************************************************************************/
+#define XML_NAMESPACES_DEFAULT		16
+
+static int			
+xmlC14NIsNodeInNodeset(xmlNodeSetPtr nodes, xmlNodePtr node, xmlNodePtr parent) {
+    if((nodes != NULL) && (node != NULL)) {
+	if(node->type != XML_NAMESPACE_DECL) {
+	    return(xmlXPathNodeSetContains(nodes, node));
+	} else {
+	    xmlNs ns;
+	    
+	    memcpy(&ns, node, sizeof(ns)); 
+	    ns.next = (xmlNsPtr)parent; /* this is a libxml hack! check xpath.c for details */
+
+	    /* 
+	     * If the input is an XPath node-set, then the node-set must explicitly 
+	     * contain every node to be rendered to the canonical form.
+	     */
+	    return(xmlXPathNodeSetContains(nodes, (xmlNodePtr)&ns));
+	}
+    }
+    return(1);
+}
+
+static xmlC14NVisibleNsStackPtr
+xmlC14NVisibleNsStackCreate(void) {
+    xmlC14NVisibleNsStackPtr ret;
+
+    ret = (xmlC14NVisibleNsStackPtr) xmlMalloc(sizeof(xmlC14NVisibleNsStack));
+    if (ret == NULL) {
+        xmlC14NErrMemory("creating stack");
+	return(NULL);
+    }
+    memset(ret, 0 , (size_t) sizeof(xmlC14NVisibleNsStack));
+    return(ret);
+}
+
+static void
+xmlC14NVisibleNsStackDestroy(xmlC14NVisibleNsStackPtr cur) {
+    if(cur == NULL) {
+#ifdef DEBUG_C14N
+        xmlGenericError(xmlGenericErrorContext,
+            "xmlC14NVisibleNsStackDestroy: cur is null.\n");
+#endif
+	return;
+    }
+    if(cur->nsTab != NULL) {
+	memset(cur->nsTab, 0, cur->nsMax * sizeof(xmlNsPtr));
+	xmlFree(cur->nsTab);
+    }
+    if(cur->nodeTab != NULL) {
+	memset(cur->nodeTab, 0, cur->nsMax * sizeof(xmlNodePtr));
+	xmlFree(cur->nodeTab);
+    }
+    memset(cur, 0, sizeof(xmlC14NVisibleNsStack));
+    xmlFree(cur);
+    
+}
+
+static void 
+xmlC14NVisibleNsStackAdd(xmlC14NVisibleNsStackPtr cur, xmlNsPtr ns, xmlNodePtr node) {
+    if((cur == NULL) || 
+       ((cur->nsTab == NULL) && (cur->nodeTab != NULL)) ||
+       ((cur->nsTab != NULL) && (cur->nodeTab == NULL))) {
+#ifdef DEBUG_C14N
+        xmlGenericError(xmlGenericErrorContext,
+            "xmlC14NVisibleNsStackAdd: cur is null.\n");
+#endif
+	return;
+    }
+
+    if ((cur->nsTab == NULL) && (cur->nodeTab == NULL)) {
+        cur->nsTab = (xmlNsPtr*) xmlMalloc(XML_NAMESPACES_DEFAULT * sizeof(xmlNsPtr));
+        cur->nodeTab = (xmlNodePtr*) xmlMalloc(XML_NAMESPACES_DEFAULT * sizeof(xmlNodePtr));
+	if ((cur->nsTab == NULL) || (cur->nodeTab == NULL)) {
+	    xmlC14NErrMemory("adding node to stack");
+	    return;
+	}
+	memset(cur->nsTab, 0 , XML_NAMESPACES_DEFAULT * sizeof(xmlNsPtr));
+	memset(cur->nodeTab, 0 , XML_NAMESPACES_DEFAULT * sizeof(xmlNodePtr));
+        cur->nsMax = XML_NAMESPACES_DEFAULT;
+    } else if(cur->nsMax == cur->nsCurEnd) {
+	void *tmp;	
+	int tmpSize;
+	
+	tmpSize = 2 * cur->nsMax;
+	tmp = xmlRealloc(cur->nsTab, tmpSize * sizeof(xmlNsPtr));
+	if (tmp == NULL) {
+	    xmlC14NErrMemory("adding node to stack");
+	    return;
+	}
+	cur->nsTab = (xmlNsPtr*)tmp;
+
+	tmp = xmlRealloc(cur->nodeTab, tmpSize * sizeof(xmlNodePtr));
+	if (tmp == NULL) {
+	    xmlC14NErrMemory("adding node to stack");
+	    return;
+	}
+	cur->nodeTab = (xmlNodePtr*)tmp;
+
+	cur->nsMax = tmpSize;
+    }
+    cur->nsTab[cur->nsCurEnd] = ns;
+    cur->nodeTab[cur->nsCurEnd] = node;
+
+    ++cur->nsCurEnd;
+}
+
+static void
+xmlC14NVisibleNsStackSave(xmlC14NVisibleNsStackPtr cur, xmlC14NVisibleNsStackPtr state) {
+    if((cur == NULL) || (state == NULL)) {
+#ifdef DEBUG_C14N
+        xmlGenericError(xmlGenericErrorContext,
+            "xmlC14NVisibleNsStackSave: cur or state is null.\n");
+#endif
+	return;
+    }
+    
+    state->nsCurEnd = cur->nsCurEnd;
+    state->nsPrevStart = cur->nsPrevStart;
+    state->nsPrevEnd = cur->nsPrevEnd;
+}
+
+static void
+xmlC14NVisibleNsStackRestore(xmlC14NVisibleNsStackPtr cur, xmlC14NVisibleNsStackPtr state) {
+    if((cur == NULL) || (state == NULL)) {
+#ifdef DEBUG_C14N
+        xmlGenericError(xmlGenericErrorContext,
+            "xmlC14NVisibleNsStackRestore: cur or state is null.\n");
+#endif
+	return;
+    }
+    cur->nsCurEnd = state->nsCurEnd;
+    cur->nsPrevStart = state->nsPrevStart;
+    cur->nsPrevEnd = state->nsPrevEnd;
+}
+
+static void 
+xmlC14NVisibleNsStackShift(xmlC14NVisibleNsStackPtr cur) {
+    if(cur == NULL) {
+#ifdef DEBUG_C14N
+        xmlGenericError(xmlGenericErrorContext,
+            "xmlC14NVisibleNsStackRestore: cur is null.\n");
+#endif
+	return;
+    }
+    cur->nsPrevStart = cur->nsPrevEnd;
+    cur->nsPrevEnd = cur->nsCurEnd;
+}
+
+static int
+xmlC14NStrEqual(const xmlChar *str1, const xmlChar *str2) {
+    if (str1 == str2) return(1);
+    if (str1 == NULL) return((*str2) == '\0');
+    if (str2 == NULL) return((*str1) == '\0');
+    do {
+	if (*str1++ != *str2) return(0);
+    } while (*str2++);
+    return(1);
+}
+
+/**
+ * xmlC14NVisibleNsStackFind:
+ * @ctx:		the C14N context 
+ * @ns:			the namespace to check
+ *
+ * Checks whether the given namespace was already rendered or not
+ *
+ * Returns 1 if we already wrote this namespace or 0 otherwise
+ */
+static int
+xmlC14NVisibleNsStackFind(xmlC14NVisibleNsStackPtr cur, xmlNsPtr ns)
+{
+    int i;
+    const xmlChar *prefix;
+    const xmlChar *href;
+    int has_empty_ns;
+        
+    if(cur == NULL) {
+#ifdef DEBUG_C14N
+        xmlGenericError(xmlGenericErrorContext,
+            "xmlC14NVisibleNsStackFind: cur is null.\n");
+#endif
+        return (0);
+    }
+
+    /*
+     * if the default namespace xmlns="" is not defined yet then 
+     * we do not want to print it out
+     */
+    prefix = ((ns == NULL) || (ns->prefix == NULL)) ? BAD_CAST "" : ns->prefix;
+    href = ((ns == NULL) || (ns->href == NULL)) ? BAD_CAST "" : ns->href;
+    has_empty_ns = (xmlC14NStrEqual(prefix, NULL) && xmlC14NStrEqual(href, NULL));
+
+    if (cur->nsTab != NULL) {
+	int start = (has_empty_ns) ? 0 : cur->nsPrevStart;
+        for (i = cur->nsCurEnd - 1; i >= start; --i) {
+            xmlNsPtr ns1 = cur->nsTab[i];
+	    
+	    if(xmlC14NStrEqual(prefix, (ns1 != NULL) ? ns1->prefix : NULL)) {
+		return(xmlC14NStrEqual(href, (ns1 != NULL) ? ns1->href : NULL));
+	    }
+        }
+    }
+    return(has_empty_ns);
+}
+
+static int			
+xmlExcC14NVisibleNsStackFind(xmlC14NVisibleNsStackPtr cur, xmlNsPtr ns, xmlC14NCtxPtr ctx) {
+    int i;
+    const xmlChar *prefix;
+    const xmlChar *href;
+    int has_empty_ns;
+        
+    if(cur == NULL) {
+#ifdef DEBUG_C14N
+        xmlGenericError(xmlGenericErrorContext,
+            "xmlExcC14NVisibleNsStackFind: cur is null.\n");
+#endif
+        return (0);
+    }
+
+    /*
+     * if the default namespace xmlns="" is not defined yet then 
+     * we do not want to print it out
+     */
+    prefix = ((ns == NULL) || (ns->prefix == NULL)) ? BAD_CAST "" : ns->prefix;
+    href = ((ns == NULL) || (ns->href == NULL)) ? BAD_CAST "" : ns->href;
+    has_empty_ns = (xmlC14NStrEqual(prefix, NULL) && xmlC14NStrEqual(href, NULL));
+
+    if (cur->nsTab != NULL) {
+	int start = 0;
+        for (i = cur->nsCurEnd - 1; i >= start; --i) {
+            xmlNsPtr ns1 = cur->nsTab[i];
+	    
+	    if(xmlC14NStrEqual(prefix, (ns1 != NULL) ? ns1->prefix : NULL)) {
+		if(xmlC14NStrEqual(href, (ns1 != NULL) ? ns1->href : NULL)) {
+	    	    return(xmlC14NIsVisible(ctx, ns1, cur->nodeTab[i]));
+		} else {
+		    return(0);
+		}
+	    }
+        }
+    }
+    return(has_empty_ns);
+}
+
+
+
+
+/**
+ * xmlC14NIsXmlNs:
+ * @ns: 		the namespace to check
+ *  		
+ * Checks whether the given namespace is a default "xml:" namespace
+ * with href="http://www.w3.org/XML/1998/namespace"
+ *
+ * Returns 1 if the node is default or 0 otherwise
+ */
+
+/* todo: make it a define? */
+static int
+xmlC14NIsXmlNs(xmlNsPtr ns)
+{
+    return ((ns != NULL) &&
+            (xmlStrEqual(ns->prefix, BAD_CAST "xml")) &&
+            (xmlStrEqual(ns->href,
+                         BAD_CAST
+                         "http://www.w3.org/XML/1998/namespace")));
+}
+
+
+/**
+ * xmlC14NNsCompare:
+ * @ns1:		the pointer to first namespace
+ * @ns2: 		the pointer to second namespace
+ *
+ * Compares the namespaces by names (prefixes).
+ *
+ * Returns -1 if ns1 < ns2, 0 if ns1 == ns2 or 1 if ns1 > ns2.
+ */
+static int
+xmlC14NNsCompare(xmlNsPtr ns1, xmlNsPtr ns2)
+{
+    if (ns1 == ns2)
+        return (0);
+    if (ns1 == NULL)
+        return (-1);
+    if (ns2 == NULL)
+        return (1);
+
+    return (xmlStrcmp(ns1->prefix, ns2->prefix));
+}
+
+
+/**
+ * xmlC14NPrintNamespaces:
+ * @ns:			the pointer to namespace
+ * @ctx: 		the C14N context
+ *
+ * Prints the given namespace to the output buffer from C14N context.
+ *
+ * Returns 1 on success or 0 on fail.
+ */
+static int
+xmlC14NPrintNamespaces(const xmlNsPtr ns, xmlC14NCtxPtr ctx)
+{
+
+    if ((ns == NULL) || (ctx == NULL)) {
+#ifdef DEBUG_C14N
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlC14NPrintNamespace: namespace or context pointer is null\n");
+#endif
+        return 0;
+    }
+
+    if (ns->prefix != NULL) {
+        xmlOutputBufferWriteString(ctx->buf, " xmlns:");
+        xmlOutputBufferWriteString(ctx->buf, (const char *) ns->prefix);
+        xmlOutputBufferWriteString(ctx->buf, "=\"");
+    } else {
+        xmlOutputBufferWriteString(ctx->buf, " xmlns=\"");
+    }
+    if(ns->href != NULL) {
+	xmlOutputBufferWriteString(ctx->buf, (const char *) ns->href);
+    }
+    xmlOutputBufferWriteString(ctx->buf, "\"");
+    return (1);
+}
+
+/**
+ * xmlC14NProcessNamespacesAxis:
+ * @ctx: 		the C14N context
+ * @node:		the current node
+ *
+ * Prints out canonical namespace axis of the current node to the
+ * buffer from C14N context as follows 
+ *
+ * Canonical XML v 1.0 (http://www.w3.org/TR/xml-c14n)
+ *
+ * Namespace Axis
+ * Consider a list L containing only namespace nodes in the 
+ * axis and in the node-set in lexicographic order (ascending). To begin 
+ * processing L, if the first node is not the default namespace node (a node 
+ * with no namespace URI and no local name), then generate a space followed 
+ * by xmlns="" if and only if the following conditions are met:
+ *    - the element E that owns the axis is in the node-set
+ *    - The nearest ancestor element of E in the node-set has a default 
+ *	    namespace node in the node-set (default namespace nodes always 
+ *      have non-empty values in XPath)
+ * The latter condition eliminates unnecessary occurrences of xmlns="" in 
+ * the canonical form since an element only receives an xmlns="" if its 
+ * default namespace is empty and if it has an immediate parent in the 
+ * canonical form that has a non-empty default namespace. To finish 
+ * processing  L, simply process every namespace node in L, except omit 
+ * namespace node with local name xml, which defines the xml prefix, 
+ * if its string value is http://www.w3.org/XML/1998/namespace.
+ *
+ * Exclusive XML Canonicalization v 1.0 (http://www.w3.org/TR/xml-exc-c14n)
+ * Canonical XML applied to a document subset requires the search of the 
+ * ancestor nodes of each orphan element node for attributes in the xml 
+ * namespace, such as xml:lang and xml:space. These are copied into the 
+ * element node except if a declaration of the same attribute is already 
+ * in the attribute axis of the element (whether or not it is included in 
+ * the document subset). This search and copying are omitted from the 
+ * Exclusive XML Canonicalization method.
+ *
+ * Returns 0 on success or -1 on fail.
+ */
+static int
+xmlC14NProcessNamespacesAxis(xmlC14NCtxPtr ctx, xmlNodePtr cur, int visible)
+{
+    xmlNodePtr n;
+    xmlNsPtr ns, tmp;
+    xmlListPtr list;
+    int already_rendered;
+    int has_empty_ns = 0;
+    
+    if ((ctx == NULL) || (cur == NULL) || (cur->type != XML_ELEMENT_NODE)) {
+#ifdef DEBUG_C14N
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlC14NProcessNamespacesAxis: Null context or node pointer or type != XML_ELEMENT_NODE.\n");
+#endif
+        return (-1);
+    }
+
+    /*
+     * Create a sorted list to store element namespaces
+     */
+    list = xmlListCreate(NULL, (xmlListDataCompare) xmlC14NNsCompare);
+    if (list == NULL) {
+#ifdef DEBUG_C14N
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlC14NProcessNamespacesAxis: list creation failed\n");
+#endif
+        return (-1);
+    }
+
+    /* check all namespaces */
+    for(n = cur; n != NULL; n = n->parent) {
+	for(ns = n->nsDef; ns != NULL; ns = ns->next) {
+	    tmp = xmlSearchNs(cur->doc, cur, ns->prefix);
+	    
+	    if((tmp == ns) && !xmlC14NIsXmlNs(ns) && xmlC14NIsVisible(ctx, ns, cur)) {
+		already_rendered = xmlC14NVisibleNsStackFind(ctx->ns_rendered, ns);
+		if(visible) {
+        	    xmlC14NVisibleNsStackAdd(ctx->ns_rendered, ns, cur);
+		}
+		if(!already_rendered) {
+		    xmlListInsert(list, ns); 
+		}
+    		if(xmlStrlen(ns->prefix) == 0) {
+		    has_empty_ns = 1;
+		}
+	    }
+	}
+    }
+	
+    /**
+     * if the first node is not the default namespace node (a node with no 
+     * namespace URI and no local name), then generate a space followed by 
+     * xmlns="" if and only if the following conditions are met:
+     *  - the element E that owns the axis is in the node-set
+     *  - the nearest ancestor element of E in the node-set has a default 
+     *     namespace node in the node-set (default namespace nodes always 
+     *     have non-empty values in XPath)
+     */
+    if(visible && !has_empty_ns) {
+        static xmlNs ns_default;
+
+        memset(&ns_default, 0, sizeof(ns_default));
+        if(!xmlC14NVisibleNsStackFind(ctx->ns_rendered, &ns_default)) {
+    	    xmlC14NPrintNamespaces(&ns_default, ctx);
+	}
+    }
+	
+    
+    /* 
+     * print out all elements from list 
+     */
+    xmlListWalk(list, (xmlListWalker) xmlC14NPrintNamespaces, (const void *) ctx);
+
+    /* 
+     * Cleanup
+     */
+    xmlListDelete(list);
+    return (0);
+}
+
+
+/**
+ * xmlExcC14NProcessNamespacesAxis:
+ * @ctx: 		the C14N context
+ * @node:		the current node
+ *
+ * Prints out exclusive canonical namespace axis of the current node to the
+ * buffer from C14N context as follows 
+ *
+ * Exclusive XML Canonicalization
+ * http://www.w3.org/TR/xml-exc-c14n
+ *
+ * If the element node is in the XPath subset then output the node in 
+ * accordance with Canonical XML except for namespace nodes which are 
+ * rendered as follows:
+ *
+ * 1. Render each namespace node iff:
+ *    * it is visibly utilized by the immediate parent element or one of 
+ *      its attributes, or is present in InclusiveNamespaces PrefixList, and
+ *    * its prefix and value do not appear in ns_rendered. ns_rendered is 
+ *      obtained by popping the state stack in order to obtain a list of 
+ *      prefixes and their values which have already been rendered by 
+ *      an output ancestor of the namespace node's parent element.
+ * 2. Append the rendered namespace node to the list ns_rendered of namespace 
+ * nodes rendered by output ancestors. Push ns_rendered on state stack and 
+ * recurse.
+ * 3. After the recursion returns, pop thestate stack.
+ *
+ *
+ * Returns 0 on success or -1 on fail.
+ */
+static int
+xmlExcC14NProcessNamespacesAxis(xmlC14NCtxPtr ctx, xmlNodePtr cur, int visible)
+{
+    xmlNsPtr ns;
+    xmlListPtr list;
+    xmlAttrPtr attr;
+    int already_rendered;
+    int has_empty_ns = 0;
+    int has_visibly_utilized_empty_ns = 0;
+    int has_empty_ns_in_inclusive_list = 0;
+        
+    if ((ctx == NULL) || (cur == NULL) || (cur->type != XML_ELEMENT_NODE)) {
+#ifdef DEBUG_C14N
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlExcC14NProcessNamespacesAxis: Null context or node pointer or type != XML_ELEMENT_NODE.\n");
+#endif
+        return (-1);
+    }
+
+    if(!ctx->exclusive) {
+#ifdef DEBUG_C14N
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlExcC14NProcessNamespacesAxis: called for non-exclusive canonization or rendered stack is NULL.\n");
+#endif
+        return (-1);
+
+    }
+
+    /*
+     * Create a sorted list to store element namespaces
+     */
+    list = xmlListCreate(NULL, (xmlListDataCompare) xmlC14NNsCompare);
+    if (list == NULL) {
+#ifdef DEBUG_C14N
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlExcC14NProcessNamespacesAxis: list creation failed\n");
+#endif
+        return (-1);
+    }
+
+    /* 
+     * process inclusive namespaces:
+     * All namespace nodes appearing on inclusive ns list are 
+     * handled as provided in Canonical XML
+     */
+    if(ctx->inclusive_ns_prefixes != NULL) {
+	xmlChar *prefix; 
+	int i;
+	
+	for (i = 0; ctx->inclusive_ns_prefixes[i] != NULL; ++i) {
+	    prefix = ctx->inclusive_ns_prefixes[i];
+	    /*
+	     * Special values for namespace with empty prefix
+	     */
+            if (xmlStrEqual(prefix, BAD_CAST "#default")
+                || xmlStrEqual(prefix, BAD_CAST "")) {
+                prefix = NULL;
+		has_empty_ns_in_inclusive_list = 1;
+            }
+	
+	    ns = xmlSearchNs(cur->doc, cur, prefix);	    
+	    if((ns != NULL) && !xmlC14NIsXmlNs(ns) && xmlC14NIsVisible(ctx, ns, cur)) {
+		already_rendered = xmlC14NVisibleNsStackFind(ctx->ns_rendered, ns);
+		if(visible) {
+    	    	    xmlC14NVisibleNsStackAdd(ctx->ns_rendered, ns, cur);
+		}
+		if(!already_rendered) {
+	    	    xmlListInsert(list, ns); 
+		}
+    		if(xmlStrlen(ns->prefix) == 0) {
+		    has_empty_ns = 1;
+		}
+	    }
+	}
+    }
+    
+    /* add node namespace */
+    if(cur->ns != NULL) {
+	ns = cur->ns;
+    } else {
+        ns = xmlSearchNs(cur->doc, cur, NULL);
+	has_visibly_utilized_empty_ns = 1;
+    }
+    if((ns != NULL) && !xmlC14NIsXmlNs(ns)) {
+	if(visible && xmlC14NIsVisible(ctx, ns, cur)) { 
+	    if(!xmlExcC14NVisibleNsStackFind(ctx->ns_rendered, ns, ctx)) {
+		xmlListInsert(list, ns);
+	    }
+	}
+	if(visible) {
+    	    xmlC14NVisibleNsStackAdd(ctx->ns_rendered, ns, cur); 
+	}
+	if(xmlStrlen(ns->prefix) == 0) {
+	    has_empty_ns = 1;
+	}
+    }
+    
+        
+    /* add attributes */
+    for(attr = cur->properties; attr != NULL; attr = attr->next) {
+        /* 
+         * we need to check that attribute is visible and has non
+         * default namespace (XML Namespaces: "default namespaces 
+    	 * do not apply directly to attributes")	 
+         */
+	if((attr->ns != NULL) && xmlC14NIsVisible(ctx, attr, cur)) {
+	    already_rendered = xmlExcC14NVisibleNsStackFind(ctx->ns_rendered, attr->ns, ctx);
+	    xmlC14NVisibleNsStackAdd(ctx->ns_rendered, attr->ns, (xmlNodePtr)attr); 
+	    if(!already_rendered && visible) {
+		xmlListInsert(list, attr->ns); 
+	    }
+	    if(xmlStrlen(attr->ns->prefix) == 0) {
+		has_empty_ns = 1;
+	    }
+	} else if(attr->ns == NULL) {
+	    has_visibly_utilized_empty_ns = 1;
+	}
+    }
+
+    /*
+     * Process xmlns=""
+     */
+    if(visible && has_visibly_utilized_empty_ns && 
+	    !has_empty_ns && !has_empty_ns_in_inclusive_list) {
+        static xmlNs ns_default;
+
+        memset(&ns_default, 0, sizeof(ns_default));
+	
+        already_rendered = xmlExcC14NVisibleNsStackFind(ctx->ns_rendered, &ns_default, ctx);
+	if(!already_rendered) {
+    	    xmlC14NPrintNamespaces(&ns_default, ctx);
+	}
+    } else if(visible && !has_empty_ns && has_empty_ns_in_inclusive_list) {
+        static xmlNs ns_default;
+
+        memset(&ns_default, 0, sizeof(ns_default));
+        if(!xmlC14NVisibleNsStackFind(ctx->ns_rendered, &ns_default)) {
+    	    xmlC14NPrintNamespaces(&ns_default, ctx);
+	}
+    }
+
+    
+
+    /* 
+     * print out all elements from list 
+     */
+    xmlListWalk(list, (xmlListWalker) xmlC14NPrintNamespaces, (const void *) ctx);
+
+    /* 
+     * Cleanup
+     */
+    xmlListDelete(list);
+    return (0);
+}
+
+
+/**
+ * xmlC14NAttrsCompare:
+ * @attr1:		the pointer tls o first attr
+ * @attr2: 		the pointer to second attr
+ *
+ * Prints the given attribute to the output buffer from C14N context.
+ *
+ * Returns -1 if attr1 < attr2, 0 if attr1 == attr2 or 1 if attr1 > attr2.
+ */
+static int
+xmlC14NAttrsCompare(xmlAttrPtr attr1, xmlAttrPtr attr2)
+{
+    int ret = 0;
+
+    /*
+     * Simple cases
+     */
+    if (attr1 == attr2)
+        return (0);
+    if (attr1 == NULL)
+        return (-1);
+    if (attr2 == NULL)
+        return (1);
+    if (attr1->ns == attr2->ns) {
+        return (xmlStrcmp(attr1->name, attr2->name));
+    }
+
+    /* 
+     * Attributes in the default namespace are first
+     * because the default namespace is not applied to
+     * unqualified attributes
+     */
+    if (attr1->ns == NULL)
+        return (-1);
+    if (attr2->ns == NULL)
+        return (1);
+    if (attr1->ns->prefix == NULL)
+        return (-1);
+    if (attr2->ns->prefix == NULL)
+        return (1);
+
+    ret = xmlStrcmp(attr1->ns->href, attr2->ns->href);
+    if (ret == 0) {
+        ret = xmlStrcmp(attr1->name, attr2->name);
+    }
+    return (ret);
+}
+
+
+/**
+ * xmlC14NPrintAttrs:
+ * @attr:		the pointer to attr
+ * @ctx: 		the C14N context
+ *
+ * Prints out canonical attribute urrent node to the
+ * buffer from C14N context as follows 
+ *
+ * Canonical XML v 1.0 (http://www.w3.org/TR/xml-c14n)
+ *
+ * Returns 1 on success or 0 on fail.
+ */
+static int
+xmlC14NPrintAttrs(const xmlAttrPtr attr, xmlC14NCtxPtr ctx)
+{
+    xmlChar *value;
+    xmlChar *buffer;
+
+    if ((attr == NULL) || (ctx == NULL)) {
+#ifdef DEBUG_C14N
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlC14NPrintAttrs: attr == NULL or ctx == NULL\n");
+#endif
+        return (0);
+    }
+
+    xmlOutputBufferWriteString(ctx->buf, " ");
+    if (attr->ns != NULL && xmlStrlen(attr->ns->prefix) > 0) {
+        xmlOutputBufferWriteString(ctx->buf,
+                                   (const char *) attr->ns->prefix);
+        xmlOutputBufferWriteString(ctx->buf, ":");
+    }
+    xmlOutputBufferWriteString(ctx->buf, (const char *) attr->name);
+    xmlOutputBufferWriteString(ctx->buf, "=\"");
+
+    value = xmlNodeListGetString(attr->doc, attr->children, 1);
+    /* todo: should we log an error if value==NULL ? */
+    if (value != NULL) {
+        buffer = xmlC11NNormalizeAttr(value);
+        xmlFree(value);
+        if (buffer != NULL) {
+            xmlOutputBufferWriteString(ctx->buf, (const char *) buffer);
+            xmlFree(buffer);
+        } else {
+#ifdef DEBUG_C14N
+            xmlGenericError(xmlGenericErrorContext,
+                            "xmlC14NPrintAttrs: xmlC11NNormalizeAttr failed\n");
+#endif
+            return (0);
+        }
+    }
+    xmlOutputBufferWriteString(ctx->buf, "\"");
+    return (1);
+}
+
+/**
+ * xmlC14NProcessAttrsAxis:
+ * @ctx: 		the C14N context
+ * @cur:		the current node
+ *
+ * Prints out canonical attribute axis of the current node to the
+ * buffer from C14N context as follows 
+ *
+ * Canonical XML v 1.0 (http://www.w3.org/TR/xml-c14n)
+ *
+ * Attribute Axis 
+ * In lexicographic order (ascending), process each node that 
+ * is in the element's attribute axis and in the node-set.
+ * 
+ * The processing of an element node E MUST be modified slightly 
+ * when an XPath node-set is given as input and the element's 
+ * parent is omitted from the node-set.
+ *
+ *
+ * Exclusive XML Canonicalization v 1.0 (http://www.w3.org/TR/xml-exc-c14n)
+ *
+ * Canonical XML applied to a document subset requires the search of the 
+ * ancestor nodes of each orphan element node for attributes in the xml 
+ * namespace, such as xml:lang and xml:space. These are copied into the 
+ * element node except if a declaration of the same attribute is already 
+ * in the attribute axis of the element (whether or not it is included in 
+ * the document subset). This search and copying are omitted from the 
+ * Exclusive XML Canonicalization method.
+ *
+ * Returns 0 on success or -1 on fail.
+ */
+static int
+xmlC14NProcessAttrsAxis(xmlC14NCtxPtr ctx, xmlNodePtr cur)
+{
+    xmlAttrPtr attr;
+    xmlListPtr list;
+
+    if ((ctx == NULL) || (cur == NULL) || (cur->type != XML_ELEMENT_NODE)) {
+#ifdef DEBUG_C14N
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlC14NProcessAttrsAxis: Null context or node pointer or type != XML_ELEMENT_NODE.\n");
+#endif
+        return (-1);
+    }
+
+    /*
+     * Create a sorted list to store element attributes
+     */
+    list = xmlListCreate(NULL, (xmlListDataCompare) xmlC14NAttrsCompare);
+    if (list == NULL) {
+#ifdef DEBUG_C14N
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlC14NProcessAttrsAxis: list creation failed\n");
+#endif
+        return (-1);
+    }
+
+    /* 
+     * Add all visible attributes from current node. 
+     */
+    attr = cur->properties;
+    while (attr != NULL) {
+        /* check that attribute is visible */
+        if (xmlC14NIsVisible(ctx, attr, cur)) {
+            xmlListInsert(list, attr);
+        }
+        attr = attr->next;
+    }
+
+    /* 
+     * include attributes in "xml" namespace defined in ancestors
+     * (only for non-exclusive XML Canonicalization)
+     */
+    if ((!ctx->exclusive) && (cur->parent != NULL)
+        && (!xmlC14NIsVisible(ctx, cur->parent, cur->parent->parent))) {
+        /*
+         * If XPath node-set is not specified then the parent is always 
+         * visible!
+         */
+        cur = cur->parent;
+        while (cur != NULL) {
+            attr = cur->properties;
+            while (attr != NULL) {
+                if ((attr->ns != NULL)
+                    && (xmlStrEqual(attr->ns->prefix, BAD_CAST "xml"))) {
+                    if (xmlListSearch(list, attr) == NULL) {
+                        xmlListInsert(list, attr);
+                    }
+                }
+                attr = attr->next;
+            }
+            cur = cur->parent;
+        }
+    }
+
+    /* 
+     * print out all elements from list 
+     */
+    xmlListWalk(list, (xmlListWalker) xmlC14NPrintAttrs, (const void *) ctx);
+
+    /* 
+     * Cleanup
+     */
+    xmlListDelete(list);
+    return (0);
+}
+
+/** 
+ * xmlC14NCheckForRelativeNamespaces:
+ * @ctx:		the C14N context
+ * @cur:		the current element node
+ *
+ * Checks that current element node has no relative namespaces defined
+ *
+ * Returns 0 if the node has no relative namespaces or -1 otherwise.
+ */
+static int
+xmlC14NCheckForRelativeNamespaces(xmlC14NCtxPtr ctx, xmlNodePtr cur)
+{
+    xmlNsPtr ns;
+
+    if ((ctx == NULL) || (cur == NULL) || (cur->type != XML_ELEMENT_NODE)) {
+#ifdef DEBUG_C14N
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlC14NCheckForRelativeNamespaces: Null context or node pointer or type != XML_ELEMENT_NODE.\n");
+#endif
+        return (-1);
+    }
+
+    ns = cur->nsDef;
+    while (ns != NULL) {
+        if (xmlStrlen(ns->href) > 0) {
+            xmlURIPtr uri;
+
+            uri = xmlParseURI((const char *) ns->href);
+            if (uri == NULL) {
+#ifdef DEBUG_C14N
+                xmlGenericError(xmlGenericErrorContext,
+                                "xmlC14NCheckForRelativeNamespaces: unable to parse uri=\"%s\".\n",
+                                ns->href);
+#endif
+                return (-1);
+            }
+            if (xmlStrlen((const xmlChar *) uri->scheme) == 0) {
+                xmlFreeURI(uri);
+                return (-1);
+            }
+            if ((!xmlStrEqual
+                 ((const xmlChar *) uri->scheme, BAD_CAST "urn"))
+                && (xmlStrlen((const xmlChar *) uri->server) == 0)) {
+                xmlFreeURI(uri);
+                return (-1);
+            }
+            xmlFreeURI(uri);
+        }
+        ns = ns->next;
+    }
+    return (0);
+}
+
+/**
+ * xmlC14NProcessElementNode:
+ * @ctx: 		the pointer to C14N context object
+ * @cur:		the node to process
+ *  		
+ * Canonical XML v 1.0 (http://www.w3.org/TR/xml-c14n)
+ *
+ * Element Nodes
+ * If the element is not in the node-set, then the result is obtained 
+ * by processing the namespace axis, then the attribute axis, then 
+ * processing the child nodes of the element that are in the node-set 
+ * (in document order). If the element is in the node-set, then the result 
+ * is an open angle bracket (<), the element QName, the result of 
+ * processing the namespace axis, the result of processing the attribute 
+ * axis, a close angle bracket (>), the result of processing the child 
+ * nodes of the element that are in the node-set (in document order), an 
+ * open angle bracket, a forward slash (/), the element QName, and a close 
+ * angle bracket.
+ *
+ * Returns non-negative value on success or negative value on fail
+ */
+static int
+xmlC14NProcessElementNode(xmlC14NCtxPtr ctx, xmlNodePtr cur, int visible)
+{
+    int ret;
+    xmlC14NVisibleNsStack state;
+    int parent_is_doc = 0;
+
+    if ((ctx == NULL) || (cur == NULL) || (cur->type != XML_ELEMENT_NODE)) {
+#ifdef DEBUG_C14N
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlC14NProcessElementNode: Null context or node pointer or type != XML_ELEMENT_NODE.\n");
+#endif
+        return (-1);
+    }
+
+    /* 
+     * Check relative relative namespaces:
+     * implementations of XML canonicalization MUST report an operation
+     * failure on documents containing relative namespace URIs.
+     */
+    if (xmlC14NCheckForRelativeNamespaces(ctx, cur) < 0) {
+#ifdef DEBUG_C14N
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlC14NProcessElementNode: xmlC14NCheckForRelativeNamespaces failed.\n");
+#endif
+        return (-1);
+    }
+
+
+    /* 
+     * Save ns_rendered stack position
+     */
+    xmlC14NVisibleNsStackSave(ctx->ns_rendered, &state);
+
+    if (visible) {	
+        if (ctx->parent_is_doc) {
+	    /* save this flag into the stack */
+	    parent_is_doc = ctx->parent_is_doc;
+	    ctx->parent_is_doc = 0;
+            ctx->pos = XMLC14N_INSIDE_DOCUMENT_ELEMENT;
+        }
+        xmlOutputBufferWriteString(ctx->buf, "<");
+
+        if ((cur->ns != NULL) && (xmlStrlen(cur->ns->prefix) > 0)) {
+            xmlOutputBufferWriteString(ctx->buf,
+                                       (const char *) cur->ns->prefix);
+            xmlOutputBufferWriteString(ctx->buf, ":");
+        }
+        xmlOutputBufferWriteString(ctx->buf, (const char *) cur->name);
+    }
+
+    if (!ctx->exclusive) {
+        ret = xmlC14NProcessNamespacesAxis(ctx, cur, visible);
+    } else {
+        ret = xmlExcC14NProcessNamespacesAxis(ctx, cur, visible);
+    }
+    if (ret < 0) {
+#ifdef DEBUG_C14N
+        xmlGenericError(xmlGenericErrorContext,
+            "xmlC14NProcessElementNode: xmlC14NProcessNamespacesAxis failed.\n");
+#endif
+        return (-1);
+    }
+    /* todo: shouldn't this go to "visible only"? */
+    if(visible) {
+	xmlC14NVisibleNsStackShift(ctx->ns_rendered);
+    }
+    
+    if(visible) {
+	ret = xmlC14NProcessAttrsAxis(ctx, cur);
+	if (ret < 0) {
+#ifdef DEBUG_C14N
+    	    xmlGenericError(xmlGenericErrorContext,
+                "xmlC14NProcessElementNode: xmlC14NProcessAttrsAxis failed.\n");
+#endif
+    	    return (-1);
+	}
+    }
+
+    if (visible) { 
+        xmlOutputBufferWriteString(ctx->buf, ">");
+    }
+    if (cur->children != NULL) {
+        ret = xmlC14NProcessNodeList(ctx, cur->children);
+        if (ret < 0) {
+#ifdef DEBUG_C14N
+            xmlGenericError(xmlGenericErrorContext,
+                            "xmlC14NProcessElementNode: xmlC14NProcessNodeList failed.\n");
+#endif
+            return (-1);
+        }
+    }
+    if (visible) {
+        xmlOutputBufferWriteString(ctx->buf, "</");
+        if ((cur->ns != NULL) && (xmlStrlen(cur->ns->prefix) > 0)) {
+            xmlOutputBufferWriteString(ctx->buf,
+                                       (const char *) cur->ns->prefix);
+            xmlOutputBufferWriteString(ctx->buf, ":");
+        }
+        xmlOutputBufferWriteString(ctx->buf, (const char *) cur->name);
+        xmlOutputBufferWriteString(ctx->buf, ">");
+        if (parent_is_doc) {
+	    /* restore this flag from the stack for next node */
+            ctx->parent_is_doc = parent_is_doc;
+	    ctx->pos = XMLC14N_AFTER_DOCUMENT_ELEMENT;
+        }
+    }
+
+    /* 
+     * Restore ns_rendered stack position
+     */
+    xmlC14NVisibleNsStackRestore(ctx->ns_rendered, &state);
+    return (0);
+}
+
+/**
+ * xmlC14NProcessNode:
+ * @ctx: 		the pointer to C14N context object
+ * @cur:		the node to process
+ *  		
+ * Processes the given node
+ *
+ * Returns non-negative value on success or negative value on fail
+ */
+static int
+xmlC14NProcessNode(xmlC14NCtxPtr ctx, xmlNodePtr cur)
+{
+    int ret = 0;
+    int visible;
+
+    if ((ctx == NULL) || (cur == NULL)) {
+#ifdef DEBUG_C14N
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlC14NProcessNode: Null context or node pointer.\n");
+#endif
+        return (-1);
+    }
+
+    visible = xmlC14NIsVisible(ctx, cur, cur->parent);
+    switch (cur->type) {
+        case XML_ELEMENT_NODE:
+            ret = xmlC14NProcessElementNode(ctx, cur, visible);
+            break;
+        case XML_CDATA_SECTION_NODE:
+        case XML_TEXT_NODE:
+            /*
+             * Text Nodes
+             * the string value, except all ampersands are replaced 
+             * by &amp;, all open angle brackets (<) are replaced by &lt;, all closing 
+             * angle brackets (>) are replaced by &gt;, and all #xD characters are 
+             * replaced by &#xD;.
+             */
+            /* cdata sections are processed as text nodes */
+            /* todo: verify that cdata sections are included in XPath nodes set */
+            if ((visible) && (cur->content != NULL)) {
+                xmlChar *buffer;
+
+                buffer = xmlC11NNormalizeText(cur->content);
+                if (buffer != NULL) {
+                    xmlOutputBufferWriteString(ctx->buf,
+                                               (const char *) buffer);
+                    xmlFree(buffer);
+                } else {
+#ifdef DEBUG_C14N
+                    xmlGenericError(xmlGenericErrorContext,
+                                    "xmlC14NProcessNode: xmlC11NNormalizeText() failed\n");
+#endif
+                    return (-1);
+                }
+            }
+            break;
+        case XML_PI_NODE:
+            /* 
+             * Processing Instruction (PI) Nodes- 
+             * The opening PI symbol (<?), the PI target name of the node, 
+             * a leading space and the string value if it is not empty, and 
+             * the closing PI symbol (?>). If the string value is empty, 
+             * then the leading space is not added. Also, a trailing #xA is 
+             * rendered after the closing PI symbol for PI children of the 
+             * root node with a lesser document order than the document 
+             * element, and a leading #xA is rendered before the opening PI 
+             * symbol of PI children of the root node with a greater document 
+             * order than the document element.
+             */
+            if (visible) {
+                if (ctx->pos == XMLC14N_AFTER_DOCUMENT_ELEMENT) {
+                    xmlOutputBufferWriteString(ctx->buf, "\x0A<?");
+                } else {
+                    xmlOutputBufferWriteString(ctx->buf, "<?");
+                }
+
+                xmlOutputBufferWriteString(ctx->buf,
+                                           (const char *) cur->name);
+                if ((cur->content != NULL) && (*(cur->content) != '\0')) {
+                    xmlChar *buffer;
+
+                    xmlOutputBufferWriteString(ctx->buf, " ");
+
+                    /* todo: do we need to normalize pi? */
+                    buffer = xmlC11NNormalizePI(cur->content);
+                    if (buffer != NULL) {
+                        xmlOutputBufferWriteString(ctx->buf,
+                                                   (const char *) buffer);
+                        xmlFree(buffer);
+                    } else {
+#ifdef DEBUG_C14N
+                        xmlGenericError(xmlGenericErrorContext,
+                                        "xmlC14NProcessNode: xmlC11NNormalizePI() failed\n");
+#endif
+                        return (-1);
+                    }
+                }
+
+                if (ctx->pos == XMLC14N_BEFORE_DOCUMENT_ELEMENT) {
+                    xmlOutputBufferWriteString(ctx->buf, "?>\x0A");
+                } else {
+                    xmlOutputBufferWriteString(ctx->buf, "?>");
+                }
+            }
+            break;
+        case XML_COMMENT_NODE:
+            /*
+             * Comment Nodes
+             * Nothing if generating canonical XML without  comments. For 
+             * canonical XML with comments, generate the opening comment 
+             * symbol (<!--), the string value of the node, and the 
+             * closing comment symbol (-->). Also, a trailing #xA is rendered 
+             * after the closing comment symbol for comment children of the 
+             * root node with a lesser document order than the document 
+             * element, and a leading #xA is rendered before the opening 
+             * comment symbol of comment children of the root node with a 
+             * greater document order than the document element. (Comment 
+             * children of the root node represent comments outside of the 
+             * top-level document element and outside of the document type 
+             * declaration).
+             */
+            if (visible && ctx->with_comments) {
+                if (ctx->pos == XMLC14N_AFTER_DOCUMENT_ELEMENT) {
+                    xmlOutputBufferWriteString(ctx->buf, "\x0A<!--");
+                } else {
+                    xmlOutputBufferWriteString(ctx->buf, "<!--");
+                }
+
+                if (cur->content != NULL) {
+                    xmlChar *buffer;
+
+                    /* todo: do we need to normalize comment? */
+                    buffer = xmlC11NNormalizeComment(cur->content);
+                    if (buffer != NULL) {
+                        xmlOutputBufferWriteString(ctx->buf,
+                                                   (const char *) buffer);
+                        xmlFree(buffer);
+                    } else {
+#ifdef DEBUG_C14N
+                        xmlGenericError(xmlGenericErrorContext,
+                                        "xmlC14NProcessNode: xmlC11NNormalizeComment() failed\n");
+#endif
+                        return (-1);
+                    }
+                }
+
+                if (ctx->pos == XMLC14N_BEFORE_DOCUMENT_ELEMENT) {
+                    xmlOutputBufferWriteString(ctx->buf, "-->\x0A");
+                } else {
+                    xmlOutputBufferWriteString(ctx->buf, "-->");
+                }
+            }
+            break;
+        case XML_DOCUMENT_NODE:
+        case XML_DOCUMENT_FRAG_NODE:   /* should be processed as document? */
+#ifdef LIBXML_DOCB_ENABLED
+        case XML_DOCB_DOCUMENT_NODE:   /* should be processed as document? */
+#endif
+#ifdef LIBXML_HTML_ENABLED
+        case XML_HTML_DOCUMENT_NODE:   /* should be processed as document? */
+#endif
+            if (cur->children != NULL) {
+                ctx->pos = XMLC14N_BEFORE_DOCUMENT_ELEMENT;
+                ctx->parent_is_doc = 1;
+                ret = xmlC14NProcessNodeList(ctx, cur->children);
+            }
+            break;
+
+        case XML_ATTRIBUTE_NODE:
+	    xmlC14NErr(ctx, cur, XML_C14N_INVALID_NODE,
+		"xmlC14NProcessNode: XML_ATTRIBUTE_NODE is illegal here\n");
+            return (-1);
+        case XML_NAMESPACE_DECL:
+	    xmlC14NErr(ctx, cur, XML_C14N_INVALID_NODE,
+		"xmlC14NProcessNode: XML_NAMESPACE_DECL is illegal here\n");
+            return (-1);
+        case XML_ENTITY_REF_NODE:
+	    xmlC14NErr(ctx, cur, XML_C14N_INVALID_NODE,
+		"xmlC14NProcessNode: XML_ENTITY_REF_NODE is illegal here\n");
+            return (-1);
+        case XML_ENTITY_NODE:
+	    xmlC14NErr(ctx, cur, XML_C14N_INVALID_NODE,
+		"xmlC14NProcessNode: XML_ENTITY_NODE is illegal here\n");
+            return (-1);
+
+        case XML_DOCUMENT_TYPE_NODE:
+        case XML_NOTATION_NODE:
+        case XML_DTD_NODE:
+        case XML_ELEMENT_DECL:
+        case XML_ATTRIBUTE_DECL:
+        case XML_ENTITY_DECL:
+#ifdef LIBXML_XINCLUDE_ENABLED
+        case XML_XINCLUDE_START:
+        case XML_XINCLUDE_END:
+#endif
+            /* 
+             * should be ignored according to "W3C Canonical XML" 
+             */
+            break;
+        default:
+#ifdef DEBUG_C14N
+            xmlGenericError(xmlGenericErrorContext,
+                            "xmlC14NProcessNode: unknown node type = %d\n",
+                            cur->type);
+#endif
+            return (-1);
+    }
+
+    return (ret);
+}
+
+/**
+ * xmlC14NProcessNodeList:
+ * @ctx: 		the pointer to C14N context object
+ * @cur:		the node to start from
+ *  		
+ * Processes all nodes in the row starting from cur.
+ *
+ * Returns non-negative value on success or negative value on fail
+ */
+static int
+xmlC14NProcessNodeList(xmlC14NCtxPtr ctx, xmlNodePtr cur)
+{
+    int ret;
+
+    if (ctx == NULL) {
+#ifdef DEBUG_C14N
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlC14NProcessNodeList: Null context pointer.\n");
+#endif
+        return (-1);
+    }
+
+    for (ret = 0; cur != NULL && ret >= 0; cur = cur->next) {
+        ret = xmlC14NProcessNode(ctx, cur);
+    }
+    return (ret);
+}
+
+
+/**
+ * xmlC14NFreeCtx:
+ * @ctx: the pointer to C14N context object
+ * 		
+ * Cleanups the C14N context object.
+ */
+
+static void
+xmlC14NFreeCtx(xmlC14NCtxPtr ctx)
+{
+    if (ctx == NULL) {
+#ifdef DEBUG_C14N
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlC14NFreeCtx: ctx == NULL\n");
+#endif
+        return;
+    }
+
+    if (ctx->ns_rendered != NULL) {
+        xmlC14NVisibleNsStackDestroy(ctx->ns_rendered);
+    }
+    xmlFree(ctx);
+}
+
+/**
+ * xmlC14NNewCtx:
+ * @doc: 		the XML document for canonization
+ * @is_visible_callback:the function to use to determine is node visible 
+ *			or not
+ * @user_data: 		the first parameter for @is_visible_callback function
+ *			(in most cases, it is nodes set)
+ * @inclusive_ns_prefixe the list of inclusive namespace prefixes 
+ *			ended with a NULL or NULL if there is no
+ *			inclusive namespaces (only for exclusive 
+ *			canonicalization)
+ * @with_comments: 	include comments in the result (!=0) or not (==0)
+ * @buf: 		the output buffer to store canonical XML; this 
+ *			buffer MUST have encoder==NULL because C14N requires
+ *			UTF-8 output
+ *  		
+ * Creates new C14N context object to store C14N parameters.
+ *
+ * Returns pointer to newly created object (success) or NULL (fail)
+ */
+static xmlC14NCtxPtr
+xmlC14NNewCtx(xmlDocPtr doc,  
+	      xmlC14NIsVisibleCallback is_visible_callback, void* user_data,
+              int exclusive, xmlChar ** inclusive_ns_prefixes,
+              int with_comments, xmlOutputBufferPtr buf)
+{
+    xmlC14NCtxPtr ctx = NULL;
+
+    if ((doc == NULL) || (buf == NULL)) {
+#ifdef DEBUG_C14N
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlC14NNewCtx: pointer to document or output buffer is NULL\n");
+#endif
+        return (NULL);
+    }
+
+    /*
+     *  Validate the encoding output buffer encoding
+     */
+    if (buf->encoder != NULL) {
+        xmlC14NErr(ctx, (xmlNodePtr) doc, XML_C14N_REQUIRES_UTF8,
+"xmlC14NNewCtx: output buffer encoder != NULL but C14N requires UTF8 output\n");
+        return (NULL);
+    }
+
+    /*
+     *  Validate the XML document encoding value, if provided.
+     */
+    if (doc->charset != XML_CHAR_ENCODING_UTF8) {
+        xmlC14NErr(ctx, (xmlNodePtr) doc, XML_C14N_REQUIRES_UTF8,
+		   "xmlC14NNewCtx: source document not in UTF8\n");
+        return (NULL);
+    }
+
+    /*
+     * Allocate a new xmlC14NCtxPtr and fill the fields.
+     */
+    ctx = (xmlC14NCtxPtr) xmlMalloc(sizeof(xmlC14NCtx));
+    if (ctx == NULL) {
+	xmlC14NErrMemory("creating context");
+        return (NULL);
+    }
+    memset(ctx, 0, sizeof(xmlC14NCtx));
+
+    /*
+     * initialize C14N context
+     */
+    ctx->doc = doc;
+    ctx->with_comments = with_comments;
+    ctx->is_visible_callback = is_visible_callback;
+    ctx->user_data = user_data;
+    ctx->buf = buf;
+    ctx->parent_is_doc = 1;
+    ctx->pos = XMLC14N_BEFORE_DOCUMENT_ELEMENT;
+    ctx->ns_rendered = xmlC14NVisibleNsStackCreate();
+
+    if(ctx->ns_rendered == NULL) {
+        xmlC14NErr(ctx, (xmlNodePtr) doc, XML_C14N_CREATE_STACK,
+		   "xmlC14NNewCtx: xmlC14NVisibleNsStackCreate failed\n");
+	xmlC14NFreeCtx(ctx);
+        return (NULL);
+    }
+
+    /*
+     * Set "exclusive" flag, create a nodes set for namespaces
+     * stack and remember list of incluseve prefixes
+     */
+    if (exclusive) {
+        ctx->exclusive = 1;
+        ctx->inclusive_ns_prefixes = inclusive_ns_prefixes;
+    }
+    return (ctx);
+}
+
+/**
+ * xmlC14NExecute:
+ * @doc: 		the XML document for canonization
+ * @is_visible_callback:the function to use to determine is node visible 
+ *			or not
+ * @user_data: 		the first parameter for @is_visible_callback function
+ *			(in most cases, it is nodes set)
+ * @exclusive:		the exclusive flag (0 - non-exclusive canonicalization;
+ *			otherwise - exclusive canonicalization)
+ * @inclusive_ns_prefixes: the list of inclusive namespace prefixes 
+ *			ended with a NULL or NULL if there is no
+ *			inclusive namespaces (only for exclusive 
+ *			canonicalization, ignored otherwise)
+ * @with_comments: 	include comments in the result (!=0) or not (==0)
+ * @buf: 		the output buffer to store canonical XML; this 
+ *			buffer MUST have encoder==NULL because C14N requires
+ *			UTF-8 output
+ *  		
+ * Dumps the canonized image of given XML document into the provided buffer.
+ * For details see "Canonical XML" (http://www.w3.org/TR/xml-c14n) or
+ * "Exclusive XML Canonicalization" (http://www.w3.org/TR/xml-exc-c14n)
+ *
+ * Returns non-negative value on success or a negative value on fail  
+ */
+int 		
+xmlC14NExecute(xmlDocPtr doc, xmlC14NIsVisibleCallback is_visible_callback,
+	 void* user_data, int exclusive, xmlChar **inclusive_ns_prefixes,
+	 int with_comments, xmlOutputBufferPtr buf) {
+
+    xmlC14NCtxPtr ctx;
+    int ret;
+
+    if ((buf == NULL) || (doc == NULL)) {
+#ifdef DEBUG_C14N
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlC14NExecute: null return buffer or doc pointer\n");
+#endif
+        return (-1);
+    }
+
+    /*
+     *  Validate the encoding output buffer encoding
+     */
+    if (buf->encoder != NULL) {
+        xmlC14NErr(NULL, (xmlNodePtr) doc, XML_C14N_REQUIRES_UTF8,
+"xmlC14NExecute: output buffer encoder != NULL but C14N requires UTF8 output\n");
+        return (-1);
+    }
+
+    ctx = xmlC14NNewCtx(doc, is_visible_callback, user_data, 
+			exclusive, inclusive_ns_prefixes,
+                        with_comments, buf);
+    if (ctx == NULL) {
+        xmlC14NErr(NULL, (xmlNodePtr) doc, XML_C14N_CREATE_CTXT,
+		   "xmlC14NExecute: unable to create C14N context\n");
+        return (-1);
+    }
+
+
+
+    /*  
+     * Root Node
+     * The root node is the parent of the top-level document element. The 
+     * result of processing each of its child nodes that is in the node-set 
+     * in document order. The root node does not generate a byte order mark, 
+     * XML declaration, nor anything from within the document type 
+     * declaration.
+     */
+    if (doc->children != NULL) {
+        ret = xmlC14NProcessNodeList(ctx, doc->children);
+        if (ret < 0) {
+#ifdef DEBUG_C14N
+            xmlGenericError(xmlGenericErrorContext,
+                            "xmlC14NExecute: process childrens' list failed.\n");
+#endif
+            xmlC14NFreeCtx(ctx);
+            return (-1);
+        }
+    }
+
+    /*
+     * Flush buffer to get number of bytes written
+     */
+    ret = xmlOutputBufferFlush(buf);
+    if (ret < 0) {
+#ifdef DEBUG_C14N
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlC14NExecute: buffer flush failed.\n");
+#endif
+        xmlC14NFreeCtx(ctx);
+        return (-1);
+    }
+
+    /* 
+     * Cleanup
+     */
+    xmlC14NFreeCtx(ctx);
+    return (ret);
+}
+
+/**
+ * xmlC14NDocSaveTo:
+ * @doc: 		the XML document for canonization
+ * @nodes: 		the nodes set to be included in the canonized image
+ *      		or NULL if all document nodes should be included
+ * @exclusive:		the exclusive flag (0 - non-exclusive canonicalization;
+ *			otherwise - exclusive canonicalization)
+ * @inclusive_ns_prefixes: the list of inclusive namespace prefixes 
+ *			ended with a NULL or NULL if there is no
+ *			inclusive namespaces (only for exclusive 
+ *			canonicalization, ignored otherwise)
+ * @with_comments: 	include comments in the result (!=0) or not (==0)
+ * @buf: 		the output buffer to store canonical XML; this 
+ *			buffer MUST have encoder==NULL because C14N requires
+ *			UTF-8 output
+ *  		
+ * Dumps the canonized image of given XML document into the provided buffer.
+ * For details see "Canonical XML" (http://www.w3.org/TR/xml-c14n) or
+ * "Exclusive XML Canonicalization" (http://www.w3.org/TR/xml-exc-c14n)
+ *
+ * Returns non-negative value on success or a negative value on fail  
+ */
+int
+xmlC14NDocSaveTo(xmlDocPtr doc, xmlNodeSetPtr nodes,
+                 int exclusive, xmlChar ** inclusive_ns_prefixes,
+                 int with_comments, xmlOutputBufferPtr buf) {
+    return(xmlC14NExecute(doc, 
+			(xmlC14NIsVisibleCallback)xmlC14NIsNodeInNodeset,
+			nodes,
+			exclusive,
+			inclusive_ns_prefixes,
+			with_comments,
+			buf));
+}
+
+
+/**
+ * xmlC14NDocDumpMemory:
+ * @doc: 		the XML document for canonization
+ * @nodes: 		the nodes set to be included in the canonized image
+ *      		or NULL if all document nodes should be included
+ * @exclusive:		the exclusive flag (0 - non-exclusive canonicalization;
+ *			otherwise - exclusive canonicalization)
+ * @inclusive_ns_prefixes: the list of inclusive namespace prefixes 
+ *			ended with a NULL or NULL if there is no
+ *			inclusive namespaces (only for exclusive 
+ *			canonicalization, ignored otherwise)
+ * @with_comments: 	include comments in the result (!=0) or not (==0)
+ * @doc_txt_ptr: 	the memory pointer for allocated canonical XML text;
+ *			the caller of this functions is responsible for calling
+ *			xmlFree() to free allocated memory 
+ *  		
+ * Dumps the canonized image of given XML document into memory.
+ * For details see "Canonical XML" (http://www.w3.org/TR/xml-c14n) or
+ * "Exclusive XML Canonicalization" (http://www.w3.org/TR/xml-exc-c14n)
+ *
+ * Returns the number of bytes written on success or a negative value on fail  
+ */
+int
+xmlC14NDocDumpMemory(xmlDocPtr doc, xmlNodeSetPtr nodes,
+                     int exclusive, xmlChar ** inclusive_ns_prefixes,
+                     int with_comments, xmlChar ** doc_txt_ptr)
+{
+    int ret;
+    xmlOutputBufferPtr buf;
+
+    if (doc_txt_ptr == NULL) {
+#ifdef DEBUG_C14N
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlC14NDocDumpMemory:  null return buffer pointer\n");
+#endif
+        return (-1);
+    }
+
+    *doc_txt_ptr = NULL;
+
+    /*
+     * create memory buffer with UTF8 (default) encoding 
+     */
+    buf = xmlAllocOutputBuffer(NULL);
+    if (buf == NULL) {
+#ifdef DEBUG_C14N
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlC14NDocDumpMemory: failed to allocate output buffer.\n");
+#endif
+        return (-1);
+    }
+
+    /*
+     * canonize document and write to buffer
+     */
+    ret = xmlC14NDocSaveTo(doc, nodes, exclusive, inclusive_ns_prefixes,
+                           with_comments, buf);
+    if (ret < 0) {
+#ifdef DEBUG_C14N
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlC14NDocDumpMemory: xmlC14NDocSaveTo failed.\n");
+#endif
+        (void) xmlOutputBufferClose(buf);
+        return (-1);
+    }
+
+    ret = buf->buffer->use;
+    if (ret > 0) {
+        *doc_txt_ptr = xmlStrndup(buf->buffer->content, ret);
+    }
+    (void) xmlOutputBufferClose(buf);
+
+    if ((*doc_txt_ptr == NULL) && (ret > 0)) {
+#ifdef DEBUG_C14N
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlC14NDocDumpMemory: failed to allocate memory for document text representation\n");
+#endif
+        return (-1);
+    }
+    return (ret);
+}
+
+/**
+ * xmlC14NDocSave:
+ * @doc: 		the XML document for canonization
+ * @nodes: 		the nodes set to be included in the canonized image
+ *      		or NULL if all document nodes should be included
+ * @exclusive:		the exclusive flag (0 - non-exclusive canonicalization;
+ *			otherwise - exclusive canonicalization)
+ * @inclusive_ns_prefixes: the list of inclusive namespace prefixes 
+ *			ended with a NULL or NULL if there is no
+ *			inclusive namespaces (only for exclusive 
+ *			canonicalization, ignored otherwise)
+ * @with_comments: 	include comments in the result (!=0) or not (==0)
+ * @filename: 		the filename to store canonical XML image
+ * @compression:	the compression level (zlib requred): 
+ *				-1 - libxml default,
+ *				 0 - uncompressed, 
+ *				>0 - compression level
+ *  		
+ * Dumps the canonized image of given XML document into the file.
+ * For details see "Canonical XML" (http://www.w3.org/TR/xml-c14n) or
+ * "Exclusive XML Canonicalization" (http://www.w3.org/TR/xml-exc-c14n)
+ *
+ * Returns the number of bytes written success or a negative value on fail  
+ */
+int
+xmlC14NDocSave(xmlDocPtr doc, xmlNodeSetPtr nodes,
+               int exclusive, xmlChar ** inclusive_ns_prefixes,
+               int with_comments, const char *filename, int compression)
+{
+    xmlOutputBufferPtr buf;
+    int ret;
+
+    if (filename == NULL) {
+#ifdef DEBUG_C14N
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlC14NDocSave:  filename is NULL\n");
+#endif
+        return (-1);
+    }
+#ifdef HAVE_ZLIB_H
+    if (compression < 0)
+        compression = xmlGetCompressMode();
+#endif
+
+    /* 
+     * save the content to a temp buffer, use default UTF8 encoding.
+     */
+    buf = xmlOutputBufferCreateFilename(filename, NULL, compression);
+    if (buf == NULL) {
+#ifdef DEBUG_C14N
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlC14NDocSave:  unable to create buffer for file=\"%s\" with compressin=%d\n",
+                        filename, compression);
+#endif
+        return (-1);
+    }
+
+    /*
+     * canonize document and write to buffer
+     */
+    ret = xmlC14NDocSaveTo(doc, nodes, exclusive, inclusive_ns_prefixes,
+                           with_comments, buf);
+    if (ret < 0) {
+#ifdef DEBUG_C14N
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlC14NDocSave: xmlC14NDocSaveTo failed.\n");
+#endif
+        (void) xmlOutputBufferClose(buf);
+        return (-1);
+    }
+
+    /* 
+     * get the numbers of bytes written 
+     */
+    ret = xmlOutputBufferClose(buf);
+    return (ret);
+}
+
+
+
+/*
+ * Macro used to grow the current buffer.
+ */
+#define growBufferReentrant() {						\
+    buffer_size *= 2;							\
+    buffer = (xmlChar *)						\
+    		xmlRealloc(buffer, buffer_size * sizeof(xmlChar));	\
+    if (buffer == NULL) {						\
+	xmlC14NErrMemory("growing buffer");				\
+	return(NULL);							\
+    }									\
+}
+
+/** 
+ * xmlC11NNormalizeString:
+ * @input:		the input string
+ * @mode:		the normalization mode (attribute, comment, PI or text)
+ *
+ * Converts a string to a canonical (normalized) format. The code is stolen
+ * from xmlEncodeEntitiesReentrant(). Added normalization of \x09, \x0a, \x0A
+ * and the @mode parameter
+ *
+ * Returns a normalized string (caller is responsible for calling xmlFree())
+ * or NULL if an error occurs
+ */
+static xmlChar *
+xmlC11NNormalizeString(const xmlChar * input,
+                       xmlC14NNormalizationMode mode)
+{
+    const xmlChar *cur = input;
+    xmlChar *buffer = NULL;
+    xmlChar *out = NULL;
+    int buffer_size = 0;
+
+    if (input == NULL)
+        return (NULL);
+
+    /*
+     * allocate an translation buffer.
+     */
+    buffer_size = 1000;
+    buffer = (xmlChar *) xmlMallocAtomic(buffer_size * sizeof(xmlChar));
+    if (buffer == NULL) {
+	xmlC14NErrMemory("allocating buffer");
+        return (NULL);
+    }
+    out = buffer;
+
+    while (*cur != '\0') {
+        if ((out - buffer) > (buffer_size - 10)) {
+            int indx = out - buffer;
+
+            growBufferReentrant();
+            out = &buffer[indx];
+        }
+
+        if ((*cur == '<') && ((mode == XMLC14N_NORMALIZE_ATTR) ||
+                              (mode == XMLC14N_NORMALIZE_TEXT))) {
+            *out++ = '&';
+            *out++ = 'l';
+            *out++ = 't';
+            *out++ = ';';
+        } else if ((*cur == '>') && (mode == XMLC14N_NORMALIZE_TEXT)) {
+            *out++ = '&';
+            *out++ = 'g';
+            *out++ = 't';
+            *out++ = ';';
+        } else if ((*cur == '&') && ((mode == XMLC14N_NORMALIZE_ATTR) ||
+                                     (mode == XMLC14N_NORMALIZE_TEXT))) {
+            *out++ = '&';
+            *out++ = 'a';
+            *out++ = 'm';
+            *out++ = 'p';
+            *out++ = ';';
+        } else if ((*cur == '"') && (mode == XMLC14N_NORMALIZE_ATTR)) {
+            *out++ = '&';
+            *out++ = 'q';
+            *out++ = 'u';
+            *out++ = 'o';
+            *out++ = 't';
+            *out++ = ';';
+        } else if ((*cur == '\x09') && (mode == XMLC14N_NORMALIZE_ATTR)) {
+            *out++ = '&';
+            *out++ = '#';
+            *out++ = 'x';
+            *out++ = '9';
+            *out++ = ';';
+        } else if ((*cur == '\x0A') && (mode == XMLC14N_NORMALIZE_ATTR)) {
+            *out++ = '&';
+            *out++ = '#';
+            *out++ = 'x';
+            *out++ = 'A';
+            *out++ = ';';
+        } else if ((*cur == '\x0D') && ((mode == XMLC14N_NORMALIZE_ATTR) ||
+                                        (mode == XMLC14N_NORMALIZE_TEXT) ||
+                                        (mode == XMLC14N_NORMALIZE_COMMENT) ||
+					(mode == XMLC14N_NORMALIZE_PI))) {
+            *out++ = '&';
+            *out++ = '#';
+            *out++ = 'x';
+            *out++ = 'D';
+            *out++ = ';';
+        } else {
+            /*
+             * Works because on UTF-8, all extended sequences cannot
+             * result in bytes in the ASCII range.
+             */
+            *out++ = *cur;
+        }
+        cur++;
+    }
+    *out++ = 0;
+    return (buffer);
+}
+#endif /* LIBXML_OUTPUT_ENABLED */
+#endif /* LIBXML_C14N_ENABLED */
diff --git a/src/libxml/src/catalog.c b/src/libxml/src/catalog.c
new file mode 100644
index 0000000..711761e
--- /dev/null
+++ b/src/libxml/src/catalog.c
@@ -0,0 +1,3589 @@
+/**
+ * catalog.c: set of generic Catalog related routines 
+ *
+ * Reference:  SGML Open Technical Resolution TR9401:1997.
+ *             http://www.jclark.com/sp/catalog.htm
+ *
+ *             XML Catalogs Working Draft 06 August 2001
+ *             http://www.oasis-open.org/committees/entity/spec-2001-08-06.html
+ *
+ * See Copyright for the status of this software.
+ *
+ * Daniel.Veillard@imag.fr
+ */
+
+#define IN_LIBXML
+#include "libxml.h"
+
+#ifdef LIBXML_CATALOG_ENABLED
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_STAT_H
+#include <sys/stat.h>
+#endif
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#ifdef HAVE_FCNTL_H
+#include <fcntl.h>
+#endif
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+#include <string.h>
+#include <libxml/xmlmemory.h>
+#include <libxml/hash.h>
+#include <libxml/uri.h>
+#include <libxml/parserInternals.h>
+#include <libxml/catalog.h>
+#include <libxml/xmlerror.h>
+#include <libxml/threads.h>
+#include <libxml/globals.h>
+
+#define MAX_DELEGATE	50
+#define MAX_CATAL_DEPTH	50
+
+/**
+ * TODO:
+ *
+ * macro to flag unimplemented blocks
+ * XML_CATALOG_PREFER user env to select between system/public prefered
+ * option. C.f. Richard Tobin <richard@cogsci.ed.ac.uk>
+ *> Just FYI, I am using an environment variable XML_CATALOG_PREFER with
+ *> values "system" and "public".  I have made the default be "system" to
+ *> match yours.
+ */
+#define TODO 								\
+    xmlGenericError(xmlGenericErrorContext,				\
+	    "Unimplemented block at %s:%d\n",				\
+            __FILE__, __LINE__);
+
+#define XML_URN_PUBID "urn:publicid:"
+#define XML_CATAL_BREAK ((xmlChar *) -1)
+#ifndef XML_XML_DEFAULT_CATALOG
+#define XML_XML_DEFAULT_CATALOG "file:///etc/xml/catalog"
+#endif
+#ifndef XML_SGML_DEFAULT_CATALOG
+#define XML_SGML_DEFAULT_CATALOG "file:///etc/sgml/catalog"
+#endif
+
+static int xmlExpandCatalog(xmlCatalogPtr catal, const char *filename);
+
+/************************************************************************
+ *									*
+ *			Types, all private				*
+ *									*
+ ************************************************************************/
+
+typedef enum {
+    XML_CATA_REMOVED = -1,
+    XML_CATA_NONE = 0,
+    XML_CATA_CATALOG,
+    XML_CATA_BROKEN_CATALOG,
+    XML_CATA_NEXT_CATALOG,
+    XML_CATA_PUBLIC,
+    XML_CATA_SYSTEM,
+    XML_CATA_REWRITE_SYSTEM,
+    XML_CATA_DELEGATE_PUBLIC,
+    XML_CATA_DELEGATE_SYSTEM,
+    XML_CATA_URI,
+    XML_CATA_REWRITE_URI,
+    XML_CATA_DELEGATE_URI,
+    SGML_CATA_SYSTEM,
+    SGML_CATA_PUBLIC,
+    SGML_CATA_ENTITY,
+    SGML_CATA_PENTITY,
+    SGML_CATA_DOCTYPE,
+    SGML_CATA_LINKTYPE,
+    SGML_CATA_NOTATION,
+    SGML_CATA_DELEGATE,
+    SGML_CATA_BASE,
+    SGML_CATA_CATALOG,
+    SGML_CATA_DOCUMENT,
+    SGML_CATA_SGMLDECL
+} xmlCatalogEntryType;
+
+typedef struct _xmlCatalogEntry xmlCatalogEntry;
+typedef xmlCatalogEntry *xmlCatalogEntryPtr;
+struct _xmlCatalogEntry {
+    struct _xmlCatalogEntry *next;
+    struct _xmlCatalogEntry *parent;
+    struct _xmlCatalogEntry *children;
+    xmlCatalogEntryType type;
+    xmlChar *name;
+    xmlChar *value;
+    xmlChar *URL;  /* The expanded URL using the base */
+    xmlCatalogPrefer prefer;
+    int dealloc;
+    int depth;
+};
+
+typedef enum {
+    XML_XML_CATALOG_TYPE = 1,
+    XML_SGML_CATALOG_TYPE
+} xmlCatalogType;
+
+#define XML_MAX_SGML_CATA_DEPTH 10
+struct _xmlCatalog {
+    xmlCatalogType type;	/* either XML or SGML */
+
+    /*
+     * SGML Catalogs are stored as a simple hash table of catalog entries
+     * Catalog stack to check against overflows when building the
+     * SGML catalog
+     */
+    char *catalTab[XML_MAX_SGML_CATA_DEPTH];	/* stack of catals */
+    int          catalNr;	/* Number of current catal streams */
+    int          catalMax;	/* Max number of catal streams */
+    xmlHashTablePtr sgml;
+
+    /*
+     * XML Catalogs are stored as a tree of Catalog entries
+     */
+    xmlCatalogPrefer prefer;
+    xmlCatalogEntryPtr xml;
+};
+
+/************************************************************************
+ *									*
+ *			Global variables				*
+ *									*
+ ************************************************************************/
+
+/*
+ * Those are preferences
+ */
+static int xmlDebugCatalogs = 0;   /* used for debugging */
+static xmlCatalogAllow xmlCatalogDefaultAllow = XML_CATA_ALLOW_ALL;
+static xmlCatalogPrefer xmlCatalogDefaultPrefer = XML_CATA_PREFER_PUBLIC;
+
+/*
+ * Hash table containing all the trees of XML catalogs parsed by
+ * the application.
+ */
+static xmlHashTablePtr xmlCatalogXMLFiles = NULL;
+
+/*
+ * The default catalog in use by the application
+ */
+static xmlCatalogPtr xmlDefaultCatalog = NULL;
+
+/*
+ * A mutex for modifying the shared global catalog(s)
+ * xmlDefaultCatalog tree.
+ * It also protects xmlCatalogXMLFiles
+ * The core of this readers/writer scheme is in xmlFetchXMLCatalogFile()
+ */
+static xmlRMutexPtr xmlCatalogMutex = NULL;
+
+/*
+ * Whether the catalog support was initialized.
+ */
+static int xmlCatalogInitialized = 0;
+
+/************************************************************************
+ *									*
+ * 			Catalog error handlers				*
+ *									*
+ ************************************************************************/
+
+/**
+ * xmlCatalogErrMemory:
+ * @extra:  extra informations
+ *
+ * Handle an out of memory condition
+ */
+static void
+xmlCatalogErrMemory(const char *extra)
+{
+    __xmlRaiseError(NULL, NULL, NULL, NULL, NULL, XML_FROM_CATALOG,
+                    XML_ERR_NO_MEMORY, XML_ERR_ERROR, NULL, 0,
+		    extra, NULL, NULL, 0, 0,
+		    "Memory allocation failed : %s\n", extra);
+}
+
+/**
+ * xmlCatalogErr:
+ * @catal: the Catalog entry
+ * @node: the context node
+ * @msg:  the error message
+ * @extra:  extra informations
+ *
+ * Handle a catalog error
+ */
+static void
+xmlCatalogErr(xmlCatalogEntryPtr catal, xmlNodePtr node, int error,
+               const char *msg, const xmlChar *str1, const xmlChar *str2,
+	       const xmlChar *str3)
+{
+    __xmlRaiseError(NULL, NULL, NULL, catal, node, XML_FROM_CATALOG,
+                    error, XML_ERR_ERROR, NULL, 0,
+		    (const char *) str1, (const char *) str2,
+		    (const char *) str3, 0, 0,
+		    msg, str1, str2, str3);
+}
+
+
+/************************************************************************
+ *									*
+ *			Allocation and Freeing				*
+ *									*
+ ************************************************************************/
+
+/**
+ * xmlNewCatalogEntry:
+ * @type:  type of entry
+ * @name:  name of the entry
+ * @value:  value of the entry
+ * @prefer:  the PUBLIC vs. SYSTEM current preference value
+ *
+ * create a new Catalog entry, this type is shared both by XML and 
+ * SGML catalogs, but the acceptable types values differs.
+ *
+ * Returns the xmlCatalogEntryPtr or NULL in case of error
+ */
+static xmlCatalogEntryPtr
+xmlNewCatalogEntry(xmlCatalogEntryType type, const xmlChar *name,
+	   const xmlChar *value, const xmlChar *URL, xmlCatalogPrefer prefer) {
+    xmlCatalogEntryPtr ret;
+
+    ret = (xmlCatalogEntryPtr) xmlMalloc(sizeof(xmlCatalogEntry));
+    if (ret == NULL) {
+        xmlCatalogErrMemory("allocating catalog entry");
+	return(NULL);
+    }
+    ret->next = NULL;
+    ret->parent = NULL;
+    ret->children = NULL;
+    ret->type = type;
+    if (name != NULL)
+	ret->name = xmlStrdup(name);
+    else
+	ret->name = NULL;
+    if (value != NULL)
+	ret->value = xmlStrdup(value);
+    else
+	ret->value = NULL;
+    if (URL == NULL)
+	URL = value;
+    if (URL != NULL)
+	ret->URL = xmlStrdup(URL);
+    else
+	ret->URL = NULL;
+    ret->prefer = prefer;
+    ret->dealloc = 0;
+    ret->depth = 0;
+    return(ret);
+}
+
+static void
+xmlFreeCatalogEntryList(xmlCatalogEntryPtr ret);
+
+/**
+ * xmlFreeCatalogEntry:
+ * @ret:  a Catalog entry
+ *
+ * Free the memory allocated to a Catalog entry
+ */
+static void
+xmlFreeCatalogEntry(xmlCatalogEntryPtr ret) {
+    if (ret == NULL)
+	return;
+    /*
+     * Entries stored in the file hash must be deallocated
+     * only by the file hash cleaner !
+     */
+    if (ret->dealloc == 1)
+	return;
+
+    if (xmlDebugCatalogs) {
+	if (ret->name != NULL)
+	    xmlGenericError(xmlGenericErrorContext,
+		    "Free catalog entry %s\n", ret->name);
+	else if (ret->value != NULL)
+	    xmlGenericError(xmlGenericErrorContext,
+		    "Free catalog entry %s\n", ret->value);
+	else
+	    xmlGenericError(xmlGenericErrorContext,
+		    "Free catalog entry\n");
+    }
+
+    if (ret->name != NULL)
+	xmlFree(ret->name);
+    if (ret->value != NULL)
+	xmlFree(ret->value);
+    if (ret->URL != NULL)
+	xmlFree(ret->URL);
+    xmlFree(ret);
+}
+
+/**
+ * xmlFreeCatalogEntryList:
+ * @ret:  a Catalog entry list
+ *
+ * Free the memory allocated to a full chained list of Catalog entries
+ */
+static void
+xmlFreeCatalogEntryList(xmlCatalogEntryPtr ret) {
+    xmlCatalogEntryPtr next;
+
+    while (ret != NULL) {
+	next = ret->next;
+	xmlFreeCatalogEntry(ret);
+	ret = next;
+    }
+}
+
+/**
+ * xmlFreeCatalogHashEntryList:
+ * @ret:  a Catalog entry list
+ *
+ * Free the memory allocated to list of Catalog entries from the
+ * catalog file hash.
+ */
+static void
+xmlFreeCatalogHashEntryList(xmlCatalogEntryPtr catal) {
+    xmlCatalogEntryPtr children, next;
+
+    if (catal == NULL)
+	return;
+
+    children = catal->children;
+    while (children != NULL) {
+	next = children->next;
+	children->dealloc = 0;
+	children->children = NULL;
+	xmlFreeCatalogEntry(children);
+	children = next;
+    }
+    catal->dealloc = 0;
+    xmlFreeCatalogEntry(catal);
+}
+
+/**
+ * xmlCreateNewCatalog:
+ * @type:  type of catalog
+ * @prefer:  the PUBLIC vs. SYSTEM current preference value
+ *
+ * create a new Catalog, this type is shared both by XML and 
+ * SGML catalogs, but the acceptable types values differs.
+ *
+ * Returns the xmlCatalogPtr or NULL in case of error
+ */
+static xmlCatalogPtr
+xmlCreateNewCatalog(xmlCatalogType type, xmlCatalogPrefer prefer) {
+    xmlCatalogPtr ret;
+
+    ret = (xmlCatalogPtr) xmlMalloc(sizeof(xmlCatalog));
+    if (ret == NULL) {
+        xmlCatalogErrMemory("allocating catalog");
+	return(NULL);
+    }
+    memset(ret, 0, sizeof(xmlCatalog));
+    ret->type = type;
+    ret->catalNr = 0;
+    ret->catalMax = XML_MAX_SGML_CATA_DEPTH;
+    ret->prefer = prefer;
+    if (ret->type == XML_SGML_CATALOG_TYPE)
+	ret->sgml = xmlHashCreate(10);
+    return(ret);
+}
+
+/**
+ * xmlFreeCatalog:
+ * @catal:  a Catalog
+ *
+ * Free the memory allocated to a Catalog
+ */
+void
+xmlFreeCatalog(xmlCatalogPtr catal) {
+    if (catal == NULL)
+	return;
+    if (catal->xml != NULL)
+	xmlFreeCatalogEntryList(catal->xml);
+    if (catal->sgml != NULL)
+	xmlHashFree(catal->sgml,
+		(xmlHashDeallocator) xmlFreeCatalogEntry);
+    xmlFree(catal);
+}
+
+/************************************************************************
+ *									*
+ *			Serializing Catalogs				*
+ *									*
+ ************************************************************************/
+
+#ifdef LIBXML_OUTPUT_ENABLED
+/**
+ * xmlCatalogDumpEntry:
+ * @entry:  the catalog entry
+ * @out:  the file.
+ *
+ * Serialize an SGML Catalog entry
+ */
+static void
+xmlCatalogDumpEntry(xmlCatalogEntryPtr entry, FILE *out) {
+    if ((entry == NULL) || (out == NULL))
+	return;
+    switch (entry->type) {
+	case SGML_CATA_ENTITY:
+	    fprintf(out, "ENTITY "); break;
+	case SGML_CATA_PENTITY:
+	    fprintf(out, "ENTITY %%"); break;
+	case SGML_CATA_DOCTYPE:
+	    fprintf(out, "DOCTYPE "); break;
+	case SGML_CATA_LINKTYPE:
+	    fprintf(out, "LINKTYPE "); break;
+	case SGML_CATA_NOTATION:
+	    fprintf(out, "NOTATION "); break;
+	case SGML_CATA_PUBLIC:
+	    fprintf(out, "PUBLIC "); break;
+	case SGML_CATA_SYSTEM:
+	    fprintf(out, "SYSTEM "); break;
+	case SGML_CATA_DELEGATE:
+	    fprintf(out, "DELEGATE "); break;
+	case SGML_CATA_BASE:
+	    fprintf(out, "BASE "); break;
+	case SGML_CATA_CATALOG:
+	    fprintf(out, "CATALOG "); break;
+	case SGML_CATA_DOCUMENT:
+	    fprintf(out, "DOCUMENT "); break;
+	case SGML_CATA_SGMLDECL:
+	    fprintf(out, "SGMLDECL "); break;
+	default:
+	    return;
+    }
+    switch (entry->type) {
+	case SGML_CATA_ENTITY:
+	case SGML_CATA_PENTITY:
+	case SGML_CATA_DOCTYPE:
+	case SGML_CATA_LINKTYPE:
+	case SGML_CATA_NOTATION:
+	    fprintf(out, "%s", (const char *) entry->name); break;
+	case SGML_CATA_PUBLIC:
+	case SGML_CATA_SYSTEM:
+	case SGML_CATA_SGMLDECL:
+	case SGML_CATA_DOCUMENT:
+	case SGML_CATA_CATALOG:
+	case SGML_CATA_BASE:
+	case SGML_CATA_DELEGATE:
+	    fprintf(out, "\"%s\"", entry->name); break;
+	default:
+	    break;
+    }
+    switch (entry->type) {
+	case SGML_CATA_ENTITY:
+	case SGML_CATA_PENTITY:
+	case SGML_CATA_DOCTYPE:
+	case SGML_CATA_LINKTYPE:
+	case SGML_CATA_NOTATION:
+	case SGML_CATA_PUBLIC:
+	case SGML_CATA_SYSTEM:
+	case SGML_CATA_DELEGATE:
+	    fprintf(out, " \"%s\"", entry->value); break;
+	default:
+	    break;
+    }
+    fprintf(out, "\n");
+}
+
+static int
+xmlDumpXMLCatalog(FILE *out, xmlCatalogEntryPtr catal) {
+    int ret;
+    xmlDocPtr doc;
+    xmlNsPtr ns;
+    xmlDtdPtr dtd;
+    xmlNodePtr node, catalog;
+    xmlOutputBufferPtr buf;
+    xmlCatalogEntryPtr cur;
+
+    /*
+     * Rebuild a catalog
+     */
+    doc = xmlNewDoc(NULL);
+    if (doc == NULL)
+	return(-1);
+    dtd = xmlNewDtd(doc, BAD_CAST "catalog",
+	       BAD_CAST "-//OASIS//DTD Entity Resolution XML Catalog V1.0//EN",
+BAD_CAST "http://www.oasis-open.org/committees/entity/release/1.0/catalog.dtd");
+
+    xmlAddChild((xmlNodePtr) doc, (xmlNodePtr) dtd);
+
+    ns = xmlNewNs(NULL, XML_CATALOGS_NAMESPACE, NULL);
+    if (ns == NULL) {
+	xmlFreeDoc(doc);
+	return(-1);
+    }
+    catalog = xmlNewDocNode(doc, ns, BAD_CAST "catalog", NULL);
+    if (catalog == NULL) {
+	xmlFreeNs(ns);
+	xmlFreeDoc(doc);
+	return(-1);
+    }
+    catalog->nsDef = ns;
+    xmlAddChild((xmlNodePtr) doc, catalog);
+
+    /*
+     * add all the catalog entries
+     */
+    cur = catal;
+    while (cur != NULL) {
+	switch (cur->type) {
+	    case XML_CATA_REMOVED:
+		break;
+	    case XML_CATA_BROKEN_CATALOG:
+	    case XML_CATA_CATALOG:
+		if (cur == catal) {
+		    cur = cur->children;
+		    continue;
+		}
+		break;
+	    case XML_CATA_NEXT_CATALOG:
+		node = xmlNewDocNode(doc, ns, BAD_CAST "nextCatalog", NULL);
+		xmlSetProp(node, BAD_CAST "catalog", cur->value);
+		xmlAddChild(catalog, node);
+                break;
+	    case XML_CATA_NONE:
+		break;
+	    case XML_CATA_PUBLIC:
+		node = xmlNewDocNode(doc, ns, BAD_CAST "public", NULL);
+		xmlSetProp(node, BAD_CAST "publicId", cur->name);
+		xmlSetProp(node, BAD_CAST "uri", cur->value);
+		xmlAddChild(catalog, node);
+		break;
+	    case XML_CATA_SYSTEM:
+		node = xmlNewDocNode(doc, ns, BAD_CAST "system", NULL);
+		xmlSetProp(node, BAD_CAST "systemId", cur->name);
+		xmlSetProp(node, BAD_CAST "uri", cur->value);
+		xmlAddChild(catalog, node);
+		break;
+	    case XML_CATA_REWRITE_SYSTEM:
+		node = xmlNewDocNode(doc, ns, BAD_CAST "rewriteSystem", NULL);
+		xmlSetProp(node, BAD_CAST "systemIdStartString", cur->name);
+		xmlSetProp(node, BAD_CAST "rewritePrefix", cur->value);
+		xmlAddChild(catalog, node);
+		break;
+	    case XML_CATA_DELEGATE_PUBLIC:
+		node = xmlNewDocNode(doc, ns, BAD_CAST "delegatePublic", NULL);
+		xmlSetProp(node, BAD_CAST "publicIdStartString", cur->name);
+		xmlSetProp(node, BAD_CAST "catalog", cur->value);
+		xmlAddChild(catalog, node);
+		break;
+	    case XML_CATA_DELEGATE_SYSTEM:
+		node = xmlNewDocNode(doc, ns, BAD_CAST "delegateSystem", NULL);
+		xmlSetProp(node, BAD_CAST "systemIdStartString", cur->name);
+		xmlSetProp(node, BAD_CAST "catalog", cur->value);
+		xmlAddChild(catalog, node);
+		break;
+	    case XML_CATA_URI:
+		node = xmlNewDocNode(doc, ns, BAD_CAST "uri", NULL);
+		xmlSetProp(node, BAD_CAST "name", cur->name);
+		xmlSetProp(node, BAD_CAST "uri", cur->value);
+		xmlAddChild(catalog, node);
+		break;
+	    case XML_CATA_REWRITE_URI:
+		node = xmlNewDocNode(doc, ns, BAD_CAST "rewriteURI", NULL);
+		xmlSetProp(node, BAD_CAST "uriStartString", cur->name);
+		xmlSetProp(node, BAD_CAST "rewritePrefix", cur->value);
+		xmlAddChild(catalog, node);
+		break;
+	    case XML_CATA_DELEGATE_URI:
+		node = xmlNewDocNode(doc, ns, BAD_CAST "delegateURI", NULL);
+		xmlSetProp(node, BAD_CAST "uriStartString", cur->name);
+		xmlSetProp(node, BAD_CAST "catalog", cur->value);
+		xmlAddChild(catalog, node);
+		break;
+	    case SGML_CATA_SYSTEM:
+	    case SGML_CATA_PUBLIC:
+	    case SGML_CATA_ENTITY:
+	    case SGML_CATA_PENTITY:
+	    case SGML_CATA_DOCTYPE:
+	    case SGML_CATA_LINKTYPE:
+	    case SGML_CATA_NOTATION:
+	    case SGML_CATA_DELEGATE:
+	    case SGML_CATA_BASE:
+	    case SGML_CATA_CATALOG:
+	    case SGML_CATA_DOCUMENT:
+	    case SGML_CATA_SGMLDECL:
+		break;
+	}
+	cur = cur->next;
+    }
+
+    /*
+     * reserialize it
+     */
+    buf = xmlOutputBufferCreateFile(out, NULL);
+    if (buf == NULL) {
+	xmlFreeDoc(doc);
+	return(-1);
+    }
+    ret = xmlSaveFormatFileTo(buf, doc, NULL, 1);
+
+    /*
+     * Free it
+     */
+    xmlFreeDoc(doc);
+
+    return(ret);
+}
+#endif /* LIBXML_OUTPUT_ENABLED */
+
+/************************************************************************
+ *									*
+ *			Converting SGML Catalogs to XML			*
+ *									*
+ ************************************************************************/
+
+/**
+ * xmlCatalogConvertEntry:
+ * @entry:  the entry
+ * @catal:  pointer to the catalog being converted
+ *
+ * Convert one entry from the catalog
+ */
+static void
+xmlCatalogConvertEntry(xmlCatalogEntryPtr entry, xmlCatalogPtr catal) {
+    if ((entry == NULL) || (catal == NULL) || (catal->sgml == NULL) ||
+	(catal->xml == NULL))
+	return;
+    switch (entry->type) {
+	case SGML_CATA_ENTITY:
+	    entry->type = XML_CATA_PUBLIC;
+	    break;
+	case SGML_CATA_PENTITY:
+	    entry->type = XML_CATA_PUBLIC;
+	    break;
+	case SGML_CATA_DOCTYPE:
+	    entry->type = XML_CATA_PUBLIC;
+	    break;
+	case SGML_CATA_LINKTYPE:
+	    entry->type = XML_CATA_PUBLIC;
+	    break;
+	case SGML_CATA_NOTATION:
+	    entry->type = XML_CATA_PUBLIC;
+	    break;
+	case SGML_CATA_PUBLIC:
+	    entry->type = XML_CATA_PUBLIC;
+	    break;
+	case SGML_CATA_SYSTEM:
+	    entry->type = XML_CATA_SYSTEM;
+	    break;
+	case SGML_CATA_DELEGATE:
+	    entry->type = XML_CATA_DELEGATE_PUBLIC;
+	    break;
+	case SGML_CATA_CATALOG:
+	    entry->type = XML_CATA_CATALOG;
+	    break;
+	default:
+	    xmlHashRemoveEntry(catal->sgml, entry->name,
+		               (xmlHashDeallocator) xmlFreeCatalogEntry);
+	    return;
+    }
+    /*
+     * Conversion successful, remove from the SGML catalog
+     * and add it to the default XML one
+     */
+    xmlHashRemoveEntry(catal->sgml, entry->name, NULL);
+    entry->parent = catal->xml;
+    entry->next = NULL;
+    if (catal->xml->children == NULL)
+	catal->xml->children = entry;
+    else {
+	xmlCatalogEntryPtr prev;
+
+	prev = catal->xml->children;
+	while (prev->next != NULL)
+	    prev = prev->next;
+	prev->next = entry;
+    }
+}
+
+/**
+ * xmlConvertSGMLCatalog:
+ * @catal: the catalog
+ *
+ * Convert all the SGML catalog entries as XML ones
+ *
+ * Returns the number of entries converted if successful, -1 otherwise
+ */
+int
+xmlConvertSGMLCatalog(xmlCatalogPtr catal) {
+
+    if ((catal == NULL) || (catal->type != XML_SGML_CATALOG_TYPE))
+	return(-1);
+
+    if (xmlDebugCatalogs) {
+	xmlGenericError(xmlGenericErrorContext,
+		"Converting SGML catalog to XML\n");
+    }
+    xmlHashScan(catal->sgml,
+		(xmlHashScanner) xmlCatalogConvertEntry,
+		&catal);
+    return(0);
+}
+
+/************************************************************************
+ *									*
+ *			Helper function					*
+ *									*
+ ************************************************************************/
+
+/**
+ * xmlCatalogUnWrapURN:
+ * @urn:  an "urn:publicid:" to unwrap
+ *
+ * Expand the URN into the equivalent Public Identifier
+ *
+ * Returns the new identifier or NULL, the string must be deallocated
+ *         by the caller.
+ */
+static xmlChar *
+xmlCatalogUnWrapURN(const xmlChar *urn) {
+    xmlChar result[2000];
+    unsigned int i = 0;
+
+    if (xmlStrncmp(urn, BAD_CAST XML_URN_PUBID, sizeof(XML_URN_PUBID) - 1))
+	return(NULL);
+    urn += sizeof(XML_URN_PUBID) - 1;
+    
+    while (*urn != 0) {
+	if (i > sizeof(result) - 4)
+	    break;
+	if (*urn == '+') {
+	    result[i++] = ' ';
+	    urn++;
+	} else if (*urn == ':') {
+	    result[i++] = '/';
+	    result[i++] = '/';
+	    urn++;
+	} else if (*urn == ';') {
+	    result[i++] = ':';
+	    result[i++] = ':';
+	    urn++;
+	} else if (*urn == '%') {
+	    if ((urn[1] == '2') && (urn[2] == 'B'))
+		result[i++] = '+';
+	    else if ((urn[1] == '3') && (urn[2] == 'A'))
+		result[i++] = ':';
+	    else if ((urn[1] == '2') && (urn[2] == 'F'))
+		result[i++] = '/';
+	    else if ((urn[1] == '3') && (urn[2] == 'B'))
+		result[i++] = ';';
+	    else if ((urn[1] == '2') && (urn[2] == '7'))
+		result[i++] = '\'';
+	    else if ((urn[1] == '3') && (urn[2] == 'F'))
+		result[i++] = '?';
+	    else if ((urn[1] == '2') && (urn[2] == '3'))
+		result[i++] = '#';
+	    else if ((urn[1] == '2') && (urn[2] == '5'))
+		result[i++] = '%';
+	    else {
+		result[i++] = *urn;
+		urn++;
+		continue;
+	    }
+	    urn += 3;
+	} else {
+	    result[i++] = *urn;
+	    urn++;
+	}
+    }
+    result[i] = 0;
+
+    return(xmlStrdup(result));
+}
+
+/**
+ * xmlParseCatalogFile:
+ * @filename:  the filename
+ *
+ * parse an XML file and build a tree. It's like xmlParseFile()
+ * except it bypass all catalog lookups.
+ *
+ * Returns the resulting document tree or NULL in case of error
+ */
+
+xmlDocPtr
+xmlParseCatalogFile(const char *filename) {
+    xmlDocPtr ret;
+    xmlParserCtxtPtr ctxt;
+    char *directory = NULL;
+    xmlParserInputPtr inputStream;
+    xmlParserInputBufferPtr buf;
+
+    ctxt = xmlNewParserCtxt();
+    if (ctxt == NULL) {
+	if (xmlDefaultSAXHandler.error != NULL) {
+	    xmlDefaultSAXHandler.error(NULL, "out of memory\n");
+	}
+	return(NULL);
+    }
+
+    buf = xmlParserInputBufferCreateFilename(filename, XML_CHAR_ENCODING_NONE);
+    if (buf == NULL) {
+	xmlFreeParserCtxt(ctxt);
+	return(NULL);
+    }
+
+    inputStream = xmlNewInputStream(ctxt);
+    if (inputStream == NULL) {
+	xmlFreeParserCtxt(ctxt);
+	return(NULL);
+    }
+
+    inputStream->filename = (char *) xmlCanonicPath((const xmlChar *)filename);
+    inputStream->buf = buf;
+    inputStream->base = inputStream->buf->buffer->content;
+    inputStream->cur = inputStream->buf->buffer->content;
+    inputStream->end = 
+	&inputStream->buf->buffer->content[inputStream->buf->buffer->use];
+
+    inputPush(ctxt, inputStream);
+    if ((ctxt->directory == NULL) && (directory == NULL))
+        directory = xmlParserGetDirectory(filename);
+    if ((ctxt->directory == NULL) && (directory != NULL))
+        ctxt->directory = directory;
+    ctxt->valid = 0;
+    ctxt->validate = 0;
+    ctxt->loadsubset = 0;
+    ctxt->pedantic = 0;
+
+    xmlParseDocument(ctxt);
+
+    if (ctxt->wellFormed)
+	ret = ctxt->myDoc;
+    else {
+        ret = NULL;
+        xmlFreeDoc(ctxt->myDoc);
+        ctxt->myDoc = NULL;
+    }
+    xmlFreeParserCtxt(ctxt);
+    
+    return(ret);
+}
+
+/**
+ * xmlLoadFileContent:
+ * @filename:  a file path
+ *
+ * Load a file content into memory.
+ *
+ * Returns a pointer to the 0 terminated string or NULL in case of error
+ */
+static xmlChar *
+xmlLoadFileContent(const char *filename)
+{
+#ifdef HAVE_STAT
+    int fd;
+#else
+    FILE *fd;
+#endif
+    int len;
+    long size;
+
+#ifdef HAVE_STAT
+    struct stat info;
+#endif
+    xmlChar *content;
+
+    if (filename == NULL)
+        return (NULL);
+
+#ifdef HAVE_STAT
+    if (stat(filename, &info) < 0)
+        return (NULL);
+#endif
+
+#ifdef HAVE_STAT
+    if ((fd = open(filename, O_RDONLY)) < 0)
+#else
+    if ((fd = fopen(filename, "rb")) == NULL)
+#endif
+    {
+        return (NULL);
+    }
+#ifdef HAVE_STAT
+    size = info.st_size;
+#else
+    if (fseek(fd, 0, SEEK_END) || (size = ftell(fd)) == EOF || fseek(fd, 0, SEEK_SET)) {        /* File operations denied? ok, just close and return failure */
+        fclose(fd);
+        return (NULL);
+    }
+#endif
+    content = xmlMallocAtomic(size + 10);
+    if (content == NULL) {
+        xmlCatalogErrMemory("allocating catalog data");
+        return (NULL);
+    }
+#ifdef HAVE_STAT
+    len = read(fd, content, size);
+#else
+    len = fread(content, 1, size, fd);
+#endif
+    if (len < 0) {
+        xmlFree(content);
+        return (NULL);
+    }
+#ifdef HAVE_STAT
+    close(fd);
+#else
+    fclose(fd);
+#endif
+    content[len] = 0;
+
+    return(content);
+}
+
+/************************************************************************
+ *									*
+ *			The XML Catalog parser				*
+ *									*
+ ************************************************************************/
+
+static xmlCatalogEntryPtr
+xmlParseXMLCatalogFile(xmlCatalogPrefer prefer, const xmlChar *filename);
+static void
+xmlParseXMLCatalogNodeList(xmlNodePtr cur, xmlCatalogPrefer prefer,
+	                   xmlCatalogEntryPtr parent);
+static xmlChar *
+xmlCatalogListXMLResolve(xmlCatalogEntryPtr catal, const xmlChar *pubID,
+	              const xmlChar *sysID);
+static xmlChar *
+xmlCatalogListXMLResolveURI(xmlCatalogEntryPtr catal, const xmlChar *URI);
+
+
+/**
+ * xmlGetXMLCatalogEntryType:
+ * @name:  the name
+ *
+ * lookup the internal type associated to an XML catalog entry name
+ *
+ * Returns the type associated with that name
+ */
+static xmlCatalogEntryType
+xmlGetXMLCatalogEntryType(const xmlChar *name) {
+    xmlCatalogEntryType type = XML_CATA_NONE;
+    if (xmlStrEqual(name, (const xmlChar *) "system"))
+	type = XML_CATA_SYSTEM;
+    else if (xmlStrEqual(name, (const xmlChar *) "public"))
+	type = XML_CATA_PUBLIC;
+    else if (xmlStrEqual(name, (const xmlChar *) "rewriteSystem"))
+	type = XML_CATA_REWRITE_SYSTEM;
+    else if (xmlStrEqual(name, (const xmlChar *) "delegatePublic"))
+	type = XML_CATA_DELEGATE_PUBLIC;
+    else if (xmlStrEqual(name, (const xmlChar *) "delegateSystem"))
+	type = XML_CATA_DELEGATE_SYSTEM;
+    else if (xmlStrEqual(name, (const xmlChar *) "uri"))
+	type = XML_CATA_URI;
+    else if (xmlStrEqual(name, (const xmlChar *) "rewriteURI"))
+	type = XML_CATA_REWRITE_URI;
+    else if (xmlStrEqual(name, (const xmlChar *) "delegateURI"))
+	type = XML_CATA_DELEGATE_URI;
+    else if (xmlStrEqual(name, (const xmlChar *) "nextCatalog"))
+	type = XML_CATA_NEXT_CATALOG;
+    else if (xmlStrEqual(name, (const xmlChar *) "catalog"))
+	type = XML_CATA_CATALOG;
+    return(type);
+}
+
+/**
+ * xmlParseXMLCatalogOneNode:
+ * @cur:  the XML node
+ * @type:  the type of Catalog entry
+ * @name:  the name of the node
+ * @attrName:  the attribute holding the value
+ * @uriAttrName:  the attribute holding the URI-Reference
+ * @prefer:  the PUBLIC vs. SYSTEM current preference value
+ *
+ * Finishes the examination of an XML tree node of a catalog and build
+ * a Catalog entry from it.
+ *
+ * Returns the new Catalog entry node or NULL in case of error.
+ */
+static xmlCatalogEntryPtr
+xmlParseXMLCatalogOneNode(xmlNodePtr cur, xmlCatalogEntryType type,
+			  const xmlChar *name, const xmlChar *attrName,
+			  const xmlChar *uriAttrName, xmlCatalogPrefer prefer) {
+    int ok = 1;
+    xmlChar *uriValue;
+    xmlChar *nameValue = NULL;
+    xmlChar *base = NULL;
+    xmlChar *URL = NULL;
+    xmlCatalogEntryPtr ret = NULL;
+
+    if (attrName != NULL) {
+	nameValue = xmlGetProp(cur, attrName);
+	if (nameValue == NULL) {
+	    xmlCatalogErr(ret, cur, XML_CATALOG_MISSING_ATTR,
+			  "%s entry lacks '%s'\n", name, attrName, NULL);
+	    ok = 0;
+	}
+    }
+    uriValue = xmlGetProp(cur, uriAttrName);
+    if (uriValue == NULL) {
+	xmlCatalogErr(ret, cur, XML_CATALOG_MISSING_ATTR,
+		"%s entry lacks '%s'\n", name, uriAttrName, NULL);
+	ok = 0;
+    }
+    if (!ok) {
+	if (nameValue != NULL)
+	    xmlFree(nameValue);
+	if (uriValue != NULL)
+	    xmlFree(uriValue);
+	return(NULL);
+    }
+
+    base = xmlNodeGetBase(cur->doc, cur);
+    URL = xmlBuildURI(uriValue, base);
+    if (URL != NULL) {
+	if (xmlDebugCatalogs > 1) {
+	    if (nameValue != NULL)
+		xmlGenericError(xmlGenericErrorContext,
+			"Found %s: '%s' '%s'\n", name, nameValue, URL);
+	    else
+		xmlGenericError(xmlGenericErrorContext,
+			"Found %s: '%s'\n", name, URL);
+	}
+	ret = xmlNewCatalogEntry(type, nameValue, uriValue, URL, prefer);
+    } else {
+	xmlCatalogErr(ret, cur, XML_CATALOG_ENTRY_BROKEN,
+		"%s entry '%s' broken ?: %s\n", name, uriAttrName, uriValue);
+    }
+    if (nameValue != NULL)
+	xmlFree(nameValue);
+    if (uriValue != NULL)
+	xmlFree(uriValue);
+    if (base != NULL)
+	xmlFree(base);
+    if (URL != NULL)
+	xmlFree(URL);
+    return(ret);
+}
+
+/**
+ * xmlParseXMLCatalogNode:
+ * @cur:  the XML node
+ * @prefer:  the PUBLIC vs. SYSTEM current preference value
+ * @parent:  the parent Catalog entry
+ *
+ * Examines an XML tree node of a catalog and build
+ * a Catalog entry from it adding it to its parent. The examination can
+ * be recursive.
+ */
+static void
+xmlParseXMLCatalogNode(xmlNodePtr cur, xmlCatalogPrefer prefer,
+	               xmlCatalogEntryPtr parent)
+{
+    xmlChar *uri = NULL;
+    xmlChar *URL = NULL;
+    xmlChar *base = NULL;
+    xmlCatalogEntryPtr entry = NULL;
+
+    if (cur == NULL)
+        return;
+    if (xmlStrEqual(cur->name, BAD_CAST "group")) {
+        xmlChar *prop;
+
+        prop = xmlGetProp(cur, BAD_CAST "prefer");
+        if (prop != NULL) {
+            if (xmlStrEqual(prop, BAD_CAST "system")) {
+                prefer = XML_CATA_PREFER_SYSTEM;
+            } else if (xmlStrEqual(prop, BAD_CAST "public")) {
+                prefer = XML_CATA_PREFER_PUBLIC;
+            } else {
+		xmlCatalogErr(parent, cur, XML_CATALOG_PREFER_VALUE,
+                              "Invalid value for prefer: '%s'\n",
+			      prop, NULL, NULL);
+            }
+            xmlFree(prop);
+        }
+	/*
+	 * Recurse to propagate prefer to the subtree
+	 * (xml:base handling is automated)
+	 */
+        xmlParseXMLCatalogNodeList(cur->children, prefer, parent);
+    } else if (xmlStrEqual(cur->name, BAD_CAST "public")) {
+	entry = xmlParseXMLCatalogOneNode(cur, XML_CATA_PUBLIC,
+		BAD_CAST "public", BAD_CAST "publicId", BAD_CAST "uri", prefer);
+    } else if (xmlStrEqual(cur->name, BAD_CAST "system")) {
+	entry = xmlParseXMLCatalogOneNode(cur, XML_CATA_SYSTEM,
+		BAD_CAST "system", BAD_CAST "systemId", BAD_CAST "uri", prefer);
+    } else if (xmlStrEqual(cur->name, BAD_CAST "rewriteSystem")) {
+	entry = xmlParseXMLCatalogOneNode(cur, XML_CATA_REWRITE_SYSTEM,
+		BAD_CAST "rewriteSystem", BAD_CAST "systemIdStartString",
+		BAD_CAST "rewritePrefix", prefer);
+    } else if (xmlStrEqual(cur->name, BAD_CAST "delegatePublic")) {
+	entry = xmlParseXMLCatalogOneNode(cur, XML_CATA_DELEGATE_PUBLIC,
+		BAD_CAST "delegatePublic", BAD_CAST "publicIdStartString",
+		BAD_CAST "catalog", prefer);
+    } else if (xmlStrEqual(cur->name, BAD_CAST "delegateSystem")) {
+	entry = xmlParseXMLCatalogOneNode(cur, XML_CATA_DELEGATE_SYSTEM,
+		BAD_CAST "delegateSystem", BAD_CAST "systemIdStartString",
+		BAD_CAST "catalog", prefer);
+    } else if (xmlStrEqual(cur->name, BAD_CAST "uri")) {
+	entry = xmlParseXMLCatalogOneNode(cur, XML_CATA_URI,
+		BAD_CAST "uri", BAD_CAST "name",
+		BAD_CAST "uri", prefer);
+    } else if (xmlStrEqual(cur->name, BAD_CAST "rewriteURI")) {
+	entry = xmlParseXMLCatalogOneNode(cur, XML_CATA_REWRITE_URI,
+		BAD_CAST "rewriteURI", BAD_CAST "uriStartString",
+		BAD_CAST "rewritePrefix", prefer);
+    } else if (xmlStrEqual(cur->name, BAD_CAST "delegateURI")) {
+	entry = xmlParseXMLCatalogOneNode(cur, XML_CATA_DELEGATE_URI,
+		BAD_CAST "delegateURI", BAD_CAST "uriStartString",
+		BAD_CAST "catalog", prefer);
+    } else if (xmlStrEqual(cur->name, BAD_CAST "nextCatalog")) {
+	entry = xmlParseXMLCatalogOneNode(cur, XML_CATA_NEXT_CATALOG,
+		BAD_CAST "nextCatalog", NULL,
+		BAD_CAST "catalog", prefer);
+    }
+    if ((entry != NULL) && (parent != NULL)) {
+	entry->parent = parent;
+	if (parent->children == NULL)
+	    parent->children = entry;
+	else {
+	    xmlCatalogEntryPtr prev;
+
+	    prev = parent->children;
+	    while (prev->next != NULL)
+		prev = prev->next;
+	    prev->next = entry;
+	}
+    }
+    if (base != NULL)
+	xmlFree(base);
+    if (uri != NULL)
+	xmlFree(uri);
+    if (URL != NULL)
+	xmlFree(URL);
+}
+
+/**
+ * xmlParseXMLCatalogNodeList:
+ * @cur:  the XML node list of siblings
+ * @prefer:  the PUBLIC vs. SYSTEM current preference value
+ * @parent:  the parent Catalog entry
+ *
+ * Examines a list of XML sibling nodes of a catalog and build
+ * a list of Catalog entry from it adding it to the parent.
+ * The examination will recurse to examine node subtrees.
+ */
+static void
+xmlParseXMLCatalogNodeList(xmlNodePtr cur, xmlCatalogPrefer prefer,
+	                   xmlCatalogEntryPtr parent) {
+    while (cur != NULL) {
+	if ((cur->ns != NULL) && (cur->ns->href != NULL) &&
+	    (xmlStrEqual(cur->ns->href, XML_CATALOGS_NAMESPACE))) {
+	    xmlParseXMLCatalogNode(cur, prefer, parent);
+	}
+	cur = cur->next;
+    }
+    /* TODO: sort the list according to REWRITE lengths and prefer value */
+}
+
+/**
+ * xmlParseXMLCatalogFile:
+ * @prefer:  the PUBLIC vs. SYSTEM current preference value
+ * @filename:  the filename for the catalog
+ *
+ * Parses the catalog file to extract the XML tree and then analyze the
+ * tree to build a list of Catalog entries corresponding to this catalog
+ * 
+ * Returns the resulting Catalog entries list
+ */
+static xmlCatalogEntryPtr
+xmlParseXMLCatalogFile(xmlCatalogPrefer prefer, const xmlChar *filename) {
+    xmlDocPtr doc;
+    xmlNodePtr cur;
+    xmlChar *prop;
+    xmlCatalogEntryPtr parent = NULL;
+
+    if (filename == NULL)
+        return(NULL);
+
+    doc = xmlParseCatalogFile((const char *) filename);
+    if (doc == NULL) {
+	if (xmlDebugCatalogs)
+	    xmlGenericError(xmlGenericErrorContext,
+		    "Failed to parse catalog %s\n", filename);
+	return(NULL);
+    }
+
+    if (xmlDebugCatalogs)
+	xmlGenericError(xmlGenericErrorContext,
+		"%d Parsing catalog %s\n", xmlGetThreadId(), filename);
+
+    cur = xmlDocGetRootElement(doc);
+    if ((cur != NULL) && (xmlStrEqual(cur->name, BAD_CAST "catalog")) &&
+	(cur->ns != NULL) && (cur->ns->href != NULL) &&
+	(xmlStrEqual(cur->ns->href, XML_CATALOGS_NAMESPACE))) {
+
+	parent = xmlNewCatalogEntry(XML_CATA_CATALOG, NULL,
+				    (const xmlChar *)filename, NULL, prefer);
+        if (parent == NULL) {
+	    xmlFreeDoc(doc);
+	    return(NULL);
+	}
+
+	prop = xmlGetProp(cur, BAD_CAST "prefer");
+	if (prop != NULL) {
+	    if (xmlStrEqual(prop, BAD_CAST "system")) {
+		prefer = XML_CATA_PREFER_SYSTEM;
+	    } else if (xmlStrEqual(prop, BAD_CAST "public")) {
+		prefer = XML_CATA_PREFER_PUBLIC;
+	    } else {
+		xmlCatalogErr(NULL, cur, XML_CATALOG_PREFER_VALUE,
+			      "Invalid value for prefer: '%s'\n",
+			      prop, NULL, NULL);
+	    }
+	    xmlFree(prop);
+	}
+	cur = cur->children;
+	xmlParseXMLCatalogNodeList(cur, prefer, parent);
+    } else {
+	xmlCatalogErr(NULL, (xmlNodePtr) doc, XML_CATALOG_NOT_CATALOG,
+		      "File %s is not an XML Catalog\n",
+		      filename, NULL, NULL);
+	xmlFreeDoc(doc);
+	return(NULL);
+    }
+    xmlFreeDoc(doc);
+    return(parent);
+}
+
+/**
+ * xmlFetchXMLCatalogFile:
+ * @catal:  an existing but incomplete catalog entry
+ *
+ * Fetch and parse the subcatalog referenced by an entry
+ * 
+ * Returns 0 in case of success, -1 otherwise
+ */
+static int
+xmlFetchXMLCatalogFile(xmlCatalogEntryPtr catal) {
+    xmlCatalogEntryPtr doc;
+
+    if (catal == NULL) 
+	return(-1);
+    if (catal->URL == NULL)
+	return(-1);
+    if (catal->children != NULL)
+	return(-1);
+
+    /*
+     * lock the whole catalog for modification
+     */
+    xmlRMutexLock(xmlCatalogMutex);
+    if (catal->children != NULL) {
+	/* Okay someone else did it in the meantime */
+	xmlRMutexUnlock(xmlCatalogMutex);
+	return(0);
+    }
+
+    if (xmlCatalogXMLFiles != NULL) {
+	doc = (xmlCatalogEntryPtr)
+	    xmlHashLookup(xmlCatalogXMLFiles, catal->URL);
+	if (doc != NULL) {
+	    if (xmlDebugCatalogs)
+		xmlGenericError(xmlGenericErrorContext,
+		    "Found %s in file hash\n", catal->URL);
+
+	    if (catal->type == XML_CATA_CATALOG)
+		catal->children = doc->children;
+	    else
+		catal->children = doc;
+	    catal->dealloc = 0;
+	    xmlRMutexUnlock(xmlCatalogMutex);
+	    return(0);
+	}
+	if (xmlDebugCatalogs)
+	    xmlGenericError(xmlGenericErrorContext,
+		"%s not found in file hash\n", catal->URL);
+    }
+
+    /*
+     * Fetch and parse. Note that xmlParseXMLCatalogFile does not
+     * use the existing catalog, there is no recursion allowed at
+     * that level.
+     */
+    doc = xmlParseXMLCatalogFile(catal->prefer, catal->URL);
+    if (doc == NULL) {
+	catal->type = XML_CATA_BROKEN_CATALOG;
+	xmlRMutexUnlock(xmlCatalogMutex);
+	return(-1);
+    }
+
+    if (catal->type == XML_CATA_CATALOG)
+	catal->children = doc->children;
+    else
+	catal->children = doc;
+
+    doc->dealloc = 1;
+
+    if (xmlCatalogXMLFiles == NULL)
+	xmlCatalogXMLFiles = xmlHashCreate(10);
+    if (xmlCatalogXMLFiles != NULL) {
+	if (xmlDebugCatalogs)
+	    xmlGenericError(xmlGenericErrorContext,
+		"%s added to file hash\n", catal->URL);
+	xmlHashAddEntry(xmlCatalogXMLFiles, catal->URL, doc);
+    }
+    xmlRMutexUnlock(xmlCatalogMutex);
+    return(0);
+}
+
+/************************************************************************
+ *									*
+ *			XML Catalog handling				*
+ *									*
+ ************************************************************************/
+
+/**
+ * xmlAddXMLCatalog:
+ * @catal:  top of an XML catalog
+ * @type:  the type of record to add to the catalog
+ * @orig:  the system, public or prefix to match (or NULL)
+ * @replace:  the replacement value for the match
+ *
+ * Add an entry in the XML catalog, it may overwrite existing but
+ * different entries.
+ *
+ * Returns 0 if successful, -1 otherwise
+ */
+static int
+xmlAddXMLCatalog(xmlCatalogEntryPtr catal, const xmlChar *type,
+	      const xmlChar *orig, const xmlChar *replace) {
+    xmlCatalogEntryPtr cur;
+    xmlCatalogEntryType typ;
+    int doregister = 0;
+
+    if ((catal == NULL) || 
+	((catal->type != XML_CATA_CATALOG) &&
+	 (catal->type != XML_CATA_BROKEN_CATALOG)))
+	return(-1);
+    if (catal->children == NULL) {
+	xmlFetchXMLCatalogFile(catal);
+    }
+    if (catal->children == NULL)
+	doregister = 1;
+
+    typ = xmlGetXMLCatalogEntryType(type);
+    if (typ == XML_CATA_NONE) {
+	if (xmlDebugCatalogs)
+	    xmlGenericError(xmlGenericErrorContext,
+		    "Failed to add unknown element %s to catalog\n", type);
+	return(-1);
+    }
+
+    cur = catal->children;
+    /*
+     * Might be a simple "update in place"
+     */
+    if (cur != NULL) {
+	while (cur != NULL) {
+	    if ((orig != NULL) && (cur->type == typ) &&
+		(xmlStrEqual(orig, cur->name))) {
+		if (xmlDebugCatalogs)
+		    xmlGenericError(xmlGenericErrorContext,
+			    "Updating element %s to catalog\n", type);
+		if (cur->value != NULL)
+		    xmlFree(cur->value);
+		if (cur->URL != NULL)
+		    xmlFree(cur->URL);
+		cur->value = xmlStrdup(replace);
+		cur->URL = xmlStrdup(replace);
+		return(0);
+	    }
+	    if (cur->next == NULL)
+		break;
+	    cur = cur->next;
+	}
+    }
+    if (xmlDebugCatalogs)
+	xmlGenericError(xmlGenericErrorContext,
+		"Adding element %s to catalog\n", type);
+    if (cur == NULL)
+	catal->children = xmlNewCatalogEntry(typ, orig, replace,
+		                             NULL, catal->prefer);
+    else
+	cur->next = xmlNewCatalogEntry(typ, orig, replace,
+		                       NULL, catal->prefer);
+    if (doregister) {
+	cur = xmlHashLookup(xmlCatalogXMLFiles, catal->URL);
+	if (cur != NULL)
+	    cur->children = catal->children;
+    }
+
+    return(0);
+}
+
+/**
+ * xmlDelXMLCatalog:
+ * @catal:  top of an XML catalog
+ * @value:  the value to remove from the catalog
+ *
+ * Remove entries in the XML catalog where the value or the URI
+ * is equal to @value
+ *
+ * Returns the number of entries removed if successful, -1 otherwise
+ */
+static int
+xmlDelXMLCatalog(xmlCatalogEntryPtr catal, const xmlChar *value) {
+    xmlCatalogEntryPtr cur;
+    int ret = 0;
+
+    if ((catal == NULL) || 
+	((catal->type != XML_CATA_CATALOG) &&
+	 (catal->type != XML_CATA_BROKEN_CATALOG)))
+	return(-1);
+    if (value == NULL)
+	return(-1);
+    if (catal->children == NULL) {
+	xmlFetchXMLCatalogFile(catal);
+    }
+
+    /*
+     * Scan the children
+     */
+    cur = catal->children;
+    while (cur != NULL) {
+	if (((cur->name != NULL) && (xmlStrEqual(value, cur->name))) ||
+	    (xmlStrEqual(value, cur->value))) {
+	    if (xmlDebugCatalogs) {
+		if (cur->name != NULL)
+		    xmlGenericError(xmlGenericErrorContext,
+			    "Removing element %s from catalog\n", cur->name);
+		else
+		    xmlGenericError(xmlGenericErrorContext,
+			    "Removing element %s from catalog\n", cur->value);
+	    }
+	    cur->type = XML_CATA_REMOVED;
+	}
+	cur = cur->next;
+    }
+    return(ret);
+}
+
+/**
+ * xmlCatalogXMLResolve:
+ * @catal:  a catalog list
+ * @pubID:  the public ID string
+ * @sysID:  the system ID string
+ *
+ * Do a complete resolution lookup of an External Identifier for a
+ * list of catalog entries.
+ *
+ * Implements (or tries to) 7.1. External Identifier Resolution
+ * from http://www.oasis-open.org/committees/entity/spec-2001-08-06.html
+ *
+ * Returns the URI of the resource or NULL if not found
+ */
+static xmlChar *
+xmlCatalogXMLResolve(xmlCatalogEntryPtr catal, const xmlChar *pubID,
+	              const xmlChar *sysID) {
+    xmlChar *ret = NULL;
+    xmlCatalogEntryPtr cur;
+    int haveDelegate = 0;
+    int haveNext = 0;
+
+    /*
+     * protection against loops
+     */
+    if (catal->depth > MAX_CATAL_DEPTH) {
+	xmlCatalogErr(catal, NULL, XML_CATALOG_RECURSION,
+		      "Detected recursion in catalog %s\n",
+		      catal->name, NULL, NULL);
+	return(NULL);
+    }
+    catal->depth++;
+
+    /*
+     * First tries steps 2/ 3/ 4/ if a system ID is provided.
+     */
+    if (sysID != NULL) {
+	xmlCatalogEntryPtr rewrite = NULL;
+	int lenrewrite = 0, len;
+	cur = catal;
+	haveDelegate = 0;
+	while (cur != NULL) {
+	    switch (cur->type) {
+		case XML_CATA_SYSTEM:
+		    if (xmlStrEqual(sysID, cur->name)) {
+			if (xmlDebugCatalogs)
+			    xmlGenericError(xmlGenericErrorContext,
+				    "Found system match %s\n", cur->name);
+			catal->depth--;
+			return(xmlStrdup(cur->URL));
+		    }
+		    break;
+		case XML_CATA_REWRITE_SYSTEM:
+		    len = xmlStrlen(cur->name);
+		    if ((len > lenrewrite) &&
+			(!xmlStrncmp(sysID, cur->name, len))) {
+			lenrewrite = len;
+			rewrite = cur;
+		    }
+		    break;
+		case XML_CATA_DELEGATE_SYSTEM:
+		    if (!xmlStrncmp(sysID, cur->name, xmlStrlen(cur->name)))
+			haveDelegate++;
+		    break;
+		case XML_CATA_NEXT_CATALOG:
+		    haveNext++;
+		    break;
+		default:
+		    break;
+	    }
+	    cur = cur->next;
+	}
+	if (rewrite != NULL) {
+	    if (xmlDebugCatalogs)
+		xmlGenericError(xmlGenericErrorContext,
+			"Using rewriting rule %s\n", rewrite->name);
+	    ret = xmlStrdup(rewrite->URL);
+	    if (ret != NULL)
+		ret = xmlStrcat(ret, &sysID[lenrewrite]);
+	    catal->depth--;
+	    return(ret);
+	}
+	if (haveDelegate) {
+	    const xmlChar *delegates[MAX_DELEGATE];
+	    int nbList = 0, i;
+
+	    /*
+	     * Assume the entries have been sorted by decreasing substring
+	     * matches when the list was produced.
+	     */
+	    cur = catal;
+	    while (cur != NULL) {
+		if ((cur->type == XML_CATA_DELEGATE_SYSTEM) &&
+		    (!xmlStrncmp(sysID, cur->name, xmlStrlen(cur->name)))) {
+		    for (i = 0;i < nbList;i++)
+			if (xmlStrEqual(cur->URL, delegates[i]))
+			    break;
+		    if (i < nbList) {
+			cur = cur->next;
+			continue;
+		    }
+		    if (nbList < MAX_DELEGATE)
+			delegates[nbList++] = cur->URL;
+
+		    if (cur->children == NULL) {
+			xmlFetchXMLCatalogFile(cur);
+		    }
+		    if (cur->children != NULL) {
+			if (xmlDebugCatalogs)
+			    xmlGenericError(xmlGenericErrorContext,
+				    "Trying system delegate %s\n", cur->URL);
+			ret = xmlCatalogListXMLResolve(
+				cur->children, NULL, sysID);
+			if (ret != NULL) {
+			    catal->depth--;
+			    return(ret);
+			}
+		    }
+		}
+		cur = cur->next;
+	    }
+	    /*
+	     * Apply the cut algorithm explained in 4/
+	     */
+	    catal->depth--;
+	    return(XML_CATAL_BREAK);
+	}
+    }
+    /*
+     * Then tries 5/ 6/ if a public ID is provided
+     */
+    if (pubID != NULL) {
+	cur = catal;
+	haveDelegate = 0;
+	while (cur != NULL) {
+	    switch (cur->type) {
+		case XML_CATA_PUBLIC:
+		    if (xmlStrEqual(pubID, cur->name)) {
+			if (xmlDebugCatalogs)
+			    xmlGenericError(xmlGenericErrorContext,
+				    "Found public match %s\n", cur->name);
+			catal->depth--;
+			return(xmlStrdup(cur->URL));
+		    }
+		    break;
+		case XML_CATA_DELEGATE_PUBLIC:
+		    if (!xmlStrncmp(pubID, cur->name, xmlStrlen(cur->name)) &&
+			(cur->prefer == XML_CATA_PREFER_PUBLIC))
+			haveDelegate++;
+		    break;
+		case XML_CATA_NEXT_CATALOG:
+		    if (sysID == NULL)
+			haveNext++;
+		    break;
+		default:
+		    break;
+	    }
+	    cur = cur->next;
+	}
+	if (haveDelegate) {
+	    const xmlChar *delegates[MAX_DELEGATE];
+	    int nbList = 0, i;
+
+	    /*
+	     * Assume the entries have been sorted by decreasing substring
+	     * matches when the list was produced.
+	     */
+	    cur = catal;
+	    while (cur != NULL) {
+		if ((cur->type == XML_CATA_DELEGATE_PUBLIC) &&
+		    (cur->prefer == XML_CATA_PREFER_PUBLIC) &&
+		    (!xmlStrncmp(pubID, cur->name, xmlStrlen(cur->name)))) {
+
+		    for (i = 0;i < nbList;i++)
+			if (xmlStrEqual(cur->URL, delegates[i]))
+			    break;
+		    if (i < nbList) {
+			cur = cur->next;
+			continue;
+		    }
+		    if (nbList < MAX_DELEGATE)
+			delegates[nbList++] = cur->URL;
+			    
+		    if (cur->children == NULL) {
+			xmlFetchXMLCatalogFile(cur);
+		    }
+		    if (cur->children != NULL) {
+			if (xmlDebugCatalogs)
+			    xmlGenericError(xmlGenericErrorContext,
+				    "Trying public delegate %s\n", cur->URL);
+			ret = xmlCatalogListXMLResolve(
+				cur->children, pubID, NULL);
+			if (ret != NULL) {
+			    catal->depth--;
+			    return(ret);
+			}
+		    }
+		}
+		cur = cur->next;
+	    }
+	    /*
+	     * Apply the cut algorithm explained in 4/
+	     */
+	    catal->depth--;
+	    return(XML_CATAL_BREAK);
+	}
+    }
+    if (haveNext) {
+	cur = catal;
+	while (cur != NULL) {
+	    if (cur->type == XML_CATA_NEXT_CATALOG) {
+		if (cur->children == NULL) {
+		    xmlFetchXMLCatalogFile(cur);
+		}
+		if (cur->children != NULL) {
+		    ret = xmlCatalogListXMLResolve(cur->children, pubID, sysID);
+		    if (ret != NULL) {
+			catal->depth--;
+			return(ret);
+		    }
+		}
+	    }
+	    cur = cur->next;
+	}
+    }
+
+    catal->depth--;
+    return(NULL);
+}
+
+/**
+ * xmlCatalogXMLResolveURI:
+ * @catal:  a catalog list
+ * @URI:  the URI
+ * @sysID:  the system ID string
+ *
+ * Do a complete resolution lookup of an External Identifier for a
+ * list of catalog entries.
+ *
+ * Implements (or tries to) 7.2.2. URI Resolution
+ * from http://www.oasis-open.org/committees/entity/spec-2001-08-06.html
+ *
+ * Returns the URI of the resource or NULL if not found
+ */
+static xmlChar *
+xmlCatalogXMLResolveURI(xmlCatalogEntryPtr catal, const xmlChar *URI) {
+    xmlChar *ret = NULL;
+    xmlCatalogEntryPtr cur;
+    int haveDelegate = 0;
+    int haveNext = 0;
+    xmlCatalogEntryPtr rewrite = NULL;
+    int lenrewrite = 0, len;
+
+    if (catal == NULL)
+	return(NULL);
+
+    if (URI == NULL)
+	return(NULL);
+
+    /*
+     * First tries steps 2/ 3/ 4/ if a system ID is provided.
+     */
+    cur = catal;
+    haveDelegate = 0;
+    while (cur != NULL) {
+	switch (cur->type) {
+	    case XML_CATA_URI:
+		if (xmlStrEqual(URI, cur->name)) {
+		    if (xmlDebugCatalogs)
+			xmlGenericError(xmlGenericErrorContext,
+				"Found URI match %s\n", cur->name);
+		    return(xmlStrdup(cur->URL));
+		}
+		break;
+	    case XML_CATA_REWRITE_URI:
+		len = xmlStrlen(cur->name);
+		if ((len > lenrewrite) &&
+		    (!xmlStrncmp(URI, cur->name, len))) {
+		    lenrewrite = len;
+		    rewrite = cur;
+		}
+		break;
+	    case XML_CATA_DELEGATE_URI:
+		if (!xmlStrncmp(URI, cur->name, xmlStrlen(cur->name)))
+		    haveDelegate++;
+		break;
+	    case XML_CATA_NEXT_CATALOG:
+		haveNext++;
+		break;
+	    default:
+		break;
+	}
+	cur = cur->next;
+    }
+    if (rewrite != NULL) {
+	if (xmlDebugCatalogs)
+	    xmlGenericError(xmlGenericErrorContext,
+		    "Using rewriting rule %s\n", rewrite->name);
+	ret = xmlStrdup(rewrite->URL);
+	if (ret != NULL)
+	    ret = xmlStrcat(ret, &URI[lenrewrite]);
+	return(ret);
+    }
+    if (haveDelegate) {
+	const xmlChar *delegates[MAX_DELEGATE];
+	int nbList = 0, i;
+
+	/*
+	 * Assume the entries have been sorted by decreasing substring
+	 * matches when the list was produced.
+	 */
+	cur = catal;
+	while (cur != NULL) {
+	    if (((cur->type == XML_CATA_DELEGATE_SYSTEM) ||
+	         (cur->type == XML_CATA_DELEGATE_URI)) &&
+		(!xmlStrncmp(URI, cur->name, xmlStrlen(cur->name)))) {
+		for (i = 0;i < nbList;i++)
+		    if (xmlStrEqual(cur->URL, delegates[i]))
+			break;
+		if (i < nbList) {
+		    cur = cur->next;
+		    continue;
+		}
+		if (nbList < MAX_DELEGATE)
+		    delegates[nbList++] = cur->URL;
+
+		if (cur->children == NULL) {
+		    xmlFetchXMLCatalogFile(cur);
+		}
+		if (cur->children != NULL) {
+		    if (xmlDebugCatalogs)
+			xmlGenericError(xmlGenericErrorContext,
+				"Trying URI delegate %s\n", cur->URL);
+		    ret = xmlCatalogListXMLResolveURI(
+			    cur->children, URI);
+		    if (ret != NULL)
+			return(ret);
+		}
+	    }
+	    cur = cur->next;
+	}
+	/*
+	 * Apply the cut algorithm explained in 4/
+	 */
+	return(XML_CATAL_BREAK);
+    }
+    if (haveNext) {
+	cur = catal;
+	while (cur != NULL) {
+	    if (cur->type == XML_CATA_NEXT_CATALOG) {
+		if (cur->children == NULL) {
+		    xmlFetchXMLCatalogFile(cur);
+		}
+		if (cur->children != NULL) {
+		    ret = xmlCatalogListXMLResolveURI(cur->children, URI);
+		    if (ret != NULL)
+			return(ret);
+		}
+	    }
+	    cur = cur->next;
+	}
+    }
+
+    return(NULL);
+}
+
+/**
+ * xmlCatalogListXMLResolve:
+ * @catal:  a catalog list
+ * @pubID:  the public ID string
+ * @sysID:  the system ID string
+ *
+ * Do a complete resolution lookup of an External Identifier for a
+ * list of catalogs
+ *
+ * Implements (or tries to) 7.1. External Identifier Resolution
+ * from http://www.oasis-open.org/committees/entity/spec-2001-08-06.html
+ *
+ * Returns the URI of the resource or NULL if not found
+ */
+static xmlChar *
+xmlCatalogListXMLResolve(xmlCatalogEntryPtr catal, const xmlChar *pubID,
+	              const xmlChar *sysID) {
+    xmlChar *ret = NULL;
+    xmlChar *urnID = NULL;
+    
+    if (catal == NULL)
+        return(NULL);
+    if ((pubID == NULL) && (sysID == NULL))
+	return(NULL);
+
+    if (!xmlStrncmp(pubID, BAD_CAST XML_URN_PUBID, sizeof(XML_URN_PUBID) - 1)) {
+	urnID = xmlCatalogUnWrapURN(pubID);
+	if (xmlDebugCatalogs) {
+	    if (urnID == NULL)
+		xmlGenericError(xmlGenericErrorContext,
+			"Public URN ID %s expanded to NULL\n", pubID);
+	    else
+		xmlGenericError(xmlGenericErrorContext,
+			"Public URN ID expanded to %s\n", urnID);
+	}
+	ret = xmlCatalogListXMLResolve(catal, urnID, sysID);
+	if (urnID != NULL)
+	    xmlFree(urnID);
+	return(ret);
+    }
+    if (!xmlStrncmp(sysID, BAD_CAST XML_URN_PUBID, sizeof(XML_URN_PUBID) - 1)) {
+	urnID = xmlCatalogUnWrapURN(sysID);
+	if (xmlDebugCatalogs) {
+	    if (urnID == NULL)
+		xmlGenericError(xmlGenericErrorContext,
+			"System URN ID %s expanded to NULL\n", sysID);
+	    else
+		xmlGenericError(xmlGenericErrorContext,
+			"System URN ID expanded to %s\n", urnID);
+	}
+	if (pubID == NULL)
+	    ret = xmlCatalogListXMLResolve(catal, urnID, NULL);
+	else if (xmlStrEqual(pubID, urnID))
+	    ret = xmlCatalogListXMLResolve(catal, pubID, NULL);
+	else {
+	    ret = xmlCatalogListXMLResolve(catal, pubID, urnID);
+	}
+	if (urnID != NULL)
+	    xmlFree(urnID);
+	return(ret);
+    }
+    while (catal != NULL) {
+	if (catal->type == XML_CATA_CATALOG) {
+	    if (catal->children == NULL) {
+		xmlFetchXMLCatalogFile(catal);
+	    }
+	    if (catal->children != NULL) {
+		ret = xmlCatalogXMLResolve(catal->children, pubID, sysID);
+		if (ret != NULL)
+		    return(ret);
+	    }
+	}
+	catal = catal->next;
+    }
+    return(ret);
+}
+
+/**
+ * xmlCatalogListXMLResolveURI:
+ * @catal:  a catalog list
+ * @URI:  the URI
+ *
+ * Do a complete resolution lookup of an URI for a list of catalogs
+ *
+ * Implements (or tries to) 7.2. URI Resolution
+ * from http://www.oasis-open.org/committees/entity/spec-2001-08-06.html
+ *
+ * Returns the URI of the resource or NULL if not found
+ */
+static xmlChar *
+xmlCatalogListXMLResolveURI(xmlCatalogEntryPtr catal, const xmlChar *URI) {
+    xmlChar *ret = NULL;
+    xmlChar *urnID = NULL;
+    
+    if (catal == NULL)
+        return(NULL);
+    if (URI == NULL)
+	return(NULL);
+
+    if (!xmlStrncmp(URI, BAD_CAST XML_URN_PUBID, sizeof(XML_URN_PUBID) - 1)) {
+	urnID = xmlCatalogUnWrapURN(URI);
+	if (xmlDebugCatalogs) {
+	    if (urnID == NULL)
+		xmlGenericError(xmlGenericErrorContext,
+			"URN ID %s expanded to NULL\n", URI);
+	    else
+		xmlGenericError(xmlGenericErrorContext,
+			"URN ID expanded to %s\n", urnID);
+	}
+	ret = xmlCatalogListXMLResolve(catal, urnID, NULL);
+	if (urnID != NULL)
+	    xmlFree(urnID);
+	return(ret);
+    }
+    while (catal != NULL) {
+	if (catal->type == XML_CATA_CATALOG) {
+	    if (catal->children == NULL) {
+		xmlFetchXMLCatalogFile(catal);
+	    }
+	    if (catal->children != NULL) {
+		ret = xmlCatalogXMLResolveURI(catal->children, URI);
+		if (ret != NULL)
+		    return(ret);
+	    }
+	}
+	catal = catal->next;
+    }
+    return(ret);
+}
+
+/************************************************************************
+ *									*
+ *			The SGML Catalog parser				*
+ *									*
+ ************************************************************************/
+
+
+#define RAW *cur
+#define NEXT cur++;
+#define SKIP(x) cur += x;
+
+#define SKIP_BLANKS while (IS_BLANK_CH(*cur)) NEXT;
+
+/**
+ * xmlParseSGMLCatalogComment:
+ * @cur:  the current character
+ *
+ * Skip a comment in an SGML catalog
+ *
+ * Returns new current character
+ */
+static const xmlChar *
+xmlParseSGMLCatalogComment(const xmlChar *cur) {
+    if ((cur[0] != '-') || (cur[1] != '-')) 
+	return(cur);
+    SKIP(2);
+    while ((cur[0] != 0) && ((cur[0] != '-') || ((cur[1] != '-'))))
+	NEXT;
+    if (cur[0] == 0) {
+	return(NULL);
+    }
+    return(cur + 2);
+}
+
+/**
+ * xmlParseSGMLCatalogPubid:
+ * @cur:  the current character
+ * @id:  the return location
+ *
+ * Parse an SGML catalog ID
+ *
+ * Returns new current character and store the value in @id
+ */
+static const xmlChar *
+xmlParseSGMLCatalogPubid(const xmlChar *cur, xmlChar **id) {
+    xmlChar *buf = NULL, *tmp;
+    int len = 0;
+    int size = 50;
+    xmlChar stop;
+    int count = 0;
+
+    *id = NULL;
+
+    if (RAW == '"') {
+        NEXT;
+	stop = '"';
+    } else if (RAW == '\'') {
+        NEXT;
+	stop = '\'';
+    } else {
+	stop = ' ';
+    }
+    buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar));
+    if (buf == NULL) {
+        xmlCatalogErrMemory("allocating public ID");
+	return(NULL);
+    }
+    while (IS_PUBIDCHAR_CH(*cur) || (*cur == '?')) {
+	if ((*cur == stop) && (stop != ' '))
+	    break;
+	if ((stop == ' ') && (IS_BLANK_CH(*cur)))
+	    break;
+	if (len + 1 >= size) {
+	    size *= 2;
+	    tmp = (xmlChar *) xmlRealloc(buf, size * sizeof(xmlChar));
+	    if (tmp == NULL) {
+		xmlCatalogErrMemory("allocating public ID");
+		xmlFree(buf);
+		return(NULL);
+	    }
+	    buf = tmp;
+	}
+	buf[len++] = *cur;
+	count++;
+	NEXT;
+    }
+    buf[len] = 0;
+    if (stop == ' ') {
+	if (!IS_BLANK_CH(*cur)) {
+	    xmlFree(buf);
+	    return(NULL);
+	}
+    } else {
+	if (*cur != stop) {
+	    xmlFree(buf);
+	    return(NULL);
+	}
+	NEXT;
+    }
+    *id = buf;
+    return(cur);
+}
+
+/**
+ * xmlParseSGMLCatalogName:
+ * @cur:  the current character
+ * @name:  the return location
+ *
+ * Parse an SGML catalog name
+ *
+ * Returns new current character and store the value in @name
+ */
+static const xmlChar *
+xmlParseSGMLCatalogName(const xmlChar *cur, xmlChar **name) {
+    xmlChar buf[XML_MAX_NAMELEN + 5];
+    int len = 0;
+    int c;
+
+    *name = NULL;
+
+    /*
+     * Handler for more complex cases
+     */
+    c = *cur;
+    if ((!IS_LETTER(c) && (c != '_') && (c != ':'))) {
+	return(NULL);
+    }
+
+    while (((IS_LETTER(c)) || (IS_DIGIT(c)) ||
+            (c == '.') || (c == '-') ||
+	    (c == '_') || (c == ':'))) {
+	buf[len++] = c;
+	cur++;
+	c = *cur;
+	if (len >= XML_MAX_NAMELEN)
+	    return(NULL);
+    }
+    *name = xmlStrndup(buf, len);
+    return(cur);
+}
+
+/**
+ * xmlGetSGMLCatalogEntryType:
+ * @name:  the entry name
+ *
+ * Get the Catalog entry type for a given SGML Catalog name
+ *
+ * Returns Catalog entry type
+ */
+static xmlCatalogEntryType
+xmlGetSGMLCatalogEntryType(const xmlChar *name) {
+    xmlCatalogEntryType type = XML_CATA_NONE;
+    if (xmlStrEqual(name, (const xmlChar *) "SYSTEM"))
+	type = SGML_CATA_SYSTEM;
+    else if (xmlStrEqual(name, (const xmlChar *) "PUBLIC"))
+	type = SGML_CATA_PUBLIC;
+    else if (xmlStrEqual(name, (const xmlChar *) "DELEGATE"))
+	type = SGML_CATA_DELEGATE;
+    else if (xmlStrEqual(name, (const xmlChar *) "ENTITY"))
+	type = SGML_CATA_ENTITY;
+    else if (xmlStrEqual(name, (const xmlChar *) "DOCTYPE"))
+	type = SGML_CATA_DOCTYPE;
+    else if (xmlStrEqual(name, (const xmlChar *) "LINKTYPE"))
+	type = SGML_CATA_LINKTYPE;
+    else if (xmlStrEqual(name, (const xmlChar *) "NOTATION"))
+	type = SGML_CATA_NOTATION;
+    else if (xmlStrEqual(name, (const xmlChar *) "SGMLDECL"))
+	type = SGML_CATA_SGMLDECL;
+    else if (xmlStrEqual(name, (const xmlChar *) "DOCUMENT"))
+	type = SGML_CATA_DOCUMENT;
+    else if (xmlStrEqual(name, (const xmlChar *) "CATALOG"))
+	type = SGML_CATA_CATALOG;
+    else if (xmlStrEqual(name, (const xmlChar *) "BASE"))
+	type = SGML_CATA_BASE;
+    else if (xmlStrEqual(name, (const xmlChar *) "DELEGATE"))
+	type = SGML_CATA_DELEGATE;
+    return(type);
+}
+
+/**
+ * xmlParseSGMLCatalog:
+ * @catal:  the SGML Catalog
+ * @value:  the content of the SGML Catalog serialization
+ * @file:  the filepath for the catalog
+ * @super:  should this be handled as a Super Catalog in which case
+ *          parsing is not recursive
+ *
+ * Parse an SGML catalog content and fill up the @catal hash table with
+ * the new entries found.
+ *
+ * Returns 0 in case of success, -1 in case of error.
+ */
+static int
+xmlParseSGMLCatalog(xmlCatalogPtr catal, const xmlChar *value,
+	            const char *file, int super) {
+    const xmlChar *cur = value;
+    xmlChar *base = NULL;
+    int res;
+
+    if ((cur == NULL) || (file == NULL))
+        return(-1);
+    base = xmlStrdup((const xmlChar *) file);
+
+    while ((cur != NULL) && (cur[0] != 0)) {
+	SKIP_BLANKS;
+	if (cur[0] == 0)
+	    break;
+	if ((cur[0] == '-') && (cur[1] == '-')) {
+	    cur = xmlParseSGMLCatalogComment(cur);
+	    if (cur == NULL) {
+		/* error */
+		break;
+	    }
+	} else {
+	    xmlChar *sysid = NULL;
+	    xmlChar *name = NULL;
+	    xmlCatalogEntryType type = XML_CATA_NONE;
+
+	    cur = xmlParseSGMLCatalogName(cur, &name);
+	    if (name == NULL) {
+		/* error */
+		break;
+	    }
+	    if (!IS_BLANK_CH(*cur)) {
+		/* error */
+		break;
+	    }
+	    SKIP_BLANKS;
+	    if (xmlStrEqual(name, (const xmlChar *) "SYSTEM"))
+                type = SGML_CATA_SYSTEM;
+	    else if (xmlStrEqual(name, (const xmlChar *) "PUBLIC"))
+                type = SGML_CATA_PUBLIC;
+	    else if (xmlStrEqual(name, (const xmlChar *) "DELEGATE"))
+                type = SGML_CATA_DELEGATE;
+	    else if (xmlStrEqual(name, (const xmlChar *) "ENTITY"))
+                type = SGML_CATA_ENTITY;
+	    else if (xmlStrEqual(name, (const xmlChar *) "DOCTYPE"))
+                type = SGML_CATA_DOCTYPE;
+	    else if (xmlStrEqual(name, (const xmlChar *) "LINKTYPE"))
+                type = SGML_CATA_LINKTYPE;
+	    else if (xmlStrEqual(name, (const xmlChar *) "NOTATION"))
+                type = SGML_CATA_NOTATION;
+	    else if (xmlStrEqual(name, (const xmlChar *) "SGMLDECL"))
+                type = SGML_CATA_SGMLDECL;
+	    else if (xmlStrEqual(name, (const xmlChar *) "DOCUMENT"))
+                type = SGML_CATA_DOCUMENT;
+	    else if (xmlStrEqual(name, (const xmlChar *) "CATALOG"))
+                type = SGML_CATA_CATALOG;
+	    else if (xmlStrEqual(name, (const xmlChar *) "BASE"))
+                type = SGML_CATA_BASE;
+	    else if (xmlStrEqual(name, (const xmlChar *) "DELEGATE"))
+                type = SGML_CATA_DELEGATE;
+	    else if (xmlStrEqual(name, (const xmlChar *) "OVERRIDE")) {
+		xmlFree(name);
+		cur = xmlParseSGMLCatalogName(cur, &name);
+		if (name == NULL) {
+		    /* error */
+		    break;
+		}
+		xmlFree(name);
+		continue;
+	    }
+	    xmlFree(name);
+	    name = NULL;
+
+	    switch(type) {
+		case SGML_CATA_ENTITY:
+		    if (*cur == '%')
+			type = SGML_CATA_PENTITY;
+		case SGML_CATA_PENTITY:
+		case SGML_CATA_DOCTYPE:
+		case SGML_CATA_LINKTYPE:
+		case SGML_CATA_NOTATION:
+		    cur = xmlParseSGMLCatalogName(cur, &name);
+		    if (cur == NULL) {
+			/* error */
+			break;
+		    }
+		    if (!IS_BLANK_CH(*cur)) {
+			/* error */
+			break;
+		    }
+		    SKIP_BLANKS;
+		    cur = xmlParseSGMLCatalogPubid(cur, &sysid);
+		    if (cur == NULL) {
+			/* error */
+			break;
+		    }
+		    break;
+		case SGML_CATA_PUBLIC:
+		case SGML_CATA_SYSTEM:
+		case SGML_CATA_DELEGATE:
+		    cur = xmlParseSGMLCatalogPubid(cur, &name);
+		    if (cur == NULL) {
+			/* error */
+			break;
+		    }
+		    if (!IS_BLANK_CH(*cur)) {
+			/* error */
+			break;
+		    }
+		    SKIP_BLANKS;
+		    cur = xmlParseSGMLCatalogPubid(cur, &sysid);
+		    if (cur == NULL) {
+			/* error */
+			break;
+		    }
+		    break;
+		case SGML_CATA_BASE:
+		case SGML_CATA_CATALOG:
+		case SGML_CATA_DOCUMENT:
+		case SGML_CATA_SGMLDECL:
+		    cur = xmlParseSGMLCatalogPubid(cur, &sysid);
+		    if (cur == NULL) {
+			/* error */
+			break;
+		    }
+		    break;
+		default:
+		    break;
+	    }
+	    if (cur == NULL) {
+		if (name != NULL)
+		    xmlFree(name);
+		if (sysid != NULL)
+		    xmlFree(sysid);
+		break;
+	    } else if (type == SGML_CATA_BASE) {
+		if (base != NULL)
+		    xmlFree(base);
+		base = xmlStrdup(sysid);
+	    } else if ((type == SGML_CATA_PUBLIC) ||
+		       (type == SGML_CATA_SYSTEM)) {
+		xmlChar *filename;
+
+		filename = xmlBuildURI(sysid, base);
+		if (filename != NULL) {
+		    xmlCatalogEntryPtr entry;
+
+		    entry = xmlNewCatalogEntry(type, name, filename,
+			                       NULL, XML_CATA_PREFER_NONE);
+		    res = xmlHashAddEntry(catal->sgml, name, entry);
+		    if (res < 0) {
+			xmlFreeCatalogEntry(entry);
+		    }
+		    xmlFree(filename);
+		}
+
+	    } else if (type == SGML_CATA_CATALOG) {
+		if (super) {
+		    xmlCatalogEntryPtr entry;
+
+		    entry = xmlNewCatalogEntry(type, sysid, NULL, NULL,
+			                       XML_CATA_PREFER_NONE);
+		    res = xmlHashAddEntry(catal->sgml, sysid, entry);
+		    if (res < 0) {
+			xmlFreeCatalogEntry(entry);
+		    }
+		} else {
+		    xmlChar *filename;
+
+		    filename = xmlBuildURI(sysid, base);
+		    if (filename != NULL) {
+			xmlExpandCatalog(catal, (const char *)filename);
+			xmlFree(filename);
+		    }
+		}
+	    }
+	    /*
+	     * drop anything else we won't handle it
+	     */
+	    if (name != NULL)
+		xmlFree(name);
+	    if (sysid != NULL)
+		xmlFree(sysid);
+	}
+    }
+    if (base != NULL)
+	xmlFree(base);
+    if (cur == NULL)
+	return(-1);
+    return(0);
+}
+
+/************************************************************************
+ *									*
+ *			SGML Catalog handling				*
+ *									*
+ ************************************************************************/
+
+/**
+ * xmlCatalogGetSGMLPublic:
+ * @catal:  an SGML catalog hash
+ * @pubID:  the public ID string
+ *
+ * Try to lookup the catalog local reference associated to a public ID
+ *
+ * Returns the local resource if found or NULL otherwise.
+ */
+static const xmlChar *
+xmlCatalogGetSGMLPublic(xmlHashTablePtr catal, const xmlChar *pubID) {
+    xmlCatalogEntryPtr entry;
+
+    if (catal == NULL)
+	return(NULL);
+
+    entry = (xmlCatalogEntryPtr) xmlHashLookup(catal, pubID);
+    if (entry == NULL)
+	return(NULL);
+    if (entry->type == SGML_CATA_PUBLIC)
+	return(entry->URL);
+    return(NULL);
+}
+
+/**
+ * xmlCatalogGetSGMLSystem:
+ * @catal:  an SGML catalog hash
+ * @sysID:  the system ID string
+ *
+ * Try to lookup the catalog local reference for a system ID
+ *
+ * Returns the local resource if found or NULL otherwise.
+ */
+static const xmlChar *
+xmlCatalogGetSGMLSystem(xmlHashTablePtr catal, const xmlChar *sysID) {
+    xmlCatalogEntryPtr entry;
+
+    if (catal == NULL)
+	return(NULL);
+
+    entry = (xmlCatalogEntryPtr) xmlHashLookup(catal, sysID);
+    if (entry == NULL)
+	return(NULL);
+    if (entry->type == SGML_CATA_SYSTEM)
+	return(entry->URL);
+    return(NULL);
+}
+
+/**
+ * xmlCatalogSGMLResolve:
+ * @catal:  the SGML catalog
+ * @pubID:  the public ID string
+ * @sysID:  the system ID string
+ *
+ * Do a complete resolution lookup of an External Identifier
+ *
+ * Returns the URI of the resource or NULL if not found
+ */
+static const xmlChar *
+xmlCatalogSGMLResolve(xmlCatalogPtr catal, const xmlChar *pubID,
+	              const xmlChar *sysID) {
+    const xmlChar *ret = NULL;
+
+    if (catal->sgml == NULL)
+	return(NULL);
+
+    if (pubID != NULL)
+	ret = xmlCatalogGetSGMLPublic(catal->sgml, pubID);
+    if (ret != NULL)
+	return(ret);
+    if (sysID != NULL)
+	ret = xmlCatalogGetSGMLSystem(catal->sgml, sysID);
+    return(NULL);
+}
+
+/************************************************************************
+ *									*
+ *			Specific Public interfaces			*
+ *									*
+ ************************************************************************/
+
+/**
+ * xmlLoadSGMLSuperCatalog:
+ * @filename:  a file path
+ *
+ * Load an SGML super catalog. It won't expand CATALOG or DELEGATE
+ * references. This is only needed for manipulating SGML Super Catalogs
+ * like adding and removing CATALOG or DELEGATE entries.
+ *
+ * Returns the catalog parsed or NULL in case of error
+ */
+xmlCatalogPtr
+xmlLoadSGMLSuperCatalog(const char *filename)
+{
+    xmlChar *content;
+    xmlCatalogPtr catal;
+    int ret;
+
+    content = xmlLoadFileContent(filename);
+    if (content == NULL)
+        return(NULL);
+
+    catal = xmlCreateNewCatalog(XML_SGML_CATALOG_TYPE, xmlCatalogDefaultPrefer);
+    if (catal == NULL) {
+	xmlFree(content);
+	return(NULL);
+    }
+
+    ret = xmlParseSGMLCatalog(catal, content, filename, 1);
+    xmlFree(content);
+    if (ret < 0) {
+	xmlFreeCatalog(catal);
+	return(NULL);
+    }
+    return (catal);
+}
+
+/**
+ * xmlLoadACatalog:
+ * @filename:  a file path
+ *
+ * Load the catalog and build the associated data structures.
+ * This can be either an XML Catalog or an SGML Catalog
+ * It will recurse in SGML CATALOG entries. On the other hand XML
+ * Catalogs are not handled recursively.
+ *
+ * Returns the catalog parsed or NULL in case of error
+ */
+xmlCatalogPtr
+xmlLoadACatalog(const char *filename)
+{
+    xmlChar *content;
+    xmlChar *first;
+    xmlCatalogPtr catal;
+    int ret;
+
+    content = xmlLoadFileContent(filename);
+    if (content == NULL)
+        return(NULL);
+
+
+    first = content;
+   
+    while ((*first != 0) && (*first != '-') && (*first != '<') &&
+	   (!(((*first >= 'A') && (*first <= 'Z')) ||
+	      ((*first >= 'a') && (*first <= 'z')))))
+	first++;
+
+    if (*first != '<') {
+	catal = xmlCreateNewCatalog(XML_SGML_CATALOG_TYPE, xmlCatalogDefaultPrefer);
+	if (catal == NULL) {
+	    xmlFree(content);
+	    return(NULL);
+	}
+        ret = xmlParseSGMLCatalog(catal, content, filename, 0);
+	if (ret < 0) {
+	    xmlFreeCatalog(catal);
+	    xmlFree(content);
+	    return(NULL);
+	}
+    } else {
+	catal = xmlCreateNewCatalog(XML_XML_CATALOG_TYPE, xmlCatalogDefaultPrefer);
+	if (catal == NULL) {
+	    xmlFree(content);
+	    return(NULL);
+	}
+        catal->xml = xmlNewCatalogEntry(XML_CATA_CATALOG, NULL,
+		       NULL, BAD_CAST filename, xmlCatalogDefaultPrefer);
+    }
+    xmlFree(content);
+    return (catal);
+}
+
+/**
+ * xmlExpandCatalog:
+ * @catal:  a catalog
+ * @filename:  a file path
+ *
+ * Load the catalog and expand the existing catal structure.
+ * This can be either an XML Catalog or an SGML Catalog
+ *
+ * Returns 0 in case of success, -1 in case of error
+ */
+static int
+xmlExpandCatalog(xmlCatalogPtr catal, const char *filename)
+{
+    int ret;
+
+    if ((catal == NULL) || (filename == NULL))
+	return(-1);
+
+
+    if (catal->type == XML_SGML_CATALOG_TYPE) {
+	xmlChar *content;
+
+	content = xmlLoadFileContent(filename);
+	if (content == NULL)
+	    return(-1);
+
+        ret = xmlParseSGMLCatalog(catal, content, filename, 0);
+	if (ret < 0) {
+	    xmlFree(content);
+	    return(-1);
+	}
+	xmlFree(content);
+    } else {
+	xmlCatalogEntryPtr tmp, cur;
+	tmp = xmlNewCatalogEntry(XML_CATA_CATALOG, NULL,
+		       NULL, BAD_CAST filename, xmlCatalogDefaultPrefer);
+
+	cur = catal->xml;
+	if (cur == NULL) {
+	    catal->xml = tmp;
+	} else {
+	    while (cur->next != NULL) cur = cur->next;
+	    cur->next = tmp;
+	}
+    }
+    return (0);
+}
+
+/**
+ * xmlACatalogResolveSystem:
+ * @catal:  a Catalog
+ * @sysID:  the system ID string
+ *
+ * Try to lookup the catalog resource for a system ID
+ *
+ * Returns the resource if found or NULL otherwise, the value returned
+ *      must be freed by the caller.
+ */
+xmlChar *
+xmlACatalogResolveSystem(xmlCatalogPtr catal, const xmlChar *sysID) {
+    xmlChar *ret = NULL;
+
+    if ((sysID == NULL) || (catal == NULL))
+	return(NULL);
+    
+    if (xmlDebugCatalogs)
+	xmlGenericError(xmlGenericErrorContext,
+		"Resolve sysID %s\n", sysID);
+
+    if (catal->type == XML_XML_CATALOG_TYPE) {
+	ret = xmlCatalogListXMLResolve(catal->xml, NULL, sysID);
+	if (ret == XML_CATAL_BREAK)
+	    ret = NULL;
+    } else {
+	const xmlChar *sgml;
+
+	sgml = xmlCatalogGetSGMLSystem(catal->sgml, sysID);
+	if (sgml != NULL)
+	    ret = xmlStrdup(sgml);
+    }
+    return(ret);
+}
+
+/**
+ * xmlACatalogResolvePublic:
+ * @catal:  a Catalog
+ * @pubID:  the public ID string
+ *
+ * Try to lookup the catalog local reference associated to a public ID in that catalog
+ *
+ * Returns the local resource if found or NULL otherwise, the value returned
+ *      must be freed by the caller.
+ */
+xmlChar *
+xmlACatalogResolvePublic(xmlCatalogPtr catal, const xmlChar *pubID) {
+    xmlChar *ret = NULL;
+
+    if ((pubID == NULL) || (catal == NULL))
+	return(NULL);
+    
+    if (xmlDebugCatalogs)
+	xmlGenericError(xmlGenericErrorContext,
+		"Resolve pubID %s\n", pubID);
+
+    if (catal->type == XML_XML_CATALOG_TYPE) {
+	ret = xmlCatalogListXMLResolve(catal->xml, pubID, NULL);
+	if (ret == XML_CATAL_BREAK)
+	    ret = NULL;
+    } else {
+	const xmlChar *sgml;
+
+	sgml = xmlCatalogGetSGMLPublic(catal->sgml, pubID);
+	if (sgml != NULL)
+	    ret = xmlStrdup(sgml);
+    }
+    return(ret);
+}
+
+/**
+ * xmlACatalogResolve:
+ * @catal:  a Catalog
+ * @pubID:  the public ID string
+ * @sysID:  the system ID string
+ *
+ * Do a complete resolution lookup of an External Identifier
+ *
+ * Returns the URI of the resource or NULL if not found, it must be freed
+ *      by the caller.
+ */
+xmlChar *
+xmlACatalogResolve(xmlCatalogPtr catal, const xmlChar * pubID,
+                   const xmlChar * sysID)
+{
+    xmlChar *ret = NULL;
+
+    if (((pubID == NULL) && (sysID == NULL)) || (catal == NULL))
+        return (NULL);
+
+    if (xmlDebugCatalogs) {
+         if ((pubID != NULL) && (sysID != NULL)) {
+             xmlGenericError(xmlGenericErrorContext,
+                             "Resolve: pubID %s sysID %s\n", pubID, sysID);
+         } else if (pubID != NULL) {
+             xmlGenericError(xmlGenericErrorContext,
+                             "Resolve: pubID %s\n", pubID);
+         } else {
+             xmlGenericError(xmlGenericErrorContext,
+                             "Resolve: sysID %s\n", sysID);
+         }
+    }
+
+    if (catal->type == XML_XML_CATALOG_TYPE) {
+        ret = xmlCatalogListXMLResolve(catal->xml, pubID, sysID);
+	if (ret == XML_CATAL_BREAK)
+	    ret = NULL;
+    } else {
+        const xmlChar *sgml;
+
+        sgml = xmlCatalogSGMLResolve(catal, pubID, sysID);
+        if (sgml != NULL)
+            ret = xmlStrdup(sgml);
+    }
+    return (ret);
+}
+
+/**
+ * xmlACatalogResolveURI:
+ * @catal:  a Catalog
+ * @URI:  the URI
+ *
+ * Do a complete resolution lookup of an URI
+ *
+ * Returns the URI of the resource or NULL if not found, it must be freed
+ *      by the caller.
+ */
+xmlChar *
+xmlACatalogResolveURI(xmlCatalogPtr catal, const xmlChar *URI) {
+    xmlChar *ret = NULL;
+
+    if ((URI == NULL) || (catal == NULL))
+	return(NULL);
+
+    if (xmlDebugCatalogs)
+	xmlGenericError(xmlGenericErrorContext,
+		"Resolve URI %s\n", URI);
+
+    if (catal->type == XML_XML_CATALOG_TYPE) {
+	ret = xmlCatalogListXMLResolveURI(catal->xml, URI);
+	if (ret == XML_CATAL_BREAK)
+	    ret = NULL;
+    } else {
+	const xmlChar *sgml;
+
+	sgml = xmlCatalogSGMLResolve(catal, NULL, URI);
+	if (sgml != NULL)
+            sgml = xmlStrdup(sgml);
+    }
+    return(ret);
+}
+
+#ifdef LIBXML_OUTPUT_ENABLED
+/**
+ * xmlACatalogDump:
+ * @catal:  a Catalog
+ * @out:  the file.
+ *
+ * Dump the given catalog to the given file.
+ */
+void
+xmlACatalogDump(xmlCatalogPtr catal, FILE *out) {
+    if ((out == NULL) || (catal == NULL))
+	return;
+
+    if (catal->type == XML_XML_CATALOG_TYPE) {
+	xmlDumpXMLCatalog(out, catal->xml);
+    } else {
+	xmlHashScan(catal->sgml,
+		    (xmlHashScanner) xmlCatalogDumpEntry, out);
+    } 
+}
+#endif /* LIBXML_OUTPUT_ENABLED */
+
+/**
+ * xmlACatalogAdd:
+ * @catal:  a Catalog
+ * @type:  the type of record to add to the catalog
+ * @orig:  the system, public or prefix to match 
+ * @replace:  the replacement value for the match
+ *
+ * Add an entry in the catalog, it may overwrite existing but
+ * different entries.
+ *
+ * Returns 0 if successful, -1 otherwise
+ */
+int
+xmlACatalogAdd(xmlCatalogPtr catal, const xmlChar * type,
+              const xmlChar * orig, const xmlChar * replace)
+{
+    int res = -1;
+
+    if (catal == NULL)
+	return(-1);
+
+    if (catal->type == XML_XML_CATALOG_TYPE) {
+        res = xmlAddXMLCatalog(catal->xml, type, orig, replace);
+    } else {
+        xmlCatalogEntryType cattype;
+
+        cattype = xmlGetSGMLCatalogEntryType(type);
+        if (cattype != XML_CATA_NONE) {
+            xmlCatalogEntryPtr entry;
+
+            entry = xmlNewCatalogEntry(cattype, orig, replace, NULL,
+                                       XML_CATA_PREFER_NONE);
+	    if (catal->sgml == NULL)
+		catal->sgml = xmlHashCreate(10);
+            res = xmlHashAddEntry(catal->sgml, orig, entry);
+        }
+    }
+    return (res);
+}
+
+/**
+ * xmlACatalogRemove:
+ * @catal:  a Catalog
+ * @value:  the value to remove
+ *
+ * Remove an entry from the catalog
+ *
+ * Returns the number of entries removed if successful, -1 otherwise
+ */
+int
+xmlACatalogRemove(xmlCatalogPtr catal, const xmlChar *value) {
+    int res = -1;
+
+    if ((catal == NULL) || (value == NULL))
+	return(-1);
+
+    if (catal->type == XML_XML_CATALOG_TYPE) {
+	res = xmlDelXMLCatalog(catal->xml, value);
+    } else {
+	res = xmlHashRemoveEntry(catal->sgml, value,
+		(xmlHashDeallocator) xmlFreeCatalogEntry);
+	if (res == 0)
+	    res = 1;
+    } 
+    return(res);
+}
+
+/**
+ * xmlNewCatalog:
+ * @sgml:  should this create an SGML catalog
+ *
+ * create a new Catalog.
+ *
+ * Returns the xmlCatalogPtr or NULL in case of error
+ */
+xmlCatalogPtr
+xmlNewCatalog(int sgml) {
+    xmlCatalogPtr catal = NULL;
+
+    if (sgml) {
+	catal = xmlCreateNewCatalog(XML_SGML_CATALOG_TYPE,
+		                    xmlCatalogDefaultPrefer);
+        if ((catal != NULL) && (catal->sgml == NULL))
+	    catal->sgml = xmlHashCreate(10);
+    } else
+	catal = xmlCreateNewCatalog(XML_XML_CATALOG_TYPE,
+		                    xmlCatalogDefaultPrefer);
+    return(catal);
+}
+
+/**
+ * xmlCatalogIsEmpty:
+ * @catal:  should this create an SGML catalog
+ *
+ * Check is a catalog is empty
+ *
+ * Returns 1 if the catalog is empty, 0 if not, amd -1 in case of error.
+ */
+int
+xmlCatalogIsEmpty(xmlCatalogPtr catal) {
+    if (catal == NULL)
+	return(-1);
+
+    if (catal->type == XML_XML_CATALOG_TYPE) {
+	if (catal->xml == NULL)
+	    return(1);
+	if ((catal->xml->type != XML_CATA_CATALOG) &&
+	    (catal->xml->type != XML_CATA_BROKEN_CATALOG))
+	    return(-1);
+	if (catal->xml->children == NULL)
+	    return(1);
+        return(0);
+    } else {
+	int res;
+
+	if (catal->sgml == NULL)
+	    return(1);
+	res = xmlHashSize(catal->sgml);
+	if (res == 0)
+	    return(1);
+	if (res < 0)
+	    return(-1);
+    } 
+    return(0);
+}
+
+/************************************************************************
+ *									*
+ *   Public interfaces manipulating the global shared default catalog	*
+ *									*
+ ************************************************************************/
+
+/**
+ * xmlInitializeCatalogData:
+ *
+ * Do the catalog initialization only of global data, doesn't try to load
+ * any catalog actually.
+ * this function is not thread safe, catalog initialization should
+ * preferably be done once at startup
+ */
+static void
+xmlInitializeCatalogData(void) {
+    if (xmlCatalogInitialized != 0)
+	return;
+
+    if (getenv("XML_DEBUG_CATALOG")) 
+	xmlDebugCatalogs = 1;
+    xmlCatalogMutex = xmlNewRMutex();
+
+    xmlCatalogInitialized = 1;
+}
+/**
+ * xmlInitializeCatalog:
+ *
+ * Do the catalog initialization.
+ * this function is not thread safe, catalog initialization should
+ * preferably be done once at startup
+ */
+void
+xmlInitializeCatalog(void) {
+    if (xmlCatalogInitialized != 0)
+	return;
+
+    xmlInitializeCatalogData();
+    xmlRMutexLock(xmlCatalogMutex);
+
+    if (getenv("XML_DEBUG_CATALOG")) 
+	xmlDebugCatalogs = 1;
+
+    if (xmlDefaultCatalog == NULL) {
+	const char *catalogs;
+	char *path;
+	const char *cur, *paths;
+	xmlCatalogPtr catal;
+	xmlCatalogEntryPtr *nextent;
+
+	catalogs = (const char *) getenv("XML_CATALOG_FILES");
+	if (catalogs == NULL)
+	    catalogs = XML_XML_DEFAULT_CATALOG;
+
+	catal = xmlCreateNewCatalog(XML_XML_CATALOG_TYPE, 
+		xmlCatalogDefaultPrefer);
+	if (catal != NULL) {
+	    /* the XML_CATALOG_FILES envvar is allowed to contain a 
+	       space-separated list of entries. */
+	    cur = catalogs;
+	    nextent = &catal->xml;
+	    while (*cur != '\0') {
+		while (xmlIsBlank_ch(*cur)) 
+		    cur++;
+		if (*cur != 0) {
+		    paths = cur;
+		    while ((*cur != 0) && (!xmlIsBlank_ch(*cur)))
+			cur++;
+		    path = (char *) xmlStrndup((const xmlChar *)paths, cur - paths);
+		    if (path != NULL) {
+			*nextent = xmlNewCatalogEntry(XML_CATA_CATALOG, NULL,
+				NULL, BAD_CAST path, xmlCatalogDefaultPrefer);
+			if (*nextent != NULL)
+			    nextent = &((*nextent)->next);
+			xmlFree(path);
+		    }
+		}
+	    }
+	    xmlDefaultCatalog = catal;
+	}
+    }
+
+    xmlRMutexUnlock(xmlCatalogMutex);
+}
+
+
+/**
+ * xmlLoadCatalog:
+ * @filename:  a file path
+ *
+ * Load the catalog and makes its definitions effective for the default
+ * external entity loader. It will recurse in SGML CATALOG entries.
+ * this function is not thread safe, catalog initialization should
+ * preferably be done once at startup
+ *
+ * Returns 0 in case of success -1 in case of error
+ */
+int
+xmlLoadCatalog(const char *filename)
+{
+    int ret;
+    xmlCatalogPtr catal;
+
+    if (!xmlCatalogInitialized)
+	xmlInitializeCatalogData();
+
+    xmlRMutexLock(xmlCatalogMutex);
+
+    if (xmlDefaultCatalog == NULL) {
+	catal = xmlLoadACatalog(filename);
+	if (catal == NULL) {
+	    xmlRMutexUnlock(xmlCatalogMutex);
+	    return(-1);
+	}
+
+	xmlDefaultCatalog = catal;
+	xmlRMutexUnlock(xmlCatalogMutex);
+	return(0);
+    }
+
+    ret = xmlExpandCatalog(xmlDefaultCatalog, filename);
+    xmlRMutexUnlock(xmlCatalogMutex);
+    return(ret);
+}
+
+/**
+ * xmlLoadCatalogs:
+ * @pathss:  a list of directories separated by a colon or a space.
+ *
+ * Load the catalogs and makes their definitions effective for the default
+ * external entity loader.
+ * this function is not thread safe, catalog initialization should
+ * preferably be done once at startup
+ */
+void
+xmlLoadCatalogs(const char *pathss) {
+    const char *cur;
+    const char *paths;
+    xmlChar *path;
+
+    if (pathss == NULL)
+	return;
+
+    cur = pathss;
+    while ((cur != NULL) && (*cur != 0)) {
+	while (xmlIsBlank_ch(*cur)) cur++;
+	if (*cur != 0) {
+	    paths = cur;
+	    while ((*cur != 0) && (*cur != ':') && (!xmlIsBlank_ch(*cur)))
+		cur++;
+	    path = xmlStrndup((const xmlChar *)paths, cur - paths);
+	    if (path != NULL) {
+		xmlLoadCatalog((const char *) path);
+		xmlFree(path);
+	    }
+	}
+	while (*cur == ':')
+	    cur++;
+    }
+}
+
+/**
+ * xmlCatalogCleanup:
+ *
+ * Free up all the memory associated with catalogs
+ */
+void
+xmlCatalogCleanup(void) {
+    if (xmlCatalogInitialized == 0)
+        return;
+
+    xmlRMutexLock(xmlCatalogMutex);
+    if (xmlDebugCatalogs)
+	xmlGenericError(xmlGenericErrorContext,
+		"Catalogs cleanup\n");
+    if (xmlCatalogXMLFiles != NULL)
+	xmlHashFree(xmlCatalogXMLFiles, 
+		    (xmlHashDeallocator)xmlFreeCatalogHashEntryList);
+    xmlCatalogXMLFiles = NULL;
+    if (xmlDefaultCatalog != NULL)
+	xmlFreeCatalog(xmlDefaultCatalog);
+    xmlDefaultCatalog = NULL;
+    xmlDebugCatalogs = 0;
+    xmlCatalogInitialized = 0;
+    xmlRMutexUnlock(xmlCatalogMutex);
+    xmlFreeRMutex(xmlCatalogMutex);
+}
+
+/**
+ * xmlCatalogResolveSystem:
+ * @sysID:  the system ID string
+ *
+ * Try to lookup the catalog resource for a system ID
+ *
+ * Returns the resource if found or NULL otherwise, the value returned
+ *      must be freed by the caller.
+ */
+xmlChar *
+xmlCatalogResolveSystem(const xmlChar *sysID) {
+    xmlChar *ret;
+
+    if (!xmlCatalogInitialized)
+	xmlInitializeCatalog();
+
+    ret = xmlACatalogResolveSystem(xmlDefaultCatalog, sysID);
+    return(ret);
+}
+
+/**
+ * xmlCatalogResolvePublic:
+ * @pubID:  the public ID string
+ *
+ * Try to lookup the catalog reference associated to a public ID
+ *
+ * Returns the resource if found or NULL otherwise, the value returned
+ *      must be freed by the caller.
+ */
+xmlChar *
+xmlCatalogResolvePublic(const xmlChar *pubID) {
+    xmlChar *ret;
+
+    if (!xmlCatalogInitialized)
+	xmlInitializeCatalog();
+
+    ret = xmlACatalogResolvePublic(xmlDefaultCatalog, pubID);
+    return(ret);
+}
+
+/**
+ * xmlCatalogResolve:
+ * @pubID:  the public ID string
+ * @sysID:  the system ID string
+ *
+ * Do a complete resolution lookup of an External Identifier
+ *
+ * Returns the URI of the resource or NULL if not found, it must be freed
+ *      by the caller.
+ */
+xmlChar *
+xmlCatalogResolve(const xmlChar *pubID, const xmlChar *sysID) {
+    xmlChar *ret;
+
+    if (!xmlCatalogInitialized)
+	xmlInitializeCatalog();
+
+    ret = xmlACatalogResolve(xmlDefaultCatalog, pubID, sysID);
+    return(ret);
+}
+
+/**
+ * xmlCatalogResolveURI:
+ * @URI:  the URI
+ *
+ * Do a complete resolution lookup of an URI
+ *
+ * Returns the URI of the resource or NULL if not found, it must be freed
+ *      by the caller.
+ */
+xmlChar *
+xmlCatalogResolveURI(const xmlChar *URI) {
+    xmlChar *ret;
+
+    if (!xmlCatalogInitialized)
+	xmlInitializeCatalog();
+
+    ret = xmlACatalogResolveURI(xmlDefaultCatalog, URI);
+    return(ret);
+}
+
+#ifdef LIBXML_OUTPUT_ENABLED
+/**
+ * xmlCatalogDump:
+ * @out:  the file.
+ *
+ * Dump all the global catalog content to the given file.
+ */
+void
+xmlCatalogDump(FILE *out) {
+    if (out == NULL)
+	return;
+
+    if (!xmlCatalogInitialized)
+	xmlInitializeCatalog();
+
+    xmlACatalogDump(xmlDefaultCatalog, out);
+}
+#endif /* LIBXML_OUTPUT_ENABLED */
+
+/**
+ * xmlCatalogAdd:
+ * @type:  the type of record to add to the catalog
+ * @orig:  the system, public or prefix to match 
+ * @replace:  the replacement value for the match
+ *
+ * Add an entry in the catalog, it may overwrite existing but
+ * different entries.
+ * If called before any other catalog routine, allows to override the
+ * default shared catalog put in place by xmlInitializeCatalog();
+ *
+ * Returns 0 if successful, -1 otherwise
+ */
+int
+xmlCatalogAdd(const xmlChar *type, const xmlChar *orig, const xmlChar *replace) {
+    int res = -1;
+
+    if (!xmlCatalogInitialized)
+	xmlInitializeCatalogData();
+
+    xmlRMutexLock(xmlCatalogMutex);
+    /*
+     * Specific case where one want to override the default catalog
+     * put in place by xmlInitializeCatalog();
+     */
+    if ((xmlDefaultCatalog == NULL) &&
+	(xmlStrEqual(type, BAD_CAST "catalog"))) {
+	xmlDefaultCatalog = xmlCreateNewCatalog(XML_XML_CATALOG_TYPE,
+		                          xmlCatalogDefaultPrefer);
+	xmlDefaultCatalog->xml = xmlNewCatalogEntry(XML_CATA_CATALOG, NULL,
+				    orig, NULL,  xmlCatalogDefaultPrefer);
+
+	xmlRMutexUnlock(xmlCatalogMutex);
+	return(0);
+    } 
+
+    res = xmlACatalogAdd(xmlDefaultCatalog, type, orig, replace);
+    xmlRMutexUnlock(xmlCatalogMutex);
+    return(res);
+}
+
+/**
+ * xmlCatalogRemove:
+ * @value:  the value to remove
+ *
+ * Remove an entry from the catalog
+ *
+ * Returns the number of entries removed if successful, -1 otherwise
+ */
+int
+xmlCatalogRemove(const xmlChar *value) {
+    int res;
+
+    if (!xmlCatalogInitialized)
+	xmlInitializeCatalog();
+
+    xmlRMutexLock(xmlCatalogMutex);
+    res = xmlACatalogRemove(xmlDefaultCatalog, value);
+    xmlRMutexUnlock(xmlCatalogMutex);
+    return(res);
+}
+
+/**
+ * xmlCatalogConvert:
+ *
+ * Convert all the SGML catalog entries as XML ones
+ *
+ * Returns the number of entries converted if successful, -1 otherwise
+ */
+int
+xmlCatalogConvert(void) {
+    int res = -1;
+
+    if (!xmlCatalogInitialized)
+	xmlInitializeCatalog();
+
+    xmlRMutexLock(xmlCatalogMutex);
+    res = xmlConvertSGMLCatalog(xmlDefaultCatalog);
+    xmlRMutexUnlock(xmlCatalogMutex);
+    return(res);
+}
+
+/************************************************************************
+ *									*
+ *	Public interface manipulating the common preferences		*
+ *									*
+ ************************************************************************/
+
+/**
+ * xmlCatalogGetDefaults:
+ *
+ * Used to get the user preference w.r.t. to what catalogs should
+ * be accepted
+ *
+ * Returns the current xmlCatalogAllow value
+ */
+xmlCatalogAllow
+xmlCatalogGetDefaults(void) {
+    return(xmlCatalogDefaultAllow);
+}
+
+/**
+ * xmlCatalogSetDefaults:
+ * @allow:  what catalogs should be accepted
+ *
+ * Used to set the user preference w.r.t. to what catalogs should
+ * be accepted
+ */
+void
+xmlCatalogSetDefaults(xmlCatalogAllow allow) {
+    if (xmlDebugCatalogs) {
+	switch (allow) {
+	    case XML_CATA_ALLOW_NONE:
+		xmlGenericError(xmlGenericErrorContext,
+			"Disabling catalog usage\n");
+		break;
+	    case XML_CATA_ALLOW_GLOBAL:
+		xmlGenericError(xmlGenericErrorContext,
+			"Allowing only global catalogs\n");
+		break;
+	    case XML_CATA_ALLOW_DOCUMENT:
+		xmlGenericError(xmlGenericErrorContext,
+			"Allowing only catalogs from the document\n");
+		break;
+	    case XML_CATA_ALLOW_ALL:
+		xmlGenericError(xmlGenericErrorContext,
+			"Allowing all catalogs\n");
+		break;
+	}
+    }
+    xmlCatalogDefaultAllow = allow;
+}
+
+/**
+ * xmlCatalogSetDefaultPrefer:
+ * @prefer:  the default preference for delegation
+ *
+ * Allows to set the preference between public and system for deletion
+ * in XML Catalog resolution. C.f. section 4.1.1 of the spec
+ * Values accepted are XML_CATA_PREFER_PUBLIC or XML_CATA_PREFER_SYSTEM
+ *
+ * Returns the previous value of the default preference for delegation
+ */
+xmlCatalogPrefer
+xmlCatalogSetDefaultPrefer(xmlCatalogPrefer prefer) {
+    xmlCatalogPrefer ret = xmlCatalogDefaultPrefer;
+
+    if (prefer == XML_CATA_PREFER_NONE)
+	return(ret);
+
+    if (xmlDebugCatalogs) {
+	switch (prefer) {
+	    case XML_CATA_PREFER_PUBLIC:
+		xmlGenericError(xmlGenericErrorContext,
+			"Setting catalog preference to PUBLIC\n");
+		break;
+	    case XML_CATA_PREFER_SYSTEM:
+		xmlGenericError(xmlGenericErrorContext,
+			"Setting catalog preference to SYSTEM\n");
+		break;
+	    case XML_CATA_PREFER_NONE:
+		break;
+	}
+    }
+    xmlCatalogDefaultPrefer = prefer;
+    return(ret);
+}
+
+/**
+ * xmlCatalogSetDebug:
+ * @level:  the debug level of catalogs required
+ *
+ * Used to set the debug level for catalog operation, 0 disable
+ * debugging, 1 enable it
+ *
+ * Returns the previous value of the catalog debugging level
+ */
+int
+xmlCatalogSetDebug(int level) {
+    int ret = xmlDebugCatalogs;
+
+    if (level <= 0)
+        xmlDebugCatalogs = 0;
+    else
+	xmlDebugCatalogs = level;
+    return(ret);
+}
+
+/************************************************************************
+ *									*
+ *   Minimal interfaces used for per-document catalogs by the parser	*
+ *									*
+ ************************************************************************/
+
+/**
+ * xmlCatalogFreeLocal:
+ * @catalogs:  a document's list of catalogs
+ *
+ * Free up the memory associated to the catalog list
+ */
+void
+xmlCatalogFreeLocal(void *catalogs) {
+    xmlCatalogEntryPtr catal;
+
+    if (!xmlCatalogInitialized)
+	xmlInitializeCatalog();
+
+    catal = (xmlCatalogEntryPtr) catalogs;
+    if (catal != NULL)
+	xmlFreeCatalogEntryList(catal);
+}
+
+
+/**
+ * xmlCatalogAddLocal:
+ * @catalogs:  a document's list of catalogs
+ * @URL:  the URL to a new local catalog
+ *
+ * Add the new entry to the catalog list
+ *
+ * Returns the updated list
+ */
+void *	
+xmlCatalogAddLocal(void *catalogs, const xmlChar *URL) {
+    xmlCatalogEntryPtr catal, add;
+
+    if (!xmlCatalogInitialized)
+	xmlInitializeCatalog();
+
+    if (URL == NULL)
+	return(catalogs);
+
+    if (xmlDebugCatalogs)
+	xmlGenericError(xmlGenericErrorContext,
+		"Adding document catalog %s\n", URL);
+
+    add = xmlNewCatalogEntry(XML_CATA_CATALOG, NULL, URL, NULL,
+	                     xmlCatalogDefaultPrefer);
+    if (add == NULL)
+	return(catalogs);
+
+    catal = (xmlCatalogEntryPtr) catalogs;
+    if (catal == NULL) 
+	return((void *) add);
+
+    while (catal->next != NULL)
+	catal = catal->next;
+    catal->next = add;
+    return(catalogs);
+}
+
+/**
+ * xmlCatalogLocalResolve:
+ * @catalogs:  a document's list of catalogs
+ * @pubID:  the public ID string
+ * @sysID:  the system ID string
+ *
+ * Do a complete resolution lookup of an External Identifier using a 
+ * document's private catalog list
+ *
+ * Returns the URI of the resource or NULL if not found, it must be freed
+ *      by the caller.
+ */
+xmlChar *
+xmlCatalogLocalResolve(void *catalogs, const xmlChar *pubID,
+	               const xmlChar *sysID) {
+    xmlCatalogEntryPtr catal;
+    xmlChar *ret;
+
+    if (!xmlCatalogInitialized)
+	xmlInitializeCatalog();
+
+    if ((pubID == NULL) && (sysID == NULL))
+	return(NULL);
+
+    if (xmlDebugCatalogs) {
+        if ((pubID != NULL) && (sysID != NULL)) {
+            xmlGenericError(xmlGenericErrorContext,
+                            "Local Resolve: pubID %s sysID %s\n", pubID, sysID);
+        } else if (pubID != NULL) {
+            xmlGenericError(xmlGenericErrorContext,
+                            "Local Resolve: pubID %s\n", pubID);
+        } else {
+            xmlGenericError(xmlGenericErrorContext,
+                            "Local Resolve: sysID %s\n", sysID);
+        }
+    }
+
+    catal = (xmlCatalogEntryPtr) catalogs;
+    if (catal == NULL)
+	return(NULL);
+    ret = xmlCatalogListXMLResolve(catal, pubID, sysID);
+    if ((ret != NULL) && (ret != XML_CATAL_BREAK))
+	return(ret);
+    return(NULL);
+}
+
+/**
+ * xmlCatalogLocalResolveURI:
+ * @catalogs:  a document's list of catalogs
+ * @URI:  the URI
+ *
+ * Do a complete resolution lookup of an URI using a 
+ * document's private catalog list
+ *
+ * Returns the URI of the resource or NULL if not found, it must be freed
+ *      by the caller.
+ */
+xmlChar *
+xmlCatalogLocalResolveURI(void *catalogs, const xmlChar *URI) {
+    xmlCatalogEntryPtr catal;
+    xmlChar *ret;
+
+    if (!xmlCatalogInitialized)
+	xmlInitializeCatalog();
+
+    if (URI == NULL)
+	return(NULL);
+
+    if (xmlDebugCatalogs)
+	xmlGenericError(xmlGenericErrorContext,
+		"Resolve URI %s\n", URI);
+
+    catal = (xmlCatalogEntryPtr) catalogs;
+    if (catal == NULL)
+	return(NULL);
+    ret = xmlCatalogListXMLResolveURI(catal, URI);
+    if ((ret != NULL) && (ret != XML_CATAL_BREAK))
+	return(ret);
+    return(NULL);
+}
+
+/************************************************************************
+ *									*
+ *			Deprecated interfaces				*
+ *									*
+ ************************************************************************/
+/**
+ * xmlCatalogGetSystem:
+ * @sysID:  the system ID string
+ *
+ * Try to lookup the catalog reference associated to a system ID
+ * DEPRECATED, use xmlCatalogResolveSystem()
+ *
+ * Returns the resource if found or NULL otherwise.
+ */
+const xmlChar *
+xmlCatalogGetSystem(const xmlChar *sysID) {
+    xmlChar *ret;
+    static xmlChar result[1000];
+    static int msg = 0;
+
+    if (!xmlCatalogInitialized)
+	xmlInitializeCatalog();
+
+    if (msg == 0) {
+	xmlGenericError(xmlGenericErrorContext,
+		"Use of deprecated xmlCatalogGetSystem() call\n");
+	msg++;
+    }
+
+    if (sysID == NULL)
+	return(NULL);
+    
+    /*
+     * Check first the XML catalogs
+     */
+    if (xmlDefaultCatalog != NULL) {
+	ret = xmlCatalogListXMLResolve(xmlDefaultCatalog->xml, NULL, sysID);
+	if ((ret != NULL) && (ret != XML_CATAL_BREAK)) {
+	    snprintf((char *) result, sizeof(result) - 1, "%s", (char *) ret);
+	    result[sizeof(result) - 1] = 0;
+	    return(result);
+	}
+    }
+
+    if (xmlDefaultCatalog != NULL)
+	return(xmlCatalogGetSGMLSystem(xmlDefaultCatalog->sgml, sysID));
+    return(NULL);
+}
+
+/**
+ * xmlCatalogGetPublic:
+ * @pubID:  the public ID string
+ *
+ * Try to lookup the catalog reference associated to a public ID
+ * DEPRECATED, use xmlCatalogResolvePublic()
+ *
+ * Returns the resource if found or NULL otherwise.
+ */
+const xmlChar *
+xmlCatalogGetPublic(const xmlChar *pubID) {
+    xmlChar *ret;
+    static xmlChar result[1000];
+    static int msg = 0;
+
+    if (!xmlCatalogInitialized)
+	xmlInitializeCatalog();
+
+    if (msg == 0) {
+	xmlGenericError(xmlGenericErrorContext,
+		"Use of deprecated xmlCatalogGetPublic() call\n");
+	msg++;
+    }
+
+    if (pubID == NULL)
+	return(NULL);
+    
+    /*
+     * Check first the XML catalogs
+     */
+    if (xmlDefaultCatalog != NULL) {
+	ret = xmlCatalogListXMLResolve(xmlDefaultCatalog->xml, pubID, NULL);
+	if ((ret != NULL) && (ret != XML_CATAL_BREAK)) {
+	    snprintf((char *) result, sizeof(result) - 1, "%s", (char *) ret);
+	    result[sizeof(result) - 1] = 0;
+	    return(result);
+	}
+    }
+
+    if (xmlDefaultCatalog != NULL)
+	return(xmlCatalogGetSGMLPublic(xmlDefaultCatalog->sgml, pubID));
+    return(NULL);
+}
+
+#endif /* LIBXML_CATALOG_ENABLED */
diff --git a/src/libxml/src/chvalid.c b/src/libxml/src/chvalid.c
new file mode 100644
index 0000000..d47bc6a
--- /dev/null
+++ b/src/libxml/src/chvalid.c
@@ -0,0 +1,329 @@
+/*
+ * chvalid.c:	this module implements the character range
+ *		validation APIs
+ *
+ * This file is automatically generated from the cvs source
+ * definition files using the genChRanges.py Python script
+ *
+ * Generation date: Tue Nov 18 08:14:21 2003
+ * Sources: chvalid.def
+ * William Brack <wbrack@mmm.com.hk>
+ */
+
+#define IN_LIBXML
+#include "libxml.h"
+#include <libxml/chvalid.h>
+
+/*
+ * The initial tables ({func_name}_tab) are used to validate whether a
+ * single-byte character is within the specified group.  Each table
+ * contains 256 bytes, with each byte representing one of the 256
+ * possible characters.  If the table byte is set, the character is
+ * allowed.
+ *
+ */
+unsigned char xmlIsPubidChar_tab[256] = {
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x01,
+    0x01, 0x01, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+    0x00, 0x01, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+    0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00 };
+
+static xmlChSRange xmlIsBaseChar_srng[] = { {0x100, 0x131}, {0x134, 0x13e}, 
+    {0x141, 0x148}, {0x14a, 0x17e}, {0x180, 0x1c3}, {0x1cd, 0x1f0}, 
+    {0x1f4, 0x1f5}, {0x1fa, 0x217}, {0x250, 0x2a8}, {0x2bb, 0x2c1}, 
+    {0x386, 0x386}, {0x388, 0x38a}, {0x38c, 0x38c}, {0x38e, 0x3a1}, 
+    {0x3a3, 0x3ce}, {0x3d0, 0x3d6}, {0x3da, 0x3da}, {0x3dc, 0x3dc}, 
+    {0x3de, 0x3de}, {0x3e0, 0x3e0}, {0x3e2, 0x3f3}, {0x401, 0x40c}, 
+    {0x40e, 0x44f}, {0x451, 0x45c}, {0x45e, 0x481}, {0x490, 0x4c4}, 
+    {0x4c7, 0x4c8}, {0x4cb, 0x4cc}, {0x4d0, 0x4eb}, {0x4ee, 0x4f5}, 
+    {0x4f8, 0x4f9}, {0x531, 0x556}, {0x559, 0x559}, {0x561, 0x586}, 
+    {0x5d0, 0x5ea}, {0x5f0, 0x5f2}, {0x621, 0x63a}, {0x641, 0x64a}, 
+    {0x671, 0x6b7}, {0x6ba, 0x6be}, {0x6c0, 0x6ce}, {0x6d0, 0x6d3}, 
+    {0x6d5, 0x6d5}, {0x6e5, 0x6e6}, {0x905, 0x939}, {0x93d, 0x93d}, 
+    {0x958, 0x961}, {0x985, 0x98c}, {0x98f, 0x990}, {0x993, 0x9a8}, 
+    {0x9aa, 0x9b0}, {0x9b2, 0x9b2}, {0x9b6, 0x9b9}, {0x9dc, 0x9dd}, 
+    {0x9df, 0x9e1}, {0x9f0, 0x9f1}, {0xa05, 0xa0a}, {0xa0f, 0xa10}, 
+    {0xa13, 0xa28}, {0xa2a, 0xa30}, {0xa32, 0xa33}, {0xa35, 0xa36}, 
+    {0xa38, 0xa39}, {0xa59, 0xa5c}, {0xa5e, 0xa5e}, {0xa72, 0xa74}, 
+    {0xa85, 0xa8b}, {0xa8d, 0xa8d}, {0xa8f, 0xa91}, {0xa93, 0xaa8}, 
+    {0xaaa, 0xab0}, {0xab2, 0xab3}, {0xab5, 0xab9}, {0xabd, 0xabd}, 
+    {0xae0, 0xae0}, {0xb05, 0xb0c}, {0xb0f, 0xb10}, {0xb13, 0xb28}, 
+    {0xb2a, 0xb30}, {0xb32, 0xb33}, {0xb36, 0xb39}, {0xb3d, 0xb3d}, 
+    {0xb5c, 0xb5d}, {0xb5f, 0xb61}, {0xb85, 0xb8a}, {0xb8e, 0xb90}, 
+    {0xb92, 0xb95}, {0xb99, 0xb9a}, {0xb9c, 0xb9c}, {0xb9e, 0xb9f}, 
+    {0xba3, 0xba4}, {0xba8, 0xbaa}, {0xbae, 0xbb5}, {0xbb7, 0xbb9}, 
+    {0xc05, 0xc0c}, {0xc0e, 0xc10}, {0xc12, 0xc28}, {0xc2a, 0xc33}, 
+    {0xc35, 0xc39}, {0xc60, 0xc61}, {0xc85, 0xc8c}, {0xc8e, 0xc90}, 
+    {0xc92, 0xca8}, {0xcaa, 0xcb3}, {0xcb5, 0xcb9}, {0xcde, 0xcde}, 
+    {0xce0, 0xce1}, {0xd05, 0xd0c}, {0xd0e, 0xd10}, {0xd12, 0xd28}, 
+    {0xd2a, 0xd39}, {0xd60, 0xd61}, {0xe01, 0xe2e}, {0xe30, 0xe30}, 
+    {0xe32, 0xe33}, {0xe40, 0xe45}, {0xe81, 0xe82}, {0xe84, 0xe84}, 
+    {0xe87, 0xe88}, {0xe8a, 0xe8a}, {0xe8d, 0xe8d}, {0xe94, 0xe97}, 
+    {0xe99, 0xe9f}, {0xea1, 0xea3}, {0xea5, 0xea5}, {0xea7, 0xea7}, 
+    {0xeaa, 0xeab}, {0xead, 0xeae}, {0xeb0, 0xeb0}, {0xeb2, 0xeb3}, 
+    {0xebd, 0xebd}, {0xec0, 0xec4}, {0xf40, 0xf47}, {0xf49, 0xf69}, 
+    {0x10a0, 0x10c5}, {0x10d0, 0x10f6}, {0x1100, 0x1100}, {0x1102, 0x1103}, 
+    {0x1105, 0x1107}, {0x1109, 0x1109}, {0x110b, 0x110c}, {0x110e, 0x1112}, 
+    {0x113c, 0x113c}, {0x113e, 0x113e}, {0x1140, 0x1140}, {0x114c, 0x114c}, 
+    {0x114e, 0x114e}, {0x1150, 0x1150}, {0x1154, 0x1155}, {0x1159, 0x1159}, 
+    {0x115f, 0x1161}, {0x1163, 0x1163}, {0x1165, 0x1165}, {0x1167, 0x1167}, 
+    {0x1169, 0x1169}, {0x116d, 0x116e}, {0x1172, 0x1173}, {0x1175, 0x1175}, 
+    {0x119e, 0x119e}, {0x11a8, 0x11a8}, {0x11ab, 0x11ab}, {0x11ae, 0x11af}, 
+    {0x11b7, 0x11b8}, {0x11ba, 0x11ba}, {0x11bc, 0x11c2}, {0x11eb, 0x11eb}, 
+    {0x11f0, 0x11f0}, {0x11f9, 0x11f9}, {0x1e00, 0x1e9b}, {0x1ea0, 0x1ef9}, 
+    {0x1f00, 0x1f15}, {0x1f18, 0x1f1d}, {0x1f20, 0x1f45}, {0x1f48, 0x1f4d}, 
+    {0x1f50, 0x1f57}, {0x1f59, 0x1f59}, {0x1f5b, 0x1f5b}, {0x1f5d, 0x1f5d}, 
+    {0x1f5f, 0x1f7d}, {0x1f80, 0x1fb4}, {0x1fb6, 0x1fbc}, {0x1fbe, 0x1fbe}, 
+    {0x1fc2, 0x1fc4}, {0x1fc6, 0x1fcc}, {0x1fd0, 0x1fd3}, {0x1fd6, 0x1fdb}, 
+    {0x1fe0, 0x1fec}, {0x1ff2, 0x1ff4}, {0x1ff6, 0x1ffc}, {0x2126, 0x2126}, 
+    {0x212a, 0x212b}, {0x212e, 0x212e}, {0x2180, 0x2182}, {0x3041, 0x3094}, 
+    {0x30a1, 0x30fa}, {0x3105, 0x312c}, {0xac00, 0xd7a3}};
+xmlChRangeGroup xmlIsBaseCharGroup =
+	{197, 0, xmlIsBaseChar_srng, (xmlChLRangePtr)0};
+
+static xmlChSRange xmlIsChar_srng[] = { {0x100, 0xd7ff}, {0xe000, 0xfffd}};
+static xmlChLRange xmlIsChar_lrng[] = { {0x10000, 0x10ffff}};
+xmlChRangeGroup xmlIsCharGroup =
+	{2, 1, xmlIsChar_srng, xmlIsChar_lrng};
+
+static xmlChSRange xmlIsCombining_srng[] = { {0x300, 0x345}, 
+    {0x360, 0x361}, {0x483, 0x486}, {0x591, 0x5a1}, {0x5a3, 0x5b9}, 
+    {0x5bb, 0x5bd}, {0x5bf, 0x5bf}, {0x5c1, 0x5c2}, {0x5c4, 0x5c4}, 
+    {0x64b, 0x652}, {0x670, 0x670}, {0x6d6, 0x6dc}, {0x6dd, 0x6df}, 
+    {0x6e0, 0x6e4}, {0x6e7, 0x6e8}, {0x6ea, 0x6ed}, {0x901, 0x903}, 
+    {0x93c, 0x93c}, {0x93e, 0x94c}, {0x94d, 0x94d}, {0x951, 0x954}, 
+    {0x962, 0x963}, {0x981, 0x983}, {0x9bc, 0x9bc}, {0x9be, 0x9be}, 
+    {0x9bf, 0x9bf}, {0x9c0, 0x9c4}, {0x9c7, 0x9c8}, {0x9cb, 0x9cd}, 
+    {0x9d7, 0x9d7}, {0x9e2, 0x9e3}, {0xa02, 0xa02}, {0xa3c, 0xa3c}, 
+    {0xa3e, 0xa3e}, {0xa3f, 0xa3f}, {0xa40, 0xa42}, {0xa47, 0xa48}, 
+    {0xa4b, 0xa4d}, {0xa70, 0xa71}, {0xa81, 0xa83}, {0xabc, 0xabc}, 
+    {0xabe, 0xac5}, {0xac7, 0xac9}, {0xacb, 0xacd}, {0xb01, 0xb03}, 
+    {0xb3c, 0xb3c}, {0xb3e, 0xb43}, {0xb47, 0xb48}, {0xb4b, 0xb4d}, 
+    {0xb56, 0xb57}, {0xb82, 0xb83}, {0xbbe, 0xbc2}, {0xbc6, 0xbc8}, 
+    {0xbca, 0xbcd}, {0xbd7, 0xbd7}, {0xc01, 0xc03}, {0xc3e, 0xc44}, 
+    {0xc46, 0xc48}, {0xc4a, 0xc4d}, {0xc55, 0xc56}, {0xc82, 0xc83}, 
+    {0xcbe, 0xcc4}, {0xcc6, 0xcc8}, {0xcca, 0xccd}, {0xcd5, 0xcd6}, 
+    {0xd02, 0xd03}, {0xd3e, 0xd43}, {0xd46, 0xd48}, {0xd4a, 0xd4d}, 
+    {0xd57, 0xd57}, {0xe31, 0xe31}, {0xe34, 0xe3a}, {0xe47, 0xe4e}, 
+    {0xeb1, 0xeb1}, {0xeb4, 0xeb9}, {0xebb, 0xebc}, {0xec8, 0xecd}, 
+    {0xf18, 0xf19}, {0xf35, 0xf35}, {0xf37, 0xf37}, {0xf39, 0xf39}, 
+    {0xf3e, 0xf3e}, {0xf3f, 0xf3f}, {0xf71, 0xf84}, {0xf86, 0xf8b}, 
+    {0xf90, 0xf95}, {0xf97, 0xf97}, {0xf99, 0xfad}, {0xfb1, 0xfb7}, 
+    {0xfb9, 0xfb9}, {0x20d0, 0x20dc}, {0x20e1, 0x20e1}, {0x302a, 0x302f}, 
+    {0x3099, 0x3099}, {0x309a, 0x309a}};
+xmlChRangeGroup xmlIsCombiningGroup =
+	{95, 0, xmlIsCombining_srng, (xmlChLRangePtr)0};
+
+static xmlChSRange xmlIsDigit_srng[] = { {0x660, 0x669}, {0x6f0, 0x6f9}, 
+    {0x966, 0x96f}, {0x9e6, 0x9ef}, {0xa66, 0xa6f}, {0xae6, 0xaef}, 
+    {0xb66, 0xb6f}, {0xbe7, 0xbef}, {0xc66, 0xc6f}, {0xce6, 0xcef}, 
+    {0xd66, 0xd6f}, {0xe50, 0xe59}, {0xed0, 0xed9}, {0xf20, 0xf29}};
+xmlChRangeGroup xmlIsDigitGroup =
+	{14, 0, xmlIsDigit_srng, (xmlChLRangePtr)0};
+
+static xmlChSRange xmlIsExtender_srng[] = { {0x2d0, 0x2d0}, {0x2d1, 0x2d1}, 
+    {0x387, 0x387}, {0x640, 0x640}, {0xe46, 0xe46}, {0xec6, 0xec6}, 
+    {0x3005, 0x3005}, {0x3031, 0x3035}, {0x309d, 0x309e}, {0x30fc, 0x30fe}};
+xmlChRangeGroup xmlIsExtenderGroup =
+	{10, 0, xmlIsExtender_srng, (xmlChLRangePtr)0};
+
+static xmlChSRange xmlIsIdeographic_srng[] = { {0x3007, 0x3007}, 
+    {0x3021, 0x3029}, {0x4e00, 0x9fa5}};
+xmlChRangeGroup xmlIsIdeographicGroup =
+	{3, 0, xmlIsIdeographic_srng, (xmlChLRangePtr)0};
+
+
+/**
+ * xmlCharInRange:
+ * @val: character to be validated
+ * @rptr: pointer to range to be used to validate
+ *
+ * Does a binary search of the range table to determine if char
+ * is valid
+ *
+ * Returns: true if character valid, false otherwise
+ */
+int
+xmlCharInRange (unsigned int val, const xmlChRangeGroupPtr rptr) {
+    int low, high, mid;
+    xmlChSRangePtr sptr;
+    xmlChLRangePtr lptr;
+    if (val < 0x10000) {	/* is val in 'short' or 'long'  array? */
+	if (rptr->nbShortRange == 0)
+	    return 0;
+	low = 0;
+	high = rptr->nbShortRange - 1;
+	sptr = rptr->shortRange;
+	while (low <= high) {
+	    mid = (low + high) / 2;
+	    if ((unsigned short) val < sptr[mid].low) {
+		high = mid - 1;
+	    } else {
+	        if ((unsigned short) val > sptr[mid].high) {
+		    low = mid + 1;
+		} else {
+		    return 1;
+		}
+	    }
+	}
+    } else {
+	if (rptr->nbLongRange == 0) {
+	    return 0;
+	}
+	low = 0;
+	high = rptr->nbLongRange - 1;
+	lptr = rptr->longRange;
+	while (low <= high) {
+	    mid = (low + high) / 2;
+	    if (val < lptr[mid].low) {
+		high = mid - 1;
+	    } else {
+	        if (val > lptr[mid].high) {
+		    low = mid + 1;
+		} else {
+		    return 1;
+		}
+	    }
+	}
+    }
+    return 0;
+}
+
+
+/**
+ * xmlIsBaseChar:
+ * @ch:  character to validate
+ *
+ * This function is DEPRECATED.
+ * Use xmlIsBaseChar_ch or xmlIsBaseCharQ instead
+ *
+ * Returns true if argument valid, false otherwise
+ */
+int
+xmlIsBaseChar(unsigned int ch) {
+    return(xmlIsBaseCharQ(ch));
+}
+
+
+/**
+ * xmlIsBlank:
+ * @ch:  character to validate
+ *
+ * This function is DEPRECATED.
+ * Use xmlIsBlank_ch or xmlIsBlankQ instead
+ *
+ * Returns true if argument valid, false otherwise
+ */
+int
+xmlIsBlank(unsigned int ch) {
+    return(xmlIsBlankQ(ch));
+}
+
+
+/**
+ * xmlIsChar:
+ * @ch:  character to validate
+ *
+ * This function is DEPRECATED.
+ * Use xmlIsChar_ch or xmlIsCharQ instead
+ *
+ * Returns true if argument valid, false otherwise
+ */
+int
+xmlIsChar(unsigned int ch) {
+    return(xmlIsCharQ(ch));
+}
+
+
+/**
+ * xmlIsCombining:
+ * @ch:  character to validate
+ *
+ * This function is DEPRECATED.
+ * Use xmlIsCombiningQ instead
+ *
+ * Returns true if argument valid, false otherwise
+ */
+int
+xmlIsCombining(unsigned int ch) {
+    return(xmlIsCombiningQ(ch));
+}
+
+
+/**
+ * xmlIsDigit:
+ * @ch:  character to validate
+ *
+ * This function is DEPRECATED.
+ * Use xmlIsDigit_ch or xmlIsDigitQ instead
+ *
+ * Returns true if argument valid, false otherwise
+ */
+int
+xmlIsDigit(unsigned int ch) {
+    return(xmlIsDigitQ(ch));
+}
+
+
+/**
+ * xmlIsExtender:
+ * @ch:  character to validate
+ *
+ * This function is DEPRECATED.
+ * Use xmlIsExtender_ch or xmlIsExtenderQ instead
+ *
+ * Returns true if argument valid, false otherwise
+ */
+int
+xmlIsExtender(unsigned int ch) {
+    return(xmlIsExtenderQ(ch));
+}
+
+
+/**
+ * xmlIsIdeographic:
+ * @ch:  character to validate
+ *
+ * This function is DEPRECATED.
+ * Use xmlIsIdeographicQ instead
+ *
+ * Returns true if argument valid, false otherwise
+ */
+int
+xmlIsIdeographic(unsigned int ch) {
+    return(xmlIsIdeographicQ(ch));
+}
+
+
+/**
+ * xmlIsPubidChar:
+ * @ch:  character to validate
+ *
+ * This function is DEPRECATED.
+ * Use xmlIsPubidChar_ch or xmlIsPubidCharQ instead
+ *
+ * Returns true if argument valid, false otherwise
+ */
+int
+xmlIsPubidChar(unsigned int ch) {
+    return(xmlIsPubidCharQ(ch));
+}
+
diff --git a/src/libxml/src/config.h b/src/libxml/src/config.h
new file mode 100644
index 0000000..c530c3c
--- /dev/null
+++ b/src/libxml/src/config.h
@@ -0,0 +1,285 @@
+/* config.h.  Generated by configure.  */
+/* config.h.in.  Generated from configure.in by autoheader.  */
+#define PACKAGE "libxml2"
+#define VERSION "2.6.9"
+#define HAVE_LIBZ 
+/* #undef HAVE_LIBM */
+/* #undef HAVE_ISINF */
+#define HAVE_ISNAN 
+#define HAVE_LIBHISTORY 
+#define HAVE_LIBREADLINE 
+#define SOCKLEN_T int
+#define HAVE_LIBPTHREAD 
+#define HAVE_PTHREAD_H 
+
+/* Define if IPV6 support is there */
+/* #undef SUPPORT_IP6 */
+
+/* Define if getaddrinfo is there */
+/* #undef HAVE_GETADDRINFO */
+
+/* Define to 1 if you have the <ansidecl.h> header file. */
+/* #undef HAVE_ANSIDECL_H */
+
+/* Define to 1 if you have the <arpa/inet.h> header file. */
+#define HAVE_ARPA_INET_H 1
+
+/* Define to 1 if you have the <arpa/nameser.h> header file. */
+#define HAVE_ARPA_NAMESER_H 1
+
+/* Define to 1 if you have the `class' function. */
+/* #undef HAVE_CLASS */
+
+/* Define to 1 if you have the <ctype.h> header file. */
+#define HAVE_CTYPE_H 1
+
+/* Define to 1 if you have the <dirent.h> header file. */
+#define HAVE_DIRENT_H 1
+
+/* Define to 1 if you have the <dlfcn.h> header file. */
+#define HAVE_DLFCN_H 1
+
+/* Define to 1 if you have the <errno.h> header file. */
+#define HAVE_ERRNO_H 1
+
+/* Define to 1 if you have the <fcntl.h> header file. */
+#define HAVE_FCNTL_H 1
+
+/* Define to 1 if you have the `finite' function. */
+/* #undef HAVE_FINITE */
+
+/* Define to 1 if you have the <float.h> header file. */
+#define HAVE_FLOAT_H 1
+
+/* Define to 1 if you have the `fpclass' function. */
+/* #undef HAVE_FPCLASS */
+
+/* Define to 1 if you have the `fprintf' function. */
+#define HAVE_FPRINTF 1
+
+/* Define to 1 if you have the `fp_class' function. */
+/* #undef HAVE_FP_CLASS */
+
+/* Define to 1 if you have the <fp_class.h> header file. */
+/* #undef HAVE_FP_CLASS_H */
+
+/* Define to 1 if you have the `ftime' function. */
+#define HAVE_FTIME 1
+
+/* Define if getaddrinfo is there */
+/* #undef HAVE_GETADDRINFO */
+
+/* Define to 1 if you have the `gettimeofday' function. */
+#define HAVE_GETTIMEOFDAY 1
+
+/* Define to 1 if you have the <ieeefp.h> header file. */
+/* #undef HAVE_IEEEFP_H */
+
+/* Define to 1 if you have the <inttypes.h> header file. */
+#define HAVE_INTTYPES_H 1
+
+/* Define if isinf is there */
+/* #undef HAVE_ISINF */
+
+/* Define if isnan is there */
+#define HAVE_ISNAN 
+
+/* Define to 1 if you have the `isnand' function. */
+/* #undef HAVE_ISNAND */
+
+/* Define if history library is there (-lhistory) */
+#define HAVE_LIBHISTORY 
+
+/* Define to 1 if you have the `inet' library (-linet). */
+/* #undef HAVE_LIBINET */
+
+/* Define to 1 if you have the `nsl' library (-lnsl). */
+/* #undef HAVE_LIBNSL */
+
+/* Define if pthread library is there (-lpthread) */
+#define HAVE_LIBPTHREAD 
+
+/* Define if readline library is there (-lreadline) */
+#define HAVE_LIBREADLINE 
+
+/* Define to 1 if you have the `socket' library (-lsocket). */
+/* #undef HAVE_LIBSOCKET */
+
+/* Have compression library */
+#define HAVE_LIBZ 
+
+/* Define to 1 if you have the <limits.h> header file. */
+#define HAVE_LIMITS_H 1
+
+/* Define to 1 if you have the `localtime' function. */
+#define HAVE_LOCALTIME 1
+
+/* Define to 1 if you have the <malloc.h> header file. */
+#define HAVE_MALLOC_H 1
+
+/* Define to 1 if you have the <math.h> header file. */
+#define HAVE_MATH_H 1
+
+/* Define to 1 if you have the <memory.h> header file. */
+#define HAVE_MEMORY_H 1
+
+/* Define to 1 if you have the <nan.h> header file. */
+#define HAVE_NAN_H 1
+
+/* Define to 1 if you have the <ndir.h> header file, and it defines `DIR'. */
+/* #undef HAVE_NDIR_H */
+
+/* Define to 1 if you have the <netdb.h> header file. */
+#define HAVE_NETDB_H 1
+
+/* Define to 1 if you have the <netinet/in.h> header file. */
+#define HAVE_NETINET_IN_H 1
+
+/* Define to 1 if you have the `printf' function. */
+#define HAVE_PRINTF 1
+
+/* Define if <pthread.h> is there */
+#define HAVE_PTHREAD_H 
+
+/* Define to 1 if you have the <resolv.h> header file. */
+#define HAVE_RESOLV_H 1
+
+/* Define to 1 if you have the `signal' function. */
+#define HAVE_SIGNAL 1
+
+/* Define to 1 if you have the <signal.h> header file. */
+#define HAVE_SIGNAL_H 1
+
+/* Define to 1 if you have the `snprintf' function. */
+#define HAVE_SNPRINTF 1
+
+/* Define to 1 if you have the `sprintf' function. */
+#define HAVE_SPRINTF 1
+
+/* Define to 1 if you have the `sscanf' function. */
+#define HAVE_SSCANF 1
+
+/* Define to 1 if you have the `stat' function. */
+#define HAVE_STAT 1
+
+/* Define to 1 if you have the <stdarg.h> header file. */
+#define HAVE_STDARG_H 1
+
+/* Define to 1 if you have the <stdint.h> header file. */
+/* #undef HAVE_STDINT_H */
+
+/* Define to 1 if you have the <stdlib.h> header file. */
+#define HAVE_STDLIB_H 1
+
+/* Define to 1 if you have the `strdup' function. */
+#define HAVE_STRDUP 1
+
+/* Define to 1 if you have the `strerror' function. */
+#define HAVE_STRERROR 1
+
+/* Define to 1 if you have the `strftime' function. */
+#define HAVE_STRFTIME 1
+
+/* Define to 1 if you have the <strings.h> header file. */
+#define HAVE_STRINGS_H 1
+
+/* Define to 1 if you have the <string.h> header file. */
+#define HAVE_STRING_H 1
+
+/* Define to 1 if you have the `strndup' function. */
+/* #undef HAVE_STRNDUP */
+
+/* Define to 1 if you have the <sys/dir.h> header file, and it defines `DIR'.
+   */
+/* #undef HAVE_SYS_DIR_H */
+
+/* Define to 1 if you have the <sys/mman.h> header file. */
+#define HAVE_SYS_MMAN_H 1
+
+/* Define to 1 if you have the <sys/ndir.h> header file, and it defines `DIR'.
+   */
+/* #undef HAVE_SYS_NDIR_H */
+
+/* Define to 1 if you have the <sys/select.h> header file. */
+/* #undef HAVE_SYS_SELECT_H */
+
+/* Define to 1 if you have the <sys/socket.h> header file. */
+#define HAVE_SYS_SOCKET_H 1
+
+/* Define to 1 if you have the <sys/stat.h> header file. */
+#define HAVE_SYS_STAT_H 1
+
+/* Define to 1 if you have the <sys/timeb.h> header file. */
+#define HAVE_SYS_TIMEB_H 1
+
+/* Define to 1 if you have the <sys/time.h> header file. */
+#define HAVE_SYS_TIME_H 1
+
+/* Define to 1 if you have the <sys/types.h> header file. */
+#define HAVE_SYS_TYPES_H 1
+
+/* Define to 1 if you have the <time.h> header file. */
+#define HAVE_TIME_H 1
+
+/* Define to 1 if you have the <unistd.h> header file. */
+#define HAVE_UNISTD_H 1
+
+/* Define to 1 if you have the `vfprintf' function. */
+#define HAVE_VFPRINTF 1
+
+/* Define to 1 if you have the `vsnprintf' function. */
+#define HAVE_VSNPRINTF 1
+
+/* Define to 1 if you have the `vsprintf' function. */
+#define HAVE_VSPRINTF 1
+
+/* Define to 1 if you have the <zlib.h> header file. */
+#define HAVE_ZLIB_H 1
+
+/* Define to 1 if you have the `_stat' function. */
+#define HAVE__STAT 1
+
+/* Name of package */
+#define PACKAGE "libxml2"
+
+/* Define to the address where bug reports for this package should be sent. */
+#define PACKAGE_BUGREPORT ""
+
+/* Define to the full name of this package. */
+#define PACKAGE_NAME ""
+
+/* Define to the full name and version of this package. */
+#define PACKAGE_STRING ""
+
+/* Define to the one symbol short name of this package. */
+#define PACKAGE_TARNAME ""
+
+/* Define to the version of this package. */
+#define PACKAGE_VERSION ""
+
+/* Define to 1 if the C compiler supports function prototypes. */
+#define PROTOTYPES 1
+
+/* Determine what socket length (socklen_t) data type is */
+#define SOCKLEN_T int
+
+/* Define to 1 if you have the ANSI C header files. */
+#define STDC_HEADERS 1
+
+/* Support for IPv6 */
+/* #undef SUPPORT_IP6 */
+
+/* Version number of package */
+#define VERSION "2.6.9"
+
+/* Using the Win32 Socket implementation */
+/* #undef _WINSOCKAPI_ */
+
+/* Define like PROTOTYPES; this can be used by system headers. */
+#define __PROTOTYPES 1
+
+/* Win32 Std C name mangling work-around */
+/* #undef snprintf */
+
+/* Win32 Std C name mangling work-around */
+/* #undef vsnprintf */
diff --git a/src/libxml/src/debugXML.c b/src/libxml/src/debugXML.c
new file mode 100644
index 0000000..6886ee8
--- /dev/null
+++ b/src/libxml/src/debugXML.c
@@ -0,0 +1,2578 @@
+/*
+ * debugXML.c : This is a set of routines used for debugging the tree
+ *              produced by the XML parser.
+ *
+ * See Copyright for the status of this software.
+ *
+ * Daniel Veillard <daniel@veillard.com>
+ */
+
+#define IN_LIBXML
+#include "libxml.h"
+#ifdef LIBXML_DEBUG_ENABLED
+
+#include <string.h>
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+#ifdef HAVE_STRING_H
+#include <string.h>
+#endif
+#include <libxml/xmlmemory.h>
+#include <libxml/tree.h>
+#include <libxml/parser.h>
+#include <libxml/parserInternals.h>
+#include <libxml/valid.h>
+#include <libxml/debugXML.h>
+#include <libxml/HTMLtree.h>
+#include <libxml/HTMLparser.h>
+#include <libxml/xmlerror.h>
+#include <libxml/globals.h>
+#include <libxml/xpathInternals.h>
+#include <libxml/uri.h>
+#ifdef LIBXML_SCHEMAS_ENABLED
+#include <libxml/relaxng.h>
+#endif
+
+/**
+ * xmlDebugDumpString:
+ * @output:  the FILE * for the output
+ * @str:  the string
+ *
+ * Dumps informations about the string, shorten it if necessary
+ */
+void
+xmlDebugDumpString(FILE * output, const xmlChar * str)
+{
+    int i;
+
+    if (output == NULL)
+	output = stdout;
+    if (str == NULL) {
+        fprintf(output, "(NULL)");
+        return;
+    }
+    for (i = 0; i < 40; i++)
+        if (str[i] == 0)
+            return;
+        else if (IS_BLANK_CH(str[i]))
+            fputc(' ', output);
+        else if (str[i] >= 0x80)
+            fprintf(output, "#%X", str[i]);
+        else
+            fputc(str[i], output);
+    fprintf(output, "...");
+}
+
+static void
+xmlDebugDumpDtdNode(FILE *output, xmlDtdPtr dtd, int depth) {
+    int i;
+    char shift[100];
+
+    for (i = 0;((i < depth) && (i < 25));i++)
+        shift[2 * i] = shift[2 * i + 1] = ' ';
+    shift[2 * i] = shift[2 * i + 1] = 0;
+
+    fprintf(output, shift);
+
+    if (dtd == NULL) {
+	fprintf(output, "DTD node is NULL\n");
+	return;
+    }
+
+    if (dtd->type != XML_DTD_NODE) {
+	fprintf(output, "PBM: not a DTD\n");
+	return;
+    }
+    if (dtd->name != NULL)
+	fprintf(output, "DTD(%s)", dtd->name);
+    else
+	fprintf(output, "DTD");
+    if (dtd->ExternalID != NULL)
+	fprintf(output, ", PUBLIC %s", dtd->ExternalID);
+    if (dtd->SystemID != NULL)
+	fprintf(output, ", SYSTEM %s", dtd->SystemID);
+    fprintf(output, "\n");
+    /*
+     * Do a bit of checking
+     */
+    if (dtd->parent == NULL)
+	fprintf(output, "PBM: DTD has no parent\n");
+    if (dtd->doc == NULL)
+	fprintf(output, "PBM: DTD has no doc\n");
+    if ((dtd->parent != NULL) && (dtd->doc != dtd->parent->doc))
+	fprintf(output, "PBM: DTD doc differs from parent's one\n");
+    if (dtd->prev == NULL) {
+	if ((dtd->parent != NULL) && (dtd->parent->children != (xmlNodePtr)dtd))
+	    fprintf(output, "PBM: DTD has no prev and not first of list\n");
+    } else {
+	if (dtd->prev->next != (xmlNodePtr) dtd)
+	    fprintf(output, "PBM: DTD prev->next : back link wrong\n");
+    }
+    if (dtd->next == NULL) {
+	if ((dtd->parent != NULL) && (dtd->parent->last != (xmlNodePtr) dtd))
+	    fprintf(output, "PBM: DTD has no next and not last of list\n");
+    } else {
+	if (dtd->next->prev != (xmlNodePtr) dtd)
+	    fprintf(output, "PBM: DTD next->prev : forward link wrong\n");
+    }
+}
+
+static void
+xmlDebugDumpAttrDecl(FILE *output, xmlAttributePtr attr, int depth) {
+    int i;
+    char shift[100];
+
+    for (i = 0;((i < depth) && (i < 25));i++)
+        shift[2 * i] = shift[2 * i + 1] = ' ';
+    shift[2 * i] = shift[2 * i + 1] = 0;
+
+    fprintf(output, shift);
+
+    if (attr == NULL) {
+	fprintf(output, "Attribute declaration is NULL\n");
+	return;
+    }
+    if (attr->type != XML_ATTRIBUTE_DECL) {
+	fprintf(output, "PBM: not a Attr\n");
+	return;
+    }
+    if (attr->name != NULL)
+	fprintf(output, "ATTRDECL(%s)", attr->name);
+    else
+	fprintf(output, "PBM ATTRDECL noname!!!");
+    if (attr->elem != NULL)
+	fprintf(output, " for %s", attr->elem);
+    else
+	fprintf(output, " PBM noelem!!!");
+    switch (attr->atype) {
+        case XML_ATTRIBUTE_CDATA:
+	    fprintf(output, " CDATA");
+	    break;
+        case XML_ATTRIBUTE_ID:
+	    fprintf(output, " ID");
+	    break;
+        case XML_ATTRIBUTE_IDREF:
+	    fprintf(output, " IDREF");
+	    break;
+        case XML_ATTRIBUTE_IDREFS:
+	    fprintf(output, " IDREFS");
+	    break;
+        case XML_ATTRIBUTE_ENTITY:
+	    fprintf(output, " ENTITY");
+	    break;
+        case XML_ATTRIBUTE_ENTITIES:
+	    fprintf(output, " ENTITIES");
+	    break;
+        case XML_ATTRIBUTE_NMTOKEN:
+	    fprintf(output, " NMTOKEN");
+	    break;
+        case XML_ATTRIBUTE_NMTOKENS:
+	    fprintf(output, " NMTOKENS");
+	    break;
+        case XML_ATTRIBUTE_ENUMERATION:
+	    fprintf(output, " ENUMERATION");
+	    break;
+        case XML_ATTRIBUTE_NOTATION:
+	    fprintf(output, " NOTATION ");
+	    break;
+    }
+    if (attr->tree != NULL) {
+	int indx;
+	xmlEnumerationPtr cur = attr->tree;
+
+	for (indx = 0;indx < 5; indx++) {
+	    if (indx != 0)
+		fprintf(output, "|%s", cur->name);
+	    else
+		fprintf(output, " (%s", cur->name);
+	    cur = cur->next;
+	    if (cur == NULL) break;
+	}
+	if (cur == NULL)
+	    fprintf(output, ")");
+	else
+	    fprintf(output, "...)");
+    }
+    switch (attr->def) {
+        case XML_ATTRIBUTE_NONE:
+	    break;
+        case XML_ATTRIBUTE_REQUIRED:
+	    fprintf(output, " REQUIRED");
+	    break;
+        case XML_ATTRIBUTE_IMPLIED:
+	    fprintf(output, " IMPLIED");
+	    break;
+        case XML_ATTRIBUTE_FIXED:
+	    fprintf(output, " FIXED");
+	    break;
+    }
+    if (attr->defaultValue != NULL) {
+	fprintf(output, "\"");
+	xmlDebugDumpString(output, attr->defaultValue);
+	fprintf(output, "\"");
+    }
+    fprintf(output, "\n");
+
+    /*
+     * Do a bit of checking
+     */
+    if (attr->parent == NULL)
+	fprintf(output, "PBM: Attr has no parent\n");
+    if (attr->doc == NULL)
+	fprintf(output, "PBM: Attr has no doc\n");
+    if ((attr->parent != NULL) && (attr->doc != attr->parent->doc))
+	fprintf(output, "PBM: Attr doc differs from parent's one\n");
+    if (attr->prev == NULL) {
+	if ((attr->parent != NULL) && (attr->parent->children != (xmlNodePtr)attr))
+	    fprintf(output, "PBM: Attr has no prev and not first of list\n");
+    } else {
+	if (attr->prev->next != (xmlNodePtr) attr)
+	    fprintf(output, "PBM: Attr prev->next : back link wrong\n");
+    }
+    if (attr->next == NULL) {
+	if ((attr->parent != NULL) && (attr->parent->last != (xmlNodePtr) attr))
+	    fprintf(output, "PBM: Attr has no next and not last of list\n");
+    } else {
+	if (attr->next->prev != (xmlNodePtr) attr)
+	    fprintf(output, "PBM: Attr next->prev : forward link wrong\n");
+    }
+}
+
+static void
+xmlDebugDumpElemDecl(FILE *output, xmlElementPtr elem, int depth) {
+    int i;
+    char shift[100];
+
+    for (i = 0;((i < depth) && (i < 25));i++)
+        shift[2 * i] = shift[2 * i + 1] = ' ';
+    shift[2 * i] = shift[2 * i + 1] = 0;
+
+    fprintf(output, shift);
+
+    if (elem == NULL) {
+	fprintf(output, "Element declaration is NULL\n");
+	return;
+    }
+    if (elem->type != XML_ELEMENT_DECL) {
+	fprintf(output, "PBM: not a Elem\n");
+	return;
+    }
+    if (elem->name != NULL) {
+	fprintf(output, "ELEMDECL(");
+	xmlDebugDumpString(output, elem->name);
+	fprintf(output, ")");
+    } else
+	fprintf(output, "PBM ELEMDECL noname!!!");
+    switch (elem->etype) {
+	case XML_ELEMENT_TYPE_UNDEFINED: 
+	    fprintf(output, ", UNDEFINED");
+	    break;
+	case XML_ELEMENT_TYPE_EMPTY: 
+	    fprintf(output, ", EMPTY");
+	    break;
+	case XML_ELEMENT_TYPE_ANY: 
+	    fprintf(output, ", ANY");
+	    break;
+	case XML_ELEMENT_TYPE_MIXED: 
+	    fprintf(output, ", MIXED ");
+	    break;
+	case XML_ELEMENT_TYPE_ELEMENT: 
+	    fprintf(output, ", MIXED ");
+	    break;
+    }
+    if ((elem->type != XML_ELEMENT_NODE) &&
+	(elem->content != NULL)) {
+	char buf[5001];
+
+	buf[0] = 0;
+	xmlSnprintfElementContent(buf, 5000, elem->content, 1);
+	buf[5000] = 0;
+	fprintf(output, "%s", buf);
+    }
+    fprintf(output, "\n");
+
+    /*
+     * Do a bit of checking
+     */
+    if (elem->parent == NULL)
+	fprintf(output, "PBM: Elem has no parent\n");
+    if (elem->doc == NULL)
+	fprintf(output, "PBM: Elem has no doc\n");
+    if ((elem->parent != NULL) && (elem->doc != elem->parent->doc))
+	fprintf(output, "PBM: Elem doc differs from parent's one\n");
+    if (elem->prev == NULL) {
+	if ((elem->parent != NULL) && (elem->parent->children != (xmlNodePtr)elem))
+	    fprintf(output, "PBM: Elem has no prev and not first of list\n");
+    } else {
+	if (elem->prev->next != (xmlNodePtr) elem)
+	    fprintf(output, "PBM: Elem prev->next : back link wrong\n");
+    }
+    if (elem->next == NULL) {
+	if ((elem->parent != NULL) && (elem->parent->last != (xmlNodePtr) elem))
+	    fprintf(output, "PBM: Elem has no next and not last of list\n");
+    } else {
+	if (elem->next->prev != (xmlNodePtr) elem)
+	    fprintf(output, "PBM: Elem next->prev : forward link wrong\n");
+    }
+}
+
+static void
+xmlDebugDumpEntityDecl(FILE *output, xmlEntityPtr ent, int depth) {
+    int i;
+    char shift[100];
+
+    for (i = 0;((i < depth) && (i < 25));i++)
+        shift[2 * i] = shift[2 * i + 1] = ' ';
+    shift[2 * i] = shift[2 * i + 1] = 0;
+
+    fprintf(output, shift);
+
+    if (ent == NULL) {
+	fprintf(output, "Entity declaration is NULL\n");
+	return;
+    }
+    if (ent->type != XML_ENTITY_DECL) {
+	fprintf(output, "PBM: not a Entity decl\n");
+	return;
+    }
+    if (ent->name != NULL) {
+	fprintf(output, "ENTITYDECL(");
+	xmlDebugDumpString(output, ent->name);
+	fprintf(output, ")");
+    } else
+	fprintf(output, "PBM ENTITYDECL noname!!!");
+    switch (ent->etype) {
+	case XML_INTERNAL_GENERAL_ENTITY: 
+	    fprintf(output, ", internal\n");
+	    break;
+	case XML_EXTERNAL_GENERAL_PARSED_ENTITY: 
+	    fprintf(output, ", external parsed\n");
+	    break;
+	case XML_EXTERNAL_GENERAL_UNPARSED_ENTITY: 
+	    fprintf(output, ", unparsed\n");
+	    break;
+	case XML_INTERNAL_PARAMETER_ENTITY: 
+	    fprintf(output, ", parameter\n");
+	    break;
+	case XML_EXTERNAL_PARAMETER_ENTITY: 
+	    fprintf(output, ", external parameter\n");
+	    break;
+	case XML_INTERNAL_PREDEFINED_ENTITY: 
+	    fprintf(output, ", predefined\n");
+	    break;
+    }
+    if (ent->ExternalID) {
+        fprintf(output, shift);
+        fprintf(output, " ExternalID=%s\n", ent->ExternalID);
+    }
+    if (ent->SystemID) {
+        fprintf(output, shift);
+        fprintf(output, " SystemID=%s\n", ent->SystemID);
+    }
+    if (ent->URI != NULL) {
+        fprintf(output, shift);
+        fprintf(output, " URI=%s\n", ent->URI);
+    }
+    if (ent->content) {
+        fprintf(output, shift);
+	fprintf(output, " content=");
+	xmlDebugDumpString(output, ent->content);
+	fprintf(output, "\n");
+    }
+
+    /*
+     * Do a bit of checking
+     */
+    if (ent->parent == NULL)
+	fprintf(output, "PBM: Ent has no parent\n");
+    if (ent->doc == NULL)
+	fprintf(output, "PBM: Ent has no doc\n");
+    if ((ent->parent != NULL) && (ent->doc != ent->parent->doc))
+	fprintf(output, "PBM: Ent doc differs from parent's one\n");
+    if (ent->prev == NULL) {
+	if ((ent->parent != NULL) && (ent->parent->children != (xmlNodePtr)ent))
+	    fprintf(output, "PBM: Ent has no prev and not first of list\n");
+    } else {
+	if (ent->prev->next != (xmlNodePtr) ent)
+	    fprintf(output, "PBM: Ent prev->next : back link wrong\n");
+    }
+    if (ent->next == NULL) {
+	if ((ent->parent != NULL) && (ent->parent->last != (xmlNodePtr) ent))
+	    fprintf(output, "PBM: Ent has no next and not last of list\n");
+    } else {
+	if (ent->next->prev != (xmlNodePtr) ent)
+	    fprintf(output, "PBM: Ent next->prev : forward link wrong\n");
+    }
+}
+
+static void
+xmlDebugDumpNamespace(FILE *output, xmlNsPtr ns, int depth) {
+    int i;
+    char shift[100];
+
+    for (i = 0;((i < depth) && (i < 25));i++)
+        shift[2 * i] = shift[2 * i + 1] = ' ';
+    shift[2 * i] = shift[2 * i + 1] = 0;
+
+    fprintf(output, shift);
+
+    if (ns == NULL) {
+	fprintf(output, "namespace node is NULL\n");
+	return;
+    }
+    if (ns->type != XML_NAMESPACE_DECL) {
+        fprintf(output, "invalid namespace node %d\n", ns->type);
+	return;
+    }
+    if (ns->href == NULL) {
+	if (ns->prefix != NULL)
+	    fprintf(output, "incomplete namespace %s href=NULL\n", ns->prefix);
+	else
+	    fprintf(output, "incomplete default namespace href=NULL\n");
+    } else {
+	if (ns->prefix != NULL)
+	    fprintf(output, "namespace %s href=", ns->prefix);
+	else
+	    fprintf(output, "default namespace href=");
+
+	xmlDebugDumpString(output, ns->href);
+	fprintf(output, "\n");
+    }
+}
+
+static void
+xmlDebugDumpNamespaceList(FILE *output, xmlNsPtr ns, int depth) {
+    while (ns != NULL) {
+        xmlDebugDumpNamespace(output, ns, depth);
+	ns = ns->next;
+    }
+}
+
+static void
+xmlDebugDumpEntity(FILE *output, xmlEntityPtr ent, int depth) {
+    int i;
+    char shift[100];
+
+    for (i = 0;((i < depth) && (i < 25));i++)
+        shift[2 * i] = shift[2 * i + 1] = ' ';
+    shift[2 * i] = shift[2 * i + 1] = 0;
+
+    fprintf(output, shift);
+    
+    if (ent == NULL) {
+	fprintf(output, "Entity is NULL\n");
+	return;
+    }
+    switch (ent->etype) {
+        case XML_INTERNAL_GENERAL_ENTITY:
+	    fprintf(output, "INTERNAL_GENERAL_ENTITY ");
+	    break;
+        case XML_EXTERNAL_GENERAL_PARSED_ENTITY:
+	    fprintf(output, "EXTERNAL_GENERAL_PARSED_ENTITY ");
+	    break;
+        case XML_EXTERNAL_GENERAL_UNPARSED_ENTITY:
+	    fprintf(output, "EXTERNAL_GENERAL_UNPARSED_ENTITY ");
+	    break;
+        case XML_INTERNAL_PARAMETER_ENTITY:
+	    fprintf(output, "INTERNAL_PARAMETER_ENTITY ");
+	    break;
+        case XML_EXTERNAL_PARAMETER_ENTITY:
+	    fprintf(output, "EXTERNAL_PARAMETER_ENTITY ");
+	    break;
+	default:
+	    fprintf(output, "ENTITY_%d ! ", ent->etype);
+    }
+    fprintf(output, "%s\n", ent->name);
+    if (ent->ExternalID) {
+        fprintf(output, shift);
+        fprintf(output, "ExternalID=%s\n", ent->ExternalID);
+    }
+    if (ent->SystemID) {
+        fprintf(output, shift);
+        fprintf(output, "SystemID=%s\n", ent->SystemID);
+    }
+    if (ent->URI) {
+        fprintf(output, shift);
+        fprintf(output, "URI=%s\n", ent->URI);
+    }
+    if (ent->content) {
+        fprintf(output, shift);
+	fprintf(output, "content=");
+	xmlDebugDumpString(output, ent->content);
+	fprintf(output, "\n");
+    }
+}
+
+/**
+ * xmlDebugDumpAttr:
+ * @output:  the FILE * for the output
+ * @attr:  the attribute
+ * @depth:  the indentation level.
+ *
+ * Dumps debug information for the attribute
+ */
+void
+xmlDebugDumpAttr(FILE *output, xmlAttrPtr attr, int depth) {
+    int i;
+    char shift[100];
+
+    for (i = 0;((i < depth) && (i < 25));i++)
+        shift[2 * i] = shift[2 * i + 1] = ' ';
+    shift[2 * i] = shift[2 * i + 1] = 0;
+
+    fprintf(output, shift);
+    
+    if (attr == NULL) {
+	fprintf(output, "Attr is NULL");
+	return;
+    }
+    fprintf(output, "ATTRIBUTE ");
+    xmlDebugDumpString(output, attr->name);
+    fprintf(output, "\n");
+    if (attr->children != NULL) 
+        xmlDebugDumpNodeList(output, attr->children, depth + 1);
+
+    /*
+     * Do a bit of checking
+     */
+    if (attr->parent == NULL)
+	fprintf(output, "PBM: Attr has no parent\n");
+    if (attr->doc == NULL)
+	fprintf(output, "PBM: Attr has no doc\n");
+    if ((attr->parent != NULL) && (attr->doc != attr->parent->doc))
+	fprintf(output, "PBM: Attr doc differs from parent's one\n");
+    if (attr->prev == NULL) {
+	if ((attr->parent != NULL) && (attr->parent->properties != attr))
+	    fprintf(output, "PBM: Attr has no prev and not first of list\n");
+    } else {
+	if (attr->prev->next != attr)
+	    fprintf(output, "PBM: Attr prev->next : back link wrong\n");
+    }
+    if (attr->next != NULL) {
+	if (attr->next->prev != attr)
+	    fprintf(output, "PBM: Attr next->prev : forward link wrong\n");
+    }
+}
+
+/**
+ * xmlDebugDumpAttrList:
+ * @output:  the FILE * for the output
+ * @attr:  the attribute list
+ * @depth:  the indentation level.
+ *
+ * Dumps debug information for the attribute list
+ */
+void
+xmlDebugDumpAttrList(FILE * output, xmlAttrPtr attr, int depth)
+{
+    if (output == NULL)
+	output = stdout;
+    while (attr != NULL) {
+        xmlDebugDumpAttr(output, attr, depth);
+        attr = attr->next;
+    }
+}
+
+/**
+ * xmlDebugDumpOneNode:
+ * @output:  the FILE * for the output
+ * @node:  the node
+ * @depth:  the indentation level.
+ *
+ * Dumps debug information for the element node, it is not recursive
+ */
+void
+xmlDebugDumpOneNode(FILE * output, xmlNodePtr node, int depth)
+{
+    int i;
+    char shift[100];
+
+    if (output == NULL)
+	output = stdout;
+    for (i = 0; ((i < depth) && (i < 25)); i++)
+        shift[2 * i] = shift[2 * i + 1] = ' ';
+    shift[2 * i] = shift[2 * i + 1] = 0;
+
+    if (node == NULL) {
+	fprintf(output, shift);
+	fprintf(output, "node is NULL\n");
+	return;
+    }
+    switch (node->type) {
+        case XML_ELEMENT_NODE:
+            fprintf(output, shift);
+            fprintf(output, "ELEMENT ");
+            if ((node->ns != NULL) && (node->ns->prefix != NULL)) {
+                xmlDebugDumpString(output, node->ns->prefix);
+                fprintf(output, ":");
+            }
+            xmlDebugDumpString(output, node->name);
+            fprintf(output, "\n");
+            break;
+        case XML_ATTRIBUTE_NODE:
+            fprintf(output, shift);
+            fprintf(output, "Error, ATTRIBUTE found here\n");
+            break;
+        case XML_TEXT_NODE:
+            fprintf(output, shift);
+	    if (node->name == (const xmlChar *) xmlStringTextNoenc)
+		fprintf(output, "TEXT no enc\n");
+	    else
+		fprintf(output, "TEXT\n");
+            break;
+        case XML_CDATA_SECTION_NODE:
+            fprintf(output, shift);
+            fprintf(output, "CDATA_SECTION\n");
+            break;
+        case XML_ENTITY_REF_NODE:
+            fprintf(output, shift);
+            fprintf(output, "ENTITY_REF(%s)\n", node->name);
+            break;
+        case XML_ENTITY_NODE:
+            fprintf(output, shift);
+            fprintf(output, "ENTITY\n");
+            break;
+        case XML_PI_NODE:
+            fprintf(output, shift);
+            fprintf(output, "PI %s\n", node->name);
+            break;
+        case XML_COMMENT_NODE:
+            fprintf(output, shift);
+            fprintf(output, "COMMENT\n");
+            break;
+        case XML_DOCUMENT_NODE:
+        case XML_HTML_DOCUMENT_NODE:
+            fprintf(output, shift);
+            fprintf(output, "Error, DOCUMENT found here\n");
+            break;
+        case XML_DOCUMENT_TYPE_NODE:
+            fprintf(output, shift);
+            fprintf(output, "DOCUMENT_TYPE\n");
+            break;
+        case XML_DOCUMENT_FRAG_NODE:
+            fprintf(output, shift);
+            fprintf(output, "DOCUMENT_FRAG\n");
+            break;
+        case XML_NOTATION_NODE:
+            fprintf(output, shift);
+            fprintf(output, "NOTATION\n");
+            break;
+        case XML_DTD_NODE:
+            xmlDebugDumpDtdNode(output, (xmlDtdPtr) node, depth);
+            return;
+        case XML_ELEMENT_DECL:
+            xmlDebugDumpElemDecl(output, (xmlElementPtr) node, depth);
+            return;
+        case XML_ATTRIBUTE_DECL:
+            xmlDebugDumpAttrDecl(output, (xmlAttributePtr) node, depth);
+            return;
+        case XML_ENTITY_DECL:
+            xmlDebugDumpEntityDecl(output, (xmlEntityPtr) node, depth);
+            return;
+        case XML_NAMESPACE_DECL:
+            xmlDebugDumpNamespace(output, (xmlNsPtr) node, depth);
+            return;
+        case XML_XINCLUDE_START:
+            fprintf(output, shift);
+            fprintf(output, "INCLUDE START\n");
+            return;
+        case XML_XINCLUDE_END:
+            fprintf(output, shift);
+            fprintf(output, "INCLUDE END\n");
+            return;
+        default:
+            fprintf(output, shift);
+            fprintf(output, "NODE_%d !!!\n", node->type);
+            return;
+    }
+    if (node->doc == NULL) {
+        fprintf(output, shift);
+        fprintf(output, "doc == NULL !!!\n");
+    }
+    if (node->nsDef != NULL)
+        xmlDebugDumpNamespaceList(output, node->nsDef, depth + 1);
+    if (node->properties != NULL)
+        xmlDebugDumpAttrList(output, node->properties, depth + 1);
+    if (node->type != XML_ENTITY_REF_NODE) {
+        if ((node->type != XML_ELEMENT_NODE) && (node->content != NULL)) {
+            shift[2 * i] = shift[2 * i + 1] = ' ';
+            shift[2 * i + 2] = shift[2 * i + 3] = 0;
+            fprintf(output, shift);
+            fprintf(output, "content=");
+            xmlDebugDumpString(output, node->content);
+            fprintf(output, "\n");
+        }
+    } else {
+        xmlEntityPtr ent;
+
+        ent = xmlGetDocEntity(node->doc, node->name);
+        if (ent != NULL)
+            xmlDebugDumpEntity(output, ent, depth + 1);
+    }
+    /*
+     * Do a bit of checking
+     */
+    if (node->parent == NULL)
+        fprintf(output, "PBM: Node has no parent\n");
+    if (node->doc == NULL)
+        fprintf(output, "PBM: Node has no doc\n");
+    if ((node->parent != NULL) && (node->doc != node->parent->doc))
+        fprintf(output, "PBM: Node doc differs from parent's one\n");
+    if (node->prev == NULL) {
+        if ((node->parent != NULL) && (node->parent->children != node))
+            fprintf(output,
+                    "PBM: Node has no prev and not first of list\n");
+    } else {
+        if (node->prev->next != node)
+            fprintf(output, "PBM: Node prev->next : back link wrong\n");
+    }
+    if (node->next == NULL) {
+        if ((node->parent != NULL) && (node->parent->last != node))
+            fprintf(output,
+                    "PBM: Node has no next and not last of list\n");
+    } else {
+        if (node->next->prev != node)
+            fprintf(output, "PBM: Node next->prev : forward link wrong\n");
+    }
+}
+
+/**
+ * xmlDebugDumpNode:
+ * @output:  the FILE * for the output
+ * @node:  the node
+ * @depth:  the indentation level.
+ *
+ * Dumps debug information for the element node, it is recursive
+ */
+void
+xmlDebugDumpNode(FILE * output, xmlNodePtr node, int depth)
+{
+    if (output == NULL)
+	output = stdout;
+    if (node == NULL) {
+	int i;
+	char shift[100];
+    	
+	for (i = 0; ((i < depth) && (i < 25)); i++)
+	    shift[2 * i] = shift[2 * i + 1] = ' ';
+	shift[2 * i] = shift[2 * i + 1] = 0;
+	
+	fprintf(output, shift);
+	fprintf(output, "node is NULL\n");
+	return;
+    }	
+    xmlDebugDumpOneNode(output, node, depth);
+    if ((node->children != NULL) && (node->type != XML_ENTITY_REF_NODE))
+        xmlDebugDumpNodeList(output, node->children, depth + 1);
+}
+
+/**
+ * xmlDebugDumpNodeList:
+ * @output:  the FILE * for the output
+ * @node:  the node list
+ * @depth:  the indentation level.
+ *
+ * Dumps debug information for the list of element node, it is recursive
+ */
+void
+xmlDebugDumpNodeList(FILE * output, xmlNodePtr node, int depth)
+{
+    if (output == NULL)
+	output = stdout;
+    while (node != NULL) {
+        xmlDebugDumpNode(output, node, depth);
+        node = node->next;
+    }
+}
+
+
+/**
+ * xmlDebugDumpDocumentHead:
+ * @output:  the FILE * for the output
+ * @doc:  the document
+ *
+ * Dumps debug information cncerning the document, not recursive
+ */
+void
+xmlDebugDumpDocumentHead(FILE * output, xmlDocPtr doc)
+{
+    if (output == NULL)
+        output = stdout;
+    if (doc == NULL) {
+        fprintf(output, "DOCUMENT == NULL !\n");
+        return;
+    }
+
+    switch (doc->type) {
+        case XML_ELEMENT_NODE:
+            fprintf(output, "Error, ELEMENT found here ");
+            break;
+        case XML_ATTRIBUTE_NODE:
+            fprintf(output, "Error, ATTRIBUTE found here\n");
+            break;
+        case XML_TEXT_NODE:
+            fprintf(output, "Error, TEXT\n");
+            break;
+        case XML_CDATA_SECTION_NODE:
+            fprintf(output, "Error, CDATA_SECTION\n");
+            break;
+        case XML_ENTITY_REF_NODE:
+            fprintf(output, "Error, ENTITY_REF\n");
+            break;
+        case XML_ENTITY_NODE:
+            fprintf(output, "Error, ENTITY\n");
+            break;
+        case XML_PI_NODE:
+            fprintf(output, "Error, PI\n");
+            break;
+        case XML_COMMENT_NODE:
+            fprintf(output, "Error, COMMENT\n");
+            break;
+        case XML_DOCUMENT_NODE:
+            fprintf(output, "DOCUMENT\n");
+            break;
+        case XML_HTML_DOCUMENT_NODE:
+            fprintf(output, "HTML DOCUMENT\n");
+            break;
+        case XML_DOCUMENT_TYPE_NODE:
+            fprintf(output, "Error, DOCUMENT_TYPE\n");
+            break;
+        case XML_DOCUMENT_FRAG_NODE:
+            fprintf(output, "Error, DOCUMENT_FRAG\n");
+            break;
+        case XML_NOTATION_NODE:
+            fprintf(output, "Error, NOTATION\n");
+            break;
+        default:
+            fprintf(output, "NODE_%d\n", doc->type);
+    }
+    if (doc->name != NULL) {
+        fprintf(output, "name=");
+        xmlDebugDumpString(output, BAD_CAST doc->name);
+        fprintf(output, "\n");
+    }
+    if (doc->version != NULL) {
+        fprintf(output, "version=");
+        xmlDebugDumpString(output, doc->version);
+        fprintf(output, "\n");
+    }
+    if (doc->encoding != NULL) {
+        fprintf(output, "encoding=");
+        xmlDebugDumpString(output, doc->encoding);
+        fprintf(output, "\n");
+    }
+    if (doc->URL != NULL) {
+        fprintf(output, "URL=");
+        xmlDebugDumpString(output, doc->URL);
+        fprintf(output, "\n");
+    }
+    if (doc->standalone)
+        fprintf(output, "standalone=true\n");
+    if (doc->oldNs != NULL)
+        xmlDebugDumpNamespaceList(output, doc->oldNs, 0);
+}
+
+/**
+ * xmlDebugDumpDocument:
+ * @output:  the FILE * for the output
+ * @doc:  the document
+ *
+ * Dumps debug information for the document, it's recursive
+ */
+void
+xmlDebugDumpDocument(FILE * output, xmlDocPtr doc)
+{
+    if (output == NULL)
+        output = stdout;
+    if (doc == NULL) {
+        fprintf(output, "DOCUMENT == NULL !\n");
+        return;
+    }
+    xmlDebugDumpDocumentHead(output, doc);
+    if (((doc->type == XML_DOCUMENT_NODE) ||
+         (doc->type == XML_HTML_DOCUMENT_NODE)) && (doc->children != NULL))
+        xmlDebugDumpNodeList(output, doc->children, 1);
+}
+
+/**
+ * xmlDebugDumpDTD:
+ * @output:  the FILE * for the output
+ * @dtd:  the DTD
+ *
+ * Dumps debug information for the DTD
+ */
+void
+xmlDebugDumpDTD(FILE * output, xmlDtdPtr dtd)
+{
+    if (output == NULL)
+	output = stdout;
+    if (dtd == NULL) {
+	fprintf(output, "DTD is NULL\n");
+        return;
+    }
+    if (dtd->type != XML_DTD_NODE) {
+        fprintf(output, "PBM: not a DTD\n");
+        return;
+    }
+    if (dtd->name != NULL)
+        fprintf(output, "DTD(%s)", dtd->name);
+    else
+        fprintf(output, "DTD");
+    if (dtd->ExternalID != NULL)
+        fprintf(output, ", PUBLIC %s", dtd->ExternalID);
+    if (dtd->SystemID != NULL)
+        fprintf(output, ", SYSTEM %s", dtd->SystemID);
+    fprintf(output, "\n");
+    /*
+     * Do a bit of checking
+     */
+    if ((dtd->parent != NULL) && (dtd->doc != dtd->parent->doc))
+        fprintf(output, "PBM: DTD doc differs from parent's one\n");
+    if (dtd->prev == NULL) {
+        if ((dtd->parent != NULL)
+            && (dtd->parent->children != (xmlNodePtr) dtd))
+            fprintf(output,
+                    "PBM: DTD has no prev and not first of list\n");
+    } else {
+        if (dtd->prev->next != (xmlNodePtr) dtd)
+            fprintf(output, "PBM: DTD prev->next : back link wrong\n");
+    }
+    if (dtd->next == NULL) {
+        if ((dtd->parent != NULL)
+            && (dtd->parent->last != (xmlNodePtr) dtd))
+            fprintf(output, "PBM: DTD has no next and not last of list\n");
+    } else {
+        if (dtd->next->prev != (xmlNodePtr) dtd)
+            fprintf(output, "PBM: DTD next->prev : forward link wrong\n");
+    }
+    if (dtd->children == NULL)
+        fprintf(output, "    DTD is empty\n");
+    else
+        xmlDebugDumpNodeList(output, dtd->children, 1);
+}
+
+static void
+xmlDebugDumpEntityCallback(xmlEntityPtr cur, FILE *output) {
+    if (cur == NULL) {
+	fprintf(output, "Entity is NULL");
+	return;
+    }
+    fprintf(output, "%s : ", cur->name);
+    switch (cur->etype) {
+	case XML_INTERNAL_GENERAL_ENTITY:
+	    fprintf(output, "INTERNAL GENERAL, ");
+	    break;
+	case XML_EXTERNAL_GENERAL_PARSED_ENTITY:
+	    fprintf(output, "EXTERNAL PARSED, ");
+	    break;
+	case XML_EXTERNAL_GENERAL_UNPARSED_ENTITY:
+	    fprintf(output, "EXTERNAL UNPARSED, ");
+	    break;
+	case XML_INTERNAL_PARAMETER_ENTITY:
+	    fprintf(output, "INTERNAL PARAMETER, ");
+	    break;
+	case XML_EXTERNAL_PARAMETER_ENTITY:
+	    fprintf(output, "EXTERNAL PARAMETER, ");
+	    break;
+	default:
+	    fprintf(output, "UNKNOWN TYPE %d",
+		    cur->etype);
+    }
+    if (cur->ExternalID != NULL) 
+	fprintf(output, "ID \"%s\"", cur->ExternalID);
+    if (cur->SystemID != NULL)
+	fprintf(output, "SYSTEM \"%s\"", cur->SystemID);
+    if (cur->orig != NULL)
+	fprintf(output, "\n orig \"%s\"", cur->orig);
+    if ((cur->type != XML_ELEMENT_NODE) &&
+	(cur->content != NULL))
+	fprintf(output, "\n content \"%s\"", cur->content);
+    fprintf(output, "\n");	
+}
+
+/**
+ * xmlDebugDumpEntities:
+ * @output:  the FILE * for the output
+ * @doc:  the document
+ *
+ * Dumps debug information for all the entities in use by the document
+ */
+void
+xmlDebugDumpEntities(FILE * output, xmlDocPtr doc)
+{
+    if (output == NULL)
+        output = stdout;
+    if (doc == NULL) {
+        fprintf(output, "DOCUMENT == NULL !\n");
+        return;
+    }
+
+    switch (doc->type) {
+        case XML_ELEMENT_NODE:
+            fprintf(output, "Error, ELEMENT found here ");
+            break;
+        case XML_ATTRIBUTE_NODE:
+            fprintf(output, "Error, ATTRIBUTE found here\n");
+            break;
+        case XML_TEXT_NODE:
+            fprintf(output, "Error, TEXT\n");
+            break;
+        case XML_CDATA_SECTION_NODE:
+            fprintf(output, "Error, CDATA_SECTION\n");
+            break;
+        case XML_ENTITY_REF_NODE:
+            fprintf(output, "Error, ENTITY_REF\n");
+            break;
+        case XML_ENTITY_NODE:
+            fprintf(output, "Error, ENTITY\n");
+            break;
+        case XML_PI_NODE:
+            fprintf(output, "Error, PI\n");
+            break;
+        case XML_COMMENT_NODE:
+            fprintf(output, "Error, COMMENT\n");
+            break;
+        case XML_DOCUMENT_NODE:
+            fprintf(output, "DOCUMENT\n");
+            break;
+        case XML_HTML_DOCUMENT_NODE:
+            fprintf(output, "HTML DOCUMENT\n");
+            break;
+        case XML_DOCUMENT_TYPE_NODE:
+            fprintf(output, "Error, DOCUMENT_TYPE\n");
+            break;
+        case XML_DOCUMENT_FRAG_NODE:
+            fprintf(output, "Error, DOCUMENT_FRAG\n");
+            break;
+        case XML_NOTATION_NODE:
+            fprintf(output, "Error, NOTATION\n");
+            break;
+        default:
+            fprintf(output, "NODE_%d\n", doc->type);
+    }
+    if ((doc->intSubset != NULL) && (doc->intSubset->entities != NULL)) {
+        xmlEntitiesTablePtr table = (xmlEntitiesTablePtr)
+            doc->intSubset->entities;
+
+        fprintf(output, "Entities in internal subset\n");
+        xmlHashScan(table, (xmlHashScanner) xmlDebugDumpEntityCallback,
+                    output);
+    } else
+        fprintf(output, "No entities in internal subset\n");
+    if ((doc->extSubset != NULL) && (doc->extSubset->entities != NULL)) {
+        xmlEntitiesTablePtr table = (xmlEntitiesTablePtr)
+            doc->extSubset->entities;
+
+        fprintf(output, "Entities in external subset\n");
+        xmlHashScan(table, (xmlHashScanner) xmlDebugDumpEntityCallback,
+                    output);
+    } else
+        fprintf(output, "No entities in external subset\n");
+}
+
+/**
+ * xmlLsCountNode:
+ * @node:  the node to count
+ *
+ * Count the children of @node.
+ *
+ * Returns the number of children of @node.
+ */
+int
+xmlLsCountNode(xmlNodePtr node) {
+    int ret = 0;
+    xmlNodePtr list = NULL;
+    
+    if (node == NULL)
+	return(0);
+
+    switch (node->type) {
+	case XML_ELEMENT_NODE:
+	    list = node->children;
+	    break;
+	case XML_DOCUMENT_NODE:
+	case XML_HTML_DOCUMENT_NODE:
+#ifdef LIBXML_DOCB_ENABLED
+	case XML_DOCB_DOCUMENT_NODE:
+#endif
+	    list = ((xmlDocPtr) node)->children;
+	    break;
+	case XML_ATTRIBUTE_NODE:
+	    list = ((xmlAttrPtr) node)->children;
+	    break;
+	case XML_TEXT_NODE:
+	case XML_CDATA_SECTION_NODE:
+	case XML_PI_NODE:
+	case XML_COMMENT_NODE:
+	    if (node->content != NULL) {
+		ret = xmlStrlen(node->content);
+            }
+	    break;
+	case XML_ENTITY_REF_NODE:
+	case XML_DOCUMENT_TYPE_NODE:
+	case XML_ENTITY_NODE:
+	case XML_DOCUMENT_FRAG_NODE:
+	case XML_NOTATION_NODE:
+	case XML_DTD_NODE:
+        case XML_ELEMENT_DECL:
+        case XML_ATTRIBUTE_DECL:
+        case XML_ENTITY_DECL:
+	case XML_NAMESPACE_DECL:
+	case XML_XINCLUDE_START:
+	case XML_XINCLUDE_END:
+	    ret = 1;
+	    break;
+    }
+    for (;list != NULL;ret++) 
+        list = list->next;
+    return(ret);
+}
+
+/**
+ * xmlLsOneNode:
+ * @output:  the FILE * for the output
+ * @node:  the node to dump
+ *
+ * Dump to @output the type and name of @node.
+ */
+void
+xmlLsOneNode(FILE *output, xmlNodePtr node) {
+    if (node == NULL) {
+	fprintf(output, "NULL\n");
+	return;
+    }
+    switch (node->type) {
+	case XML_ELEMENT_NODE:
+	    fprintf(output, "-");
+	    break;
+	case XML_ATTRIBUTE_NODE:
+	    fprintf(output, "a");
+	    break;
+	case XML_TEXT_NODE:
+	    fprintf(output, "t");
+	    break;
+	case XML_CDATA_SECTION_NODE:
+	    fprintf(output, "C");
+	    break;
+	case XML_ENTITY_REF_NODE:
+	    fprintf(output, "e");
+	    break;
+	case XML_ENTITY_NODE:
+	    fprintf(output, "E");
+	    break;
+	case XML_PI_NODE:
+	    fprintf(output, "p");
+	    break;
+	case XML_COMMENT_NODE:
+	    fprintf(output, "c");
+	    break;
+	case XML_DOCUMENT_NODE:
+	    fprintf(output, "d");
+	    break;
+	case XML_HTML_DOCUMENT_NODE:
+	    fprintf(output, "h");
+	    break;
+	case XML_DOCUMENT_TYPE_NODE:
+	    fprintf(output, "T");
+	    break;
+	case XML_DOCUMENT_FRAG_NODE:
+	    fprintf(output, "F");
+	    break;
+	case XML_NOTATION_NODE:
+	    fprintf(output, "N");
+	    break;
+	case XML_NAMESPACE_DECL:
+	    fprintf(output, "n");
+	    break;
+	default:
+	    fprintf(output, "?");
+    }
+    if (node->type != XML_NAMESPACE_DECL) {
+	if (node->properties != NULL)
+	    fprintf(output, "a");
+	else	
+	    fprintf(output, "-");
+	if (node->nsDef != NULL) 
+	    fprintf(output, "n");
+	else	
+	    fprintf(output, "-");
+    }
+
+    fprintf(output, " %8d ", xmlLsCountNode(node));
+
+    switch (node->type) {
+	case XML_ELEMENT_NODE:
+	    if (node->name != NULL)
+		fprintf(output, "%s", (const char *) node->name);
+	    break;
+	case XML_ATTRIBUTE_NODE:
+	    if (node->name != NULL)
+		fprintf(output, "%s", (const char *) node->name);
+	    break;
+	case XML_TEXT_NODE:
+	    if (node->content != NULL) {
+		xmlDebugDumpString(output, node->content);
+            }
+	    break;
+	case XML_CDATA_SECTION_NODE:
+	    break;
+	case XML_ENTITY_REF_NODE:
+	    if (node->name != NULL)
+		fprintf(output, "%s", (const char *) node->name);
+	    break;
+	case XML_ENTITY_NODE:
+	    if (node->name != NULL)
+		fprintf(output, "%s", (const char *) node->name);
+	    break;
+	case XML_PI_NODE:
+	    if (node->name != NULL)
+		fprintf(output, "%s", (const char *) node->name);
+	    break;
+	case XML_COMMENT_NODE:
+	    break;
+	case XML_DOCUMENT_NODE:
+	    break;
+	case XML_HTML_DOCUMENT_NODE:
+	    break;
+	case XML_DOCUMENT_TYPE_NODE:
+	    break;
+	case XML_DOCUMENT_FRAG_NODE:
+	    break;
+	case XML_NOTATION_NODE:
+	    break;
+	case XML_NAMESPACE_DECL: {
+	    xmlNsPtr ns = (xmlNsPtr) node;
+
+	    if (ns->prefix == NULL)
+		fprintf(output, "default -> %s", ns->href);
+	    else
+		fprintf(output, "%s -> %s", ns->prefix, ns->href);
+	    break;
+	}
+	default:
+	    if (node->name != NULL)
+		fprintf(output, "%s", (const char *) node->name);
+    }
+    fprintf(output, "\n");
+}
+
+/**
+ * xmlBoolToText:
+ * @boolval: a bool to turn into text
+ *
+ * Convenient way to turn bool into text 
+ *
+ * Returns a pointer to either "True" or "False"
+ */
+const char *
+xmlBoolToText(int boolval)
+{
+    if (boolval)
+        return("True");
+    else
+        return("False");
+}
+
+/****************************************************************
+ *								*
+ *	 	The XML shell related functions			*
+ *								*
+ ****************************************************************/
+
+
+
+/*
+ * TODO: Improvement/cleanups for the XML shell
+ *     - allow to shell out an editor on a subpart
+ *     - cleanup function registrations (with help) and calling
+ *     - provide registration routines
+ */
+
+/**
+ * xmlShellPrintXPathError:
+ * @errorType: valid xpath error id
+ * @arg: the argument that cause xpath to fail
+ *
+ * Print the xpath error to libxml default error channel
+ */
+void
+xmlShellPrintXPathError(int errorType, const char *arg)
+{
+    const char *default_arg = "Result";
+
+    if (!arg)
+        arg = default_arg;
+
+    switch (errorType) {
+        case XPATH_UNDEFINED:
+            xmlGenericError(xmlGenericErrorContext,
+                            "%s: no such node\n", arg);
+            break;
+
+        case XPATH_BOOLEAN:
+            xmlGenericError(xmlGenericErrorContext,
+                            "%s is a Boolean\n", arg);
+            break;
+        case XPATH_NUMBER:
+            xmlGenericError(xmlGenericErrorContext,
+                            "%s is a number\n", arg);
+            break;
+        case XPATH_STRING:
+            xmlGenericError(xmlGenericErrorContext,
+                            "%s is a string\n", arg);
+            break;
+        case XPATH_POINT:
+            xmlGenericError(xmlGenericErrorContext,
+                            "%s is a point\n", arg);
+            break;
+        case XPATH_RANGE:
+            xmlGenericError(xmlGenericErrorContext,
+                            "%s is a range\n", arg);
+            break;
+        case XPATH_LOCATIONSET:
+            xmlGenericError(xmlGenericErrorContext,
+                            "%s is a range\n", arg);
+            break;
+        case XPATH_USERS:
+            xmlGenericError(xmlGenericErrorContext,
+                            "%s is user-defined\n", arg);
+            break;
+        case XPATH_XSLT_TREE:
+            xmlGenericError(xmlGenericErrorContext,
+                            "%s is an XSLT value tree\n", arg);
+            break;
+    }
+    xmlGenericError(xmlGenericErrorContext,
+                    "Try casting the result string function (xpath builtin)\n",
+                    arg);
+}
+
+
+#ifdef LIBXML_OUTPUT_ENABLED
+/**
+ * xmlShellPrintNodeCtxt:
+ * @ctxt : a non-null shell context
+ * @node : a non-null node to print to the output FILE
+ *
+ * Print node to the output FILE
+ */
+static void
+xmlShellPrintNodeCtxt(xmlShellCtxtPtr ctxt,xmlNodePtr node)
+{
+    FILE *fp;
+
+    if (!node)
+        return;
+    if (ctxt == NULL)
+	fp = stdout;
+    else
+	fp = ctxt->output;
+
+    if (node->type == XML_DOCUMENT_NODE)
+        xmlDocDump(fp, (xmlDocPtr) node);
+    else if (node->type == XML_ATTRIBUTE_NODE)
+        xmlDebugDumpAttrList(fp, (xmlAttrPtr) node, 0);
+    else
+        xmlElemDump(fp, node->doc, node);
+
+    fprintf(fp, "\n");
+}
+
+/**
+ * xmlShellPrintNode:
+ * @node : a non-null node to print to the output FILE
+ *
+ * Print node to the output FILE
+ */
+void
+xmlShellPrintNode(xmlNodePtr node)
+{
+    xmlShellPrintNodeCtxt(NULL, node);
+}
+#endif /* LIBXML_OUTPUT_ENABLED */
+
+/**
+ * xmlShellPrintXPathResultCtxt:
+ * @ctxt: a valid shell context
+ * @list: a valid result generated by an xpath evaluation
+ *
+ * Prints result to the output FILE
+ */
+static void
+xmlShellPrintXPathResultCtxt(xmlShellCtxtPtr ctxt,xmlXPathObjectPtr list)
+{
+    if (!ctxt)
+       return;
+
+    if (list != NULL) {
+        switch (list->type) {
+            case XPATH_NODESET:{
+#ifdef LIBXML_OUTPUT_ENABLED
+                    int indx;
+
+                    if (list->nodesetval) {
+                        for (indx = 0; indx < list->nodesetval->nodeNr;
+                             indx++) {
+                            xmlShellPrintNodeCtxt(ctxt,
+				    list->nodesetval->nodeTab[indx]);
+                        }
+                    } else {
+                        xmlGenericError(xmlGenericErrorContext,
+                                        "Empty node set\n");
+                    }
+                    break;
+#else
+		    xmlGenericError(xmlGenericErrorContext,
+				    "Node set\n");
+#endif /* LIBXML_OUTPUT_ENABLED */
+                }
+            case XPATH_BOOLEAN:
+                xmlGenericError(xmlGenericErrorContext,
+                                "Is a Boolean:%s\n",
+                                xmlBoolToText(list->boolval));
+                break;
+            case XPATH_NUMBER:
+                xmlGenericError(xmlGenericErrorContext,
+                                "Is a number:%0g\n", list->floatval);
+                break;
+            case XPATH_STRING:
+                xmlGenericError(xmlGenericErrorContext,
+                                "Is a string:%s\n", list->stringval);
+                break;
+
+            default:
+                xmlShellPrintXPathError(list->type, NULL);
+        }
+    }
+}
+
+/**
+ * xmlShellPrintXPathResult:
+ * @list: a valid result generated by an xpath evaluation
+ *
+ * Prints result to the output FILE
+ */
+void
+xmlShellPrintXPathResult(xmlXPathObjectPtr list)
+{
+    xmlShellPrintXPathResultCtxt(NULL, list);
+}
+
+/**
+ * xmlShellList:
+ * @ctxt:  the shell context
+ * @arg:  unused
+ * @node:  a node
+ * @node2:  unused
+ *
+ * Implements the XML shell function "ls"
+ * Does an Unix like listing of the given node (like a directory)
+ *
+ * Returns 0
+ */
+int
+xmlShellList(xmlShellCtxtPtr ctxt,
+             char *arg ATTRIBUTE_UNUSED, xmlNodePtr node,
+             xmlNodePtr node2 ATTRIBUTE_UNUSED)
+{
+    xmlNodePtr cur;
+    if (!ctxt)
+        return (0);
+    if (node == NULL) {
+	fprintf(ctxt->output, "NULL\n");
+	return (0);
+    }
+    if ((node->type == XML_DOCUMENT_NODE) ||
+        (node->type == XML_HTML_DOCUMENT_NODE)) {
+        cur = ((xmlDocPtr) node)->children;
+    } else if (node->type == XML_NAMESPACE_DECL) {
+        xmlLsOneNode(ctxt->output, node);
+        return (0);
+    } else if (node->children != NULL) {
+        cur = node->children;
+    } else {
+        xmlLsOneNode(ctxt->output, node);
+        return (0);
+    }
+    while (cur != NULL) {
+        xmlLsOneNode(ctxt->output, cur);
+        cur = cur->next;
+    }
+    return (0);
+}
+
+/**
+ * xmlShellBase:
+ * @ctxt:  the shell context
+ * @arg:  unused
+ * @node:  a node
+ * @node2:  unused
+ *
+ * Implements the XML shell function "base"
+ * dumps the current XML base of the node
+ *
+ * Returns 0
+ */
+int
+xmlShellBase(xmlShellCtxtPtr ctxt,
+             char *arg ATTRIBUTE_UNUSED, xmlNodePtr node,
+             xmlNodePtr node2 ATTRIBUTE_UNUSED)
+{
+    xmlChar *base;
+    if (!ctxt)
+        return 0;
+    if (node == NULL) {
+	fprintf(ctxt->output, "NULL\n");
+	return (0);
+    }    
+
+    base = xmlNodeGetBase(node->doc, node);
+
+    if (base == NULL) {
+        fprintf(ctxt->output, " No base found !!!\n");
+    } else {
+        fprintf(ctxt->output, "%s\n", base);
+        xmlFree(base);
+    }
+    return (0);
+}
+
+#ifdef LIBXML_TREE_ENABLED
+/**
+ * xmlShellSetBase:
+ * @ctxt:  the shell context
+ * @arg:  the new base
+ * @node:  a node
+ * @node2:  unused
+ *
+ * Implements the XML shell function "setbase"
+ * change the current XML base of the node
+ *
+ * Returns 0
+ */
+static int
+xmlShellSetBase(xmlShellCtxtPtr ctxt ATTRIBUTE_UNUSED,
+             char *arg ATTRIBUTE_UNUSED, xmlNodePtr node,
+             xmlNodePtr node2 ATTRIBUTE_UNUSED)
+{
+    xmlNodeSetBase(node, (xmlChar*) arg);
+    return (0);
+}
+#endif
+
+/**
+ * xmlShellGrep:
+ * @ctxt:  the shell context
+ * @arg:  the string or regular expression to find
+ * @node:  a node
+ * @node2:  unused
+ *
+ * Implements the XML shell function "grep"
+ * dumps informations about the node (namespace, attributes, content).
+ *
+ * Returns 0
+ */
+static int
+xmlShellGrep(xmlShellCtxtPtr ctxt ATTRIBUTE_UNUSED,
+            char *arg, xmlNodePtr node, xmlNodePtr node2 ATTRIBUTE_UNUSED)
+{
+    if (!ctxt)
+        return (0);
+    if (node == NULL)
+	return (0);
+    if (arg == NULL)
+	return (0);
+#ifdef LIBXML_REGEXP_ENABLED
+    if ((xmlStrchr((xmlChar *) arg, '?')) ||
+	(xmlStrchr((xmlChar *) arg, '*')) ||
+	(xmlStrchr((xmlChar *) arg, '.')) ||
+	(xmlStrchr((xmlChar *) arg, '['))) {
+    }
+#endif
+    while (node != NULL) {
+        if (node->type == XML_COMMENT_NODE) {
+	    if (xmlStrstr(node->content, (xmlChar *) arg)) {
+
+		fprintf(ctxt->output, "%s : ", xmlGetNodePath(node));
+                xmlShellList(ctxt, NULL, node, NULL);
+	    }
+        } else if (node->type == XML_TEXT_NODE) {
+	    if (xmlStrstr(node->content, (xmlChar *) arg)) {
+
+		fprintf(ctxt->output, "%s : ", xmlGetNodePath(node->parent));
+                xmlShellList(ctxt, NULL, node->parent, NULL);
+	    }
+        }
+
+        /*
+         * Browse the full subtree, deep first
+         */
+
+        if ((node->type == XML_DOCUMENT_NODE) ||
+            (node->type == XML_HTML_DOCUMENT_NODE)) {
+            node = ((xmlDocPtr) node)->children;
+        } else if ((node->children != NULL)
+                   && (node->type != XML_ENTITY_REF_NODE)) {
+            /* deep first */
+            node = node->children;
+        } else if (node->next != NULL) {
+            /* then siblings */
+            node = node->next;
+        } else {
+            /* go up to parents->next if needed */
+            while (node != NULL) {
+                if (node->parent != NULL) {
+                    node = node->parent;
+                }
+                if (node->next != NULL) {
+                    node = node->next;
+                    break;
+                }
+                if (node->parent == NULL) {
+                    node = NULL;
+                    break;
+                }
+            }
+	}
+    }
+    return (0);
+}
+
+/**
+ * xmlShellDir:
+ * @ctxt:  the shell context
+ * @arg:  unused
+ * @node:  a node
+ * @node2:  unused
+ *
+ * Implements the XML shell function "dir"
+ * dumps informations about the node (namespace, attributes, content).
+ *
+ * Returns 0
+ */
+int
+xmlShellDir(xmlShellCtxtPtr ctxt ATTRIBUTE_UNUSED,
+            char *arg ATTRIBUTE_UNUSED, xmlNodePtr node,
+            xmlNodePtr node2 ATTRIBUTE_UNUSED)
+{
+    if (!ctxt)
+        return (0);
+    if (node == NULL) {
+	fprintf(ctxt->output, "NULL\n");
+	return (0);
+    }    
+    if ((node->type == XML_DOCUMENT_NODE) ||
+        (node->type == XML_HTML_DOCUMENT_NODE)) {
+        xmlDebugDumpDocumentHead(ctxt->output, (xmlDocPtr) node);
+    } else if (node->type == XML_ATTRIBUTE_NODE) {
+        xmlDebugDumpAttr(ctxt->output, (xmlAttrPtr) node, 0);
+    } else {
+        xmlDebugDumpOneNode(ctxt->output, node, 0);
+    }
+    return (0);
+}
+
+#ifdef LIBXML_SCHEMAS_ENABLED
+/**
+ * xmlShellRNGValidate:
+ * @ctxt:  the shell context
+ * @schemas:  the path to the Relax-NG schemas
+ * @node:  a node
+ * @node2:  unused
+ *
+ * Implements the XML shell function "relaxng"
+ * validating the instance against a Relax-NG schemas
+ *
+ * Returns 0
+ */
+static int
+xmlShellRNGValidate(xmlShellCtxtPtr sctxt, char *schemas,
+            xmlNodePtr node ATTRIBUTE_UNUSED,
+	    xmlNodePtr node2 ATTRIBUTE_UNUSED)
+{
+    xmlRelaxNGPtr relaxngschemas;
+    xmlRelaxNGParserCtxtPtr ctxt;
+    xmlRelaxNGValidCtxtPtr vctxt;
+    int ret;
+
+    ctxt = xmlRelaxNGNewParserCtxt(schemas);
+    xmlRelaxNGSetParserErrors(ctxt,
+	    (xmlRelaxNGValidityErrorFunc) fprintf,
+	    (xmlRelaxNGValidityWarningFunc) fprintf,
+	    stderr);
+    relaxngschemas = xmlRelaxNGParse(ctxt);
+    xmlRelaxNGFreeParserCtxt(ctxt);
+    if (relaxngschemas == NULL) {
+	xmlGenericError(xmlGenericErrorContext,
+		"Relax-NG schema %s failed to compile\n", schemas);
+	return(-1);
+    }
+    vctxt = xmlRelaxNGNewValidCtxt(relaxngschemas);
+    xmlRelaxNGSetValidErrors(vctxt,
+	    (xmlRelaxNGValidityErrorFunc) fprintf,
+	    (xmlRelaxNGValidityWarningFunc) fprintf,
+	    stderr);
+    ret = xmlRelaxNGValidateDoc(vctxt, sctxt->doc);
+    if (ret == 0) {
+	fprintf(stderr, "%s validates\n", sctxt->filename);
+    } else if (ret > 0) {
+	fprintf(stderr, "%s fails to validate\n", sctxt->filename);
+    } else {
+	fprintf(stderr, "%s validation generated an internal error\n",
+	       sctxt->filename);
+    }
+    xmlRelaxNGFreeValidCtxt(vctxt);
+    if (relaxngschemas != NULL)
+	xmlRelaxNGFree(relaxngschemas);
+    return(0);
+}
+#endif
+
+#ifdef LIBXML_OUTPUT_ENABLED
+/**
+ * xmlShellCat:
+ * @ctxt:  the shell context
+ * @arg:  unused
+ * @node:  a node
+ * @node2:  unused
+ *
+ * Implements the XML shell function "cat"
+ * dumps the serialization node content (XML or HTML).
+ *
+ * Returns 0
+ */
+int
+xmlShellCat(xmlShellCtxtPtr ctxt, char *arg ATTRIBUTE_UNUSED,
+            xmlNodePtr node, xmlNodePtr node2 ATTRIBUTE_UNUSED)
+{
+    if (!ctxt)
+        return (0);
+    if (node == NULL) {
+	fprintf(ctxt->output, "NULL\n");
+	return (0);
+    }    
+    if (ctxt->doc->type == XML_HTML_DOCUMENT_NODE) {
+#ifdef LIBXML_HTML_ENABLED
+        if (node->type == XML_HTML_DOCUMENT_NODE)
+            htmlDocDump(ctxt->output, (htmlDocPtr) node);
+        else
+            htmlNodeDumpFile(ctxt->output, ctxt->doc, node);
+#else
+        if (node->type == XML_DOCUMENT_NODE)
+            xmlDocDump(ctxt->output, (xmlDocPtr) node);
+        else
+            xmlElemDump(ctxt->output, ctxt->doc, node);
+#endif /* LIBXML_HTML_ENABLED */
+    } else {
+        if (node->type == XML_DOCUMENT_NODE)
+            xmlDocDump(ctxt->output, (xmlDocPtr) node);
+        else
+            xmlElemDump(ctxt->output, ctxt->doc, node);
+    }
+    fprintf(ctxt->output, "\n");
+    return (0);
+}
+#endif /* LIBXML_OUTPUT_ENABLED */
+
+/**
+ * xmlShellLoad:
+ * @ctxt:  the shell context
+ * @filename:  the file name
+ * @node:  unused
+ * @node2:  unused
+ *
+ * Implements the XML shell function "load"
+ * loads a new document specified by the filename
+ *
+ * Returns 0 or -1 if loading failed
+ */
+int
+xmlShellLoad(xmlShellCtxtPtr ctxt, char *filename,
+             xmlNodePtr node ATTRIBUTE_UNUSED,
+             xmlNodePtr node2 ATTRIBUTE_UNUSED)
+{
+    xmlDocPtr doc;
+    int html = 0;
+
+    if (ctxt->doc != NULL)
+        html = (ctxt->doc->type == XML_HTML_DOCUMENT_NODE);
+
+    if (html) {
+#ifdef LIBXML_HTML_ENABLED
+        doc = htmlParseFile(filename, NULL);
+#else
+        fprintf(ctxt->output, "HTML support not compiled in\n");
+        doc = NULL;
+#endif /* LIBXML_HTML_ENABLED */
+    } else {
+        doc = xmlReadFile(filename,NULL,0);
+    }
+    if (doc != NULL) {
+        if (ctxt->loaded == 1) {
+            xmlFreeDoc(ctxt->doc);
+        }
+        ctxt->loaded = 1;
+#ifdef LIBXML_XPATH_ENABLED
+        xmlXPathFreeContext(ctxt->pctxt);
+#endif /* LIBXML_XPATH_ENABLED */
+        xmlFree(ctxt->filename);
+        ctxt->doc = doc;
+        ctxt->node = (xmlNodePtr) doc;
+#ifdef LIBXML_XPATH_ENABLED
+        ctxt->pctxt = xmlXPathNewContext(doc);
+#endif /* LIBXML_XPATH_ENABLED */
+        ctxt->filename = (char *) xmlCanonicPath((xmlChar *) filename);
+    } else
+        return (-1);
+    return (0);
+}
+
+#ifdef LIBXML_OUTPUT_ENABLED
+/**
+ * xmlShellWrite:
+ * @ctxt:  the shell context
+ * @filename:  the file name
+ * @node:  a node in the tree
+ * @node2:  unused
+ *
+ * Implements the XML shell function "write"
+ * Write the current node to the filename, it saves the serialization
+ * of the subtree under the @node specified
+ *
+ * Returns 0 or -1 in case of error
+ */
+int
+xmlShellWrite(xmlShellCtxtPtr ctxt, char *filename, xmlNodePtr node,
+              xmlNodePtr node2 ATTRIBUTE_UNUSED)
+{
+    if (node == NULL)
+        return (-1);
+    if ((filename == NULL) || (filename[0] == 0)) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "Write command requires a filename argument\n");
+        return (-1);
+    }
+#ifdef W_OK
+    if (access((char *) filename, W_OK)) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "Cannot write to %s\n", filename);
+        return (-1);
+    }
+#endif
+    switch (node->type) {
+        case XML_DOCUMENT_NODE:
+            if (xmlSaveFile((char *) filename, ctxt->doc) < -1) {
+                xmlGenericError(xmlGenericErrorContext,
+                                "Failed to write to %s\n", filename);
+                return (-1);
+            }
+            break;
+        case XML_HTML_DOCUMENT_NODE:
+#ifdef LIBXML_HTML_ENABLED
+            if (htmlSaveFile((char *) filename, ctxt->doc) < 0) {
+                xmlGenericError(xmlGenericErrorContext,
+                                "Failed to write to %s\n", filename);
+                return (-1);
+            }
+#else
+            if (xmlSaveFile((char *) filename, ctxt->doc) < -1) {
+                xmlGenericError(xmlGenericErrorContext,
+                                "Failed to write to %s\n", filename);
+                return (-1);
+            }
+#endif /* LIBXML_HTML_ENABLED */
+            break;
+        default:{
+                FILE *f;
+
+                f = fopen((char *) filename, "w");
+                if (f == NULL) {
+                    xmlGenericError(xmlGenericErrorContext,
+                                    "Failed to write to %s\n", filename);
+                    return (-1);
+                }
+                xmlElemDump(f, ctxt->doc, node);
+                fclose(f);
+            }
+    }
+    return (0);
+}
+
+/**
+ * xmlShellSave:
+ * @ctxt:  the shell context
+ * @filename:  the file name (optional)
+ * @node:  unused
+ * @node2:  unused
+ *
+ * Implements the XML shell function "save"
+ * Write the current document to the filename, or it's original name
+ *
+ * Returns 0 or -1 in case of error
+ */
+int
+xmlShellSave(xmlShellCtxtPtr ctxt, char *filename,
+             xmlNodePtr node ATTRIBUTE_UNUSED,
+             xmlNodePtr node2 ATTRIBUTE_UNUSED)
+{
+    if (ctxt->doc == NULL)
+        return (-1);
+    if ((filename == NULL) || (filename[0] == 0))
+        filename = ctxt->filename;
+#ifdef W_OK
+    if (access((char *) filename, W_OK)) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "Cannot save to %s\n", filename);
+        return (-1);
+    }
+#endif
+    switch (ctxt->doc->type) {
+        case XML_DOCUMENT_NODE:
+            if (xmlSaveFile((char *) filename, ctxt->doc) < 0) {
+                xmlGenericError(xmlGenericErrorContext,
+                                "Failed to save to %s\n", filename);
+            }
+            break;
+        case XML_HTML_DOCUMENT_NODE:
+#ifdef LIBXML_HTML_ENABLED
+            if (htmlSaveFile((char *) filename, ctxt->doc) < 0) {
+                xmlGenericError(xmlGenericErrorContext,
+                                "Failed to save to %s\n", filename);
+            }
+#else
+            if (xmlSaveFile((char *) filename, ctxt->doc) < 0) {
+                xmlGenericError(xmlGenericErrorContext,
+                                "Failed to save to %s\n", filename);
+            }
+#endif /* LIBXML_HTML_ENABLED */
+            break;
+        default:
+            xmlGenericError(xmlGenericErrorContext,
+	    "To save to subparts of a document use the 'write' command\n");
+            return (-1);
+
+    }
+    return (0);
+}
+#endif /* LIBXML_OUTPUT_ENABLED */
+
+#ifdef LIBXML_VALID_ENABLED
+/**
+ * xmlShellValidate:
+ * @ctxt:  the shell context
+ * @dtd:  the DTD URI (optional)
+ * @node:  unused
+ * @node2:  unused
+ *
+ * Implements the XML shell function "validate"
+ * Validate the document, if a DTD path is provided, then the validation
+ * is done against the given DTD.
+ *
+ * Returns 0 or -1 in case of error
+ */
+int
+xmlShellValidate(xmlShellCtxtPtr ctxt, char *dtd,
+                 xmlNodePtr node ATTRIBUTE_UNUSED,
+                 xmlNodePtr node2 ATTRIBUTE_UNUSED)
+{
+    xmlValidCtxt vctxt;
+    int res = -1;
+
+    vctxt.userData = stderr;
+    vctxt.error = (xmlValidityErrorFunc) fprintf;
+    vctxt.warning = (xmlValidityWarningFunc) fprintf;
+
+    if ((dtd == NULL) || (dtd[0] == 0)) {
+        res = xmlValidateDocument(&vctxt, ctxt->doc);
+    } else {
+        xmlDtdPtr subset;
+
+        subset = xmlParseDTD(NULL, (xmlChar *) dtd);
+        if (subset != NULL) {
+            res = xmlValidateDtd(&vctxt, ctxt->doc, subset);
+
+            xmlFreeDtd(subset);
+        }
+    }
+    return (res);
+}
+#endif /* LIBXML_VALID_ENABLED */
+
+/**
+ * xmlShellDu:
+ * @ctxt:  the shell context
+ * @arg:  unused
+ * @tree:  a node defining a subtree
+ * @node2:  unused
+ *
+ * Implements the XML shell function "du"
+ * show the structure of the subtree under node @tree
+ * If @tree is null, the command works on the current node.
+ *
+ * Returns 0 or -1 in case of error
+ */
+int
+xmlShellDu(xmlShellCtxtPtr ctxt,
+           char *arg ATTRIBUTE_UNUSED, xmlNodePtr tree,
+           xmlNodePtr node2 ATTRIBUTE_UNUSED)
+{
+    xmlNodePtr node;
+    int indent = 0, i;
+
+    if (!ctxt)
+	return (-1);
+
+    if (tree == NULL)
+        return (-1);
+    node = tree;
+    while (node != NULL) {
+        if ((node->type == XML_DOCUMENT_NODE) ||
+            (node->type == XML_HTML_DOCUMENT_NODE)) {
+            fprintf(ctxt->output, "/\n");
+        } else if (node->type == XML_ELEMENT_NODE) {
+            for (i = 0; i < indent; i++)
+                fprintf(ctxt->output, "  ");
+            fprintf(ctxt->output, "%s\n", node->name);
+        } else {
+        }
+
+        /*
+         * Browse the full subtree, deep first
+         */
+
+        if ((node->type == XML_DOCUMENT_NODE) ||
+            (node->type == XML_HTML_DOCUMENT_NODE)) {
+            node = ((xmlDocPtr) node)->children;
+        } else if ((node->children != NULL)
+                   && (node->type != XML_ENTITY_REF_NODE)) {
+            /* deep first */
+            node = node->children;
+            indent++;
+        } else if ((node != tree) && (node->next != NULL)) {
+            /* then siblings */
+            node = node->next;
+        } else if (node != tree) {
+            /* go up to parents->next if needed */
+            while (node != tree) {
+                if (node->parent != NULL) {
+                    node = node->parent;
+                    indent--;
+                }
+                if ((node != tree) && (node->next != NULL)) {
+                    node = node->next;
+                    break;
+                }
+                if (node->parent == NULL) {
+                    node = NULL;
+                    break;
+                }
+                if (node == tree) {
+                    node = NULL;
+                    break;
+                }
+            }
+            /* exit condition */
+            if (node == tree)
+                node = NULL;
+        } else
+            node = NULL;
+    }
+    return (0);
+}
+
+/**
+ * xmlShellPwd:
+ * @ctxt:  the shell context
+ * @buffer:  the output buffer
+ * @node:  a node 
+ * @node2:  unused
+ *
+ * Implements the XML shell function "pwd"
+ * Show the full path from the root to the node, if needed building
+ * thumblers when similar elements exists at a given ancestor level.
+ * The output is compatible with XPath commands.
+ *
+ * Returns 0 or -1 in case of error
+ */
+int
+xmlShellPwd(xmlShellCtxtPtr ctxt ATTRIBUTE_UNUSED, char *buffer,
+            xmlNodePtr node, xmlNodePtr node2 ATTRIBUTE_UNUSED)
+{
+    xmlChar *path;
+
+    if (node == NULL)
+        return (-1);
+
+    path = xmlGetNodePath(node);
+    if (path == NULL)
+	return (-1);
+
+    /*
+     * This test prevents buffer overflow, because this routine
+     * is only called by xmlShell, in which the second argument is
+     * 500 chars long.
+     * It is a dirty hack before a cleaner solution is found.
+     * Documentation should mention that the second argument must
+     * be at least 500 chars long, and could be stripped if too long.
+     */
+    snprintf(buffer, 499, "%s", path);
+    buffer[499] = '0';
+    xmlFree(path);
+
+    return (0);
+}
+
+/**
+ * xmlShell:
+ * @doc:  the initial document
+ * @filename:  the output buffer
+ * @input:  the line reading function
+ * @output:  the output FILE*, defaults to stdout if NULL
+ *
+ * Implements the XML shell 
+ * This allow to load, validate, view, modify and save a document
+ * using a environment similar to a UNIX commandline.
+ */
+void
+xmlShell(xmlDocPtr doc, char *filename, xmlShellReadlineFunc input,
+         FILE * output)
+{
+    char prompt[500] = "/ > ";
+    char *cmdline = NULL, *cur;
+    int nbargs;
+    char command[100];
+    char arg[400];
+    int i;
+    xmlShellCtxtPtr ctxt;
+    xmlXPathObjectPtr list;
+
+    if (doc == NULL)
+        return;
+    if (filename == NULL)
+        return;
+    if (input == NULL)
+        return;
+    if (output == NULL)
+        output = stdout;
+    ctxt = (xmlShellCtxtPtr) xmlMalloc(sizeof(xmlShellCtxt));
+    if (ctxt == NULL)
+        return;
+    ctxt->loaded = 0;
+    ctxt->doc = doc;
+    ctxt->input = input;
+    ctxt->output = output;
+    ctxt->filename = (char *) xmlStrdup((xmlChar *) filename);
+    ctxt->node = (xmlNodePtr) ctxt->doc;
+
+#ifdef LIBXML_XPATH_ENABLED
+    ctxt->pctxt = xmlXPathNewContext(ctxt->doc);
+    if (ctxt->pctxt == NULL) {
+        xmlFree(ctxt);
+        return;
+    }
+#endif /* LIBXML_XPATH_ENABLED */
+    while (1) {
+        if (ctxt->node == (xmlNodePtr) ctxt->doc)
+            snprintf(prompt, sizeof(prompt), "%s > ", "/");
+        else if ((ctxt->node != NULL) && (ctxt->node->name))
+            snprintf(prompt, sizeof(prompt), "%s > ", ctxt->node->name);
+        else
+            snprintf(prompt, sizeof(prompt), "? > ");
+        prompt[sizeof(prompt) - 1] = 0;
+
+        /*
+         * Get a new command line
+         */
+        cmdline = ctxt->input(prompt);
+        if (cmdline == NULL)
+            break;
+
+        /*
+         * Parse the command itself
+         */
+        cur = cmdline;
+        nbargs = 0;
+        while ((*cur == ' ') || (*cur == '\t'))
+            cur++;
+        i = 0;
+        while ((*cur != ' ') && (*cur != '\t') &&
+               (*cur != '\n') && (*cur != '\r')) {
+            if (*cur == 0)
+                break;
+            command[i++] = *cur++;
+        }
+        command[i] = 0;
+        if (i == 0)
+            continue;
+        nbargs++;
+
+        /*
+         * Parse the argument
+         */
+        while ((*cur == ' ') || (*cur == '\t'))
+            cur++;
+        i = 0;
+        while ((*cur != '\n') && (*cur != '\r') && (*cur != 0)) {
+            if (*cur == 0)
+                break;
+            arg[i++] = *cur++;
+        }
+        arg[i] = 0;
+        if (i != 0)
+            nbargs++;
+
+        /*
+         * start interpreting the command
+         */
+        if (!strcmp(command, "exit"))
+            break;
+        if (!strcmp(command, "quit"))
+            break;
+        if (!strcmp(command, "bye"))
+            break;
+		if (!strcmp(command, "help")) {
+		  fprintf(ctxt->output, "\tbase         display XML base of the node\n");
+		  fprintf(ctxt->output, "\tsetbase URI  change the XML base of the node\n");
+		  fprintf(ctxt->output, "\tbye          leave shell\n");
+		  fprintf(ctxt->output, "\tcat [node]   display node or current node\n");
+		  fprintf(ctxt->output, "\tcd [path]    change directory to path or to root\n");
+		  fprintf(ctxt->output, "\tdir [path]   dumps informations about the node (namespace, attributes, content)\n");
+		  fprintf(ctxt->output, "\tdu [path]    show the structure of the subtree under path or the current node\n");
+		  fprintf(ctxt->output, "\texit         leave shell\n");
+		  fprintf(ctxt->output, "\thelp         display this help\n");
+		  fprintf(ctxt->output, "\tfree         display memory usage\n");
+		  fprintf(ctxt->output, "\tload [name]  load a new document with name\n");
+		  fprintf(ctxt->output, "\tls [path]    list contents of path or the current directory\n");
+#ifdef LIBXML_XPATH_ENABLED
+		  fprintf(ctxt->output, "\txpath expr   evaluate the XPath expression in that context and print the result\n");
+#endif /* LIBXML_XPATH_ENABLED */
+		  fprintf(ctxt->output, "\tpwd          display current working directory\n");
+		  fprintf(ctxt->output, "\tquit         leave shell\n");
+#ifdef LIBXML_OUTPUT_ENABLED
+		  fprintf(ctxt->output, "\tsave [name]  save this document to name or the original name\n");
+		  fprintf(ctxt->output, "\twrite [name] write the current node to the filename\n");
+#endif /* LIBXML_OUTPUT_ENABLED */
+#ifdef LIBXML_VALID_ENABLED
+		  fprintf(ctxt->output, "\tvalidate     check the document for errors\n");
+#endif /* LIBXML_VALID_ENABLED */
+#ifdef LIBXML_SCHEMAS_ENABLED
+		  fprintf(ctxt->output, "\trelaxng rng  validate the document agaisnt the Relax-NG schemas\n");
+#endif
+		  fprintf(ctxt->output, "\tgrep string  search for a string in the subtree\n");
+#ifdef LIBXML_VALID_ENABLED
+        } else if (!strcmp(command, "validate")) {
+            xmlShellValidate(ctxt, arg, NULL, NULL);
+#endif /* LIBXML_VALID_ENABLED */
+        } else if (!strcmp(command, "load")) {
+            xmlShellLoad(ctxt, arg, NULL, NULL);
+#ifdef LIBXML_SCHEMAS_ENABLED
+        } else if (!strcmp(command, "relaxng")) {
+            xmlShellRNGValidate(ctxt, arg, NULL, NULL);
+#endif
+#ifdef LIBXML_OUTPUT_ENABLED
+        } else if (!strcmp(command, "save")) {
+            xmlShellSave(ctxt, arg, NULL, NULL);
+        } else if (!strcmp(command, "write")) {
+            xmlShellWrite(ctxt, arg, NULL, NULL);
+#endif /* LIBXML_OUTPUT_ENABLED */
+        } else if (!strcmp(command, "grep")) {
+            xmlShellGrep(ctxt, arg, ctxt->node, NULL);
+        } else if (!strcmp(command, "free")) {
+            if (arg[0] == 0) {
+                xmlMemShow(ctxt->output, 0);
+            } else {
+                int len = 0;
+
+                sscanf(arg, "%d", &len);
+                xmlMemShow(ctxt->output, len);
+            }
+        } else if (!strcmp(command, "pwd")) {
+            char dir[500];
+
+            if (!xmlShellPwd(ctxt, dir, ctxt->node, NULL))
+                fprintf(ctxt->output, "%s\n", dir);
+        } else if (!strcmp(command, "du")) {
+            xmlShellDu(ctxt, NULL, ctxt->node, NULL);
+        } else if (!strcmp(command, "base")) {
+            xmlShellBase(ctxt, NULL, ctxt->node, NULL);
+#ifdef LIBXML_XPATH_ENABLED
+        } else if (!strcmp(command, "xpath")) {
+            if (arg[0] == 0) {
+		xmlGenericError(xmlGenericErrorContext,
+				"xpath: expression required\n");
+	    } else {
+                ctxt->pctxt->node = ctxt->node;
+                list = xmlXPathEval((xmlChar *) arg, ctxt->pctxt);
+		xmlXPathDebugDumpObject(ctxt->output, list, 0);
+		xmlXPathFreeObject(list);
+	    }
+#endif /* LIBXML_XPATH_ENABLED */
+#ifdef LIBXML_TREE_ENABLED
+        } else if (!strcmp(command, "setbase")) {
+            xmlShellSetBase(ctxt, arg, ctxt->node, NULL);
+#endif
+        } else if ((!strcmp(command, "ls")) || (!strcmp(command, "dir"))) {
+            int dir = (!strcmp(command, "dir"));
+
+            if (arg[0] == 0) {
+                if (dir)
+                    xmlShellDir(ctxt, NULL, ctxt->node, NULL);
+                else
+                    xmlShellList(ctxt, NULL, ctxt->node, NULL);
+            } else {
+                ctxt->pctxt->node = ctxt->node;
+#ifdef LIBXML_XPATH_ENABLED
+                ctxt->pctxt->node = ctxt->node;
+                list = xmlXPathEval((xmlChar *) arg, ctxt->pctxt);
+#else
+                list = NULL;
+#endif /* LIBXML_XPATH_ENABLED */
+                if (list != NULL) {
+                    switch (list->type) {
+                        case XPATH_UNDEFINED:
+                            xmlGenericError(xmlGenericErrorContext,
+                                            "%s: no such node\n", arg);
+                            break;
+                        case XPATH_NODESET:{
+                                int indx;
+
+				if (list->nodesetval == NULL)
+				    break;
+
+                                for (indx = 0;
+                                     indx < list->nodesetval->nodeNr;
+                                     indx++) {
+                                    if (dir)
+                                        xmlShellDir(ctxt, NULL,
+                                                    list->nodesetval->
+                                                    nodeTab[indx], NULL);
+                                    else
+                                        xmlShellList(ctxt, NULL,
+                                                     list->nodesetval->
+                                                     nodeTab[indx], NULL);
+                                }
+                                break;
+                            }
+                        case XPATH_BOOLEAN:
+                            xmlGenericError(xmlGenericErrorContext,
+                                            "%s is a Boolean\n", arg);
+                            break;
+                        case XPATH_NUMBER:
+                            xmlGenericError(xmlGenericErrorContext,
+                                            "%s is a number\n", arg);
+                            break;
+                        case XPATH_STRING:
+                            xmlGenericError(xmlGenericErrorContext,
+                                            "%s is a string\n", arg);
+                            break;
+                        case XPATH_POINT:
+                            xmlGenericError(xmlGenericErrorContext,
+                                            "%s is a point\n", arg);
+                            break;
+                        case XPATH_RANGE:
+                            xmlGenericError(xmlGenericErrorContext,
+                                            "%s is a range\n", arg);
+                            break;
+                        case XPATH_LOCATIONSET:
+                            xmlGenericError(xmlGenericErrorContext,
+                                            "%s is a range\n", arg);
+                            break;
+                        case XPATH_USERS:
+                            xmlGenericError(xmlGenericErrorContext,
+                                            "%s is user-defined\n", arg);
+                            break;
+                        case XPATH_XSLT_TREE:
+                            xmlGenericError(xmlGenericErrorContext,
+                                            "%s is an XSLT value tree\n",
+                                            arg);
+                            break;
+                    }
+#ifdef LIBXML_XPATH_ENABLED
+                    xmlXPathFreeObject(list);
+#endif
+                } else {
+                    xmlGenericError(xmlGenericErrorContext,
+                                    "%s: no such node\n", arg);
+                }
+                ctxt->pctxt->node = NULL;
+            }
+        } else if (!strcmp(command, "cd")) {
+            if (arg[0] == 0) {
+                ctxt->node = (xmlNodePtr) ctxt->doc;
+            } else {
+#ifdef LIBXML_XPATH_ENABLED
+                ctxt->pctxt->node = ctxt->node;
+                list = xmlXPathEval((xmlChar *) arg, ctxt->pctxt);
+#else
+                list = NULL;
+#endif /* LIBXML_XPATH_ENABLED */
+                if (list != NULL) {
+                    switch (list->type) {
+                        case XPATH_UNDEFINED:
+                            xmlGenericError(xmlGenericErrorContext,
+                                            "%s: no such node\n", arg);
+                            break;
+                        case XPATH_NODESET:
+                            if (list->nodesetval != NULL) {
+				if (list->nodesetval->nodeNr == 1) {
+				    ctxt->node = list->nodesetval->nodeTab[0];
+				    if ((ctxt->node != NULL) &&
+				        (ctxt->node->type ==
+					 XML_NAMESPACE_DECL)) {
+					xmlGenericError(xmlGenericErrorContext,
+						    "cannot cd to namespace\n");
+					ctxt->node = NULL;
+				    }
+				} else
+				    xmlGenericError(xmlGenericErrorContext,
+						    "%s is a %d Node Set\n",
+						    arg,
+						    list->nodesetval->nodeNr);
+                            } else
+                                xmlGenericError(xmlGenericErrorContext,
+                                                "%s is an empty Node Set\n",
+                                                arg);
+                            break;
+                        case XPATH_BOOLEAN:
+                            xmlGenericError(xmlGenericErrorContext,
+                                            "%s is a Boolean\n", arg);
+                            break;
+                        case XPATH_NUMBER:
+                            xmlGenericError(xmlGenericErrorContext,
+                                            "%s is a number\n", arg);
+                            break;
+                        case XPATH_STRING:
+                            xmlGenericError(xmlGenericErrorContext,
+                                            "%s is a string\n", arg);
+                            break;
+                        case XPATH_POINT:
+                            xmlGenericError(xmlGenericErrorContext,
+                                            "%s is a point\n", arg);
+                            break;
+                        case XPATH_RANGE:
+                            xmlGenericError(xmlGenericErrorContext,
+                                            "%s is a range\n", arg);
+                            break;
+                        case XPATH_LOCATIONSET:
+                            xmlGenericError(xmlGenericErrorContext,
+                                            "%s is a range\n", arg);
+                            break;
+                        case XPATH_USERS:
+                            xmlGenericError(xmlGenericErrorContext,
+                                            "%s is user-defined\n", arg);
+                            break;
+                        case XPATH_XSLT_TREE:
+                            xmlGenericError(xmlGenericErrorContext,
+                                            "%s is an XSLT value tree\n",
+                                            arg);
+                            break;
+                    }
+#ifdef LIBXML_XPATH_ENABLED
+                    xmlXPathFreeObject(list);
+#endif
+                } else {
+                    xmlGenericError(xmlGenericErrorContext,
+                                    "%s: no such node\n", arg);
+                }
+                ctxt->pctxt->node = NULL;
+            }
+#ifdef LIBXML_OUTPUT_ENABLED
+        } else if (!strcmp(command, "cat")) {
+            if (arg[0] == 0) {
+                xmlShellCat(ctxt, NULL, ctxt->node, NULL);
+            } else {
+                ctxt->pctxt->node = ctxt->node;
+#ifdef LIBXML_XPATH_ENABLED
+                ctxt->pctxt->node = ctxt->node;
+                list = xmlXPathEval((xmlChar *) arg, ctxt->pctxt);
+#else
+                list = NULL;
+#endif /* LIBXML_XPATH_ENABLED */
+                if (list != NULL) {
+                    switch (list->type) {
+                        case XPATH_UNDEFINED:
+                            xmlGenericError(xmlGenericErrorContext,
+                                            "%s: no such node\n", arg);
+                            break;
+                        case XPATH_NODESET:{
+                                int indx;
+
+				if (list->nodesetval == NULL)
+				    break;
+
+                                for (indx = 0;
+                                     indx < list->nodesetval->nodeNr;
+                                     indx++) {
+                                    if (i > 0)
+                                        fprintf(ctxt->output, " -------\n");
+                                    xmlShellCat(ctxt, NULL,
+                                                list->nodesetval->
+                                                nodeTab[indx], NULL);
+                                }
+                                break;
+                            }
+                        case XPATH_BOOLEAN:
+                            xmlGenericError(xmlGenericErrorContext,
+                                            "%s is a Boolean\n", arg);
+                            break;
+                        case XPATH_NUMBER:
+                            xmlGenericError(xmlGenericErrorContext,
+                                            "%s is a number\n", arg);
+                            break;
+                        case XPATH_STRING:
+                            xmlGenericError(xmlGenericErrorContext,
+                                            "%s is a string\n", arg);
+                            break;
+                        case XPATH_POINT:
+                            xmlGenericError(xmlGenericErrorContext,
+                                            "%s is a point\n", arg);
+                            break;
+                        case XPATH_RANGE:
+                            xmlGenericError(xmlGenericErrorContext,
+                                            "%s is a range\n", arg);
+                            break;
+                        case XPATH_LOCATIONSET:
+                            xmlGenericError(xmlGenericErrorContext,
+                                            "%s is a range\n", arg);
+                            break;
+                        case XPATH_USERS:
+                            xmlGenericError(xmlGenericErrorContext,
+                                            "%s is user-defined\n", arg);
+                            break;
+                        case XPATH_XSLT_TREE:
+                            xmlGenericError(xmlGenericErrorContext,
+                                            "%s is an XSLT value tree\n",
+                                            arg);
+                            break;
+                    }
+#ifdef LIBXML_XPATH_ENABLED
+                    xmlXPathFreeObject(list);
+#endif
+                } else {
+                    xmlGenericError(xmlGenericErrorContext,
+                                    "%s: no such node\n", arg);
+                }
+                ctxt->pctxt->node = NULL;
+            }
+#endif /* LIBXML_OUTPUT_ENABLED */
+        } else {
+            xmlGenericError(xmlGenericErrorContext,
+                            "Unknown command %s\n", command);
+        }
+        free(cmdline);          /* not xmlFree here ! */
+    }
+#ifdef LIBXML_XPATH_ENABLED
+    xmlXPathFreeContext(ctxt->pctxt);
+#endif /* LIBXML_XPATH_ENABLED */
+    if (ctxt->loaded) {
+        xmlFreeDoc(ctxt->doc);
+    }
+    if (ctxt->filename != NULL)
+        xmlFree(ctxt->filename);
+    xmlFree(ctxt);
+    if (cmdline != NULL)
+        free(cmdline);          /* not xmlFree here ! */
+}
+
+#endif /* LIBXML_DEBUG_ENABLED */
diff --git a/src/libxml/src/dict.c b/src/libxml/src/dict.c
new file mode 100644
index 0000000..2ffd6a5
--- /dev/null
+++ b/src/libxml/src/dict.c
@@ -0,0 +1,738 @@
+/*
+ * dict.c: dictionary of reusable strings, just used to avoid allocation
+ *         and freeing operations.
+ *
+ * Copyright (C) 2003 Daniel Veillard.
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
+ * MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE AUTHORS AND
+ * CONTRIBUTORS ACCEPT NO RESPONSIBILITY IN ANY CONCEIVABLE MANNER.
+ *
+ * Author: daniel@veillard.com
+ */
+
+#define IN_LIBXML
+#include "libxml.h"
+
+#include <string.h>
+#include <libxml/tree.h>
+#include <libxml/dict.h>
+#include <libxml/xmlmemory.h>
+#include <libxml/xmlerror.h>
+#include <libxml/globals.h>
+
+#define MAX_HASH_LEN 4
+#define MIN_DICT_SIZE 128
+#define MAX_DICT_HASH 8 * 2048
+
+/* #define ALLOW_REMOVAL */
+/* #define DEBUG_GROW */
+
+/*
+ * An entry in the dictionnary
+ */
+typedef struct _xmlDictEntry xmlDictEntry;
+typedef xmlDictEntry *xmlDictEntryPtr;
+struct _xmlDictEntry {
+    struct _xmlDictEntry *next;
+    const xmlChar *name;
+    int len;
+    int valid;
+};
+
+typedef struct _xmlDictStrings xmlDictStrings;
+typedef xmlDictStrings *xmlDictStringsPtr;
+struct _xmlDictStrings {
+    xmlDictStringsPtr next;
+    xmlChar *free;
+    xmlChar *end;
+    int size;
+    int nbStrings;
+    xmlChar array[1];
+};
+/*
+ * The entire dictionnary
+ */
+struct _xmlDict {
+    int ref_counter;
+
+    struct _xmlDictEntry *dict;
+    int size;
+    int nbElems;
+    xmlDictStringsPtr strings;
+
+    struct _xmlDict *subdict;
+};
+
+/*
+ * xmlDictAddString:
+ * @dict: the dictionnary
+ * @name: the name of the userdata
+ * @len: the length of the name, if -1 it is recomputed
+ *
+ * Add the string to the array[s]
+ *
+ * Returns the pointer of the local string, or NULL in case of error.
+ */
+static const xmlChar *
+xmlDictAddString(xmlDictPtr dict, const xmlChar *name, int namelen) {
+    xmlDictStringsPtr pool;
+    const xmlChar *ret;
+    int size = 0; /* + sizeof(_xmlDictStrings) == 1024 */
+
+    pool = dict->strings;
+    while (pool != NULL) {
+	if (pool->end - pool->free > namelen)
+	    goto found_pool;
+	if (pool->size > size) size = pool->size;
+	pool = pool->next;
+    }
+    /*
+     * Not found, need to allocate
+     */
+    if (pool == NULL) {
+        if (size == 0) size = 1000;
+	else size *= 4; /* exponential growth */
+        if (size < 4 * namelen) 
+	    size = 4 * namelen; /* just in case ! */
+	pool = (xmlDictStringsPtr) xmlMalloc(sizeof(xmlDictStrings) + size);
+	if (pool == NULL)
+	    return(NULL);
+	pool->size = size;
+	pool->nbStrings = 0;
+	pool->free = &pool->array[0];
+	pool->end = &pool->array[size];
+	pool->next = dict->strings;
+	dict->strings = pool;
+    }
+found_pool:
+    ret = pool->free;
+    memcpy(pool->free, name, namelen);
+    pool->free += namelen;
+    *(pool->free++) = 0;
+    return(ret);
+}
+
+/*
+ * xmlDictAddQString:
+ * @dict: the dictionnary
+ * @prefix: the prefix of the userdata
+ * @name: the name of the userdata
+ * @len: the length of the name, if -1 it is recomputed
+ *
+ * Add the QName to the array[s]
+ *
+ * Returns the pointer of the local string, or NULL in case of error.
+ */
+static const xmlChar *
+xmlDictAddQString(xmlDictPtr dict, const xmlChar *prefix,
+                 const xmlChar *name, int namelen)
+{
+    xmlDictStringsPtr pool;
+    const xmlChar *ret;
+    int size = 0; /* + sizeof(_xmlDictStrings) == 1024 */
+    int plen;
+
+    if (prefix == NULL) return(xmlDictAddString(dict, name, namelen));
+    plen = xmlStrlen(prefix);
+
+    pool = dict->strings;
+    while (pool != NULL) {
+	if (pool->end - pool->free > namelen)
+	    goto found_pool;
+	if (pool->size > size) size = pool->size;
+	pool = pool->next;
+    }
+    /*
+     * Not found, need to allocate
+     */
+    if (pool == NULL) {
+        if (size == 0) size = 1000;
+	else size *= 4; /* exponential growth */
+        if (size < 4 * namelen) 
+	    size = 4 * namelen; /* just in case ! */
+	pool = (xmlDictStringsPtr) xmlMalloc(sizeof(xmlDictStrings) + size);
+	if (pool == NULL)
+	    return(NULL);
+	pool->size = size;
+	pool->nbStrings = 0;
+	pool->free = &pool->array[0];
+	pool->end = &pool->array[size];
+	pool->next = dict->strings;
+	dict->strings = pool;
+    }
+found_pool:
+    ret = pool->free;
+    memcpy(pool->free, prefix, plen);
+    pool->free += plen;
+    *(pool->free++) = ':';
+    namelen -= plen + 1;
+    memcpy(pool->free, name, namelen);
+    pool->free += namelen;
+    *(pool->free++) = 0;
+    return(ret);
+}
+
+/*
+ * xmlDictComputeKey:
+ * Calculate the hash key
+ */
+static unsigned long
+xmlDictComputeKey(const xmlChar *name, int namelen) {
+    unsigned long value = 0L;
+    
+    if (name == NULL) return(0);
+    value = *name;
+    value <<= 5;
+    if (namelen > 10) {
+        value += name[namelen - 1];
+        namelen = 10;
+    }
+    switch (namelen) {
+        case 10: value += name[9];
+        case 9: value += name[8];
+        case 8: value += name[7];
+        case 7: value += name[6];
+        case 6: value += name[5];
+        case 5: value += name[4];
+        case 4: value += name[3];
+        case 3: value += name[2];
+        case 2: value += name[1];
+        default: break;
+    }
+    return(value);
+}
+
+/*
+ * xmlDictComputeQKey:
+ * Calculate the hash key
+ */
+static unsigned long
+xmlDictComputeQKey(const xmlChar *prefix, const xmlChar *name, int len)
+{
+    unsigned long value = 0L;
+    int plen;
+    
+    if (prefix == NULL)
+        return(xmlDictComputeKey(name, len));
+
+    plen = xmlStrlen(prefix);
+    if (plen == 0)
+	value += 30 * (unsigned long) ':';
+    else
+	value += 30 * (*prefix);
+    
+    if (len > 10) {
+        value += name[len - (plen + 1 + 1)];
+        len = 10;
+	if (plen > 10)
+	    plen = 10;
+    }
+    switch (plen) {
+        case 10: value += prefix[9];
+        case 9: value += prefix[8];
+        case 8: value += prefix[7];
+        case 7: value += prefix[6];
+        case 6: value += prefix[5];
+        case 5: value += prefix[4];
+        case 4: value += prefix[3];
+        case 3: value += prefix[2];
+        case 2: value += prefix[1];
+        case 1: value += prefix[0];
+        default: break;
+    }
+    len -= plen;
+    if (len > 0) {
+        value += (unsigned long) ':';
+	len--;
+    }
+    switch (len) {
+        case 10: value += name[9];
+        case 9: value += name[8];
+        case 8: value += name[7];
+        case 7: value += name[6];
+        case 6: value += name[5];
+        case 5: value += name[4];
+        case 4: value += name[3];
+        case 3: value += name[2];
+        case 2: value += name[1];
+        case 1: value += name[0];
+        default: break;
+    }
+    return(value);
+}
+
+/**
+ * xmlDictCreate:
+ *
+ * Create a new dictionary
+ *
+ * Returns the newly created dictionnary, or NULL if an error occured.
+ */
+xmlDictPtr
+xmlDictCreate(void) {
+    xmlDictPtr dict;
+  
+    dict = xmlMalloc(sizeof(xmlDict));
+    if (dict) {
+        dict->ref_counter = 1;
+
+        dict->size = MIN_DICT_SIZE;
+	dict->nbElems = 0;
+        dict->dict = xmlMalloc(MIN_DICT_SIZE * sizeof(xmlDictEntry));
+	dict->strings = NULL;
+	dict->subdict = NULL;
+        if (dict->dict) {
+  	    memset(dict->dict, 0, MIN_DICT_SIZE * sizeof(xmlDictEntry));
+  	    return(dict);
+        }
+        xmlFree(dict);
+    }
+    return(NULL);
+}
+
+/**
+ * xmlDictCreateSub:
+ * @sub: an existing dictionnary
+ *
+ * Create a new dictionary, inheriting strings from the read-only
+ * dictionnary @sub. On lookup, strings are first searched in the
+ * new dictionnary, then in @sub, and if not found are created in the
+ * new dictionnary.
+ *
+ * Returns the newly created dictionnary, or NULL if an error occured.
+ */
+xmlDictPtr
+xmlDictCreateSub(xmlDictPtr sub) {
+    xmlDictPtr dict = xmlDictCreate();
+  
+    if ((dict != NULL) && (sub != NULL)) {
+        dict->subdict = sub;
+	xmlDictReference(dict->subdict);
+    }
+    return(dict);
+}
+
+/**
+ * xmlDictReference:
+ * @dict: the dictionnary
+ *
+ * Increment the reference counter of a dictionary
+ *
+ * Returns 0 in case of success and -1 in case of error
+ */
+int
+xmlDictReference(xmlDictPtr dict) {
+    if (dict == NULL) return -1;
+    dict->ref_counter++;
+    return(0);
+}
+
+/**
+ * xmlDictGrow:
+ * @dict: the dictionnary
+ * @size: the new size of the dictionnary
+ *
+ * resize the dictionnary
+ *
+ * Returns 0 in case of success, -1 in case of failure
+ */
+static int
+xmlDictGrow(xmlDictPtr dict, int size) {
+    unsigned long key;
+    int oldsize, i;
+    xmlDictEntryPtr iter, next;
+    struct _xmlDictEntry *olddict;
+#ifdef DEBUG_GROW
+    unsigned long nbElem = 0;
+#endif
+  
+    if (dict == NULL)
+	return(-1);
+    if (size < 8)
+        return(-1);
+    if (size > 8 * 2048)
+	return(-1);
+
+    oldsize = dict->size;
+    olddict = dict->dict;
+    if (olddict == NULL)
+        return(-1);
+  
+    dict->dict = xmlMalloc(size * sizeof(xmlDictEntry));
+    if (dict->dict == NULL) {
+	dict->dict = olddict;
+	return(-1);
+    }
+    memset(dict->dict, 0, size * sizeof(xmlDictEntry));
+    dict->size = size;
+
+    /*	If the two loops are merged, there would be situations where
+	a new entry needs to allocated and data copied into it from 
+	the main dict. So instead, we run through the array twice, first
+	copying all the elements in the main array (where we can't get
+	conflicts) and then the rest, so we only free (and don't allocate)
+    */
+    for (i = 0; i < oldsize; i++) {
+	if (olddict[i].valid == 0) 
+	    continue;
+	key = xmlDictComputeKey(olddict[i].name, olddict[i].len) % dict->size;
+	memcpy(&(dict->dict[key]), &(olddict[i]), sizeof(xmlDictEntry));
+	dict->dict[key].next = NULL;
+#ifdef DEBUG_GROW
+	nbElem++;
+#endif
+    }
+
+    for (i = 0; i < oldsize; i++) {
+	iter = olddict[i].next;
+	while (iter) {
+	    next = iter->next;
+
+	    /*
+	     * put back the entry in the new dict
+	     */
+
+	    key = xmlDictComputeKey(iter->name, iter->len) % dict->size;
+	    if (dict->dict[key].valid == 0) {
+		memcpy(&(dict->dict[key]), iter, sizeof(xmlDictEntry));
+		dict->dict[key].next = NULL;
+		dict->dict[key].valid = 1;
+		xmlFree(iter);
+	    } else {
+	    	iter->next = dict->dict[key].next;
+	    	dict->dict[key].next = iter;
+	    }
+
+#ifdef DEBUG_GROW
+	    nbElem++;
+#endif
+
+	    iter = next;
+	}
+    }
+
+    xmlFree(olddict);
+
+#ifdef DEBUG_GROW
+    xmlGenericError(xmlGenericErrorContext,
+	    "xmlDictGrow : from %d to %d, %d elems\n", oldsize, size, nbElem);
+#endif
+
+    return(0);
+}
+
+/**
+ * xmlDictFree:
+ * @dict: the dictionnary
+ *
+ * Free the hash @dict and its contents. The userdata is
+ * deallocated with @f if provided.
+ */
+void
+xmlDictFree(xmlDictPtr dict) {
+    int i;
+    xmlDictEntryPtr iter;
+    xmlDictEntryPtr next;
+    int inside_dict = 0;
+    xmlDictStringsPtr pool, nextp;
+
+    if (dict == NULL)
+	return;
+
+    /* decrement the counter, it may be shared by a parser and docs */
+    dict->ref_counter--;
+    if (dict->ref_counter > 0) return;
+
+    if (dict->subdict != NULL) {
+        xmlDictFree(dict->subdict);
+    }
+
+    if (dict->dict) {
+	for(i = 0; ((i < dict->size) && (dict->nbElems > 0)); i++) {
+	    iter = &(dict->dict[i]);
+	    if (iter->valid == 0)
+		continue;
+	    inside_dict = 1;
+	    while (iter) {
+		next = iter->next;
+		if (!inside_dict)
+		    xmlFree(iter);
+		dict->nbElems--;
+		inside_dict = 0;
+		iter = next;
+	    }
+	    inside_dict = 0;
+	}
+	xmlFree(dict->dict);
+    }
+    pool = dict->strings;
+    while (pool != NULL) {
+        nextp = pool->next;
+	xmlFree(pool);
+	pool = nextp;
+    }
+    xmlFree(dict);
+}
+
+/**
+ * xmlDictLookup:
+ * @dict: the dictionnary
+ * @name: the name of the userdata
+ * @len: the length of the name, if -1 it is recomputed
+ *
+ * Add the @name to the hash @dict if not present.
+ *
+ * Returns the internal copy of the name or NULL in case of internal error
+ */
+const xmlChar *
+xmlDictLookup(xmlDictPtr dict, const xmlChar *name, int len) {
+    unsigned long key, okey, nbi = 0;
+    xmlDictEntryPtr entry;
+    xmlDictEntryPtr insert;
+    const xmlChar *ret;
+
+    if ((dict == NULL) || (name == NULL))
+	return(NULL);
+
+    if (len < 0)
+        len = xmlStrlen(name);
+
+    /*
+     * Check for duplicate and insertion location.
+     */
+    okey = xmlDictComputeKey(name, len);
+    key = okey % dict->size;
+    if (dict->dict[key].valid == 0) {
+	insert = NULL;
+    } else {
+	for (insert = &(dict->dict[key]); insert->next != NULL;
+	     insert = insert->next) {
+#ifdef __GNUC__
+	    if (insert->len == len) {
+		if (!memcmp(insert->name, name, len))
+		    return(insert->name);
+	    }
+#else
+	    if ((insert->len == len) &&
+	        (!xmlStrncmp(insert->name, name, len)))
+		return(insert->name);
+#endif
+	    nbi++;
+	}
+#ifdef __GNUC__
+	if (insert->len == len) {
+	    if (!memcmp(insert->name, name, len))
+		return(insert->name);
+	}
+#else
+	if ((insert->len == len) &&
+	    (!xmlStrncmp(insert->name, name, len)))
+	    return(insert->name);
+#endif
+    }
+
+    if (dict->subdict) {
+	key = okey % dict->subdict->size;
+	if (dict->subdict->dict[key].valid != 0) {
+	    xmlDictEntryPtr tmp;
+
+	    for (tmp = &(dict->subdict->dict[key]); tmp->next != NULL;
+		 tmp = tmp->next) {
+#ifdef __GNUC__
+		if (tmp->len == len) {
+		    if (!memcmp(tmp->name, name, len))
+			return(tmp->name);
+		}
+#else
+		if ((tmp->len == len) &&
+		    (!xmlStrncmp(tmp->name, name, len)))
+		    return(tmp->name);
+#endif
+		nbi++;
+	    }
+#ifdef __GNUC__
+	    if (tmp->len == len) {
+		if (!memcmp(tmp->name, name, len))
+		    return(tmp->name);
+	    }
+#else
+	    if ((tmp->len == len) &&
+		(!xmlStrncmp(tmp->name, name, len)))
+		return(tmp->name);
+#endif
+	}
+	key = okey % dict->size;
+    }
+
+    ret = xmlDictAddString(dict, name, len);
+    if (ret == NULL)
+        return(NULL);
+    if (insert == NULL) {
+	entry = &(dict->dict[key]);
+    } else {
+	entry = xmlMalloc(sizeof(xmlDictEntry));
+	if (entry == NULL)
+	     return(NULL);
+    }
+    entry->name = ret;
+    entry->len = len;
+    entry->next = NULL;
+    entry->valid = 1;
+
+
+    if (insert != NULL) 
+	insert->next = entry;
+
+    dict->nbElems++;
+
+    if ((nbi > MAX_HASH_LEN) &&
+        (dict->size <= ((MAX_DICT_HASH / 2) / MAX_HASH_LEN)))
+	xmlDictGrow(dict, MAX_HASH_LEN * 2 * dict->size);
+    /* Note that entry may have been freed at this point by xmlDictGrow */
+
+    return(ret);
+}
+
+/**
+ * xmlDictQLookup:
+ * @dict: the dictionnary
+ * @prefix: the prefix 
+ * @name: the name
+ *
+ * Add the QName @prefix:@name to the hash @dict if not present.
+ *
+ * Returns the internal copy of the QName or NULL in case of internal error
+ */
+const xmlChar *
+xmlDictQLookup(xmlDictPtr dict, const xmlChar *prefix, const xmlChar *name) {
+    unsigned long okey, key, nbi = 0;
+    xmlDictEntryPtr entry;
+    xmlDictEntryPtr insert;
+    const xmlChar *ret;
+    int len;
+
+    if ((dict == NULL) || (name == NULL))
+	return(NULL);
+
+    len = xmlStrlen(name);
+    if (prefix != NULL)
+        len += 1 + xmlStrlen(prefix);
+
+    /*
+     * Check for duplicate and insertion location.
+     */
+    okey = xmlDictComputeQKey(prefix, name, len);
+    key = okey % dict->size;
+    if (dict->dict[key].valid == 0) {
+	insert = NULL;
+    } else {
+	for (insert = &(dict->dict[key]); insert->next != NULL;
+	     insert = insert->next) {
+	    if ((insert->len == len) &&
+	        (xmlStrQEqual(prefix, name, insert->name)))
+		return(insert->name);
+	    nbi++;
+	}
+	if ((insert->len == len) &&
+	    (xmlStrQEqual(prefix, name, insert->name)))
+	    return(insert->name);
+    }
+
+    if (dict->subdict) {
+	key = okey % dict->subdict->size;
+	if (dict->subdict->dict[key].valid != 0) {
+	    xmlDictEntryPtr tmp;
+	    for (tmp = &(dict->subdict->dict[key]); tmp->next != NULL;
+		 tmp = tmp->next) {
+		if ((tmp->len == len) &&
+		    (xmlStrQEqual(prefix, name, tmp->name)))
+		    return(tmp->name);
+		nbi++;
+	    }
+	    if ((tmp->len == len) &&
+		(xmlStrQEqual(prefix, name, tmp->name)))
+		return(tmp->name);
+	}
+	key = okey % dict->size;
+    }
+
+    ret = xmlDictAddQString(dict, prefix, name, len);
+    if (ret == NULL)
+        return(NULL);
+    if (insert == NULL) {
+	entry = &(dict->dict[key]);
+    } else {
+	entry = xmlMalloc(sizeof(xmlDictEntry));
+	if (entry == NULL)
+	     return(NULL);
+    }
+    entry->name = ret;
+    entry->len = len;
+    entry->next = NULL;
+    entry->valid = 1;
+
+    if (insert != NULL) 
+	insert->next = entry;
+
+    dict->nbElems++;
+
+    if ((nbi > MAX_HASH_LEN) &&
+        (dict->size <= ((MAX_DICT_HASH / 2) / MAX_HASH_LEN)))
+	xmlDictGrow(dict, MAX_HASH_LEN * 2 * dict->size);
+    /* Note that entry may have been freed at this point by xmlDictGrow */
+
+    return(ret);
+}
+
+/**
+ * xmlDictOwns:
+ * @dict: the dictionnary
+ * @str: the string
+ *
+ * check if a string is owned by the disctionary
+ *
+ * Returns 1 if true, 0 if false and -1 in case of error
+ * -1 in case of error
+ */
+int
+xmlDictOwns(xmlDictPtr dict, const xmlChar *str) {
+    xmlDictStringsPtr pool;
+
+    if ((dict == NULL) || (str == NULL))
+	return(-1);
+    pool = dict->strings;
+    while (pool != NULL) {
+        if ((str >= pool->array) && (str <= pool->free))
+	    return(1);
+	pool = pool->next;
+    }
+    if (dict->subdict)
+        return(xmlDictOwns(dict->subdict, str));
+    return(0);
+}
+
+/**
+ * xmlDictSize:
+ * @dict: the dictionnary
+ *
+ * Query the number of elements installed in the hash @dict.
+ *
+ * Returns the number of elements in the dictionnary or
+ * -1 in case of error
+ */
+int
+xmlDictSize(xmlDictPtr dict) {
+    if (dict == NULL)
+	return(-1);
+    if (dict->subdict)
+        return(dict->nbElems + dict->subdict->nbElems);
+    return(dict->nbElems);
+}
+
+
diff --git a/src/libxml/src/encoding.c b/src/libxml/src/encoding.c
new file mode 100644
index 0000000..58cc8c1
--- /dev/null
+++ b/src/libxml/src/encoding.c
@@ -0,0 +1,3237 @@
+/*
+ * encoding.c : implements the encoding conversion functions needed for XML
+ *
+ * Related specs: 
+ * rfc2044        (UTF-8 and UTF-16) F. Yergeau Alis Technologies
+ * rfc2781        UTF-16, an encoding of ISO 10646, P. Hoffman, F. Yergeau
+ * [ISO-10646]    UTF-8 and UTF-16 in Annexes
+ * [ISO-8859-1]   ISO Latin-1 characters codes.
+ * [UNICODE]      The Unicode Consortium, "The Unicode Standard --
+ *                Worldwide Character Encoding -- Version 1.0", Addison-
+ *                Wesley, Volume 1, 1991, Volume 2, 1992.  UTF-8 is
+ *                described in Unicode Technical Report #4.
+ * [US-ASCII]     Coded Character Set--7-bit American Standard Code for
+ *                Information Interchange, ANSI X3.4-1986.
+ *
+ * See Copyright for the status of this software.
+ *
+ * daniel@veillard.com
+ *
+ * Original code for IsoLatin1 and UTF-16 by "Martin J. Duerst" <duerst@w3.org>
+ */
+
+#define IN_LIBXML
+#include "libxml.h"
+
+#include <string.h>
+
+#ifdef HAVE_CTYPE_H
+#include <ctype.h>
+#endif
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+#ifdef LIBXML_ICONV_ENABLED
+#ifdef HAVE_ERRNO_H
+#include <errno.h>
+#endif
+#endif
+#include <libxml/encoding.h>
+#include <libxml/xmlmemory.h>
+#ifdef LIBXML_HTML_ENABLED
+#include <libxml/HTMLparser.h>
+#endif
+#include <libxml/globals.h>
+#include <libxml/xmlerror.h>
+
+static xmlCharEncodingHandlerPtr xmlUTF16LEHandler = NULL;
+static xmlCharEncodingHandlerPtr xmlUTF16BEHandler = NULL;
+
+typedef struct _xmlCharEncodingAlias xmlCharEncodingAlias;
+typedef xmlCharEncodingAlias *xmlCharEncodingAliasPtr;
+struct _xmlCharEncodingAlias {
+    const char *name;
+    const char *alias;
+};
+
+static xmlCharEncodingAliasPtr xmlCharEncodingAliases = NULL;
+static int xmlCharEncodingAliasesNb = 0;
+static int xmlCharEncodingAliasesMax = 0;
+
+#ifdef LIBXML_ICONV_ENABLED
+#if 0
+#define DEBUG_ENCODING  /* Define this to get encoding traces */
+#endif
+#else
+#ifdef LIBXML_ISO8859X_ENABLED
+static void xmlRegisterCharEncodingHandlersISO8859x (void);
+#endif
+#endif
+
+static int xmlLittleEndian = 1;
+
+
+/************************************************************************
+ *									*
+ *		Conversions To/From UTF8 encoding			*
+ *									*
+ ************************************************************************/
+
+/**
+ * asciiToUTF8:
+ * @out:  a pointer to an array of bytes to store the result
+ * @outlen:  the length of @out
+ * @in:  a pointer to an array of ASCII chars
+ * @inlen:  the length of @in
+ *
+ * Take a block of ASCII chars in and try to convert it to an UTF-8
+ * block of chars out.
+ * Returns 0 if success, or -1 otherwise
+ * The value of @inlen after return is the number of octets consumed
+ *     if the return value is positive, else unpredictable.
+ * The value of @outlen after return is the number of octets consumed.
+ */
+static int
+asciiToUTF8(unsigned char* out, int *outlen,
+              const unsigned char* in, int *inlen) {
+    unsigned char* outstart = out;
+    const unsigned char* base = in;
+    const unsigned char* processed = in;
+    unsigned char* outend = out + *outlen;
+    const unsigned char* inend;
+    unsigned int c;
+    int bits;
+
+    inend = in + (*inlen);
+    while ((in < inend) && (out - outstart + 5 < *outlen)) {
+	c= *in++;
+
+	/* assertion: c is a single UTF-4 value */
+        if (out >= outend)
+	    break;
+        if      (c <    0x80) {  *out++=  c;                bits= -6; }
+        else { 
+	    *outlen = out - outstart;
+	    *inlen = processed - base;
+	    return(-1);
+	}
+ 
+        for ( ; bits >= 0; bits-= 6) {
+            if (out >= outend)
+	        break;
+            *out++= ((c >> bits) & 0x3F) | 0x80;
+        }
+	processed = (const unsigned char*) in;
+    }
+    *outlen = out - outstart;
+    *inlen = processed - base;
+    return(0);
+}
+
+#ifdef LIBXML_OUTPUT_ENABLED
+/**
+ * UTF8Toascii:
+ * @out:  a pointer to an array of bytes to store the result
+ * @outlen:  the length of @out
+ * @in:  a pointer to an array of UTF-8 chars
+ * @inlen:  the length of @in
+ *
+ * Take a block of UTF-8 chars in and try to convert it to an ASCII
+ * block of chars out.
+ *
+ * Returns 0 if success, -2 if the transcoding fails, or -1 otherwise
+ * The value of @inlen after return is the number of octets consumed
+ *     if the return value is positive, else unpredictable.
+ * The value of @outlen after return is the number of octets consumed.
+ */
+static int
+UTF8Toascii(unsigned char* out, int *outlen,
+              const unsigned char* in, int *inlen) {
+    const unsigned char* processed = in;
+    const unsigned char* outend;
+    const unsigned char* outstart = out;
+    const unsigned char* instart = in;
+    const unsigned char* inend;
+    unsigned int c, d;
+    int trailing;
+
+    if (in == NULL) {
+        /*
+	 * initialization nothing to do
+	 */
+	*outlen = 0;
+	*inlen = 0;
+	return(0);
+    }
+    inend = in + (*inlen);
+    outend = out + (*outlen);
+    while (in < inend) {
+	d = *in++;
+	if      (d < 0x80)  { c= d; trailing= 0; }
+	else if (d < 0xC0) {
+	    /* trailing byte in leading position */
+	    *outlen = out - outstart;
+	    *inlen = processed - instart;
+	    return(-2);
+        } else if (d < 0xE0)  { c= d & 0x1F; trailing= 1; }
+        else if (d < 0xF0)  { c= d & 0x0F; trailing= 2; }
+        else if (d < 0xF8)  { c= d & 0x07; trailing= 3; }
+	else {
+	    /* no chance for this in Ascii */
+	    *outlen = out - outstart;
+	    *inlen = processed - instart;
+	    return(-2);
+	}
+
+	if (inend - in < trailing) {
+	    break;
+	} 
+
+	for ( ; trailing; trailing--) {
+	    if ((in >= inend) || (((d= *in++) & 0xC0) != 0x80))
+		break;
+	    c <<= 6;
+	    c |= d & 0x3F;
+	}
+
+	/* assertion: c is a single UTF-4 value */
+	if (c < 0x80) {
+	    if (out >= outend)
+		break;
+	    *out++ = c;
+	} else {
+	    /* no chance for this in Ascii */
+	    *outlen = out - outstart;
+	    *inlen = processed - instart;
+	    return(-2);
+	}
+	processed = in;
+    }
+    *outlen = out - outstart;
+    *inlen = processed - instart;
+    return(0);
+}
+#endif /* LIBXML_OUTPUT_ENABLED */
+
+/**
+ * isolat1ToUTF8:
+ * @out:  a pointer to an array of bytes to store the result
+ * @outlen:  the length of @out
+ * @in:  a pointer to an array of ISO Latin 1 chars
+ * @inlen:  the length of @in
+ *
+ * Take a block of ISO Latin 1 chars in and try to convert it to an UTF-8
+ * block of chars out.
+ * Returns 0 if success, or -1 otherwise
+ * The value of @inlen after return is the number of octets consumed
+ *     if the return value is positive, else unpredictable.
+ * The value of @outlen after return is the number of octets consumed.
+ */
+int
+isolat1ToUTF8(unsigned char* out, int *outlen,
+              const unsigned char* in, int *inlen) {
+    unsigned char* outstart = out;
+    const unsigned char* base = in;
+    unsigned char* outend = out + *outlen;
+    const unsigned char* inend;
+    const unsigned char* instop;
+
+    inend = in + (*inlen);
+    instop = inend;
+    
+    while (in < inend && out < outend - 1) {
+    	if (*in >= 0x80) {
+	    *out++ = (((*in) >>  6) & 0x1F) | 0xC0;
+        *out++ = ((*in) & 0x3F) | 0x80;
+	    ++in;
+	}
+	if (instop - in > outend - out) instop = in + (outend - out); 
+	while (in < instop && *in < 0x80) {
+	    *out++ = *in++;
+	}
+    }	
+    if (in < inend && out < outend && *in < 0x80) {
+        *out++ = *in++;
+    }
+    *outlen = out - outstart;
+    *inlen = in - base;
+    return(0);
+}
+
+/**
+ * UTF8ToUTF8:
+ * @out:  a pointer to an array of bytes to store the result
+ * @outlen:  the length of @out
+ * @inb:  a pointer to an array of UTF-8 chars
+ * @inlenb:  the length of @in in UTF-8 chars
+ *
+ * No op copy operation for UTF8 handling.
+ *
+ * Returns the number of bytes written, or -1 if lack of space.
+ *     The value of *inlen after return is the number of octets consumed
+ *     if the return value is positive, else unpredictable.
+ */
+static int
+UTF8ToUTF8(unsigned char* out, int *outlen,
+           const unsigned char* inb, int *inlenb)
+{
+    int len;
+
+    if ((out == NULL) || (inb == NULL) || (outlen == NULL) || (inlenb == NULL))
+	return(-1);
+    if (*outlen > *inlenb) {
+	len = *inlenb;
+    } else {
+	len = *outlen;
+    }
+    if (len < 0)
+	return(-1);
+
+    memcpy(out, inb, len);
+
+    *outlen = len;
+    *inlenb = len;
+    return(0);
+}
+
+
+#ifdef LIBXML_OUTPUT_ENABLED
+/**
+ * UTF8Toisolat1:
+ * @out:  a pointer to an array of bytes to store the result
+ * @outlen:  the length of @out
+ * @in:  a pointer to an array of UTF-8 chars
+ * @inlen:  the length of @in
+ *
+ * Take a block of UTF-8 chars in and try to convert it to an ISO Latin 1
+ * block of chars out.
+ *
+ * Returns 0 if success, -2 if the transcoding fails, or -1 otherwise
+ * The value of @inlen after return is the number of octets consumed
+ *     if the return value is positive, else unpredictable.
+ * The value of @outlen after return is the number of octets consumed.
+ */
+int
+UTF8Toisolat1(unsigned char* out, int *outlen,
+              const unsigned char* in, int *inlen) {
+    const unsigned char* processed = in;
+    const unsigned char* outend;
+    const unsigned char* outstart = out;
+    const unsigned char* instart = in;
+    const unsigned char* inend;
+    unsigned int c, d;
+    int trailing;
+
+    if (in == NULL) {
+        /*
+	 * initialization nothing to do
+	 */
+	*outlen = 0;
+	*inlen = 0;
+	return(0);
+    }
+    inend = in + (*inlen);
+    outend = out + (*outlen);
+    while (in < inend) {
+	d = *in++;
+	if      (d < 0x80)  { c= d; trailing= 0; }
+	else if (d < 0xC0) {
+	    /* trailing byte in leading position */
+	    *outlen = out - outstart;
+	    *inlen = processed - instart;
+	    return(-2);
+        } else if (d < 0xE0)  { c= d & 0x1F; trailing= 1; }
+        else if (d < 0xF0)  { c= d & 0x0F; trailing= 2; }
+        else if (d < 0xF8)  { c= d & 0x07; trailing= 3; }
+	else {
+	    /* no chance for this in IsoLat1 */
+	    *outlen = out - outstart;
+	    *inlen = processed - instart;
+	    return(-2);
+	}
+
+	if (inend - in < trailing) {
+	    break;
+	} 
+
+	for ( ; trailing; trailing--) {
+	    if (in >= inend)
+		break;
+	    if (((d= *in++) & 0xC0) != 0x80) {
+		*outlen = out - outstart;
+		*inlen = processed - instart;
+		return(-2);
+	    }
+	    c <<= 6;
+	    c |= d & 0x3F;
+	}
+
+	/* assertion: c is a single UTF-4 value */
+	if (c <= 0xFF) {
+	    if (out >= outend)
+		break;
+	    *out++ = c;
+	} else {
+	    /* no chance for this in IsoLat1 */
+	    *outlen = out - outstart;
+	    *inlen = processed - instart;
+	    return(-2);
+	}
+	processed = in;
+    }
+    *outlen = out - outstart;
+    *inlen = processed - instart;
+    return(0);
+}
+#endif /* LIBXML_OUTPUT_ENABLED */
+
+/**
+ * UTF16LEToUTF8:
+ * @out:  a pointer to an array of bytes to store the result
+ * @outlen:  the length of @out
+ * @inb:  a pointer to an array of UTF-16LE passwd as a byte array
+ * @inlenb:  the length of @in in UTF-16LE chars
+ *
+ * Take a block of UTF-16LE ushorts in and try to convert it to an UTF-8
+ * block of chars out. This function assumes the endian property
+ * is the same between the native type of this machine and the
+ * inputed one.
+ *
+ * Returns the number of bytes written, or -1 if lack of space, or -2
+ *     if the transcoding fails (if *in is not a valid utf16 string)
+ *     The value of *inlen after return is the number of octets consumed
+ *     if the return value is positive, else unpredictable.
+ */
+static int
+UTF16LEToUTF8(unsigned char* out, int *outlen,
+            const unsigned char* inb, int *inlenb)
+{
+    unsigned char* outstart = out;
+    const unsigned char* processed = inb;
+    unsigned char* outend = out + *outlen;
+    unsigned short* in = (unsigned short*) inb;
+    unsigned short* inend;
+    unsigned int c, d, inlen;
+    unsigned char *tmp;
+    int bits;
+
+    if ((*inlenb % 2) == 1)
+        (*inlenb)--;
+    inlen = *inlenb / 2;
+    inend = in + inlen;
+    while ((in < inend) && (out - outstart + 5 < *outlen)) {
+        if (xmlLittleEndian) {
+	    c= *in++;
+	} else {
+	    tmp = (unsigned char *) in;
+	    c = *tmp++;
+	    c = c | (((unsigned int)*tmp) << 8);
+	    in++;
+	}
+        if ((c & 0xFC00) == 0xD800) {    /* surrogates */
+	    if (in >= inend) {           /* (in > inend) shouldn't happens */
+		break;
+	    }
+	    if (xmlLittleEndian) {
+		d = *in++;
+	    } else {
+		tmp = (unsigned char *) in;
+		d = *tmp++;
+		d = d | (((unsigned int)*tmp) << 8);
+		in++;
+	    }
+            if ((d & 0xFC00) == 0xDC00) {
+                c &= 0x03FF;
+                c <<= 10;
+                c |= d & 0x03FF;
+                c += 0x10000;
+            }
+            else {
+		*outlen = out - outstart;
+		*inlenb = processed - inb;
+	        return(-2);
+	    }
+        }
+
+	/* assertion: c is a single UTF-4 value */
+        if (out >= outend)
+	    break;
+        if      (c <    0x80) {  *out++=  c;                bits= -6; }
+        else if (c <   0x800) {  *out++= ((c >>  6) & 0x1F) | 0xC0;  bits=  0; }
+        else if (c < 0x10000) {  *out++= ((c >> 12) & 0x0F) | 0xE0;  bits=  6; }
+        else                  {  *out++= ((c >> 18) & 0x07) | 0xF0;  bits= 12; }
+ 
+        for ( ; bits >= 0; bits-= 6) {
+            if (out >= outend)
+	        break;
+            *out++= ((c >> bits) & 0x3F) | 0x80;
+        }
+	processed = (const unsigned char*) in;
+    }
+    *outlen = out - outstart;
+    *inlenb = processed - inb;
+    return(0);
+}
+
+#ifdef LIBXML_OUTPUT_ENABLED
+/**
+ * UTF8ToUTF16LE:
+ * @outb:  a pointer to an array of bytes to store the result
+ * @outlen:  the length of @outb
+ * @in:  a pointer to an array of UTF-8 chars
+ * @inlen:  the length of @in
+ *
+ * Take a block of UTF-8 chars in and try to convert it to an UTF-16LE
+ * block of chars out.
+ *
+ * Returns the number of bytes written, or -1 if lack of space, or -2
+ *     if the transcoding failed. 
+ */
+static int
+UTF8ToUTF16LE(unsigned char* outb, int *outlen,
+            const unsigned char* in, int *inlen)
+{
+    unsigned short* out = (unsigned short*) outb;
+    const unsigned char* processed = in;
+    const unsigned char *const instart = in;
+    unsigned short* outstart= out;
+    unsigned short* outend;
+    const unsigned char* inend= in+*inlen;
+    unsigned int c, d;
+    int trailing;
+    unsigned char *tmp;
+    unsigned short tmp1, tmp2;
+
+    /* UTF16LE encoding has no BOM */
+    if (in == NULL) {
+	*outlen = 0;
+	*inlen = 0;
+	return(0);
+    }
+    outend = out + (*outlen / 2);
+    while (in < inend) {
+      d= *in++;
+      if      (d < 0x80)  { c= d; trailing= 0; }
+      else if (d < 0xC0) {
+          /* trailing byte in leading position */
+	  *outlen = (out - outstart) * 2;
+	  *inlen = processed - instart;
+	  return(-2);
+      } else if (d < 0xE0)  { c= d & 0x1F; trailing= 1; }
+      else if (d < 0xF0)  { c= d & 0x0F; trailing= 2; }
+      else if (d < 0xF8)  { c= d & 0x07; trailing= 3; }
+      else {
+	/* no chance for this in UTF-16 */
+	*outlen = (out - outstart) * 2;
+	*inlen = processed - instart;
+	return(-2);
+      }
+
+      if (inend - in < trailing) {
+          break;
+      } 
+
+      for ( ; trailing; trailing--) {
+          if ((in >= inend) || (((d= *in++) & 0xC0) != 0x80))
+	      break;
+          c <<= 6;
+          c |= d & 0x3F;
+      }
+
+      /* assertion: c is a single UTF-4 value */
+        if (c < 0x10000) {
+            if (out >= outend)
+	        break;
+	    if (xmlLittleEndian) {
+		*out++ = c;
+	    } else {
+		tmp = (unsigned char *) out;
+		*tmp = c ;
+		*(tmp + 1) = c >> 8 ;
+		out++;
+	    }
+        }
+        else if (c < 0x110000) {
+            if (out+1 >= outend)
+	        break;
+            c -= 0x10000;
+	    if (xmlLittleEndian) {
+		*out++ = 0xD800 | (c >> 10);
+		*out++ = 0xDC00 | (c & 0x03FF);
+	    } else {
+		tmp1 = 0xD800 | (c >> 10);
+		tmp = (unsigned char *) out;
+		*tmp = (unsigned char) tmp1;
+		*(tmp + 1) = tmp1 >> 8;
+		out++;
+
+		tmp2 = 0xDC00 | (c & 0x03FF);
+		tmp = (unsigned char *) out;
+		*tmp  = (unsigned char) tmp2;
+		*(tmp + 1) = tmp2 >> 8;
+		out++;
+	    }
+        }
+        else
+	    break;
+	processed = in;
+    }
+    *outlen = (out - outstart) * 2;
+    *inlen = processed - instart;
+    return(0);
+}
+
+/**
+ * UTF8ToUTF16:
+ * @outb:  a pointer to an array of bytes to store the result
+ * @outlen:  the length of @outb
+ * @in:  a pointer to an array of UTF-8 chars
+ * @inlen:  the length of @in
+ *
+ * Take a block of UTF-8 chars in and try to convert it to an UTF-16
+ * block of chars out.
+ *
+ * Returns the number of bytes written, or -1 if lack of space, or -2
+ *     if the transcoding failed. 
+ */
+static int
+UTF8ToUTF16(unsigned char* outb, int *outlen,
+            const unsigned char* in, int *inlen)
+{
+    if (in == NULL) {
+	/*
+	 * initialization, add the Byte Order Mark for UTF-16LE
+	 */
+        if (*outlen >= 2) {
+	    outb[0] = 0xFF;
+	    outb[1] = 0xFE;
+	    *outlen = 2;
+	    *inlen = 0;
+#ifdef DEBUG_ENCODING
+            xmlGenericError(xmlGenericErrorContext,
+		    "Added FFFE Byte Order Mark\n");
+#endif
+	    return(2);
+	}
+	*outlen = 0;
+	*inlen = 0;
+	return(0);
+    }
+    return (UTF8ToUTF16LE(outb, outlen, in, inlen));
+}
+#endif /* LIBXML_OUTPUT_ENABLED */
+
+/**
+ * UTF16BEToUTF8:
+ * @out:  a pointer to an array of bytes to store the result
+ * @outlen:  the length of @out
+ * @inb:  a pointer to an array of UTF-16 passed as a byte array
+ * @inlenb:  the length of @in in UTF-16 chars
+ *
+ * Take a block of UTF-16 ushorts in and try to convert it to an UTF-8
+ * block of chars out. This function assumes the endian property
+ * is the same between the native type of this machine and the
+ * inputed one.
+ *
+ * Returns the number of bytes written, or -1 if lack of space, or -2
+ *     if the transcoding fails (if *in is not a valid utf16 string)
+ * The value of *inlen after return is the number of octets consumed
+ *     if the return value is positive, else unpredictable.
+ */
+static int
+UTF16BEToUTF8(unsigned char* out, int *outlen,
+            const unsigned char* inb, int *inlenb)
+{
+    unsigned char* outstart = out;
+    const unsigned char* processed = inb;
+    unsigned char* outend = out + *outlen;
+    unsigned short* in = (unsigned short*) inb;
+    unsigned short* inend;
+    unsigned int c, d, inlen;
+    unsigned char *tmp;
+    int bits;
+
+    if ((*inlenb % 2) == 1)
+        (*inlenb)--;
+    inlen = *inlenb / 2;
+    inend= in + inlen;
+    while (in < inend) {
+	if (xmlLittleEndian) {
+	    tmp = (unsigned char *) in;
+	    c = *tmp++;
+	    c = c << 8;
+	    c = c | (unsigned int) *tmp;
+	    in++;
+	} else {
+	    c= *in++;
+	} 
+        if ((c & 0xFC00) == 0xD800) {    /* surrogates */
+	    if (in >= inend) {           /* (in > inend) shouldn't happens */
+		*outlen = out - outstart;
+		*inlenb = processed - inb;
+	        return(-2);
+	    }
+	    if (xmlLittleEndian) {
+		tmp = (unsigned char *) in;
+		d = *tmp++;
+		d = d << 8;
+		d = d | (unsigned int) *tmp;
+		in++;
+	    } else {
+		d= *in++;
+	    }
+            if ((d & 0xFC00) == 0xDC00) {
+                c &= 0x03FF;
+                c <<= 10;
+                c |= d & 0x03FF;
+                c += 0x10000;
+            }
+            else {
+		*outlen = out - outstart;
+		*inlenb = processed - inb;
+	        return(-2);
+	    }
+        }
+
+	/* assertion: c is a single UTF-4 value */
+        if (out >= outend) 
+	    break;
+        if      (c <    0x80) {  *out++=  c;                bits= -6; }
+        else if (c <   0x800) {  *out++= ((c >>  6) & 0x1F) | 0xC0;  bits=  0; }
+        else if (c < 0x10000) {  *out++= ((c >> 12) & 0x0F) | 0xE0;  bits=  6; }
+        else                  {  *out++= ((c >> 18) & 0x07) | 0xF0;  bits= 12; }
+ 
+        for ( ; bits >= 0; bits-= 6) {
+            if (out >= outend) 
+	        break;
+            *out++= ((c >> bits) & 0x3F) | 0x80;
+        }
+	processed = (const unsigned char*) in;
+    }
+    *outlen = out - outstart;
+    *inlenb = processed - inb;
+    return(0);
+}
+
+#ifdef LIBXML_OUTPUT_ENABLED
+/**
+ * UTF8ToUTF16BE:
+ * @outb:  a pointer to an array of bytes to store the result
+ * @outlen:  the length of @outb
+ * @in:  a pointer to an array of UTF-8 chars
+ * @inlen:  the length of @in
+ *
+ * Take a block of UTF-8 chars in and try to convert it to an UTF-16BE
+ * block of chars out.
+ *
+ * Returns the number of byte written, or -1 by lack of space, or -2
+ *     if the transcoding failed. 
+ */
+static int
+UTF8ToUTF16BE(unsigned char* outb, int *outlen,
+            const unsigned char* in, int *inlen)
+{
+    unsigned short* out = (unsigned short*) outb;
+    const unsigned char* processed = in;
+    const unsigned char *const instart = in;
+    unsigned short* outstart= out;
+    unsigned short* outend;
+    const unsigned char* inend= in+*inlen;
+    unsigned int c, d;
+    int trailing;
+    unsigned char *tmp;
+    unsigned short tmp1, tmp2;
+
+    /* UTF-16BE has no BOM */
+    if (in == NULL) {
+	*outlen = 0;
+	*inlen = 0;
+	return(0);
+    }
+    outend = out + (*outlen / 2);
+    while (in < inend) {
+      d= *in++;
+      if      (d < 0x80)  { c= d; trailing= 0; }
+      else if (d < 0xC0)  {
+          /* trailing byte in leading position */
+	  *outlen = out - outstart;
+	  *inlen = processed - instart;
+	  return(-2);
+      } else if (d < 0xE0)  { c= d & 0x1F; trailing= 1; }
+      else if (d < 0xF0)  { c= d & 0x0F; trailing= 2; }
+      else if (d < 0xF8)  { c= d & 0x07; trailing= 3; }
+      else {
+          /* no chance for this in UTF-16 */
+	  *outlen = out - outstart;
+	  *inlen = processed - instart;
+	  return(-2);
+      }
+
+      if (inend - in < trailing) {
+          break;
+      } 
+
+      for ( ; trailing; trailing--) {
+          if ((in >= inend) || (((d= *in++) & 0xC0) != 0x80))  break;
+          c <<= 6;
+          c |= d & 0x3F;
+      }
+
+      /* assertion: c is a single UTF-4 value */
+        if (c < 0x10000) {
+            if (out >= outend)  break;
+	    if (xmlLittleEndian) {
+		tmp = (unsigned char *) out;
+		*tmp = c >> 8;
+		*(tmp + 1) = c;
+		out++;
+	    } else {
+		*out++ = c;
+	    }
+        }
+        else if (c < 0x110000) {
+            if (out+1 >= outend)  break;
+            c -= 0x10000;
+	    if (xmlLittleEndian) {
+		tmp1 = 0xD800 | (c >> 10);
+		tmp = (unsigned char *) out;
+		*tmp = tmp1 >> 8;
+		*(tmp + 1) = (unsigned char) tmp1;
+		out++;
+
+		tmp2 = 0xDC00 | (c & 0x03FF);
+		tmp = (unsigned char *) out;
+		*tmp = tmp2 >> 8;
+		*(tmp + 1) = (unsigned char) tmp2;
+		out++;
+	    } else {
+		*out++ = 0xD800 | (c >> 10);
+		*out++ = 0xDC00 | (c & 0x03FF);
+	    }
+        }
+        else
+	    break;
+	processed = in;
+    }
+    *outlen = (out - outstart) * 2;
+    *inlen = processed - instart;
+    return(0);
+}
+#endif /* LIBXML_OUTPUT_ENABLED */
+
+/************************************************************************
+ *									*
+ *		Generic encoding handling routines			*
+ *									*
+ ************************************************************************/
+
+/**
+ * xmlDetectCharEncoding:
+ * @in:  a pointer to the first bytes of the XML entity, must be at least
+ *       2 bytes long (at least 4 if encoding is UTF4 variant).
+ * @len:  pointer to the length of the buffer
+ *
+ * Guess the encoding of the entity using the first bytes of the entity content
+ * according to the non-normative appendix F of the XML-1.0 recommendation.
+ * 
+ * Returns one of the XML_CHAR_ENCODING_... values.
+ */
+xmlCharEncoding
+xmlDetectCharEncoding(const unsigned char* in, int len)
+{
+    if (len >= 4) {
+	if ((in[0] == 0x00) && (in[1] == 0x00) &&
+	    (in[2] == 0x00) && (in[3] == 0x3C))
+	    return(XML_CHAR_ENCODING_UCS4BE);
+	if ((in[0] == 0x3C) && (in[1] == 0x00) &&
+	    (in[2] == 0x00) && (in[3] == 0x00))
+	    return(XML_CHAR_ENCODING_UCS4LE);
+	if ((in[0] == 0x00) && (in[1] == 0x00) &&
+	    (in[2] == 0x3C) && (in[3] == 0x00))
+	    return(XML_CHAR_ENCODING_UCS4_2143);
+	if ((in[0] == 0x00) && (in[1] == 0x3C) &&
+	    (in[2] == 0x00) && (in[3] == 0x00))
+	    return(XML_CHAR_ENCODING_UCS4_3412);
+	if ((in[0] == 0x4C) && (in[1] == 0x6F) &&
+	    (in[2] == 0xA7) && (in[3] == 0x94))
+	    return(XML_CHAR_ENCODING_EBCDIC);
+	if ((in[0] == 0x3C) && (in[1] == 0x3F) &&
+	    (in[2] == 0x78) && (in[3] == 0x6D))
+	    return(XML_CHAR_ENCODING_UTF8);
+	/*
+	 * Although not part of the recommendation, we also
+	 * attempt an "auto-recognition" of UTF-16LE and
+	 * UTF-16BE encodings.
+	 */
+	if ((in[0] == 0x3C) && (in[1] == 0x00) &&
+	    (in[2] == 0x3F) && (in[3] == 0x00))
+	    return(XML_CHAR_ENCODING_UTF16LE);
+	if ((in[0] == 0x00) && (in[1] == 0x3C) &&
+	    (in[2] == 0x00) && (in[3] == 0x3F))
+	    return(XML_CHAR_ENCODING_UTF16BE);
+    }
+    if (len >= 3) {
+	/*
+	 * Errata on XML-1.0 June 20 2001
+	 * We now allow an UTF8 encoded BOM
+	 */
+	if ((in[0] == 0xEF) && (in[1] == 0xBB) &&
+	    (in[2] == 0xBF))
+	    return(XML_CHAR_ENCODING_UTF8);
+    }
+    /* For UTF-16 we can recognize by the BOM */
+    if (len >= 2) {
+	if ((in[0] == 0xFE) && (in[1] == 0xFF))
+	    return(XML_CHAR_ENCODING_UTF16BE);
+	if ((in[0] == 0xFF) && (in[1] == 0xFE))
+	    return(XML_CHAR_ENCODING_UTF16LE);
+    }
+    return(XML_CHAR_ENCODING_NONE);
+}
+
+/**
+ * xmlCleanupEncodingAliases:
+ *
+ * Unregisters all aliases
+ */
+void
+xmlCleanupEncodingAliases(void) {
+    int i;
+
+    if (xmlCharEncodingAliases == NULL)
+	return;
+
+    for (i = 0;i < xmlCharEncodingAliasesNb;i++) {
+	if (xmlCharEncodingAliases[i].name != NULL)
+	    xmlFree((char *) xmlCharEncodingAliases[i].name);
+	if (xmlCharEncodingAliases[i].alias != NULL)
+	    xmlFree((char *) xmlCharEncodingAliases[i].alias);
+    }
+    xmlCharEncodingAliasesNb = 0;
+    xmlCharEncodingAliasesMax = 0;
+    xmlFree(xmlCharEncodingAliases);
+    xmlCharEncodingAliases = NULL;
+}
+
+/**
+ * xmlGetEncodingAlias:
+ * @alias:  the alias name as parsed, in UTF-8 format (ASCII actually)
+ *
+ * Lookup an encoding name for the given alias.
+ * 
+ * Returns NULL if not found, otherwise the original name
+ */
+const char *
+xmlGetEncodingAlias(const char *alias) {
+    int i;
+    char upper[100];
+
+    if (alias == NULL)
+	return(NULL);
+
+    if (xmlCharEncodingAliases == NULL)
+	return(NULL);
+
+    for (i = 0;i < 99;i++) {
+        upper[i] = toupper(alias[i]);
+	if (upper[i] == 0) break;
+    }
+    upper[i] = 0;
+
+    /*
+     * Walk down the list looking for a definition of the alias
+     */
+    for (i = 0;i < xmlCharEncodingAliasesNb;i++) {
+	if (!strcmp(xmlCharEncodingAliases[i].alias, upper)) {
+	    return(xmlCharEncodingAliases[i].name);
+	}
+    }
+    return(NULL);
+}
+
+/**
+ * xmlAddEncodingAlias:
+ * @name:  the encoding name as parsed, in UTF-8 format (ASCII actually)
+ * @alias:  the alias name as parsed, in UTF-8 format (ASCII actually)
+ *
+ * Registers an alias @alias for an encoding named @name. Existing alias
+ * will be overwritten.
+ * 
+ * Returns 0 in case of success, -1 in case of error
+ */
+int
+xmlAddEncodingAlias(const char *name, const char *alias) {
+    int i;
+    char upper[100];
+
+    if ((name == NULL) || (alias == NULL))
+	return(-1);
+
+    for (i = 0;i < 99;i++) {
+        upper[i] = toupper(alias[i]);
+	if (upper[i] == 0) break;
+    }
+    upper[i] = 0;
+
+    if (xmlCharEncodingAliases == NULL) {
+	xmlCharEncodingAliasesNb = 0;
+	xmlCharEncodingAliasesMax = 20;
+	xmlCharEncodingAliases = (xmlCharEncodingAliasPtr) 
+	      xmlMalloc(xmlCharEncodingAliasesMax * sizeof(xmlCharEncodingAlias));
+	if (xmlCharEncodingAliases == NULL)
+	    return(-1);
+    } else if (xmlCharEncodingAliasesNb >= xmlCharEncodingAliasesMax) {
+	xmlCharEncodingAliasesMax *= 2;
+	xmlCharEncodingAliases = (xmlCharEncodingAliasPtr) 
+	      xmlRealloc(xmlCharEncodingAliases,
+		         xmlCharEncodingAliasesMax * sizeof(xmlCharEncodingAlias));
+    }
+    /*
+     * Walk down the list looking for a definition of the alias
+     */
+    for (i = 0;i < xmlCharEncodingAliasesNb;i++) {
+	if (!strcmp(xmlCharEncodingAliases[i].alias, upper)) {
+	    /*
+	     * Replace the definition.
+	     */
+	    xmlFree((char *) xmlCharEncodingAliases[i].name);
+	    xmlCharEncodingAliases[i].name = xmlMemStrdup(name);
+	    return(0);
+	}
+    }
+    /*
+     * Add the definition
+     */
+    xmlCharEncodingAliases[xmlCharEncodingAliasesNb].name = xmlMemStrdup(name);
+    xmlCharEncodingAliases[xmlCharEncodingAliasesNb].alias = xmlMemStrdup(upper);
+    xmlCharEncodingAliasesNb++;
+    return(0);
+}
+
+/**
+ * xmlDelEncodingAlias:
+ * @alias:  the alias name as parsed, in UTF-8 format (ASCII actually)
+ *
+ * Unregisters an encoding alias @alias
+ * 
+ * Returns 0 in case of success, -1 in case of error
+ */
+int
+xmlDelEncodingAlias(const char *alias) {
+    int i;
+
+    if (alias == NULL)
+	return(-1);
+
+    if (xmlCharEncodingAliases == NULL)
+	return(-1);
+    /*
+     * Walk down the list looking for a definition of the alias
+     */
+    for (i = 0;i < xmlCharEncodingAliasesNb;i++) {
+	if (!strcmp(xmlCharEncodingAliases[i].alias, alias)) {
+	    xmlFree((char *) xmlCharEncodingAliases[i].name);
+	    xmlFree((char *) xmlCharEncodingAliases[i].alias);
+	    xmlCharEncodingAliasesNb--;
+	    memmove(&xmlCharEncodingAliases[i], &xmlCharEncodingAliases[i + 1],
+		    sizeof(xmlCharEncodingAlias) * (xmlCharEncodingAliasesNb - i));
+	    return(0);
+	}
+    }
+    return(-1);
+}
+
+/**
+ * xmlParseCharEncoding:
+ * @name:  the encoding name as parsed, in UTF-8 format (ASCII actually)
+ *
+ * Compare the string to the encoding schemes already known. Note
+ * that the comparison is case insensitive accordingly to the section
+ * [XML] 4.3.3 Character Encoding in Entities.
+ * 
+ * Returns one of the XML_CHAR_ENCODING_... values or XML_CHAR_ENCODING_NONE
+ * if not recognized.
+ */
+xmlCharEncoding
+xmlParseCharEncoding(const char* name)
+{
+    const char *alias;
+    char upper[500];
+    int i;
+
+    if (name == NULL)
+	return(XML_CHAR_ENCODING_NONE);
+
+    /*
+     * Do the alias resolution
+     */
+    alias = xmlGetEncodingAlias(name);
+    if (alias != NULL)
+	name = alias;
+
+    for (i = 0;i < 499;i++) {
+        upper[i] = toupper(name[i]);
+	if (upper[i] == 0) break;
+    }
+    upper[i] = 0;
+
+    if (!strcmp(upper, "")) return(XML_CHAR_ENCODING_NONE);
+    if (!strcmp(upper, "UTF-8")) return(XML_CHAR_ENCODING_UTF8);
+    if (!strcmp(upper, "UTF8")) return(XML_CHAR_ENCODING_UTF8);
+
+    /*
+     * NOTE: if we were able to parse this, the endianness of UTF16 is
+     *       already found and in use
+     */
+    if (!strcmp(upper, "UTF-16")) return(XML_CHAR_ENCODING_UTF16LE);
+    if (!strcmp(upper, "UTF16")) return(XML_CHAR_ENCODING_UTF16LE);
+    
+    if (!strcmp(upper, "ISO-10646-UCS-2")) return(XML_CHAR_ENCODING_UCS2);
+    if (!strcmp(upper, "UCS-2")) return(XML_CHAR_ENCODING_UCS2);
+    if (!strcmp(upper, "UCS2")) return(XML_CHAR_ENCODING_UCS2);
+
+    /*
+     * NOTE: if we were able to parse this, the endianness of UCS4 is
+     *       already found and in use
+     */
+    if (!strcmp(upper, "ISO-10646-UCS-4")) return(XML_CHAR_ENCODING_UCS4LE);
+    if (!strcmp(upper, "UCS-4")) return(XML_CHAR_ENCODING_UCS4LE);
+    if (!strcmp(upper, "UCS4")) return(XML_CHAR_ENCODING_UCS4LE);
+
+    
+    if (!strcmp(upper,  "ISO-8859-1")) return(XML_CHAR_ENCODING_8859_1);
+    if (!strcmp(upper,  "ISO-LATIN-1")) return(XML_CHAR_ENCODING_8859_1);
+    if (!strcmp(upper,  "ISO LATIN 1")) return(XML_CHAR_ENCODING_8859_1);
+
+    if (!strcmp(upper,  "ISO-8859-2")) return(XML_CHAR_ENCODING_8859_2);
+    if (!strcmp(upper,  "ISO-LATIN-2")) return(XML_CHAR_ENCODING_8859_2);
+    if (!strcmp(upper,  "ISO LATIN 2")) return(XML_CHAR_ENCODING_8859_2);
+
+    if (!strcmp(upper,  "ISO-8859-3")) return(XML_CHAR_ENCODING_8859_3);
+    if (!strcmp(upper,  "ISO-8859-4")) return(XML_CHAR_ENCODING_8859_4);
+    if (!strcmp(upper,  "ISO-8859-5")) return(XML_CHAR_ENCODING_8859_5);
+    if (!strcmp(upper,  "ISO-8859-6")) return(XML_CHAR_ENCODING_8859_6);
+    if (!strcmp(upper,  "ISO-8859-7")) return(XML_CHAR_ENCODING_8859_7);
+    if (!strcmp(upper,  "ISO-8859-8")) return(XML_CHAR_ENCODING_8859_8);
+    if (!strcmp(upper,  "ISO-8859-9")) return(XML_CHAR_ENCODING_8859_9);
+
+    if (!strcmp(upper, "ISO-2022-JP")) return(XML_CHAR_ENCODING_2022_JP);
+    if (!strcmp(upper, "SHIFT_JIS")) return(XML_CHAR_ENCODING_SHIFT_JIS);
+    if (!strcmp(upper, "EUC-JP")) return(XML_CHAR_ENCODING_EUC_JP);
+
+#ifdef DEBUG_ENCODING
+    xmlGenericError(xmlGenericErrorContext, "Unknown encoding %s\n", name);
+#endif
+    return(XML_CHAR_ENCODING_ERROR);
+}
+
+/**
+ * xmlGetCharEncodingName:
+ * @enc:  the encoding
+ *
+ * The "canonical" name for XML encoding.
+ * C.f. http://www.w3.org/TR/REC-xml#charencoding
+ * Section 4.3.3  Character Encoding in Entities
+ *
+ * Returns the canonical name for the given encoding
+ */
+
+const char*
+xmlGetCharEncodingName(xmlCharEncoding enc) {
+    switch (enc) {
+        case XML_CHAR_ENCODING_ERROR:
+	    return(NULL);
+        case XML_CHAR_ENCODING_NONE:
+	    return(NULL);
+        case XML_CHAR_ENCODING_UTF8:
+	    return("UTF-8");
+        case XML_CHAR_ENCODING_UTF16LE:
+	    return("UTF-16");
+        case XML_CHAR_ENCODING_UTF16BE:
+	    return("UTF-16");
+        case XML_CHAR_ENCODING_EBCDIC:
+            return("EBCDIC");
+        case XML_CHAR_ENCODING_UCS4LE:
+            return("ISO-10646-UCS-4");
+        case XML_CHAR_ENCODING_UCS4BE:
+            return("ISO-10646-UCS-4");
+        case XML_CHAR_ENCODING_UCS4_2143:
+            return("ISO-10646-UCS-4");
+        case XML_CHAR_ENCODING_UCS4_3412:
+            return("ISO-10646-UCS-4");
+        case XML_CHAR_ENCODING_UCS2:
+            return("ISO-10646-UCS-2");
+        case XML_CHAR_ENCODING_8859_1:
+	    return("ISO-8859-1");
+        case XML_CHAR_ENCODING_8859_2:
+	    return("ISO-8859-2");
+        case XML_CHAR_ENCODING_8859_3:
+	    return("ISO-8859-3");
+        case XML_CHAR_ENCODING_8859_4:
+	    return("ISO-8859-4");
+        case XML_CHAR_ENCODING_8859_5:
+	    return("ISO-8859-5");
+        case XML_CHAR_ENCODING_8859_6:
+	    return("ISO-8859-6");
+        case XML_CHAR_ENCODING_8859_7:
+	    return("ISO-8859-7");
+        case XML_CHAR_ENCODING_8859_8:
+	    return("ISO-8859-8");
+        case XML_CHAR_ENCODING_8859_9:
+	    return("ISO-8859-9");
+        case XML_CHAR_ENCODING_2022_JP:
+            return("ISO-2022-JP");
+        case XML_CHAR_ENCODING_SHIFT_JIS:
+            return("Shift-JIS");
+        case XML_CHAR_ENCODING_EUC_JP:
+            return("EUC-JP");
+	case XML_CHAR_ENCODING_ASCII:
+	    return(NULL);
+    }
+    return(NULL);
+}
+
+/************************************************************************
+ *									*
+ *			Char encoding handlers				*
+ *									*
+ ************************************************************************/
+
+
+/* the size should be growable, but it's not a big deal ... */
+#define MAX_ENCODING_HANDLERS 50
+static xmlCharEncodingHandlerPtr *handlers = NULL;
+static int nbCharEncodingHandler = 0;
+
+/*
+ * The default is UTF-8 for XML, that's also the default used for the
+ * parser internals, so the default encoding handler is NULL
+ */
+
+static xmlCharEncodingHandlerPtr xmlDefaultCharEncodingHandler = NULL;
+
+/**
+ * xmlNewCharEncodingHandler:
+ * @name:  the encoding name, in UTF-8 format (ASCII actually)
+ * @input:  the xmlCharEncodingInputFunc to read that encoding
+ * @output:  the xmlCharEncodingOutputFunc to write that encoding
+ *
+ * Create and registers an xmlCharEncodingHandler.
+ *
+ * Returns the xmlCharEncodingHandlerPtr created (or NULL in case of error).
+ */
+xmlCharEncodingHandlerPtr
+xmlNewCharEncodingHandler(const char *name, 
+                          xmlCharEncodingInputFunc input,
+                          xmlCharEncodingOutputFunc output) {
+    xmlCharEncodingHandlerPtr handler;
+    const char *alias;
+    char upper[500];
+    int i;
+    char *up = 0;
+
+    /*
+     * Do the alias resolution
+     */
+    alias = xmlGetEncodingAlias(name);
+    if (alias != NULL)
+	name = alias;
+
+    /*
+     * Keep only the uppercase version of the encoding.
+     */
+    if (name == NULL) {
+        xmlGenericError(xmlGenericErrorContext,
+		"xmlNewCharEncodingHandler : no name !\n");
+	return(NULL);
+    }
+    for (i = 0;i < 499;i++) {
+        upper[i] = toupper(name[i]);
+	if (upper[i] == 0) break;
+    }
+    upper[i] = 0;
+    up = xmlMemStrdup(upper);
+    if (up == NULL) {
+        xmlGenericError(xmlGenericErrorContext,
+		"xmlNewCharEncodingHandler : out of memory !\n");
+	return(NULL);
+    }
+
+    /*
+     * allocate and fill-up an handler block.
+     */
+    handler = (xmlCharEncodingHandlerPtr)
+              xmlMalloc(sizeof(xmlCharEncodingHandler));
+    if (handler == NULL) {
+        xmlGenericError(xmlGenericErrorContext,
+		"xmlNewCharEncodingHandler : out of memory !\n");
+	return(NULL);
+    }
+    handler->input = input;
+    handler->output = output;
+    handler->name = up;
+
+#ifdef LIBXML_ICONV_ENABLED
+    handler->iconv_in = NULL;
+    handler->iconv_out = NULL;
+#endif /* LIBXML_ICONV_ENABLED */
+
+    /*
+     * registers and returns the handler.
+     */
+    xmlRegisterCharEncodingHandler(handler);
+#ifdef DEBUG_ENCODING
+    xmlGenericError(xmlGenericErrorContext,
+	    "Registered encoding handler for %s\n", name);
+#endif
+    return(handler);
+}
+
+/**
+ * xmlInitCharEncodingHandlers:
+ *
+ * Initialize the char encoding support, it registers the default
+ * encoding supported.
+ * NOTE: while public, this function usually doesn't need to be called
+ *       in normal processing.
+ */
+void
+xmlInitCharEncodingHandlers(void) {
+    unsigned short int tst = 0x1234;
+    unsigned char *ptr = (unsigned char *) &tst; 
+
+    if (handlers != NULL) return;
+
+    handlers = (xmlCharEncodingHandlerPtr *)
+        xmlMalloc(MAX_ENCODING_HANDLERS * sizeof(xmlCharEncodingHandlerPtr));
+
+    if (*ptr == 0x12) xmlLittleEndian = 0;
+    else if (*ptr == 0x34) xmlLittleEndian = 1;
+    else xmlGenericError(xmlGenericErrorContext,
+	    "Odd problem at endianness detection\n");
+
+    if (handlers == NULL) {
+        xmlGenericError(xmlGenericErrorContext,
+		"xmlInitCharEncodingHandlers : out of memory !\n");
+	return;
+    }
+    xmlNewCharEncodingHandler("UTF-8", UTF8ToUTF8, UTF8ToUTF8);
+#ifdef LIBXML_OUTPUT_ENABLED
+    xmlUTF16LEHandler = 
+          xmlNewCharEncodingHandler("UTF-16LE", UTF16LEToUTF8, UTF8ToUTF16LE);
+    xmlUTF16BEHandler = 
+          xmlNewCharEncodingHandler("UTF-16BE", UTF16BEToUTF8, UTF8ToUTF16BE);
+    xmlNewCharEncodingHandler("UTF-16", UTF16LEToUTF8, UTF8ToUTF16);
+    xmlNewCharEncodingHandler("ISO-8859-1", isolat1ToUTF8, UTF8Toisolat1);
+    xmlNewCharEncodingHandler("ASCII", asciiToUTF8, UTF8Toascii);
+    xmlNewCharEncodingHandler("US-ASCII", asciiToUTF8, UTF8Toascii);
+#ifdef LIBXML_HTML_ENABLED
+    xmlNewCharEncodingHandler("HTML", NULL, UTF8ToHtml);
+#endif
+#else
+    xmlUTF16LEHandler = 
+          xmlNewCharEncodingHandler("UTF-16LE", UTF16LEToUTF8, NULL);
+    xmlUTF16BEHandler = 
+          xmlNewCharEncodingHandler("UTF-16BE", UTF16BEToUTF8, NULL);
+    xmlNewCharEncodingHandler("UTF-16", UTF16LEToUTF8, NULL);
+    xmlNewCharEncodingHandler("ISO-8859-1", isolat1ToUTF8, NULL);
+    xmlNewCharEncodingHandler("ASCII", asciiToUTF8, NULL);
+    xmlNewCharEncodingHandler("US-ASCII", asciiToUTF8, NULL);
+#endif /* LIBXML_OUTPUT_ENABLED */
+#ifndef LIBXML_ICONV_ENABLED
+#ifdef LIBXML_ISO8859X_ENABLED
+    xmlRegisterCharEncodingHandlersISO8859x ();
+#endif
+#endif
+
+}
+
+/**
+ * xmlCleanupCharEncodingHandlers:
+ *
+ * Cleanup the memory allocated for the char encoding support, it
+ * unregisters all the encoding handlers and the aliases.
+ */
+void
+xmlCleanupCharEncodingHandlers(void) {
+    xmlCleanupEncodingAliases();
+
+    if (handlers == NULL) return;
+
+    for (;nbCharEncodingHandler > 0;) {
+        nbCharEncodingHandler--;
+	if (handlers[nbCharEncodingHandler] != NULL) {
+	    if (handlers[nbCharEncodingHandler]->name != NULL)
+		xmlFree(handlers[nbCharEncodingHandler]->name);
+	    xmlFree(handlers[nbCharEncodingHandler]);
+	}
+    }
+    xmlFree(handlers);
+    handlers = NULL;
+    nbCharEncodingHandler = 0;
+    xmlDefaultCharEncodingHandler = NULL;
+}
+
+/**
+ * xmlRegisterCharEncodingHandler:
+ * @handler:  the xmlCharEncodingHandlerPtr handler block
+ *
+ * Register the char encoding handler, surprising, isn't it ?
+ */
+void
+xmlRegisterCharEncodingHandler(xmlCharEncodingHandlerPtr handler) {
+    if (handlers == NULL) xmlInitCharEncodingHandlers();
+    if (handler == NULL) {
+        xmlGenericError(xmlGenericErrorContext,
+		"xmlRegisterCharEncodingHandler: NULL handler !\n");
+	return;
+    }
+
+    if (nbCharEncodingHandler >= MAX_ENCODING_HANDLERS) {
+        xmlGenericError(xmlGenericErrorContext, 
+	"xmlRegisterCharEncodingHandler: Too many handler registered\n");
+        xmlGenericError(xmlGenericErrorContext,
+		"\tincrease MAX_ENCODING_HANDLERS : %s\n", __FILE__);
+	return;
+    }
+    handlers[nbCharEncodingHandler++] = handler;
+}
+
+/**
+ * xmlGetCharEncodingHandler:
+ * @enc:  an xmlCharEncoding value.
+ *
+ * Search in the registered set the handler able to read/write that encoding.
+ *
+ * Returns the handler or NULL if not found
+ */
+xmlCharEncodingHandlerPtr
+xmlGetCharEncodingHandler(xmlCharEncoding enc) {
+    xmlCharEncodingHandlerPtr handler;
+
+    if (handlers == NULL) xmlInitCharEncodingHandlers();
+    switch (enc) {
+        case XML_CHAR_ENCODING_ERROR:
+	    return(NULL);
+        case XML_CHAR_ENCODING_NONE:
+	    return(NULL);
+        case XML_CHAR_ENCODING_UTF8:
+	    return(NULL);
+        case XML_CHAR_ENCODING_UTF16LE:
+	    return(xmlUTF16LEHandler);
+        case XML_CHAR_ENCODING_UTF16BE:
+	    return(xmlUTF16BEHandler);
+        case XML_CHAR_ENCODING_EBCDIC:
+            handler = xmlFindCharEncodingHandler("EBCDIC");
+            if (handler != NULL) return(handler);
+            handler = xmlFindCharEncodingHandler("ebcdic");
+            if (handler != NULL) return(handler);
+	    break;
+        case XML_CHAR_ENCODING_UCS4BE:
+            handler = xmlFindCharEncodingHandler("ISO-10646-UCS-4");
+            if (handler != NULL) return(handler);
+            handler = xmlFindCharEncodingHandler("UCS-4");
+            if (handler != NULL) return(handler);
+            handler = xmlFindCharEncodingHandler("UCS4");
+            if (handler != NULL) return(handler);
+	    break;
+        case XML_CHAR_ENCODING_UCS4LE:
+            handler = xmlFindCharEncodingHandler("ISO-10646-UCS-4");
+            if (handler != NULL) return(handler);
+            handler = xmlFindCharEncodingHandler("UCS-4");
+            if (handler != NULL) return(handler);
+            handler = xmlFindCharEncodingHandler("UCS4");
+            if (handler != NULL) return(handler);
+	    break;
+        case XML_CHAR_ENCODING_UCS4_2143:
+	    break;
+        case XML_CHAR_ENCODING_UCS4_3412:
+	    break;
+        case XML_CHAR_ENCODING_UCS2:
+            handler = xmlFindCharEncodingHandler("ISO-10646-UCS-2");
+            if (handler != NULL) return(handler);
+            handler = xmlFindCharEncodingHandler("UCS-2");
+            if (handler != NULL) return(handler);
+            handler = xmlFindCharEncodingHandler("UCS2");
+            if (handler != NULL) return(handler);
+	    break;
+
+	    /*
+	     * We used to keep ISO Latin encodings native in the
+	     * generated data. This led to so many problems that
+	     * this has been removed. One can still change this
+	     * back by registering no-ops encoders for those
+	     */
+        case XML_CHAR_ENCODING_8859_1:
+	    handler = xmlFindCharEncodingHandler("ISO-8859-1");
+	    if (handler != NULL) return(handler);
+	    break;
+        case XML_CHAR_ENCODING_8859_2:
+	    handler = xmlFindCharEncodingHandler("ISO-8859-2");
+	    if (handler != NULL) return(handler);
+	    break;
+        case XML_CHAR_ENCODING_8859_3:
+	    handler = xmlFindCharEncodingHandler("ISO-8859-3");
+	    if (handler != NULL) return(handler);
+	    break;
+        case XML_CHAR_ENCODING_8859_4:
+	    handler = xmlFindCharEncodingHandler("ISO-8859-4");
+	    if (handler != NULL) return(handler);
+	    break;
+        case XML_CHAR_ENCODING_8859_5:
+	    handler = xmlFindCharEncodingHandler("ISO-8859-5");
+	    if (handler != NULL) return(handler);
+	    break;
+        case XML_CHAR_ENCODING_8859_6:
+	    handler = xmlFindCharEncodingHandler("ISO-8859-6");
+	    if (handler != NULL) return(handler);
+	    break;
+        case XML_CHAR_ENCODING_8859_7:
+	    handler = xmlFindCharEncodingHandler("ISO-8859-7");
+	    if (handler != NULL) return(handler);
+	    break;
+        case XML_CHAR_ENCODING_8859_8:
+	    handler = xmlFindCharEncodingHandler("ISO-8859-8");
+	    if (handler != NULL) return(handler);
+	    break;
+        case XML_CHAR_ENCODING_8859_9:
+	    handler = xmlFindCharEncodingHandler("ISO-8859-9");
+	    if (handler != NULL) return(handler);
+	    break;
+
+
+        case XML_CHAR_ENCODING_2022_JP:
+            handler = xmlFindCharEncodingHandler("ISO-2022-JP");
+            if (handler != NULL) return(handler);
+	    break;
+        case XML_CHAR_ENCODING_SHIFT_JIS:
+            handler = xmlFindCharEncodingHandler("SHIFT-JIS");
+            if (handler != NULL) return(handler);
+            handler = xmlFindCharEncodingHandler("SHIFT_JIS");
+            if (handler != NULL) return(handler);
+            handler = xmlFindCharEncodingHandler("Shift_JIS");
+            if (handler != NULL) return(handler);
+	    break;
+        case XML_CHAR_ENCODING_EUC_JP:
+            handler = xmlFindCharEncodingHandler("EUC-JP");
+            if (handler != NULL) return(handler);
+	    break;
+	default: 
+	    break;
+    }
+    
+#ifdef DEBUG_ENCODING
+    xmlGenericError(xmlGenericErrorContext,
+	    "No handler found for encoding %d\n", enc);
+#endif
+    return(NULL);
+}
+
+/**
+ * xmlFindCharEncodingHandler:
+ * @name:  a string describing the char encoding.
+ *
+ * Search in the registered set the handler able to read/write that encoding.
+ *
+ * Returns the handler or NULL if not found
+ */
+xmlCharEncodingHandlerPtr
+xmlFindCharEncodingHandler(const char *name) {
+    const char *nalias;
+    const char *norig;
+    xmlCharEncoding alias;
+#ifdef LIBXML_ICONV_ENABLED
+    xmlCharEncodingHandlerPtr enc;
+    iconv_t icv_in, icv_out;
+#endif /* LIBXML_ICONV_ENABLED */
+    char upper[100];
+    int i;
+
+    if (handlers == NULL) xmlInitCharEncodingHandlers();
+    if (name == NULL) return(xmlDefaultCharEncodingHandler);
+    if (name[0] == 0) return(xmlDefaultCharEncodingHandler);
+
+    /*
+     * Do the alias resolution
+     */
+    norig = name;
+    nalias = xmlGetEncodingAlias(name);
+    if (nalias != NULL)
+	name = nalias;
+
+    /*
+     * Check first for directly registered encoding names
+     */
+    for (i = 0;i < 99;i++) {
+        upper[i] = toupper(name[i]);
+	if (upper[i] == 0) break;
+    }
+    upper[i] = 0;
+
+    for (i = 0;i < nbCharEncodingHandler; i++)
+        if (!strcmp(upper, handlers[i]->name)) {
+#ifdef DEBUG_ENCODING
+            xmlGenericError(xmlGenericErrorContext,
+		    "Found registered handler for encoding %s\n", name);
+#endif
+	    return(handlers[i]);
+	}
+
+#ifdef LIBXML_ICONV_ENABLED
+    /* check whether iconv can handle this */
+    icv_in = iconv_open("UTF-8", name);
+    icv_out = iconv_open(name, "UTF-8");
+    if ((icv_in != (iconv_t) -1) && (icv_out != (iconv_t) -1)) {
+	    enc = (xmlCharEncodingHandlerPtr)
+	          xmlMalloc(sizeof(xmlCharEncodingHandler));
+	    if (enc == NULL) {
+	        iconv_close(icv_in);
+	        iconv_close(icv_out);
+		return(NULL);
+	    }
+	    enc->name = xmlMemStrdup(name);
+	    enc->input = NULL;
+	    enc->output = NULL;
+	    enc->iconv_in = icv_in;
+	    enc->iconv_out = icv_out;
+#ifdef DEBUG_ENCODING
+            xmlGenericError(xmlGenericErrorContext,
+		    "Found iconv handler for encoding %s\n", name);
+#endif
+	    return enc;
+    } else if ((icv_in != (iconv_t) -1) || icv_out != (iconv_t) -1) {
+	    xmlGenericError(xmlGenericErrorContext,
+		    "iconv : problems with filters for '%s'\n", name);
+    }
+#endif /* LIBXML_ICONV_ENABLED */
+
+#ifdef DEBUG_ENCODING
+    xmlGenericError(xmlGenericErrorContext,
+	    "No handler found for encoding %s\n", name);
+#endif
+
+    /*
+     * Fallback using the canonical names
+     */
+    alias = xmlParseCharEncoding(norig);
+    if (alias != XML_CHAR_ENCODING_ERROR) {
+        const char* canon;
+        canon = xmlGetCharEncodingName(alias);
+        if ((canon != NULL) && (strcmp(name, canon))) {
+	    return(xmlFindCharEncodingHandler(canon));
+        }
+    }
+
+    /* If "none of the above", give up */
+    return(NULL);
+}
+
+/************************************************************************
+ *									*
+ *		ICONV based generic conversion functions		*
+ *									*
+ ************************************************************************/
+
+#ifdef LIBXML_ICONV_ENABLED
+/**
+ * xmlIconvWrapper:
+ * @cd:		iconv converter data structure
+ * @out:  a pointer to an array of bytes to store the result
+ * @outlen:  the length of @out
+ * @in:  a pointer to an array of ISO Latin 1 chars
+ * @inlen:  the length of @in
+ *
+ * Returns 0 if success, or 
+ *     -1 by lack of space, or
+ *     -2 if the transcoding fails (for *in is not valid utf8 string or
+ *        the result of transformation can't fit into the encoding we want), or
+ *     -3 if there the last byte can't form a single output char.
+ *     
+ * The value of @inlen after return is the number of octets consumed
+ *     as the return value is positive, else unpredictable.
+ * The value of @outlen after return is the number of ocetes consumed.
+ */
+static int
+xmlIconvWrapper(iconv_t cd,
+    unsigned char *out, int *outlen,
+    const unsigned char *in, int *inlen) {
+
+    size_t icv_inlen = *inlen, icv_outlen = *outlen;
+    const char *icv_in = (const char *) in;
+    char *icv_out = (char *) out;
+    int ret;
+
+    ret = iconv(cd, (char **) &icv_in, &icv_inlen, &icv_out, &icv_outlen);
+    if (in != NULL) {
+        *inlen -= icv_inlen;
+        *outlen -= icv_outlen;
+    } else {
+        *inlen = 0;
+        *outlen = 0;
+    }
+    if ((icv_inlen != 0) || (ret == -1)) {
+#ifdef EILSEQ
+        if (errno == EILSEQ) {
+            return -2;
+        } else
+#endif
+#ifdef E2BIG
+        if (errno == E2BIG) {
+            return -1;
+        } else
+#endif
+#ifdef EINVAL
+        if (errno == EINVAL) {
+            return -3;
+        } else
+#endif
+        {
+            return -3;
+        }
+    }
+    return 0;
+}
+#endif /* LIBXML_ICONV_ENABLED */
+
+/************************************************************************
+ *									*
+ *		The real API used by libxml for on-the-fly conversion	*
+ *									*
+ ************************************************************************/
+
+/**
+ * xmlCharEncFirstLine:
+ * @handler:	char enconding transformation data structure
+ * @out:  an xmlBuffer for the output.
+ * @in:  an xmlBuffer for the input
+ *     
+ * Front-end for the encoding handler input function, but handle only
+ * the very first line, i.e. limit itself to 45 chars.
+ *     
+ * Returns the number of byte written if success, or 
+ *     -1 general error
+ *     -2 if the transcoding fails (for *in is not valid utf8 string or
+ *        the result of transformation can't fit into the encoding we want), or
+ */
+int
+xmlCharEncFirstLine(xmlCharEncodingHandler *handler, xmlBufferPtr out,
+                 xmlBufferPtr in) {
+    int ret = -2;
+    int written;
+    int toconv;
+
+    if (handler == NULL) return(-1);
+    if (out == NULL) return(-1);
+    if (in == NULL) return(-1);
+
+    written = out->size - out->use;
+    toconv = in->use;
+    if (toconv * 2 >= written) {
+        xmlBufferGrow(out, toconv);
+	written = out->size - out->use - 1;
+    }
+
+    /*
+     * echo '<?xml version="1.0" encoding="UCS4"?>' | wc -c => 38
+     * 45 chars should be sufficient to reach the end of the encoding
+     * declaration without going too far inside the document content.
+     */
+    written = 45;
+
+    if (handler->input != NULL) {
+	ret = handler->input(&out->content[out->use], &written,
+	                     in->content, &toconv);
+	xmlBufferShrink(in, toconv);
+	out->use += written;
+	out->content[out->use] = 0;
+    }
+#ifdef LIBXML_ICONV_ENABLED
+    else if (handler->iconv_in != NULL) {
+	ret = xmlIconvWrapper(handler->iconv_in, &out->content[out->use],
+	                      &written, in->content, &toconv);
+	xmlBufferShrink(in, toconv);
+	out->use += written;
+	out->content[out->use] = 0;
+	if (ret == -1) ret = -3;
+    }
+#endif /* LIBXML_ICONV_ENABLED */
+#ifdef DEBUG_ENCODING
+    switch (ret) {
+        case 0:
+	    xmlGenericError(xmlGenericErrorContext,
+		    "converted %d bytes to %d bytes of input\n",
+	            toconv, written);
+	    break;
+        case -1:
+	    xmlGenericError(xmlGenericErrorContext,"converted %d bytes to %d bytes of input, %d left\n",
+	            toconv, written, in->use);
+	    break;
+        case -2:
+	    xmlGenericError(xmlGenericErrorContext,
+		    "input conversion failed due to input error\n");
+	    break;
+        case -3:
+	    xmlGenericError(xmlGenericErrorContext,"converted %d bytes to %d bytes of input, %d left\n",
+	            toconv, written, in->use);
+	    break;
+	default:
+	    xmlGenericError(xmlGenericErrorContext,"Unknown input conversion failed %d\n", ret);
+    }
+#endif /* DEBUG_ENCODING */
+    /*
+     * Ignore when input buffer is not on a boundary
+     */
+    if (ret == -3) ret = 0;
+    if (ret == -1) ret = 0;
+    return(ret);
+}
+
+/**
+ * xmlCharEncInFunc:
+ * @handler:	char encoding transformation data structure
+ * @out:  an xmlBuffer for the output.
+ * @in:  an xmlBuffer for the input
+ *     
+ * Generic front-end for the encoding handler input function
+ *     
+ * Returns the number of byte written if success, or 
+ *     -1 general error
+ *     -2 if the transcoding fails (for *in is not valid utf8 string or
+ *        the result of transformation can't fit into the encoding we want), or
+ */
+int
+xmlCharEncInFunc(xmlCharEncodingHandler * handler, xmlBufferPtr out,
+                 xmlBufferPtr in)
+{
+    int ret = -2;
+    int written;
+    int toconv;
+
+    if (handler == NULL)
+        return (-1);
+    if (out == NULL)
+        return (-1);
+    if (in == NULL)
+        return (-1);
+
+    toconv = in->use;
+    if (toconv == 0)
+        return (0);
+    written = out->size - out->use;
+    if (toconv * 2 >= written) {
+        xmlBufferGrow(out, out->size + toconv * 2);
+        written = out->size - out->use - 1;
+    }
+    if (handler->input != NULL) {
+        ret = handler->input(&out->content[out->use], &written,
+                             in->content, &toconv);
+        xmlBufferShrink(in, toconv);
+        out->use += written;
+        out->content[out->use] = 0;
+    }
+#ifdef LIBXML_ICONV_ENABLED
+    else if (handler->iconv_in != NULL) {
+        ret = xmlIconvWrapper(handler->iconv_in, &out->content[out->use],
+                              &written, in->content, &toconv);
+        xmlBufferShrink(in, toconv);
+        out->use += written;
+        out->content[out->use] = 0;
+        if (ret == -1)
+            ret = -3;
+    }
+#endif /* LIBXML_ICONV_ENABLED */
+    switch (ret) {
+        case 0:
+#ifdef DEBUG_ENCODING
+            xmlGenericError(xmlGenericErrorContext,
+                            "converted %d bytes to %d bytes of input\n",
+                            toconv, written);
+#endif
+            break;
+        case -1:
+#ifdef DEBUG_ENCODING
+            xmlGenericError(xmlGenericErrorContext,
+                         "converted %d bytes to %d bytes of input, %d left\n",
+                            toconv, written, in->use);
+#endif
+            break;
+        case -3:
+#ifdef DEBUG_ENCODING
+            xmlGenericError(xmlGenericErrorContext,
+                        "converted %d bytes to %d bytes of input, %d left\n",
+                            toconv, written, in->use);
+#endif
+            break;
+        case -2:
+            xmlGenericError(xmlGenericErrorContext,
+                            "input conversion failed due to input error\n");
+            xmlGenericError(xmlGenericErrorContext,
+                            "Bytes: 0x%02X 0x%02X 0x%02X 0x%02X\n",
+                            in->content[0], in->content[1],
+                            in->content[2], in->content[3]);
+    }
+    /*
+     * Ignore when input buffer is not on a boundary
+     */
+    if (ret == -3)
+        ret = 0;
+    return (written);
+}
+
+/**
+ * xmlCharEncOutFunc:
+ * @handler:	char enconding transformation data structure
+ * @out:  an xmlBuffer for the output.
+ * @in:  an xmlBuffer for the input
+ *     
+ * Generic front-end for the encoding handler output function
+ * a first call with @in == NULL has to be made firs to initiate the 
+ * output in case of non-stateless encoding needing to initiate their
+ * state or the output (like the BOM in UTF16).
+ * In case of UTF8 sequence conversion errors for the given encoder,
+ * the content will be automatically remapped to a CharRef sequence.
+ *     
+ * Returns the number of byte written if success, or 
+ *     -1 general error
+ *     -2 if the transcoding fails (for *in is not valid utf8 string or
+ *        the result of transformation can't fit into the encoding we want), or
+ */
+int
+xmlCharEncOutFunc(xmlCharEncodingHandler *handler, xmlBufferPtr out,
+                  xmlBufferPtr in) {
+    int ret = -2;
+    int written;
+    int writtentot = 0;
+    int toconv;
+    int output = 0;
+
+    if (handler == NULL) return(-1);
+    if (out == NULL) return(-1);
+
+retry:
+    
+    written = out->size - out->use;
+
+    if (written > 0)
+	written--; /* Gennady: count '/0' */
+
+    /*
+     * First specific handling of in = NULL, i.e. the initialization call
+     */
+    if (in == NULL) {
+        toconv = 0;
+	if (handler->output != NULL) {
+	    ret = handler->output(&out->content[out->use], &written,
+				  NULL, &toconv);
+	    if (ret >= 0) { /* Gennady: check return value */
+		out->use += written;
+		out->content[out->use] = 0;
+	    }
+	}
+#ifdef LIBXML_ICONV_ENABLED
+	else if (handler->iconv_out != NULL) {
+	    ret = xmlIconvWrapper(handler->iconv_out, &out->content[out->use],
+				  &written, NULL, &toconv);
+	    out->use += written;
+	    out->content[out->use] = 0;
+	}
+#endif /* LIBXML_ICONV_ENABLED */
+#ifdef DEBUG_ENCODING
+	xmlGenericError(xmlGenericErrorContext,
+		"initialized encoder\n");
+#endif
+        return(0);
+    }
+
+    /*
+     * Conversion itself.
+     */
+    toconv = in->use;
+    if (toconv == 0)
+	return(0);
+    if (toconv * 2 >= written) {
+        xmlBufferGrow(out, toconv * 2);
+	written = out->size - out->use - 1;
+    }
+    if (handler->output != NULL) {
+	ret = handler->output(&out->content[out->use], &written,
+	                      in->content, &toconv);
+	xmlBufferShrink(in, toconv);
+	out->use += written;
+	writtentot += written;
+	out->content[out->use] = 0;
+    }
+#ifdef LIBXML_ICONV_ENABLED
+    else if (handler->iconv_out != NULL) {
+	ret = xmlIconvWrapper(handler->iconv_out, &out->content[out->use],
+	                      &written, in->content, &toconv);
+	xmlBufferShrink(in, toconv);
+	out->use += written;
+	writtentot += written;
+	out->content[out->use] = 0;
+	if (ret == -1) {
+	    if (written > 0) {
+		/*
+		 * Can be a limitation of iconv
+		 */
+		goto retry;
+	    }
+	    ret = -3;
+	}
+    }
+#endif /* LIBXML_ICONV_ENABLED */
+    else {
+	xmlGenericError(xmlGenericErrorContext,
+		"xmlCharEncOutFunc: no output function !\n");
+	return(-1);
+    }
+
+    if (ret >= 0) output += ret;
+
+    /*
+     * Attempt to handle error cases
+     */
+    switch (ret) {
+        case 0:
+#ifdef DEBUG_ENCODING
+	    xmlGenericError(xmlGenericErrorContext,
+		    "converted %d bytes to %d bytes of output\n",
+	            toconv, written);
+#endif
+	    break;
+        case -1:
+#ifdef DEBUG_ENCODING
+	    xmlGenericError(xmlGenericErrorContext,
+		    "output conversion failed by lack of space\n");
+#endif
+	    break;
+        case -3:
+#ifdef DEBUG_ENCODING
+	    xmlGenericError(xmlGenericErrorContext,"converted %d bytes to %d bytes of output %d left\n",
+	            toconv, written, in->use);
+#endif
+	    break;
+        case -2: {
+	    int len = in->use;
+	    const xmlChar *utf = (const xmlChar *) in->content;
+	    int cur;
+
+	    cur = xmlGetUTF8Char(utf, &len);
+	    if (cur > 0) {
+		xmlChar charref[20];
+
+#ifdef DEBUG_ENCODING
+		xmlGenericError(xmlGenericErrorContext,
+			"handling output conversion error\n");
+		xmlGenericError(xmlGenericErrorContext,
+			"Bytes: 0x%02X 0x%02X 0x%02X 0x%02X\n",
+			in->content[0], in->content[1],
+			in->content[2], in->content[3]);
+#endif
+		/*
+		 * Removes the UTF8 sequence, and replace it by a charref
+		 * and continue the transcoding phase, hoping the error
+		 * did not mangle the encoder state.
+		 */
+		snprintf((char *) charref, sizeof(charref), "&#%d;", cur);
+		xmlBufferShrink(in, len);
+		xmlBufferAddHead(in, charref, -1);
+
+		goto retry;
+	    } else {
+		xmlGenericError(xmlGenericErrorContext,
+			"output conversion failed due to conv error\n");
+		xmlGenericError(xmlGenericErrorContext,
+			"Bytes: 0x%02X 0x%02X 0x%02X 0x%02X\n",
+			in->content[0], in->content[1],
+			in->content[2], in->content[3]);
+		in->content[0] = ' ';
+	    }
+	    break;
+	}
+    }
+    return(ret);
+}
+
+/**
+ * xmlCharEncCloseFunc:
+ * @handler:	char enconding transformation data structure
+ *     
+ * Generic front-end for encoding handler close function
+ *
+ * Returns 0 if success, or -1 in case of error
+ */
+int
+xmlCharEncCloseFunc(xmlCharEncodingHandler *handler) {
+    int ret = 0;
+    if (handler == NULL) return(-1);
+    if (handler->name == NULL) return(-1);
+#ifdef LIBXML_ICONV_ENABLED
+    /*
+     * Iconv handlers can be used only once, free the whole block.
+     * and the associated icon resources.
+     */
+    if ((handler->iconv_out != NULL) || (handler->iconv_in != NULL)) {
+	if (handler->name != NULL)
+	    xmlFree(handler->name);
+	handler->name = NULL;
+	if (handler->iconv_out != NULL) {
+	    if (iconv_close(handler->iconv_out))
+		ret = -1;
+	    handler->iconv_out = NULL;
+	}
+	if (handler->iconv_in != NULL) {
+	    if (iconv_close(handler->iconv_in))
+		ret = -1;
+	    handler->iconv_in = NULL;
+	}
+	xmlFree(handler);
+    }
+#endif /* LIBXML_ICONV_ENABLED */
+#ifdef DEBUG_ENCODING
+    if (ret)
+        xmlGenericError(xmlGenericErrorContext,
+		"failed to close the encoding handler\n");
+    else
+        xmlGenericError(xmlGenericErrorContext,
+		"closed the encoding handler\n");
+#endif
+
+    return(ret);
+}
+
+/**
+ * xmlByteConsumed:
+ * @ctxt: an XML parser context
+ *
+ * This function provides the current index of the parser relative
+ * to the start of the current entity. This function is computed in
+ * bytes from the beginning starting at zero and finishing at the
+ * size in byte of the file if parsing a file. The function is
+ * of constant cost if the input is UTF-8 but can be costly if run
+ * on non-UTF-8 input.
+ *
+ * Returns the index in bytes from the beginning of the entity or -1
+ *         in case the index could not be computed.
+ */
+long
+xmlByteConsumed(xmlParserCtxtPtr ctxt) {
+    xmlParserInputPtr in;
+    
+    if (ctxt == NULL) return(-1);
+    in = ctxt->input;
+    if (in == NULL)  return(-1);
+    if ((in->buf != NULL) && (in->buf->encoder != NULL)) {
+        unsigned int unused = 0;
+	xmlCharEncodingHandler * handler = in->buf->encoder;
+        /*
+	 * Encoding conversion, compute the number of unused original
+	 * bytes from the input not consumed and substract that from
+	 * the raw consumed value, this is not a cheap operation
+	 */
+        if (in->end - in->cur > 0) {
+	    static unsigned char convbuf[32000];
+	    unsigned const char *cur = (unsigned const char *)in->cur;
+	    int toconv = in->end - in->cur, written = 32000;
+
+	    int ret;
+
+	    if (handler->output != NULL) {
+	        do {
+		    toconv = in->end - cur;
+		    written = 32000;
+		    ret = handler->output(&convbuf[0], &written,
+				      cur, &toconv);
+		    if (ret == -1) return(-1);
+		    unused += written;
+		    cur += toconv;
+		} while (ret == -2);
+#ifdef LIBXML_ICONV_ENABLED
+	    } else if (handler->iconv_out != NULL) {
+	        do {
+		    toconv = in->end - cur;
+		    written = 32000;
+		    ret = xmlIconvWrapper(handler->iconv_out, &convbuf[0],
+	                      &written, cur, &toconv);
+		    if (ret == -1) {
+		        if (written > 0)
+			    ret = -2;
+			else
+			    return(-1);
+		    }
+		    unused += written;
+		    cur += toconv;
+		} while (ret == -2);
+#endif
+            } else {
+	        /* could not find a converter */
+	        return(-1);
+	    }
+	}
+	if (in->buf->rawconsumed < unused)
+	    return(-1);
+	return(in->buf->rawconsumed - unused);
+    }
+    return(in->consumed + (in->cur - in->base));
+}
+
+#ifndef LIBXML_ICONV_ENABLED
+#ifdef LIBXML_ISO8859X_ENABLED
+
+/**
+ * UTF8ToISO8859x:
+ * @out:  a pointer to an array of bytes to store the result
+ * @outlen:  the length of @out
+ * @in:  a pointer to an array of UTF-8 chars
+ * @inlen:  the length of @in
+ * @xlattable: the 2-level transcoding table
+ *
+ * Take a block of UTF-8 chars in and try to convert it to an ISO 8859-*
+ * block of chars out.
+ *
+ * Returns 0 if success, -2 if the transcoding fails, or -1 otherwise
+ * The value of @inlen after return is the number of octets consumed
+ *     as the return value is positive, else unpredictable.
+ * The value of @outlen after return is the number of ocetes consumed.
+ */
+static int
+UTF8ToISO8859x(unsigned char* out, int *outlen,
+              const unsigned char* in, int *inlen,
+              unsigned char const *xlattable) {
+    const unsigned char* outstart = out;
+    const unsigned char* inend;
+    const unsigned char* instart = in;
+
+    if (in == NULL) {
+        /*
+        * initialization nothing to do
+        */
+        *outlen = 0;
+        *inlen = 0;
+        return(0);
+    }
+    inend = in + (*inlen);
+    while (in < inend) {
+        unsigned char d = *in++;
+        if  (d < 0x80)  {
+            *out++ = d; 
+        } else if (d < 0xC0) {
+            /* trailing byte in leading position */
+            *outlen = out - outstart;
+            *inlen = in - instart - 1;
+            return(-2);
+        } else if (d < 0xE0) {
+            unsigned char c;
+            if (!(in < inend)) {
+                /* trailing byte not in input buffer */
+                *outlen = out - outstart;
+                *inlen = in - instart - 1;
+                return(-2);
+            }
+            c = *in++;
+            if ((c & 0xC0) != 0xC0) {
+                /* not a trailing byte */
+                *outlen = out - outstart;
+                *inlen = in - instart - 2;
+                return(-2);
+            }
+            c = c & 0x3F; 
+            d = d & 0x1F;
+            d = xlattable [48 + c + xlattable [d] * 64];
+            if (d == 0) {
+                /* not in character set */
+                *outlen = out - outstart;
+                *inlen = in - instart - 2;
+                return(-2);
+            }
+            *out++ = d; 
+        } else if (d < 0xF0) {
+            unsigned char c1;
+            unsigned char c2;
+            if (!(in < inend - 1)) {
+                /* trailing bytes not in input buffer */
+                *outlen = out - outstart;
+                *inlen = in - instart - 1;
+                return(-2);
+            }
+            c1 = *in++;
+            if ((c1 & 0xC0) != 0xC0) {
+                /* not a trailing byte (c1) */
+                *outlen = out - outstart;
+                *inlen = in - instart - 2;
+                return(-2);
+            }
+            c2 = *in++;
+            if ((c2 & 0xC0) != 0xC0) {
+                /* not a trailing byte (c2) */
+                *outlen = out - outstart;
+                *inlen = in - instart - 2;
+                return(-2);
+            }
+            c1 = c1 & 0x3F; 
+            c2 = c2 & 0x3F; 
+            d = d & 0x0F;
+            d = xlattable [48 + c2 + xlattable [48 + c1 + xlattable [32 + d] * 64] * 64];
+            if (d == 0) {
+                /* not in character set */
+                *outlen = out - outstart;
+                *inlen = in - instart - 3;
+                return(-2);
+            }
+            *out++ = d; 
+        } else {
+            /* cannot transcode >= U+010000 */
+            *outlen = out - outstart;
+            *inlen = in - instart - 1;
+            return(-2);
+        }
+    }
+    *outlen = out - outstart;
+    *inlen = in - instart;
+    return(0);
+}
+
+/**
+ * ISO8859xToUTF8
+ * @out:  a pointer to an array of bytes to store the result
+ * @outlen:  the length of @out
+ * @in:  a pointer to an array of ISO Latin 1 chars
+ * @inlen:  the length of @in
+ *
+ * Take a block of ISO 8859-* chars in and try to convert it to an UTF-8
+ * block of chars out.
+ * Returns 0 if success, or -1 otherwise
+ * The value of @inlen after return is the number of octets consumed
+ * The value of @outlen after return is the number of ocetes produced.
+ */
+static int
+ISO8859xToUTF8(unsigned char* out, int *outlen,
+              const unsigned char* in, int *inlen,
+              unsigned short const *unicodetable) {
+    unsigned char* outstart = out;
+    unsigned char* outend = out + *outlen;
+    const unsigned char* instart = in;
+    const unsigned char* inend = in + *inlen;
+    const unsigned char* instop = inend;
+    unsigned int c = *in;
+
+    while (in < inend && out < outend - 1) {
+        if (c >= 0x80) {
+            c = unicodetable [c - 0x80];
+            if (c == 0) {
+                /* undefined code point */
+                *outlen = out - outstart;
+                *inlen = in - instart;
+                return (-1);
+            } 
+            if (c < 0x800) {
+                *out++ = ((c >>  6) & 0x1F) | 0xC0;
+                *out++ = (c & 0x3F) | 0x80;
+            } else {
+                *out++ = ((c >>  12) & 0x0F) | 0xE0;
+                *out++ = ((c >>  6) & 0x3F) | 0x80;
+                *out++ = (c & 0x3F) | 0x80;
+            }    
+            ++in;
+            c = *in;
+        }
+        if (instop - in > outend - out) instop = in + (outend - out); 
+        while (c < 0x80 && in < instop) {
+            *out++ =  c;
+            ++in;
+            c = *in;
+        }
+    }   
+    if (in < inend && out < outend && c < 0x80) {
+        *out++ =  c;
+        ++in;
+    }
+    *outlen = out - outstart;
+    *inlen = in - instart;
+    return (0);
+}
+
+    
+/************************************************************************
+ * Lookup tables for ISO-8859-2..ISO-8859-16 transcoding                *
+ ************************************************************************/
+
+static unsigned short const xmlunicodetable_ISO8859_2 [128] = {
+    0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087, 
+    0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f, 
+    0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097, 
+    0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f, 
+    0x00a0, 0x0104, 0x02d8, 0x0141, 0x00a4, 0x013d, 0x015a, 0x00a7, 
+    0x00a8, 0x0160, 0x015e, 0x0164, 0x0179, 0x00ad, 0x017d, 0x017b, 
+    0x00b0, 0x0105, 0x02db, 0x0142, 0x00b4, 0x013e, 0x015b, 0x02c7, 
+    0x00b8, 0x0161, 0x015f, 0x0165, 0x017a, 0x02dd, 0x017e, 0x017c, 
+    0x0154, 0x00c1, 0x00c2, 0x0102, 0x00c4, 0x0139, 0x0106, 0x00c7, 
+    0x010c, 0x00c9, 0x0118, 0x00cb, 0x011a, 0x00cd, 0x00ce, 0x010e, 
+    0x0110, 0x0143, 0x0147, 0x00d3, 0x00d4, 0x0150, 0x00d6, 0x00d7, 
+    0x0158, 0x016e, 0x00da, 0x0170, 0x00dc, 0x00dd, 0x0162, 0x00df, 
+    0x0155, 0x00e1, 0x00e2, 0x0103, 0x00e4, 0x013a, 0x0107, 0x00e7, 
+    0x010d, 0x00e9, 0x0119, 0x00eb, 0x011b, 0x00ed, 0x00ee, 0x010f, 
+    0x0111, 0x0144, 0x0148, 0x00f3, 0x00f4, 0x0151, 0x00f6, 0x00f7, 
+    0x0159, 0x016f, 0x00fa, 0x0171, 0x00fc, 0x00fd, 0x0163, 0x02d9, 
+};
+
+static unsigned char const xmltranscodetable_ISO8859_2 [48 + 6 * 64] = {
+    "\x00\x00\x01\x05\x02\x04\x00\x00\x00\x00\x00\x03\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f"
+    "\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f"
+    "\xa0\x00\x00\x00\xa4\x00\x00\xa7\xa8\x00\x00\x00\x00\xad\x00\x00"
+    "\xb0\x00\x00\x00\xb4\x00\x00\x00\xb8\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\xc3\xe3\xa1\xb1\xc6\xe6\x00\x00\x00\x00\xc8\xe8\xcf\xef"
+    "\xd0\xf0\x00\x00\x00\x00\x00\x00\xca\xea\xcc\xec\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc5\xe5\x00\x00\xa5\xb5\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\xa2\xff\x00\xb2\x00\xbd\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\xa3\xb3\xd1\xf1\x00\x00\xd2\xf2\x00\x00\x00\x00\x00\x00\x00"
+    "\xd5\xf5\x00\x00\xc0\xe0\x00\x00\xd8\xf8\xa6\xb6\x00\x00\xaa\xba"
+    "\xa9\xb9\xde\xfe\xab\xbb\x00\x00\x00\x00\x00\x00\x00\x00\xd9\xf9"
+    "\xdb\xfb\x00\x00\x00\x00\x00\x00\x00\xac\xbc\xaf\xbf\xae\xbe\x00"
+    "\x00\xc1\xc2\x00\xc4\x00\x00\xc7\x00\xc9\x00\xcb\x00\xcd\xce\x00"
+    "\x00\x00\x00\xd3\xd4\x00\xd6\xd7\x00\x00\xda\x00\xdc\xdd\x00\xdf"
+    "\x00\xe1\xe2\x00\xe4\x00\x00\xe7\x00\xe9\x00\xeb\x00\xed\xee\x00"
+    "\x00\x00\x00\xf3\xf4\x00\xf6\xf7\x00\x00\xfa\x00\xfc\xfd\x00\x00"
+};
+
+static unsigned short const xmlunicodetable_ISO8859_3 [128] = {
+    0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087, 
+    0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f, 
+    0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097, 
+    0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f, 
+    0x00a0, 0x0126, 0x02d8, 0x00a3, 0x00a4, 0x0000, 0x0124, 0x00a7, 
+    0x00a8, 0x0130, 0x015e, 0x011e, 0x0134, 0x00ad, 0x0000, 0x017b, 
+    0x00b0, 0x0127, 0x00b2, 0x00b3, 0x00b4, 0x00b5, 0x0125, 0x00b7, 
+    0x00b8, 0x0131, 0x015f, 0x011f, 0x0135, 0x00bd, 0x0000, 0x017c, 
+    0x00c0, 0x00c1, 0x00c2, 0x0000, 0x00c4, 0x010a, 0x0108, 0x00c7, 
+    0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce, 0x00cf, 
+    0x0000, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x0120, 0x00d6, 0x00d7, 
+    0x011c, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x016c, 0x015c, 0x00df, 
+    0x00e0, 0x00e1, 0x00e2, 0x0000, 0x00e4, 0x010b, 0x0109, 0x00e7, 
+    0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef, 
+    0x0000, 0x00f1, 0x00f2, 0x00f3, 0x00f4, 0x0121, 0x00f6, 0x00f7, 
+    0x011d, 0x00f9, 0x00fa, 0x00fb, 0x00fc, 0x016d, 0x015d, 0x02d9, 
+};
+
+static unsigned char const xmltranscodetable_ISO8859_3 [48 + 7 * 64] = {
+    "\x04\x00\x01\x06\x02\x05\x00\x00\x00\x00\x00\x03\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f"
+    "\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f"
+    "\xa0\x00\x00\xa3\xa4\x00\x00\xa7\xa8\x00\x00\x00\x00\xad\x00\x00"
+    "\xb0\x00\xb2\xb3\xb4\xb5\x00\xb7\xb8\x00\x00\x00\x00\xbd\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\xc6\xe6\xc5\xe5\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd8\xf8\xab\xbb"
+    "\xd5\xf5\x00\x00\xa6\xb6\xa1\xb1\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\xa9\xb9\x00\x00\xac\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\xa2\xff\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\xf0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xde\xfe\xaa\xba"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdd\xfd\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\xbf\x00\x00\x00"
+    "\xc0\xc1\xc2\x00\xc4\x00\x00\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf"
+    "\x00\xd1\xd2\xd3\xd4\x00\xd6\xd7\x00\xd9\xda\xdb\xdc\x00\x00\xdf"
+    "\xe0\xe1\xe2\x00\xe4\x00\x00\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef"
+    "\x00\xf1\xf2\xf3\xf4\x00\xf6\xf7\x00\xf9\xfa\xfb\xfc\x00\x00\x00"
+};
+
+static unsigned short const xmlunicodetable_ISO8859_4 [128] = {
+    0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087, 
+    0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f, 
+    0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097, 
+    0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f, 
+    0x00a0, 0x0104, 0x0138, 0x0156, 0x00a4, 0x0128, 0x013b, 0x00a7, 
+    0x00a8, 0x0160, 0x0112, 0x0122, 0x0166, 0x00ad, 0x017d, 0x00af, 
+    0x00b0, 0x0105, 0x02db, 0x0157, 0x00b4, 0x0129, 0x013c, 0x02c7, 
+    0x00b8, 0x0161, 0x0113, 0x0123, 0x0167, 0x014a, 0x017e, 0x014b, 
+    0x0100, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6, 0x012e, 
+    0x010c, 0x00c9, 0x0118, 0x00cb, 0x0116, 0x00cd, 0x00ce, 0x012a, 
+    0x0110, 0x0145, 0x014c, 0x0136, 0x00d4, 0x00d5, 0x00d6, 0x00d7, 
+    0x00d8, 0x0172, 0x00da, 0x00db, 0x00dc, 0x0168, 0x016a, 0x00df, 
+    0x0101, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6, 0x012f, 
+    0x010d, 0x00e9, 0x0119, 0x00eb, 0x0117, 0x00ed, 0x00ee, 0x012b, 
+    0x0111, 0x0146, 0x014d, 0x0137, 0x00f4, 0x00f5, 0x00f6, 0x00f7, 
+    0x00f8, 0x0173, 0x00fa, 0x00fb, 0x00fc, 0x0169, 0x016b, 0x02d9, 
+};
+
+static unsigned char const xmltranscodetable_ISO8859_4 [48 + 6 * 64] = {
+    "\x00\x00\x01\x05\x02\x03\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f"
+    "\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f"
+    "\xa0\x00\x00\x00\xa4\x00\x00\xa7\xa8\x00\x00\x00\x00\xad\x00\xaf"
+    "\xb0\x00\x00\x00\xb4\x00\x00\x00\xb8\x00\x00\x00\x00\x00\x00\x00"
+    "\xc0\xe0\x00\x00\xa1\xb1\x00\x00\x00\x00\x00\x00\xc8\xe8\x00\x00"
+    "\xd0\xf0\xaa\xba\x00\x00\xcc\xec\xca\xea\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\xab\xbb\x00\x00\x00\x00\xa5\xb5\xcf\xef\x00\x00\xc7\xe7"
+    "\x00\x00\x00\x00\x00\x00\xd3\xf3\xa2\x00\x00\xa6\xb6\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\xd1\xf1\x00\x00\x00\xbd\xbf\xd2\xf2\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\xa3\xb3\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\xa9\xb9\x00\x00\x00\x00\xac\xbc\xdd\xfd\xde\xfe\x00\x00\x00\x00"
+    "\x00\x00\xd9\xf9\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\xbe\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\x00\xb2\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\xc1\xc2\xc3\xc4\xc5\xc6\x00\x00\xc9\x00\xcb\x00\xcd\xce\x00"
+    "\x00\x00\x00\x00\xd4\xd5\xd6\xd7\xd8\x00\xda\xdb\xdc\x00\x00\xdf"
+    "\x00\xe1\xe2\xe3\xe4\xe5\xe6\x00\x00\xe9\x00\xeb\x00\xed\xee\x00"
+    "\x00\x00\x00\x00\xf4\xf5\xf6\xf7\xf8\x00\xfa\xfb\xfc\x00\x00\x00"
+};
+
+static unsigned short const xmlunicodetable_ISO8859_5 [128] = {
+    0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087, 
+    0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f, 
+    0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097, 
+    0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f, 
+    0x00a0, 0x0401, 0x0402, 0x0403, 0x0404, 0x0405, 0x0406, 0x0407, 
+    0x0408, 0x0409, 0x040a, 0x040b, 0x040c, 0x00ad, 0x040e, 0x040f, 
+    0x0410, 0x0411, 0x0412, 0x0413, 0x0414, 0x0415, 0x0416, 0x0417, 
+    0x0418, 0x0419, 0x041a, 0x041b, 0x041c, 0x041d, 0x041e, 0x041f, 
+    0x0420, 0x0421, 0x0422, 0x0423, 0x0424, 0x0425, 0x0426, 0x0427, 
+    0x0428, 0x0429, 0x042a, 0x042b, 0x042c, 0x042d, 0x042e, 0x042f, 
+    0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0436, 0x0437, 
+    0x0438, 0x0439, 0x043a, 0x043b, 0x043c, 0x043d, 0x043e, 0x043f, 
+    0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447, 
+    0x0448, 0x0449, 0x044a, 0x044b, 0x044c, 0x044d, 0x044e, 0x044f, 
+    0x2116, 0x0451, 0x0452, 0x0453, 0x0454, 0x0455, 0x0456, 0x0457, 
+    0x0458, 0x0459, 0x045a, 0x045b, 0x045c, 0x00a7, 0x045e, 0x045f, 
+};
+
+static unsigned char const xmltranscodetable_ISO8859_5 [48 + 6 * 64] = {
+    "\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x02\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f"
+    "\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f"
+    "\xa0\x00\x00\x00\x00\x00\x00\xfd\x00\x00\x00\x00\x00\xad\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\x00\xae\xaf"
+    "\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf"
+    "\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf"
+    "\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf"
+    "\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef"
+    "\x00\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\x00\xfe\xff"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\xf0\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+};
+
+static unsigned short const xmlunicodetable_ISO8859_6 [128] = {
+    0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087, 
+    0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f, 
+    0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097, 
+    0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f, 
+    0x00a0, 0x0000, 0x0000, 0x0000, 0x00a4, 0x0000, 0x0000, 0x0000, 
+    0x0000, 0x0000, 0x0000, 0x0000, 0x060c, 0x00ad, 0x0000, 0x0000, 
+    0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
+    0x0000, 0x0000, 0x0000, 0x061b, 0x0000, 0x0000, 0x0000, 0x061f, 
+    0x0000, 0x0621, 0x0622, 0x0623, 0x0624, 0x0625, 0x0626, 0x0627, 
+    0x0628, 0x0629, 0x062a, 0x062b, 0x062c, 0x062d, 0x062e, 0x062f, 
+    0x0630, 0x0631, 0x0632, 0x0633, 0x0634, 0x0635, 0x0636, 0x0637, 
+    0x0638, 0x0639, 0x063a, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
+    0x0640, 0x0641, 0x0642, 0x0643, 0x0644, 0x0645, 0x0646, 0x0647, 
+    0x0648, 0x0649, 0x064a, 0x064b, 0x064c, 0x064d, 0x064e, 0x064f, 
+    0x0650, 0x0651, 0x0652, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
+    0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
+};
+
+static unsigned char const xmltranscodetable_ISO8859_6 [48 + 5 * 64] = {
+    "\x02\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x03\x04\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f"
+    "\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f"
+    "\xa0\x00\x00\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\xad\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\xbf"
+    "\x00\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf"
+    "\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\x00\x00\x00\x00\x00"
+    "\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef"
+    "\xf0\xf1\xf2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+};
+
+static unsigned short const xmlunicodetable_ISO8859_7 [128] = {
+    0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087, 
+    0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f, 
+    0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097, 
+    0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f, 
+    0x00a0, 0x2018, 0x2019, 0x00a3, 0x0000, 0x0000, 0x00a6, 0x00a7, 
+    0x00a8, 0x00a9, 0x0000, 0x00ab, 0x00ac, 0x00ad, 0x0000, 0x2015, 
+    0x00b0, 0x00b1, 0x00b2, 0x00b3, 0x0384, 0x0385, 0x0386, 0x00b7, 
+    0x0388, 0x0389, 0x038a, 0x00bb, 0x038c, 0x00bd, 0x038e, 0x038f, 
+    0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396, 0x0397, 
+    0x0398, 0x0399, 0x039a, 0x039b, 0x039c, 0x039d, 0x039e, 0x039f, 
+    0x03a0, 0x03a1, 0x0000, 0x03a3, 0x03a4, 0x03a5, 0x03a6, 0x03a7, 
+    0x03a8, 0x03a9, 0x03aa, 0x03ab, 0x03ac, 0x03ad, 0x03ae, 0x03af, 
+    0x03b0, 0x03b1, 0x03b2, 0x03b3, 0x03b4, 0x03b5, 0x03b6, 0x03b7, 
+    0x03b8, 0x03b9, 0x03ba, 0x03bb, 0x03bc, 0x03bd, 0x03be, 0x03bf, 
+    0x03c0, 0x03c1, 0x03c2, 0x03c3, 0x03c4, 0x03c5, 0x03c6, 0x03c7, 
+    0x03c8, 0x03c9, 0x03ca, 0x03cb, 0x03cc, 0x03cd, 0x03ce, 0x0000, 
+};
+
+static unsigned char const xmltranscodetable_ISO8859_7 [48 + 7 * 64] = {
+    "\x04\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x06"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f"
+    "\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f"
+    "\xa0\x00\x00\xa3\x00\x00\xa6\xa7\xa8\xa9\x00\xab\xac\xad\x00\x00"
+    "\xb0\xb1\xb2\xb3\x00\x00\x00\xb7\x00\x00\x00\xbb\x00\xbd\x00\x00"
+    "\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\xaf\x00\x00\xa1\xa2\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\xb4\xb5\xb6\x00\xb8\xb9\xba\x00\xbc\x00\xbe\xbf"
+    "\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf"
+    "\xd0\xd1\x00\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf"
+    "\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef"
+    "\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+};
+
+static unsigned short const xmlunicodetable_ISO8859_8 [128] = {
+    0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087, 
+    0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f, 
+    0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097, 
+    0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f, 
+    0x00a0, 0x0000, 0x00a2, 0x00a3, 0x00a4, 0x00a5, 0x00a6, 0x00a7, 
+    0x00a8, 0x00a9, 0x00d7, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x00af, 
+    0x00b0, 0x00b1, 0x00b2, 0x00b3, 0x00b4, 0x00b5, 0x00b6, 0x00b7, 
+    0x00b8, 0x00b9, 0x00f7, 0x00bb, 0x00bc, 0x00bd, 0x00be, 0x0000, 
+    0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
+    0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
+    0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
+    0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2017, 
+    0x05d0, 0x05d1, 0x05d2, 0x05d3, 0x05d4, 0x05d5, 0x05d6, 0x05d7, 
+    0x05d8, 0x05d9, 0x05da, 0x05db, 0x05dc, 0x05dd, 0x05de, 0x05df, 
+    0x05e0, 0x05e1, 0x05e2, 0x05e3, 0x05e4, 0x05e5, 0x05e6, 0x05e7, 
+    0x05e8, 0x05e9, 0x05ea, 0x0000, 0x0000, 0x200e, 0x200f, 0x0000, 
+};
+
+static unsigned char const xmltranscodetable_ISO8859_8 [48 + 7 * 64] = {
+    "\x02\x00\x01\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x06\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f"
+    "\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f"
+    "\xa0\x00\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\x00\xab\xac\xad\xae\xaf"
+    "\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\x00\xbb\xbc\xbd\xbe\x00"
+    "\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\xaa\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\xba\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfd\xfe"
+    "\x00\x00\x00\x00\x00\x00\x00\xdf\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef"
+    "\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+};
+
+static unsigned short const xmlunicodetable_ISO8859_9 [128] = {
+    0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087, 
+    0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f, 
+    0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097, 
+    0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f, 
+    0x00a0, 0x00a1, 0x00a2, 0x00a3, 0x00a4, 0x00a5, 0x00a6, 0x00a7, 
+    0x00a8, 0x00a9, 0x00aa, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x00af, 
+    0x00b0, 0x00b1, 0x00b2, 0x00b3, 0x00b4, 0x00b5, 0x00b6, 0x00b7, 
+    0x00b8, 0x00b9, 0x00ba, 0x00bb, 0x00bc, 0x00bd, 0x00be, 0x00bf, 
+    0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6, 0x00c7, 
+    0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce, 0x00cf, 
+    0x011e, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7, 
+    0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x0130, 0x015e, 0x00df, 
+    0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6, 0x00e7, 
+    0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef, 
+    0x011f, 0x00f1, 0x00f2, 0x00f3, 0x00f4, 0x00f5, 0x00f6, 0x00f7, 
+    0x00f8, 0x00f9, 0x00fa, 0x00fb, 0x00fc, 0x0131, 0x015f, 0x00ff, 
+};
+
+static unsigned char const xmltranscodetable_ISO8859_9 [48 + 5 * 64] = {
+    "\x00\x00\x01\x02\x03\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f"
+    "\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f"
+    "\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf"
+    "\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf"
+    "\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf"
+    "\x00\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\x00\x00\xdf"
+    "\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef"
+    "\x00\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\x00\x00\xff"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd0\xf0"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\xdd\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xde\xfe"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+};
+
+static unsigned short const xmlunicodetable_ISO8859_10 [128] = {
+    0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087, 
+    0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f, 
+    0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097, 
+    0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f, 
+    0x00a0, 0x0104, 0x0112, 0x0122, 0x012a, 0x0128, 0x0136, 0x00a7, 
+    0x013b, 0x0110, 0x0160, 0x0166, 0x017d, 0x00ad, 0x016a, 0x014a, 
+    0x00b0, 0x0105, 0x0113, 0x0123, 0x012b, 0x0129, 0x0137, 0x00b7, 
+    0x013c, 0x0111, 0x0161, 0x0167, 0x017e, 0x2015, 0x016b, 0x014b, 
+    0x0100, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6, 0x012e, 
+    0x010c, 0x00c9, 0x0118, 0x00cb, 0x0116, 0x00cd, 0x00ce, 0x00cf, 
+    0x00d0, 0x0145, 0x014c, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x0168, 
+    0x00d8, 0x0172, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df, 
+    0x0101, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6, 0x012f, 
+    0x010d, 0x00e9, 0x0119, 0x00eb, 0x0117, 0x00ed, 0x00ee, 0x00ef, 
+    0x00f0, 0x0146, 0x014d, 0x00f3, 0x00f4, 0x00f5, 0x00f6, 0x0169, 
+    0x00f8, 0x0173, 0x00fa, 0x00fb, 0x00fc, 0x00fd, 0x00fe, 0x0138, 
+};
+
+static unsigned char const xmltranscodetable_ISO8859_10 [48 + 7 * 64] = {
+    "\x00\x00\x01\x06\x02\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f"
+    "\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f"
+    "\xa0\x00\x00\x00\x00\x00\x00\xa7\x00\x00\x00\x00\x00\xad\x00\x00"
+    "\xb0\x00\x00\x00\x00\x00\x00\xb7\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\xc0\xe0\x00\x00\xa1\xb1\x00\x00\x00\x00\x00\x00\xc8\xe8\x00\x00"
+    "\xa9\xb9\xa2\xb2\x00\x00\xcc\xec\xca\xea\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\xa3\xb3\x00\x00\x00\x00\xa5\xb5\xa4\xb4\x00\x00\xc7\xe7"
+    "\x00\x00\x00\x00\x00\x00\xa6\xb6\xff\x00\x00\xa8\xb8\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\xd1\xf1\x00\x00\x00\xaf\xbf\xd2\xf2\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\xaa\xba\x00\x00\x00\x00\xab\xbb\xd7\xf7\xae\xbe\x00\x00\x00\x00"
+    "\x00\x00\xd9\xf9\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\xbc\x00"
+    "\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\xbd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\xc1\xc2\xc3\xc4\xc5\xc6\x00\x00\xc9\x00\xcb\x00\xcd\xce\xcf"
+    "\xd0\x00\x00\xd3\xd4\xd5\xd6\x00\xd8\x00\xda\xdb\xdc\xdd\xde\xdf"
+    "\x00\xe1\xe2\xe3\xe4\xe5\xe6\x00\x00\xe9\x00\xeb\x00\xed\xee\xef"
+    "\xf0\x00\x00\xf3\xf4\xf5\xf6\x00\xf8\x00\xfa\xfb\xfc\xfd\xfe\x00"
+};
+
+static unsigned short const xmlunicodetable_ISO8859_11 [128] = {
+    0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087, 
+    0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f, 
+    0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097, 
+    0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f, 
+    0x00a0, 0x0e01, 0x0e02, 0x0e03, 0x0e04, 0x0e05, 0x0e06, 0x0e07, 
+    0x0e08, 0x0e09, 0x0e0a, 0x0e0b, 0x0e0c, 0x0e0d, 0x0e0e, 0x0e0f, 
+    0x0e10, 0x0e11, 0x0e12, 0x0e13, 0x0e14, 0x0e15, 0x0e16, 0x0e17, 
+    0x0e18, 0x0e19, 0x0e1a, 0x0e1b, 0x0e1c, 0x0e1d, 0x0e1e, 0x0e1f, 
+    0x0e20, 0x0e21, 0x0e22, 0x0e23, 0x0e24, 0x0e25, 0x0e26, 0x0e27, 
+    0x0e28, 0x0e29, 0x0e2a, 0x0e2b, 0x0e2c, 0x0e2d, 0x0e2e, 0x0e2f, 
+    0x0e30, 0x0e31, 0x0e32, 0x0e33, 0x0e34, 0x0e35, 0x0e36, 0x0e37, 
+    0x0e38, 0x0e39, 0x0e3a, 0x0000, 0x0000, 0x0000, 0x0000, 0x0e3f, 
+    0x0e40, 0x0e41, 0x0e42, 0x0e43, 0x0e44, 0x0e45, 0x0e46, 0x0e47, 
+    0x0e48, 0x0e49, 0x0e4a, 0x0e4b, 0x0e4c, 0x0e4d, 0x0e4e, 0x0e4f, 
+    0x0e50, 0x0e51, 0x0e52, 0x0e53, 0x0e54, 0x0e55, 0x0e56, 0x0e57, 
+    0x0e58, 0x0e59, 0x0e5a, 0x0e5b, 0x0000, 0x0000, 0x0000, 0x0000, 
+};
+
+static unsigned char const xmltranscodetable_ISO8859_11 [48 + 6 * 64] = {
+    "\x04\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f"
+    "\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f"
+    "\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x03\x05\x00\x00\x00\x00\x00\x00"
+    "\x00\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf"
+    "\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf"
+    "\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf"
+    "\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\x00\x00\x00\x00\xdf"
+    "\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef"
+    "\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+};
+
+static unsigned short const xmlunicodetable_ISO8859_13 [128] = {
+    0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087, 
+    0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f, 
+    0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097, 
+    0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f, 
+    0x00a0, 0x201d, 0x00a2, 0x00a3, 0x00a4, 0x201e, 0x00a6, 0x00a7, 
+    0x00d8, 0x00a9, 0x0156, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x00c6, 
+    0x00b0, 0x00b1, 0x00b2, 0x00b3, 0x201c, 0x00b5, 0x00b6, 0x00b7, 
+    0x00f8, 0x00b9, 0x0157, 0x00bb, 0x00bc, 0x00bd, 0x00be, 0x00e6, 
+    0x0104, 0x012e, 0x0100, 0x0106, 0x00c4, 0x00c5, 0x0118, 0x0112, 
+    0x010c, 0x00c9, 0x0179, 0x0116, 0x0122, 0x0136, 0x012a, 0x013b, 
+    0x0160, 0x0143, 0x0145, 0x00d3, 0x014c, 0x00d5, 0x00d6, 0x00d7, 
+    0x0172, 0x0141, 0x015a, 0x016a, 0x00dc, 0x017b, 0x017d, 0x00df, 
+    0x0105, 0x012f, 0x0101, 0x0107, 0x00e4, 0x00e5, 0x0119, 0x0113, 
+    0x010d, 0x00e9, 0x017a, 0x0117, 0x0123, 0x0137, 0x012b, 0x013c, 
+    0x0161, 0x0144, 0x0146, 0x00f3, 0x014d, 0x00f5, 0x00f6, 0x00f7, 
+    0x0173, 0x0142, 0x015b, 0x016b, 0x00fc, 0x017c, 0x017e, 0x2019, 
+};
+
+static unsigned char const xmltranscodetable_ISO8859_13 [48 + 7 * 64] = {
+    "\x00\x00\x01\x04\x06\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f"
+    "\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f"
+    "\xa0\x00\xa2\xa3\xa4\x00\xa6\xa7\x00\xa9\x00\xab\xac\xad\xae\x00"
+    "\xb0\xb1\xb2\xb3\x00\xb5\xb6\xb7\x00\xb9\x00\xbb\xbc\xbd\xbe\x00"
+    "\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\x00\x00\xb4\xa1\xa5\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\xc4\xc5\xaf\x00\x00\xc9\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\xd3\x00\xd5\xd6\xd7\xa8\x00\x00\x00\xdc\x00\x00\xdf"
+    "\x00\x00\x00\x00\xe4\xe5\xbf\x00\x00\xe9\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\xf3\x00\xf5\xf6\xf7\xb8\x00\x00\x00\xfc\x00\x00\x00"
+    "\x00\xd9\xf9\xd1\xf1\xd2\xf2\x00\x00\x00\x00\x00\xd4\xf4\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\xaa\xba\x00\x00\xda\xfa\x00\x00\x00\x00"
+    "\xd0\xf0\x00\x00\x00\x00\x00\x00\x00\x00\xdb\xfb\x00\x00\x00\x00"
+    "\x00\x00\xd8\xf8\x00\x00\x00\x00\x00\xca\xea\xdd\xfd\xde\xfe\x00"
+    "\xc2\xe2\x00\x00\xc0\xe0\xc3\xe3\x00\x00\x00\x00\xc8\xe8\x00\x00"
+    "\x00\x00\xc7\xe7\x00\x00\xcb\xeb\xc6\xe6\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\xcc\xec\x00\x00\x00\x00\x00\x00\xce\xee\x00\x00\xc1\xe1"
+    "\x00\x00\x00\x00\x00\x00\xcd\xed\x00\x00\x00\xcf\xef\x00\x00\x00"
+};
+
+static unsigned short const xmlunicodetable_ISO8859_14 [128] = {
+    0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087, 
+    0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f, 
+    0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097, 
+    0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f, 
+    0x00a0, 0x1e02, 0x1e03, 0x00a3, 0x010a, 0x010b, 0x1e0a, 0x00a7, 
+    0x1e80, 0x00a9, 0x1e82, 0x1e0b, 0x1ef2, 0x00ad, 0x00ae, 0x0178, 
+    0x1e1e, 0x1e1f, 0x0120, 0x0121, 0x1e40, 0x1e41, 0x00b6, 0x1e56, 
+    0x1e81, 0x1e57, 0x1e83, 0x1e60, 0x1ef3, 0x1e84, 0x1e85, 0x1e61, 
+    0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6, 0x00c7, 
+    0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce, 0x00cf, 
+    0x0174, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x1e6a, 
+    0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x0176, 0x00df, 
+    0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6, 0x00e7, 
+    0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef, 
+    0x0175, 0x00f1, 0x00f2, 0x00f3, 0x00f4, 0x00f5, 0x00f6, 0x1e6b, 
+    0x00f8, 0x00f9, 0x00fa, 0x00fb, 0x00fc, 0x00fd, 0x0177, 0x00ff, 
+};
+
+static unsigned char const xmltranscodetable_ISO8859_14 [48 + 10 * 64] = {
+    "\x00\x00\x01\x09\x04\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f"
+    "\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f"
+    "\xa0\x00\x00\xa3\x00\x00\x00\xa7\x00\xa9\x00\x00\x00\xad\xae\x00"
+    "\x00\x00\x00\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x03\x08\x05\x06\x00\x00\x00\x00"
+    "\x00\x00\xa1\xa2\x00\x00\x00\x00\x00\x00\xa6\xab\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\xb1"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\xa5\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\xb2\xb3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\xa8\xb8\xaa\xba\xbd\xbe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\xac\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\xd0\xf0\xde\xfe\xaf\x00\x00\x00\x00\x00\x00\x00"
+    "\xb4\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\xb7\xb9\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\xbb\xbf\x00\x00\x00\x00\x00\x00\x00\x00\xd7\xf7\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf"
+    "\x00\xd1\xd2\xd3\xd4\xd5\xd6\x00\xd8\xd9\xda\xdb\xdc\xdd\x00\xdf"
+    "\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef"
+    "\x00\xf1\xf2\xf3\xf4\xf5\xf6\x00\xf8\xf9\xfa\xfb\xfc\xfd\x00\xff"
+};
+
+static unsigned short const xmlunicodetable_ISO8859_15 [128] = {
+    0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087, 
+    0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f, 
+    0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097, 
+    0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f, 
+    0x00a0, 0x00a1, 0x00a2, 0x00a3, 0x20ac, 0x00a5, 0x0160, 0x00a7, 
+    0x0161, 0x00a9, 0x00aa, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x00af, 
+    0x00b0, 0x00b1, 0x00b2, 0x00b3, 0x017d, 0x00b5, 0x00b6, 0x00b7, 
+    0x017e, 0x00b9, 0x00ba, 0x00bb, 0x0152, 0x0153, 0x0178, 0x00bf, 
+    0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6, 0x00c7, 
+    0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce, 0x00cf, 
+    0x00d0, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7, 
+    0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df, 
+    0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6, 0x00e7, 
+    0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef, 
+    0x00f0, 0x00f1, 0x00f2, 0x00f3, 0x00f4, 0x00f5, 0x00f6, 0x00f7, 
+    0x00f8, 0x00f9, 0x00fa, 0x00fb, 0x00fc, 0x00fd, 0x00fe, 0x00ff, 
+};
+
+static unsigned char const xmltranscodetable_ISO8859_15 [48 + 6 * 64] = {
+    "\x00\x00\x01\x05\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f"
+    "\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f"
+    "\xa0\xa1\xa2\xa3\x00\xa5\x00\xa7\x00\xa9\xaa\xab\xac\xad\xae\xaf"
+    "\xb0\xb1\xb2\xb3\x00\xb5\xb6\xb7\x00\xb9\xba\xbb\x00\x00\x00\xbf"
+    "\x00\x00\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\xbc\xbd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\xa6\xa8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\xbe\x00\x00\x00\x00\xb4\xb8\x00"
+    "\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf"
+    "\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf"
+    "\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef"
+    "\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff"
+};
+
+static unsigned short const xmlunicodetable_ISO8859_16 [128] = {
+    0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087, 
+    0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f, 
+    0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097, 
+    0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f, 
+    0x00a0, 0x0104, 0x0105, 0x0141, 0x20ac, 0x201e, 0x0160, 0x00a7, 
+    0x0161, 0x00a9, 0x0218, 0x00ab, 0x0179, 0x00ad, 0x017a, 0x017b, 
+    0x00b0, 0x00b1, 0x010c, 0x0142, 0x017d, 0x201d, 0x00b6, 0x00b7, 
+    0x017e, 0x010d, 0x0219, 0x00bb, 0x0152, 0x0153, 0x0178, 0x017c, 
+    0x00c0, 0x00c1, 0x00c2, 0x0102, 0x00c4, 0x0106, 0x00c6, 0x00c7, 
+    0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce, 0x00cf, 
+    0x0110, 0x0143, 0x00d2, 0x00d3, 0x00d4, 0x0150, 0x00d6, 0x015a, 
+    0x0170, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x0118, 0x021a, 0x00df, 
+    0x00e0, 0x00e1, 0x00e2, 0x0103, 0x00e4, 0x0107, 0x00e6, 0x00e7, 
+    0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef, 
+    0x0111, 0x0144, 0x00f2, 0x00f3, 0x00f4, 0x0151, 0x00f6, 0x015b, 
+    0x0171, 0x00f9, 0x00fa, 0x00fb, 0x00fc, 0x0119, 0x021b, 0x00ff, 
+};
+
+static unsigned char const xmltranscodetable_ISO8859_16 [48 + 9 * 64] = {
+    "\x00\x00\x01\x08\x02\x03\x00\x00\x07\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f"
+    "\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f"
+    "\xa0\x00\x00\x00\x00\x00\x00\xa7\x00\xa9\x00\xab\x00\xad\x00\x00"
+    "\xb0\xb1\x00\x00\x00\x00\xb6\xb7\x00\x00\x00\xbb\x00\x00\x00\x00"
+    "\x00\x00\xc3\xe3\xa1\xa2\xc5\xe5\x00\x00\x00\x00\xb2\xb9\x00\x00"
+    "\xd0\xf0\x00\x00\x00\x00\x00\x00\xdd\xfd\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\xa3\xb3\xd1\xf1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\xd5\xf5\xbc\xbd\x00\x00\x00\x00\x00\x00\xd7\xf7\x00\x00\x00\x00"
+    "\xa6\xa8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\xd8\xf8\x00\x00\x00\x00\x00\x00\xbe\xac\xae\xaf\xbf\xb4\xb8\x00"
+    "\x06\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb5\xa5\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\xaa\xba\xde\xfe\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\xc0\xc1\xc2\x00\xc4\x00\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf"
+    "\x00\x00\xd2\xd3\xd4\x00\xd6\x00\x00\xd9\xda\xdb\xdc\x00\x00\xdf"
+    "\xe0\xe1\xe2\x00\xe4\x00\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef"
+    "\x00\x00\xf2\xf3\xf4\x00\xf6\x00\x00\xf9\xfa\xfb\xfc\x00\x00\xff"
+};
+
+
+/*
+ * auto-generated functions for ISO-8859-2 .. ISO-8859-16
+ */
+
+static int ISO8859_2ToUTF8 (unsigned char* out, int *outlen,
+    const unsigned char* in, int *inlen) {
+    return ISO8859xToUTF8 (out, outlen, in, inlen, xmlunicodetable_ISO8859_2);
+}
+static int UTF8ToISO8859_2 (unsigned char* out, int *outlen,
+    const unsigned char* in, int *inlen) {
+    return UTF8ToISO8859x (out, outlen, in, inlen, xmltranscodetable_ISO8859_2);
+}
+
+static int ISO8859_3ToUTF8 (unsigned char* out, int *outlen,
+    const unsigned char* in, int *inlen) {
+    return ISO8859xToUTF8 (out, outlen, in, inlen, xmlunicodetable_ISO8859_3);
+}
+static int UTF8ToISO8859_3 (unsigned char* out, int *outlen,
+    const unsigned char* in, int *inlen) {
+    return UTF8ToISO8859x (out, outlen, in, inlen, xmltranscodetable_ISO8859_3);
+}
+
+static int ISO8859_4ToUTF8 (unsigned char* out, int *outlen,
+    const unsigned char* in, int *inlen) {
+    return ISO8859xToUTF8 (out, outlen, in, inlen, xmlunicodetable_ISO8859_4);
+}
+static int UTF8ToISO8859_4 (unsigned char* out, int *outlen,
+    const unsigned char* in, int *inlen) {
+    return UTF8ToISO8859x (out, outlen, in, inlen, xmltranscodetable_ISO8859_4);
+}
+
+static int ISO8859_5ToUTF8 (unsigned char* out, int *outlen,
+    const unsigned char* in, int *inlen) {
+    return ISO8859xToUTF8 (out, outlen, in, inlen, xmlunicodetable_ISO8859_5);
+}
+static int UTF8ToISO8859_5 (unsigned char* out, int *outlen,
+    const unsigned char* in, int *inlen) {
+    return UTF8ToISO8859x (out, outlen, in, inlen, xmltranscodetable_ISO8859_5);
+}
+
+static int ISO8859_6ToUTF8 (unsigned char* out, int *outlen,
+    const unsigned char* in, int *inlen) {
+    return ISO8859xToUTF8 (out, outlen, in, inlen, xmlunicodetable_ISO8859_6);
+}
+static int UTF8ToISO8859_6 (unsigned char* out, int *outlen,
+    const unsigned char* in, int *inlen) {
+    return UTF8ToISO8859x (out, outlen, in, inlen, xmltranscodetable_ISO8859_6);
+}
+
+static int ISO8859_7ToUTF8 (unsigned char* out, int *outlen,
+    const unsigned char* in, int *inlen) {
+    return ISO8859xToUTF8 (out, outlen, in, inlen, xmlunicodetable_ISO8859_7);
+}
+static int UTF8ToISO8859_7 (unsigned char* out, int *outlen,
+    const unsigned char* in, int *inlen) {
+    return UTF8ToISO8859x (out, outlen, in, inlen, xmltranscodetable_ISO8859_7);
+}
+
+static int ISO8859_8ToUTF8 (unsigned char* out, int *outlen,
+    const unsigned char* in, int *inlen) {
+    return ISO8859xToUTF8 (out, outlen, in, inlen, xmlunicodetable_ISO8859_8);
+}
+static int UTF8ToISO8859_8 (unsigned char* out, int *outlen,
+    const unsigned char* in, int *inlen) {
+    return UTF8ToISO8859x (out, outlen, in, inlen, xmltranscodetable_ISO8859_8);
+}
+
+static int ISO8859_9ToUTF8 (unsigned char* out, int *outlen,
+    const unsigned char* in, int *inlen) {
+    return ISO8859xToUTF8 (out, outlen, in, inlen, xmlunicodetable_ISO8859_9);
+}
+static int UTF8ToISO8859_9 (unsigned char* out, int *outlen,
+    const unsigned char* in, int *inlen) {
+    return UTF8ToISO8859x (out, outlen, in, inlen, xmltranscodetable_ISO8859_9);
+}
+
+static int ISO8859_10ToUTF8 (unsigned char* out, int *outlen,
+    const unsigned char* in, int *inlen) {
+    return ISO8859xToUTF8 (out, outlen, in, inlen, xmlunicodetable_ISO8859_10);
+}
+static int UTF8ToISO8859_10 (unsigned char* out, int *outlen,
+    const unsigned char* in, int *inlen) {
+    return UTF8ToISO8859x (out, outlen, in, inlen, xmltranscodetable_ISO8859_10);
+}
+
+static int ISO8859_11ToUTF8 (unsigned char* out, int *outlen,
+    const unsigned char* in, int *inlen) {
+    return ISO8859xToUTF8 (out, outlen, in, inlen, xmlunicodetable_ISO8859_11);
+}
+static int UTF8ToISO8859_11 (unsigned char* out, int *outlen,
+    const unsigned char* in, int *inlen) {
+    return UTF8ToISO8859x (out, outlen, in, inlen, xmltranscodetable_ISO8859_11);
+}
+
+static int ISO8859_13ToUTF8 (unsigned char* out, int *outlen,
+    const unsigned char* in, int *inlen) {
+    return ISO8859xToUTF8 (out, outlen, in, inlen, xmlunicodetable_ISO8859_13);
+}
+static int UTF8ToISO8859_13 (unsigned char* out, int *outlen,
+    const unsigned char* in, int *inlen) {
+    return UTF8ToISO8859x (out, outlen, in, inlen, xmltranscodetable_ISO8859_13);
+}
+
+static int ISO8859_14ToUTF8 (unsigned char* out, int *outlen,
+    const unsigned char* in, int *inlen) {
+    return ISO8859xToUTF8 (out, outlen, in, inlen, xmlunicodetable_ISO8859_14);
+}
+static int UTF8ToISO8859_14 (unsigned char* out, int *outlen,
+    const unsigned char* in, int *inlen) {
+    return UTF8ToISO8859x (out, outlen, in, inlen, xmltranscodetable_ISO8859_14);
+}
+
+static int ISO8859_15ToUTF8 (unsigned char* out, int *outlen,
+    const unsigned char* in, int *inlen) {
+    return ISO8859xToUTF8 (out, outlen, in, inlen, xmlunicodetable_ISO8859_15);
+}
+static int UTF8ToISO8859_15 (unsigned char* out, int *outlen,
+    const unsigned char* in, int *inlen) {
+    return UTF8ToISO8859x (out, outlen, in, inlen, xmltranscodetable_ISO8859_15);
+}
+
+static int ISO8859_16ToUTF8 (unsigned char* out, int *outlen,
+    const unsigned char* in, int *inlen) {
+    return ISO8859xToUTF8 (out, outlen, in, inlen, xmlunicodetable_ISO8859_16);
+}
+static int UTF8ToISO8859_16 (unsigned char* out, int *outlen,
+    const unsigned char* in, int *inlen) {
+    return UTF8ToISO8859x (out, outlen, in, inlen, xmltranscodetable_ISO8859_16);
+}
+
+static void
+xmlRegisterCharEncodingHandlersISO8859x (void) {
+    xmlNewCharEncodingHandler ("ISO-8859-2", ISO8859_2ToUTF8, UTF8ToISO8859_2);
+    xmlNewCharEncodingHandler ("ISO-8859-3", ISO8859_3ToUTF8, UTF8ToISO8859_3);
+    xmlNewCharEncodingHandler ("ISO-8859-4", ISO8859_4ToUTF8, UTF8ToISO8859_4);
+    xmlNewCharEncodingHandler ("ISO-8859-5", ISO8859_5ToUTF8, UTF8ToISO8859_5);
+    xmlNewCharEncodingHandler ("ISO-8859-6", ISO8859_6ToUTF8, UTF8ToISO8859_6);
+    xmlNewCharEncodingHandler ("ISO-8859-7", ISO8859_7ToUTF8, UTF8ToISO8859_7);
+    xmlNewCharEncodingHandler ("ISO-8859-8", ISO8859_8ToUTF8, UTF8ToISO8859_8);
+    xmlNewCharEncodingHandler ("ISO-8859-9", ISO8859_9ToUTF8, UTF8ToISO8859_9);
+    xmlNewCharEncodingHandler ("ISO-8859-10", ISO8859_10ToUTF8, UTF8ToISO8859_10);
+    xmlNewCharEncodingHandler ("ISO-8859-11", ISO8859_11ToUTF8, UTF8ToISO8859_11);
+    xmlNewCharEncodingHandler ("ISO-8859-13", ISO8859_13ToUTF8, UTF8ToISO8859_13);
+    xmlNewCharEncodingHandler ("ISO-8859-14", ISO8859_14ToUTF8, UTF8ToISO8859_14);
+    xmlNewCharEncodingHandler ("ISO-8859-15", ISO8859_15ToUTF8, UTF8ToISO8859_15);
+    xmlNewCharEncodingHandler ("ISO-8859-16", ISO8859_16ToUTF8, UTF8ToISO8859_16);
+}
+
+#endif
+#endif
+
+
diff --git a/src/libxml/src/entities.c b/src/libxml/src/entities.c
new file mode 100644
index 0000000..db1c4c9
--- /dev/null
+++ b/src/libxml/src/entities.c
@@ -0,0 +1,897 @@
+/*
+ * entities.c : implementation for the XML entities handling
+ *
+ * See Copyright for the status of this software.
+ *
+ * daniel@veillard.com
+ */
+
+#define IN_LIBXML
+#include "libxml.h"
+
+#include <string.h>
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+#include <libxml/xmlmemory.h>
+#include <libxml/hash.h>
+#include <libxml/entities.h>
+#include <libxml/parser.h>
+#include <libxml/parserInternals.h>
+#include <libxml/xmlerror.h>
+#include <libxml/globals.h>
+
+/*
+ * The XML predefined entities.
+ */
+
+static xmlEntity xmlEntityLt = {
+    NULL, XML_ENTITY_DECL, BAD_CAST "lt",
+    NULL, NULL, NULL, NULL, NULL, NULL, 
+    BAD_CAST "<", BAD_CAST "<", 1,
+    XML_INTERNAL_PREDEFINED_ENTITY,
+    NULL, NULL, NULL, NULL, 0
+};
+static xmlEntity xmlEntityGt = {
+    NULL, XML_ENTITY_DECL, BAD_CAST "gt",
+    NULL, NULL, NULL, NULL, NULL, NULL, 
+    BAD_CAST ">", BAD_CAST ">", 1,
+    XML_INTERNAL_PREDEFINED_ENTITY,
+    NULL, NULL, NULL, NULL, 0
+};
+static xmlEntity xmlEntityAmp = {
+    NULL, XML_ENTITY_DECL, BAD_CAST "amp",
+    NULL, NULL, NULL, NULL, NULL, NULL, 
+    BAD_CAST "&", BAD_CAST "&", 1,
+    XML_INTERNAL_PREDEFINED_ENTITY,
+    NULL, NULL, NULL, NULL, 0
+};
+static xmlEntity xmlEntityQuot = {
+    NULL, XML_ENTITY_DECL, BAD_CAST "quot",
+    NULL, NULL, NULL, NULL, NULL, NULL, 
+    BAD_CAST "\"", BAD_CAST "\"", 1,
+    XML_INTERNAL_PREDEFINED_ENTITY,
+    NULL, NULL, NULL, NULL, 0
+};
+static xmlEntity xmlEntityApos = {
+    NULL, XML_ENTITY_DECL, BAD_CAST "apos",
+    NULL, NULL, NULL, NULL, NULL, NULL, 
+    BAD_CAST "'", BAD_CAST "'", 1,
+    XML_INTERNAL_PREDEFINED_ENTITY,
+    NULL, NULL, NULL, NULL, 0
+};
+
+/*
+ * xmlFreeEntity : clean-up an entity record.
+ */
+static void xmlFreeEntity(xmlEntityPtr entity) {
+    if (entity == NULL) return;
+
+    if ((entity->children) && (entity->owner == 1) &&
+	(entity == (xmlEntityPtr) entity->children->parent))
+	xmlFreeNodeList(entity->children);
+    if (entity->name != NULL)
+	xmlFree((char *) entity->name);
+    if (entity->ExternalID != NULL)
+        xmlFree((char *) entity->ExternalID);
+    if (entity->SystemID != NULL)
+        xmlFree((char *) entity->SystemID);
+    if (entity->URI != NULL)
+        xmlFree((char *) entity->URI);
+    if (entity->content != NULL)
+        xmlFree((char *) entity->content);
+    if (entity->orig != NULL)
+        xmlFree((char *) entity->orig);
+    xmlFree(entity);
+}
+
+/*
+ * xmlAddEntity : register a new entity for an entities table.
+ */
+static xmlEntityPtr
+xmlAddEntity(xmlDtdPtr dtd, const xmlChar *name, int type,
+	  const xmlChar *ExternalID, const xmlChar *SystemID,
+	  const xmlChar *content) {
+    xmlEntitiesTablePtr table = NULL;
+    xmlEntityPtr ret;
+
+    if (name == NULL)
+	return(NULL);
+    switch (type) {
+        case XML_INTERNAL_GENERAL_ENTITY:
+        case XML_EXTERNAL_GENERAL_PARSED_ENTITY:
+        case XML_EXTERNAL_GENERAL_UNPARSED_ENTITY:
+	    if (dtd->entities == NULL)
+		dtd->entities = xmlHashCreate(0);
+	    table = dtd->entities;
+	    break;
+        case XML_INTERNAL_PARAMETER_ENTITY:
+        case XML_EXTERNAL_PARAMETER_ENTITY:
+	    if (dtd->pentities == NULL)
+		dtd->pentities = xmlHashCreate(0);
+	    table = dtd->pentities;
+	    break;
+        case XML_INTERNAL_PREDEFINED_ENTITY:
+	    return(NULL);
+    }
+    if (table == NULL)
+	return(NULL);
+    ret = (xmlEntityPtr) xmlMalloc(sizeof(xmlEntity));
+    if (ret == NULL) {
+	xmlGenericError(xmlGenericErrorContext,
+		"xmlAddEntity: out of memory\n");
+	return(NULL);
+    }
+    memset(ret, 0, sizeof(xmlEntity));
+    ret->type = XML_ENTITY_DECL;
+
+    /*
+     * fill the structure.
+     */
+    ret->name = xmlStrdup(name);
+    ret->etype = (xmlEntityType) type;
+    if (ExternalID != NULL)
+	ret->ExternalID = xmlStrdup(ExternalID);
+    if (SystemID != NULL)
+	ret->SystemID = xmlStrdup(SystemID);
+    if (content != NULL) {
+        ret->length = xmlStrlen(content);
+	ret->content = xmlStrndup(content, ret->length);
+     } else {
+        ret->length = 0;
+        ret->content = NULL;
+    }
+    ret->URI = NULL; /* to be computed by the layer knowing
+			the defining entity */
+    ret->orig = NULL;
+    ret->owner = 0;
+
+    if (xmlHashAddEntry(table, name, ret)) {
+	/*
+	 * entity was already defined at another level.
+	 */
+        xmlFreeEntity(ret);
+	return(NULL);
+    }
+    return(ret);
+}
+
+/**
+ * xmlGetPredefinedEntity:
+ * @name:  the entity name
+ *
+ * Check whether this name is an predefined entity.
+ *
+ * Returns NULL if not, otherwise the entity
+ */
+xmlEntityPtr
+xmlGetPredefinedEntity(const xmlChar *name) {
+    if (name == NULL) return(NULL);
+    switch (name[0]) {
+        case 'l':
+	    if (xmlStrEqual(name, BAD_CAST "lt"))
+	        return(&xmlEntityLt);
+	    break;
+        case 'g':
+	    if (xmlStrEqual(name, BAD_CAST "gt"))
+	        return(&xmlEntityGt);
+	    break;
+        case 'a':
+	    if (xmlStrEqual(name, BAD_CAST "amp"))
+	        return(&xmlEntityAmp);
+	    if (xmlStrEqual(name, BAD_CAST "apos"))
+	        return(&xmlEntityApos);
+	    break;
+        case 'q':
+	    if (xmlStrEqual(name, BAD_CAST "quot"))
+	        return(&xmlEntityQuot);
+	    break;
+	default:
+	    break;
+    }
+    return(NULL);
+}
+
+/**
+ * xmlAddDtdEntity:
+ * @doc:  the document
+ * @name:  the entity name
+ * @type:  the entity type XML_xxx_yyy_ENTITY
+ * @ExternalID:  the entity external ID if available
+ * @SystemID:  the entity system ID if available
+ * @content:  the entity content
+ *
+ * Register a new entity for this document DTD external subset.
+ *
+ * Returns a pointer to the entity or NULL in case of error
+ */
+xmlEntityPtr
+xmlAddDtdEntity(xmlDocPtr doc, const xmlChar *name, int type,
+	        const xmlChar *ExternalID, const xmlChar *SystemID,
+		const xmlChar *content) {
+    xmlEntityPtr ret;
+    xmlDtdPtr dtd;
+
+    if (doc == NULL) {
+        xmlGenericError(xmlGenericErrorContext,
+	        "xmlAddDtdEntity: doc == NULL !\n");
+	return(NULL);
+    }
+    if (doc->extSubset == NULL) {
+        xmlGenericError(xmlGenericErrorContext,
+	        "xmlAddDtdEntity: document without external subset !\n");
+	return(NULL);
+    }
+    dtd = doc->extSubset;
+    ret = xmlAddEntity(dtd, name, type, ExternalID, SystemID, content);
+    if (ret == NULL) return(NULL);
+
+    /*
+     * Link it to the DTD
+     */
+    ret->parent = dtd;
+    ret->doc = dtd->doc;
+    if (dtd->last == NULL) {
+	dtd->children = dtd->last = (xmlNodePtr) ret;
+    } else {
+        dtd->last->next = (xmlNodePtr) ret;
+	ret->prev = dtd->last;
+	dtd->last = (xmlNodePtr) ret;
+    }
+    return(ret);
+}
+
+/**
+ * xmlAddDocEntity:
+ * @doc:  the document
+ * @name:  the entity name
+ * @type:  the entity type XML_xxx_yyy_ENTITY
+ * @ExternalID:  the entity external ID if available
+ * @SystemID:  the entity system ID if available
+ * @content:  the entity content
+ *
+ * Register a new entity for this document.
+ *
+ * Returns a pointer to the entity or NULL in case of error
+ */
+xmlEntityPtr
+xmlAddDocEntity(xmlDocPtr doc, const xmlChar *name, int type,
+	        const xmlChar *ExternalID, const xmlChar *SystemID,
+	        const xmlChar *content) {
+    xmlEntityPtr ret;
+    xmlDtdPtr dtd;
+
+    if (doc == NULL) {
+        xmlGenericError(xmlGenericErrorContext,
+	        "xmlAddDocEntity: document is NULL !\n");
+	return(NULL);
+    }
+    if (doc->intSubset == NULL) {
+        xmlGenericError(xmlGenericErrorContext,
+	        "xmlAddDocEntity: document without internal subset !\n");
+	return(NULL);
+    }
+    dtd = doc->intSubset;
+    ret = xmlAddEntity(dtd, name, type, ExternalID, SystemID, content);
+    if (ret == NULL) return(NULL);
+
+    /*
+     * Link it to the DTD
+     */
+    ret->parent = dtd;
+    ret->doc = dtd->doc;
+    if (dtd->last == NULL) {
+	dtd->children = dtd->last = (xmlNodePtr) ret;
+    } else {
+	dtd->last->next = (xmlNodePtr) ret;
+	ret->prev = dtd->last;
+	dtd->last = (xmlNodePtr) ret;
+    }
+    return(ret);
+}
+
+/**
+ * xmlGetEntityFromTable:
+ * @table:  an entity table
+ * @name:  the entity name
+ * @parameter:  look for parameter entities
+ *
+ * Do an entity lookup in the table.
+ * returns the corresponding parameter entity, if found.
+ * 
+ * Returns A pointer to the entity structure or NULL if not found.
+ */
+static xmlEntityPtr
+xmlGetEntityFromTable(xmlEntitiesTablePtr table, const xmlChar *name) {
+    return((xmlEntityPtr) xmlHashLookup(table, name));
+}
+
+/**
+ * xmlGetParameterEntity:
+ * @doc:  the document referencing the entity
+ * @name:  the entity name
+ *
+ * Do an entity lookup in the internal and external subsets and
+ * returns the corresponding parameter entity, if found.
+ * 
+ * Returns A pointer to the entity structure or NULL if not found.
+ */
+xmlEntityPtr
+xmlGetParameterEntity(xmlDocPtr doc, const xmlChar *name) {
+    xmlEntitiesTablePtr table;
+    xmlEntityPtr ret;
+
+    if (doc == NULL)
+	return(NULL);
+    if ((doc->intSubset != NULL) && (doc->intSubset->pentities != NULL)) {
+	table = (xmlEntitiesTablePtr) doc->intSubset->pentities;
+	ret = xmlGetEntityFromTable(table, name);
+	if (ret != NULL)
+	    return(ret);
+    }
+    if ((doc->extSubset != NULL) && (doc->extSubset->pentities != NULL)) {
+	table = (xmlEntitiesTablePtr) doc->extSubset->pentities;
+	return(xmlGetEntityFromTable(table, name));
+    }
+    return(NULL);
+}
+
+/**
+ * xmlGetDtdEntity:
+ * @doc:  the document referencing the entity
+ * @name:  the entity name
+ *
+ * Do an entity lookup in the DTD entity hash table and
+ * returns the corresponding entity, if found.
+ * Note: the first argument is the document node, not the DTD node.
+ * 
+ * Returns A pointer to the entity structure or NULL if not found.
+ */
+xmlEntityPtr
+xmlGetDtdEntity(xmlDocPtr doc, const xmlChar *name) {
+    xmlEntitiesTablePtr table;
+
+    if (doc == NULL)
+	return(NULL);
+    if ((doc->extSubset != NULL) && (doc->extSubset->entities != NULL)) {
+	table = (xmlEntitiesTablePtr) doc->extSubset->entities;
+	return(xmlGetEntityFromTable(table, name));
+    }
+    return(NULL);
+}
+
+/**
+ * xmlGetDocEntity:
+ * @doc:  the document referencing the entity
+ * @name:  the entity name
+ *
+ * Do an entity lookup in the document entity hash table and
+ * returns the corresponding entity, otherwise a lookup is done
+ * in the predefined entities too.
+ * 
+ * Returns A pointer to the entity structure or NULL if not found.
+ */
+xmlEntityPtr
+xmlGetDocEntity(xmlDocPtr doc, const xmlChar *name) {
+    xmlEntityPtr cur;
+    xmlEntitiesTablePtr table;
+
+    if (doc != NULL) {
+	if ((doc->intSubset != NULL) && (doc->intSubset->entities != NULL)) {
+	    table = (xmlEntitiesTablePtr) doc->intSubset->entities;
+	    cur = xmlGetEntityFromTable(table, name);
+	    if (cur != NULL)
+		return(cur);
+	}
+	if (doc->standalone != 1) {
+	    if ((doc->extSubset != NULL) &&
+		(doc->extSubset->entities != NULL)) {
+		table = (xmlEntitiesTablePtr) doc->extSubset->entities;
+		cur = xmlGetEntityFromTable(table, name);
+		if (cur != NULL)
+		    return(cur);
+	    }
+	}
+    }
+    return(xmlGetPredefinedEntity(name));
+}
+
+/*
+ * Macro used to grow the current buffer.
+ */
+#define growBufferReentrant() {						\
+    buffer_size *= 2;							\
+    buffer = (xmlChar *)						\
+    		xmlRealloc(buffer, buffer_size * sizeof(xmlChar));	\
+    if (buffer == NULL) {						\
+	xmlGenericError(xmlGenericErrorContext, "realloc failed\n");	\
+	return(NULL);							\
+    }									\
+}
+
+
+/**
+ * xmlEncodeEntitiesReentrant:
+ * @doc:  the document containing the string
+ * @input:  A string to convert to XML.
+ *
+ * Do a global encoding of a string, replacing the predefined entities
+ * and non ASCII values with their entities and CharRef counterparts.
+ * Contrary to xmlEncodeEntities, this routine is reentrant, and result
+ * must be deallocated.
+ *
+ * Returns A newly allocated string with the substitution done.
+ */
+xmlChar *
+xmlEncodeEntitiesReentrant(xmlDocPtr doc, const xmlChar *input) {
+    const xmlChar *cur = input;
+    xmlChar *buffer = NULL;
+    xmlChar *out = NULL;
+    int buffer_size = 0;
+    int html = 0;
+
+    if (input == NULL) return(NULL);
+    if (doc != NULL)
+        html = (doc->type == XML_HTML_DOCUMENT_NODE);
+
+    /*
+     * allocate an translation buffer.
+     */
+    buffer_size = 1000;
+    buffer = (xmlChar *) xmlMalloc(buffer_size * sizeof(xmlChar));
+    if (buffer == NULL) {
+	xmlGenericError(xmlGenericErrorContext, "malloc failed\n");
+	return(NULL);
+    }
+    out = buffer;
+
+    while (*cur != '\0') {
+        if (out - buffer > buffer_size - 100) {
+	    int indx = out - buffer;
+
+	    growBufferReentrant();
+	    out = &buffer[indx];
+	}
+
+	/*
+	 * By default one have to encode at least '<', '>', '"' and '&' !
+	 */
+	if (*cur == '<') {
+	    *out++ = '&';
+	    *out++ = 'l';
+	    *out++ = 't';
+	    *out++ = ';';
+	} else if (*cur == '>') {
+	    *out++ = '&';
+	    *out++ = 'g';
+	    *out++ = 't';
+	    *out++ = ';';
+	} else if (*cur == '&') {
+	    *out++ = '&';
+	    *out++ = 'a';
+	    *out++ = 'm';
+	    *out++ = 'p';
+	    *out++ = ';';
+	} else if (((*cur >= 0x20) && (*cur < 0x80)) ||
+	    (*cur == '\n') || (*cur == '\t') || ((html) && (*cur == '\r'))) {
+	    /*
+	     * default case, just copy !
+	     */
+	    *out++ = *cur;
+	} else if (*cur >= 0x80) {
+	    if (((doc != NULL) && (doc->encoding != NULL)) || (html)) {
+		/*
+		 * Bjørn Reese <br@sseusa.com> provided the patch
+	        xmlChar xc;
+	        xc = (*cur & 0x3F) << 6;
+	        if (cur[1] != 0) {
+		    xc += *(++cur) & 0x3F;
+		    *out++ = xc;
+	        } else
+		 */
+		    *out++ = *cur;
+	    } else {
+		/*
+		 * We assume we have UTF-8 input.
+		 */
+		char buf[11], *ptr;
+		int val = 0, l = 1;
+
+		if (*cur < 0xC0) {
+		    xmlGenericError(xmlGenericErrorContext,
+			    "xmlEncodeEntitiesReentrant : input not UTF-8\n");
+		    if (doc != NULL)
+			doc->encoding = xmlStrdup(BAD_CAST "ISO-8859-1");
+		    snprintf(buf, sizeof(buf), "&#%d;", *cur);
+		    buf[sizeof(buf) - 1] = 0;
+		    ptr = buf;
+		    while (*ptr != 0) *out++ = *ptr++;
+		    cur++;
+		    continue;
+		} else if (*cur < 0xE0) {
+                    val = (cur[0]) & 0x1F;
+		    val <<= 6;
+		    val |= (cur[1]) & 0x3F;
+		    l = 2;
+		} else if (*cur < 0xF0) {
+                    val = (cur[0]) & 0x0F;
+		    val <<= 6;
+		    val |= (cur[1]) & 0x3F;
+		    val <<= 6;
+		    val |= (cur[2]) & 0x3F;
+		    l = 3;
+		} else if (*cur < 0xF8) {
+                    val = (cur[0]) & 0x07;
+		    val <<= 6;
+		    val |= (cur[1]) & 0x3F;
+		    val <<= 6;
+		    val |= (cur[2]) & 0x3F;
+		    val <<= 6;
+		    val |= (cur[3]) & 0x3F;
+		    l = 4;
+		}
+		if ((l == 1) || (!IS_CHAR(val))) {
+		    xmlGenericError(xmlGenericErrorContext,
+			"xmlEncodeEntitiesReentrant : char out of range\n");
+		    if (doc != NULL)
+			doc->encoding = xmlStrdup(BAD_CAST "ISO-8859-1");
+		    snprintf(buf, sizeof(buf), "&#%d;", *cur);
+		    buf[sizeof(buf) - 1] = 0;
+		    ptr = buf;
+		    while (*ptr != 0) *out++ = *ptr++;
+		    cur++;
+		    continue;
+		}
+		/*
+		 * We could do multiple things here. Just save as a char ref
+		 */
+		if (html)
+		    snprintf(buf, sizeof(buf), "&#%d;", val);
+		else
+		    snprintf(buf, sizeof(buf), "&#x%X;", val);
+		buf[sizeof(buf) - 1] = 0;
+		ptr = buf;
+		while (*ptr != 0) *out++ = *ptr++;
+		cur += l;
+		continue;
+	    }
+	} else if (IS_BYTE_CHAR(*cur)) {
+	    char buf[11], *ptr;
+
+	    snprintf(buf, sizeof(buf), "&#%d;", *cur);
+	    buf[sizeof(buf) - 1] = 0;
+            ptr = buf;
+	    while (*ptr != 0) *out++ = *ptr++;
+	}
+	cur++;
+    }
+    *out++ = 0;
+    return(buffer);
+}
+
+/**
+ * xmlEncodeSpecialChars:
+ * @doc:  the document containing the string
+ * @input:  A string to convert to XML.
+ *
+ * Do a global encoding of a string, replacing the predefined entities
+ * this routine is reentrant, and result must be deallocated.
+ *
+ * Returns A newly allocated string with the substitution done.
+ */
+xmlChar *
+xmlEncodeSpecialChars(xmlDocPtr doc ATTRIBUTE_UNUSED, const xmlChar *input) {
+    const xmlChar *cur = input;
+    xmlChar *buffer = NULL;
+    xmlChar *out = NULL;
+    int buffer_size = 0;
+    if (input == NULL) return(NULL);
+
+    /*
+     * allocate an translation buffer.
+     */
+    buffer_size = 1000;
+    buffer = (xmlChar *) xmlMalloc(buffer_size * sizeof(xmlChar));
+    if (buffer == NULL) {
+	xmlGenericError(xmlGenericErrorContext, "malloc failed\n");
+	return(NULL);
+    }
+    out = buffer;
+
+    while (*cur != '\0') {
+        if (out - buffer > buffer_size - 10) {
+	    int indx = out - buffer;
+
+	    growBufferReentrant();
+	    out = &buffer[indx];
+	}
+
+	/*
+	 * By default one have to encode at least '<', '>', '"' and '&' !
+	 */
+	if (*cur == '<') {
+	    *out++ = '&';
+	    *out++ = 'l';
+	    *out++ = 't';
+	    *out++ = ';';
+	} else if (*cur == '>') {
+	    *out++ = '&';
+	    *out++ = 'g';
+	    *out++ = 't';
+	    *out++ = ';';
+	} else if (*cur == '&') {
+	    *out++ = '&';
+	    *out++ = 'a';
+	    *out++ = 'm';
+	    *out++ = 'p';
+	    *out++ = ';';
+#if 0
+	} else if (*cur == '"') {
+	    *out++ = '&';
+	    *out++ = 'q';
+	    *out++ = 'u';
+	    *out++ = 'o';
+	    *out++ = 't';
+	    *out++ = ';';
+#endif
+	} else if (*cur == '\r') {
+	    *out++ = '&';
+	    *out++ = '#';
+	    *out++ = '1';
+	    *out++ = '3';
+	    *out++ = ';';
+	} else {
+	    /*
+	     * Works because on UTF-8, all extended sequences cannot
+	     * result in bytes in the ASCII range.
+	     */
+	    *out++ = *cur;
+	}
+	cur++;
+    }
+    *out++ = 0;
+    return(buffer);
+}
+
+/**
+ * xmlCreateEntitiesTable:
+ *
+ * create and initialize an empty entities hash table.
+ *
+ * Returns the xmlEntitiesTablePtr just created or NULL in case of error.
+ */
+xmlEntitiesTablePtr
+xmlCreateEntitiesTable(void) {
+    return((xmlEntitiesTablePtr) xmlHashCreate(0));
+}
+
+/**
+ * xmlFreeEntityWrapper:
+ * @entity:  An entity
+ * @name:  its name
+ *
+ * Deallocate the memory used by an entities in the hash table.
+ */
+static void
+xmlFreeEntityWrapper(xmlEntityPtr entity,
+	               const xmlChar *name ATTRIBUTE_UNUSED) {
+    if (entity != NULL)
+	xmlFreeEntity(entity);
+}
+
+/**
+ * xmlFreeEntitiesTable:
+ * @table:  An entity table
+ *
+ * Deallocate the memory used by an entities hash table.
+ */
+void
+xmlFreeEntitiesTable(xmlEntitiesTablePtr table) {
+    xmlHashFree(table, (xmlHashDeallocator) xmlFreeEntityWrapper);
+}
+
+#ifdef LIBXML_TREE_ENABLED
+/**
+ * xmlCopyEntity:
+ * @ent:  An entity
+ *
+ * Build a copy of an entity
+ * 
+ * Returns the new xmlEntitiesPtr or NULL in case of error.
+ */
+static xmlEntityPtr
+xmlCopyEntity(xmlEntityPtr ent) {
+    xmlEntityPtr cur;
+
+    cur = (xmlEntityPtr) xmlMalloc(sizeof(xmlEntity));
+    if (cur == NULL) {
+	xmlGenericError(xmlGenericErrorContext,
+		"xmlCopyEntity: out of memory !\n");
+	return(NULL);
+    }
+    memset(cur, 0, sizeof(xmlEntity));
+    cur->type = XML_ENTITY_DECL;
+
+    cur->etype = ent->etype;
+    if (ent->name != NULL)
+	cur->name = xmlStrdup(ent->name);
+    if (ent->ExternalID != NULL)
+	cur->ExternalID = xmlStrdup(ent->ExternalID);
+    if (ent->SystemID != NULL)
+	cur->SystemID = xmlStrdup(ent->SystemID);
+    if (ent->content != NULL)
+	cur->content = xmlStrdup(ent->content);
+    if (ent->orig != NULL)
+	cur->orig = xmlStrdup(ent->orig);
+    if (ent->URI != NULL)
+	cur->URI = xmlStrdup(ent->URI);
+    return(cur);
+}
+
+/**
+ * xmlCopyEntitiesTable:
+ * @table:  An entity table
+ *
+ * Build a copy of an entity table.
+ * 
+ * Returns the new xmlEntitiesTablePtr or NULL in case of error.
+ */
+xmlEntitiesTablePtr
+xmlCopyEntitiesTable(xmlEntitiesTablePtr table) {
+    return(xmlHashCopy(table, (xmlHashCopier) xmlCopyEntity));
+}
+#endif /* LIBXML_TREE_ENABLED */
+
+#ifdef LIBXML_OUTPUT_ENABLED
+
+/**
+ * xmlDumpEntityContent:
+ * @buf:  An XML buffer.
+ * @content:  The entity content.
+ *
+ * This will dump the quoted string value, taking care of the special
+ * treatment required by %
+ */
+static void
+xmlDumpEntityContent(xmlBufferPtr buf, const xmlChar *content) {
+    if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE) return;
+    if (xmlStrchr(content, '%')) {
+        const xmlChar * base, *cur;
+
+	xmlBufferCCat(buf, "\"");
+	base = cur = content;
+	while (*cur != 0) {
+	    if (*cur == '"') {
+		if (base != cur)
+		    xmlBufferAdd(buf, base, cur - base);
+		xmlBufferAdd(buf, BAD_CAST "&quot;", 6);
+		cur++;
+		base = cur;
+	    } else if (*cur == '%') {
+		if (base != cur)
+		    xmlBufferAdd(buf, base, cur - base);
+		xmlBufferAdd(buf, BAD_CAST "&#x25;", 6);
+		cur++;
+		base = cur;
+	    } else {
+		cur++;
+	    }
+	}
+	if (base != cur)
+	    xmlBufferAdd(buf, base, cur - base);
+	xmlBufferCCat(buf, "\"");
+    } else {
+        xmlBufferWriteQuotedString(buf, content);
+    }
+}
+
+/**
+ * xmlDumpEntityDecl:
+ * @buf:  An XML buffer.
+ * @ent:  An entity table
+ *
+ * This will dump the content of the entity table as an XML DTD definition
+ */
+void
+xmlDumpEntityDecl(xmlBufferPtr buf, xmlEntityPtr ent) {
+    switch (ent->etype) {
+	case XML_INTERNAL_GENERAL_ENTITY:
+	    xmlBufferWriteChar(buf, "<!ENTITY ");
+	    xmlBufferWriteCHAR(buf, ent->name);
+	    xmlBufferWriteChar(buf, " ");
+	    if (ent->orig != NULL)
+		xmlBufferWriteQuotedString(buf, ent->orig);
+	    else
+		xmlDumpEntityContent(buf, ent->content);
+	    xmlBufferWriteChar(buf, ">\n");
+	    break;
+	case XML_EXTERNAL_GENERAL_PARSED_ENTITY:
+	    xmlBufferWriteChar(buf, "<!ENTITY ");
+	    xmlBufferWriteCHAR(buf, ent->name);
+	    if (ent->ExternalID != NULL) {
+		 xmlBufferWriteChar(buf, " PUBLIC ");
+		 xmlBufferWriteQuotedString(buf, ent->ExternalID);
+		 xmlBufferWriteChar(buf, " ");
+		 xmlBufferWriteQuotedString(buf, ent->SystemID);
+	    } else {
+		 xmlBufferWriteChar(buf, " SYSTEM ");
+		 xmlBufferWriteQuotedString(buf, ent->SystemID);
+	    }
+	    xmlBufferWriteChar(buf, ">\n");
+	    break;
+	case XML_EXTERNAL_GENERAL_UNPARSED_ENTITY:
+	    xmlBufferWriteChar(buf, "<!ENTITY ");
+	    xmlBufferWriteCHAR(buf, ent->name);
+	    if (ent->ExternalID != NULL) {
+		 xmlBufferWriteChar(buf, " PUBLIC ");
+		 xmlBufferWriteQuotedString(buf, ent->ExternalID);
+		 xmlBufferWriteChar(buf, " ");
+		 xmlBufferWriteQuotedString(buf, ent->SystemID);
+	    } else {
+		 xmlBufferWriteChar(buf, " SYSTEM ");
+		 xmlBufferWriteQuotedString(buf, ent->SystemID);
+	    }
+	    if (ent->content != NULL) { /* Should be true ! */
+		xmlBufferWriteChar(buf, " NDATA ");
+		if (ent->orig != NULL)
+		    xmlBufferWriteCHAR(buf, ent->orig);
+		else
+		    xmlBufferWriteCHAR(buf, ent->content);
+	    }
+	    xmlBufferWriteChar(buf, ">\n");
+	    break;
+	case XML_INTERNAL_PARAMETER_ENTITY:
+	    xmlBufferWriteChar(buf, "<!ENTITY % ");
+	    xmlBufferWriteCHAR(buf, ent->name);
+	    xmlBufferWriteChar(buf, " ");
+	    if (ent->orig == NULL)
+		xmlDumpEntityContent(buf, ent->content);
+	    else
+		xmlBufferWriteQuotedString(buf, ent->orig);
+	    xmlBufferWriteChar(buf, ">\n");
+	    break;
+	case XML_EXTERNAL_PARAMETER_ENTITY:
+	    xmlBufferWriteChar(buf, "<!ENTITY % ");
+	    xmlBufferWriteCHAR(buf, ent->name);
+	    if (ent->ExternalID != NULL) {
+		 xmlBufferWriteChar(buf, " PUBLIC ");
+		 xmlBufferWriteQuotedString(buf, ent->ExternalID);
+		 xmlBufferWriteChar(buf, " ");
+		 xmlBufferWriteQuotedString(buf, ent->SystemID);
+	    } else {
+		 xmlBufferWriteChar(buf, " SYSTEM ");
+		 xmlBufferWriteQuotedString(buf, ent->SystemID);
+	    }
+	    xmlBufferWriteChar(buf, ">\n");
+	    break;
+	default:
+	    xmlGenericError(xmlGenericErrorContext,
+		"xmlDumpEntitiesDecl: internal: unknown type %d\n",
+		    ent->etype);
+    }
+}
+
+/**
+ * xmlDumpEntityDeclScan:
+ * @ent:  An entity table
+ * @buf:  An XML buffer.
+ *
+ * When using the hash table scan function, arguments need to be reversed
+ */
+static void
+xmlDumpEntityDeclScan(xmlEntityPtr ent, xmlBufferPtr buf) {
+    xmlDumpEntityDecl(buf, ent);
+}
+      
+/**
+ * xmlDumpEntitiesTable:
+ * @buf:  An XML buffer.
+ * @table:  An entity table
+ *
+ * This will dump the content of the entity table as an XML DTD definition
+ */
+void
+xmlDumpEntitiesTable(xmlBufferPtr buf, xmlEntitiesTablePtr table) {
+    xmlHashScan(table, (xmlHashScanner)xmlDumpEntityDeclScan, buf);
+}
+#endif /* LIBXML_OUTPUT_ENABLED */
diff --git a/src/libxml/src/error.c b/src/libxml/src/error.c
new file mode 100644
index 0000000..bd9b324
--- /dev/null
+++ b/src/libxml/src/error.c
@@ -0,0 +1,937 @@
+/*
+ * error.c: module displaying/handling XML parser errors
+ *
+ * See Copyright for the status of this software.
+ *
+ * Daniel Veillard <daniel@veillard.com>
+ */
+
+#define IN_LIBXML
+#include "libxml.h"
+
+#include <string.h>
+#include <stdarg.h>
+#include <libxml/parser.h>
+#include <libxml/xmlerror.h>
+#include <libxml/xmlmemory.h>
+#include <libxml/globals.h>
+
+void xmlGenericErrorDefaultFunc	(void *ctx ATTRIBUTE_UNUSED,
+				 const char *msg,
+				 ...);
+
+#define XML_GET_VAR_STR(msg, str) {				\
+    int       size;						\
+    int       chars;						\
+    char      *larger;						\
+    va_list   ap;						\
+								\
+    str = (char *) xmlMalloc(150);				\
+    if (str != NULL) {						\
+								\
+    size = 150;							\
+								\
+    while (1) {							\
+	va_start(ap, msg);					\
+  	chars = vsnprintf(str, size, msg, ap);			\
+	va_end(ap);						\
+	if ((chars > -1) && (chars < size))			\
+	    break;						\
+	if (chars > -1)						\
+	    size += chars + 1;					\
+	else							\
+	    size += 100;					\
+	if ((larger = (char *) xmlRealloc(str, size)) == NULL) {\
+	    break;						\
+	}							\
+	str = larger;						\
+    }}								\
+}
+
+/************************************************************************
+ * 									*
+ * 			Handling of out of context errors		*
+ * 									*
+ ************************************************************************/
+
+/**
+ * xmlGenericErrorDefaultFunc:
+ * @ctx:  an error context
+ * @msg:  the message to display/transmit
+ * @...:  extra parameters for the message display
+ * 
+ * Default handler for out of context error messages.
+ */
+void
+xmlGenericErrorDefaultFunc(void *ctx ATTRIBUTE_UNUSED, const char *msg, ...) {
+    va_list args;
+
+    if (xmlGenericErrorContext == NULL)
+	xmlGenericErrorContext = (void *) stderr;
+
+    va_start(args, msg);
+    vfprintf((FILE *)xmlGenericErrorContext, msg, args);
+    va_end(args);
+}
+
+/**
+ * initGenericErrorDefaultFunc:
+ * @handler:  the handler
+ * 
+ * Set or reset (if NULL) the default handler for generic errors
+ * to the builtin error function.
+ */
+void
+initGenericErrorDefaultFunc(xmlGenericErrorFunc * handler)
+{
+    if (handler == NULL)
+        xmlGenericError = xmlGenericErrorDefaultFunc;
+    else
+        (*handler) = xmlGenericErrorDefaultFunc;
+}
+
+/**
+ * xmlSetGenericErrorFunc:
+ * @ctx:  the new error handling context
+ * @handler:  the new handler function
+ *
+ * Function to reset the handler and the error context for out of
+ * context error messages.
+ * This simply means that @handler will be called for subsequent
+ * error messages while not parsing nor validating. And @ctx will
+ * be passed as first argument to @handler
+ * One can simply force messages to be emitted to another FILE * than
+ * stderr by setting @ctx to this file handle and @handler to NULL.
+ */
+void
+xmlSetGenericErrorFunc(void *ctx, xmlGenericErrorFunc handler) {
+    xmlGenericErrorContext = ctx;
+    if (handler != NULL)
+	xmlGenericError = handler;
+    else
+	xmlGenericError = xmlGenericErrorDefaultFunc;
+}
+
+/**
+ * xmlSetStructuredErrorFunc:
+ * @ctx:  the new error handling context
+ * @handler:  the new handler function
+ *
+ * Function to reset the handler and the error context for out of
+ * context structured error messages.
+ * This simply means that @handler will be called for subsequent
+ * error messages while not parsing nor validating. And @ctx will
+ * be passed as first argument to @handler
+ */
+void
+xmlSetStructuredErrorFunc(void *ctx, xmlStructuredErrorFunc handler) {
+    xmlGenericErrorContext = ctx;
+    xmlStructuredError = handler;
+}
+
+/************************************************************************
+ * 									*
+ * 			Handling of parsing errors			*
+ * 									*
+ ************************************************************************/
+
+/**
+ * xmlParserPrintFileInfo:
+ * @input:  an xmlParserInputPtr input
+ * 
+ * Displays the associated file and line informations for the current input
+ */
+
+void
+xmlParserPrintFileInfo(xmlParserInputPtr input) {
+    if (input != NULL) {
+	if (input->filename)
+	    xmlGenericError(xmlGenericErrorContext,
+		    "%s:%d: ", input->filename,
+		    input->line);
+	else
+	    xmlGenericError(xmlGenericErrorContext,
+		    "Entity: line %d: ", input->line);
+    }
+}
+
+/**
+ * xmlParserPrintFileContext:
+ * @input:  an xmlParserInputPtr input
+ * 
+ * Displays current context within the input content for error tracking
+ */
+
+static void
+xmlParserPrintFileContextInternal(xmlParserInputPtr input , 
+		xmlGenericErrorFunc channel, void *data ) {
+    const xmlChar *cur, *base;
+    unsigned int n, col;	/* GCC warns if signed, because compared with sizeof() */
+    xmlChar  content[81]; /* space for 80 chars + line terminator */
+    xmlChar *ctnt;
+
+    if (input == NULL) return;
+    cur = input->cur;
+    base = input->base;
+    /* skip backwards over any end-of-lines */
+    while ((cur > base) && ((*(cur) == '\n') || (*(cur) == '\r'))) {
+	cur--;
+    }
+    n = 0;
+    /* search backwards for beginning-of-line (to max buff size) */
+    while ((n++ < (sizeof(content)-1)) && (cur > base) && 
+    	   (*(cur) != '\n') && (*(cur) != '\r'))
+        cur--;
+    if ((*(cur) == '\n') || (*(cur) == '\r')) cur++;
+    /* calculate the error position in terms of the current position */
+    col = input->cur - cur;
+    /* search forward for end-of-line (to max buff size) */
+    n = 0;
+    ctnt = content;
+    /* copy selected text to our buffer */
+    while ((*cur != 0) && (*(cur) != '\n') && 
+    	   (*(cur) != '\r') && (n < sizeof(content)-1)) {
+		*ctnt++ = *cur++;
+	n++;
+    }
+    *ctnt = 0;
+    /* print out the selected text */
+    channel(data ,"%s\n", content);
+    /* create blank line with problem pointer */
+    n = 0;
+    ctnt = content;
+    /* (leave buffer space for pointer + line terminator) */
+    while ((n<col) && (n++ < sizeof(content)-2) && (*ctnt != 0)) {
+	if (*(ctnt) != '\t')
+	    *(ctnt) = ' ';
+	ctnt++;
+    }
+    *ctnt++ = '^';
+    *ctnt = 0;
+    channel(data ,"%s\n", content);
+}
+
+/**
+ * xmlParserPrintFileContext:
+ * @input:  an xmlParserInputPtr input
+ * 
+ * Displays current context within the input content for error tracking
+ */
+void
+xmlParserPrintFileContext(xmlParserInputPtr input) {
+   xmlParserPrintFileContextInternal(input, xmlGenericError,
+                                     xmlGenericErrorContext);
+}
+
+/**
+ * xmlReportError:
+ * @err: the error
+ * @ctx: the parser context or NULL
+ * @str: the formatted error message
+ *
+ * Report an erro with its context, replace the 4 old error/warning
+ * routines.
+ */
+static void
+xmlReportError(xmlErrorPtr err, xmlParserCtxtPtr ctxt, const char *str,
+               xmlGenericErrorFunc channel, void *data)
+{
+    char *file = NULL;
+    int line = 0;
+    int code = -1;
+    int domain;
+    const xmlChar *name = NULL;
+    xmlNodePtr node;
+    xmlErrorLevel level;
+    xmlParserInputPtr input = NULL;
+    xmlParserInputPtr cur = NULL;
+
+    if (err == NULL)
+        return;
+
+    if (channel == NULL) {
+	channel = xmlGenericError;
+	data = xmlGenericErrorContext;
+    }
+    file = err->file;
+    line = err->line;
+    code = err->code;
+    domain = err->domain;
+    level = err->level;
+    node = err->node;
+
+    if (code == XML_ERR_OK)
+        return;
+
+    if ((node != NULL) && (node->type == XML_ELEMENT_NODE))
+        name = node->name;
+
+    /*
+     * Maintain the compatibility with the legacy error handling
+     */
+    if (ctxt != NULL) {
+        input = ctxt->input;
+        if ((input != NULL) && (input->filename == NULL) &&
+            (ctxt->inputNr > 1)) {
+            cur = input;
+            input = ctxt->inputTab[ctxt->inputNr - 2];
+        }
+        if (input != NULL) {
+            if (input->filename)
+                channel(data, "%s:%d: ", input->filename, input->line);
+            else if ((line != 0) && (domain == XML_FROM_PARSER))
+                channel(data, "Entity: line %d: ", input->line);
+        }
+    } else {
+        if (file != NULL)
+            channel(data, "%s:%d: ", file, line);
+        else if ((line != 0) && (domain == XML_FROM_PARSER))
+            channel(data, "Entity: line %d: ", line);
+    }
+    if (name != NULL) {
+        channel(data, "element %s: ", name);
+    }
+    if (code == XML_ERR_OK)
+        return;
+    switch (domain) {
+        case XML_FROM_PARSER:
+            channel(data, "parser ");
+            break;
+        case XML_FROM_NAMESPACE:
+            channel(data, "namespace ");
+            break;
+        case XML_FROM_DTD:
+        case XML_FROM_VALID:
+            channel(data, "validity ");
+            break;
+        case XML_FROM_HTML:
+            channel(data, "HTML parser ");
+            break;
+        case XML_FROM_MEMORY:
+            channel(data, "memory ");
+            break;
+        case XML_FROM_OUTPUT:
+            channel(data, "output ");
+            break;
+        case XML_FROM_IO:
+            channel(data, "I/O ");
+            break;
+        case XML_FROM_XINCLUDE:
+            channel(data, "XInclude ");
+            break;
+        case XML_FROM_XPATH:
+            channel(data, "XPath ");
+            break;
+        case XML_FROM_XPOINTER:
+            channel(data, "parser ");
+            break;
+        case XML_FROM_REGEXP:
+            channel(data, "regexp ");
+            break;
+        case XML_FROM_SCHEMASV:
+            channel(data, "Schemas validity ");
+            break;
+        case XML_FROM_SCHEMASP:
+            channel(data, "Schemas parser ");
+            break;
+        case XML_FROM_RELAXNGP:
+            channel(data, "Relax-NG parser ");
+            break;
+        case XML_FROM_RELAXNGV:
+            channel(data, "Relax-NG validity ");
+            break;
+        case XML_FROM_CATALOG:
+            channel(data, "Catalog ");
+            break;
+        case XML_FROM_C14N:
+            channel(data, "C14N ");
+            break;
+        case XML_FROM_XSLT:
+            channel(data, "XSLT ");
+            break;
+        default:
+            break;
+    }
+    if (code == XML_ERR_OK)
+        return;
+    switch (level) {
+        case XML_ERR_NONE:
+            channel(data, ": ");
+            break;
+        case XML_ERR_WARNING:
+            channel(data, "warning : ");
+            break;
+        case XML_ERR_ERROR:
+            channel(data, "error : ");
+            break;
+        case XML_ERR_FATAL:
+            channel(data, "error : ");
+            break;
+    }
+    if (code == XML_ERR_OK)
+        return;
+    if (str != NULL) {
+        int len;
+	len = xmlStrlen((const xmlChar *)str);
+	if ((len > 0) && (str[len - 1] != '\n'))
+	    channel(data, "%s\n", str);
+	else
+	    channel(data, "%s", str);
+    } else {
+        channel(data, "%s\n", "out of memory error");
+    }
+    if (code == XML_ERR_OK)
+        return;
+
+    if (ctxt != NULL) {
+        xmlParserPrintFileContextInternal(input, channel, data);
+        if (cur != NULL) {
+            if (cur->filename)
+                channel(data, "%s:%d: \n", cur->filename, cur->line);
+            else if ((line != 0) && (domain == XML_FROM_PARSER))
+                channel(data, "Entity: line %d: \n", cur->line);
+            xmlParserPrintFileContextInternal(cur, channel, data);
+        }
+    }
+    if ((domain == XML_FROM_XPATH) && (err->str1 != NULL) &&
+        (err->int1 < 100) &&
+	(err->int1 < xmlStrlen((const xmlChar *)err->str1))) {
+	xmlChar buf[150];
+	int i;
+
+	channel(data, "%s\n", err->str1);
+	for (i=0;i < err->int1;i++)
+	     buf[i] = ' ';
+	buf[i++] = '^';
+	buf[i] = 0;
+	channel(data, "%s\n", buf);
+    }
+}
+
+/**
+ * __xmlRaiseError:
+ * @channel: the structured callback channel
+ * @channel: the old callback channel
+ * @data: the callback data
+ * @ctx: the parser context or NULL
+ * @ctx: the parser context or NULL
+ * @domain: the domain for the error
+ * @code: the code for the error
+ * @level: the xmlErrorLevel for the error
+ * @file: the file source of the error (or NULL)
+ * @line: the line of the error or 0 if N/A
+ * @str1: extra string info
+ * @str2: extra string info
+ * @str3: extra string info
+ * @int1: extra int info
+ * @int2: extra int info
+ * @msg:  the message to display/transmit
+ * @...:  extra parameters for the message display
+ *
+ * Update teh appropriate global or contextual error structure,
+ * then forward the error message down the parser or generic
+ * error callback handler
+ */
+void
+__xmlRaiseError(xmlStructuredErrorFunc schannel,
+              xmlGenericErrorFunc channel, void *data, void *ctx,
+              void *nod, int domain, int code, xmlErrorLevel level,
+              const char *file, int line, const char *str1,
+              const char *str2, const char *str3, int int1, int int2,
+	      const char *msg, ...)
+{
+    xmlParserCtxtPtr ctxt = NULL;
+    xmlNodePtr node = (xmlNodePtr) nod;
+    char *str = NULL;
+    xmlParserInputPtr input = NULL;
+    xmlErrorPtr to = &xmlLastError;
+    xmlChar *base = NULL;
+
+    if ((xmlGetWarningsDefaultValue == 0) && (level == XML_ERR_WARNING))
+        return;
+    if ((domain == XML_FROM_PARSER) || (domain == XML_FROM_HTML) ||
+        (domain == XML_FROM_DTD) || (domain == XML_FROM_NAMESPACE) ||
+	(domain == XML_FROM_IO)) {
+	ctxt = (xmlParserCtxtPtr) ctx;
+	if ((schannel == NULL) && (ctxt != NULL) && (ctxt->sax != NULL) &&
+	    (ctxt->sax->initialized == XML_SAX2_MAGIC))
+	    schannel = ctxt->sax->serror;
+    }
+    if (schannel == NULL)
+	schannel = xmlStructuredError;
+    if ((domain == XML_FROM_VALID) &&
+        ((channel == xmlParserValidityError) ||
+	 (channel == xmlParserValidityWarning))) {
+	ctxt = (xmlParserCtxtPtr) ctx;
+	if ((schannel == NULL) && (ctxt != NULL) && (ctxt->sax != NULL) &&
+	    (ctxt->sax->initialized == XML_SAX2_MAGIC))
+	    schannel = ctxt->sax->serror;
+    }
+    if (code == XML_ERR_OK)
+        return;
+    /*
+     * Formatting the message
+     */
+    if (msg == NULL) {
+        str = (char *) xmlStrdup(BAD_CAST "No error message provided");
+    } else {
+        XML_GET_VAR_STR(msg, str);
+    }
+
+    /*
+     * specific processing if a parser context is provided
+     */
+    if (ctxt != NULL) {
+        if (file == NULL) {
+            input = ctxt->input;
+            if ((input != NULL) && (input->filename == NULL) &&
+                (ctxt->inputNr > 1)) {
+                input = ctxt->inputTab[ctxt->inputNr - 2];
+            }
+            if (input != NULL) {
+                file = input->filename;
+                line = input->line;
+            }
+        }
+        to = &ctxt->lastError;
+    } else if ((node != NULL) && (file == NULL)) {
+	int i;
+
+	if ((node->doc != NULL) && (node->doc->URL != NULL))
+	    base = xmlStrdup(node->doc->URL);
+	for (i = 0;
+	     ((i < 10) && (node != NULL) && (node->type != XML_ELEMENT_NODE));
+	     i++)
+	     node = node->parent;
+        if ((base == NULL) && (node != NULL) &&
+	    (node->doc != NULL) && (node->doc->URL != NULL))
+	    base = xmlStrdup(node->doc->URL);
+
+	if ((node != NULL) && (node->type == XML_ELEMENT_NODE))
+	    line = node->line;
+    }
+
+    /*
+     * Save the informations about the error
+     */
+    xmlResetError(to);
+    to->domain = domain;
+    to->code = code;
+    to->message = str;
+    to->level = level;
+    if (file != NULL)
+        to->file = (char *) xmlStrdup((const xmlChar *) file);
+    else if (base != NULL) {
+        to->file = (char *) base;
+	file = (char *) base;
+    }
+    to->line = line;
+    if (str1 != NULL)
+        to->str1 = (char *) xmlStrdup((const xmlChar *) str1);
+    if (str2 != NULL)
+        to->str2 = (char *) xmlStrdup((const xmlChar *) str2);
+    if (str3 != NULL)
+        to->str3 = (char *) xmlStrdup((const xmlChar *) str3);
+    to->int1 = int1;
+    to->int2 = int2;
+    to->node = node;
+    to->ctxt = ctx;
+
+    if (to != &xmlLastError)
+        xmlCopyError(to,&xmlLastError);
+
+    /*
+     * Find the callback channel.
+     */
+    if ((ctxt != NULL) && (channel == NULL)) {
+        if (level == XML_ERR_WARNING)
+	    channel = ctxt->sax->warning;
+        else
+	    channel = ctxt->sax->error;
+	data = ctxt->userData;
+    } else if (channel == NULL) {
+        if (xmlStructuredError != NULL)
+	    schannel = xmlStructuredError;
+	else
+	    channel = xmlGenericError;
+	data = xmlGenericErrorContext;
+    }
+    if (schannel != NULL) {
+        schannel(data, to);
+	return;
+    }
+    if (channel == NULL)
+        return;
+
+    if ((channel == xmlParserError) ||
+        (channel == xmlParserWarning) ||
+	(channel == xmlParserValidityError) ||
+	(channel == xmlParserValidityWarning))
+	xmlReportError(to, ctxt, str, NULL, NULL);
+    else if ((channel == (xmlGenericErrorFunc) fprintf) ||
+             (channel == xmlGenericErrorDefaultFunc))
+	xmlReportError(to, ctxt, str, channel, data);
+    else
+	channel(data, "%s", str);
+}
+
+/**
+ * __xmlSimpleError:
+ * @domain: where the error comes from
+ * @code: the error code
+ * @node: the context node
+ * @extra:  extra informations
+ *
+ * Handle an out of memory condition
+ */
+void
+__xmlSimpleError(int domain, int code, xmlNodePtr node,
+                 const char *msg, const char *extra)
+{
+
+    if (code == XML_ERR_NO_MEMORY) {
+	if (extra)
+	    __xmlRaiseError(NULL, NULL, NULL, NULL, node, domain,
+			    XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0, extra,
+			    NULL, NULL, 0, 0,
+			    "Memory allocation failed : %s\n", extra);
+	else
+	    __xmlRaiseError(NULL, NULL, NULL, NULL, node, domain,
+			    XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0, NULL,
+			    NULL, NULL, 0, 0, "Memory allocation failed\n");
+    } else {
+	__xmlRaiseError(NULL, NULL, NULL, NULL, node, domain,
+			code, XML_ERR_ERROR, NULL, 0, extra,
+			NULL, NULL, 0, 0, msg, extra);
+    }
+}
+/**
+ * xmlParserError:
+ * @ctx:  an XML parser context
+ * @msg:  the message to display/transmit
+ * @...:  extra parameters for the message display
+ * 
+ * Display and format an error messages, gives file, line, position and
+ * extra parameters.
+ */
+void
+xmlParserError(void *ctx, const char *msg, ...)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+    xmlParserInputPtr input = NULL;
+    xmlParserInputPtr cur = NULL;
+    char * str;
+
+    if (ctxt != NULL) {
+	input = ctxt->input;
+	if ((input != NULL) && (input->filename == NULL) &&
+	    (ctxt->inputNr > 1)) {
+	    cur = input;
+	    input = ctxt->inputTab[ctxt->inputNr - 2];
+	}
+	xmlParserPrintFileInfo(input);
+    }
+
+    xmlGenericError(xmlGenericErrorContext, "error: ");
+    XML_GET_VAR_STR(msg, str);
+    xmlGenericError(xmlGenericErrorContext, "%s", str);
+    if (str != NULL)
+	xmlFree(str);
+
+    if (ctxt != NULL) {
+	xmlParserPrintFileContext(input);
+	if (cur != NULL) {
+	    xmlParserPrintFileInfo(cur);
+	    xmlGenericError(xmlGenericErrorContext, "\n");
+	    xmlParserPrintFileContext(cur);
+	}
+    }
+}
+
+/**
+ * xmlParserWarning:
+ * @ctx:  an XML parser context
+ * @msg:  the message to display/transmit
+ * @...:  extra parameters for the message display
+ * 
+ * Display and format a warning messages, gives file, line, position and
+ * extra parameters.
+ */
+void
+xmlParserWarning(void *ctx, const char *msg, ...)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+    xmlParserInputPtr input = NULL;
+    xmlParserInputPtr cur = NULL;
+    char * str;
+
+    if (ctxt != NULL) {
+	input = ctxt->input;
+	if ((input != NULL) && (input->filename == NULL) &&
+	    (ctxt->inputNr > 1)) {
+	    cur = input;
+	    input = ctxt->inputTab[ctxt->inputNr - 2];
+	}
+	xmlParserPrintFileInfo(input);
+    }
+        
+    xmlGenericError(xmlGenericErrorContext, "warning: ");
+    XML_GET_VAR_STR(msg, str);
+    xmlGenericError(xmlGenericErrorContext, "%s", str);
+    if (str != NULL)
+	xmlFree(str);
+
+    if (ctxt != NULL) {
+	xmlParserPrintFileContext(input);
+	if (cur != NULL) {
+	    xmlParserPrintFileInfo(cur);
+	    xmlGenericError(xmlGenericErrorContext, "\n");
+	    xmlParserPrintFileContext(cur);
+	}
+    }
+}
+
+/************************************************************************
+ * 									*
+ * 			Handling of validation errors			*
+ * 									*
+ ************************************************************************/
+
+/**
+ * xmlParserValidityError:
+ * @ctx:  an XML parser context
+ * @msg:  the message to display/transmit
+ * @...:  extra parameters for the message display
+ * 
+ * Display and format an validity error messages, gives file,
+ * line, position and extra parameters.
+ */
+void
+xmlParserValidityError(void *ctx, const char *msg, ...)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+    xmlParserInputPtr input = NULL;
+    char * str;
+    int len = xmlStrlen((const xmlChar *) msg);
+    static int had_info = 0;
+
+    if ((len > 1) && (msg[len - 2] != ':')) {
+	if (ctxt != NULL) {
+	    input = ctxt->input;
+	    if ((input->filename == NULL) && (ctxt->inputNr > 1))
+		input = ctxt->inputTab[ctxt->inputNr - 2];
+		
+	    if (had_info == 0) {
+		xmlParserPrintFileInfo(input);
+	    }
+	}
+	xmlGenericError(xmlGenericErrorContext, "validity error: ");
+	had_info = 0;
+    } else {
+	had_info = 1;
+    }
+
+    XML_GET_VAR_STR(msg, str);
+    xmlGenericError(xmlGenericErrorContext, "%s", str);
+    if (str != NULL)
+	xmlFree(str);
+
+    if ((ctxt != NULL) && (input != NULL)) {
+	xmlParserPrintFileContext(input);
+    }
+}
+
+/**
+ * xmlParserValidityWarning:
+ * @ctx:  an XML parser context
+ * @msg:  the message to display/transmit
+ * @...:  extra parameters for the message display
+ * 
+ * Display and format a validity warning messages, gives file, line,
+ * position and extra parameters.
+ */
+void
+xmlParserValidityWarning(void *ctx, const char *msg, ...)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+    xmlParserInputPtr input = NULL;
+    char * str;
+    int len = xmlStrlen((const xmlChar *) msg);
+
+    if ((ctxt != NULL) && (len != 0) && (msg[len - 1] != ':')) {
+	input = ctxt->input;
+	if ((input->filename == NULL) && (ctxt->inputNr > 1))
+	    input = ctxt->inputTab[ctxt->inputNr - 2];
+
+	xmlParserPrintFileInfo(input);
+    }
+        
+    xmlGenericError(xmlGenericErrorContext, "validity warning: ");
+    XML_GET_VAR_STR(msg, str);
+    xmlGenericError(xmlGenericErrorContext, "%s", str);
+    if (str != NULL)
+	xmlFree(str);
+
+    if (ctxt != NULL) {
+	xmlParserPrintFileContext(input);
+    }
+}
+
+
+/************************************************************************
+ *									*
+ *			Extended Error Handling				*
+ *									*
+ ************************************************************************/
+
+/**
+ * xmlGetLastError:
+ *
+ * Get the last global error registered. This is per thread if compiled
+ * with thread support.
+ *
+ * Returns NULL if no error occured or a pointer to the error
+ */
+xmlErrorPtr
+xmlGetLastError(void)
+{
+    if (xmlLastError.code == XML_ERR_OK)
+        return (NULL);
+    return (&xmlLastError);
+}
+
+/**
+ * xmlResetError:
+ * @err: pointer to the error.
+ *
+ * Cleanup the error.
+ */
+void
+xmlResetError(xmlErrorPtr err)
+{
+    if (err == NULL)
+        return;
+    if (err->code == XML_ERR_OK)
+        return;
+    if (err->message != NULL)
+        xmlFree(err->message);
+    if (err->file != NULL)
+        xmlFree(err->file);
+    if (err->str1 != NULL)
+        xmlFree(err->str1);
+    if (err->str2 != NULL)
+        xmlFree(err->str2);
+    if (err->str3 != NULL)
+        xmlFree(err->str3);
+    memset(err, 0, sizeof(xmlError));
+    err->code = XML_ERR_OK;
+}
+
+/**
+ * xmlResetLastError:
+ *
+ * Cleanup the last global error registered. For parsing error
+ * this does not change the well-formedness result.
+ */
+void
+xmlResetLastError(void)
+{
+    if (xmlLastError.code == XML_ERR_OK)
+        return;
+    xmlResetError(&xmlLastError);
+}
+
+/**
+ * xmlCtxtGetLastError:
+ * @ctx:  an XML parser context
+ *
+ * Get the last parsing error registered.
+ *
+ * Returns NULL if no error occured or a pointer to the error
+ */
+xmlErrorPtr
+xmlCtxtGetLastError(void *ctx)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+
+    if (ctxt == NULL)
+        return (NULL);
+    if (ctxt->lastError.code == XML_ERR_OK)
+        return (NULL);
+    return (&ctxt->lastError);
+}
+
+/**
+ * xmlCtxtResetLastError:
+ * @ctx:  an XML parser context
+ *
+ * Cleanup the last global error registered. For parsing error
+ * this does not change the well-formedness result.
+ */
+void
+xmlCtxtResetLastError(void *ctx)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+
+    if (ctxt == NULL)
+        return;
+    if (ctxt->lastError.code == XML_ERR_OK)
+        return;
+    xmlResetError(&ctxt->lastError);
+}
+
+/**
+ * xmlCopyError:
+ * @from:  a source error
+ * @to:  a target error
+ *
+ * Save the original error to the new place.
+ *
+ * Returns 0 in case of success and -1 in case of error.
+ */
+int
+xmlCopyError(xmlErrorPtr from, xmlErrorPtr to) {
+    if ((from == NULL) || (to == NULL))
+        return(-1);
+    if (to->message != NULL)
+        xmlFree(to->message);
+    if (to->file != NULL)
+        xmlFree(to->file);
+    if (to->str1 != NULL)
+        xmlFree(to->str1);
+    if (to->str2 != NULL)
+        xmlFree(to->str2);
+    if (to->str3 != NULL)
+        xmlFree(to->str3);
+    to->domain = from->domain;
+    to->code = from->code;
+    to->level = from->level;
+    to->line = from->line;
+    to->node = from->node;
+    to->int1 = from->int1;
+    to->int2 = from->int2;
+    to->node = from->node;
+    to->ctxt = from->ctxt;
+    if (from->message != NULL)
+        to->message = (char *) xmlStrdup((xmlChar *) from->message);
+    else
+        to->message = NULL;
+    if (from->file != NULL)
+        to->file = (char *) xmlStrdup((xmlChar *) from->file);
+    else
+        to->file = NULL;
+    if (from->str1 != NULL)
+        to->str1 = (char *) xmlStrdup((xmlChar *) from->str1);
+    else
+        to->str1 = NULL;
+    if (from->str2 != NULL)
+        to->str2 = (char *) xmlStrdup((xmlChar *) from->str2);
+    else
+        to->str2 = NULL;
+    if (from->str3 != NULL)
+        to->str3 = (char *) xmlStrdup((xmlChar *) from->str3);
+    else
+        to->str3 = NULL;
+    return(0);
+}
+
diff --git a/src/libxml/src/globals.c b/src/libxml/src/globals.c
new file mode 100644
index 0000000..f1aa150
--- /dev/null
+++ b/src/libxml/src/globals.c
@@ -0,0 +1,983 @@
+/*
+ * globals.c: definition and handling of the set of global variables
+ *            of the library
+ *
+ * The bottom of this file is automatically generated by build_glob.py
+ * based on the description file global.data
+ *
+ * See Copyright for the status of this software.
+ *
+ * Gary Pennington <Gary.Pennington@uk.sun.com>
+ * daniel@veillard.com
+ */
+
+#define IN_LIBXML
+#include "libxml.h"
+
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+#include <string.h>
+
+#include <libxml/globals.h>
+#include <libxml/xmlmemory.h>
+#include <libxml/threads.h>
+
+/* #define DEBUG_GLOBALS */
+
+/*
+ * Helpful Macro
+ */
+#ifdef LIBXML_THREAD_ENABLED
+#define IS_MAIN_THREAD (xmlIsMainThread())
+#else
+#define IS_MAIN_THREAD 1
+#endif
+
+/*
+ * Mutex to protect "ForNewThreads" variables
+ */
+static xmlMutexPtr xmlThrDefMutex = NULL;
+
+/**
+ * xmlInitGlobals:
+ *
+ * Additional initialisation for multi-threading
+ */
+void xmlInitGlobals()
+{
+    xmlThrDefMutex = xmlNewMutex();
+}
+
+/**
+ * xmlCleanupGlobals:
+ *
+ * Additional cleanup for multi-threading
+ */
+void xmlCleanupGlobals()
+{
+    if (xmlThrDefMutex != NULL) {
+	xmlFreeMutex(xmlThrDefMutex);
+	xmlThrDefMutex = NULL;
+    }
+}
+
+/************************************************************************
+ * 									*
+ *	All the user accessible global variables of the library		*
+ * 									*
+ ************************************************************************/
+
+/*
+ * Memory allocation routines
+ */
+#if defined(DEBUG_MEMORY_LOCATION) || defined(DEBUG_MEMORY)
+#ifndef __DEBUG_MEMORY_ALLOC__
+extern void xmlMemFree(void *ptr);
+extern void * xmlMemMalloc(size_t size);
+extern void * xmlMemRealloc(void *ptr,size_t size);
+extern char * xmlMemoryStrdup(const char *str);
+#endif
+
+xmlFreeFunc xmlFree = (xmlFreeFunc) xmlMemFree;
+xmlMallocFunc xmlMalloc = (xmlMallocFunc) xmlMemMalloc;
+xmlMallocFunc xmlMallocAtomic = (xmlMallocFunc) xmlMemMalloc;
+xmlReallocFunc xmlRealloc = (xmlReallocFunc) xmlMemRealloc;
+xmlStrdupFunc xmlMemStrdup = (xmlStrdupFunc) xmlMemoryStrdup;
+#else
+/**
+ * xmlFree:
+ * @mem: an already allocated block of memory
+ *
+ * The variable holding the libxml free() implementation
+ */
+xmlFreeFunc xmlFree = (xmlFreeFunc) free;
+/**
+ * xmlMalloc:
+ * @size:  the size requested in bytes
+ *
+ * The variable holding the libxml malloc() implementation
+ *
+ * Returns a pointer to the newly allocated block or NULL in case of error
+ */
+xmlMallocFunc xmlMalloc = (xmlMallocFunc) malloc;
+/**
+ * xmlMallocAtomic:
+ * @size:  the size requested in bytes
+ *
+ * The variable holding the libxml malloc() implementation for atomic
+ * data (i.e. blocks not containings pointers), useful when using a
+ * garbage collecting allocator.
+ *
+ * Returns a pointer to the newly allocated block or NULL in case of error
+ */
+xmlMallocFunc xmlMallocAtomic = (xmlMallocFunc) malloc;
+/**
+ * xmlRealloc:
+ * @mem: an already allocated block of memory
+ * @size:  the new size requested in bytes
+ *
+ * The variable holding the libxml realloc() implementation
+ *
+ * Returns a pointer to the newly reallocated block or NULL in case of error
+ */
+xmlReallocFunc xmlRealloc = (xmlReallocFunc) realloc;
+/**
+ * xmlMemStrdup:
+ * @str: a zero terminated string
+ *
+ * The variable holding the libxml strdup() implementation
+ *
+ * Returns the copy of the string or NULL in case of error
+ */
+xmlStrdupFunc xmlMemStrdup = (xmlStrdupFunc) xmlStrdup;
+#endif /* DEBUG_MEMORY_LOCATION || DEBUG_MEMORY */
+
+#include <libxml/threads.h>
+#include <libxml/globals.h>
+#include <libxml/SAX.h>
+
+#undef	docbDefaultSAXHandler
+#undef	htmlDefaultSAXHandler
+#undef	oldXMLWDcompatibility
+#undef	xmlBufferAllocScheme
+#undef	xmlDefaultBufferSize
+#undef	xmlDefaultSAXHandler
+#undef	xmlDefaultSAXLocator
+#undef	xmlDoValidityCheckingDefaultValue
+#undef	xmlGenericError
+#undef	xmlStructuredError
+#undef	xmlGenericErrorContext
+#undef	xmlGetWarningsDefaultValue
+#undef	xmlIndentTreeOutput
+#undef  xmlTreeIndentString
+#undef	xmlKeepBlanksDefaultValue
+#undef	xmlLineNumbersDefaultValue
+#undef	xmlLoadExtDtdDefaultValue
+#undef	xmlParserDebugEntities
+#undef	xmlParserVersion
+#undef	xmlPedanticParserDefaultValue
+#undef	xmlSaveNoEmptyTags
+#undef	xmlSubstituteEntitiesDefaultValue
+#undef	xmlRegisterNodeDefaultValue
+#undef	xmlDeregisterNodeDefaultValue
+#undef	xmlLastError
+
+#undef	xmlFree
+#undef	xmlMalloc
+#undef	xmlMallocAtomic
+#undef	xmlMemStrdup
+#undef	xmlRealloc
+
+/**
+ * xmlParserVersion:
+ *
+ * Constant string describing the internal version of the library
+ */
+const char *xmlParserVersion = LIBXML_VERSION_STRING;
+
+/**
+ * xmlBufferAllocScheme:
+ *
+ * Global setting, default allocation policy for buffers, default is
+ * XML_BUFFER_ALLOC_EXACT
+ */
+xmlBufferAllocationScheme xmlBufferAllocScheme = XML_BUFFER_ALLOC_EXACT;
+static xmlBufferAllocationScheme xmlBufferAllocSchemeThrDef = XML_BUFFER_ALLOC_EXACT;
+/**
+ * xmlDefaultBufferSize:
+ *
+ * Global setting, default buffer size. Default value is BASE_BUFFER_SIZE
+ */
+int xmlDefaultBufferSize = BASE_BUFFER_SIZE;
+static int xmlDefaultBufferSizeThrDef = BASE_BUFFER_SIZE;
+
+/*
+ * Parser defaults
+ */
+
+/**
+ * oldXMLWDcompatibility:
+ *
+ * Global setting, DEPRECATED.
+ */
+int oldXMLWDcompatibility = 0; /* DEPRECATED */
+/**
+ * xmlParserDebugEntities:
+ *
+ * Global setting, asking the parser to print out debugging informations.
+ * while handling entities.
+ * Disabled by default
+ */
+int xmlParserDebugEntities = 0;
+static int xmlParserDebugEntitiesThrDef = 0;
+/**
+ * xmlDoValidityCheckingDefaultValue:
+ *
+ * Global setting, indicate that the parser should work in validating mode.
+ * Disabled by default.
+ */
+int xmlDoValidityCheckingDefaultValue = 0;
+static int xmlDoValidityCheckingDefaultValueThrDef = 0;
+/**
+ * xmlGetWarningsDefaultValue:
+ *
+ * Global setting, indicate that the parser should provide warnings.
+ * Activated by default.
+ */
+int xmlGetWarningsDefaultValue = 1;
+static int xmlGetWarningsDefaultValueThrDef = 1;
+/**
+ * xmlLoadExtDtdDefaultValue:
+ *
+ * Global setting, indicate that the parser should load DTD while not
+ * validating.
+ * Disabled by default.
+ */
+int xmlLoadExtDtdDefaultValue = 0;
+static int xmlLoadExtDtdDefaultValueThrDef = 0;
+/**
+ * xmlPedanticParserDefaultValue:
+ *
+ * Global setting, indicate that the parser be pedantic
+ * Disabled by default.
+ */
+int xmlPedanticParserDefaultValue = 0;
+static int xmlPedanticParserDefaultValueThrDef = 0;
+/**
+ * xmlLineNumbersDefaultValue:
+ *
+ * Global setting, indicate that the parser should store the line number
+ * in the content field of elements in the DOM tree. 
+ * Disabled by default since this may not be safe for old classes of
+ * applicaton.
+ */
+int xmlLineNumbersDefaultValue = 0;
+static int xmlLineNumbersDefaultValueThrDef = 0;
+/**
+ * xmlKeepBlanksDefaultValue:
+ *
+ * Global setting, indicate that the parser should keep all blanks
+ * nodes found in the content
+ * Activated by default, this is actually needed to have the parser
+ * conformant to the XML Recommendation, however the option is kept
+ * for some applications since this was libxml1 default behaviour.
+ */
+int xmlKeepBlanksDefaultValue = 1;
+static int xmlKeepBlanksDefaultValueThrDef = 1;
+/**
+ * xmlSubstituteEntitiesDefaultValue:
+ *
+ * Global setting, indicate that the parser should not generate entity
+ * references but replace them with the actual content of the entity
+ * Disabled by default, this should be activated when using XPath since
+ * the XPath data model requires entities replacement and the XPath
+ * engine does not handle entities references transparently.
+ */
+int xmlSubstituteEntitiesDefaultValue = 0;
+static int xmlSubstituteEntitiesDefaultValueThrDef = 0;
+
+xmlRegisterNodeFunc xmlRegisterNodeDefaultValue = NULL;
+static xmlRegisterNodeFunc xmlRegisterNodeDefaultValueThrDef = NULL;
+xmlDeregisterNodeFunc xmlDeregisterNodeDefaultValue = NULL;
+static xmlDeregisterNodeFunc xmlDeregisterNodeDefaultValueThrDef = NULL;
+
+/*
+ * Error handling
+ */
+
+/* xmlGenericErrorFunc xmlGenericError = xmlGenericErrorDefaultFunc; */
+/* Must initialize xmlGenericError in xmlInitParser */
+void xmlGenericErrorDefaultFunc	(void *ctx ATTRIBUTE_UNUSED,
+				 const char *msg,
+				 ...);
+/**
+ * xmlGenericError:
+ *
+ * Global setting: function used for generic error callbacks
+ */
+xmlGenericErrorFunc xmlGenericError = xmlGenericErrorDefaultFunc;
+static xmlGenericErrorFunc xmlGenericErrorThrDef = xmlGenericErrorDefaultFunc;
+/**
+ * xmlStructuredError:
+ *
+ * Global setting: function used for structured error callbacks
+ */
+xmlStructuredErrorFunc xmlStructuredError = NULL;
+static xmlStructuredErrorFunc xmlStructuredErrorThrDef = NULL;
+/**
+ * xmlGenericErrorContext:
+ *
+ * Global setting passed to generic error callbacks
+ */
+void *xmlGenericErrorContext = NULL;
+static void *xmlGenericErrorContextThrDef = NULL;
+xmlError xmlLastError;
+
+/*
+ * output defaults
+ */
+/**
+ * xmlIndentTreeOutput:
+ *
+ * Global setting, asking the serializer to indent the output tree by default
+ * Enabled by default
+ */
+int xmlIndentTreeOutput = 1;
+static int xmlIndentTreeOutputThrDef = 1;
+
+/**
+ * xmlTreeIndentString:
+ *
+ * The string used to do one-level indent. By default is equal to "  " (two spaces)
+ */
+const char *xmlTreeIndentString = "  ";
+static const char *xmlTreeIndentStringThrDef = "  ";
+
+/**
+ * xmlSaveNoEmptyTags:
+ *
+ * Global setting, asking the serializer to not output empty tags
+ * as <empty/> but <empty></empty>. those two forms are undistinguishable
+ * once parsed.
+ * Disabled by default
+ */
+int xmlSaveNoEmptyTags = 0;
+int xmlSaveNoEmptyTagsThrDef = 0;
+
+#ifdef LIBXML_SAX1_ENABLED
+/**
+ * xmlDefaultSAXHandler:
+ *
+ * Default SAX version1 handler for XML, builds the DOM tree
+ */
+xmlSAXHandlerV1 xmlDefaultSAXHandler = {
+    xmlSAX2InternalSubset,
+    xmlSAX2IsStandalone,
+    xmlSAX2HasInternalSubset,
+    xmlSAX2HasExternalSubset,
+    xmlSAX2ResolveEntity,
+    xmlSAX2GetEntity,
+    xmlSAX2EntityDecl,
+    xmlSAX2NotationDecl,
+    xmlSAX2AttributeDecl,
+    xmlSAX2ElementDecl,
+    xmlSAX2UnparsedEntityDecl,
+    xmlSAX2SetDocumentLocator,
+    xmlSAX2StartDocument,
+    xmlSAX2EndDocument,
+    xmlSAX2StartElement,
+    xmlSAX2EndElement,
+    xmlSAX2Reference,
+    xmlSAX2Characters,
+    xmlSAX2Characters,
+    xmlSAX2ProcessingInstruction,
+    xmlSAX2Comment,
+    xmlParserWarning,
+    xmlParserError,
+    xmlParserError,
+    xmlSAX2GetParameterEntity,
+    xmlSAX2CDataBlock,
+    xmlSAX2ExternalSubset,
+    0,
+};
+#endif /* LIBXML_SAX1_ENABLED */
+
+/**
+ * xmlDefaultSAXLocator:
+ *
+ * The default SAX Locator
+ * { getPublicId, getSystemId, getLineNumber, getColumnNumber}
+ */
+xmlSAXLocator xmlDefaultSAXLocator = {
+    xmlSAX2GetPublicId,
+    xmlSAX2GetSystemId,
+    xmlSAX2GetLineNumber,
+    xmlSAX2GetColumnNumber
+};
+
+#ifdef LIBXML_HTML_ENABLED
+/**
+ * htmlDefaultSAXHandler:
+ *
+ * Default old SAX v1 handler for HTML, builds the DOM tree
+ */
+xmlSAXHandlerV1 htmlDefaultSAXHandler = {
+    xmlSAX2InternalSubset,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    xmlSAX2GetEntity,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    xmlSAX2SetDocumentLocator,
+    xmlSAX2StartDocument,
+    xmlSAX2EndDocument,
+    xmlSAX2StartElement,
+    xmlSAX2EndElement,
+    NULL,
+    xmlSAX2Characters,
+    xmlSAX2IgnorableWhitespace,
+    NULL,
+    xmlSAX2Comment,
+    xmlParserWarning,
+    xmlParserError,
+    xmlParserError,
+    xmlSAX2GetParameterEntity,
+    xmlSAX2CDataBlock,
+    NULL,
+    0,
+};
+#endif /* LIBXML_HTML_ENABLED */
+
+#ifdef LIBXML_DOCB_ENABLED
+/**
+ * docbDefaultSAXHandler:
+ *
+ * Default old SAX v1 handler for SGML DocBook, builds the DOM tree
+ */
+xmlSAXHandlerV1 docbDefaultSAXHandler = {
+    xmlSAX2InternalSubset,
+    xmlSAX2IsStandalone,
+    xmlSAX2HasInternalSubset,
+    xmlSAX2HasExternalSubset,
+    xmlSAX2ResolveEntity,
+    xmlSAX2GetEntity,
+    xmlSAX2EntityDecl,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    xmlSAX2SetDocumentLocator,
+    xmlSAX2StartDocument,
+    xmlSAX2EndDocument,
+    xmlSAX2StartElement,
+    xmlSAX2EndElement,
+    xmlSAX2Reference,
+    xmlSAX2Characters,
+    xmlSAX2IgnorableWhitespace,
+    NULL,
+    xmlSAX2Comment,
+    xmlParserWarning,
+    xmlParserError,
+    xmlParserError,
+    xmlSAX2GetParameterEntity,
+    NULL,
+    NULL,
+    0,
+};
+#endif /* LIBXML_DOCB_ENABLED */
+
+/**
+ * xmlInitializeGlobalState:
+ * @gs: a pointer to a newly allocated global state
+ *
+ * xmlInitializeGlobalState() initialize a global state with all the
+ * default values of the library.
+ */
+void
+xmlInitializeGlobalState(xmlGlobalStatePtr gs)
+{
+#ifdef DEBUG_GLOBALS
+    fprintf(stderr, "Initializing globals at %lu for thread %d\n",
+	    (unsigned long) gs, xmlGetThreadId());
+#endif
+
+    /*
+     * Perform initialization as required by libxml
+     */
+    if (xmlThrDefMutex == NULL)
+        xmlInitGlobals();
+
+    xmlMutexLock(xmlThrDefMutex);
+
+#ifdef LIBXML_DOCB_ENABLED
+    initdocbDefaultSAXHandler(&gs->docbDefaultSAXHandler);
+#endif
+#ifdef LIBXML_HTML_ENABLED
+    inithtmlDefaultSAXHandler(&gs->htmlDefaultSAXHandler);
+#endif
+
+    gs->oldXMLWDcompatibility = 0;
+    gs->xmlBufferAllocScheme = xmlBufferAllocSchemeThrDef;
+    gs->xmlDefaultBufferSize = xmlDefaultBufferSizeThrDef;
+#ifdef LIBXML_SAX1_ENABLED
+    initxmlDefaultSAXHandler(&gs->xmlDefaultSAXHandler, 1);
+#endif /* LIBXML_SAX1_ENABLED */
+    gs->xmlDefaultSAXLocator.getPublicId = xmlSAX2GetPublicId;
+    gs->xmlDefaultSAXLocator.getSystemId = xmlSAX2GetSystemId;
+    gs->xmlDefaultSAXLocator.getLineNumber = xmlSAX2GetLineNumber;
+    gs->xmlDefaultSAXLocator.getColumnNumber = xmlSAX2GetColumnNumber;
+    gs->xmlDoValidityCheckingDefaultValue = 
+         xmlDoValidityCheckingDefaultValueThrDef;
+#if defined(DEBUG_MEMORY_LOCATION) | defined(DEBUG_MEMORY)
+    gs->xmlFree = (xmlFreeFunc) xmlMemFree;
+    gs->xmlMalloc = (xmlMallocFunc) xmlMemMalloc;
+    gs->xmlMallocAtomic = (xmlMallocFunc) xmlMemMalloc;
+    gs->xmlRealloc = (xmlReallocFunc) xmlMemRealloc;
+    gs->xmlMemStrdup = (xmlStrdupFunc) xmlMemoryStrdup;
+#else
+    gs->xmlFree = (xmlFreeFunc) free;
+    gs->xmlMalloc = (xmlMallocFunc) malloc;
+    gs->xmlMallocAtomic = (xmlMallocFunc) malloc;
+    gs->xmlRealloc = (xmlReallocFunc) realloc;
+    gs->xmlMemStrdup = (xmlStrdupFunc) xmlStrdup;
+#endif
+    gs->xmlGetWarningsDefaultValue = xmlGetWarningsDefaultValueThrDef;
+    gs->xmlIndentTreeOutput = xmlIndentTreeOutputThrDef;
+    gs->xmlTreeIndentString = xmlTreeIndentStringThrDef;
+    gs->xmlKeepBlanksDefaultValue = xmlKeepBlanksDefaultValueThrDef;
+    gs->xmlLineNumbersDefaultValue = xmlLineNumbersDefaultValueThrDef;
+    gs->xmlLoadExtDtdDefaultValue = xmlLoadExtDtdDefaultValueThrDef;
+    gs->xmlParserDebugEntities = xmlParserDebugEntitiesThrDef;
+    gs->xmlParserVersion = LIBXML_VERSION_STRING;
+    gs->xmlPedanticParserDefaultValue = xmlPedanticParserDefaultValueThrDef;
+    gs->xmlSaveNoEmptyTags = xmlSaveNoEmptyTagsThrDef;
+    gs->xmlSubstituteEntitiesDefaultValue = 
+        xmlSubstituteEntitiesDefaultValueThrDef;
+
+    gs->xmlGenericError = xmlGenericErrorThrDef;
+    gs->xmlStructuredError = xmlStructuredErrorThrDef;
+    gs->xmlGenericErrorContext = xmlGenericErrorContextThrDef;
+    gs->xmlRegisterNodeDefaultValue = xmlRegisterNodeDefaultValueThrDef;
+    gs->xmlDeregisterNodeDefaultValue = xmlDeregisterNodeDefaultValueThrDef;
+    memset(&gs->xmlLastError, 0, sizeof(xmlError));
+
+    xmlMutexUnlock(xmlThrDefMutex);
+}
+
+/**
+ * DOC_DISABLE : we ignore missing doc for the xmlThrDef functions,
+ *               those are really internal work
+ */
+void
+xmlThrDefSetGenericErrorFunc(void *ctx, xmlGenericErrorFunc handler) {
+    xmlMutexLock(xmlThrDefMutex);
+    xmlGenericErrorContextThrDef = ctx;
+    if (handler != NULL)
+	xmlGenericErrorThrDef = handler;
+    else
+	xmlGenericErrorThrDef = xmlGenericErrorDefaultFunc;
+    xmlMutexUnlock(xmlThrDefMutex);
+}
+
+void
+xmlThrDefSetStructuredErrorFunc(void *ctx, xmlStructuredErrorFunc handler) {
+    xmlMutexLock(xmlThrDefMutex);
+    xmlGenericErrorContextThrDef = ctx;
+    xmlStructuredErrorThrDef = handler;
+    xmlMutexUnlock(xmlThrDefMutex);
+}
+
+/**
+ * xmlRegisterNodeDefault:
+ * @func: function pointer to the new RegisterNodeFunc
+ *
+ * Registers a callback for node creation
+ *
+ * Returns the old value of the registration function
+ */
+xmlRegisterNodeFunc
+xmlRegisterNodeDefault(xmlRegisterNodeFunc func)
+{
+    xmlRegisterNodeFunc old = xmlRegisterNodeDefaultValue;
+    
+    __xmlRegisterCallbacks = 1;
+    xmlRegisterNodeDefaultValue = func;
+    return(old);
+}
+
+xmlRegisterNodeFunc
+xmlThrDefRegisterNodeDefault(xmlRegisterNodeFunc func)
+{
+    xmlRegisterNodeFunc old;
+    
+    xmlMutexLock(xmlThrDefMutex);
+    old = xmlRegisterNodeDefaultValueThrDef;
+    
+    __xmlRegisterCallbacks = 1;
+    xmlRegisterNodeDefaultValueThrDef = func;
+    xmlMutexUnlock(xmlThrDefMutex);
+
+    return(old);
+}
+
+/**
+ * xmlDeregisterNodeDefault:
+ * @func: function pointer to the new DeregisterNodeFunc
+ *
+ * Registers a callback for node destruction
+ *
+ * Returns the previous value of the deregistration function
+ */
+xmlDeregisterNodeFunc
+xmlDeregisterNodeDefault(xmlDeregisterNodeFunc func)
+{
+    xmlDeregisterNodeFunc old = xmlDeregisterNodeDefaultValue;
+    
+    __xmlRegisterCallbacks = 1;
+    xmlDeregisterNodeDefaultValue = func;
+    return(old);
+}
+
+xmlDeregisterNodeFunc
+xmlThrDefDeregisterNodeDefault(xmlDeregisterNodeFunc func)
+{
+    xmlDeregisterNodeFunc old;
+
+    xmlMutexLock(xmlThrDefMutex);
+    old = xmlDeregisterNodeDefaultValueThrDef;
+    
+    __xmlRegisterCallbacks = 1;
+    xmlDeregisterNodeDefaultValueThrDef = func;
+    xmlMutexUnlock(xmlThrDefMutex);
+
+    return(old);
+}
+
+
+#ifdef LIBXML_DOCB_ENABLED
+#undef	docbDefaultSAXHandler
+xmlSAXHandlerV1 *
+__docbDefaultSAXHandler(void) {
+    if (IS_MAIN_THREAD)
+	return (&docbDefaultSAXHandler);
+    else
+	return (&xmlGetGlobalState()->docbDefaultSAXHandler);
+}
+#endif
+
+#ifdef LIBXML_HTML_ENABLED
+#undef	htmlDefaultSAXHandler
+xmlSAXHandlerV1 *
+__htmlDefaultSAXHandler(void) {
+    if (IS_MAIN_THREAD)
+	return (&htmlDefaultSAXHandler);
+    else
+	return (&xmlGetGlobalState()->htmlDefaultSAXHandler);
+}
+#endif
+
+#undef xmlLastError
+xmlError *
+__xmlLastError(void) {
+    if (IS_MAIN_THREAD)
+	return (&xmlLastError);
+    else
+	return (&xmlGetGlobalState()->xmlLastError);
+}
+
+/*
+ * Everything starting from the line below is
+ * Automatically generated by build_glob.py.
+ * Do not modify the previous line.
+ */
+
+
+#undef	oldXMLWDcompatibility
+int *
+__oldXMLWDcompatibility(void) {
+    if (IS_MAIN_THREAD)
+	return (&oldXMLWDcompatibility);
+    else
+	return (&xmlGetGlobalState()->oldXMLWDcompatibility);
+}
+
+#undef	xmlBufferAllocScheme
+xmlBufferAllocationScheme *
+__xmlBufferAllocScheme(void) {
+    if (IS_MAIN_THREAD)
+	return (&xmlBufferAllocScheme);
+    else
+	return (&xmlGetGlobalState()->xmlBufferAllocScheme);
+}
+xmlBufferAllocationScheme xmlThrDefBufferAllocScheme(xmlBufferAllocationScheme v) {
+    xmlBufferAllocationScheme ret;
+    xmlMutexLock(xmlThrDefMutex);
+    ret = xmlBufferAllocSchemeThrDef;
+    xmlBufferAllocSchemeThrDef = v;
+    xmlMutexUnlock(xmlThrDefMutex);
+    return ret;
+}
+
+#undef	xmlDefaultBufferSize
+int *
+__xmlDefaultBufferSize(void) {
+    if (IS_MAIN_THREAD)
+	return (&xmlDefaultBufferSize);
+    else
+	return (&xmlGetGlobalState()->xmlDefaultBufferSize);
+}
+int xmlThrDefDefaultBufferSize(int v) {
+    int ret;
+    xmlMutexLock(xmlThrDefMutex);
+    ret = xmlDefaultBufferSizeThrDef;
+    xmlDefaultBufferSizeThrDef = v;
+    xmlMutexUnlock(xmlThrDefMutex);
+    return ret;
+}
+
+#ifdef LIBXML_SAX1_ENABLED
+#undef	xmlDefaultSAXHandler
+xmlSAXHandlerV1 *
+__xmlDefaultSAXHandler(void) {
+    if (IS_MAIN_THREAD)
+	return (&xmlDefaultSAXHandler);
+    else
+	return (&xmlGetGlobalState()->xmlDefaultSAXHandler);
+}
+#endif /* LIBXML_SAX1_ENABLED */
+
+#undef	xmlDefaultSAXLocator
+xmlSAXLocator *
+__xmlDefaultSAXLocator(void) {
+    if (IS_MAIN_THREAD)
+	return (&xmlDefaultSAXLocator);
+    else
+	return (&xmlGetGlobalState()->xmlDefaultSAXLocator);
+}
+
+#undef	xmlDoValidityCheckingDefaultValue
+int *
+__xmlDoValidityCheckingDefaultValue(void) {
+    if (IS_MAIN_THREAD)
+	return (&xmlDoValidityCheckingDefaultValue);
+    else
+	return (&xmlGetGlobalState()->xmlDoValidityCheckingDefaultValue);
+}
+int xmlThrDefDoValidityCheckingDefaultValue(int v) {
+    int ret;
+    xmlMutexLock(xmlThrDefMutex);
+    ret = xmlDoValidityCheckingDefaultValueThrDef;
+    xmlDoValidityCheckingDefaultValueThrDef = v;
+    xmlMutexUnlock(xmlThrDefMutex);
+    return ret;
+}
+
+#undef	xmlGenericError
+xmlGenericErrorFunc *
+__xmlGenericError(void) {
+    if (IS_MAIN_THREAD)
+	return (&xmlGenericError);
+    else
+	return (&xmlGetGlobalState()->xmlGenericError);
+}
+
+#undef	xmlStructuredError
+xmlStructuredErrorFunc *
+__xmlStructuredError(void) {
+    if (IS_MAIN_THREAD)
+	return (&xmlStructuredError);
+    else
+	return (&xmlGetGlobalState()->xmlStructuredError);
+}
+
+#undef	xmlGenericErrorContext
+void * *
+__xmlGenericErrorContext(void) {
+    if (IS_MAIN_THREAD)
+	return (&xmlGenericErrorContext);
+    else
+	return (&xmlGetGlobalState()->xmlGenericErrorContext);
+}
+
+#undef	xmlGetWarningsDefaultValue
+int *
+__xmlGetWarningsDefaultValue(void) {
+    if (IS_MAIN_THREAD)
+	return (&xmlGetWarningsDefaultValue);
+    else
+	return (&xmlGetGlobalState()->xmlGetWarningsDefaultValue);
+}
+int xmlThrDefGetWarningsDefaultValue(int v) {
+    int ret;
+    xmlMutexLock(xmlThrDefMutex);
+    ret = xmlGetWarningsDefaultValueThrDef;
+    xmlGetWarningsDefaultValueThrDef = v;
+    xmlMutexUnlock(xmlThrDefMutex);
+    return ret;
+}
+
+#undef	xmlIndentTreeOutput
+int *
+__xmlIndentTreeOutput(void) {
+    if (IS_MAIN_THREAD)
+	return (&xmlIndentTreeOutput);
+    else
+	return (&xmlGetGlobalState()->xmlIndentTreeOutput);
+}
+int xmlThrDefIndentTreeOutput(int v) {
+    int ret;
+    xmlMutexLock(xmlThrDefMutex);
+    ret = xmlIndentTreeOutputThrDef;
+    xmlIndentTreeOutputThrDef = v;
+    xmlMutexUnlock(xmlThrDefMutex);
+    return ret;
+}
+
+#undef xmlTreeIndentString
+const char * *
+__xmlTreeIndentString(void) {
+    if (IS_MAIN_THREAD)
+	return (&xmlTreeIndentString);
+    else
+	return (&xmlGetGlobalState()->xmlTreeIndentString);
+}
+const char * xmlThrDefTreeIndentString(const char * v) {
+    const char * ret;
+    xmlMutexLock(xmlThrDefMutex);
+    ret = xmlTreeIndentStringThrDef;
+    xmlTreeIndentStringThrDef = v;
+    xmlMutexUnlock(xmlThrDefMutex);
+    return ret;
+}
+
+#undef	xmlKeepBlanksDefaultValue
+int *
+__xmlKeepBlanksDefaultValue(void) {
+    if (IS_MAIN_THREAD)
+	return (&xmlKeepBlanksDefaultValue);
+    else
+	return (&xmlGetGlobalState()->xmlKeepBlanksDefaultValue);
+}
+int xmlThrDefKeepBlanksDefaultValue(int v) {
+    int ret;
+    xmlMutexLock(xmlThrDefMutex);
+    ret = xmlKeepBlanksDefaultValueThrDef;
+    xmlKeepBlanksDefaultValueThrDef = v;
+    xmlMutexUnlock(xmlThrDefMutex);
+    return ret;
+}
+
+#undef	xmlLineNumbersDefaultValue
+int *
+__xmlLineNumbersDefaultValue(void) {
+    if (IS_MAIN_THREAD)
+	return (&xmlLineNumbersDefaultValue);
+    else
+	return (&xmlGetGlobalState()->xmlLineNumbersDefaultValue);
+}
+int xmlThrDefLineNumbersDefaultValue(int v) {
+    int ret;
+    xmlMutexLock(xmlThrDefMutex);
+    ret = xmlLineNumbersDefaultValueThrDef;
+    xmlLineNumbersDefaultValueThrDef = v;
+    xmlMutexUnlock(xmlThrDefMutex);
+    return ret;
+}
+
+#undef	xmlLoadExtDtdDefaultValue
+int *
+__xmlLoadExtDtdDefaultValue(void) {
+    if (IS_MAIN_THREAD)
+	return (&xmlLoadExtDtdDefaultValue);
+    else
+	return (&xmlGetGlobalState()->xmlLoadExtDtdDefaultValue);
+}
+int xmlThrDefLoadExtDtdDefaultValue(int v) {
+    int ret;
+    xmlMutexLock(xmlThrDefMutex);
+    ret = xmlLoadExtDtdDefaultValueThrDef;
+    xmlLoadExtDtdDefaultValueThrDef = v;
+    xmlMutexUnlock(xmlThrDefMutex);
+    return ret;
+}
+
+#undef	xmlParserDebugEntities
+int *
+__xmlParserDebugEntities(void) {
+    if (IS_MAIN_THREAD)
+	return (&xmlParserDebugEntities);
+    else
+	return (&xmlGetGlobalState()->xmlParserDebugEntities);
+}
+int xmlThrDefParserDebugEntities(int v) {
+    int ret;
+    xmlMutexLock(xmlThrDefMutex);
+    ret = xmlParserDebugEntitiesThrDef;
+    xmlParserDebugEntitiesThrDef = v;
+    xmlMutexUnlock(xmlThrDefMutex);
+    return ret;
+}
+
+#undef	xmlParserVersion
+const char * *
+__xmlParserVersion(void) {
+    if (IS_MAIN_THREAD)
+	return (&xmlParserVersion);
+    else
+	return (&xmlGetGlobalState()->xmlParserVersion);
+}
+
+#undef	xmlPedanticParserDefaultValue
+int *
+__xmlPedanticParserDefaultValue(void) {
+    if (IS_MAIN_THREAD)
+	return (&xmlPedanticParserDefaultValue);
+    else
+	return (&xmlGetGlobalState()->xmlPedanticParserDefaultValue);
+}
+int xmlThrDefPedanticParserDefaultValue(int v) {
+    int ret;
+    xmlMutexLock(xmlThrDefMutex);
+    ret = xmlPedanticParserDefaultValueThrDef;
+    xmlPedanticParserDefaultValueThrDef = v;
+    xmlMutexUnlock(xmlThrDefMutex);
+    return ret;
+}
+
+#undef	xmlSaveNoEmptyTags
+int *
+__xmlSaveNoEmptyTags(void) {
+    if (IS_MAIN_THREAD)
+	return (&xmlSaveNoEmptyTags);
+    else
+	return (&xmlGetGlobalState()->xmlSaveNoEmptyTags);
+}
+int xmlThrDefSaveNoEmptyTags(int v) {
+    int ret;
+    xmlMutexLock(xmlThrDefMutex);
+    ret = xmlSaveNoEmptyTagsThrDef;
+    xmlSaveNoEmptyTagsThrDef = v;
+    xmlMutexUnlock(xmlThrDefMutex);
+    return ret;
+}
+
+#undef	xmlSubstituteEntitiesDefaultValue
+int *
+__xmlSubstituteEntitiesDefaultValue(void) {
+    if (IS_MAIN_THREAD)
+	return (&xmlSubstituteEntitiesDefaultValue);
+    else
+	return (&xmlGetGlobalState()->xmlSubstituteEntitiesDefaultValue);
+}
+int xmlThrDefSubstituteEntitiesDefaultValue(int v) {
+    int ret;
+    xmlMutexLock(xmlThrDefMutex);
+    ret = xmlSubstituteEntitiesDefaultValueThrDef;
+    xmlSubstituteEntitiesDefaultValueThrDef = v;
+    xmlMutexUnlock(xmlThrDefMutex);
+    return ret;
+}
+
+#undef	xmlRegisterNodeDefaultValue
+xmlRegisterNodeFunc *
+__xmlRegisterNodeDefaultValue(void) {
+    if (IS_MAIN_THREAD)
+	return (&xmlRegisterNodeDefaultValue);
+    else
+	return (&xmlGetGlobalState()->xmlRegisterNodeDefaultValue);
+}
+
+#undef	xmlDeregisterNodeDefaultValue
+xmlDeregisterNodeFunc *
+__xmlDeregisterNodeDefaultValue(void) {
+    if (IS_MAIN_THREAD)
+	return (&xmlDeregisterNodeDefaultValue);
+    else
+	return (&xmlGetGlobalState()->xmlDeregisterNodeDefaultValue);
+}
diff --git a/src/libxml/src/hash.c b/src/libxml/src/hash.c
new file mode 100644
index 0000000..ff06b01
--- /dev/null
+++ b/src/libxml/src/hash.c
@@ -0,0 +1,949 @@
+/*
+ * hash.c: chained hash tables
+ *
+ * Reference: Your favorite introductory book on algorithms
+ *
+ * Copyright (C) 2000 Bjorn Reese and Daniel Veillard.
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
+ * MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE AUTHORS AND
+ * CONTRIBUTORS ACCEPT NO RESPONSIBILITY IN ANY CONCEIVABLE MANNER.
+ *
+ * Author: breese@users.sourceforge.net
+ */
+
+#define IN_LIBXML
+#include "libxml.h"
+
+#include <string.h>
+#include <libxml/parser.h>
+#include <libxml/hash.h>
+#include <libxml/xmlmemory.h>
+#include <libxml/xmlerror.h>
+#include <libxml/globals.h>
+
+#define MAX_HASH_LEN 8
+
+/* #define DEBUG_GROW */
+
+/*
+ * A single entry in the hash table
+ */
+typedef struct _xmlHashEntry xmlHashEntry;
+typedef xmlHashEntry *xmlHashEntryPtr;
+struct _xmlHashEntry {
+    struct _xmlHashEntry *next;
+    xmlChar *name;
+    xmlChar *name2;
+    xmlChar *name3;
+    void *payload;
+    int valid;
+};
+
+/*
+ * The entire hash table
+ */
+struct _xmlHashTable {
+    struct _xmlHashEntry *table;
+    int size;
+    int nbElems;
+};
+
+/*
+ * xmlHashComputeKey:
+ * Calculate the hash key
+ */
+static unsigned long
+xmlHashComputeKey(xmlHashTablePtr table, const xmlChar *name,
+	          const xmlChar *name2, const xmlChar *name3) {
+    unsigned long value = 0L;
+    char ch;
+    
+    if (name != NULL) {
+	value += 30 * (*name);
+	while ((ch = *name++) != 0) {
+	    value = value ^ ((value << 5) + (value >> 3) + (unsigned long)ch);
+	}
+    }
+    if (name2 != NULL) {
+	while ((ch = *name2++) != 0) {
+	    value = value ^ ((value << 5) + (value >> 3) + (unsigned long)ch);
+	}
+    }
+    if (name3 != NULL) {
+	while ((ch = *name3++) != 0) {
+	    value = value ^ ((value << 5) + (value >> 3) + (unsigned long)ch);
+	}
+    }
+    return (value % table->size);
+}
+
+static unsigned long
+xmlHashComputeQKey(xmlHashTablePtr table,
+		   const xmlChar *prefix, const xmlChar *name,
+		   const xmlChar *prefix2, const xmlChar *name2,
+		   const xmlChar *prefix3, const xmlChar *name3) {
+    unsigned long value = 0L;
+    char ch;
+    
+    if (prefix != NULL)
+	value += 30 * (*prefix);
+    else
+	value += 30 * (*name);
+
+    if (prefix != NULL) {
+	while ((ch = *prefix++) != 0) {
+	    value = value ^ ((value << 5) + (value >> 3) + (unsigned long)ch);
+	}
+	value = value ^ ((value << 5) + (value >> 3) + (unsigned long)':');
+    }
+    if (name != NULL) {
+	while ((ch = *name++) != 0) {
+	    value = value ^ ((value << 5) + (value >> 3) + (unsigned long)ch);
+	}
+    }
+    if (prefix2 != NULL) {
+	while ((ch = *prefix2++) != 0) {
+	    value = value ^ ((value << 5) + (value >> 3) + (unsigned long)ch);
+	}
+	value = value ^ ((value << 5) + (value >> 3) + (unsigned long)':');
+    }
+    if (name2 != NULL) {
+	while ((ch = *name2++) != 0) {
+	    value = value ^ ((value << 5) + (value >> 3) + (unsigned long)ch);
+	}
+    }
+    if (prefix3 != NULL) {
+	while ((ch = *prefix3++) != 0) {
+	    value = value ^ ((value << 5) + (value >> 3) + (unsigned long)ch);
+	}
+	value = value ^ ((value << 5) + (value >> 3) + (unsigned long)':');
+    }
+    if (name3 != NULL) {
+	while ((ch = *name3++) != 0) {
+	    value = value ^ ((value << 5) + (value >> 3) + (unsigned long)ch);
+	}
+    }
+    return (value % table->size);
+}
+
+/**
+ * xmlHashCreate:
+ * @size: the size of the hash table
+ *
+ * Create a new xmlHashTablePtr.
+ *
+ * Returns the newly created object, or NULL if an error occured.
+ */
+xmlHashTablePtr
+xmlHashCreate(int size) {
+    xmlHashTablePtr table;
+  
+    if (size <= 0)
+        size = 256;
+  
+    table = xmlMalloc(sizeof(xmlHashTable));
+    if (table) {
+        table->size = size;
+	table->nbElems = 0;
+        table->table = xmlMalloc(size * sizeof(xmlHashEntry));
+        if (table->table) {
+  	    memset(table->table, 0, size * sizeof(xmlHashEntry));
+  	    return(table);
+        }
+        xmlFree(table);
+    }
+    return(NULL);
+}
+
+/**
+ * xmlHashGrow:
+ * @table: the hash table
+ * @size: the new size of the hash table
+ *
+ * resize the hash table
+ *
+ * Returns 0 in case of success, -1 in case of failure
+ */
+static int
+xmlHashGrow(xmlHashTablePtr table, int size) {
+    unsigned long key;
+    int oldsize, i;
+    xmlHashEntryPtr iter, next;
+    struct _xmlHashEntry *oldtable;
+#ifdef DEBUG_GROW
+    unsigned long nbElem = 0;
+#endif
+  
+    if (table == NULL)
+	return(-1);
+    if (size < 8)
+        return(-1);
+    if (size > 8 * 2048)
+	return(-1);
+
+    oldsize = table->size;
+    oldtable = table->table;
+    if (oldtable == NULL)
+        return(-1);
+  
+    table->table = xmlMalloc(size * sizeof(xmlHashEntry));
+    if (table->table == NULL) {
+	table->table = oldtable;
+	return(-1);
+    }
+    memset(table->table, 0, size * sizeof(xmlHashEntry));
+    table->size = size;
+
+    /*	If the two loops are merged, there would be situations where
+	a new entry needs to allocated and data copied into it from 
+	the main table. So instead, we run through the array twice, first
+	copying all the elements in the main array (where we can't get
+	conflicts) and then the rest, so we only free (and don't allocate)
+    */
+    for (i = 0; i < oldsize; i++) {
+	if (oldtable[i].valid == 0) 
+	    continue;
+	key = xmlHashComputeKey(table, oldtable[i].name, oldtable[i].name2,
+				oldtable[i].name3);
+	memcpy(&(table->table[key]), &(oldtable[i]), sizeof(xmlHashEntry));
+	table->table[key].next = NULL;
+    }
+
+    for (i = 0; i < oldsize; i++) {
+	iter = oldtable[i].next;
+	while (iter) {
+	    next = iter->next;
+
+	    /*
+	     * put back the entry in the new table
+	     */
+
+	    key = xmlHashComputeKey(table, iter->name, iter->name2,
+		                    iter->name3);
+	    if (table->table[key].valid == 0) {
+		memcpy(&(table->table[key]), iter, sizeof(xmlHashEntry));
+		table->table[key].next = NULL;
+		xmlFree(iter);
+	    } else {
+	    	iter->next = table->table[key].next;
+	    	table->table[key].next = iter;
+	    }
+
+#ifdef DEBUG_GROW
+	    nbElem++;
+#endif
+
+	    iter = next;
+	}
+    }
+
+    xmlFree(oldtable);
+
+#ifdef DEBUG_GROW
+    xmlGenericError(xmlGenericErrorContext,
+	    "xmlHashGrow : from %d to %d, %d elems\n", oldsize, size, nbElem);
+#endif
+
+    return(0);
+}
+
+/**
+ * xmlHashFree:
+ * @table: the hash table
+ * @f:  the deallocator function for items in the hash
+ *
+ * Free the hash @table and its contents. The userdata is
+ * deallocated with @f if provided.
+ */
+void
+xmlHashFree(xmlHashTablePtr table, xmlHashDeallocator f) {
+    int i;
+    xmlHashEntryPtr iter;
+    xmlHashEntryPtr next;
+    int inside_table = 0;
+    int nbElems;
+
+    if (table == NULL)
+	return;
+    if (table->table) {
+	nbElems = table->nbElems;
+	for(i = 0; (i < table->size) && (nbElems > 0); i++) {
+	    iter = &(table->table[i]);
+	    if (iter->valid == 0)
+		continue;
+	    inside_table = 1;
+	    while (iter) {
+		next = iter->next;
+		if ((f != NULL) && (iter->payload != NULL))
+		    f(iter->payload, iter->name);
+		if (iter->name)
+		    xmlFree(iter->name);
+		if (iter->name2)
+		    xmlFree(iter->name2);
+		if (iter->name3)
+		    xmlFree(iter->name3);
+		iter->payload = NULL;
+		if (!inside_table)
+		    xmlFree(iter);
+		nbElems--;
+		inside_table = 0;
+		iter = next;
+	    }
+	    inside_table = 0;
+	}
+	xmlFree(table->table);
+    }
+    xmlFree(table);
+}
+
+/**
+ * xmlHashAddEntry:
+ * @table: the hash table
+ * @name: the name of the userdata
+ * @userdata: a pointer to the userdata
+ *
+ * Add the @userdata to the hash @table. This can later be retrieved
+ * by using the @name. Duplicate names generate errors.
+ *
+ * Returns 0 the addition succeeded and -1 in case of error.
+ */
+int
+xmlHashAddEntry(xmlHashTablePtr table, const xmlChar *name, void *userdata) {
+    return(xmlHashAddEntry3(table, name, NULL, NULL, userdata));
+}
+
+/**
+ * xmlHashAddEntry2:
+ * @table: the hash table
+ * @name: the name of the userdata
+ * @name2: a second name of the userdata
+ * @userdata: a pointer to the userdata
+ *
+ * Add the @userdata to the hash @table. This can later be retrieved
+ * by using the (@name, @name2) tuple. Duplicate tuples generate errors.
+ *
+ * Returns 0 the addition succeeded and -1 in case of error.
+ */
+int
+xmlHashAddEntry2(xmlHashTablePtr table, const xmlChar *name,
+	        const xmlChar *name2, void *userdata) {
+    return(xmlHashAddEntry3(table, name, name2, NULL, userdata));
+}
+
+/**
+ * xmlHashUpdateEntry:
+ * @table: the hash table
+ * @name: the name of the userdata
+ * @userdata: a pointer to the userdata
+ * @f: the deallocator function for replaced item (if any)
+ *
+ * Add the @userdata to the hash @table. This can later be retrieved
+ * by using the @name. Existing entry for this @name will be removed
+ * and freed with @f if found.
+ *
+ * Returns 0 the addition succeeded and -1 in case of error.
+ */
+int
+xmlHashUpdateEntry(xmlHashTablePtr table, const xmlChar *name,
+	           void *userdata, xmlHashDeallocator f) {
+    return(xmlHashUpdateEntry3(table, name, NULL, NULL, userdata, f));
+}
+
+/**
+ * xmlHashUpdateEntry2:
+ * @table: the hash table
+ * @name: the name of the userdata
+ * @name2: a second name of the userdata
+ * @userdata: a pointer to the userdata
+ * @f: the deallocator function for replaced item (if any)
+ *
+ * Add the @userdata to the hash @table. This can later be retrieved
+ * by using the (@name, @name2) tuple. Existing entry for this tuple will
+ * be removed and freed with @f if found.
+ *
+ * Returns 0 the addition succeeded and -1 in case of error.
+ */
+int
+xmlHashUpdateEntry2(xmlHashTablePtr table, const xmlChar *name,
+	           const xmlChar *name2, void *userdata,
+		   xmlHashDeallocator f) {
+    return(xmlHashUpdateEntry3(table, name, name2, NULL, userdata, f));
+}
+
+/**
+ * xmlHashLookup:
+ * @table: the hash table
+ * @name: the name of the userdata
+ *
+ * Find the userdata specified by the @name.
+ *
+ * Returns the pointer to the userdata
+ */
+void *
+xmlHashLookup(xmlHashTablePtr table, const xmlChar *name) {
+    return(xmlHashLookup3(table, name, NULL, NULL));
+}
+
+/**
+ * xmlHashLookup2:
+ * @table: the hash table
+ * @name: the name of the userdata
+ * @name2: a second name of the userdata
+ *
+ * Find the userdata specified by the (@name, @name2) tuple.
+ *
+ * Returns the pointer to the userdata
+ */
+void *
+xmlHashLookup2(xmlHashTablePtr table, const xmlChar *name,
+	      const xmlChar *name2) {
+    return(xmlHashLookup3(table, name, name2, NULL));
+}
+
+/**
+ * xmlHashQLookup:
+ * @table: the hash table
+ * @prefix: the prefix of the userdata
+ * @name: the name of the userdata
+ *
+ * Find the userdata specified by the QName @prefix:@name/@name.
+ *
+ * Returns the pointer to the userdata
+ */
+void *
+xmlHashQLookup(xmlHashTablePtr table, const xmlChar *prefix,
+               const xmlChar *name) {
+    return(xmlHashQLookup3(table, prefix, name, NULL, NULL, NULL, NULL));
+}
+
+/**
+ * xmlHashQLookup2:
+ * @table: the hash table
+ * @prefix: the prefix of the userdata
+ * @name: the name of the userdata
+ * @prefix2: the second prefix of the userdata
+ * @name2: a second name of the userdata
+ *
+ * Find the userdata specified by the QNames tuple
+ *
+ * Returns the pointer to the userdata
+ */
+void *
+xmlHashQLookup2(xmlHashTablePtr table, const xmlChar *prefix,
+                const xmlChar *name, const xmlChar *prefix2,
+	        const xmlChar *name2) {
+    return(xmlHashQLookup3(table, prefix, name, prefix2, name2, NULL, NULL));
+}
+
+/**
+ * xmlHashAddEntry3:
+ * @table: the hash table
+ * @name: the name of the userdata
+ * @name2: a second name of the userdata
+ * @name3: a third name of the userdata
+ * @userdata: a pointer to the userdata
+ *
+ * Add the @userdata to the hash @table. This can later be retrieved
+ * by using the tuple (@name, @name2, @name3). Duplicate entries generate
+ * errors.
+ *
+ * Returns 0 the addition succeeded and -1 in case of error.
+ */
+int
+xmlHashAddEntry3(xmlHashTablePtr table, const xmlChar *name,
+	         const xmlChar *name2, const xmlChar *name3,
+		 void *userdata) {
+    unsigned long key, len = 0;
+    xmlHashEntryPtr entry;
+    xmlHashEntryPtr insert;
+
+    if ((table == NULL) || name == NULL)
+	return(-1);
+
+    /*
+     * Check for duplicate and insertion location.
+     */
+    key = xmlHashComputeKey(table, name, name2, name3);
+    if (table->table[key].valid == 0) {
+	insert = NULL;
+    } else {
+	for (insert = &(table->table[key]); insert->next != NULL;
+	     insert = insert->next) {
+	    if ((xmlStrEqual(insert->name, name)) &&
+		(xmlStrEqual(insert->name2, name2)) &&
+		(xmlStrEqual(insert->name3, name3)))
+		return(-1);
+	    len++;
+	}
+	if ((xmlStrEqual(insert->name, name)) &&
+	    (xmlStrEqual(insert->name2, name2)) &&
+	    (xmlStrEqual(insert->name3, name3)))
+	    return(-1);
+    }
+
+    if (insert == NULL) {
+	entry = &(table->table[key]);
+    } else {
+	entry = xmlMalloc(sizeof(xmlHashEntry));
+	if (entry == NULL)
+	     return(-1);
+    }
+
+    entry->name = xmlStrdup(name);
+    entry->name2 = xmlStrdup(name2);
+    entry->name3 = xmlStrdup(name3);
+    entry->payload = userdata;
+    entry->next = NULL;
+    entry->valid = 1;
+
+
+    if (insert != NULL) 
+	insert->next = entry;
+
+    table->nbElems++;
+
+    if (len > MAX_HASH_LEN)
+	xmlHashGrow(table, MAX_HASH_LEN * table->size);
+
+    return(0);
+}
+
+/**
+ * xmlHashUpdateEntry3:
+ * @table: the hash table
+ * @name: the name of the userdata
+ * @name2: a second name of the userdata
+ * @name3: a third name of the userdata
+ * @userdata: a pointer to the userdata
+ * @f: the deallocator function for replaced item (if any)
+ *
+ * Add the @userdata to the hash @table. This can later be retrieved
+ * by using the tuple (@name, @name2, @name3). Existing entry for this tuple
+ * will be removed and freed with @f if found.
+ *
+ * Returns 0 the addition succeeded and -1 in case of error.
+ */
+int
+xmlHashUpdateEntry3(xmlHashTablePtr table, const xmlChar *name,
+	           const xmlChar *name2, const xmlChar *name3,
+		   void *userdata, xmlHashDeallocator f) {
+    unsigned long key;
+    xmlHashEntryPtr entry;
+    xmlHashEntryPtr insert;
+
+    if ((table == NULL) || name == NULL)
+	return(-1);
+
+    /*
+     * Check for duplicate and insertion location.
+     */
+    key = xmlHashComputeKey(table, name, name2, name3);
+    if (table->table[key].valid == 0) {
+	insert = NULL;
+    } else {
+	for (insert = &(table->table[key]); insert->next != NULL;
+	     insert = insert->next) {
+	    if ((xmlStrEqual(insert->name, name)) &&
+		(xmlStrEqual(insert->name2, name2)) &&
+		(xmlStrEqual(insert->name3, name3))) {
+		if (f)
+		    f(insert->payload, insert->name);
+		insert->payload = userdata;
+		return(0);
+	    }
+	}
+	if ((xmlStrEqual(insert->name, name)) &&
+	    (xmlStrEqual(insert->name2, name2)) &&
+	    (xmlStrEqual(insert->name3, name3))) {
+	    if (f)
+		f(insert->payload, insert->name);
+	    insert->payload = userdata;
+	    return(0);
+	}
+    }
+
+    if (insert == NULL) {
+	entry =  &(table->table[key]);
+    } else {
+	entry = xmlMalloc(sizeof(xmlHashEntry));
+	if (entry == NULL)
+	     return(-1);
+    }
+
+    entry->name = xmlStrdup(name);
+    entry->name2 = xmlStrdup(name2);
+    entry->name3 = xmlStrdup(name3);
+    entry->payload = userdata;
+    entry->next = NULL;
+    entry->valid = 1;
+    table->nbElems++;
+
+
+    if (insert != NULL) {
+	insert->next = entry;
+    }
+    return(0);
+}
+
+/**
+ * xmlHashLookup3:
+ * @table: the hash table
+ * @name: the name of the userdata
+ * @name2: a second name of the userdata
+ * @name3: a third name of the userdata
+ *
+ * Find the userdata specified by the (@name, @name2, @name3) tuple.
+ *
+ * Returns the a pointer to the userdata
+ */
+void *
+xmlHashLookup3(xmlHashTablePtr table, const xmlChar *name, 
+	       const xmlChar *name2, const xmlChar *name3) {
+    unsigned long key;
+    xmlHashEntryPtr entry;
+
+    if (table == NULL)
+	return(NULL);
+    if (name == NULL)
+	return(NULL);
+    key = xmlHashComputeKey(table, name, name2, name3);
+    if (table->table[key].valid == 0)
+	return(NULL);
+    for (entry = &(table->table[key]); entry != NULL; entry = entry->next) {
+	if ((xmlStrEqual(entry->name, name)) &&
+	    (xmlStrEqual(entry->name2, name2)) &&
+	    (xmlStrEqual(entry->name3, name3)))
+	    return(entry->payload);
+    }
+    return(NULL);
+}
+
+/**
+ * xmlHashQLookup3:
+ * @table: the hash table
+ * @prefix: the prefix of the userdata
+ * @name: the name of the userdata
+ * @prefix2: the second prefix of the userdata
+ * @name2: a second name of the userdata
+ * @prefix3: the third prefix of the userdata
+ * @name3: a third name of the userdata
+ *
+ * Find the userdata specified by the (@name, @name2, @name3) tuple.
+ *
+ * Returns the a pointer to the userdata
+ */
+void *
+xmlHashQLookup3(xmlHashTablePtr table,
+                const xmlChar *prefix, const xmlChar *name,
+		const xmlChar *prefix2, const xmlChar *name2,
+		const xmlChar *prefix3, const xmlChar *name3) {
+    unsigned long key;
+    xmlHashEntryPtr entry;
+
+    if (table == NULL)
+	return(NULL);
+    if (name == NULL)
+	return(NULL);
+    key = xmlHashComputeQKey(table, prefix, name, prefix2,
+                             name2, prefix3, name3);
+    if (table->table[key].valid == 0)
+	return(NULL);
+    for (entry = &(table->table[key]); entry != NULL; entry = entry->next) {
+	if ((xmlStrQEqual(prefix, name, entry->name)) &&
+	    (xmlStrQEqual(prefix2, name2, entry->name2)) &&
+	    (xmlStrQEqual(prefix3, name3, entry->name3)))
+	    return(entry->payload);
+    }
+    return(NULL);
+}
+
+typedef struct {
+    xmlHashScanner hashscanner;
+    void *data;
+} stubData;
+
+static void 
+stubHashScannerFull (void *payload, void *data, const xmlChar *name, 
+                     const xmlChar *name2 ATTRIBUTE_UNUSED,
+		     const xmlChar *name3 ATTRIBUTE_UNUSED) {
+    stubData *stubdata = (stubData *) data;
+    stubdata->hashscanner (payload, stubdata->data, (xmlChar *) name);
+}                                  
+ 
+/**
+ * xmlHashScan:
+ * @table: the hash table
+ * @f:  the scanner function for items in the hash
+ * @data:  extra data passed to f
+ *
+ * Scan the hash @table and applied @f to each value.
+ */
+void
+xmlHashScan(xmlHashTablePtr table, xmlHashScanner f, void *data) {
+    stubData stubdata;
+    stubdata.data = data;
+    stubdata.hashscanner = f; 
+    xmlHashScanFull (table, stubHashScannerFull, &stubdata);
+}
+
+/**
+ * xmlHashScanFull:
+ * @table: the hash table
+ * @f:  the scanner function for items in the hash
+ * @data:  extra data passed to f
+ *
+ * Scan the hash @table and applied @f to each value.
+ */
+void
+xmlHashScanFull(xmlHashTablePtr table, xmlHashScannerFull f, void *data) {
+    int i;
+    xmlHashEntryPtr iter;
+    xmlHashEntryPtr next;
+
+    if (table == NULL)
+	return;
+    if (f == NULL)
+	return;
+
+    if (table->table) {
+	for(i = 0; i < table->size; i++) {
+	    if (table->table[i].valid == 0) 
+		continue;
+	    iter = &(table->table[i]);
+	    while (iter) {
+		next = iter->next;
+		if ((f != NULL) && (iter->payload != NULL))
+		    f(iter->payload, data, iter->name,
+		      iter->name2, iter->name3);
+		iter = next;
+	    }
+	}
+    }
+}
+
+/**
+ * xmlHashScan3:
+ * @table: the hash table
+ * @name: the name of the userdata or NULL
+ * @name2: a second name of the userdata or NULL
+ * @name3: a third name of the userdata or NULL
+ * @f:  the scanner function for items in the hash
+ * @data:  extra data passed to f
+ *
+ * Scan the hash @table and applied @f to each value matching
+ * (@name, @name2, @name3) tuple. If one of the names is null,
+ * the comparison is considered to match.
+ */
+void
+xmlHashScan3(xmlHashTablePtr table, const xmlChar *name, 
+	     const xmlChar *name2, const xmlChar *name3,
+	     xmlHashScanner f, void *data) {
+    xmlHashScanFull3 (table, name, name2, name3,
+		      (xmlHashScannerFull) f, data);
+}
+
+/**
+ * xmlHashScanFull3:
+ * @table: the hash table
+ * @name: the name of the userdata or NULL
+ * @name2: a second name of the userdata or NULL
+ * @name3: a third name of the userdata or NULL
+ * @f:  the scanner function for items in the hash
+ * @data:  extra data passed to f
+ *
+ * Scan the hash @table and applied @f to each value matching
+ * (@name, @name2, @name3) tuple. If one of the names is null,
+ * the comparison is considered to match.
+ */
+void
+xmlHashScanFull3(xmlHashTablePtr table, const xmlChar *name, 
+		 const xmlChar *name2, const xmlChar *name3,
+		 xmlHashScannerFull f, void *data) {
+    int i;
+    xmlHashEntryPtr iter;
+    xmlHashEntryPtr next;
+
+    if (table == NULL)
+	return;
+    if (f == NULL)
+	return;
+
+    if (table->table) {
+	for(i = 0; i < table->size; i++) {
+	    if (table->table[i].valid == 0)
+		continue;
+	    iter = &(table->table[i]);
+	    while (iter) {
+		next = iter->next;
+		if (((name == NULL) || (xmlStrEqual(name, iter->name))) &&
+		    ((name2 == NULL) || (xmlStrEqual(name2, iter->name2))) &&
+		    ((name3 == NULL) || (xmlStrEqual(name3, iter->name3))) &&
+		    (iter->payload != NULL)) {
+		    f(iter->payload, data, iter->name,
+		      iter->name2, iter->name3);
+		}
+		iter = next;
+	    }
+	}
+    }
+}
+
+/**
+ * xmlHashCopy:
+ * @table: the hash table
+ * @f:  the copier function for items in the hash
+ *
+ * Scan the hash @table and applied @f to each value.
+ *
+ * Returns the new table or NULL in case of error.
+ */
+xmlHashTablePtr
+xmlHashCopy(xmlHashTablePtr table, xmlHashCopier f) {
+    int i;
+    xmlHashEntryPtr iter;
+    xmlHashEntryPtr next;
+    xmlHashTablePtr ret;
+
+    if (table == NULL)
+	return(NULL);
+    if (f == NULL)
+	return(NULL);
+
+    ret = xmlHashCreate(table->size);
+    if (table->table) {
+	for(i = 0; i < table->size; i++) {
+	    if (table->table[i].valid == 0)
+		continue;
+	    iter = &(table->table[i]);
+	    while (iter) {
+		next = iter->next;
+		xmlHashAddEntry3(ret, iter->name, iter->name2,
+			         iter->name3, f(iter->payload, iter->name));
+		iter = next;
+	    }
+	}
+    }
+    ret->nbElems = table->nbElems;
+    return(ret);
+}
+
+/**
+ * xmlHashSize:
+ * @table: the hash table
+ *
+ * Query the number of elements installed in the hash @table.
+ *
+ * Returns the number of elements in the hash table or
+ * -1 in case of error
+ */
+int
+xmlHashSize(xmlHashTablePtr table) {
+    if (table == NULL)
+	return(-1);
+    return(table->nbElems);
+}
+
+/**
+ * xmlHashRemoveEntry:
+ * @table: the hash table
+ * @name: the name of the userdata
+ * @f: the deallocator function for removed item (if any)
+ *
+ * Find the userdata specified by the @name and remove
+ * it from the hash @table. Existing userdata for this tuple will be removed
+ * and freed with @f.
+ *
+ * Returns 0 if the removal succeeded and -1 in case of error or not found.
+ */
+int xmlHashRemoveEntry(xmlHashTablePtr table, const xmlChar *name,
+		       xmlHashDeallocator f) {
+    return(xmlHashRemoveEntry3(table, name, NULL, NULL, f));
+}
+
+/**
+ * xmlHashRemoveEntry2:
+ * @table: the hash table
+ * @name: the name of the userdata
+ * @name2: a second name of the userdata
+ * @f: the deallocator function for removed item (if any)
+ *
+ * Find the userdata specified by the (@name, @name2) tuple and remove
+ * it from the hash @table. Existing userdata for this tuple will be removed
+ * and freed with @f.
+ *
+ * Returns 0 if the removal succeeded and -1 in case of error or not found.
+ */
+int
+xmlHashRemoveEntry2(xmlHashTablePtr table, const xmlChar *name,
+			const xmlChar *name2, xmlHashDeallocator f) {
+    return(xmlHashRemoveEntry3(table, name, name2, NULL, f));
+}
+
+/**
+ * xmlHashRemoveEntry3:
+ * @table: the hash table
+ * @name: the name of the userdata
+ * @name2: a second name of the userdata
+ * @name3: a third name of the userdata
+ * @f: the deallocator function for removed item (if any)
+ *
+ * Find the userdata specified by the (@name, @name2, @name3) tuple and remove
+ * it from the hash @table. Existing userdata for this tuple will be removed
+ * and freed with @f.
+ *
+ * Returns 0 if the removal succeeded and -1 in case of error or not found.
+ */
+int
+xmlHashRemoveEntry3(xmlHashTablePtr table, const xmlChar *name,
+    const xmlChar *name2, const xmlChar *name3, xmlHashDeallocator f) {
+    unsigned long key;
+    xmlHashEntryPtr entry;
+    xmlHashEntryPtr prev = NULL;
+
+    if (table == NULL || name == NULL)
+        return(-1);
+
+    key = xmlHashComputeKey(table, name, name2, name3);
+    if (table->table[key].valid == 0) {
+        return(-1);
+    } else {
+        for (entry = &(table->table[key]); entry != NULL; entry = entry->next) {
+            if (xmlStrEqual(entry->name, name) &&
+                    xmlStrEqual(entry->name2, name2) &&
+                    xmlStrEqual(entry->name3, name3)) {
+                if ((f != NULL) && (entry->payload != NULL))
+                    f(entry->payload, entry->name);
+                entry->payload = NULL;
+                if(entry->name)
+                    xmlFree(entry->name);
+                if(entry->name2)
+                    xmlFree(entry->name2);
+                if(entry->name3)
+                    xmlFree(entry->name3);
+                if(prev) {
+                    prev->next = entry->next;
+		    xmlFree(entry);
+		} else {
+		    if (entry->next == NULL) {
+			entry->valid = 0;
+		    } else {
+			entry = entry->next;
+			memcpy(&(table->table[key]), entry, sizeof(xmlHashEntry));
+			xmlFree(entry);
+		    }
+		}
+                table->nbElems--;
+                return(0);
+            }
+            prev = entry;
+        }
+        return(-1);
+    }
+}
+
diff --git a/src/libxml/src/legacy.c b/src/libxml/src/legacy.c
new file mode 100644
index 0000000..9ed7413
--- /dev/null
+++ b/src/libxml/src/legacy.c
@@ -0,0 +1,1340 @@
+/*
+ * legacy.c: set of deprecated routines, not to be used anymore but
+ *           kept purely for ABI compatibility
+ *
+ * See Copyright for the status of this software.
+ *
+ * daniel@veillard.com
+ */
+
+#define IN_LIBXML
+#include "libxml.h"
+
+#ifdef LIBXML_LEGACY_ENABLED
+#include <string.h>
+
+#include <libxml/tree.h>
+#include <libxml/entities.h>
+#include <libxml/SAX.h>
+#include <libxml/parserInternals.h>
+#include <libxml/HTMLparser.h>
+
+void xmlUpgradeOldNs(xmlDocPtr doc);
+
+/************************************************************************
+ *									*
+ *		Deprecated functions kept for compatibility		*
+ *									*
+ ************************************************************************/
+
+xmlChar *htmlDecodeEntities(htmlParserCtxtPtr ctxt, int len, xmlChar end,
+                            xmlChar end2, xmlChar end3);
+
+/**
+ * htmlDecodeEntities:
+ * @ctxt:  the parser context
+ * @len:  the len to decode (in bytes !), -1 for no size limit
+ * @end:  an end marker xmlChar, 0 if none
+ * @end2:  an end marker xmlChar, 0 if none
+ * @end3:  an end marker xmlChar, 0 if none
+ *
+ * Substitute the HTML entities by their value
+ *
+ * DEPRECATED !!!!
+ *
+ * Returns A newly allocated string with the substitution done. The caller
+ *      must deallocate it !
+ */
+xmlChar *
+htmlDecodeEntities(htmlParserCtxtPtr ctxt ATTRIBUTE_UNUSED,
+                   int len ATTRIBUTE_UNUSED, xmlChar end ATTRIBUTE_UNUSED,
+                   xmlChar end2 ATTRIBUTE_UNUSED,
+                   xmlChar end3 ATTRIBUTE_UNUSED)
+{
+    static int deprecated = 0;
+
+    if (!deprecated) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "htmlDecodeEntities() deprecated function reached\n");
+        deprecated = 1;
+    }
+    return (NULL);
+}
+
+/**
+ * xmlInitializePredefinedEntities:
+ *
+ * Set up the predefined entities.
+ * Deprecated call
+ */
+void
+xmlInitializePredefinedEntities(void)
+{
+}
+
+/**
+ * xmlCleanupPredefinedEntities:
+ *
+ * Cleanup up the predefined entities table.
+ * Deprecated call
+ */
+void
+xmlCleanupPredefinedEntities(void)
+{
+}
+
+static const char *xmlFeaturesList[] = {
+    "validate",
+    "load subset",
+    "keep blanks",
+    "disable SAX",
+    "fetch external entities",
+    "substitute entities",
+    "gather line info",
+    "user data",
+    "is html",
+    "is standalone",
+    "stop parser",
+    "document",
+    "is well formed",
+    "is valid",
+    "SAX block",
+    "SAX function internalSubset",
+    "SAX function isStandalone",
+    "SAX function hasInternalSubset",
+    "SAX function hasExternalSubset",
+    "SAX function resolveEntity",
+    "SAX function getEntity",
+    "SAX function entityDecl",
+    "SAX function notationDecl",
+    "SAX function attributeDecl",
+    "SAX function elementDecl",
+    "SAX function unparsedEntityDecl",
+    "SAX function setDocumentLocator",
+    "SAX function startDocument",
+    "SAX function endDocument",
+    "SAX function startElement",
+    "SAX function endElement",
+    "SAX function reference",
+    "SAX function characters",
+    "SAX function ignorableWhitespace",
+    "SAX function processingInstruction",
+    "SAX function comment",
+    "SAX function warning",
+    "SAX function error",
+    "SAX function fatalError",
+    "SAX function getParameterEntity",
+    "SAX function cdataBlock",
+    "SAX function externalSubset",
+};
+
+/**
+ * xmlGetFeaturesList:
+ * @len:  the length of the features name array (input/output)
+ * @result:  an array of string to be filled with the features name.
+ *
+ * Copy at most *@len feature names into the @result array
+ *
+ * Returns -1 in case or error, or the total number of features,
+ *            len is updated with the number of strings copied,
+ *            strings must not be deallocated
+ */
+int
+xmlGetFeaturesList(int *len, const char **result)
+{
+    int ret, i;
+
+    ret = sizeof(xmlFeaturesList) / sizeof(xmlFeaturesList[0]);
+    if ((len == NULL) || (result == NULL))
+        return (ret);
+    if ((*len < 0) || (*len >= 1000))
+        return (-1);
+    if (*len > ret)
+        *len = ret;
+    for (i = 0; i < *len; i++)
+        result[i] = xmlFeaturesList[i];
+    return (ret);
+}
+
+/**
+ * xmlGetFeature:
+ * @ctxt:  an XML/HTML parser context
+ * @name:  the feature name
+ * @result:  location to store the result
+ *
+ * Read the current value of one feature of this parser instance
+ *
+ * Returns -1 in case or error, 0 otherwise
+ */
+int
+xmlGetFeature(xmlParserCtxtPtr ctxt, const char *name, void *result)
+{
+    if ((ctxt == NULL) || (name == NULL) || (result == NULL))
+        return (-1);
+
+    if (!strcmp(name, "validate")) {
+        *((int *) result) = ctxt->validate;
+    } else if (!strcmp(name, "keep blanks")) {
+        *((int *) result) = ctxt->keepBlanks;
+    } else if (!strcmp(name, "disable SAX")) {
+        *((int *) result) = ctxt->disableSAX;
+    } else if (!strcmp(name, "fetch external entities")) {
+        *((int *) result) = ctxt->loadsubset;
+    } else if (!strcmp(name, "substitute entities")) {
+        *((int *) result) = ctxt->replaceEntities;
+    } else if (!strcmp(name, "gather line info")) {
+        *((int *) result) = ctxt->record_info;
+    } else if (!strcmp(name, "user data")) {
+        *((void **) result) = ctxt->userData;
+    } else if (!strcmp(name, "is html")) {
+        *((int *) result) = ctxt->html;
+    } else if (!strcmp(name, "is standalone")) {
+        *((int *) result) = ctxt->standalone;
+    } else if (!strcmp(name, "document")) {
+        *((xmlDocPtr *) result) = ctxt->myDoc;
+    } else if (!strcmp(name, "is well formed")) {
+        *((int *) result) = ctxt->wellFormed;
+    } else if (!strcmp(name, "is valid")) {
+        *((int *) result) = ctxt->valid;
+    } else if (!strcmp(name, "SAX block")) {
+        *((xmlSAXHandlerPtr *) result) = ctxt->sax;
+    } else if (!strcmp(name, "SAX function internalSubset")) {
+        *((internalSubsetSAXFunc *) result) = ctxt->sax->internalSubset;
+    } else if (!strcmp(name, "SAX function isStandalone")) {
+        *((isStandaloneSAXFunc *) result) = ctxt->sax->isStandalone;
+    } else if (!strcmp(name, "SAX function hasInternalSubset")) {
+        *((hasInternalSubsetSAXFunc *) result) =
+            ctxt->sax->hasInternalSubset;
+    } else if (!strcmp(name, "SAX function hasExternalSubset")) {
+        *((hasExternalSubsetSAXFunc *) result) =
+            ctxt->sax->hasExternalSubset;
+    } else if (!strcmp(name, "SAX function resolveEntity")) {
+        *((resolveEntitySAXFunc *) result) = ctxt->sax->resolveEntity;
+    } else if (!strcmp(name, "SAX function getEntity")) {
+        *((getEntitySAXFunc *) result) = ctxt->sax->getEntity;
+    } else if (!strcmp(name, "SAX function entityDecl")) {
+        *((entityDeclSAXFunc *) result) = ctxt->sax->entityDecl;
+    } else if (!strcmp(name, "SAX function notationDecl")) {
+        *((notationDeclSAXFunc *) result) = ctxt->sax->notationDecl;
+    } else if (!strcmp(name, "SAX function attributeDecl")) {
+        *((attributeDeclSAXFunc *) result) = ctxt->sax->attributeDecl;
+    } else if (!strcmp(name, "SAX function elementDecl")) {
+        *((elementDeclSAXFunc *) result) = ctxt->sax->elementDecl;
+    } else if (!strcmp(name, "SAX function unparsedEntityDecl")) {
+        *((unparsedEntityDeclSAXFunc *) result) =
+            ctxt->sax->unparsedEntityDecl;
+    } else if (!strcmp(name, "SAX function setDocumentLocator")) {
+        *((setDocumentLocatorSAXFunc *) result) =
+            ctxt->sax->setDocumentLocator;
+    } else if (!strcmp(name, "SAX function startDocument")) {
+        *((startDocumentSAXFunc *) result) = ctxt->sax->startDocument;
+    } else if (!strcmp(name, "SAX function endDocument")) {
+        *((endDocumentSAXFunc *) result) = ctxt->sax->endDocument;
+    } else if (!strcmp(name, "SAX function startElement")) {
+        *((startElementSAXFunc *) result) = ctxt->sax->startElement;
+    } else if (!strcmp(name, "SAX function endElement")) {
+        *((endElementSAXFunc *) result) = ctxt->sax->endElement;
+    } else if (!strcmp(name, "SAX function reference")) {
+        *((referenceSAXFunc *) result) = ctxt->sax->reference;
+    } else if (!strcmp(name, "SAX function characters")) {
+        *((charactersSAXFunc *) result) = ctxt->sax->characters;
+    } else if (!strcmp(name, "SAX function ignorableWhitespace")) {
+        *((ignorableWhitespaceSAXFunc *) result) =
+            ctxt->sax->ignorableWhitespace;
+    } else if (!strcmp(name, "SAX function processingInstruction")) {
+        *((processingInstructionSAXFunc *) result) =
+            ctxt->sax->processingInstruction;
+    } else if (!strcmp(name, "SAX function comment")) {
+        *((commentSAXFunc *) result) = ctxt->sax->comment;
+    } else if (!strcmp(name, "SAX function warning")) {
+        *((warningSAXFunc *) result) = ctxt->sax->warning;
+    } else if (!strcmp(name, "SAX function error")) {
+        *((errorSAXFunc *) result) = ctxt->sax->error;
+    } else if (!strcmp(name, "SAX function fatalError")) {
+        *((fatalErrorSAXFunc *) result) = ctxt->sax->fatalError;
+    } else if (!strcmp(name, "SAX function getParameterEntity")) {
+        *((getParameterEntitySAXFunc *) result) =
+            ctxt->sax->getParameterEntity;
+    } else if (!strcmp(name, "SAX function cdataBlock")) {
+        *((cdataBlockSAXFunc *) result) = ctxt->sax->cdataBlock;
+    } else if (!strcmp(name, "SAX function externalSubset")) {
+        *((externalSubsetSAXFunc *) result) = ctxt->sax->externalSubset;
+    } else {
+        return (-1);
+    }
+    return (0);
+}
+
+/**
+ * xmlSetFeature:
+ * @ctxt:  an XML/HTML parser context
+ * @name:  the feature name
+ * @value:  pointer to the location of the new value
+ *
+ * Change the current value of one feature of this parser instance
+ *
+ * Returns -1 in case or error, 0 otherwise
+ */
+int
+xmlSetFeature(xmlParserCtxtPtr ctxt, const char *name, void *value)
+{
+    if ((ctxt == NULL) || (name == NULL) || (value == NULL))
+        return (-1);
+
+    if (!strcmp(name, "validate")) {
+        int newvalidate = *((int *) value);
+
+        if ((!ctxt->validate) && (newvalidate != 0)) {
+            if (ctxt->vctxt.warning == NULL)
+                ctxt->vctxt.warning = xmlParserValidityWarning;
+            if (ctxt->vctxt.error == NULL)
+                ctxt->vctxt.error = xmlParserValidityError;
+            ctxt->vctxt.nodeMax = 0;
+        }
+        ctxt->validate = newvalidate;
+    } else if (!strcmp(name, "keep blanks")) {
+        ctxt->keepBlanks = *((int *) value);
+    } else if (!strcmp(name, "disable SAX")) {
+        ctxt->disableSAX = *((int *) value);
+    } else if (!strcmp(name, "fetch external entities")) {
+        ctxt->loadsubset = *((int *) value);
+    } else if (!strcmp(name, "substitute entities")) {
+        ctxt->replaceEntities = *((int *) value);
+    } else if (!strcmp(name, "gather line info")) {
+        ctxt->record_info = *((int *) value);
+    } else if (!strcmp(name, "user data")) {
+        ctxt->userData = *((void **) value);
+    } else if (!strcmp(name, "is html")) {
+        ctxt->html = *((int *) value);
+    } else if (!strcmp(name, "is standalone")) {
+        ctxt->standalone = *((int *) value);
+    } else if (!strcmp(name, "document")) {
+        ctxt->myDoc = *((xmlDocPtr *) value);
+    } else if (!strcmp(name, "is well formed")) {
+        ctxt->wellFormed = *((int *) value);
+    } else if (!strcmp(name, "is valid")) {
+        ctxt->valid = *((int *) value);
+    } else if (!strcmp(name, "SAX block")) {
+        ctxt->sax = *((xmlSAXHandlerPtr *) value);
+    } else if (!strcmp(name, "SAX function internalSubset")) {
+        ctxt->sax->internalSubset = *((internalSubsetSAXFunc *) value);
+    } else if (!strcmp(name, "SAX function isStandalone")) {
+        ctxt->sax->isStandalone = *((isStandaloneSAXFunc *) value);
+    } else if (!strcmp(name, "SAX function hasInternalSubset")) {
+        ctxt->sax->hasInternalSubset =
+            *((hasInternalSubsetSAXFunc *) value);
+    } else if (!strcmp(name, "SAX function hasExternalSubset")) {
+        ctxt->sax->hasExternalSubset =
+            *((hasExternalSubsetSAXFunc *) value);
+    } else if (!strcmp(name, "SAX function resolveEntity")) {
+        ctxt->sax->resolveEntity = *((resolveEntitySAXFunc *) value);
+    } else if (!strcmp(name, "SAX function getEntity")) {
+        ctxt->sax->getEntity = *((getEntitySAXFunc *) value);
+    } else if (!strcmp(name, "SAX function entityDecl")) {
+        ctxt->sax->entityDecl = *((entityDeclSAXFunc *) value);
+    } else if (!strcmp(name, "SAX function notationDecl")) {
+        ctxt->sax->notationDecl = *((notationDeclSAXFunc *) value);
+    } else if (!strcmp(name, "SAX function attributeDecl")) {
+        ctxt->sax->attributeDecl = *((attributeDeclSAXFunc *) value);
+    } else if (!strcmp(name, "SAX function elementDecl")) {
+        ctxt->sax->elementDecl = *((elementDeclSAXFunc *) value);
+    } else if (!strcmp(name, "SAX function unparsedEntityDecl")) {
+        ctxt->sax->unparsedEntityDecl =
+            *((unparsedEntityDeclSAXFunc *) value);
+    } else if (!strcmp(name, "SAX function setDocumentLocator")) {
+        ctxt->sax->setDocumentLocator =
+            *((setDocumentLocatorSAXFunc *) value);
+    } else if (!strcmp(name, "SAX function startDocument")) {
+        ctxt->sax->startDocument = *((startDocumentSAXFunc *) value);
+    } else if (!strcmp(name, "SAX function endDocument")) {
+        ctxt->sax->endDocument = *((endDocumentSAXFunc *) value);
+    } else if (!strcmp(name, "SAX function startElement")) {
+        ctxt->sax->startElement = *((startElementSAXFunc *) value);
+    } else if (!strcmp(name, "SAX function endElement")) {
+        ctxt->sax->endElement = *((endElementSAXFunc *) value);
+    } else if (!strcmp(name, "SAX function reference")) {
+        ctxt->sax->reference = *((referenceSAXFunc *) value);
+    } else if (!strcmp(name, "SAX function characters")) {
+        ctxt->sax->characters = *((charactersSAXFunc *) value);
+    } else if (!strcmp(name, "SAX function ignorableWhitespace")) {
+        ctxt->sax->ignorableWhitespace =
+            *((ignorableWhitespaceSAXFunc *) value);
+    } else if (!strcmp(name, "SAX function processingInstruction")) {
+        ctxt->sax->processingInstruction =
+            *((processingInstructionSAXFunc *) value);
+    } else if (!strcmp(name, "SAX function comment")) {
+        ctxt->sax->comment = *((commentSAXFunc *) value);
+    } else if (!strcmp(name, "SAX function warning")) {
+        ctxt->sax->warning = *((warningSAXFunc *) value);
+    } else if (!strcmp(name, "SAX function error")) {
+        ctxt->sax->error = *((errorSAXFunc *) value);
+    } else if (!strcmp(name, "SAX function fatalError")) {
+        ctxt->sax->fatalError = *((fatalErrorSAXFunc *) value);
+    } else if (!strcmp(name, "SAX function getParameterEntity")) {
+        ctxt->sax->getParameterEntity =
+            *((getParameterEntitySAXFunc *) value);
+    } else if (!strcmp(name, "SAX function cdataBlock")) {
+        ctxt->sax->cdataBlock = *((cdataBlockSAXFunc *) value);
+    } else if (!strcmp(name, "SAX function externalSubset")) {
+        ctxt->sax->externalSubset = *((externalSubsetSAXFunc *) value);
+    } else {
+        return (-1);
+    }
+    return (0);
+}
+
+/**
+ * xmlDecodeEntities:
+ * @ctxt:  the parser context
+ * @len:  the len to decode (in bytes !), -1 for no size limit
+ * @what:  combination of XML_SUBSTITUTE_REF and XML_SUBSTITUTE_PEREF
+ * @end:  an end marker xmlChar, 0 if none
+ * @end2:  an end marker xmlChar, 0 if none
+ * @end3:  an end marker xmlChar, 0 if none
+ * 
+ * This function is deprecated, we now always process entities content
+ * through xmlStringDecodeEntities
+ *
+ * TODO: remove it in next major release.
+ *
+ * [67] Reference ::= EntityRef | CharRef
+ *
+ * [69] PEReference ::= '%' Name ';'
+ *
+ * Returns A newly allocated string with the substitution done. The caller
+ *      must deallocate it !
+ */
+xmlChar *
+xmlDecodeEntities(xmlParserCtxtPtr ctxt ATTRIBUTE_UNUSED,
+                  int len ATTRIBUTE_UNUSED, int what ATTRIBUTE_UNUSED,
+                  xmlChar end ATTRIBUTE_UNUSED,
+                  xmlChar end2 ATTRIBUTE_UNUSED,
+                  xmlChar end3 ATTRIBUTE_UNUSED)
+{
+    static int deprecated = 0;
+
+    if (!deprecated) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlDecodeEntities() deprecated function reached\n");
+        deprecated = 1;
+    }
+    return (NULL);
+}
+
+/**
+ * xmlNamespaceParseNCName:
+ * @ctxt:  an XML parser context
+ *
+ * parse an XML namespace name.
+ *
+ * TODO: this seems not in use anymore, the namespace handling is done on
+ *       top of the SAX interfaces, i.e. not on raw input.
+ *
+ * [NS 3] NCName ::= (Letter | '_') (NCNameChar)*
+ *
+ * [NS 4] NCNameChar ::= Letter | Digit | '.' | '-' | '_' |
+ *                       CombiningChar | Extender
+ *
+ * Returns the namespace name or NULL
+ */
+
+xmlChar *
+xmlNamespaceParseNCName(xmlParserCtxtPtr ctxt ATTRIBUTE_UNUSED)
+{
+    static int deprecated = 0;
+
+    if (!deprecated) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlNamespaceParseNCName() deprecated function reached\n");
+        deprecated = 1;
+    }
+    return (NULL);
+}
+
+/**
+ * xmlNamespaceParseQName:
+ * @ctxt:  an XML parser context
+ * @prefix:  a xmlChar ** 
+ *
+ * TODO: this seems not in use anymore, the namespace handling is done on
+ *       top of the SAX interfaces, i.e. not on raw input.
+ *
+ * parse an XML qualified name
+ *
+ * [NS 5] QName ::= (Prefix ':')? LocalPart
+ *
+ * [NS 6] Prefix ::= NCName
+ *
+ * [NS 7] LocalPart ::= NCName
+ *
+ * Returns the local part, and prefix is updated
+ *   to get the Prefix if any.
+ */
+
+xmlChar *
+xmlNamespaceParseQName(xmlParserCtxtPtr ctxt ATTRIBUTE_UNUSED,
+                       xmlChar ** prefix ATTRIBUTE_UNUSED)
+{
+
+    static int deprecated = 0;
+
+    if (!deprecated) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlNamespaceParseQName() deprecated function reached\n");
+        deprecated = 1;
+    }
+    return (NULL);
+}
+
+/**
+ * xmlNamespaceParseNSDef:
+ * @ctxt:  an XML parser context
+ *
+ * parse a namespace prefix declaration
+ *
+ * TODO: this seems not in use anymore, the namespace handling is done on
+ *       top of the SAX interfaces, i.e. not on raw input.
+ *
+ * [NS 1] NSDef ::= PrefixDef Eq SystemLiteral
+ *
+ * [NS 2] PrefixDef ::= 'xmlns' (':' NCName)?
+ *
+ * Returns the namespace name
+ */
+
+xmlChar *
+xmlNamespaceParseNSDef(xmlParserCtxtPtr ctxt ATTRIBUTE_UNUSED)
+{
+    static int deprecated = 0;
+
+    if (!deprecated) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlNamespaceParseNSDef() deprecated function reached\n");
+        deprecated = 1;
+    }
+    return (NULL);
+}
+
+/**
+ * xmlParseQuotedString:
+ * @ctxt:  an XML parser context
+ *
+ * Parse and return a string between quotes or doublequotes
+ *
+ * TODO: Deprecated, to  be removed at next drop of binary compatibility
+ *
+ * Returns the string parser or NULL.
+ */
+xmlChar *
+xmlParseQuotedString(xmlParserCtxtPtr ctxt ATTRIBUTE_UNUSED)
+{
+    static int deprecated = 0;
+
+    if (!deprecated) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlParseQuotedString() deprecated function reached\n");
+        deprecated = 1;
+    }
+    return (NULL);
+}
+
+/**
+ * xmlParseNamespace:
+ * @ctxt:  an XML parser context
+ *
+ * xmlParseNamespace: parse specific PI '<?namespace ...' constructs.
+ *
+ * This is what the older xml-name Working Draft specified, a bunch of
+ * other stuff may still rely on it, so support is still here as
+ * if it was declared on the root of the Tree:-(
+ *
+ * TODO: remove from library
+ *
+ * To be removed at next drop of binary compatibility
+ */
+
+void
+xmlParseNamespace(xmlParserCtxtPtr ctxt ATTRIBUTE_UNUSED)
+{
+    static int deprecated = 0;
+
+    if (!deprecated) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlParseNamespace() deprecated function reached\n");
+        deprecated = 1;
+    }
+}
+
+/**
+ * xmlScanName:
+ * @ctxt:  an XML parser context
+ *
+ * Trickery: parse an XML name but without consuming the input flow
+ * Needed for rollback cases. Used only when parsing entities references.
+ *
+ * TODO: seems deprecated now, only used in the default part of
+ *       xmlParserHandleReference
+ *
+ * [4] NameChar ::= Letter | Digit | '.' | '-' | '_' | ':' |
+ *                  CombiningChar | Extender
+ *
+ * [5] Name ::= (Letter | '_' | ':') (NameChar)*
+ *
+ * [6] Names ::= Name (S Name)*
+ *
+ * Returns the Name parsed or NULL
+ */
+
+xmlChar *
+xmlScanName(xmlParserCtxtPtr ctxt ATTRIBUTE_UNUSED)
+{
+    static int deprecated = 0;
+
+    if (!deprecated) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlScanName() deprecated function reached\n");
+        deprecated = 1;
+    }
+    return (NULL);
+}
+
+/**
+ * xmlParserHandleReference:
+ * @ctxt:  the parser context
+ * 
+ * TODO: Remove, now deprecated ... the test is done directly in the
+ *       content parsing
+ * routines.
+ *
+ * [67] Reference ::= EntityRef | CharRef
+ *
+ * [68] EntityRef ::= '&' Name ';'
+ *
+ * [ WFC: Entity Declared ]
+ * the Name given in the entity reference must match that in an entity
+ * declaration, except that well-formed documents need not declare any
+ * of the following entities: amp, lt, gt, apos, quot. 
+ *
+ * [ WFC: Parsed Entity ]
+ * An entity reference must not contain the name of an unparsed entity
+ *
+ * [66] CharRef ::= '&#' [0-9]+ ';' |
+ *                  '&#x' [0-9a-fA-F]+ ';'
+ *
+ * A PEReference may have been detected in the current input stream
+ * the handling is done accordingly to 
+ *      http://www.w3.org/TR/REC-xml#entproc
+ */
+void
+xmlParserHandleReference(xmlParserCtxtPtr ctxt ATTRIBUTE_UNUSED)
+{
+    static int deprecated = 0;
+
+    if (!deprecated) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlParserHandleReference() deprecated function reached\n");
+        deprecated = 1;
+    }
+
+    return;
+}
+
+/**
+ * xmlHandleEntity:
+ * @ctxt:  an XML parser context
+ * @entity:  an XML entity pointer.
+ *
+ * Default handling of defined entities, when should we define a new input
+ * stream ? When do we just handle that as a set of chars ?
+ *
+ * OBSOLETE: to be removed at some point.
+ */
+
+void
+xmlHandleEntity(xmlParserCtxtPtr ctxt ATTRIBUTE_UNUSED,
+                xmlEntityPtr entity ATTRIBUTE_UNUSED)
+{
+    static int deprecated = 0;
+
+    if (!deprecated) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlHandleEntity() deprecated function reached\n");
+        deprecated = 1;
+    }
+}
+
+/**
+ * xmlNewGlobalNs:
+ * @doc:  the document carrying the namespace
+ * @href:  the URI associated
+ * @prefix:  the prefix for the namespace
+ *
+ * Creation of a Namespace, the old way using PI and without scoping
+ *   DEPRECATED !!!
+ * It now create a namespace on the root element of the document if found.
+ * Returns NULL this functionality had been removed
+ */
+xmlNsPtr
+xmlNewGlobalNs(xmlDocPtr doc ATTRIBUTE_UNUSED,
+               const xmlChar * href ATTRIBUTE_UNUSED,
+               const xmlChar * prefix ATTRIBUTE_UNUSED)
+{
+    static int deprecated = 0;
+
+    if (!deprecated) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlNewGlobalNs() deprecated function reached\n");
+        deprecated = 1;
+    }
+    return (NULL);
+}
+
+/**
+ * xmlUpgradeOldNs:
+ * @doc:  a document pointer
+ * 
+ * Upgrade old style Namespaces (PI) and move them to the root of the document.
+ * DEPRECATED
+ */
+void
+xmlUpgradeOldNs(xmlDocPtr doc ATTRIBUTE_UNUSED)
+{
+    static int deprecated = 0;
+
+    if (!deprecated) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlUpgradeOldNs() deprecated function reached\n");
+        deprecated = 1;
+    }
+}
+
+/**
+ * xmlEncodeEntities:
+ * @doc:  the document containing the string
+ * @input:  A string to convert to XML.
+ *
+ * TODO: remove xmlEncodeEntities, once we are not afraid of breaking binary
+ *       compatibility
+ *
+ * People must migrate their code to xmlEncodeEntitiesReentrant !
+ * This routine will issue a warning when encountered.
+ * 
+ * Returns NULL
+ */
+const xmlChar *
+xmlEncodeEntities(xmlDocPtr doc ATTRIBUTE_UNUSED,
+                  const xmlChar * input ATTRIBUTE_UNUSED)
+{
+    static int warning = 1;
+
+    if (warning) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "Deprecated API xmlEncodeEntities() used\n");
+        xmlGenericError(xmlGenericErrorContext,
+                        "   change code to use xmlEncodeEntitiesReentrant()\n");
+        warning = 0;
+    }
+    return (NULL);
+}
+
+/************************************************************************
+ *									*
+ *		Old set of SAXv1 functions 				*
+ *									*
+ ************************************************************************/
+static int deprecated_v1_msg = 0;
+
+#define DEPRECATED(n)						\
+    if (deprecated_v1_msg == 0)					\
+	xmlGenericError(xmlGenericErrorContext,			\
+	  "Use of deprecated SAXv1 function %s\n", n);		\
+    deprecated_v1_msg++;
+
+/**
+ * getPublicId:
+ * @ctx: the user data (XML parser context)
+ *
+ * Provides the public ID e.g. "-//SGMLSOURCE//DTD DEMO//EN"
+ * DEPRECATED: use xmlSAX2GetPublicId()
+ *
+ * Returns a xmlChar *
+ */
+const xmlChar *
+getPublicId(void *ctx)
+{
+    DEPRECATED("getPublicId")
+        return (xmlSAX2GetPublicId(ctx));
+}
+
+/**
+ * getSystemId:
+ * @ctx: the user data (XML parser context)
+ *
+ * Provides the system ID, basically URL or filename e.g.
+ * http://www.sgmlsource.com/dtds/memo.dtd
+ * DEPRECATED: use xmlSAX2GetSystemId()
+ *
+ * Returns a xmlChar *
+ */
+const xmlChar *
+getSystemId(void *ctx)
+{
+    DEPRECATED("getSystemId")
+        return (xmlSAX2GetSystemId(ctx));
+}
+
+/**
+ * getLineNumber:
+ * @ctx: the user data (XML parser context)
+ *
+ * Provide the line number of the current parsing point.
+ * DEPRECATED: use xmlSAX2GetLineNumber()
+ *
+ * Returns an int
+ */
+int
+getLineNumber(void *ctx)
+{
+    DEPRECATED("getLineNumber")
+        return (xmlSAX2GetLineNumber(ctx));
+}
+
+/**
+ * getColumnNumber:
+ * @ctx: the user data (XML parser context)
+ *
+ * Provide the column number of the current parsing point.
+ * DEPRECATED: use xmlSAX2GetColumnNumber()
+ *
+ * Returns an int
+ */
+int
+getColumnNumber(void *ctx)
+{
+    DEPRECATED("getColumnNumber")
+        return (xmlSAX2GetColumnNumber(ctx));
+}
+
+/**
+ * isStandalone:
+ * @ctx: the user data (XML parser context)
+ *
+ * Is this document tagged standalone ?
+ * DEPRECATED: use xmlSAX2IsStandalone()
+ *
+ * Returns 1 if true
+ */
+int
+isStandalone(void *ctx)
+{
+    DEPRECATED("isStandalone")
+        return (xmlSAX2IsStandalone(ctx));
+}
+
+/**
+ * hasInternalSubset:
+ * @ctx: the user data (XML parser context)
+ *
+ * Does this document has an internal subset
+ * DEPRECATED: use xmlSAX2HasInternalSubset()
+ *
+ * Returns 1 if true
+ */
+int
+hasInternalSubset(void *ctx)
+{
+    DEPRECATED("hasInternalSubset")
+        return (xmlSAX2HasInternalSubset(ctx));
+}
+
+/**
+ * hasExternalSubset:
+ * @ctx: the user data (XML parser context)
+ *
+ * Does this document has an external subset
+ * DEPRECATED: use xmlSAX2HasExternalSubset()
+ *
+ * Returns 1 if true
+ */
+int
+hasExternalSubset(void *ctx)
+{
+    DEPRECATED("hasExternalSubset")
+        return (xmlSAX2HasExternalSubset(ctx));
+}
+
+/**
+ * internalSubset:
+ * @ctx:  the user data (XML parser context)
+ * @name:  the root element name
+ * @ExternalID:  the external ID
+ * @SystemID:  the SYSTEM ID (e.g. filename or URL)
+ *
+ * Callback on internal subset declaration.
+ * DEPRECATED: use xmlSAX2InternalSubset()
+ */
+void
+internalSubset(void *ctx, const xmlChar * name,
+               const xmlChar * ExternalID, const xmlChar * SystemID)
+{
+    DEPRECATED("internalSubset")
+        xmlSAX2InternalSubset(ctx, name, ExternalID, SystemID);
+}
+
+/**
+ * externalSubset:
+ * @ctx: the user data (XML parser context)
+ * @name:  the root element name
+ * @ExternalID:  the external ID
+ * @SystemID:  the SYSTEM ID (e.g. filename or URL)
+ *
+ * Callback on external subset declaration.
+ * DEPRECATED: use xmlSAX2ExternalSubset()
+ */
+void
+externalSubset(void *ctx, const xmlChar * name,
+               const xmlChar * ExternalID, const xmlChar * SystemID)
+{
+    DEPRECATED("externalSubset")
+        xmlSAX2ExternalSubset(ctx, name, ExternalID, SystemID);
+}
+
+/**
+ * resolveEntity:
+ * @ctx: the user data (XML parser context)
+ * @publicId: The public ID of the entity
+ * @systemId: The system ID of the entity
+ *
+ * The entity loader, to control the loading of external entities,
+ * the application can either:
+ *    - override this resolveEntity() callback in the SAX block
+ *    - or better use the xmlSetExternalEntityLoader() function to
+ *      set up it's own entity resolution routine
+ * DEPRECATED: use xmlSAX2ResolveEntity()
+ *
+ * Returns the xmlParserInputPtr if inlined or NULL for DOM behaviour.
+ */
+xmlParserInputPtr
+resolveEntity(void *ctx, const xmlChar * publicId,
+              const xmlChar * systemId)
+{
+    DEPRECATED("resolveEntity")
+        return (xmlSAX2ResolveEntity(ctx, publicId, systemId));
+}
+
+/**
+ * getEntity:
+ * @ctx: the user data (XML parser context)
+ * @name: The entity name
+ *
+ * Get an entity by name
+ * DEPRECATED: use xmlSAX2GetEntity()
+ *
+ * Returns the xmlEntityPtr if found.
+ */
+xmlEntityPtr
+getEntity(void *ctx, const xmlChar * name)
+{
+    DEPRECATED("getEntity")
+        return (xmlSAX2GetEntity(ctx, name));
+}
+
+/**
+ * getParameterEntity:
+ * @ctx: the user data (XML parser context)
+ * @name: The entity name
+ *
+ * Get a parameter entity by name
+ * DEPRECATED: use xmlSAX2GetParameterEntity()
+ *
+ * Returns the xmlEntityPtr if found.
+ */
+xmlEntityPtr
+getParameterEntity(void *ctx, const xmlChar * name)
+{
+    DEPRECATED("getParameterEntity")
+        return (xmlSAX2GetParameterEntity(ctx, name));
+}
+
+
+/**
+ * entityDecl:
+ * @ctx: the user data (XML parser context)
+ * @name:  the entity name 
+ * @type:  the entity type 
+ * @publicId: The public ID of the entity
+ * @systemId: The system ID of the entity
+ * @content: the entity value (without processing).
+ *
+ * An entity definition has been parsed
+ * DEPRECATED: use xmlSAX2EntityDecl()
+ */
+void
+entityDecl(void *ctx, const xmlChar * name, int type,
+           const xmlChar * publicId, const xmlChar * systemId,
+           xmlChar * content)
+{
+    DEPRECATED("entityDecl")
+        xmlSAX2EntityDecl(ctx, name, type, publicId, systemId, content);
+}
+
+/**
+ * attributeDecl:
+ * @ctx: the user data (XML parser context)
+ * @elem:  the name of the element
+ * @fullname:  the attribute name 
+ * @type:  the attribute type 
+ * @def:  the type of default value
+ * @defaultValue: the attribute default value
+ * @tree:  the tree of enumerated value set
+ *
+ * An attribute definition has been parsed
+ * DEPRECATED: use xmlSAX2AttributeDecl()
+ */
+void
+attributeDecl(void *ctx, const xmlChar * elem, const xmlChar * fullname,
+              int type, int def, const xmlChar * defaultValue,
+              xmlEnumerationPtr tree)
+{
+    DEPRECATED("attributeDecl")
+        xmlSAX2AttributeDecl(ctx, elem, fullname, type, def, defaultValue,
+                             tree);
+}
+
+/**
+ * elementDecl:
+ * @ctx: the user data (XML parser context)
+ * @name:  the element name 
+ * @type:  the element type 
+ * @content: the element value tree
+ *
+ * An element definition has been parsed
+ * DEPRECATED: use xmlSAX2ElementDecl()
+ */
+void
+elementDecl(void *ctx, const xmlChar * name, int type,
+            xmlElementContentPtr content)
+{
+    DEPRECATED("elementDecl")
+        xmlSAX2ElementDecl(ctx, name, type, content);
+}
+
+/**
+ * notationDecl:
+ * @ctx: the user data (XML parser context)
+ * @name: The name of the notation
+ * @publicId: The public ID of the entity
+ * @systemId: The system ID of the entity
+ *
+ * What to do when a notation declaration has been parsed.
+ * DEPRECATED: use xmlSAX2NotationDecl()
+ */
+void
+notationDecl(void *ctx, const xmlChar * name,
+             const xmlChar * publicId, const xmlChar * systemId)
+{
+    DEPRECATED("notationDecl")
+        xmlSAX2NotationDecl(ctx, name, publicId, systemId);
+}
+
+/**
+ * unparsedEntityDecl:
+ * @ctx: the user data (XML parser context)
+ * @name: The name of the entity
+ * @publicId: The public ID of the entity
+ * @systemId: The system ID of the entity
+ * @notationName: the name of the notation
+ *
+ * What to do when an unparsed entity declaration is parsed
+ * DEPRECATED: use xmlSAX2UnparsedEntityDecl()
+ */
+void
+unparsedEntityDecl(void *ctx, const xmlChar * name,
+                   const xmlChar * publicId, const xmlChar * systemId,
+                   const xmlChar * notationName)
+{
+    DEPRECATED("unparsedEntityDecl")
+        xmlSAX2UnparsedEntityDecl(ctx, name, publicId, systemId,
+                                  notationName);
+}
+
+/**
+ * setDocumentLocator:
+ * @ctx: the user data (XML parser context)
+ * @loc: A SAX Locator
+ *
+ * Receive the document locator at startup, actually xmlDefaultSAXLocator
+ * Everything is available on the context, so this is useless in our case.
+ * DEPRECATED
+ */
+void
+setDocumentLocator(void *ctx ATTRIBUTE_UNUSED,
+                   xmlSAXLocatorPtr loc ATTRIBUTE_UNUSED)
+{
+    DEPRECATED("setDocumentLocator")
+}
+
+/**
+ * startDocument:
+ * @ctx: the user data (XML parser context)
+ *
+ * called when the document start being processed.
+ * DEPRECATED: use xmlSAX2StartDocument()
+ */
+void
+startDocument(void *ctx)
+{
+   /* don't be too painful for glade users */
+   /*  DEPRECATED("startDocument") */
+        xmlSAX2StartDocument(ctx);
+}
+
+/**
+ * endDocument:
+ * @ctx: the user data (XML parser context)
+ *
+ * called when the document end has been detected.
+ * DEPRECATED: use xmlSAX2EndDocument()
+ */
+void
+endDocument(void *ctx)
+{
+    DEPRECATED("endDocument")
+        xmlSAX2EndDocument(ctx);
+}
+
+/**
+ * attribute:
+ * @ctx: the user data (XML parser context)
+ * @fullname:  The attribute name, including namespace prefix
+ * @value:  The attribute value
+ *
+ * Handle an attribute that has been read by the parser.
+ * The default handling is to convert the attribute into an
+ * DOM subtree and past it in a new xmlAttr element added to
+ * the element.
+ * DEPRECATED: use xmlSAX2Attribute()
+ */
+void
+attribute(void *ctx ATTRIBUTE_UNUSED,
+          const xmlChar * fullname ATTRIBUTE_UNUSED,
+          const xmlChar * value ATTRIBUTE_UNUSED)
+{
+    DEPRECATED("attribute")
+}
+
+/**
+ * startElement:
+ * @ctx: the user data (XML parser context)
+ * @fullname:  The element name, including namespace prefix
+ * @atts:  An array of name/value attributes pairs, NULL terminated
+ *
+ * called when an opening tag has been processed.
+ * DEPRECATED: use xmlSAX2StartElement()
+ */
+void
+startElement(void *ctx, const xmlChar * fullname, const xmlChar ** atts)
+{
+    xmlSAX2StartElement(ctx, fullname, atts);
+}
+
+/**
+ * endElement:
+ * @ctx: the user data (XML parser context)
+ * @name:  The element name
+ *
+ * called when the end of an element has been detected.
+ * DEPRECATED: use xmlSAX2EndElement()
+ */
+void
+endElement(void *ctx, const xmlChar * name ATTRIBUTE_UNUSED)
+{
+    DEPRECATED("endElement")
+        xmlSAX2EndElement(ctx, name);
+}
+
+/**
+ * reference:
+ * @ctx: the user data (XML parser context)
+ * @name:  The entity name
+ *
+ * called when an entity reference is detected. 
+ * DEPRECATED: use xmlSAX2Reference()
+ */
+void
+reference(void *ctx, const xmlChar * name)
+{
+    DEPRECATED("reference")
+        xmlSAX2Reference(ctx, name);
+}
+
+/**
+ * characters:
+ * @ctx: the user data (XML parser context)
+ * @ch:  a xmlChar string
+ * @len: the number of xmlChar
+ *
+ * receiving some chars from the parser.
+ * DEPRECATED: use xmlSAX2Characters()
+ */
+void
+characters(void *ctx, const xmlChar * ch, int len)
+{
+    DEPRECATED("characters")
+        xmlSAX2Characters(ctx, ch, len);
+}
+
+/**
+ * ignorableWhitespace:
+ * @ctx: the user data (XML parser context)
+ * @ch:  a xmlChar string
+ * @len: the number of xmlChar
+ *
+ * receiving some ignorable whitespaces from the parser.
+ * UNUSED: by default the DOM building will use characters
+ * DEPRECATED: use xmlSAX2IgnorableWhitespace()
+ */
+void
+ignorableWhitespace(void *ctx ATTRIBUTE_UNUSED,
+                    const xmlChar * ch ATTRIBUTE_UNUSED,
+                    int len ATTRIBUTE_UNUSED)
+{
+    DEPRECATED("ignorableWhitespace")
+}
+
+/**
+ * processingInstruction:
+ * @ctx: the user data (XML parser context)
+ * @target:  the target name
+ * @data: the PI data's
+ *
+ * A processing instruction has been parsed.
+ * DEPRECATED: use xmlSAX2ProcessingInstruction()
+ */
+void
+processingInstruction(void *ctx, const xmlChar * target,
+                      const xmlChar * data)
+{
+    DEPRECATED("processingInstruction")
+        xmlSAX2ProcessingInstruction(ctx, target, data);
+}
+
+/**
+ * globalNamespace:
+ * @ctx: the user data (XML parser context)
+ * @href:  the namespace associated URN
+ * @prefix: the namespace prefix
+ *
+ * An old global namespace has been parsed.
+ * DEPRECATED
+ */
+void
+globalNamespace(void *ctx ATTRIBUTE_UNUSED,
+                const xmlChar * href ATTRIBUTE_UNUSED,
+                const xmlChar * prefix ATTRIBUTE_UNUSED)
+{
+    DEPRECATED("globalNamespace")
+}
+
+/**
+ * setNamespace:
+ * @ctx: the user data (XML parser context)
+ * @name:  the namespace prefix
+ *
+ * Set the current element namespace.
+ * DEPRECATED
+ */
+
+void
+setNamespace(void *ctx ATTRIBUTE_UNUSED,
+             const xmlChar * name ATTRIBUTE_UNUSED)
+{
+    DEPRECATED("setNamespace")
+}
+
+/**
+ * getNamespace:
+ * @ctx: the user data (XML parser context)
+ *
+ * Get the current element namespace.
+ * DEPRECATED
+ *
+ * Returns the xmlNsPtr or NULL if none
+ */
+
+xmlNsPtr
+getNamespace(void *ctx ATTRIBUTE_UNUSED)
+{
+    DEPRECATED("getNamespace")
+        return (NULL);
+}
+
+/**
+ * checkNamespace:
+ * @ctx: the user data (XML parser context)
+ * @namespace: the namespace to check against
+ *
+ * Check that the current element namespace is the same as the
+ * one read upon parsing.
+ * DEPRECATED
+ *
+ * Returns 1 if true 0 otherwise
+ */
+
+int
+checkNamespace(void *ctx ATTRIBUTE_UNUSED,
+               xmlChar * namespace ATTRIBUTE_UNUSED)
+{
+    DEPRECATED("checkNamespace")
+        return (0);
+}
+
+/**
+ * namespaceDecl:
+ * @ctx: the user data (XML parser context)
+ * @href:  the namespace associated URN
+ * @prefix: the namespace prefix
+ *
+ * A namespace has been parsed.
+ * DEPRECATED
+ */
+void
+namespaceDecl(void *ctx ATTRIBUTE_UNUSED,
+              const xmlChar * href ATTRIBUTE_UNUSED,
+              const xmlChar * prefix ATTRIBUTE_UNUSED)
+{
+    DEPRECATED("namespaceDecl")
+}
+
+/**
+ * comment:
+ * @ctx: the user data (XML parser context)
+ * @value:  the comment content
+ *
+ * A comment has been parsed.
+ * DEPRECATED: use xmlSAX2Comment()
+ */
+void
+comment(void *ctx, const xmlChar * value)
+{
+    DEPRECATED("comment")
+        xmlSAX2Comment(ctx, value);
+}
+
+/**
+ * cdataBlock:
+ * @ctx: the user data (XML parser context)
+ * @value:  The pcdata content
+ * @len:  the block length
+ *
+ * called when a pcdata block has been parsed
+ * DEPRECATED: use xmlSAX2CDataBlock()
+ */
+void
+cdataBlock(void *ctx, const xmlChar * value, int len)
+{
+    DEPRECATED("cdataBlock")
+        xmlSAX2CDataBlock(ctx, value, len);
+}
+#endif /* LIBXML_LEGACY_ENABLED */
+
diff --git a/src/libxml/src/libxml.c b/src/libxml/src/libxml.c
new file mode 100644
index 0000000..dbf2304
--- /dev/null
+++ b/src/libxml/src/libxml.c
@@ -0,0 +1,19 @@
+/*----------------------------------------------------------------------------*/
+/* $Workfile:   libxml.c  $                                                   */
+/*----------------------------------------------------------------------------*/
+/* $Author: agibert $                                                      */
+/* $Date: 2008/11/12 02:25:23 $                                           */
+/* $Revision: 1.1 $                                                       */
+/* $Label:  $                                                         */
+/*----------------------------------------------------------------------------*/
+
+
+
+char IMRG_XML_WHAT_IDENT[] = "@(#) VERSIONIMR: $Label:  $   $Date: 2008/11/12 02:25:23 $   $Workfile:   libxml.c  $";
+
+
+
+void libxml_dummy(void)
+{
+    int i=0;
+}
diff --git a/src/libxml/src/libxml.h b/src/libxml/src/libxml.h
new file mode 100644
index 0000000..69e02a2
--- /dev/null
+++ b/src/libxml/src/libxml.h
@@ -0,0 +1,52 @@
+/*
+ * libxml.h: internal header only used during the compilation of libxml
+ *
+ * See COPYRIGHT for the status of this software
+ *
+ * Author: breese@users.sourceforge.net
+ */
+
+#ifndef __XML_LIBXML_H__
+#define __XML_LIBXML_H__
+
+#ifndef NO_LARGEFILE_SOURCE
+#ifndef _LARGEFILE_SOURCE
+#define _LARGEFILE_SOURCE
+#endif
+#ifndef _FILE_OFFSET_BITS
+#define _FILE_OFFSET_BITS 64
+#endif
+#endif
+
+#if defined(macintosh)
+#include "config-mac.h"
+#else
+#include "config.h"
+#include <libxml/xmlversion.h>
+#endif
+
+#ifndef WITH_TRIO
+#include <stdio.h>
+#else
+/**
+ * TRIO_REPLACE_STDIO:
+ *
+ * This macro is defined if teh trio string formatting functions are to
+ * be used instead of the default stdio ones.
+ */
+#define TRIO_REPLACE_STDIO
+#include "trio.h"
+#endif
+
+/*
+ * Internal variable indicating if a callback has been registered for
+ * node creation/destruction. It avoids spending a lot of time in locking
+ * function while checking if the callback exists.
+ */
+extern int __xmlRegisterCallbacks;
+/*
+ * internal error reporting routines, shared but not partof the API.
+ */
+void __xmlIOErr(int domain, int code, const char *extra);
+void __xmlLoaderErr(void *ctx, const char *msg, const char *filename);
+#endif /* ! __XML_LIBXML_H__ */
diff --git a/src/libxml/src/list.c b/src/libxml/src/list.c
new file mode 100644
index 0000000..18a8297
--- /dev/null
+++ b/src/libxml/src/list.c
@@ -0,0 +1,720 @@
+/*
+ * list.c: lists handling implementation
+ *
+ * Copyright (C) 2000 Gary Pennington and Daniel Veillard.
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
+ * MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE AUTHORS AND
+ * CONTRIBUTORS ACCEPT NO RESPONSIBILITY IN ANY CONCEIVABLE MANNER.
+ *
+ * Author: Gary.Pennington@uk.sun.com
+ */
+
+#define IN_LIBXML
+#include "libxml.h"
+
+#include <stdlib.h>
+#include <string.h>
+#include <libxml/xmlmemory.h>
+#include <libxml/list.h>
+#include <libxml/globals.h>
+
+/*
+ * Type definition are kept internal
+ */
+
+struct _xmlLink
+{
+    struct _xmlLink *next;
+    struct _xmlLink *prev;
+    void *data;
+};
+
+struct _xmlList
+{
+    xmlLinkPtr sentinel;
+    void (*linkDeallocator)(xmlLinkPtr );
+    int (*linkCompare)(const void *, const void*);
+};
+
+/************************************************************************
+ *                                    *
+ *                Interfaces                *
+ *                                    *
+ ************************************************************************/
+
+/**
+ * xmlLinkDeallocator:
+ * @l:  a list
+ * @lk:  a link
+ *
+ * Unlink and deallocate @lk from list @l
+ */
+static void
+xmlLinkDeallocator(xmlListPtr l, xmlLinkPtr lk)
+{
+    (lk->prev)->next = lk->next;
+    (lk->next)->prev = lk->prev;
+    if(l->linkDeallocator)
+        l->linkDeallocator(lk);
+    xmlFree(lk);
+}
+
+/**
+ * xmlLinkCompare:
+ * @data0:  first data
+ * @data1:  second data
+ *
+ * Compares two arbitrary data
+ *
+ * Returns -1, 0 or 1 depending on whether data1 is greater equal or smaller
+ *          than data0
+ */
+static int
+xmlLinkCompare(const void *data0, const void *data1)
+{
+    if (data0 < data1)
+        return (-1);
+    else if (data0 == data1)
+	return (0);
+    return (1);
+}
+
+/**
+ * xmlListLowerSearch:
+ * @l:  a list
+ * @data:  a data
+ *
+ * Search data in the ordered list walking from the beginning
+ *
+ * Returns the link containing the data or NULL
+ */
+static xmlLinkPtr 
+xmlListLowerSearch(xmlListPtr l, void *data) 
+{
+    xmlLinkPtr lk;
+
+    for(lk = l->sentinel->next;lk != l->sentinel && l->linkCompare(lk->data, data) <0 ;lk = lk->next);
+    return lk;    
+}
+
+/**
+ * xmlListHigherSearch:
+ * @l:  a list
+ * @data:  a data
+ *
+ * Search data in the ordered list walking backward from the end
+ *
+ * Returns the link containing the data or NULL
+ */
+static xmlLinkPtr 
+xmlListHigherSearch(xmlListPtr l, void *data) 
+{
+    xmlLinkPtr lk;
+
+    for(lk = l->sentinel->prev;lk != l->sentinel && l->linkCompare(lk->data, data) >0 ;lk = lk->prev);
+    return lk;    
+}
+
+/**
+ * xmlListSearch:
+ * @l:  a list
+ * @data:  a data
+ *
+ * Search data in the list
+ *
+ * Returns the link containing the data or NULL
+ */
+static xmlLinkPtr 
+xmlListLinkSearch(xmlListPtr l, void *data) 
+{
+    xmlLinkPtr lk;
+    lk = xmlListLowerSearch(l, data);
+    if (lk == l->sentinel)
+        return NULL;
+    else {
+        if (l->linkCompare(lk->data, data) ==0)
+            return lk;
+        return NULL;
+    }
+}
+
+/**
+ * xmlListLinkReverseSearch:
+ * @l:  a list
+ * @data:  a data
+ *
+ * Search data in the list processing backward
+ *
+ * Returns the link containing the data or NULL
+ */
+static xmlLinkPtr 
+xmlListLinkReverseSearch(xmlListPtr l, void *data) 
+{
+    xmlLinkPtr lk;
+    lk = xmlListHigherSearch(l, data);
+    if (lk == l->sentinel)
+        return NULL;
+    else {
+        if (l->linkCompare(lk->data, data) ==0)
+            return lk;
+        return NULL;
+    }
+}
+
+/**
+ * xmlListCreate:
+ * @deallocator:  an optional deallocator function
+ * @compare:  an optional comparison function
+ *
+ * Create a new list
+ *
+ * Returns the new list or NULL in case of error
+ */
+xmlListPtr
+xmlListCreate(xmlListDeallocator deallocator, xmlListDataCompare compare)
+{
+    xmlListPtr l;
+    if (NULL == (l = (xmlListPtr )xmlMalloc( sizeof(xmlList)))) {
+        xmlGenericError(xmlGenericErrorContext, 
+		        "Cannot initialize memory for list");
+        return (NULL);
+    }
+    /* Initialize the list to NULL */
+    memset(l, 0, sizeof(xmlList));
+    
+    /* Add the sentinel */
+    if (NULL ==(l->sentinel = (xmlLinkPtr )xmlMalloc(sizeof(xmlLink)))) {
+        xmlGenericError(xmlGenericErrorContext, 
+		        "Cannot initialize memory for sentinel");
+	xmlFree(l);
+        return (NULL);
+    }
+    l->sentinel->next = l->sentinel;
+    l->sentinel->prev = l->sentinel;
+    l->sentinel->data = NULL;
+    
+    /* If there is a link deallocator, use it */
+    if (deallocator != NULL)
+        l->linkDeallocator = deallocator;
+    /* If there is a link comparator, use it */
+    if (compare != NULL)
+        l->linkCompare = compare;
+    else /* Use our own */
+        l->linkCompare = xmlLinkCompare;
+    return l;
+}
+    
+/**
+ * xmlListSearch:
+ * @l:  a list
+ * @data:  a search value
+ *
+ * Search the list for an existing value of @data
+ *
+ * Returns the value associated to @data or NULL in case of error
+ */
+void *
+xmlListSearch(xmlListPtr l, void *data) 
+{
+    xmlLinkPtr lk;
+    lk = xmlListLinkSearch(l, data);
+    if (lk)
+        return (lk->data);
+    return NULL;
+}
+
+/**
+ * xmlListReverseSearch:
+ * @l:  a list
+ * @data:  a search value
+ *
+ * Search the list in reverse order for an existing value of @data
+ *
+ * Returns the value associated to @data or NULL in case of error
+ */
+void *
+xmlListReverseSearch(xmlListPtr l, void *data) 
+{
+    xmlLinkPtr lk;
+    lk = xmlListLinkReverseSearch(l, data);
+    if (lk)
+        return (lk->data);
+    return NULL;
+}
+
+/**
+ * xmlListInsert:
+ * @l:  a list
+ * @data:  the data
+ *
+ * Insert data in the ordered list at the beginning for this value
+ *
+ * Returns 0 in case of success, 1 in case of failure
+ */
+int
+xmlListInsert(xmlListPtr l, void *data) 
+{
+    xmlLinkPtr lkPlace, lkNew;
+
+    lkPlace = xmlListLowerSearch(l, data);
+    /* Add the new link */
+    lkNew = (xmlLinkPtr) xmlMalloc(sizeof(xmlLink));
+    if (lkNew == NULL) {
+        xmlGenericError(xmlGenericErrorContext, 
+		        "Cannot initialize memory for new link");
+        return (1);
+    }
+    lkNew->data = data;
+    lkPlace = lkPlace->prev;
+    lkNew->next = lkPlace->next;
+    (lkPlace->next)->prev = lkNew;
+    lkPlace->next = lkNew;
+    lkNew->prev = lkPlace;
+    return 0;
+}
+
+/**
+ * xmlListAppend:
+ * @l:  a list
+ * @data:  the data
+ *
+ * Insert data in the ordered list at the end for this value
+ *
+ * Returns 0 in case of success, 1 in case of failure
+ */
+int xmlListAppend(xmlListPtr l, void *data) 
+{
+    xmlLinkPtr lkPlace, lkNew;
+
+    lkPlace = xmlListHigherSearch(l, data);
+    /* Add the new link */
+    lkNew = (xmlLinkPtr) xmlMalloc(sizeof(xmlLink));
+    if (lkNew == NULL) {
+        xmlGenericError(xmlGenericErrorContext, 
+		        "Cannot initialize memory for new link");
+        return (0);
+    }
+    lkNew->data = data;
+    lkNew->next = lkPlace->next;
+    (lkPlace->next)->prev = lkNew;
+    lkPlace->next = lkNew;
+    lkNew->prev = lkPlace;
+    return 1;
+}
+
+/**
+ * xmlListDelete:
+ * @l:  a list
+ *
+ * Deletes the list and its associated data
+ */
+void xmlListDelete(xmlListPtr l)
+{
+    xmlListClear(l);
+    xmlFree(l->sentinel);
+    xmlFree(l);
+}
+
+/**
+ * xmlListRemoveFirst:
+ * @l:  a list
+ * @data:  list data
+ *
+ * Remove the first instance associated to data in the list
+ *
+ * Returns 1 if a deallocation occured, or 0 if not found
+ */
+int
+xmlListRemoveFirst(xmlListPtr l, void *data)
+{
+    xmlLinkPtr lk;
+    
+    /*Find the first instance of this data */
+    lk = xmlListLinkSearch(l, data);
+    if (lk != NULL) {
+        xmlLinkDeallocator(l, lk);
+        return 1;
+    }
+    return 0;
+}
+
+/**
+ * xmlListRemoveLast:
+ * @l:  a list
+ * @data:  list data
+ *
+ * Remove the last instance associated to data in the list
+ *
+ * Returns 1 if a deallocation occured, or 0 if not found
+ */
+int
+xmlListRemoveLast(xmlListPtr l, void *data)
+{
+    xmlLinkPtr lk;
+    
+    /*Find the last instance of this data */
+    lk = xmlListLinkReverseSearch(l, data);
+    if (lk != NULL) {
+	xmlLinkDeallocator(l, lk);
+        return 1;
+    }
+    return 0;
+}
+
+/**
+ * xmlListRemoveAll:
+ * @l:  a list
+ * @data:  list data
+ *
+ * Remove the all instance associated to data in the list
+ *
+ * Returns the number of deallocation, or 0 if not found
+ */
+int
+xmlListRemoveAll(xmlListPtr l, void *data)
+{
+    int count=0;
+    
+
+    while(xmlListRemoveFirst(l, data))
+        count++;
+    return count;
+}
+
+/**
+ * xmlListClear:
+ * @l:  a list
+ *
+ * Remove the all data in the list
+ */
+void
+xmlListClear(xmlListPtr l)
+{
+    xmlLinkPtr  lk = l->sentinel->next;
+    
+    while(lk != l->sentinel) {
+        xmlLinkPtr next = lk->next;
+
+        xmlLinkDeallocator(l, lk);
+        lk = next;
+    }
+}
+
+/**
+ * xmlListEmpty:
+ * @l:  a list
+ *
+ * Is the list empty ?
+ *
+ * Returns 1 if the list is empty, 0 otherwise
+ */
+int
+xmlListEmpty(xmlListPtr l)
+{
+    return (l->sentinel->next == l->sentinel);
+}
+
+/**
+ * xmlListFront:
+ * @l:  a list
+ *
+ * Get the first element in the list
+ *
+ * Returns the first element in the list, or NULL
+ */
+xmlLinkPtr 
+xmlListFront(xmlListPtr l)
+{
+    return (l->sentinel->next);
+}
+    
+/**
+ * xmlListEnd:
+ * @l:  a list
+ *
+ * Get the last element in the list
+ *
+ * Returns the last element in the list, or NULL
+ */
+xmlLinkPtr 
+xmlListEnd(xmlListPtr l)
+{
+    return (l->sentinel->prev);
+}
+    
+/**
+ * xmlListSize:
+ * @l:  a list
+ *
+ * Get the number of elements in the list
+ *
+ * Returns the number of elements in the list
+ */
+int
+xmlListSize(xmlListPtr l)
+{
+    xmlLinkPtr lk;
+    int count=0;
+
+    /* TODO: keep a counter in xmlList instead */
+    for(lk = l->sentinel->next; lk != l->sentinel; lk = lk->next, count++);
+    return count;
+}
+
+/**
+ * xmlListPopFront:
+ * @l:  a list
+ *
+ * Removes the first element in the list
+ */
+void
+xmlListPopFront(xmlListPtr l)
+{
+    if(!xmlListEmpty(l))
+        xmlLinkDeallocator(l, l->sentinel->next);
+}
+
+/**
+ * xmlListPopBack:
+ * @l:  a list
+ *
+ * Removes the last element in the list
+ */
+void
+xmlListPopBack(xmlListPtr l)
+{
+    if(!xmlListEmpty(l))
+        xmlLinkDeallocator(l, l->sentinel->prev);
+}
+
+/**
+ * xmlListPushFront:
+ * @l:  a list
+ * @data:  new data
+ *
+ * add the new data at the beginning of the list
+ *
+ * Returns 1 if successful, 0 otherwise
+ */
+int
+xmlListPushFront(xmlListPtr l, void *data) 
+{
+    xmlLinkPtr lkPlace, lkNew;
+
+    lkPlace = l->sentinel;
+    /* Add the new link */
+    lkNew = (xmlLinkPtr) xmlMalloc(sizeof(xmlLink));
+    if (lkNew == NULL) {
+        xmlGenericError(xmlGenericErrorContext, 
+		        "Cannot initialize memory for new link");
+        return (0);
+    }
+    lkNew->data = data;
+    lkNew->next = lkPlace->next;
+    (lkPlace->next)->prev = lkNew;
+    lkPlace->next = lkNew;
+    lkNew->prev = lkPlace;
+    return 1;
+}
+
+/**
+ * xmlListPushBack:
+ * @l:  a list
+ * @data:  new data
+ *
+ * add the new data at the end of the list
+ *
+ * Returns 1 if successful, 0 otherwise
+ */
+int
+xmlListPushBack(xmlListPtr l, void *data) 
+{
+    xmlLinkPtr lkPlace, lkNew;
+
+    lkPlace = l->sentinel->prev;
+    /* Add the new link */
+    if (NULL ==(lkNew = (xmlLinkPtr )xmlMalloc(sizeof(xmlLink)))) {
+        xmlGenericError(xmlGenericErrorContext, 
+		        "Cannot initialize memory for new link");
+        return (0);
+    }
+    lkNew->data = data;
+    lkNew->next = lkPlace->next;
+    (lkPlace->next)->prev = lkNew;
+    lkPlace->next = lkNew;
+    lkNew->prev = lkPlace;
+    return 1;
+}
+
+/**
+ * xmlLinkGetData:
+ * @lk:  a link
+ *
+ * See Returns.
+ *
+ * Returns a pointer to the data referenced from this link
+ */
+void *
+xmlLinkGetData(xmlLinkPtr lk)
+{
+    return lk->data;
+}
+
+/**
+ * xmlListReverse:
+ * @l:  a list
+ *
+ * Reverse the order of the elements in the list
+ */
+void
+xmlListReverse(xmlListPtr l) {
+  xmlLinkPtr lk;
+  xmlLinkPtr lkPrev = l->sentinel;
+  
+  for(lk = l->sentinel->next; lk != l->sentinel; lk = lk->next) {
+    lkPrev->next = lkPrev->prev;
+    lkPrev->prev = lk;
+    lkPrev = lk;
+  }
+  /* Fix up the last node */
+  lkPrev->next = lkPrev->prev;
+  lkPrev->prev = lk;
+}
+
+/**
+ * xmlListSort:
+ * @l:  a list
+ *
+ * Sort all the elements in the list
+ */
+void
+xmlListSort(xmlListPtr l)
+{
+    xmlListPtr lTemp;
+    
+    if(xmlListEmpty(l))
+        return;
+
+    /* I think that the real answer is to implement quicksort, the
+     * alternative is to implement some list copying procedure which
+     * would be based on a list copy followed by a clear followed by
+     * an insert. This is slow...
+     */
+
+    if (NULL ==(lTemp = xmlListDup(l)))
+        return;
+    xmlListClear(l);
+    xmlListMerge(l, lTemp);
+    xmlListDelete(lTemp);
+    return;
+}
+
+/**
+ * xmlListWalk:
+ * @l:  a list
+ * @walker:  a processing function
+ * @user:  a user parameter passed to the walker function
+ *
+ * Walk all the element of the first from first to last and
+ * apply the walker function to it
+ */
+void
+xmlListWalk(xmlListPtr l, xmlListWalker walker, const void *user) {
+    xmlLinkPtr lk;
+
+    for(lk = l->sentinel->next; lk != l->sentinel; lk = lk->next) {
+        if((walker(lk->data, user)) == 0)
+                break;
+    }
+}
+
+/**
+ * xmlListReverseWalk:
+ * @l:  a list
+ * @walker:  a processing function
+ * @user:  a user parameter passed to the walker function
+ *
+ * Walk all the element of the list in reverse order and
+ * apply the walker function to it
+ */
+void
+xmlListReverseWalk(xmlListPtr l, xmlListWalker walker, const void *user) {
+    xmlLinkPtr lk;
+
+    for(lk = l->sentinel->prev; lk != l->sentinel; lk = lk->prev) {
+        if((walker(lk->data, user)) == 0)
+                break;
+    }
+}
+
+/**
+ * xmlListMerge:
+ * @l1:  the original list
+ * @l2:  the new list
+ *
+ * include all the elements of the second list in the first one and
+ * clear the second list
+ */
+void
+xmlListMerge(xmlListPtr l1, xmlListPtr l2)
+{
+    xmlListCopy(l1, l2);
+    xmlListClear(l2);
+}
+
+/**
+ * xmlListDup:
+ * @old:  the list
+ *
+ * Duplicate the list
+ * 
+ * Returns a new copy of the list or NULL in case of error
+ */
+xmlListPtr 
+xmlListDup(const xmlListPtr old)
+{
+    xmlListPtr cur;
+    /* Hmmm, how to best deal with allocation issues when copying
+     * lists. If there is a de-allocator, should responsibility lie with
+     * the new list or the old list. Surely not both. I'll arbitrarily
+     * set it to be the old list for the time being whilst I work out
+     * the answer
+     */
+    if (NULL ==(cur = xmlListCreate(NULL, old->linkCompare)))
+        return (NULL);
+    if (0 != xmlListCopy(cur, old))
+        return NULL;
+    return cur;
+}
+
+/**
+ * xmlListCopy:
+ * @cur:  the new list
+ * @old:  the old list
+ *
+ * Move all the element from the old list in the new list
+ * 
+ * Returns 0 in case of success 1 in case of error
+ */
+int
+xmlListCopy(xmlListPtr cur, const xmlListPtr old)
+{
+    /* Walk the old tree and insert the data into the new one */
+    xmlLinkPtr lk;
+
+    for(lk = old->sentinel->next; lk != old->sentinel; lk = lk->next) {
+        if (0 !=xmlListInsert(cur, lk->data)) {
+            xmlListDelete(cur);
+            return (1);
+        }
+    }
+    return (0);    
+}
+/* xmlListUnique() */
+/* xmlListSwap */
diff --git a/src/libxml/src/nanoftp.c b/src/libxml/src/nanoftp.c
new file mode 100644
index 0000000..a2ecc40
--- /dev/null
+++ b/src/libxml/src/nanoftp.c
@@ -0,0 +1,2276 @@
+/*
+ * nanoftp.c: basic FTP client support
+ *
+ *  Reference: RFC 959
+ */
+
+#ifdef TESTING
+#define STANDALONE
+#define HAVE_STDLIB_H
+#define HAVE_UNISTD_H
+#define HAVE_SYS_SOCKET_H
+#define HAVE_NETINET_IN_H
+#define HAVE_NETDB_H
+#define HAVE_SYS_TIME_H
+#else /* TESTING */
+#define NEED_SOCKETS
+#endif /* TESTING */
+
+#define IN_LIBXML
+#include "libxml.h"
+
+#ifdef LIBXML_FTP_ENABLED
+#include <string.h>
+
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
+#ifdef HAVE_ARPA_INET_H
+#include <arpa/inet.h>
+#endif
+#ifdef HAVE_NETDB_H
+#include <netdb.h>
+#endif
+#ifdef HAVE_FCNTL_H
+#include <fcntl.h> 
+#endif
+#ifdef HAVE_ERRNO_H
+#include <errno.h>
+#endif
+#ifdef HAVE_SYS_TIME_H
+#include <sys/time.h>
+#endif
+#ifdef HAVE_SYS_SELECT_H
+#include <sys/select.h>
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_STRINGS_H
+#include <strings.h>
+#endif
+
+#include <libxml/xmlmemory.h>
+#include <libxml/parser.h>
+#include <libxml/xmlerror.h>
+#include <libxml/uri.h>
+#include <libxml/nanoftp.h>
+#include <libxml/globals.h>
+
+/* #define DEBUG_FTP 1  */
+#ifdef STANDALONE
+#ifndef DEBUG_FTP
+#define DEBUG_FTP 1
+#endif
+#endif
+
+
+#ifdef __MINGW32__
+#define _WINSOCKAPI_
+#include <wsockcompat.h>
+#include <winsock2.h>
+#undef SOCKLEN_T
+#define SOCKLEN_T unsigned int
+#endif
+
+
+/**
+ * A couple portability macros
+ */
+#ifndef _WINSOCKAPI_
+#ifndef __BEOS__
+#define closesocket(s) close(s)
+#endif
+#define SOCKET int
+#endif
+#if defined(VMS) || defined(__VMS)
+#define SOCKLEN_T unsigned int
+#endif
+
+#ifdef __BEOS__
+#ifndef PF_INET
+#define PF_INET AF_INET
+#endif
+#endif
+
+
+#define FTP_COMMAND_OK		200
+#define FTP_SYNTAX_ERROR	500
+#define FTP_GET_PASSWD		331
+#define FTP_BUF_SIZE		512
+
+#define XML_NANO_MAX_URLBUF	4096
+
+typedef struct xmlNanoFTPCtxt {
+    char *protocol;	/* the protocol name */
+    char *hostname;	/* the host name */
+    int port;		/* the port */
+    char *path;		/* the path within the URL */
+    char *user;		/* user string */
+    char *passwd;	/* passwd string */
+#ifdef SUPPORT_IP6
+    struct sockaddr_storage ftpAddr; /* this is large enough to hold IPv6 address*/
+#else
+    struct sockaddr_in ftpAddr; /* the socket address struct */
+#endif
+    int passive;	/* currently we support only passive !!! */
+    SOCKET controlFd;	/* the file descriptor for the control socket */
+    SOCKET dataFd;	/* the file descriptor for the data socket */
+    int state;		/* WRITE / READ / CLOSED */
+    int returnValue;	/* the protocol return value */
+    /* buffer for data received from the control connection */
+    char controlBuf[FTP_BUF_SIZE + 1];
+    int controlBufIndex;
+    int controlBufUsed;
+    int controlBufAnswer;
+} xmlNanoFTPCtxt, *xmlNanoFTPCtxtPtr;
+
+static int initialized = 0;
+static char *proxy = NULL;	/* the proxy name if any */
+static int proxyPort = 0;	/* the proxy port if any */
+static char *proxyUser = NULL;	/* user for proxy authentication */
+static char *proxyPasswd = NULL;/* passwd for proxy authentication */
+static int proxyType = 0;	/* uses TYPE or a@b ? */
+
+#ifdef SUPPORT_IP6
+static
+int have_ipv6(void) {
+    int s;
+
+    s = socket (AF_INET6, SOCK_STREAM, 0);
+    if (s != -1) {
+	close (s);
+	return (1);
+    }
+    return (0);
+}
+#endif
+
+/**
+ * xmlFTPErrMemory:
+ * @extra:  extra informations
+ *
+ * Handle an out of memory condition
+ */
+static void
+xmlFTPErrMemory(const char *extra)
+{
+    __xmlSimpleError(XML_FROM_FTP, XML_ERR_NO_MEMORY, NULL, NULL, extra);
+}
+
+/**
+ * xmlNanoFTPInit:
+ *
+ * Initialize the FTP protocol layer.
+ * Currently it just checks for proxy informations,
+ * and get the hostname
+ */
+
+void
+xmlNanoFTPInit(void) {
+    const char *env;
+#ifdef _WINSOCKAPI_
+    WSADATA wsaData;    
+#endif
+
+    if (initialized)
+	return;
+
+#ifdef _WINSOCKAPI_
+    if (WSAStartup(MAKEWORD(1, 1), &wsaData) != 0)
+	return;
+#endif
+
+    proxyPort = 21;
+    env = getenv("no_proxy");
+    if (env != NULL)
+	return;
+    env = getenv("ftp_proxy");
+    if (env != NULL) {
+	xmlNanoFTPScanProxy(env);
+    } else {
+	env = getenv("FTP_PROXY");
+	if (env != NULL) {
+	    xmlNanoFTPScanProxy(env);
+	}
+    }
+    env = getenv("ftp_proxy_user");
+    if (env != NULL) {
+	proxyUser = xmlMemStrdup(env);
+    }
+    env = getenv("ftp_proxy_password");
+    if (env != NULL) {
+	proxyPasswd = xmlMemStrdup(env);
+    }
+    initialized = 1;
+}
+
+/**
+ * xmlNanoFTPCleanup:
+ *
+ * Cleanup the FTP protocol layer. This cleanup proxy informations.
+ */
+
+void
+xmlNanoFTPCleanup(void) {
+    if (proxy != NULL) {
+	xmlFree(proxy);
+	proxy = NULL;
+    }
+    if (proxyUser != NULL) {
+	xmlFree(proxyUser);
+	proxyUser = NULL;
+    }
+    if (proxyPasswd != NULL) {
+	xmlFree(proxyPasswd);
+	proxyPasswd = NULL;
+    }
+#ifdef _WINSOCKAPI_
+    if (initialized)
+	WSACleanup();
+#endif
+    initialized = 0;
+}
+
+/**
+ * xmlNanoFTPProxy:
+ * @host:  the proxy host name
+ * @port:  the proxy port
+ * @user:  the proxy user name
+ * @passwd:  the proxy password
+ * @type:  the type of proxy 1 for using SITE, 2 for USER a@b
+ *
+ * Setup the FTP proxy informations.
+ * This can also be done by using ftp_proxy ftp_proxy_user and
+ * ftp_proxy_password environment variables.
+ */
+
+void
+xmlNanoFTPProxy(const char *host, int port, const char *user,
+	        const char *passwd, int type) {
+    if (proxy != NULL)
+	xmlFree(proxy);
+    if (proxyUser != NULL)
+	xmlFree(proxyUser);
+    if (proxyPasswd != NULL)
+	xmlFree(proxyPasswd);
+    if (host)
+	proxy = xmlMemStrdup(host);
+    if (user)
+	proxyUser = xmlMemStrdup(user);
+    if (passwd)
+	proxyPasswd = xmlMemStrdup(passwd);
+    proxyPort = port;
+    proxyType = type;
+}
+
+/**
+ * xmlNanoFTPScanURL:
+ * @ctx:  an FTP context
+ * @URL:  The URL used to initialize the context
+ *
+ * (Re)Initialize an FTP context by parsing the URL and finding
+ * the protocol host port and path it indicates.
+ */
+
+static void
+xmlNanoFTPScanURL(void *ctx, const char *URL) {
+    xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
+    const char *cur = URL;
+    char buf[XML_NANO_MAX_URLBUF];
+    int indx = 0;
+    int port = 0;
+
+    if (ctxt->protocol != NULL) { 
+        xmlFree(ctxt->protocol);
+	ctxt->protocol = NULL;
+    }
+    if (ctxt->hostname != NULL) { 
+        xmlFree(ctxt->hostname);
+	ctxt->hostname = NULL;
+    }
+    if (ctxt->path != NULL) { 
+        xmlFree(ctxt->path);
+	ctxt->path = NULL;
+    }
+    if (URL == NULL) return;
+    buf[indx] = 0;
+    while ((*cur != 0) && (indx < XML_NANO_MAX_URLBUF - 1)) {
+        if ((cur[0] == ':') && (cur[1] == '/') && (cur[2] == '/')) {
+	    buf[indx] = 0;
+	    ctxt->protocol = xmlMemStrdup(buf);
+	    indx = 0;
+            cur += 3;
+	    break;
+	}
+	buf[indx++] = *cur++;
+    }
+    if (*cur == 0) return;
+
+    buf[indx] = 0;
+    /* allow user@ and user:pass@ forms */
+    {
+	const char *p = strchr(cur, '@');
+	if(p) {
+	    while(indx < XML_NANO_MAX_URLBUF-1) {
+		if(cur[0] == ':' || cur[0] == '@') break;
+		buf[indx++] = *cur++;
+	    }
+	    buf[indx] = 0;
+	    ctxt->user = xmlMemStrdup(buf);
+	    indx = 0;
+	    if(cur[0] == ':') {
+		cur++;
+		while(indx < XML_NANO_MAX_URLBUF-1) {
+		    if(cur[0] == '@') break;
+		    buf[indx++] = *cur++;
+		}
+		buf[indx] = 0;
+		ctxt->passwd = xmlMemStrdup(buf);
+		indx = 0;
+	    }
+	    cur = p+1;
+	}
+    }
+
+    while (indx < XML_NANO_MAX_URLBUF - 1) {
+	if ((strchr (cur, '[') && !strchr (cur, ']')) ||
+		(!strchr (cur, '[') && strchr (cur, ']'))) {
+	    xmlGenericError (xmlGenericErrorContext, "\nxmlNanoFTPScanURL: %s",
+		    "Syntax Error\n");
+	    return;
+	}
+
+	if (cur[0] == '[') {
+	    cur++;
+	    while (cur[0] != ']')
+		buf[indx++] = *cur++;
+
+	    if (!strchr (buf, ':')) {
+		xmlGenericError (xmlGenericErrorContext, "\nxmlNanoFTPScanURL: %s",
+			"Use [IPv6]/IPv4 format\n");
+		return;
+	    }
+
+	    buf[indx] = 0;
+	    ctxt->hostname = xmlMemStrdup (buf);
+	    indx = 0;
+	    cur += 1;
+	    if (cur[0] == ':') {
+		cur++;
+		while (*cur >= '0' && *cur <= '9') {
+		    port *= 10;
+		    port += *cur - '0';
+		    cur++;
+		}
+
+		if (port != 0) ctxt->port = port;
+		while ((cur[0] != '/') && (*cur != 0))
+		    cur++;
+	    }
+	    break;
+	}
+	else {     /* address is an IPv4 one*/
+	    if (cur[0] == ':') {
+		buf[indx] = 0;
+		ctxt->hostname = xmlMemStrdup (buf);
+		indx = 0;
+		cur += 1;
+		while ((*cur >= '0') && (*cur <= '9')) {
+		    port *= 10;
+		    port += *cur - '0';
+		    cur++;
+		}
+		if (port != 0) ctxt->port = port;
+		while ((cur[0] != '/') && (*cur != 0)) 
+		    cur++;
+		break;
+	    }
+	    if ((*cur == '/') || (*cur == 0)) {
+		buf[indx] = 0;
+		ctxt->hostname = xmlMemStrdup (buf);
+		indx = 0;
+		break;
+	    }
+	}
+	buf[indx++] = *cur++;
+    }
+    if (*cur == 0) 
+        ctxt->path = xmlMemStrdup("/");
+    else {
+        indx = 0;
+        buf[indx] = 0;
+	while ((*cur != 0) && (indx < XML_NANO_MAX_URLBUF-1))
+	    buf[indx++] = *cur++;
+	buf[indx] = 0;
+	ctxt->path = xmlMemStrdup(buf);
+    }	
+}
+
+/**
+ * xmlNanoFTPUpdateURL:
+ * @ctx:  an FTP context
+ * @URL:  The URL used to update the context
+ *
+ * Update an FTP context by parsing the URL and finding
+ * new path it indicates. If there is an error in the 
+ * protocol, hostname, port or other information, the
+ * error is raised. It indicates a new connection has to
+ * be established.
+ *
+ * Returns 0 if Ok, -1 in case of error (other host).
+ */
+
+int
+xmlNanoFTPUpdateURL(void *ctx, const char *URL) {
+    xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
+    const char *cur = URL;
+    char buf[XML_NANO_MAX_URLBUF];
+    int indx = 0;
+    int port = 0;
+
+    if (URL == NULL)
+	return(-1);
+    if (ctxt == NULL)
+	return(-1);
+    if (ctxt->protocol == NULL)
+	return(-1);
+    if (ctxt->hostname == NULL)
+	return(-1);
+    buf[indx] = 0;
+    while ((*cur != 0) && (indx < XML_NANO_MAX_URLBUF-1)) {
+        if ((cur[0] == ':') && (cur[1] == '/') && (cur[2] == '/')) {
+	    buf[indx] = 0;
+	    if (strcmp(ctxt->protocol, buf))
+		return(-1);
+	    indx = 0;
+            cur += 3;
+	    break;
+	}
+	buf[indx++] = *cur++;
+    }
+    if (*cur == 0)
+	return(-1);
+
+    buf[indx] = 0;
+    while (indx < XML_NANO_MAX_URLBUF-1) {
+	if ((strchr (cur, '[') && !strchr (cur, ']')) ||
+		(!strchr (cur, '[') && strchr (cur, ']'))) {
+	    xmlGenericError (xmlGenericErrorContext, "\nxmlNanoFTPUpdateURL: %s",
+		    "Syntax Error\n");
+	    return (-1);
+	}
+
+	if (cur[0] == '[') {
+	    cur++;
+	    while ((cur[0] != ']') && (indx < XML_NANO_MAX_URLBUF-1))
+		buf[indx++] = *cur++;
+
+	    if (!strchr (buf, ':')) {
+		xmlGenericError (xmlGenericErrorContext, "\nxmlNanoFTPUpdateURL: %s",
+			"Use [IPv6]/IPv4 format\n");
+		return (-1);
+	    }
+
+	    buf[indx] = 0;
+	    if (strcmp (ctxt->hostname, buf))
+		return (-1);
+	    indx = 0;
+	    cur += 1;
+	    if (cur[0] == ':') {
+		cur++;
+		while (*cur >= '0' && *cur <= '9') {
+		    port *= 10;
+		    port += *cur - '0';
+		    cur++;
+		}
+
+		if (port != ctxt->port)
+		    return (-1);
+		while ((cur[0] != '/') && (*cur != 0))
+		    cur++;
+	    }
+	    break;
+	}
+	else {
+	    if (cur[0] == ':') {
+		buf[indx] = 0;
+		if (strcmp (ctxt->hostname, buf))
+		    return (-1);
+		indx = 0;
+		cur += 1;
+		while ((*cur >= '0') && (*cur <= '9')) {
+		    port *= 10;
+		    port += *cur - '0';
+		    cur++;
+		}
+		if (port != ctxt->port)
+		    return (-1);
+		while ((cur[0] != '/') && (*cur != 0)) 
+		    cur++;
+		break;
+	    }
+	    if ((*cur == '/') || (*cur == 0)) {
+		buf[indx] = 0;
+		if (strcmp (ctxt->hostname, buf))
+		    return (-1);
+		indx = 0;
+		break;
+	    }
+	}
+	buf[indx++] = *cur++;
+    }
+    if (ctxt->path != NULL) {
+	xmlFree(ctxt->path);
+	ctxt->path = NULL;
+    }
+
+    if (*cur == 0) 
+        ctxt->path = xmlMemStrdup("/");
+    else {
+        indx = 0;
+        buf[indx] = 0;
+	while ((*cur != 0) && (indx < XML_NANO_MAX_URLBUF-1))
+	    buf[indx++] = *cur++;
+	buf[indx] = 0;
+	ctxt->path = xmlMemStrdup(buf);
+    }	
+    return(0);
+}
+
+/**
+ * xmlNanoFTPScanProxy:
+ * @URL:  The proxy URL used to initialize the proxy context
+ *
+ * (Re)Initialize the FTP Proxy context by parsing the URL and finding
+ * the protocol host port it indicates.
+ * Should be like ftp://myproxy/ or ftp://myproxy:3128/
+ * A NULL URL cleans up proxy informations.
+ */
+
+void
+xmlNanoFTPScanProxy(const char *URL) {
+    const char *cur = URL;
+    char buf[XML_NANO_MAX_URLBUF];
+    int indx = 0;
+    int port = 0;
+
+    if (proxy != NULL) { 
+        xmlFree(proxy);
+	proxy = NULL;
+    }
+    if (proxyPort != 0) { 
+	proxyPort = 0;
+    }
+#ifdef DEBUG_FTP
+    if (URL == NULL)
+	xmlGenericError(xmlGenericErrorContext, "Removing FTP proxy info\n");
+    else
+	xmlGenericError(xmlGenericErrorContext, "Using FTP proxy %s\n", URL);
+#endif
+    if (URL == NULL) return;
+    buf[indx] = 0;
+    while ((*cur != 0) && (indx < XML_NANO_MAX_URLBUF-1)) {
+        if ((cur[0] == ':') && (cur[1] == '/') && (cur[2] == '/')) {
+	    buf[indx] = 0;
+	    indx = 0;
+            cur += 3;
+	    break;
+	}
+	buf[indx++] = *cur++;
+    }
+    if (*cur == 0) return;
+
+    buf[indx] = 0;
+    while (indx < XML_NANO_MAX_URLBUF-1) {
+	if ((strchr (cur, '[') && !strchr (cur, ']')) ||
+		(!strchr (cur, '[') && strchr (cur, ']'))) {
+	    xmlGenericError (xmlGenericErrorContext, "\nxmlNanoFTPScanProxy: %s",
+		    "Syntax error\n");
+	    return;
+	}
+
+	if (cur[0] == '[') {
+	    cur++;
+	    while (cur[0] != ']')
+		buf[indx++] = *cur++;
+	    if (!strchr (buf, ':')) {
+		xmlGenericError (xmlGenericErrorContext, "\nxmlNanoFTPScanProxy: %s",
+			"Use [IPv6]/IPv4 format\n");
+		return;
+	    }
+
+	    buf[indx] = 0;
+	    proxy = xmlMemStrdup (buf);
+	    indx = 0;
+	    cur += 1;
+	    if (cur[0] == ':') {
+		cur++;
+		while (*cur >= '0' && *cur <= '9') {
+		    port *= 10;
+		    port += *cur - '0';
+		    cur++;
+		}
+
+		if (port != 0) proxyPort = port;
+		while ((cur[0] != '/') && (*cur != 0))
+		    cur++;
+	    }
+	    break;
+	}
+	else {
+	    if (cur[0] == ':') {
+		buf[indx] = 0;
+		proxy = xmlMemStrdup (buf);
+		indx = 0;
+		cur += 1;
+		while ((*cur >= '0') && (*cur <= '9')) {
+		    port *= 10;
+		    port += *cur - '0';
+		    cur++;
+		}
+		if (port != 0) proxyPort = port;
+		while ((cur[0] != '/') && (*cur != 0)) 
+		    cur++;
+		break;
+	    }
+	    if ((*cur == '/') || (*cur == 0)) {
+		buf[indx] = 0;
+		proxy = xmlMemStrdup (buf);
+		indx = 0;
+		break;
+	    }
+	}
+	buf[indx++] = *cur++;
+    }
+}
+
+/**
+ * xmlNanoFTPNewCtxt:
+ * @URL:  The URL used to initialize the context
+ *
+ * Allocate and initialize a new FTP context.
+ *
+ * Returns an FTP context or NULL in case of error.
+ */
+
+void*
+xmlNanoFTPNewCtxt(const char *URL) {
+    xmlNanoFTPCtxtPtr ret;
+    char *unescaped;
+
+    ret = (xmlNanoFTPCtxtPtr) xmlMalloc(sizeof(xmlNanoFTPCtxt));
+    if (ret == NULL) {
+        xmlFTPErrMemory("allocating FTP context");
+        return(NULL);
+    }
+
+    memset(ret, 0, sizeof(xmlNanoFTPCtxt));
+    ret->port = 21;
+    ret->passive = 1;
+    ret->returnValue = 0;
+    ret->controlBufIndex = 0;
+    ret->controlBufUsed = 0;
+    ret->controlFd = -1;
+
+    unescaped = xmlURIUnescapeString(URL, 0, NULL);
+    if (unescaped != NULL)
+	xmlNanoFTPScanURL(ret, unescaped);
+    else if (URL != NULL)
+	xmlNanoFTPScanURL(ret, URL);
+    xmlFree(unescaped);
+
+    return(ret);
+}
+
+/**
+ * xmlNanoFTPFreeCtxt:
+ * @ctx:  an FTP context
+ *
+ * Frees the context after closing the connection.
+ */
+
+void
+xmlNanoFTPFreeCtxt(void * ctx) {
+    xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
+    if (ctxt == NULL) return;
+    if (ctxt->hostname != NULL) xmlFree(ctxt->hostname);
+    if (ctxt->protocol != NULL) xmlFree(ctxt->protocol);
+    if (ctxt->path != NULL) xmlFree(ctxt->path);
+    ctxt->passive = 1;
+    if (ctxt->controlFd >= 0) closesocket(ctxt->controlFd);
+    ctxt->controlFd = -1;
+    ctxt->controlBufIndex = -1;
+    ctxt->controlBufUsed = -1;
+    xmlFree(ctxt);
+}
+
+/**
+ * xmlNanoFTPParseResponse:
+ * @buf:  the buffer containing the response
+ * @len:  the buffer length
+ * 
+ * Parsing of the server answer, we just extract the code.
+ *
+ * returns 0 for errors
+ *     +XXX for last line of response
+ *     -XXX for response to be continued
+ */
+static int
+xmlNanoFTPParseResponse(char *buf, int len) {
+    int val = 0;
+
+    if (len < 3) return(-1);
+    if ((*buf >= '0') && (*buf <= '9')) 
+        val = val * 10 + (*buf - '0');
+    else
+        return(0);
+    buf++;
+    if ((*buf >= '0') && (*buf <= '9')) 
+        val = val * 10 + (*buf - '0');
+    else
+        return(0);
+    buf++;
+    if ((*buf >= '0') && (*buf <= '9')) 
+        val = val * 10 + (*buf - '0');
+    else
+        return(0);
+    buf++;
+    if (*buf == '-') 
+        return(-val);
+    return(val);
+}
+
+/**
+ * xmlNanoFTPGetMore:
+ * @ctx:  an FTP context
+ *
+ * Read more information from the FTP control connection
+ * Returns the number of bytes read, < 0 indicates an error
+ */
+static int
+xmlNanoFTPGetMore(void *ctx) {
+    xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
+    int len;
+    int size;
+
+    if ((ctxt->controlBufIndex < 0) || (ctxt->controlBufIndex > FTP_BUF_SIZE)) {
+#ifdef DEBUG_FTP
+        xmlGenericError(xmlGenericErrorContext,
+		"xmlNanoFTPGetMore : controlBufIndex = %d\n",
+		ctxt->controlBufIndex);
+#endif
+	return(-1);
+    }
+
+    if ((ctxt->controlBufUsed < 0) || (ctxt->controlBufUsed > FTP_BUF_SIZE)) {
+#ifdef DEBUG_FTP
+        xmlGenericError(xmlGenericErrorContext,
+		"xmlNanoFTPGetMore : controlBufUsed = %d\n",
+		ctxt->controlBufUsed);
+#endif
+	return(-1);
+    }
+    if (ctxt->controlBufIndex > ctxt->controlBufUsed) {
+#ifdef DEBUG_FTP
+        xmlGenericError(xmlGenericErrorContext,
+		"xmlNanoFTPGetMore : controlBufIndex > controlBufUsed %d > %d\n",
+	       ctxt->controlBufIndex, ctxt->controlBufUsed);
+#endif
+	return(-1);
+    }
+
+    /*
+     * First pack the control buffer
+     */
+    if (ctxt->controlBufIndex > 0) {
+	memmove(&ctxt->controlBuf[0], &ctxt->controlBuf[ctxt->controlBufIndex],
+		ctxt->controlBufUsed - ctxt->controlBufIndex);
+	ctxt->controlBufUsed -= ctxt->controlBufIndex;
+	ctxt->controlBufIndex = 0;
+    }
+    size = FTP_BUF_SIZE - ctxt->controlBufUsed;
+    if (size == 0) {
+#ifdef DEBUG_FTP
+        xmlGenericError(xmlGenericErrorContext,
+		"xmlNanoFTPGetMore : buffer full %d \n", ctxt->controlBufUsed);
+#endif
+	return(0);
+    }
+
+    /*
+     * Read the amount left on the control connection
+     */
+    if ((len = recv(ctxt->controlFd, &ctxt->controlBuf[ctxt->controlBufIndex],
+		    size, 0)) < 0) {
+	__xmlIOErr(XML_FROM_FTP, 0, "recv failed");
+	closesocket(ctxt->controlFd); ctxt->controlFd = -1;
+        ctxt->controlFd = -1;
+        return(-1);
+    }
+#ifdef DEBUG_FTP
+    xmlGenericError(xmlGenericErrorContext,
+	    "xmlNanoFTPGetMore : read %d [%d - %d]\n", len,
+	   ctxt->controlBufUsed, ctxt->controlBufUsed + len);
+#endif
+    ctxt->controlBufUsed += len;
+    ctxt->controlBuf[ctxt->controlBufUsed] = 0;
+
+    return(len);
+}
+
+/**
+ * xmlNanoFTPReadResponse:
+ * @ctx:  an FTP context
+ *
+ * Read the response from the FTP server after a command.
+ * Returns the code number
+ */
+static int
+xmlNanoFTPReadResponse(void *ctx) {
+    xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
+    char *ptr, *end;
+    int len;
+    int res = -1, cur = -1;
+
+get_more:
+    /*
+     * Assumes everything up to controlBuf[controlBufIndex] has been read
+     * and analyzed.
+     */
+    len = xmlNanoFTPGetMore(ctx);
+    if (len < 0) {
+        return(-1);
+    }
+    if ((ctxt->controlBufUsed == 0) && (len == 0)) {
+        return(-1);
+    }
+    ptr = &ctxt->controlBuf[ctxt->controlBufIndex];
+    end = &ctxt->controlBuf[ctxt->controlBufUsed];
+
+#ifdef DEBUG_FTP
+    xmlGenericError(xmlGenericErrorContext,
+	    "\n<<<\n%s\n--\n", ptr);
+#endif
+    while (ptr < end) {
+        cur = xmlNanoFTPParseResponse(ptr, end - ptr);
+	if (cur > 0) {
+	    /*
+	     * Successfully scanned the control code, scratch
+	     * till the end of the line, but keep the index to be
+	     * able to analyze the result if needed.
+	     */
+	    res = cur;
+	    ptr += 3;
+	    ctxt->controlBufAnswer = ptr - ctxt->controlBuf;
+	    while ((ptr < end) && (*ptr != '\n')) ptr++;
+	    if (*ptr == '\n') ptr++;
+	    if (*ptr == '\r') ptr++;
+	    break;
+	}
+	while ((ptr < end) && (*ptr != '\n')) ptr++;
+	if (ptr >= end) {
+	    ctxt->controlBufIndex = ctxt->controlBufUsed;
+	    goto get_more;
+	}
+	if (*ptr != '\r') ptr++;
+    }
+
+    if (res < 0) goto get_more;
+    ctxt->controlBufIndex = ptr - ctxt->controlBuf;
+#ifdef DEBUG_FTP
+    ptr = &ctxt->controlBuf[ctxt->controlBufIndex];
+    xmlGenericError(xmlGenericErrorContext, "\n---\n%s\n--\n", ptr);
+#endif
+
+#ifdef DEBUG_FTP
+    xmlGenericError(xmlGenericErrorContext, "Got %d\n", res);
+#endif
+    return(res / 100);
+}
+
+/**
+ * xmlNanoFTPGetResponse:
+ * @ctx:  an FTP context
+ *
+ * Get the response from the FTP server after a command.
+ * Returns the code number
+ */
+
+int
+xmlNanoFTPGetResponse(void *ctx) {
+    int res;
+
+    res = xmlNanoFTPReadResponse(ctx);
+
+    return(res);
+}
+
+/**
+ * xmlNanoFTPCheckResponse:
+ * @ctx:  an FTP context
+ *
+ * Check if there is a response from the FTP server after a command.
+ * Returns the code number, or 0
+ */
+
+int
+xmlNanoFTPCheckResponse(void *ctx) {
+    xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
+    fd_set rfd;
+    struct timeval tv;
+
+    tv.tv_sec = 0;
+    tv.tv_usec = 0;
+    FD_ZERO(&rfd);
+    FD_SET(ctxt->controlFd, &rfd);
+    switch(select(ctxt->controlFd + 1, &rfd, NULL, NULL, &tv)) {
+	case 0:
+	    return(0);
+	case -1:
+	    __xmlIOErr(XML_FROM_FTP, 0, "select");
+	    return(-1);
+			
+    }
+
+    return(xmlNanoFTPReadResponse(ctx));
+}
+
+/**
+ * Send the user authentication
+ */
+
+static int
+xmlNanoFTPSendUser(void *ctx) {
+    xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
+    char buf[200];
+    int len;
+    int res;
+
+    if (ctxt->user == NULL)
+	snprintf(buf, sizeof(buf), "USER anonymous\r\n");
+    else
+	snprintf(buf, sizeof(buf), "USER %s\r\n", ctxt->user);
+    buf[sizeof(buf) - 1] = 0;
+    len = strlen(buf);
+#ifdef DEBUG_FTP
+    xmlGenericError(xmlGenericErrorContext, "%s", buf);
+#endif
+    res = send(ctxt->controlFd, buf, len, 0);
+    if (res < 0) {
+	__xmlIOErr(XML_FROM_FTP, 0, "send failed");
+	return(res);
+    }
+    return(0);
+}
+
+/**
+ * Send the password authentication
+ */
+
+static int
+xmlNanoFTPSendPasswd(void *ctx) {
+    xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
+    char buf[200];
+    int len;
+    int res;
+
+    if (ctxt->passwd == NULL)
+	snprintf(buf, sizeof(buf), "PASS anonymous@\r\n");
+    else
+	snprintf(buf, sizeof(buf), "PASS %s\r\n", ctxt->passwd);
+    buf[sizeof(buf) - 1] = 0;
+    len = strlen(buf);
+#ifdef DEBUG_FTP
+    xmlGenericError(xmlGenericErrorContext, "%s", buf);
+#endif
+    res = send(ctxt->controlFd, buf, len, 0);
+    if (res < 0) {
+	__xmlIOErr(XML_FROM_FTP, 0, "send failed");
+	return(res);
+    }
+    return(0);
+}
+
+/**
+ * xmlNanoFTPQuit:
+ * @ctx:  an FTP context
+ *
+ * Send a QUIT command to the server
+ *
+ * Returns -1 in case of error, 0 otherwise
+ */
+
+
+int
+xmlNanoFTPQuit(void *ctx) {
+    xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
+    char buf[200];
+    int len, res;
+
+    snprintf(buf, sizeof(buf), "QUIT\r\n");
+    len = strlen(buf);
+#ifdef DEBUG_FTP
+    xmlGenericError(xmlGenericErrorContext, "%s", buf); /* Just to be consistent, even though we know it can't have a % in it */
+#endif
+    res = send(ctxt->controlFd, buf, len, 0);
+    if (res < 0) {
+	__xmlIOErr(XML_FROM_FTP, 0, "send failed");
+	return(res);
+    }
+    return(0);
+}
+
+/**
+ * xmlNanoFTPConnect:
+ * @ctx:  an FTP context
+ *
+ * Tries to open a control connection
+ *
+ * Returns -1 in case of error, 0 otherwise
+ */
+
+int
+xmlNanoFTPConnect(void *ctx) {
+    xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
+    struct hostent *hp;
+    int port;
+    int res;
+    int addrlen = sizeof (struct sockaddr_in);
+
+    if (ctxt == NULL)
+	return(-1);
+    if (ctxt->hostname == NULL)
+	return(-1);
+
+    /*
+     * do the blocking DNS query.
+     */
+    if (proxy) {
+        port = proxyPort;
+    } else {
+	port = ctxt->port;
+    }
+    if (port == 0)
+	port = 21;
+
+    memset (&ctxt->ftpAddr, 0, sizeof(ctxt->ftpAddr));
+
+#ifdef SUPPORT_IP6
+    if (have_ipv6 ()) {
+	struct addrinfo hints, *tmp, *result;
+
+	result = NULL;
+	memset (&hints, 0, sizeof(hints));
+	hints.ai_socktype = SOCK_STREAM;
+
+	if (proxy) {
+	    if (getaddrinfo (proxy, NULL, &hints, &result) != 0) {
+		__xmlIOErr(XML_FROM_FTP, 0, "getaddrinfo failed");
+		return (-1);
+	    }
+	}
+	else
+	    if (getaddrinfo (ctxt->hostname, NULL, &hints, &result) != 0) {
+		__xmlIOErr(XML_FROM_FTP, 0, "getaddrinfo failed");
+		return (-1);
+	    }
+
+	for (tmp = result; tmp; tmp = tmp->ai_next)
+	    if (tmp->ai_family == AF_INET || tmp->ai_family == AF_INET6)
+		break;
+
+	if (!tmp) {
+	    if (result)
+		freeaddrinfo (result);
+	    return (-1);
+	}
+	else {
+	    if (tmp->ai_family == AF_INET6) {
+		memcpy (&ctxt->ftpAddr, tmp->ai_addr, tmp->ai_addrlen);
+		((struct sockaddr_in6 *) &ctxt->ftpAddr)->sin6_port = htons (port);
+		ctxt->controlFd = socket (AF_INET6, SOCK_STREAM, 0);
+	    }
+	    else {
+		memcpy (&ctxt->ftpAddr, tmp->ai_addr, tmp->ai_addrlen);
+		((struct sockaddr_in *) &ctxt->ftpAddr)->sin_port = htons (port);
+		ctxt->controlFd = socket (AF_INET, SOCK_STREAM, 0);
+	    }
+	    addrlen = tmp->ai_addrlen;
+	    freeaddrinfo (result);
+	}
+    }
+    else
+#endif
+    {
+	if (proxy)
+	    hp = gethostbyname (proxy);
+	else
+	    hp = gethostbyname (ctxt->hostname);
+	if (hp == NULL) {
+	    __xmlIOErr(XML_FROM_FTP, 0, "gethostbyname failed");
+	    return (-1);
+	}
+
+    /*
+     * Prepare the socket
+     */
+	((struct sockaddr_in *)&ctxt->ftpAddr)->sin_family = AF_INET;
+	memcpy (&((struct sockaddr_in *)&ctxt->ftpAddr)->sin_addr,
+		hp->h_addr_list[0], hp->h_length);
+	((struct sockaddr_in *)&ctxt->ftpAddr)->sin_port = htons (port);
+	ctxt->controlFd = socket (AF_INET, SOCK_STREAM, 0);
+	addrlen = sizeof (struct sockaddr_in);
+    }
+
+    if (ctxt->controlFd < 0) {
+	__xmlIOErr(XML_FROM_FTP, 0, "socket failed");
+        return(-1);
+    }
+
+    /*
+     * Do the connect.
+     */
+    if (connect(ctxt->controlFd, (struct sockaddr *) &ctxt->ftpAddr,
+	    addrlen) < 0) {
+	__xmlIOErr(XML_FROM_FTP, 0, "Failed to create a connection");
+        closesocket(ctxt->controlFd); ctxt->controlFd = -1;
+        ctxt->controlFd = -1;
+	return(-1);
+    }
+
+    /*
+     * Wait for the HELLO from the server.
+     */
+    res = xmlNanoFTPGetResponse(ctxt);
+    if (res != 2) {
+        closesocket(ctxt->controlFd); ctxt->controlFd = -1;
+        ctxt->controlFd = -1;
+	return(-1);
+    }
+
+    /*
+     * State diagram for the login operation on the FTP server
+     *
+     * Reference: RFC 959
+     *
+     *                       1
+     * +---+   USER    +---+------------->+---+
+     * | B |---------->| W | 2       ---->| E |
+     * +---+           +---+------  |  -->+---+
+     *                  | |       | | |
+     *                3 | | 4,5   | | |
+     *    --------------   -----  | | |
+     *   |                      | | | |
+     *   |                      | | | |
+     *   |                 ---------  |
+     *   |               1|     | |   |
+     *   V                |     | |   |
+     * +---+   PASS    +---+ 2  |  ------>+---+
+     * |   |---------->| W |------------->| S |
+     * +---+           +---+   ---------->+---+
+     *                  | |   | |     |
+     *                3 | |4,5| |     |
+     *    --------------   --------   |
+     *   |                    | |  |  |
+     *   |                    | |  |  |
+     *   |                 -----------
+     *   |             1,3|   | |  |
+     *   V                |  2| |  |
+     * +---+   ACCT    +---+--  |   ----->+---+
+     * |   |---------->| W | 4,5 -------->| F |
+     * +---+           +---+------------->+---+
+     *
+     * Of course in case of using a proxy this get really nasty and is not
+     * standardized at all :-(
+     */
+    if (proxy) {
+        int len;
+	char buf[400];
+
+        if (proxyUser != NULL) {
+	    /*
+	     * We need proxy auth
+	     */
+	    snprintf(buf, sizeof(buf), "USER %s\r\n", proxyUser);
+            buf[sizeof(buf) - 1] = 0;
+            len = strlen(buf);
+#ifdef DEBUG_FTP
+	    xmlGenericError(xmlGenericErrorContext, "%s", buf);
+#endif
+	    res = send(ctxt->controlFd, buf, len, 0);
+	    if (res < 0) {
+		__xmlIOErr(XML_FROM_FTP, 0, "send failed");
+		closesocket(ctxt->controlFd);
+		ctxt->controlFd = -1;
+	        return(res);
+	    }
+	    res = xmlNanoFTPGetResponse(ctxt);
+	    switch (res) {
+		case 2:
+		    if (proxyPasswd == NULL)
+			break;
+		case 3:
+		    if (proxyPasswd != NULL)
+			snprintf(buf, sizeof(buf), "PASS %s\r\n", proxyPasswd);
+		    else
+			snprintf(buf, sizeof(buf), "PASS anonymous@\r\n");
+                    buf[sizeof(buf) - 1] = 0;
+                    len = strlen(buf);
+#ifdef DEBUG_FTP
+		    xmlGenericError(xmlGenericErrorContext, "%s", buf);
+#endif
+		    res = send(ctxt->controlFd, buf, len, 0);
+		    if (res < 0) {
+			__xmlIOErr(XML_FROM_FTP, 0, "send failed");
+			closesocket(ctxt->controlFd);
+			ctxt->controlFd = -1;
+			return(res);
+		    }
+		    res = xmlNanoFTPGetResponse(ctxt);
+		    if (res > 3) {
+			closesocket(ctxt->controlFd);
+			ctxt->controlFd = -1;
+			return(-1);
+		    }
+		    break;
+		case 1:
+		    break;
+		case 4:
+		case 5:
+		case -1:
+		default:
+		    closesocket(ctxt->controlFd);
+		    ctxt->controlFd = -1;
+		    return(-1);
+	    }
+	}
+
+	/*
+	 * We assume we don't need more authentication to the proxy
+	 * and that it succeeded :-\
+	 */
+	switch (proxyType) {
+	    case 0:
+		/* we will try in sequence */
+	    case 1:
+		/* Using SITE command */
+		snprintf(buf, sizeof(buf), "SITE %s\r\n", ctxt->hostname);
+                buf[sizeof(buf) - 1] = 0;
+                len = strlen(buf);
+#ifdef DEBUG_FTP
+		xmlGenericError(xmlGenericErrorContext, "%s", buf);
+#endif
+		res = send(ctxt->controlFd, buf, len, 0);
+		if (res < 0) {
+		    __xmlIOErr(XML_FROM_FTP, 0, "send failed");
+		    closesocket(ctxt->controlFd); ctxt->controlFd = -1;
+		    ctxt->controlFd = -1;
+		    return(res);
+		}
+		res = xmlNanoFTPGetResponse(ctxt);
+		if (res == 2) {
+		    /* we assume it worked :-\ 1 is error for SITE command */
+		    proxyType = 1;
+		    break;
+		}    
+		if (proxyType == 1) {
+		    closesocket(ctxt->controlFd); ctxt->controlFd = -1;
+		    ctxt->controlFd = -1;
+		    return(-1);
+		}
+	    case 2:
+		/* USER user@host command */
+		if (ctxt->user == NULL)
+		    snprintf(buf, sizeof(buf), "USER anonymous@%s\r\n",
+			           ctxt->hostname);
+		else
+		    snprintf(buf, sizeof(buf), "USER %s@%s\r\n",
+			           ctxt->user, ctxt->hostname);
+                buf[sizeof(buf) - 1] = 0;
+                len = strlen(buf);
+#ifdef DEBUG_FTP
+		xmlGenericError(xmlGenericErrorContext, "%s", buf);
+#endif
+		res = send(ctxt->controlFd, buf, len, 0);
+		if (res < 0) {
+		    __xmlIOErr(XML_FROM_FTP, 0, "send failed");
+		    closesocket(ctxt->controlFd); ctxt->controlFd = -1;
+		    ctxt->controlFd = -1;
+		    return(res);
+		}
+		res = xmlNanoFTPGetResponse(ctxt);
+		if ((res == 1) || (res == 2)) {
+		    /* we assume it worked :-\ */
+		    proxyType = 2;
+		    return(0);
+		}    
+		if (ctxt->passwd == NULL)
+		    snprintf(buf, sizeof(buf), "PASS anonymous@\r\n");
+		else
+		    snprintf(buf, sizeof(buf), "PASS %s\r\n", ctxt->passwd);
+                buf[sizeof(buf) - 1] = 0;
+                len = strlen(buf);
+#ifdef DEBUG_FTP
+		xmlGenericError(xmlGenericErrorContext, "%s", buf);
+#endif
+		res = send(ctxt->controlFd, buf, len, 0);
+		if (res < 0) {
+		    __xmlIOErr(XML_FROM_FTP, 0, "send failed");
+		    closesocket(ctxt->controlFd); ctxt->controlFd = -1;
+		    ctxt->controlFd = -1;
+		    return(res);
+		}
+		res = xmlNanoFTPGetResponse(ctxt);
+		if ((res == 1) || (res == 2)) {
+		    /* we assume it worked :-\ */
+		    proxyType = 2;
+		    return(0);
+		}
+		if (proxyType == 2) {
+		    closesocket(ctxt->controlFd); ctxt->controlFd = -1;
+		    ctxt->controlFd = -1;
+		    return(-1);
+		}
+	    case 3:
+		/*
+		 * If you need support for other Proxy authentication scheme
+		 * send the code or at least the sequence in use.
+		 */
+	    default:
+		closesocket(ctxt->controlFd); ctxt->controlFd = -1;
+		ctxt->controlFd = -1;
+		return(-1);
+	}
+    }
+    /*
+     * Non-proxy handling.
+     */
+    res = xmlNanoFTPSendUser(ctxt);
+    if (res < 0) {
+        closesocket(ctxt->controlFd); ctxt->controlFd = -1;
+        ctxt->controlFd = -1;
+	return(-1);
+    }
+    res = xmlNanoFTPGetResponse(ctxt);
+    switch (res) {
+	case 2:
+	    return(0);
+	case 3:
+	    break;
+	case 1:
+	case 4:
+	case 5:
+        case -1:
+	default:
+	    closesocket(ctxt->controlFd); ctxt->controlFd = -1;
+	    ctxt->controlFd = -1;
+	    return(-1);
+    }
+    res = xmlNanoFTPSendPasswd(ctxt);
+    if (res < 0) {
+        closesocket(ctxt->controlFd); ctxt->controlFd = -1;
+        ctxt->controlFd = -1;
+	return(-1);
+    }
+    res = xmlNanoFTPGetResponse(ctxt);
+    switch (res) {
+	case 2:
+	    break;
+	case 3:
+	    __xmlIOErr(XML_FROM_FTP, XML_FTP_ACCNT,
+		       "FTP server asking for ACCNT on anonymous\n");
+	case 1:
+	case 4:
+	case 5:
+        case -1:
+	default:
+	    closesocket(ctxt->controlFd); ctxt->controlFd = -1;
+	    ctxt->controlFd = -1;
+	    return(-1);
+    }
+
+    return(0);
+}
+
+/**
+ * xmlNanoFTPConnectTo:
+ * @server:  an FTP server name
+ * @port:  the port (use 21 if 0)
+ *
+ * Tries to open a control connection to the given server/port
+ *
+ * Returns an fTP context or NULL if it failed
+ */
+
+void*
+xmlNanoFTPConnectTo(const char *server, int port) {
+    xmlNanoFTPCtxtPtr ctxt;
+    int res;
+
+    xmlNanoFTPInit();
+    if (server == NULL) 
+	return(NULL);
+    ctxt = (xmlNanoFTPCtxtPtr) xmlNanoFTPNewCtxt(NULL);
+    ctxt->hostname = xmlMemStrdup(server);
+    if (port != 0)
+	ctxt->port = port;
+    res = xmlNanoFTPConnect(ctxt);
+    if (res < 0) {
+	xmlNanoFTPFreeCtxt(ctxt);
+	return(NULL);
+    }
+    return(ctxt);
+}
+
+/**
+ * xmlNanoFTPCwd:
+ * @ctx:  an FTP context
+ * @directory:  a directory on the server
+ *
+ * Tries to change the remote directory
+ *
+ * Returns -1 incase of error, 1 if CWD worked, 0 if it failed
+ */
+
+int
+xmlNanoFTPCwd(void *ctx, char *directory) {
+    xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
+    char buf[400];
+    int len;
+    int res;
+
+    /*
+     * Expected response code for CWD:
+     *
+     * CWD
+     *     250
+     *     500, 501, 502, 421, 530, 550
+     */
+    snprintf(buf, sizeof(buf), "CWD %s\r\n", directory);
+    buf[sizeof(buf) - 1] = 0;
+    len = strlen(buf);
+#ifdef DEBUG_FTP
+    xmlGenericError(xmlGenericErrorContext, "%s", buf);
+#endif
+    res = send(ctxt->controlFd, buf, len, 0);
+    if (res < 0) {
+	__xmlIOErr(XML_FROM_FTP, 0, "send failed");
+	return(res);
+    }
+    res = xmlNanoFTPGetResponse(ctxt);
+    if (res == 4) {
+	return(-1);
+    }
+    if (res == 2) return(1);
+    if (res == 5) {
+	return(0);
+    }
+    return(0);
+}
+
+/**
+ * xmlNanoFTPDele:
+ * @ctx:  an FTP context
+ * @file:  a file or directory on the server
+ *
+ * Tries to delete an item (file or directory) from server
+ *
+ * Returns -1 incase of error, 1 if DELE worked, 0 if it failed
+ */
+
+int
+xmlNanoFTPDele(void *ctx, char *file) {
+    xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
+    char buf[400];
+    int len;
+    int res;
+
+    /*
+     * Expected response code for DELE:
+     *
+     * DELE
+     *       250
+     *       450, 550
+     *       500, 501, 502, 421, 530
+     */
+	 
+    snprintf(buf, sizeof(buf), "DELE %s\r\n", file);
+    buf[sizeof(buf) - 1] = 0;
+    len = strlen(buf);
+#ifdef DEBUG_FTP
+    xmlGenericError(xmlGenericErrorContext, "%s", buf);
+#endif
+    res = send(ctxt->controlFd, buf, len, 0);
+    if (res < 0) {
+	__xmlIOErr(XML_FROM_FTP, 0, "send failed");
+	return(res);
+    }
+    res = xmlNanoFTPGetResponse(ctxt);
+    if (res == 4) {
+	return(-1);
+    }
+    if (res == 2) return(1);
+    if (res == 5) {
+	return(0);
+    }
+    return(0);
+}
+/**
+ * xmlNanoFTPGetConnection:
+ * @ctx:  an FTP context
+ *
+ * Try to open a data connection to the server. Currently only
+ * passive mode is supported.
+ *
+ * Returns -1 incase of error, 0 otherwise
+ */
+
+int
+xmlNanoFTPGetConnection(void *ctx) {
+    xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
+    char buf[200], *cur;
+    int len, i;
+    int res;
+    unsigned char ad[6], *adp, *portp;
+    unsigned int temp[6];
+#ifdef SUPPORT_IP6
+    struct sockaddr_storage dataAddr;
+#else
+    struct sockaddr_in dataAddr;
+#endif
+    SOCKLEN_T dataAddrLen;
+
+    memset (&dataAddr, 0, sizeof(dataAddr));
+#ifdef SUPPORT_IP6
+    if ((ctxt->ftpAddr).ss_family == AF_INET6) {
+	ctxt->dataFd = socket (AF_INET6, SOCK_STREAM, IPPROTO_TCP);
+	((struct sockaddr_in6 *)&dataAddr)->sin6_family = AF_INET6;
+	dataAddrLen = sizeof(struct sockaddr_in6);
+    } else
+#endif
+    {
+	ctxt->dataFd = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP);
+	((struct sockaddr_in *)&dataAddr)->sin_family = AF_INET;
+	dataAddrLen = sizeof (struct sockaddr_in);
+    }
+
+    if (ctxt->dataFd < 0) {
+	__xmlIOErr(XML_FROM_FTP, 0, "socket failed");
+	return (-1);
+    }
+
+    if (ctxt->passive) {
+#ifdef SUPPORT_IP6
+	if ((ctxt->ftpAddr).ss_family == AF_INET6)
+	    snprintf (buf, sizeof(buf), "EPSV\r\n");
+	else
+#endif
+	    snprintf (buf, sizeof(buf), "PASV\r\n");
+        len = strlen (buf);
+#ifdef DEBUG_FTP
+	xmlGenericError(xmlGenericErrorContext, "%s", buf);
+#endif
+	res = send(ctxt->controlFd, buf, len, 0);
+	if (res < 0) {
+	    __xmlIOErr(XML_FROM_FTP, 0, "send failed");
+	    closesocket(ctxt->dataFd); ctxt->dataFd = -1;
+	    return(res);
+	}
+        res = xmlNanoFTPReadResponse(ctx);
+	if (res != 2) {
+	    if (res == 5) {
+	        closesocket(ctxt->dataFd); ctxt->dataFd = -1;
+		return(-1);
+	    } else {
+		/*
+		 * retry with an active connection
+		 */
+	        closesocket(ctxt->dataFd); ctxt->dataFd = -1;
+	        ctxt->passive = 0;
+	    }
+	}
+	cur = &ctxt->controlBuf[ctxt->controlBufAnswer]; 
+	while (((*cur < '0') || (*cur > '9')) && *cur != '\0') cur++;
+#ifdef SUPPORT_IP6
+	if ((ctxt->ftpAddr).ss_family == AF_INET6) {
+	    if (sscanf (cur, "%u", &temp[0]) != 1) {
+		__xmlIOErr(XML_FROM_FTP, XML_FTP_EPSV_ANSWER,
+			"Invalid answer to EPSV\n");
+		if (ctxt->dataFd != -1) {
+		    closesocket (ctxt->dataFd); ctxt->dataFd = -1;
+		}
+		return (-1);
+	    }
+	    memcpy (&((struct sockaddr_in6 *)&dataAddr)->sin6_addr, &((struct sockaddr_in6 *)&ctxt->ftpAddr)->sin6_addr, sizeof(struct in6_addr));
+	    ((struct sockaddr_in6 *)&dataAddr)->sin6_port = htons (temp[0]);
+	}
+	else
+#endif
+	{
+	    if (sscanf (cur, "%u,%u,%u,%u,%u,%u", &temp[0], &temp[1], &temp[2],
+		&temp[3], &temp[4], &temp[5]) != 6) {
+		__xmlIOErr(XML_FROM_FTP, XML_FTP_PASV_ANSWER,
+			"Invalid answer to PASV\n");
+		if (ctxt->dataFd != -1) {
+		    closesocket (ctxt->dataFd); ctxt->dataFd = -1;
+		}
+		return (-1);
+	    }
+	    for (i=0; i<6; i++) ad[i] = (unsigned char) (temp[i] & 0xff);
+	    memcpy (&((struct sockaddr_in *)&dataAddr)->sin_addr, &ad[0], 4);
+	    memcpy (&((struct sockaddr_in *)&dataAddr)->sin_port, &ad[4], 2);
+	}
+
+	if (connect(ctxt->dataFd, (struct sockaddr *) &dataAddr, dataAddrLen) < 0) {
+	    __xmlIOErr(XML_FROM_FTP, 0, "Failed to create a data connection");
+	    closesocket(ctxt->dataFd); ctxt->dataFd = -1;
+	    return (-1);
+	}
+    } else {
+        getsockname(ctxt->dataFd, (struct sockaddr *) &dataAddr, &dataAddrLen);
+#ifdef SUPPORT_IP6
+	if ((ctxt->ftpAddr).ss_family == AF_INET6)
+	    ((struct sockaddr_in6 *)&dataAddr)->sin6_port = 0;
+	else
+#endif
+	    ((struct sockaddr_in *)&dataAddr)->sin_port = 0;
+
+	if (bind(ctxt->dataFd, (struct sockaddr *) &dataAddr, dataAddrLen) < 0) {
+	    __xmlIOErr(XML_FROM_FTP, 0, "bind failed");
+	    closesocket(ctxt->dataFd); ctxt->dataFd = -1;
+	    return (-1);
+	}
+        getsockname(ctxt->dataFd, (struct sockaddr *) &dataAddr, &dataAddrLen);
+
+	if (listen(ctxt->dataFd, 1) < 0) {
+	    __xmlIOErr(XML_FROM_FTP, 0, "listen failed");
+	    closesocket(ctxt->dataFd); ctxt->dataFd = -1;
+	    return (-1);
+	}
+#ifdef SUPPORT_IP6
+	if ((ctxt->ftpAddr).ss_family == AF_INET6) {
+	    char buf6[INET6_ADDRSTRLEN];
+	    inet_ntop (AF_INET6, &((struct sockaddr_in6 *)&dataAddr)->sin6_addr,
+		    buf6, INET6_ADDRSTRLEN);
+	    adp = (unsigned char *) buf6;
+	    portp = (unsigned char *) &((struct sockaddr_in6 *)&dataAddr)->sin6_port;
+	    snprintf (buf, sizeof(buf), "EPRT |2|%s|%s|\r\n", adp, portp);
+        } else
+#endif
+	{
+	    adp = (unsigned char *) &((struct sockaddr_in *)&dataAddr)->sin_addr;
+	    portp = (unsigned char *) &((struct sockaddr_in *)&dataAddr)->sin_port;
+	    snprintf (buf, sizeof(buf), "PORT %d,%d,%d,%d,%d,%d\r\n",
+	    adp[0] & 0xff, adp[1] & 0xff, adp[2] & 0xff, adp[3] & 0xff,
+	    portp[0] & 0xff, portp[1] & 0xff);
+	}
+
+        buf[sizeof(buf) - 1] = 0;
+        len = strlen(buf);
+#ifdef DEBUG_FTP
+	xmlGenericError(xmlGenericErrorContext, "%s", buf);
+#endif
+
+	res = send(ctxt->controlFd, buf, len, 0);
+	if (res < 0) {
+	    __xmlIOErr(XML_FROM_FTP, 0, "send failed");
+	    closesocket(ctxt->dataFd); ctxt->dataFd = -1;
+	    return(res);
+	}
+        res = xmlNanoFTPGetResponse(ctxt);
+	if (res != 2) {
+	    closesocket(ctxt->dataFd); ctxt->dataFd = -1;
+	    return(-1);
+        }
+    }
+    return(ctxt->dataFd);
+    
+}
+
+/**
+ * xmlNanoFTPCloseConnection:
+ * @ctx:  an FTP context
+ *
+ * Close the data connection from the server
+ *
+ * Returns -1 incase of error, 0 otherwise
+ */
+
+int
+xmlNanoFTPCloseConnection(void *ctx) {
+    xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
+    int res;
+    fd_set rfd, efd;
+    struct timeval tv;
+
+    closesocket(ctxt->dataFd); ctxt->dataFd = -1;
+    tv.tv_sec = 15;
+    tv.tv_usec = 0;
+    FD_ZERO(&rfd);
+    FD_SET(ctxt->controlFd, &rfd);
+    FD_ZERO(&efd);
+    FD_SET(ctxt->controlFd, &efd);
+    res = select(ctxt->controlFd + 1, &rfd, NULL, &efd, &tv);
+    if (res < 0) {
+#ifdef DEBUG_FTP
+	perror("select");
+#endif
+	closesocket(ctxt->controlFd); ctxt->controlFd = -1;
+	return(-1);
+    }
+    if (res == 0) {
+#ifdef DEBUG_FTP
+	xmlGenericError(xmlGenericErrorContext,
+		"xmlNanoFTPCloseConnection: timeout\n");
+#endif
+	closesocket(ctxt->controlFd); ctxt->controlFd = -1;
+    } else {
+	res = xmlNanoFTPGetResponse(ctxt);
+	if (res != 2) {
+	    closesocket(ctxt->controlFd); ctxt->controlFd = -1;
+	    return(-1);
+	}
+    }
+    return(0);
+}
+
+/**
+ * xmlNanoFTPParseList:
+ * @list:  some data listing received from the server
+ * @callback:  the user callback
+ * @userData:  the user callback data
+ *
+ * Parse at most one entry from the listing. 
+ *
+ * Returns -1 incase of error, the length of data parsed otherwise
+ */
+
+static int
+xmlNanoFTPParseList(const char *list, ftpListCallback callback, void *userData) {
+    const char *cur = list;
+    char filename[151];
+    char attrib[11];
+    char owner[11];
+    char group[11];
+    char month[4];
+    int year = 0;
+    int minute = 0;
+    int hour = 0;
+    int day = 0;
+    unsigned long size = 0;
+    int links = 0;
+    int i;
+
+    if (!strncmp(cur, "total", 5)) {
+        cur += 5;
+	while (*cur == ' ') cur++;
+	while ((*cur >= '0') && (*cur <= '9'))
+	    links = (links * 10) + (*cur++ - '0');
+	while ((*cur == ' ') || (*cur == '\n')  || (*cur == '\r'))
+	    cur++;
+	return(cur - list);
+    } else if (*list == '+') {
+	return(0);
+    } else {
+	while ((*cur == ' ') || (*cur == '\n')  || (*cur == '\r'))
+	    cur++;
+	if (*cur == 0) return(0);
+	i = 0;
+	while (*cur != ' ') {
+	    if (i < 10) 
+		attrib[i++] = *cur;
+	    cur++;
+	    if (*cur == 0) return(0);
+	}
+	attrib[10] = 0;
+	while (*cur == ' ') cur++;
+	if (*cur == 0) return(0);
+	while ((*cur >= '0') && (*cur <= '9'))
+	    links = (links * 10) + (*cur++ - '0');
+	while (*cur == ' ') cur++;
+	if (*cur == 0) return(0);
+	i = 0;
+	while (*cur != ' ') {
+	    if (i < 10) 
+		owner[i++] = *cur;
+	    cur++;
+	    if (*cur == 0) return(0);
+	}
+	owner[i] = 0;
+	while (*cur == ' ') cur++;
+	if (*cur == 0) return(0);
+	i = 0;
+	while (*cur != ' ') {
+	    if (i < 10) 
+		group[i++] = *cur;
+	    cur++;
+	    if (*cur == 0) return(0);
+	}
+	group[i] = 0;
+	while (*cur == ' ') cur++;
+	if (*cur == 0) return(0);
+	while ((*cur >= '0') && (*cur <= '9'))
+	    size = (size * 10) + (*cur++ - '0');
+	while (*cur == ' ') cur++;
+	if (*cur == 0) return(0);
+	i = 0;
+	while (*cur != ' ') {
+	    if (i < 3)
+		month[i++] = *cur;
+	    cur++;
+	    if (*cur == 0) return(0);
+	}
+	month[i] = 0;
+	while (*cur == ' ') cur++;
+	if (*cur == 0) return(0);
+        while ((*cur >= '0') && (*cur <= '9'))
+	    day = (day * 10) + (*cur++ - '0');
+	while (*cur == ' ') cur++;
+	if (*cur == 0) return(0);
+	if ((cur[1] == 0) || (cur[2] == 0)) return(0);
+	if ((cur[1] == ':') || (cur[2] == ':')) {
+	    while ((*cur >= '0') && (*cur <= '9'))
+		hour = (hour * 10) + (*cur++ - '0');
+	    if (*cur == ':') cur++;
+	    while ((*cur >= '0') && (*cur <= '9'))
+		minute = (minute * 10) + (*cur++ - '0');
+	} else {
+	    while ((*cur >= '0') && (*cur <= '9'))
+		year = (year * 10) + (*cur++ - '0');
+	}
+	while (*cur == ' ') cur++;
+	if (*cur == 0) return(0);
+	i = 0;
+	while ((*cur != '\n')  && (*cur != '\r')) {
+	    if (i < 150)
+		filename[i++] = *cur;
+	    cur++;
+	    if (*cur == 0) return(0);
+	}
+	filename[i] = 0;
+	if ((*cur != '\n') && (*cur != '\r'))
+	    return(0);
+	while ((*cur == '\n')  || (*cur == '\r'))
+	    cur++;
+    }
+    if (callback != NULL) {
+        callback(userData, filename, attrib, owner, group, size, links,
+		 year, month, day, hour, minute);
+    }
+    return(cur - list);
+}
+
+/**
+ * xmlNanoFTPList:
+ * @ctx:  an FTP context
+ * @callback:  the user callback
+ * @userData:  the user callback data
+ * @filename:  optional files to list
+ *
+ * Do a listing on the server. All files info are passed back
+ * in the callbacks.
+ *
+ * Returns -1 incase of error, 0 otherwise
+ */
+
+int
+xmlNanoFTPList(void *ctx, ftpListCallback callback, void *userData,
+	       char *filename) {
+    xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
+    char buf[4096 + 1];
+    int len, res;
+    int indx = 0, base;
+    fd_set rfd, efd;
+    struct timeval tv;
+
+    if (filename == NULL) {
+        if (xmlNanoFTPCwd(ctxt, ctxt->path) < 1)
+	    return(-1);
+	ctxt->dataFd = xmlNanoFTPGetConnection(ctxt);
+	if (ctxt->dataFd == -1)
+	    return(-1);
+	snprintf(buf, sizeof(buf), "LIST -L\r\n");
+    } else {
+	if (filename[0] != '/') {
+	    if (xmlNanoFTPCwd(ctxt, ctxt->path) < 1)
+		return(-1);
+	}
+	ctxt->dataFd = xmlNanoFTPGetConnection(ctxt);
+	if (ctxt->dataFd == -1)
+	    return(-1);
+	snprintf(buf, sizeof(buf), "LIST -L %s\r\n", filename);
+    }
+    buf[sizeof(buf) - 1] = 0;
+    len = strlen(buf);
+#ifdef DEBUG_FTP
+    xmlGenericError(xmlGenericErrorContext, "%s", buf);
+#endif
+    res = send(ctxt->controlFd, buf, len, 0);
+    if (res < 0) {
+	__xmlIOErr(XML_FROM_FTP, 0, "send failed");
+	closesocket(ctxt->dataFd); ctxt->dataFd = -1;
+	return(res);
+    }
+    res = xmlNanoFTPReadResponse(ctxt);
+    if (res != 1) {
+	closesocket(ctxt->dataFd); ctxt->dataFd = -1;
+	return(-res);
+    }
+
+    do {
+	tv.tv_sec = 1;
+	tv.tv_usec = 0;
+	FD_ZERO(&rfd);
+	FD_SET(ctxt->dataFd, &rfd);
+	FD_ZERO(&efd);
+	FD_SET(ctxt->dataFd, &efd);
+	res = select(ctxt->dataFd + 1, &rfd, NULL, &efd, &tv);
+	if (res < 0) {
+#ifdef DEBUG_FTP
+	    perror("select");
+#endif
+	    closesocket(ctxt->dataFd); ctxt->dataFd = -1;
+	    return(-1);
+	}
+	if (res == 0) {
+	    res = xmlNanoFTPCheckResponse(ctxt);
+	    if (res < 0) {
+		closesocket(ctxt->dataFd); ctxt->dataFd = -1;
+		ctxt->dataFd = -1;
+		return(-1);
+	    }
+	    if (res == 2) {
+		closesocket(ctxt->dataFd); ctxt->dataFd = -1;
+		return(0);
+	    }
+
+	    continue;
+	}
+
+	if ((len = recv(ctxt->dataFd, &buf[indx], sizeof(buf) - (indx + 1), 0)) < 0) {
+	    __xmlIOErr(XML_FROM_FTP, 0, "recv");
+	    closesocket(ctxt->dataFd); ctxt->dataFd = -1;
+	    ctxt->dataFd = -1;
+	    return(-1);
+	}
+#ifdef DEBUG_FTP
+        write(1, &buf[indx], len);
+#endif
+	indx += len;
+	buf[indx] = 0;
+	base = 0;
+	do {
+	    res = xmlNanoFTPParseList(&buf[base], callback, userData);
+	    base += res;
+	} while (res > 0);
+
+	memmove(&buf[0], &buf[base], indx - base);
+	indx -= base;
+    } while (len != 0);
+    xmlNanoFTPCloseConnection(ctxt);
+    return(0);
+}
+
+/**
+ * xmlNanoFTPGetSocket:
+ * @ctx:  an FTP context
+ * @filename:  the file to retrieve (or NULL if path is in context).
+ *
+ * Initiate fetch of the given file from the server.
+ *
+ * Returns the socket for the data connection, or <0 in case of error
+ */
+
+
+int
+xmlNanoFTPGetSocket(void *ctx, const char *filename) {
+    xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
+    char buf[300];
+    int res, len;
+    if ((filename == NULL) && (ctxt->path == NULL))
+	return(-1);
+    ctxt->dataFd = xmlNanoFTPGetConnection(ctxt);
+    if (ctxt->dataFd == -1)
+	return(-1);
+
+    snprintf(buf, sizeof(buf), "TYPE I\r\n");
+    len = strlen(buf);
+#ifdef DEBUG_FTP
+    xmlGenericError(xmlGenericErrorContext, "%s", buf);
+#endif
+    res = send(ctxt->controlFd, buf, len, 0);
+    if (res < 0) {
+	__xmlIOErr(XML_FROM_FTP, 0, "send failed");
+	closesocket(ctxt->dataFd); ctxt->dataFd = -1;
+	return(res);
+    }
+    res = xmlNanoFTPReadResponse(ctxt);
+    if (res != 2) {
+	closesocket(ctxt->dataFd); ctxt->dataFd = -1;
+	return(-res);
+    }
+    if (filename == NULL)
+	snprintf(buf, sizeof(buf), "RETR %s\r\n", ctxt->path);
+    else
+	snprintf(buf, sizeof(buf), "RETR %s\r\n", filename);
+    buf[sizeof(buf) - 1] = 0;
+    len = strlen(buf);
+#ifdef DEBUG_FTP
+    xmlGenericError(xmlGenericErrorContext, "%s", buf);
+#endif
+    res = send(ctxt->controlFd, buf, len, 0);
+    if (res < 0) {
+	__xmlIOErr(XML_FROM_FTP, 0, "send failed");
+	closesocket(ctxt->dataFd); ctxt->dataFd = -1;
+	return(res);
+    }
+    res = xmlNanoFTPReadResponse(ctxt);
+    if (res != 1) {
+	closesocket(ctxt->dataFd); ctxt->dataFd = -1;
+	return(-res);
+    }
+    return(ctxt->dataFd);
+}
+
+/**
+ * xmlNanoFTPGet:
+ * @ctx:  an FTP context
+ * @callback:  the user callback
+ * @userData:  the user callback data
+ * @filename:  the file to retrieve
+ *
+ * Fetch the given file from the server. All data are passed back
+ * in the callbacks. The last callback has a size of 0 block.
+ *
+ * Returns -1 incase of error, 0 otherwise
+ */
+
+int
+xmlNanoFTPGet(void *ctx, ftpDataCallback callback, void *userData,
+	      const char *filename) {
+    xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
+    char buf[4096];
+    int len = 0, res;
+    fd_set rfd;
+    struct timeval tv;
+
+    if ((filename == NULL) && (ctxt->path == NULL))
+	return(-1);
+    if (callback == NULL)
+	return(-1);
+    if (xmlNanoFTPGetSocket(ctxt, filename) < 0)
+	return(-1);
+
+    do {
+	tv.tv_sec = 1;
+	tv.tv_usec = 0;
+	FD_ZERO(&rfd);
+	FD_SET(ctxt->dataFd, &rfd);
+	res = select(ctxt->dataFd + 1, &rfd, NULL, NULL, &tv);
+	if (res < 0) {
+#ifdef DEBUG_FTP
+	    perror("select");
+#endif
+	    closesocket(ctxt->dataFd); ctxt->dataFd = -1;
+	    return(-1);
+	}
+	if (res == 0) {
+	    res = xmlNanoFTPCheckResponse(ctxt);
+	    if (res < 0) {
+		closesocket(ctxt->dataFd); ctxt->dataFd = -1;
+		ctxt->dataFd = -1;
+		return(-1);
+	    }
+	    if (res == 2) {
+		closesocket(ctxt->dataFd); ctxt->dataFd = -1;
+		return(0);
+	    }
+
+	    continue;
+	}
+	if ((len = recv(ctxt->dataFd, buf, sizeof(buf), 0)) < 0) {
+	    __xmlIOErr(XML_FROM_FTP, 0, "recv failed");
+	    callback(userData, buf, len);
+	    closesocket(ctxt->dataFd); ctxt->dataFd = -1;
+	    return(-1);
+	}
+	callback(userData, buf, len);
+    } while (len != 0);
+
+    return(xmlNanoFTPCloseConnection(ctxt));
+}
+
+/**
+ * xmlNanoFTPRead:
+ * @ctx:  the FTP context
+ * @dest:  a buffer
+ * @len:  the buffer length
+ *
+ * This function tries to read @len bytes from the existing FTP connection
+ * and saves them in @dest. This is a blocking call.
+ *
+ * Returns the number of byte read. 0 is an indication of an end of connection.
+ *         -1 indicates a parameter error.
+ */
+int
+xmlNanoFTPRead(void *ctx, void *dest, int len) {
+    xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
+
+    if (ctx == NULL) return(-1);
+    if (ctxt->dataFd < 0) return(0);
+    if (dest == NULL) return(-1);
+    if (len <= 0) return(0);
+
+    len = recv(ctxt->dataFd, dest, len, 0);
+    if (len <= 0) {
+        __xmlIOErr(XML_FROM_FTP, 0, "recv failed");
+	xmlNanoFTPCloseConnection(ctxt);
+    }
+#ifdef DEBUG_FTP
+    xmlGenericError(xmlGenericErrorContext, "Recvd %d bytes\n", len);
+#endif
+    return(len);
+}
+
+/**
+ * xmlNanoFTPOpen:
+ * @URL: the URL to the resource
+ *
+ * Start to fetch the given ftp:// resource
+ *
+ * Returns an FTP context, or NULL 
+ */
+
+void*
+xmlNanoFTPOpen(const char *URL) {
+    xmlNanoFTPCtxtPtr ctxt;
+    int sock;
+
+    xmlNanoFTPInit();
+    if (URL == NULL) return(NULL);
+    if (strncmp("ftp://", URL, 6)) return(NULL);
+
+    ctxt = (xmlNanoFTPCtxtPtr) xmlNanoFTPNewCtxt(URL);
+    if (ctxt == NULL) return(NULL);
+    if (xmlNanoFTPConnect(ctxt) < 0) {
+	xmlNanoFTPFreeCtxt(ctxt);
+	return(NULL);
+    }
+    sock = xmlNanoFTPGetSocket(ctxt, ctxt->path);
+    if (sock < 0) {
+	xmlNanoFTPFreeCtxt(ctxt);
+	return(NULL);
+    }
+    return(ctxt);
+}
+
+/**
+ * xmlNanoFTPClose:
+ * @ctx: an FTP context
+ *
+ * Close the connection and both control and transport
+ *
+ * Returns -1 incase of error, 0 otherwise
+ */
+
+int
+xmlNanoFTPClose(void *ctx) {
+    xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
+
+    if (ctxt == NULL)
+	return(-1);
+
+    if (ctxt->dataFd >= 0) {
+	closesocket(ctxt->dataFd);
+	ctxt->dataFd = -1;
+    }
+    if (ctxt->controlFd >= 0) {
+	xmlNanoFTPQuit(ctxt);
+	closesocket(ctxt->controlFd);
+	ctxt->controlFd = -1;
+    }
+    xmlNanoFTPFreeCtxt(ctxt);
+    return(0);
+}
+
+#ifdef STANDALONE
+/************************************************************************
+ * 									*
+ * 			Basic test in Standalone mode			*
+ * 									*
+ ************************************************************************/
+static
+void ftpList(void *userData, const char *filename, const char* attrib,
+	     const char *owner, const char *group, unsigned long size, int links,
+	     int year, const char *month, int day, int hour, int minute) {
+    xmlGenericError(xmlGenericErrorContext,
+	    "%s %s %s %ld %s\n", attrib, owner, group, size, filename);
+}
+static
+void ftpData(void *userData, const char *data, int len) {
+    if (userData == NULL) return;
+    if (len <= 0) {
+	fclose((FILE*)userData);
+	return;
+    }	
+    fwrite(data, len, 1, (FILE*)userData);
+}
+
+int main(int argc, char **argv) {
+    void *ctxt;
+    FILE *output;
+    char *tstfile = NULL;
+
+    xmlNanoFTPInit();
+    if (argc > 1) {
+	ctxt = xmlNanoFTPNewCtxt(argv[1]);
+	if (xmlNanoFTPConnect(ctxt) < 0) {
+	    xmlGenericError(xmlGenericErrorContext,
+		    "Couldn't connect to %s\n", argv[1]);
+	    exit(1);
+	}
+	if (argc > 2)
+	    tstfile = argv[2];
+    } else
+	ctxt = xmlNanoFTPConnectTo("localhost", 0);
+    if (ctxt == NULL) {
+        xmlGenericError(xmlGenericErrorContext,
+		"Couldn't connect to localhost\n");
+        exit(1);
+    }
+    xmlNanoFTPList(ctxt, ftpList, NULL, tstfile);
+    output = fopen("/tmp/tstdata", "w");
+    if (output != NULL) {
+	if (xmlNanoFTPGet(ctxt, ftpData, (void *) output, tstfile) < 0)
+	    xmlGenericError(xmlGenericErrorContext,
+		    "Failed to get file\n");
+	
+    }
+    xmlNanoFTPClose(ctxt);
+    xmlMemoryDump();
+    exit(0);
+}
+#endif /* STANDALONE */
+#else /* !LIBXML_FTP_ENABLED */
+#ifdef STANDALONE
+#include <stdio.h>
+int main(int argc, char **argv) {
+    xmlGenericError(xmlGenericErrorContext,
+	    "%s : FTP support not compiled in\n", argv[0]);
+    return(0);
+}
+#endif /* STANDALONE */
+#endif /* LIBXML_FTP_ENABLED */
diff --git a/src/libxml/src/nanohttp.c b/src/libxml/src/nanohttp.c
new file mode 100644
index 0000000..9f3c75a
--- /dev/null
+++ b/src/libxml/src/nanohttp.c
@@ -0,0 +1,1789 @@
+/*
+ * nanohttp.c: minimalist HTTP GET implementation to fetch external subsets.
+ *             focuses on size, streamability, reentrancy and portability
+ *
+ * This is clearly not a general purpose HTTP implementation
+ * If you look for one, check:
+ *         http://www.w3.org/Library/
+ *
+ * See Copyright for the status of this software.
+ *
+ * daniel@veillard.com
+ */
+ 
+/* TODO add compression support, Send the Accept- , and decompress on the
+        fly with ZLIB if found at compile-time */
+
+#define NEED_SOCKETS
+#define IN_LIBXML
+#include "libxml.h"
+
+#ifdef LIBXML_HTTP_ENABLED
+#include <string.h>
+
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
+#ifdef HAVE_ARPA_INET_H
+#include <arpa/inet.h>
+#endif
+#ifdef HAVE_NETDB_H
+#include <netdb.h>
+#endif
+#ifdef HAVE_RESOLV_H
+#ifdef HAVE_ARPA_NAMESER_H
+#include <arpa/nameser.h>
+#endif
+#include <resolv.h>
+#endif
+#ifdef HAVE_FCNTL_H
+#include <fcntl.h> 
+#endif
+#ifdef HAVE_ERRNO_H
+#include <errno.h>
+#endif
+#ifdef HAVE_SYS_TIME_H
+#include <sys/time.h>
+#endif
+#ifdef HAVE_SYS_SELECT_H
+#include <sys/select.h>
+#endif
+#ifdef HAVE_STRINGS_H
+#include <strings.h>
+#endif
+#ifdef SUPPORT_IP6
+#include <resolv.h>
+#endif
+
+#ifdef VMS
+#include <stropts>
+#define SOCKLEN_T unsigned int
+#define SOCKET int
+#endif
+
+
+#ifdef __MINGW32__
+#define _WINSOCKAPI_
+#include <wsockcompat.h>
+#include <winsock2.h>
+#undef SOCKLEN_T
+#define SOCKLEN_T unsigned int
+#endif
+
+
+#include <libxml/globals.h>
+#include <libxml/xmlerror.h>
+#include <libxml/xmlmemory.h>
+#include <libxml/parser.h> /* for xmlStr(n)casecmp() */
+#include <libxml/nanohttp.h>
+#include <libxml/globals.h>
+#include <libxml/uri.h>
+
+/**
+ * A couple portability macros
+ */
+#ifndef _WINSOCKAPI_
+#ifndef __BEOS__
+#define closesocket(s) close(s)
+#endif
+#define SOCKET int
+#endif
+
+#ifdef __BEOS__
+#ifndef PF_INET
+#define PF_INET AF_INET
+#endif
+#endif
+
+#ifndef SOCKLEN_T
+#define SOCKLEN_T unsigned int
+#endif
+#ifndef SOCKET
+#define SOCKET int
+#endif
+
+#ifdef STANDALONE
+#define DEBUG_HTTP
+#define xmlStrncasecmp(a, b, n) strncasecmp((char *)a, (char *)b, n)
+#define xmlStrcasecmpi(a, b) strcasecmp((char *)a, (char *)b)
+#endif
+
+#define XML_NANO_HTTP_MAX_REDIR	10
+
+#define XML_NANO_HTTP_CHUNK	4096
+
+#define XML_NANO_HTTP_CLOSED	0
+#define XML_NANO_HTTP_WRITE	1
+#define XML_NANO_HTTP_READ	2
+#define XML_NANO_HTTP_NONE	4
+
+typedef struct xmlNanoHTTPCtxt {
+    char *protocol;	/* the protocol name */
+    char *hostname;	/* the host name */
+    int port;		/* the port */
+    char *path;		/* the path within the URL */
+    SOCKET fd;		/* the file descriptor for the socket */
+    int state;		/* WRITE / READ / CLOSED */
+    char *out;		/* buffer sent (zero terminated) */
+    char *outptr;	/* index within the buffer sent */
+    char *in;		/* the receiving buffer */
+    char *content;	/* the start of the content */
+    char *inptr;	/* the next byte to read from network */
+    char *inrptr;	/* the next byte to give back to the client */
+    int inlen;		/* len of the input buffer */
+    int last;		/* return code for last operation */
+    int returnValue;	/* the protocol return value */
+    int ContentLength;  /* specified content length from HTTP header */
+    char *contentType;	/* the MIME type for the input */
+    char *location;	/* the new URL in case of redirect */
+    char *authHeader;	/* contents of {WWW,Proxy}-Authenticate header */
+    char *encoding;	/* encoding extracted from the contentType */
+    char *mimeType;	/* Mime-Type extracted from the contentType */
+} xmlNanoHTTPCtxt, *xmlNanoHTTPCtxtPtr;
+
+static int initialized = 0;
+static char *proxy = NULL;	 /* the proxy name if any */
+static int proxyPort;	/* the proxy port if any */
+static unsigned int timeout = 60;/* the select() timeout in seconds */
+
+int xmlNanoHTTPFetchContent( void * ctx, char ** ptr, int * len );
+int xmlNanoHTTPContentLength( void * ctx );
+
+/**
+ * xmlHTTPErrMemory:
+ * @extra:  extra informations
+ *
+ * Handle an out of memory condition
+ */
+static void
+xmlHTTPErrMemory(const char *extra)
+{
+    __xmlSimpleError(XML_FROM_HTTP, XML_ERR_NO_MEMORY, NULL, NULL, extra);
+}
+
+/**
+ * A portability function
+ */
+static int socket_errno(void) {
+#ifdef _WINSOCKAPI_
+    return(WSAGetLastError());
+#else
+    return(errno);
+#endif
+}
+
+#ifdef SUPPORT_IP6
+static
+int have_ipv6(void) {
+    int s;
+
+    s = socket (AF_INET6, SOCK_STREAM, 0);
+    if (s != -1) {
+	close (s);
+	return (1);
+    }
+    return (0);
+}
+#endif
+
+/**
+ * xmlNanoHTTPInit:
+ *
+ * Initialize the HTTP protocol layer.
+ * Currently it just checks for proxy informations
+ */
+
+void
+xmlNanoHTTPInit(void) {
+    const char *env;
+#ifdef _WINSOCKAPI_
+    WSADATA wsaData;    
+#endif
+
+    if (initialized)
+	return;
+
+#ifdef _WINSOCKAPI_
+    if (WSAStartup(MAKEWORD(1, 1), &wsaData) != 0)
+	return;
+#endif
+
+    if (proxy == NULL) {
+	proxyPort = 80;
+	env = getenv("no_proxy");
+	if (env != NULL)
+	    goto done;
+	env = getenv("http_proxy");
+	if (env != NULL) {
+	    xmlNanoHTTPScanProxy(env);
+	    goto done;
+	}
+	env = getenv("HTTP_PROXY");
+	if (env != NULL) {
+	    xmlNanoHTTPScanProxy(env);
+	    goto done;
+	}
+    }
+done:
+    initialized = 1;
+}
+
+/**
+ * xmlNanoHTTPCleanup:
+ *
+ * Cleanup the HTTP protocol layer.
+ */
+
+void
+xmlNanoHTTPCleanup(void) {
+    if (proxy != NULL)
+	xmlFree(proxy);
+#ifdef _WINSOCKAPI_
+    if (initialized)
+	WSACleanup();
+#endif
+    initialized = 0;
+    return;
+}
+
+/**
+ * xmlNanoHTTPScanURL:
+ * @ctxt:  an HTTP context
+ * @URL:  The URL used to initialize the context
+ *
+ * (Re)Initialize an HTTP context by parsing the URL and finding
+ * the protocol host port and path it indicates.
+ */
+
+static void
+xmlNanoHTTPScanURL(xmlNanoHTTPCtxtPtr ctxt, const char *URL) {
+    const char *cur = URL;
+    char buf[4096];
+    int indx = 0;
+    const int indxMax = 4096 - 1;
+    int port = 0;
+
+    if (ctxt->protocol != NULL) { 
+        xmlFree(ctxt->protocol);
+	ctxt->protocol = NULL;
+    }
+    if (ctxt->hostname != NULL) { 
+        xmlFree(ctxt->hostname);
+	ctxt->hostname = NULL;
+    }
+    if (ctxt->path != NULL) { 
+        xmlFree(ctxt->path);
+	ctxt->path = NULL;
+    }
+    if (URL == NULL) return;
+    buf[indx] = 0;
+    while ((*cur != 0) && (indx < indxMax)) {
+        if ((cur[0] == ':') && (cur[1] == '/') && (cur[2] == '/')) {
+	    buf[indx] = 0;
+	    ctxt->protocol = xmlMemStrdup(buf);
+	    indx = 0;
+            cur += 3;
+	    break;
+	}
+	buf[indx++] = *cur++;
+    }
+    if (*cur == 0) return;
+
+    buf[indx] = 0;
+    while (indx < indxMax) {
+	if ((strchr (cur, '[') && !strchr (cur, ']')) ||
+		(!strchr (cur, '[') && strchr (cur, ']'))) {
+	    __xmlIOErr(XML_FROM_HTTP, XML_HTTP_URL_SYNTAX, 
+	               "Syntax Error\n");
+	    return;
+	}
+
+	if (cur[0] == '[') {
+	    cur++;
+	    while ((cur[0] != ']') && (indx < indxMax))
+		buf[indx++] = *cur++;
+    
+	    if (!strchr (buf, ':')) {
+		__xmlIOErr(XML_FROM_HTTP, XML_HTTP_USE_IP,
+			"Use [IPv6]/IPv4 format\n");
+		return;
+	    }
+
+	    buf[indx] = 0;
+	    ctxt->hostname = xmlMemStrdup (buf);
+	    indx = 0;
+	    cur += 1;
+	    if (cur[0] == ':') {
+		cur++;
+		while (*cur >= '0' && *cur <= '9') {
+		    port *= 10;
+		    port += *cur - '0';
+		    cur++;
+		}
+
+		if (port != 0) ctxt->port = port;
+		while ((cur[0] != '/') && (*cur != 0))
+		    cur++;
+	    }
+	    break;
+        }
+	else {
+	    if (cur[0] == ':') {
+		buf[indx] = 0;
+		ctxt->hostname = xmlMemStrdup (buf);
+		indx = 0;
+		cur += 1;
+		while ((*cur >= '0') && (*cur <= '9')) {
+		    port *= 10;
+		    port += *cur - '0';
+		    cur++;
+		}
+		if (port != 0) ctxt->port = port;
+		while ((cur[0] != '/') && (*cur != 0)) 
+		    cur++;
+		break;
+	    }
+	    if ((*cur == '/') || (*cur == 0)) {
+		buf[indx] = 0;
+		ctxt->hostname = xmlMemStrdup (buf);
+		indx = 0;
+		break;
+	    }
+	}
+	buf[indx++] = *cur++;
+    }
+    if (*cur == 0) 
+        ctxt->path = xmlMemStrdup("/");
+    else {
+        indx = 0;
+        buf[indx] = 0;
+	while ((*cur != 0) && (indx < indxMax))
+	    buf[indx++] = *cur++;
+	buf[indx] = 0;
+	ctxt->path = xmlMemStrdup(buf);
+    }	
+}
+
+/**
+ * xmlNanoHTTPScanProxy:
+ * @URL:  The proxy URL used to initialize the proxy context
+ *
+ * (Re)Initialize the HTTP Proxy context by parsing the URL and finding
+ * the protocol host port it indicates.
+ * Should be like http://myproxy/ or http://myproxy:3128/
+ * A NULL URL cleans up proxy informations.
+ */
+
+void
+xmlNanoHTTPScanProxy(const char *URL) {
+    const char *cur = URL;
+    char buf[4096];
+    int indx = 0;
+    const int indxMax = 4096 - 1;
+    int port = 0;
+
+    if (proxy != NULL) { 
+        xmlFree(proxy);
+	proxy = NULL;
+    }
+    if (proxyPort != 0) { 
+	proxyPort = 0;
+    }
+#ifdef DEBUG_HTTP
+    if (URL == NULL)
+	xmlGenericError(xmlGenericErrorContext,
+		"Removing HTTP proxy info\n");
+    else
+	xmlGenericError(xmlGenericErrorContext,
+		"Using HTTP proxy %s\n", URL);
+#endif
+    if (URL == NULL) return;
+    buf[indx] = 0;
+    while ((*cur != 0) && (indx < indxMax)) {
+        if ((cur[0] == ':') && (cur[1] == '/') && (cur[2] == '/')) {
+	    buf[indx] = 0;
+	    indx = 0;
+            cur += 3;
+	    break;
+	}
+	buf[indx++] = *cur++;
+    }
+    if (*cur == 0) return;
+
+    buf[indx] = 0;
+    while (indx < indxMax) {
+	if ((strchr (cur, '[') && !strchr (cur, ']')) ||
+		(!strchr (cur, '[') && strchr (cur, ']'))) {
+	    __xmlIOErr(XML_FROM_HTTP, XML_HTTP_URL_SYNTAX, "Syntax Error\n");
+	    return;
+	}
+
+	if (cur[0] == '[') {
+	    cur++;
+	    while ((cur[0] != ']') && (indx < indxMax))
+		buf[indx++] = *cur++;
+
+	    if (!strchr (buf, ':')) {
+		__xmlIOErr(XML_FROM_HTTP, XML_HTTP_USE_IP,
+			"Use [IPv6]/IPv4 format\n");
+		return;
+	    }
+
+	    buf[indx] = 0;
+	    proxy = xmlMemStrdup (buf);
+	    indx = 0;
+	    cur += 1;
+	    if (cur[0] == ':') {
+	        cur++;
+		while (*cur >= '0' && *cur <= '9') {
+		    port *= 10;
+		    port += *cur - '0';
+		    cur++;
+		}
+
+		if (port != 0) proxyPort = port;
+		while ((cur[0] != '/') && (*cur != 0))
+		    cur ++;
+	    }
+	    break;
+	}
+	else {
+	    if (cur[0] == ':') {
+		buf[indx] = 0;
+		proxy = xmlMemStrdup (buf);
+		indx = 0;
+		cur += 1;
+		while ((*cur >= '0') && (*cur <= '9')) {
+		    port *= 10;
+		    port += *cur - '0';
+		    cur++;
+		}
+		if (port != 0) proxyPort = port;
+		while ((cur[0] != '/') && (*cur != 0)) 
+		    cur++;
+		break;
+	    }
+	    if ((*cur == '/') || (*cur == 0)) {
+		buf[indx] = 0;
+		proxy = xmlMemStrdup (buf);
+		indx = 0;
+		break;
+	    }
+	}
+	buf[indx++] = *cur++;
+    }
+}
+
+/**
+ * xmlNanoHTTPNewCtxt:
+ * @URL:  The URL used to initialize the context
+ *
+ * Allocate and initialize a new HTTP context.
+ *
+ * Returns an HTTP context or NULL in case of error.
+ */
+
+static xmlNanoHTTPCtxtPtr
+xmlNanoHTTPNewCtxt(const char *URL) {
+    xmlNanoHTTPCtxtPtr ret;
+
+    ret = (xmlNanoHTTPCtxtPtr) xmlMalloc(sizeof(xmlNanoHTTPCtxt));
+    if (ret == NULL) {
+        xmlHTTPErrMemory("allocating context");
+        return(NULL);
+    }
+
+    memset(ret, 0, sizeof(xmlNanoHTTPCtxt));
+    ret->port = 80;
+    ret->returnValue = 0;
+    ret->fd = -1;
+    ret->ContentLength = -1;
+
+    xmlNanoHTTPScanURL(ret, URL);
+
+    return(ret);
+}
+
+/**
+ * xmlNanoHTTPFreeCtxt:
+ * @ctxt:  an HTTP context
+ *
+ * Frees the context after closing the connection.
+ */
+
+static void
+xmlNanoHTTPFreeCtxt(xmlNanoHTTPCtxtPtr ctxt) {
+    if (ctxt == NULL) return;
+    if (ctxt->hostname != NULL) xmlFree(ctxt->hostname);
+    if (ctxt->protocol != NULL) xmlFree(ctxt->protocol);
+    if (ctxt->path != NULL) xmlFree(ctxt->path);
+    if (ctxt->out != NULL) xmlFree(ctxt->out);
+    if (ctxt->in != NULL) xmlFree(ctxt->in);
+    if (ctxt->contentType != NULL) xmlFree(ctxt->contentType);
+    if (ctxt->encoding != NULL) xmlFree(ctxt->encoding);
+    if (ctxt->mimeType != NULL) xmlFree(ctxt->mimeType);
+    if (ctxt->location != NULL) xmlFree(ctxt->location);
+    if (ctxt->authHeader != NULL) xmlFree(ctxt->authHeader);
+    ctxt->state = XML_NANO_HTTP_NONE;
+    if (ctxt->fd >= 0) closesocket(ctxt->fd);
+    ctxt->fd = -1;
+    xmlFree(ctxt);
+}
+
+/**
+ * xmlNanoHTTPSend:
+ * @ctxt:  an HTTP context
+ *
+ * Send the input needed to initiate the processing on the server side
+ * Returns number of bytes sent or -1 on error.
+ */
+
+static int
+xmlNanoHTTPSend(xmlNanoHTTPCtxtPtr ctxt, const char * xmt_ptr, int outlen) {
+
+    int 	total_sent = 0;
+
+    if ( (ctxt->state & XML_NANO_HTTP_WRITE) && (xmt_ptr != NULL ) ) {
+        while (total_sent < outlen) {
+            int nsent = send(ctxt->fd, xmt_ptr + total_sent,
+                                      outlen - total_sent, 0);
+            if (nsent>0)
+                total_sent += nsent;
+	    else if ( ( nsent == -1 ) && 
+#if defined(EAGAIN) && EAGAIN != EWOULDBLOCK
+	    	      ( socket_errno( ) != EAGAIN ) &&
+#endif
+		        ( socket_errno( ) != EWOULDBLOCK ) ) {
+		__xmlIOErr(XML_FROM_HTTP, 0, "send failed\n");
+		if ( total_sent == 0 )
+		    total_sent = -1;
+		break;
+	    }
+	    else {
+	        /*
+		**  No data sent
+		**  Since non-blocking sockets are used, wait for 
+		**  socket to be writable or default timeout prior
+		**  to retrying.
+		*/
+
+		struct timeval	tv;
+		fd_set		wfd;
+
+		tv.tv_sec = timeout;
+		tv.tv_usec = 0;
+		FD_ZERO( &wfd );
+		FD_SET( ctxt->fd, &wfd );
+		(void)select( ctxt->fd + 1, NULL, &wfd, NULL, &tv );
+	    }
+	}
+    }
+
+    return total_sent;
+}
+
+/**
+ * xmlNanoHTTPRecv:
+ * @ctxt:  an HTTP context
+ *
+ * Read information coming from the HTTP connection.
+ * This is a blocking call (but it blocks in select(), not read()).
+ *
+ * Returns the number of byte read or -1 in case of error.
+ */
+
+static int
+xmlNanoHTTPRecv(xmlNanoHTTPCtxtPtr ctxt) {
+    fd_set rfd;
+    struct timeval tv;
+
+
+    while (ctxt->state & XML_NANO_HTTP_READ) {
+	if (ctxt->in == NULL) {
+	    ctxt->in = (char *) xmlMallocAtomic(65000 * sizeof(char));
+	    if (ctxt->in == NULL) {
+		xmlHTTPErrMemory("allocating input");
+	        ctxt->last = -1;
+		return(-1);
+	    }
+	    ctxt->inlen = 65000;
+	    ctxt->inptr = ctxt->content = ctxt->inrptr = ctxt->in;
+	}
+	if (ctxt->inrptr > ctxt->in + XML_NANO_HTTP_CHUNK) {
+	    int delta = ctxt->inrptr - ctxt->in;
+	    int len = ctxt->inptr - ctxt->inrptr;
+	    
+	    memmove(ctxt->in, ctxt->inrptr, len);
+	    ctxt->inrptr -= delta;
+	    ctxt->content -= delta;
+	    ctxt->inptr -= delta;
+	}
+        if ((ctxt->in + ctxt->inlen) < (ctxt->inptr + XML_NANO_HTTP_CHUNK)) {
+	    int d_inptr = ctxt->inptr - ctxt->in;
+	    int d_content = ctxt->content - ctxt->in;
+	    int d_inrptr = ctxt->inrptr - ctxt->in;
+	    char *	tmp_ptr = ctxt->in;
+
+	    ctxt->inlen *= 2;
+            ctxt->in = (char *) xmlRealloc(tmp_ptr, ctxt->inlen);
+	    if (ctxt->in == NULL) {
+		xmlHTTPErrMemory("allocating input buffer");
+		xmlFree( tmp_ptr );
+	        ctxt->last = -1;
+		return(-1);
+	    }
+            ctxt->inptr = ctxt->in + d_inptr;
+            ctxt->content = ctxt->in + d_content;
+            ctxt->inrptr = ctxt->in + d_inrptr;
+	}
+	ctxt->last = recv(ctxt->fd, ctxt->inptr, XML_NANO_HTTP_CHUNK, 0);
+	if (ctxt->last > 0) {
+	    ctxt->inptr += ctxt->last;
+	    return(ctxt->last);
+	}
+	if (ctxt->last == 0) {
+	    return(0);
+	}
+	if (ctxt->last == -1) {
+	    switch (socket_errno()) {
+		case EINPROGRESS:
+		case EWOULDBLOCK:
+#if defined(EAGAIN) && EAGAIN != EWOULDBLOCK
+		case EAGAIN:
+#endif
+		    break;
+
+		case ECONNRESET:
+		case ESHUTDOWN:
+		    return ( 0 );
+
+		default:
+		    __xmlIOErr(XML_FROM_HTTP, 0, "recv failed\n");
+		    return(-1);
+	    }
+	}
+
+	tv.tv_sec = timeout;
+	tv.tv_usec = 0;
+	FD_ZERO(&rfd);
+	FD_SET(ctxt->fd, &rfd);
+	
+	if ( (select(ctxt->fd+1, &rfd, NULL, NULL, &tv)<1)
+#if defined(EINTR)
+		&& (errno != EINTR)
+#endif
+	)
+		return(0);
+    }
+    return(0);
+}
+
+/**
+ * xmlNanoHTTPReadLine:
+ * @ctxt:  an HTTP context
+ *
+ * Read one line in the HTTP server output, usually for extracting
+ * the HTTP protocol informations from the answer header.
+ *
+ * Returns a newly allocated string with a copy of the line, or NULL
+ *         which indicate the end of the input.
+ */
+
+static char *
+xmlNanoHTTPReadLine(xmlNanoHTTPCtxtPtr ctxt) {
+    char buf[4096];
+    char *bp = buf;
+    int	rc;
+    
+    while (bp - buf < 4095) {
+	if (ctxt->inrptr == ctxt->inptr) {
+	    if ( (rc = xmlNanoHTTPRecv(ctxt)) == 0) {
+		if (bp == buf)
+		    return(NULL);
+		else
+		    *bp = 0;
+		return(xmlMemStrdup(buf));
+	    }
+	    else if ( rc == -1 ) {
+	        return ( NULL );
+	    }
+	}
+	*bp = *ctxt->inrptr++;
+	if (*bp == '\n') {
+	    *bp = 0;
+	    return(xmlMemStrdup(buf));
+	}
+	if (*bp != '\r')
+	    bp++;
+    }
+    buf[4095] = 0;
+    return(xmlMemStrdup(buf));
+}
+
+
+/**
+ * xmlNanoHTTPScanAnswer:
+ * @ctxt:  an HTTP context
+ * @line:  an HTTP header line
+ *
+ * Try to extract useful informations from the server answer.
+ * We currently parse and process:
+ *  - The HTTP revision/ return code
+ *  - The Content-Type, Mime-Type and charset used
+ *  - The Location for redirect processing.
+ *
+ * Returns -1 in case of failure, the file descriptor number otherwise
+ */
+
+static void
+xmlNanoHTTPScanAnswer(xmlNanoHTTPCtxtPtr ctxt, const char *line) {
+    const char *cur = line;
+
+    if (line == NULL) return;
+
+    if (!strncmp(line, "HTTP/", 5)) {
+        int version = 0;
+	int ret = 0;
+
+	cur += 5;
+	while ((*cur >= '0') && (*cur <= '9')) {
+	    version *= 10;
+	    version += *cur - '0';
+	    cur++;
+	}
+	if (*cur == '.') {
+	    cur++;
+	    if ((*cur >= '0') && (*cur <= '9')) {
+		version *= 10;
+		version += *cur - '0';
+		cur++;
+	    }
+	    while ((*cur >= '0') && (*cur <= '9'))
+		cur++;
+	} else
+	    version *= 10;
+	if ((*cur != ' ') && (*cur != '\t')) return;
+	while ((*cur == ' ') || (*cur == '\t')) cur++;
+	if ((*cur < '0') || (*cur > '9')) return;
+	while ((*cur >= '0') && (*cur <= '9')) {
+	    ret *= 10;
+	    ret += *cur - '0';
+	    cur++;
+	}
+	if ((*cur != 0) && (*cur != ' ') && (*cur != '\t')) return;
+	ctxt->returnValue = ret;
+    } else if (!xmlStrncasecmp(BAD_CAST line, BAD_CAST"Content-Type:", 13)) {
+        const xmlChar *charset, *last, *mime;
+        cur += 13;
+	while ((*cur == ' ') || (*cur == '\t')) cur++;
+	if (ctxt->contentType != NULL)
+	    xmlFree(ctxt->contentType);
+	ctxt->contentType = xmlMemStrdup(cur);
+	mime = (const xmlChar *) cur;
+	last = mime;
+	while ((*last != 0) && (*last != ' ') && (*last != '\t') &&
+	       (*last != ';') && (*last != ','))
+	    last++;
+	if (ctxt->mimeType != NULL)
+	    xmlFree(ctxt->mimeType);
+	ctxt->mimeType = (char *) xmlStrndup(mime, last - mime);
+	charset = xmlStrstr(BAD_CAST ctxt->contentType, BAD_CAST "charset=");
+	if (charset != NULL) {
+	    charset += 8;
+	    last = charset;
+	    while ((*last != 0) && (*last != ' ') && (*last != '\t') &&
+	           (*last != ';') && (*last != ','))
+		last++;
+	    if (ctxt->encoding != NULL)
+	        xmlFree(ctxt->encoding);
+	    ctxt->encoding = (char *) xmlStrndup(charset, last - charset);
+	}
+    } else if (!xmlStrncasecmp(BAD_CAST line, BAD_CAST"ContentType:", 12)) {
+        const xmlChar *charset, *last, *mime;
+        cur += 12;
+	if (ctxt->contentType != NULL) return;
+	while ((*cur == ' ') || (*cur == '\t')) cur++;
+	ctxt->contentType = xmlMemStrdup(cur);
+	mime = (const xmlChar *) cur;
+	last = mime;
+	while ((*last != 0) && (*last != ' ') && (*last != '\t') &&
+	       (*last != ';') && (*last != ','))
+	    last++;
+	if (ctxt->mimeType != NULL)
+	    xmlFree(ctxt->mimeType);
+	ctxt->mimeType = (char *) xmlStrndup(mime, last - mime);
+	charset = xmlStrstr(BAD_CAST ctxt->contentType, BAD_CAST "charset=");
+	if (charset != NULL) {
+	    charset += 8;
+	    last = charset;
+	    while ((*last != 0) && (*last != ' ') && (*last != '\t') &&
+	           (*last != ';') && (*last != ','))
+		last++;
+	    if (ctxt->encoding != NULL)
+	        xmlFree(ctxt->encoding);
+	    ctxt->encoding = (char *) xmlStrndup(charset, last - charset);
+	}
+    } else if (!xmlStrncasecmp(BAD_CAST line, BAD_CAST"Location:", 9)) {
+        cur += 9;
+	while ((*cur == ' ') || (*cur == '\t')) cur++;
+	if (ctxt->location != NULL)
+	    xmlFree(ctxt->location);
+	if (*cur == '/') {
+	    xmlChar *tmp_http = xmlStrdup(BAD_CAST "http://");
+	    xmlChar *tmp_loc = 
+	        xmlStrcat(tmp_http, (const xmlChar *) ctxt->hostname);
+	    ctxt->location = 
+	        (char *) xmlStrcat (tmp_loc, (const xmlChar *) cur);
+	} else {
+	    ctxt->location = xmlMemStrdup(cur);
+	}
+    } else if (!xmlStrncasecmp(BAD_CAST line, BAD_CAST"WWW-Authenticate:", 17)) {
+        cur += 17;
+	while ((*cur == ' ') || (*cur == '\t')) cur++;
+	if (ctxt->authHeader != NULL)
+	    xmlFree(ctxt->authHeader);
+	ctxt->authHeader = xmlMemStrdup(cur);
+    } else if (!xmlStrncasecmp(BAD_CAST line, BAD_CAST"Proxy-Authenticate:", 19)) {
+        cur += 19;
+	while ((*cur == ' ') || (*cur == '\t')) cur++;
+	if (ctxt->authHeader != NULL)
+	    xmlFree(ctxt->authHeader);
+	ctxt->authHeader = xmlMemStrdup(cur);
+    } else if ( !xmlStrncasecmp( BAD_CAST line, BAD_CAST"Content-Length:", 15) ) {
+	cur += 15;
+	ctxt->ContentLength = strtol( cur, NULL, 10 );
+    }
+}
+
+/**
+ * xmlNanoHTTPConnectAttempt:
+ * @addr:  a socket address structure
+ *
+ * Attempt a connection to the given IP:port endpoint. It forces
+ * non-blocking semantic on the socket, and allow 60 seconds for
+ * the host to answer.
+ *
+ * Returns -1 in case of failure, the file descriptor number otherwise
+ */
+
+static int
+xmlNanoHTTPConnectAttempt(struct sockaddr *addr)
+{
+    fd_set wfd;
+#ifdef _WINSOCKAPI_
+    fd_set xfd;
+#endif
+    struct timeval tv;
+    int status;
+    int addrlen;
+    SOCKET s;
+    
+#ifdef SUPPORT_IP6
+    if (addr->sa_family == AF_INET6) {
+	s = socket (PF_INET6, SOCK_STREAM, IPPROTO_TCP);
+	addrlen = sizeof (struct sockaddr_in6);
+    }
+    else
+#endif
+    {
+	s = socket (PF_INET, SOCK_STREAM, IPPROTO_TCP);
+	addrlen = sizeof (struct sockaddr_in);
+    }
+    if (s==-1) {
+#ifdef DEBUG_HTTP
+	perror("socket");
+#endif
+	__xmlIOErr(XML_FROM_HTTP, 0, "socket failed\n");
+	return(-1);
+    }
+    
+#ifdef _WINSOCKAPI_
+    {
+	u_long one = 1;
+
+	status = ioctlsocket(s, FIONBIO, &one) == SOCKET_ERROR ? -1 : 0;
+    }
+#else /* _WINSOCKAPI_ */
+#if defined(VMS)
+    {
+	int enable = 1;
+	status = ioctl(s, FIONBIO, &enable);
+    }
+#else /* VMS */
+#if defined(__BEOS__)
+	{
+		bool noblock = true;
+		status = setsockopt(s, SOL_SOCKET, SO_NONBLOCK, &noblock, sizeof(noblock));
+	}
+#else /* __BEOS__ */
+    if ((status = fcntl(s, F_GETFL, 0)) != -1) {
+#ifdef O_NONBLOCK
+	status |= O_NONBLOCK;
+#else /* O_NONBLOCK */
+#ifdef F_NDELAY
+	status |= F_NDELAY;
+#endif /* F_NDELAY */
+#endif /* !O_NONBLOCK */
+	status = fcntl(s, F_SETFL, status);
+    }
+    if (status < 0) {
+#ifdef DEBUG_HTTP
+	perror("nonblocking");
+#endif
+	__xmlIOErr(XML_FROM_HTTP, 0, "error setting non-blocking IO\n");
+	closesocket(s);
+	return(-1);
+    }
+#endif /* !__BEOS__ */
+#endif /* !VMS */
+#endif /* !_WINSOCKAPI_ */
+
+    if (connect (s, addr, addrlen) == -1) {
+	switch (socket_errno()) {
+	    case EINPROGRESS:
+	    case EWOULDBLOCK:
+		break;
+	    default:
+		__xmlIOErr(XML_FROM_HTTP, 0, "error connecting to HTTP server");
+		closesocket(s);
+		return(-1);
+	}
+    }	
+    
+    tv.tv_sec = timeout;
+    tv.tv_usec = 0;
+    
+    FD_ZERO(&wfd);
+    FD_SET(s, &wfd);
+
+#ifdef _WINSOCKAPI_    
+    FD_ZERO(&xfd);
+    FD_SET(s, &xfd);
+    
+    switch(select(s+1, NULL, &wfd, &xfd, &tv))
+#else
+    switch(select(s+1, NULL, &wfd, NULL, &tv))
+#endif
+    {
+	case 0:
+	    /* Time out */
+	    __xmlIOErr(XML_FROM_HTTP, 0, "Connect attempt timed out");
+	    closesocket(s);
+	    return(-1);
+	case -1:
+	    /* Ermm.. ?? */
+	    __xmlIOErr(XML_FROM_HTTP, 0, "Connect failed");
+	    closesocket(s);
+	    return(-1);
+    }
+
+    if ( FD_ISSET(s, &wfd)
+#ifdef _WINSOCKAPI_
+                           || FD_ISSET(s, &xfd)
+#endif
+                                                ) {
+	SOCKLEN_T len;
+	len = sizeof(status);
+#ifdef SO_ERROR
+	if (getsockopt(s, SOL_SOCKET, SO_ERROR, (char*)&status, &len) < 0 ) {
+	    /* Solaris error code */
+	    __xmlIOErr(XML_FROM_HTTP, 0, "getsockopt failed\n");
+	    return (-1);
+	}
+#endif
+	if ( status ) {
+	    __xmlIOErr(XML_FROM_HTTP, 0, "Error connecting to remote host");
+	    closesocket(s);
+	    errno = status;
+	    return (-1);
+	}
+    } else {
+	/* pbm */
+	__xmlIOErr(XML_FROM_HTTP, 0, "select failed\n");
+	closesocket(s);
+	return (-1);
+    }
+    
+    return(s);
+}
+ 
+/**
+ * xmlNanoHTTPConnectHost:
+ * @host:  the host name
+ * @port:  the port number
+ *
+ * Attempt a connection to the given host:port endpoint. It tries
+ * the multiple IP provided by the DNS if available.
+ *
+ * Returns -1 in case of failure, the file descriptor number otherwise
+ */
+
+static int
+xmlNanoHTTPConnectHost(const char *host, int port)
+{
+    struct hostent *h;
+    struct sockaddr *addr = NULL;
+    struct in_addr ia;
+    struct sockaddr_in sockin;
+
+#ifdef SUPPORT_IP6
+    struct in6_addr ia6;
+    struct sockaddr_in6 sockin6;
+#endif
+    int i;
+    int s;
+
+    memset (&sockin, 0, sizeof(sockin));
+#ifdef SUPPORT_IP6
+    memset (&sockin6, 0, sizeof(sockin6));
+    if (have_ipv6 ())
+#if !defined(HAVE_GETADDRINFO) && defined(RES_USE_INET6)
+    {
+	if (!(_res.options & RES_INIT))
+	    res_init();
+	_res.options |= RES_USE_INET6;
+    }
+#elif defined(HAVE_GETADDRINFO)
+    {
+	int status;
+	struct addrinfo hints, *res, *result;
+
+	result = NULL;
+	memset (&hints, 0,sizeof(hints));
+	hints.ai_socktype = SOCK_STREAM;
+
+	status = getaddrinfo (host, NULL, &hints, &result);
+	if (status) {
+	    __xmlIOErr(XML_FROM_HTTP, 0, "getaddrinfo failed\n");
+	    return (-1);
+	}
+
+	for (res = result; res; res = res->ai_next) {
+	    if (res->ai_family == AF_INET || res->ai_family == AF_INET6) {
+		if (res->ai_family == AF_INET6) {
+		    memcpy (&sockin6, res->ai_addr, res->ai_addrlen);
+		    sockin6.sin6_port = htons (port);
+		    addr = (struct sockaddr *)&sockin6;
+		}
+		else {
+		    memcpy (&sockin, res->ai_addr, res->ai_addrlen);
+		    sockin.sin_port = htons (port);
+		    addr = (struct sockaddr *)&sockin;
+		}
+
+		s = xmlNanoHTTPConnectAttempt (addr);
+		if (s != -1) {
+		    freeaddrinfo (result);
+		    return (s);
+		}
+	    }
+	}
+	if (result)
+	    freeaddrinfo (result);
+	return (-1);
+    } else
+#endif
+#endif
+    {   
+	h = gethostbyname (host);
+	if (h == NULL) {
+
+/*
+ * Okay, I got fed up by the non-portability of this error message
+ * extraction code. it work on Linux, if it work on your platform
+ * and one want to enable it, send me the defined(foobar) needed
+ */
+#if defined(HAVE_NETDB_H) && defined(HOST_NOT_FOUND) && defined(linux)
+	    const char *h_err_txt = "";
+
+	    switch (h_errno) {
+		case HOST_NOT_FOUND:
+		    h_err_txt = "Authoritive host not found";
+		    break;
+
+		case TRY_AGAIN:
+		    h_err_txt =
+			"Non-authoritive host not found or server failure.";
+		    break;
+
+		case NO_RECOVERY:
+		    h_err_txt =
+			"Non-recoverable errors:  FORMERR, REFUSED, or NOTIMP.";
+		    break;
+
+		case NO_ADDRESS:
+		    h_err_txt =
+			"Valid name, no data record of requested type.";
+		    break;
+
+		default:
+		    h_err_txt = "No error text defined.";
+		    break;
+	    }
+	    __xmlIOErr(XML_FROM_HTTP, 0, h_err_txt);
+#else
+	    __xmlIOErr(XML_FROM_HTTP, 0, "Failed to resolve host");
+#endif
+	    return (-1);
+	}
+
+	for (i = 0; h->h_addr_list[i]; i++) {
+	    if (h->h_addrtype == AF_INET) {
+		/* A records (IPv4) */
+		memcpy (&ia, h->h_addr_list[i], h->h_length);
+		sockin.sin_family = h->h_addrtype;
+		sockin.sin_addr = ia;
+		sockin.sin_port = htons (port);
+		addr = (struct sockaddr *) &sockin;
+#ifdef SUPPORT_IP6
+	    } else if (have_ipv6 () && (h->h_addrtype == AF_INET6)) {
+		/* AAAA records (IPv6) */
+		memcpy (&ia6, h->h_addr_list[i], h->h_length);
+		sockin6.sin6_family = h->h_addrtype;
+		sockin6.sin6_addr = ia6;
+		sockin6.sin6_port = htons (port);
+		addr = (struct sockaddr *) &sockin6;
+#endif
+	    } else
+		break;              /* for */
+
+	    s = xmlNanoHTTPConnectAttempt (addr);
+	    if (s != -1)
+		return (s);
+	}
+    }
+#ifdef DEBUG_HTTP
+    xmlGenericError(xmlGenericErrorContext,
+                    "xmlNanoHTTPConnectHost:  unable to connect to '%s'.\n",
+                    host);
+#endif
+    return (-1);
+}
+
+
+/**
+ * xmlNanoHTTPOpen:
+ * @URL:  The URL to load
+ * @contentType:  if available the Content-Type information will be
+ *                returned at that location
+ *
+ * This function try to open a connection to the indicated resource
+ * via HTTP GET.
+ *
+ * Returns NULL in case of failure, otherwise a request handler.
+ *     The contentType, if provided must be freed by the caller
+ */
+
+void*
+xmlNanoHTTPOpen(const char *URL, char **contentType) {
+    if (contentType != NULL) *contentType = NULL;
+    return(xmlNanoHTTPMethod(URL, NULL, NULL, contentType, NULL, 0));
+}
+
+/**
+ * xmlNanoHTTPOpenRedir:
+ * @URL:  The URL to load
+ * @contentType:  if available the Content-Type information will be
+ *                returned at that location
+ * @redir: if available the redirected URL will be returned
+ *
+ * This function try to open a connection to the indicated resource
+ * via HTTP GET.
+ *
+ * Returns NULL in case of failure, otherwise a request handler.
+ *     The contentType, if provided must be freed by the caller
+ */
+
+void*
+xmlNanoHTTPOpenRedir(const char *URL, char **contentType, char **redir) {
+    if (contentType != NULL) *contentType = NULL;
+    if (redir != NULL) *redir = NULL;
+    return(xmlNanoHTTPMethodRedir(URL, NULL, NULL, contentType, redir, NULL,0));
+}
+
+/**
+ * xmlNanoHTTPRead:
+ * @ctx:  the HTTP context
+ * @dest:  a buffer
+ * @len:  the buffer length
+ *
+ * This function tries to read @len bytes from the existing HTTP connection
+ * and saves them in @dest. This is a blocking call.
+ *
+ * Returns the number of byte read. 0 is an indication of an end of connection.
+ *         -1 indicates a parameter error.
+ */
+int
+xmlNanoHTTPRead(void *ctx, void *dest, int len) {
+    xmlNanoHTTPCtxtPtr ctxt = (xmlNanoHTTPCtxtPtr) ctx;
+
+    if (ctx == NULL) return(-1);
+    if (dest == NULL) return(-1);
+    if (len <= 0) return(0);
+
+    while (ctxt->inptr - ctxt->inrptr < len) {
+        if (xmlNanoHTTPRecv(ctxt) <= 0) break;
+    }
+    if (ctxt->inptr - ctxt->inrptr < len)
+        len = ctxt->inptr - ctxt->inrptr;
+    memcpy(dest, ctxt->inrptr, len);
+    ctxt->inrptr += len;
+    return(len);
+}
+
+/**
+ * xmlNanoHTTPClose:
+ * @ctx:  the HTTP context
+ *
+ * This function closes an HTTP context, it ends up the connection and
+ * free all data related to it.
+ */
+void
+xmlNanoHTTPClose(void *ctx) {
+    xmlNanoHTTPCtxtPtr ctxt = (xmlNanoHTTPCtxtPtr) ctx;
+
+    if (ctx == NULL) return;
+
+    xmlNanoHTTPFreeCtxt(ctxt);
+}
+
+/**
+ * xmlNanoHTTPMethodRedir:
+ * @URL:  The URL to load
+ * @method:  the HTTP method to use
+ * @input:  the input string if any
+ * @contentType:  the Content-Type information IN and OUT
+ * @redir:  the redirected URL OUT
+ * @headers:  the extra headers
+ * @ilen:  input length
+ *
+ * This function try to open a connection to the indicated resource
+ * via HTTP using the given @method, adding the given extra headers
+ * and the input buffer for the request content.
+ *
+ * Returns NULL in case of failure, otherwise a request handler.
+ *     The contentType, or redir, if provided must be freed by the caller
+ */
+
+void*
+xmlNanoHTTPMethodRedir(const char *URL, const char *method, const char *input,
+                  char **contentType, char **redir,
+		  const char *headers, int ilen ) {
+    xmlNanoHTTPCtxtPtr ctxt;
+    char *bp, *p;
+    int blen, ret;
+    int head;
+    int nbRedirects = 0;
+    char *redirURL = NULL;
+#ifdef DEBUG_HTTP
+    int xmt_bytes;
+#endif
+    
+    if (URL == NULL) return(NULL);
+    if (method == NULL) method = "GET";
+    xmlNanoHTTPInit();
+
+retry:
+    if (redirURL == NULL)
+	ctxt = xmlNanoHTTPNewCtxt(URL);
+    else {
+	ctxt = xmlNanoHTTPNewCtxt(redirURL);
+	ctxt->location = xmlMemStrdup(redirURL);
+    }
+
+    if ( ctxt == NULL ) {
+	return ( NULL );
+    }
+
+    if ((ctxt->protocol == NULL) || (strcmp(ctxt->protocol, "http"))) {
+	__xmlIOErr(XML_FROM_HTTP, XML_HTTP_URL_SYNTAX, "Not a valid HTTP URI");
+        xmlNanoHTTPFreeCtxt(ctxt);
+	if (redirURL != NULL) xmlFree(redirURL);
+        return(NULL);
+    }
+    if (ctxt->hostname == NULL) {
+	__xmlIOErr(XML_FROM_HTTP, XML_HTTP_UNKNOWN_HOST,
+	           "Failed to identify host in URI");
+        xmlNanoHTTPFreeCtxt(ctxt);
+	if (redirURL != NULL) xmlFree(redirURL);
+        return(NULL);
+    }
+    if (proxy) {
+	blen = strlen(ctxt->hostname) * 2 + 16;
+	ret = xmlNanoHTTPConnectHost(proxy, proxyPort);
+    }
+    else {
+	blen = strlen(ctxt->hostname);
+	ret = xmlNanoHTTPConnectHost(ctxt->hostname, ctxt->port);
+    }
+    if (ret < 0) {
+        xmlNanoHTTPFreeCtxt(ctxt);
+	if (redirURL != NULL) xmlFree(redirURL);
+        return(NULL);
+    }
+    ctxt->fd = ret;
+
+    if (input == NULL)
+	ilen = 0;
+    else
+	blen += 36;
+
+    if (headers != NULL)
+	blen += strlen(headers) + 2;
+    if (contentType && *contentType)
+	blen += strlen(*contentType) + 16;
+    blen += strlen(method) + strlen(ctxt->path) + 24;
+    bp = (char*)xmlMallocAtomic(blen);
+    if ( bp == NULL ) {
+        xmlNanoHTTPFreeCtxt( ctxt );
+	xmlHTTPErrMemory("allocating header buffer");
+	return ( NULL );
+    }
+
+    p = bp;
+
+    if (proxy) {
+	if (ctxt->port != 80) {
+	    p += snprintf( p, blen - (p - bp), "%s http://%s:%d%s", 
+			method, ctxt->hostname,
+		 	ctxt->port, ctxt->path );
+	}
+	else 
+	    p += snprintf( p, blen - (p - bp), "%s http://%s%s", method,
+	    		ctxt->hostname, ctxt->path);
+    }
+    else
+	p += snprintf( p, blen - (p - bp), "%s %s", method, ctxt->path);
+
+    p += snprintf( p, blen - (p - bp), " HTTP/1.0\r\nHost: %s\r\n", 
+		    ctxt->hostname);
+
+    if (contentType != NULL && *contentType) 
+	p += snprintf(p, blen - (p - bp), "Content-Type: %s\r\n", *contentType);
+
+    if (headers != NULL)
+	p += snprintf( p, blen - (p - bp), "%s", headers );
+
+    if (input != NULL)
+	snprintf(p, blen - (p - bp), "Content-Length: %d\r\n\r\n", ilen );
+    else
+	snprintf(p, blen - (p - bp), "\r\n");
+
+#ifdef DEBUG_HTTP
+    xmlGenericError(xmlGenericErrorContext,
+	    "-> %s%s", proxy? "(Proxy) " : "", bp);
+    if ((blen -= strlen(bp)+1) < 0)
+	xmlGenericError(xmlGenericErrorContext,
+		"ERROR: overflowed buffer by %d bytes\n", -blen);
+#endif
+    ctxt->outptr = ctxt->out = bp;
+    ctxt->state = XML_NANO_HTTP_WRITE;
+    blen = strlen( ctxt->out );
+#ifdef DEBUG_HTTP
+    xmt_bytes = xmlNanoHTTPSend(ctxt, ctxt->out, blen );
+    if ( xmt_bytes != blen )
+        xmlGenericError( xmlGenericErrorContext,
+			"xmlNanoHTTPMethodRedir:  Only %d of %d %s %s\n",
+			xmt_bytes, blen,
+			"bytes of HTTP headers sent to host",
+			ctxt->hostname );
+#else
+    xmlNanoHTTPSend(ctxt, ctxt->out, blen );
+#endif
+
+    if ( input != NULL ) {
+#ifdef DEBUG_HTTP
+        xmt_bytes = xmlNanoHTTPSend( ctxt, input, ilen );
+
+	if ( xmt_bytes != ilen )
+	    xmlGenericError( xmlGenericErrorContext,
+	    		"xmlNanoHTTPMethodRedir:  Only %d of %d %s %s\n",
+			xmt_bytes, ilen,
+			"bytes of HTTP content sent to host",
+			ctxt->hostname );
+#else
+	xmlNanoHTTPSend( ctxt, input, ilen );
+#endif
+    }
+
+    ctxt->state = XML_NANO_HTTP_READ;
+    head = 1;
+
+    while ((p = xmlNanoHTTPReadLine(ctxt)) != NULL) {
+        if (head && (*p == 0)) {
+	    head = 0;
+	    ctxt->content = ctxt->inrptr;
+	    xmlFree(p);
+	    break;
+	}
+	xmlNanoHTTPScanAnswer(ctxt, p);
+
+#ifdef DEBUG_HTTP
+	xmlGenericError(xmlGenericErrorContext, "<- %s\n", p);
+#endif
+        xmlFree(p);
+    }
+
+    if ((ctxt->location != NULL) && (ctxt->returnValue >= 300) &&
+        (ctxt->returnValue < 400)) {
+#ifdef DEBUG_HTTP
+	xmlGenericError(xmlGenericErrorContext,
+		"\nRedirect to: %s\n", ctxt->location);
+#endif
+	while ( xmlNanoHTTPRecv(ctxt) > 0 ) ;
+        if (nbRedirects < XML_NANO_HTTP_MAX_REDIR) {
+	    nbRedirects++;
+	    if (redirURL != NULL)
+		xmlFree(redirURL);
+	    redirURL = xmlMemStrdup(ctxt->location);
+	    xmlNanoHTTPFreeCtxt(ctxt);
+	    goto retry;
+	}
+	xmlNanoHTTPFreeCtxt(ctxt);
+	if (redirURL != NULL) xmlFree(redirURL);
+#ifdef DEBUG_HTTP
+	xmlGenericError(xmlGenericErrorContext,
+		"xmlNanoHTTPMethodRedir: Too many redirects, aborting ...\n");
+#endif
+	return(NULL);
+    }
+
+    if (contentType != NULL) {
+	if (ctxt->contentType != NULL)
+	    *contentType = xmlMemStrdup(ctxt->contentType);
+	else
+	    *contentType = NULL;
+    }
+
+    if ((redir != NULL) && (redirURL != NULL)) {
+	*redir = redirURL;
+    } else {
+	if (redirURL != NULL)
+	    xmlFree(redirURL);
+	if (redir != NULL)
+	    *redir = NULL;
+    }
+
+#ifdef DEBUG_HTTP
+    if (ctxt->contentType != NULL)
+	xmlGenericError(xmlGenericErrorContext,
+		"\nCode %d, content-type '%s'\n\n",
+	       ctxt->returnValue, ctxt->contentType);
+    else
+	xmlGenericError(xmlGenericErrorContext,
+		"\nCode %d, no content-type\n\n",
+	       ctxt->returnValue);
+#endif
+
+    return((void *) ctxt);
+}
+
+/**
+ * xmlNanoHTTPMethod:
+ * @URL:  The URL to load
+ * @method:  the HTTP method to use
+ * @input:  the input string if any
+ * @contentType:  the Content-Type information IN and OUT
+ * @headers:  the extra headers
+ * @ilen:  input length
+ *
+ * This function try to open a connection to the indicated resource
+ * via HTTP using the given @method, adding the given extra headers
+ * and the input buffer for the request content.
+ *
+ * Returns NULL in case of failure, otherwise a request handler.
+ *     The contentType, if provided must be freed by the caller
+ */
+
+void*
+xmlNanoHTTPMethod(const char *URL, const char *method, const char *input,
+                  char **contentType, const char *headers, int ilen) {
+    return(xmlNanoHTTPMethodRedir(URL, method, input, contentType,
+		                  NULL, headers, ilen));
+}
+
+/**
+ * xmlNanoHTTPFetch:
+ * @URL:  The URL to load
+ * @filename:  the filename where the content should be saved
+ * @contentType:  if available the Content-Type information will be
+ *                returned at that location
+ *
+ * This function try to fetch the indicated resource via HTTP GET
+ * and save it's content in the file.
+ *
+ * Returns -1 in case of failure, 0 incase of success. The contentType,
+ *     if provided must be freed by the caller
+ */
+int
+xmlNanoHTTPFetch(const char *URL, const char *filename, char **contentType) {
+    void *ctxt = NULL;
+    char *buf = NULL;
+    int fd;
+    int len;
+    
+    ctxt = xmlNanoHTTPOpen(URL, contentType);
+    if (ctxt == NULL) return(-1);
+
+    if (!strcmp(filename, "-")) 
+        fd = 0;
+    else {
+        fd = open(filename, O_CREAT | O_WRONLY, 00644);
+	if (fd < 0) {
+	    xmlNanoHTTPClose(ctxt);
+	    if ((contentType != NULL) && (*contentType != NULL)) {
+	        xmlFree(*contentType);
+		*contentType = NULL;
+	    }
+	    return(-1);
+	}
+    }
+
+    xmlNanoHTTPFetchContent( ctxt, &buf, &len );
+    if ( len > 0 ) {
+	write(fd, buf, len);
+    }
+
+    xmlNanoHTTPClose(ctxt);
+    close(fd);
+    return(0);
+}
+
+#ifdef LIBXML_OUTPUT_ENABLED
+/**
+ * xmlNanoHTTPSave:
+ * @ctxt:  the HTTP context
+ * @filename:  the filename where the content should be saved
+ *
+ * This function saves the output of the HTTP transaction to a file
+ * It closes and free the context at the end
+ *
+ * Returns -1 in case of failure, 0 incase of success.
+ */
+int
+xmlNanoHTTPSave(void *ctxt, const char *filename) {
+    char *buf = NULL;
+    int fd;
+    int len;
+    
+    if (ctxt == NULL) return(-1);
+
+    if (!strcmp(filename, "-")) 
+        fd = 0;
+    else {
+        fd = open(filename, O_CREAT | O_WRONLY);
+	if (fd < 0) {
+	    xmlNanoHTTPClose(ctxt);
+	    return(-1);
+	}
+    }
+
+    xmlNanoHTTPFetchContent( ctxt, &buf, &len );
+    if ( len > 0 ) {
+	write(fd, buf, len);
+    }
+
+    xmlNanoHTTPClose(ctxt);
+    close(fd);
+    return(0);
+}
+#endif /* LIBXML_OUTPUT_ENABLED */
+
+/**
+ * xmlNanoHTTPReturnCode:
+ * @ctx:  the HTTP context
+ *
+ * Get the latest HTTP return code received
+ *
+ * Returns the HTTP return code for the request.
+ */
+int
+xmlNanoHTTPReturnCode(void *ctx) {
+    xmlNanoHTTPCtxtPtr ctxt = (xmlNanoHTTPCtxtPtr) ctx;
+
+    if (ctxt == NULL) return(-1);
+
+    return(ctxt->returnValue);
+}
+
+/**
+ * xmlNanoHTTPAuthHeader:
+ * @ctx:  the HTTP context
+ *
+ * Get the authentication header of an HTTP context
+ *
+ * Returns the stashed value of the WWW-Authenticate or Proxy-Authenticate
+ * header.
+ */
+const char *
+xmlNanoHTTPAuthHeader(void *ctx) {
+    xmlNanoHTTPCtxtPtr ctxt = (xmlNanoHTTPCtxtPtr) ctx;
+
+    if (ctxt == NULL) return(NULL);
+
+    return(ctxt->authHeader);
+}
+
+/**
+ * xmlNanoHTTPContentLength:
+ * @ctx:  the HTTP context
+ *
+ * Provides the specified content length from the HTTP header.
+ *
+ * Return the specified content length from the HTTP header.  Note that
+ * a value of -1 indicates that the content length element was not included in
+ * the response header.
+ */
+int
+xmlNanoHTTPContentLength( void * ctx ) {
+    xmlNanoHTTPCtxtPtr	ctxt = (xmlNanoHTTPCtxtPtr)ctx;
+
+    return ( ( ctxt == NULL ) ? -1 : ctxt->ContentLength );
+}
+
+/**
+ * xmlNanoHTTPRedir:
+ * @ctx:  the HTTP context
+ *
+ * Provides the specified redirection URL if available from the HTTP header.
+ *
+ * Return the specified redirection URL or NULL if not redirected.
+ */
+const char *
+xmlNanoHTTPRedir( void * ctx ) {
+    xmlNanoHTTPCtxtPtr	ctxt = (xmlNanoHTTPCtxtPtr)ctx;
+
+    return ( ( ctxt == NULL ) ? NULL : ctxt->location );
+}
+
+/**
+ * xmlNanoHTTPEncoding:
+ * @ctx:  the HTTP context
+ *
+ * Provides the specified encoding if specified in the HTTP headers.
+ *
+ * Return the specified encoding or NULL if not available
+ */
+const char *
+xmlNanoHTTPEncoding( void * ctx ) {
+    xmlNanoHTTPCtxtPtr	ctxt = (xmlNanoHTTPCtxtPtr)ctx;
+
+    return ( ( ctxt == NULL ) ? NULL : ctxt->encoding );
+}
+
+/**
+ * xmlNanoHTTPMimeType:
+ * @ctx:  the HTTP context
+ *
+ * Provides the specified Mime-Type if specified in the HTTP headers.
+ *
+ * Return the specified Mime-Type or NULL if not available
+ */
+const char *
+xmlNanoHTTPMimeType( void * ctx ) {
+    xmlNanoHTTPCtxtPtr	ctxt = (xmlNanoHTTPCtxtPtr)ctx;
+
+    return ( ( ctxt == NULL ) ? NULL : ctxt->mimeType );
+}
+
+/**
+ * xmlNanoHTTPFetchContent:
+ * @ctx:  the HTTP context
+ * @ptr:  pointer to set to the content buffer.
+ * @len:  integer pointer to hold the length of the content
+ *
+ * Check if all the content was read
+ *
+ * Returns 0 if all the content was read and available, returns
+ * -1 if received content length was less than specified or an error 
+ * occurred.
+ */
+int
+xmlNanoHTTPFetchContent( void * ctx, char ** ptr, int * len ) {
+    xmlNanoHTTPCtxtPtr	ctxt = (xmlNanoHTTPCtxtPtr)ctx;
+
+    int			rc = 0;
+    int			cur_lgth;
+    int			rcvd_lgth;
+    int			dummy_int;
+    char *		dummy_ptr = NULL;
+
+    /*  Dummy up return input parameters if not provided  */
+
+    if ( len == NULL )
+        len = &dummy_int;
+
+    if ( ptr == NULL )
+        ptr = &dummy_ptr;
+
+    /*  But can't work without the context pointer  */
+
+    if ( ( ctxt == NULL ) || ( ctxt->content == NULL ) ) {
+        *len = 0;
+	*ptr = NULL;
+	return ( -1 );
+    }
+
+    rcvd_lgth = ctxt->inptr - ctxt->content;
+
+    while ( (cur_lgth = xmlNanoHTTPRecv( ctxt )) > 0 ) {
+
+	rcvd_lgth += cur_lgth;
+	if ( (ctxt->ContentLength > 0) && (rcvd_lgth >= ctxt->ContentLength) )
+	    break;
+    }
+
+    *ptr = ctxt->content;
+    *len = rcvd_lgth;
+
+    if ( ( ctxt->ContentLength > 0 ) && ( rcvd_lgth < ctxt->ContentLength ) )
+        rc = -1;
+    else if ( rcvd_lgth == 0 )
+	rc = -1;
+
+    return ( rc );
+}
+
+#ifdef STANDALONE
+int main(int argc, char **argv) {
+    char *contentType = NULL;
+
+    if (argv[1] != NULL) {
+	if (argv[2] != NULL) 
+	    xmlNanoHTTPFetch(argv[1], argv[2], &contentType);
+        else
+	    xmlNanoHTTPFetch(argv[1], "-", &contentType);
+	if (contentType != NULL) xmlFree(contentType);
+    } else {
+        xmlGenericError(xmlGenericErrorContext,
+		"%s: minimal HTTP GET implementation\n", argv[0]);
+        xmlGenericError(xmlGenericErrorContext,
+		"\tusage %s [ URL [ filename ] ]\n", argv[0]);
+    }
+    xmlNanoHTTPCleanup();
+    xmlMemoryDump();
+    return(0);
+}
+#endif /* STANDALONE */
+#else /* !LIBXML_HTTP_ENABLED */
+#ifdef STANDALONE
+#include <stdio.h>
+int main(int argc, char **argv) {
+    xmlGenericError(xmlGenericErrorContext,
+	    "%s : HTTP support not compiled in\n", argv[0]);
+    return(0);
+}
+#endif /* STANDALONE */
+#endif /* LIBXML_HTTP_ENABLED */
diff --git a/src/libxml/src/parser.c b/src/libxml/src/parser.c
new file mode 100644
index 0000000..7662929
--- /dev/null
+++ b/src/libxml/src/parser.c
@@ -0,0 +1,12409 @@
+/*
+ * parser.c : an XML 1.0 parser, namespaces and validity support are mostly
+ *            implemented on top of the SAX interfaces
+ *
+ * References:
+ *   The XML specification:
+ *     http://www.w3.org/TR/REC-xml
+ *   Original 1.0 version:
+ *     http://www.w3.org/TR/1998/REC-xml-19980210
+ *   XML second edition working draft
+ *     http://www.w3.org/TR/2000/WD-xml-2e-20000814
+ *
+ * Okay this is a big file, the parser core is around 7000 lines, then it
+ * is followed by the progressive parser top routines, then the various
+ * high level APIs to call the parser and a few miscellaneous functions.
+ * A number of helper functions and deprecated ones have been moved to
+ * parserInternals.c to reduce this file size.
+ * As much as possible the functions are associated with their relative
+ * production in the XML specification. A few productions defining the
+ * different ranges of character are actually implanted either in 
+ * parserInternals.h or parserInternals.c
+ * The DOM tree build is realized from the default SAX callbacks in
+ * the module SAX.c.
+ * The routines doing the validation checks are in valid.c and called either
+ * from the SAX callbacks or as standalone functions using a preparsed
+ * document.
+ *
+ * See Copyright for the status of this software.
+ *
+ * daniel@veillard.com
+ */
+
+#define IN_LIBXML
+#include "libxml.h"
+
+#if defined(WIN32) && !defined (__CYGWIN__)
+#define XML_DIR_SEP '\\'
+#else
+#define XML_DIR_SEP '/'
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+#include <libxml/xmlmemory.h>
+#include <libxml/threads.h>
+#include <libxml/globals.h>
+#include <libxml/tree.h>
+#include <libxml/parser.h>
+#include <libxml/parserInternals.h>
+#include <libxml/valid.h>
+#include <libxml/entities.h>
+#include <libxml/xmlerror.h>
+#include <libxml/encoding.h>
+#include <libxml/xmlIO.h>
+#include <libxml/uri.h>
+#ifdef LIBXML_CATALOG_ENABLED
+#include <libxml/catalog.h>
+#endif
+
+#ifdef HAVE_CTYPE_H
+#include <ctype.h>
+#endif
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+#ifdef HAVE_SYS_STAT_H
+#include <sys/stat.h>
+#endif
+#ifdef HAVE_FCNTL_H
+#include <fcntl.h>
+#endif
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#ifdef HAVE_ZLIB_H
+#include <zlib.h>
+#endif
+
+/**
+ * xmlParserMaxDepth:
+ *
+ * arbitrary depth limit for the XML documents that we allow to 
+ * process. This is not a limitation of the parser but a safety 
+ * boundary feature.
+ */
+unsigned int xmlParserMaxDepth = 1024;
+
+#define SAX2 1
+
+#define XML_PARSER_BIG_BUFFER_SIZE 300
+#define XML_PARSER_BUFFER_SIZE 100
+
+#define SAX_COMPAT_MODE BAD_CAST "SAX compatibility mode document"
+
+/*
+ * List of XML prefixed PI allowed by W3C specs
+ */
+
+static const char *xmlW3CPIs[] = {
+    "xml-stylesheet",
+    NULL
+};
+
+
+/* DEPR void xmlParserHandleReference(xmlParserCtxtPtr ctxt); */
+xmlEntityPtr xmlParseStringPEReference(xmlParserCtxtPtr ctxt,
+                                       const xmlChar **str);
+
+static xmlParserErrors
+xmlParseExternalEntityPrivate(xmlDocPtr doc, xmlParserCtxtPtr oldctxt,
+	              xmlSAXHandlerPtr sax,
+		      void *user_data, int depth, const xmlChar *URL,
+		      const xmlChar *ID, xmlNodePtr *list);
+
+#ifdef LIBXML_LEGACY_ENABLED
+static void
+xmlAddEntityReference(xmlEntityPtr ent, xmlNodePtr firstNode,
+                      xmlNodePtr lastNode);
+#endif /* LIBXML_LEGACY_ENABLED */
+
+static xmlParserErrors
+xmlParseBalancedChunkMemoryInternal(xmlParserCtxtPtr oldctxt,
+		      const xmlChar *string, void *user_data, xmlNodePtr *lst);
+
+/************************************************************************
+ *									*
+ * 		Some factorized error routines				*
+ *									*
+ ************************************************************************/
+
+/**
+ * xmlErrAttributeDup:
+ * @ctxt:  an XML parser context
+ * @prefix:  the attribute prefix
+ * @localname:  the attribute localname
+ *
+ * Handle a redefinition of attribute error
+ */
+static void
+xmlErrAttributeDup(xmlParserCtxtPtr ctxt, const xmlChar * prefix,
+                   const xmlChar * localname)
+{
+    if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
+        (ctxt->instate == XML_PARSER_EOF))
+	return;
+    ctxt->errNo = XML_ERR_ATTRIBUTE_REDEFINED;
+    if (prefix == NULL)
+        __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER,
+                        ctxt->errNo, XML_ERR_FATAL, NULL, 0,
+                        (const char *) localname, NULL, NULL, 0, 0,
+                        "Attribute %s redefined\n", localname);
+    else
+        __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER,
+                        ctxt->errNo, XML_ERR_FATAL, NULL, 0,
+                        (const char *) prefix, (const char *) localname,
+                        NULL, 0, 0, "Attribute %s:%s redefined\n", prefix,
+                        localname);
+    ctxt->wellFormed = 0;
+    if (ctxt->recovery == 0)
+        ctxt->disableSAX = 1;
+}
+
+/**
+ * xmlFatalErr:
+ * @ctxt:  an XML parser context
+ * @error:  the error number
+ * @extra:  extra information string
+ *
+ * Handle a fatal parser error, i.e. violating Well-Formedness constraints
+ */
+static void
+xmlFatalErr(xmlParserCtxtPtr ctxt, xmlParserErrors error, const char *info)
+{
+    const char *errmsg;
+
+    if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
+        (ctxt->instate == XML_PARSER_EOF))
+	return;
+    switch (error) {
+        case XML_ERR_INVALID_HEX_CHARREF:
+            errmsg = "CharRef: invalid hexadecimal value\n";
+            break;
+        case XML_ERR_INVALID_DEC_CHARREF:
+            errmsg = "CharRef: invalid decimal value\n";
+            break;
+        case XML_ERR_INVALID_CHARREF:
+            errmsg = "CharRef: invalid value\n";
+            break;
+        case XML_ERR_INTERNAL_ERROR:
+            errmsg = "internal error";
+            break;
+        case XML_ERR_PEREF_AT_EOF:
+            errmsg = "PEReference at end of document\n";
+            break;
+        case XML_ERR_PEREF_IN_PROLOG:
+            errmsg = "PEReference in prolog\n";
+            break;
+        case XML_ERR_PEREF_IN_EPILOG:
+            errmsg = "PEReference in epilog\n";
+            break;
+        case XML_ERR_PEREF_NO_NAME:
+            errmsg = "PEReference: no name\n";
+            break;
+        case XML_ERR_PEREF_SEMICOL_MISSING:
+            errmsg = "PEReference: expecting ';'\n";
+            break;
+        case XML_ERR_ENTITY_LOOP:
+            errmsg = "Detected an entity reference loop\n";
+            break;
+        case XML_ERR_ENTITY_NOT_STARTED:
+            errmsg = "EntityValue: \" or ' expected\n";
+            break;
+        case XML_ERR_ENTITY_PE_INTERNAL:
+            errmsg = "PEReferences forbidden in internal subset\n";
+            break;
+        case XML_ERR_ENTITY_NOT_FINISHED:
+            errmsg = "EntityValue: \" or ' expected\n";
+            break;
+        case XML_ERR_ATTRIBUTE_NOT_STARTED:
+            errmsg = "AttValue: \" or ' expected\n";
+            break;
+        case XML_ERR_LT_IN_ATTRIBUTE:
+            errmsg = "Unescaped '<' not allowed in attributes values\n";
+            break;
+        case XML_ERR_LITERAL_NOT_STARTED:
+            errmsg = "SystemLiteral \" or ' expected\n";
+            break;
+        case XML_ERR_LITERAL_NOT_FINISHED:
+            errmsg = "Unfinished System or Public ID \" or ' expected\n";
+            break;
+        case XML_ERR_MISPLACED_CDATA_END:
+            errmsg = "Sequence ']]>' not allowed in content\n";
+            break;
+        case XML_ERR_URI_REQUIRED:
+            errmsg = "SYSTEM or PUBLIC, the URI is missing\n";
+            break;
+        case XML_ERR_PUBID_REQUIRED:
+            errmsg = "PUBLIC, the Public Identifier is missing\n";
+            break;
+        case XML_ERR_HYPHEN_IN_COMMENT:
+            errmsg = "Comment must not contain '--' (double-hyphen)\n";
+            break;
+        case XML_ERR_PI_NOT_STARTED:
+            errmsg = "xmlParsePI : no target name\n";
+            break;
+        case XML_ERR_RESERVED_XML_NAME:
+            errmsg = "Invalid PI name\n";
+            break;
+        case XML_ERR_NOTATION_NOT_STARTED:
+            errmsg = "NOTATION: Name expected here\n";
+            break;
+        case XML_ERR_NOTATION_NOT_FINISHED:
+            errmsg = "'>' required to close NOTATION declaration\n";
+            break;
+        case XML_ERR_VALUE_REQUIRED:
+            errmsg = "Entity value required\n";
+            break;
+        case XML_ERR_URI_FRAGMENT:
+            errmsg = "Fragment not allowed";
+            break;
+        case XML_ERR_ATTLIST_NOT_STARTED:
+            errmsg = "'(' required to start ATTLIST enumeration\n";
+            break;
+        case XML_ERR_NMTOKEN_REQUIRED:
+            errmsg = "NmToken expected in ATTLIST enumeration\n";
+            break;
+        case XML_ERR_ATTLIST_NOT_FINISHED:
+            errmsg = "')' required to finish ATTLIST enumeration\n";
+            break;
+        case XML_ERR_MIXED_NOT_STARTED:
+            errmsg = "MixedContentDecl : '|' or ')*' expected\n";
+            break;
+        case XML_ERR_PCDATA_REQUIRED:
+            errmsg = "MixedContentDecl : '#PCDATA' expected\n";
+            break;
+        case XML_ERR_ELEMCONTENT_NOT_STARTED:
+            errmsg = "ContentDecl : Name or '(' expected\n";
+            break;
+        case XML_ERR_ELEMCONTENT_NOT_FINISHED:
+            errmsg = "ContentDecl : ',' '|' or ')' expected\n";
+            break;
+        case XML_ERR_PEREF_IN_INT_SUBSET:
+            errmsg =
+                "PEReference: forbidden within markup decl in internal subset\n";
+            break;
+        case XML_ERR_GT_REQUIRED:
+            errmsg = "expected '>'\n";
+            break;
+        case XML_ERR_CONDSEC_INVALID:
+            errmsg = "XML conditional section '[' expected\n";
+            break;
+        case XML_ERR_EXT_SUBSET_NOT_FINISHED:
+            errmsg = "Content error in the external subset\n";
+            break;
+        case XML_ERR_CONDSEC_INVALID_KEYWORD:
+            errmsg =
+                "conditional section INCLUDE or IGNORE keyword expected\n";
+            break;
+        case XML_ERR_CONDSEC_NOT_FINISHED:
+            errmsg = "XML conditional section not closed\n";
+            break;
+        case XML_ERR_XMLDECL_NOT_STARTED:
+            errmsg = "Text declaration '<?xml' required\n";
+            break;
+        case XML_ERR_XMLDECL_NOT_FINISHED:
+            errmsg = "parsing XML declaration: '?>' expected\n";
+            break;
+        case XML_ERR_EXT_ENTITY_STANDALONE:
+            errmsg = "external parsed entities cannot be standalone\n";
+            break;
+        case XML_ERR_ENTITYREF_SEMICOL_MISSING:
+            errmsg = "EntityRef: expecting ';'\n";
+            break;
+        case XML_ERR_DOCTYPE_NOT_FINISHED:
+            errmsg = "DOCTYPE improperly terminated\n";
+            break;
+        case XML_ERR_LTSLASH_REQUIRED:
+            errmsg = "EndTag: '</' not found\n";
+            break;
+        case XML_ERR_EQUAL_REQUIRED:
+            errmsg = "expected '='\n";
+            break;
+        case XML_ERR_STRING_NOT_CLOSED:
+            errmsg = "String not closed expecting \" or '\n";
+            break;
+        case XML_ERR_STRING_NOT_STARTED:
+            errmsg = "String not started expecting ' or \"\n";
+            break;
+        case XML_ERR_ENCODING_NAME:
+            errmsg = "Invalid XML encoding name\n";
+            break;
+        case XML_ERR_STANDALONE_VALUE:
+            errmsg = "standalone accepts only 'yes' or 'no'\n";
+            break;
+        case XML_ERR_DOCUMENT_EMPTY:
+            errmsg = "Document is empty\n";
+            break;
+        case XML_ERR_DOCUMENT_END:
+            errmsg = "Extra content at the end of the document\n";
+            break;
+        case XML_ERR_NOT_WELL_BALANCED:
+            errmsg = "chunk is not well balanced\n";
+            break;
+        case XML_ERR_EXTRA_CONTENT:
+            errmsg = "extra content at the end of well balanced chunk\n";
+            break;
+        case XML_ERR_VERSION_MISSING:
+            errmsg = "Malformed declaration expecting version\n";
+            break;
+#if 0
+        case:
+            errmsg = "\n";
+            break;
+#endif
+        default:
+            errmsg = "Unregistered error message\n";
+    }
+    ctxt->errNo = error;
+    __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER, error,
+                    XML_ERR_FATAL, NULL, 0, info, NULL, NULL, 0, 0, errmsg,
+                    info);
+    ctxt->wellFormed = 0;
+    if (ctxt->recovery == 0)
+        ctxt->disableSAX = 1;
+}
+
+/**
+ * xmlFatalErrMsg:
+ * @ctxt:  an XML parser context
+ * @error:  the error number
+ * @msg:  the error message
+ *
+ * Handle a fatal parser error, i.e. violating Well-Formedness constraints
+ */
+static void
+xmlFatalErrMsg(xmlParserCtxtPtr ctxt, xmlParserErrors error,
+               const char *msg)
+{
+    if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
+        (ctxt->instate == XML_PARSER_EOF))
+	return;
+    ctxt->errNo = error;
+    __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER, error,
+                    XML_ERR_FATAL, NULL, 0, NULL, NULL, NULL, 0, 0, msg);
+    ctxt->wellFormed = 0;
+    if (ctxt->recovery == 0)
+        ctxt->disableSAX = 1;
+}
+
+/**
+ * xmlWarningMsg:
+ * @ctxt:  an XML parser context
+ * @error:  the error number
+ * @msg:  the error message
+ * @str1:  extra data
+ * @str2:  extra data
+ *
+ * Handle a warning.
+ */
+static void
+xmlWarningMsg(xmlParserCtxtPtr ctxt, xmlParserErrors error,
+              const char *msg, const xmlChar *str1, const xmlChar *str2)
+{
+    xmlStructuredErrorFunc schannel = NULL;
+    
+    if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
+        (ctxt->instate == XML_PARSER_EOF))
+	return;
+    ctxt->errNo = error;
+    if ((ctxt->sax != NULL) && (ctxt->sax->initialized == XML_SAX2_MAGIC))
+        schannel = ctxt->sax->serror;
+    __xmlRaiseError(schannel,
+                    (ctxt->sax) ? ctxt->sax->warning : NULL,
+                    ctxt->userData,
+                    ctxt, NULL, XML_FROM_PARSER, error,
+                    XML_ERR_WARNING, NULL, 0,
+		    (const char *) str1, (const char *) str2, NULL, 0, 0,
+		    msg, (const char *) str1, (const char *) str2);
+}
+
+/**
+ * xmlValidityError:
+ * @ctxt:  an XML parser context
+ * @error:  the error number
+ * @msg:  the error message
+ * @str1:  extra data
+ *
+ * Handle a validity error.
+ */
+static void
+xmlValidityError(xmlParserCtxtPtr ctxt, xmlParserErrors error,
+              const char *msg, const xmlChar *str1)
+{
+    xmlStructuredErrorFunc schannel = NULL;
+
+    if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
+        (ctxt->instate == XML_PARSER_EOF))
+	return;
+    ctxt->errNo = error;
+    if ((ctxt->sax != NULL) && (ctxt->sax->initialized == XML_SAX2_MAGIC))
+        schannel = ctxt->sax->serror;
+    __xmlRaiseError(schannel,
+                    ctxt->vctxt.error, ctxt->vctxt.userData,
+                    ctxt, NULL, XML_FROM_DTD, error,
+                    XML_ERR_ERROR, NULL, 0, (const char *) str1,
+		    NULL, NULL, 0, 0,
+		    msg, (const char *) str1);
+    ctxt->valid = 0;
+}
+
+/**
+ * xmlFatalErrMsgInt:
+ * @ctxt:  an XML parser context
+ * @error:  the error number
+ * @msg:  the error message
+ * @val:  an integer value
+ *
+ * Handle a fatal parser error, i.e. violating Well-Formedness constraints
+ */
+static void
+xmlFatalErrMsgInt(xmlParserCtxtPtr ctxt, xmlParserErrors error,
+                  const char *msg, int val)
+{
+    if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
+        (ctxt->instate == XML_PARSER_EOF))
+	return;
+    ctxt->errNo = error;
+    __xmlRaiseError(NULL, NULL, NULL,
+                    ctxt, NULL, XML_FROM_PARSER, error, XML_ERR_FATAL,
+                    NULL, 0, NULL, NULL, NULL, val, 0, msg, val);
+    ctxt->wellFormed = 0;
+    if (ctxt->recovery == 0)
+        ctxt->disableSAX = 1;
+}
+
+/**
+ * xmlFatalErrMsgStrIntStr:
+ * @ctxt:  an XML parser context
+ * @error:  the error number
+ * @msg:  the error message
+ * @str1:  an string info
+ * @val:  an integer value
+ * @str2:  an string info
+ *
+ * Handle a fatal parser error, i.e. violating Well-Formedness constraints
+ */
+static void
+xmlFatalErrMsgStrIntStr(xmlParserCtxtPtr ctxt, xmlParserErrors error,
+                  const char *msg, const xmlChar *str1, int val, 
+		  const xmlChar *str2)
+{
+    if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
+        (ctxt->instate == XML_PARSER_EOF))
+	return;
+    ctxt->errNo = error;
+    __xmlRaiseError(NULL, NULL, NULL,
+                    ctxt, NULL, XML_FROM_PARSER, error, XML_ERR_FATAL,
+                    NULL, 0, (const char *) str1, (const char *) str2,
+		    NULL, val, 0, msg, str1, val, str2);
+    ctxt->wellFormed = 0;
+    if (ctxt->recovery == 0)
+        ctxt->disableSAX = 1;
+}
+
+/**
+ * xmlFatalErrMsgStr:
+ * @ctxt:  an XML parser context
+ * @error:  the error number
+ * @msg:  the error message
+ * @val:  a string value
+ *
+ * Handle a fatal parser error, i.e. violating Well-Formedness constraints
+ */
+static void
+xmlFatalErrMsgStr(xmlParserCtxtPtr ctxt, xmlParserErrors error,
+                  const char *msg, const xmlChar * val)
+{
+    if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
+        (ctxt->instate == XML_PARSER_EOF))
+	return;
+    ctxt->errNo = error;
+    __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL,
+                    XML_FROM_PARSER, error, XML_ERR_FATAL,
+                    NULL, 0, (const char *) val, NULL, NULL, 0, 0, msg,
+                    val);
+    ctxt->wellFormed = 0;
+    if (ctxt->recovery == 0)
+        ctxt->disableSAX = 1;
+}
+
+/**
+ * xmlErrMsgStr:
+ * @ctxt:  an XML parser context
+ * @error:  the error number
+ * @msg:  the error message
+ * @val:  a string value
+ *
+ * Handle a non fatal parser error
+ */
+static void
+xmlErrMsgStr(xmlParserCtxtPtr ctxt, xmlParserErrors error,
+                  const char *msg, const xmlChar * val)
+{
+    if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
+        (ctxt->instate == XML_PARSER_EOF))
+	return;
+    ctxt->errNo = error;
+    __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL,
+                    XML_FROM_PARSER, error, XML_ERR_ERROR,
+                    NULL, 0, (const char *) val, NULL, NULL, 0, 0, msg,
+                    val);
+}
+
+/**
+ * xmlNsErr:
+ * @ctxt:  an XML parser context
+ * @error:  the error number
+ * @msg:  the message
+ * @info1:  extra information string
+ * @info2:  extra information string
+ *
+ * Handle a fatal parser error, i.e. violating Well-Formedness constraints
+ */
+static void
+xmlNsErr(xmlParserCtxtPtr ctxt, xmlParserErrors error,
+         const char *msg,
+         const xmlChar * info1, const xmlChar * info2,
+         const xmlChar * info3)
+{
+    if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
+        (ctxt->instate == XML_PARSER_EOF))
+	return;
+    ctxt->errNo = error;
+    __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_NAMESPACE, error,
+                    XML_ERR_ERROR, NULL, 0, (const char *) info1,
+                    (const char *) info2, (const char *) info3, 0, 0, msg,
+                    info1, info2, info3);
+    ctxt->nsWellFormed = 0;
+}
+
+/************************************************************************
+ *									*
+ * 		SAX2 defaulted attributes handling			*
+ *									*
+ ************************************************************************/
+
+/**
+ * xmlDetectSAX2:
+ * @ctxt:  an XML parser context
+ *
+ * Do the SAX2 detection and specific intialization
+ */
+static void
+xmlDetectSAX2(xmlParserCtxtPtr ctxt) {
+    if (ctxt == NULL) return;
+#ifdef LIBXML_SAX1_ENABLED
+    if ((ctxt->sax) &&  (ctxt->sax->initialized == XML_SAX2_MAGIC) &&
+        ((ctxt->sax->startElementNs != NULL) ||
+         (ctxt->sax->endElementNs != NULL))) ctxt->sax2 = 1;
+#else
+    ctxt->sax2 = 1;
+#endif /* LIBXML_SAX1_ENABLED */
+
+    ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3);
+    ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5);
+    ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36);
+}
+
+typedef struct _xmlDefAttrs xmlDefAttrs;
+typedef xmlDefAttrs *xmlDefAttrsPtr;
+struct _xmlDefAttrs {
+    int nbAttrs;	/* number of defaulted attributes on that element */
+    int maxAttrs;       /* the size of the array */
+    const xmlChar *values[4]; /* array of localname/prefix/values */
+};
+
+/**
+ * xmlAddDefAttrs:
+ * @ctxt:  an XML parser context
+ * @fullname:  the element fullname
+ * @fullattr:  the attribute fullname
+ * @value:  the attribute value
+ *
+ * Add a defaulted attribute for an element
+ */
+static void
+xmlAddDefAttrs(xmlParserCtxtPtr ctxt,
+               const xmlChar *fullname,
+               const xmlChar *fullattr,
+               const xmlChar *value) {
+    xmlDefAttrsPtr defaults;
+    int len;
+    const xmlChar *name;
+    const xmlChar *prefix;
+
+    if (ctxt->attsDefault == NULL) {
+        ctxt->attsDefault = xmlHashCreate(10);
+	if (ctxt->attsDefault == NULL)
+	    goto mem_error;
+    }
+
+    /*
+     * plit the element name into prefix:localname , the string found
+     * are within the DTD and hen not associated to namespace names.
+     */
+    name = xmlSplitQName3(fullname, &len);
+    if (name == NULL) {
+        name = xmlDictLookup(ctxt->dict, fullname, -1);
+	prefix = NULL;
+    } else {
+        name = xmlDictLookup(ctxt->dict, name, -1);
+	prefix = xmlDictLookup(ctxt->dict, fullname, len);
+    }
+
+    /*
+     * make sure there is some storage
+     */
+    defaults = xmlHashLookup2(ctxt->attsDefault, name, prefix);
+    if (defaults == NULL) {
+        defaults = (xmlDefAttrsPtr) xmlMalloc(sizeof(xmlDefAttrs) +
+	                               12 * sizeof(const xmlChar *));
+	if (defaults == NULL)
+	    goto mem_error;
+	defaults->maxAttrs = 4;
+	defaults->nbAttrs = 0;
+	xmlHashUpdateEntry2(ctxt->attsDefault, name, prefix, defaults, NULL);
+    } else if (defaults->nbAttrs >= defaults->maxAttrs) {
+        defaults = (xmlDefAttrsPtr) xmlRealloc(defaults, sizeof(xmlDefAttrs) +
+		       (2 * defaults->maxAttrs * 4) * sizeof(const xmlChar *));
+	if (defaults == NULL)
+	    goto mem_error;
+	defaults->maxAttrs *= 2;
+	xmlHashUpdateEntry2(ctxt->attsDefault, name, prefix, defaults, NULL);
+    }
+
+    /*
+     * plit the element name into prefix:localname , the string found
+     * are within the DTD and hen not associated to namespace names.
+     */
+    name = xmlSplitQName3(fullattr, &len);
+    if (name == NULL) {
+        name = xmlDictLookup(ctxt->dict, fullattr, -1);
+	prefix = NULL;
+    } else {
+        name = xmlDictLookup(ctxt->dict, name, -1);
+	prefix = xmlDictLookup(ctxt->dict, fullattr, len);
+    }
+
+    defaults->values[4 * defaults->nbAttrs] = name;
+    defaults->values[4 * defaults->nbAttrs + 1] = prefix;
+    /* intern the string and precompute the end */
+    len = xmlStrlen(value);
+    value = xmlDictLookup(ctxt->dict, value, len);
+    defaults->values[4 * defaults->nbAttrs + 2] = value;
+    defaults->values[4 * defaults->nbAttrs + 3] = value + len;
+    defaults->nbAttrs++;
+
+    return;
+
+mem_error:
+    xmlErrMemory(ctxt, NULL);
+    return;
+}
+
+/**
+ * xmlAddSpecialAttr:
+ * @ctxt:  an XML parser context
+ * @fullname:  the element fullname
+ * @fullattr:  the attribute fullname
+ * @type:  the attribute type
+ *
+ * Register that this attribute is not CDATA
+ */
+static void
+xmlAddSpecialAttr(xmlParserCtxtPtr ctxt,
+		  const xmlChar *fullname,
+		  const xmlChar *fullattr,
+		  int type)
+{
+    if (ctxt->attsSpecial == NULL) {
+        ctxt->attsSpecial = xmlHashCreate(10);
+	if (ctxt->attsSpecial == NULL)
+	    goto mem_error;
+    }
+
+    xmlHashAddEntry2(ctxt->attsSpecial, fullname, fullattr,
+                     (void *) (long) type);
+    return;
+
+mem_error:
+    xmlErrMemory(ctxt, NULL);
+    return;
+}
+
+/**
+ * xmlCheckLanguageID:
+ * @lang:  pointer to the string value
+ *
+ * Checks that the value conforms to the LanguageID production:
+ *
+ * NOTE: this is somewhat deprecated, those productions were removed from
+ *       the XML Second edition.
+ *
+ * [33] LanguageID ::= Langcode ('-' Subcode)*
+ * [34] Langcode ::= ISO639Code |  IanaCode |  UserCode
+ * [35] ISO639Code ::= ([a-z] | [A-Z]) ([a-z] | [A-Z])
+ * [36] IanaCode ::= ('i' | 'I') '-' ([a-z] | [A-Z])+
+ * [37] UserCode ::= ('x' | 'X') '-' ([a-z] | [A-Z])+
+ * [38] Subcode ::= ([a-z] | [A-Z])+
+ *
+ * Returns 1 if correct 0 otherwise
+ **/
+int
+xmlCheckLanguageID(const xmlChar * lang)
+{
+    const xmlChar *cur = lang;
+
+    if (cur == NULL)
+        return (0);
+    if (((cur[0] == 'i') && (cur[1] == '-')) ||
+        ((cur[0] == 'I') && (cur[1] == '-'))) {
+        /*
+         * IANA code
+         */
+        cur += 2;
+        while (((cur[0] >= 'A') && (cur[0] <= 'Z')) ||  /* non input consuming */
+               ((cur[0] >= 'a') && (cur[0] <= 'z')))
+            cur++;
+    } else if (((cur[0] == 'x') && (cur[1] == '-')) ||
+               ((cur[0] == 'X') && (cur[1] == '-'))) {
+        /*
+         * User code
+         */
+        cur += 2;
+        while (((cur[0] >= 'A') && (cur[0] <= 'Z')) ||  /* non input consuming */
+               ((cur[0] >= 'a') && (cur[0] <= 'z')))
+            cur++;
+    } else if (((cur[0] >= 'A') && (cur[0] <= 'Z')) ||
+               ((cur[0] >= 'a') && (cur[0] <= 'z'))) {
+        /*
+         * ISO639
+         */
+        cur++;
+        if (((cur[0] >= 'A') && (cur[0] <= 'Z')) ||
+            ((cur[0] >= 'a') && (cur[0] <= 'z')))
+            cur++;
+        else
+            return (0);
+    } else
+        return (0);
+    while (cur[0] != 0) {       /* non input consuming */
+        if (cur[0] != '-')
+            return (0);
+        cur++;
+        if (((cur[0] >= 'A') && (cur[0] <= 'Z')) ||
+            ((cur[0] >= 'a') && (cur[0] <= 'z')))
+            cur++;
+        else
+            return (0);
+        while (((cur[0] >= 'A') && (cur[0] <= 'Z')) ||  /* non input consuming */
+               ((cur[0] >= 'a') && (cur[0] <= 'z')))
+            cur++;
+    }
+    return (1);
+}
+
+/************************************************************************
+ *									*
+ * 		Parser stacks related functions and macros		*
+ *									*
+ ************************************************************************/
+
+xmlEntityPtr xmlParseStringEntityRef(xmlParserCtxtPtr ctxt,
+                                     const xmlChar ** str);
+
+#ifdef SAX2
+/**
+ * nsPush:
+ * @ctxt:  an XML parser context
+ * @prefix:  the namespace prefix or NULL
+ * @URL:  the namespace name
+ *
+ * Pushes a new parser namespace on top of the ns stack
+ *
+ * Returns -1 in case of error, -2 if the namespace should be discarded
+ *	   and the index in the stack otherwise.
+ */
+static int
+nsPush(xmlParserCtxtPtr ctxt, const xmlChar *prefix, const xmlChar *URL)
+{
+    if (ctxt->options & XML_PARSE_NSCLEAN) {
+        int i;
+	for (i = 0;i < ctxt->nsNr;i += 2) {
+	    if (ctxt->nsTab[i] == prefix) {
+		/* in scope */
+	        if (ctxt->nsTab[i + 1] == URL)
+		    return(-2);
+		/* out of scope keep it */
+		break;
+	    }
+	}
+    }
+    if ((ctxt->nsMax == 0) || (ctxt->nsTab == NULL)) {
+	ctxt->nsMax = 10;
+	ctxt->nsNr = 0;
+	ctxt->nsTab = (const xmlChar **)
+	              xmlMalloc(ctxt->nsMax * sizeof(xmlChar *));
+	if (ctxt->nsTab == NULL) {
+	    xmlErrMemory(ctxt, NULL);
+	    ctxt->nsMax = 0;
+            return (-1);
+	}
+    } else if (ctxt->nsNr >= ctxt->nsMax) {
+        ctxt->nsMax *= 2;
+        ctxt->nsTab = (const xmlChar **)
+	              xmlRealloc((char *) ctxt->nsTab,
+				 ctxt->nsMax * sizeof(ctxt->nsTab[0]));
+        if (ctxt->nsTab == NULL) {
+            xmlErrMemory(ctxt, NULL);
+	    ctxt->nsMax /= 2;
+            return (-1);
+        }
+    }
+    ctxt->nsTab[ctxt->nsNr++] = prefix;
+    ctxt->nsTab[ctxt->nsNr++] = URL;
+    return (ctxt->nsNr);
+}
+/**
+ * nsPop:
+ * @ctxt: an XML parser context
+ * @nr:  the number to pop
+ *
+ * Pops the top @nr parser prefix/namespace from the ns stack
+ *
+ * Returns the number of namespaces removed
+ */
+static int
+nsPop(xmlParserCtxtPtr ctxt, int nr)
+{
+    int i;
+
+    if (ctxt->nsTab == NULL) return(0);
+    if (ctxt->nsNr < nr) {
+        xmlGenericError(xmlGenericErrorContext, "Pbm popping %d NS\n", nr);
+        nr = ctxt->nsNr;
+    }
+    if (ctxt->nsNr <= 0)
+        return (0);
+    
+    for (i = 0;i < nr;i++) {
+         ctxt->nsNr--;
+	 ctxt->nsTab[ctxt->nsNr] = NULL;
+    }
+    return(nr);
+}
+#endif
+
+static int
+xmlCtxtGrowAttrs(xmlParserCtxtPtr ctxt, int nr) {
+    const xmlChar **atts;
+    int *attallocs;
+    int maxatts;
+
+    if (ctxt->atts == NULL) {
+	maxatts = 55; /* allow for 10 attrs by default */
+	atts = (const xmlChar **)
+	       xmlMalloc(maxatts * sizeof(xmlChar *));
+	if (atts == NULL) goto mem_error;
+	ctxt->atts = atts;
+	attallocs = (int *) xmlMalloc((maxatts / 5) * sizeof(int));
+	if (attallocs == NULL) goto mem_error;
+	ctxt->attallocs = attallocs;
+	ctxt->maxatts = maxatts;
+    } else if (nr + 5 > ctxt->maxatts) {
+	maxatts = (nr + 5) * 2;
+	atts = (const xmlChar **) xmlRealloc((void *) ctxt->atts,
+				     maxatts * sizeof(const xmlChar *));
+	if (atts == NULL) goto mem_error;
+	ctxt->atts = atts;
+	attallocs = (int *) xmlRealloc((void *) ctxt->attallocs,
+	                             (maxatts / 5) * sizeof(int));
+	if (attallocs == NULL) goto mem_error;
+	ctxt->attallocs = attallocs;
+	ctxt->maxatts = maxatts;
+    }
+    return(ctxt->maxatts);
+mem_error:
+    xmlErrMemory(ctxt, NULL);
+    return(-1);
+}
+
+/**
+ * inputPush:
+ * @ctxt:  an XML parser context
+ * @value:  the parser input
+ *
+ * Pushes a new parser input on top of the input stack
+ *
+ * Returns 0 in case of error, the index in the stack otherwise
+ */
+extern int
+inputPush(xmlParserCtxtPtr ctxt, xmlParserInputPtr value)
+{
+    if (ctxt->inputNr >= ctxt->inputMax) {
+        ctxt->inputMax *= 2;
+        ctxt->inputTab =
+            (xmlParserInputPtr *) xmlRealloc(ctxt->inputTab,
+                                             ctxt->inputMax *
+                                             sizeof(ctxt->inputTab[0]));
+        if (ctxt->inputTab == NULL) {
+            xmlErrMemory(ctxt, NULL);
+            return (0);
+        }
+    }
+    ctxt->inputTab[ctxt->inputNr] = value;
+    ctxt->input = value;
+    return (ctxt->inputNr++);
+}
+/**
+ * inputPop:
+ * @ctxt: an XML parser context
+ *
+ * Pops the top parser input from the input stack
+ *
+ * Returns the input just removed
+ */
+extern xmlParserInputPtr
+inputPop(xmlParserCtxtPtr ctxt)
+{
+    xmlParserInputPtr ret;
+
+    if (ctxt->inputNr <= 0)
+        return (0);
+    ctxt->inputNr--;
+    if (ctxt->inputNr > 0)
+        ctxt->input = ctxt->inputTab[ctxt->inputNr - 1];
+    else
+        ctxt->input = NULL;
+    ret = ctxt->inputTab[ctxt->inputNr];
+    ctxt->inputTab[ctxt->inputNr] = 0;
+    return (ret);
+}
+/**
+ * nodePush:
+ * @ctxt:  an XML parser context
+ * @value:  the element node
+ *
+ * Pushes a new element node on top of the node stack
+ *
+ * Returns 0 in case of error, the index in the stack otherwise
+ */
+extern int
+nodePush(xmlParserCtxtPtr ctxt, xmlNodePtr value)
+{
+    if (ctxt->nodeNr >= ctxt->nodeMax) {
+        ctxt->nodeMax *= 2;
+        ctxt->nodeTab =
+            (xmlNodePtr *) xmlRealloc(ctxt->nodeTab,
+                                      ctxt->nodeMax *
+                                      sizeof(ctxt->nodeTab[0]));
+        if (ctxt->nodeTab == NULL) {
+            xmlErrMemory(ctxt, NULL);
+            return (0);
+        }
+    }
+    if (((unsigned int) ctxt->nodeNr) > xmlParserMaxDepth) {
+	xmlFatalErrMsgInt(ctxt, XML_ERR_INTERNAL_ERROR,
+		 "Excessive depth in document: change xmlParserMaxDepth = %d\n",
+			  xmlParserMaxDepth);
+	ctxt->instate = XML_PARSER_EOF;
+	return(0);
+    }
+    ctxt->nodeTab[ctxt->nodeNr] = value;
+    ctxt->node = value;
+    return (ctxt->nodeNr++);
+}
+/**
+ * nodePop:
+ * @ctxt: an XML parser context
+ *
+ * Pops the top element node from the node stack
+ *
+ * Returns the node just removed
+ */
+extern xmlNodePtr
+nodePop(xmlParserCtxtPtr ctxt)
+{
+    xmlNodePtr ret;
+
+    if (ctxt->nodeNr <= 0)
+        return (0);
+    ctxt->nodeNr--;
+    if (ctxt->nodeNr > 0)
+        ctxt->node = ctxt->nodeTab[ctxt->nodeNr - 1];
+    else
+        ctxt->node = NULL;
+    ret = ctxt->nodeTab[ctxt->nodeNr];
+    ctxt->nodeTab[ctxt->nodeNr] = 0;
+    return (ret);
+}
+/**
+ * nameNsPush:
+ * @ctxt:  an XML parser context
+ * @value:  the element name
+ * @prefix:  the element prefix
+ * @URI:  the element namespace name
+ *
+ * Pushes a new element name/prefix/URL on top of the name stack
+ *
+ * Returns -1 in case of error, the index in the stack otherwise
+ */
+static int
+nameNsPush(xmlParserCtxtPtr ctxt, const xmlChar * value,
+           const xmlChar *prefix, const xmlChar *URI, int nsNr)
+{
+    if (ctxt->nameNr >= ctxt->nameMax) {
+        const xmlChar * *tmp;
+        void **tmp2;
+        ctxt->nameMax *= 2;
+        tmp = (const xmlChar * *) xmlRealloc((xmlChar * *)ctxt->nameTab,
+                                    ctxt->nameMax *
+                                    sizeof(ctxt->nameTab[0]));
+        if (tmp == NULL) {
+	    ctxt->nameMax /= 2;
+	    goto mem_error;
+        }
+	ctxt->nameTab = tmp;
+        tmp2 = (void **) xmlRealloc((void * *)ctxt->pushTab,
+                                    ctxt->nameMax * 3 *
+                                    sizeof(ctxt->pushTab[0]));
+        if (tmp2 == NULL) {
+	    ctxt->nameMax /= 2;
+	    goto mem_error;
+        }
+	ctxt->pushTab = tmp2;
+    }
+    ctxt->nameTab[ctxt->nameNr] = value;
+    ctxt->name = value;
+    ctxt->pushTab[ctxt->nameNr * 3] = (void *) prefix;
+    ctxt->pushTab[ctxt->nameNr * 3 + 1] = (void *) URI;
+    ctxt->pushTab[ctxt->nameNr * 3 + 2] = (void *) (long) nsNr;
+    return (ctxt->nameNr++);
+mem_error:
+    xmlErrMemory(ctxt, NULL);
+    return (-1);
+}
+/**
+ * nameNsPop:
+ * @ctxt: an XML parser context
+ *
+ * Pops the top element/prefix/URI name from the name stack
+ *
+ * Returns the name just removed
+ */
+static const xmlChar *
+nameNsPop(xmlParserCtxtPtr ctxt)
+{
+    const xmlChar *ret;
+
+    if (ctxt->nameNr <= 0)
+        return (0);
+    ctxt->nameNr--;
+    if (ctxt->nameNr > 0)
+        ctxt->name = ctxt->nameTab[ctxt->nameNr - 1];
+    else
+        ctxt->name = NULL;
+    ret = ctxt->nameTab[ctxt->nameNr];
+    ctxt->nameTab[ctxt->nameNr] = NULL;
+    return (ret);
+}
+
+/**
+ * namePush:
+ * @ctxt:  an XML parser context
+ * @value:  the element name
+ *
+ * Pushes a new element name on top of the name stack
+ *
+ * Returns -1 in case of error, the index in the stack otherwise
+ */
+extern int
+namePush(xmlParserCtxtPtr ctxt, const xmlChar * value)
+{
+    if (ctxt->nameNr >= ctxt->nameMax) {
+        const xmlChar * *tmp;
+        ctxt->nameMax *= 2;
+        tmp = (const xmlChar * *) xmlRealloc((xmlChar * *)ctxt->nameTab,
+                                    ctxt->nameMax *
+                                    sizeof(ctxt->nameTab[0]));
+        if (tmp == NULL) {
+	    ctxt->nameMax /= 2;
+	    goto mem_error;
+        }
+	ctxt->nameTab = tmp;
+    }
+    ctxt->nameTab[ctxt->nameNr] = value;
+    ctxt->name = value;
+    return (ctxt->nameNr++);
+mem_error:
+    xmlErrMemory(ctxt, NULL);
+    return (-1);
+}
+/**
+ * namePop:
+ * @ctxt: an XML parser context
+ *
+ * Pops the top element name from the name stack
+ *
+ * Returns the name just removed
+ */
+extern const xmlChar *
+namePop(xmlParserCtxtPtr ctxt)
+{
+    const xmlChar *ret;
+
+    if (ctxt->nameNr <= 0)
+        return (0);
+    ctxt->nameNr--;
+    if (ctxt->nameNr > 0)
+        ctxt->name = ctxt->nameTab[ctxt->nameNr - 1];
+    else
+        ctxt->name = NULL;
+    ret = ctxt->nameTab[ctxt->nameNr];
+    ctxt->nameTab[ctxt->nameNr] = 0;
+    return (ret);
+}
+
+static int spacePush(xmlParserCtxtPtr ctxt, int val) {
+    if (ctxt->spaceNr >= ctxt->spaceMax) {
+	ctxt->spaceMax *= 2;
+        ctxt->spaceTab = (int *) xmlRealloc(ctxt->spaceTab,
+	             ctxt->spaceMax * sizeof(ctxt->spaceTab[0]));
+        if (ctxt->spaceTab == NULL) {
+	    xmlErrMemory(ctxt, NULL);
+	    return(0);
+	}
+    }
+    ctxt->spaceTab[ctxt->spaceNr] = val;
+    ctxt->space = &ctxt->spaceTab[ctxt->spaceNr];
+    return(ctxt->spaceNr++);
+}
+
+static int spacePop(xmlParserCtxtPtr ctxt) {
+    int ret;
+    if (ctxt->spaceNr <= 0) return(0);
+    ctxt->spaceNr--;
+    if (ctxt->spaceNr > 0)
+	ctxt->space = &ctxt->spaceTab[ctxt->spaceNr - 1];
+    else
+        ctxt->space = NULL;
+    ret = ctxt->spaceTab[ctxt->spaceNr];
+    ctxt->spaceTab[ctxt->spaceNr] = -1;
+    return(ret);
+}
+
+/*
+ * Macros for accessing the content. Those should be used only by the parser,
+ * and not exported.
+ *
+ * Dirty macros, i.e. one often need to make assumption on the context to
+ * use them
+ *
+ *   CUR_PTR return the current pointer to the xmlChar to be parsed.
+ *           To be used with extreme caution since operations consuming
+ *           characters may move the input buffer to a different location !
+ *   CUR     returns the current xmlChar value, i.e. a 8 bit value if compiled
+ *           This should be used internally by the parser
+ *           only to compare to ASCII values otherwise it would break when
+ *           running with UTF-8 encoding.
+ *   RAW     same as CUR but in the input buffer, bypass any token
+ *           extraction that may have been done
+ *   NXT(n)  returns the n'th next xmlChar. Same as CUR is should be used only
+ *           to compare on ASCII based substring.
+ *   SKIP(n) Skip n xmlChar, and must also be used only to skip ASCII defined
+ *           strings without newlines within the parser.
+ *   NEXT1(l) Skip 1 xmlChar, and must also be used only to skip 1 non-newline ASCII 
+ *           defined char within the parser.
+ * Clean macros, not dependent of an ASCII context, expect UTF-8 encoding
+ *
+ *   NEXT    Skip to the next character, this does the proper decoding
+ *           in UTF-8 mode. It also pop-up unfinished entities on the fly.
+ *   NEXTL(l) Skip the current unicode character of l xmlChars long.
+ *   CUR_CHAR(l) returns the current unicode character (int), set l
+ *           to the number of xmlChars used for the encoding [0-5].
+ *   CUR_SCHAR  same but operate on a string instead of the context
+ *   COPY_BUF  copy the current unicode char to the target buffer, increment
+ *            the index
+ *   GROW, SHRINK  handling of input buffers
+ */
+
+#define RAW (*ctxt->input->cur)
+#define CUR (*ctxt->input->cur)
+#define NXT(val) ctxt->input->cur[(val)]
+#define CUR_PTR ctxt->input->cur
+
+#define CMP4( s, c1, c2, c3, c4 ) \
+  ( ((unsigned char *) s)[ 0 ] == c1 && ((unsigned char *) s)[ 1 ] == c2 && \
+    ((unsigned char *) s)[ 2 ] == c3 && ((unsigned char *) s)[ 3 ] == c4 )
+#define CMP5( s, c1, c2, c3, c4, c5 ) \
+  ( CMP4( s, c1, c2, c3, c4 ) && ((unsigned char *) s)[ 4 ] == c5 )
+#define CMP6( s, c1, c2, c3, c4, c5, c6 ) \
+  ( CMP5( s, c1, c2, c3, c4, c5 ) && ((unsigned char *) s)[ 5 ] == c6 )
+#define CMP7( s, c1, c2, c3, c4, c5, c6, c7 ) \
+  ( CMP6( s, c1, c2, c3, c4, c5, c6 ) && ((unsigned char *) s)[ 6 ] == c7 )
+#define CMP8( s, c1, c2, c3, c4, c5, c6, c7, c8 ) \
+  ( CMP7( s, c1, c2, c3, c4, c5, c6, c7 ) && ((unsigned char *) s)[ 7 ] == c8 )
+#define CMP9( s, c1, c2, c3, c4, c5, c6, c7, c8, c9 ) \
+  ( CMP8( s, c1, c2, c3, c4, c5, c6, c7, c8 ) && \
+    ((unsigned char *) s)[ 8 ] == c9 )
+#define CMP10( s, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10 ) \
+  ( CMP9( s, c1, c2, c3, c4, c5, c6, c7, c8, c9 ) && \
+    ((unsigned char *) s)[ 9 ] == c10 )
+
+#define SKIP(val) do {							\
+    ctxt->nbChars += (val),ctxt->input->cur += (val),ctxt->input->col+=(val);			\
+    if (*ctxt->input->cur == '%') xmlParserHandlePEReference(ctxt);	\
+    if ((*ctxt->input->cur == 0) &&					\
+        (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0))		\
+	    xmlPopInput(ctxt);						\
+  } while (0)
+
+#define SKIPL(val) do {							\
+    int skipl;								\
+    for(skipl=0; skipl<val; skipl++) {					\
+    	if (*(ctxt->input->cur) == '\n') {				\
+	ctxt->input->line++; ctxt->input->col = 1;			\
+    	} else ctxt->input->col++;					\
+    	ctxt->nbChars++;						\
+	ctxt->input->cur++;						\
+    }									\
+    if (*ctxt->input->cur == '%') xmlParserHandlePEReference(ctxt);	\
+    if ((*ctxt->input->cur == 0) &&					\
+        (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0))		\
+	    xmlPopInput(ctxt);						\
+  } while (0)
+
+#define SHRINK if ((ctxt->progressive == 0) &&				\
+		   (ctxt->input->cur - ctxt->input->base > 2 * INPUT_CHUNK) && \
+		   (ctxt->input->end - ctxt->input->cur < 2 * INPUT_CHUNK)) \
+	xmlSHRINK (ctxt);
+
+static void xmlSHRINK (xmlParserCtxtPtr ctxt) {
+    xmlParserInputShrink(ctxt->input);
+    if ((*ctxt->input->cur == 0) &&
+        (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0))
+	    xmlPopInput(ctxt);
+  }
+
+#define GROW if ((ctxt->progressive == 0) &&				\
+		 (ctxt->input->end - ctxt->input->cur < INPUT_CHUNK))	\
+	xmlGROW (ctxt);
+
+static void xmlGROW (xmlParserCtxtPtr ctxt) {
+    xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
+    if ((*ctxt->input->cur == 0) &&
+        (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0))
+	    xmlPopInput(ctxt);
+}
+
+#define SKIP_BLANKS xmlSkipBlankChars(ctxt)
+
+#define NEXT xmlNextChar(ctxt)
+
+#define NEXT1 {								\
+	ctxt->input->col++;						\
+	ctxt->input->cur++;						\
+	ctxt->nbChars++;						\
+	if (*ctxt->input->cur == 0)					\
+	    xmlParserInputGrow(ctxt->input, INPUT_CHUNK);		\
+    }
+
+#define NEXTL(l) do {							\
+    if (*(ctxt->input->cur) == '\n') {					\
+	ctxt->input->line++; ctxt->input->col = 1;			\
+    } else ctxt->input->col++;						\
+    ctxt->input->cur += l;				\
+    if (*ctxt->input->cur == '%') xmlParserHandlePEReference(ctxt);	\
+  } while (0)
+
+#define CUR_CHAR(l) xmlCurrentChar(ctxt, &l)
+#define CUR_SCHAR(s, l) xmlStringCurrentChar(ctxt, s, &l)
+
+#define COPY_BUF(l,b,i,v)						\
+    if (l == 1) b[i++] = (xmlChar) v;					\
+    else i += xmlCopyCharMultiByte(&b[i],v)
+
+/**
+ * xmlSkipBlankChars:
+ * @ctxt:  the XML parser context
+ *
+ * skip all blanks character found at that point in the input streams.
+ * It pops up finished entities in the process if allowable at that point.
+ *
+ * Returns the number of space chars skipped
+ */
+
+int
+xmlSkipBlankChars(xmlParserCtxtPtr ctxt) {
+    int res = 0;
+
+    /*
+     * It's Okay to use CUR/NEXT here since all the blanks are on
+     * the ASCII range.
+     */
+    if ((ctxt->inputNr == 1) && (ctxt->instate != XML_PARSER_DTD)) {
+	const xmlChar *cur;
+	/*
+	 * if we are in the document content, go really fast
+	 */
+	cur = ctxt->input->cur;
+	while (IS_BLANK_CH(*cur)) {
+	    if (*cur == '\n') {
+		ctxt->input->line++; ctxt->input->col = 1;
+	    }
+	    cur++;
+	    res++;
+	    if (*cur == 0) {
+		ctxt->input->cur = cur;
+		xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
+		cur = ctxt->input->cur;
+	    }
+	}
+	ctxt->input->cur = cur;
+    } else {
+	int cur;
+	do {
+	    cur = CUR;
+	    while (IS_BLANK(cur)) { /* CHECKED tstblanks.xml */
+		NEXT;
+		cur = CUR;
+		res++;
+	    }
+	    while ((cur == 0) && (ctxt->inputNr > 1) &&
+		   (ctxt->instate != XML_PARSER_COMMENT)) {
+		xmlPopInput(ctxt);
+		cur = CUR;
+	    }
+	    /*
+	     * Need to handle support of entities branching here
+	     */
+	    if (*ctxt->input->cur == '%') xmlParserHandlePEReference(ctxt);
+	} while (IS_BLANK(cur)); /* CHECKED tstblanks.xml */
+    }
+    return(res);
+}
+
+/************************************************************************
+ *									*
+ *		Commodity functions to handle entities			*
+ *									*
+ ************************************************************************/
+
+/**
+ * xmlPopInput:
+ * @ctxt:  an XML parser context
+ *
+ * xmlPopInput: the current input pointed by ctxt->input came to an end
+ *          pop it and return the next char.
+ *
+ * Returns the current xmlChar in the parser context
+ */
+xmlChar
+xmlPopInput(xmlParserCtxtPtr ctxt) {
+    if (ctxt->inputNr == 1) return(0); /* End of main Input */
+    if (xmlParserDebugEntities)
+	xmlGenericError(xmlGenericErrorContext,
+		"Popping input %d\n", ctxt->inputNr);
+    xmlFreeInputStream(inputPop(ctxt));
+    if ((*ctxt->input->cur == 0) &&
+        (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0))
+	    return(xmlPopInput(ctxt));
+    return(CUR);
+}
+
+/**
+ * xmlPushInput:
+ * @ctxt:  an XML parser context
+ * @input:  an XML parser input fragment (entity, XML fragment ...).
+ *
+ * xmlPushInput: switch to a new input stream which is stacked on top
+ *               of the previous one(s).
+ */
+void
+xmlPushInput(xmlParserCtxtPtr ctxt, xmlParserInputPtr input) {
+    if (input == NULL) return;
+
+    if (xmlParserDebugEntities) {
+	if ((ctxt->input != NULL) && (ctxt->input->filename))
+	    xmlGenericError(xmlGenericErrorContext,
+		    "%s(%d): ", ctxt->input->filename,
+		    ctxt->input->line);
+	xmlGenericError(xmlGenericErrorContext,
+		"Pushing input %d : %.30s\n", ctxt->inputNr+1, input->cur);
+    }
+    inputPush(ctxt, input);
+    GROW;
+}
+
+/**
+ * xmlParseCharRef:
+ * @ctxt:  an XML parser context
+ *
+ * parse Reference declarations
+ *
+ * [66] CharRef ::= '&#' [0-9]+ ';' |
+ *                  '&#x' [0-9a-fA-F]+ ';'
+ *
+ * [ WFC: Legal Character ]
+ * Characters referred to using character references must match the
+ * production for Char. 
+ *
+ * Returns the value parsed (as an int), 0 in case of error
+ */
+int
+xmlParseCharRef(xmlParserCtxtPtr ctxt) {
+    unsigned int val = 0;
+    int count = 0;
+
+    /*
+     * Using RAW/CUR/NEXT is okay since we are working on ASCII range here
+     */
+    if ((RAW == '&') && (NXT(1) == '#') &&
+        (NXT(2) == 'x')) {
+	SKIP(3);
+	GROW;
+	while (RAW != ';') { /* loop blocked by count */
+	    if (count++ > 20) {
+		count = 0;
+		GROW;
+	    }
+	    if ((RAW >= '0') && (RAW <= '9')) 
+	        val = val * 16 + (CUR - '0');
+	    else if ((RAW >= 'a') && (RAW <= 'f') && (count < 20))
+	        val = val * 16 + (CUR - 'a') + 10;
+	    else if ((RAW >= 'A') && (RAW <= 'F') && (count < 20))
+	        val = val * 16 + (CUR - 'A') + 10;
+	    else {
+		xmlFatalErr(ctxt, XML_ERR_INVALID_HEX_CHARREF, NULL);
+		val = 0;
+		break;
+	    }
+	    NEXT;
+	    count++;
+	}
+	if (RAW == ';') {
+	    /* on purpose to avoid reentrancy problems with NEXT and SKIP */
+	    ctxt->input->col++;
+	    ctxt->nbChars ++;
+	    ctxt->input->cur++;
+	}
+    } else if  ((RAW == '&') && (NXT(1) == '#')) {
+	SKIP(2);
+	GROW;
+	while (RAW != ';') { /* loop blocked by count */
+	    if (count++ > 20) {
+		count = 0;
+		GROW;
+	    }
+	    if ((RAW >= '0') && (RAW <= '9')) 
+	        val = val * 10 + (CUR - '0');
+	    else {
+		xmlFatalErr(ctxt, XML_ERR_INVALID_DEC_CHARREF, NULL);
+		val = 0;
+		break;
+	    }
+	    NEXT;
+	    count++;
+	}
+	if (RAW == ';') {
+	    /* on purpose to avoid reentrancy problems with NEXT and SKIP */
+	    ctxt->input->col++;
+	    ctxt->nbChars ++;
+	    ctxt->input->cur++;
+	}
+    } else {
+        xmlFatalErr(ctxt, XML_ERR_INVALID_CHARREF, NULL);
+    }
+
+    /*
+     * [ WFC: Legal Character ]
+     * Characters referred to using character references must match the
+     * production for Char. 
+     */
+    if (IS_CHAR(val)) {
+        return(val);
+    } else {
+        xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
+                          "xmlParseCharRef: invalid xmlChar value %d\n",
+	                  val);
+    }
+    return(0);
+}
+
+/**
+ * xmlParseStringCharRef:
+ * @ctxt:  an XML parser context
+ * @str:  a pointer to an index in the string
+ *
+ * parse Reference declarations, variant parsing from a string rather
+ * than an an input flow.
+ *
+ * [66] CharRef ::= '&#' [0-9]+ ';' |
+ *                  '&#x' [0-9a-fA-F]+ ';'
+ *
+ * [ WFC: Legal Character ]
+ * Characters referred to using character references must match the
+ * production for Char. 
+ *
+ * Returns the value parsed (as an int), 0 in case of error, str will be
+ *         updated to the current value of the index
+ */
+static int
+xmlParseStringCharRef(xmlParserCtxtPtr ctxt, const xmlChar **str) {
+    const xmlChar *ptr;
+    xmlChar cur;
+    int val = 0;
+
+    if ((str == NULL) || (*str == NULL)) return(0);
+    ptr = *str;
+    cur = *ptr;
+    if ((cur == '&') && (ptr[1] == '#') && (ptr[2] == 'x')) {
+	ptr += 3;
+	cur = *ptr;
+	while (cur != ';') { /* Non input consuming loop */
+	    if ((cur >= '0') && (cur <= '9')) 
+	        val = val * 16 + (cur - '0');
+	    else if ((cur >= 'a') && (cur <= 'f'))
+	        val = val * 16 + (cur - 'a') + 10;
+	    else if ((cur >= 'A') && (cur <= 'F'))
+	        val = val * 16 + (cur - 'A') + 10;
+	    else {
+		xmlFatalErr(ctxt, XML_ERR_INVALID_HEX_CHARREF, NULL);
+		val = 0;
+		break;
+	    }
+	    ptr++;
+	    cur = *ptr;
+	}
+	if (cur == ';')
+	    ptr++;
+    } else if  ((cur == '&') && (ptr[1] == '#')){
+	ptr += 2;
+	cur = *ptr;
+	while (cur != ';') { /* Non input consuming loops */
+	    if ((cur >= '0') && (cur <= '9')) 
+	        val = val * 10 + (cur - '0');
+	    else {
+		xmlFatalErr(ctxt, XML_ERR_INVALID_DEC_CHARREF, NULL);
+		val = 0;
+		break;
+	    }
+	    ptr++;
+	    cur = *ptr;
+	}
+	if (cur == ';')
+	    ptr++;
+    } else {
+	xmlFatalErr(ctxt, XML_ERR_INVALID_CHARREF, NULL);
+	return(0);
+    }
+    *str = ptr;
+
+    /*
+     * [ WFC: Legal Character ]
+     * Characters referred to using character references must match the
+     * production for Char. 
+     */
+    if (IS_CHAR(val)) {
+        return(val);
+    } else {
+        xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
+			  "xmlParseStringCharRef: invalid xmlChar value %d\n",
+			  val);
+    }
+    return(0);
+}
+
+/**
+ * xmlNewBlanksWrapperInputStream:
+ * @ctxt:  an XML parser context
+ * @entity:  an Entity pointer
+ *
+ * Create a new input stream for wrapping
+ * blanks around a PEReference
+ *
+ * Returns the new input stream or NULL
+ */
+ 
+static void deallocblankswrapper (xmlChar *str) {xmlFree(str);}
+ 
+static xmlParserInputPtr
+xmlNewBlanksWrapperInputStream(xmlParserCtxtPtr ctxt, xmlEntityPtr entity) {
+    xmlParserInputPtr input;
+    xmlChar *buffer;
+    size_t length;
+    if (entity == NULL) {
+	xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
+	            "xmlNewBlanksWrapperInputStream entity\n");
+	return(NULL);
+    }
+    if (xmlParserDebugEntities)
+	xmlGenericError(xmlGenericErrorContext,
+		"new blanks wrapper for entity: %s\n", entity->name);
+    input = xmlNewInputStream(ctxt);
+    if (input == NULL) {
+	return(NULL);
+    }
+    length = xmlStrlen(entity->name) + 5;
+    buffer = xmlMallocAtomic(length);
+    if (buffer == NULL) {
+	xmlErrMemory(ctxt, NULL);
+    	return(NULL);
+    }
+    buffer [0] = ' ';
+    buffer [1] = '%';
+    buffer [length-3] = ';';
+    buffer [length-2] = ' ';
+    buffer [length-1] = 0;
+    memcpy(buffer + 2, entity->name, length - 5);
+    input->free = deallocblankswrapper;
+    input->base = buffer;
+    input->cur = buffer;
+    input->length = length;
+    input->end = &buffer[length];
+    return(input);
+}
+
+/**
+ * xmlParserHandlePEReference:
+ * @ctxt:  the parser context
+ * 
+ * [69] PEReference ::= '%' Name ';'
+ *
+ * [ WFC: No Recursion ]
+ * A parsed entity must not contain a recursive
+ * reference to itself, either directly or indirectly. 
+ *
+ * [ WFC: Entity Declared ]
+ * In a document without any DTD, a document with only an internal DTD
+ * subset which contains no parameter entity references, or a document
+ * with "standalone='yes'", ...  ... The declaration of a parameter
+ * entity must precede any reference to it...
+ *
+ * [ VC: Entity Declared ]
+ * In a document with an external subset or external parameter entities
+ * with "standalone='no'", ...  ... The declaration of a parameter entity
+ * must precede any reference to it...
+ *
+ * [ WFC: In DTD ]
+ * Parameter-entity references may only appear in the DTD.
+ * NOTE: misleading but this is handled.
+ *
+ * A PEReference may have been detected in the current input stream
+ * the handling is done accordingly to 
+ *      http://www.w3.org/TR/REC-xml#entproc
+ * i.e. 
+ *   - Included in literal in entity values
+ *   - Included as Parameter Entity reference within DTDs
+ */
+void
+xmlParserHandlePEReference(xmlParserCtxtPtr ctxt) {
+    const xmlChar *name;
+    xmlEntityPtr entity = NULL;
+    xmlParserInputPtr input;
+
+    if (RAW != '%') return;
+    switch(ctxt->instate) {
+	case XML_PARSER_CDATA_SECTION:
+	    return;
+        case XML_PARSER_COMMENT:
+	    return;
+	case XML_PARSER_START_TAG:
+	    return;
+	case XML_PARSER_END_TAG:
+	    return;
+        case XML_PARSER_EOF:
+	    xmlFatalErr(ctxt, XML_ERR_PEREF_AT_EOF, NULL);
+	    return;
+        case XML_PARSER_PROLOG:
+	case XML_PARSER_START:
+	case XML_PARSER_MISC:
+	    xmlFatalErr(ctxt, XML_ERR_PEREF_IN_PROLOG, NULL);
+	    return;
+	case XML_PARSER_ENTITY_DECL:
+        case XML_PARSER_CONTENT:
+        case XML_PARSER_ATTRIBUTE_VALUE:
+        case XML_PARSER_PI:
+	case XML_PARSER_SYSTEM_LITERAL:
+	case XML_PARSER_PUBLIC_LITERAL:
+	    /* we just ignore it there */
+	    return;
+        case XML_PARSER_EPILOG:
+	    xmlFatalErr(ctxt, XML_ERR_PEREF_IN_EPILOG, NULL);
+	    return;
+	case XML_PARSER_ENTITY_VALUE:
+	    /*
+	     * NOTE: in the case of entity values, we don't do the
+	     *       substitution here since we need the literal
+	     *       entity value to be able to save the internal
+	     *       subset of the document.
+	     *       This will be handled by xmlStringDecodeEntities
+	     */
+	    return;
+        case XML_PARSER_DTD:
+	    /*
+	     * [WFC: Well-Formedness Constraint: PEs in Internal Subset]
+	     * In the internal DTD subset, parameter-entity references
+	     * can occur only where markup declarations can occur, not
+	     * within markup declarations.
+	     * In that case this is handled in xmlParseMarkupDecl
+	     */
+	    if ((ctxt->external == 0) && (ctxt->inputNr == 1))
+		return;
+	    if (IS_BLANK_CH(NXT(1)) || NXT(1) == 0)
+		return;
+            break;
+        case XML_PARSER_IGNORE:
+            return;
+    }
+
+    NEXT;
+    name = xmlParseName(ctxt);
+    if (xmlParserDebugEntities)
+	xmlGenericError(xmlGenericErrorContext,
+		"PEReference: %s\n", name);
+    if (name == NULL) {
+	xmlFatalErr(ctxt, XML_ERR_PEREF_NO_NAME, NULL);
+    } else {
+	if (RAW == ';') {
+	    NEXT;
+	    if ((ctxt->sax != NULL) && (ctxt->sax->getParameterEntity != NULL))
+		entity = ctxt->sax->getParameterEntity(ctxt->userData, name);
+	    if (entity == NULL) {
+	        
+		/*
+		 * [ WFC: Entity Declared ]
+		 * In a document without any DTD, a document with only an
+		 * internal DTD subset which contains no parameter entity
+		 * references, or a document with "standalone='yes'", ...
+		 * ... The declaration of a parameter entity must precede
+		 * any reference to it...
+		 */
+		if ((ctxt->standalone == 1) ||
+		    ((ctxt->hasExternalSubset == 0) &&
+		     (ctxt->hasPErefs == 0))) {
+		    xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
+			 "PEReference: %%%s; not found\n", name);
+	        } else {
+		    /*
+		     * [ VC: Entity Declared ]
+		     * In a document with an external subset or external
+		     * parameter entities with "standalone='no'", ...
+		     * ... The declaration of a parameter entity must precede
+		     * any reference to it...
+		     */
+		    if ((ctxt->validate) && (ctxt->vctxt.error != NULL)) {
+		        xmlValidityError(ctxt, XML_WAR_UNDECLARED_ENTITY,
+			                 "PEReference: %%%s; not found\n",
+				         name);
+		    } else 
+		        xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
+			              "PEReference: %%%s; not found\n",
+				      name, NULL);
+		    ctxt->valid = 0;
+		}
+	    } else if (ctxt->input->free != deallocblankswrapper) {
+		    input = xmlNewBlanksWrapperInputStream(ctxt, entity);
+		    xmlPushInput(ctxt, input);
+	    } else {
+	        if ((entity->etype == XML_INTERNAL_PARAMETER_ENTITY) ||
+		    (entity->etype == XML_EXTERNAL_PARAMETER_ENTITY)) {
+		    xmlChar start[4];
+		    xmlCharEncoding enc;
+
+		    /*
+		     * handle the extra spaces added before and after
+		     * c.f. http://www.w3.org/TR/REC-xml#as-PE
+		     * this is done independently.
+		     */
+		    input = xmlNewEntityInputStream(ctxt, entity);
+		    xmlPushInput(ctxt, input);
+
+		    /* 
+		     * Get the 4 first bytes and decode the charset
+		     * if enc != XML_CHAR_ENCODING_NONE
+		     * plug some encoding conversion routines.
+		     * Note that, since we may have some non-UTF8
+		     * encoding (like UTF16, bug 135229), the 'length'
+		     * is not known, but we can calculate based upon
+		     * the amount of data in the buffer.
+		     */
+		    GROW
+		    if ((ctxt->input->end - ctxt->input->cur)>=4) {
+			start[0] = RAW;
+			start[1] = NXT(1);
+			start[2] = NXT(2);
+			start[3] = NXT(3);
+			enc = xmlDetectCharEncoding(start, 4);
+			if (enc != XML_CHAR_ENCODING_NONE) {
+			    xmlSwitchEncoding(ctxt, enc);
+			}
+		    }
+
+		    if ((entity->etype == XML_EXTERNAL_PARAMETER_ENTITY) &&
+			(CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l' )) &&
+			(IS_BLANK_CH(NXT(5)))) {
+			xmlParseTextDecl(ctxt);
+		    }
+		} else {
+		    xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_PARAMETER,
+			     "PEReference: %s is not a parameter entity\n",
+				      name);
+		}
+	    }
+	} else {
+	    xmlFatalErr(ctxt, XML_ERR_PEREF_SEMICOL_MISSING, NULL);
+	}
+    }
+}
+
+/*
+ * Macro used to grow the current buffer.
+ */
+#define growBuffer(buffer) {						\
+    xmlChar *tmp;							\
+    buffer##_size *= 2;							\
+    tmp = (xmlChar *)							\
+    		xmlRealloc(buffer, buffer##_size * sizeof(xmlChar));	\
+    if (tmp == NULL) goto mem_error;					\
+    buffer = tmp;							\
+}
+
+/**
+ * xmlStringLenDecodeEntities:
+ * @ctxt:  the parser context
+ * @str:  the input string
+ * @len: the string length
+ * @what:  combination of XML_SUBSTITUTE_REF and XML_SUBSTITUTE_PEREF
+ * @end:  an end marker xmlChar, 0 if none
+ * @end2:  an end marker xmlChar, 0 if none
+ * @end3:  an end marker xmlChar, 0 if none
+ * 
+ * Takes a entity string content and process to do the adequate substitutions.
+ *
+ * [67] Reference ::= EntityRef | CharRef
+ *
+ * [69] PEReference ::= '%' Name ';'
+ *
+ * Returns A newly allocated string with the substitution done. The caller
+ *      must deallocate it !
+ */
+xmlChar *
+xmlStringLenDecodeEntities(xmlParserCtxtPtr ctxt, const xmlChar *str, int len,
+		      int what, xmlChar end, xmlChar  end2, xmlChar end3) {
+    xmlChar *buffer = NULL;
+    int buffer_size = 0;
+
+    xmlChar *current = NULL;
+    const xmlChar *last;
+    xmlEntityPtr ent;
+    int c,l;
+    int nbchars = 0;
+
+    if ((str == NULL) || (len < 0))
+	return(NULL);
+    last = str + len;
+
+    if (ctxt->depth > 40) {
+	xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
+	return(NULL);
+    }
+
+    /*
+     * allocate a translation buffer.
+     */
+    buffer_size = XML_PARSER_BIG_BUFFER_SIZE;
+    buffer = (xmlChar *) xmlMallocAtomic(buffer_size * sizeof(xmlChar));
+    if (buffer == NULL) goto mem_error;
+
+    /*
+     * OK loop until we reach one of the ending char or a size limit.
+     * we are operating on already parsed values.
+     */
+    if (str < last)
+	c = CUR_SCHAR(str, l);
+    else
+        c = 0;
+    while ((c != 0) && (c != end) && /* non input consuming loop */
+	   (c != end2) && (c != end3)) {
+
+	if (c == 0) break;
+        if ((c == '&') && (str[1] == '#')) {
+	    int val = xmlParseStringCharRef(ctxt, &str);
+	    if (val != 0) {
+		COPY_BUF(0,buffer,nbchars,val);
+	    }
+	} else if ((c == '&') && (what & XML_SUBSTITUTE_REF)) {
+	    if (xmlParserDebugEntities)
+		xmlGenericError(xmlGenericErrorContext,
+			"String decoding Entity Reference: %.30s\n",
+			str);
+	    ent = xmlParseStringEntityRef(ctxt, &str);
+	    if ((ent != NULL) &&
+		(ent->etype == XML_INTERNAL_PREDEFINED_ENTITY)) {
+		if (ent->content != NULL) {
+		    COPY_BUF(0,buffer,nbchars,ent->content[0]);
+		} else {
+		    xmlFatalErrMsg(ctxt, XML_ERR_INTERNAL_ERROR,
+			    "predefined entity has no content\n");
+		}
+	    } else if ((ent != NULL) && (ent->content != NULL)) {
+		xmlChar *rep;
+
+		ctxt->depth++;
+		rep = xmlStringDecodeEntities(ctxt, ent->content, what,
+			                      0, 0, 0);
+		ctxt->depth--;
+		if (rep != NULL) {
+		    current = rep;
+		    while (*current != 0) { /* non input consuming loop */
+			buffer[nbchars++] = *current++;
+			if (nbchars >
+		            buffer_size - XML_PARSER_BUFFER_SIZE) {
+			    growBuffer(buffer);
+			}
+		    }
+		    xmlFree(rep);
+		}
+	    } else if (ent != NULL) {
+		int i = xmlStrlen(ent->name);
+		const xmlChar *cur = ent->name;
+
+		buffer[nbchars++] = '&';
+		if (nbchars > buffer_size - i - XML_PARSER_BUFFER_SIZE) {
+		    growBuffer(buffer);
+		}
+		for (;i > 0;i--)
+		    buffer[nbchars++] = *cur++;
+		buffer[nbchars++] = ';';
+	    }
+	} else if (c == '%' && (what & XML_SUBSTITUTE_PEREF)) {
+	    if (xmlParserDebugEntities)
+		xmlGenericError(xmlGenericErrorContext,
+			"String decoding PE Reference: %.30s\n", str);
+	    ent = xmlParseStringPEReference(ctxt, &str);
+	    if (ent != NULL) {
+		xmlChar *rep;
+
+		ctxt->depth++;
+		rep = xmlStringDecodeEntities(ctxt, ent->content, what,
+			                      0, 0, 0);
+		ctxt->depth--;
+		if (rep != NULL) {
+		    current = rep;
+		    while (*current != 0) { /* non input consuming loop */
+			buffer[nbchars++] = *current++;
+			if (nbchars >
+		            buffer_size - XML_PARSER_BUFFER_SIZE) {
+			    growBuffer(buffer);
+			}
+		    }
+		    xmlFree(rep);
+		}
+	    }
+	} else {
+	    COPY_BUF(l,buffer,nbchars,c);
+	    str += l;
+	    if (nbchars > buffer_size - XML_PARSER_BUFFER_SIZE) {
+	      growBuffer(buffer);
+	    }
+	}
+	if (str < last)
+	    c = CUR_SCHAR(str, l);
+	else
+	    c = 0;
+    }
+    buffer[nbchars++] = 0;
+    return(buffer);
+
+mem_error:
+    xmlErrMemory(ctxt, NULL);
+    return(NULL);
+}
+
+/**
+ * xmlStringDecodeEntities:
+ * @ctxt:  the parser context
+ * @str:  the input string
+ * @what:  combination of XML_SUBSTITUTE_REF and XML_SUBSTITUTE_PEREF
+ * @end:  an end marker xmlChar, 0 if none
+ * @end2:  an end marker xmlChar, 0 if none
+ * @end3:  an end marker xmlChar, 0 if none
+ * 
+ * Takes a entity string content and process to do the adequate substitutions.
+ *
+ * [67] Reference ::= EntityRef | CharRef
+ *
+ * [69] PEReference ::= '%' Name ';'
+ *
+ * Returns A newly allocated string with the substitution done. The caller
+ *      must deallocate it !
+ */
+xmlChar *
+xmlStringDecodeEntities(xmlParserCtxtPtr ctxt, const xmlChar *str, int what,
+		        xmlChar end, xmlChar  end2, xmlChar end3) {
+    return(xmlStringLenDecodeEntities(ctxt, str, xmlStrlen(str), what,
+           end, end2, end3));
+}
+
+/************************************************************************
+ *									*
+ *		Commodity functions, cleanup needed ?			*
+ *									*
+ ************************************************************************/
+
+/**
+ * areBlanks:
+ * @ctxt:  an XML parser context
+ * @str:  a xmlChar *
+ * @len:  the size of @str
+ * @blank_chars: we know the chars are blanks
+ *
+ * Is this a sequence of blank chars that one can ignore ?
+ *
+ * Returns 1 if ignorable 0 otherwise.
+ */
+
+static int areBlanks(xmlParserCtxtPtr ctxt, const xmlChar *str, int len,
+                     int blank_chars) {
+    int i, ret;
+    xmlNodePtr lastChild;
+
+    /*
+     * Don't spend time trying to differentiate them, the same callback is
+     * used !
+     */
+    if (ctxt->sax->ignorableWhitespace == ctxt->sax->characters)
+	return(0);
+
+    /*
+     * Check for xml:space value.
+     */
+    if (*(ctxt->space) == 1)
+	return(0);
+
+    /*
+     * Check that the string is made of blanks
+     */
+    if (blank_chars == 0) {
+	for (i = 0;i < len;i++)
+	    if (!(IS_BLANK_CH(str[i]))) return(0);
+    }
+
+    /*
+     * Look if the element is mixed content in the DTD if available
+     */
+    if (ctxt->node == NULL) return(0);
+    if (ctxt->myDoc != NULL) {
+	ret = xmlIsMixedElement(ctxt->myDoc, ctxt->node->name);
+        if (ret == 0) return(1);
+        if (ret == 1) return(0);
+    }
+
+    /*
+     * Otherwise, heuristic :-\
+     */
+    if (RAW != '<') return(0);
+    if ((ctxt->node->children == NULL) &&
+	(RAW == '<') && (NXT(1) == '/')) return(0);
+
+    lastChild = xmlGetLastChild(ctxt->node);
+    if (lastChild == NULL) {
+        if ((ctxt->node->type != XML_ELEMENT_NODE) &&
+            (ctxt->node->content != NULL)) return(0);
+    } else if (xmlNodeIsText(lastChild))
+        return(0);
+    else if ((ctxt->node->children != NULL) &&
+             (xmlNodeIsText(ctxt->node->children)))
+        return(0);
+    return(1);
+}
+
+/************************************************************************
+ *									*
+ *		Extra stuff for namespace support			*
+ *	Relates to http://www.w3.org/TR/WD-xml-names			*
+ *									*
+ ************************************************************************/
+
+/**
+ * xmlSplitQName:
+ * @ctxt:  an XML parser context
+ * @name:  an XML parser context
+ * @prefix:  a xmlChar ** 
+ *
+ * parse an UTF8 encoded XML qualified name string
+ *
+ * [NS 5] QName ::= (Prefix ':')? LocalPart
+ *
+ * [NS 6] Prefix ::= NCName
+ *
+ * [NS 7] LocalPart ::= NCName
+ *
+ * Returns the local part, and prefix is updated
+ *   to get the Prefix if any.
+ */
+
+xmlChar *
+xmlSplitQName(xmlParserCtxtPtr ctxt, const xmlChar *name, xmlChar **prefix) {
+    xmlChar buf[XML_MAX_NAMELEN + 5];
+    xmlChar *buffer = NULL;
+    int len = 0;
+    int max = XML_MAX_NAMELEN;
+    xmlChar *ret = NULL;
+    const xmlChar *cur = name;
+    int c;
+
+    *prefix = NULL;
+
+    if (cur == NULL) return(NULL);
+
+#ifndef XML_XML_NAMESPACE
+    /* xml: prefix is not really a namespace */
+    if ((cur[0] == 'x') && (cur[1] == 'm') &&
+        (cur[2] == 'l') && (cur[3] == ':'))
+	return(xmlStrdup(name));
+#endif
+
+    /* nasty but well=formed */
+    if (cur[0] == ':')
+	return(xmlStrdup(name));
+
+    c = *cur++;
+    while ((c != 0) && (c != ':') && (len < max)) { /* tested bigname.xml */
+	buf[len++] = c;
+	c = *cur++;
+    }
+    if (len >= max) {
+	/*
+	 * Okay someone managed to make a huge name, so he's ready to pay
+	 * for the processing speed.
+	 */
+	max = len * 2;
+	
+	buffer = (xmlChar *) xmlMallocAtomic(max * sizeof(xmlChar));
+	if (buffer == NULL) {
+	    xmlErrMemory(ctxt, NULL);
+	    return(NULL);
+	}
+	memcpy(buffer, buf, len);
+	while ((c != 0) && (c != ':')) { /* tested bigname.xml */
+	    if (len + 10 > max) {
+		max *= 2;
+		buffer = (xmlChar *) xmlRealloc(buffer,
+						max * sizeof(xmlChar));
+		if (buffer == NULL) {
+		    xmlErrMemory(ctxt, NULL);
+		    return(NULL);
+		}
+	    }
+	    buffer[len++] = c;
+	    c = *cur++;
+	}
+	buffer[len] = 0;
+    }
+    
+    /* nasty but well=formed
+    if ((c == ':') && (*cur == 0)) {
+	return(xmlStrdup(name));
+    } */
+
+    if (buffer == NULL)
+	ret = xmlStrndup(buf, len);
+    else {
+	ret = buffer;
+	buffer = NULL;
+	max = XML_MAX_NAMELEN;
+    }
+
+
+    if (c == ':') {
+	c = *cur;
+        *prefix = ret;
+	if (c == 0) {
+	    return(xmlStrndup(BAD_CAST "", 0));
+	}
+	len = 0;
+
+	/*
+	 * Check that the first character is proper to start
+	 * a new name
+	 */
+	if (!(((c >= 0x61) && (c <= 0x7A)) ||
+	      ((c >= 0x41) && (c <= 0x5A)) ||
+	      (c == '_') || (c == ':'))) {
+	    int l;
+	    int first = CUR_SCHAR(cur, l);
+
+	    if (!IS_LETTER(first) && (first != '_')) {
+		xmlFatalErrMsgStr(ctxt, XML_NS_ERR_QNAME,
+			    "Name %s is not XML Namespace compliant\n",
+				  name);
+	    }
+	}
+	cur++;
+
+	while ((c != 0) && (len < max)) { /* tested bigname2.xml */
+	    buf[len++] = c;
+	    c = *cur++;
+	}
+	if (len >= max) {
+	    /*
+	     * Okay someone managed to make a huge name, so he's ready to pay
+	     * for the processing speed.
+	     */
+	    max = len * 2;
+	    
+	    buffer = (xmlChar *) xmlMallocAtomic(max * sizeof(xmlChar));
+	    if (buffer == NULL) {
+	        xmlErrMemory(ctxt, NULL);
+		return(NULL);
+	    }
+	    memcpy(buffer, buf, len);
+	    while (c != 0) { /* tested bigname2.xml */
+		if (len + 10 > max) {
+		    max *= 2;
+		    buffer = (xmlChar *) xmlRealloc(buffer,
+						    max * sizeof(xmlChar));
+		    if (buffer == NULL) {
+			xmlErrMemory(ctxt, NULL);
+			return(NULL);
+		    }
+		}
+		buffer[len++] = c;
+		c = *cur++;
+	    }
+	    buffer[len] = 0;
+	}
+	
+	if (buffer == NULL)
+	    ret = xmlStrndup(buf, len);
+	else {
+	    ret = buffer;
+	}
+    }
+
+    return(ret);
+}
+
+/************************************************************************
+ *									*
+ *			The parser itself				*
+ *	Relates to http://www.w3.org/TR/REC-xml				*
+ *									*
+ ************************************************************************/
+
+static const xmlChar * xmlParseNameComplex(xmlParserCtxtPtr ctxt);
+static xmlChar * xmlParseAttValueInternal(xmlParserCtxtPtr ctxt,
+                                          int *len, int *alloc, int normalize);
+
+/**
+ * xmlParseName:
+ * @ctxt:  an XML parser context
+ *
+ * parse an XML name.
+ *
+ * [4] NameChar ::= Letter | Digit | '.' | '-' | '_' | ':' |
+ *                  CombiningChar | Extender
+ *
+ * [5] Name ::= (Letter | '_' | ':') (NameChar)*
+ *
+ * [6] Names ::= Name (S Name)*
+ *
+ * Returns the Name parsed or NULL
+ */
+
+const xmlChar *
+xmlParseName(xmlParserCtxtPtr ctxt) {
+    const xmlChar *in;
+    const xmlChar *ret;
+    int count = 0;
+
+    GROW;
+
+    /*
+     * Accelerator for simple ASCII names
+     */
+    in = ctxt->input->cur;
+    if (((*in >= 0x61) && (*in <= 0x7A)) ||
+	((*in >= 0x41) && (*in <= 0x5A)) ||
+	(*in == '_') || (*in == ':')) {
+	in++;
+	while (((*in >= 0x61) && (*in <= 0x7A)) ||
+	       ((*in >= 0x41) && (*in <= 0x5A)) ||
+	       ((*in >= 0x30) && (*in <= 0x39)) ||
+	       (*in == '_') || (*in == '-') ||
+	       (*in == ':') || (*in == '.'))
+	    in++;
+	if ((*in > 0) && (*in < 0x80)) {
+	    count = in - ctxt->input->cur;
+	    ret = xmlDictLookup(ctxt->dict, ctxt->input->cur, count);
+	    ctxt->input->cur = in;
+	    ctxt->nbChars += count;
+	    ctxt->input->col += count;
+	    if (ret == NULL)
+	        xmlErrMemory(ctxt, NULL);
+	    return(ret);
+	}
+    }
+    return(xmlParseNameComplex(ctxt));
+}
+
+/**
+ * xmlParseNameAndCompare:
+ * @ctxt:  an XML parser context
+ *
+ * parse an XML name and compares for match
+ * (specialized for endtag parsing)
+ *
+ * Returns NULL for an illegal name, (xmlChar*) 1 for success
+ * and the name for mismatch
+ */
+
+static const xmlChar *
+xmlParseNameAndCompare(xmlParserCtxtPtr ctxt, xmlChar const *other) {
+    register const xmlChar *cmp = other;
+    register const xmlChar *in;
+    const xmlChar *ret;
+
+    GROW;
+    
+    in = ctxt->input->cur;
+    while (*in != 0 && *in == *cmp) {
+    	++in;
+	++cmp;
+    }
+    if (*cmp == 0 && (*in == '>' || IS_BLANK_CH (*in))) {
+    	/* success */
+	ctxt->input->cur = in;
+	return (const xmlChar*) 1;
+    }
+    /* failure (or end of input buffer), check with full function */
+    ret = xmlParseName (ctxt);
+    /* strings coming from the dictionnary direct compare possible */
+    if (ret == other) {
+	return (const xmlChar*) 1;
+    }
+    return ret;
+}
+
+static const xmlChar *
+xmlParseNameComplex(xmlParserCtxtPtr ctxt) {
+    int len = 0, l;
+    int c;
+    int count = 0;
+
+    /*
+     * Handler for more complex cases
+     */
+    GROW;
+    c = CUR_CHAR(l);
+    if ((c == ' ') || (c == '>') || (c == '/') || /* accelerators */
+	(!IS_LETTER(c) && (c != '_') &&
+         (c != ':'))) {
+	return(NULL);
+    }
+
+    while ((c != ' ') && (c != '>') && (c != '/') && /* test bigname.xml */
+	   ((IS_LETTER(c)) || (IS_DIGIT(c)) ||
+            (c == '.') || (c == '-') ||
+	    (c == '_') || (c == ':') || 
+	    (IS_COMBINING(c)) ||
+	    (IS_EXTENDER(c)))) {
+	if (count++ > 100) {
+	    count = 0;
+	    GROW;
+	}
+	len += l;
+	NEXTL(l);
+	c = CUR_CHAR(l);
+    }
+    return(xmlDictLookup(ctxt->dict, ctxt->input->cur - len, len));
+}
+
+/**
+ * xmlParseStringName:
+ * @ctxt:  an XML parser context
+ * @str:  a pointer to the string pointer (IN/OUT)
+ *
+ * parse an XML name.
+ *
+ * [4] NameChar ::= Letter | Digit | '.' | '-' | '_' | ':' |
+ *                  CombiningChar | Extender
+ *
+ * [5] Name ::= (Letter | '_' | ':') (NameChar)*
+ *
+ * [6] Names ::= Name (S Name)*
+ *
+ * Returns the Name parsed or NULL. The @str pointer 
+ * is updated to the current location in the string.
+ */
+
+static xmlChar *
+xmlParseStringName(xmlParserCtxtPtr ctxt, const xmlChar** str) {
+    xmlChar buf[XML_MAX_NAMELEN + 5];
+    const xmlChar *cur = *str;
+    int len = 0, l;
+    int c;
+
+    c = CUR_SCHAR(cur, l);
+    if (!IS_LETTER(c) && (c != '_') &&
+        (c != ':')) {
+	return(NULL);
+    }
+
+    while ((IS_LETTER(c)) || (IS_DIGIT(c)) || /* test bigentname.xml */
+           (c == '.') || (c == '-') ||
+	   (c == '_') || (c == ':') || 
+	   (IS_COMBINING(c)) ||
+	   (IS_EXTENDER(c))) {
+	COPY_BUF(l,buf,len,c);
+	cur += l;
+	c = CUR_SCHAR(cur, l);
+	if (len >= XML_MAX_NAMELEN) { /* test bigentname.xml */
+	    /*
+	     * Okay someone managed to make a huge name, so he's ready to pay
+	     * for the processing speed.
+	     */
+	    xmlChar *buffer;
+	    int max = len * 2;
+	    
+	    buffer = (xmlChar *) xmlMallocAtomic(max * sizeof(xmlChar));
+	    if (buffer == NULL) {
+	        xmlErrMemory(ctxt, NULL);
+		return(NULL);
+	    }
+	    memcpy(buffer, buf, len);
+	    while ((IS_LETTER(c)) || (IS_DIGIT(c)) ||
+	             /* test bigentname.xml */
+		   (c == '.') || (c == '-') ||
+		   (c == '_') || (c == ':') || 
+		   (IS_COMBINING(c)) ||
+		   (IS_EXTENDER(c))) {
+		if (len + 10 > max) {
+		    max *= 2;
+		    buffer = (xmlChar *) xmlRealloc(buffer,
+			                            max * sizeof(xmlChar));
+		    if (buffer == NULL) {
+			xmlErrMemory(ctxt, NULL);
+			return(NULL);
+		    }
+		}
+		COPY_BUF(l,buffer,len,c);
+		cur += l;
+		c = CUR_SCHAR(cur, l);
+	    }
+	    buffer[len] = 0;
+	    *str = cur;
+	    return(buffer);
+	}
+    }
+    *str = cur;
+    return(xmlStrndup(buf, len));
+}
+
+/**
+ * xmlParseNmtoken:
+ * @ctxt:  an XML parser context
+ * 
+ * parse an XML Nmtoken.
+ *
+ * [7] Nmtoken ::= (NameChar)+
+ *
+ * [8] Nmtokens ::= Nmtoken (S Nmtoken)*
+ *
+ * Returns the Nmtoken parsed or NULL
+ */
+
+xmlChar *
+xmlParseNmtoken(xmlParserCtxtPtr ctxt) {
+    xmlChar buf[XML_MAX_NAMELEN + 5];
+    int len = 0, l;
+    int c;
+    int count = 0;
+
+    GROW;
+    c = CUR_CHAR(l);
+
+    while ((IS_LETTER(c)) || (IS_DIGIT(c)) || /* test bigtoken.xml */
+           (c == '.') || (c == '-') ||
+	   (c == '_') || (c == ':') || 
+	   (IS_COMBINING(c)) ||
+	   (IS_EXTENDER(c))) {
+	if (count++ > 100) {
+	    count = 0;
+	    GROW;
+	}
+	COPY_BUF(l,buf,len,c);
+	NEXTL(l);
+	c = CUR_CHAR(l);
+	if (len >= XML_MAX_NAMELEN) {
+	    /*
+	     * Okay someone managed to make a huge token, so he's ready to pay
+	     * for the processing speed.
+	     */
+	    xmlChar *buffer;
+	    int max = len * 2;
+	    
+	    buffer = (xmlChar *) xmlMallocAtomic(max * sizeof(xmlChar));
+	    if (buffer == NULL) {
+	        xmlErrMemory(ctxt, NULL);
+		return(NULL);
+	    }
+	    memcpy(buffer, buf, len);
+	    while ((IS_LETTER(c)) || (IS_DIGIT(c)) || /* test bigtoken.xml */
+		   (c == '.') || (c == '-') ||
+		   (c == '_') || (c == ':') || 
+		   (IS_COMBINING(c)) ||
+		   (IS_EXTENDER(c))) {
+		if (count++ > 100) {
+		    count = 0;
+		    GROW;
+		}
+		if (len + 10 > max) {
+		    max *= 2;
+		    buffer = (xmlChar *) xmlRealloc(buffer,
+			                            max * sizeof(xmlChar));
+		    if (buffer == NULL) {
+			xmlErrMemory(ctxt, NULL);
+			return(NULL);
+		    }
+		}
+		COPY_BUF(l,buffer,len,c);
+		NEXTL(l);
+		c = CUR_CHAR(l);
+	    }
+	    buffer[len] = 0;
+	    return(buffer);
+	}
+    }
+    if (len == 0)
+        return(NULL);
+    return(xmlStrndup(buf, len));
+}
+
+/**
+ * xmlParseEntityValue:
+ * @ctxt:  an XML parser context
+ * @orig:  if non-NULL store a copy of the original entity value
+ *
+ * parse a value for ENTITY declarations
+ *
+ * [9] EntityValue ::= '"' ([^%&"] | PEReference | Reference)* '"' |
+ *	               "'" ([^%&'] | PEReference | Reference)* "'"
+ *
+ * Returns the EntityValue parsed with reference substituted or NULL
+ */
+
+xmlChar *
+xmlParseEntityValue(xmlParserCtxtPtr ctxt, xmlChar **orig) {
+    xmlChar *buf = NULL;
+    int len = 0;
+    int size = XML_PARSER_BUFFER_SIZE;
+    int c, l;
+    xmlChar stop;
+    xmlChar *ret = NULL;
+    const xmlChar *cur = NULL;
+    xmlParserInputPtr input;
+
+    if (RAW == '"') stop = '"';
+    else if (RAW == '\'') stop = '\'';
+    else {
+	xmlFatalErr(ctxt, XML_ERR_ENTITY_NOT_STARTED, NULL);
+	return(NULL);
+    }
+    buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar));
+    if (buf == NULL) {
+	xmlErrMemory(ctxt, NULL);
+	return(NULL);
+    }
+
+    /*
+     * The content of the entity definition is copied in a buffer.
+     */
+
+    ctxt->instate = XML_PARSER_ENTITY_VALUE;
+    input = ctxt->input;
+    GROW;
+    NEXT;
+    c = CUR_CHAR(l);
+    /*
+     * NOTE: 4.4.5 Included in Literal
+     * When a parameter entity reference appears in a literal entity
+     * value, ... a single or double quote character in the replacement
+     * text is always treated as a normal data character and will not
+     * terminate the literal. 
+     * In practice it means we stop the loop only when back at parsing
+     * the initial entity and the quote is found
+     */
+    while ((IS_CHAR(c)) && ((c != stop) || /* checked */
+	   (ctxt->input != input))) {
+	if (len + 5 >= size) {
+	    size *= 2;
+	    buf = (xmlChar *) xmlRealloc(buf, size * sizeof(xmlChar));
+	    if (buf == NULL) {
+		xmlErrMemory(ctxt, NULL);
+		return(NULL);
+	    }
+	}
+	COPY_BUF(l,buf,len,c);
+	NEXTL(l);
+	/*
+	 * Pop-up of finished entities.
+	 */
+	while ((RAW == 0) && (ctxt->inputNr > 1)) /* non input consuming */
+	    xmlPopInput(ctxt);
+
+	GROW;
+	c = CUR_CHAR(l);
+	if (c == 0) {
+	    GROW;
+	    c = CUR_CHAR(l);
+	}
+    }
+    buf[len] = 0;
+
+    /*
+     * Raise problem w.r.t. '&' and '%' being used in non-entities
+     * reference constructs. Note Charref will be handled in
+     * xmlStringDecodeEntities()
+     */
+    cur = buf;
+    while (*cur != 0) { /* non input consuming */
+	if ((*cur == '%') || ((*cur == '&') && (cur[1] != '#'))) {
+	    xmlChar *name;
+	    xmlChar tmp = *cur;
+
+	    cur++;
+	    name = xmlParseStringName(ctxt, &cur);
+            if ((name == NULL) || (*cur != ';')) {
+		xmlFatalErrMsgInt(ctxt, XML_ERR_ENTITY_CHAR_ERROR,
+	    "EntityValue: '%c' forbidden except for entities references\n",
+	                          tmp);
+	    }
+	    if ((tmp == '%') && (ctxt->inSubset == 1) &&
+		(ctxt->inputNr == 1)) {
+		xmlFatalErr(ctxt, XML_ERR_ENTITY_PE_INTERNAL, NULL);
+	    }
+	    if (name != NULL)
+		xmlFree(name);
+	    if (*cur == 0)
+	        break;
+	}
+	cur++;
+    }
+
+    /*
+     * Then PEReference entities are substituted.
+     */
+    if (c != stop) {
+	xmlFatalErr(ctxt, XML_ERR_ENTITY_NOT_FINISHED, NULL);
+	xmlFree(buf);
+    } else {
+	NEXT;
+	/*
+	 * NOTE: 4.4.7 Bypassed
+	 * When a general entity reference appears in the EntityValue in
+	 * an entity declaration, it is bypassed and left as is.
+	 * so XML_SUBSTITUTE_REF is not set here.
+	 */
+	ret = xmlStringDecodeEntities(ctxt, buf, XML_SUBSTITUTE_PEREF,
+				      0, 0, 0);
+	if (orig != NULL) 
+	    *orig = buf;
+	else
+	    xmlFree(buf);
+    }
+    
+    return(ret);
+}
+
+/**
+ * xmlParseAttValueComplex:
+ * @ctxt:  an XML parser context
+ * @len:   the resulting attribute len
+ * @normalize:  wether to apply the inner normalization
+ *
+ * parse a value for an attribute, this is the fallback function
+ * of xmlParseAttValue() when the attribute parsing requires handling
+ * of non-ASCII characters, or normalization compaction.
+ *
+ * Returns the AttValue parsed or NULL. The value has to be freed by the caller.
+ */
+static xmlChar *
+xmlParseAttValueComplex(xmlParserCtxtPtr ctxt, int *attlen, int normalize) {
+    xmlChar limit = 0;
+    xmlChar *buf = NULL;
+    int len = 0;
+    int buf_size = 0;
+    int c, l, in_space = 0;
+    xmlChar *current = NULL;
+    xmlEntityPtr ent;
+
+    if (NXT(0) == '"') {
+	ctxt->instate = XML_PARSER_ATTRIBUTE_VALUE;
+	limit = '"';
+        NEXT;
+    } else if (NXT(0) == '\'') {
+	limit = '\'';
+	ctxt->instate = XML_PARSER_ATTRIBUTE_VALUE;
+        NEXT;
+    } else {
+	xmlFatalErr(ctxt, XML_ERR_ATTRIBUTE_NOT_STARTED, NULL);
+	return(NULL);
+    }
+    
+    /*
+     * allocate a translation buffer.
+     */
+    buf_size = XML_PARSER_BUFFER_SIZE;
+    buf = (xmlChar *) xmlMallocAtomic(buf_size * sizeof(xmlChar));
+    if (buf == NULL) goto mem_error;
+
+    /*
+     * OK loop until we reach one of the ending char or a size limit.
+     */
+    c = CUR_CHAR(l);
+    while ((NXT(0) != limit) && /* checked */
+	   (c != '<')) {
+	if (c == 0) break;
+	if (c == '&') {
+	    in_space = 0;
+	    if (NXT(1) == '#') {
+		int val = xmlParseCharRef(ctxt);
+
+		if (val == '&') {
+		    if (ctxt->replaceEntities) {
+			if (len > buf_size - 10) {
+			    growBuffer(buf);
+			}
+			buf[len++] = '&';
+		    } else {
+			/*
+			 * The reparsing will be done in xmlStringGetNodeList()
+			 * called by the attribute() function in SAX.c
+			 */
+			if (len > buf_size - 10) {
+			    growBuffer(buf);
+			}
+			buf[len++] = '&';
+			buf[len++] = '#';
+			buf[len++] = '3';
+			buf[len++] = '8';
+			buf[len++] = ';';
+		    }
+		} else {
+		    if (len > buf_size - 10) {
+			growBuffer(buf);
+		    }
+		    len += xmlCopyChar(0, &buf[len], val);
+		}
+	    } else {
+		ent = xmlParseEntityRef(ctxt);
+		if ((ent != NULL) &&
+		    (ent->etype == XML_INTERNAL_PREDEFINED_ENTITY)) {
+		    if (len > buf_size - 10) {
+			growBuffer(buf);
+		    }
+		    if ((ctxt->replaceEntities == 0) &&
+		        (ent->content[0] == '&')) {
+			buf[len++] = '&';
+			buf[len++] = '#';
+			buf[len++] = '3';
+			buf[len++] = '8';
+			buf[len++] = ';';
+		    } else {
+			buf[len++] = ent->content[0];
+		    }
+		} else if ((ent != NULL) && 
+		           (ctxt->replaceEntities != 0)) {
+		    xmlChar *rep;
+
+		    if (ent->etype != XML_INTERNAL_PREDEFINED_ENTITY) {
+			rep = xmlStringDecodeEntities(ctxt, ent->content,
+						      XML_SUBSTITUTE_REF,
+						      0, 0, 0);
+			if (rep != NULL) {
+			    current = rep;
+			    while (*current != 0) { /* non input consuming */
+				buf[len++] = *current++;
+				if (len > buf_size - 10) {
+				    growBuffer(buf);
+				}
+			    }
+			    xmlFree(rep);
+			}
+		    } else {
+			if (len > buf_size - 10) {
+			    growBuffer(buf);
+			}
+			if (ent->content != NULL)
+			    buf[len++] = ent->content[0];
+		    }
+		} else if (ent != NULL) {
+		    int i = xmlStrlen(ent->name);
+		    const xmlChar *cur = ent->name;
+
+		    /*
+		     * This may look absurd but is needed to detect
+		     * entities problems
+		     */
+		    if ((ent->etype != XML_INTERNAL_PREDEFINED_ENTITY) &&
+			(ent->content != NULL)) {
+			xmlChar *rep;
+			rep = xmlStringDecodeEntities(ctxt, ent->content,
+						      XML_SUBSTITUTE_REF, 0, 0, 0);
+			if (rep != NULL)
+			    xmlFree(rep);
+		    }
+
+		    /*
+		     * Just output the reference
+		     */
+		    buf[len++] = '&';
+		    if (len > buf_size - i - 10) {
+			growBuffer(buf);
+		    }
+		    for (;i > 0;i--)
+			buf[len++] = *cur++;
+		    buf[len++] = ';';
+		}
+	    }
+	} else {
+	    if ((c == 0x20) || (c == 0xD) || (c == 0xA) || (c == 0x9)) {
+	        if ((len != 0) || (!normalize)) {
+		    if ((!normalize) || (!in_space)) {
+			COPY_BUF(l,buf,len,0x20);
+			if (len > buf_size - 10) {
+			    growBuffer(buf);
+			}
+		    }
+		    in_space = 1;
+		}
+	    } else {
+	        in_space = 0;
+		COPY_BUF(l,buf,len,c);
+		if (len > buf_size - 10) {
+		    growBuffer(buf);
+		}
+	    }
+	    NEXTL(l);
+	}
+	GROW;
+	c = CUR_CHAR(l);
+    }
+    if ((in_space) && (normalize)) {
+        while (buf[len - 1] == 0x20) len--;
+    }
+    buf[len] = 0;
+    if (RAW == '<') {
+	xmlFatalErr(ctxt, XML_ERR_LT_IN_ATTRIBUTE, NULL);
+    } else if (RAW != limit) {
+        xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
+	               "AttValue: ' expected\n");
+    } else
+	NEXT;
+    if (attlen != NULL) *attlen = len;
+    return(buf);
+
+mem_error:
+    xmlErrMemory(ctxt, NULL);
+    return(NULL);
+}
+
+/**
+ * xmlParseAttValue:
+ * @ctxt:  an XML parser context
+ *
+ * parse a value for an attribute
+ * Note: the parser won't do substitution of entities here, this
+ * will be handled later in xmlStringGetNodeList
+ *
+ * [10] AttValue ::= '"' ([^<&"] | Reference)* '"' |
+ *                   "'" ([^<&'] | Reference)* "'"
+ *
+ * 3.3.3 Attribute-Value Normalization:
+ * Before the value of an attribute is passed to the application or
+ * checked for validity, the XML processor must normalize it as follows: 
+ * - a character reference is processed by appending the referenced
+ *   character to the attribute value
+ * - an entity reference is processed by recursively processing the
+ *   replacement text of the entity 
+ * - a whitespace character (#x20, #xD, #xA, #x9) is processed by
+ *   appending #x20 to the normalized value, except that only a single
+ *   #x20 is appended for a "#xD#xA" sequence that is part of an external
+ *   parsed entity or the literal entity value of an internal parsed entity 
+ * - other characters are processed by appending them to the normalized value 
+ * If the declared value is not CDATA, then the XML processor must further
+ * process the normalized attribute value by discarding any leading and
+ * trailing space (#x20) characters, and by replacing sequences of space
+ * (#x20) characters by a single space (#x20) character.  
+ * All attributes for which no declaration has been read should be treated
+ * by a non-validating parser as if declared CDATA.
+ *
+ * Returns the AttValue parsed or NULL. The value has to be freed by the caller.
+ */
+
+
+xmlChar *
+xmlParseAttValue(xmlParserCtxtPtr ctxt) {
+    return(xmlParseAttValueInternal(ctxt, NULL, NULL, 0));
+}
+
+/**
+ * xmlParseSystemLiteral:
+ * @ctxt:  an XML parser context
+ * 
+ * parse an XML Literal
+ *
+ * [11] SystemLiteral ::= ('"' [^"]* '"') | ("'" [^']* "'")
+ *
+ * Returns the SystemLiteral parsed or NULL
+ */
+
+xmlChar *
+xmlParseSystemLiteral(xmlParserCtxtPtr ctxt) {
+    xmlChar *buf = NULL;
+    int len = 0;
+    int size = XML_PARSER_BUFFER_SIZE;
+    int cur, l;
+    xmlChar stop;
+    int state = ctxt->instate;
+    int count = 0;
+
+    SHRINK;
+    if (RAW == '"') {
+        NEXT;
+	stop = '"';
+    } else if (RAW == '\'') {
+        NEXT;
+	stop = '\'';
+    } else {
+	xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_STARTED, NULL);
+	return(NULL);
+    }
+    
+    buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar));
+    if (buf == NULL) {
+        xmlErrMemory(ctxt, NULL);
+	return(NULL);
+    }
+    ctxt->instate = XML_PARSER_SYSTEM_LITERAL;
+    cur = CUR_CHAR(l);
+    while ((IS_CHAR(cur)) && (cur != stop)) { /* checked */
+	if (len + 5 >= size) {
+	    size *= 2;
+	    buf = (xmlChar *) xmlRealloc(buf, size * sizeof(xmlChar));
+	    if (buf == NULL) {
+		xmlErrMemory(ctxt, NULL);
+		ctxt->instate = (xmlParserInputState) state;
+		return(NULL);
+	    }
+	}
+	count++;
+	if (count > 50) {
+	    GROW;
+	    count = 0;
+	}
+	COPY_BUF(l,buf,len,cur);
+	NEXTL(l);
+	cur = CUR_CHAR(l);
+	if (cur == 0) {
+	    GROW;
+	    SHRINK;
+	    cur = CUR_CHAR(l);
+	}
+    }
+    buf[len] = 0;
+    ctxt->instate = (xmlParserInputState) state;
+    if (!IS_CHAR(cur)) {
+	xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_FINISHED, NULL);
+    } else {
+	NEXT;
+    }
+    return(buf);
+}
+
+/**
+ * xmlParsePubidLiteral:
+ * @ctxt:  an XML parser context
+ *
+ * parse an XML public literal
+ *
+ * [12] PubidLiteral ::= '"' PubidChar* '"' | "'" (PubidChar - "'")* "'"
+ *
+ * Returns the PubidLiteral parsed or NULL.
+ */
+
+xmlChar *
+xmlParsePubidLiteral(xmlParserCtxtPtr ctxt) {
+    xmlChar *buf = NULL;
+    int len = 0;
+    int size = XML_PARSER_BUFFER_SIZE;
+    xmlChar cur;
+    xmlChar stop;
+    int count = 0;
+    xmlParserInputState oldstate = ctxt->instate;
+
+    SHRINK;
+    if (RAW == '"') {
+        NEXT;
+	stop = '"';
+    } else if (RAW == '\'') {
+        NEXT;
+	stop = '\'';
+    } else {
+	xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_STARTED, NULL);
+	return(NULL);
+    }
+    buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar));
+    if (buf == NULL) {
+	xmlErrMemory(ctxt, NULL);
+	return(NULL);
+    }
+    ctxt->instate = XML_PARSER_PUBLIC_LITERAL;
+    cur = CUR;
+    while ((IS_PUBIDCHAR_CH(cur)) && (cur != stop)) { /* checked */
+	if (len + 1 >= size) {
+	    size *= 2;
+	    buf = (xmlChar *) xmlRealloc(buf, size * sizeof(xmlChar));
+	    if (buf == NULL) {
+		xmlErrMemory(ctxt, NULL);
+		return(NULL);
+	    }
+	}
+	buf[len++] = cur;
+	count++;
+	if (count > 50) {
+	    GROW;
+	    count = 0;
+	}
+	NEXT;
+	cur = CUR;
+	if (cur == 0) {
+	    GROW;
+	    SHRINK;
+	    cur = CUR;
+	}
+    }
+    buf[len] = 0;
+    if (cur != stop) {
+	xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_FINISHED, NULL);
+    } else {
+	NEXT;
+    }
+    ctxt->instate = oldstate;
+    return(buf);
+}
+
+void xmlParseCharDataComplex(xmlParserCtxtPtr ctxt, int cdata);
+/**
+ * xmlParseCharData:
+ * @ctxt:  an XML parser context
+ * @cdata:  int indicating whether we are within a CDATA section
+ *
+ * parse a CharData section.
+ * if we are within a CDATA section ']]>' marks an end of section.
+ *
+ * The right angle bracket (>) may be represented using the string "&gt;",
+ * and must, for compatibility, be escaped using "&gt;" or a character
+ * reference when it appears in the string "]]>" in content, when that
+ * string is not marking the end of a CDATA section. 
+ *
+ * [14] CharData ::= [^<&]* - ([^<&]* ']]>' [^<&]*)
+ */
+
+void
+xmlParseCharData(xmlParserCtxtPtr ctxt, int cdata) {
+    const xmlChar *in;
+    int nbchar = 0;
+    int line = ctxt->input->line;
+    int col = ctxt->input->col;
+
+    SHRINK;
+    GROW;
+    /*
+     * Accelerated common case where input don't need to be
+     * modified before passing it to the handler.
+     */
+    if (!cdata) {
+	in = ctxt->input->cur;
+	do {
+get_more_space:
+	    while (*in == 0x20) in++;
+	    if (*in == 0xA) {
+		ctxt->input->line++;
+		in++;
+		while (*in == 0xA) {
+		    ctxt->input->line++;
+		    in++;
+		}
+		goto get_more_space;
+	    }
+	    if (*in == '<') {
+		nbchar = in - ctxt->input->cur;
+		if (nbchar > 0) {
+		    const xmlChar *tmp = ctxt->input->cur;
+		    ctxt->input->cur = in;
+
+		    if (ctxt->sax->ignorableWhitespace !=
+		        ctxt->sax->characters) {
+			if (areBlanks(ctxt, tmp, nbchar, 1)) {
+			    ctxt->sax->ignorableWhitespace(ctxt->userData,
+						   tmp, nbchar);
+			} else if (ctxt->sax->characters != NULL)
+			    ctxt->sax->characters(ctxt->userData,
+						  tmp, nbchar);
+		    } else if (ctxt->sax->characters != NULL) {
+			ctxt->sax->characters(ctxt->userData,
+					      tmp, nbchar);
+		    }
+		}
+		return;
+	    }
+get_more:
+	    while (((*in > ']') && (*in <= 0x7F)) ||
+	           ((*in > '&') && (*in < '<')) ||
+	           ((*in > '<') && (*in < ']')) ||
+		   ((*in >= 0x20) && (*in < '&')) ||
+		   (*in == 0x09))
+		in++;
+	    if (*in == 0xA) {
+		ctxt->input->line++;
+		in++;
+		while (*in == 0xA) {
+		    ctxt->input->line++;
+		    in++;
+		}
+		goto get_more;
+	    }
+	    if (*in == ']') {
+		if ((in[1] == ']') && (in[2] == '>')) {
+		    xmlFatalErr(ctxt, XML_ERR_MISPLACED_CDATA_END, NULL);
+		    ctxt->input->cur = in;
+		    return;
+		}
+		in++;
+		goto get_more;
+	    }
+	    nbchar = in - ctxt->input->cur;
+	    if (nbchar > 0) {
+		if ((ctxt->sax->ignorableWhitespace !=
+		     ctxt->sax->characters) &&
+		    (IS_BLANK_CH(*ctxt->input->cur))) {
+		    const xmlChar *tmp = ctxt->input->cur;
+		    ctxt->input->cur = in;
+
+		    if (areBlanks(ctxt, tmp, nbchar, 0)) {
+			ctxt->sax->ignorableWhitespace(ctxt->userData,
+					       tmp, nbchar);
+		    } else if (ctxt->sax->characters != NULL)
+			ctxt->sax->characters(ctxt->userData,
+					      tmp, nbchar);
+                    line = ctxt->input->line;
+                    col = ctxt->input->col;
+		} else {
+		    if (ctxt->sax->characters != NULL)
+			ctxt->sax->characters(ctxt->userData,
+					      ctxt->input->cur, nbchar);
+                    line = ctxt->input->line;
+                    col = ctxt->input->col;
+		}
+	    }
+	    ctxt->input->cur = in;
+	    if (*in == 0xD) {
+		in++;
+		if (*in == 0xA) {
+		    ctxt->input->cur = in;
+		    in++;
+		    ctxt->input->line++;
+		    continue; /* while */
+		}
+		in--;
+	    }
+	    if (*in == '<') {
+		return;
+	    }
+	    if (*in == '&') {
+		return;
+	    }
+	    SHRINK;
+	    GROW;
+	    in = ctxt->input->cur;
+	} while (((*in >= 0x20) && (*in <= 0x7F)) || (*in == 0x09));
+	nbchar = 0;
+    }
+    ctxt->input->line = line;
+    ctxt->input->col = col;
+    xmlParseCharDataComplex(ctxt, cdata);
+}
+
+/**
+ * xmlParseCharDataComplex:
+ * @ctxt:  an XML parser context
+ * @cdata:  int indicating whether we are within a CDATA section
+ *
+ * parse a CharData section.this is the fallback function
+ * of xmlParseCharData() when the parsing requires handling
+ * of non-ASCII characters.
+ */
+void
+xmlParseCharDataComplex(xmlParserCtxtPtr ctxt, int cdata) {
+    xmlChar buf[XML_PARSER_BIG_BUFFER_SIZE + 5];
+    int nbchar = 0;
+    int cur, l;
+    int count = 0;
+
+    SHRINK;
+    GROW;
+    cur = CUR_CHAR(l);
+    while ((cur != '<') && /* checked */
+           (cur != '&') && 
+	   (IS_CHAR(cur))) /* test also done in xmlCurrentChar() */ {
+	if ((cur == ']') && (NXT(1) == ']') &&
+	    (NXT(2) == '>')) {
+	    if (cdata) break;
+	    else {
+		xmlFatalErr(ctxt, XML_ERR_MISPLACED_CDATA_END, NULL);
+	    }
+	}
+	COPY_BUF(l,buf,nbchar,cur);
+	if (nbchar >= XML_PARSER_BIG_BUFFER_SIZE) {
+	    buf[nbchar] = 0;
+
+	    /*
+	     * OK the segment is to be consumed as chars.
+	     */
+	    if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) {
+		if (areBlanks(ctxt, buf, nbchar, 0)) {
+		    if (ctxt->sax->ignorableWhitespace != NULL)
+			ctxt->sax->ignorableWhitespace(ctxt->userData,
+			                               buf, nbchar);
+		} else {
+		    if (ctxt->sax->characters != NULL)
+			ctxt->sax->characters(ctxt->userData, buf, nbchar);
+		}
+	    }
+	    nbchar = 0;
+	}
+	count++;
+	if (count > 50) {
+	    GROW;
+	    count = 0;
+	}
+	NEXTL(l);
+	cur = CUR_CHAR(l);
+    }
+    if (nbchar != 0) {
+        buf[nbchar] = 0;
+	/*
+	 * OK the segment is to be consumed as chars.
+	 */
+	if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) {
+	    if (areBlanks(ctxt, buf, nbchar, 0)) {
+		if (ctxt->sax->ignorableWhitespace != NULL)
+		    ctxt->sax->ignorableWhitespace(ctxt->userData, buf, nbchar);
+	    } else {
+		if (ctxt->sax->characters != NULL)
+		    ctxt->sax->characters(ctxt->userData, buf, nbchar);
+	    }
+	}
+    }
+}
+
+/**
+ * xmlParseExternalID:
+ * @ctxt:  an XML parser context
+ * @publicID:  a xmlChar** receiving PubidLiteral
+ * @strict: indicate whether we should restrict parsing to only
+ *          production [75], see NOTE below
+ *
+ * Parse an External ID or a Public ID
+ *
+ * NOTE: Productions [75] and [83] interact badly since [75] can generate
+ *       'PUBLIC' S PubidLiteral S SystemLiteral
+ *
+ * [75] ExternalID ::= 'SYSTEM' S SystemLiteral
+ *                   | 'PUBLIC' S PubidLiteral S SystemLiteral
+ *
+ * [83] PublicID ::= 'PUBLIC' S PubidLiteral
+ *
+ * Returns the function returns SystemLiteral and in the second
+ *                case publicID receives PubidLiteral, is strict is off
+ *                it is possible to return NULL and have publicID set.
+ */
+
+xmlChar *
+xmlParseExternalID(xmlParserCtxtPtr ctxt, xmlChar **publicID, int strict) {
+    xmlChar *URI = NULL;
+
+    SHRINK;
+
+    *publicID = NULL;
+    if (CMP6(CUR_PTR, 'S', 'Y', 'S', 'T', 'E', 'M')) {
+        SKIP(6);
+	if (!IS_BLANK_CH(CUR)) {
+	    xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
+	                   "Space required after 'SYSTEM'\n");
+	}
+        SKIP_BLANKS;
+	URI = xmlParseSystemLiteral(ctxt);
+	if (URI == NULL) {
+	    xmlFatalErr(ctxt, XML_ERR_URI_REQUIRED, NULL);
+        }
+    } else if (CMP6(CUR_PTR, 'P', 'U', 'B', 'L', 'I', 'C')) {
+        SKIP(6);
+	if (!IS_BLANK_CH(CUR)) {
+	    xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
+		    "Space required after 'PUBLIC'\n");
+	}
+        SKIP_BLANKS;
+	*publicID = xmlParsePubidLiteral(ctxt);
+	if (*publicID == NULL) {
+	    xmlFatalErr(ctxt, XML_ERR_PUBID_REQUIRED, NULL);
+	}
+	if (strict) {
+	    /*
+	     * We don't handle [83] so "S SystemLiteral" is required.
+	     */
+	    if (!IS_BLANK_CH(CUR)) {
+		xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
+			"Space required after the Public Identifier\n");
+	    }
+	} else {
+	    /*
+	     * We handle [83] so we return immediately, if 
+	     * "S SystemLiteral" is not detected. From a purely parsing
+	     * point of view that's a nice mess.
+	     */
+	    const xmlChar *ptr;
+	    GROW;
+
+	    ptr = CUR_PTR;
+	    if (!IS_BLANK_CH(*ptr)) return(NULL);
+	    
+	    while (IS_BLANK_CH(*ptr)) ptr++; /* TODO: dangerous, fix ! */
+	    if ((*ptr != '\'') && (*ptr != '"')) return(NULL);
+	}
+        SKIP_BLANKS;
+	URI = xmlParseSystemLiteral(ctxt);
+	if (URI == NULL) {
+	    xmlFatalErr(ctxt, XML_ERR_URI_REQUIRED, NULL);
+        }
+    }
+    return(URI);
+}
+
+/**
+ * xmlParseComment:
+ * @ctxt:  an XML parser context
+ *
+ * Skip an XML (SGML) comment <!-- .... -->
+ *  The spec says that "For compatibility, the string "--" (double-hyphen)
+ *  must not occur within comments. "
+ *
+ * [15] Comment ::= '<!--' ((Char - '-') | ('-' (Char - '-')))* '-->'
+ */
+void
+xmlParseComment(xmlParserCtxtPtr ctxt) {
+    xmlChar *buf = NULL;
+    int len;
+    int size = XML_PARSER_BUFFER_SIZE;
+    int q, ql;
+    int r, rl;
+    int cur, l;
+    xmlParserInputState state;
+    xmlParserInputPtr input = ctxt->input;
+    int count = 0;
+
+    /*
+     * Check that there is a comment right here.
+     */
+    if ((RAW != '<') || (NXT(1) != '!') ||
+        (NXT(2) != '-') || (NXT(3) != '-')) return;
+
+    state = ctxt->instate;
+    ctxt->instate = XML_PARSER_COMMENT;
+    SHRINK;
+    SKIP(4);
+    buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar));
+    if (buf == NULL) {
+        xmlErrMemory(ctxt, NULL);
+	ctxt->instate = state;
+	return;
+    }
+    q = CUR_CHAR(ql);
+    if (q == 0)
+        goto not_terminated;
+    NEXTL(ql);
+    r = CUR_CHAR(rl);
+    if (r == 0)
+        goto not_terminated;
+    NEXTL(rl);
+    cur = CUR_CHAR(l);
+    if (cur == 0)
+        goto not_terminated;
+    len = 0;
+    while (IS_CHAR(cur) && /* checked */
+           ((cur != '>') ||
+	    (r != '-') || (q != '-'))) {
+	if ((r == '-') && (q == '-')) {
+	    xmlFatalErr(ctxt, XML_ERR_HYPHEN_IN_COMMENT, NULL);
+	}
+	if (len + 5 >= size) {
+	    size *= 2;
+	    buf = (xmlChar *) xmlRealloc(buf, size * sizeof(xmlChar));
+	    if (buf == NULL) {
+		xmlErrMemory(ctxt, NULL);
+		ctxt->instate = state;
+		return;
+	    }
+	}
+	COPY_BUF(ql,buf,len,q);
+	q = r;
+	ql = rl;
+	r = cur;
+	rl = l;
+
+	count++;
+	if (count > 50) {
+	    GROW;
+	    count = 0;
+	}
+	NEXTL(l);
+	cur = CUR_CHAR(l);
+	if (cur == 0) {
+	    SHRINK;
+	    GROW;
+	    cur = CUR_CHAR(l);
+	}
+    }
+    buf[len] = 0;
+    if (!IS_CHAR(cur)) {
+	xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED,
+	                     "Comment not terminated \n<!--%.50s\n", buf);
+	xmlFree(buf);
+    } else {
+	if (input != ctxt->input) {
+	    xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
+		"Comment doesn't start and stop in the same entity\n");
+	}
+        NEXT;
+	if ((ctxt->sax != NULL) && (ctxt->sax->comment != NULL) &&
+	    (!ctxt->disableSAX))
+	    ctxt->sax->comment(ctxt->userData, buf);
+	xmlFree(buf);
+    }
+    ctxt->instate = state;
+    return;
+not_terminated:
+    xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED,
+			 "Comment not terminated\n", NULL);
+    xmlFree(buf);
+}
+
+/**
+ * xmlParsePITarget:
+ * @ctxt:  an XML parser context
+ * 
+ * parse the name of a PI
+ *
+ * [17] PITarget ::= Name - (('X' | 'x') ('M' | 'm') ('L' | 'l'))
+ *
+ * Returns the PITarget name or NULL
+ */
+
+const xmlChar *
+xmlParsePITarget(xmlParserCtxtPtr ctxt) {
+    const xmlChar *name;
+
+    name = xmlParseName(ctxt);
+    if ((name != NULL) &&
+        ((name[0] == 'x') || (name[0] == 'X')) &&
+        ((name[1] == 'm') || (name[1] == 'M')) &&
+        ((name[2] == 'l') || (name[2] == 'L'))) {
+	int i;
+	if ((name[0] == 'x') && (name[1] == 'm') &&
+	    (name[2] == 'l') && (name[3] == 0)) {
+	    xmlFatalErrMsg(ctxt, XML_ERR_RESERVED_XML_NAME,
+		 "XML declaration allowed only at the start of the document\n");
+	    return(name);
+	} else if (name[3] == 0) {
+	    xmlFatalErr(ctxt, XML_ERR_RESERVED_XML_NAME, NULL);
+	    return(name);
+	}
+	for (i = 0;;i++) {
+	    if (xmlW3CPIs[i] == NULL) break;
+	    if (xmlStrEqual(name, (const xmlChar *)xmlW3CPIs[i]))
+	        return(name);
+	}
+	xmlWarningMsg(ctxt, XML_ERR_RESERVED_XML_NAME,
+		      "xmlParsePITarget: invalid name prefix 'xml'\n",
+		      NULL, NULL);
+    }
+    return(name);
+}
+
+#ifdef LIBXML_CATALOG_ENABLED
+/**
+ * xmlParseCatalogPI:
+ * @ctxt:  an XML parser context
+ * @catalog:  the PI value string
+ * 
+ * parse an XML Catalog Processing Instruction.
+ *
+ * <?oasis-xml-catalog catalog="http://example.com/catalog.xml"?>
+ *
+ * Occurs only if allowed by the user and if happening in the Misc
+ * part of the document before any doctype informations
+ * This will add the given catalog to the parsing context in order
+ * to be used if there is a resolution need further down in the document
+ */
+
+static void
+xmlParseCatalogPI(xmlParserCtxtPtr ctxt, const xmlChar *catalog) {
+    xmlChar *URL = NULL;
+    const xmlChar *tmp, *base;
+    xmlChar marker;
+
+    tmp = catalog;
+    while (IS_BLANK_CH(*tmp)) tmp++;
+    if (xmlStrncmp(tmp, BAD_CAST"catalog", 7))
+	goto error;
+    tmp += 7;
+    while (IS_BLANK_CH(*tmp)) tmp++;
+    if (*tmp != '=') {
+	return;
+    }
+    tmp++;
+    while (IS_BLANK_CH(*tmp)) tmp++;
+    marker = *tmp;
+    if ((marker != '\'') && (marker != '"'))
+	goto error;
+    tmp++;
+    base = tmp;
+    while ((*tmp != 0) && (*tmp != marker)) tmp++;
+    if (*tmp == 0)
+	goto error;
+    URL = xmlStrndup(base, tmp - base);
+    tmp++;
+    while (IS_BLANK_CH(*tmp)) tmp++;
+    if (*tmp != 0)
+	goto error;
+
+    if (URL != NULL) {
+	ctxt->catalogs = xmlCatalogAddLocal(ctxt->catalogs, URL);
+	xmlFree(URL);
+    }
+    return;
+
+error:
+    xmlWarningMsg(ctxt, XML_WAR_CATALOG_PI,
+	          "Catalog PI syntax error: %s\n",
+		  catalog, NULL);
+    if (URL != NULL)
+	xmlFree(URL);
+}
+#endif
+
+/**
+ * xmlParsePI:
+ * @ctxt:  an XML parser context
+ * 
+ * parse an XML Processing Instruction.
+ *
+ * [16] PI ::= '<?' PITarget (S (Char* - (Char* '?>' Char*)))? '?>'
+ *
+ * The processing is transfered to SAX once parsed.
+ */
+
+void
+xmlParsePI(xmlParserCtxtPtr ctxt) {
+    xmlChar *buf = NULL;
+    int len = 0;
+    int size = XML_PARSER_BUFFER_SIZE;
+    int cur, l;
+    const xmlChar *target;
+    xmlParserInputState state;
+    int count = 0;
+
+    if ((RAW == '<') && (NXT(1) == '?')) {
+	xmlParserInputPtr input = ctxt->input;
+	state = ctxt->instate;
+        ctxt->instate = XML_PARSER_PI;
+	/*
+	 * this is a Processing Instruction.
+	 */
+	SKIP(2);
+	SHRINK;
+
+	/*
+	 * Parse the target name and check for special support like
+	 * namespace.
+	 */
+        target = xmlParsePITarget(ctxt);
+	if (target != NULL) {
+	    if ((RAW == '?') && (NXT(1) == '>')) {
+		if (input != ctxt->input) {
+		    xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
+	    "PI declaration doesn't start and stop in the same entity\n");
+		}
+		SKIP(2);
+
+		/*
+		 * SAX: PI detected.
+		 */
+		if ((ctxt->sax) && (!ctxt->disableSAX) &&
+		    (ctxt->sax->processingInstruction != NULL))
+		    ctxt->sax->processingInstruction(ctxt->userData,
+		                                     target, NULL);
+		ctxt->instate = state;
+		return;
+	    }
+	    buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar));
+	    if (buf == NULL) {
+		xmlErrMemory(ctxt, NULL);
+		ctxt->instate = state;
+		return;
+	    }
+	    cur = CUR;
+	    if (!IS_BLANK(cur)) {
+		xmlFatalErrMsgStr(ctxt, XML_ERR_SPACE_REQUIRED,
+			  "ParsePI: PI %s space expected\n", target);
+	    }
+            SKIP_BLANKS;
+	    cur = CUR_CHAR(l);
+	    while (IS_CHAR(cur) && /* checked */
+		   ((cur != '?') || (NXT(1) != '>'))) {
+		if (len + 5 >= size) {
+		    size *= 2;
+		    buf = (xmlChar *) xmlRealloc(buf, size * sizeof(xmlChar));
+		    if (buf == NULL) {
+			xmlErrMemory(ctxt, NULL);
+			ctxt->instate = state;
+			return;
+		    }
+		}
+		count++;
+		if (count > 50) {
+		    GROW;
+		    count = 0;
+		}
+		COPY_BUF(l,buf,len,cur);
+		NEXTL(l);
+		cur = CUR_CHAR(l);
+		if (cur == 0) {
+		    SHRINK;
+		    GROW;
+		    cur = CUR_CHAR(l);
+		}
+	    }
+	    buf[len] = 0;
+	    if (cur != '?') {
+		xmlFatalErrMsgStr(ctxt, XML_ERR_PI_NOT_FINISHED,
+		      "ParsePI: PI %s never end ...\n", target);
+	    } else {
+		if (input != ctxt->input) {
+		    xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
+	    "PI declaration doesn't start and stop in the same entity\n");
+		}
+		SKIP(2);
+
+#ifdef LIBXML_CATALOG_ENABLED
+		if (((state == XML_PARSER_MISC) ||
+	             (state == XML_PARSER_START)) &&
+		    (xmlStrEqual(target, XML_CATALOG_PI))) {
+		    xmlCatalogAllow allow = xmlCatalogGetDefaults();
+		    if ((allow == XML_CATA_ALLOW_DOCUMENT) ||
+			(allow == XML_CATA_ALLOW_ALL))
+			xmlParseCatalogPI(ctxt, buf);
+		}
+#endif
+
+
+		/*
+		 * SAX: PI detected.
+		 */
+		if ((ctxt->sax) && (!ctxt->disableSAX) &&
+		    (ctxt->sax->processingInstruction != NULL))
+		    ctxt->sax->processingInstruction(ctxt->userData,
+		                                     target, buf);
+	    }
+	    xmlFree(buf);
+	} else {
+	    xmlFatalErr(ctxt, XML_ERR_PI_NOT_STARTED, NULL);
+	}
+	ctxt->instate = state;
+    }
+}
+
+/**
+ * xmlParseNotationDecl:
+ * @ctxt:  an XML parser context
+ *
+ * parse a notation declaration
+ *
+ * [82] NotationDecl ::= '<!NOTATION' S Name S (ExternalID |  PublicID) S? '>'
+ *
+ * Hence there is actually 3 choices:
+ *     'PUBLIC' S PubidLiteral
+ *     'PUBLIC' S PubidLiteral S SystemLiteral
+ * and 'SYSTEM' S SystemLiteral
+ *
+ * See the NOTE on xmlParseExternalID().
+ */
+
+void
+xmlParseNotationDecl(xmlParserCtxtPtr ctxt) {
+    const xmlChar *name;
+    xmlChar *Pubid;
+    xmlChar *Systemid;
+    
+    if (CMP10(CUR_PTR, '<', '!', 'N', 'O', 'T', 'A', 'T', 'I', 'O', 'N')) {
+	xmlParserInputPtr input = ctxt->input;
+	SHRINK;
+	SKIP(10);
+	if (!IS_BLANK_CH(CUR)) {
+	    xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
+			   "Space required after '<!NOTATION'\n");
+	    return;
+	}
+	SKIP_BLANKS;
+
+        name = xmlParseName(ctxt);
+	if (name == NULL) {
+	    xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_STARTED, NULL);
+	    return;
+	}
+	if (!IS_BLANK_CH(CUR)) {
+	    xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
+		     "Space required after the NOTATION name'\n");
+	    return;
+	}
+	SKIP_BLANKS;
+
+	/*
+	 * Parse the IDs.
+	 */
+	Systemid = xmlParseExternalID(ctxt, &Pubid, 0);
+	SKIP_BLANKS;
+
+	if (RAW == '>') {
+	    if (input != ctxt->input) {
+		xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
+	"Notation declaration doesn't start and stop in the same entity\n");
+	    }
+	    NEXT;
+	    if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
+		(ctxt->sax->notationDecl != NULL))
+		ctxt->sax->notationDecl(ctxt->userData, name, Pubid, Systemid);
+	} else {
+	    xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_FINISHED, NULL);
+	}
+	if (Systemid != NULL) xmlFree(Systemid);
+	if (Pubid != NULL) xmlFree(Pubid);
+    }
+}
+
+/**
+ * xmlParseEntityDecl:
+ * @ctxt:  an XML parser context
+ *
+ * parse <!ENTITY declarations
+ *
+ * [70] EntityDecl ::= GEDecl | PEDecl
+ *
+ * [71] GEDecl ::= '<!ENTITY' S Name S EntityDef S? '>'
+ *
+ * [72] PEDecl ::= '<!ENTITY' S '%' S Name S PEDef S? '>'
+ *
+ * [73] EntityDef ::= EntityValue | (ExternalID NDataDecl?)
+ *
+ * [74] PEDef ::= EntityValue | ExternalID
+ *
+ * [76] NDataDecl ::= S 'NDATA' S Name
+ *
+ * [ VC: Notation Declared ]
+ * The Name must match the declared name of a notation.
+ */
+
+void
+xmlParseEntityDecl(xmlParserCtxtPtr ctxt) {
+    const xmlChar *name = NULL;
+    xmlChar *value = NULL;
+    xmlChar *URI = NULL, *literal = NULL;
+    const xmlChar *ndata = NULL;
+    int isParameter = 0;
+    xmlChar *orig = NULL;
+    int skipped;
+    
+    GROW;
+    if (CMP8(CUR_PTR, '<', '!', 'E', 'N', 'T', 'I', 'T', 'Y')) {
+	xmlParserInputPtr input = ctxt->input;
+	SHRINK;
+	SKIP(8);
+	skipped = SKIP_BLANKS;
+	if (skipped == 0) {
+	    xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
+			   "Space required after '<!ENTITY'\n");
+	}
+
+	if (RAW == '%') {
+	    NEXT;
+	    skipped = SKIP_BLANKS;
+	    if (skipped == 0) {
+		xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
+			       "Space required after '%'\n");
+	    }
+	    isParameter = 1;
+	}
+
+        name = xmlParseName(ctxt);
+	if (name == NULL) {
+	    xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
+	                   "xmlParseEntityDecl: no name\n");
+            return;
+	}
+        skipped = SKIP_BLANKS;
+	if (skipped == 0) {
+	    xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
+			   "Space required after the entity name\n");
+	}
+
+	ctxt->instate = XML_PARSER_ENTITY_DECL;
+	/*
+	 * handle the various case of definitions...
+	 */
+	if (isParameter) {
+	    if ((RAW == '"') || (RAW == '\'')) {
+	        value = xmlParseEntityValue(ctxt, &orig);
+		if (value) {
+		    if ((ctxt->sax != NULL) &&
+			(!ctxt->disableSAX) && (ctxt->sax->entityDecl != NULL))
+			ctxt->sax->entityDecl(ctxt->userData, name,
+		                    XML_INTERNAL_PARAMETER_ENTITY,
+				    NULL, NULL, value);
+		}
+	    } else {
+	        URI = xmlParseExternalID(ctxt, &literal, 1);
+		if ((URI == NULL) && (literal == NULL)) {
+		    xmlFatalErr(ctxt, XML_ERR_VALUE_REQUIRED, NULL);
+		}
+		if (URI) {
+		    xmlURIPtr uri;
+
+		    uri = xmlParseURI((const char *) URI);
+		    if (uri == NULL) {
+		        xmlErrMsgStr(ctxt, XML_ERR_INVALID_URI,
+				     "Invalid URI: %s\n", URI);
+			/*
+			 * This really ought to be a well formedness error
+			 * but the XML Core WG decided otherwise c.f. issue
+			 * E26 of the XML erratas.
+			 */
+		    } else {
+			if (uri->fragment != NULL) {
+			    /*
+			     * Okay this is foolish to block those but not
+			     * invalid URIs.
+			     */
+			    xmlFatalErr(ctxt, XML_ERR_URI_FRAGMENT, NULL);
+			} else {
+			    if ((ctxt->sax != NULL) &&
+				(!ctxt->disableSAX) &&
+				(ctxt->sax->entityDecl != NULL))
+				ctxt->sax->entityDecl(ctxt->userData, name,
+					    XML_EXTERNAL_PARAMETER_ENTITY,
+					    literal, URI, NULL);
+			}
+			xmlFreeURI(uri);
+		    }
+		}
+	    }
+	} else {
+	    if ((RAW == '"') || (RAW == '\'')) {
+	        value = xmlParseEntityValue(ctxt, &orig);
+		if ((ctxt->sax != NULL) &&
+		    (!ctxt->disableSAX) && (ctxt->sax->entityDecl != NULL))
+		    ctxt->sax->entityDecl(ctxt->userData, name,
+				XML_INTERNAL_GENERAL_ENTITY,
+				NULL, NULL, value);
+		/*
+		 * For expat compatibility in SAX mode.
+		 */
+		if ((ctxt->myDoc == NULL) ||
+		    (xmlStrEqual(ctxt->myDoc->version, SAX_COMPAT_MODE))) {
+		    if (ctxt->myDoc == NULL) {
+			ctxt->myDoc = xmlNewDoc(SAX_COMPAT_MODE);
+		    }
+		    if (ctxt->myDoc->intSubset == NULL)
+			ctxt->myDoc->intSubset = xmlNewDtd(ctxt->myDoc,
+					    BAD_CAST "fake", NULL, NULL);
+
+		    xmlSAX2EntityDecl(ctxt, name, XML_INTERNAL_GENERAL_ENTITY,
+			              NULL, NULL, value);
+		}
+	    } else {
+	        URI = xmlParseExternalID(ctxt, &literal, 1);
+		if ((URI == NULL) && (literal == NULL)) {
+		    xmlFatalErr(ctxt, XML_ERR_VALUE_REQUIRED, NULL);
+		}
+		if (URI) {
+		    xmlURIPtr uri;
+
+		    uri = xmlParseURI((const char *)URI);
+		    if (uri == NULL) {
+		        xmlErrMsgStr(ctxt, XML_ERR_INVALID_URI,
+				     "Invalid URI: %s\n", URI);
+			/*
+			 * This really ought to be a well formedness error
+			 * but the XML Core WG decided otherwise c.f. issue
+			 * E26 of the XML erratas.
+			 */
+		    } else {
+			if (uri->fragment != NULL) {
+			    /*
+			     * Okay this is foolish to block those but not
+			     * invalid URIs.
+			     */
+			    xmlFatalErr(ctxt, XML_ERR_URI_FRAGMENT, NULL);
+			}
+			xmlFreeURI(uri);
+		    }
+		}
+		if ((RAW != '>') && (!IS_BLANK_CH(CUR))) {
+		    xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
+				   "Space required before 'NDATA'\n");
+		}
+		SKIP_BLANKS;
+		if (CMP5(CUR_PTR, 'N', 'D', 'A', 'T', 'A')) {
+		    SKIP(5);
+		    if (!IS_BLANK_CH(CUR)) {
+			xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
+				       "Space required after 'NDATA'\n");
+		    }
+		    SKIP_BLANKS;
+		    ndata = xmlParseName(ctxt);
+		    if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
+		        (ctxt->sax->unparsedEntityDecl != NULL))
+			ctxt->sax->unparsedEntityDecl(ctxt->userData, name,
+				    literal, URI, ndata);
+		} else {
+		    if ((ctxt->sax != NULL) &&
+		        (!ctxt->disableSAX) && (ctxt->sax->entityDecl != NULL))
+			ctxt->sax->entityDecl(ctxt->userData, name,
+				    XML_EXTERNAL_GENERAL_PARSED_ENTITY,
+				    literal, URI, NULL);
+		    /*
+		     * For expat compatibility in SAX mode.
+		     * assuming the entity repalcement was asked for
+		     */
+		    if ((ctxt->replaceEntities != 0) &&
+			((ctxt->myDoc == NULL) ||
+			(xmlStrEqual(ctxt->myDoc->version, SAX_COMPAT_MODE)))) {
+			if (ctxt->myDoc == NULL) {
+			    ctxt->myDoc = xmlNewDoc(SAX_COMPAT_MODE);
+			}
+
+			if (ctxt->myDoc->intSubset == NULL)
+			    ctxt->myDoc->intSubset = xmlNewDtd(ctxt->myDoc,
+						BAD_CAST "fake", NULL, NULL);
+			xmlSAX2EntityDecl(ctxt, name,
+				          XML_EXTERNAL_GENERAL_PARSED_ENTITY,
+				          literal, URI, NULL);
+		    }
+		}
+	    }
+	}
+	SKIP_BLANKS;
+	if (RAW != '>') {
+	    xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_NOT_FINISHED,
+	            "xmlParseEntityDecl: entity %s not terminated\n", name);
+	} else {
+	    if (input != ctxt->input) {
+		xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
+	"Entity declaration doesn't start and stop in the same entity\n");
+	    }
+	    NEXT;
+	}
+	if (orig != NULL) {
+	    /*
+	     * Ugly mechanism to save the raw entity value.
+	     */
+	    xmlEntityPtr cur = NULL;
+
+	    if (isParameter) {
+	        if ((ctxt->sax != NULL) &&
+		    (ctxt->sax->getParameterEntity != NULL))
+		    cur = ctxt->sax->getParameterEntity(ctxt->userData, name);
+	    } else {
+	        if ((ctxt->sax != NULL) &&
+		    (ctxt->sax->getEntity != NULL))
+		    cur = ctxt->sax->getEntity(ctxt->userData, name);
+		if ((cur == NULL) && (ctxt->userData==ctxt)) {
+		    cur = xmlSAX2GetEntity(ctxt, name);
+		}
+	    }
+            if (cur != NULL) {
+	        if (cur->orig != NULL)
+		    xmlFree(orig);
+		else
+		    cur->orig = orig;
+	    } else
+		xmlFree(orig);
+	}
+	if (value != NULL) xmlFree(value);
+	if (URI != NULL) xmlFree(URI);
+	if (literal != NULL) xmlFree(literal);
+    }
+}
+
+/**
+ * xmlParseDefaultDecl:
+ * @ctxt:  an XML parser context
+ * @value:  Receive a possible fixed default value for the attribute
+ *
+ * Parse an attribute default declaration
+ *
+ * [60] DefaultDecl ::= '#REQUIRED' | '#IMPLIED' | (('#FIXED' S)? AttValue)
+ *
+ * [ VC: Required Attribute ]
+ * if the default declaration is the keyword #REQUIRED, then the
+ * attribute must be specified for all elements of the type in the
+ * attribute-list declaration.
+ *
+ * [ VC: Attribute Default Legal ]
+ * The declared default value must meet the lexical constraints of
+ * the declared attribute type c.f. xmlValidateAttributeDecl()
+ *
+ * [ VC: Fixed Attribute Default ]
+ * if an attribute has a default value declared with the #FIXED
+ * keyword, instances of that attribute must match the default value. 
+ *
+ * [ WFC: No < in Attribute Values ]
+ * handled in xmlParseAttValue()
+ *
+ * returns: XML_ATTRIBUTE_NONE, XML_ATTRIBUTE_REQUIRED, XML_ATTRIBUTE_IMPLIED
+ *          or XML_ATTRIBUTE_FIXED. 
+ */
+
+int
+xmlParseDefaultDecl(xmlParserCtxtPtr ctxt, xmlChar **value) {
+    int val;
+    xmlChar *ret;
+
+    *value = NULL;
+    if (CMP9(CUR_PTR, '#', 'R', 'E', 'Q', 'U', 'I', 'R', 'E', 'D')) {
+	SKIP(9);
+	return(XML_ATTRIBUTE_REQUIRED);
+    }
+    if (CMP8(CUR_PTR, '#', 'I', 'M', 'P', 'L', 'I', 'E', 'D')) {
+	SKIP(8);
+	return(XML_ATTRIBUTE_IMPLIED);
+    }
+    val = XML_ATTRIBUTE_NONE;
+    if (CMP6(CUR_PTR, '#', 'F', 'I', 'X', 'E', 'D')) {
+	SKIP(6);
+	val = XML_ATTRIBUTE_FIXED;
+	if (!IS_BLANK_CH(CUR)) {
+	    xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
+			   "Space required after '#FIXED'\n");
+	}
+	SKIP_BLANKS;
+    }
+    ret = xmlParseAttValue(ctxt);
+    ctxt->instate = XML_PARSER_DTD;
+    if (ret == NULL) {
+	xmlFatalErrMsg(ctxt, (xmlParserErrors)ctxt->errNo,
+		       "Attribute default value declaration error\n");
+    } else
+        *value = ret;
+    return(val);
+}
+
+/**
+ * xmlParseNotationType:
+ * @ctxt:  an XML parser context
+ *
+ * parse an Notation attribute type.
+ *
+ * Note: the leading 'NOTATION' S part has already being parsed...
+ *
+ * [58] NotationType ::= 'NOTATION' S '(' S? Name (S? '|' S? Name)* S? ')'
+ *
+ * [ VC: Notation Attributes ]
+ * Values of this type must match one of the notation names included
+ * in the declaration; all notation names in the declaration must be declared. 
+ *
+ * Returns: the notation attribute tree built while parsing
+ */
+
+xmlEnumerationPtr
+xmlParseNotationType(xmlParserCtxtPtr ctxt) {
+    const xmlChar *name;
+    xmlEnumerationPtr ret = NULL, last = NULL, cur;
+
+    if (RAW != '(') {
+	xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_STARTED, NULL);
+	return(NULL);
+    }
+    SHRINK;
+    do {
+        NEXT;
+	SKIP_BLANKS;
+        name = xmlParseName(ctxt);
+	if (name == NULL) {
+	    xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
+			   "Name expected in NOTATION declaration\n");
+	    return(ret);
+	}
+	cur = xmlCreateEnumeration(name);
+	if (cur == NULL) return(ret);
+	if (last == NULL) ret = last = cur;
+	else {
+	    last->next = cur;
+	    last = cur;
+	}
+	SKIP_BLANKS;
+    } while (RAW == '|');
+    if (RAW != ')') {
+	xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_FINISHED, NULL);
+	if ((last != NULL) && (last != ret))
+	    xmlFreeEnumeration(last);
+	return(ret);
+    }
+    NEXT;
+    return(ret);
+}
+
+/**
+ * xmlParseEnumerationType:
+ * @ctxt:  an XML parser context
+ *
+ * parse an Enumeration attribute type.
+ *
+ * [59] Enumeration ::= '(' S? Nmtoken (S? '|' S? Nmtoken)* S? ')'
+ *
+ * [ VC: Enumeration ]
+ * Values of this type must match one of the Nmtoken tokens in
+ * the declaration
+ *
+ * Returns: the enumeration attribute tree built while parsing
+ */
+
+xmlEnumerationPtr
+xmlParseEnumerationType(xmlParserCtxtPtr ctxt) {
+    xmlChar *name;
+    xmlEnumerationPtr ret = NULL, last = NULL, cur;
+
+    if (RAW != '(') {
+	xmlFatalErr(ctxt, XML_ERR_ATTLIST_NOT_STARTED, NULL);
+	return(NULL);
+    }
+    SHRINK;
+    do {
+        NEXT;
+	SKIP_BLANKS;
+        name = xmlParseNmtoken(ctxt);
+	if (name == NULL) {
+	    xmlFatalErr(ctxt, XML_ERR_NMTOKEN_REQUIRED, NULL);
+	    return(ret);
+	}
+	cur = xmlCreateEnumeration(name);
+	xmlFree(name);
+	if (cur == NULL) return(ret);
+	if (last == NULL) ret = last = cur;
+	else {
+	    last->next = cur;
+	    last = cur;
+	}
+	SKIP_BLANKS;
+    } while (RAW == '|');
+    if (RAW != ')') {
+	xmlFatalErr(ctxt, XML_ERR_ATTLIST_NOT_FINISHED, NULL);
+	return(ret);
+    }
+    NEXT;
+    return(ret);
+}
+
+/**
+ * xmlParseEnumeratedType:
+ * @ctxt:  an XML parser context
+ * @tree:  the enumeration tree built while parsing
+ *
+ * parse an Enumerated attribute type.
+ *
+ * [57] EnumeratedType ::= NotationType | Enumeration
+ *
+ * [58] NotationType ::= 'NOTATION' S '(' S? Name (S? '|' S? Name)* S? ')'
+ *
+ *
+ * Returns: XML_ATTRIBUTE_ENUMERATION or XML_ATTRIBUTE_NOTATION
+ */
+
+int
+xmlParseEnumeratedType(xmlParserCtxtPtr ctxt, xmlEnumerationPtr *tree) {
+    if (CMP8(CUR_PTR, 'N', 'O', 'T', 'A', 'T', 'I', 'O', 'N')) {
+	SKIP(8);
+	if (!IS_BLANK_CH(CUR)) {
+	    xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
+			   "Space required after 'NOTATION'\n");
+	    return(0);
+	}
+        SKIP_BLANKS;
+	*tree = xmlParseNotationType(ctxt);
+	if (*tree == NULL) return(0);
+	return(XML_ATTRIBUTE_NOTATION);
+    }
+    *tree = xmlParseEnumerationType(ctxt);
+    if (*tree == NULL) return(0);
+    return(XML_ATTRIBUTE_ENUMERATION);
+}
+
+/**
+ * xmlParseAttributeType:
+ * @ctxt:  an XML parser context
+ * @tree:  the enumeration tree built while parsing
+ *
+ * parse the Attribute list def for an element
+ *
+ * [54] AttType ::= StringType | TokenizedType | EnumeratedType
+ *
+ * [55] StringType ::= 'CDATA'
+ *
+ * [56] TokenizedType ::= 'ID' | 'IDREF' | 'IDREFS' | 'ENTITY' |
+ *                        'ENTITIES' | 'NMTOKEN' | 'NMTOKENS'
+ *
+ * Validity constraints for attribute values syntax are checked in
+ * xmlValidateAttributeValue()
+ *
+ * [ VC: ID ]
+ * Values of type ID must match the Name production. A name must not
+ * appear more than once in an XML document as a value of this type;
+ * i.e., ID values must uniquely identify the elements which bear them.
+ *
+ * [ VC: One ID per Element Type ]
+ * No element type may have more than one ID attribute specified.
+ *
+ * [ VC: ID Attribute Default ]
+ * An ID attribute must have a declared default of #IMPLIED or #REQUIRED.
+ *
+ * [ VC: IDREF ]
+ * Values of type IDREF must match the Name production, and values
+ * of type IDREFS must match Names; each IDREF Name must match the value
+ * of an ID attribute on some element in the XML document; i.e. IDREF
+ * values must match the value of some ID attribute.
+ *
+ * [ VC: Entity Name ]
+ * Values of type ENTITY must match the Name production, values
+ * of type ENTITIES must match Names; each Entity Name must match the
+ * name of an unparsed entity declared in the DTD.  
+ *
+ * [ VC: Name Token ]
+ * Values of type NMTOKEN must match the Nmtoken production; values
+ * of type NMTOKENS must match Nmtokens. 
+ *
+ * Returns the attribute type
+ */
+int 
+xmlParseAttributeType(xmlParserCtxtPtr ctxt, xmlEnumerationPtr *tree) {
+    SHRINK;
+    if (CMP5(CUR_PTR, 'C', 'D', 'A', 'T', 'A')) {
+	SKIP(5);
+	return(XML_ATTRIBUTE_CDATA);
+     } else if (CMP6(CUR_PTR, 'I', 'D', 'R', 'E', 'F', 'S')) {
+	SKIP(6);
+	return(XML_ATTRIBUTE_IDREFS);
+     } else if (CMP5(CUR_PTR, 'I', 'D', 'R', 'E', 'F')) {
+	SKIP(5);
+	return(XML_ATTRIBUTE_IDREF);
+     } else if ((RAW == 'I') && (NXT(1) == 'D')) {
+        SKIP(2);
+	return(XML_ATTRIBUTE_ID);
+     } else if (CMP6(CUR_PTR, 'E', 'N', 'T', 'I', 'T', 'Y')) {
+	SKIP(6);
+	return(XML_ATTRIBUTE_ENTITY);
+     } else if (CMP8(CUR_PTR, 'E', 'N', 'T', 'I', 'T', 'I', 'E', 'S')) {
+	SKIP(8);
+	return(XML_ATTRIBUTE_ENTITIES);
+     } else if (CMP8(CUR_PTR, 'N', 'M', 'T', 'O', 'K', 'E', 'N', 'S')) {
+	SKIP(8);
+	return(XML_ATTRIBUTE_NMTOKENS);
+     } else if (CMP7(CUR_PTR, 'N', 'M', 'T', 'O', 'K', 'E', 'N')) {
+	SKIP(7);
+	return(XML_ATTRIBUTE_NMTOKEN);
+     }
+     return(xmlParseEnumeratedType(ctxt, tree));
+}
+
+/**
+ * xmlParseAttributeListDecl:
+ * @ctxt:  an XML parser context
+ *
+ * : parse the Attribute list def for an element
+ *
+ * [52] AttlistDecl ::= '<!ATTLIST' S Name AttDef* S? '>'
+ *
+ * [53] AttDef ::= S Name S AttType S DefaultDecl
+ *
+ */
+void
+xmlParseAttributeListDecl(xmlParserCtxtPtr ctxt) {
+    const xmlChar *elemName;
+    const xmlChar *attrName;
+    xmlEnumerationPtr tree;
+
+    if (CMP9(CUR_PTR, '<', '!', 'A', 'T', 'T', 'L', 'I', 'S', 'T')) {
+	xmlParserInputPtr input = ctxt->input;
+
+	SKIP(9);
+	if (!IS_BLANK_CH(CUR)) {
+	    xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
+		                 "Space required after '<!ATTLIST'\n");
+	}
+        SKIP_BLANKS;
+        elemName = xmlParseName(ctxt);
+	if (elemName == NULL) {
+	    xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
+			   "ATTLIST: no name for Element\n");
+	    return;
+	}
+	SKIP_BLANKS;
+	GROW;
+	while (RAW != '>') {
+	    const xmlChar *check = CUR_PTR;
+	    int type;
+	    int def;
+	    xmlChar *defaultValue = NULL;
+
+	    GROW;
+            tree = NULL;
+	    attrName = xmlParseName(ctxt);
+	    if (attrName == NULL) {
+		xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
+			       "ATTLIST: no name for Attribute\n");
+		break;
+	    }
+	    GROW;
+	    if (!IS_BLANK_CH(CUR)) {
+		xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
+		        "Space required after the attribute name\n");
+                if (defaultValue != NULL)
+		    xmlFree(defaultValue);
+		break;
+	    }
+	    SKIP_BLANKS;
+
+	    type = xmlParseAttributeType(ctxt, &tree);
+	    if (type <= 0) {
+                if (defaultValue != NULL)
+		    xmlFree(defaultValue);
+	        break;
+	    }
+
+	    GROW;
+	    if (!IS_BLANK_CH(CUR)) {
+		xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
+			       "Space required after the attribute type\n");
+                if (defaultValue != NULL)
+		    xmlFree(defaultValue);
+	        if (tree != NULL)
+		    xmlFreeEnumeration(tree);
+		break;
+	    }
+	    SKIP_BLANKS;
+
+	    def = xmlParseDefaultDecl(ctxt, &defaultValue);
+	    if (def <= 0) {
+                if (defaultValue != NULL)
+		    xmlFree(defaultValue);
+	        if (tree != NULL)
+		    xmlFreeEnumeration(tree);
+	        break;
+	    }
+
+	    GROW;
+            if (RAW != '>') {
+		if (!IS_BLANK_CH(CUR)) {
+		    xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
+			"Space required after the attribute default value\n");
+		    if (defaultValue != NULL)
+			xmlFree(defaultValue);
+		    if (tree != NULL)
+			xmlFreeEnumeration(tree);
+		    break;
+		}
+		SKIP_BLANKS;
+	    }
+	    if (check == CUR_PTR) {
+		xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
+		            "in xmlParseAttributeListDecl\n");
+		if (defaultValue != NULL)
+		    xmlFree(defaultValue);
+	        if (tree != NULL)
+		    xmlFreeEnumeration(tree);
+		break;
+	    }
+	    if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
+		(ctxt->sax->attributeDecl != NULL))
+		ctxt->sax->attributeDecl(ctxt->userData, elemName, attrName,
+	                        type, def, defaultValue, tree);
+	    else if (tree != NULL)
+		xmlFreeEnumeration(tree);
+
+	    if ((ctxt->sax2) && (defaultValue != NULL) &&
+	        (def != XML_ATTRIBUTE_IMPLIED) && 
+		(def != XML_ATTRIBUTE_REQUIRED)) {
+		xmlAddDefAttrs(ctxt, elemName, attrName, defaultValue);
+	    }
+	    if ((ctxt->sax2) && (type != XML_ATTRIBUTE_CDATA)) {
+		xmlAddSpecialAttr(ctxt, elemName, attrName, type);
+	    }
+	    if (defaultValue != NULL)
+	        xmlFree(defaultValue);
+	    GROW;
+	}
+	if (RAW == '>') {
+	    if (input != ctxt->input) {
+		xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
+    "Attribute list declaration doesn't start and stop in the same entity\n");
+	    }
+	    NEXT;
+	}
+    }
+}
+
+/**
+ * xmlParseElementMixedContentDecl:
+ * @ctxt:  an XML parser context
+ * @inputchk:  the input used for the current entity, needed for boundary checks
+ *
+ * parse the declaration for a Mixed Element content
+ * The leading '(' and spaces have been skipped in xmlParseElementContentDecl
+ * 
+ * [51] Mixed ::= '(' S? '#PCDATA' (S? '|' S? Name)* S? ')*' |
+ *                '(' S? '#PCDATA' S? ')'
+ *
+ * [ VC: Proper Group/PE Nesting ] applies to [51] too (see [49])
+ *
+ * [ VC: No Duplicate Types ]
+ * The same name must not appear more than once in a single
+ * mixed-content declaration. 
+ *
+ * returns: the list of the xmlElementContentPtr describing the element choices
+ */
+xmlElementContentPtr
+xmlParseElementMixedContentDecl(xmlParserCtxtPtr ctxt, int inputchk) {
+    xmlElementContentPtr ret = NULL, cur = NULL, n;
+    const xmlChar *elem = NULL;
+
+    GROW;
+    if (CMP7(CUR_PTR, '#', 'P', 'C', 'D', 'A', 'T', 'A')) {
+	SKIP(7);
+	SKIP_BLANKS;
+	SHRINK;
+	if (RAW == ')') {
+	    if ((ctxt->validate) && (ctxt->input->id != inputchk)) {
+		xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
+"Element content declaration doesn't start and stop in the same entity\n",
+                                 NULL);
+	    }
+	    NEXT;
+	    ret = xmlNewElementContent(NULL, XML_ELEMENT_CONTENT_PCDATA);
+	    if (RAW == '*') {
+		ret->ocur = XML_ELEMENT_CONTENT_MULT;
+		NEXT;
+	    }
+	    return(ret);
+	}
+	if ((RAW == '(') || (RAW == '|')) {
+	    ret = cur = xmlNewElementContent(NULL, XML_ELEMENT_CONTENT_PCDATA);
+	    if (ret == NULL) return(NULL);
+	}
+	while (RAW == '|') {
+	    NEXT;
+	    if (elem == NULL) {
+	        ret = xmlNewElementContent(NULL, XML_ELEMENT_CONTENT_OR);
+		if (ret == NULL) return(NULL);
+		ret->c1 = cur;
+		if (cur != NULL)
+		    cur->parent = ret;
+		cur = ret;
+	    } else {
+	        n = xmlNewElementContent(NULL, XML_ELEMENT_CONTENT_OR);
+		if (n == NULL) return(NULL);
+		n->c1 = xmlNewElementContent(elem, XML_ELEMENT_CONTENT_ELEMENT);
+		if (n->c1 != NULL)
+		    n->c1->parent = n;
+	        cur->c2 = n;
+		if (n != NULL)
+		    n->parent = cur;
+		cur = n;
+	    }
+	    SKIP_BLANKS;
+	    elem = xmlParseName(ctxt);
+	    if (elem == NULL) {
+		xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
+			"xmlParseElementMixedContentDecl : Name expected\n");
+		xmlFreeElementContent(cur);
+		return(NULL);
+	    }
+	    SKIP_BLANKS;
+	    GROW;
+	}
+	if ((RAW == ')') && (NXT(1) == '*')) {
+	    if (elem != NULL) {
+		cur->c2 = xmlNewElementContent(elem,
+		                               XML_ELEMENT_CONTENT_ELEMENT);
+		if (cur->c2 != NULL)
+		    cur->c2->parent = cur;
+            }
+	    ret->ocur = XML_ELEMENT_CONTENT_MULT;
+	    if ((ctxt->validate) && (ctxt->input->id != inputchk)) {
+		xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
+"Element content declaration doesn't start and stop in the same entity\n",
+				 NULL);
+	    }
+	    SKIP(2);
+	} else {
+	    xmlFreeElementContent(ret);
+	    xmlFatalErr(ctxt, XML_ERR_MIXED_NOT_STARTED, NULL);
+	    return(NULL);
+	}
+
+    } else {
+	xmlFatalErr(ctxt, XML_ERR_PCDATA_REQUIRED, NULL);
+    }
+    return(ret);
+}
+
+/**
+ * xmlParseElementChildrenContentDecl:
+ * @ctxt:  an XML parser context
+ * @inputchk:  the input used for the current entity, needed for boundary checks
+ *
+ * parse the declaration for a Mixed Element content
+ * The leading '(' and spaces have been skipped in xmlParseElementContentDecl
+ * 
+ *
+ * [47] children ::= (choice | seq) ('?' | '*' | '+')?
+ *
+ * [48] cp ::= (Name | choice | seq) ('?' | '*' | '+')?
+ *
+ * [49] choice ::= '(' S? cp ( S? '|' S? cp )* S? ')'
+ *
+ * [50] seq ::= '(' S? cp ( S? ',' S? cp )* S? ')'
+ *
+ * [ VC: Proper Group/PE Nesting ] applies to [49] and [50]
+ * TODO Parameter-entity replacement text must be properly nested
+ *	with parenthesized groups. That is to say, if either of the
+ *	opening or closing parentheses in a choice, seq, or Mixed
+ *	construct is contained in the replacement text for a parameter
+ *	entity, both must be contained in the same replacement text. For
+ *	interoperability, if a parameter-entity reference appears in a
+ *	choice, seq, or Mixed construct, its replacement text should not
+ *	be empty, and neither the first nor last non-blank character of
+ *	the replacement text should be a connector (| or ,).
+ *
+ * Returns the tree of xmlElementContentPtr describing the element 
+ *          hierarchy.
+ */
+xmlElementContentPtr
+xmlParseElementChildrenContentDecl (xmlParserCtxtPtr ctxt, int inputchk) {
+    xmlElementContentPtr ret = NULL, cur = NULL, last = NULL, op = NULL;
+    const xmlChar *elem;
+    xmlChar type = 0;
+
+    SKIP_BLANKS;
+    GROW;
+    if (RAW == '(') {
+	int inputid = ctxt->input->id;
+
+        /* Recurse on first child */
+	NEXT;
+	SKIP_BLANKS;
+        cur = ret = xmlParseElementChildrenContentDecl(ctxt, inputid);
+	SKIP_BLANKS;
+	GROW;
+    } else {
+	elem = xmlParseName(ctxt);
+	if (elem == NULL) {
+	    xmlFatalErr(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED, NULL);
+	    return(NULL);
+	}
+        cur = ret = xmlNewElementContent(elem, XML_ELEMENT_CONTENT_ELEMENT);
+	if (cur == NULL) {
+	    xmlErrMemory(ctxt, NULL);
+	    return(NULL);
+	}
+	GROW;
+	if (RAW == '?') {
+	    cur->ocur = XML_ELEMENT_CONTENT_OPT;
+	    NEXT;
+	} else if (RAW == '*') {
+	    cur->ocur = XML_ELEMENT_CONTENT_MULT;
+	    NEXT;
+	} else if (RAW == '+') {
+	    cur->ocur = XML_ELEMENT_CONTENT_PLUS;
+	    NEXT;
+	} else {
+	    cur->ocur = XML_ELEMENT_CONTENT_ONCE;
+	}
+	GROW;
+    }
+    SKIP_BLANKS;
+    SHRINK;
+    while (RAW != ')') {
+        /*
+	 * Each loop we parse one separator and one element.
+	 */
+        if (RAW == ',') {
+	    if (type == 0) type = CUR;
+
+	    /*
+	     * Detect "Name | Name , Name" error
+	     */
+	    else if (type != CUR) {
+		xmlFatalErrMsgInt(ctxt, XML_ERR_SEPARATOR_REQUIRED,
+		    "xmlParseElementChildrenContentDecl : '%c' expected\n",
+		                  type);
+		if ((last != NULL) && (last != ret))
+		    xmlFreeElementContent(last);
+		if (ret != NULL)
+		    xmlFreeElementContent(ret);
+		return(NULL);
+	    }
+	    NEXT;
+
+	    op = xmlNewElementContent(NULL, XML_ELEMENT_CONTENT_SEQ);
+	    if (op == NULL) {
+		if ((last != NULL) && (last != ret))
+		    xmlFreeElementContent(last);
+	        xmlFreeElementContent(ret);
+		return(NULL);
+	    }
+	    if (last == NULL) {
+		op->c1 = ret;
+		if (ret != NULL)
+		    ret->parent = op;
+		ret = cur = op;
+	    } else {
+	        cur->c2 = op;
+		if (op != NULL)
+		    op->parent = cur;
+		op->c1 = last;
+		if (last != NULL)
+		    last->parent = op;
+		cur =op;
+		last = NULL;
+	    }
+	} else if (RAW == '|') {
+	    if (type == 0) type = CUR;
+
+	    /*
+	     * Detect "Name , Name | Name" error
+	     */
+	    else if (type != CUR) {
+		xmlFatalErrMsgInt(ctxt, XML_ERR_SEPARATOR_REQUIRED,
+		    "xmlParseElementChildrenContentDecl : '%c' expected\n",
+				  type);
+		if ((last != NULL) && (last != ret))
+		    xmlFreeElementContent(last);
+		if (ret != NULL)
+		    xmlFreeElementContent(ret);
+		return(NULL);
+	    }
+	    NEXT;
+
+	    op = xmlNewElementContent(NULL, XML_ELEMENT_CONTENT_OR);
+	    if (op == NULL) {
+		if ((last != NULL) && (last != ret))
+		    xmlFreeElementContent(last);
+		if (ret != NULL)
+		    xmlFreeElementContent(ret);
+		return(NULL);
+	    }
+	    if (last == NULL) {
+		op->c1 = ret;
+		if (ret != NULL)
+		    ret->parent = op;
+		ret = cur = op;
+	    } else {
+	        cur->c2 = op;
+		if (op != NULL)
+		    op->parent = cur;
+		op->c1 = last;
+		if (last != NULL)
+		    last->parent = op;
+		cur =op;
+		last = NULL;
+	    }
+	} else {
+	    xmlFatalErr(ctxt, XML_ERR_ELEMCONTENT_NOT_FINISHED, NULL);
+	    if (ret != NULL)
+		xmlFreeElementContent(ret);
+	    return(NULL);
+	}
+	GROW;
+	SKIP_BLANKS;
+	GROW;
+	if (RAW == '(') {
+	    int inputid = ctxt->input->id;
+	    /* Recurse on second child */
+	    NEXT;
+	    SKIP_BLANKS;
+	    last = xmlParseElementChildrenContentDecl(ctxt, inputid);
+	    SKIP_BLANKS;
+	} else {
+	    elem = xmlParseName(ctxt);
+	    if (elem == NULL) {
+		xmlFatalErr(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED, NULL);
+		if (ret != NULL)
+		    xmlFreeElementContent(ret);
+		return(NULL);
+	    }
+	    last = xmlNewElementContent(elem, XML_ELEMENT_CONTENT_ELEMENT);
+	    if (RAW == '?') {
+		last->ocur = XML_ELEMENT_CONTENT_OPT;
+		NEXT;
+	    } else if (RAW == '*') {
+		last->ocur = XML_ELEMENT_CONTENT_MULT;
+		NEXT;
+	    } else if (RAW == '+') {
+		last->ocur = XML_ELEMENT_CONTENT_PLUS;
+		NEXT;
+	    } else {
+		last->ocur = XML_ELEMENT_CONTENT_ONCE;
+	    }
+	}
+	SKIP_BLANKS;
+	GROW;
+    }
+    if ((cur != NULL) && (last != NULL)) {
+        cur->c2 = last;
+	if (last != NULL)
+	    last->parent = cur;
+    }
+    if ((ctxt->validate) && (ctxt->input->id != inputchk)) {
+	xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
+"Element content declaration doesn't start and stop in the same entity\n",
+			 NULL);
+    }
+    NEXT;
+    if (RAW == '?') {
+	if (ret != NULL)
+	    ret->ocur = XML_ELEMENT_CONTENT_OPT;
+	NEXT;
+    } else if (RAW == '*') {
+	if (ret != NULL) {
+	    ret->ocur = XML_ELEMENT_CONTENT_MULT;
+	    cur = ret;
+	    /*
+	     * Some normalization:
+	     * (a | b* | c?)* == (a | b | c)*
+	     */
+	    while (cur->type == XML_ELEMENT_CONTENT_OR) {
+		if ((cur->c1 != NULL) &&
+	            ((cur->c1->ocur == XML_ELEMENT_CONTENT_OPT) ||
+		     (cur->c1->ocur == XML_ELEMENT_CONTENT_MULT)))
+		    cur->c1->ocur = XML_ELEMENT_CONTENT_ONCE;
+		if ((cur->c2 != NULL) &&
+	            ((cur->c2->ocur == XML_ELEMENT_CONTENT_OPT) ||
+		     (cur->c2->ocur == XML_ELEMENT_CONTENT_MULT)))
+		    cur->c2->ocur = XML_ELEMENT_CONTENT_ONCE;
+		cur = cur->c2;
+	    }
+	}
+	NEXT;
+    } else if (RAW == '+') {
+	if (ret != NULL) {
+	    int found = 0;
+
+	    ret->ocur = XML_ELEMENT_CONTENT_PLUS;
+	    /*
+	     * Some normalization:
+	     * (a | b*)+ == (a | b)*
+	     * (a | b?)+ == (a | b)*
+	     */
+	    while (cur->type == XML_ELEMENT_CONTENT_OR) {
+		if ((cur->c1 != NULL) &&
+	            ((cur->c1->ocur == XML_ELEMENT_CONTENT_OPT) ||
+		     (cur->c1->ocur == XML_ELEMENT_CONTENT_MULT))) {
+		    cur->c1->ocur = XML_ELEMENT_CONTENT_ONCE;
+		    found = 1;
+		}
+		if ((cur->c2 != NULL) &&
+	            ((cur->c2->ocur == XML_ELEMENT_CONTENT_OPT) ||
+		     (cur->c2->ocur == XML_ELEMENT_CONTENT_MULT))) {
+		    cur->c2->ocur = XML_ELEMENT_CONTENT_ONCE;
+		    found = 1;
+		}
+		cur = cur->c2;
+	    }
+	    if (found)
+		ret->ocur = XML_ELEMENT_CONTENT_MULT;
+	}
+	NEXT;
+    }
+    return(ret);
+}
+
+/**
+ * xmlParseElementContentDecl:
+ * @ctxt:  an XML parser context
+ * @name:  the name of the element being defined.
+ * @result:  the Element Content pointer will be stored here if any
+ *
+ * parse the declaration for an Element content either Mixed or Children,
+ * the cases EMPTY and ANY are handled directly in xmlParseElementDecl
+ * 
+ * [46] contentspec ::= 'EMPTY' | 'ANY' | Mixed | children
+ *
+ * returns: the type of element content XML_ELEMENT_TYPE_xxx
+ */
+
+int
+xmlParseElementContentDecl(xmlParserCtxtPtr ctxt, const xmlChar *name,
+                           xmlElementContentPtr *result) {
+
+    xmlElementContentPtr tree = NULL;
+    int inputid = ctxt->input->id;
+    int res;
+
+    *result = NULL;
+
+    if (RAW != '(') {
+	xmlFatalErrMsgStr(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED,
+		"xmlParseElementContentDecl : %s '(' expected\n", name);
+	return(-1);
+    }
+    NEXT;
+    GROW;
+    SKIP_BLANKS;
+    if (CMP7(CUR_PTR, '#', 'P', 'C', 'D', 'A', 'T', 'A')) {
+        tree = xmlParseElementMixedContentDecl(ctxt, inputid);
+	res = XML_ELEMENT_TYPE_MIXED;
+    } else {
+        tree = xmlParseElementChildrenContentDecl(ctxt, inputid);
+	res = XML_ELEMENT_TYPE_ELEMENT;
+    }
+    SKIP_BLANKS;
+    *result = tree;
+    return(res);
+}
+
+/**
+ * xmlParseElementDecl:
+ * @ctxt:  an XML parser context
+ *
+ * parse an Element declaration.
+ *
+ * [45] elementdecl ::= '<!ELEMENT' S Name S contentspec S? '>'
+ *
+ * [ VC: Unique Element Type Declaration ]
+ * No element type may be declared more than once
+ *
+ * Returns the type of the element, or -1 in case of error
+ */
+int
+xmlParseElementDecl(xmlParserCtxtPtr ctxt) {
+    const xmlChar *name;
+    int ret = -1;
+    xmlElementContentPtr content  = NULL;
+
+    GROW;
+    if (CMP9(CUR_PTR, '<', '!', 'E', 'L', 'E', 'M', 'E', 'N', 'T')) {
+	xmlParserInputPtr input = ctxt->input;
+
+	SKIP(9);
+	if (!IS_BLANK_CH(CUR)) {
+	    xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
+		           "Space required after 'ELEMENT'\n");
+	}
+        SKIP_BLANKS;
+        name = xmlParseName(ctxt);
+	if (name == NULL) {
+	    xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
+			   "xmlParseElementDecl: no name for Element\n");
+	    return(-1);
+	}
+	while ((RAW == 0) && (ctxt->inputNr > 1))
+	    xmlPopInput(ctxt);
+	if (!IS_BLANK_CH(CUR)) {
+	    xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
+			   "Space required after the element name\n");
+	}
+        SKIP_BLANKS;
+	if (CMP5(CUR_PTR, 'E', 'M', 'P', 'T', 'Y')) {
+	    SKIP(5);
+	    /*
+	     * Element must always be empty.
+	     */
+	    ret = XML_ELEMENT_TYPE_EMPTY;
+	} else if ((RAW == 'A') && (NXT(1) == 'N') &&
+	           (NXT(2) == 'Y')) {
+	    SKIP(3);
+	    /*
+	     * Element is a generic container.
+	     */
+	    ret = XML_ELEMENT_TYPE_ANY;
+	} else if (RAW == '(') {
+	    ret = xmlParseElementContentDecl(ctxt, name, &content);
+	} else {
+	    /*
+	     * [ WFC: PEs in Internal Subset ] error handling.
+	     */
+	    if ((RAW == '%') && (ctxt->external == 0) &&
+	        (ctxt->inputNr == 1)) {
+		xmlFatalErrMsg(ctxt, XML_ERR_PEREF_IN_INT_SUBSET,
+	  "PEReference: forbidden within markup decl in internal subset\n");
+	    } else {
+		xmlFatalErrMsg(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED,
+		      "xmlParseElementDecl: 'EMPTY', 'ANY' or '(' expected\n");
+            }
+	    return(-1);
+	}
+
+	SKIP_BLANKS;
+	/*
+	 * Pop-up of finished entities.
+	 */
+	while ((RAW == 0) && (ctxt->inputNr > 1))
+	    xmlPopInput(ctxt);
+	SKIP_BLANKS;
+
+	if (RAW != '>') {
+	    xmlFatalErr(ctxt, XML_ERR_GT_REQUIRED, NULL);
+	} else {
+	    if (input != ctxt->input) {
+		xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
+    "Element declaration doesn't start and stop in the same entity\n");
+	    }
+		
+	    NEXT;
+	    if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
+		(ctxt->sax->elementDecl != NULL))
+	        ctxt->sax->elementDecl(ctxt->userData, name, ret,
+		                       content);
+	}
+	if (content != NULL) {
+	    xmlFreeElementContent(content);
+	}
+    }
+    return(ret);
+}
+
+/**
+ * xmlParseConditionalSections
+ * @ctxt:  an XML parser context
+ *
+ * [61] conditionalSect ::= includeSect | ignoreSect 
+ * [62] includeSect ::= '<![' S? 'INCLUDE' S? '[' extSubsetDecl ']]>' 
+ * [63] ignoreSect ::= '<![' S? 'IGNORE' S? '[' ignoreSectContents* ']]>'
+ * [64] ignoreSectContents ::= Ignore ('<![' ignoreSectContents ']]>' Ignore)*
+ * [65] Ignore ::= Char* - (Char* ('<![' | ']]>') Char*)
+ */
+
+static void
+xmlParseConditionalSections(xmlParserCtxtPtr ctxt) {
+    SKIP(3);
+    SKIP_BLANKS;
+    if (CMP7(CUR_PTR, 'I', 'N', 'C', 'L', 'U', 'D', 'E')) {
+	SKIP(7);
+	SKIP_BLANKS;
+	if (RAW != '[') {
+	    xmlFatalErr(ctxt, XML_ERR_CONDSEC_INVALID, NULL);
+	} else {
+	    NEXT;
+	}
+	if (xmlParserDebugEntities) {
+	    if ((ctxt->input != NULL) && (ctxt->input->filename))
+		xmlGenericError(xmlGenericErrorContext,
+			"%s(%d): ", ctxt->input->filename,
+			ctxt->input->line);
+	    xmlGenericError(xmlGenericErrorContext,
+		    "Entering INCLUDE Conditional Section\n");
+	}
+
+	while ((RAW != 0) && ((RAW != ']') || (NXT(1) != ']') ||
+	       (NXT(2) != '>'))) {
+	    const xmlChar *check = CUR_PTR;
+	    unsigned int cons = ctxt->input->consumed;
+
+	    if ((RAW == '<') && (NXT(1) == '!') && (NXT(2) == '[')) {
+		xmlParseConditionalSections(ctxt);
+	    } else if (IS_BLANK_CH(CUR)) {
+		NEXT;
+	    } else if (RAW == '%') {
+		xmlParsePEReference(ctxt);
+	    } else
+		xmlParseMarkupDecl(ctxt);
+
+	    /*
+	     * Pop-up of finished entities.
+	     */
+	    while ((RAW == 0) && (ctxt->inputNr > 1))
+		xmlPopInput(ctxt);
+
+	    if ((CUR_PTR == check) && (cons == ctxt->input->consumed)) {
+		xmlFatalErr(ctxt, XML_ERR_EXT_SUBSET_NOT_FINISHED, NULL);
+		break;
+	    }
+	}
+	if (xmlParserDebugEntities) {
+	    if ((ctxt->input != NULL) && (ctxt->input->filename))
+		xmlGenericError(xmlGenericErrorContext,
+			"%s(%d): ", ctxt->input->filename,
+			ctxt->input->line);
+	    xmlGenericError(xmlGenericErrorContext,
+		    "Leaving INCLUDE Conditional Section\n");
+	}
+
+    } else if (CMP6(CUR_PTR, 'I', 'G', 'N', 'O', 'R', 'E')) {
+	int state;
+	xmlParserInputState instate;
+	int depth = 0;
+
+	SKIP(6);
+	SKIP_BLANKS;
+	if (RAW != '[') {
+	    xmlFatalErr(ctxt, XML_ERR_CONDSEC_INVALID, NULL);
+	} else {
+	    NEXT;
+	}
+	if (xmlParserDebugEntities) {
+	    if ((ctxt->input != NULL) && (ctxt->input->filename))
+		xmlGenericError(xmlGenericErrorContext,
+			"%s(%d): ", ctxt->input->filename,
+			ctxt->input->line);
+	    xmlGenericError(xmlGenericErrorContext,
+		    "Entering IGNORE Conditional Section\n");
+	}
+
+	/*
+	 * Parse up to the end of the conditional section
+	 * But disable SAX event generating DTD building in the meantime
+	 */
+	state = ctxt->disableSAX;
+	instate = ctxt->instate;
+	if (ctxt->recovery == 0) ctxt->disableSAX = 1;
+	ctxt->instate = XML_PARSER_IGNORE;
+
+	while ((depth >= 0) && (RAW != 0)) {
+	  if ((RAW == '<') && (NXT(1) == '!') && (NXT(2) == '[')) {
+	    depth++;
+	    SKIP(3);
+	    continue;
+	  }
+	  if ((RAW == ']') && (NXT(1) == ']') && (NXT(2) == '>')) {
+	    if (--depth >= 0) SKIP(3);
+	    continue;
+	  }
+	  NEXT;
+	  continue;
+	}
+
+	ctxt->disableSAX = state;
+	ctxt->instate = instate;
+
+	if (xmlParserDebugEntities) {
+	    if ((ctxt->input != NULL) && (ctxt->input->filename))
+		xmlGenericError(xmlGenericErrorContext,
+			"%s(%d): ", ctxt->input->filename,
+			ctxt->input->line);
+	    xmlGenericError(xmlGenericErrorContext,
+		    "Leaving IGNORE Conditional Section\n");
+	}
+
+    } else {
+	xmlFatalErr(ctxt, XML_ERR_CONDSEC_INVALID_KEYWORD, NULL);
+    }
+
+    if (RAW == 0)
+        SHRINK;
+
+    if (RAW == 0) {
+	xmlFatalErr(ctxt, XML_ERR_CONDSEC_NOT_FINISHED, NULL);
+    } else {
+        SKIP(3);
+    }
+}
+
+/**
+ * xmlParseMarkupDecl:
+ * @ctxt:  an XML parser context
+ * 
+ * parse Markup declarations
+ *
+ * [29] markupdecl ::= elementdecl | AttlistDecl | EntityDecl |
+ *                     NotationDecl | PI | Comment
+ *
+ * [ VC: Proper Declaration/PE Nesting ]
+ * Parameter-entity replacement text must be properly nested with
+ * markup declarations. That is to say, if either the first character
+ * or the last character of a markup declaration (markupdecl above) is
+ * contained in the replacement text for a parameter-entity reference,
+ * both must be contained in the same replacement text.
+ *
+ * [ WFC: PEs in Internal Subset ]
+ * In the internal DTD subset, parameter-entity references can occur
+ * only where markup declarations can occur, not within markup declarations.
+ * (This does not apply to references that occur in external parameter
+ * entities or to the external subset.) 
+ */
+void
+xmlParseMarkupDecl(xmlParserCtxtPtr ctxt) {
+    GROW;
+    xmlParseElementDecl(ctxt);
+    xmlParseAttributeListDecl(ctxt);
+    xmlParseEntityDecl(ctxt);
+    xmlParseNotationDecl(ctxt);
+    xmlParsePI(ctxt);
+    xmlParseComment(ctxt);
+    /*
+     * This is only for internal subset. On external entities,
+     * the replacement is done before parsing stage
+     */
+    if ((ctxt->external == 0) && (ctxt->inputNr == 1))
+	xmlParsePEReference(ctxt);
+
+    /*
+     * Conditional sections are allowed from entities included
+     * by PE References in the internal subset.
+     */
+    if ((ctxt->external == 0) && (ctxt->inputNr > 1)) {
+        if ((RAW == '<') && (NXT(1) == '!') && (NXT(2) == '[')) {
+	    xmlParseConditionalSections(ctxt);
+	}
+    }
+
+    ctxt->instate = XML_PARSER_DTD;
+}
+
+/**
+ * xmlParseTextDecl:
+ * @ctxt:  an XML parser context
+ * 
+ * parse an XML declaration header for external entities
+ *
+ * [77] TextDecl ::= '<?xml' VersionInfo? EncodingDecl S? '?>'
+ *
+ * Question: Seems that EncodingDecl is mandatory ? Is that a typo ?
+ */
+
+void
+xmlParseTextDecl(xmlParserCtxtPtr ctxt) {
+    xmlChar *version;
+    const xmlChar *encoding;
+
+    /*
+     * We know that '<?xml' is here.
+     */
+    if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) {
+	SKIP(5);
+    } else {
+	xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_STARTED, NULL);
+	return;
+    }
+
+    if (!IS_BLANK_CH(CUR)) {
+	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
+		       "Space needed after '<?xml'\n");
+    }
+    SKIP_BLANKS;
+
+    /*
+     * We may have the VersionInfo here.
+     */
+    version = xmlParseVersionInfo(ctxt);
+    if (version == NULL)
+	version = xmlCharStrdup(XML_DEFAULT_VERSION);
+    else {
+	if (!IS_BLANK_CH(CUR)) {
+	    xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
+		           "Space needed here\n");
+	}
+    }
+    ctxt->input->version = version;
+
+    /*
+     * We must have the encoding declaration
+     */
+    encoding = xmlParseEncodingDecl(ctxt);
+    if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
+	/*
+	 * The XML REC instructs us to stop parsing right here
+	 */
+        return;
+    }
+    if ((encoding == NULL) && (ctxt->errNo == XML_ERR_OK)) {
+	xmlFatalErrMsg(ctxt, XML_ERR_MISSING_ENCODING,
+		       "Missing encoding in text declaration\n");
+    }
+
+    SKIP_BLANKS;
+    if ((RAW == '?') && (NXT(1) == '>')) {
+        SKIP(2);
+    } else if (RAW == '>') {
+        /* Deprecated old WD ... */
+	xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL);
+	NEXT;
+    } else {
+	xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL);
+	MOVETO_ENDTAG(CUR_PTR);
+	NEXT;
+    }
+}
+
+/**
+ * xmlParseExternalSubset:
+ * @ctxt:  an XML parser context
+ * @ExternalID: the external identifier
+ * @SystemID: the system identifier (or URL)
+ * 
+ * parse Markup declarations from an external subset
+ *
+ * [30] extSubset ::= textDecl? extSubsetDecl
+ *
+ * [31] extSubsetDecl ::= (markupdecl | conditionalSect | PEReference | S) *
+ */
+void
+xmlParseExternalSubset(xmlParserCtxtPtr ctxt, const xmlChar *ExternalID,
+                       const xmlChar *SystemID) {
+    xmlDetectSAX2(ctxt);
+    GROW;
+    if (CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) {
+	xmlParseTextDecl(ctxt);
+	if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
+	    /*
+	     * The XML REC instructs us to stop parsing right here
+	     */
+	    ctxt->instate = XML_PARSER_EOF;
+	    return;
+	}
+    }
+    if (ctxt->myDoc == NULL) {
+        ctxt->myDoc = xmlNewDoc(BAD_CAST "1.0");
+    }
+    if ((ctxt->myDoc != NULL) && (ctxt->myDoc->intSubset == NULL))
+        xmlCreateIntSubset(ctxt->myDoc, NULL, ExternalID, SystemID);
+
+    ctxt->instate = XML_PARSER_DTD;
+    ctxt->external = 1;
+    while (((RAW == '<') && (NXT(1) == '?')) ||
+           ((RAW == '<') && (NXT(1) == '!')) ||
+	   (RAW == '%') || IS_BLANK_CH(CUR)) {
+	const xmlChar *check = CUR_PTR;
+	unsigned int cons = ctxt->input->consumed;
+
+	GROW;
+        if ((RAW == '<') && (NXT(1) == '!') && (NXT(2) == '[')) {
+	    xmlParseConditionalSections(ctxt);
+	} else if (IS_BLANK_CH(CUR)) {
+	    NEXT;
+	} else if (RAW == '%') {
+            xmlParsePEReference(ctxt);
+	} else
+	    xmlParseMarkupDecl(ctxt);
+
+	/*
+	 * Pop-up of finished entities.
+	 */
+	while ((RAW == 0) && (ctxt->inputNr > 1))
+	    xmlPopInput(ctxt);
+
+	if ((CUR_PTR == check) && (cons == ctxt->input->consumed)) {
+	    xmlFatalErr(ctxt, XML_ERR_EXT_SUBSET_NOT_FINISHED, NULL);
+	    break;
+	}
+    }
+    
+    if (RAW != 0) {
+	xmlFatalErr(ctxt, XML_ERR_EXT_SUBSET_NOT_FINISHED, NULL);
+    }
+
+}
+
+/**
+ * xmlParseReference:
+ * @ctxt:  an XML parser context
+ * 
+ * parse and handle entity references in content, depending on the SAX
+ * interface, this may end-up in a call to character() if this is a
+ * CharRef, a predefined entity, if there is no reference() callback.
+ * or if the parser was asked to switch to that mode.
+ *
+ * [67] Reference ::= EntityRef | CharRef
+ */
+void
+xmlParseReference(xmlParserCtxtPtr ctxt) {
+    xmlEntityPtr ent;
+    xmlChar *val;
+    if (RAW != '&') return;
+
+    if (NXT(1) == '#') {
+	int i = 0;
+	xmlChar out[10];
+	int hex = NXT(2);
+	int value = xmlParseCharRef(ctxt);
+	
+	if (ctxt->charset != XML_CHAR_ENCODING_UTF8) {
+	    /*
+	     * So we are using non-UTF-8 buffers
+	     * Check that the char fit on 8bits, if not
+	     * generate a CharRef.
+	     */
+	    if (value <= 0xFF) {
+		out[0] = value;
+		out[1] = 0;
+		if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL) &&
+		    (!ctxt->disableSAX))
+		    ctxt->sax->characters(ctxt->userData, out, 1);
+	    } else {
+		if ((hex == 'x') || (hex == 'X'))
+		    snprintf((char *)out, sizeof(out), "#x%X", value);
+		else
+		    snprintf((char *)out, sizeof(out), "#%d", value);
+		if ((ctxt->sax != NULL) && (ctxt->sax->reference != NULL) &&
+		    (!ctxt->disableSAX))
+		    ctxt->sax->reference(ctxt->userData, out);
+	    }
+	} else {
+	    /*
+	     * Just encode the value in UTF-8
+	     */
+	    COPY_BUF(0 ,out, i, value);
+	    out[i] = 0;
+	    if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL) &&
+		(!ctxt->disableSAX))
+		ctxt->sax->characters(ctxt->userData, out, i);
+	}
+    } else {
+	ent = xmlParseEntityRef(ctxt);
+	if (ent == NULL) return;
+	if (!ctxt->wellFormed)
+	    return;
+	if ((ent->name != NULL) && 
+	    (ent->etype != XML_INTERNAL_PREDEFINED_ENTITY)) {
+	    xmlNodePtr list = NULL;
+	    xmlParserErrors ret = XML_ERR_OK;
+
+
+	    /*
+	     * The first reference to the entity trigger a parsing phase
+	     * where the ent->children is filled with the result from
+	     * the parsing.
+	     */
+	    if (ent->children == NULL) {
+		xmlChar *value;
+		value = ent->content;
+
+		/*
+		 * Check that this entity is well formed
+		 */
+		if ((value != NULL) && (value[0] != 0) &&
+		    (value[1] == 0) && (value[0] == '<') &&
+		    (xmlStrEqual(ent->name, BAD_CAST "lt"))) {
+		    /*
+		     * DONE: get definite answer on this !!!
+		     * Lots of entity decls are used to declare a single
+		     * char 
+		     *    <!ENTITY lt     "<">
+		     * Which seems to be valid since
+		     * 2.4: The ampersand character (&) and the left angle
+		     * bracket (<) may appear in their literal form only
+		     * when used ... They are also legal within the literal
+		     * entity value of an internal entity declaration;i
+		     * see "4.3.2 Well-Formed Parsed Entities". 
+		     * IMHO 2.4 and 4.3.2 are directly in contradiction.
+		     * Looking at the OASIS test suite and James Clark 
+		     * tests, this is broken. However the XML REC uses
+		     * it. Is the XML REC not well-formed ????
+		     * This is a hack to avoid this problem
+		     *
+		     * ANSWER: since lt gt amp .. are already defined,
+		     *   this is a redefinition and hence the fact that the
+		     *   content is not well balanced is not a Wf error, this
+		     *   is lousy but acceptable.
+		     */
+		    list = xmlNewDocText(ctxt->myDoc, value);
+		    if (list != NULL) {
+			if ((ent->etype == XML_INTERNAL_GENERAL_ENTITY) &&
+			    (ent->children == NULL)) {
+			    ent->children = list;
+			    ent->last = list;
+			    ent->owner = 1;
+			    list->parent = (xmlNodePtr) ent;
+			} else {
+			    xmlFreeNodeList(list);
+			}
+		    } else if (list != NULL) {
+			xmlFreeNodeList(list);
+		    }
+		} else {
+		    /*
+		     * 4.3.2: An internal general parsed entity is well-formed
+		     * if its replacement text matches the production labeled
+		     * content.
+		     */
+
+		    void *user_data;
+		    /*
+		     * This is a bit hackish but this seems the best
+		     * way to make sure both SAX and DOM entity support
+		     * behaves okay.
+		     */
+		    if (ctxt->userData == ctxt)
+			user_data = NULL;
+		    else
+			user_data = ctxt->userData;
+
+		    if (ent->etype == XML_INTERNAL_GENERAL_ENTITY) {
+			ctxt->depth++;
+			ret = xmlParseBalancedChunkMemoryInternal(ctxt,
+					   value, user_data, &list);
+			ctxt->depth--;
+		    } else if (ent->etype ==
+			       XML_EXTERNAL_GENERAL_PARSED_ENTITY) {
+			ctxt->depth++;
+			ret = xmlParseExternalEntityPrivate(ctxt->myDoc, ctxt,
+				   ctxt->sax, user_data, ctxt->depth,
+				   ent->URI, ent->ExternalID, &list);
+			ctxt->depth--;
+		    } else {
+			ret = XML_ERR_ENTITY_PE_INTERNAL;
+			xmlErrMsgStr(ctxt, XML_ERR_INTERNAL_ERROR,
+				     "invalid entity type found\n", NULL);
+		    }
+		    if (ret == XML_ERR_ENTITY_LOOP) {
+			xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
+			return;
+		    } else if ((ret == XML_ERR_OK) && (list != NULL)) {
+			if (((ent->etype == XML_INTERNAL_GENERAL_ENTITY) ||
+			 (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY))&&
+			    (ent->children == NULL)) {
+			    ent->children = list;
+			    if (ctxt->replaceEntities) {
+				/*
+				 * Prune it directly in the generated document
+				 * except for single text nodes.
+				 */
+				if ((list->type == XML_TEXT_NODE) &&
+				    (list->next == NULL)) {
+				    list->parent = (xmlNodePtr) ent;
+				    list = NULL;
+				    ent->owner = 1;
+				} else {
+				    ent->owner = 0;
+				    while (list != NULL) {
+					list->parent = (xmlNodePtr) ctxt->node;
+					list->doc = ctxt->myDoc;
+					if (list->next == NULL)
+					    ent->last = list;
+					list = list->next;
+			 	    }
+				    list = ent->children;
+#ifdef LIBXML_LEGACY_ENABLED
+				    if (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)
+				      xmlAddEntityReference(ent, list, NULL);
+#endif /* LIBXML_LEGACY_ENABLED */
+				}
+			    } else {
+				ent->owner = 1;
+				while (list != NULL) {
+				    list->parent = (xmlNodePtr) ent;
+				    if (list->next == NULL)
+					ent->last = list;
+				    list = list->next;
+				}
+			    }
+			} else {
+			    xmlFreeNodeList(list);
+			    list = NULL;
+			}
+		    } else if ((ret != XML_ERR_OK) &&
+		               (ret != XML_WAR_UNDECLARED_ENTITY)) {
+			xmlFatalErr(ctxt, ret, NULL);
+		    } else if (list != NULL) {
+			xmlFreeNodeList(list);
+			list = NULL;
+		    }
+		}
+	    }
+	    if ((ctxt->sax != NULL) && (ctxt->sax->reference != NULL) &&
+		(ctxt->replaceEntities == 0) && (!ctxt->disableSAX)) {
+		/*
+		 * Create a node.
+		 */
+		ctxt->sax->reference(ctxt->userData, ent->name);
+		return;
+	    } else if (ctxt->replaceEntities) {
+		if ((ctxt->node != NULL) && (ent->children != NULL)) {
+		    /*
+		     * Seems we are generating the DOM content, do
+		     * a simple tree copy for all references except the first
+		     * In the first occurrence list contains the replacement
+		     */
+		    if ((list == NULL) && (ent->owner == 0)) {
+			xmlNodePtr nw = NULL, cur, firstChild = NULL;
+			cur = ent->children;
+			while (cur != NULL) {
+			    nw = xmlCopyNode(cur, 1);
+			    if (nw != NULL) {
+				nw->_private = cur->_private;
+				if (firstChild == NULL){
+				    firstChild = nw;
+				}
+				xmlAddChild(ctxt->node, nw);
+			    }
+			    if (cur == ent->last)
+				break;
+			    cur = cur->next;
+			}
+#ifdef LIBXML_LEGACY_ENABLED
+			if (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)			      
+			  xmlAddEntityReference(ent, firstChild, nw);
+#endif /* LIBXML_LEGACY_ENABLED */
+		    } else if (list == NULL) {
+			xmlNodePtr nw = NULL, cur, next, last,
+			           firstChild = NULL;
+			/*
+			 * Copy the entity child list and make it the new
+			 * entity child list. The goal is to make sure any
+			 * ID or REF referenced will be the one from the
+			 * document content and not the entity copy.
+			 */
+			cur = ent->children;
+			ent->children = NULL;
+			last = ent->last;
+			ent->last = NULL;
+			while (cur != NULL) {
+			    next = cur->next;
+			    cur->next = NULL;
+			    cur->parent = NULL;
+			    nw = xmlCopyNode(cur, 1);
+			    if (nw != NULL) {
+				nw->_private = cur->_private;
+				if (firstChild == NULL){
+				    firstChild = cur;
+				}
+				xmlAddChild((xmlNodePtr) ent, nw);
+				xmlAddChild(ctxt->node, cur);
+			    }
+			    if (cur == last)
+				break;
+			    cur = next;
+			}
+			ent->owner = 1;
+#ifdef LIBXML_LEGACY_ENABLED
+			if (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)			      
+			  xmlAddEntityReference(ent, firstChild, nw);
+#endif /* LIBXML_LEGACY_ENABLED */
+		    } else {
+			/*
+			 * the name change is to avoid coalescing of the
+			 * node with a possible previous text one which
+			 * would make ent->children a dangling pointer
+			 */
+			if (ent->children->type == XML_TEXT_NODE)
+			    ent->children->name = xmlStrdup(BAD_CAST "nbktext");
+			if ((ent->last != ent->children) &&
+			    (ent->last->type == XML_TEXT_NODE))
+			    ent->last->name = xmlStrdup(BAD_CAST "nbktext");
+			xmlAddChildList(ctxt->node, ent->children);
+		    }
+
+		    /*
+		     * This is to avoid a nasty side effect, see
+		     * characters() in SAX.c
+		     */
+		    ctxt->nodemem = 0;
+		    ctxt->nodelen = 0;
+		    return;
+		} else {
+		    /*
+		     * Probably running in SAX mode
+		     */
+		    xmlParserInputPtr input;
+
+		    input = xmlNewEntityInputStream(ctxt, ent);
+		    xmlPushInput(ctxt, input);
+		    if ((ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY) &&
+			(CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) &&
+			(IS_BLANK_CH(NXT(5)))) {
+			xmlParseTextDecl(ctxt);
+			if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
+			    /*
+			     * The XML REC instructs us to stop parsing right here
+			     */
+			    ctxt->instate = XML_PARSER_EOF;
+			    return;
+			}
+			if (input->standalone == 1) {
+			    xmlFatalErr(ctxt, XML_ERR_EXT_ENTITY_STANDALONE,
+			                NULL);
+			}
+		    }
+		    return;
+		}
+	    }
+	} else {
+	    val = ent->content;
+	    if (val == NULL) return;
+	    /*
+	     * inline the entity.
+	     */
+	    if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL) &&
+		(!ctxt->disableSAX))
+		ctxt->sax->characters(ctxt->userData, val, xmlStrlen(val));
+	}
+    }
+}
+
+/**
+ * xmlParseEntityRef:
+ * @ctxt:  an XML parser context
+ *
+ * parse ENTITY references declarations
+ *
+ * [68] EntityRef ::= '&' Name ';'
+ *
+ * [ WFC: Entity Declared ]
+ * In a document without any DTD, a document with only an internal DTD
+ * subset which contains no parameter entity references, or a document
+ * with "standalone='yes'", the Name given in the entity reference
+ * must match that in an entity declaration, except that well-formed
+ * documents need not declare any of the following entities: amp, lt,
+ * gt, apos, quot.  The declaration of a parameter entity must precede
+ * any reference to it.  Similarly, the declaration of a general entity
+ * must precede any reference to it which appears in a default value in an
+ * attribute-list declaration. Note that if entities are declared in the
+ * external subset or in external parameter entities, a non-validating
+ * processor is not obligated to read and process their declarations;
+ * for such documents, the rule that an entity must be declared is a
+ * well-formedness constraint only if standalone='yes'.
+ *
+ * [ WFC: Parsed Entity ]
+ * An entity reference must not contain the name of an unparsed entity
+ *
+ * Returns the xmlEntityPtr if found, or NULL otherwise.
+ */
+xmlEntityPtr
+xmlParseEntityRef(xmlParserCtxtPtr ctxt) {
+    const xmlChar *name;
+    xmlEntityPtr ent = NULL;
+
+    GROW;
+    
+    if (RAW == '&') {
+        NEXT;
+        name = xmlParseName(ctxt);
+	if (name == NULL) {
+	    xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
+			   "xmlParseEntityRef: no name\n");
+	} else {
+	    if (RAW == ';') {
+	        NEXT;
+		/*
+		 * Ask first SAX for entity resolution, otherwise try the
+		 * predefined set.
+		 */
+		if (ctxt->sax != NULL) {
+		    if (ctxt->sax->getEntity != NULL)
+			ent = ctxt->sax->getEntity(ctxt->userData, name);
+		    if ((ctxt->wellFormed == 1 ) && (ent == NULL))
+		        ent = xmlGetPredefinedEntity(name);
+		    if ((ctxt->wellFormed == 1 ) && (ent == NULL) &&
+			(ctxt->userData==ctxt)) {
+			ent = xmlSAX2GetEntity(ctxt, name);
+		    }
+		}
+		/*
+		 * [ WFC: Entity Declared ]
+		 * In a document without any DTD, a document with only an
+		 * internal DTD subset which contains no parameter entity
+		 * references, or a document with "standalone='yes'", the
+		 * Name given in the entity reference must match that in an
+		 * entity declaration, except that well-formed documents
+		 * need not declare any of the following entities: amp, lt,
+		 * gt, apos, quot.
+		 * The declaration of a parameter entity must precede any
+		 * reference to it.
+		 * Similarly, the declaration of a general entity must
+		 * precede any reference to it which appears in a default
+		 * value in an attribute-list declaration. Note that if
+		 * entities are declared in the external subset or in
+		 * external parameter entities, a non-validating processor
+		 * is not obligated to read and process their declarations;
+		 * for such documents, the rule that an entity must be
+		 * declared is a well-formedness constraint only if
+		 * standalone='yes'. 
+		 */
+		if (ent == NULL) {
+		    if ((ctxt->standalone == 1) ||
+		        ((ctxt->hasExternalSubset == 0) &&
+			 (ctxt->hasPErefs == 0))) {
+			xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
+				 "Entity '%s' not defined\n", name);
+		    } else {
+		        xmlErrMsgStr(ctxt, XML_WAR_UNDECLARED_ENTITY,
+				 "Entity '%s' not defined\n", name);
+		    }
+		    ctxt->valid = 0;
+		}
+
+		/*
+		 * [ WFC: Parsed Entity ]
+		 * An entity reference must not contain the name of an
+		 * unparsed entity
+		 */
+		else if (ent->etype == XML_EXTERNAL_GENERAL_UNPARSED_ENTITY) {
+		    xmlFatalErrMsgStr(ctxt, XML_ERR_UNPARSED_ENTITY,
+			     "Entity reference to unparsed entity %s\n", name);
+		}
+
+		/*
+		 * [ WFC: No External Entity References ]
+		 * Attribute values cannot contain direct or indirect
+		 * entity references to external entities.
+		 */
+		else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
+		         (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)) {
+		    xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_EXTERNAL,
+			 "Attribute references external entity '%s'\n", name);
+		}
+		/*
+		 * [ WFC: No < in Attribute Values ]
+		 * The replacement text of any entity referred to directly or
+		 * indirectly in an attribute value (other than "&lt;") must
+		 * not contain a <. 
+		 */
+		else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
+		         (ent != NULL) &&
+			 (!xmlStrEqual(ent->name, BAD_CAST "lt")) &&
+		         (ent->content != NULL) &&
+			 (xmlStrchr(ent->content, '<'))) {
+		    xmlFatalErrMsgStr(ctxt, XML_ERR_LT_IN_ATTRIBUTE,
+	 "'<' in entity '%s' is not allowed in attributes values\n", name);
+		}
+
+		/*
+		 * Internal check, no parameter entities here ...
+		 */
+		else {
+		    switch (ent->etype) {
+			case XML_INTERNAL_PARAMETER_ENTITY:
+			case XML_EXTERNAL_PARAMETER_ENTITY:
+			xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_PARAMETER,
+			 "Attempt to reference the parameter entity '%s'\n",
+		                          name);
+			break;
+			default:
+			break;
+		    }
+		}
+
+		/*
+		 * [ WFC: No Recursion ]
+		 * A parsed entity must not contain a recursive reference
+		 * to itself, either directly or indirectly. 
+		 * Done somewhere else
+		 */
+
+	    } else {
+		xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
+	    }
+	}
+    }
+    return(ent);
+}
+
+/**
+ * xmlParseStringEntityRef:
+ * @ctxt:  an XML parser context
+ * @str:  a pointer to an index in the string
+ *
+ * parse ENTITY references declarations, but this version parses it from
+ * a string value.
+ *
+ * [68] EntityRef ::= '&' Name ';'
+ *
+ * [ WFC: Entity Declared ]
+ * In a document without any DTD, a document with only an internal DTD
+ * subset which contains no parameter entity references, or a document
+ * with "standalone='yes'", the Name given in the entity reference
+ * must match that in an entity declaration, except that well-formed
+ * documents need not declare any of the following entities: amp, lt,
+ * gt, apos, quot.  The declaration of a parameter entity must precede
+ * any reference to it.  Similarly, the declaration of a general entity
+ * must precede any reference to it which appears in a default value in an
+ * attribute-list declaration. Note that if entities are declared in the
+ * external subset or in external parameter entities, a non-validating
+ * processor is not obligated to read and process their declarations;
+ * for such documents, the rule that an entity must be declared is a
+ * well-formedness constraint only if standalone='yes'.
+ *
+ * [ WFC: Parsed Entity ]
+ * An entity reference must not contain the name of an unparsed entity
+ *
+ * Returns the xmlEntityPtr if found, or NULL otherwise. The str pointer
+ * is updated to the current location in the string.
+ */
+xmlEntityPtr
+xmlParseStringEntityRef(xmlParserCtxtPtr ctxt, const xmlChar ** str) {
+    xmlChar *name;
+    const xmlChar *ptr;
+    xmlChar cur;
+    xmlEntityPtr ent = NULL;
+
+    if ((str == NULL) || (*str == NULL))
+        return(NULL);
+    ptr = *str;
+    cur = *ptr;
+    if (cur == '&') {
+        ptr++;
+	cur = *ptr;
+        name = xmlParseStringName(ctxt, &ptr);
+	if (name == NULL) {
+	    xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
+			   "xmlParseStringEntityRef: no name\n");
+	} else {
+	    if (*ptr == ';') {
+	        ptr++;
+		/*
+		 * Ask first SAX for entity resolution, otherwise try the
+		 * predefined set.
+		 */
+		if (ctxt->sax != NULL) {
+		    if (ctxt->sax->getEntity != NULL)
+			ent = ctxt->sax->getEntity(ctxt->userData, name);
+		    if (ent == NULL)
+		        ent = xmlGetPredefinedEntity(name);
+		    if ((ent == NULL) && (ctxt->userData==ctxt)) {
+			ent = xmlSAX2GetEntity(ctxt, name);
+		    }
+		}
+		/*
+		 * [ WFC: Entity Declared ]
+		 * In a document without any DTD, a document with only an
+		 * internal DTD subset which contains no parameter entity
+		 * references, or a document with "standalone='yes'", the
+		 * Name given in the entity reference must match that in an
+		 * entity declaration, except that well-formed documents
+		 * need not declare any of the following entities: amp, lt,
+		 * gt, apos, quot.
+		 * The declaration of a parameter entity must precede any
+		 * reference to it.
+		 * Similarly, the declaration of a general entity must
+		 * precede any reference to it which appears in a default
+		 * value in an attribute-list declaration. Note that if
+		 * entities are declared in the external subset or in
+		 * external parameter entities, a non-validating processor
+		 * is not obligated to read and process their declarations;
+		 * for such documents, the rule that an entity must be
+		 * declared is a well-formedness constraint only if
+		 * standalone='yes'. 
+		 */
+		if (ent == NULL) {
+		    if ((ctxt->standalone == 1) ||
+		        ((ctxt->hasExternalSubset == 0) &&
+			 (ctxt->hasPErefs == 0))) {
+			xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
+				 "Entity '%s' not defined\n", name);
+		    } else {
+			xmlErrMsgStr(ctxt, XML_WAR_UNDECLARED_ENTITY,
+				      "Entity '%s' not defined\n",
+				      name);
+		    }
+		    /* TODO ? check regressions ctxt->valid = 0; */
+		}
+
+		/*
+		 * [ WFC: Parsed Entity ]
+		 * An entity reference must not contain the name of an
+		 * unparsed entity
+		 */
+		else if (ent->etype == XML_EXTERNAL_GENERAL_UNPARSED_ENTITY) {
+		    xmlFatalErrMsgStr(ctxt, XML_ERR_UNPARSED_ENTITY,
+			     "Entity reference to unparsed entity %s\n", name);
+		}
+
+		/*
+		 * [ WFC: No External Entity References ]
+		 * Attribute values cannot contain direct or indirect
+		 * entity references to external entities.
+		 */
+		else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
+		         (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)) {
+		    xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_EXTERNAL,
+		     "Attribute references external entity '%s'\n", name);
+		}
+		/*
+		 * [ WFC: No < in Attribute Values ]
+		 * The replacement text of any entity referred to directly or
+		 * indirectly in an attribute value (other than "&lt;") must
+		 * not contain a <. 
+		 */
+		else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
+		         (ent != NULL) &&
+			 (!xmlStrEqual(ent->name, BAD_CAST "lt")) &&
+		         (ent->content != NULL) &&
+			 (xmlStrchr(ent->content, '<'))) {
+		    xmlFatalErrMsgStr(ctxt, XML_ERR_LT_IN_ATTRIBUTE,
+		 "'<' in entity '%s' is not allowed in attributes values\n",
+	                              name);
+		}
+
+		/*
+		 * Internal check, no parameter entities here ...
+		 */
+		else {
+		    switch (ent->etype) {
+			case XML_INTERNAL_PARAMETER_ENTITY:
+			case XML_EXTERNAL_PARAMETER_ENTITY:
+			    xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_PARAMETER,
+			 "Attempt to reference the parameter entity '%s'\n",
+			                      name);
+			break;
+			default:
+			break;
+		    }
+		}
+
+		/*
+		 * [ WFC: No Recursion ]
+		 * A parsed entity must not contain a recursive reference
+		 * to itself, either directly or indirectly. 
+		 * Done somewhere else
+		 */
+
+	    } else {
+		xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
+	    }
+	    xmlFree(name);
+	}
+    }
+    *str = ptr;
+    return(ent);
+}
+
+/**
+ * xmlParsePEReference:
+ * @ctxt:  an XML parser context
+ *
+ * parse PEReference declarations
+ * The entity content is handled directly by pushing it's content as
+ * a new input stream.
+ *
+ * [69] PEReference ::= '%' Name ';'
+ *
+ * [ WFC: No Recursion ]
+ * A parsed entity must not contain a recursive
+ * reference to itself, either directly or indirectly. 
+ *
+ * [ WFC: Entity Declared ]
+ * In a document without any DTD, a document with only an internal DTD
+ * subset which contains no parameter entity references, or a document
+ * with "standalone='yes'", ...  ... The declaration of a parameter
+ * entity must precede any reference to it...
+ *
+ * [ VC: Entity Declared ]
+ * In a document with an external subset or external parameter entities
+ * with "standalone='no'", ...  ... The declaration of a parameter entity
+ * must precede any reference to it...
+ *
+ * [ WFC: In DTD ]
+ * Parameter-entity references may only appear in the DTD.
+ * NOTE: misleading but this is handled.
+ */
+void
+xmlParsePEReference(xmlParserCtxtPtr ctxt)
+{
+    const xmlChar *name;
+    xmlEntityPtr entity = NULL;
+    xmlParserInputPtr input;
+
+    if (RAW == '%') {
+        NEXT;
+        name = xmlParseName(ctxt);
+        if (name == NULL) {
+            xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
+                           "xmlParsePEReference: no name\n");
+        } else {
+            if (RAW == ';') {
+                NEXT;
+                if ((ctxt->sax != NULL) &&
+                    (ctxt->sax->getParameterEntity != NULL))
+                    entity = ctxt->sax->getParameterEntity(ctxt->userData,
+                                                           name);
+                if (entity == NULL) {
+                    /*
+                     * [ WFC: Entity Declared ]
+                     * In a document without any DTD, a document with only an
+                     * internal DTD subset which contains no parameter entity
+                     * references, or a document with "standalone='yes'", ...
+                     * ... The declaration of a parameter entity must precede
+                     * any reference to it...
+                     */
+                    if ((ctxt->standalone == 1) ||
+                        ((ctxt->hasExternalSubset == 0) &&
+                         (ctxt->hasPErefs == 0))) {
+                        xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
+                                          "PEReference: %%%s; not found\n",
+                                          name);
+                    } else {
+                        /*
+                         * [ VC: Entity Declared ]
+                         * In a document with an external subset or external
+                         * parameter entities with "standalone='no'", ...
+                         * ... The declaration of a parameter entity must
+			 * precede any reference to it...
+                         */
+                        xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
+                                      "PEReference: %%%s; not found\n",
+                                      name, NULL);
+                        ctxt->valid = 0;
+                    }
+                } else {
+                    /*
+                     * Internal checking in case the entity quest barfed
+                     */
+                    if ((entity->etype != XML_INTERNAL_PARAMETER_ENTITY) &&
+                        (entity->etype != XML_EXTERNAL_PARAMETER_ENTITY)) {
+                        xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
+			      "Internal: %%%s; is not a parameter entity\n",
+                                      name, NULL);
+                    } else if (ctxt->input->free != deallocblankswrapper) {
+                        input =
+                            xmlNewBlanksWrapperInputStream(ctxt, entity);
+                        xmlPushInput(ctxt, input);
+                    } else {
+                        /*
+                         * TODO !!!
+                         * handle the extra spaces added before and after
+                         * c.f. http://www.w3.org/TR/REC-xml#as-PE
+                         */
+                        input = xmlNewEntityInputStream(ctxt, entity);
+                        xmlPushInput(ctxt, input);
+                        if ((entity->etype == XML_EXTERNAL_PARAMETER_ENTITY) &&
+			    (CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) &&
+			    (IS_BLANK_CH(NXT(5)))) {
+                            xmlParseTextDecl(ctxt);
+                            if (ctxt->errNo ==
+                                XML_ERR_UNSUPPORTED_ENCODING) {
+                                /*
+                                 * The XML REC instructs us to stop parsing
+                                 * right here
+                                 */
+                                ctxt->instate = XML_PARSER_EOF;
+                                return;
+                            }
+                        }
+                    }
+                }
+                ctxt->hasPErefs = 1;
+            } else {
+                xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
+            }
+        }
+    }
+}
+
+/**
+ * xmlParseStringPEReference:
+ * @ctxt:  an XML parser context
+ * @str:  a pointer to an index in the string
+ *
+ * parse PEReference declarations
+ *
+ * [69] PEReference ::= '%' Name ';'
+ *
+ * [ WFC: No Recursion ]
+ * A parsed entity must not contain a recursive
+ * reference to itself, either directly or indirectly. 
+ *
+ * [ WFC: Entity Declared ]
+ * In a document without any DTD, a document with only an internal DTD
+ * subset which contains no parameter entity references, or a document
+ * with "standalone='yes'", ...  ... The declaration of a parameter
+ * entity must precede any reference to it...
+ *
+ * [ VC: Entity Declared ]
+ * In a document with an external subset or external parameter entities
+ * with "standalone='no'", ...  ... The declaration of a parameter entity
+ * must precede any reference to it...
+ *
+ * [ WFC: In DTD ]
+ * Parameter-entity references may only appear in the DTD.
+ * NOTE: misleading but this is handled.
+ *
+ * Returns the string of the entity content.
+ *         str is updated to the current value of the index
+ */
+xmlEntityPtr
+xmlParseStringPEReference(xmlParserCtxtPtr ctxt, const xmlChar **str) {
+    const xmlChar *ptr;
+    xmlChar cur;
+    xmlChar *name;
+    xmlEntityPtr entity = NULL;
+
+    if ((str == NULL) || (*str == NULL)) return(NULL);
+    ptr = *str;
+    cur = *ptr;
+    if (cur == '%') {
+        ptr++;
+	cur = *ptr;
+        name = xmlParseStringName(ctxt, &ptr);
+	if (name == NULL) {
+	    xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
+			   "xmlParseStringPEReference: no name\n");
+	} else {
+	    cur = *ptr;
+	    if (cur == ';') {
+		ptr++;
+		cur = *ptr;
+		if ((ctxt->sax != NULL) &&
+		    (ctxt->sax->getParameterEntity != NULL))
+		    entity = ctxt->sax->getParameterEntity(ctxt->userData,
+		                                           name);
+		if (entity == NULL) {
+		    /*
+		     * [ WFC: Entity Declared ]
+		     * In a document without any DTD, a document with only an
+		     * internal DTD subset which contains no parameter entity
+		     * references, or a document with "standalone='yes'", ...
+		     * ... The declaration of a parameter entity must precede
+		     * any reference to it...
+		     */
+		    if ((ctxt->standalone == 1) ||
+			((ctxt->hasExternalSubset == 0) &&
+			 (ctxt->hasPErefs == 0))) {
+			xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
+			     "PEReference: %%%s; not found\n", name);
+		    } else {
+			/*
+			 * [ VC: Entity Declared ]
+			 * In a document with an external subset or external
+			 * parameter entities with "standalone='no'", ...
+			 * ... The declaration of a parameter entity must
+			 * precede any reference to it...
+			 */
+			xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
+				      "PEReference: %%%s; not found\n",
+			              name, NULL);
+			ctxt->valid = 0;
+		    }
+		} else {
+		    /*
+		     * Internal checking in case the entity quest barfed
+		     */
+		    if ((entity->etype != XML_INTERNAL_PARAMETER_ENTITY) &&
+		        (entity->etype != XML_EXTERNAL_PARAMETER_ENTITY)) {
+			xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
+			              "%%%s; is not a parameter entity\n",
+				      name, NULL);
+		    }
+		}
+		ctxt->hasPErefs = 1;
+	    } else {
+		xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
+	    }
+	    xmlFree(name);
+	}
+    }
+    *str = ptr;
+    return(entity);
+}
+
+/**
+ * xmlParseDocTypeDecl:
+ * @ctxt:  an XML parser context
+ *
+ * parse a DOCTYPE declaration
+ *
+ * [28] doctypedecl ::= '<!DOCTYPE' S Name (S ExternalID)? S? 
+ *                      ('[' (markupdecl | PEReference | S)* ']' S?)? '>'
+ *
+ * [ VC: Root Element Type ]
+ * The Name in the document type declaration must match the element
+ * type of the root element. 
+ */
+
+void
+xmlParseDocTypeDecl(xmlParserCtxtPtr ctxt) {
+    const xmlChar *name = NULL;
+    xmlChar *ExternalID = NULL;
+    xmlChar *URI = NULL;
+
+    /*
+     * We know that '<!DOCTYPE' has been detected.
+     */
+    SKIP(9);
+
+    SKIP_BLANKS;
+
+    /*
+     * Parse the DOCTYPE name.
+     */
+    name = xmlParseName(ctxt);
+    if (name == NULL) {
+	xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
+		       "xmlParseDocTypeDecl : no DOCTYPE name !\n");
+    }
+    ctxt->intSubName = name;
+
+    SKIP_BLANKS;
+
+    /*
+     * Check for SystemID and ExternalID
+     */
+    URI = xmlParseExternalID(ctxt, &ExternalID, 1);
+
+    if ((URI != NULL) || (ExternalID != NULL)) {
+        ctxt->hasExternalSubset = 1;
+    }
+    ctxt->extSubURI = URI;
+    ctxt->extSubSystem = ExternalID;
+
+    SKIP_BLANKS;
+
+    /*
+     * Create and update the internal subset.
+     */
+    if ((ctxt->sax != NULL) && (ctxt->sax->internalSubset != NULL) &&
+	(!ctxt->disableSAX))
+	ctxt->sax->internalSubset(ctxt->userData, name, ExternalID, URI);
+
+    /*
+     * Is there any internal subset declarations ?
+     * they are handled separately in xmlParseInternalSubset()
+     */
+    if (RAW == '[')
+	return;
+
+    /*
+     * We should be at the end of the DOCTYPE declaration.
+     */
+    if (RAW != '>') {
+	xmlFatalErr(ctxt, XML_ERR_DOCTYPE_NOT_FINISHED, NULL);
+    }
+    NEXT;
+}
+
+/**
+ * xmlParseInternalSubset:
+ * @ctxt:  an XML parser context
+ *
+ * parse the internal subset declaration
+ *
+ * [28 end] ('[' (markupdecl | PEReference | S)* ']' S?)? '>'
+ */
+
+static void
+xmlParseInternalSubset(xmlParserCtxtPtr ctxt) {
+    /*
+     * Is there any DTD definition ?
+     */
+    if (RAW == '[') {
+        ctxt->instate = XML_PARSER_DTD;
+        NEXT;
+	/*
+	 * Parse the succession of Markup declarations and 
+	 * PEReferences.
+	 * Subsequence (markupdecl | PEReference | S)*
+	 */
+	while (RAW != ']') {
+	    const xmlChar *check = CUR_PTR;
+	    unsigned int cons = ctxt->input->consumed;
+
+	    SKIP_BLANKS;
+	    xmlParseMarkupDecl(ctxt);
+	    xmlParsePEReference(ctxt);
+
+	    /*
+	     * Pop-up of finished entities.
+	     */
+	    while ((RAW == 0) && (ctxt->inputNr > 1))
+		xmlPopInput(ctxt);
+
+	    if ((CUR_PTR == check) && (cons == ctxt->input->consumed)) {
+		xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
+	     "xmlParseInternalSubset: error detected in Markup declaration\n");
+		break;
+	    }
+	}
+	if (RAW == ']') { 
+	    NEXT;
+	    SKIP_BLANKS;
+	}
+    }
+
+    /*
+     * We should be at the end of the DOCTYPE declaration.
+     */
+    if (RAW != '>') {
+	xmlFatalErr(ctxt, XML_ERR_DOCTYPE_NOT_FINISHED, NULL);
+    }
+    NEXT;
+}
+
+#ifdef LIBXML_SAX1_ENABLED
+/**
+ * xmlParseAttribute:
+ * @ctxt:  an XML parser context
+ * @value:  a xmlChar ** used to store the value of the attribute
+ *
+ * parse an attribute
+ *
+ * [41] Attribute ::= Name Eq AttValue
+ *
+ * [ WFC: No External Entity References ]
+ * Attribute values cannot contain direct or indirect entity references
+ * to external entities.
+ *
+ * [ WFC: No < in Attribute Values ]
+ * The replacement text of any entity referred to directly or indirectly in
+ * an attribute value (other than "&lt;") must not contain a <. 
+ * 
+ * [ VC: Attribute Value Type ]
+ * The attribute must have been declared; the value must be of the type
+ * declared for it.
+ *
+ * [25] Eq ::= S? '=' S?
+ *
+ * With namespace:
+ *
+ * [NS 11] Attribute ::= QName Eq AttValue
+ *
+ * Also the case QName == xmlns:??? is handled independently as a namespace
+ * definition.
+ *
+ * Returns the attribute name, and the value in *value.
+ */
+
+const xmlChar *
+xmlParseAttribute(xmlParserCtxtPtr ctxt, xmlChar **value) {
+    const xmlChar *name;
+    xmlChar *val;
+
+    *value = NULL;
+    GROW;
+    name = xmlParseName(ctxt);
+    if (name == NULL) {
+	xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
+	               "error parsing attribute name\n");
+        return(NULL);
+    }
+
+    /*
+     * read the value
+     */
+    SKIP_BLANKS;
+    if (RAW == '=') {
+        NEXT;
+	SKIP_BLANKS;
+	val = xmlParseAttValue(ctxt);
+	ctxt->instate = XML_PARSER_CONTENT;
+    } else {
+	xmlFatalErrMsgStr(ctxt, XML_ERR_ATTRIBUTE_WITHOUT_VALUE,
+	       "Specification mandate value for attribute %s\n", name);
+	return(NULL);
+    }
+
+    /*
+     * Check that xml:lang conforms to the specification
+     * No more registered as an error, just generate a warning now
+     * since this was deprecated in XML second edition
+     */
+    if ((ctxt->pedantic) && (xmlStrEqual(name, BAD_CAST "xml:lang"))) {
+	if (!xmlCheckLanguageID(val)) {
+	    xmlWarningMsg(ctxt, XML_WAR_LANG_VALUE,
+		          "Malformed value for xml:lang : %s\n",
+			  val, NULL);
+	}
+    }
+
+    /*
+     * Check that xml:space conforms to the specification
+     */
+    if (xmlStrEqual(name, BAD_CAST "xml:space")) {
+	if (xmlStrEqual(val, BAD_CAST "default"))
+	    *(ctxt->space) = 0;
+	else if (xmlStrEqual(val, BAD_CAST "preserve"))
+	    *(ctxt->space) = 1;
+	else {
+	    xmlFatalErrMsgStr(ctxt, XML_ERR_ATTRIBUTE_WITHOUT_VALUE,
+"Invalid value \"%s\" for xml:space : \"default\" or \"preserve\" expected\n",
+                                 val);
+	}
+    }
+
+    *value = val;
+    return(name);
+}
+
+/**
+ * xmlParseStartTag:
+ * @ctxt:  an XML parser context
+ * 
+ * parse a start of tag either for rule element or
+ * EmptyElement. In both case we don't parse the tag closing chars.
+ *
+ * [40] STag ::= '<' Name (S Attribute)* S? '>'
+ *
+ * [ WFC: Unique Att Spec ]
+ * No attribute name may appear more than once in the same start-tag or
+ * empty-element tag. 
+ *
+ * [44] EmptyElemTag ::= '<' Name (S Attribute)* S? '/>'
+ *
+ * [ WFC: Unique Att Spec ]
+ * No attribute name may appear more than once in the same start-tag or
+ * empty-element tag. 
+ *
+ * With namespace:
+ *
+ * [NS 8] STag ::= '<' QName (S Attribute)* S? '>'
+ *
+ * [NS 10] EmptyElement ::= '<' QName (S Attribute)* S? '/>'
+ *
+ * Returns the element name parsed
+ */
+
+const xmlChar *
+xmlParseStartTag(xmlParserCtxtPtr ctxt) {
+    const xmlChar *name;
+    const xmlChar *attname;
+    xmlChar *attvalue;
+    const xmlChar **atts = ctxt->atts;
+    int nbatts = 0;
+    int maxatts = ctxt->maxatts;
+    int i;
+
+    if (RAW != '<') return(NULL);
+    NEXT1;
+
+    name = xmlParseName(ctxt);
+    if (name == NULL) {
+	xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
+	     "xmlParseStartTag: invalid element name\n");
+        return(NULL);
+    }
+
+    /*
+     * Now parse the attributes, it ends up with the ending
+     *
+     * (S Attribute)* S?
+     */
+    SKIP_BLANKS;
+    GROW;
+
+    while ((RAW != '>') && 
+	   ((RAW != '/') || (NXT(1) != '>')) &&
+	   (IS_BYTE_CHAR(RAW))) {
+	const xmlChar *q = CUR_PTR;
+	unsigned int cons = ctxt->input->consumed;
+
+	attname = xmlParseAttribute(ctxt, &attvalue);
+        if ((attname != NULL) && (attvalue != NULL)) {
+	    /*
+	     * [ WFC: Unique Att Spec ]
+	     * No attribute name may appear more than once in the same
+	     * start-tag or empty-element tag. 
+	     */
+	    for (i = 0; i < nbatts;i += 2) {
+	        if (xmlStrEqual(atts[i], attname)) {
+		    xmlErrAttributeDup(ctxt, NULL, attname);
+		    xmlFree(attvalue);
+		    goto failed;
+		}
+	    }
+	    /*
+	     * Add the pair to atts
+	     */
+	    if (atts == NULL) {
+	        maxatts = 22; /* allow for 10 attrs by default */
+	        atts = (const xmlChar **)
+		       xmlMalloc(maxatts * sizeof(xmlChar *));
+		if (atts == NULL) {
+		    xmlErrMemory(ctxt, NULL);
+		    if (attvalue != NULL)
+			xmlFree(attvalue);
+		    goto failed;
+		}
+		ctxt->atts = atts;
+		ctxt->maxatts = maxatts;
+	    } else if (nbatts + 4 > maxatts) {
+	        const xmlChar **n;
+
+	        maxatts *= 2;
+	        n = (const xmlChar **) xmlRealloc((void *) atts,
+					     maxatts * sizeof(const xmlChar *));
+		if (n == NULL) {
+		    xmlErrMemory(ctxt, NULL);
+		    if (attvalue != NULL)
+			xmlFree(attvalue);
+		    goto failed;
+		}
+		atts = n;
+		ctxt->atts = atts;
+		ctxt->maxatts = maxatts;
+	    }
+	    atts[nbatts++] = attname;
+	    atts[nbatts++] = attvalue;
+	    atts[nbatts] = NULL;
+	    atts[nbatts + 1] = NULL;
+	} else {
+	    if (attvalue != NULL)
+		xmlFree(attvalue);
+	}
+
+failed:     
+
+	GROW
+	if ((RAW == '>') || (((RAW == '/') && (NXT(1) == '>'))))
+	    break;
+	if (!IS_BLANK_CH(RAW)) {
+	    xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
+			   "attributes construct error\n");
+	}
+	SKIP_BLANKS;
+        if ((cons == ctxt->input->consumed) && (q == CUR_PTR) &&
+            (attname == NULL) && (attvalue == NULL)) {
+	    xmlFatalErrMsg(ctxt, XML_ERR_INTERNAL_ERROR,
+			   "xmlParseStartTag: problem parsing attributes\n");
+	    break;
+	}
+	SHRINK;
+        GROW;
+    }
+
+    /*
+     * SAX: Start of Element !
+     */
+    if ((ctxt->sax != NULL) && (ctxt->sax->startElement != NULL) &&
+	(!ctxt->disableSAX)) {
+	if (nbatts > 0)
+	    ctxt->sax->startElement(ctxt->userData, name, atts);
+	else
+	    ctxt->sax->startElement(ctxt->userData, name, NULL);
+    }
+
+    if (atts != NULL) {
+        /* Free only the content strings */
+        for (i = 1;i < nbatts;i+=2)
+	    if (atts[i] != NULL)
+	       xmlFree((xmlChar *) atts[i]);
+    }
+    return(name);
+}
+
+/**
+ * xmlParseEndTag1:
+ * @ctxt:  an XML parser context
+ * @line:  line of the start tag
+ * @nsNr:  number of namespaces on the start tag
+ *
+ * parse an end of tag
+ *
+ * [42] ETag ::= '</' Name S? '>'
+ *
+ * With namespace
+ *
+ * [NS 9] ETag ::= '</' QName S? '>'
+ */
+
+static void
+xmlParseEndTag1(xmlParserCtxtPtr ctxt, int line) {
+    const xmlChar *name;
+
+    GROW;
+    if ((RAW != '<') || (NXT(1) != '/')) {
+	xmlFatalErrMsg(ctxt, XML_ERR_LTSLASH_REQUIRED,
+		       "xmlParseEndTag: '</' not found\n");
+	return;
+    }
+    SKIP(2);
+
+    name = xmlParseNameAndCompare(ctxt,ctxt->name);
+
+    /*
+     * We should definitely be at the ending "S? '>'" part
+     */
+    GROW;
+    SKIP_BLANKS;
+    if ((!IS_BYTE_CHAR(RAW)) || (RAW != '>')) {
+	xmlFatalErr(ctxt, XML_ERR_GT_REQUIRED, NULL);
+    } else
+	NEXT1;
+
+    /*
+     * [ WFC: Element Type Match ]
+     * The Name in an element's end-tag must match the element type in the
+     * start-tag. 
+     *
+     */
+    if (name != (xmlChar*)1) {
+        if (name == NULL) name = BAD_CAST "unparseable";
+        xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_TAG_NAME_MISMATCH,
+		     "Opening and ending tag mismatch: %s line %d and %s\n",
+		                ctxt->name, line, name);
+    }
+
+    /*
+     * SAX: End of Tag
+     */
+    if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL) &&
+	(!ctxt->disableSAX))
+        ctxt->sax->endElement(ctxt->userData, ctxt->name);
+
+    namePop(ctxt);
+    spacePop(ctxt);
+    return;
+}
+
+/**
+ * xmlParseEndTag:
+ * @ctxt:  an XML parser context
+ *
+ * parse an end of tag
+ *
+ * [42] ETag ::= '</' Name S? '>'
+ *
+ * With namespace
+ *
+ * [NS 9] ETag ::= '</' QName S? '>'
+ */
+
+void
+xmlParseEndTag(xmlParserCtxtPtr ctxt) {
+    xmlParseEndTag1(ctxt, 0);
+}
+#endif /* LIBXML_SAX1_ENABLED */
+
+/************************************************************************
+ *									*
+ *		      SAX 2 specific operations				*
+ *									*
+ ************************************************************************/
+
+static const xmlChar *
+xmlParseNCNameComplex(xmlParserCtxtPtr ctxt) {
+    int len = 0, l;
+    int c;
+    int count = 0;
+
+    /*
+     * Handler for more complex cases
+     */
+    GROW;
+    c = CUR_CHAR(l);
+    if ((c == ' ') || (c == '>') || (c == '/') || /* accelerators */
+	(!IS_LETTER(c) && (c != '_'))) {
+	return(NULL);
+    }
+
+    while ((c != ' ') && (c != '>') && (c != '/') && /* test bigname.xml */
+	   ((IS_LETTER(c)) || (IS_DIGIT(c)) ||
+            (c == '.') || (c == '-') || (c == '_') ||
+	    (IS_COMBINING(c)) ||
+	    (IS_EXTENDER(c)))) {
+	if (count++ > 100) {
+	    count = 0;
+	    GROW;
+	}
+	len += l;
+	NEXTL(l);
+	c = CUR_CHAR(l);
+    }
+    return(xmlDictLookup(ctxt->dict, ctxt->input->cur - len, len));
+}
+
+/*
+ * xmlGetNamespace:
+ * @ctxt:  an XML parser context
+ * @prefix:  the prefix to lookup
+ *
+ * Lookup the namespace name for the @prefix (which ca be NULL)
+ * The prefix must come from the @ctxt->dict dictionnary
+ *
+ * Returns the namespace name or NULL if not bound
+ */
+static const xmlChar *
+xmlGetNamespace(xmlParserCtxtPtr ctxt, const xmlChar *prefix) {
+    int i;
+
+    if (prefix == ctxt->str_xml) return(ctxt->str_xml_ns);
+    for (i = ctxt->nsNr - 2;i >= 0;i-=2)
+        if (ctxt->nsTab[i] == prefix) {
+	    if ((prefix == NULL) && (*ctxt->nsTab[i + 1] == 0))
+	        return(NULL);
+	    return(ctxt->nsTab[i + 1]);
+	}
+    return(NULL);
+}
+
+/**
+ * xmlParseNCName:
+ * @ctxt:  an XML parser context
+ * @len:  lenght of the string parsed
+ *
+ * parse an XML name.
+ *
+ * [4NS] NCNameChar ::= Letter | Digit | '.' | '-' | '_' |
+ *                      CombiningChar | Extender
+ *
+ * [5NS] NCName ::= (Letter | '_') (NCNameChar)*
+ *
+ * Returns the Name parsed or NULL
+ */
+
+static const xmlChar *
+xmlParseNCName(xmlParserCtxtPtr ctxt) {
+    const xmlChar *in;
+    const xmlChar *ret;
+    int count = 0;
+
+    /*
+     * Accelerator for simple ASCII names
+     */
+    in = ctxt->input->cur;
+    if (((*in >= 0x61) && (*in <= 0x7A)) ||
+	((*in >= 0x41) && (*in <= 0x5A)) ||
+	(*in == '_')) {
+	in++;
+	while (((*in >= 0x61) && (*in <= 0x7A)) ||
+	       ((*in >= 0x41) && (*in <= 0x5A)) ||
+	       ((*in >= 0x30) && (*in <= 0x39)) ||
+	       (*in == '_') || (*in == '-') ||
+	       (*in == '.'))
+	    in++;
+	if ((*in > 0) && (*in < 0x80)) {
+	    count = in - ctxt->input->cur;
+	    ret = xmlDictLookup(ctxt->dict, ctxt->input->cur, count);
+	    ctxt->input->cur = in;
+	    ctxt->nbChars += count;
+	    ctxt->input->col += count;
+	    if (ret == NULL) {
+	        xmlErrMemory(ctxt, NULL);
+	    }
+	    return(ret);
+	}
+    }
+    return(xmlParseNCNameComplex(ctxt));
+}
+
+/**
+ * xmlParseQName:
+ * @ctxt:  an XML parser context
+ * @prefix:  pointer to store the prefix part
+ *
+ * parse an XML Namespace QName
+ *
+ * [6]  QName  ::= (Prefix ':')? LocalPart
+ * [7]  Prefix  ::= NCName
+ * [8]  LocalPart  ::= NCName
+ *
+ * Returns the Name parsed or NULL
+ */
+
+static const xmlChar *
+xmlParseQName(xmlParserCtxtPtr ctxt, const xmlChar **prefix) {
+    const xmlChar *l, *p;
+
+    GROW;
+
+    l = xmlParseNCName(ctxt);
+    if (l == NULL) {
+        if (CUR == ':') {
+	    l = xmlParseName(ctxt);
+	    if (l != NULL) {
+	        xmlNsErr(ctxt, XML_NS_ERR_QNAME, 
+		         "Failed to parse QName '%s'\n", l, NULL, NULL);
+		*prefix = NULL;
+		return(l);
+	    }
+	}
+        return(NULL);
+    }
+    if (CUR == ':') {
+        NEXT;
+	p = l;
+	l = xmlParseNCName(ctxt);
+	if (l == NULL) {
+	    xmlChar *tmp;
+
+            xmlNsErr(ctxt, XML_NS_ERR_QNAME,
+	             "Failed to parse QName '%s:'\n", p, NULL, NULL);
+	    tmp = xmlBuildQName(BAD_CAST "", p, NULL, 0);
+	    p = xmlDictLookup(ctxt->dict, tmp, -1);
+	    if (tmp != NULL) xmlFree(tmp);
+	    *prefix = NULL;
+	    return(p);
+	}
+	if (CUR == ':') {
+	    xmlChar *tmp;
+
+            xmlNsErr(ctxt, XML_NS_ERR_QNAME,
+	             "Failed to parse QName '%s:%s:'\n", p, l, NULL);
+	    NEXT;
+	    tmp = (xmlChar *) xmlParseName(ctxt);
+	    if (tmp != NULL) {
+	        tmp = xmlBuildQName(tmp, l, NULL, 0);
+		l = xmlDictLookup(ctxt->dict, tmp, -1);
+		if (tmp != NULL) xmlFree(tmp);
+		*prefix = p;
+		return(l);
+	    }
+	    tmp = xmlBuildQName(BAD_CAST "", l, NULL, 0);
+	    l = xmlDictLookup(ctxt->dict, tmp, -1);
+	    if (tmp != NULL) xmlFree(tmp);
+	    *prefix = p;
+	    return(l);
+	}
+	*prefix = p;
+    } else
+        *prefix = NULL;
+    return(l);
+}
+
+/**
+ * xmlParseQNameAndCompare:
+ * @ctxt:  an XML parser context
+ * @name:  the localname
+ * @prefix:  the prefix, if any.
+ *
+ * parse an XML name and compares for match
+ * (specialized for endtag parsing)
+ *
+ * Returns NULL for an illegal name, (xmlChar*) 1 for success
+ * and the name for mismatch
+ */
+
+static const xmlChar *
+xmlParseQNameAndCompare(xmlParserCtxtPtr ctxt, xmlChar const *name,
+                        xmlChar const *prefix) {
+    const xmlChar *cmp = name;
+    const xmlChar *in;
+    const xmlChar *ret;
+    const xmlChar *prefix2;
+
+    if (prefix == NULL) return(xmlParseNameAndCompare(ctxt, name));
+
+    GROW;
+    in = ctxt->input->cur;
+    
+    cmp = prefix;
+    while (*in != 0 && *in == *cmp) {
+    	++in;
+	++cmp;
+    }
+    if ((*cmp == 0) && (*in == ':')) {
+        in++;
+	cmp = name;
+	while (*in != 0 && *in == *cmp) {
+	    ++in;
+	    ++cmp;
+	}
+	if (*cmp == 0 && (*in == '>' || IS_BLANK_CH (*in))) {
+	    /* success */
+	    ctxt->input->cur = in;
+	    return((const xmlChar*) 1);
+	}
+    }
+    /*
+     * all strings coms from the dictionary, equality can be done directly
+     */
+    ret = xmlParseQName (ctxt, &prefix2);
+    if ((ret == name) && (prefix == prefix2))
+	return((const xmlChar*) 1);
+    return ret;
+}
+
+/**
+ * xmlParseAttValueInternal:
+ * @ctxt:  an XML parser context
+ * @len:  attribute len result
+ * @alloc:  whether the attribute was reallocated as a new string
+ * @normalize:  if 1 then further non-CDATA normalization must be done
+ *
+ * parse a value for an attribute.
+ * NOTE: if no normalization is needed, the routine will return pointers
+ *       directly from the data buffer.
+ *
+ * 3.3.3 Attribute-Value Normalization:
+ * Before the value of an attribute is passed to the application or
+ * checked for validity, the XML processor must normalize it as follows: 
+ * - a character reference is processed by appending the referenced
+ *   character to the attribute value
+ * - an entity reference is processed by recursively processing the
+ *   replacement text of the entity 
+ * - a whitespace character (#x20, #xD, #xA, #x9) is processed by
+ *   appending #x20 to the normalized value, except that only a single
+ *   #x20 is appended for a "#xD#xA" sequence that is part of an external
+ *   parsed entity or the literal entity value of an internal parsed entity 
+ * - other characters are processed by appending them to the normalized value 
+ * If the declared value is not CDATA, then the XML processor must further
+ * process the normalized attribute value by discarding any leading and
+ * trailing space (#x20) characters, and by replacing sequences of space
+ * (#x20) characters by a single space (#x20) character.  
+ * All attributes for which no declaration has been read should be treated
+ * by a non-validating parser as if declared CDATA.
+ *
+ * Returns the AttValue parsed or NULL. The value has to be freed by the
+ *     caller if it was copied, this can be detected by val[*len] == 0.
+ */
+
+static xmlChar *
+xmlParseAttValueInternal(xmlParserCtxtPtr ctxt, int *len, int *alloc,
+                         int normalize)
+{
+    xmlChar limit = 0;
+    const xmlChar *in = NULL, *start, *end, *last;
+    xmlChar *ret = NULL;
+
+    GROW;
+    in = (xmlChar *) CUR_PTR;
+    if (*in != '"' && *in != '\'') {
+        xmlFatalErr(ctxt, XML_ERR_ATTRIBUTE_NOT_STARTED, NULL);
+        return (NULL);
+    }
+    ctxt->instate = XML_PARSER_ATTRIBUTE_VALUE;
+
+    /*
+     * try to handle in this routine the most common case where no
+     * allocation of a new string is required and where content is
+     * pure ASCII.
+     */
+    limit = *in++;
+    end = ctxt->input->end;
+    start = in;
+    if (in >= end) {
+        const xmlChar *oldbase = ctxt->input->base;
+	GROW;
+	if (oldbase != ctxt->input->base) {
+	    long delta = ctxt->input->base - oldbase;
+	    start = start + delta;
+	    in = in + delta;
+	}
+	end = ctxt->input->end;
+    }
+    if (normalize) {
+        /*
+	 * Skip any leading spaces
+	 */
+	while ((in < end) && (*in != limit) && 
+	       ((*in == 0x20) || (*in == 0x9) ||
+	        (*in == 0xA) || (*in == 0xD))) {
+	    in++;
+	    start = in;
+	    if (in >= end) {
+		const xmlChar *oldbase = ctxt->input->base;
+		GROW;
+		if (oldbase != ctxt->input->base) {
+		    long delta = ctxt->input->base - oldbase;
+		    start = start + delta;
+		    in = in + delta;
+		}
+		end = ctxt->input->end;
+	    }
+	}
+	while ((in < end) && (*in != limit) && (*in >= 0x20) &&
+	       (*in <= 0x7f) && (*in != '&') && (*in != '<')) {
+	    if ((*in++ == 0x20) && (*in == 0x20)) break;
+	    if (in >= end) {
+		const xmlChar *oldbase = ctxt->input->base;
+		GROW;
+		if (oldbase != ctxt->input->base) {
+		    long delta = ctxt->input->base - oldbase;
+		    start = start + delta;
+		    in = in + delta;
+		}
+		end = ctxt->input->end;
+	    }
+	}
+	last = in;
+	/*
+	 * skip the trailing blanks
+	 */
+	while ((last[-1] == 0x20) && (last > start)) last--;
+	while ((in < end) && (*in != limit) && 
+	       ((*in == 0x20) || (*in == 0x9) ||
+	        (*in == 0xA) || (*in == 0xD))) {
+	    in++;
+	    if (in >= end) {
+		const xmlChar *oldbase = ctxt->input->base;
+		GROW;
+		if (oldbase != ctxt->input->base) {
+		    long delta = ctxt->input->base - oldbase;
+		    start = start + delta;
+		    in = in + delta;
+		    last = last + delta;
+		}
+		end = ctxt->input->end;
+	    }
+	}
+	if (*in != limit) goto need_complex;
+    } else {
+	while ((in < end) && (*in != limit) && (*in >= 0x20) &&
+	       (*in <= 0x7f) && (*in != '&') && (*in != '<')) {
+	    in++;
+	    if (in >= end) {
+		const xmlChar *oldbase = ctxt->input->base;
+		GROW;
+		if (oldbase != ctxt->input->base) {
+		    long delta = ctxt->input->base - oldbase;
+		    start = start + delta;
+		    in = in + delta;
+		}
+		end = ctxt->input->end;
+	    }
+	}
+	last = in;
+	if (*in != limit) goto need_complex;
+    }
+    in++;
+    if (len != NULL) {
+        *len = last - start;
+        ret = (xmlChar *) start;
+    } else {
+        if (alloc) *alloc = 1;
+        ret = xmlStrndup(start, last - start);
+    }
+    CUR_PTR = in;
+    if (alloc) *alloc = 0;
+    return ret;
+need_complex:
+    if (alloc) *alloc = 1;
+    return xmlParseAttValueComplex(ctxt, len, normalize);
+}
+
+/**
+ * xmlParseAttribute2:
+ * @ctxt:  an XML parser context
+ * @pref:  the element prefix
+ * @elem:  the element name
+ * @prefix:  a xmlChar ** used to store the value of the attribute prefix
+ * @value:  a xmlChar ** used to store the value of the attribute
+ * @len:  an int * to save the length of the attribute
+ * @alloc:  an int * to indicate if the attribute was allocated
+ *
+ * parse an attribute in the new SAX2 framework.
+ *
+ * Returns the attribute name, and the value in *value, .
+ */
+
+static const xmlChar *
+xmlParseAttribute2(xmlParserCtxtPtr ctxt,
+                   const xmlChar *pref, const xmlChar *elem,
+                   const xmlChar **prefix, xmlChar **value,
+		   int *len, int *alloc) {
+    const xmlChar *name;
+    xmlChar *val;
+    int normalize = 0;
+
+    *value = NULL;
+    GROW;
+    name = xmlParseQName(ctxt, prefix);
+    if (name == NULL) {
+	xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
+	               "error parsing attribute name\n");
+        return(NULL);
+    }
+
+    /*
+     * get the type if needed
+     */
+    if (ctxt->attsSpecial != NULL) {
+        int type;
+
+        type = (int) (long) xmlHashQLookup2(ctxt->attsSpecial,
+	                                    pref, elem, *prefix, name);
+	if (type != 0) normalize = 1;
+    }
+
+    /*
+     * read the value
+     */
+    SKIP_BLANKS;
+    if (RAW == '=') {
+        NEXT;
+	SKIP_BLANKS;
+	val = xmlParseAttValueInternal(ctxt, len, alloc, normalize);
+	ctxt->instate = XML_PARSER_CONTENT;
+    } else {
+	xmlFatalErrMsgStr(ctxt, XML_ERR_ATTRIBUTE_WITHOUT_VALUE,
+	       "Specification mandate value for attribute %s\n", name);
+	return(NULL);
+    }
+
+    /*
+     * Check that xml:lang conforms to the specification
+     * No more registered as an error, just generate a warning now
+     * since this was deprecated in XML second edition
+     */
+    if ((ctxt->pedantic) && (xmlStrEqual(name, BAD_CAST "xml:lang"))) {
+	if (!xmlCheckLanguageID(val)) {
+	    xmlWarningMsg(ctxt, XML_WAR_LANG_VALUE,
+		          "Malformed value for xml:lang : %s\n",
+			  val, NULL);
+	}
+    }
+
+    /*
+     * Check that xml:space conforms to the specification
+     */
+    if (xmlStrEqual(name, BAD_CAST "xml:space")) {
+	if (xmlStrEqual(val, BAD_CAST "default"))
+	    *(ctxt->space) = 0;
+	else if (xmlStrEqual(val, BAD_CAST "preserve"))
+	    *(ctxt->space) = 1;
+	else {
+	    xmlFatalErrMsgStr(ctxt, XML_ERR_ATTRIBUTE_WITHOUT_VALUE,
+"Invalid value \"%s\" for xml:space : \"default\" or \"preserve\" expected\n",
+                                 val);
+	}
+    }
+
+    *value = val;
+    return(name);
+}
+
+/**
+ * xmlParseStartTag2:
+ * @ctxt:  an XML parser context
+ * 
+ * parse a start of tag either for rule element or
+ * EmptyElement. In both case we don't parse the tag closing chars.
+ * This routine is called when running SAX2 parsing
+ *
+ * [40] STag ::= '<' Name (S Attribute)* S? '>'
+ *
+ * [ WFC: Unique Att Spec ]
+ * No attribute name may appear more than once in the same start-tag or
+ * empty-element tag. 
+ *
+ * [44] EmptyElemTag ::= '<' Name (S Attribute)* S? '/>'
+ *
+ * [ WFC: Unique Att Spec ]
+ * No attribute name may appear more than once in the same start-tag or
+ * empty-element tag. 
+ *
+ * With namespace:
+ *
+ * [NS 8] STag ::= '<' QName (S Attribute)* S? '>'
+ *
+ * [NS 10] EmptyElement ::= '<' QName (S Attribute)* S? '/>'
+ *
+ * Returns the element name parsed
+ */
+
+static const xmlChar *
+xmlParseStartTag2(xmlParserCtxtPtr ctxt, const xmlChar **pref,
+                  const xmlChar **URI, int *tlen) {
+    const xmlChar *localname;
+    const xmlChar *prefix;
+    const xmlChar *attname;
+    const xmlChar *aprefix;
+    const xmlChar *nsname;
+    xmlChar *attvalue;
+    const xmlChar **atts = ctxt->atts;
+    int maxatts = ctxt->maxatts;
+    int nratts, nbatts, nbdef;
+    int i, j, nbNs, attval;
+    const xmlChar *base;
+    unsigned long cur;
+
+    if (RAW != '<') return(NULL);
+    NEXT1;
+
+    /*
+     * NOTE: it is crucial with the SAX2 API to never call SHRINK beyond that
+     *       point since the attribute values may be stored as pointers to
+     *       the buffer and calling SHRINK would destroy them !
+     *       The Shrinking is only possible once the full set of attribute
+     *       callbacks have been done.
+     */
+reparse:
+    SHRINK;
+    base = ctxt->input->base;
+    cur = ctxt->input->cur - ctxt->input->base;
+    nbatts = 0;
+    nratts = 0;
+    nbdef = 0;
+    nbNs = 0;
+    attval = 0;
+
+    localname = xmlParseQName(ctxt, &prefix);
+    if (localname == NULL) {
+	xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
+		       "StartTag: invalid element name\n");
+        return(NULL);
+    }
+    *tlen = ctxt->input->cur - ctxt->input->base - cur;
+
+    /*
+     * Now parse the attributes, it ends up with the ending
+     *
+     * (S Attribute)* S?
+     */
+    SKIP_BLANKS;
+    GROW;
+    if (ctxt->input->base != base) goto base_changed;
+
+    while ((RAW != '>') && 
+	   ((RAW != '/') || (NXT(1) != '>')) &&
+	   (IS_BYTE_CHAR(RAW))) {
+	const xmlChar *q = CUR_PTR;
+	unsigned int cons = ctxt->input->consumed;
+	int len = -1, alloc = 0;
+
+	attname = xmlParseAttribute2(ctxt, prefix, localname,
+	                             &aprefix, &attvalue, &len, &alloc);
+        if ((attname != NULL) && (attvalue != NULL)) {
+	    if (len < 0) len = xmlStrlen(attvalue);
+            if ((attname == ctxt->str_xmlns) && (aprefix == NULL)) {
+	        const xmlChar *URL = xmlDictLookup(ctxt->dict, attvalue, len);
+		xmlURIPtr uri;
+
+                if (*URL != 0) {
+		    uri = xmlParseURI((const char *) URL);
+		    if (uri == NULL) {
+			xmlWarningMsg(ctxt, XML_WAR_NS_URI,
+				      "xmlns: %s not a valid URI\n",
+				      URL, NULL);
+		    } else {
+			if (uri->scheme == NULL) {
+			    xmlWarningMsg(ctxt, XML_WAR_NS_URI_RELATIVE,
+				   "xmlns: URI %s is not absolute\n",
+				          URL, NULL);
+			}
+			xmlFreeURI(uri);
+		    }
+		}
+		/*
+		 * check that it's not a defined namespace
+		 */
+		for (j = 1;j <= nbNs;j++)
+		    if (ctxt->nsTab[ctxt->nsNr - 2 * j] == NULL)
+			break;
+		if (j <= nbNs)
+		    xmlErrAttributeDup(ctxt, NULL, attname);
+		else
+		    if (nsPush(ctxt, NULL, URL) > 0) nbNs++;
+		if (alloc != 0) xmlFree(attvalue);
+		SKIP_BLANKS;
+		continue;
+	    }
+            if (aprefix == ctxt->str_xmlns) {
+	        const xmlChar *URL = xmlDictLookup(ctxt->dict, attvalue, len);
+		xmlURIPtr uri;
+
+                if (attname == ctxt->str_xml) {
+		    if (URL != ctxt->str_xml_ns) {
+		        xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
+			         "xml namespace prefix mapped to wrong URI\n",
+			         NULL, NULL, NULL);
+		    }
+		    /*
+		     * Do not keep a namespace definition node
+		     */
+		    if (alloc != 0) xmlFree(attvalue);
+		    SKIP_BLANKS;
+		    continue;
+		}
+		uri = xmlParseURI((const char *) URL);
+		if (uri == NULL) {
+		    xmlWarningMsg(ctxt, XML_WAR_NS_URI,
+			 "xmlns:%s: '%s' is not a valid URI\n",
+				       attname, URL);
+		} else {
+		    if ((ctxt->pedantic) && (uri->scheme == NULL)) {
+			xmlWarningMsg(ctxt, XML_WAR_NS_URI_RELATIVE,
+				      "xmlns:%s: URI %s is not absolute\n",
+			              attname, URL);
+		    }
+		    xmlFreeURI(uri);
+		}
+
+		/*
+		 * check that it's not a defined namespace
+		 */
+		for (j = 1;j <= nbNs;j++)
+		    if (ctxt->nsTab[ctxt->nsNr - 2 * j] == attname)
+			break;
+		if (j <= nbNs)
+		    xmlErrAttributeDup(ctxt, aprefix, attname);
+		else
+		    if (nsPush(ctxt, attname, URL) > 0) nbNs++;
+		if (alloc != 0) xmlFree(attvalue);
+		SKIP_BLANKS;
+		if (ctxt->input->base != base) goto base_changed;
+		continue;
+	    }
+
+	    /*
+	     * Add the pair to atts
+	     */
+	    if ((atts == NULL) || (nbatts + 5 > maxatts)) {
+	        if (xmlCtxtGrowAttrs(ctxt, nbatts + 5) < 0) {
+		    if (attvalue[len] == 0)
+			xmlFree(attvalue);
+		    goto failed;
+		}
+	        maxatts = ctxt->maxatts;
+		atts = ctxt->atts;
+	    }
+	    ctxt->attallocs[nratts++] = alloc;
+	    atts[nbatts++] = attname;
+	    atts[nbatts++] = aprefix;
+	    atts[nbatts++] = NULL; /* the URI will be fetched later */
+	    atts[nbatts++] = attvalue;
+	    attvalue += len;
+	    atts[nbatts++] = attvalue;
+	    /*
+	     * tag if some deallocation is needed
+	     */
+	    if (alloc != 0) attval = 1;
+	} else {
+	    if ((attvalue != NULL) && (attvalue[len] == 0))
+		xmlFree(attvalue);
+	}
+
+failed:     
+
+	GROW
+	if (ctxt->input->base != base) goto base_changed;
+	if ((RAW == '>') || (((RAW == '/') && (NXT(1) == '>'))))
+	    break;
+	if (!IS_BLANK_CH(RAW)) {
+	    xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
+			   "attributes construct error\n");
+	}
+	SKIP_BLANKS;
+        if ((cons == ctxt->input->consumed) && (q == CUR_PTR) &&
+            (attname == NULL) && (attvalue == NULL)) {
+	    xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
+	         "xmlParseStartTag: problem parsing attributes\n");
+	    break;
+	}
+        GROW;
+	if (ctxt->input->base != base) goto base_changed;
+    }
+
+    /*
+     * The attributes defaulting
+     */
+    if (ctxt->attsDefault != NULL) {
+        xmlDefAttrsPtr defaults;
+
+	defaults = xmlHashLookup2(ctxt->attsDefault, localname, prefix);
+	if (defaults != NULL) {
+	    for (i = 0;i < defaults->nbAttrs;i++) {
+	        attname = defaults->values[4 * i];
+		aprefix = defaults->values[4 * i + 1];
+
+                /*
+		 * special work for namespaces defaulted defs
+		 */
+		if ((attname == ctxt->str_xmlns) && (aprefix == NULL)) {
+		    /*
+		     * check that it's not a defined namespace
+		     */
+		    for (j = 1;j <= nbNs;j++)
+		        if (ctxt->nsTab[ctxt->nsNr - 2 * j] == NULL)
+			    break;
+	            if (j <= nbNs) continue;
+
+		    nsname = xmlGetNamespace(ctxt, NULL);
+		    if (nsname != defaults->values[4 * i + 2]) {
+			if (nsPush(ctxt, NULL,
+			           defaults->values[4 * i + 2]) > 0)
+			    nbNs++;
+		    }
+		} else if (aprefix == ctxt->str_xmlns) {
+		    /*
+		     * check that it's not a defined namespace
+		     */
+		    for (j = 1;j <= nbNs;j++)
+		        if (ctxt->nsTab[ctxt->nsNr - 2 * j] == attname)
+			    break;
+	            if (j <= nbNs) continue;
+
+		    nsname = xmlGetNamespace(ctxt, attname);
+		    if (nsname != defaults->values[2]) {
+			if (nsPush(ctxt, attname,
+			           defaults->values[4 * i + 2]) > 0)
+			    nbNs++;
+		    }
+		} else {
+		    /*
+		     * check that it's not a defined attribute
+		     */
+		    for (j = 0;j < nbatts;j+=5) {
+			if ((attname == atts[j]) && (aprefix == atts[j+1]))
+			    break;
+		    }
+		    if (j < nbatts) continue;
+
+		    if ((atts == NULL) || (nbatts + 5 > maxatts)) {
+			if (xmlCtxtGrowAttrs(ctxt, nbatts + 5) < 0) {
+			    return(NULL);
+			}
+			maxatts = ctxt->maxatts;
+			atts = ctxt->atts;
+		    }
+		    atts[nbatts++] = attname;
+		    atts[nbatts++] = aprefix;
+		    if (aprefix == NULL)
+			atts[nbatts++] = NULL;
+		    else
+		        atts[nbatts++] = xmlGetNamespace(ctxt, aprefix);
+		    atts[nbatts++] = defaults->values[4 * i + 2];
+		    atts[nbatts++] = defaults->values[4 * i + 3];
+		    nbdef++;
+		}
+	    }
+	}
+    }
+
+    /*
+     * The attributes checkings
+     */
+    for (i = 0; i < nbatts;i += 5) {
+        nsname = xmlGetNamespace(ctxt, atts[i + 1]);
+	if ((atts[i + 1] != NULL) && (nsname == NULL)) {
+	    xmlNsErr(ctxt, XML_NS_ERR_UNDEFINED_NAMESPACE,
+		 "Namespace prefix %s for %s on %s is not defined\n",
+		     atts[i + 1], atts[i], localname);
+	}
+	atts[i + 2] = nsname;
+	/*
+	 * [ WFC: Unique Att Spec ]
+	 * No attribute name may appear more than once in the same
+	 * start-tag or empty-element tag. 
+	 * As extended by the Namespace in XML REC.
+	 */
+        for (j = 0; j < i;j += 5) {
+	    if (atts[i] == atts[j]) {
+	        if (atts[i+1] == atts[j+1]) {
+		    xmlErrAttributeDup(ctxt, atts[i+1], atts[i]);
+		    break;
+		}
+		if ((nsname != NULL) && (atts[j + 2] == nsname)) {
+		    xmlNsErr(ctxt, XML_NS_ERR_ATTRIBUTE_REDEFINED,
+			     "Namespaced Attribute %s in '%s' redefined\n",
+			     atts[i], nsname, NULL);
+		    break;
+		}
+	    }
+	}
+    }
+
+    nsname = xmlGetNamespace(ctxt, prefix);
+    if ((prefix != NULL) && (nsname == NULL)) {
+	xmlNsErr(ctxt, XML_NS_ERR_UNDEFINED_NAMESPACE,
+	         "Namespace prefix %s on %s is not defined\n",
+		 prefix, localname, NULL);
+    }
+    *pref = prefix;
+    *URI = nsname;
+
+    /*
+     * SAX: Start of Element !
+     */
+    if ((ctxt->sax != NULL) && (ctxt->sax->startElementNs != NULL) &&
+	(!ctxt->disableSAX)) {
+	if (nbNs > 0)
+	    ctxt->sax->startElementNs(ctxt->userData, localname, prefix,
+			  nsname, nbNs, &ctxt->nsTab[ctxt->nsNr - 2 * nbNs],
+			  nbatts / 5, nbdef, atts);
+	else
+	    ctxt->sax->startElementNs(ctxt->userData, localname, prefix,
+	                  nsname, 0, NULL, nbatts / 5, nbdef, atts);
+    }
+
+    /*
+     * Free up attribute allocated strings if needed
+     */
+    if (attval != 0) {
+	for (i = 3,j = 0; j < nratts;i += 5,j++)
+	    if ((ctxt->attallocs[j] != 0) && (atts[i] != NULL))
+	        xmlFree((xmlChar *) atts[i]);
+    }
+
+    return(localname);
+
+base_changed:
+    /*
+     * the attribute strings are valid iif the base didn't changed
+     */
+    if (attval != 0) {
+	for (i = 3,j = 0; j < nratts;i += 5,j++)
+	    if ((ctxt->attallocs[j] != 0) && (atts[i] != NULL))
+	        xmlFree((xmlChar *) atts[i]);
+    }
+    ctxt->input->cur = ctxt->input->base + cur;
+    if (ctxt->wellFormed == 1) {
+	goto reparse;
+    }
+    return(NULL);
+}
+
+/**
+ * xmlParseEndTag2:
+ * @ctxt:  an XML parser context
+ * @line:  line of the start tag
+ * @nsNr:  number of namespaces on the start tag
+ *
+ * parse an end of tag
+ *
+ * [42] ETag ::= '</' Name S? '>'
+ *
+ * With namespace
+ *
+ * [NS 9] ETag ::= '</' QName S? '>'
+ */
+
+static void
+xmlParseEndTag2(xmlParserCtxtPtr ctxt, const xmlChar *prefix,
+                const xmlChar *URI, int line, int nsNr, int tlen) {
+    const xmlChar *name;
+
+    GROW;
+    if ((RAW != '<') || (NXT(1) != '/')) {
+	xmlFatalErr(ctxt, XML_ERR_LTSLASH_REQUIRED, NULL);
+	return;
+    }
+    SKIP(2);
+
+    if ((tlen > 0) && (memcmp(ctxt->input->cur, ctxt->name, tlen) == 0)) {
+        if (ctxt->input->cur[tlen] == '>') {
+	    ctxt->input->cur += tlen + 1;
+	    goto done;
+	}
+	ctxt->input->cur += tlen;
+	name = (xmlChar*)1;
+    } else {
+	if (prefix == NULL)
+	    name = xmlParseNameAndCompare(ctxt, ctxt->name);
+	else
+	    name = xmlParseQNameAndCompare(ctxt, ctxt->name, prefix);
+    }
+
+    /*
+     * We should definitely be at the ending "S? '>'" part
+     */
+    GROW;
+    SKIP_BLANKS;
+    if ((!IS_BYTE_CHAR(RAW)) || (RAW != '>')) {
+	xmlFatalErr(ctxt, XML_ERR_GT_REQUIRED, NULL);
+    } else
+	NEXT1;
+
+    /*
+     * [ WFC: Element Type Match ]
+     * The Name in an element's end-tag must match the element type in the
+     * start-tag. 
+     *
+     */
+    if (name != (xmlChar*)1) {
+        if (name == NULL) name = BAD_CAST "unparseable";
+        xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_TAG_NAME_MISMATCH,
+		     "Opening and ending tag mismatch: %s line %d and %s\n",
+		                ctxt->name, line, name);
+    }
+
+    /*
+     * SAX: End of Tag
+     */
+done:
+    if ((ctxt->sax != NULL) && (ctxt->sax->endElementNs != NULL) &&
+	(!ctxt->disableSAX))
+	ctxt->sax->endElementNs(ctxt->userData, ctxt->name, prefix, URI);
+
+    spacePop(ctxt);
+    if (nsNr != 0)
+	nsPop(ctxt, nsNr);
+    return;
+}
+
+/**
+ * xmlParseCDSect:
+ * @ctxt:  an XML parser context
+ * 
+ * Parse escaped pure raw content.
+ *
+ * [18] CDSect ::= CDStart CData CDEnd
+ *
+ * [19] CDStart ::= '<![CDATA['
+ *
+ * [20] Data ::= (Char* - (Char* ']]>' Char*))
+ *
+ * [21] CDEnd ::= ']]>'
+ */
+void
+xmlParseCDSect(xmlParserCtxtPtr ctxt) {
+    xmlChar *buf = NULL;
+    int len = 0;
+    int size = XML_PARSER_BUFFER_SIZE;
+    int r, rl;
+    int	s, sl;
+    int cur, l;
+    int count = 0;
+
+    /* Check 2.6.0 was NXT(0) not RAW */
+    if (CMP9(CUR_PTR, '<', '!', '[', 'C', 'D', 'A', 'T', 'A', '[')) {
+	SKIP(9);
+    } else
+        return;
+
+    ctxt->instate = XML_PARSER_CDATA_SECTION;
+    r = CUR_CHAR(rl);
+    if (!IS_CHAR(r)) {
+	xmlFatalErr(ctxt, XML_ERR_CDATA_NOT_FINISHED, NULL);
+	ctxt->instate = XML_PARSER_CONTENT;
+        return;
+    }
+    NEXTL(rl);
+    s = CUR_CHAR(sl);
+    if (!IS_CHAR(s)) {
+	xmlFatalErr(ctxt, XML_ERR_CDATA_NOT_FINISHED, NULL);
+	ctxt->instate = XML_PARSER_CONTENT;
+        return;
+    }
+    NEXTL(sl);
+    cur = CUR_CHAR(l);
+    buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar));
+    if (buf == NULL) {
+	xmlErrMemory(ctxt, NULL);
+	return;
+    }
+    while (IS_CHAR(cur) &&
+           ((r != ']') || (s != ']') || (cur != '>'))) {
+	if (len + 5 >= size) {
+	    size *= 2;
+	    buf = (xmlChar *) xmlRealloc(buf, size * sizeof(xmlChar));
+	    if (buf == NULL) {
+		xmlErrMemory(ctxt, NULL);
+		return;
+	    }
+	}
+	COPY_BUF(rl,buf,len,r);
+	r = s;
+	rl = sl;
+	s = cur;
+	sl = l;
+	count++;
+	if (count > 50) {
+	    GROW;
+	    count = 0;
+	}
+	NEXTL(l);
+	cur = CUR_CHAR(l);
+    }
+    buf[len] = 0;
+    ctxt->instate = XML_PARSER_CONTENT;
+    if (cur != '>') {
+	xmlFatalErrMsgStr(ctxt, XML_ERR_CDATA_NOT_FINISHED,
+	                     "CData section not finished\n%.50s\n", buf);
+	xmlFree(buf);
+        return;
+    }
+    NEXTL(l);
+
+    /*
+     * OK the buffer is to be consumed as cdata.
+     */
+    if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) {
+	if (ctxt->sax->cdataBlock != NULL)
+	    ctxt->sax->cdataBlock(ctxt->userData, buf, len);
+	else if (ctxt->sax->characters != NULL)
+	    ctxt->sax->characters(ctxt->userData, buf, len);
+    }
+    xmlFree(buf);
+}
+
+/**
+ * xmlParseContent:
+ * @ctxt:  an XML parser context
+ *
+ * Parse a content:
+ *
+ * [43] content ::= (element | CharData | Reference | CDSect | PI | Comment)*
+ */
+
+void
+xmlParseContent(xmlParserCtxtPtr ctxt) {
+    GROW;
+    while ((RAW != 0) &&
+	   ((RAW != '<') || (NXT(1) != '/'))) {
+	const xmlChar *test = CUR_PTR;
+	unsigned int cons = ctxt->input->consumed;
+	const xmlChar *cur = ctxt->input->cur;
+
+	/*
+	 * First case : a Processing Instruction.
+	 */
+	if ((*cur == '<') && (cur[1] == '?')) {
+	    xmlParsePI(ctxt);
+	}
+
+	/*
+	 * Second case : a CDSection
+	 */
+	/* 2.6.0 test was *cur not RAW */
+	else if (CMP9(CUR_PTR, '<', '!', '[', 'C', 'D', 'A', 'T', 'A', '[')) {
+	    xmlParseCDSect(ctxt);
+	}
+
+	/*
+	 * Third case :  a comment
+	 */
+	else if ((*cur == '<') && (NXT(1) == '!') &&
+		 (NXT(2) == '-') && (NXT(3) == '-')) {
+	    xmlParseComment(ctxt);
+	    ctxt->instate = XML_PARSER_CONTENT;
+	}
+
+	/*
+	 * Fourth case :  a sub-element.
+	 */
+	else if (*cur == '<') {
+	    xmlParseElement(ctxt);
+	}
+
+	/*
+	 * Fifth case : a reference. If if has not been resolved,
+	 *    parsing returns it's Name, create the node 
+	 */
+
+	else if (*cur == '&') {
+	    xmlParseReference(ctxt);
+	}
+
+	/*
+	 * Last case, text. Note that References are handled directly.
+	 */
+	else {
+	    xmlParseCharData(ctxt, 0);
+	}
+
+	GROW;
+	/*
+	 * Pop-up of finished entities.
+	 */
+	while ((RAW == 0) && (ctxt->inputNr > 1))
+	    xmlPopInput(ctxt);
+	SHRINK;
+
+	if ((cons == ctxt->input->consumed) && (test == CUR_PTR)) {
+	    xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
+	                "detected an error in element content\n");
+	    ctxt->instate = XML_PARSER_EOF;
+            break;
+	}
+    }
+}
+
+/**
+ * xmlParseElement:
+ * @ctxt:  an XML parser context
+ *
+ * parse an XML element, this is highly recursive
+ *
+ * [39] element ::= EmptyElemTag | STag content ETag
+ *
+ * [ WFC: Element Type Match ]
+ * The Name in an element's end-tag must match the element type in the
+ * start-tag. 
+ *
+ */
+
+void
+xmlParseElement(xmlParserCtxtPtr ctxt) {
+    const xmlChar *name;
+    const xmlChar *prefix;
+    const xmlChar *URI;
+    xmlParserNodeInfo node_info;
+    int line, tlen;
+    xmlNodePtr ret;
+    int nsNr = ctxt->nsNr;
+
+    /* Capture start position */
+    if (ctxt->record_info) {
+        node_info.begin_pos = ctxt->input->consumed +
+                          (CUR_PTR - ctxt->input->base);
+	node_info.begin_line = ctxt->input->line;
+    }
+
+    if (ctxt->spaceNr == 0)
+	spacePush(ctxt, -1);
+    else
+	spacePush(ctxt, *ctxt->space);
+
+    line = ctxt->input->line;
+#ifdef LIBXML_SAX1_ENABLED
+    if (ctxt->sax2)
+#endif /* LIBXML_SAX1_ENABLED */
+        name = xmlParseStartTag2(ctxt, &prefix, &URI, &tlen);
+#ifdef LIBXML_SAX1_ENABLED
+    else
+	name = xmlParseStartTag(ctxt);
+#endif /* LIBXML_SAX1_ENABLED */
+    if (name == NULL) {
+	spacePop(ctxt);
+        return;
+    }
+    namePush(ctxt, name);
+    ret = ctxt->node;
+
+#ifdef LIBXML_VALID_ENABLED
+    /*
+     * [ VC: Root Element Type ]
+     * The Name in the document type declaration must match the element
+     * type of the root element. 
+     */
+    if (ctxt->validate && ctxt->wellFormed && ctxt->myDoc &&
+        ctxt->node && (ctxt->node == ctxt->myDoc->children))
+        ctxt->valid &= xmlValidateRoot(&ctxt->vctxt, ctxt->myDoc);
+#endif /* LIBXML_VALID_ENABLED */
+
+    /*
+     * Check for an Empty Element.
+     */
+    if ((RAW == '/') && (NXT(1) == '>')) {
+        SKIP(2);
+	if (ctxt->sax2) {
+	    if ((ctxt->sax != NULL) && (ctxt->sax->endElementNs != NULL) &&
+		(!ctxt->disableSAX))
+		ctxt->sax->endElementNs(ctxt->userData, name, prefix, URI);
+#ifdef LIBXML_SAX1_ENABLED
+	} else {
+	    if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL) &&
+		(!ctxt->disableSAX))
+		ctxt->sax->endElement(ctxt->userData, name);
+#endif /* LIBXML_SAX1_ENABLED */
+	}
+	namePop(ctxt);
+	spacePop(ctxt);
+	if (nsNr != ctxt->nsNr)
+	    nsPop(ctxt, ctxt->nsNr - nsNr);
+	if ( ret != NULL && ctxt->record_info ) {
+	   node_info.end_pos = ctxt->input->consumed +
+			      (CUR_PTR - ctxt->input->base);
+	   node_info.end_line = ctxt->input->line;
+	   node_info.node = ret;
+	   xmlParserAddNodeInfo(ctxt, &node_info);
+	}
+	return;
+    }
+    if (RAW == '>') {
+        NEXT1;
+    } else {
+        xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_GT_REQUIRED,
+		     "Couldn't find end of Start Tag %s line %d\n",
+		                name, line, NULL);
+
+	/*
+	 * end of parsing of this node.
+	 */
+	nodePop(ctxt);
+	namePop(ctxt);
+	spacePop(ctxt);
+	if (nsNr != ctxt->nsNr)
+	    nsPop(ctxt, ctxt->nsNr - nsNr);
+
+	/*
+	 * Capture end position and add node
+	 */
+	if ( ret != NULL && ctxt->record_info ) {
+	   node_info.end_pos = ctxt->input->consumed +
+			      (CUR_PTR - ctxt->input->base);
+	   node_info.end_line = ctxt->input->line;
+	   node_info.node = ret;
+	   xmlParserAddNodeInfo(ctxt, &node_info);
+	}
+	return;
+    }
+
+    /*
+     * Parse the content of the element:
+     */
+    xmlParseContent(ctxt);
+    if (!IS_BYTE_CHAR(RAW)) {
+        xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_TAG_NOT_FINISHED,
+	 "Premature end of data in tag %s line %d\n",
+		                name, line, NULL);
+
+	/*
+	 * end of parsing of this node.
+	 */
+	nodePop(ctxt);
+	namePop(ctxt);
+	spacePop(ctxt);
+	if (nsNr != ctxt->nsNr)
+	    nsPop(ctxt, ctxt->nsNr - nsNr);
+	return;
+    }
+
+    /*
+     * parse the end of tag: '</' should be here.
+     */
+    if (ctxt->sax2) {
+	xmlParseEndTag2(ctxt, prefix, URI, line, ctxt->nsNr - nsNr, tlen);
+	namePop(ctxt);
+    }
+#ifdef LIBXML_SAX1_ENABLED
+      else
+	xmlParseEndTag1(ctxt, line);
+#endif /* LIBXML_SAX1_ENABLED */
+
+    /*
+     * Capture end position and add node
+     */
+    if ( ret != NULL && ctxt->record_info ) {
+       node_info.end_pos = ctxt->input->consumed +
+                          (CUR_PTR - ctxt->input->base);
+       node_info.end_line = ctxt->input->line;
+       node_info.node = ret;
+       xmlParserAddNodeInfo(ctxt, &node_info);
+    }
+}
+
+/**
+ * xmlParseVersionNum:
+ * @ctxt:  an XML parser context
+ *
+ * parse the XML version value.
+ *
+ * [26] VersionNum ::= ([a-zA-Z0-9_.:] | '-')+
+ *
+ * Returns the string giving the XML version number, or NULL
+ */
+xmlChar *
+xmlParseVersionNum(xmlParserCtxtPtr ctxt) {
+    xmlChar *buf = NULL;
+    int len = 0;
+    int size = 10;
+    xmlChar cur;
+
+    buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar));
+    if (buf == NULL) {
+	xmlErrMemory(ctxt, NULL);
+	return(NULL);
+    }
+    cur = CUR;
+    while (((cur >= 'a') && (cur <= 'z')) ||
+           ((cur >= 'A') && (cur <= 'Z')) ||
+           ((cur >= '0') && (cur <= '9')) ||
+           (cur == '_') || (cur == '.') ||
+	   (cur == ':') || (cur == '-')) {
+	if (len + 1 >= size) {
+	    size *= 2;
+	    buf = (xmlChar *) xmlRealloc(buf, size * sizeof(xmlChar));
+	    if (buf == NULL) {
+		xmlErrMemory(ctxt, NULL);
+		return(NULL);
+	    }
+	}
+	buf[len++] = cur;
+	NEXT;
+	cur=CUR;
+    }
+    buf[len] = 0;
+    return(buf);
+}
+
+/**
+ * xmlParseVersionInfo:
+ * @ctxt:  an XML parser context
+ * 
+ * parse the XML version.
+ *
+ * [24] VersionInfo ::= S 'version' Eq (' VersionNum ' | " VersionNum ")
+ * 
+ * [25] Eq ::= S? '=' S?
+ *
+ * Returns the version string, e.g. "1.0"
+ */
+
+xmlChar *
+xmlParseVersionInfo(xmlParserCtxtPtr ctxt) {
+    xmlChar *version = NULL;
+
+    if (CMP7(CUR_PTR, 'v', 'e', 'r', 's', 'i', 'o', 'n')) {
+	SKIP(7);
+	SKIP_BLANKS;
+	if (RAW != '=') {
+	    xmlFatalErr(ctxt, XML_ERR_EQUAL_REQUIRED, NULL);
+	    return(NULL);
+        }
+	NEXT;
+	SKIP_BLANKS;
+	if (RAW == '"') {
+	    NEXT;
+	    version = xmlParseVersionNum(ctxt);
+	    if (RAW != '"') {
+		xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
+	    } else
+	        NEXT;
+	} else if (RAW == '\''){
+	    NEXT;
+	    version = xmlParseVersionNum(ctxt);
+	    if (RAW != '\'') {
+		xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
+	    } else
+	        NEXT;
+	} else {
+	    xmlFatalErr(ctxt, XML_ERR_STRING_NOT_STARTED, NULL);
+	}
+    }
+    return(version);
+}
+
+/**
+ * xmlParseEncName:
+ * @ctxt:  an XML parser context
+ *
+ * parse the XML encoding name
+ *
+ * [81] EncName ::= [A-Za-z] ([A-Za-z0-9._] | '-')*
+ *
+ * Returns the encoding name value or NULL
+ */
+xmlChar *
+xmlParseEncName(xmlParserCtxtPtr ctxt) {
+    xmlChar *buf = NULL;
+    int len = 0;
+    int size = 10;
+    xmlChar cur;
+
+    cur = CUR;
+    if (((cur >= 'a') && (cur <= 'z')) ||
+        ((cur >= 'A') && (cur <= 'Z'))) {
+	buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar));
+	if (buf == NULL) {
+	    xmlErrMemory(ctxt, NULL);
+	    return(NULL);
+	}
+	
+	buf[len++] = cur;
+	NEXT;
+	cur = CUR;
+	while (((cur >= 'a') && (cur <= 'z')) ||
+	       ((cur >= 'A') && (cur <= 'Z')) ||
+	       ((cur >= '0') && (cur <= '9')) ||
+	       (cur == '.') || (cur == '_') ||
+	       (cur == '-')) {
+	    if (len + 1 >= size) {
+		size *= 2;
+		buf = (xmlChar *) xmlRealloc(buf, size * sizeof(xmlChar));
+		if (buf == NULL) {
+		    xmlErrMemory(ctxt, NULL);
+		    return(NULL);
+		}
+	    }
+	    buf[len++] = cur;
+	    NEXT;
+	    cur = CUR;
+	    if (cur == 0) {
+	        SHRINK;
+		GROW;
+		cur = CUR;
+	    }
+        }
+	buf[len] = 0;
+    } else {
+	xmlFatalErr(ctxt, XML_ERR_ENCODING_NAME, NULL);
+    }
+    return(buf);
+}
+
+/**
+ * xmlParseEncodingDecl:
+ * @ctxt:  an XML parser context
+ * 
+ * parse the XML encoding declaration
+ *
+ * [80] EncodingDecl ::= S 'encoding' Eq ('"' EncName '"' |  "'" EncName "'")
+ *
+ * this setups the conversion filters.
+ *
+ * Returns the encoding value or NULL
+ */
+
+const xmlChar *
+xmlParseEncodingDecl(xmlParserCtxtPtr ctxt) {
+    xmlChar *encoding = NULL;
+
+    SKIP_BLANKS;
+    if (CMP8(CUR_PTR, 'e', 'n', 'c', 'o', 'd', 'i', 'n', 'g')) {
+	SKIP(8);
+	SKIP_BLANKS;
+	if (RAW != '=') {
+	    xmlFatalErr(ctxt, XML_ERR_EQUAL_REQUIRED, NULL);
+	    return(NULL);
+        }
+	NEXT;
+	SKIP_BLANKS;
+	if (RAW == '"') {
+	    NEXT;
+	    encoding = xmlParseEncName(ctxt);
+	    if (RAW != '"') {
+		xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
+	    } else
+	        NEXT;
+	} else if (RAW == '\''){
+	    NEXT;
+	    encoding = xmlParseEncName(ctxt);
+	    if (RAW != '\'') {
+		xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
+	    } else
+	        NEXT;
+	} else {
+	    xmlFatalErr(ctxt, XML_ERR_STRING_NOT_STARTED, NULL);
+	}
+	/*
+	 * UTF-16 encoding stwich has already taken place at this stage,
+	 * more over the little-endian/big-endian selection is already done
+	 */
+        if ((encoding != NULL) &&
+	    ((!xmlStrcasecmp(encoding, BAD_CAST "UTF-16")) ||
+	     (!xmlStrcasecmp(encoding, BAD_CAST "UTF16")))) {
+	    if (ctxt->encoding != NULL)
+		xmlFree((xmlChar *) ctxt->encoding);
+	    ctxt->encoding = encoding;
+	}
+	/*
+	 * UTF-8 encoding is handled natively
+	 */
+        else if ((encoding != NULL) &&
+	    ((!xmlStrcasecmp(encoding, BAD_CAST "UTF-8")) ||
+	     (!xmlStrcasecmp(encoding, BAD_CAST "UTF8")))) {
+	    if (ctxt->encoding != NULL)
+		xmlFree((xmlChar *) ctxt->encoding);
+	    ctxt->encoding = encoding;
+	}
+	else if (encoding != NULL) {
+	    xmlCharEncodingHandlerPtr handler;
+
+	    if (ctxt->input->encoding != NULL)
+		xmlFree((xmlChar *) ctxt->input->encoding);
+	    ctxt->input->encoding = encoding;
+
+            handler = xmlFindCharEncodingHandler((const char *) encoding);
+	    if (handler != NULL) {
+		xmlSwitchToEncoding(ctxt, handler);
+	    } else {
+		xmlFatalErrMsgStr(ctxt, XML_ERR_UNSUPPORTED_ENCODING,
+			"Unsupported encoding %s\n", encoding);
+		return(NULL);
+	    }
+	}
+    }
+    return(encoding);
+}
+
+/**
+ * xmlParseSDDecl:
+ * @ctxt:  an XML parser context
+ *
+ * parse the XML standalone declaration
+ *
+ * [32] SDDecl ::= S 'standalone' Eq
+ *                 (("'" ('yes' | 'no') "'") | ('"' ('yes' | 'no')'"')) 
+ *
+ * [ VC: Standalone Document Declaration ]
+ * TODO The standalone document declaration must have the value "no"
+ * if any external markup declarations contain declarations of:
+ *  - attributes with default values, if elements to which these
+ *    attributes apply appear in the document without specifications
+ *    of values for these attributes, or
+ *  - entities (other than amp, lt, gt, apos, quot), if references
+ *    to those entities appear in the document, or
+ *  - attributes with values subject to normalization, where the
+ *    attribute appears in the document with a value which will change
+ *    as a result of normalization, or
+ *  - element types with element content, if white space occurs directly
+ *    within any instance of those types.
+ *
+ * Returns 1 if standalone, 0 otherwise
+ */
+
+int
+xmlParseSDDecl(xmlParserCtxtPtr ctxt) {
+    int standalone = -1;
+
+    SKIP_BLANKS;
+    if (CMP10(CUR_PTR, 's', 't', 'a', 'n', 'd', 'a', 'l', 'o', 'n', 'e')) {
+	SKIP(10);
+        SKIP_BLANKS;
+	if (RAW != '=') {
+	    xmlFatalErr(ctxt, XML_ERR_EQUAL_REQUIRED, NULL);
+	    return(standalone);
+        }
+	NEXT;
+	SKIP_BLANKS;
+        if (RAW == '\''){
+	    NEXT;
+	    if ((RAW == 'n') && (NXT(1) == 'o')) {
+	        standalone = 0;
+                SKIP(2);
+	    } else if ((RAW == 'y') && (NXT(1) == 'e') &&
+	               (NXT(2) == 's')) {
+	        standalone = 1;
+		SKIP(3);
+            } else {
+		xmlFatalErr(ctxt, XML_ERR_STANDALONE_VALUE, NULL);
+	    }
+	    if (RAW != '\'') {
+		xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
+	    } else
+	        NEXT;
+	} else if (RAW == '"'){
+	    NEXT;
+	    if ((RAW == 'n') && (NXT(1) == 'o')) {
+	        standalone = 0;
+		SKIP(2);
+	    } else if ((RAW == 'y') && (NXT(1) == 'e') &&
+	               (NXT(2) == 's')) {
+	        standalone = 1;
+                SKIP(3);
+            } else {
+		xmlFatalErr(ctxt, XML_ERR_STANDALONE_VALUE, NULL);
+	    }
+	    if (RAW != '"') {
+		xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
+	    } else
+	        NEXT;
+	} else {
+	    xmlFatalErr(ctxt, XML_ERR_STRING_NOT_STARTED, NULL);
+        }
+    }
+    return(standalone);
+}
+
+/**
+ * xmlParseXMLDecl:
+ * @ctxt:  an XML parser context
+ * 
+ * parse an XML declaration header
+ *
+ * [23] XMLDecl ::= '<?xml' VersionInfo EncodingDecl? SDDecl? S? '?>'
+ */
+
+void
+xmlParseXMLDecl(xmlParserCtxtPtr ctxt) {
+    xmlChar *version;
+
+    /*
+     * We know that '<?xml' is here.
+     */
+    SKIP(5);
+
+    if (!IS_BLANK_CH(RAW)) {
+	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
+	               "Blank needed after '<?xml'\n");
+    }
+    SKIP_BLANKS;
+
+    /*
+     * We must have the VersionInfo here.
+     */
+    version = xmlParseVersionInfo(ctxt);
+    if (version == NULL) {
+	xmlFatalErr(ctxt, XML_ERR_VERSION_MISSING, NULL);
+    } else {
+	if (!xmlStrEqual(version, (const xmlChar *) XML_DEFAULT_VERSION)) {
+	    /*
+	     * TODO: Blueberry should be detected here
+	     */
+	    xmlWarningMsg(ctxt, XML_WAR_UNKNOWN_VERSION,
+		          "Unsupported version '%s'\n",
+			  version, NULL);
+	}
+	if (ctxt->version != NULL)
+	    xmlFree((void *) ctxt->version);
+	ctxt->version = version;
+    }
+
+    /*
+     * We may have the encoding declaration
+     */
+    if (!IS_BLANK_CH(RAW)) {
+        if ((RAW == '?') && (NXT(1) == '>')) {
+	    SKIP(2);
+	    return;
+	}
+	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, "Blank needed here\n");
+    }
+    xmlParseEncodingDecl(ctxt);
+    if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
+	/*
+	 * The XML REC instructs us to stop parsing right here
+	 */
+        return;
+    }
+
+    /*
+     * We may have the standalone status.
+     */
+    if ((ctxt->input->encoding != NULL) && (!IS_BLANK_CH(RAW))) {
+        if ((RAW == '?') && (NXT(1) == '>')) {
+	    SKIP(2);
+	    return;
+	}
+	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, "Blank needed here\n");
+    }
+    SKIP_BLANKS;
+    ctxt->input->standalone = xmlParseSDDecl(ctxt);
+
+    SKIP_BLANKS;
+    if ((RAW == '?') && (NXT(1) == '>')) {
+        SKIP(2);
+    } else if (RAW == '>') {
+        /* Deprecated old WD ... */
+	xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL);
+	NEXT;
+    } else {
+	xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL);
+	MOVETO_ENDTAG(CUR_PTR);
+	NEXT;
+    }
+}
+
+/**
+ * xmlParseMisc:
+ * @ctxt:  an XML parser context
+ * 
+ * parse an XML Misc* optional field.
+ *
+ * [27] Misc ::= Comment | PI |  S
+ */
+
+void
+xmlParseMisc(xmlParserCtxtPtr ctxt) {
+    while (((RAW == '<') && (NXT(1) == '?')) ||
+           (CMP4(CUR_PTR, '<', '!', '-', '-')) ||
+           IS_BLANK_CH(CUR)) {
+        if ((RAW == '<') && (NXT(1) == '?')) {
+	    xmlParsePI(ctxt);
+	} else if (IS_BLANK_CH(CUR)) {
+	    NEXT;
+	} else
+	    xmlParseComment(ctxt);
+    }
+}
+
+/**
+ * xmlParseDocument:
+ * @ctxt:  an XML parser context
+ * 
+ * parse an XML document (and build a tree if using the standard SAX
+ * interface).
+ *
+ * [1] document ::= prolog element Misc*
+ *
+ * [22] prolog ::= XMLDecl? Misc* (doctypedecl Misc*)?
+ *
+ * Returns 0, -1 in case of error. the parser context is augmented
+ *                as a result of the parsing.
+ */
+
+int
+xmlParseDocument(xmlParserCtxtPtr ctxt) {
+    xmlChar start[4];
+    xmlCharEncoding enc;
+
+    xmlInitParser();
+
+    GROW;
+
+    /*
+     * SAX: detecting the level.
+     */
+    xmlDetectSAX2(ctxt);
+
+    /*
+     * SAX: beginning of the document processing.
+     */
+    if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
+        ctxt->sax->setDocumentLocator(ctxt->userData, &xmlDefaultSAXLocator);
+
+    if ((ctxt->encoding == (const xmlChar *)XML_CHAR_ENCODING_NONE) &&
+        ((ctxt->input->end - ctxt->input->cur) >= 4)) {
+	/* 
+	 * Get the 4 first bytes and decode the charset
+	 * if enc != XML_CHAR_ENCODING_NONE
+	 * plug some encoding conversion routines.
+	 */
+	start[0] = RAW;
+	start[1] = NXT(1);
+	start[2] = NXT(2);
+	start[3] = NXT(3);
+	enc = xmlDetectCharEncoding(&start[0], 4);
+	if (enc != XML_CHAR_ENCODING_NONE) {
+	    xmlSwitchEncoding(ctxt, enc);
+	}
+    }
+
+
+    if (CUR == 0) {
+	xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL);
+    }
+
+    /*
+     * Check for the XMLDecl in the Prolog.
+     */
+    GROW;
+    if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) {
+
+	/*
+	 * Note that we will switch encoding on the fly.
+	 */
+	xmlParseXMLDecl(ctxt);
+	if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
+	    /*
+	     * The XML REC instructs us to stop parsing right here
+	     */
+	    return(-1);
+	}
+	ctxt->standalone = ctxt->input->standalone;
+	SKIP_BLANKS;
+    } else {
+	ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION);
+    }
+    if ((ctxt->sax) && (ctxt->sax->startDocument) && (!ctxt->disableSAX))
+        ctxt->sax->startDocument(ctxt->userData);
+
+    /*
+     * The Misc part of the Prolog
+     */
+    GROW;
+    xmlParseMisc(ctxt);
+
+    /*
+     * Then possibly doc type declaration(s) and more Misc
+     * (doctypedecl Misc*)?
+     */
+    GROW;
+    if (CMP9(CUR_PTR, '<', '!', 'D', 'O', 'C', 'T', 'Y', 'P', 'E')) {
+
+	ctxt->inSubset = 1;
+	xmlParseDocTypeDecl(ctxt);
+	if (RAW == '[') {
+	    ctxt->instate = XML_PARSER_DTD;
+	    xmlParseInternalSubset(ctxt);
+	}
+
+	/*
+	 * Create and update the external subset.
+	 */
+	ctxt->inSubset = 2;
+	if ((ctxt->sax != NULL) && (ctxt->sax->externalSubset != NULL) &&
+	    (!ctxt->disableSAX))
+	    ctxt->sax->externalSubset(ctxt->userData, ctxt->intSubName,
+	                              ctxt->extSubSystem, ctxt->extSubURI);
+	ctxt->inSubset = 0;
+
+
+	ctxt->instate = XML_PARSER_PROLOG;
+	xmlParseMisc(ctxt);
+    }
+
+    /*
+     * Time to start parsing the tree itself
+     */
+    GROW;
+    if (RAW != '<') {
+	xmlFatalErrMsg(ctxt, XML_ERR_DOCUMENT_EMPTY,
+		       "Start tag expected, '<' not found\n");
+    } else {
+	ctxt->instate = XML_PARSER_CONTENT;
+	xmlParseElement(ctxt);
+	ctxt->instate = XML_PARSER_EPILOG;
+
+
+	/*
+	 * The Misc part at the end
+	 */
+	xmlParseMisc(ctxt);
+
+	if (RAW != 0) {
+	    xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL);
+	}
+	ctxt->instate = XML_PARSER_EOF;
+    }
+
+    /*
+     * SAX: end of the document processing.
+     */
+    if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
+        ctxt->sax->endDocument(ctxt->userData);
+
+    /*
+     * Remove locally kept entity definitions if the tree was not built
+     */
+    if ((ctxt->myDoc != NULL) &&
+	(xmlStrEqual(ctxt->myDoc->version, SAX_COMPAT_MODE))) {
+	xmlFreeDoc(ctxt->myDoc);
+	ctxt->myDoc = NULL;
+    }
+
+    if (! ctxt->wellFormed) {
+	ctxt->valid = 0;
+	return(-1);
+    }
+    return(0);
+}
+
+/**
+ * xmlParseExtParsedEnt:
+ * @ctxt:  an XML parser context
+ * 
+ * parse a general parsed entity
+ * An external general parsed entity is well-formed if it matches the
+ * production labeled extParsedEnt.
+ *
+ * [78] extParsedEnt ::= TextDecl? content
+ *
+ * Returns 0, -1 in case of error. the parser context is augmented
+ *                as a result of the parsing.
+ */
+
+int
+xmlParseExtParsedEnt(xmlParserCtxtPtr ctxt) {
+    xmlChar start[4];
+    xmlCharEncoding enc;
+
+    xmlDefaultSAXHandlerInit();
+
+    xmlDetectSAX2(ctxt);
+
+    GROW;
+
+    /*
+     * SAX: beginning of the document processing.
+     */
+    if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
+        ctxt->sax->setDocumentLocator(ctxt->userData, &xmlDefaultSAXLocator);
+
+    /* 
+     * Get the 4 first bytes and decode the charset
+     * if enc != XML_CHAR_ENCODING_NONE
+     * plug some encoding conversion routines.
+     */
+    if ((ctxt->input->end - ctxt->input->cur) >= 4) {
+	start[0] = RAW;
+	start[1] = NXT(1);
+	start[2] = NXT(2);
+	start[3] = NXT(3);
+	enc = xmlDetectCharEncoding(start, 4);
+	if (enc != XML_CHAR_ENCODING_NONE) {
+	    xmlSwitchEncoding(ctxt, enc);
+	}
+    }
+
+
+    if (CUR == 0) {
+	xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL);
+    }
+
+    /*
+     * Check for the XMLDecl in the Prolog.
+     */
+    GROW;
+    if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) {
+
+	/*
+	 * Note that we will switch encoding on the fly.
+	 */
+	xmlParseXMLDecl(ctxt);
+	if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
+	    /*
+	     * The XML REC instructs us to stop parsing right here
+	     */
+	    return(-1);
+	}
+	SKIP_BLANKS;
+    } else {
+	ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION);
+    }
+    if ((ctxt->sax) && (ctxt->sax->startDocument) && (!ctxt->disableSAX))
+        ctxt->sax->startDocument(ctxt->userData);
+
+    /*
+     * Doing validity checking on chunk doesn't make sense
+     */
+    ctxt->instate = XML_PARSER_CONTENT;
+    ctxt->validate = 0;
+    ctxt->loadsubset = 0;
+    ctxt->depth = 0;
+
+    xmlParseContent(ctxt);
+   
+    if ((RAW == '<') && (NXT(1) == '/')) {
+	xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
+    } else if (RAW != 0) {
+	xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
+    }
+
+    /*
+     * SAX: end of the document processing.
+     */
+    if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
+        ctxt->sax->endDocument(ctxt->userData);
+
+    if (! ctxt->wellFormed) return(-1);
+    return(0);
+}
+
+#ifdef LIBXML_PUSH_ENABLED
+/************************************************************************
+ *									*
+ * 		Progressive parsing interfaces				*
+ *									*
+ ************************************************************************/
+
+/**
+ * xmlParseLookupSequence:
+ * @ctxt:  an XML parser context
+ * @first:  the first char to lookup
+ * @next:  the next char to lookup or zero
+ * @third:  the next char to lookup or zero
+ *
+ * Try to find if a sequence (first, next, third) or  just (first next) or
+ * (first) is available in the input stream.
+ * This function has a side effect of (possibly) incrementing ctxt->checkIndex
+ * to avoid rescanning sequences of bytes, it DOES change the state of the
+ * parser, do not use liberally.
+ *
+ * Returns the index to the current parsing point if the full sequence
+ *      is available, -1 otherwise.
+ */
+static int
+xmlParseLookupSequence(xmlParserCtxtPtr ctxt, xmlChar first,
+                       xmlChar next, xmlChar third) {
+    int base, len;
+    xmlParserInputPtr in;
+    const xmlChar *buf;
+
+    in = ctxt->input;
+    if (in == NULL) return(-1);
+    base = in->cur - in->base;
+    if (base < 0) return(-1);
+    if (ctxt->checkIndex > base)
+        base = ctxt->checkIndex;
+    if (in->buf == NULL) {
+	buf = in->base;
+	len = in->length;
+    } else {
+	buf = in->buf->buffer->content;
+	len = in->buf->buffer->use;
+    }
+    /* take into account the sequence length */
+    if (third) len -= 2;
+    else if (next) len --;
+    for (;base < len;base++) {
+        if (buf[base] == first) {
+	    if (third != 0) {
+		if ((buf[base + 1] != next) ||
+		    (buf[base + 2] != third)) continue;
+	    } else if (next != 0) {
+		if (buf[base + 1] != next) continue;
+	    }
+	    ctxt->checkIndex = 0;
+#ifdef DEBUG_PUSH
+	    if (next == 0)
+		xmlGenericError(xmlGenericErrorContext,
+			"PP: lookup '%c' found at %d\n",
+			first, base);
+	    else if (third == 0)
+		xmlGenericError(xmlGenericErrorContext,
+			"PP: lookup '%c%c' found at %d\n",
+			first, next, base);
+	    else 
+		xmlGenericError(xmlGenericErrorContext,
+			"PP: lookup '%c%c%c' found at %d\n",
+			first, next, third, base);
+#endif
+	    return(base - (in->cur - in->base));
+	}
+    }
+    ctxt->checkIndex = base;
+#ifdef DEBUG_PUSH
+    if (next == 0)
+	xmlGenericError(xmlGenericErrorContext,
+		"PP: lookup '%c' failed\n", first);
+    else if (third == 0)
+	xmlGenericError(xmlGenericErrorContext,
+		"PP: lookup '%c%c' failed\n", first, next);
+    else	
+	xmlGenericError(xmlGenericErrorContext,
+		"PP: lookup '%c%c%c' failed\n", first, next, third);
+#endif
+    return(-1);
+}
+
+/**
+ * xmlParseGetLasts:
+ * @ctxt:  an XML parser context
+ * @lastlt:  pointer to store the last '<' from the input
+ * @lastgt:  pointer to store the last '>' from the input
+ *
+ * Lookup the last < and > in the current chunk
+ */
+static void
+xmlParseGetLasts(xmlParserCtxtPtr ctxt, const xmlChar **lastlt,
+                 const xmlChar **lastgt) {
+    const xmlChar *tmp;
+
+    if ((ctxt == NULL) || (lastlt == NULL) || (lastgt == NULL)) {
+	xmlGenericError(xmlGenericErrorContext,
+		    "Internal error: xmlParseGetLasts\n");
+	return;
+    }
+    if ((ctxt->progressive == 1) && (ctxt->inputNr == 1)) {
+        tmp = ctxt->input->end;
+	tmp--;
+	while ((tmp >= ctxt->input->base) && (*tmp != '<') &&
+	       (*tmp != '>')) tmp--;
+	if (tmp < ctxt->input->base) {
+	    *lastlt = NULL;
+	    *lastgt = NULL;
+	} else if (*tmp == '<') {
+	    *lastlt = tmp;
+	    tmp--;
+	    while ((tmp >= ctxt->input->base) && (*tmp != '>')) tmp--;
+	    if (tmp < ctxt->input->base)
+	        *lastgt = NULL;
+	    else
+	        *lastgt = tmp;
+	} else {
+	    *lastgt = tmp;
+	    tmp--;
+	    while ((tmp >= ctxt->input->base) && (*tmp != '<')) tmp--;
+	    if (tmp < ctxt->input->base)
+	        *lastlt = NULL;
+	    else
+	        *lastlt = tmp;
+	}
+        
+    } else {
+        *lastlt = NULL;
+	*lastgt = NULL;
+    }
+}
+/**
+ * xmlParseTryOrFinish:
+ * @ctxt:  an XML parser context
+ * @terminate:  last chunk indicator
+ *
+ * Try to progress on parsing
+ *
+ * Returns zero if no parsing was possible
+ */
+static int
+xmlParseTryOrFinish(xmlParserCtxtPtr ctxt, int terminate) {
+    int ret = 0;
+    int avail, tlen;
+    xmlChar cur, next;
+    const xmlChar *lastlt, *lastgt;
+
+#ifdef DEBUG_PUSH
+    switch (ctxt->instate) {
+	case XML_PARSER_EOF:
+	    xmlGenericError(xmlGenericErrorContext,
+		    "PP: try EOF\n"); break;
+	case XML_PARSER_START:
+	    xmlGenericError(xmlGenericErrorContext,
+		    "PP: try START\n"); break;
+	case XML_PARSER_MISC:
+	    xmlGenericError(xmlGenericErrorContext,
+		    "PP: try MISC\n");break;
+	case XML_PARSER_COMMENT:
+	    xmlGenericError(xmlGenericErrorContext,
+		    "PP: try COMMENT\n");break;
+	case XML_PARSER_PROLOG:
+	    xmlGenericError(xmlGenericErrorContext,
+		    "PP: try PROLOG\n");break;
+	case XML_PARSER_START_TAG:
+	    xmlGenericError(xmlGenericErrorContext,
+		    "PP: try START_TAG\n");break;
+	case XML_PARSER_CONTENT:
+	    xmlGenericError(xmlGenericErrorContext,
+		    "PP: try CONTENT\n");break;
+	case XML_PARSER_CDATA_SECTION:
+	    xmlGenericError(xmlGenericErrorContext,
+		    "PP: try CDATA_SECTION\n");break;
+	case XML_PARSER_END_TAG:
+	    xmlGenericError(xmlGenericErrorContext,
+		    "PP: try END_TAG\n");break;
+	case XML_PARSER_ENTITY_DECL:
+	    xmlGenericError(xmlGenericErrorContext,
+		    "PP: try ENTITY_DECL\n");break;
+	case XML_PARSER_ENTITY_VALUE:
+	    xmlGenericError(xmlGenericErrorContext,
+		    "PP: try ENTITY_VALUE\n");break;
+	case XML_PARSER_ATTRIBUTE_VALUE:
+	    xmlGenericError(xmlGenericErrorContext,
+		    "PP: try ATTRIBUTE_VALUE\n");break;
+	case XML_PARSER_DTD:
+	    xmlGenericError(xmlGenericErrorContext,
+		    "PP: try DTD\n");break;
+	case XML_PARSER_EPILOG:
+	    xmlGenericError(xmlGenericErrorContext,
+		    "PP: try EPILOG\n");break;
+	case XML_PARSER_PI:
+	    xmlGenericError(xmlGenericErrorContext,
+		    "PP: try PI\n");break;
+        case XML_PARSER_IGNORE:
+            xmlGenericError(xmlGenericErrorContext,
+		    "PP: try IGNORE\n");break;
+    }
+#endif
+
+    if ((ctxt->input != NULL) &&
+        (ctxt->input->cur - ctxt->input->base > 4096)) {
+	xmlSHRINK(ctxt);
+	ctxt->checkIndex = 0;
+    }
+    xmlParseGetLasts(ctxt, &lastlt, &lastgt);
+
+    while (1) {
+	if ((ctxt->errNo != XML_ERR_OK) && (ctxt->disableSAX == 1))
+	    return(0);
+
+        
+	/*
+	 * Pop-up of finished entities.
+	 */
+	while ((RAW == 0) && (ctxt->inputNr > 1))
+	    xmlPopInput(ctxt);
+
+	if (ctxt->input == NULL) break;
+	if (ctxt->input->buf == NULL)
+	    avail = ctxt->input->length -
+	            (ctxt->input->cur - ctxt->input->base);
+	else {
+	    /*
+	     * If we are operating on converted input, try to flush
+	     * remainng chars to avoid them stalling in the non-converted
+	     * buffer.
+	     */
+	    if ((ctxt->input->buf->raw != NULL) &&
+		(ctxt->input->buf->raw->use > 0)) {
+		int base = ctxt->input->base -
+		           ctxt->input->buf->buffer->content;
+		int current = ctxt->input->cur - ctxt->input->base;
+
+		xmlParserInputBufferPush(ctxt->input->buf, 0, "");
+		ctxt->input->base = ctxt->input->buf->buffer->content + base;
+		ctxt->input->cur = ctxt->input->base + current;
+		ctxt->input->end =
+		    &ctxt->input->buf->buffer->content[
+		                       ctxt->input->buf->buffer->use];
+	    }
+	    avail = ctxt->input->buf->buffer->use -
+		    (ctxt->input->cur - ctxt->input->base);
+	}
+        if (avail < 1)
+	    goto done;
+        switch (ctxt->instate) {
+            case XML_PARSER_EOF:
+	        /*
+		 * Document parsing is done !
+		 */
+	        goto done;
+            case XML_PARSER_START:
+		if (ctxt->charset == XML_CHAR_ENCODING_NONE) {
+		    xmlChar start[4];
+		    xmlCharEncoding enc;
+
+		    /*
+		     * Very first chars read from the document flow.
+		     */
+		    if (avail < 4)
+			goto done;
+
+		    /* 
+		     * Get the 4 first bytes and decode the charset
+		     * if enc != XML_CHAR_ENCODING_NONE
+		     * plug some encoding conversion routines.
+		     */
+		    start[0] = RAW;
+		    start[1] = NXT(1);
+		    start[2] = NXT(2);
+		    start[3] = NXT(3);
+		    enc = xmlDetectCharEncoding(start, 4);
+		    if (enc != XML_CHAR_ENCODING_NONE) {
+			xmlSwitchEncoding(ctxt, enc);
+		    }
+		    break;
+		}
+
+		if (avail < 2)
+		    goto done;
+		cur = ctxt->input->cur[0];
+		next = ctxt->input->cur[1];
+		if (cur == 0) {
+		    if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
+			ctxt->sax->setDocumentLocator(ctxt->userData,
+						      &xmlDefaultSAXLocator);
+		    xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL);
+		    ctxt->instate = XML_PARSER_EOF;
+#ifdef DEBUG_PUSH
+		    xmlGenericError(xmlGenericErrorContext,
+			    "PP: entering EOF\n");
+#endif
+		    if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
+			ctxt->sax->endDocument(ctxt->userData);
+		    goto done;
+		}
+	        if ((cur == '<') && (next == '?')) {
+		    /* PI or XML decl */
+		    if (avail < 5) return(ret);
+		    if ((!terminate) &&
+		        (xmlParseLookupSequence(ctxt, '?', '>', 0) < 0))
+			return(ret);
+		    if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
+			ctxt->sax->setDocumentLocator(ctxt->userData,
+						      &xmlDefaultSAXLocator);
+		    if ((ctxt->input->cur[2] == 'x') &&
+			(ctxt->input->cur[3] == 'm') &&
+			(ctxt->input->cur[4] == 'l') &&
+			(IS_BLANK_CH(ctxt->input->cur[5]))) {
+			ret += 5;
+#ifdef DEBUG_PUSH
+			xmlGenericError(xmlGenericErrorContext,
+				"PP: Parsing XML Decl\n");
+#endif
+			xmlParseXMLDecl(ctxt);
+			if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
+			    /*
+			     * The XML REC instructs us to stop parsing right
+			     * here
+			     */
+			    ctxt->instate = XML_PARSER_EOF;
+			    return(0);
+			}
+			ctxt->standalone = ctxt->input->standalone;
+			if ((ctxt->encoding == NULL) &&
+			    (ctxt->input->encoding != NULL))
+			    ctxt->encoding = xmlStrdup(ctxt->input->encoding);
+			if ((ctxt->sax) && (ctxt->sax->startDocument) &&
+			    (!ctxt->disableSAX))
+			    ctxt->sax->startDocument(ctxt->userData);
+			ctxt->instate = XML_PARSER_MISC;
+#ifdef DEBUG_PUSH
+			xmlGenericError(xmlGenericErrorContext,
+				"PP: entering MISC\n");
+#endif
+		    } else {
+			ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION);
+			if ((ctxt->sax) && (ctxt->sax->startDocument) &&
+			    (!ctxt->disableSAX))
+			    ctxt->sax->startDocument(ctxt->userData);
+			ctxt->instate = XML_PARSER_MISC;
+#ifdef DEBUG_PUSH
+			xmlGenericError(xmlGenericErrorContext,
+				"PP: entering MISC\n");
+#endif
+		    }
+		} else {
+		    if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
+			ctxt->sax->setDocumentLocator(ctxt->userData,
+						      &xmlDefaultSAXLocator);
+		    ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION);
+		    if ((ctxt->sax) && (ctxt->sax->startDocument) &&
+		        (!ctxt->disableSAX))
+			ctxt->sax->startDocument(ctxt->userData);
+		    ctxt->instate = XML_PARSER_MISC;
+#ifdef DEBUG_PUSH
+		    xmlGenericError(xmlGenericErrorContext,
+			    "PP: entering MISC\n");
+#endif
+		}
+		break;
+            case XML_PARSER_START_TAG: {
+	        const xmlChar *name;
+		const xmlChar *prefix;
+		const xmlChar *URI;
+		int nsNr = ctxt->nsNr;
+
+		if ((avail < 2) && (ctxt->inputNr == 1))
+		    goto done;
+		cur = ctxt->input->cur[0];
+	        if (cur != '<') {
+		    xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL);
+		    ctxt->instate = XML_PARSER_EOF;
+		    if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
+			ctxt->sax->endDocument(ctxt->userData);
+		    goto done;
+		}
+		if (!terminate) {
+		    if (ctxt->progressive) {
+		        /* > can be found unescaped in attribute values */
+		        if ((lastlt == NULL) || (ctxt->input->cur >= lastlt))
+			    goto done;
+		    } else if (xmlParseLookupSequence(ctxt, '>', 0, 0) < 0) {
+			goto done;
+		    }
+		}
+		if (ctxt->spaceNr == 0)
+		    spacePush(ctxt, -1);
+		else
+		    spacePush(ctxt, *ctxt->space);
+#ifdef LIBXML_SAX1_ENABLED
+		if (ctxt->sax2)
+#endif /* LIBXML_SAX1_ENABLED */
+		    name = xmlParseStartTag2(ctxt, &prefix, &URI, &tlen);
+#ifdef LIBXML_SAX1_ENABLED
+		else
+		    name = xmlParseStartTag(ctxt);
+#endif /* LIBXML_SAX1_ENABLED */
+		if (name == NULL) {
+		    spacePop(ctxt);
+		    ctxt->instate = XML_PARSER_EOF;
+		    if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
+			ctxt->sax->endDocument(ctxt->userData);
+		    goto done;
+		}
+#ifdef LIBXML_VALID_ENABLED
+		/*
+		 * [ VC: Root Element Type ]
+		 * The Name in the document type declaration must match
+		 * the element type of the root element. 
+		 */
+		if (ctxt->validate && ctxt->wellFormed && ctxt->myDoc &&
+		    ctxt->node && (ctxt->node == ctxt->myDoc->children))
+		    ctxt->valid &= xmlValidateRoot(&ctxt->vctxt, ctxt->myDoc);
+#endif /* LIBXML_VALID_ENABLED */
+
+		/*
+		 * Check for an Empty Element.
+		 */
+		if ((RAW == '/') && (NXT(1) == '>')) {
+		    SKIP(2);
+
+		    if (ctxt->sax2) {
+			if ((ctxt->sax != NULL) &&
+			    (ctxt->sax->endElementNs != NULL) &&
+			    (!ctxt->disableSAX))
+			    ctxt->sax->endElementNs(ctxt->userData, name,
+			                            prefix, URI);
+#ifdef LIBXML_SAX1_ENABLED
+		    } else {
+			if ((ctxt->sax != NULL) &&
+			    (ctxt->sax->endElement != NULL) &&
+			    (!ctxt->disableSAX))
+			    ctxt->sax->endElement(ctxt->userData, name);
+#endif /* LIBXML_SAX1_ENABLED */
+		    }
+		    spacePop(ctxt);
+		    if (ctxt->nameNr == 0) {
+			ctxt->instate = XML_PARSER_EPILOG;
+		    } else {
+			ctxt->instate = XML_PARSER_CONTENT;
+		    }
+		    break;
+		}
+		if (RAW == '>') {
+		    NEXT;
+		} else {
+		    xmlFatalErrMsgStr(ctxt, XML_ERR_GT_REQUIRED,
+					 "Couldn't find end of Start Tag %s\n",
+					 name);
+		    nodePop(ctxt);
+		    spacePop(ctxt);
+		}
+		if (ctxt->sax2)
+		    nameNsPush(ctxt, name, prefix, URI, ctxt->nsNr - nsNr);
+#ifdef LIBXML_SAX1_ENABLED
+		else
+		    namePush(ctxt, name);
+#endif /* LIBXML_SAX1_ENABLED */
+
+		ctxt->instate = XML_PARSER_CONTENT;
+                break;
+	    }
+            case XML_PARSER_CONTENT: {
+		const xmlChar *test;
+		unsigned int cons;
+		if ((avail < 2) && (ctxt->inputNr == 1))
+		    goto done;
+		cur = ctxt->input->cur[0];
+		next = ctxt->input->cur[1];
+
+		test = CUR_PTR;
+	        cons = ctxt->input->consumed;
+		if ((cur == '<') && (next == '/')) {
+		    ctxt->instate = XML_PARSER_END_TAG;
+		    break;
+	        } else if ((cur == '<') && (next == '?')) {
+		    if ((!terminate) &&
+		        (xmlParseLookupSequence(ctxt, '?', '>', 0) < 0))
+			goto done;
+		    xmlParsePI(ctxt);
+		} else if ((cur == '<') && (next != '!')) {
+		    ctxt->instate = XML_PARSER_START_TAG;
+		    break;
+		} else if ((cur == '<') && (next == '!') &&
+		           (ctxt->input->cur[2] == '-') &&
+			   (ctxt->input->cur[3] == '-')) {
+		    if ((!terminate) &&
+		        (xmlParseLookupSequence(ctxt, '-', '-', '>') < 0))
+			goto done;
+		    xmlParseComment(ctxt);
+		    ctxt->instate = XML_PARSER_CONTENT;
+		} else if ((cur == '<') && (ctxt->input->cur[1] == '!') &&
+		    (ctxt->input->cur[2] == '[') &&
+		    (ctxt->input->cur[3] == 'C') &&
+		    (ctxt->input->cur[4] == 'D') &&
+		    (ctxt->input->cur[5] == 'A') &&
+		    (ctxt->input->cur[6] == 'T') &&
+		    (ctxt->input->cur[7] == 'A') &&
+		    (ctxt->input->cur[8] == '[')) {
+		    SKIP(9);
+		    ctxt->instate = XML_PARSER_CDATA_SECTION;
+		    break;
+		} else if ((cur == '<') && (next == '!') &&
+		           (avail < 9)) {
+		    goto done;
+		} else if (cur == '&') {
+		    if ((!terminate) &&
+		        (xmlParseLookupSequence(ctxt, ';', 0, 0) < 0))
+			goto done;
+		    xmlParseReference(ctxt);
+		} else {
+		    /* TODO Avoid the extra copy, handle directly !!! */
+		    /*
+		     * Goal of the following test is:
+		     *  - minimize calls to the SAX 'character' callback
+		     *    when they are mergeable
+		     *  - handle an problem for isBlank when we only parse
+		     *    a sequence of blank chars and the next one is
+		     *    not available to check against '<' presence.
+		     *  - tries to homogenize the differences in SAX
+		     *    callbacks between the push and pull versions
+		     *    of the parser.
+		     */
+		    if ((ctxt->inputNr == 1) &&
+		        (avail < XML_PARSER_BIG_BUFFER_SIZE)) {
+			if (!terminate) {
+			    if (ctxt->progressive) {
+				if ((lastlt == NULL) ||
+				    (ctxt->input->cur > lastlt))
+				    goto done;
+			    } else if (xmlParseLookupSequence(ctxt,
+			                                      '<', 0, 0) < 0) {
+				goto done;
+			    }
+			}
+                    }
+		    ctxt->checkIndex = 0;
+		    xmlParseCharData(ctxt, 0);
+		}
+		/*
+		 * Pop-up of finished entities.
+		 */
+		while ((RAW == 0) && (ctxt->inputNr > 1))
+		    xmlPopInput(ctxt);
+		if ((cons == ctxt->input->consumed) && (test == CUR_PTR)) {
+		    xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
+		                "detected an error in element content\n");
+		    ctxt->instate = XML_PARSER_EOF;
+		    break;
+		}
+		break;
+	    }
+            case XML_PARSER_END_TAG:
+		if (avail < 2)
+		    goto done;
+		if (!terminate) {
+		    if (ctxt->progressive) {
+		        if ((lastgt == NULL) || (ctxt->input->cur > lastgt))
+			    goto done;
+		    } else if (xmlParseLookupSequence(ctxt, '>', 0, 0) < 0) {
+			goto done;
+		    }
+		}
+		if (ctxt->sax2) {
+		    xmlParseEndTag2(ctxt,
+		           (void *) ctxt->pushTab[ctxt->nameNr * 3 - 3],
+		           (void *) ctxt->pushTab[ctxt->nameNr * 3 - 2], 0,
+		       (int) (long) ctxt->pushTab[ctxt->nameNr * 3 - 1], 0);
+		    nameNsPop(ctxt);
+		}
+#ifdef LIBXML_SAX1_ENABLED
+		  else
+		    xmlParseEndTag1(ctxt, 0);
+#endif /* LIBXML_SAX1_ENABLED */
+		if (ctxt->nameNr == 0) {
+		    ctxt->instate = XML_PARSER_EPILOG;
+		} else {
+		    ctxt->instate = XML_PARSER_CONTENT;
+		}
+		break;
+            case XML_PARSER_CDATA_SECTION: {
+	        /*
+		 * The Push mode need to have the SAX callback for 
+		 * cdataBlock merge back contiguous callbacks.
+		 */
+		int base;
+
+		base = xmlParseLookupSequence(ctxt, ']', ']', '>');
+		if (base < 0) {
+		    if (avail >= XML_PARSER_BIG_BUFFER_SIZE + 2) {
+			if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) {
+			    if (ctxt->sax->cdataBlock != NULL)
+				ctxt->sax->cdataBlock(ctxt->userData,
+				                      ctxt->input->cur,
+					  XML_PARSER_BIG_BUFFER_SIZE);
+			    else if (ctxt->sax->characters != NULL)
+				ctxt->sax->characters(ctxt->userData,
+				                      ctxt->input->cur,
+					  XML_PARSER_BIG_BUFFER_SIZE);
+			}
+			SKIPL(XML_PARSER_BIG_BUFFER_SIZE);
+			ctxt->checkIndex = 0;
+		    }
+		    goto done;
+		} else {
+		    if ((ctxt->sax != NULL) && (base > 0) &&
+			(!ctxt->disableSAX)) {
+			if (ctxt->sax->cdataBlock != NULL)
+			    ctxt->sax->cdataBlock(ctxt->userData,
+						  ctxt->input->cur, base);
+			else if (ctxt->sax->characters != NULL)
+			    ctxt->sax->characters(ctxt->userData,
+						  ctxt->input->cur, base);
+		    }
+		    SKIPL(base + 3);
+		    ctxt->checkIndex = 0;
+		    ctxt->instate = XML_PARSER_CONTENT;
+#ifdef DEBUG_PUSH
+		    xmlGenericError(xmlGenericErrorContext,
+			    "PP: entering CONTENT\n");
+#endif
+		}
+		break;
+	    }
+            case XML_PARSER_MISC:
+		SKIP_BLANKS;
+		if (ctxt->input->buf == NULL)
+		    avail = ctxt->input->length -
+		            (ctxt->input->cur - ctxt->input->base);
+		else
+		    avail = ctxt->input->buf->buffer->use -
+		            (ctxt->input->cur - ctxt->input->base);
+		if (avail < 2)
+		    goto done;
+		cur = ctxt->input->cur[0];
+		next = ctxt->input->cur[1];
+	        if ((cur == '<') && (next == '?')) {
+		    if ((!terminate) &&
+		        (xmlParseLookupSequence(ctxt, '?', '>', 0) < 0))
+			goto done;
+#ifdef DEBUG_PUSH
+		    xmlGenericError(xmlGenericErrorContext,
+			    "PP: Parsing PI\n");
+#endif
+		    xmlParsePI(ctxt);
+		} else if ((cur == '<') && (next == '!') &&
+		    (ctxt->input->cur[2] == '-') &&
+		    (ctxt->input->cur[3] == '-')) {
+		    if ((!terminate) &&
+		        (xmlParseLookupSequence(ctxt, '-', '-', '>') < 0))
+			goto done;
+#ifdef DEBUG_PUSH
+		    xmlGenericError(xmlGenericErrorContext,
+			    "PP: Parsing Comment\n");
+#endif
+		    xmlParseComment(ctxt);
+		    ctxt->instate = XML_PARSER_MISC;
+		} else if ((cur == '<') && (next == '!') &&
+		    (ctxt->input->cur[2] == 'D') &&
+		    (ctxt->input->cur[3] == 'O') &&
+		    (ctxt->input->cur[4] == 'C') &&
+		    (ctxt->input->cur[5] == 'T') &&
+		    (ctxt->input->cur[6] == 'Y') &&
+		    (ctxt->input->cur[7] == 'P') &&
+		    (ctxt->input->cur[8] == 'E')) {
+		    if ((!terminate) &&
+		        (xmlParseLookupSequence(ctxt, '>', 0, 0) < 0))
+			goto done;
+#ifdef DEBUG_PUSH
+		    xmlGenericError(xmlGenericErrorContext,
+			    "PP: Parsing internal subset\n");
+#endif
+		    ctxt->inSubset = 1;
+		    xmlParseDocTypeDecl(ctxt);
+		    if (RAW == '[') {
+			ctxt->instate = XML_PARSER_DTD;
+#ifdef DEBUG_PUSH
+			xmlGenericError(xmlGenericErrorContext,
+				"PP: entering DTD\n");
+#endif
+		    } else {
+			/*
+			 * Create and update the external subset.
+			 */
+			ctxt->inSubset = 2;
+			if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
+			    (ctxt->sax->externalSubset != NULL))
+			    ctxt->sax->externalSubset(ctxt->userData,
+				    ctxt->intSubName, ctxt->extSubSystem,
+				    ctxt->extSubURI);
+			ctxt->inSubset = 0;
+			ctxt->instate = XML_PARSER_PROLOG;
+#ifdef DEBUG_PUSH
+			xmlGenericError(xmlGenericErrorContext,
+				"PP: entering PROLOG\n");
+#endif
+		    }
+		} else if ((cur == '<') && (next == '!') &&
+		           (avail < 9)) {
+		    goto done;
+		} else {
+		    ctxt->instate = XML_PARSER_START_TAG;
+		    ctxt->progressive = 1;
+		    xmlParseGetLasts(ctxt, &lastlt, &lastgt);
+#ifdef DEBUG_PUSH
+		    xmlGenericError(xmlGenericErrorContext,
+			    "PP: entering START_TAG\n");
+#endif
+		}
+		break;
+            case XML_PARSER_PROLOG:
+		SKIP_BLANKS;
+		if (ctxt->input->buf == NULL)
+		    avail = ctxt->input->length - (ctxt->input->cur - ctxt->input->base);
+		else
+		    avail = ctxt->input->buf->buffer->use - (ctxt->input->cur - ctxt->input->base);
+		if (avail < 2) 
+		    goto done;
+		cur = ctxt->input->cur[0];
+		next = ctxt->input->cur[1];
+	        if ((cur == '<') && (next == '?')) {
+		    if ((!terminate) &&
+		        (xmlParseLookupSequence(ctxt, '?', '>', 0) < 0))
+			goto done;
+#ifdef DEBUG_PUSH
+		    xmlGenericError(xmlGenericErrorContext,
+			    "PP: Parsing PI\n");
+#endif
+		    xmlParsePI(ctxt);
+		} else if ((cur == '<') && (next == '!') &&
+		    (ctxt->input->cur[2] == '-') && (ctxt->input->cur[3] == '-')) {
+		    if ((!terminate) &&
+		        (xmlParseLookupSequence(ctxt, '-', '-', '>') < 0))
+			goto done;
+#ifdef DEBUG_PUSH
+		    xmlGenericError(xmlGenericErrorContext,
+			    "PP: Parsing Comment\n");
+#endif
+		    xmlParseComment(ctxt);
+		    ctxt->instate = XML_PARSER_PROLOG;
+		} else if ((cur == '<') && (next == '!') &&
+		           (avail < 4)) {
+		    goto done;
+		} else {
+		    ctxt->instate = XML_PARSER_START_TAG;
+		    ctxt->progressive = 1;
+		    xmlParseGetLasts(ctxt, &lastlt, &lastgt);
+#ifdef DEBUG_PUSH
+		    xmlGenericError(xmlGenericErrorContext,
+			    "PP: entering START_TAG\n");
+#endif
+		}
+		break;
+            case XML_PARSER_EPILOG:
+		SKIP_BLANKS;
+		if (ctxt->input->buf == NULL)
+		    avail = ctxt->input->length - (ctxt->input->cur - ctxt->input->base);
+		else
+		    avail = ctxt->input->buf->buffer->use - (ctxt->input->cur - ctxt->input->base);
+		if (avail < 2)
+		    goto done;
+		cur = ctxt->input->cur[0];
+		next = ctxt->input->cur[1];
+	        if ((cur == '<') && (next == '?')) {
+		    if ((!terminate) &&
+		        (xmlParseLookupSequence(ctxt, '?', '>', 0) < 0))
+			goto done;
+#ifdef DEBUG_PUSH
+		    xmlGenericError(xmlGenericErrorContext,
+			    "PP: Parsing PI\n");
+#endif
+		    xmlParsePI(ctxt);
+		    ctxt->instate = XML_PARSER_EPILOG;
+		} else if ((cur == '<') && (next == '!') &&
+		    (ctxt->input->cur[2] == '-') && (ctxt->input->cur[3] == '-')) {
+		    if ((!terminate) &&
+		        (xmlParseLookupSequence(ctxt, '-', '-', '>') < 0))
+			goto done;
+#ifdef DEBUG_PUSH
+		    xmlGenericError(xmlGenericErrorContext,
+			    "PP: Parsing Comment\n");
+#endif
+		    xmlParseComment(ctxt);
+		    ctxt->instate = XML_PARSER_EPILOG;
+		} else if ((cur == '<') && (next == '!') &&
+		           (avail < 4)) {
+		    goto done;
+		} else {
+		    xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL);
+		    ctxt->instate = XML_PARSER_EOF;
+#ifdef DEBUG_PUSH
+		    xmlGenericError(xmlGenericErrorContext,
+			    "PP: entering EOF\n");
+#endif
+		    if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
+			ctxt->sax->endDocument(ctxt->userData);
+		    goto done;
+		}
+		break;
+            case XML_PARSER_DTD: {
+	        /*
+		 * Sorry but progressive parsing of the internal subset
+		 * is not expected to be supported. We first check that
+		 * the full content of the internal subset is available and
+		 * the parsing is launched only at that point.
+		 * Internal subset ends up with "']' S? '>'" in an unescaped
+		 * section and not in a ']]>' sequence which are conditional
+		 * sections (whoever argued to keep that crap in XML deserve
+		 * a place in hell !).
+		 */
+		int base, i;
+		xmlChar *buf;
+	        xmlChar quote = 0;
+
+		base = ctxt->input->cur - ctxt->input->base;
+		if (base < 0) return(0);
+		if (ctxt->checkIndex > base)
+		    base = ctxt->checkIndex;
+		buf = ctxt->input->buf->buffer->content;
+		for (;(unsigned int) base < ctxt->input->buf->buffer->use;
+		     base++) {
+		    if (quote != 0) {
+		        if (buf[base] == quote)
+			    quote = 0;
+			continue;    
+		    }
+		    if ((quote == 0) && (buf[base] == '<')) {
+		        int found  = 0;
+			/* special handling of comments */
+		        if (((unsigned int) base + 4 <
+			     ctxt->input->buf->buffer->use) &&
+			    (buf[base + 1] == '!') &&
+			    (buf[base + 2] == '-') &&
+			    (buf[base + 3] == '-')) {
+			    for (;(unsigned int) base + 3 <
+			          ctxt->input->buf->buffer->use; base++) {
+				if ((buf[base] == '-') &&
+				    (buf[base + 1] == '-') &&
+				    (buf[base + 2] == '>')) {
+				    found = 1;
+				    base += 2;
+				    break;
+				}
+		            }
+			    if (!found)
+			        break;
+		            continue;
+			}
+		    }
+		    if (buf[base] == '"') {
+		        quote = '"';
+			continue;
+		    }
+		    if (buf[base] == '\'') {
+		        quote = '\'';
+			continue;
+		    }
+		    if (buf[base] == ']') {
+		        if ((unsigned int) base +1 >=
+		            ctxt->input->buf->buffer->use)
+			    break;
+			if (buf[base + 1] == ']') {
+			    /* conditional crap, skip both ']' ! */
+			    base++;
+			    continue;
+			}
+		        for (i = 0;
+		     (unsigned int) base + i < ctxt->input->buf->buffer->use;
+		             i++) {
+			    if (buf[base + i] == '>')
+			        goto found_end_int_subset;
+			}
+		        break;
+		    }
+		}
+		/*
+		 * We didn't found the end of the Internal subset
+		 */
+		if (quote == 0) 
+		    ctxt->checkIndex = base;
+#ifdef DEBUG_PUSH
+		if (next == 0)
+		    xmlGenericError(xmlGenericErrorContext,
+			    "PP: lookup of int subset end filed\n");
+#endif
+	        goto done;
+
+found_end_int_subset:
+		xmlParseInternalSubset(ctxt);
+		ctxt->inSubset = 2;
+		if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
+		    (ctxt->sax->externalSubset != NULL))
+		    ctxt->sax->externalSubset(ctxt->userData, ctxt->intSubName,
+			    ctxt->extSubSystem, ctxt->extSubURI);
+		ctxt->inSubset = 0;
+		ctxt->instate = XML_PARSER_PROLOG;
+		ctxt->checkIndex = 0;
+#ifdef DEBUG_PUSH
+		xmlGenericError(xmlGenericErrorContext,
+			"PP: entering PROLOG\n");
+#endif
+                break;
+	    }
+            case XML_PARSER_COMMENT:
+		xmlGenericError(xmlGenericErrorContext,
+			"PP: internal error, state == COMMENT\n");
+		ctxt->instate = XML_PARSER_CONTENT;
+#ifdef DEBUG_PUSH
+		xmlGenericError(xmlGenericErrorContext,
+			"PP: entering CONTENT\n");
+#endif
+		break;
+            case XML_PARSER_IGNORE:
+		xmlGenericError(xmlGenericErrorContext,
+			"PP: internal error, state == IGNORE");
+	        ctxt->instate = XML_PARSER_DTD;
+#ifdef DEBUG_PUSH
+		xmlGenericError(xmlGenericErrorContext,
+			"PP: entering DTD\n");
+#endif
+	        break;
+            case XML_PARSER_PI:
+		xmlGenericError(xmlGenericErrorContext,
+			"PP: internal error, state == PI\n");
+		ctxt->instate = XML_PARSER_CONTENT;
+#ifdef DEBUG_PUSH
+		xmlGenericError(xmlGenericErrorContext,
+			"PP: entering CONTENT\n");
+#endif
+		break;
+            case XML_PARSER_ENTITY_DECL:
+		xmlGenericError(xmlGenericErrorContext,
+			"PP: internal error, state == ENTITY_DECL\n");
+		ctxt->instate = XML_PARSER_DTD;
+#ifdef DEBUG_PUSH
+		xmlGenericError(xmlGenericErrorContext,
+			"PP: entering DTD\n");
+#endif
+		break;
+            case XML_PARSER_ENTITY_VALUE:
+		xmlGenericError(xmlGenericErrorContext,
+			"PP: internal error, state == ENTITY_VALUE\n");
+		ctxt->instate = XML_PARSER_CONTENT;
+#ifdef DEBUG_PUSH
+		xmlGenericError(xmlGenericErrorContext,
+			"PP: entering DTD\n");
+#endif
+		break;
+            case XML_PARSER_ATTRIBUTE_VALUE:
+		xmlGenericError(xmlGenericErrorContext,
+			"PP: internal error, state == ATTRIBUTE_VALUE\n");
+		ctxt->instate = XML_PARSER_START_TAG;
+#ifdef DEBUG_PUSH
+		xmlGenericError(xmlGenericErrorContext,
+			"PP: entering START_TAG\n");
+#endif
+		break;
+            case XML_PARSER_SYSTEM_LITERAL:
+		xmlGenericError(xmlGenericErrorContext,
+			"PP: internal error, state == SYSTEM_LITERAL\n");
+		ctxt->instate = XML_PARSER_START_TAG;
+#ifdef DEBUG_PUSH
+		xmlGenericError(xmlGenericErrorContext,
+			"PP: entering START_TAG\n");
+#endif
+		break;
+            case XML_PARSER_PUBLIC_LITERAL:
+		xmlGenericError(xmlGenericErrorContext,
+			"PP: internal error, state == PUBLIC_LITERAL\n");
+		ctxt->instate = XML_PARSER_START_TAG;
+#ifdef DEBUG_PUSH
+		xmlGenericError(xmlGenericErrorContext,
+			"PP: entering START_TAG\n");
+#endif
+		break;
+	}
+    }
+done:    
+#ifdef DEBUG_PUSH
+    xmlGenericError(xmlGenericErrorContext, "PP: done %d\n", ret);
+#endif
+    return(ret);
+}
+
+/**
+ * xmlParseChunk:
+ * @ctxt:  an XML parser context
+ * @chunk:  an char array
+ * @size:  the size in byte of the chunk
+ * @terminate:  last chunk indicator
+ *
+ * Parse a Chunk of memory
+ *
+ * Returns zero if no error, the xmlParserErrors otherwise.
+ */
+int
+xmlParseChunk(xmlParserCtxtPtr ctxt, const char *chunk, int size,
+              int terminate) {
+    if ((ctxt->errNo != XML_ERR_OK) && (ctxt->disableSAX == 1))
+        return(ctxt->errNo);
+    if (ctxt->instate == XML_PARSER_START)
+        xmlDetectSAX2(ctxt);
+    if ((size > 0) && (chunk != NULL) && (ctxt->input != NULL) &&
+        (ctxt->input->buf != NULL) && (ctxt->instate != XML_PARSER_EOF))  {
+	int base = ctxt->input->base - ctxt->input->buf->buffer->content;
+	int cur = ctxt->input->cur - ctxt->input->base;
+	
+	xmlParserInputBufferPush(ctxt->input->buf, size, chunk);	      
+	ctxt->input->base = ctxt->input->buf->buffer->content + base;
+	ctxt->input->cur = ctxt->input->base + cur;
+	ctxt->input->end =
+	    &ctxt->input->buf->buffer->content[ctxt->input->buf->buffer->use];
+#ifdef DEBUG_PUSH
+	xmlGenericError(xmlGenericErrorContext, "PP: pushed %d\n", size);
+#endif
+
+    } else if (ctxt->instate != XML_PARSER_EOF) {
+	if ((ctxt->input != NULL) && ctxt->input->buf != NULL) {
+	    xmlParserInputBufferPtr in = ctxt->input->buf;
+	    if ((in->encoder != NULL) && (in->buffer != NULL) &&
+		    (in->raw != NULL)) {
+		int nbchars;
+		    
+		nbchars = xmlCharEncInFunc(in->encoder, in->buffer, in->raw);
+		if (nbchars < 0) {
+		    /* TODO 2.6.0 */
+		    xmlGenericError(xmlGenericErrorContext,
+				    "xmlParseChunk: encoder error\n");
+		    return(XML_ERR_INVALID_ENCODING);
+		}
+	    }
+	}
+    }
+    xmlParseTryOrFinish(ctxt, terminate);
+    if ((ctxt->errNo != XML_ERR_OK) && (ctxt->disableSAX == 1))
+        return(ctxt->errNo);
+    if (terminate) {
+	/*
+	 * Check for termination
+	 */
+	    int avail = 0;
+	    if (ctxt->input->buf == NULL)
+                avail = ctxt->input->length -
+		        (ctxt->input->cur - ctxt->input->base);
+            else
+                avail = ctxt->input->buf->buffer->use -
+		        (ctxt->input->cur - ctxt->input->base);
+			    
+	if ((ctxt->instate != XML_PARSER_EOF) &&
+	    (ctxt->instate != XML_PARSER_EPILOG)) {
+	    xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL);
+	} 
+	if ((ctxt->instate == XML_PARSER_EPILOG) && (avail > 0)) {
+	    xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL);
+	}
+	if (ctxt->instate != XML_PARSER_EOF) {
+	    if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
+		ctxt->sax->endDocument(ctxt->userData);
+	}
+	ctxt->instate = XML_PARSER_EOF;
+    }
+    return((xmlParserErrors) ctxt->errNo);	      
+}
+
+/************************************************************************
+ *									*
+ * 		I/O front end functions to the parser			*
+ *									*
+ ************************************************************************/
+
+/**
+ * xmlStopParser:
+ * @ctxt:  an XML parser context
+ *
+ * Blocks further parser processing
+ */
+void           
+xmlStopParser(xmlParserCtxtPtr ctxt) {
+    if (ctxt == NULL)
+        return;
+    ctxt->instate = XML_PARSER_EOF;
+    ctxt->disableSAX = 1;
+    if (ctxt->input != NULL)
+	ctxt->input->cur = BAD_CAST"";
+}
+
+/**
+ * xmlCreatePushParserCtxt:
+ * @sax:  a SAX handler
+ * @user_data:  The user data returned on SAX callbacks
+ * @chunk:  a pointer to an array of chars
+ * @size:  number of chars in the array
+ * @filename:  an optional file name or URI
+ *
+ * Create a parser context for using the XML parser in push mode.
+ * If @buffer and @size are non-NULL, the data is used to detect
+ * the encoding.  The remaining characters will be parsed so they
+ * don't need to be fed in again through xmlParseChunk.
+ * To allow content encoding detection, @size should be >= 4
+ * The value of @filename is used for fetching external entities
+ * and error/warning reports.
+ *
+ * Returns the new parser context or NULL
+ */
+
+xmlParserCtxtPtr
+xmlCreatePushParserCtxt(xmlSAXHandlerPtr sax, void *user_data, 
+                        const char *chunk, int size, const char *filename) {
+    xmlParserCtxtPtr ctxt;
+    xmlParserInputPtr inputStream;
+    xmlParserInputBufferPtr buf;
+    xmlCharEncoding enc = XML_CHAR_ENCODING_NONE;
+
+    /*
+     * plug some encoding conversion routines
+     */
+    if ((chunk != NULL) && (size >= 4))
+	enc = xmlDetectCharEncoding((const xmlChar *) chunk, size);
+
+    buf = xmlAllocParserInputBuffer(enc);
+    if (buf == NULL) return(NULL);
+
+    ctxt = xmlNewParserCtxt();
+    if (ctxt == NULL) {
+        xmlErrMemory(NULL, "creating parser: out of memory\n");
+	xmlFreeParserInputBuffer(buf);
+	return(NULL);
+    }
+    ctxt->pushTab = (void **) xmlMalloc(ctxt->nameMax * 3 * sizeof(xmlChar *));
+    if (ctxt->pushTab == NULL) {
+        xmlErrMemory(ctxt, NULL);
+	xmlFreeParserInputBuffer(buf);
+	xmlFreeParserCtxt(ctxt);
+	return(NULL);
+    }
+    if (sax != NULL) {
+#ifdef LIBXML_SAX1_ENABLED
+	if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
+#endif /* LIBXML_SAX1_ENABLED */
+	    xmlFree(ctxt->sax);
+	ctxt->sax = (xmlSAXHandlerPtr) xmlMalloc(sizeof(xmlSAXHandler));
+	if (ctxt->sax == NULL) {
+	    xmlErrMemory(ctxt, NULL);
+	    xmlFreeParserInputBuffer(buf);
+	    xmlFreeParserCtxt(ctxt);
+	    return(NULL);
+	}
+	memcpy(ctxt->sax, sax, sizeof(xmlSAXHandler));
+	if (user_data != NULL)
+	    ctxt->userData = user_data;
+    }	
+    if (filename == NULL) {
+	ctxt->directory = NULL;
+    } else {
+        ctxt->directory = xmlParserGetDirectory(filename);
+    }
+
+    inputStream = xmlNewInputStream(ctxt);
+    if (inputStream == NULL) {
+	xmlFreeParserCtxt(ctxt);
+	xmlFreeParserInputBuffer(buf);
+	return(NULL);
+    }
+
+    if (filename == NULL)
+	inputStream->filename = NULL;
+    else
+	inputStream->filename = (char *)
+	    xmlCanonicPath((const xmlChar *) filename);
+    inputStream->buf = buf;
+    inputStream->base = inputStream->buf->buffer->content;
+    inputStream->cur = inputStream->buf->buffer->content;
+    inputStream->end = 
+	&inputStream->buf->buffer->content[inputStream->buf->buffer->use];
+
+    inputPush(ctxt, inputStream);
+
+    if ((size > 0) && (chunk != NULL) && (ctxt->input != NULL) &&
+        (ctxt->input->buf != NULL))  {	      
+	int base = ctxt->input->base - ctxt->input->buf->buffer->content;
+	int cur = ctxt->input->cur - ctxt->input->base;
+
+	xmlParserInputBufferPush(ctxt->input->buf, size, chunk);	      
+
+	ctxt->input->base = ctxt->input->buf->buffer->content + base;
+	ctxt->input->cur = ctxt->input->base + cur;
+	ctxt->input->end =
+	    &ctxt->input->buf->buffer->content[ctxt->input->buf->buffer->use];
+#ifdef DEBUG_PUSH
+	xmlGenericError(xmlGenericErrorContext, "PP: pushed %d\n", size);
+#endif
+    }
+
+    if (enc != XML_CHAR_ENCODING_NONE) {
+        xmlSwitchEncoding(ctxt, enc);
+    }
+
+    return(ctxt);
+}
+#endif /* LIBXML_PUSH_ENABLED */
+
+/**
+ * xmlCreateIOParserCtxt:
+ * @sax:  a SAX handler
+ * @user_data:  The user data returned on SAX callbacks
+ * @ioread:  an I/O read function
+ * @ioclose:  an I/O close function
+ * @ioctx:  an I/O handler
+ * @enc:  the charset encoding if known
+ *
+ * Create a parser context for using the XML parser with an existing
+ * I/O stream
+ *
+ * Returns the new parser context or NULL
+ */
+xmlParserCtxtPtr
+xmlCreateIOParserCtxt(xmlSAXHandlerPtr sax, void *user_data,
+	xmlInputReadCallback   ioread, xmlInputCloseCallback  ioclose,
+	void *ioctx, xmlCharEncoding enc) {
+    xmlParserCtxtPtr ctxt;
+    xmlParserInputPtr inputStream;
+    xmlParserInputBufferPtr buf;
+
+    buf = xmlParserInputBufferCreateIO(ioread, ioclose, ioctx, enc);
+    if (buf == NULL) return(NULL);
+
+    ctxt = xmlNewParserCtxt();
+    if (ctxt == NULL) {
+	xmlFree(buf);
+	return(NULL);
+    }
+    if (sax != NULL) {
+#ifdef LIBXML_SAX1_ENABLED
+	if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
+#endif /* LIBXML_SAX1_ENABLED */
+	    xmlFree(ctxt->sax);
+	ctxt->sax = (xmlSAXHandlerPtr) xmlMalloc(sizeof(xmlSAXHandler));
+	if (ctxt->sax == NULL) {
+	    xmlErrMemory(ctxt, NULL);
+	    xmlFree(ctxt);
+	    return(NULL);
+	}
+	memcpy(ctxt->sax, sax, sizeof(xmlSAXHandler));
+	if (user_data != NULL)
+	    ctxt->userData = user_data;
+    }	
+
+    inputStream = xmlNewIOInputStream(ctxt, buf, enc);
+    if (inputStream == NULL) {
+	xmlFreeParserCtxt(ctxt);
+	return(NULL);
+    }
+    inputPush(ctxt, inputStream);
+
+    return(ctxt);
+}
+
+#ifdef LIBXML_VALID_ENABLED
+/************************************************************************
+ *									*
+ * 		Front ends when parsing a DTD				*
+ *									*
+ ************************************************************************/
+
+/**
+ * xmlIOParseDTD:
+ * @sax:  the SAX handler block or NULL
+ * @input:  an Input Buffer
+ * @enc:  the charset encoding if known
+ *
+ * Load and parse a DTD
+ * 
+ * Returns the resulting xmlDtdPtr or NULL in case of error.
+ * @input will be freed at parsing end.
+ */
+
+xmlDtdPtr
+xmlIOParseDTD(xmlSAXHandlerPtr sax, xmlParserInputBufferPtr input,
+	      xmlCharEncoding enc) {
+    xmlDtdPtr ret = NULL;
+    xmlParserCtxtPtr ctxt;
+    xmlParserInputPtr pinput = NULL;
+    xmlChar start[4];
+
+    if (input == NULL)
+	return(NULL);
+
+    ctxt = xmlNewParserCtxt();
+    if (ctxt == NULL) {
+	return(NULL);
+    }
+
+    /*
+     * Set-up the SAX context
+     */
+    if (sax != NULL) { 
+	if (ctxt->sax != NULL)
+	    xmlFree(ctxt->sax);
+        ctxt->sax = sax;
+        ctxt->userData = ctxt;
+    }
+    xmlDetectSAX2(ctxt);
+
+    /*
+     * generate a parser input from the I/O handler
+     */
+
+    pinput = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
+    if (pinput == NULL) {
+        if (sax != NULL) ctxt->sax = NULL;
+	xmlFreeParserCtxt(ctxt);
+	return(NULL);
+    }
+
+    /*
+     * plug some encoding conversion routines here.
+     */
+    xmlPushInput(ctxt, pinput);
+    if (enc != XML_CHAR_ENCODING_NONE) {
+        xmlSwitchEncoding(ctxt, enc);
+    }
+
+    pinput->filename = NULL;
+    pinput->line = 1;
+    pinput->col = 1;
+    pinput->base = ctxt->input->cur;
+    pinput->cur = ctxt->input->cur;
+    pinput->free = NULL;
+
+    /*
+     * let's parse that entity knowing it's an external subset.
+     */
+    ctxt->inSubset = 2;
+    ctxt->myDoc = xmlNewDoc(BAD_CAST "1.0");
+    ctxt->myDoc->extSubset = xmlNewDtd(ctxt->myDoc, BAD_CAST "none",
+	                               BAD_CAST "none", BAD_CAST "none");
+
+    if ((enc == XML_CHAR_ENCODING_NONE) &&
+        ((ctxt->input->end - ctxt->input->cur) >= 4)) {
+	/* 
+	 * Get the 4 first bytes and decode the charset
+	 * if enc != XML_CHAR_ENCODING_NONE
+	 * plug some encoding conversion routines.
+	 */
+	start[0] = RAW;
+	start[1] = NXT(1);
+	start[2] = NXT(2);
+	start[3] = NXT(3);
+	enc = xmlDetectCharEncoding(start, 4);
+	if (enc != XML_CHAR_ENCODING_NONE) {
+	    xmlSwitchEncoding(ctxt, enc);
+	}
+    }
+
+    xmlParseExternalSubset(ctxt, BAD_CAST "none", BAD_CAST "none");
+
+    if (ctxt->myDoc != NULL) {
+	if (ctxt->wellFormed) {
+	    ret = ctxt->myDoc->extSubset;
+	    ctxt->myDoc->extSubset = NULL;
+	    if (ret != NULL) {
+		xmlNodePtr tmp;
+
+		ret->doc = NULL;
+		tmp = ret->children;
+		while (tmp != NULL) {
+		    tmp->doc = NULL;
+		    tmp = tmp->next;
+		}
+	    }
+	} else {
+	    ret = NULL;
+	}
+        xmlFreeDoc(ctxt->myDoc);
+        ctxt->myDoc = NULL;
+    }
+    if (sax != NULL) ctxt->sax = NULL;
+    xmlFreeParserCtxt(ctxt);
+    
+    return(ret);
+}
+
+/**
+ * xmlSAXParseDTD:
+ * @sax:  the SAX handler block
+ * @ExternalID:  a NAME* containing the External ID of the DTD
+ * @SystemID:  a NAME* containing the URL to the DTD
+ *
+ * Load and parse an external subset.
+ * 
+ * Returns the resulting xmlDtdPtr or NULL in case of error.
+ */
+
+xmlDtdPtr
+xmlSAXParseDTD(xmlSAXHandlerPtr sax, const xmlChar *ExternalID,
+                          const xmlChar *SystemID) {
+    xmlDtdPtr ret = NULL;
+    xmlParserCtxtPtr ctxt;
+    xmlParserInputPtr input = NULL;
+    xmlCharEncoding enc;
+
+    if ((ExternalID == NULL) && (SystemID == NULL)) return(NULL);
+
+    ctxt = xmlNewParserCtxt();
+    if (ctxt == NULL) {
+	return(NULL);
+    }
+
+    /*
+     * Set-up the SAX context
+     */
+    if (sax != NULL) { 
+	if (ctxt->sax != NULL)
+	    xmlFree(ctxt->sax);
+        ctxt->sax = sax;
+        ctxt->userData = ctxt;
+    }
+
+    /*
+     * Ask the Entity resolver to load the damn thing
+     */
+
+    if ((ctxt->sax != NULL) && (ctxt->sax->resolveEntity != NULL))
+	input = ctxt->sax->resolveEntity(ctxt, ExternalID, SystemID);
+    if (input == NULL) {
+        if (sax != NULL) ctxt->sax = NULL;
+	xmlFreeParserCtxt(ctxt);
+	return(NULL);
+    }
+
+    /*
+     * plug some encoding conversion routines here.
+     */
+    xmlPushInput(ctxt, input);
+    if ((ctxt->input->end - ctxt->input->cur) >= 4) {
+	enc = xmlDetectCharEncoding(ctxt->input->cur, 4);
+	xmlSwitchEncoding(ctxt, enc);
+    }
+
+    if (input->filename == NULL)
+	input->filename = (char *) xmlCanonicPath(SystemID);
+    input->line = 1;
+    input->col = 1;
+    input->base = ctxt->input->cur;
+    input->cur = ctxt->input->cur;
+    input->free = NULL;
+
+    /*
+     * let's parse that entity knowing it's an external subset.
+     */
+    ctxt->inSubset = 2;
+    ctxt->myDoc = xmlNewDoc(BAD_CAST "1.0");
+    ctxt->myDoc->extSubset = xmlNewDtd(ctxt->myDoc, BAD_CAST "none",
+	                               ExternalID, SystemID);
+    xmlParseExternalSubset(ctxt, ExternalID, SystemID);
+
+    if (ctxt->myDoc != NULL) {
+	if (ctxt->wellFormed) {
+	    ret = ctxt->myDoc->extSubset;
+	    ctxt->myDoc->extSubset = NULL;
+	    if (ret != NULL) {
+		xmlNodePtr tmp;
+
+		ret->doc = NULL;
+		tmp = ret->children;
+		while (tmp != NULL) {
+		    tmp->doc = NULL;
+		    tmp = tmp->next;
+		}
+	    }
+	} else {
+	    ret = NULL;
+	}
+        xmlFreeDoc(ctxt->myDoc);
+        ctxt->myDoc = NULL;
+    }
+    if (sax != NULL) ctxt->sax = NULL;
+    xmlFreeParserCtxt(ctxt);
+    
+    return(ret);
+}
+
+
+/**
+ * xmlParseDTD:
+ * @ExternalID:  a NAME* containing the External ID of the DTD
+ * @SystemID:  a NAME* containing the URL to the DTD
+ *
+ * Load and parse an external subset.
+ * 
+ * Returns the resulting xmlDtdPtr or NULL in case of error.
+ */
+
+xmlDtdPtr
+xmlParseDTD(const xmlChar *ExternalID, const xmlChar *SystemID) {
+    return(xmlSAXParseDTD(NULL, ExternalID, SystemID));
+}
+#endif /* LIBXML_VALID_ENABLED */
+
+/************************************************************************
+ *									*
+ * 		Front ends when parsing an Entity			*
+ *									*
+ ************************************************************************/
+
+/**
+ * xmlParseCtxtExternalEntity:
+ * @ctx:  the existing parsing context
+ * @URL:  the URL for the entity to load
+ * @ID:  the System ID for the entity to load
+ * @lst:  the return value for the set of parsed nodes
+ *
+ * Parse an external general entity within an existing parsing context
+ * An external general parsed entity is well-formed if it matches the
+ * production labeled extParsedEnt.
+ *
+ * [78] extParsedEnt ::= TextDecl? content
+ *
+ * Returns 0 if the entity is well formed, -1 in case of args problem and
+ *    the parser error code otherwise
+ */
+
+int
+xmlParseCtxtExternalEntity(xmlParserCtxtPtr ctx, const xmlChar *URL,
+	               const xmlChar *ID, xmlNodePtr *lst) {
+    xmlParserCtxtPtr ctxt;
+    xmlDocPtr newDoc;
+    xmlSAXHandlerPtr oldsax = NULL;
+    int ret = 0;
+    xmlChar start[4];
+    xmlCharEncoding enc;
+
+    if (ctx->depth > 40) {
+	return(XML_ERR_ENTITY_LOOP);
+    }
+
+    if (lst != NULL)
+        *lst = NULL;
+    if ((URL == NULL) && (ID == NULL))
+	return(-1);
+    if (ctx->myDoc == NULL) /* @@ relax but check for dereferences */
+	return(-1);
+
+
+    ctxt = xmlCreateEntityParserCtxt(URL, ID, NULL);
+    if (ctxt == NULL) return(-1);
+    ctxt->userData = ctxt;
+    ctxt->_private = ctx->_private;
+    oldsax = ctxt->sax;
+    ctxt->sax = ctx->sax;
+    xmlDetectSAX2(ctxt);
+    newDoc = xmlNewDoc(BAD_CAST "1.0");
+    if (newDoc == NULL) {
+	xmlFreeParserCtxt(ctxt);
+	return(-1);
+    }
+    if (ctx->myDoc != NULL) {
+	newDoc->intSubset = ctx->myDoc->intSubset;
+	newDoc->extSubset = ctx->myDoc->extSubset;
+    }
+    if (ctx->myDoc->URL != NULL) {
+	newDoc->URL = xmlStrdup(ctx->myDoc->URL);
+    }
+    newDoc->children = xmlNewDocNode(newDoc, NULL, BAD_CAST "pseudoroot", NULL);
+    if (newDoc->children == NULL) {
+	ctxt->sax = oldsax;
+	xmlFreeParserCtxt(ctxt);
+	newDoc->intSubset = NULL;
+	newDoc->extSubset = NULL;
+        xmlFreeDoc(newDoc);
+	return(-1);
+    }
+    nodePush(ctxt, newDoc->children);
+    if (ctx->myDoc == NULL) {
+	ctxt->myDoc = newDoc;
+    } else {
+	ctxt->myDoc = ctx->myDoc;
+	newDoc->children->doc = ctx->myDoc;
+    }
+
+    /* 
+     * Get the 4 first bytes and decode the charset
+     * if enc != XML_CHAR_ENCODING_NONE
+     * plug some encoding conversion routines.
+     */
+    GROW
+    if ((ctxt->input->end - ctxt->input->cur) >= 4) {
+	start[0] = RAW;
+	start[1] = NXT(1);
+	start[2] = NXT(2);
+	start[3] = NXT(3);
+	enc = xmlDetectCharEncoding(start, 4);
+	if (enc != XML_CHAR_ENCODING_NONE) {
+	    xmlSwitchEncoding(ctxt, enc);
+	}
+    }
+
+    /*
+     * Parse a possible text declaration first
+     */
+    if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) {
+	xmlParseTextDecl(ctxt);
+    }
+
+    /*
+     * Doing validity checking on chunk doesn't make sense
+     */
+    ctxt->instate = XML_PARSER_CONTENT;
+    ctxt->validate = ctx->validate;
+    ctxt->valid = ctx->valid;
+    ctxt->loadsubset = ctx->loadsubset;
+    ctxt->depth = ctx->depth + 1;
+    ctxt->replaceEntities = ctx->replaceEntities;
+    if (ctxt->validate) {
+	ctxt->vctxt.error = ctx->vctxt.error;
+	ctxt->vctxt.warning = ctx->vctxt.warning;
+    } else {
+	ctxt->vctxt.error = NULL;
+	ctxt->vctxt.warning = NULL;
+    }
+    ctxt->vctxt.nodeTab = NULL;
+    ctxt->vctxt.nodeNr = 0;
+    ctxt->vctxt.nodeMax = 0;
+    ctxt->vctxt.node = NULL;
+    if (ctxt->dict != NULL) xmlDictFree(ctxt->dict);
+    ctxt->dict = ctx->dict;
+    ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3);
+    ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5);
+    ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36);
+    ctxt->dictNames = ctx->dictNames;
+    ctxt->attsDefault = ctx->attsDefault;
+    ctxt->attsSpecial = ctx->attsSpecial;
+
+    xmlParseContent(ctxt);
+   
+    ctx->validate = ctxt->validate;
+    ctx->valid = ctxt->valid;
+    if ((RAW == '<') && (NXT(1) == '/')) {
+	xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
+    } else if (RAW != 0) {
+	xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
+    }
+    if (ctxt->node != newDoc->children) {
+	xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
+    }
+
+    if (!ctxt->wellFormed) {
+        if (ctxt->errNo == 0)
+	    ret = 1;
+	else
+	    ret = ctxt->errNo;
+    } else {
+	if (lst != NULL) {
+	    xmlNodePtr cur;
+
+	    /*
+	     * Return the newly created nodeset after unlinking it from
+	     * they pseudo parent.
+	     */
+	    cur = newDoc->children->children;
+	    *lst = cur;
+	    while (cur != NULL) {
+		cur->parent = NULL;
+		cur = cur->next;
+	    }
+            newDoc->children->children = NULL;
+	}
+	ret = 0;
+    }
+    ctxt->sax = oldsax;
+    ctxt->dict = NULL;
+    ctxt->attsDefault = NULL;
+    ctxt->attsSpecial = NULL;
+    xmlFreeParserCtxt(ctxt);
+    newDoc->intSubset = NULL;
+    newDoc->extSubset = NULL;
+    xmlFreeDoc(newDoc);
+    
+    return(ret);
+}
+
+/**
+ * xmlParseExternalEntityPrivate:
+ * @doc:  the document the chunk pertains to
+ * @oldctxt:  the previous parser context if available
+ * @sax:  the SAX handler bloc (possibly NULL)
+ * @user_data:  The user data returned on SAX callbacks (possibly NULL)
+ * @depth:  Used for loop detection, use 0
+ * @URL:  the URL for the entity to load
+ * @ID:  the System ID for the entity to load
+ * @list:  the return value for the set of parsed nodes
+ *
+ * Private version of xmlParseExternalEntity()
+ *
+ * Returns 0 if the entity is well formed, -1 in case of args problem and
+ *    the parser error code otherwise
+ */
+
+static xmlParserErrors
+xmlParseExternalEntityPrivate(xmlDocPtr doc, xmlParserCtxtPtr oldctxt,
+	              xmlSAXHandlerPtr sax,
+		      void *user_data, int depth, const xmlChar *URL,
+		      const xmlChar *ID, xmlNodePtr *list) {
+    xmlParserCtxtPtr ctxt;
+    xmlDocPtr newDoc;
+    xmlSAXHandlerPtr oldsax = NULL;
+    xmlParserErrors ret = XML_ERR_OK;
+    xmlChar start[4];
+    xmlCharEncoding enc;
+
+    if (depth > 40) {
+	return(XML_ERR_ENTITY_LOOP);
+    }
+
+
+
+    if (list != NULL)
+        *list = NULL;
+    if ((URL == NULL) && (ID == NULL))
+	return(XML_ERR_INTERNAL_ERROR);
+    if (doc == NULL) /* @@ relax but check for dereferences */
+	return(XML_ERR_INTERNAL_ERROR);
+
+
+    ctxt = xmlCreateEntityParserCtxt(URL, ID, NULL);
+    if (ctxt == NULL) return(XML_WAR_UNDECLARED_ENTITY);
+    ctxt->userData = ctxt;
+    if (oldctxt != NULL) {
+	ctxt->_private = oldctxt->_private;
+	ctxt->loadsubset = oldctxt->loadsubset;
+	ctxt->validate = oldctxt->validate;
+	ctxt->external = oldctxt->external;
+	ctxt->record_info = oldctxt->record_info;
+	ctxt->node_seq.maximum = oldctxt->node_seq.maximum;
+	ctxt->node_seq.length = oldctxt->node_seq.length;
+	ctxt->node_seq.buffer = oldctxt->node_seq.buffer;
+    } else {
+	/*
+	 * Doing validity checking on chunk without context
+	 * doesn't make sense
+	 */
+	ctxt->_private = NULL;
+	ctxt->validate = 0;
+	ctxt->external = 2;
+	ctxt->loadsubset = 0;
+    }
+    if (sax != NULL) {
+	oldsax = ctxt->sax;
+        ctxt->sax = sax;
+	if (user_data != NULL)
+	    ctxt->userData = user_data;
+    }
+    xmlDetectSAX2(ctxt);
+    newDoc = xmlNewDoc(BAD_CAST "1.0");
+    if (newDoc == NULL) {
+	ctxt->node_seq.maximum = 0;
+	ctxt->node_seq.length = 0;
+	ctxt->node_seq.buffer = NULL;
+	xmlFreeParserCtxt(ctxt);
+	return(XML_ERR_INTERNAL_ERROR);
+    }
+    if (doc != NULL) {
+	newDoc->intSubset = doc->intSubset;
+	newDoc->extSubset = doc->extSubset;
+    }
+    if (doc->URL != NULL) {
+	newDoc->URL = xmlStrdup(doc->URL);
+    }
+    newDoc->children = xmlNewDocNode(newDoc, NULL, BAD_CAST "pseudoroot", NULL);
+    if (newDoc->children == NULL) {
+	if (sax != NULL)
+	    ctxt->sax = oldsax;
+	ctxt->node_seq.maximum = 0;
+	ctxt->node_seq.length = 0;
+	ctxt->node_seq.buffer = NULL;
+	xmlFreeParserCtxt(ctxt);
+	newDoc->intSubset = NULL;
+	newDoc->extSubset = NULL;
+        xmlFreeDoc(newDoc);
+	return(XML_ERR_INTERNAL_ERROR);
+    }
+    nodePush(ctxt, newDoc->children);
+    if (doc == NULL) {
+	ctxt->myDoc = newDoc;
+    } else {
+	ctxt->myDoc = doc;
+	newDoc->children->doc = doc;
+    }
+
+    /* 
+     * Get the 4 first bytes and decode the charset
+     * if enc != XML_CHAR_ENCODING_NONE
+     * plug some encoding conversion routines.
+     */
+    GROW;
+    if ((ctxt->input->end - ctxt->input->cur) >= 4) {
+	start[0] = RAW;
+	start[1] = NXT(1);
+	start[2] = NXT(2);
+	start[3] = NXT(3);
+	enc = xmlDetectCharEncoding(start, 4);
+	if (enc != XML_CHAR_ENCODING_NONE) {
+	    xmlSwitchEncoding(ctxt, enc);
+	}
+    }
+
+    /*
+     * Parse a possible text declaration first
+     */
+    if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) {
+	xmlParseTextDecl(ctxt);
+    }
+
+    ctxt->instate = XML_PARSER_CONTENT;
+    ctxt->depth = depth;
+
+    xmlParseContent(ctxt);
+   
+    if ((RAW == '<') && (NXT(1) == '/')) {
+	xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
+    } else if (RAW != 0) {
+	xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
+    }
+    if (ctxt->node != newDoc->children) {
+	xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
+    }
+
+    if (!ctxt->wellFormed) {
+        if (ctxt->errNo == 0)
+	    ret = XML_ERR_INTERNAL_ERROR;
+	else
+	    ret = (xmlParserErrors)ctxt->errNo;
+    } else {
+	if (list != NULL) {
+	    xmlNodePtr cur;
+
+	    /*
+	     * Return the newly created nodeset after unlinking it from
+	     * they pseudo parent.
+	     */
+	    cur = newDoc->children->children;
+	    *list = cur;
+	    while (cur != NULL) {
+		cur->parent = NULL;
+		cur = cur->next;
+	    }
+            newDoc->children->children = NULL;
+	}
+	ret = XML_ERR_OK;
+    }
+    if (sax != NULL) 
+	ctxt->sax = oldsax;
+    oldctxt->node_seq.maximum = ctxt->node_seq.maximum;
+    oldctxt->node_seq.length = ctxt->node_seq.length;
+    oldctxt->node_seq.buffer = ctxt->node_seq.buffer;
+    ctxt->node_seq.maximum = 0;
+    ctxt->node_seq.length = 0;
+    ctxt->node_seq.buffer = NULL;
+    xmlFreeParserCtxt(ctxt);
+    newDoc->intSubset = NULL;
+    newDoc->extSubset = NULL;
+    xmlFreeDoc(newDoc);
+    
+    return(ret);
+}
+
+#ifdef LIBXML_SAX1_ENABLED
+/**
+ * xmlParseExternalEntity:
+ * @doc:  the document the chunk pertains to
+ * @sax:  the SAX handler bloc (possibly NULL)
+ * @user_data:  The user data returned on SAX callbacks (possibly NULL)
+ * @depth:  Used for loop detection, use 0
+ * @URL:  the URL for the entity to load
+ * @ID:  the System ID for the entity to load
+ * @lst:  the return value for the set of parsed nodes
+ *
+ * Parse an external general entity
+ * An external general parsed entity is well-formed if it matches the
+ * production labeled extParsedEnt.
+ *
+ * [78] extParsedEnt ::= TextDecl? content
+ *
+ * Returns 0 if the entity is well formed, -1 in case of args problem and
+ *    the parser error code otherwise
+ */
+
+int
+xmlParseExternalEntity(xmlDocPtr doc, xmlSAXHandlerPtr sax, void *user_data,
+	  int depth, const xmlChar *URL, const xmlChar *ID, xmlNodePtr *lst) {
+    return(xmlParseExternalEntityPrivate(doc, NULL, sax, user_data, depth, URL,
+		                       ID, lst));
+}
+
+/**
+ * xmlParseBalancedChunkMemory:
+ * @doc:  the document the chunk pertains to
+ * @sax:  the SAX handler bloc (possibly NULL)
+ * @user_data:  The user data returned on SAX callbacks (possibly NULL)
+ * @depth:  Used for loop detection, use 0
+ * @string:  the input string in UTF8 or ISO-Latin (zero terminated)
+ * @lst:  the return value for the set of parsed nodes
+ *
+ * Parse a well-balanced chunk of an XML document
+ * called by the parser
+ * The allowed sequence for the Well Balanced Chunk is the one defined by
+ * the content production in the XML grammar:
+ *
+ * [43] content ::= (element | CharData | Reference | CDSect | PI | Comment)*
+ *
+ * Returns 0 if the chunk is well balanced, -1 in case of args problem and
+ *    the parser error code otherwise
+ */
+
+int
+xmlParseBalancedChunkMemory(xmlDocPtr doc, xmlSAXHandlerPtr sax,
+     void *user_data, int depth, const xmlChar *string, xmlNodePtr *lst) {
+    return xmlParseBalancedChunkMemoryRecover( doc, sax, user_data,
+                                                depth, string, lst, 0 );
+}
+#endif /* LIBXML_SAX1_ENABLED */
+
+/**
+ * xmlParseBalancedChunkMemoryInternal:
+ * @oldctxt:  the existing parsing context
+ * @string:  the input string in UTF8 or ISO-Latin (zero terminated)
+ * @user_data:  the user data field for the parser context
+ * @lst:  the return value for the set of parsed nodes
+ *
+ *
+ * Parse a well-balanced chunk of an XML document
+ * called by the parser
+ * The allowed sequence for the Well Balanced Chunk is the one defined by
+ * the content production in the XML grammar:
+ *
+ * [43] content ::= (element | CharData | Reference | CDSect | PI | Comment)*
+ *
+ * Returns XML_ERR_OK if the chunk is well balanced, and the parser
+ * error code otherwise
+ *    
+ * In case recover is set to 1, the nodelist will not be empty even if
+ * the parsed chunk is not well balanced. 
+ */
+static xmlParserErrors
+xmlParseBalancedChunkMemoryInternal(xmlParserCtxtPtr oldctxt,
+	const xmlChar *string, void *user_data, xmlNodePtr *lst) {
+    xmlParserCtxtPtr ctxt;
+    xmlDocPtr newDoc = NULL;
+    xmlSAXHandlerPtr oldsax = NULL;
+    xmlNodePtr content = NULL;
+    int size;
+    xmlParserErrors ret = XML_ERR_OK;
+
+    if (oldctxt->depth > 40) {
+	return(XML_ERR_ENTITY_LOOP);
+    }
+
+
+    if (lst != NULL)
+        *lst = NULL;
+    if (string == NULL)
+        return(XML_ERR_INTERNAL_ERROR);
+
+    size = xmlStrlen(string);
+
+    ctxt = xmlCreateMemoryParserCtxt((char *) string, size);
+    if (ctxt == NULL) return(XML_WAR_UNDECLARED_ENTITY);
+    if (user_data != NULL)
+	ctxt->userData = user_data;
+    else
+	ctxt->userData = ctxt;
+    if (ctxt->dict != NULL) xmlDictFree(ctxt->dict);
+    ctxt->dict = oldctxt->dict;
+    ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3);
+    ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5);
+    ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36);
+
+    oldsax = ctxt->sax;
+    ctxt->sax = oldctxt->sax;
+    xmlDetectSAX2(ctxt);
+    ctxt->replaceEntities = oldctxt->replaceEntities;
+    ctxt->options = oldctxt->options;
+    
+    ctxt->_private = oldctxt->_private;
+    if (oldctxt->myDoc == NULL) {
+	newDoc = xmlNewDoc(BAD_CAST "1.0");
+	if (newDoc == NULL) {
+	    ctxt->sax = oldsax;
+	    ctxt->dict = NULL;
+	    xmlFreeParserCtxt(ctxt);
+	    return(XML_ERR_INTERNAL_ERROR);
+	}
+	ctxt->myDoc = newDoc;
+    } else {
+	ctxt->myDoc = oldctxt->myDoc;
+        content = ctxt->myDoc->children;
+    }
+    ctxt->myDoc->children = xmlNewDocNode(ctxt->myDoc, NULL,
+	                                  BAD_CAST "pseudoroot", NULL);
+    if (ctxt->myDoc->children == NULL) {
+	ctxt->sax = oldsax;
+	ctxt->dict = NULL;
+	xmlFreeParserCtxt(ctxt);
+	if (newDoc != NULL)
+	    xmlFreeDoc(newDoc);
+	return(XML_ERR_INTERNAL_ERROR);
+    }
+    nodePush(ctxt, ctxt->myDoc->children);
+    ctxt->instate = XML_PARSER_CONTENT;
+    ctxt->depth = oldctxt->depth + 1;
+
+    ctxt->validate = 0;
+    ctxt->loadsubset = oldctxt->loadsubset;
+    if ((oldctxt->validate) || (oldctxt->replaceEntities != 0)) {
+	/*
+	 * ID/IDREF registration will be done in xmlValidateElement below
+	 */
+	ctxt->loadsubset |= XML_SKIP_IDS;
+    }
+    ctxt->dictNames = oldctxt->dictNames;
+    ctxt->attsDefault = oldctxt->attsDefault;
+    ctxt->attsSpecial = oldctxt->attsSpecial;
+
+    xmlParseContent(ctxt);
+    if ((RAW == '<') && (NXT(1) == '/')) {
+	xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
+    } else if (RAW != 0) {
+	xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
+    }
+    if (ctxt->node != ctxt->myDoc->children) {
+	xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
+    }
+
+    if (!ctxt->wellFormed) {
+        if (ctxt->errNo == 0)
+	    ret = XML_ERR_INTERNAL_ERROR;
+	else
+	    ret = (xmlParserErrors)ctxt->errNo;
+    } else {
+      ret = XML_ERR_OK;
+    }
+    
+    if ((lst != NULL) && (ret == XML_ERR_OK)) {
+	xmlNodePtr cur;
+
+	/*
+	 * Return the newly created nodeset after unlinking it from
+	 * they pseudo parent.
+	 */
+	cur = ctxt->myDoc->children->children;
+	*lst = cur;
+	while (cur != NULL) {
+#ifdef LIBXML_VALID_ENABLED
+	    if (oldctxt->validate && oldctxt->wellFormed &&
+		oldctxt->myDoc && oldctxt->myDoc->intSubset) {
+		oldctxt->valid &= xmlValidateElement(&oldctxt->vctxt,
+			oldctxt->myDoc, cur);
+	    }
+#endif /* LIBXML_VALID_ENABLED */
+	    cur->parent = NULL;
+	    cur = cur->next;
+	}
+	ctxt->myDoc->children->children = NULL;
+    }
+    if (ctxt->myDoc != NULL) {
+	xmlFreeNode(ctxt->myDoc->children);
+        ctxt->myDoc->children = content;
+    }
+	
+    ctxt->sax = oldsax;
+    ctxt->dict = NULL;
+    ctxt->attsDefault = NULL;
+    ctxt->attsSpecial = NULL;
+    xmlFreeParserCtxt(ctxt);
+    if (newDoc != NULL)
+	xmlFreeDoc(newDoc);
+    
+    return(ret);
+}
+
+#ifdef LIBXML_SAX1_ENABLED
+/**
+ * xmlParseBalancedChunkMemoryRecover:
+ * @doc:  the document the chunk pertains to
+ * @sax:  the SAX handler bloc (possibly NULL)
+ * @user_data:  The user data returned on SAX callbacks (possibly NULL)
+ * @depth:  Used for loop detection, use 0
+ * @string:  the input string in UTF8 or ISO-Latin (zero terminated)
+ * @lst:  the return value for the set of parsed nodes
+ * @recover: return nodes even if the data is broken (use 0)
+ *
+ *
+ * Parse a well-balanced chunk of an XML document
+ * called by the parser
+ * The allowed sequence for the Well Balanced Chunk is the one defined by
+ * the content production in the XML grammar:
+ *
+ * [43] content ::= (element | CharData | Reference | CDSect | PI | Comment)*
+ *
+ * Returns 0 if the chunk is well balanced, -1 in case of args problem and
+ *    the parser error code otherwise
+ *    
+ * In case recover is set to 1, the nodelist will not be empty even if
+ * the parsed chunk is not well balanced. 
+ */
+int
+xmlParseBalancedChunkMemoryRecover(xmlDocPtr doc, xmlSAXHandlerPtr sax,
+     void *user_data, int depth, const xmlChar *string, xmlNodePtr *lst, 
+     int recover) {
+    xmlParserCtxtPtr ctxt;
+    xmlDocPtr newDoc;
+    xmlSAXHandlerPtr oldsax = NULL;
+    xmlNodePtr content;
+    int size;
+    int ret = 0;
+
+    if (depth > 40) {
+	return(XML_ERR_ENTITY_LOOP);
+    }
+
+
+    if (lst != NULL)
+        *lst = NULL;
+    if (string == NULL)
+        return(-1);
+
+    size = xmlStrlen(string);
+
+    ctxt = xmlCreateMemoryParserCtxt((char *) string, size);
+    if (ctxt == NULL) return(-1);
+    ctxt->userData = ctxt;
+    if (sax != NULL) {
+	oldsax = ctxt->sax;
+        ctxt->sax = sax;
+	if (user_data != NULL)
+	    ctxt->userData = user_data;
+    }
+    newDoc = xmlNewDoc(BAD_CAST "1.0");
+    if (newDoc == NULL) {
+	xmlFreeParserCtxt(ctxt);
+	return(-1);
+    }
+    if (doc != NULL) {
+	newDoc->intSubset = doc->intSubset;
+	newDoc->extSubset = doc->extSubset;
+    }
+    newDoc->children = xmlNewDocNode(newDoc, NULL, BAD_CAST "pseudoroot", NULL);
+    if (newDoc->children == NULL) {
+	if (sax != NULL)
+	    ctxt->sax = oldsax;
+	xmlFreeParserCtxt(ctxt);
+	newDoc->intSubset = NULL;
+	newDoc->extSubset = NULL;
+        xmlFreeDoc(newDoc);
+	return(-1);
+    }
+    nodePush(ctxt, newDoc->children);
+    if (doc == NULL) {
+	ctxt->myDoc = newDoc;
+    } else {
+	ctxt->myDoc = newDoc;
+	newDoc->children->doc = doc;
+    }
+    ctxt->instate = XML_PARSER_CONTENT;
+    ctxt->depth = depth;
+
+    /*
+     * Doing validity checking on chunk doesn't make sense
+     */
+    ctxt->validate = 0;
+    ctxt->loadsubset = 0;
+    xmlDetectSAX2(ctxt);
+
+    if ( doc != NULL ){
+        content = doc->children;
+        doc->children = NULL;
+        xmlParseContent(ctxt);
+        doc->children = content;
+    }
+    else {
+        xmlParseContent(ctxt);
+    }
+    if ((RAW == '<') && (NXT(1) == '/')) {
+	xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
+    } else if (RAW != 0) {
+	xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
+    }
+    if (ctxt->node != newDoc->children) {
+	xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
+    }
+
+    if (!ctxt->wellFormed) {
+        if (ctxt->errNo == 0)
+	    ret = 1;
+	else
+	    ret = ctxt->errNo;
+    } else {
+      ret = 0;
+    }
+    
+    if (lst != NULL && (ret == 0 || recover == 1)) {
+      xmlNodePtr cur;
+
+	    /*
+	     * Return the newly created nodeset after unlinking it from
+	     * they pseudo parent.
+	     */
+	    cur = newDoc->children->children;
+	    *lst = cur;
+	    while (cur != NULL) {
+		cur->parent = NULL;
+		cur = cur->next;
+	    }
+            newDoc->children->children = NULL;
+	}
+	
+    if (sax != NULL) 
+	ctxt->sax = oldsax;
+    xmlFreeParserCtxt(ctxt);
+    newDoc->intSubset = NULL;
+    newDoc->extSubset = NULL;
+    xmlFreeDoc(newDoc);
+    
+    return(ret);
+}
+
+/**
+ * xmlSAXParseEntity:
+ * @sax:  the SAX handler block
+ * @filename:  the filename
+ *
+ * parse an XML external entity out of context and build a tree.
+ * It use the given SAX function block to handle the parsing callback.
+ * If sax is NULL, fallback to the default DOM tree building routines.
+ *
+ * [78] extParsedEnt ::= TextDecl? content
+ *
+ * This correspond to a "Well Balanced" chunk
+ *
+ * Returns the resulting document tree
+ */
+
+xmlDocPtr
+xmlSAXParseEntity(xmlSAXHandlerPtr sax, const char *filename) {
+    xmlDocPtr ret;
+    xmlParserCtxtPtr ctxt;
+
+    ctxt = xmlCreateFileParserCtxt(filename);
+    if (ctxt == NULL) {
+	return(NULL);
+    }
+    if (sax != NULL) {
+	if (ctxt->sax != NULL)
+	    xmlFree(ctxt->sax);
+        ctxt->sax = sax;
+        ctxt->userData = NULL;
+    }
+
+    xmlParseExtParsedEnt(ctxt);
+
+    if (ctxt->wellFormed)
+	ret = ctxt->myDoc;
+    else {
+        ret = NULL;
+        xmlFreeDoc(ctxt->myDoc);
+        ctxt->myDoc = NULL;
+    }
+    if (sax != NULL)
+        ctxt->sax = NULL;
+    xmlFreeParserCtxt(ctxt);
+    
+    return(ret);
+}
+
+/**
+ * xmlParseEntity:
+ * @filename:  the filename
+ *
+ * parse an XML external entity out of context and build a tree.
+ *
+ * [78] extParsedEnt ::= TextDecl? content
+ *
+ * This correspond to a "Well Balanced" chunk
+ *
+ * Returns the resulting document tree
+ */
+
+xmlDocPtr
+xmlParseEntity(const char *filename) {
+    return(xmlSAXParseEntity(NULL, filename));
+}
+#endif /* LIBXML_SAX1_ENABLED */
+
+/**
+ * xmlCreateEntityParserCtxt:
+ * @URL:  the entity URL
+ * @ID:  the entity PUBLIC ID
+ * @base:  a possible base for the target URI
+ *
+ * Create a parser context for an external entity
+ * Automatic support for ZLIB/Compress compressed document is provided
+ * by default if found at compile-time.
+ *
+ * Returns the new parser context or NULL
+ */
+xmlParserCtxtPtr
+xmlCreateEntityParserCtxt(const xmlChar *URL, const xmlChar *ID,
+	                  const xmlChar *base) {
+    xmlParserCtxtPtr ctxt;
+    xmlParserInputPtr inputStream;
+    char *directory = NULL;
+    xmlChar *uri;
+    
+    ctxt = xmlNewParserCtxt();
+    if (ctxt == NULL) {
+	return(NULL);
+    }
+
+    uri = xmlBuildURI(URL, base);
+
+    if (uri == NULL) {
+	inputStream = xmlLoadExternalEntity((char *)URL, (char *)ID, ctxt);
+	if (inputStream == NULL) {
+	    xmlFreeParserCtxt(ctxt);
+	    return(NULL);
+	}
+
+	inputPush(ctxt, inputStream);
+
+	if ((ctxt->directory == NULL) && (directory == NULL))
+	    directory = xmlParserGetDirectory((char *)URL);
+	if ((ctxt->directory == NULL) && (directory != NULL))
+	    ctxt->directory = directory;
+    } else {
+	inputStream = xmlLoadExternalEntity((char *)uri, (char *)ID, ctxt);
+	if (inputStream == NULL) {
+	    xmlFree(uri);
+	    xmlFreeParserCtxt(ctxt);
+	    return(NULL);
+	}
+
+	inputPush(ctxt, inputStream);
+
+	if ((ctxt->directory == NULL) && (directory == NULL))
+	    directory = xmlParserGetDirectory((char *)uri);
+	if ((ctxt->directory == NULL) && (directory != NULL))
+	    ctxt->directory = directory;
+	xmlFree(uri);
+    }
+    return(ctxt);
+}
+
+/************************************************************************
+ *									*
+ * 		Front ends when parsing from a file			*
+ *									*
+ ************************************************************************/
+
+/**
+ * xmlCreateURLParserCtxt:
+ * @filename:  the filename or URL
+ * @options:  a combination of xmlParserOption
+ *
+ * Create a parser context for a file or URL content. 
+ * Automatic support for ZLIB/Compress compressed document is provided
+ * by default if found at compile-time and for file accesses
+ *
+ * Returns the new parser context or NULL
+ */
+xmlParserCtxtPtr
+xmlCreateURLParserCtxt(const char *filename, int options)
+{
+    xmlParserCtxtPtr ctxt;
+    xmlParserInputPtr inputStream;
+    char *directory = NULL;
+
+    ctxt = xmlNewParserCtxt();
+    if (ctxt == NULL) {
+	xmlErrMemory(NULL, "cannot allocate parser context");
+	return(NULL);
+    }
+
+    if (options != 0)
+        xmlCtxtUseOptions(ctxt, options);
+    
+    inputStream = xmlLoadExternalEntity(filename, NULL, ctxt);
+    if (inputStream == NULL) {
+	xmlFreeParserCtxt(ctxt);
+	return(NULL);
+    }
+
+    inputPush(ctxt, inputStream);
+    if ((ctxt->directory == NULL) && (directory == NULL))
+        directory = xmlParserGetDirectory(filename);
+    if ((ctxt->directory == NULL) && (directory != NULL))
+        ctxt->directory = directory;
+
+    return(ctxt);
+}
+
+/**
+ * xmlCreateFileParserCtxt:
+ * @filename:  the filename
+ *
+ * Create a parser context for a file content. 
+ * Automatic support for ZLIB/Compress compressed document is provided
+ * by default if found at compile-time.
+ *
+ * Returns the new parser context or NULL
+ */
+xmlParserCtxtPtr
+xmlCreateFileParserCtxt(const char *filename)
+{
+    return(xmlCreateURLParserCtxt(filename, 0));
+}
+
+#ifdef LIBXML_SAX1_ENABLED
+/**
+ * xmlSAXParseFileWithData:
+ * @sax:  the SAX handler block
+ * @filename:  the filename
+ * @recovery:  work in recovery mode, i.e. tries to read no Well Formed
+ *             documents
+ * @data:  the userdata
+ *
+ * parse an XML file and build a tree. Automatic support for ZLIB/Compress
+ * compressed document is provided by default if found at compile-time.
+ * It use the given SAX function block to handle the parsing callback.
+ * If sax is NULL, fallback to the default DOM tree building routines.
+ *
+ * User data (void *) is stored within the parser context in the
+ * context's _private member, so it is available nearly everywhere in libxml
+ *
+ * Returns the resulting document tree
+ */
+
+xmlDocPtr
+xmlSAXParseFileWithData(xmlSAXHandlerPtr sax, const char *filename,
+                        int recovery, void *data) {
+    xmlDocPtr ret;
+    xmlParserCtxtPtr ctxt;
+    char *directory = NULL;
+
+    xmlInitParser();
+
+    ctxt = xmlCreateFileParserCtxt(filename);
+    if (ctxt == NULL) {
+	return(NULL);
+    }
+    if (sax != NULL) {
+	if (ctxt->sax != NULL)
+	    xmlFree(ctxt->sax);
+        ctxt->sax = sax;
+    }
+    xmlDetectSAX2(ctxt);
+    if (data!=NULL) {
+	ctxt->_private = data;
+    }
+
+    if ((ctxt->directory == NULL) && (directory == NULL))
+        directory = xmlParserGetDirectory(filename);
+    if ((ctxt->directory == NULL) && (directory != NULL))
+        ctxt->directory = (char *) xmlStrdup((xmlChar *) directory);
+
+    ctxt->recovery = recovery;
+
+    xmlParseDocument(ctxt);
+
+    if ((ctxt->wellFormed) || recovery) {
+        ret = ctxt->myDoc;
+	if (ret != NULL) {
+	    if (ctxt->input->buf->compressed > 0)
+		ret->compression = 9;
+	    else
+		ret->compression = ctxt->input->buf->compressed;
+	}
+    }
+    else {
+       ret = NULL;
+       xmlFreeDoc(ctxt->myDoc);
+       ctxt->myDoc = NULL;
+    }
+    if (sax != NULL)
+        ctxt->sax = NULL;
+    xmlFreeParserCtxt(ctxt);
+    
+    return(ret);
+}
+
+/**
+ * xmlSAXParseFile:
+ * @sax:  the SAX handler block
+ * @filename:  the filename
+ * @recovery:  work in recovery mode, i.e. tries to read no Well Formed
+ *             documents
+ *
+ * parse an XML file and build a tree. Automatic support for ZLIB/Compress
+ * compressed document is provided by default if found at compile-time.
+ * It use the given SAX function block to handle the parsing callback.
+ * If sax is NULL, fallback to the default DOM tree building routines.
+ *
+ * Returns the resulting document tree
+ */
+
+xmlDocPtr
+xmlSAXParseFile(xmlSAXHandlerPtr sax, const char *filename,
+                          int recovery) {
+    return(xmlSAXParseFileWithData(sax,filename,recovery,NULL));
+}
+
+/**
+ * xmlRecoverDoc:
+ * @cur:  a pointer to an array of xmlChar
+ *
+ * parse an XML in-memory document and build a tree.
+ * In the case the document is not Well Formed, a tree is built anyway
+ * 
+ * Returns the resulting document tree
+ */
+
+xmlDocPtr
+xmlRecoverDoc(xmlChar *cur) {
+    return(xmlSAXParseDoc(NULL, cur, 1));
+}
+
+/**
+ * xmlParseFile:
+ * @filename:  the filename
+ *
+ * parse an XML file and build a tree. Automatic support for ZLIB/Compress
+ * compressed document is provided by default if found at compile-time.
+ *
+ * Returns the resulting document tree if the file was wellformed,
+ * NULL otherwise.
+ */
+
+xmlDocPtr
+xmlParseFile(const char *filename) {
+    return(xmlSAXParseFile(NULL, filename, 0));
+}
+
+/**
+ * xmlRecoverFile:
+ * @filename:  the filename
+ *
+ * parse an XML file and build a tree. Automatic support for ZLIB/Compress
+ * compressed document is provided by default if found at compile-time.
+ * In the case the document is not Well Formed, a tree is built anyway
+ *
+ * Returns the resulting document tree
+ */
+
+xmlDocPtr
+xmlRecoverFile(const char *filename) {
+    return(xmlSAXParseFile(NULL, filename, 1));
+}
+
+
+/**
+ * xmlSetupParserForBuffer:
+ * @ctxt:  an XML parser context
+ * @buffer:  a xmlChar * buffer
+ * @filename:  a file name
+ *
+ * Setup the parser context to parse a new buffer; Clears any prior
+ * contents from the parser context. The buffer parameter must not be
+ * NULL, but the filename parameter can be
+ */
+void
+xmlSetupParserForBuffer(xmlParserCtxtPtr ctxt, const xmlChar* buffer,
+                             const char* filename)
+{
+    xmlParserInputPtr input;
+
+    input = xmlNewInputStream(ctxt);
+    if (input == NULL) {
+        xmlErrMemory(NULL, "parsing new buffer: out of memory\n");
+        xmlFree(ctxt);
+        return;
+    }
+  
+    xmlClearParserCtxt(ctxt);
+    if (filename != NULL)
+        input->filename = (char *) xmlCanonicPath((const xmlChar *)filename);
+    input->base = buffer;
+    input->cur = buffer;
+    input->end = &buffer[xmlStrlen(buffer)];
+    inputPush(ctxt, input);
+}
+
+/**
+ * xmlSAXUserParseFile:
+ * @sax:  a SAX handler
+ * @user_data:  The user data returned on SAX callbacks
+ * @filename:  a file name
+ *
+ * parse an XML file and call the given SAX handler routines.
+ * Automatic support for ZLIB/Compress compressed document is provided
+ * 
+ * Returns 0 in case of success or a error number otherwise
+ */
+int
+xmlSAXUserParseFile(xmlSAXHandlerPtr sax, void *user_data,
+                    const char *filename) {
+    int ret = 0;
+    xmlParserCtxtPtr ctxt;
+    
+    ctxt = xmlCreateFileParserCtxt(filename);
+    if (ctxt == NULL) return -1;
+#ifdef LIBXML_SAX1_ENABLED
+    if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
+#endif /* LIBXML_SAX1_ENABLED */
+	xmlFree(ctxt->sax);
+    ctxt->sax = sax;
+    xmlDetectSAX2(ctxt);
+
+    if (user_data != NULL)
+	ctxt->userData = user_data;
+    
+    xmlParseDocument(ctxt);
+    
+    if (ctxt->wellFormed)
+	ret = 0;
+    else {
+        if (ctxt->errNo != 0)
+	    ret = ctxt->errNo;
+	else
+	    ret = -1;
+    }
+    if (sax != NULL)
+	ctxt->sax = NULL;
+    xmlFreeParserCtxt(ctxt);
+    
+    return ret;
+}
+#endif /* LIBXML_SAX1_ENABLED */
+
+/************************************************************************
+ *									*
+ * 		Front ends when parsing from memory			*
+ *									*
+ ************************************************************************/
+
+/**
+ * xmlCreateMemoryParserCtxt:
+ * @buffer:  a pointer to a char array
+ * @size:  the size of the array
+ *
+ * Create a parser context for an XML in-memory document.
+ *
+ * Returns the new parser context or NULL
+ */
+xmlParserCtxtPtr
+xmlCreateMemoryParserCtxt(const char *buffer, int size) {
+    xmlParserCtxtPtr ctxt;
+    xmlParserInputPtr input;
+    xmlParserInputBufferPtr buf;
+
+    if (buffer == NULL)
+	return(NULL);
+    if (size <= 0)
+	return(NULL);
+
+    ctxt = xmlNewParserCtxt();
+    if (ctxt == NULL)
+	return(NULL);
+
+    /* TODO: xmlParserInputBufferCreateStatic, requires some serious changes */
+    buf = xmlParserInputBufferCreateMem(buffer, size, XML_CHAR_ENCODING_NONE);
+    if (buf == NULL) {
+	xmlFreeParserCtxt(ctxt);
+	return(NULL);
+    }
+
+    input = xmlNewInputStream(ctxt);
+    if (input == NULL) {
+	xmlFreeParserInputBuffer(buf);
+	xmlFreeParserCtxt(ctxt);
+	return(NULL);
+    }
+
+    input->filename = NULL;
+    input->buf = buf;
+    input->base = input->buf->buffer->content;
+    input->cur = input->buf->buffer->content;
+    input->end = &input->buf->buffer->content[input->buf->buffer->use];
+
+    inputPush(ctxt, input);
+    return(ctxt);
+}
+
+#ifdef LIBXML_SAX1_ENABLED
+/**
+ * xmlSAXParseMemoryWithData:
+ * @sax:  the SAX handler block
+ * @buffer:  an pointer to a char array
+ * @size:  the size of the array
+ * @recovery:  work in recovery mode, i.e. tries to read no Well Formed
+ *             documents
+ * @data:  the userdata
+ *
+ * parse an XML in-memory block and use the given SAX function block
+ * to handle the parsing callback. If sax is NULL, fallback to the default
+ * DOM tree building routines.
+ *
+ * User data (void *) is stored within the parser context in the
+ * context's _private member, so it is available nearly everywhere in libxml
+ *
+ * Returns the resulting document tree
+ */
+
+xmlDocPtr
+xmlSAXParseMemoryWithData(xmlSAXHandlerPtr sax, const char *buffer,
+	          int size, int recovery, void *data) {
+    xmlDocPtr ret;
+    xmlParserCtxtPtr ctxt;
+
+    ctxt = xmlCreateMemoryParserCtxt(buffer, size);
+    if (ctxt == NULL) return(NULL);
+    if (sax != NULL) {
+	if (ctxt->sax != NULL)
+	    xmlFree(ctxt->sax);
+        ctxt->sax = sax;
+    }
+    xmlDetectSAX2(ctxt);
+    if (data!=NULL) {
+	ctxt->_private=data;
+    }
+
+    ctxt->recovery = recovery;
+
+    xmlParseDocument(ctxt);
+
+    if ((ctxt->wellFormed) || recovery) ret = ctxt->myDoc;
+    else {
+       ret = NULL;
+       xmlFreeDoc(ctxt->myDoc);
+       ctxt->myDoc = NULL;
+    }
+    if (sax != NULL) 
+	ctxt->sax = NULL;
+    xmlFreeParserCtxt(ctxt);
+    
+    return(ret);
+}
+
+/**
+ * xmlSAXParseMemory:
+ * @sax:  the SAX handler block
+ * @buffer:  an pointer to a char array
+ * @size:  the size of the array
+ * @recovery:  work in recovery mode, i.e. tries to read not Well Formed
+ *             documents
+ *
+ * parse an XML in-memory block and use the given SAX function block
+ * to handle the parsing callback. If sax is NULL, fallback to the default
+ * DOM tree building routines.
+ * 
+ * Returns the resulting document tree
+ */
+xmlDocPtr
+xmlSAXParseMemory(xmlSAXHandlerPtr sax, const char *buffer,
+	          int size, int recovery) {
+    return xmlSAXParseMemoryWithData(sax, buffer, size, recovery, NULL);
+}
+
+/**
+ * xmlParseMemory:
+ * @buffer:  an pointer to a char array
+ * @size:  the size of the array
+ *
+ * parse an XML in-memory block and build a tree.
+ * 
+ * Returns the resulting document tree
+ */
+
+xmlDocPtr xmlParseMemory(const char *buffer, int size) {
+   return(xmlSAXParseMemory(NULL, buffer, size, 0));
+}
+
+/**
+ * xmlRecoverMemory:
+ * @buffer:  an pointer to a char array
+ * @size:  the size of the array
+ *
+ * parse an XML in-memory block and build a tree.
+ * In the case the document is not Well Formed, a tree is built anyway
+ * 
+ * Returns the resulting document tree
+ */
+
+xmlDocPtr xmlRecoverMemory(const char *buffer, int size) {
+   return(xmlSAXParseMemory(NULL, buffer, size, 1));
+}
+
+/**
+ * xmlSAXUserParseMemory:
+ * @sax:  a SAX handler
+ * @user_data:  The user data returned on SAX callbacks
+ * @buffer:  an in-memory XML document input
+ * @size:  the length of the XML document in bytes
+ *
+ * A better SAX parsing routine.
+ * parse an XML in-memory buffer and call the given SAX handler routines.
+ * 
+ * Returns 0 in case of success or a error number otherwise
+ */
+int xmlSAXUserParseMemory(xmlSAXHandlerPtr sax, void *user_data,
+			  const char *buffer, int size) {
+    int ret = 0;
+    xmlParserCtxtPtr ctxt;
+    xmlSAXHandlerPtr oldsax = NULL;
+    
+    if (sax == NULL) return -1;
+    ctxt = xmlCreateMemoryParserCtxt(buffer, size);
+    if (ctxt == NULL) return -1;
+    oldsax = ctxt->sax;
+    ctxt->sax = sax;
+    xmlDetectSAX2(ctxt);
+    if (user_data != NULL)
+	ctxt->userData = user_data;
+    
+    xmlParseDocument(ctxt);
+    
+    if (ctxt->wellFormed)
+	ret = 0;
+    else {
+        if (ctxt->errNo != 0)
+	    ret = ctxt->errNo;
+	else
+	    ret = -1;
+    }
+    ctxt->sax = oldsax;
+    xmlFreeParserCtxt(ctxt);
+    
+    return ret;
+}
+#endif /* LIBXML_SAX1_ENABLED */
+
+/**
+ * xmlCreateDocParserCtxt:
+ * @cur:  a pointer to an array of xmlChar
+ *
+ * Creates a parser context for an XML in-memory document.
+ *
+ * Returns the new parser context or NULL
+ */
+xmlParserCtxtPtr
+xmlCreateDocParserCtxt(const xmlChar *cur) {
+    int len;
+
+    if (cur == NULL)
+	return(NULL);
+    len = xmlStrlen(cur);
+    return(xmlCreateMemoryParserCtxt((const char *)cur, len));
+}
+
+#ifdef LIBXML_SAX1_ENABLED
+/**
+ * xmlSAXParseDoc:
+ * @sax:  the SAX handler block
+ * @cur:  a pointer to an array of xmlChar
+ * @recovery:  work in recovery mode, i.e. tries to read no Well Formed
+ *             documents
+ *
+ * parse an XML in-memory document and build a tree.
+ * It use the given SAX function block to handle the parsing callback.
+ * If sax is NULL, fallback to the default DOM tree building routines.
+ * 
+ * Returns the resulting document tree
+ */
+
+xmlDocPtr
+xmlSAXParseDoc(xmlSAXHandlerPtr sax, xmlChar *cur, int recovery) {
+    xmlDocPtr ret;
+    xmlParserCtxtPtr ctxt;
+
+    if (cur == NULL) return(NULL);
+
+
+    ctxt = xmlCreateDocParserCtxt(cur);
+    if (ctxt == NULL) return(NULL);
+    if (sax != NULL) { 
+        ctxt->sax = sax;
+        ctxt->userData = NULL;
+    }
+    xmlDetectSAX2(ctxt);
+
+    xmlParseDocument(ctxt);
+    if ((ctxt->wellFormed) || recovery) ret = ctxt->myDoc;
+    else {
+       ret = NULL;
+       xmlFreeDoc(ctxt->myDoc);
+       ctxt->myDoc = NULL;
+    }
+    if (sax != NULL) 
+	ctxt->sax = NULL;
+    xmlFreeParserCtxt(ctxt);
+    
+    return(ret);
+}
+
+/**
+ * xmlParseDoc:
+ * @cur:  a pointer to an array of xmlChar
+ *
+ * parse an XML in-memory document and build a tree.
+ * 
+ * Returns the resulting document tree
+ */
+
+xmlDocPtr
+xmlParseDoc(xmlChar *cur) {
+    return(xmlSAXParseDoc(NULL, cur, 0));
+}
+#endif /* LIBXML_SAX1_ENABLED */
+
+#ifdef LIBXML_LEGACY_ENABLED
+/************************************************************************
+ *									*
+ * 	Specific function to keep track of entities references		*
+ * 	and used by the XSLT debugger					*
+ *									*
+ ************************************************************************/
+
+static xmlEntityReferenceFunc xmlEntityRefFunc = NULL;
+
+/**
+ * xmlAddEntityReference:
+ * @ent : A valid entity
+ * @firstNode : A valid first node for children of entity
+ * @lastNode : A valid last node of children entity 
+ *
+ * Notify of a reference to an entity of type XML_EXTERNAL_GENERAL_PARSED_ENTITY
+ */
+static void
+xmlAddEntityReference(xmlEntityPtr ent, xmlNodePtr firstNode,
+                      xmlNodePtr lastNode)
+{
+    if (xmlEntityRefFunc != NULL) {
+        (*xmlEntityRefFunc) (ent, firstNode, lastNode);
+    }
+}
+
+
+/**
+ * xmlSetEntityReferenceFunc:
+ * @func: A valid function
+ *
+ * Set the function to call call back when a xml reference has been made
+ */
+void
+xmlSetEntityReferenceFunc(xmlEntityReferenceFunc func)
+{
+    xmlEntityRefFunc = func;
+}
+#endif /* LIBXML_LEGACY_ENABLED */
+
+/************************************************************************
+ *									*
+ * 				Miscellaneous				*
+ *									*
+ ************************************************************************/
+
+#ifdef LIBXML_XPATH_ENABLED
+#include <libxml/xpath.h>
+#endif
+
+extern void xmlGenericErrorDefaultFunc(void *ctx, const char *msg, ...);
+static int xmlParserInitialized = 0;
+
+/**
+ * xmlInitParser:
+ *
+ * Initialization function for the XML parser.
+ * This is not reentrant. Call once before processing in case of
+ * use in multithreaded programs.
+ */
+
+void
+xmlInitParser(void) {
+    if (xmlParserInitialized != 0)
+	return;
+
+    if ((xmlGenericError == xmlGenericErrorDefaultFunc) ||
+	(xmlGenericError == NULL))
+	initGenericErrorDefaultFunc(NULL);
+    xmlInitGlobals();
+    xmlInitThreads();
+    xmlInitMemory();
+    xmlInitCharEncodingHandlers();
+    xmlDefaultSAXHandlerInit();
+    xmlRegisterDefaultInputCallbacks();
+#ifdef LIBXML_OUTPUT_ENABLED
+    xmlRegisterDefaultOutputCallbacks();
+#endif /* LIBXML_OUTPUT_ENABLED */
+#ifdef LIBXML_HTML_ENABLED
+    htmlInitAutoClose();
+    htmlDefaultSAXHandlerInit();
+#endif
+#ifdef LIBXML_XPATH_ENABLED
+    xmlXPathInit();
+#endif
+    xmlParserInitialized = 1;
+}
+
+/**
+ * xmlCleanupParser:
+ *
+ * Cleanup function for the XML library. It tries to reclaim all
+ * parsing related global memory allocated for the library processing.
+ * It doesn't deallocate any document related memory. Calling this
+ * function should not prevent reusing the library but one should
+ * call xmlCleanupParser() only when the process has
+ * finished using the library or XML document built with it.
+ */
+
+void
+xmlCleanupParser(void) {
+    if (!xmlParserInitialized)
+	return;
+
+    xmlCleanupCharEncodingHandlers();
+#ifdef LIBXML_CATALOG_ENABLED
+    xmlCatalogCleanup();
+#endif
+    xmlCleanupInputCallbacks();
+#ifdef LIBXML_OUTPUT_ENABLED
+    xmlCleanupOutputCallbacks();
+#endif
+    xmlCleanupGlobals();
+    xmlResetLastError();
+    xmlCleanupThreads(); /* must be last if called not from the main thread */
+    xmlCleanupMemory();
+    xmlParserInitialized = 0;
+}
+
+/************************************************************************
+ *									*
+ *	New set (2.6.0) of simpler and more flexible APIs		*
+ *									*
+ ************************************************************************/
+
+/**
+ * DICT_FREE:
+ * @str:  a string
+ *
+ * Free a string if it is not owned by the "dict" dictionnary in the
+ * current scope
+ */
+#define DICT_FREE(str)						\
+	if ((str) && ((!dict) || 				\
+	    (xmlDictOwns(dict, (const xmlChar *)(str)) == 0)))	\
+	    xmlFree((char *)(str));
+
+/**
+ * xmlCtxtReset:
+ * @ctxt: an XML parser context
+ *
+ * Reset a parser context
+ */
+void
+xmlCtxtReset(xmlParserCtxtPtr ctxt)
+{
+    xmlParserInputPtr input;
+    xmlDictPtr dict = ctxt->dict;
+
+    while ((input = inputPop(ctxt)) != NULL) { /* Non consuming */
+        xmlFreeInputStream(input);
+    }
+    ctxt->inputNr = 0;
+    ctxt->input = NULL;
+
+    ctxt->spaceNr = 0;
+    ctxt->spaceTab[0] = -1;
+    ctxt->space = &ctxt->spaceTab[0];
+
+
+    ctxt->nodeNr = 0;
+    ctxt->node = NULL;
+
+    ctxt->nameNr = 0;
+    ctxt->name = NULL;
+
+    DICT_FREE(ctxt->version);
+    ctxt->version = NULL;
+    DICT_FREE(ctxt->encoding);
+    ctxt->encoding = NULL;
+    DICT_FREE(ctxt->directory);
+    ctxt->directory = NULL;
+    DICT_FREE(ctxt->extSubURI);
+    ctxt->extSubURI = NULL;
+    DICT_FREE(ctxt->extSubSystem);
+    ctxt->extSubSystem = NULL;
+    if (ctxt->myDoc != NULL)
+        xmlFreeDoc(ctxt->myDoc);
+    ctxt->myDoc = NULL;
+
+    ctxt->standalone = -1;
+    ctxt->hasExternalSubset = 0;
+    ctxt->hasPErefs = 0;
+    ctxt->html = 0;
+    ctxt->external = 0;
+    ctxt->instate = XML_PARSER_START;
+    ctxt->token = 0;
+
+    ctxt->wellFormed = 1;
+    ctxt->nsWellFormed = 1;
+    ctxt->disableSAX = 0;
+    ctxt->valid = 1;
+#if 0
+    ctxt->vctxt.userData = ctxt;
+    ctxt->vctxt.error = xmlParserValidityError;
+    ctxt->vctxt.warning = xmlParserValidityWarning;
+#endif
+    ctxt->record_info = 0;
+    ctxt->nbChars = 0;
+    ctxt->checkIndex = 0;
+    ctxt->inSubset = 0;
+    ctxt->errNo = XML_ERR_OK;
+    ctxt->depth = 0;
+    ctxt->charset = XML_CHAR_ENCODING_UTF8;
+    ctxt->catalogs = NULL;
+    xmlInitNodeInfoSeq(&ctxt->node_seq);
+
+    if (ctxt->attsDefault != NULL) {
+        xmlHashFree(ctxt->attsDefault, (xmlHashDeallocator) xmlFree);
+        ctxt->attsDefault = NULL;
+    }
+    if (ctxt->attsSpecial != NULL) {
+        xmlHashFree(ctxt->attsSpecial, NULL);
+        ctxt->attsSpecial = NULL;
+    }
+
+#ifdef LIBXML_CATALOG_ENABLED
+    if (ctxt->catalogs != NULL)
+	xmlCatalogFreeLocal(ctxt->catalogs);
+#endif
+    if (ctxt->lastError.code != XML_ERR_OK)
+        xmlResetError(&ctxt->lastError);
+}
+
+/**
+ * xmlCtxtResetPush:
+ * @ctxt: an XML parser context
+ * @chunk:  a pointer to an array of chars
+ * @size:  number of chars in the array
+ * @filename:  an optional file name or URI
+ * @encoding:  the document encoding, or NULL
+ *
+ * Reset a push parser context
+ *
+ * Returns 0 in case of success and 1 in case of error
+ */
+int
+xmlCtxtResetPush(xmlParserCtxtPtr ctxt, const char *chunk,
+                 int size, const char *filename, const char *encoding)
+{
+    xmlParserInputPtr inputStream;
+    xmlParserInputBufferPtr buf;
+    xmlCharEncoding enc = XML_CHAR_ENCODING_NONE;
+
+    if (ctxt == NULL)
+        return(1);
+
+    if ((encoding == NULL) && (chunk != NULL) && (size >= 4))
+        enc = xmlDetectCharEncoding((const xmlChar *) chunk, size);
+
+    buf = xmlAllocParserInputBuffer(enc);
+    if (buf == NULL)
+        return(1);
+
+    if (ctxt == NULL) {
+        xmlFreeParserInputBuffer(buf);
+        return(1);
+    }
+
+    xmlCtxtReset(ctxt);
+
+    if (ctxt->pushTab == NULL) {
+        ctxt->pushTab = (void **) xmlMalloc(ctxt->nameMax * 3 *
+	                                    sizeof(xmlChar *));
+        if (ctxt->pushTab == NULL) {
+	    xmlErrMemory(ctxt, NULL);
+            xmlFreeParserInputBuffer(buf);
+            return(1);
+        }
+    }
+
+    if (filename == NULL) {
+        ctxt->directory = NULL;
+    } else {
+        ctxt->directory = xmlParserGetDirectory(filename);
+    }
+
+    inputStream = xmlNewInputStream(ctxt);
+    if (inputStream == NULL) {
+        xmlFreeParserInputBuffer(buf);
+        return(1);
+    }
+
+    if (filename == NULL)
+        inputStream->filename = NULL;
+    else
+        inputStream->filename = (char *)
+            xmlCanonicPath((const xmlChar *) filename);
+    inputStream->buf = buf;
+    inputStream->base = inputStream->buf->buffer->content;
+    inputStream->cur = inputStream->buf->buffer->content;
+    inputStream->end =
+        &inputStream->buf->buffer->content[inputStream->buf->buffer->use];
+
+    inputPush(ctxt, inputStream);
+
+    if ((size > 0) && (chunk != NULL) && (ctxt->input != NULL) &&
+        (ctxt->input->buf != NULL)) {
+        int base = ctxt->input->base - ctxt->input->buf->buffer->content;
+        int cur = ctxt->input->cur - ctxt->input->base;
+
+        xmlParserInputBufferPush(ctxt->input->buf, size, chunk);
+
+        ctxt->input->base = ctxt->input->buf->buffer->content + base;
+        ctxt->input->cur = ctxt->input->base + cur;
+        ctxt->input->end =
+            &ctxt->input->buf->buffer->content[ctxt->input->buf->buffer->
+                                               use];
+#ifdef DEBUG_PUSH
+        xmlGenericError(xmlGenericErrorContext, "PP: pushed %d\n", size);
+#endif
+    }
+
+    if (encoding != NULL) {
+        xmlCharEncodingHandlerPtr hdlr;
+
+        hdlr = xmlFindCharEncodingHandler(encoding);
+        if (hdlr != NULL) {
+            xmlSwitchToEncoding(ctxt, hdlr);
+	} else {
+	    xmlFatalErrMsgStr(ctxt, XML_ERR_UNSUPPORTED_ENCODING,
+			      "Unsupported encoding %s\n", BAD_CAST encoding);
+        }
+    } else if (enc != XML_CHAR_ENCODING_NONE) {
+        xmlSwitchEncoding(ctxt, enc);
+    }
+
+    return(0);
+}
+
+/**
+ * xmlCtxtUseOptions:
+ * @ctxt: an XML parser context
+ * @options:  a combination of xmlParserOption
+ *
+ * Applies the options to the parser context
+ *
+ * Returns 0 in case of success, the set of unknown or unimplemented options
+ *         in case of error.
+ */
+int
+xmlCtxtUseOptions(xmlParserCtxtPtr ctxt, int options)
+{
+    if (options & XML_PARSE_RECOVER) {
+        ctxt->recovery = 1;
+        options -= XML_PARSE_RECOVER;
+    } else
+        ctxt->recovery = 0;
+    if (options & XML_PARSE_DTDLOAD) {
+        ctxt->loadsubset = XML_DETECT_IDS;
+        options -= XML_PARSE_DTDLOAD;
+    } else
+        ctxt->loadsubset = 0;
+    if (options & XML_PARSE_DTDATTR) {
+        ctxt->loadsubset |= XML_COMPLETE_ATTRS;
+        options -= XML_PARSE_DTDATTR;
+    }
+    if (options & XML_PARSE_NOENT) {
+        ctxt->replaceEntities = 1;
+        /* ctxt->loadsubset |= XML_DETECT_IDS; */
+        options -= XML_PARSE_NOENT;
+    } else
+        ctxt->replaceEntities = 0;
+    if (options & XML_PARSE_NOWARNING) {
+        ctxt->sax->warning = NULL;
+        options -= XML_PARSE_NOWARNING;
+    }
+    if (options & XML_PARSE_NOERROR) {
+        ctxt->sax->error = NULL;
+        ctxt->sax->fatalError = NULL;
+        options -= XML_PARSE_NOERROR;
+    }
+    if (options & XML_PARSE_PEDANTIC) {
+        ctxt->pedantic = 1;
+        options -= XML_PARSE_PEDANTIC;
+    } else
+        ctxt->pedantic = 0;
+    if (options & XML_PARSE_NOBLANKS) {
+        ctxt->keepBlanks = 0;
+        ctxt->sax->ignorableWhitespace = xmlSAX2IgnorableWhitespace;
+        options -= XML_PARSE_NOBLANKS;
+    } else
+        ctxt->keepBlanks = 1;
+    if (options & XML_PARSE_DTDVALID) {
+        ctxt->validate = 1;
+        if (options & XML_PARSE_NOWARNING)
+            ctxt->vctxt.warning = NULL;
+        if (options & XML_PARSE_NOERROR)
+            ctxt->vctxt.error = NULL;
+        options -= XML_PARSE_DTDVALID;
+    } else
+        ctxt->validate = 0;
+#ifdef LIBXML_SAX1_ENABLED
+    if (options & XML_PARSE_SAX1) {
+        ctxt->sax->startElement = xmlSAX2StartElement;
+        ctxt->sax->endElement = xmlSAX2EndElement;
+        ctxt->sax->startElementNs = NULL;
+        ctxt->sax->endElementNs = NULL;
+        ctxt->sax->initialized = 1;
+        options -= XML_PARSE_SAX1;
+    }
+#endif /* LIBXML_SAX1_ENABLED */
+    if (options & XML_PARSE_NODICT) {
+        ctxt->dictNames = 0;
+        options -= XML_PARSE_NODICT;
+    } else {
+        ctxt->dictNames = 1;
+    }
+    if (options & XML_PARSE_NOCDATA) {
+        ctxt->sax->cdataBlock = NULL;
+        options -= XML_PARSE_NOCDATA;
+    }
+    if (options & XML_PARSE_NSCLEAN) {
+	ctxt->options |= XML_PARSE_NSCLEAN;
+        options -= XML_PARSE_NSCLEAN;
+    }
+    if (options & XML_PARSE_NONET) {
+	ctxt->options |= XML_PARSE_NONET;
+        options -= XML_PARSE_NONET;
+    }
+    ctxt->linenumbers = 1;
+    return (options);
+}
+
+/**
+ * xmlDoRead:
+ * @ctxt:  an XML parser context
+ * @URL:  the base URL to use for the document
+ * @encoding:  the document encoding, or NULL
+ * @options:  a combination of xmlParserOption
+ * @reuse:  keep the context for reuse
+ *
+ * Common front-end for the xmlRead functions
+ * 
+ * Returns the resulting document tree or NULL
+ */
+static xmlDocPtr
+xmlDoRead(xmlParserCtxtPtr ctxt, const char *URL, const char *encoding,
+          int options, int reuse)
+{
+    xmlDocPtr ret;
+    
+    xmlCtxtUseOptions(ctxt, options);
+    if (encoding != NULL) {
+        xmlCharEncodingHandlerPtr hdlr;
+
+	hdlr = xmlFindCharEncodingHandler(encoding);
+	if (hdlr != NULL)
+	    xmlSwitchToEncoding(ctxt, hdlr);
+    }
+    if ((URL != NULL) && (ctxt->input != NULL) &&
+        (ctxt->input->filename == NULL))
+        ctxt->input->filename = (char *) xmlStrdup((const xmlChar *) URL);
+    xmlParseDocument(ctxt);
+    if ((ctxt->wellFormed) || ctxt->recovery)
+        ret = ctxt->myDoc;
+    else {
+        ret = NULL;
+	if (ctxt->myDoc != NULL) {
+	    xmlFreeDoc(ctxt->myDoc);
+	}
+    }
+    ctxt->myDoc = NULL;
+    if (!reuse) {
+	xmlFreeParserCtxt(ctxt);
+    }
+
+    return (ret);
+}
+
+/**
+ * xmlReadDoc:
+ * @cur:  a pointer to a zero terminated string
+ * @URL:  the base URL to use for the document
+ * @encoding:  the document encoding, or NULL
+ * @options:  a combination of xmlParserOption
+ *
+ * parse an XML in-memory document and build a tree.
+ * 
+ * Returns the resulting document tree
+ */
+xmlDocPtr
+xmlReadDoc(const xmlChar * cur, const char *URL, const char *encoding, int options)
+{
+    xmlParserCtxtPtr ctxt;
+
+    if (cur == NULL)
+        return (NULL);
+
+    ctxt = xmlCreateDocParserCtxt(cur);
+    if (ctxt == NULL)
+        return (NULL);
+    return (xmlDoRead(ctxt, URL, encoding, options, 0));
+}
+
+/**
+ * xmlReadFile:
+ * @filename:  a file or URL
+ * @encoding:  the document encoding, or NULL
+ * @options:  a combination of xmlParserOption
+ *
+ * parse an XML file from the filesystem or the network.
+ * 
+ * Returns the resulting document tree
+ */
+xmlDocPtr
+xmlReadFile(const char *filename, const char *encoding, int options)
+{
+    xmlParserCtxtPtr ctxt;
+
+    ctxt = xmlCreateURLParserCtxt(filename, options);
+    if (ctxt == NULL)
+        return (NULL);
+    return (xmlDoRead(ctxt, NULL, encoding, options, 0));
+}
+
+/**
+ * xmlReadMemory:
+ * @buffer:  a pointer to a char array
+ * @size:  the size of the array
+ * @URL:  the base URL to use for the document
+ * @encoding:  the document encoding, or NULL
+ * @options:  a combination of xmlParserOption
+ *
+ * parse an XML in-memory document and build a tree.
+ * 
+ * Returns the resulting document tree
+ */
+xmlDocPtr
+xmlReadMemory(const char *buffer, int size, const char *URL, const char *encoding, int options)
+{
+    xmlParserCtxtPtr ctxt;
+
+    ctxt = xmlCreateMemoryParserCtxt(buffer, size);
+    if (ctxt == NULL)
+        return (NULL);
+    return (xmlDoRead(ctxt, URL, encoding, options, 0));
+}
+
+/**
+ * xmlReadFd:
+ * @fd:  an open file descriptor
+ * @URL:  the base URL to use for the document
+ * @encoding:  the document encoding, or NULL
+ * @options:  a combination of xmlParserOption
+ *
+ * parse an XML from a file descriptor and build a tree.
+ * NOTE that the file descriptor will not be closed when the
+ *      reader is closed or reset.
+ * 
+ * Returns the resulting document tree
+ */
+xmlDocPtr
+xmlReadFd(int fd, const char *URL, const char *encoding, int options)
+{
+    xmlParserCtxtPtr ctxt;
+    xmlParserInputBufferPtr input;
+    xmlParserInputPtr stream;
+
+    if (fd < 0)
+        return (NULL);
+
+    input = xmlParserInputBufferCreateFd(fd, XML_CHAR_ENCODING_NONE);
+    if (input == NULL)
+        return (NULL);
+    input->closecallback = NULL;
+    ctxt = xmlNewParserCtxt();
+    if (ctxt == NULL) {
+        xmlFreeParserInputBuffer(input);
+        return (NULL);
+    }
+    stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
+    if (stream == NULL) {
+        xmlFreeParserInputBuffer(input);
+	xmlFreeParserCtxt(ctxt);
+        return (NULL);
+    }
+    inputPush(ctxt, stream);
+    return (xmlDoRead(ctxt, URL, encoding, options, 0));
+}
+
+/**
+ * xmlReadIO:
+ * @ioread:  an I/O read function
+ * @ioclose:  an I/O close function
+ * @ioctx:  an I/O handler
+ * @URL:  the base URL to use for the document
+ * @encoding:  the document encoding, or NULL
+ * @options:  a combination of xmlParserOption
+ *
+ * parse an XML document from I/O functions and source and build a tree.
+ * 
+ * Returns the resulting document tree
+ */
+xmlDocPtr
+xmlReadIO(xmlInputReadCallback ioread, xmlInputCloseCallback ioclose,
+          void *ioctx, const char *URL, const char *encoding, int options)
+{
+    xmlParserCtxtPtr ctxt;
+    xmlParserInputBufferPtr input;
+    xmlParserInputPtr stream;
+
+    if (ioread == NULL)
+        return (NULL);
+
+    input = xmlParserInputBufferCreateIO(ioread, ioclose, ioctx,
+                                         XML_CHAR_ENCODING_NONE);
+    if (input == NULL)
+        return (NULL);
+    ctxt = xmlNewParserCtxt();
+    if (ctxt == NULL) {
+        xmlFreeParserInputBuffer(input);
+        return (NULL);
+    }
+    stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
+    if (stream == NULL) {
+        xmlFreeParserInputBuffer(input);
+	xmlFreeParserCtxt(ctxt);
+        return (NULL);
+    }
+    inputPush(ctxt, stream);
+    return (xmlDoRead(ctxt, URL, encoding, options, 0));
+}
+
+/**
+ * xmlCtxtReadDoc:
+ * @ctxt:  an XML parser context
+ * @cur:  a pointer to a zero terminated string
+ * @URL:  the base URL to use for the document
+ * @encoding:  the document encoding, or NULL
+ * @options:  a combination of xmlParserOption
+ *
+ * parse an XML in-memory document and build a tree.
+ * This reuses the existing @ctxt parser context
+ * 
+ * Returns the resulting document tree
+ */
+xmlDocPtr
+xmlCtxtReadDoc(xmlParserCtxtPtr ctxt, const xmlChar * cur,
+               const char *URL, const char *encoding, int options)
+{
+    xmlParserInputPtr stream;
+
+    if (cur == NULL)
+        return (NULL);
+    if (ctxt == NULL)
+        return (NULL);
+
+    xmlCtxtReset(ctxt);
+
+    stream = xmlNewStringInputStream(ctxt, cur);
+    if (stream == NULL) {
+        return (NULL);
+    }
+    inputPush(ctxt, stream);
+    return (xmlDoRead(ctxt, URL, encoding, options, 1));
+}
+
+/**
+ * xmlCtxtReadFile:
+ * @ctxt:  an XML parser context
+ * @filename:  a file or URL
+ * @encoding:  the document encoding, or NULL
+ * @options:  a combination of xmlParserOption
+ *
+ * parse an XML file from the filesystem or the network.
+ * This reuses the existing @ctxt parser context
+ * 
+ * Returns the resulting document tree
+ */
+xmlDocPtr
+xmlCtxtReadFile(xmlParserCtxtPtr ctxt, const char *filename,
+                const char *encoding, int options)
+{
+    xmlParserInputPtr stream;
+
+    if (filename == NULL)
+        return (NULL);
+    if (ctxt == NULL)
+        return (NULL);
+
+    xmlCtxtReset(ctxt);
+
+    stream = xmlNewInputFromFile(ctxt, filename);
+    if (stream == NULL) {
+        return (NULL);
+    }
+    inputPush(ctxt, stream);
+    return (xmlDoRead(ctxt, NULL, encoding, options, 1));
+}
+
+/**
+ * xmlCtxtReadMemory:
+ * @ctxt:  an XML parser context
+ * @buffer:  a pointer to a char array
+ * @size:  the size of the array
+ * @URL:  the base URL to use for the document
+ * @encoding:  the document encoding, or NULL
+ * @options:  a combination of xmlParserOption
+ *
+ * parse an XML in-memory document and build a tree.
+ * This reuses the existing @ctxt parser context
+ * 
+ * Returns the resulting document tree
+ */
+xmlDocPtr
+xmlCtxtReadMemory(xmlParserCtxtPtr ctxt, const char *buffer, int size,
+                  const char *URL, const char *encoding, int options)
+{
+    xmlParserInputBufferPtr input;
+    xmlParserInputPtr stream;
+
+    if (ctxt == NULL)
+        return (NULL);
+    if (buffer == NULL)
+        return (NULL);
+
+    xmlCtxtReset(ctxt);
+
+    input = xmlParserInputBufferCreateMem(buffer, size, XML_CHAR_ENCODING_NONE);
+    if (input == NULL) {
+	return(NULL);
+    }
+
+    stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
+    if (stream == NULL) {
+	xmlFreeParserInputBuffer(input);
+	return(NULL);
+    }
+
+    inputPush(ctxt, stream);
+    return (xmlDoRead(ctxt, URL, encoding, options, 1));
+}
+
+/**
+ * xmlCtxtReadFd:
+ * @ctxt:  an XML parser context
+ * @fd:  an open file descriptor
+ * @URL:  the base URL to use for the document
+ * @encoding:  the document encoding, or NULL
+ * @options:  a combination of xmlParserOption
+ *
+ * parse an XML from a file descriptor and build a tree.
+ * This reuses the existing @ctxt parser context
+ * NOTE that the file descriptor will not be closed when the
+ *      reader is closed or reset.
+ * 
+ * Returns the resulting document tree
+ */
+xmlDocPtr
+xmlCtxtReadFd(xmlParserCtxtPtr ctxt, int fd,
+              const char *URL, const char *encoding, int options)
+{
+    xmlParserInputBufferPtr input;
+    xmlParserInputPtr stream;
+
+    if (fd < 0)
+        return (NULL);
+    if (ctxt == NULL)
+        return (NULL);
+
+    xmlCtxtReset(ctxt);
+
+
+    input = xmlParserInputBufferCreateFd(fd, XML_CHAR_ENCODING_NONE);
+    if (input == NULL)
+        return (NULL);
+    input->closecallback = NULL;
+    stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
+    if (stream == NULL) {
+        xmlFreeParserInputBuffer(input);
+        return (NULL);
+    }
+    inputPush(ctxt, stream);
+    return (xmlDoRead(ctxt, URL, encoding, options, 1));
+}
+
+/**
+ * xmlCtxtReadIO:
+ * @ctxt:  an XML parser context
+ * @ioread:  an I/O read function
+ * @ioclose:  an I/O close function
+ * @ioctx:  an I/O handler
+ * @URL:  the base URL to use for the document
+ * @encoding:  the document encoding, or NULL
+ * @options:  a combination of xmlParserOption
+ *
+ * parse an XML document from I/O functions and source and build a tree.
+ * This reuses the existing @ctxt parser context
+ * 
+ * Returns the resulting document tree
+ */
+xmlDocPtr
+xmlCtxtReadIO(xmlParserCtxtPtr ctxt, xmlInputReadCallback ioread,
+              xmlInputCloseCallback ioclose, void *ioctx,
+	      const char *URL,
+              const char *encoding, int options)
+{
+    xmlParserInputBufferPtr input;
+    xmlParserInputPtr stream;
+
+    if (ioread == NULL)
+        return (NULL);
+    if (ctxt == NULL)
+        return (NULL);
+
+    xmlCtxtReset(ctxt);
+
+    input = xmlParserInputBufferCreateIO(ioread, ioclose, ioctx,
+                                         XML_CHAR_ENCODING_NONE);
+    if (input == NULL)
+        return (NULL);
+    stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
+    if (stream == NULL) {
+        xmlFreeParserInputBuffer(input);
+        return (NULL);
+    }
+    inputPush(ctxt, stream);
+    return (xmlDoRead(ctxt, URL, encoding, options, 1));
+}
diff --git a/src/libxml/src/parserInternals.c b/src/libxml/src/parserInternals.c
new file mode 100644
index 0000000..d03e3d4
--- /dev/null
+++ b/src/libxml/src/parserInternals.c
@@ -0,0 +1,2036 @@
+/*
+ * parserInternals.c : Internal routines (and obsolete ones) needed for the
+ *                     XML and HTML parsers.
+ *
+ * See Copyright for the status of this software.
+ *
+ * daniel@veillard.com
+ */
+
+#define IN_LIBXML
+#include "libxml.h"
+
+#if defined(WIN32) && !defined (__CYGWIN__)
+#define XML_DIR_SEP '\\'
+#else
+#define XML_DIR_SEP '/'
+#endif
+
+#include <string.h>
+#ifdef HAVE_CTYPE_H
+#include <ctype.h>
+#endif
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+#ifdef HAVE_SYS_STAT_H
+#include <sys/stat.h>
+#endif
+#ifdef HAVE_FCNTL_H
+#include <fcntl.h>
+#endif
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#ifdef HAVE_ZLIB_H
+#include <zlib.h>
+#endif
+
+#include <libxml/xmlmemory.h>
+#include <libxml/tree.h>
+#include <libxml/parser.h>
+#include <libxml/parserInternals.h>
+#include <libxml/valid.h>
+#include <libxml/entities.h>
+#include <libxml/xmlerror.h>
+#include <libxml/encoding.h>
+#include <libxml/valid.h>
+#include <libxml/xmlIO.h>
+#include <libxml/uri.h>
+#include <libxml/dict.h>
+#include <libxml/SAX.h>
+#ifdef LIBXML_CATALOG_ENABLED
+#include <libxml/catalog.h>
+#endif
+#include <libxml/globals.h>
+#include <libxml/chvalid.h>
+
+/*
+ * Various global defaults for parsing
+ */
+
+/**
+ * xmlCheckVersion:
+ * @version: the include version number
+ *
+ * check the compiled lib version against the include one.
+ * This can warn or immediately kill the application
+ */
+void
+xmlCheckVersion(int version) {
+    int myversion = (int) LIBXML_VERSION;
+
+    xmlInitParser();
+
+    if ((myversion / 10000) != (version / 10000)) {
+	xmlGenericError(xmlGenericErrorContext, 
+		"Fatal: program compiled against libxml %d using libxml %d\n",
+		(version / 10000), (myversion / 10000));
+	fprintf(stderr, 
+		"Fatal: program compiled against libxml %d using libxml %d\n",
+		(version / 10000), (myversion / 10000));
+    }
+    if ((myversion / 100) < (version / 100)) {
+	xmlGenericError(xmlGenericErrorContext, 
+		"Warning: program compiled against libxml %d using older %d\n",
+		(version / 100), (myversion / 100));
+    }
+}
+
+
+/************************************************************************
+ *									*
+ * 		Some factorized error routines				*
+ *									*
+ ************************************************************************/
+
+
+/**
+ * xmlErrMemory:
+ * @ctxt:  an XML parser context
+ * @extra:  extra informations
+ *
+ * Handle a redefinition of attribute error
+ */
+void
+xmlErrMemory(xmlParserCtxtPtr ctxt, const char *extra)
+{
+    if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
+        (ctxt->instate == XML_PARSER_EOF))
+	return;
+    if (ctxt != NULL) {
+        ctxt->errNo = XML_ERR_NO_MEMORY;
+        ctxt->instate = XML_PARSER_EOF;
+        ctxt->disableSAX = 1;
+    }
+    if (extra)
+        __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER,
+                        XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0, extra,
+                        NULL, NULL, 0, 0,
+                        "Memory allocation failed : %s\n", extra);
+    else
+        __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER,
+                        XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0, NULL,
+                        NULL, NULL, 0, 0, "Memory allocation failed\n");
+}
+
+/**
+ * __xmlErrEncoding:
+ * @ctxt:  an XML parser context
+ * @error:  the error number
+ * @msg:  the error message
+ * @str1:  an string info
+ * @str2:  an string info
+ *
+ * Handle an encoding error
+ */
+void
+__xmlErrEncoding(xmlParserCtxtPtr ctxt, xmlParserErrors error,
+                 const char *msg, const xmlChar * str1, const xmlChar * str2)
+{
+    if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
+        (ctxt->instate == XML_PARSER_EOF))
+	return;
+    if (ctxt != NULL)
+        ctxt->errNo = error;
+    __xmlRaiseError(NULL, NULL, NULL,
+                    ctxt, NULL, XML_FROM_PARSER, error, XML_ERR_FATAL,
+                    NULL, 0, (const char *) str1, (const char *) str2,
+                    NULL, 0, 0, msg, str1, str2);
+    if (ctxt != NULL) {
+        ctxt->wellFormed = 0;
+        if (ctxt->recovery == 0)
+            ctxt->disableSAX = 1;
+    }
+}
+
+/**
+ * xmlErrInternal:
+ * @ctxt:  an XML parser context
+ * @msg:  the error message
+ * @str:  error informations
+ *
+ * Handle an internal error
+ */
+static void
+xmlErrInternal(xmlParserCtxtPtr ctxt, const char *msg, const xmlChar * str)
+{
+    if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
+        (ctxt->instate == XML_PARSER_EOF))
+	return;
+    if (ctxt != NULL)
+        ctxt->errNo = XML_ERR_INTERNAL_ERROR;
+    __xmlRaiseError(NULL, NULL, NULL,
+                    ctxt, NULL, XML_FROM_PARSER, XML_ERR_INTERNAL_ERROR,
+                    XML_ERR_FATAL, NULL, 0, (const char *) str, NULL, NULL,
+                    0, 0, msg, str);
+    if (ctxt != NULL) {
+        ctxt->wellFormed = 0;
+        if (ctxt->recovery == 0)
+            ctxt->disableSAX = 1;
+    }
+}
+
+/**
+ * xmlErrEncodingInt:
+ * @ctxt:  an XML parser context
+ * @error:  the error number
+ * @msg:  the error message
+ * @val:  an integer value
+ *
+ * n encoding error
+ */
+static void
+xmlErrEncodingInt(xmlParserCtxtPtr ctxt, xmlParserErrors error,
+                  const char *msg, int val)
+{
+    if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
+        (ctxt->instate == XML_PARSER_EOF))
+	return;
+    if (ctxt != NULL)
+        ctxt->errNo = error;
+    __xmlRaiseError(NULL, NULL, NULL,
+                    ctxt, NULL, XML_FROM_PARSER, error, XML_ERR_FATAL,
+                    NULL, 0, NULL, NULL, NULL, val, 0, msg, val);
+    if (ctxt != NULL) {
+        ctxt->wellFormed = 0;
+        if (ctxt->recovery == 0)
+            ctxt->disableSAX = 1;
+    }
+}
+
+/**
+ * xmlIsLetter:
+ * @c:  an unicode character (int)
+ *
+ * Check whether the character is allowed by the production
+ * [84] Letter ::= BaseChar | Ideographic
+ *
+ * Returns 0 if not, non-zero otherwise
+ */
+int
+xmlIsLetter(int c) {
+    return(IS_BASECHAR(c) || IS_IDEOGRAPHIC(c));
+}
+
+/************************************************************************
+ *									*
+ * 		Input handling functions for progressive parsing	*
+ *									*
+ ************************************************************************/
+
+/* #define DEBUG_INPUT */
+/* #define DEBUG_STACK */
+/* #define DEBUG_PUSH */
+
+
+/* we need to keep enough input to show errors in context */
+#define LINE_LEN        80
+
+#ifdef DEBUG_INPUT
+#define CHECK_BUFFER(in) check_buffer(in)
+
+static
+void check_buffer(xmlParserInputPtr in) {
+    if (in->base != in->buf->buffer->content) {
+        xmlGenericError(xmlGenericErrorContext,
+		"xmlParserInput: base mismatch problem\n");
+    }
+    if (in->cur < in->base) {
+        xmlGenericError(xmlGenericErrorContext,
+		"xmlParserInput: cur < base problem\n");
+    }
+    if (in->cur > in->base + in->buf->buffer->use) {
+        xmlGenericError(xmlGenericErrorContext,
+		"xmlParserInput: cur > base + use problem\n");
+    }
+    xmlGenericError(xmlGenericErrorContext,"buffer %x : content %x, cur %d, use %d, size %d\n",
+            (int) in, (int) in->buf->buffer->content, in->cur - in->base,
+	    in->buf->buffer->use, in->buf->buffer->size);
+}
+
+#else
+#define CHECK_BUFFER(in) 
+#endif
+
+
+/**
+ * xmlParserInputRead:
+ * @in:  an XML parser input
+ * @len:  an indicative size for the lookahead
+ *
+ * This function refresh the input for the parser. It doesn't try to
+ * preserve pointers to the input buffer, and discard already read data
+ *
+ * Returns the number of xmlChars read, or -1 in case of error, 0 indicate the
+ * end of this entity
+ */
+int
+xmlParserInputRead(xmlParserInputPtr in, int len) {
+    int ret;
+    int used;
+    int indx;
+
+#ifdef DEBUG_INPUT
+    xmlGenericError(xmlGenericErrorContext, "Read\n");
+#endif
+    if (in->buf == NULL) return(-1);
+    if (in->base == NULL) return(-1);
+    if (in->cur == NULL) return(-1);
+    if (in->buf->buffer == NULL) return(-1);
+    if (in->buf->readcallback == NULL) return(-1);
+
+    CHECK_BUFFER(in);
+
+    used = in->cur - in->buf->buffer->content;
+    ret = xmlBufferShrink(in->buf->buffer, used);
+    if (ret > 0) {
+	in->cur -= ret;
+	in->consumed += ret;
+    }
+    ret = xmlParserInputBufferRead(in->buf, len);
+    if (in->base != in->buf->buffer->content) {
+        /*
+	 * the buffer has been reallocated
+	 */
+	indx = in->cur - in->base;
+	in->base = in->buf->buffer->content;
+	in->cur = &in->buf->buffer->content[indx];
+    }
+    in->end = &in->buf->buffer->content[in->buf->buffer->use];
+
+    CHECK_BUFFER(in);
+
+    return(ret);
+}
+
+/**
+ * xmlParserInputGrow:
+ * @in:  an XML parser input
+ * @len:  an indicative size for the lookahead
+ *
+ * This function increase the input for the parser. It tries to
+ * preserve pointers to the input buffer, and keep already read data
+ *
+ * Returns the number of xmlChars read, or -1 in case of error, 0 indicate the
+ * end of this entity
+ */
+int
+xmlParserInputGrow(xmlParserInputPtr in, int len) {
+    int ret;
+    int indx;
+
+#ifdef DEBUG_INPUT
+    xmlGenericError(xmlGenericErrorContext, "Grow\n");
+#endif
+    if (in->buf == NULL) return(-1);
+    if (in->base == NULL) return(-1);
+    if (in->cur == NULL) return(-1);
+    if (in->buf->buffer == NULL) return(-1);
+
+    CHECK_BUFFER(in);
+
+    indx = in->cur - in->base;
+    if (in->buf->buffer->use > (unsigned int) indx + INPUT_CHUNK) {
+
+	CHECK_BUFFER(in);
+
+        return(0);
+    }
+    if (in->buf->readcallback != NULL)
+	ret = xmlParserInputBufferGrow(in->buf, len);
+    else	
+        return(0);
+
+    /*
+     * NOTE : in->base may be a "dangling" i.e. freed pointer in this
+     *        block, but we use it really as an integer to do some
+     *        pointer arithmetic. Insure will raise it as a bug but in
+     *        that specific case, that's not !
+     */
+    if (in->base != in->buf->buffer->content) {
+        /*
+	 * the buffer has been reallocated
+	 */
+	indx = in->cur - in->base;
+	in->base = in->buf->buffer->content;
+	in->cur = &in->buf->buffer->content[indx];
+    }
+    in->end = &in->buf->buffer->content[in->buf->buffer->use];
+
+    CHECK_BUFFER(in);
+
+    return(ret);
+}
+
+/**
+ * xmlParserInputShrink:
+ * @in:  an XML parser input
+ *
+ * This function removes used input for the parser.
+ */
+void
+xmlParserInputShrink(xmlParserInputPtr in) {
+    int used;
+    int ret;
+    int indx;
+
+#ifdef DEBUG_INPUT
+    xmlGenericError(xmlGenericErrorContext, "Shrink\n");
+#endif
+    if (in->buf == NULL) return;
+    if (in->base == NULL) return;
+    if (in->cur == NULL) return;
+    if (in->buf->buffer == NULL) return;
+
+    CHECK_BUFFER(in);
+
+    used = in->cur - in->buf->buffer->content;
+    /*
+     * Do not shrink on large buffers whose only a tiny fraction
+     * was consumed
+     */
+    if (used > INPUT_CHUNK) {
+	ret = xmlBufferShrink(in->buf->buffer, used - LINE_LEN);
+	if (ret > 0) {
+	    in->cur -= ret;
+	    in->consumed += ret;
+	}
+	in->end = &in->buf->buffer->content[in->buf->buffer->use];
+    }
+
+    CHECK_BUFFER(in);
+
+    if (in->buf->buffer->use > INPUT_CHUNK) {
+        return;
+    }
+    xmlParserInputBufferRead(in->buf, 2 * INPUT_CHUNK);
+    if (in->base != in->buf->buffer->content) {
+        /*
+	 * the buffer has been reallocated
+	 */
+	indx = in->cur - in->base;
+	in->base = in->buf->buffer->content;
+	in->cur = &in->buf->buffer->content[indx];
+    }
+    in->end = &in->buf->buffer->content[in->buf->buffer->use];
+
+    CHECK_BUFFER(in);
+}
+
+/************************************************************************
+ *									*
+ * 		UTF8 character input and related functions		*
+ *									*
+ ************************************************************************/
+
+/**
+ * xmlNextChar:
+ * @ctxt:  the XML parser context
+ *
+ * Skip to the next char input char.
+ */
+
+void
+xmlNextChar(xmlParserCtxtPtr ctxt)
+{
+    if (ctxt->instate == XML_PARSER_EOF)
+        return;
+
+    if (ctxt->charset == XML_CHAR_ENCODING_UTF8) {
+        if ((*ctxt->input->cur == 0) &&
+            (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0) &&
+            (ctxt->instate != XML_PARSER_COMMENT)) {
+            /*
+             * If we are at the end of the current entity and
+             * the context allows it, we pop consumed entities
+             * automatically.
+             * the auto closing should be blocked in other cases
+             */
+            xmlPopInput(ctxt);
+        } else {
+            const unsigned char *cur;
+            unsigned char c;
+
+            /*
+             *   2.11 End-of-Line Handling
+             *   the literal two-character sequence "#xD#xA" or a standalone
+             *   literal #xD, an XML processor must pass to the application
+             *   the single character #xA.
+             */
+            if (*(ctxt->input->cur) == '\n') {
+                ctxt->input->line++;
+                ctxt->input->col = 1;
+            } else
+                ctxt->input->col++;
+
+            /*
+             * We are supposed to handle UTF8, check it's valid
+             * From rfc2044: encoding of the Unicode values on UTF-8:
+             *
+             * UCS-4 range (hex.)           UTF-8 octet sequence (binary)
+             * 0000 0000-0000 007F   0xxxxxxx
+             * 0000 0080-0000 07FF   110xxxxx 10xxxxxx
+             * 0000 0800-0000 FFFF   1110xxxx 10xxxxxx 10xxxxxx 
+             *
+             * Check for the 0x110000 limit too
+             */
+            cur = ctxt->input->cur;
+
+            c = *cur;
+            if (c & 0x80) {
+	        if (c == 0xC0)
+		    goto encoding_error;
+                if (cur[1] == 0)
+                    xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
+                if ((cur[1] & 0xc0) != 0x80)
+                    goto encoding_error;
+                if ((c & 0xe0) == 0xe0) {
+                    unsigned int val;
+
+                    if (cur[2] == 0)
+                        xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
+                    if ((cur[2] & 0xc0) != 0x80)
+                        goto encoding_error;
+                    if ((c & 0xf0) == 0xf0) {
+                        if (cur[3] == 0)
+                            xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
+                        if (((c & 0xf8) != 0xf0) ||
+                            ((cur[3] & 0xc0) != 0x80))
+                            goto encoding_error;
+                        /* 4-byte code */
+                        ctxt->input->cur += 4;
+                        val = (cur[0] & 0x7) << 18;
+                        val |= (cur[1] & 0x3f) << 12;
+                        val |= (cur[2] & 0x3f) << 6;
+                        val |= cur[3] & 0x3f;
+                    } else {
+                        /* 3-byte code */
+                        ctxt->input->cur += 3;
+                        val = (cur[0] & 0xf) << 12;
+                        val |= (cur[1] & 0x3f) << 6;
+                        val |= cur[2] & 0x3f;
+                    }
+                    if (((val > 0xd7ff) && (val < 0xe000)) ||
+                        ((val > 0xfffd) && (val < 0x10000)) ||
+                        (val >= 0x110000)) {
+			xmlErrEncodingInt(ctxt, XML_ERR_INVALID_CHAR,
+					  "Char 0x%X out of allowed range\n",
+					  val);
+                    }
+                } else
+                    /* 2-byte code */
+                    ctxt->input->cur += 2;
+            } else
+                /* 1-byte code */
+                ctxt->input->cur++;
+
+            ctxt->nbChars++;
+            if (*ctxt->input->cur == 0)
+                xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
+        }
+    } else {
+        /*
+         * Assume it's a fixed length encoding (1) with
+         * a compatible encoding for the ASCII set, since
+         * XML constructs only use < 128 chars
+         */
+
+        if (*(ctxt->input->cur) == '\n') {
+            ctxt->input->line++;
+            ctxt->input->col = 1;
+        } else
+            ctxt->input->col++;
+        ctxt->input->cur++;
+        ctxt->nbChars++;
+        if (*ctxt->input->cur == 0)
+            xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
+    }
+    if ((*ctxt->input->cur == '%') && (!ctxt->html))
+        xmlParserHandlePEReference(ctxt);
+    if ((*ctxt->input->cur == 0) &&
+        (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0))
+        xmlPopInput(ctxt);
+    return;
+encoding_error:
+    /*
+     * If we detect an UTF8 error that probably mean that the
+     * input encoding didn't get properly advertised in the
+     * declaration header. Report the error and switch the encoding
+     * to ISO-Latin-1 (if you don't like this policy, just declare the
+     * encoding !)
+     */
+    __xmlErrEncoding(ctxt, XML_ERR_INVALID_CHAR,
+		   "Input is not proper UTF-8, indicate encoding !\n",
+		   NULL, NULL);
+    if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL)) {
+        ctxt->sax->error(ctxt->userData,
+                         "Bytes: 0x%02X 0x%02X 0x%02X 0x%02X\n",
+                         ctxt->input->cur[0], ctxt->input->cur[1],
+                         ctxt->input->cur[2], ctxt->input->cur[3]);
+    }
+    ctxt->charset = XML_CHAR_ENCODING_8859_1;
+    ctxt->input->cur++;
+    return;
+}
+
+/**
+ * xmlCurrentChar:
+ * @ctxt:  the XML parser context
+ * @len:  pointer to the length of the char read
+ *
+ * The current char value, if using UTF-8 this may actually span multiple
+ * bytes in the input buffer. Implement the end of line normalization:
+ * 2.11 End-of-Line Handling
+ * Wherever an external parsed entity or the literal entity value
+ * of an internal parsed entity contains either the literal two-character
+ * sequence "#xD#xA" or a standalone literal #xD, an XML processor
+ * must pass to the application the single character #xA.
+ * This behavior can conveniently be produced by normalizing all
+ * line breaks to #xA on input, before parsing.)
+ *
+ * Returns the current char value and its length
+ */
+
+int
+xmlCurrentChar(xmlParserCtxtPtr ctxt, int *len) {
+    if (ctxt->instate == XML_PARSER_EOF)
+	return(0);
+
+    if ((*ctxt->input->cur >= 0x20) && (*ctxt->input->cur <= 0x7F)) {
+	    *len = 1;
+	    return((int) *ctxt->input->cur);
+    }
+    if (ctxt->charset == XML_CHAR_ENCODING_UTF8) {
+	/*
+	 * We are supposed to handle UTF8, check it's valid
+	 * From rfc2044: encoding of the Unicode values on UTF-8:
+	 *
+	 * UCS-4 range (hex.)           UTF-8 octet sequence (binary)
+	 * 0000 0000-0000 007F   0xxxxxxx
+	 * 0000 0080-0000 07FF   110xxxxx 10xxxxxx
+	 * 0000 0800-0000 FFFF   1110xxxx 10xxxxxx 10xxxxxx 
+	 *
+	 * Check for the 0x110000 limit too
+	 */
+	const unsigned char *cur = ctxt->input->cur;
+	unsigned char c;
+	unsigned int val;
+
+	c = *cur;
+	if (c & 0x80) {
+	    if (c == 0xC0)
+		goto encoding_error;
+	    if (cur[1] == 0)
+		xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
+	    if ((cur[1] & 0xc0) != 0x80)
+		goto encoding_error;
+	    if ((c & 0xe0) == 0xe0) {
+
+		if (cur[2] == 0)
+		    xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
+		if ((cur[2] & 0xc0) != 0x80)
+		    goto encoding_error;
+		if ((c & 0xf0) == 0xf0) {
+		    if (cur[3] == 0)
+			xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
+		    if (((c & 0xf8) != 0xf0) ||
+			((cur[3] & 0xc0) != 0x80))
+			goto encoding_error;
+		    /* 4-byte code */
+		    *len = 4;
+		    val = (cur[0] & 0x7) << 18;
+		    val |= (cur[1] & 0x3f) << 12;
+		    val |= (cur[2] & 0x3f) << 6;
+		    val |= cur[3] & 0x3f;
+		} else {
+		  /* 3-byte code */
+		    *len = 3;
+		    val = (cur[0] & 0xf) << 12;
+		    val |= (cur[1] & 0x3f) << 6;
+		    val |= cur[2] & 0x3f;
+		}
+	    } else {
+	      /* 2-byte code */
+		*len = 2;
+		val = (cur[0] & 0x1f) << 6;
+		val |= cur[1] & 0x3f;
+	    }
+	    if (!IS_CHAR(val)) {
+	        xmlErrEncodingInt(ctxt, XML_ERR_INVALID_CHAR,
+				  "Char 0x%X out of allowed range\n", val);
+	    }    
+	    return(val);
+	} else {
+	    /* 1-byte code */
+	    *len = 1;
+	    if (*ctxt->input->cur == 0xD) {
+		if (ctxt->input->cur[1] == 0xA) {
+		    ctxt->nbChars++;
+		    ctxt->input->cur++;
+		}
+		return(0xA);
+	    }
+	    return((int) *ctxt->input->cur);
+	}
+    }
+    /*
+     * Assume it's a fixed length encoding (1) with
+     * a compatible encoding for the ASCII set, since
+     * XML constructs only use < 128 chars
+     */
+    *len = 1;
+    if (*ctxt->input->cur == 0xD) {
+	if (ctxt->input->cur[1] == 0xA) {
+	    ctxt->nbChars++;
+	    ctxt->input->cur++;
+	}
+	return(0xA);
+    }
+    return((int) *ctxt->input->cur);
+encoding_error:
+    /*
+     * An encoding problem may arise from a truncated input buffer
+     * splitting a character in the middle. In that case do not raise
+     * an error but return 0 to endicate an end of stream problem
+     */
+    if (ctxt->input->end - ctxt->input->cur < 4) {
+	*len = 0;
+	return(0);
+    }
+
+    /*
+     * If we detect an UTF8 error that probably mean that the
+     * input encoding didn't get properly advertised in the
+     * declaration header. Report the error and switch the encoding
+     * to ISO-Latin-1 (if you don't like this policy, just declare the
+     * encoding !)
+     */
+    __xmlErrEncoding(ctxt, XML_ERR_INVALID_CHAR,
+		   "Input is not proper UTF-8, indicate encoding !\n",
+		   NULL, NULL);
+    if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL)) {
+	ctxt->sax->error(ctxt->userData, "Bytes: 0x%02X 0x%02X 0x%02X 0x%02X\n",
+			ctxt->input->cur[0], ctxt->input->cur[1],
+			ctxt->input->cur[2], ctxt->input->cur[3]);
+    }
+    ctxt->charset = XML_CHAR_ENCODING_8859_1; 
+    *len = 1;
+    return((int) *ctxt->input->cur);
+}
+
+/**
+ * xmlStringCurrentChar:
+ * @ctxt:  the XML parser context
+ * @cur:  pointer to the beginning of the char
+ * @len:  pointer to the length of the char read
+ *
+ * The current char value, if using UTF-8 this may actually span multiple
+ * bytes in the input buffer.
+ *
+ * Returns the current char value and its length
+ */
+
+int
+xmlStringCurrentChar(xmlParserCtxtPtr ctxt, const xmlChar * cur, int *len)
+{
+    if ((ctxt == NULL) || (ctxt->charset == XML_CHAR_ENCODING_UTF8)) {
+        /*
+         * We are supposed to handle UTF8, check it's valid
+         * From rfc2044: encoding of the Unicode values on UTF-8:
+         *
+         * UCS-4 range (hex.)           UTF-8 octet sequence (binary)
+         * 0000 0000-0000 007F   0xxxxxxx
+         * 0000 0080-0000 07FF   110xxxxx 10xxxxxx
+         * 0000 0800-0000 FFFF   1110xxxx 10xxxxxx 10xxxxxx 
+         *
+         * Check for the 0x110000 limit too
+         */
+        unsigned char c;
+        unsigned int val;
+
+        c = *cur;
+        if (c & 0x80) {
+            if ((cur[1] & 0xc0) != 0x80)
+                goto encoding_error;
+            if ((c & 0xe0) == 0xe0) {
+
+                if ((cur[2] & 0xc0) != 0x80)
+                    goto encoding_error;
+                if ((c & 0xf0) == 0xf0) {
+                    if (((c & 0xf8) != 0xf0) || ((cur[3] & 0xc0) != 0x80))
+                        goto encoding_error;
+                    /* 4-byte code */
+                    *len = 4;
+                    val = (cur[0] & 0x7) << 18;
+                    val |= (cur[1] & 0x3f) << 12;
+                    val |= (cur[2] & 0x3f) << 6;
+                    val |= cur[3] & 0x3f;
+                } else {
+                    /* 3-byte code */
+                    *len = 3;
+                    val = (cur[0] & 0xf) << 12;
+                    val |= (cur[1] & 0x3f) << 6;
+                    val |= cur[2] & 0x3f;
+                }
+            } else {
+                /* 2-byte code */
+                *len = 2;
+                val = (cur[0] & 0x1f) << 6;
+                val |= cur[1] & 0x3f;
+            }
+            if (!IS_CHAR(val)) {
+	        xmlErrEncodingInt(ctxt, XML_ERR_INVALID_CHAR,
+				  "Char 0x%X out of allowed range\n", val);
+            }
+            return (val);
+        } else {
+            /* 1-byte code */
+            *len = 1;
+            return ((int) *cur);
+        }
+    }
+    /*
+     * Assume it's a fixed length encoding (1) with
+     * a compatible encoding for the ASCII set, since
+     * XML constructs only use < 128 chars
+     */
+    *len = 1;
+    return ((int) *cur);
+encoding_error:
+
+    /*
+     * If we detect an UTF8 error that probably mean that the
+     * input encoding didn't get properly advertised in the
+     * declaration header. Report the error and switch the encoding
+     * to ISO-Latin-1 (if you don't like this policy, just declare the
+     * encoding !)
+     */
+    __xmlErrEncoding(ctxt, XML_ERR_INVALID_CHAR,
+		   "Input is not proper UTF-8, indicate encoding !\n",
+		   NULL, NULL);
+    if ((ctxt != NULL) && (ctxt->sax != NULL) && (ctxt->sax->error != NULL)) {
+	ctxt->sax->error(ctxt->userData,
+			 "Bytes: 0x%02X 0x%02X 0x%02X 0x%02X\n",
+			 ctxt->input->cur[0], ctxt->input->cur[1],
+			 ctxt->input->cur[2], ctxt->input->cur[3]);
+    }
+    *len = 1;
+    return ((int) *cur);
+}
+
+/**
+ * xmlCopyCharMultiByte:
+ * @out:  pointer to an array of xmlChar
+ * @val:  the char value
+ *
+ * append the char value in the array 
+ *
+ * Returns the number of xmlChar written
+ */
+int
+xmlCopyCharMultiByte(xmlChar *out, int val) {
+    /*
+     * We are supposed to handle UTF8, check it's valid
+     * From rfc2044: encoding of the Unicode values on UTF-8:
+     *
+     * UCS-4 range (hex.)           UTF-8 octet sequence (binary)
+     * 0000 0000-0000 007F   0xxxxxxx
+     * 0000 0080-0000 07FF   110xxxxx 10xxxxxx
+     * 0000 0800-0000 FFFF   1110xxxx 10xxxxxx 10xxxxxx 
+     */
+    if  (val >= 0x80) {
+	xmlChar *savedout = out;
+	int bits;
+	if (val <   0x800) { *out++= (val >>  6) | 0xC0;  bits=  0; }
+	else if (val < 0x10000) { *out++= (val >> 12) | 0xE0;  bits=  6;}
+	else if (val < 0x110000)  { *out++= (val >> 18) | 0xF0;  bits=  12; }
+	else {
+	    xmlErrEncodingInt(NULL, XML_ERR_INVALID_CHAR,
+		    "Internal error, xmlCopyCharMultiByte 0x%X out of bound\n",
+			      val);
+	    return(0);
+	}
+	for ( ; bits >= 0; bits-= 6)
+	    *out++= ((val >> bits) & 0x3F) | 0x80 ;
+	return (out - savedout);
+    }
+    *out = (xmlChar) val;
+    return 1;
+}
+
+/**
+ * xmlCopyChar:
+ * @len:  Ignored, compatibility
+ * @out:  pointer to an array of xmlChar
+ * @val:  the char value
+ *
+ * append the char value in the array 
+ *
+ * Returns the number of xmlChar written
+ */
+
+int
+xmlCopyChar(int len ATTRIBUTE_UNUSED, xmlChar *out, int val) {
+    /* the len parameter is ignored */
+    if  (val >= 0x80) {
+	return(xmlCopyCharMultiByte (out, val));
+    }
+    *out = (xmlChar) val;
+    return 1;
+}
+
+/************************************************************************
+ *									*
+ *		Commodity functions to switch encodings			*
+ *									*
+ ************************************************************************/
+
+/**
+ * xmlSwitchEncoding:
+ * @ctxt:  the parser context
+ * @enc:  the encoding value (number)
+ *
+ * change the input functions when discovering the character encoding
+ * of a given entity.
+ *
+ * Returns 0 in case of success, -1 otherwise
+ */
+int
+xmlSwitchEncoding(xmlParserCtxtPtr ctxt, xmlCharEncoding enc)
+{
+    xmlCharEncodingHandlerPtr handler;
+
+    switch (enc) {
+	case XML_CHAR_ENCODING_ERROR:
+	    __xmlErrEncoding(ctxt, XML_ERR_UNKNOWN_ENCODING,
+	                   "encoding unknown\n", NULL, NULL);
+	    break;
+	case XML_CHAR_ENCODING_NONE:
+	    /* let's assume it's UTF-8 without the XML decl */
+	    ctxt->charset = XML_CHAR_ENCODING_UTF8;
+	    return(0);
+	case XML_CHAR_ENCODING_UTF8:
+	    /* default encoding, no conversion should be needed */
+	    ctxt->charset = XML_CHAR_ENCODING_UTF8;
+
+	    /*
+	     * Errata on XML-1.0 June 20 2001
+	     * Specific handling of the Byte Order Mark for
+	     * UTF-8
+	     */
+	    if ((ctxt->input != NULL) &&
+		(ctxt->input->cur[0] == 0xEF) &&
+		(ctxt->input->cur[1] == 0xBB) &&
+		(ctxt->input->cur[2] == 0xBF)) {
+		ctxt->input->cur += 3;
+	    }
+	    return(0);
+    case XML_CHAR_ENCODING_UTF16LE:
+    case XML_CHAR_ENCODING_UTF16BE:
+        /*The raw input characters are encoded
+         *in UTF-16. As we expect this function
+         *to be called after xmlCharEncInFunc, we expect
+         *ctxt->input->cur to contain UTF-8 encoded characters.
+         *So the raw UTF16 Byte Order Mark
+         *has also been converted into
+         *an UTF-8 BOM. Let's skip that BOM.
+         */
+        if ((ctxt->input != NULL) &&
+            (ctxt->input->cur[0] == 0xEF) &&
+            (ctxt->input->cur[1] == 0xBB) &&
+            (ctxt->input->cur[2] == 0xBF)) {
+            ctxt->input->cur += 3;
+        }
+	break ;
+	default:
+	    break;
+    }
+    handler = xmlGetCharEncodingHandler(enc);
+    if (handler == NULL) {
+	/*
+	 * Default handlers.
+	 */
+	switch (enc) {
+	    case XML_CHAR_ENCODING_ERROR:
+		__xmlErrEncoding(ctxt, XML_ERR_UNKNOWN_ENCODING,
+			       "encoding unknown\n", NULL, NULL);
+		break;
+	    case XML_CHAR_ENCODING_NONE:
+		/* let's assume it's UTF-8 without the XML decl */
+		ctxt->charset = XML_CHAR_ENCODING_UTF8;
+		return(0);
+	    case XML_CHAR_ENCODING_UTF8:
+	    case XML_CHAR_ENCODING_ASCII:
+		/* default encoding, no conversion should be needed */
+		ctxt->charset = XML_CHAR_ENCODING_UTF8;
+		return(0);
+	    case XML_CHAR_ENCODING_UTF16LE:
+		break;
+	    case XML_CHAR_ENCODING_UTF16BE:
+		break;
+	    case XML_CHAR_ENCODING_UCS4LE:
+		__xmlErrEncoding(ctxt, XML_ERR_UNSUPPORTED_ENCODING,
+			       "encoding not supported %s\n",
+			       BAD_CAST "USC4 little endian", NULL);
+		break;
+	    case XML_CHAR_ENCODING_UCS4BE:
+		__xmlErrEncoding(ctxt, XML_ERR_UNSUPPORTED_ENCODING,
+			       "encoding not supported %s\n",
+			       BAD_CAST "USC4 big endian", NULL);
+		break;
+	    case XML_CHAR_ENCODING_EBCDIC:
+		__xmlErrEncoding(ctxt, XML_ERR_UNSUPPORTED_ENCODING,
+			       "encoding not supported %s\n",
+			       BAD_CAST "EBCDIC", NULL);
+		break;
+	    case XML_CHAR_ENCODING_UCS4_2143:
+		__xmlErrEncoding(ctxt, XML_ERR_UNSUPPORTED_ENCODING,
+			       "encoding not supported %s\n",
+			       BAD_CAST "UCS4 2143", NULL);
+		break;
+	    case XML_CHAR_ENCODING_UCS4_3412:
+		__xmlErrEncoding(ctxt, XML_ERR_UNSUPPORTED_ENCODING,
+			       "encoding not supported %s\n",
+			       BAD_CAST "UCS4 3412", NULL);
+		break;
+	    case XML_CHAR_ENCODING_UCS2:
+		__xmlErrEncoding(ctxt, XML_ERR_UNSUPPORTED_ENCODING,
+			       "encoding not supported %s\n",
+			       BAD_CAST "UCS2", NULL);
+		break;
+	    case XML_CHAR_ENCODING_8859_1:
+	    case XML_CHAR_ENCODING_8859_2:
+	    case XML_CHAR_ENCODING_8859_3:
+	    case XML_CHAR_ENCODING_8859_4:
+	    case XML_CHAR_ENCODING_8859_5:
+	    case XML_CHAR_ENCODING_8859_6:
+	    case XML_CHAR_ENCODING_8859_7:
+	    case XML_CHAR_ENCODING_8859_8:
+	    case XML_CHAR_ENCODING_8859_9:
+		/*
+		 * We used to keep the internal content in the
+		 * document encoding however this turns being unmaintainable
+		 * So xmlGetCharEncodingHandler() will return non-null
+		 * values for this now.
+		 */
+		if ((ctxt->inputNr == 1) &&
+		    (ctxt->encoding == NULL) &&
+		    (ctxt->input->encoding != NULL)) {
+		    ctxt->encoding = xmlStrdup(ctxt->input->encoding);
+		}
+		ctxt->charset = enc;
+		return(0);
+	    case XML_CHAR_ENCODING_2022_JP:
+		__xmlErrEncoding(ctxt, XML_ERR_UNSUPPORTED_ENCODING,
+			       "encoding not supported %s\n",
+			       BAD_CAST "ISO-2022-JP", NULL);
+		break;
+	    case XML_CHAR_ENCODING_SHIFT_JIS:
+		__xmlErrEncoding(ctxt, XML_ERR_UNSUPPORTED_ENCODING,
+			       "encoding not supported %s\n",
+			       BAD_CAST "Shift_JIS", NULL);
+		break;
+	    case XML_CHAR_ENCODING_EUC_JP:
+		__xmlErrEncoding(ctxt, XML_ERR_UNSUPPORTED_ENCODING,
+			       "encoding not supported %s\n",
+			       BAD_CAST "EUC-JP", NULL);
+		break;
+	}
+    }
+    if (handler == NULL)
+	return(-1);
+    ctxt->charset = XML_CHAR_ENCODING_UTF8;
+    return(xmlSwitchToEncoding(ctxt, handler));
+}
+
+/**
+ * xmlSwitchInputEncoding:
+ * @ctxt:  the parser context
+ * @input:  the input stream
+ * @handler:  the encoding handler
+ *
+ * change the input functions when discovering the character encoding
+ * of a given entity.
+ *
+ * Returns 0 in case of success, -1 otherwise
+ */
+int
+xmlSwitchInputEncoding(xmlParserCtxtPtr ctxt, xmlParserInputPtr input,
+                       xmlCharEncodingHandlerPtr handler)
+{
+    int nbchars;
+
+    if (handler == NULL)
+        return (-1);
+    if (input == NULL)
+        return (-1);
+    if (input->buf != NULL) {
+        if (input->buf->encoder != NULL) {
+            /*
+             * Check in case the auto encoding detetection triggered
+             * in already.
+             */
+            if (input->buf->encoder == handler)
+                return (0);
+
+            /*
+             * "UTF-16" can be used for both LE and BE
+             if ((!xmlStrncmp(BAD_CAST input->buf->encoder->name,
+             BAD_CAST "UTF-16", 6)) &&
+             (!xmlStrncmp(BAD_CAST handler->name,
+             BAD_CAST "UTF-16", 6))) {
+             return(0);
+             }
+             */
+
+            /*
+             * Note: this is a bit dangerous, but that's what it
+             * takes to use nearly compatible signature for different
+             * encodings.
+             */
+            xmlCharEncCloseFunc(input->buf->encoder);
+            input->buf->encoder = handler;
+            return (0);
+        }
+        input->buf->encoder = handler;
+
+        /*
+         * Is there already some content down the pipe to convert ?
+         */
+        if ((input->buf->buffer != NULL) && (input->buf->buffer->use > 0)) {
+            int processed;
+	    unsigned int use;
+
+            /*
+             * Specific handling of the Byte Order Mark for 
+             * UTF-16
+             */
+            if ((handler->name != NULL) &&
+                (!strcmp(handler->name, "UTF-16LE")) &&
+                (input->cur[0] == 0xFF) && (input->cur[1] == 0xFE)) {
+                input->cur += 2;
+            }
+            if ((handler->name != NULL) &&
+                (!strcmp(handler->name, "UTF-16BE")) &&
+                (input->cur[0] == 0xFE) && (input->cur[1] == 0xFF)) {
+                input->cur += 2;
+            }
+            /*
+             * Errata on XML-1.0 June 20 2001
+             * Specific handling of the Byte Order Mark for
+             * UTF-8
+             */
+            if ((handler->name != NULL) &&
+                (!strcmp(handler->name, "UTF-8")) &&
+                (input->cur[0] == 0xEF) &&
+                (input->cur[1] == 0xBB) && (input->cur[2] == 0xBF)) {
+                input->cur += 3;
+            }
+
+            /*
+             * Shrink the current input buffer.
+             * Move it as the raw buffer and create a new input buffer
+             */
+            processed = input->cur - input->base;
+            xmlBufferShrink(input->buf->buffer, processed);
+            input->buf->raw = input->buf->buffer;
+            input->buf->buffer = xmlBufferCreate();
+	    input->buf->rawconsumed = processed;
+	    use = input->buf->raw->use;
+
+            if (ctxt->html) {
+                /*
+                 * convert as much as possible of the buffer
+                 */
+                nbchars = xmlCharEncInFunc(input->buf->encoder,
+                                           input->buf->buffer,
+                                           input->buf->raw);
+            } else {
+                /*
+                 * convert just enough to get
+                 * '<?xml version="1.0" encoding="xxx"?>'
+                 * parsed with the autodetected encoding
+                 * into the parser reading buffer.
+                 */
+                nbchars = xmlCharEncFirstLine(input->buf->encoder,
+                                              input->buf->buffer,
+                                              input->buf->raw);
+            }
+            if (nbchars < 0) {
+                xmlErrInternal(ctxt,
+                               "switching encoding: encoder error\n",
+                               NULL);
+                return (-1);
+            }
+	    input->buf->rawconsumed += use - input->buf->raw->use;
+            input->base = input->cur = input->buf->buffer->content;
+            input->end = &input->base[input->buf->buffer->use];
+
+        }
+        return (0);
+    } else {
+        if ((input->length == 0) || (input->buf == NULL)) {
+            /*
+             * When parsing a static memory array one must know the
+             * size to be able to convert the buffer.
+             */
+            xmlErrInternal(ctxt, "switching encoding : no input\n", NULL);
+            return (-1);
+        } else {
+            int processed;
+
+            /*
+             * Shrink the current input buffer.
+             * Move it as the raw buffer and create a new input buffer
+             */
+            processed = input->cur - input->base;
+
+            input->buf->raw = xmlBufferCreate();
+            xmlBufferAdd(input->buf->raw, input->cur,
+                         input->length - processed);
+            input->buf->buffer = xmlBufferCreate();
+
+            /*
+             * convert as much as possible of the raw input
+             * to the parser reading buffer.
+             */
+            nbchars = xmlCharEncInFunc(input->buf->encoder,
+                                       input->buf->buffer,
+                                       input->buf->raw);
+            if (nbchars < 0) {
+                xmlErrInternal(ctxt,
+                               "switching encoding: encoder error\n",
+                               NULL);
+                return (-1);
+            }
+
+            /*
+             * Conversion succeeded, get rid of the old buffer
+             */
+            if ((input->free != NULL) && (input->base != NULL))
+                input->free((xmlChar *) input->base);
+            input->base = input->cur = input->buf->buffer->content;
+            input->end = &input->base[input->buf->buffer->use];
+        }
+    }
+    return (0);
+}
+
+/**
+ * xmlSwitchToEncoding:
+ * @ctxt:  the parser context
+ * @handler:  the encoding handler
+ *
+ * change the input functions when discovering the character encoding
+ * of a given entity.
+ *
+ * Returns 0 in case of success, -1 otherwise
+ */
+int
+xmlSwitchToEncoding(xmlParserCtxtPtr ctxt, xmlCharEncodingHandlerPtr handler) 
+{
+    if (handler != NULL) {
+        if (ctxt->input != NULL) {
+	    xmlSwitchInputEncoding(ctxt, ctxt->input, handler);
+	} else {
+	    xmlErrInternal(ctxt, "xmlSwitchToEncoding : no input\n",
+	                   NULL);
+	    return(-1);
+	}
+	/*
+	 * The parsing is now done in UTF8 natively
+	 */
+	ctxt->charset = XML_CHAR_ENCODING_UTF8;
+    } else 
+	return(-1);
+    return(0);
+}
+
+/************************************************************************
+ *									*
+ *	Commodity functions to handle entities processing		*
+ *									*
+ ************************************************************************/
+
+/**
+ * xmlFreeInputStream:
+ * @input:  an xmlParserInputPtr
+ *
+ * Free up an input stream.
+ */
+void
+xmlFreeInputStream(xmlParserInputPtr input) {
+    if (input == NULL) return;
+
+    if (input->filename != NULL) xmlFree((char *) input->filename);
+    if (input->directory != NULL) xmlFree((char *) input->directory);
+    if (input->encoding != NULL) xmlFree((char *) input->encoding);
+    if (input->version != NULL) xmlFree((char *) input->version);
+    if ((input->free != NULL) && (input->base != NULL))
+        input->free((xmlChar *) input->base);
+    if (input->buf != NULL) 
+        xmlFreeParserInputBuffer(input->buf);
+    xmlFree(input);
+}
+
+/**
+ * xmlNewInputStream:
+ * @ctxt:  an XML parser context
+ *
+ * Create a new input stream structure
+ * Returns the new input stream or NULL
+ */
+xmlParserInputPtr
+xmlNewInputStream(xmlParserCtxtPtr ctxt) {
+    xmlParserInputPtr input;
+    static int id = 0;
+
+    input = (xmlParserInputPtr) xmlMalloc(sizeof(xmlParserInput));
+    if (input == NULL) {
+        xmlErrMemory(ctxt,  "couldn't allocate a new input stream\n");
+	return(NULL);
+    }
+    memset(input, 0, sizeof(xmlParserInput));
+    input->line = 1;
+    input->col = 1;
+    input->standalone = -1;
+    /*
+     * we don't care about thread reentrancy unicity for a single
+     * parser context (and hence thread) is sufficient.
+     */
+    input->id = id++;
+    return(input);
+}
+
+/**
+ * xmlNewIOInputStream:
+ * @ctxt:  an XML parser context
+ * @input:  an I/O Input
+ * @enc:  the charset encoding if known
+ *
+ * Create a new input stream structure encapsulating the @input into
+ * a stream suitable for the parser.
+ *
+ * Returns the new input stream or NULL
+ */
+xmlParserInputPtr
+xmlNewIOInputStream(xmlParserCtxtPtr ctxt, xmlParserInputBufferPtr input,
+	            xmlCharEncoding enc) {
+    xmlParserInputPtr inputStream;
+
+    if (xmlParserDebugEntities)
+	xmlGenericError(xmlGenericErrorContext, "new input from I/O\n");
+    inputStream = xmlNewInputStream(ctxt);
+    if (inputStream == NULL) {
+	return(NULL);
+    }
+    inputStream->filename = NULL;
+    inputStream->buf = input;
+    inputStream->base = inputStream->buf->buffer->content;
+    inputStream->cur = inputStream->buf->buffer->content;
+    inputStream->end = &inputStream->base[inputStream->buf->buffer->use];
+    if (enc != XML_CHAR_ENCODING_NONE) {
+        xmlSwitchEncoding(ctxt, enc);
+    }
+
+    return(inputStream);
+}
+
+/**
+ * xmlNewEntityInputStream:
+ * @ctxt:  an XML parser context
+ * @entity:  an Entity pointer
+ *
+ * Create a new input stream based on an xmlEntityPtr
+ *
+ * Returns the new input stream or NULL
+ */
+xmlParserInputPtr
+xmlNewEntityInputStream(xmlParserCtxtPtr ctxt, xmlEntityPtr entity) {
+    xmlParserInputPtr input;
+
+    if (entity == NULL) {
+        xmlErrInternal(ctxt, "xmlNewEntityInputStream entity = NULL\n",
+	               NULL);
+	return(NULL);
+    }
+    if (xmlParserDebugEntities)
+	xmlGenericError(xmlGenericErrorContext,
+		"new input from entity: %s\n", entity->name);
+    if (entity->content == NULL) {
+	switch (entity->etype) {
+            case XML_EXTERNAL_GENERAL_UNPARSED_ENTITY:
+	        xmlErrInternal(ctxt, "Cannot parse entity %s\n",
+		               entity->name);
+                break;
+            case XML_EXTERNAL_GENERAL_PARSED_ENTITY:
+            case XML_EXTERNAL_PARAMETER_ENTITY:
+		return(xmlLoadExternalEntity((char *) entity->URI,
+		       (char *) entity->ExternalID, ctxt));
+            case XML_INTERNAL_GENERAL_ENTITY:
+	        xmlErrInternal(ctxt,
+		      "Internal entity %s without content !\n",
+		               entity->name);
+                break;
+            case XML_INTERNAL_PARAMETER_ENTITY:
+	        xmlErrInternal(ctxt,
+		      "Internal parameter entity %s without content !\n",
+		               entity->name);
+                break;
+            case XML_INTERNAL_PREDEFINED_ENTITY:
+	        xmlErrInternal(ctxt,
+		      "Predefined entity %s without content !\n",
+		               entity->name);
+                break;
+	}
+	return(NULL);
+    }
+    input = xmlNewInputStream(ctxt);
+    if (input == NULL) {
+	return(NULL);
+    }
+    input->filename = (char *) entity->URI;
+    input->base = entity->content;
+    input->cur = entity->content;
+    input->length = entity->length;
+    input->end = &entity->content[input->length];
+    return(input);
+}
+
+/**
+ * xmlNewStringInputStream:
+ * @ctxt:  an XML parser context
+ * @buffer:  an memory buffer
+ *
+ * Create a new input stream based on a memory buffer.
+ * Returns the new input stream
+ */
+xmlParserInputPtr
+xmlNewStringInputStream(xmlParserCtxtPtr ctxt, const xmlChar *buffer) {
+    xmlParserInputPtr input;
+
+    if (buffer == NULL) {
+        xmlErrInternal(ctxt, "xmlNewStringInputStream string = NULL\n",
+	               NULL);
+	return(NULL);
+    }
+    if (xmlParserDebugEntities)
+	xmlGenericError(xmlGenericErrorContext,
+		"new fixed input: %.30s\n", buffer);
+    input = xmlNewInputStream(ctxt);
+    if (input == NULL) {
+        xmlErrMemory(ctxt,  "couldn't allocate a new input stream\n");
+	return(NULL);
+    }
+    input->base = buffer;
+    input->cur = buffer;
+    input->length = xmlStrlen(buffer);
+    input->end = &buffer[input->length];
+    return(input);
+}
+
+/**
+ * xmlNewInputFromFile:
+ * @ctxt:  an XML parser context
+ * @filename:  the filename to use as entity
+ *
+ * Create a new input stream based on a file or an URL.
+ *
+ * Returns the new input stream or NULL in case of error
+ */
+xmlParserInputPtr
+xmlNewInputFromFile(xmlParserCtxtPtr ctxt, const char *filename) {
+    xmlParserInputBufferPtr buf;
+    xmlParserInputPtr inputStream;
+    char *directory = NULL;
+    xmlChar *URI = NULL;
+
+    if (xmlParserDebugEntities)
+	xmlGenericError(xmlGenericErrorContext,
+		"new input from file: %s\n", filename);
+    if (ctxt == NULL) return(NULL);
+    buf = xmlParserInputBufferCreateFilename(filename, XML_CHAR_ENCODING_NONE);
+    if (buf == NULL) {
+        __xmlLoaderErr(ctxt, "failed to load external entity \"%s\"\n",
+                     (const char *) filename);
+	return(NULL);
+    }
+
+    inputStream = xmlNewInputStream(ctxt);
+    if (inputStream == NULL) {
+	if (directory != NULL) xmlFree((char *) directory);
+	if (URI != NULL) xmlFree((char *) URI);
+	return(NULL);
+    }
+    inputStream->buf = buf;
+    inputStream = xmlCheckHTTPInput(ctxt, inputStream);
+    if (inputStream == NULL)
+        return(NULL);
+    
+    if (inputStream->filename == NULL)
+	URI = xmlStrdup((xmlChar *) filename);
+    else
+	URI = xmlStrdup((xmlChar *) inputStream->filename);
+    directory = xmlParserGetDirectory((const char *) URI);
+    inputStream->filename = (char *) xmlCanonicPath((const xmlChar *) URI);
+    if (URI != NULL) xmlFree((char *) URI);
+    inputStream->directory = directory;
+
+    inputStream->base = inputStream->buf->buffer->content;
+    inputStream->cur = inputStream->buf->buffer->content;
+    inputStream->end = &inputStream->base[inputStream->buf->buffer->use];
+    if ((ctxt->directory == NULL) && (directory != NULL))
+        ctxt->directory = (char *) xmlStrdup((const xmlChar *) directory);
+    return(inputStream);
+}
+
+/************************************************************************
+ *									*
+ *		Commodity functions to handle parser contexts		*
+ *									*
+ ************************************************************************/
+
+/**
+ * xmlInitParserCtxt:
+ * @ctxt:  an XML parser context
+ *
+ * Initialize a parser context
+ *
+ * Returns 0 in case of success and -1 in case of error
+ */
+
+int
+xmlInitParserCtxt(xmlParserCtxtPtr ctxt)
+{
+    if(ctxt==NULL) {
+        xmlErrInternal(NULL, "Got NULL parser context\n", NULL);
+        return(-1);
+    }
+
+    xmlDefaultSAXHandlerInit();
+
+    ctxt->dict = xmlDictCreate();
+    if (ctxt->dict == NULL) {
+        xmlErrMemory(NULL, "cannot initialize parser context\n");
+	return(-1);
+    }
+    ctxt->sax = (xmlSAXHandler *) xmlMalloc(sizeof(xmlSAXHandler));
+    if (ctxt->sax == NULL) {
+        xmlErrMemory(NULL, "cannot initialize parser context\n");
+	return(-1);
+    }
+    else
+        xmlSAXVersion(ctxt->sax, 2);
+
+    ctxt->maxatts = 0;
+    ctxt->atts = NULL;
+    /* Allocate the Input stack */
+    ctxt->inputTab = (xmlParserInputPtr *)
+	        xmlMalloc(5 * sizeof(xmlParserInputPtr));
+    if (ctxt->inputTab == NULL) {
+        xmlErrMemory(NULL, "cannot initialize parser context\n");
+	ctxt->inputNr = 0;
+	ctxt->inputMax = 0;
+	ctxt->input = NULL;
+	return(-1);
+    }
+    ctxt->inputNr = 0;
+    ctxt->inputMax = 5;
+    ctxt->input = NULL;
+
+    ctxt->version = NULL;
+    ctxt->encoding = NULL;
+    ctxt->standalone = -1;
+    ctxt->hasExternalSubset = 0;
+    ctxt->hasPErefs = 0;
+    ctxt->html = 0;
+    ctxt->external = 0;
+    ctxt->instate = XML_PARSER_START;
+    ctxt->token = 0;
+    ctxt->directory = NULL;
+
+    /* Allocate the Node stack */
+    ctxt->nodeTab = (xmlNodePtr *) xmlMalloc(10 * sizeof(xmlNodePtr));
+    if (ctxt->nodeTab == NULL) {
+        xmlErrMemory(NULL, "cannot initialize parser context\n");
+	ctxt->nodeNr = 0;
+	ctxt->nodeMax = 0;
+	ctxt->node = NULL;
+	ctxt->inputNr = 0;
+	ctxt->inputMax = 0;
+	ctxt->input = NULL;
+	return(-1);
+    }
+    ctxt->nodeNr = 0;
+    ctxt->nodeMax = 10;
+    ctxt->node = NULL;
+
+    /* Allocate the Name stack */
+    ctxt->nameTab = (const xmlChar **) xmlMalloc(10 * sizeof(xmlChar *));
+    if (ctxt->nameTab == NULL) {
+        xmlErrMemory(NULL, "cannot initialize parser context\n");
+	ctxt->nodeNr = 0;
+	ctxt->nodeMax = 0;
+	ctxt->node = NULL;
+	ctxt->inputNr = 0;
+	ctxt->inputMax = 0;
+	ctxt->input = NULL;
+	ctxt->nameNr = 0;
+	ctxt->nameMax = 0;
+	ctxt->name = NULL;
+	return(-1);
+    }
+    ctxt->nameNr = 0;
+    ctxt->nameMax = 10;
+    ctxt->name = NULL;
+
+    /* Allocate the space stack */
+    ctxt->spaceTab = (int *) xmlMalloc(10 * sizeof(int));
+    if (ctxt->spaceTab == NULL) {
+        xmlErrMemory(NULL, "cannot initialize parser context\n");
+	ctxt->nodeNr = 0;
+	ctxt->nodeMax = 0;
+	ctxt->node = NULL;
+	ctxt->inputNr = 0;
+	ctxt->inputMax = 0;
+	ctxt->input = NULL;
+	ctxt->nameNr = 0;
+	ctxt->nameMax = 0;
+	ctxt->name = NULL;
+	ctxt->spaceNr = 0;
+	ctxt->spaceMax = 0;
+	ctxt->space = NULL;
+	return(-1);
+    }
+    ctxt->spaceNr = 1;
+    ctxt->spaceMax = 10;
+    ctxt->spaceTab[0] = -1;
+    ctxt->space = &ctxt->spaceTab[0];
+    ctxt->userData = ctxt;
+    ctxt->myDoc = NULL;
+    ctxt->wellFormed = 1;
+    ctxt->nsWellFormed = 1;
+    ctxt->valid = 1;
+    ctxt->loadsubset = xmlLoadExtDtdDefaultValue;
+    ctxt->validate = xmlDoValidityCheckingDefaultValue;
+    ctxt->pedantic = xmlPedanticParserDefaultValue;
+    ctxt->linenumbers = xmlLineNumbersDefaultValue;
+    ctxt->keepBlanks = xmlKeepBlanksDefaultValue;
+    if (ctxt->keepBlanks == 0)
+	ctxt->sax->ignorableWhitespace = xmlSAX2IgnorableWhitespace;
+
+    ctxt->vctxt.userData = ctxt;
+    ctxt->vctxt.error = xmlParserValidityError;
+    ctxt->vctxt.warning = xmlParserValidityWarning;
+    if (ctxt->validate) {
+	if (xmlGetWarningsDefaultValue == 0)
+	    ctxt->vctxt.warning = NULL;
+	else
+	    ctxt->vctxt.warning = xmlParserValidityWarning;
+	ctxt->vctxt.nodeMax = 0;
+    }
+    ctxt->replaceEntities = xmlSubstituteEntitiesDefaultValue;
+    ctxt->record_info = 0;
+    ctxt->nbChars = 0;
+    ctxt->checkIndex = 0;
+    ctxt->inSubset = 0;
+    ctxt->errNo = XML_ERR_OK;
+    ctxt->depth = 0;
+    ctxt->charset = XML_CHAR_ENCODING_UTF8;
+    ctxt->catalogs = NULL;
+    xmlInitNodeInfoSeq(&ctxt->node_seq);
+    return(0);
+}
+
+/**
+ * xmlFreeParserCtxt:
+ * @ctxt:  an XML parser context
+ *
+ * Free all the memory used by a parser context. However the parsed
+ * document in ctxt->myDoc is not freed.
+ */
+
+void
+xmlFreeParserCtxt(xmlParserCtxtPtr ctxt)
+{
+    xmlParserInputPtr input;
+
+    if (ctxt == NULL) return;
+
+    while ((input = inputPop(ctxt)) != NULL) { /* Non consuming */
+        xmlFreeInputStream(input);
+    }
+    if (ctxt->spaceTab != NULL) xmlFree(ctxt->spaceTab);
+    if (ctxt->nameTab != NULL) xmlFree((xmlChar * *)ctxt->nameTab);
+    if (ctxt->nodeTab != NULL) xmlFree(ctxt->nodeTab);
+    if (ctxt->inputTab != NULL) xmlFree(ctxt->inputTab);
+    if (ctxt->version != NULL) xmlFree((char *) ctxt->version);
+    if (ctxt->encoding != NULL) xmlFree((char *) ctxt->encoding);
+    if (ctxt->extSubURI != NULL) xmlFree((char *) ctxt->extSubURI);
+    if (ctxt->extSubSystem != NULL) xmlFree((char *) ctxt->extSubSystem);
+#ifdef LIBXML_SAX1_ENABLED
+    if ((ctxt->sax != NULL) &&
+        (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler))
+#else
+    if (ctxt->sax != NULL)
+#endif /* LIBXML_SAX1_ENABLED */
+        xmlFree(ctxt->sax);
+    if (ctxt->directory != NULL) xmlFree((char *) ctxt->directory);
+    if (ctxt->vctxt.nodeTab != NULL) xmlFree(ctxt->vctxt.nodeTab);
+    if (ctxt->atts != NULL) xmlFree((xmlChar * *)ctxt->atts);
+    if (ctxt->dict != NULL) xmlDictFree(ctxt->dict);
+    if (ctxt->nsTab != NULL) xmlFree((char *) ctxt->nsTab);
+    if (ctxt->pushTab != NULL) xmlFree(ctxt->pushTab);
+    if (ctxt->attallocs != NULL) xmlFree(ctxt->attallocs);
+    if (ctxt->attsDefault != NULL) 
+        xmlHashFree(ctxt->attsDefault, (xmlHashDeallocator) xmlFree);
+    if (ctxt->attsSpecial != NULL)
+        xmlHashFree(ctxt->attsSpecial, NULL);
+    if (ctxt->freeElems != NULL) {
+        xmlNodePtr cur, next;
+
+	cur = ctxt->freeElems;
+	while (cur != NULL) {
+	    next = cur->next;
+	    xmlFree(cur);
+	    cur = next;
+	}
+    }
+    if (ctxt->freeAttrs != NULL) {
+        xmlAttrPtr cur, next;
+
+	cur = ctxt->freeAttrs;
+	while (cur != NULL) {
+	    next = cur->next;
+	    xmlFree(cur);
+	    cur = next;
+	}
+    }
+    /*
+     * cleanup the error strings
+     */
+    if (ctxt->lastError.message != NULL)
+        xmlFree(ctxt->lastError.message);
+    if (ctxt->lastError.file != NULL)
+        xmlFree(ctxt->lastError.file);
+    if (ctxt->lastError.str1 != NULL)
+        xmlFree(ctxt->lastError.str1);
+    if (ctxt->lastError.str2 != NULL)
+        xmlFree(ctxt->lastError.str2);
+    if (ctxt->lastError.str3 != NULL)
+        xmlFree(ctxt->lastError.str3);
+
+#ifdef LIBXML_CATALOG_ENABLED
+    if (ctxt->catalogs != NULL)
+	xmlCatalogFreeLocal(ctxt->catalogs);
+#endif
+    xmlFree(ctxt);
+}
+
+/**
+ * xmlNewParserCtxt:
+ *
+ * Allocate and initialize a new parser context.
+ *
+ * Returns the xmlParserCtxtPtr or NULL
+ */
+
+xmlParserCtxtPtr
+xmlNewParserCtxt()
+{
+    xmlParserCtxtPtr ctxt;
+
+    ctxt = (xmlParserCtxtPtr) xmlMalloc(sizeof(xmlParserCtxt));
+    if (ctxt == NULL) {
+	xmlErrMemory(NULL, "cannot allocate parser context\n");
+	return(NULL);
+    }
+    memset(ctxt, 0, sizeof(xmlParserCtxt));
+    if (xmlInitParserCtxt(ctxt) < 0) {
+        xmlFreeParserCtxt(ctxt);
+	return(NULL);
+    }
+    return(ctxt);
+}
+
+/************************************************************************
+ *									*
+ *		Handling of node informations				*
+ *									*
+ ************************************************************************/
+
+/**
+ * xmlClearParserCtxt:
+ * @ctxt:  an XML parser context
+ *
+ * Clear (release owned resources) and reinitialize a parser context
+ */
+
+void
+xmlClearParserCtxt(xmlParserCtxtPtr ctxt)
+{
+  if (ctxt==NULL)
+    return;
+  xmlClearNodeInfoSeq(&ctxt->node_seq);
+  xmlInitParserCtxt(ctxt);
+}
+
+/**
+ * xmlParserFindNodeInfo:
+ * @ctx:  an XML parser context
+ * @node:  an XML node within the tree
+ *
+ * Find the parser node info struct for a given node
+ * 
+ * Returns an xmlParserNodeInfo block pointer or NULL
+ */
+const xmlParserNodeInfo* xmlParserFindNodeInfo(const xmlParserCtxtPtr ctx,
+                                               const xmlNodePtr node)
+{
+  unsigned long pos;
+
+  /* Find position where node should be at */
+  pos = xmlParserFindNodeInfoIndex(&ctx->node_seq, node);
+  if (pos < ctx->node_seq.length && ctx->node_seq.buffer[pos].node == node)
+    return &ctx->node_seq.buffer[pos];
+  else
+    return NULL;
+}
+
+
+/**
+ * xmlInitNodeInfoSeq:
+ * @seq:  a node info sequence pointer
+ *
+ * -- Initialize (set to initial state) node info sequence
+ */
+void
+xmlInitNodeInfoSeq(xmlParserNodeInfoSeqPtr seq)
+{
+  seq->length = 0;
+  seq->maximum = 0;
+  seq->buffer = NULL;
+}
+
+/**
+ * xmlClearNodeInfoSeq:
+ * @seq:  a node info sequence pointer
+ *
+ * -- Clear (release memory and reinitialize) node
+ *   info sequence
+ */
+void
+xmlClearNodeInfoSeq(xmlParserNodeInfoSeqPtr seq)
+{
+  if ( seq->buffer != NULL )
+    xmlFree(seq->buffer);
+  xmlInitNodeInfoSeq(seq);
+}
+
+
+/**
+ * xmlParserFindNodeInfoIndex:
+ * @seq:  a node info sequence pointer
+ * @node:  an XML node pointer
+ *
+ * 
+ * xmlParserFindNodeInfoIndex : Find the index that the info record for
+ *   the given node is or should be at in a sorted sequence
+ *
+ * Returns a long indicating the position of the record
+ */
+unsigned long xmlParserFindNodeInfoIndex(const xmlParserNodeInfoSeqPtr seq,
+                                         const xmlNodePtr node)
+{
+  unsigned long upper, lower, middle;
+  int found = 0;
+
+  /* Do a binary search for the key */
+  lower = 1;
+  upper = seq->length;
+  middle = 0;
+  while ( lower <= upper && !found) {
+    middle = lower + (upper - lower) / 2;
+    if ( node == seq->buffer[middle - 1].node )
+      found = 1;
+    else if ( node < seq->buffer[middle - 1].node )
+      upper = middle - 1;
+    else
+      lower = middle + 1;
+  }
+
+  /* Return position */
+  if ( middle == 0 || seq->buffer[middle - 1].node < node )
+    return middle;
+  else 
+    return middle - 1;
+}
+
+
+/**
+ * xmlParserAddNodeInfo:
+ * @ctxt:  an XML parser context
+ * @info:  a node info sequence pointer
+ *
+ * Insert node info record into the sorted sequence
+ */
+void
+xmlParserAddNodeInfo(xmlParserCtxtPtr ctxt,
+                     const xmlParserNodeInfoPtr info)
+{
+    unsigned long pos;
+
+    /* Find pos and check to see if node is already in the sequence */
+    pos = xmlParserFindNodeInfoIndex(&ctxt->node_seq, (xmlNodePtr)
+                                     info->node);
+    if (pos < ctxt->node_seq.length
+        && ctxt->node_seq.buffer[pos].node == info->node) {
+        ctxt->node_seq.buffer[pos] = *info;
+    }
+
+    /* Otherwise, we need to add new node to buffer */
+    else {
+        if (ctxt->node_seq.length + 1 > ctxt->node_seq.maximum) {
+            xmlParserNodeInfo *tmp_buffer;
+            unsigned int byte_size;
+
+            if (ctxt->node_seq.maximum == 0)
+                ctxt->node_seq.maximum = 2;
+            byte_size = (sizeof(*ctxt->node_seq.buffer) *
+			(2 * ctxt->node_seq.maximum));
+
+            if (ctxt->node_seq.buffer == NULL)
+                tmp_buffer = (xmlParserNodeInfo *) xmlMalloc(byte_size);
+            else
+                tmp_buffer =
+                    (xmlParserNodeInfo *) xmlRealloc(ctxt->node_seq.buffer,
+                                                     byte_size);
+
+            if (tmp_buffer == NULL) {
+		xmlErrMemory(ctxt, "failed to allocate buffer\n");
+                return;
+            }
+            ctxt->node_seq.buffer = tmp_buffer;
+            ctxt->node_seq.maximum *= 2;
+        }
+
+        /* If position is not at end, move elements out of the way */
+        if (pos != ctxt->node_seq.length) {
+            unsigned long i;
+
+            for (i = ctxt->node_seq.length; i > pos; i--)
+                ctxt->node_seq.buffer[i] = ctxt->node_seq.buffer[i - 1];
+        }
+
+        /* Copy element and increase length */
+        ctxt->node_seq.buffer[pos] = *info;
+        ctxt->node_seq.length++;
+    }
+}
+
+/************************************************************************
+ *									*
+ *		Defaults settings					*
+ *									*
+ ************************************************************************/
+/**
+ * xmlPedanticParserDefault:
+ * @val:  int 0 or 1 
+ *
+ * Set and return the previous value for enabling pedantic warnings.
+ *
+ * Returns the last value for 0 for no substitution, 1 for substitution.
+ */
+
+int
+xmlPedanticParserDefault(int val) {
+    int old = xmlPedanticParserDefaultValue;
+
+    xmlPedanticParserDefaultValue = val;
+    return(old);
+}
+
+/**
+ * xmlLineNumbersDefault:
+ * @val:  int 0 or 1 
+ *
+ * Set and return the previous value for enabling line numbers in elements
+ * contents. This may break on old application and is turned off by default.
+ *
+ * Returns the last value for 0 for no substitution, 1 for substitution.
+ */
+
+int
+xmlLineNumbersDefault(int val) {
+    int old = xmlLineNumbersDefaultValue;
+
+    xmlLineNumbersDefaultValue = val;
+    return(old);
+}
+
+/**
+ * xmlSubstituteEntitiesDefault:
+ * @val:  int 0 or 1 
+ *
+ * Set and return the previous value for default entity support.
+ * Initially the parser always keep entity references instead of substituting
+ * entity values in the output. This function has to be used to change the
+ * default parser behavior
+ * SAX::substituteEntities() has to be used for changing that on a file by
+ * file basis.
+ *
+ * Returns the last value for 0 for no substitution, 1 for substitution.
+ */
+
+int
+xmlSubstituteEntitiesDefault(int val) {
+    int old = xmlSubstituteEntitiesDefaultValue;
+
+    xmlSubstituteEntitiesDefaultValue = val;
+    return(old);
+}
+
+/**
+ * xmlKeepBlanksDefault:
+ * @val:  int 0 or 1 
+ *
+ * Set and return the previous value for default blanks text nodes support.
+ * The 1.x version of the parser used an heuristic to try to detect
+ * ignorable white spaces. As a result the SAX callback was generating
+ * xmlSAX2IgnorableWhitespace() callbacks instead of characters() one, and when
+ * using the DOM output text nodes containing those blanks were not generated.
+ * The 2.x and later version will switch to the XML standard way and
+ * ignorableWhitespace() are only generated when running the parser in
+ * validating mode and when the current element doesn't allow CDATA or
+ * mixed content.
+ * This function is provided as a way to force the standard behavior 
+ * on 1.X libs and to switch back to the old mode for compatibility when
+ * running 1.X client code on 2.X . Upgrade of 1.X code should be done
+ * by using xmlIsBlankNode() commodity function to detect the "empty"
+ * nodes generated.
+ * This value also affect autogeneration of indentation when saving code
+ * if blanks sections are kept, indentation is not generated.
+ *
+ * Returns the last value for 0 for no substitution, 1 for substitution.
+ */
+
+int
+xmlKeepBlanksDefault(int val) {
+    int old = xmlKeepBlanksDefaultValue;
+
+    xmlKeepBlanksDefaultValue = val;
+    xmlIndentTreeOutput = !val;
+    return(old);
+}
+
diff --git a/src/libxml/src/pattern.c b/src/libxml/src/pattern.c
new file mode 100644
index 0000000..36b4adf
--- /dev/null
+++ b/src/libxml/src/pattern.c
@@ -0,0 +1,933 @@
+/*
+ * pattern.c: Implemetation of selectors for nodes
+ *
+ * Reference:
+ *   http://www.w3.org/TR/2001/REC-xmlschema-1-20010502/
+ *   to some extent 
+ *   http://www.w3.org/TR/1999/REC-xml-19991116
+ *
+ * See Copyright for the status of this software.
+ *
+ * daniel@veillard.com
+ */
+
+#define IN_LIBXML
+#include "libxml.h"
+
+#include <string.h>
+#include <libxml/xmlmemory.h>
+#include <libxml/tree.h>
+#include <libxml/hash.h>
+#include <libxml/dict.h>
+#include <libxml/xmlerror.h>
+#include <libxml/parserInternals.h>
+#include <libxml/pattern.h>
+
+#ifdef LIBXML_PATTERN_ENABLED
+
+#define ERROR(a, b, c, d)
+#define ERROR5(a, b, c, d, e)
+
+/*
+ * Types are private:
+ */
+
+typedef enum {
+    XML_OP_END=0,
+    XML_OP_ROOT,
+    XML_OP_ELEM,
+    XML_OP_CHILD,
+    XML_OP_ATTR,
+    XML_OP_PARENT,
+    XML_OP_ANCESTOR,
+    XML_OP_NS,
+    XML_OP_ALL
+} xmlPatOp;
+
+
+typedef struct _xmlStepOp xmlStepOp;
+typedef xmlStepOp *xmlStepOpPtr;
+struct _xmlStepOp {
+    xmlPatOp op;
+    const xmlChar *value;
+    const xmlChar *value2;
+};
+
+struct _xmlPattern {
+    void *data;    		/* the associated template */
+    struct _xmlPattern *next; /* siblings */
+    const xmlChar *pattern;	/* the pattern */
+
+    /* TODO fix the statically allocated size steps[] */
+    int nbStep;
+    int maxStep;
+    xmlStepOp steps[10];        /* ops for computation */
+};
+
+typedef struct _xmlPatParserContext xmlPatParserContext;
+typedef xmlPatParserContext *xmlPatParserContextPtr;
+struct _xmlPatParserContext {
+    const xmlChar *cur;			/* the current char being parsed */
+    const xmlChar *base;		/* the full expression */
+    int	           error;		/* error code */
+    xmlDictPtr     dict;		/* the dictionnary if any */
+    xmlPatternPtr  comp;		/* the result */
+    xmlNodePtr     elem;		/* the current node if any */    
+    const xmlChar **namespaces;		/* the namespaces definitions */
+    int   nb_namespaces;		/* the number of namespaces */
+};
+
+/************************************************************************
+ * 									*
+ * 			Type functions 					*
+ * 									*
+ ************************************************************************/
+
+/**
+ * xmlNewPattern:
+ *
+ * Create a new XSLT Pattern
+ *
+ * Returns the newly allocated xmlPatternPtr or NULL in case of error
+ */
+static xmlPatternPtr
+xmlNewPattern(void) {
+    xmlPatternPtr cur;
+
+    cur = (xmlPatternPtr) xmlMalloc(sizeof(xmlPattern));
+    if (cur == NULL) {
+	ERROR(NULL, NULL, NULL,
+		"xmlNewPattern : malloc failed\n");
+	return(NULL);
+    }
+    memset(cur, 0, sizeof(xmlPattern));
+    cur->maxStep = 10;
+    return(cur);
+}
+
+/**
+ * xmlFreePattern:
+ * @comp:  an XSLT comp
+ *
+ * Free up the memory allocated by @comp
+ */
+void
+xmlFreePattern(xmlPatternPtr comp) {
+    xmlStepOpPtr op;
+    int i;
+
+    if (comp == NULL)
+	return;
+    if (comp->pattern != NULL)
+	xmlFree((xmlChar *)comp->pattern);
+    for (i = 0;i < comp->nbStep;i++) {
+	op = &comp->steps[i];
+	if (op->value != NULL)
+	    xmlFree((xmlChar *) op->value);
+	if (op->value2 != NULL)
+	    xmlFree((xmlChar *) op->value2);
+    }
+    memset(comp, -1, sizeof(xmlPattern));
+    xmlFree(comp);
+}
+
+/**
+ * xmlFreePatternList:
+ * @comp:  an XSLT comp list
+ *
+ * Free up the memory allocated by all the elements of @comp
+ */
+void
+xmlFreePatternList(xmlPatternPtr comp) {
+    xmlPatternPtr cur;
+
+    while (comp != NULL) {
+	cur = comp;
+	comp = comp->next;
+	xmlFreePattern(cur);
+    }
+}
+
+/**
+ * xmlNewPatParserContext:
+ * @pattern:  the pattern context
+ * @dict:  the inherited dictionnary or NULL
+ * @namespaces: the prefix definitions, array of [URI, prefix] or NULL
+ *
+ * Create a new XML pattern parser context
+ *
+ * Returns the newly allocated xmlPatParserContextPtr or NULL in case of error
+ */
+static xmlPatParserContextPtr
+xmlNewPatParserContext(const xmlChar *pattern, xmlDictPtr dict,
+                       const xmlChar **namespaces) {
+    xmlPatParserContextPtr cur;
+
+    if (pattern == NULL)
+        return(NULL);
+
+    cur = (xmlPatParserContextPtr) xmlMalloc(sizeof(xmlPatParserContext));
+    if (cur == NULL) {
+	ERROR(NULL, NULL, NULL,
+		"xmlNewPatParserContext : malloc failed\n");
+	return(NULL);
+    }
+    memset(cur, 0, sizeof(xmlPatParserContext));
+    cur->dict = dict;
+    cur->cur = pattern;
+    cur->base = pattern;
+    if (namespaces != NULL) {
+        int i;
+	for (i = 0;namespaces[2 * i] != NULL;i++);
+        cur->nb_namespaces = i;
+    } else {
+        cur->nb_namespaces = 0;
+    }
+    cur->namespaces = namespaces;
+    return(cur);
+}
+
+/**
+ * xmlFreePatParserContext:
+ * @ctxt:  an XSLT parser context
+ *
+ * Free up the memory allocated by @ctxt
+ */
+static void
+xmlFreePatParserContext(xmlPatParserContextPtr ctxt) {
+    if (ctxt == NULL)
+	return;
+    memset(ctxt, -1, sizeof(xmlPatParserContext));
+    xmlFree(ctxt);
+}
+
+/**
+ * xmlPatternAdd:
+ * @comp:  the compiled match expression
+ * @op:  an op
+ * @value:  the first value
+ * @value2:  the second value
+ *
+ * Add an step to an XSLT Compiled Match
+ *
+ * Returns -1 in case of failure, 0 otherwise.
+ */
+static int
+xmlPatternAdd(xmlPatParserContextPtr ctxt ATTRIBUTE_UNUSED,
+                xmlPatternPtr comp,
+                xmlPatOp op, xmlChar * value, xmlChar * value2)
+{
+    if (comp->nbStep >= 10) {
+        ERROR(ctxt, NULL, NULL,
+                         "xmlPatternAdd: overflow\n");
+        return (-1);
+    }
+    comp->steps[comp->nbStep].op = op;
+    comp->steps[comp->nbStep].value = value;
+    comp->steps[comp->nbStep].value2 = value2;
+    comp->nbStep++;
+    return (0);
+}
+
+#if 0
+/**
+ * xsltSwapTopPattern:
+ * @comp:  the compiled match expression
+ *
+ * reverse the two top steps.
+ */
+static void
+xsltSwapTopPattern(xmlPatternPtr comp) {
+    int i;
+    int j = comp->nbStep - 1;
+
+    if (j > 0) {
+	register const xmlChar *tmp;
+	register xmlPatOp op;
+	i = j - 1;
+	tmp = comp->steps[i].value;
+	comp->steps[i].value = comp->steps[j].value;
+	comp->steps[j].value = tmp;
+	tmp = comp->steps[i].value2;
+	comp->steps[i].value2 = comp->steps[j].value2;
+	comp->steps[j].value2 = tmp;
+	op = comp->steps[i].op;
+	comp->steps[i].op = comp->steps[j].op;
+	comp->steps[j].op = op;
+    }
+}
+#endif
+
+/**
+ * xmlReversePattern:
+ * @comp:  the compiled match expression
+ *
+ * reverse all the stack of expressions
+ */
+static void
+xmlReversePattern(xmlPatternPtr comp) {
+    int i = 0;
+    int j = comp->nbStep - 1;
+
+    while (j > i) {
+	register const xmlChar *tmp;
+	register xmlPatOp op;
+	tmp = comp->steps[i].value;
+	comp->steps[i].value = comp->steps[j].value;
+	comp->steps[j].value = tmp;
+	tmp = comp->steps[i].value2;
+	comp->steps[i].value2 = comp->steps[j].value2;
+	comp->steps[j].value2 = tmp;
+	op = comp->steps[i].op;
+	comp->steps[i].op = comp->steps[j].op;
+	comp->steps[j].op = op;
+	j--;
+	i++;
+    }
+    comp->steps[comp->nbStep++].op = XML_OP_END;
+}
+
+/************************************************************************
+ * 									*
+ * 		The interpreter for the precompiled patterns		*
+ * 									*
+ ************************************************************************/
+
+/**
+ * xmlPatMatch:
+ * @comp: the precompiled pattern
+ * @node: a node
+ *
+ * Test wether the node matches the pattern
+ *
+ * Returns 1 if it matches, 0 if it doesn't and -1 in case of failure
+ */
+static int
+xmlPatMatch(xmlPatternPtr comp, xmlNodePtr node) {
+    int i;
+    xmlStepOpPtr step;
+
+    if ((comp == NULL) || (node == NULL)) return(-1);
+    for (i = 0;i < comp->nbStep;i++) {
+	step = &comp->steps[i];
+	switch (step->op) {
+            case XML_OP_END:
+		return(1);
+            case XML_OP_ROOT:
+		if ((node->type == XML_DOCUMENT_NODE) ||
+#ifdef LIBXML_DOCB_ENABLED
+		    (node->type == XML_DOCB_DOCUMENT_NODE) ||
+#endif
+		    (node->type == XML_HTML_DOCUMENT_NODE))
+		    continue;
+		return(0);
+            case XML_OP_ELEM:
+		if (node->type != XML_ELEMENT_NODE)
+		    return(0);
+		if (step->value == NULL)
+		    continue;
+		if (step->value[0] != node->name[0])
+		    return(0);
+		if (!xmlStrEqual(step->value, node->name))
+		    return(0);
+
+		/* Namespace test */
+		if (node->ns == NULL) {
+		    if (step->value2 != NULL)
+			return(0);
+		} else if (node->ns->href != NULL) {
+		    if (step->value2 == NULL)
+			return(0);
+		    if (!xmlStrEqual(step->value2, node->ns->href))
+			return(0);
+		}
+		continue;
+            case XML_OP_CHILD: {
+		xmlNodePtr lst;
+
+		if ((node->type != XML_ELEMENT_NODE) &&
+		    (node->type != XML_DOCUMENT_NODE) &&
+#ifdef LIBXML_DOCB_ENABLED
+		    (node->type != XML_DOCB_DOCUMENT_NODE) &&
+#endif
+		    (node->type != XML_HTML_DOCUMENT_NODE))
+		    return(0);
+
+		lst = node->children;
+
+		if (step->value != NULL) {
+		    while (lst != NULL) {
+			if ((lst->type == XML_ELEMENT_NODE) &&
+			    (step->value[0] == lst->name[0]) &&
+			    (xmlStrEqual(step->value, lst->name)))
+			    break;
+			lst = lst->next;
+		    }
+		    if (lst != NULL)
+			continue;
+		}
+		return(0);
+	    }
+            case XML_OP_ATTR:
+		if (node->type != XML_ATTRIBUTE_NODE)
+		    return(0);
+		if (step->value != NULL) {
+		    if (step->value[0] != node->name[0])
+			return(0);
+		    if (!xmlStrEqual(step->value, node->name))
+			return(0);
+		}
+		/* Namespace test */
+		if (node->ns == NULL) {
+		    if (step->value2 != NULL)
+			return(0);
+		} else if (step->value2 != NULL) {
+		    if (!xmlStrEqual(step->value2, node->ns->href))
+			return(0);
+		}
+		continue;
+            case XML_OP_PARENT:
+		if ((node->type == XML_DOCUMENT_NODE) ||
+		    (node->type == XML_HTML_DOCUMENT_NODE) ||
+#ifdef LIBXML_DOCB_ENABLED
+		    (node->type == XML_DOCB_DOCUMENT_NODE) ||
+#endif
+		    (node->type == XML_NAMESPACE_DECL))
+		    return(0);
+		node = node->parent;
+		if (node == NULL)
+		    return(0);
+		if (step->value == NULL)
+		    continue;
+		if (step->value[0] != node->name[0])
+		    return(0);
+		if (!xmlStrEqual(step->value, node->name))
+		    return(0);
+		/* Namespace test */
+		if (node->ns == NULL) {
+		    if (step->value2 != NULL)
+			return(0);
+		} else if (node->ns->href != NULL) {
+		    if (step->value2 == NULL)
+			return(0);
+		    if (!xmlStrEqual(step->value2, node->ns->href))
+			return(0);
+		}
+		continue;
+            case XML_OP_ANCESTOR:
+		/* TODO: implement coalescing of ANCESTOR/NODE ops */
+		if (step->value == NULL) {
+		    i++;
+		    step = &comp->steps[i];
+		    if (step->op == XML_OP_ROOT)
+			return(1);
+		    if (step->op != XML_OP_ELEM)
+			return(0);
+		    if (step->value == NULL)
+			return(-1);
+		}
+		if (node == NULL)
+		    return(0);
+		if ((node->type == XML_DOCUMENT_NODE) ||
+		    (node->type == XML_HTML_DOCUMENT_NODE) ||
+#ifdef LIBXML_DOCB_ENABLED
+		    (node->type == XML_DOCB_DOCUMENT_NODE) ||
+#endif
+		    (node->type == XML_NAMESPACE_DECL))
+		    return(0);
+		node = node->parent;
+		while (node != NULL) {
+		    if (node == NULL)
+			return(0);
+		    if ((node->type == XML_ELEMENT_NODE) &&
+			(step->value[0] == node->name[0]) &&
+			(xmlStrEqual(step->value, node->name))) {
+			/* Namespace test */
+			if (node->ns == NULL) {
+			    if (step->value2 == NULL)
+				break;
+			} else if (node->ns->href != NULL) {
+			    if ((step->value2 != NULL) &&
+			        (xmlStrEqual(step->value2, node->ns->href)))
+				break;
+			}
+		    }
+		    node = node->parent;
+		}
+		if (node == NULL)
+		    return(0);
+		continue;
+            case XML_OP_NS:
+		if (node->type != XML_ELEMENT_NODE)
+		    return(0);
+		if (node->ns == NULL) {
+		    if (step->value != NULL)
+			return(0);
+		} else if (node->ns->href != NULL) {
+		    if (step->value == NULL)
+			return(0);
+		    if (!xmlStrEqual(step->value, node->ns->href))
+			return(0);
+		}
+		break;
+            case XML_OP_ALL:
+		if (node->type != XML_ELEMENT_NODE)
+		    return(0);
+		break;
+	}
+    }
+    return(1);
+}
+
+/************************************************************************
+ *									*
+ *			Dedicated parser for templates			*
+ *									*
+ ************************************************************************/
+
+#define TODO 								\
+    xmlGenericError(xmlGenericErrorContext,				\
+	    "Unimplemented block at %s:%d\n",				\
+            __FILE__, __LINE__);
+#define CUR (*ctxt->cur)
+#define SKIP(val) ctxt->cur += (val)
+#define NXT(val) ctxt->cur[(val)]
+#define CUR_PTR ctxt->cur
+
+#define SKIP_BLANKS 							\
+    while (IS_BLANK_CH(CUR)) NEXT
+
+#define CURRENT (*ctxt->cur)
+#define NEXT ((*ctxt->cur) ?  ctxt->cur++: ctxt->cur)
+
+
+#define PUSH(op, val, val2) 						\
+    if (xmlPatternAdd(ctxt, ctxt->comp, (op), (val), (val2))) goto error;
+
+#define XSLT_ERROR(X)							\
+    { xsltError(ctxt, __FILE__, __LINE__, X);			\
+      ctxt->error = (X); return; }
+
+#define XSLT_ERROR0(X)							\
+    { xsltError(ctxt, __FILE__, __LINE__, X);			\
+      ctxt->error = (X); return(0); }
+
+#if 0
+/**
+ * xmlPatScanLiteral:
+ * @ctxt:  the XPath Parser context
+ *
+ * Parse an XPath Litteral:
+ *
+ * [29] Literal ::= '"' [^"]* '"'
+ *                | "'" [^']* "'"
+ *
+ * Returns the Literal parsed or NULL
+ */
+
+static xmlChar *
+xmlPatScanLiteral(xmlPatParserContextPtr ctxt) {
+    const xmlChar *q, *cur;
+    xmlChar *ret = NULL;
+    int val, len;
+
+    SKIP_BLANKS;
+    if (CUR == '"') {
+        NEXT;
+	cur = q = CUR_PTR;
+	val = xmlStringCurrentChar(NULL, cur, &len);
+	while ((IS_CHAR(val)) && (val != '"')) {
+	    cur += len;
+	    val = xmlStringCurrentChar(NULL, cur, &len);
+	}
+	if (!IS_CHAR(val)) {
+	    ctxt->error = 1;
+	    return(NULL);
+	} else {
+	    ret = xmlStrndup(q, cur - q);
+        }
+	cur += len;
+	CUR_PTR = cur;
+    } else if (CUR == '\'') {
+        NEXT;
+	cur = q = CUR_PTR;
+	val = xmlStringCurrentChar(NULL, cur, &len);
+	while ((IS_CHAR(val)) && (val != '\'')) {
+	    cur += len;
+	    val = xmlStringCurrentChar(NULL, cur, &len);
+	}
+	if (!IS_CHAR(val)) {
+	    ctxt->error = 1;
+	    return(NULL);
+	} else {
+	    ret = xmlStrndup(q, cur - q);
+        }
+	cur += len;
+	CUR_PTR = cur;
+    } else {
+	/* XP_ERROR(XPATH_START_LITERAL_ERROR); */
+	ctxt->error = 1;
+	return(NULL);
+    }
+    return(ret);
+}
+#endif
+
+/**
+ * xmlPatScanName:
+ * @ctxt:  the XPath Parser context
+ *
+ * [4] NameChar ::= Letter | Digit | '.' | '-' | '_' | 
+ *                  CombiningChar | Extender
+ *
+ * [5] Name ::= (Letter | '_' | ':') (NameChar)*
+ *
+ * [6] Names ::= Name (S Name)*
+ *
+ * Returns the Name parsed or NULL
+ */
+
+static xmlChar *
+xmlPatScanName(xmlPatParserContextPtr ctxt) {
+    const xmlChar *q, *cur;
+    xmlChar *ret = NULL;
+    int val, len;
+
+    SKIP_BLANKS;
+
+    cur = q = CUR_PTR;
+    val = xmlStringCurrentChar(NULL, cur, &len);
+    if (!IS_LETTER(val) && (val != '_') && (val != ':'))
+	return(NULL);
+
+    while ((IS_LETTER(val)) || (IS_DIGIT(val)) ||
+           (val == '.') || (val == '-') ||
+	   (val == '_') || 
+	   (IS_COMBINING(val)) ||
+	   (IS_EXTENDER(val))) {
+	cur += len;
+	val = xmlStringCurrentChar(NULL, cur, &len);
+    }
+    ret = xmlStrndup(q, cur - q);
+    CUR_PTR = cur;
+    return(ret);
+}
+
+/**
+ * xmlPatScanNCName:
+ * @ctxt:  the XPath Parser context
+ *
+ * Parses a non qualified name
+ *
+ * Returns the Name parsed or NULL
+ */
+
+static xmlChar *
+xmlPatScanNCName(xmlPatParserContextPtr ctxt) {
+    const xmlChar *q, *cur;
+    xmlChar *ret = NULL;
+    int val, len;
+
+    SKIP_BLANKS;
+
+    cur = q = CUR_PTR;
+    val = xmlStringCurrentChar(NULL, cur, &len);
+    if (!IS_LETTER(val) && (val != '_'))
+	return(NULL);
+
+    while ((IS_LETTER(val)) || (IS_DIGIT(val)) ||
+           (val == '.') || (val == '-') ||
+	   (val == '_') ||
+	   (IS_COMBINING(val)) ||
+	   (IS_EXTENDER(val))) {
+	cur += len;
+	val = xmlStringCurrentChar(NULL, cur, &len);
+    }
+    ret = xmlStrndup(q, cur - q);
+    CUR_PTR = cur;
+    return(ret);
+}
+
+#if 0
+/**
+ * xmlPatScanQName:
+ * @ctxt:  the XPath Parser context
+ * @prefix:  the place to store the prefix
+ *
+ * Parse a qualified name
+ *
+ * Returns the Name parsed or NULL
+ */
+
+static xmlChar *
+xmlPatScanQName(xmlPatParserContextPtr ctxt, xmlChar **prefix) {
+    xmlChar *ret = NULL;
+
+    *prefix = NULL;
+    ret = xmlPatScanNCName(ctxt);
+    if (CUR == ':') {
+        *prefix = ret;
+	NEXT;
+	ret = xmlPatScanNCName(ctxt);
+    }
+    return(ret);
+}
+#endif
+
+/**
+ * xmlCompileStepPattern:
+ * @ctxt:  the compilation context
+ *
+ * Compile the Step Pattern and generates a precompiled
+ * form suitable for fast matching.
+ *
+ * [3]    Step    ::=    '.' | NameTest
+ * [4]    NameTest    ::=    QName | '*' | NCName ':' '*' 
+ */
+
+static void
+xmlCompileStepPattern(xmlPatParserContextPtr ctxt) {
+    xmlChar *token = NULL;
+    xmlChar *name = NULL;
+    const xmlChar *URI = NULL;
+    xmlChar *URL = NULL;
+
+    SKIP_BLANKS;
+    if (CUR == '.') {
+	NEXT;
+	PUSH(XML_OP_ELEM, NULL, NULL);
+	return;
+    }
+    name = xmlPatScanNCName(ctxt);
+    if (name == NULL) {
+	if (CUR == '*') {
+	    NEXT;
+	    PUSH(XML_OP_ALL, NULL, NULL);
+	    return;
+	} else {
+	    ERROR(NULL, NULL, NULL,
+		    "xmlCompileStepPattern : Name expected\n");
+	    ctxt->error = 1;
+	    return;
+	}
+    }
+    SKIP_BLANKS;
+    if (CUR == ':') {
+	NEXT;
+	if (CUR != ':') {
+	    xmlChar *prefix = name;
+	    xmlNsPtr ns;
+
+	    /*
+	     * This is a namespace match
+	     */
+	    token = xmlPatScanName(ctxt);
+	    ns = xmlSearchNs(NULL, ctxt->elem, prefix);
+	    if (ns == NULL) {
+		ERROR5(NULL, NULL, NULL,
+	    "xmlCompileStepPattern : no namespace bound to prefix %s\n",
+				 prefix);
+		ctxt->error = 1;
+		goto error;
+	    } else {
+		URL = xmlStrdup(ns->href);
+	    }
+	    xmlFree(prefix);
+	    if (token == NULL) {
+		if (CUR == '*') {
+		    NEXT;
+		    PUSH(XML_OP_NS, URL, NULL);
+		} else {
+		    ERROR(NULL, NULL, NULL,
+			    "xmlCompileStepPattern : Name expected\n");
+		    ctxt->error = 1;
+		    goto error;
+		}
+	    } else {
+		PUSH(XML_OP_ELEM, token, URL);
+	    }
+	} else {
+	    NEXT;
+	    if (xmlStrEqual(token, (const xmlChar *) "child")) {
+		xmlFree(token);
+		token = xmlPatScanName(ctxt);
+		if (token == NULL) {
+	            if (CUR == '*') {
+            	        NEXT;
+	                PUSH(XML_OP_ALL, token, NULL);
+	                return;
+	            } else {
+		        ERROR(NULL, NULL, NULL,
+			    "xmlCompileStepPattern : QName expected\n");
+		        ctxt->error = 1;
+		        goto error;
+		    }
+		}
+		TODO
+		/* URI = xsltGetQNameURI(ctxt->elem, &token); */
+		if (token == NULL) {
+		    ctxt->error = 1;
+		    goto error;
+		} else {
+		    name = xmlStrdup(token);
+		    if (URI != NULL)
+			URL = xmlStrdup(URI);
+		}
+		PUSH(XML_OP_CHILD, name, URL);
+	    } else if (xmlStrEqual(token, (const xmlChar *) "attribute")) {
+		xmlFree(token);
+		token = xmlPatScanName(ctxt);
+		if (token == NULL) {
+		    ERROR(NULL, NULL, NULL,
+			    "xmlCompileStepPattern : QName expected\n");
+		    ctxt->error = 1;
+		    goto error;
+		}
+		TODO
+		/* URI = xsltGetQNameURI(ctxt->elem, &token); */
+		if (token == NULL) {
+		    ctxt->error = 1;
+		    goto error;
+		} else {
+		    name = xmlStrdup(token);
+		    if (URI != NULL)
+			URL = xmlStrdup(URI);
+		}
+		PUSH(XML_OP_ATTR, name, URL);
+	    } else {
+		ERROR(NULL, NULL, NULL,
+		    "xmlCompileStepPattern : 'child' or 'attribute' expected\n");
+		ctxt->error = 1;
+		goto error;
+	    }
+	    xmlFree(token);
+	}
+    } else if (CUR == '*') {
+	NEXT;
+	PUSH(XML_OP_ALL, token, NULL);
+    } else {
+	if (name == NULL) {
+	    ctxt->error = 1;
+	    goto error;
+	}
+	PUSH(XML_OP_ELEM, name, NULL);
+    }
+    return;
+error:
+    if (token != NULL)
+	xmlFree(token);
+    if (name != NULL)
+	xmlFree(name);
+}
+
+/**
+ * xmlCompilePathPattern:
+ * @ctxt:  the compilation context
+ *
+ * Compile the Path Pattern and generates a precompiled
+ * form suitable for fast matching.
+ *
+ * [5]    Path    ::=    ('.//')? ( Step '/' )* ( Step | '@' NameTest ) 
+ */
+static void
+xmlCompilePathPattern(xmlPatParserContextPtr ctxt) {
+    SKIP_BLANKS;
+    if ((CUR == '/') && (NXT(1) == '/')) {
+	/*
+	 * since we reverse the query
+	 * a leading // can be safely ignored
+	 */
+	NEXT;
+	NEXT;
+    } else if ((CUR == '.') && (NXT(1) == '/') && (NXT(2) == '/')) {
+	/*
+	 * a leading .// can be safely ignored
+	 */
+	NEXT;
+	NEXT;
+	NEXT;
+    }
+    if (CUR == '@') {
+	TODO
+    } else {
+	xmlCompileStepPattern(ctxt);
+	SKIP_BLANKS;
+	while (CUR == '/') {
+	    if ((CUR == '/') && (NXT(1) == '/')) {
+	        PUSH(XML_OP_ANCESTOR, NULL, NULL);
+		NEXT;
+		NEXT;
+		SKIP_BLANKS;
+		xmlCompileStepPattern(ctxt);
+	    } else {
+	        PUSH(XML_OP_PARENT, NULL, NULL);
+		NEXT;
+		SKIP_BLANKS;
+		if ((CUR != 0) || (CUR == '|')) {
+		    xmlCompileStepPattern(ctxt);
+		}
+	    }
+	}
+    }
+error:
+    return;
+}
+/************************************************************************
+ *									*
+ *			The public interfaces				*
+ *									*
+ ************************************************************************/
+
+/**
+ * xmlPatterncompile:
+ * @pattern: the pattern to compile
+ * @dict: an optional dictionnary for interned strings
+ * @flags: compilation flags, undefined yet
+ * @namespaces: the prefix definitions, array of [URI, prefix] or NULL
+ *
+ * Compile a pattern.
+ *
+ * Returns the compiled for of the pattern or NULL in case of error
+ */
+xmlPatternPtr
+xmlPatterncompile(const xmlChar *pattern, xmlDict *dict,
+                  int flags ATTRIBUTE_UNUSED,
+                  const xmlChar **namespaces) {
+    xmlPatternPtr ret = NULL;
+    xmlPatParserContextPtr ctxt = NULL;
+
+    ctxt = xmlNewPatParserContext(pattern, dict, namespaces);
+    if (ctxt == NULL) goto error;
+    ret = xmlNewPattern();
+    if (ret == NULL) goto error;
+    ctxt->comp = ret;
+
+    xmlCompilePathPattern(ctxt);
+    xmlFreePatParserContext(ctxt);
+
+    xmlReversePattern(ret);
+    return(ret);
+error:
+    if (ctxt != NULL) xmlFreePatParserContext(ctxt);
+    if (ret != NULL) xmlFreePattern(ret);
+    return(NULL);
+}
+
+/**
+ * xmlPatternMatch:
+ * @comp: the precompiled pattern
+ * @node: a node
+ *
+ * Test wether the node matches the pattern
+ *
+ * Returns 1 if it matches, 0 if it doesn't and -1 in case of failure
+ */
+int
+xmlPatternMatch(xmlPatternPtr comp, xmlNodePtr node)
+{
+    if ((comp == NULL) || (node == NULL))
+        return(-1);
+    return(xmlPatMatch(comp, node));
+}
+
+#endif /* LIBXML_PATTERN_ENABLED */
diff --git a/src/libxml/src/relaxng.c b/src/libxml/src/relaxng.c
new file mode 100644
index 0000000..6bf62ee
--- /dev/null
+++ b/src/libxml/src/relaxng.c
@@ -0,0 +1,10677 @@
+/*
+ * relaxng.c : implementation of the Relax-NG handling and validity checking
+ *
+ * See Copyright for the status of this software.
+ *
+ * Daniel Veillard <veillard@redhat.com>
+ */
+
+/**
+ * TODO:
+ * - add support for DTD compatibility spec
+ *   http://www.oasis-open.org/committees/relax-ng/compatibility-20011203.html
+ * - report better mem allocations pbms at runtime and abort immediately.
+ */
+
+#define IN_LIBXML
+#include "libxml.h"
+
+#ifdef LIBXML_SCHEMAS_ENABLED
+
+#include <string.h>
+#include <stdio.h>
+#include <libxml/xmlmemory.h>
+#include <libxml/parser.h>
+#include <libxml/parserInternals.h>
+#include <libxml/hash.h>
+#include <libxml/uri.h>
+
+#include <libxml/relaxng.h>
+
+#include <libxml/xmlschemastypes.h>
+#include <libxml/xmlautomata.h>
+#include <libxml/xmlregexp.h>
+#include <libxml/xmlschemastypes.h>
+
+/*
+ * The Relax-NG namespace
+ */
+static const xmlChar *xmlRelaxNGNs = (const xmlChar *)
+    "http://relaxng.org/ns/structure/1.0";
+
+#define IS_RELAXNG(node, type)						\
+   ((node != NULL) && (node->ns != NULL) &&				\
+    (xmlStrEqual(node->name, (const xmlChar *) type)) &&		\
+    (xmlStrEqual(node->ns->href, xmlRelaxNGNs)))
+
+
+/* #define DEBUG 1 */
+
+/* #define DEBUG_GRAMMAR 1 */
+
+/* #define DEBUG_CONTENT 1 */
+
+/* #define DEBUG_TYPE 1 */
+
+/* #define DEBUG_VALID 1 */
+
+/* #define DEBUG_INTERLEAVE 1 */
+
+/* #define DEBUG_LIST 1 */
+
+/* #define DEBUG_INCLUDE */
+
+/* #define DEBUG_ERROR 1 */
+
+/* #define DEBUG_COMPILE 1 */
+
+/* #define DEBUG_PROGRESSIVE 1 */
+
+#define MAX_ERROR 5
+
+#define TODO 								\
+    xmlGenericError(xmlGenericErrorContext,				\
+	    "Unimplemented block at %s:%d\n",				\
+            __FILE__, __LINE__);
+
+typedef struct _xmlRelaxNGSchema xmlRelaxNGSchema;
+typedef xmlRelaxNGSchema *xmlRelaxNGSchemaPtr;
+
+typedef struct _xmlRelaxNGDefine xmlRelaxNGDefine;
+typedef xmlRelaxNGDefine *xmlRelaxNGDefinePtr;
+
+typedef struct _xmlRelaxNGDocument xmlRelaxNGDocument;
+typedef xmlRelaxNGDocument *xmlRelaxNGDocumentPtr;
+
+typedef struct _xmlRelaxNGInclude xmlRelaxNGInclude;
+typedef xmlRelaxNGInclude *xmlRelaxNGIncludePtr;
+
+typedef enum {
+    XML_RELAXNG_COMBINE_UNDEFINED = 0,  /* undefined */
+    XML_RELAXNG_COMBINE_CHOICE, /* choice */
+    XML_RELAXNG_COMBINE_INTERLEAVE      /* interleave */
+} xmlRelaxNGCombine;
+
+typedef enum {
+    XML_RELAXNG_CONTENT_ERROR = -1,
+    XML_RELAXNG_CONTENT_EMPTY = 0,
+    XML_RELAXNG_CONTENT_SIMPLE,
+    XML_RELAXNG_CONTENT_COMPLEX
+} xmlRelaxNGContentType;
+
+typedef struct _xmlRelaxNGGrammar xmlRelaxNGGrammar;
+typedef xmlRelaxNGGrammar *xmlRelaxNGGrammarPtr;
+
+struct _xmlRelaxNGGrammar {
+    xmlRelaxNGGrammarPtr parent;        /* the parent grammar if any */
+    xmlRelaxNGGrammarPtr children;      /* the children grammar if any */
+    xmlRelaxNGGrammarPtr next;  /* the next grammar if any */
+    xmlRelaxNGDefinePtr start;  /* <start> content */
+    xmlRelaxNGCombine combine;  /* the default combine value */
+    xmlRelaxNGDefinePtr startList;      /* list of <start> definitions */
+    xmlHashTablePtr defs;       /* define* */
+    xmlHashTablePtr refs;       /* references */
+};
+
+
+typedef enum {
+    XML_RELAXNG_NOOP = -1,      /* a no operation from simplification  */
+    XML_RELAXNG_EMPTY = 0,      /* an empty pattern */
+    XML_RELAXNG_NOT_ALLOWED,    /* not allowed top */
+    XML_RELAXNG_EXCEPT,         /* except present in nameclass defs */
+    XML_RELAXNG_TEXT,           /* textual content */
+    XML_RELAXNG_ELEMENT,        /* an element */
+    XML_RELAXNG_DATATYPE,       /* extenal data type definition */
+    XML_RELAXNG_PARAM,          /* extenal data type parameter */
+    XML_RELAXNG_VALUE,          /* value from an extenal data type definition */
+    XML_RELAXNG_LIST,           /* a list of patterns */
+    XML_RELAXNG_ATTRIBUTE,      /* an attrbute following a pattern */
+    XML_RELAXNG_DEF,            /* a definition */
+    XML_RELAXNG_REF,            /* reference to a definition */
+    XML_RELAXNG_EXTERNALREF,    /* reference to an external def */
+    XML_RELAXNG_PARENTREF,      /* reference to a def in the parent grammar */
+    XML_RELAXNG_OPTIONAL,       /* optional patterns */
+    XML_RELAXNG_ZEROORMORE,     /* zero or more non empty patterns */
+    XML_RELAXNG_ONEORMORE,      /* one or more non empty patterns */
+    XML_RELAXNG_CHOICE,         /* a choice between non empty patterns */
+    XML_RELAXNG_GROUP,          /* a pair/group of non empty patterns */
+    XML_RELAXNG_INTERLEAVE,     /* interleaving choice of non-empty patterns */
+    XML_RELAXNG_START           /* Used to keep track of starts on grammars */
+} xmlRelaxNGType;
+
+#define IS_NULLABLE		(1 << 0)
+#define IS_NOT_NULLABLE		(1 << 1)
+#define IS_INDETERMINIST	(1 << 2)
+#define IS_MIXED		(1 << 3)
+#define IS_TRIABLE		(1 << 4)
+#define IS_PROCESSED		(1 << 5)
+#define IS_COMPILABLE		(1 << 6)
+#define IS_NOT_COMPILABLE	(1 << 7)
+
+struct _xmlRelaxNGDefine {
+    xmlRelaxNGType type;        /* the type of definition */
+    xmlNodePtr node;            /* the node in the source */
+    xmlChar *name;              /* the element local name if present */
+    xmlChar *ns;                /* the namespace local name if present */
+    xmlChar *value;             /* value when available */
+    void *data;                 /* data lib or specific pointer */
+    xmlRelaxNGDefinePtr content;        /* the expected content */
+    xmlRelaxNGDefinePtr parent; /* the parent definition, if any */
+    xmlRelaxNGDefinePtr next;   /* list within grouping sequences */
+    xmlRelaxNGDefinePtr attrs;  /* list of attributes for elements */
+    xmlRelaxNGDefinePtr nameClass;      /* the nameClass definition if any */
+    xmlRelaxNGDefinePtr nextHash;       /* next define in defs/refs hash tables */
+    short depth;                /* used for the cycle detection */
+    short dflags;               /* define related flags */
+    xmlRegexpPtr contModel;     /* a compiled content model if available */
+};
+
+/**
+ * _xmlRelaxNG:
+ *
+ * A RelaxNGs definition
+ */
+struct _xmlRelaxNG {
+    void *_private;             /* unused by the library for users or bindings */
+    xmlRelaxNGGrammarPtr topgrammar;
+    xmlDocPtr doc;
+
+    int idref;                  /* requires idref checking */
+
+    xmlHashTablePtr defs;       /* define */
+    xmlHashTablePtr refs;       /* references */
+    xmlRelaxNGDocumentPtr documents;    /* all the documents loaded */
+    xmlRelaxNGIncludePtr includes;      /* all the includes loaded */
+    int defNr;                  /* number of defines used */
+    xmlRelaxNGDefinePtr *defTab;        /* pointer to the allocated definitions */
+
+};
+
+#define XML_RELAXNG_IN_ATTRIBUTE	(1 << 0)
+#define XML_RELAXNG_IN_ONEORMORE	(1 << 1)
+#define XML_RELAXNG_IN_LIST		(1 << 2)
+#define XML_RELAXNG_IN_DATAEXCEPT	(1 << 3)
+#define XML_RELAXNG_IN_START		(1 << 4)
+#define XML_RELAXNG_IN_OOMGROUP		(1 << 5)
+#define XML_RELAXNG_IN_OOMINTERLEAVE	(1 << 6)
+#define XML_RELAXNG_IN_EXTERNALREF	(1 << 7)
+#define XML_RELAXNG_IN_ANYEXCEPT	(1 << 8)
+#define XML_RELAXNG_IN_NSEXCEPT		(1 << 9)
+
+struct _xmlRelaxNGParserCtxt {
+    void *userData;             /* user specific data block */
+    xmlRelaxNGValidityErrorFunc error;  /* the callback in case of errors */
+    xmlRelaxNGValidityWarningFunc warning;      /* the callback in case of warning */
+    xmlStructuredErrorFunc serror;
+    xmlRelaxNGValidErr err;
+
+    xmlRelaxNGPtr schema;       /* The schema in use */
+    xmlRelaxNGGrammarPtr grammar;       /* the current grammar */
+    xmlRelaxNGGrammarPtr parentgrammar; /* the parent grammar */
+    int flags;                  /* parser flags */
+    int nbErrors;               /* number of errors at parse time */
+    int nbWarnings;             /* number of warnings at parse time */
+    const xmlChar *define;      /* the current define scope */
+    xmlRelaxNGDefinePtr def;    /* the current define */
+
+    int nbInterleaves;
+    xmlHashTablePtr interleaves;        /* keep track of all the interleaves */
+
+    xmlRelaxNGDocumentPtr documents;    /* all the documents loaded */
+    xmlRelaxNGIncludePtr includes;      /* all the includes loaded */
+    xmlChar *URL;
+    xmlDocPtr document;
+
+    int defNr;                  /* number of defines used */
+    int defMax;                 /* number of defines aloocated */
+    xmlRelaxNGDefinePtr *defTab;        /* pointer to the allocated definitions */
+
+    const char *buffer;
+    int size;
+
+    /* the document stack */
+    xmlRelaxNGDocumentPtr doc;  /* Current parsed external ref */
+    int docNr;                  /* Depth of the parsing stack */
+    int docMax;                 /* Max depth of the parsing stack */
+    xmlRelaxNGDocumentPtr *docTab;      /* array of docs */
+
+    /* the include stack */
+    xmlRelaxNGIncludePtr inc;   /* Current parsed include */
+    int incNr;                  /* Depth of the include parsing stack */
+    int incMax;                 /* Max depth of the parsing stack */
+    xmlRelaxNGIncludePtr *incTab;       /* array of incs */
+
+    int idref;                  /* requires idref checking */
+
+    /* used to compile content models */
+    xmlAutomataPtr am;          /* the automata */
+    xmlAutomataStatePtr state;  /* used to build the automata */
+
+    int crng;			/* compact syntax and other flags */
+};
+
+#define FLAGS_IGNORABLE		1
+#define FLAGS_NEGATIVE		2
+#define FLAGS_MIXED_CONTENT	4
+
+/**
+ * xmlRelaxNGInterleaveGroup:
+ *
+ * A RelaxNGs partition set associated to lists of definitions
+ */
+typedef struct _xmlRelaxNGInterleaveGroup xmlRelaxNGInterleaveGroup;
+typedef xmlRelaxNGInterleaveGroup *xmlRelaxNGInterleaveGroupPtr;
+struct _xmlRelaxNGInterleaveGroup {
+    xmlRelaxNGDefinePtr rule;   /* the rule to satisfy */
+    xmlRelaxNGDefinePtr *defs;  /* the array of element definitions */
+    xmlRelaxNGDefinePtr *attrs; /* the array of attributes definitions */
+};
+
+#define IS_DETERMINIST		1
+#define IS_NEEDCHECK		2
+
+/**
+ * xmlRelaxNGPartitions:
+ *
+ * A RelaxNGs partition associated to an interleave group
+ */
+typedef struct _xmlRelaxNGPartition xmlRelaxNGPartition;
+typedef xmlRelaxNGPartition *xmlRelaxNGPartitionPtr;
+struct _xmlRelaxNGPartition {
+    int nbgroups;               /* number of groups in the partitions */
+    xmlHashTablePtr triage;     /* hash table used to direct nodes to the
+                                 * right group when possible */
+    int flags;                  /* determinist ? */
+    xmlRelaxNGInterleaveGroupPtr *groups;
+};
+
+/**
+ * xmlRelaxNGValidState:
+ *
+ * A RelaxNGs validation state
+ */
+#define MAX_ATTR 20
+typedef struct _xmlRelaxNGValidState xmlRelaxNGValidState;
+typedef xmlRelaxNGValidState *xmlRelaxNGValidStatePtr;
+struct _xmlRelaxNGValidState {
+    xmlNodePtr node;            /* the current node */
+    xmlNodePtr seq;             /* the sequence of children left to validate */
+    int nbAttrs;                /* the number of attributes */
+    int maxAttrs;               /* the size of attrs */
+    int nbAttrLeft;             /* the number of attributes left to validate */
+    xmlChar *value;             /* the value when operating on string */
+    xmlChar *endvalue;          /* the end value when operating on string */
+    xmlAttrPtr *attrs;          /* the array of attributes */
+};
+
+/**
+ * xmlRelaxNGStates:
+ *
+ * A RelaxNGs container for validation state
+ */
+typedef struct _xmlRelaxNGStates xmlRelaxNGStates;
+typedef xmlRelaxNGStates *xmlRelaxNGStatesPtr;
+struct _xmlRelaxNGStates {
+    int nbState;                /* the number of states */
+    int maxState;               /* the size of the array */
+    xmlRelaxNGValidStatePtr *tabState;
+};
+
+#define ERROR_IS_DUP	1
+
+/**
+ * xmlRelaxNGValidError:
+ *
+ * A RelaxNGs validation error
+ */
+typedef struct _xmlRelaxNGValidError xmlRelaxNGValidError;
+typedef xmlRelaxNGValidError *xmlRelaxNGValidErrorPtr;
+struct _xmlRelaxNGValidError {
+    xmlRelaxNGValidErr err;     /* the error number */
+    int flags;                  /* flags */
+    xmlNodePtr node;            /* the current node */
+    xmlNodePtr seq;             /* the current child */
+    const xmlChar *arg1;        /* first arg */
+    const xmlChar *arg2;        /* second arg */
+};
+
+/**
+ * xmlRelaxNGValidCtxt:
+ *
+ * A RelaxNGs validation context
+ */
+
+struct _xmlRelaxNGValidCtxt {
+    void *userData;             /* user specific data block */
+    xmlRelaxNGValidityErrorFunc error;  /* the callback in case of errors */
+    xmlRelaxNGValidityWarningFunc warning;      /* the callback in case of warning */
+    xmlStructuredErrorFunc serror;
+    int nbErrors;               /* number of errors in validation */
+
+    xmlRelaxNGPtr schema;       /* The schema in use */
+    xmlDocPtr doc;              /* the document being validated */
+    int flags;                  /* validation flags */
+    int depth;                  /* validation depth */
+    int idref;                  /* requires idref checking */
+    int errNo;                  /* the first error found */
+
+    /*
+     * Errors accumulated in branches may have to be stacked to be
+     * provided back when it's sure they affect validation.
+     */
+    xmlRelaxNGValidErrorPtr err;        /* Last error */
+    int errNr;                  /* Depth of the error stack */
+    int errMax;                 /* Max depth of the error stack */
+    xmlRelaxNGValidErrorPtr errTab;     /* stack of errors */
+
+    xmlRelaxNGValidStatePtr state;      /* the current validation state */
+    xmlRelaxNGStatesPtr states; /* the accumulated state list */
+
+    xmlRelaxNGStatesPtr freeState;      /* the pool of free valid states */
+    int freeStatesNr;
+    int freeStatesMax;
+    xmlRelaxNGStatesPtr *freeStates;    /* the pool of free state groups */
+
+    /*
+     * This is used for "progressive" validation
+     */
+    xmlRegExecCtxtPtr elem;     /* the current element regexp */
+    int elemNr;                 /* the number of element validated */
+    int elemMax;                /* the max depth of elements */
+    xmlRegExecCtxtPtr *elemTab; /* the stack of regexp runtime */
+    int pstate;                 /* progressive state */
+    xmlNodePtr pnode;           /* the current node */
+    xmlRelaxNGDefinePtr pdef;   /* the non-streamable definition */
+    int perr;                   /* signal error in content model
+                                 * outside the regexp */
+};
+
+/**
+ * xmlRelaxNGInclude:
+ *
+ * Structure associated to a RelaxNGs document element
+ */
+struct _xmlRelaxNGInclude {
+    xmlRelaxNGIncludePtr next;  /* keep a chain of includes */
+    xmlChar *href;              /* the normalized href value */
+    xmlDocPtr doc;              /* the associated XML document */
+    xmlRelaxNGDefinePtr content;        /* the definitions */
+    xmlRelaxNGPtr schema;       /* the schema */
+};
+
+/**
+ * xmlRelaxNGDocument:
+ *
+ * Structure associated to a RelaxNGs document element
+ */
+struct _xmlRelaxNGDocument {
+    xmlRelaxNGDocumentPtr next; /* keep a chain of documents */
+    xmlChar *href;              /* the normalized href value */
+    xmlDocPtr doc;              /* the associated XML document */
+    xmlRelaxNGDefinePtr content;        /* the definitions */
+    xmlRelaxNGPtr schema;       /* the schema */
+};
+
+
+/************************************************************************
+ *									*
+ * 		Some factorized error routines				*
+ *									*
+ ************************************************************************/
+
+/**
+ * xmlRngPErrMemory:
+ * @ctxt:  an Relax-NG parser context
+ * @extra:  extra informations
+ *
+ * Handle a redefinition of attribute error
+ */
+static void
+xmlRngPErrMemory(xmlRelaxNGParserCtxtPtr ctxt, const char *extra)
+{
+    xmlStructuredErrorFunc schannel = NULL;
+    xmlGenericErrorFunc channel = NULL;
+    void *data = NULL;
+
+    if (ctxt != NULL) {
+        channel = ctxt->error;
+        data = ctxt->userData;
+        ctxt->nbErrors++;
+        schannel = ctxt->serror;
+    }
+    if (extra)
+        __xmlRaiseError(schannel, channel, data,
+                        NULL, NULL, XML_FROM_RELAXNGP,
+                        XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0, extra,
+                        NULL, NULL, 0, 0,
+                        "Memory allocation failed : %s\n", extra);
+    else
+        __xmlRaiseError(schannel, channel, data,
+                        NULL, NULL, XML_FROM_RELAXNGP,
+                        XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0, NULL,
+                        NULL, NULL, 0, 0, "Memory allocation failed\n");
+}
+
+/**
+ * xmlRngVErrMemory:
+ * @ctxt:  a Relax-NG validation context
+ * @extra:  extra informations
+ *
+ * Handle a redefinition of attribute error
+ */
+static void
+xmlRngVErrMemory(xmlRelaxNGValidCtxtPtr ctxt, const char *extra)
+{
+    xmlStructuredErrorFunc schannel = NULL;
+    xmlGenericErrorFunc channel = NULL;
+    void *data = NULL;
+
+    if (ctxt != NULL) {
+        channel = ctxt->error;
+        data = ctxt->userData;
+        ctxt->nbErrors++;
+        schannel = ctxt->serror;
+    }
+    if (extra)
+        __xmlRaiseError(schannel, channel, data,
+                        NULL, NULL, XML_FROM_RELAXNGV,
+                        XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0, extra,
+                        NULL, NULL, 0, 0,
+                        "Memory allocation failed : %s\n", extra);
+    else
+        __xmlRaiseError(schannel, channel, data,
+                        NULL, NULL, XML_FROM_RELAXNGV,
+                        XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0, NULL,
+                        NULL, NULL, 0, 0, "Memory allocation failed\n");
+}
+
+/**
+ * xmlRngPErr:
+ * @ctxt:  a Relax-NG parser context
+ * @node:  the node raising the error
+ * @error:  the error code
+ * @msg:  message
+ * @str1:  extra info
+ * @str2:  extra info
+ *
+ * Handle a Relax NG Parsing error
+ */
+static void
+xmlRngPErr(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node, int error,
+           const char *msg, const xmlChar * str1, const xmlChar * str2)
+{
+    xmlStructuredErrorFunc schannel = NULL;
+    xmlGenericErrorFunc channel = NULL;
+    void *data = NULL;
+
+    if (ctxt != NULL) {
+        channel = ctxt->error;
+        data = ctxt->userData;
+        ctxt->nbErrors++;
+        schannel = ctxt->serror;
+    }
+    __xmlRaiseError(schannel, channel, data,
+                    NULL, node, XML_FROM_RELAXNGP,
+                    error, XML_ERR_ERROR, NULL, 0,
+                    (const char *) str1, (const char *) str2, NULL, 0, 0,
+                    msg, str1, str2);
+}
+
+/**
+ * xmlRngVErr:
+ * @ctxt:  a Relax-NG validation context
+ * @node:  the node raising the error
+ * @error:  the error code
+ * @msg:  message
+ * @str1:  extra info
+ * @str2:  extra info
+ *
+ * Handle a Relax NG Validation error
+ */
+static void
+xmlRngVErr(xmlRelaxNGValidCtxtPtr ctxt, xmlNodePtr node, int error,
+           const char *msg, const xmlChar * str1, const xmlChar * str2)
+{
+    xmlStructuredErrorFunc schannel = NULL;
+    xmlGenericErrorFunc channel = NULL;
+    void *data = NULL;
+
+    if (ctxt != NULL) {
+        channel = ctxt->error;
+        data = ctxt->userData;
+        ctxt->nbErrors++;
+        schannel = ctxt->serror;
+    }
+    __xmlRaiseError(schannel, channel, data,
+                    NULL, node, XML_FROM_RELAXNGV,
+                    error, XML_ERR_ERROR, NULL, 0,
+                    (const char *) str1, (const char *) str2, NULL, 0, 0,
+                    msg, str1, str2);
+}
+
+/************************************************************************
+ * 									*
+ * 		Preliminary type checking interfaces			*
+ * 									*
+ ************************************************************************/
+
+/**
+ * xmlRelaxNGTypeHave:
+ * @data:  data needed for the library
+ * @type:  the type name
+ * @value:  the value to check
+ *
+ * Function provided by a type library to check if a type is exported
+ *
+ * Returns 1 if yes, 0 if no and -1 in case of error.
+ */
+typedef int (*xmlRelaxNGTypeHave) (void *data, const xmlChar * type);
+
+/**
+ * xmlRelaxNGTypeCheck:
+ * @data:  data needed for the library
+ * @type:  the type name
+ * @value:  the value to check
+ * @result:  place to store the result if needed
+ *
+ * Function provided by a type library to check if a value match a type
+ *
+ * Returns 1 if yes, 0 if no and -1 in case of error.
+ */
+typedef int (*xmlRelaxNGTypeCheck) (void *data, const xmlChar * type,
+                                    const xmlChar * value, void **result,
+                                    xmlNodePtr node);
+
+/**
+ * xmlRelaxNGFacetCheck:
+ * @data:  data needed for the library
+ * @type:  the type name
+ * @facet:  the facet name
+ * @val:  the facet value
+ * @strval:  the string value
+ * @value:  the value to check
+ *
+ * Function provided by a type library to check a value facet
+ *
+ * Returns 1 if yes, 0 if no and -1 in case of error.
+ */
+typedef int (*xmlRelaxNGFacetCheck) (void *data, const xmlChar * type,
+                                     const xmlChar * facet,
+                                     const xmlChar * val,
+                                     const xmlChar * strval, void *value);
+
+/**
+ * xmlRelaxNGTypeFree:
+ * @data:  data needed for the library
+ * @result:  the value to free
+ *
+ * Function provided by a type library to free a returned result
+ */
+typedef void (*xmlRelaxNGTypeFree) (void *data, void *result);
+
+/**
+ * xmlRelaxNGTypeCompare:
+ * @data:  data needed for the library
+ * @type:  the type name
+ * @value1:  the first value
+ * @value2:  the second value
+ *
+ * Function provided by a type library to compare two values accordingly
+ * to a type.
+ *
+ * Returns 1 if yes, 0 if no and -1 in case of error.
+ */
+typedef int (*xmlRelaxNGTypeCompare) (void *data, const xmlChar * type,
+                                      const xmlChar * value1,
+                                      xmlNodePtr ctxt1,
+                                      void *comp1,
+                                      const xmlChar * value2,
+                                      xmlNodePtr ctxt2);
+typedef struct _xmlRelaxNGTypeLibrary xmlRelaxNGTypeLibrary;
+typedef xmlRelaxNGTypeLibrary *xmlRelaxNGTypeLibraryPtr;
+struct _xmlRelaxNGTypeLibrary {
+    const xmlChar *namespace;   /* the datatypeLibrary value */
+    void *data;                 /* data needed for the library */
+    xmlRelaxNGTypeHave have;    /* the export function */
+    xmlRelaxNGTypeCheck check;  /* the checking function */
+    xmlRelaxNGTypeCompare comp; /* the compare function */
+    xmlRelaxNGFacetCheck facet; /* the facet check function */
+    xmlRelaxNGTypeFree freef;   /* the freeing function */
+};
+
+/************************************************************************
+ * 									*
+ * 			Allocation functions				*
+ * 									*
+ ************************************************************************/
+static void xmlRelaxNGFreeGrammar(xmlRelaxNGGrammarPtr grammar);
+static void xmlRelaxNGFreeDefine(xmlRelaxNGDefinePtr define);
+static void xmlRelaxNGNormExtSpace(xmlChar * value);
+static void xmlRelaxNGFreeInnerSchema(xmlRelaxNGPtr schema);
+static int xmlRelaxNGEqualValidState(xmlRelaxNGValidCtxtPtr ctxt
+                                     ATTRIBUTE_UNUSED,
+                                     xmlRelaxNGValidStatePtr state1,
+                                     xmlRelaxNGValidStatePtr state2);
+static void xmlRelaxNGFreeValidState(xmlRelaxNGValidCtxtPtr ctxt,
+                                     xmlRelaxNGValidStatePtr state);
+
+/**
+ * xmlRelaxNGFreeDocument:
+ * @docu:  a document structure
+ *
+ * Deallocate a RelaxNG document structure.
+ */
+static void
+xmlRelaxNGFreeDocument(xmlRelaxNGDocumentPtr docu)
+{
+    if (docu == NULL)
+        return;
+
+    if (docu->href != NULL)
+        xmlFree(docu->href);
+    if (docu->doc != NULL)
+        xmlFreeDoc(docu->doc);
+    if (docu->schema != NULL)
+        xmlRelaxNGFreeInnerSchema(docu->schema);
+    xmlFree(docu);
+}
+
+/**
+ * xmlRelaxNGFreeDocumentList:
+ * @docu:  a list of  document structure
+ *
+ * Deallocate a RelaxNG document structures.
+ */
+static void
+xmlRelaxNGFreeDocumentList(xmlRelaxNGDocumentPtr docu)
+{
+    xmlRelaxNGDocumentPtr next;
+
+    while (docu != NULL) {
+        next = docu->next;
+        xmlRelaxNGFreeDocument(docu);
+        docu = next;
+    }
+}
+
+/**
+ * xmlRelaxNGFreeInclude:
+ * @incl:  a include structure
+ *
+ * Deallocate a RelaxNG include structure.
+ */
+static void
+xmlRelaxNGFreeInclude(xmlRelaxNGIncludePtr incl)
+{
+    if (incl == NULL)
+        return;
+
+    if (incl->href != NULL)
+        xmlFree(incl->href);
+    if (incl->doc != NULL)
+        xmlFreeDoc(incl->doc);
+    if (incl->schema != NULL)
+        xmlRelaxNGFree(incl->schema);
+    xmlFree(incl);
+}
+
+/**
+ * xmlRelaxNGFreeIncludeList:
+ * @incl:  a include structure list
+ *
+ * Deallocate a RelaxNG include structure.
+ */
+static void
+xmlRelaxNGFreeIncludeList(xmlRelaxNGIncludePtr incl)
+{
+    xmlRelaxNGIncludePtr next;
+
+    while (incl != NULL) {
+        next = incl->next;
+        xmlRelaxNGFreeInclude(incl);
+        incl = next;
+    }
+}
+
+/**
+ * xmlRelaxNGNewRelaxNG:
+ * @ctxt:  a Relax-NG validation context (optional)
+ *
+ * Allocate a new RelaxNG structure.
+ *
+ * Returns the newly allocated structure or NULL in case or error
+ */
+static xmlRelaxNGPtr
+xmlRelaxNGNewRelaxNG(xmlRelaxNGParserCtxtPtr ctxt)
+{
+    xmlRelaxNGPtr ret;
+
+    ret = (xmlRelaxNGPtr) xmlMalloc(sizeof(xmlRelaxNG));
+    if (ret == NULL) {
+        xmlRngPErrMemory(ctxt, NULL);
+        return (NULL);
+    }
+    memset(ret, 0, sizeof(xmlRelaxNG));
+
+    return (ret);
+}
+
+/**
+ * xmlRelaxNGFreeInnerSchema:
+ * @schema:  a schema structure
+ *
+ * Deallocate a RelaxNG schema structure.
+ */
+static void
+xmlRelaxNGFreeInnerSchema(xmlRelaxNGPtr schema)
+{
+    if (schema == NULL)
+        return;
+
+    if (schema->doc != NULL)
+        xmlFreeDoc(schema->doc);
+    if (schema->defTab != NULL) {
+        int i;
+
+        for (i = 0; i < schema->defNr; i++)
+            xmlRelaxNGFreeDefine(schema->defTab[i]);
+        xmlFree(schema->defTab);
+    }
+
+    xmlFree(schema);
+}
+
+/**
+ * xmlRelaxNGFree:
+ * @schema:  a schema structure
+ *
+ * Deallocate a RelaxNG structure.
+ */
+void
+xmlRelaxNGFree(xmlRelaxNGPtr schema)
+{
+    if (schema == NULL)
+        return;
+
+    if (schema->topgrammar != NULL)
+        xmlRelaxNGFreeGrammar(schema->topgrammar);
+    if (schema->doc != NULL)
+        xmlFreeDoc(schema->doc);
+    if (schema->documents != NULL)
+        xmlRelaxNGFreeDocumentList(schema->documents);
+    if (schema->includes != NULL)
+        xmlRelaxNGFreeIncludeList(schema->includes);
+    if (schema->defTab != NULL) {
+        int i;
+
+        for (i = 0; i < schema->defNr; i++)
+            xmlRelaxNGFreeDefine(schema->defTab[i]);
+        xmlFree(schema->defTab);
+    }
+
+    xmlFree(schema);
+}
+
+/**
+ * xmlRelaxNGNewGrammar:
+ * @ctxt:  a Relax-NG validation context (optional)
+ *
+ * Allocate a new RelaxNG grammar.
+ *
+ * Returns the newly allocated structure or NULL in case or error
+ */
+static xmlRelaxNGGrammarPtr
+xmlRelaxNGNewGrammar(xmlRelaxNGParserCtxtPtr ctxt)
+{
+    xmlRelaxNGGrammarPtr ret;
+
+    ret = (xmlRelaxNGGrammarPtr) xmlMalloc(sizeof(xmlRelaxNGGrammar));
+    if (ret == NULL) {
+        xmlRngPErrMemory(ctxt, NULL);
+        return (NULL);
+    }
+    memset(ret, 0, sizeof(xmlRelaxNGGrammar));
+
+    return (ret);
+}
+
+/**
+ * xmlRelaxNGFreeGrammar:
+ * @grammar:  a grammar structure
+ *
+ * Deallocate a RelaxNG grammar structure.
+ */
+static void
+xmlRelaxNGFreeGrammar(xmlRelaxNGGrammarPtr grammar)
+{
+    if (grammar == NULL)
+        return;
+
+    if (grammar->children != NULL) {
+        xmlRelaxNGFreeGrammar(grammar->children);
+    }
+    if (grammar->next != NULL) {
+        xmlRelaxNGFreeGrammar(grammar->next);
+    }
+    if (grammar->refs != NULL) {
+        xmlHashFree(grammar->refs, NULL);
+    }
+    if (grammar->defs != NULL) {
+        xmlHashFree(grammar->defs, NULL);
+    }
+
+    xmlFree(grammar);
+}
+
+/**
+ * xmlRelaxNGNewDefine:
+ * @ctxt:  a Relax-NG validation context
+ * @node:  the node in the input document.
+ *
+ * Allocate a new RelaxNG define.
+ *
+ * Returns the newly allocated structure or NULL in case or error
+ */
+static xmlRelaxNGDefinePtr
+xmlRelaxNGNewDefine(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
+{
+    xmlRelaxNGDefinePtr ret;
+
+    if (ctxt->defMax == 0) {
+        ctxt->defMax = 16;
+        ctxt->defNr = 0;
+        ctxt->defTab = (xmlRelaxNGDefinePtr *)
+            xmlMalloc(ctxt->defMax * sizeof(xmlRelaxNGDefinePtr));
+        if (ctxt->defTab == NULL) {
+            xmlRngPErrMemory(ctxt, "allocating define\n");
+            return (NULL);
+        }
+    } else if (ctxt->defMax <= ctxt->defNr) {
+        xmlRelaxNGDefinePtr *tmp;
+
+        ctxt->defMax *= 2;
+        tmp = (xmlRelaxNGDefinePtr *) xmlRealloc(ctxt->defTab,
+                                                 ctxt->defMax *
+                                                 sizeof
+                                                 (xmlRelaxNGDefinePtr));
+        if (tmp == NULL) {
+            xmlRngPErrMemory(ctxt, "allocating define\n");
+            return (NULL);
+        }
+        ctxt->defTab = tmp;
+    }
+    ret = (xmlRelaxNGDefinePtr) xmlMalloc(sizeof(xmlRelaxNGDefine));
+    if (ret == NULL) {
+        xmlRngPErrMemory(ctxt, "allocating define\n");
+        return (NULL);
+    }
+    memset(ret, 0, sizeof(xmlRelaxNGDefine));
+    ctxt->defTab[ctxt->defNr++] = ret;
+    ret->node = node;
+    ret->depth = -1;
+    return (ret);
+}
+
+/**
+ * xmlRelaxNGFreePartition:
+ * @partitions:  a partition set structure
+ *
+ * Deallocate RelaxNG partition set structures.
+ */
+static void
+xmlRelaxNGFreePartition(xmlRelaxNGPartitionPtr partitions)
+{
+    xmlRelaxNGInterleaveGroupPtr group;
+    int j;
+
+    if (partitions != NULL) {
+        if (partitions->groups != NULL) {
+            for (j = 0; j < partitions->nbgroups; j++) {
+                group = partitions->groups[j];
+                if (group != NULL) {
+                    if (group->defs != NULL)
+                        xmlFree(group->defs);
+                    if (group->attrs != NULL)
+                        xmlFree(group->attrs);
+                    xmlFree(group);
+                }
+            }
+            xmlFree(partitions->groups);
+        }
+        if (partitions->triage != NULL) {
+            xmlHashFree(partitions->triage, NULL);
+        }
+        xmlFree(partitions);
+    }
+}
+
+/**
+ * xmlRelaxNGFreeDefine:
+ * @define:  a define structure
+ *
+ * Deallocate a RelaxNG define structure.
+ */
+static void
+xmlRelaxNGFreeDefine(xmlRelaxNGDefinePtr define)
+{
+    if (define == NULL)
+        return;
+
+    if ((define->type == XML_RELAXNG_VALUE) && (define->attrs != NULL)) {
+        xmlRelaxNGTypeLibraryPtr lib;
+
+        lib = (xmlRelaxNGTypeLibraryPtr) define->data;
+        if ((lib != NULL) && (lib->freef != NULL))
+            lib->freef(lib->data, (void *) define->attrs);
+    }
+    if ((define->data != NULL) && (define->type == XML_RELAXNG_INTERLEAVE))
+        xmlRelaxNGFreePartition((xmlRelaxNGPartitionPtr) define->data);
+    if ((define->data != NULL) && (define->type == XML_RELAXNG_CHOICE))
+        xmlHashFree((xmlHashTablePtr) define->data, NULL);
+    if (define->name != NULL)
+        xmlFree(define->name);
+    if (define->ns != NULL)
+        xmlFree(define->ns);
+    if (define->value != NULL)
+        xmlFree(define->value);
+    if (define->contModel != NULL)
+        xmlRegFreeRegexp(define->contModel);
+    xmlFree(define);
+}
+
+/**
+ * xmlRelaxNGNewStates:
+ * @ctxt:  a Relax-NG validation context
+ * @size:  the default size for the container
+ *
+ * Allocate a new RelaxNG validation state container
+ *
+ * Returns the newly allocated structure or NULL in case or error
+ */
+static xmlRelaxNGStatesPtr
+xmlRelaxNGNewStates(xmlRelaxNGValidCtxtPtr ctxt, int size)
+{
+    xmlRelaxNGStatesPtr ret;
+
+    if ((ctxt != NULL) &&
+        (ctxt->freeState != NULL) && (ctxt->freeStatesNr > 0)) {
+        ctxt->freeStatesNr--;
+        ret = ctxt->freeStates[ctxt->freeStatesNr];
+        ret->nbState = 0;
+        return (ret);
+    }
+    if (size < 16)
+        size = 16;
+
+    ret = (xmlRelaxNGStatesPtr) xmlMalloc(sizeof(xmlRelaxNGStates) +
+                                          (size -
+                                           1) *
+                                          sizeof(xmlRelaxNGValidStatePtr));
+    if (ret == NULL) {
+        xmlRngVErrMemory(ctxt, "allocating states\n");
+        return (NULL);
+    }
+    ret->nbState = 0;
+    ret->maxState = size;
+    ret->tabState = (xmlRelaxNGValidStatePtr *) xmlMalloc((size) *
+                                                          sizeof
+                                                          (xmlRelaxNGValidStatePtr));
+    if (ret->tabState == NULL) {
+        xmlRngVErrMemory(ctxt, "allocating states\n");
+        xmlFree(ret);
+        return (NULL);
+    }
+    return (ret);
+}
+
+/**
+ * xmlRelaxNGAddStateUniq:
+ * @ctxt:  a Relax-NG validation context
+ * @states:  the states container
+ * @state:  the validation state
+ *
+ * Add a RelaxNG validation state to the container without checking
+ * for unicity.
+ *
+ * Return 1 in case of success and 0 if this is a duplicate and -1 on error
+ */
+static int
+xmlRelaxNGAddStatesUniq(xmlRelaxNGValidCtxtPtr ctxt,
+                        xmlRelaxNGStatesPtr states,
+                        xmlRelaxNGValidStatePtr state)
+{
+    if (state == NULL) {
+        return (-1);
+    }
+    if (states->nbState >= states->maxState) {
+        xmlRelaxNGValidStatePtr *tmp;
+        int size;
+
+        size = states->maxState * 2;
+        tmp = (xmlRelaxNGValidStatePtr *) xmlRealloc(states->tabState,
+                                                     (size) *
+                                                     sizeof
+                                                     (xmlRelaxNGValidStatePtr));
+        if (tmp == NULL) {
+            xmlRngVErrMemory(ctxt, "adding states\n");
+            return (-1);
+        }
+        states->tabState = tmp;
+        states->maxState = size;
+    }
+    states->tabState[states->nbState++] = state;
+    return (1);
+}
+
+/**
+ * xmlRelaxNGAddState:
+ * @ctxt:  a Relax-NG validation context
+ * @states:  the states container
+ * @state:  the validation state
+ *
+ * Add a RelaxNG validation state to the container
+ *
+ * Return 1 in case of success and 0 if this is a duplicate and -1 on error
+ */
+static int
+xmlRelaxNGAddStates(xmlRelaxNGValidCtxtPtr ctxt,
+                    xmlRelaxNGStatesPtr states,
+                    xmlRelaxNGValidStatePtr state)
+{
+    int i;
+
+    if (state == NULL) {
+        return (-1);
+    }
+    if (states->nbState >= states->maxState) {
+        xmlRelaxNGValidStatePtr *tmp;
+        int size;
+
+        size = states->maxState * 2;
+        tmp = (xmlRelaxNGValidStatePtr *) xmlRealloc(states->tabState,
+                                                     (size) *
+                                                     sizeof
+                                                     (xmlRelaxNGValidStatePtr));
+        if (tmp == NULL) {
+            xmlRngVErrMemory(ctxt, "adding states\n");
+            return (-1);
+        }
+        states->tabState = tmp;
+        states->maxState = size;
+    }
+    for (i = 0; i < states->nbState; i++) {
+        if (xmlRelaxNGEqualValidState(ctxt, state, states->tabState[i])) {
+            xmlRelaxNGFreeValidState(ctxt, state);
+            return (0);
+        }
+    }
+    states->tabState[states->nbState++] = state;
+    return (1);
+}
+
+/**
+ * xmlRelaxNGFreeStates:
+ * @ctxt:  a Relax-NG validation context
+ * @states:  teh container
+ *
+ * Free a RelaxNG validation state container
+ */
+static void
+xmlRelaxNGFreeStates(xmlRelaxNGValidCtxtPtr ctxt,
+                     xmlRelaxNGStatesPtr states)
+{
+    if (states == NULL)
+        return;
+    if ((ctxt != NULL) && (ctxt->freeStates == NULL)) {
+        ctxt->freeStatesMax = 40;
+        ctxt->freeStatesNr = 0;
+        ctxt->freeStates = (xmlRelaxNGStatesPtr *)
+            xmlMalloc(ctxt->freeStatesMax * sizeof(xmlRelaxNGStatesPtr));
+        if (ctxt->freeStates == NULL) {
+            xmlRngVErrMemory(ctxt, "storing states\n");
+        }
+    } else if ((ctxt != NULL)
+               && (ctxt->freeStatesNr >= ctxt->freeStatesMax)) {
+        xmlRelaxNGStatesPtr *tmp;
+
+        tmp = (xmlRelaxNGStatesPtr *) xmlRealloc(ctxt->freeStates,
+                                                 2 * ctxt->freeStatesMax *
+                                                 sizeof
+                                                 (xmlRelaxNGStatesPtr));
+        if (tmp == NULL) {
+            xmlRngVErrMemory(ctxt, "storing states\n");
+            xmlFree(states->tabState);
+            xmlFree(states);
+            return;
+        }
+        ctxt->freeStates = tmp;
+        ctxt->freeStatesMax *= 2;
+    }
+    if ((ctxt == NULL) || (ctxt->freeState == NULL)) {
+        xmlFree(states->tabState);
+        xmlFree(states);
+    } else {
+        ctxt->freeStates[ctxt->freeStatesNr++] = states;
+    }
+}
+
+/**
+ * xmlRelaxNGNewValidState:
+ * @ctxt:  a Relax-NG validation context
+ * @node:  the current node or NULL for the document
+ *
+ * Allocate a new RelaxNG validation state
+ *
+ * Returns the newly allocated structure or NULL in case or error
+ */
+static xmlRelaxNGValidStatePtr
+xmlRelaxNGNewValidState(xmlRelaxNGValidCtxtPtr ctxt, xmlNodePtr node)
+{
+    xmlRelaxNGValidStatePtr ret;
+    xmlAttrPtr attr;
+    xmlAttrPtr attrs[MAX_ATTR];
+    int nbAttrs = 0;
+    xmlNodePtr root = NULL;
+
+    if (node == NULL) {
+        root = xmlDocGetRootElement(ctxt->doc);
+        if (root == NULL)
+            return (NULL);
+    } else {
+        attr = node->properties;
+        while (attr != NULL) {
+            if (nbAttrs < MAX_ATTR)
+                attrs[nbAttrs++] = attr;
+            else
+                nbAttrs++;
+            attr = attr->next;
+        }
+    }
+    if ((ctxt->freeState != NULL) && (ctxt->freeState->nbState > 0)) {
+        ctxt->freeState->nbState--;
+        ret = ctxt->freeState->tabState[ctxt->freeState->nbState];
+    } else {
+        ret =
+            (xmlRelaxNGValidStatePtr)
+            xmlMalloc(sizeof(xmlRelaxNGValidState));
+        if (ret == NULL) {
+            xmlRngVErrMemory(ctxt, "allocating states\n");
+            return (NULL);
+        }
+        memset(ret, 0, sizeof(xmlRelaxNGValidState));
+    }
+    ret->value = NULL;
+    ret->endvalue = NULL;
+    if (node == NULL) {
+        ret->node = (xmlNodePtr) ctxt->doc;
+        ret->seq = root;
+    } else {
+        ret->node = node;
+        ret->seq = node->children;
+    }
+    ret->nbAttrs = 0;
+    if (nbAttrs > 0) {
+        if (ret->attrs == NULL) {
+            if (nbAttrs < 4)
+                ret->maxAttrs = 4;
+            else
+                ret->maxAttrs = nbAttrs;
+            ret->attrs = (xmlAttrPtr *) xmlMalloc(ret->maxAttrs *
+                                                  sizeof(xmlAttrPtr));
+            if (ret->attrs == NULL) {
+                xmlRngVErrMemory(ctxt, "allocating states\n");
+                return (ret);
+            }
+        } else if (ret->maxAttrs < nbAttrs) {
+            xmlAttrPtr *tmp;
+
+            tmp = (xmlAttrPtr *) xmlRealloc(ret->attrs, nbAttrs *
+                                            sizeof(xmlAttrPtr));
+            if (tmp == NULL) {
+                xmlRngVErrMemory(ctxt, "allocating states\n");
+                return (ret);
+            }
+            ret->attrs = tmp;
+            ret->maxAttrs = nbAttrs;
+        }
+        ret->nbAttrs = nbAttrs;
+        if (nbAttrs < MAX_ATTR) {
+            memcpy(ret->attrs, attrs, sizeof(xmlAttrPtr) * nbAttrs);
+        } else {
+            attr = node->properties;
+            nbAttrs = 0;
+            while (attr != NULL) {
+                ret->attrs[nbAttrs++] = attr;
+                attr = attr->next;
+            }
+        }
+    }
+    ret->nbAttrLeft = ret->nbAttrs;
+    return (ret);
+}
+
+/**
+ * xmlRelaxNGCopyValidState:
+ * @ctxt:  a Relax-NG validation context
+ * @state:  a validation state
+ *
+ * Copy the validation state
+ *
+ * Returns the newly allocated structure or NULL in case or error
+ */
+static xmlRelaxNGValidStatePtr
+xmlRelaxNGCopyValidState(xmlRelaxNGValidCtxtPtr ctxt,
+                         xmlRelaxNGValidStatePtr state)
+{
+    xmlRelaxNGValidStatePtr ret;
+    unsigned int maxAttrs;
+    xmlAttrPtr *attrs;
+
+    if (state == NULL)
+        return (NULL);
+    if ((ctxt->freeState != NULL) && (ctxt->freeState->nbState > 0)) {
+        ctxt->freeState->nbState--;
+        ret = ctxt->freeState->tabState[ctxt->freeState->nbState];
+    } else {
+        ret =
+            (xmlRelaxNGValidStatePtr)
+            xmlMalloc(sizeof(xmlRelaxNGValidState));
+        if (ret == NULL) {
+            xmlRngVErrMemory(ctxt, "allocating states\n");
+            return (NULL);
+        }
+        memset(ret, 0, sizeof(xmlRelaxNGValidState));
+    }
+    attrs = ret->attrs;
+    maxAttrs = ret->maxAttrs;
+    memcpy(ret, state, sizeof(xmlRelaxNGValidState));
+    ret->attrs = attrs;
+    ret->maxAttrs = maxAttrs;
+    if (state->nbAttrs > 0) {
+        if (ret->attrs == NULL) {
+            ret->maxAttrs = state->maxAttrs;
+            ret->attrs = (xmlAttrPtr *) xmlMalloc(ret->maxAttrs *
+                                                  sizeof(xmlAttrPtr));
+            if (ret->attrs == NULL) {
+                xmlRngVErrMemory(ctxt, "allocating states\n");
+                ret->nbAttrs = 0;
+                return (ret);
+            }
+        } else if (ret->maxAttrs < state->nbAttrs) {
+            xmlAttrPtr *tmp;
+
+            tmp = (xmlAttrPtr *) xmlRealloc(ret->attrs, state->maxAttrs *
+                                            sizeof(xmlAttrPtr));
+            if (tmp == NULL) {
+                xmlRngVErrMemory(ctxt, "allocating states\n");
+                ret->nbAttrs = 0;
+                return (ret);
+            }
+            ret->maxAttrs = state->maxAttrs;
+            ret->attrs = tmp;
+        }
+        memcpy(ret->attrs, state->attrs,
+               state->nbAttrs * sizeof(xmlAttrPtr));
+    }
+    return (ret);
+}
+
+/**
+ * xmlRelaxNGEqualValidState:
+ * @ctxt:  a Relax-NG validation context
+ * @state1:  a validation state
+ * @state2:  a validation state
+ *
+ * Compare the validation states for equality
+ *
+ * Returns 1 if equald, 0 otherwise
+ */
+static int
+xmlRelaxNGEqualValidState(xmlRelaxNGValidCtxtPtr ctxt ATTRIBUTE_UNUSED,
+                          xmlRelaxNGValidStatePtr state1,
+                          xmlRelaxNGValidStatePtr state2)
+{
+    int i;
+
+    if ((state1 == NULL) || (state2 == NULL))
+        return (0);
+    if (state1 == state2)
+        return (1);
+    if (state1->node != state2->node)
+        return (0);
+    if (state1->seq != state2->seq)
+        return (0);
+    if (state1->nbAttrLeft != state2->nbAttrLeft)
+        return (0);
+    if (state1->nbAttrs != state2->nbAttrs)
+        return (0);
+    if (state1->endvalue != state2->endvalue)
+        return (0);
+    if ((state1->value != state2->value) &&
+        (!xmlStrEqual(state1->value, state2->value)))
+        return (0);
+    for (i = 0; i < state1->nbAttrs; i++) {
+        if (state1->attrs[i] != state2->attrs[i])
+            return (0);
+    }
+    return (1);
+}
+
+/**
+ * xmlRelaxNGFreeValidState:
+ * @state:  a validation state structure
+ *
+ * Deallocate a RelaxNG validation state structure.
+ */
+static void
+xmlRelaxNGFreeValidState(xmlRelaxNGValidCtxtPtr ctxt,
+                         xmlRelaxNGValidStatePtr state)
+{
+    if (state == NULL)
+        return;
+
+    if ((ctxt != NULL) && (ctxt->freeState == NULL)) {
+        ctxt->freeState = xmlRelaxNGNewStates(ctxt, 40);
+    }
+    if ((ctxt == NULL) || (ctxt->freeState == NULL)) {
+        if (state->attrs != NULL)
+            xmlFree(state->attrs);
+        xmlFree(state);
+    } else {
+        xmlRelaxNGAddStatesUniq(ctxt, ctxt->freeState, state);
+    }
+}
+
+/************************************************************************
+ * 									*
+ * 			Semi internal functions				*
+ * 									*
+ ************************************************************************/
+
+/**
+ * xmlRelaxParserSetFlag:
+ * @ctxt: a RelaxNG parser context
+ * @flags: a set of flags values
+ *
+ * Semi private function used to pass informations to a parser context
+ * which are a combination of xmlRelaxNGParserFlag .
+ *
+ * Returns 0 if success and -1 in case of error
+ */
+int
+xmlRelaxParserSetFlag(xmlRelaxNGParserCtxtPtr ctxt, int flags)
+{
+    if (ctxt == NULL) return(-1);
+    if (flags & XML_RELAXNGP_FREE_DOC) {
+        ctxt->crng |= XML_RELAXNGP_FREE_DOC;
+	flags -= XML_RELAXNGP_FREE_DOC;
+    }
+    if (flags & XML_RELAXNGP_CRNG) {
+        ctxt->crng |= XML_RELAXNGP_CRNG;
+	flags -= XML_RELAXNGP_CRNG;
+    }
+    if (flags != 0) return(-1);
+    return(0);
+}
+
+/************************************************************************
+ * 									*
+ * 			Document functions				*
+ * 									*
+ ************************************************************************/
+static xmlDocPtr xmlRelaxNGCleanupDoc(xmlRelaxNGParserCtxtPtr ctxt,
+                                      xmlDocPtr doc);
+
+/**
+ * xmlRelaxNGIncludePush:
+ * @ctxt:  the parser context
+ * @value:  the element doc
+ *
+ * Pushes a new include on top of the include stack
+ *
+ * Returns 0 in case of error, the index in the stack otherwise
+ */
+static int
+xmlRelaxNGIncludePush(xmlRelaxNGParserCtxtPtr ctxt,
+                      xmlRelaxNGIncludePtr value)
+{
+    if (ctxt->incTab == NULL) {
+        ctxt->incMax = 4;
+        ctxt->incNr = 0;
+        ctxt->incTab =
+            (xmlRelaxNGIncludePtr *) xmlMalloc(ctxt->incMax *
+                                               sizeof(ctxt->incTab[0]));
+        if (ctxt->incTab == NULL) {
+            xmlRngPErrMemory(ctxt, "allocating include\n");
+            return (0);
+        }
+    }
+    if (ctxt->incNr >= ctxt->incMax) {
+        ctxt->incMax *= 2;
+        ctxt->incTab =
+            (xmlRelaxNGIncludePtr *) xmlRealloc(ctxt->incTab,
+                                                ctxt->incMax *
+                                                sizeof(ctxt->incTab[0]));
+        if (ctxt->incTab == NULL) {
+            xmlRngPErrMemory(ctxt, "allocating include\n");
+            return (0);
+        }
+    }
+    ctxt->incTab[ctxt->incNr] = value;
+    ctxt->inc = value;
+    return (ctxt->incNr++);
+}
+
+/**
+ * xmlRelaxNGIncludePop:
+ * @ctxt: the parser context
+ *
+ * Pops the top include from the include stack
+ *
+ * Returns the include just removed
+ */
+static xmlRelaxNGIncludePtr
+xmlRelaxNGIncludePop(xmlRelaxNGParserCtxtPtr ctxt)
+{
+    xmlRelaxNGIncludePtr ret;
+
+    if (ctxt->incNr <= 0)
+        return (0);
+    ctxt->incNr--;
+    if (ctxt->incNr > 0)
+        ctxt->inc = ctxt->incTab[ctxt->incNr - 1];
+    else
+        ctxt->inc = NULL;
+    ret = ctxt->incTab[ctxt->incNr];
+    ctxt->incTab[ctxt->incNr] = 0;
+    return (ret);
+}
+
+/**
+ * xmlRelaxNGRemoveRedefine:
+ * @ctxt: the parser context
+ * @URL:  the normalized URL
+ * @target:  the included target
+ * @name:  the define name to eliminate
+ *
+ * Applies the elimination algorithm of 4.7
+ *
+ * Returns 0 in case of error, 1 in case of success.
+ */
+static int
+xmlRelaxNGRemoveRedefine(xmlRelaxNGParserCtxtPtr ctxt,
+                         const xmlChar * URL ATTRIBUTE_UNUSED,
+                         xmlNodePtr target, const xmlChar * name)
+{
+    int found = 0;
+    xmlNodePtr tmp, tmp2;
+    xmlChar *name2;
+
+#ifdef DEBUG_INCLUDE
+    if (name == NULL)
+        xmlGenericError(xmlGenericErrorContext,
+                        "Elimination of <include> start from %s\n", URL);
+    else
+        xmlGenericError(xmlGenericErrorContext,
+                        "Elimination of <include> define %s from %s\n",
+                        name, URL);
+#endif
+    tmp = target;
+    while (tmp != NULL) {
+        tmp2 = tmp->next;
+        if ((name == NULL) && (IS_RELAXNG(tmp, "start"))) {
+            found = 1;
+            xmlUnlinkNode(tmp);
+            xmlFreeNode(tmp);
+        } else if ((name != NULL) && (IS_RELAXNG(tmp, "define"))) {
+            name2 = xmlGetProp(tmp, BAD_CAST "name");
+            xmlRelaxNGNormExtSpace(name2);
+            if (name2 != NULL) {
+                if (xmlStrEqual(name, name2)) {
+                    found = 1;
+                    xmlUnlinkNode(tmp);
+                    xmlFreeNode(tmp);
+                }
+                xmlFree(name2);
+            }
+        } else if (IS_RELAXNG(tmp, "include")) {
+            xmlChar *href = NULL;
+            xmlRelaxNGDocumentPtr inc = tmp->psvi;
+
+            if ((inc != NULL) && (inc->doc != NULL) &&
+                (inc->doc->children != NULL)) {
+
+                if (xmlStrEqual
+                    (inc->doc->children->name, BAD_CAST "grammar")) {
+#ifdef DEBUG_INCLUDE
+                    href = xmlGetProp(tmp, BAD_CAST "href");
+#endif
+                    if (xmlRelaxNGRemoveRedefine(ctxt, href,
+                                                 inc->doc->children->
+                                                 children, name) == 1) {
+                        found = 1;
+                    }
+                    if (href != NULL)
+                        xmlFree(href);
+                }
+            }
+        }
+        tmp = tmp2;
+    }
+    return (found);
+}
+
+/**
+ * xmlRelaxNGLoadInclude:
+ * @ctxt: the parser context
+ * @URL:  the normalized URL
+ * @node: the include node.
+ * @ns:  the namespace passed from the context.
+ *
+ * First lookup if the document is already loaded into the parser context,
+ * check against recursion. If not found the resource is loaded and
+ * the content is preprocessed before being returned back to the caller.
+ *
+ * Returns the xmlRelaxNGIncludePtr or NULL in case of error
+ */
+static xmlRelaxNGIncludePtr
+xmlRelaxNGLoadInclude(xmlRelaxNGParserCtxtPtr ctxt, const xmlChar * URL,
+                      xmlNodePtr node, const xmlChar * ns)
+{
+    xmlRelaxNGIncludePtr ret = NULL;
+    xmlDocPtr doc;
+    int i;
+    xmlNodePtr root, cur;
+
+#ifdef DEBUG_INCLUDE
+    xmlGenericError(xmlGenericErrorContext,
+                    "xmlRelaxNGLoadInclude(%s)\n", URL);
+#endif
+
+    /*
+     * check against recursion in the stack
+     */
+    for (i = 0; i < ctxt->incNr; i++) {
+        if (xmlStrEqual(ctxt->incTab[i]->href, URL)) {
+            xmlRngPErr(ctxt, NULL, XML_RNGP_INCLUDE_RECURSE,
+                       "Detected an Include recursion for %s\n", URL,
+                       NULL);
+            return (NULL);
+        }
+    }
+
+    /*
+     * load the document
+     */
+    doc = xmlReadFile((const char *) URL,NULL,0);
+    if (doc == NULL) {
+        xmlRngPErr(ctxt, node, XML_RNGP_PARSE_ERROR,
+                   "xmlRelaxNG: could not load %s\n", URL, NULL);
+        return (NULL);
+    }
+#ifdef DEBUG_INCLUDE
+    xmlGenericError(xmlGenericErrorContext, "Parsed %s Okay\n", URL);
+#endif
+
+    /*
+     * Allocate the document structures and register it first.
+     */
+    ret = (xmlRelaxNGIncludePtr) xmlMalloc(sizeof(xmlRelaxNGInclude));
+    if (ret == NULL) {
+        xmlRngPErrMemory(ctxt, "allocating include\n");
+        xmlFreeDoc(doc);
+        return (NULL);
+    }
+    memset(ret, 0, sizeof(xmlRelaxNGInclude));
+    ret->doc = doc;
+    ret->href = xmlStrdup(URL);
+    ret->next = ctxt->includes;
+    ctxt->includes = ret;
+
+    /*
+     * transmit the ns if needed
+     */
+    if (ns != NULL) {
+        root = xmlDocGetRootElement(doc);
+        if (root != NULL) {
+            if (xmlHasProp(root, BAD_CAST "ns") == NULL) {
+                xmlSetProp(root, BAD_CAST "ns", ns);
+            }
+        }
+    }
+
+    /*
+     * push it on the stack
+     */
+    xmlRelaxNGIncludePush(ctxt, ret);
+
+    /*
+     * Some preprocessing of the document content, this include recursing
+     * in the include stack.
+     */
+#ifdef DEBUG_INCLUDE
+    xmlGenericError(xmlGenericErrorContext, "cleanup of %s\n", URL);
+#endif
+
+    doc = xmlRelaxNGCleanupDoc(ctxt, doc);
+    if (doc == NULL) {
+        ctxt->inc = NULL;
+        return (NULL);
+    }
+
+    /*
+     * Pop up the include from the stack
+     */
+    xmlRelaxNGIncludePop(ctxt);
+
+#ifdef DEBUG_INCLUDE
+    xmlGenericError(xmlGenericErrorContext, "Checking of %s\n", URL);
+#endif
+    /*
+     * Check that the top element is a grammar
+     */
+    root = xmlDocGetRootElement(doc);
+    if (root == NULL) {
+        xmlRngPErr(ctxt, node, XML_RNGP_EMPTY,
+                   "xmlRelaxNG: included document is empty %s\n", URL,
+                   NULL);
+        return (NULL);
+    }
+    if (!IS_RELAXNG(root, "grammar")) {
+        xmlRngPErr(ctxt, node, XML_RNGP_GRAMMAR_MISSING,
+                   "xmlRelaxNG: included document %s root is not a grammar\n",
+                   URL, NULL);
+        return (NULL);
+    }
+
+    /*
+     * Elimination of redefined rules in the include.
+     */
+    cur = node->children;
+    while (cur != NULL) {
+        if (IS_RELAXNG(cur, "start")) {
+            int found = 0;
+
+            found =
+                xmlRelaxNGRemoveRedefine(ctxt, URL, root->children, NULL);
+            if (!found) {
+                xmlRngPErr(ctxt, node, XML_RNGP_START_MISSING,
+                           "xmlRelaxNG: include %s has a start but not the included grammar\n",
+                           URL, NULL);
+            }
+        } else if (IS_RELAXNG(cur, "define")) {
+            xmlChar *name;
+
+            name = xmlGetProp(cur, BAD_CAST "name");
+            if (name == NULL) {
+                xmlRngPErr(ctxt, node, XML_RNGP_NAME_MISSING,
+                           "xmlRelaxNG: include %s has define without name\n",
+                           URL, NULL);
+            } else {
+                int found;
+
+                xmlRelaxNGNormExtSpace(name);
+                found = xmlRelaxNGRemoveRedefine(ctxt, URL,
+                                                 root->children, name);
+                if (!found) {
+                    xmlRngPErr(ctxt, node, XML_RNGP_DEFINE_MISSING,
+                               "xmlRelaxNG: include %s has a define %s but not the included grammar\n",
+                               URL, name);
+                }
+                xmlFree(name);
+            }
+        }
+        cur = cur->next;
+    }
+
+
+    return (ret);
+}
+
+/**
+ * xmlRelaxNGValidErrorPush:
+ * @ctxt:  the validation context
+ * @err:  the error code
+ * @arg1:  the first string argument
+ * @arg2:  the second string argument
+ * @dup:  arg need to be duplicated
+ *
+ * Pushes a new error on top of the error stack
+ *
+ * Returns 0 in case of error, the index in the stack otherwise
+ */
+static int
+xmlRelaxNGValidErrorPush(xmlRelaxNGValidCtxtPtr ctxt,
+                         xmlRelaxNGValidErr err, const xmlChar * arg1,
+                         const xmlChar * arg2, int dup)
+{
+    xmlRelaxNGValidErrorPtr cur;
+
+#ifdef DEBUG_ERROR
+    xmlGenericError(xmlGenericErrorContext,
+                    "Pushing error %d at %d on stack\n", err, ctxt->errNr);
+#endif
+    if (ctxt->errTab == NULL) {
+        ctxt->errMax = 8;
+        ctxt->errNr = 0;
+        ctxt->errTab =
+            (xmlRelaxNGValidErrorPtr) xmlMalloc(ctxt->errMax *
+                                                sizeof
+                                                (xmlRelaxNGValidError));
+        if (ctxt->errTab == NULL) {
+            xmlRngVErrMemory(ctxt, "pushing error\n");
+            return (0);
+        }
+        ctxt->err = NULL;
+    }
+    if (ctxt->errNr >= ctxt->errMax) {
+        ctxt->errMax *= 2;
+        ctxt->errTab =
+            (xmlRelaxNGValidErrorPtr) xmlRealloc(ctxt->errTab,
+                                                 ctxt->errMax *
+                                                 sizeof
+                                                 (xmlRelaxNGValidError));
+        if (ctxt->errTab == NULL) {
+            xmlRngVErrMemory(ctxt, "pushing error\n");
+            return (0);
+        }
+        ctxt->err = &ctxt->errTab[ctxt->errNr - 1];
+    }
+    if ((ctxt->err != NULL) && (ctxt->state != NULL) &&
+        (ctxt->err->node == ctxt->state->node) && (ctxt->err->err == err))
+        return (ctxt->errNr);
+    cur = &ctxt->errTab[ctxt->errNr];
+    cur->err = err;
+    if (dup) {
+        cur->arg1 = xmlStrdup(arg1);
+        cur->arg2 = xmlStrdup(arg2);
+        cur->flags = ERROR_IS_DUP;
+    } else {
+        cur->arg1 = arg1;
+        cur->arg2 = arg2;
+        cur->flags = 0;
+    }
+    if (ctxt->state != NULL) {
+        cur->node = ctxt->state->node;
+        cur->seq = ctxt->state->seq;
+    } else {
+        cur->node = NULL;
+        cur->seq = NULL;
+    }
+    ctxt->err = cur;
+    return (ctxt->errNr++);
+}
+
+/**
+ * xmlRelaxNGValidErrorPop:
+ * @ctxt: the validation context
+ *
+ * Pops the top error from the error stack
+ */
+static void
+xmlRelaxNGValidErrorPop(xmlRelaxNGValidCtxtPtr ctxt)
+{
+    xmlRelaxNGValidErrorPtr cur;
+
+    if (ctxt->errNr <= 0) {
+        ctxt->err = NULL;
+        return;
+    }
+    ctxt->errNr--;
+    if (ctxt->errNr > 0)
+        ctxt->err = &ctxt->errTab[ctxt->errNr - 1];
+    else
+        ctxt->err = NULL;
+    cur = &ctxt->errTab[ctxt->errNr];
+    if (cur->flags & ERROR_IS_DUP) {
+        if (cur->arg1 != NULL)
+            xmlFree((xmlChar *) cur->arg1);
+        cur->arg1 = NULL;
+        if (cur->arg2 != NULL)
+            xmlFree((xmlChar *) cur->arg2);
+        cur->arg2 = NULL;
+        cur->flags = 0;
+    }
+}
+
+/**
+ * xmlRelaxNGDocumentPush:
+ * @ctxt:  the parser context
+ * @value:  the element doc
+ *
+ * Pushes a new doc on top of the doc stack
+ *
+ * Returns 0 in case of error, the index in the stack otherwise
+ */
+static int
+xmlRelaxNGDocumentPush(xmlRelaxNGParserCtxtPtr ctxt,
+                       xmlRelaxNGDocumentPtr value)
+{
+    if (ctxt->docTab == NULL) {
+        ctxt->docMax = 4;
+        ctxt->docNr = 0;
+        ctxt->docTab =
+            (xmlRelaxNGDocumentPtr *) xmlMalloc(ctxt->docMax *
+                                                sizeof(ctxt->docTab[0]));
+        if (ctxt->docTab == NULL) {
+            xmlRngPErrMemory(ctxt, "adding document\n");
+            return (0);
+        }
+    }
+    if (ctxt->docNr >= ctxt->docMax) {
+        ctxt->docMax *= 2;
+        ctxt->docTab =
+            (xmlRelaxNGDocumentPtr *) xmlRealloc(ctxt->docTab,
+                                                 ctxt->docMax *
+                                                 sizeof(ctxt->docTab[0]));
+        if (ctxt->docTab == NULL) {
+            xmlRngPErrMemory(ctxt, "adding document\n");
+            return (0);
+        }
+    }
+    ctxt->docTab[ctxt->docNr] = value;
+    ctxt->doc = value;
+    return (ctxt->docNr++);
+}
+
+/**
+ * xmlRelaxNGDocumentPop:
+ * @ctxt: the parser context
+ *
+ * Pops the top doc from the doc stack
+ *
+ * Returns the doc just removed
+ */
+static xmlRelaxNGDocumentPtr
+xmlRelaxNGDocumentPop(xmlRelaxNGParserCtxtPtr ctxt)
+{
+    xmlRelaxNGDocumentPtr ret;
+
+    if (ctxt->docNr <= 0)
+        return (0);
+    ctxt->docNr--;
+    if (ctxt->docNr > 0)
+        ctxt->doc = ctxt->docTab[ctxt->docNr - 1];
+    else
+        ctxt->doc = NULL;
+    ret = ctxt->docTab[ctxt->docNr];
+    ctxt->docTab[ctxt->docNr] = 0;
+    return (ret);
+}
+
+/**
+ * xmlRelaxNGLoadExternalRef:
+ * @ctxt: the parser context
+ * @URL:  the normalized URL
+ * @ns:  the inherited ns if any
+ *
+ * First lookup if the document is already loaded into the parser context,
+ * check against recursion. If not found the resource is loaded and
+ * the content is preprocessed before being returned back to the caller.
+ *
+ * Returns the xmlRelaxNGDocumentPtr or NULL in case of error
+ */
+static xmlRelaxNGDocumentPtr
+xmlRelaxNGLoadExternalRef(xmlRelaxNGParserCtxtPtr ctxt,
+                          const xmlChar * URL, const xmlChar * ns)
+{
+    xmlRelaxNGDocumentPtr ret = NULL;
+    xmlDocPtr doc;
+    xmlNodePtr root;
+    int i;
+
+    /*
+     * check against recursion in the stack
+     */
+    for (i = 0; i < ctxt->docNr; i++) {
+        if (xmlStrEqual(ctxt->docTab[i]->href, URL)) {
+            xmlRngPErr(ctxt, NULL, XML_RNGP_EXTERNALREF_RECURSE,
+                       "Detected an externalRef recursion for %s\n", URL,
+                       NULL);
+            return (NULL);
+        }
+    }
+
+    /*
+     * load the document
+     */
+    doc = xmlReadFile((const char *) URL,NULL,0);
+    if (doc == NULL) {
+        xmlRngPErr(ctxt, NULL, XML_RNGP_PARSE_ERROR,
+                   "xmlRelaxNG: could not load %s\n", URL, NULL);
+        return (NULL);
+    }
+
+    /*
+     * Allocate the document structures and register it first.
+     */
+    ret = (xmlRelaxNGDocumentPtr) xmlMalloc(sizeof(xmlRelaxNGDocument));
+    if (ret == NULL) {
+        xmlRngPErr(ctxt, (xmlNodePtr) doc, XML_ERR_NO_MEMORY,
+                   "xmlRelaxNG: allocate memory for doc %s\n", URL, NULL);
+        xmlFreeDoc(doc);
+        return (NULL);
+    }
+    memset(ret, 0, sizeof(xmlRelaxNGDocument));
+    ret->doc = doc;
+    ret->href = xmlStrdup(URL);
+    ret->next = ctxt->documents;
+    ctxt->documents = ret;
+
+    /*
+     * transmit the ns if needed
+     */
+    if (ns != NULL) {
+        root = xmlDocGetRootElement(doc);
+        if (root != NULL) {
+            if (xmlHasProp(root, BAD_CAST "ns") == NULL) {
+                xmlSetProp(root, BAD_CAST "ns", ns);
+            }
+        }
+    }
+
+    /*
+     * push it on the stack and register it in the hash table
+     */
+    xmlRelaxNGDocumentPush(ctxt, ret);
+
+    /*
+     * Some preprocessing of the document content
+     */
+    doc = xmlRelaxNGCleanupDoc(ctxt, doc);
+    if (doc == NULL) {
+        ctxt->doc = NULL;
+        return (NULL);
+    }
+
+    xmlRelaxNGDocumentPop(ctxt);
+
+    return (ret);
+}
+
+/************************************************************************
+ * 									*
+ * 			Error functions					*
+ * 									*
+ ************************************************************************/
+
+#define VALID_ERR(a) xmlRelaxNGAddValidError(ctxt, a, NULL, NULL, 0);
+#define VALID_ERR2(a, b) xmlRelaxNGAddValidError(ctxt, a, b, NULL, 0);
+#define VALID_ERR3(a, b, c) xmlRelaxNGAddValidError(ctxt, a, b, c, 0);
+#define VALID_ERR2P(a, b) xmlRelaxNGAddValidError(ctxt, a, b, NULL, 1);
+#define VALID_ERR3P(a, b, c) xmlRelaxNGAddValidError(ctxt, a, b, c, 1);
+
+static const char *
+xmlRelaxNGDefName(xmlRelaxNGDefinePtr def)
+{
+    if (def == NULL)
+        return ("none");
+    switch (def->type) {
+        case XML_RELAXNG_EMPTY:
+            return ("empty");
+        case XML_RELAXNG_NOT_ALLOWED:
+            return ("notAllowed");
+        case XML_RELAXNG_EXCEPT:
+            return ("except");
+        case XML_RELAXNG_TEXT:
+            return ("text");
+        case XML_RELAXNG_ELEMENT:
+            return ("element");
+        case XML_RELAXNG_DATATYPE:
+            return ("datatype");
+        case XML_RELAXNG_VALUE:
+            return ("value");
+        case XML_RELAXNG_LIST:
+            return ("list");
+        case XML_RELAXNG_ATTRIBUTE:
+            return ("attribute");
+        case XML_RELAXNG_DEF:
+            return ("def");
+        case XML_RELAXNG_REF:
+            return ("ref");
+        case XML_RELAXNG_EXTERNALREF:
+            return ("externalRef");
+        case XML_RELAXNG_PARENTREF:
+            return ("parentRef");
+        case XML_RELAXNG_OPTIONAL:
+            return ("optional");
+        case XML_RELAXNG_ZEROORMORE:
+            return ("zeroOrMore");
+        case XML_RELAXNG_ONEORMORE:
+            return ("oneOrMore");
+        case XML_RELAXNG_CHOICE:
+            return ("choice");
+        case XML_RELAXNG_GROUP:
+            return ("group");
+        case XML_RELAXNG_INTERLEAVE:
+            return ("interleave");
+        case XML_RELAXNG_START:
+            return ("start");
+        case XML_RELAXNG_NOOP:
+            return ("noop");
+        case XML_RELAXNG_PARAM:
+            return ("param");
+    }
+    return ("unknown");
+}
+
+/**
+ * xmlRelaxNGGetErrorString:
+ * @err:  the error code
+ * @arg1:  the first string argument
+ * @arg2:  the second string argument
+ *
+ * computes a formatted error string for the given error code and args
+ *
+ * Returns the error string, it must be deallocated by the caller
+ */
+static xmlChar *
+xmlRelaxNGGetErrorString(xmlRelaxNGValidErr err, const xmlChar * arg1,
+                         const xmlChar * arg2)
+{
+    char msg[1000];
+
+    if (arg1 == NULL)
+        arg1 = BAD_CAST "";
+    if (arg2 == NULL)
+        arg2 = BAD_CAST "";
+
+    msg[0] = 0;
+    switch (err) {
+        case XML_RELAXNG_OK:
+            return (NULL);
+        case XML_RELAXNG_ERR_MEMORY:
+            return (xmlCharStrdup("out of memory\n"));
+        case XML_RELAXNG_ERR_TYPE:
+            snprintf(msg, 1000, "failed to validate type %s\n", arg1);
+            break;
+        case XML_RELAXNG_ERR_TYPEVAL:
+            snprintf(msg, 1000, "Type %s doesn't allow value '%s'\n", arg1,
+                     arg2);
+            break;
+        case XML_RELAXNG_ERR_DUPID:
+            snprintf(msg, 1000, "ID %s redefined\n", arg1);
+            break;
+        case XML_RELAXNG_ERR_TYPECMP:
+            snprintf(msg, 1000, "failed to compare type %s\n", arg1);
+            break;
+        case XML_RELAXNG_ERR_NOSTATE:
+            return (xmlCharStrdup("Internal error: no state\n"));
+        case XML_RELAXNG_ERR_NODEFINE:
+            return (xmlCharStrdup("Internal error: no define\n"));
+        case XML_RELAXNG_ERR_INTERNAL:
+            snprintf(msg, 1000, "Internal error: %s\n", arg1);
+            break;
+        case XML_RELAXNG_ERR_LISTEXTRA:
+            snprintf(msg, 1000, "Extra data in list: %s\n", arg1);
+            break;
+        case XML_RELAXNG_ERR_INTERNODATA:
+            return (xmlCharStrdup
+                    ("Internal: interleave block has no data\n"));
+        case XML_RELAXNG_ERR_INTERSEQ:
+            return (xmlCharStrdup("Invalid sequence in interleave\n"));
+        case XML_RELAXNG_ERR_INTEREXTRA:
+            snprintf(msg, 1000, "Extra element %s in interleave\n", arg1);
+            break;
+        case XML_RELAXNG_ERR_ELEMNAME:
+            snprintf(msg, 1000, "Expecting element %s, got %s\n", arg1,
+                     arg2);
+            break;
+        case XML_RELAXNG_ERR_ELEMNONS:
+            snprintf(msg, 1000, "Expecting a namespace for element %s\n",
+                     arg1);
+            break;
+        case XML_RELAXNG_ERR_ELEMWRONGNS:
+            snprintf(msg, 1000,
+                     "Element %s has wrong namespace: expecting %s\n", arg1,
+                     arg2);
+            break;
+        case XML_RELAXNG_ERR_ELEMWRONG:
+            snprintf(msg, 1000, "Did not expect element %s there\n", arg1);
+            break;
+        case XML_RELAXNG_ERR_TEXTWRONG:
+            snprintf(msg, 1000,
+                     "Did not expect text in element %s content\n", arg1);
+            break;
+        case XML_RELAXNG_ERR_ELEMEXTRANS:
+            snprintf(msg, 1000, "Expecting no namespace for element %s\n",
+                     arg1);
+            break;
+        case XML_RELAXNG_ERR_ELEMNOTEMPTY:
+            snprintf(msg, 1000, "Expecting element %s to be empty\n", arg1);
+            break;
+        case XML_RELAXNG_ERR_NOELEM:
+            snprintf(msg, 1000, "Expecting an element %s, got nothing\n",
+                     arg1);
+            break;
+        case XML_RELAXNG_ERR_NOTELEM:
+            return (xmlCharStrdup("Expecting an element got text\n"));
+        case XML_RELAXNG_ERR_ATTRVALID:
+            snprintf(msg, 1000, "Element %s failed to validate attributes\n",
+                     arg1);
+            break;
+        case XML_RELAXNG_ERR_CONTENTVALID:
+            snprintf(msg, 1000, "Element %s failed to validate content\n",
+                     arg1);
+            break;
+        case XML_RELAXNG_ERR_EXTRACONTENT:
+            snprintf(msg, 1000, "Element %s has extra content: %s\n",
+                     arg1, arg2);
+            break;
+        case XML_RELAXNG_ERR_INVALIDATTR:
+            snprintf(msg, 1000, "Invalid attribute %s for element %s\n",
+                     arg1, arg2);
+            break;
+        case XML_RELAXNG_ERR_LACKDATA:
+            snprintf(msg, 1000, "Datatype element %s contains no data\n",
+                     arg1);
+            break;
+        case XML_RELAXNG_ERR_DATAELEM:
+            snprintf(msg, 1000, "Datatype element %s has child elements\n",
+                     arg1);
+            break;
+        case XML_RELAXNG_ERR_VALELEM:
+            snprintf(msg, 1000, "Value element %s has child elements\n",
+                     arg1);
+            break;
+        case XML_RELAXNG_ERR_LISTELEM:
+            snprintf(msg, 1000, "List element %s has child elements\n",
+                     arg1);
+            break;
+        case XML_RELAXNG_ERR_DATATYPE:
+            snprintf(msg, 1000, "Error validating datatype %s\n", arg1);
+            break;
+        case XML_RELAXNG_ERR_VALUE:
+            snprintf(msg, 1000, "Error validating value %s\n", arg1);
+            break;
+        case XML_RELAXNG_ERR_LIST:
+            return (xmlCharStrdup("Error validating list\n"));
+        case XML_RELAXNG_ERR_NOGRAMMAR:
+            return (xmlCharStrdup("No top grammar defined\n"));
+        case XML_RELAXNG_ERR_EXTRADATA:
+            return (xmlCharStrdup("Extra data in the document\n"));
+        default:
+            return (xmlCharStrdup("Unknown error !\n"));
+    }
+    if (msg[0] == 0) {
+        snprintf(msg, 1000, "Unknown error code %d\n", err);
+    }
+    msg[1000 - 1] = 0;
+    return (xmlStrdup((xmlChar *) msg));
+}
+
+/**
+ * xmlRelaxNGShowValidError:
+ * @ctxt:  the validation context
+ * @err:  the error number
+ * @node:  the node
+ * @child:  the node child generating the problem.
+ * @arg1:  the first argument
+ * @arg2:  the second argument
+ *
+ * Show a validation error.
+ */
+static void
+xmlRelaxNGShowValidError(xmlRelaxNGValidCtxtPtr ctxt,
+                         xmlRelaxNGValidErr err, xmlNodePtr node,
+                         xmlNodePtr child, const xmlChar * arg1,
+                         const xmlChar * arg2)
+{
+    xmlChar *msg;
+
+    if (ctxt->error == NULL)
+        return;
+
+#ifdef DEBUG_ERROR
+    xmlGenericError(xmlGenericErrorContext, "Show error %d\n", err);
+#endif
+    msg = xmlRelaxNGGetErrorString(err, arg1, arg2);
+    if (msg == NULL)
+        return;
+
+    if (ctxt->errNo == XML_RELAXNG_OK)
+        ctxt->errNo = err;
+    xmlRngVErr(ctxt, (child == NULL ? node : child), err,
+               (const char *) msg, arg1, arg2);
+    xmlFree(msg);
+}
+
+/**
+ * xmlRelaxNGPopErrors:
+ * @ctxt:  the validation context
+ * @level:  the error level in the stack
+ *
+ * pop and discard all errors until the given level is reached
+ */
+static void
+xmlRelaxNGPopErrors(xmlRelaxNGValidCtxtPtr ctxt, int level)
+{
+    int i;
+    xmlRelaxNGValidErrorPtr err;
+
+#ifdef DEBUG_ERROR
+    xmlGenericError(xmlGenericErrorContext,
+                    "Pop errors till level %d\n", level);
+#endif
+    for (i = level; i < ctxt->errNr; i++) {
+        err = &ctxt->errTab[i];
+        if (err->flags & ERROR_IS_DUP) {
+            if (err->arg1 != NULL)
+                xmlFree((xmlChar *) err->arg1);
+            err->arg1 = NULL;
+            if (err->arg2 != NULL)
+                xmlFree((xmlChar *) err->arg2);
+            err->arg2 = NULL;
+            err->flags = 0;
+        }
+    }
+    ctxt->errNr = level;
+    if (ctxt->errNr <= 0)
+        ctxt->err = NULL;
+}
+
+/**
+ * xmlRelaxNGDumpValidError:
+ * @ctxt:  the validation context
+ *
+ * Show all validation error over a given index.
+ */
+static void
+xmlRelaxNGDumpValidError(xmlRelaxNGValidCtxtPtr ctxt)
+{
+    int i, j, k;
+    xmlRelaxNGValidErrorPtr err, dup;
+
+#ifdef DEBUG_ERROR
+    xmlGenericError(xmlGenericErrorContext,
+                    "Dumping error stack %d errors\n", ctxt->errNr);
+#endif
+    for (i = 0, k = 0; i < ctxt->errNr; i++) {
+        err = &ctxt->errTab[i];
+        if (k < MAX_ERROR) {
+            for (j = 0; j < i; j++) {
+                dup = &ctxt->errTab[j];
+                if ((err->err == dup->err) && (err->node == dup->node) &&
+                    (xmlStrEqual(err->arg1, dup->arg1)) &&
+                    (xmlStrEqual(err->arg2, dup->arg2))) {
+                    goto skip;
+                }
+            }
+            xmlRelaxNGShowValidError(ctxt, err->err, err->node, err->seq,
+                                     err->arg1, err->arg2);
+            k++;
+        }
+      skip:
+        if (err->flags & ERROR_IS_DUP) {
+            if (err->arg1 != NULL)
+                xmlFree((xmlChar *) err->arg1);
+            err->arg1 = NULL;
+            if (err->arg2 != NULL)
+                xmlFree((xmlChar *) err->arg2);
+            err->arg2 = NULL;
+            err->flags = 0;
+        }
+    }
+    ctxt->errNr = 0;
+}
+
+/**
+ * xmlRelaxNGAddValidError:
+ * @ctxt:  the validation context
+ * @err:  the error number
+ * @arg1:  the first argument
+ * @arg2:  the second argument
+ * @dup:  need to dup the args
+ *
+ * Register a validation error, either generating it if it's sure
+ * or stacking it for later handling if unsure.
+ */
+static void
+xmlRelaxNGAddValidError(xmlRelaxNGValidCtxtPtr ctxt,
+                        xmlRelaxNGValidErr err, const xmlChar * arg1,
+                        const xmlChar * arg2, int dup)
+{
+    if ((ctxt == NULL) || (ctxt->error == NULL))
+        return;
+
+#ifdef DEBUG_ERROR
+    xmlGenericError(xmlGenericErrorContext, "Adding error %d\n", err);
+#endif
+    /*
+     * generate the error directly
+     */
+    if (((ctxt->flags & FLAGS_IGNORABLE) == 0) ||
+    	 (ctxt->flags & FLAGS_NEGATIVE)) {
+        xmlNodePtr node, seq;
+
+        /*
+         * Flush first any stacked error which might be the
+         * real cause of the problem.
+         */
+        if (ctxt->errNr != 0)
+            xmlRelaxNGDumpValidError(ctxt);
+        if (ctxt->state != NULL) {
+            node = ctxt->state->node;
+            seq = ctxt->state->seq;
+        } else {
+            node = seq = NULL;
+        }
+        xmlRelaxNGShowValidError(ctxt, err, node, seq, arg1, arg2);
+    }
+    /*
+     * Stack the error for later processing if needed
+     */
+    else {
+        xmlRelaxNGValidErrorPush(ctxt, err, arg1, arg2, dup);
+    }
+}
+
+
+/************************************************************************
+ * 									*
+ * 			Type library hooks				*
+ * 									*
+ ************************************************************************/
+static xmlChar *xmlRelaxNGNormalize(xmlRelaxNGValidCtxtPtr ctxt,
+                                    const xmlChar * str);
+
+/**
+ * xmlRelaxNGSchemaTypeHave:
+ * @data:  data needed for the library
+ * @type:  the type name
+ *
+ * Check if the given type is provided by
+ * the W3C XMLSchema Datatype library.
+ *
+ * Returns 1 if yes, 0 if no and -1 in case of error.
+ */
+static int
+xmlRelaxNGSchemaTypeHave(void *data ATTRIBUTE_UNUSED, const xmlChar * type)
+{
+    xmlSchemaTypePtr typ;
+
+    if (type == NULL)
+        return (-1);
+    typ = xmlSchemaGetPredefinedType(type,
+                                     BAD_CAST
+                                     "http://www.w3.org/2001/XMLSchema");
+    if (typ == NULL)
+        return (0);
+    return (1);
+}
+
+/**
+ * xmlRelaxNGSchemaTypeCheck:
+ * @data:  data needed for the library
+ * @type:  the type name
+ * @value:  the value to check
+ * @node:  the node
+ *
+ * Check if the given type and value are validated by
+ * the W3C XMLSchema Datatype library.
+ *
+ * Returns 1 if yes, 0 if no and -1 in case of error.
+ */
+static int
+xmlRelaxNGSchemaTypeCheck(void *data ATTRIBUTE_UNUSED,
+                          const xmlChar * type,
+                          const xmlChar * value,
+                          void **result, xmlNodePtr node)
+{
+    xmlSchemaTypePtr typ;
+    int ret;
+
+    if ((type == NULL) || (value == NULL))
+        return (-1);
+    typ = xmlSchemaGetPredefinedType(type,
+                                     BAD_CAST
+                                     "http://www.w3.org/2001/XMLSchema");
+    if (typ == NULL)
+        return (-1);
+    ret = xmlSchemaValPredefTypeNode(typ, value,
+                                     (xmlSchemaValPtr *) result, node);
+    if (ret == 2)               /* special ID error code */
+        return (2);
+    if (ret == 0)
+        return (1);
+    if (ret > 0)
+        return (0);
+    return (-1);
+}
+
+/**
+ * xmlRelaxNGSchemaFacetCheck:
+ * @data:  data needed for the library
+ * @type:  the type name
+ * @facet:  the facet name
+ * @val:  the facet value
+ * @strval:  the string value
+ * @value:  the value to check
+ *
+ * Function provided by a type library to check a value facet
+ *
+ * Returns 1 if yes, 0 if no and -1 in case of error.
+ */
+static int
+xmlRelaxNGSchemaFacetCheck(void *data ATTRIBUTE_UNUSED,
+                           const xmlChar * type, const xmlChar * facetname,
+                           const xmlChar * val, const xmlChar * strval,
+                           void *value)
+{
+    xmlSchemaFacetPtr facet;
+    xmlSchemaTypePtr typ;
+    int ret;
+
+    if ((type == NULL) || (strval == NULL))
+        return (-1);
+    typ = xmlSchemaGetPredefinedType(type,
+                                     BAD_CAST
+                                     "http://www.w3.org/2001/XMLSchema");
+    if (typ == NULL)
+        return (-1);
+
+    facet = xmlSchemaNewFacet();
+    if (facet == NULL)
+        return (-1);
+
+    if (xmlStrEqual(facetname, BAD_CAST "minInclusive")) {
+        facet->type = XML_SCHEMA_FACET_MININCLUSIVE;
+    } else if (xmlStrEqual(facetname, BAD_CAST "minExclusive")) {
+        facet->type = XML_SCHEMA_FACET_MINEXCLUSIVE;
+    } else if (xmlStrEqual(facetname, BAD_CAST "maxInclusive")) {
+        facet->type = XML_SCHEMA_FACET_MAXINCLUSIVE;
+    } else if (xmlStrEqual(facetname, BAD_CAST "maxExclusive")) {
+        facet->type = XML_SCHEMA_FACET_MAXEXCLUSIVE;
+    } else if (xmlStrEqual(facetname, BAD_CAST "totalDigits")) {
+        facet->type = XML_SCHEMA_FACET_TOTALDIGITS;
+    } else if (xmlStrEqual(facetname, BAD_CAST "fractionDigits")) {
+        facet->type = XML_SCHEMA_FACET_FRACTIONDIGITS;
+    } else if (xmlStrEqual(facetname, BAD_CAST "pattern")) {
+        facet->type = XML_SCHEMA_FACET_PATTERN;
+    } else if (xmlStrEqual(facetname, BAD_CAST "enumeration")) {
+        facet->type = XML_SCHEMA_FACET_ENUMERATION;
+    } else if (xmlStrEqual(facetname, BAD_CAST "whiteSpace")) {
+        facet->type = XML_SCHEMA_FACET_WHITESPACE;
+    } else if (xmlStrEqual(facetname, BAD_CAST "length")) {
+        facet->type = XML_SCHEMA_FACET_LENGTH;
+    } else if (xmlStrEqual(facetname, BAD_CAST "maxLength")) {
+        facet->type = XML_SCHEMA_FACET_MAXLENGTH;
+    } else if (xmlStrEqual(facetname, BAD_CAST "minLength")) {
+        facet->type = XML_SCHEMA_FACET_MINLENGTH;
+    } else {
+        xmlSchemaFreeFacet(facet);
+        return (-1);
+    }
+    facet->value = val;
+    ret = xmlSchemaCheckFacet(facet, typ, NULL, type);
+    if (ret != 0) {
+        xmlSchemaFreeFacet(facet);
+        return (-1);
+    }
+    ret = xmlSchemaValidateFacet(typ, facet, strval, value);
+    xmlSchemaFreeFacet(facet);
+    if (ret != 0)
+        return (-1);
+    return (0);
+}
+
+/**
+ * xmlRelaxNGSchemaFreeValue:
+ * @data:  data needed for the library
+ * @value:  the value to free
+ *
+ * Function provided by a type library to free a Schemas value
+ *
+ * Returns 1 if yes, 0 if no and -1 in case of error.
+ */
+static void
+xmlRelaxNGSchemaFreeValue(void *data ATTRIBUTE_UNUSED, void *value)
+{
+    xmlSchemaFreeValue(value);
+}
+
+/**
+ * xmlRelaxNGSchemaTypeCompare:
+ * @data:  data needed for the library
+ * @type:  the type name
+ * @value1:  the first value
+ * @value2:  the second value
+ *
+ * Compare two values for equality accordingly a type from the W3C XMLSchema
+ * Datatype library.
+ *
+ * Returns 1 if equal, 0 if no and -1 in case of error.
+ */
+static int
+xmlRelaxNGSchemaTypeCompare(void *data ATTRIBUTE_UNUSED,
+                            const xmlChar * type,
+                            const xmlChar * value1,
+                            xmlNodePtr ctxt1,
+                            void *comp1,
+                            const xmlChar * value2, xmlNodePtr ctxt2)
+{
+    int ret;
+    xmlSchemaTypePtr typ;
+    xmlSchemaValPtr res1 = NULL, res2 = NULL;
+
+    if ((type == NULL) || (value1 == NULL) || (value2 == NULL))
+        return (-1);
+    typ = xmlSchemaGetPredefinedType(type,
+                                     BAD_CAST
+                                     "http://www.w3.org/2001/XMLSchema");
+    if (typ == NULL)
+        return (-1);
+    if (comp1 == NULL) {
+        ret = xmlSchemaValPredefTypeNode(typ, value1, &res1, ctxt1);
+        if (ret != 0)
+            return (-1);
+        if (res1 == NULL)
+            return (-1);
+    } else {
+        res1 = (xmlSchemaValPtr) comp1;
+    }
+    ret = xmlSchemaValPredefTypeNode(typ, value2, &res2, ctxt2);
+    if (ret != 0) {
+        xmlSchemaFreeValue(res1);
+        return (-1);
+    }
+    if (res1 == NULL) {
+        xmlSchemaFreeValue(res1);
+        return (-1);
+    }
+    ret = xmlSchemaCompareValues(res1, res2);
+    if (res1 != (xmlSchemaValPtr) comp1)
+        xmlSchemaFreeValue(res1);
+    xmlSchemaFreeValue(res2);
+    if (ret == -2)
+        return (-1);
+    if (ret == 0)
+        return (1);
+    return (0);
+}
+
+/**
+ * xmlRelaxNGDefaultTypeHave:
+ * @data:  data needed for the library
+ * @type:  the type name
+ *
+ * Check if the given type is provided by
+ * the default datatype library.
+ *
+ * Returns 1 if yes, 0 if no and -1 in case of error.
+ */
+static int
+xmlRelaxNGDefaultTypeHave(void *data ATTRIBUTE_UNUSED,
+                          const xmlChar * type)
+{
+    if (type == NULL)
+        return (-1);
+    if (xmlStrEqual(type, BAD_CAST "string"))
+        return (1);
+    if (xmlStrEqual(type, BAD_CAST "token"))
+        return (1);
+    return (0);
+}
+
+/**
+ * xmlRelaxNGDefaultTypeCheck:
+ * @data:  data needed for the library
+ * @type:  the type name
+ * @value:  the value to check
+ * @node:  the node
+ *
+ * Check if the given type and value are validated by
+ * the default datatype library.
+ *
+ * Returns 1 if yes, 0 if no and -1 in case of error.
+ */
+static int
+xmlRelaxNGDefaultTypeCheck(void *data ATTRIBUTE_UNUSED,
+                           const xmlChar * type ATTRIBUTE_UNUSED,
+                           const xmlChar * value ATTRIBUTE_UNUSED,
+                           void **result ATTRIBUTE_UNUSED,
+                           xmlNodePtr node ATTRIBUTE_UNUSED)
+{
+    if (value == NULL)
+        return (-1);
+    if (xmlStrEqual(type, BAD_CAST "string"))
+        return (1);
+    if (xmlStrEqual(type, BAD_CAST "token")) {
+        return (1);
+    }
+
+    return (0);
+}
+
+/**
+ * xmlRelaxNGDefaultTypeCompare:
+ * @data:  data needed for the library
+ * @type:  the type name
+ * @value1:  the first value
+ * @value2:  the second value
+ *
+ * Compare two values accordingly a type from the default
+ * datatype library.
+ *
+ * Returns 1 if yes, 0 if no and -1 in case of error.
+ */
+static int
+xmlRelaxNGDefaultTypeCompare(void *data ATTRIBUTE_UNUSED,
+                             const xmlChar * type,
+                             const xmlChar * value1,
+                             xmlNodePtr ctxt1 ATTRIBUTE_UNUSED,
+                             void *comp1 ATTRIBUTE_UNUSED,
+                             const xmlChar * value2,
+                             xmlNodePtr ctxt2 ATTRIBUTE_UNUSED)
+{
+    int ret = -1;
+
+    if (xmlStrEqual(type, BAD_CAST "string")) {
+        ret = xmlStrEqual(value1, value2);
+    } else if (xmlStrEqual(type, BAD_CAST "token")) {
+        if (!xmlStrEqual(value1, value2)) {
+            xmlChar *nval, *nvalue;
+
+            /*
+             * TODO: trivial optimizations are possible by
+             * computing at compile-time
+             */
+            nval = xmlRelaxNGNormalize(NULL, value1);
+            nvalue = xmlRelaxNGNormalize(NULL, value2);
+
+            if ((nval == NULL) || (nvalue == NULL))
+                ret = -1;
+            else if (xmlStrEqual(nval, nvalue))
+                ret = 1;
+            else
+                ret = 0;
+            if (nval != NULL)
+                xmlFree(nval);
+            if (nvalue != NULL)
+                xmlFree(nvalue);
+        } else
+            ret = 1;
+    }
+    return (ret);
+}
+
+static int xmlRelaxNGTypeInitialized = 0;
+static xmlHashTablePtr xmlRelaxNGRegisteredTypes = NULL;
+
+/**
+ * xmlRelaxNGFreeTypeLibrary:
+ * @lib:  the type library structure
+ * @namespace:  the URI bound to the library
+ *
+ * Free the structure associated to the type library
+ */
+static void
+xmlRelaxNGFreeTypeLibrary(xmlRelaxNGTypeLibraryPtr lib,
+                          const xmlChar * namespace ATTRIBUTE_UNUSED)
+{
+    if (lib == NULL)
+        return;
+    if (lib->namespace != NULL)
+        xmlFree((xmlChar *) lib->namespace);
+    xmlFree(lib);
+}
+
+/**
+ * xmlRelaxNGRegisterTypeLibrary:
+ * @namespace:  the URI bound to the library
+ * @data:  data associated to the library
+ * @have:  the provide function
+ * @check:  the checking function
+ * @comp:  the comparison function
+ *
+ * Register a new type library
+ *
+ * Returns 0 in case of success and -1 in case of error.
+ */
+static int
+xmlRelaxNGRegisterTypeLibrary(const xmlChar * namespace, void *data,
+                              xmlRelaxNGTypeHave have,
+                              xmlRelaxNGTypeCheck check,
+                              xmlRelaxNGTypeCompare comp,
+                              xmlRelaxNGFacetCheck facet,
+                              xmlRelaxNGTypeFree freef)
+{
+    xmlRelaxNGTypeLibraryPtr lib;
+    int ret;
+
+    if ((xmlRelaxNGRegisteredTypes == NULL) || (namespace == NULL) ||
+        (check == NULL) || (comp == NULL))
+        return (-1);
+    if (xmlHashLookup(xmlRelaxNGRegisteredTypes, namespace) != NULL) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "Relax-NG types library '%s' already registered\n",
+                        namespace);
+        return (-1);
+    }
+    lib =
+        (xmlRelaxNGTypeLibraryPtr)
+        xmlMalloc(sizeof(xmlRelaxNGTypeLibrary));
+    if (lib == NULL) {
+        xmlRngVErrMemory(NULL, "adding types library\n");
+        return (-1);
+    }
+    memset(lib, 0, sizeof(xmlRelaxNGTypeLibrary));
+    lib->namespace = xmlStrdup(namespace);
+    lib->data = data;
+    lib->have = have;
+    lib->comp = comp;
+    lib->check = check;
+    lib->facet = facet;
+    lib->freef = freef;
+    ret = xmlHashAddEntry(xmlRelaxNGRegisteredTypes, namespace, lib);
+    if (ret < 0) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "Relax-NG types library failed to register '%s'\n",
+                        namespace);
+        xmlRelaxNGFreeTypeLibrary(lib, namespace);
+        return (-1);
+    }
+    return (0);
+}
+
+/**
+ * xmlRelaxNGInitTypes:
+ *
+ * Initilize the default type libraries.
+ *
+ * Returns 0 in case of success and -1 in case of error.
+ */
+static int
+xmlRelaxNGInitTypes(void)
+{
+    if (xmlRelaxNGTypeInitialized != 0)
+        return (0);
+    xmlRelaxNGRegisteredTypes = xmlHashCreate(10);
+    if (xmlRelaxNGRegisteredTypes == NULL) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "Failed to allocate sh table for Relax-NG types\n");
+        return (-1);
+    }
+    xmlRelaxNGRegisterTypeLibrary(BAD_CAST
+                                  "http://www.w3.org/2001/XMLSchema-datatypes",
+                                  NULL, xmlRelaxNGSchemaTypeHave,
+                                  xmlRelaxNGSchemaTypeCheck,
+                                  xmlRelaxNGSchemaTypeCompare,
+                                  xmlRelaxNGSchemaFacetCheck,
+                                  xmlRelaxNGSchemaFreeValue);
+    xmlRelaxNGRegisterTypeLibrary(xmlRelaxNGNs, NULL,
+                                  xmlRelaxNGDefaultTypeHave,
+                                  xmlRelaxNGDefaultTypeCheck,
+                                  xmlRelaxNGDefaultTypeCompare, NULL,
+                                  NULL);
+    xmlRelaxNGTypeInitialized = 1;
+    return (0);
+}
+
+/**
+ * xmlRelaxNGCleanupTypes:
+ *
+ * Cleanup the default Schemas type library associated to RelaxNG
+ */
+void
+xmlRelaxNGCleanupTypes(void)
+{
+    xmlSchemaCleanupTypes();
+    if (xmlRelaxNGTypeInitialized == 0)
+        return;
+    xmlHashFree(xmlRelaxNGRegisteredTypes, (xmlHashDeallocator)
+                xmlRelaxNGFreeTypeLibrary);
+    xmlRelaxNGTypeInitialized = 0;
+}
+
+/************************************************************************
+ * 									*
+ * 		Compiling element content into regexp			*
+ * 									*
+ * Sometime the element content can be compiled into a pure regexp,	*
+ * This allows a faster execution and streamability at that level	*
+ * 									*
+ ************************************************************************/
+
+static int xmlRelaxNGTryCompile(xmlRelaxNGParserCtxtPtr ctxt,
+                                xmlRelaxNGDefinePtr def);
+
+/**
+ * xmlRelaxNGIsCompileable:
+ * @define:  the definition to check
+ *
+ * Check if a definition is nullable.
+ *
+ * Returns 1 if yes, 0 if no and -1 in case of error
+ */
+static int
+xmlRelaxNGIsCompileable(xmlRelaxNGDefinePtr def)
+{
+    int ret = -1;
+
+    if (def == NULL) {
+        return (-1);
+    }
+    if ((def->type != XML_RELAXNG_ELEMENT) &&
+        (def->dflags & IS_COMPILABLE))
+        return (1);
+    if ((def->type != XML_RELAXNG_ELEMENT) &&
+        (def->dflags & IS_NOT_COMPILABLE))
+        return (0);
+    switch (def->type) {
+        case XML_RELAXNG_NOOP:
+            ret = xmlRelaxNGIsCompileable(def->content);
+            break;
+        case XML_RELAXNG_TEXT:
+        case XML_RELAXNG_EMPTY:
+            ret = 1;
+            break;
+        case XML_RELAXNG_ELEMENT:
+            /*
+             * Check if the element content is compileable
+             */
+            if (((def->dflags & IS_NOT_COMPILABLE) == 0) &&
+                ((def->dflags & IS_COMPILABLE) == 0)) {
+                xmlRelaxNGDefinePtr list;
+
+                list = def->content;
+                while (list != NULL) {
+                    ret = xmlRelaxNGIsCompileable(list);
+                    if (ret != 1)
+                        break;
+                    list = list->next;
+                }
+		/*
+		 * Because the routine is recursive, we must guard against
+		 * discovering both COMPILABLE and NOT_COMPILABLE
+		 */
+                if (ret == 0) {
+		    def->dflags &= ~IS_COMPILABLE;
+                    def->dflags |= IS_NOT_COMPILABLE;
+		}
+                if ((ret == 1) && !(def->dflags &= IS_NOT_COMPILABLE))
+                    def->dflags |= IS_COMPILABLE;
+#ifdef DEBUG_COMPILE
+                if (ret == 1) {
+                    xmlGenericError(xmlGenericErrorContext,
+                                    "element content for %s is compilable\n",
+                                    def->name);
+                } else if (ret == 0) {
+                    xmlGenericError(xmlGenericErrorContext,
+                                    "element content for %s is not compilable\n",
+                                    def->name);
+                } else {
+                    xmlGenericError(xmlGenericErrorContext,
+                                    "Problem in RelaxNGIsCompileable for element %s\n",
+                                    def->name);
+                }
+#endif
+            }
+            /*
+             * All elements return a compileable status unless they
+             * are generic like anyName
+             */
+            if ((def->nameClass != NULL) || (def->name == NULL))
+                ret = 0;
+            else
+                ret = 1;
+            return (ret);
+        case XML_RELAXNG_REF:
+        case XML_RELAXNG_EXTERNALREF:
+        case XML_RELAXNG_PARENTREF:
+            if (def->depth == -20) {
+                return (1);
+            } else {
+                xmlRelaxNGDefinePtr list;
+
+                def->depth = -20;
+                list = def->content;
+                while (list != NULL) {
+                    ret = xmlRelaxNGIsCompileable(list);
+                    if (ret != 1)
+                        break;
+                    list = list->next;
+                }
+            }
+            break;
+        case XML_RELAXNG_START:
+        case XML_RELAXNG_OPTIONAL:
+        case XML_RELAXNG_ZEROORMORE:
+        case XML_RELAXNG_ONEORMORE:
+        case XML_RELAXNG_CHOICE:
+        case XML_RELAXNG_GROUP:
+        case XML_RELAXNG_DEF:{
+                xmlRelaxNGDefinePtr list;
+
+                list = def->content;
+                while (list != NULL) {
+                    ret = xmlRelaxNGIsCompileable(list);
+                    if (ret != 1)
+                        break;
+                    list = list->next;
+                }
+                break;
+            }
+        case XML_RELAXNG_EXCEPT:
+        case XML_RELAXNG_ATTRIBUTE:
+        case XML_RELAXNG_INTERLEAVE:
+        case XML_RELAXNG_DATATYPE:
+        case XML_RELAXNG_LIST:
+        case XML_RELAXNG_PARAM:
+        case XML_RELAXNG_VALUE:
+        case XML_RELAXNG_NOT_ALLOWED:
+            ret = 0;
+            break;
+    }
+    if (ret == 0)
+        def->dflags |= IS_NOT_COMPILABLE;
+    if (ret == 1)
+        def->dflags |= IS_COMPILABLE;
+#ifdef DEBUG_COMPILE
+    if (ret == 1) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "RelaxNGIsCompileable %s : true\n",
+                        xmlRelaxNGDefName(def));
+    } else if (ret == 0) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "RelaxNGIsCompileable %s : false\n",
+                        xmlRelaxNGDefName(def));
+    } else {
+        xmlGenericError(xmlGenericErrorContext,
+                        "Problem in RelaxNGIsCompileable %s\n",
+                        xmlRelaxNGDefName(def));
+    }
+#endif
+    return (ret);
+}
+
+/**
+ * xmlRelaxNGCompile:
+ * ctxt:  the RelaxNG parser context
+ * @define:  the definition tree to compile
+ *
+ * Compile the set of definitions, it works recursively, till the
+ * element boundaries, where it tries to compile the content if possible
+ *
+ * Returns 0 if success and -1 in case of error
+ */
+static int
+xmlRelaxNGCompile(xmlRelaxNGParserCtxtPtr ctxt, xmlRelaxNGDefinePtr def)
+{
+    int ret = 0;
+    xmlRelaxNGDefinePtr list;
+
+    if ((ctxt == NULL) || (def == NULL))
+        return (-1);
+
+    switch (def->type) {
+        case XML_RELAXNG_START:
+            if ((xmlRelaxNGIsCompileable(def) == 1) && (def->depth != -25)) {
+                xmlAutomataPtr oldam = ctxt->am;
+                xmlAutomataStatePtr oldstate = ctxt->state;
+
+                def->depth = -25;
+
+                list = def->content;
+                ctxt->am = xmlNewAutomata();
+                if (ctxt->am == NULL)
+                    return (-1);
+                ctxt->state = xmlAutomataGetInitState(ctxt->am);
+                while (list != NULL) {
+                    xmlRelaxNGCompile(ctxt, list);
+                    list = list->next;
+                }
+                xmlAutomataSetFinalState(ctxt->am, ctxt->state);
+                def->contModel = xmlAutomataCompile(ctxt->am);
+                xmlRegexpIsDeterminist(def->contModel);
+
+                xmlFreeAutomata(ctxt->am);
+                ctxt->state = oldstate;
+                ctxt->am = oldam;
+            }
+            break;
+        case XML_RELAXNG_ELEMENT:
+            if ((ctxt->am != NULL) && (def->name != NULL)) {
+                ctxt->state = xmlAutomataNewTransition2(ctxt->am,
+                                                        ctxt->state, NULL,
+                                                        def->name, def->ns,
+                                                        def);
+            }
+            if ((def->dflags & IS_COMPILABLE) && (def->depth != -25)) {
+                xmlAutomataPtr oldam = ctxt->am;
+                xmlAutomataStatePtr oldstate = ctxt->state;
+
+                def->depth = -25;
+
+                list = def->content;
+                ctxt->am = xmlNewAutomata();
+                if (ctxt->am == NULL)
+                    return (-1);
+                ctxt->state = xmlAutomataGetInitState(ctxt->am);
+                while (list != NULL) {
+                    xmlRelaxNGCompile(ctxt, list);
+                    list = list->next;
+                }
+                xmlAutomataSetFinalState(ctxt->am, ctxt->state);
+                def->contModel = xmlAutomataCompile(ctxt->am);
+                if (!xmlRegexpIsDeterminist(def->contModel)) {
+                    /*
+                     * we can only use the automata if it is determinist
+                     */
+                    xmlRegFreeRegexp(def->contModel);
+                    def->contModel = NULL;
+                }
+                xmlFreeAutomata(ctxt->am);
+                ctxt->state = oldstate;
+                ctxt->am = oldam;
+            } else {
+                xmlAutomataPtr oldam = ctxt->am;
+
+                /*
+                 * we can't build the content model for this element content
+                 * but it still might be possible to build it for some of its
+                 * children, recurse.
+                 */
+                ret = xmlRelaxNGTryCompile(ctxt, def);
+                ctxt->am = oldam;
+            }
+            break;
+        case XML_RELAXNG_NOOP:
+            ret = xmlRelaxNGCompile(ctxt, def->content);
+            break;
+        case XML_RELAXNG_OPTIONAL:{
+                xmlAutomataStatePtr oldstate = ctxt->state;
+
+                xmlRelaxNGCompile(ctxt, def->content);
+                xmlAutomataNewEpsilon(ctxt->am, oldstate, ctxt->state);
+                break;
+            }
+        case XML_RELAXNG_ZEROORMORE:{
+                xmlAutomataStatePtr oldstate;
+
+                ctxt->state =
+                    xmlAutomataNewEpsilon(ctxt->am, ctxt->state, NULL);
+                oldstate = ctxt->state;
+                list = def->content;
+                while (list != NULL) {
+                    xmlRelaxNGCompile(ctxt, list);
+                    list = list->next;
+                }
+                xmlAutomataNewEpsilon(ctxt->am, ctxt->state, oldstate);
+                ctxt->state =
+                    xmlAutomataNewEpsilon(ctxt->am, oldstate, NULL);
+                break;
+            }
+        case XML_RELAXNG_ONEORMORE:{
+                xmlAutomataStatePtr oldstate;
+
+                list = def->content;
+                while (list != NULL) {
+                    xmlRelaxNGCompile(ctxt, list);
+                    list = list->next;
+                }
+                oldstate = ctxt->state;
+                list = def->content;
+                while (list != NULL) {
+                    xmlRelaxNGCompile(ctxt, list);
+                    list = list->next;
+                }
+                xmlAutomataNewEpsilon(ctxt->am, ctxt->state, oldstate);
+                ctxt->state =
+                    xmlAutomataNewEpsilon(ctxt->am, oldstate, NULL);
+                break;
+            }
+        case XML_RELAXNG_CHOICE:{
+                xmlAutomataStatePtr target = NULL;
+                xmlAutomataStatePtr oldstate = ctxt->state;
+
+                list = def->content;
+                while (list != NULL) {
+                    ctxt->state = oldstate;
+                    ret = xmlRelaxNGCompile(ctxt, list);
+                    if (ret != 0)
+                        break;
+                    if (target == NULL)
+                        target = ctxt->state;
+                    else {
+                        xmlAutomataNewEpsilon(ctxt->am, ctxt->state,
+                                              target);
+                    }
+                    list = list->next;
+                }
+                ctxt->state = target;
+
+                break;
+            }
+        case XML_RELAXNG_REF:
+        case XML_RELAXNG_EXTERNALREF:
+        case XML_RELAXNG_PARENTREF:
+        case XML_RELAXNG_GROUP:
+        case XML_RELAXNG_DEF:
+            list = def->content;
+            while (list != NULL) {
+                ret = xmlRelaxNGCompile(ctxt, list);
+                if (ret != 0)
+                    break;
+                list = list->next;
+            }
+            break;
+        case XML_RELAXNG_TEXT:{
+                xmlAutomataStatePtr oldstate;
+
+                ctxt->state =
+                    xmlAutomataNewEpsilon(ctxt->am, ctxt->state, NULL);
+                oldstate = ctxt->state;
+                xmlRelaxNGCompile(ctxt, def->content);
+                xmlAutomataNewTransition(ctxt->am, ctxt->state,
+                                         ctxt->state, BAD_CAST "#text",
+                                         NULL);
+                ctxt->state =
+                    xmlAutomataNewEpsilon(ctxt->am, oldstate, NULL);
+                break;
+            }
+        case XML_RELAXNG_EMPTY:
+            ctxt->state =
+                xmlAutomataNewEpsilon(ctxt->am, ctxt->state, NULL);
+            break;
+        case XML_RELAXNG_EXCEPT:
+        case XML_RELAXNG_ATTRIBUTE:
+        case XML_RELAXNG_INTERLEAVE:
+        case XML_RELAXNG_NOT_ALLOWED:
+        case XML_RELAXNG_DATATYPE:
+        case XML_RELAXNG_LIST:
+        case XML_RELAXNG_PARAM:
+        case XML_RELAXNG_VALUE:
+            /* This should not happen and generate an internal error */
+            fprintf(stderr, "RNG internal error trying to compile %s\n",
+                    xmlRelaxNGDefName(def));
+            break;
+    }
+    return (ret);
+}
+
+/**
+ * xmlRelaxNGTryCompile:
+ * ctxt:  the RelaxNG parser context
+ * @define:  the definition tree to compile
+ *
+ * Try to compile the set of definitions, it works recursively,
+ * possibly ignoring parts which cannot be compiled.
+ *
+ * Returns 0 if success and -1 in case of error
+ */
+static int
+xmlRelaxNGTryCompile(xmlRelaxNGParserCtxtPtr ctxt, xmlRelaxNGDefinePtr def)
+{
+    int ret = 0;
+    xmlRelaxNGDefinePtr list;
+
+    if ((ctxt == NULL) || (def == NULL))
+        return (-1);
+
+    if ((def->type == XML_RELAXNG_START) ||
+        (def->type == XML_RELAXNG_ELEMENT)) {
+        ret = xmlRelaxNGIsCompileable(def);
+        if ((def->dflags & IS_COMPILABLE) && (def->depth != -25)) {
+            ctxt->am = NULL;
+            ret = xmlRelaxNGCompile(ctxt, def);
+#ifdef DEBUG_PROGRESSIVE
+            if (ret == 0) {
+                if (def->type == XML_RELAXNG_START)
+                    xmlGenericError(xmlGenericErrorContext,
+                                    "compiled the start\n");
+                else
+                    xmlGenericError(xmlGenericErrorContext,
+                                    "compiled element %s\n", def->name);
+            } else {
+                if (def->type == XML_RELAXNG_START)
+                    xmlGenericError(xmlGenericErrorContext,
+                                    "failed to compile the start\n");
+                else
+                    xmlGenericError(xmlGenericErrorContext,
+                                    "failed to compile element %s\n",
+                                    def->name);
+            }
+#endif
+            return (ret);
+        }
+    }
+    switch (def->type) {
+        case XML_RELAXNG_NOOP:
+            ret = xmlRelaxNGTryCompile(ctxt, def->content);
+            break;
+        case XML_RELAXNG_TEXT:
+        case XML_RELAXNG_DATATYPE:
+        case XML_RELAXNG_LIST:
+        case XML_RELAXNG_PARAM:
+        case XML_RELAXNG_VALUE:
+        case XML_RELAXNG_EMPTY:
+        case XML_RELAXNG_ELEMENT:
+            ret = 0;
+            break;
+        case XML_RELAXNG_OPTIONAL:
+        case XML_RELAXNG_ZEROORMORE:
+        case XML_RELAXNG_ONEORMORE:
+        case XML_RELAXNG_CHOICE:
+        case XML_RELAXNG_GROUP:
+        case XML_RELAXNG_DEF:
+        case XML_RELAXNG_START:
+        case XML_RELAXNG_REF:
+        case XML_RELAXNG_EXTERNALREF:
+        case XML_RELAXNG_PARENTREF:
+            list = def->content;
+            while (list != NULL) {
+                ret = xmlRelaxNGTryCompile(ctxt, list);
+                if (ret != 0)
+                    break;
+                list = list->next;
+            }
+            break;
+        case XML_RELAXNG_EXCEPT:
+        case XML_RELAXNG_ATTRIBUTE:
+        case XML_RELAXNG_INTERLEAVE:
+        case XML_RELAXNG_NOT_ALLOWED:
+            ret = 0;
+            break;
+    }
+    return (ret);
+}
+
+/************************************************************************
+ * 									*
+ * 			Parsing functions				*
+ * 									*
+ ************************************************************************/
+
+static xmlRelaxNGDefinePtr xmlRelaxNGParseAttribute(xmlRelaxNGParserCtxtPtr
+                                                    ctxt, xmlNodePtr node);
+static xmlRelaxNGDefinePtr xmlRelaxNGParseElement(xmlRelaxNGParserCtxtPtr
+                                                  ctxt, xmlNodePtr node);
+static xmlRelaxNGDefinePtr xmlRelaxNGParsePatterns(xmlRelaxNGParserCtxtPtr
+                                                   ctxt, xmlNodePtr nodes,
+                                                   int group);
+static xmlRelaxNGDefinePtr xmlRelaxNGParsePattern(xmlRelaxNGParserCtxtPtr
+                                                  ctxt, xmlNodePtr node);
+static xmlRelaxNGPtr xmlRelaxNGParseDocument(xmlRelaxNGParserCtxtPtr ctxt,
+                                             xmlNodePtr node);
+static int xmlRelaxNGParseGrammarContent(xmlRelaxNGParserCtxtPtr ctxt,
+                                         xmlNodePtr nodes);
+static xmlRelaxNGDefinePtr xmlRelaxNGParseNameClass(xmlRelaxNGParserCtxtPtr
+                                                    ctxt, xmlNodePtr node,
+                                                    xmlRelaxNGDefinePtr
+                                                    def);
+static xmlRelaxNGGrammarPtr xmlRelaxNGParseGrammar(xmlRelaxNGParserCtxtPtr
+                                                   ctxt, xmlNodePtr nodes);
+static int xmlRelaxNGElementMatch(xmlRelaxNGValidCtxtPtr ctxt,
+                                  xmlRelaxNGDefinePtr define,
+                                  xmlNodePtr elem);
+
+
+#define IS_BLANK_NODE(n) (xmlRelaxNGIsBlank((n)->content))
+
+/**
+ * xmlRelaxNGIsNullable:
+ * @define:  the definition to verify
+ *
+ * Check if a definition is nullable.
+ *
+ * Returns 1 if yes, 0 if no and -1 in case of error
+ */
+static int
+xmlRelaxNGIsNullable(xmlRelaxNGDefinePtr define)
+{
+    int ret;
+
+    if (define == NULL)
+        return (-1);
+
+    if (define->dflags & IS_NULLABLE)
+        return (1);
+    if (define->dflags & IS_NOT_NULLABLE)
+        return (0);
+    switch (define->type) {
+        case XML_RELAXNG_EMPTY:
+        case XML_RELAXNG_TEXT:
+            ret = 1;
+            break;
+        case XML_RELAXNG_NOOP:
+        case XML_RELAXNG_DEF:
+        case XML_RELAXNG_REF:
+        case XML_RELAXNG_EXTERNALREF:
+        case XML_RELAXNG_PARENTREF:
+        case XML_RELAXNG_ONEORMORE:
+            ret = xmlRelaxNGIsNullable(define->content);
+            break;
+        case XML_RELAXNG_EXCEPT:
+        case XML_RELAXNG_NOT_ALLOWED:
+        case XML_RELAXNG_ELEMENT:
+        case XML_RELAXNG_DATATYPE:
+        case XML_RELAXNG_PARAM:
+        case XML_RELAXNG_VALUE:
+        case XML_RELAXNG_LIST:
+        case XML_RELAXNG_ATTRIBUTE:
+            ret = 0;
+            break;
+        case XML_RELAXNG_CHOICE:{
+                xmlRelaxNGDefinePtr list = define->content;
+
+                while (list != NULL) {
+                    ret = xmlRelaxNGIsNullable(list);
+                    if (ret != 0)
+                        goto done;
+                    list = list->next;
+                }
+                ret = 0;
+                break;
+            }
+        case XML_RELAXNG_START:
+        case XML_RELAXNG_INTERLEAVE:
+        case XML_RELAXNG_GROUP:{
+                xmlRelaxNGDefinePtr list = define->content;
+
+                while (list != NULL) {
+                    ret = xmlRelaxNGIsNullable(list);
+                    if (ret != 1)
+                        goto done;
+                    list = list->next;
+                }
+                return (1);
+            }
+        default:
+            return (-1);
+    }
+  done:
+    if (ret == 0)
+        define->dflags |= IS_NOT_NULLABLE;
+    if (ret == 1)
+        define->dflags |= IS_NULLABLE;
+    return (ret);
+}
+
+/**
+ * xmlRelaxNGIsBlank:
+ * @str:  a string
+ *
+ * Check if a string is ignorable c.f. 4.2. Whitespace
+ *
+ * Returns 1 if the string is NULL or made of blanks chars, 0 otherwise
+ */
+static int
+xmlRelaxNGIsBlank(xmlChar * str)
+{
+    if (str == NULL)
+        return (1);
+    while (*str != 0) {
+        if (!(IS_BLANK_CH(*str)))
+            return (0);
+        str++;
+    }
+    return (1);
+}
+
+/**
+ * xmlRelaxNGGetDataTypeLibrary:
+ * @ctxt:  a Relax-NG parser context
+ * @node:  the current data or value element
+ *
+ * Applies algorithm from 4.3. datatypeLibrary attribute
+ *
+ * Returns the datatypeLibary value or NULL if not found
+ */
+static xmlChar *
+xmlRelaxNGGetDataTypeLibrary(xmlRelaxNGParserCtxtPtr ctxt ATTRIBUTE_UNUSED,
+                             xmlNodePtr node)
+{
+    xmlChar *ret, *escape;
+
+    if ((IS_RELAXNG(node, "data")) || (IS_RELAXNG(node, "value"))) {
+        ret = xmlGetProp(node, BAD_CAST "datatypeLibrary");
+        if (ret != NULL) {
+            if (ret[0] == 0) {
+                xmlFree(ret);
+                return (NULL);
+            }
+            escape = xmlURIEscapeStr(ret, BAD_CAST ":/#?");
+            if (escape == NULL) {
+                return (ret);
+            }
+            xmlFree(ret);
+            return (escape);
+        }
+    }
+    node = node->parent;
+    while ((node != NULL) && (node->type == XML_ELEMENT_NODE)) {
+        ret = xmlGetProp(node, BAD_CAST "datatypeLibrary");
+        if (ret != NULL) {
+            if (ret[0] == 0) {
+                xmlFree(ret);
+                return (NULL);
+            }
+            escape = xmlURIEscapeStr(ret, BAD_CAST ":/#?");
+            if (escape == NULL) {
+                return (ret);
+            }
+            xmlFree(ret);
+            return (escape);
+        }
+        node = node->parent;
+    }
+    return (NULL);
+}
+
+/**
+ * xmlRelaxNGParseValue:
+ * @ctxt:  a Relax-NG parser context
+ * @node:  the data node.
+ *
+ * parse the content of a RelaxNG value node.
+ *
+ * Returns the definition pointer or NULL in case of error
+ */
+static xmlRelaxNGDefinePtr
+xmlRelaxNGParseValue(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
+{
+    xmlRelaxNGDefinePtr def = NULL;
+    xmlRelaxNGTypeLibraryPtr lib = NULL;
+    xmlChar *type;
+    xmlChar *library;
+    int success = 0;
+
+    def = xmlRelaxNGNewDefine(ctxt, node);
+    if (def == NULL)
+        return (NULL);
+    def->type = XML_RELAXNG_VALUE;
+
+    type = xmlGetProp(node, BAD_CAST "type");
+    if (type != NULL) {
+        xmlRelaxNGNormExtSpace(type);
+        if (xmlValidateNCName(type, 0)) {
+            xmlRngPErr(ctxt, node, XML_RNGP_TYPE_VALUE,
+                       "value type '%s' is not an NCName\n", type, NULL);
+        }
+        library = xmlRelaxNGGetDataTypeLibrary(ctxt, node);
+        if (library == NULL)
+            library =
+                xmlStrdup(BAD_CAST "http://relaxng.org/ns/structure/1.0");
+
+        def->name = type;
+        def->ns = library;
+
+        lib = (xmlRelaxNGTypeLibraryPtr)
+            xmlHashLookup(xmlRelaxNGRegisteredTypes, library);
+        if (lib == NULL) {
+            xmlRngPErr(ctxt, node, XML_RNGP_UNKNOWN_TYPE_LIB,
+                       "Use of unregistered type library '%s'\n", library,
+                       NULL);
+            def->data = NULL;
+        } else {
+            def->data = lib;
+            if (lib->have == NULL) {
+                xmlRngPErr(ctxt, node, XML_RNGP_ERROR_TYPE_LIB,
+                           "Internal error with type library '%s': no 'have'\n",
+                           library, NULL);
+            } else {
+                success = lib->have(lib->data, def->name);
+                if (success != 1) {
+                    xmlRngPErr(ctxt, node, XML_RNGP_TYPE_NOT_FOUND,
+                               "Error type '%s' is not exported by type library '%s'\n",
+                               def->name, library);
+                }
+            }
+        }
+    }
+    if (node->children == NULL) {
+        def->value = xmlStrdup(BAD_CAST "");
+    } else if (((node->children->type != XML_TEXT_NODE) &&
+                (node->children->type != XML_CDATA_SECTION_NODE)) ||
+               (node->children->next != NULL)) {
+        xmlRngPErr(ctxt, node, XML_RNGP_TEXT_EXPECTED,
+                   "Expecting a single text value for <value>content\n",
+                   NULL, NULL);
+    } else if (def != NULL) {
+        def->value = xmlNodeGetContent(node);
+        if (def->value == NULL) {
+            xmlRngPErr(ctxt, node, XML_RNGP_VALUE_NO_CONTENT,
+                       "Element <value> has no content\n", NULL, NULL);
+        } else if ((lib != NULL) && (lib->check != NULL) && (success == 1)) {
+            void *val = NULL;
+
+            success =
+                lib->check(lib->data, def->name, def->value, &val, node);
+            if (success != 1) {
+                xmlRngPErr(ctxt, node, XML_RNGP_INVALID_VALUE,
+                           "Value '%s' is not acceptable for type '%s'\n",
+                           def->value, def->name);
+            } else {
+                if (val != NULL)
+                    def->attrs = val;
+            }
+        }
+    }
+    return (def);
+}
+
+/**
+ * xmlRelaxNGParseData:
+ * @ctxt:  a Relax-NG parser context
+ * @node:  the data node.
+ *
+ * parse the content of a RelaxNG data node.
+ *
+ * Returns the definition pointer or NULL in case of error
+ */
+static xmlRelaxNGDefinePtr
+xmlRelaxNGParseData(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
+{
+    xmlRelaxNGDefinePtr def = NULL, except, last = NULL;
+    xmlRelaxNGDefinePtr param, lastparam = NULL;
+    xmlRelaxNGTypeLibraryPtr lib;
+    xmlChar *type;
+    xmlChar *library;
+    xmlNodePtr content;
+    int tmp;
+
+    type = xmlGetProp(node, BAD_CAST "type");
+    if (type == NULL) {
+        xmlRngPErr(ctxt, node, XML_RNGP_TYPE_MISSING, "data has no type\n", NULL,
+                   NULL);
+        return (NULL);
+    }
+    xmlRelaxNGNormExtSpace(type);
+    if (xmlValidateNCName(type, 0)) {
+        xmlRngPErr(ctxt, node, XML_RNGP_TYPE_VALUE,
+                   "data type '%s' is not an NCName\n", type, NULL);
+    }
+    library = xmlRelaxNGGetDataTypeLibrary(ctxt, node);
+    if (library == NULL)
+        library =
+            xmlStrdup(BAD_CAST "http://relaxng.org/ns/structure/1.0");
+
+    def = xmlRelaxNGNewDefine(ctxt, node);
+    if (def == NULL) {
+        xmlFree(type);
+        return (NULL);
+    }
+    def->type = XML_RELAXNG_DATATYPE;
+    def->name = type;
+    def->ns = library;
+
+    lib = (xmlRelaxNGTypeLibraryPtr)
+        xmlHashLookup(xmlRelaxNGRegisteredTypes, library);
+    if (lib == NULL) {
+        xmlRngPErr(ctxt, node, XML_RNGP_UNKNOWN_TYPE_LIB,
+                   "Use of unregistered type library '%s'\n", library,
+                   NULL);
+        def->data = NULL;
+    } else {
+        def->data = lib;
+        if (lib->have == NULL) {
+            xmlRngPErr(ctxt, node, XML_RNGP_ERROR_TYPE_LIB,
+                       "Internal error with type library '%s': no 'have'\n",
+                       library, NULL);
+        } else {
+            tmp = lib->have(lib->data, def->name);
+            if (tmp != 1) {
+                xmlRngPErr(ctxt, node, XML_RNGP_TYPE_NOT_FOUND,
+                           "Error type '%s' is not exported by type library '%s'\n",
+                           def->name, library);
+            } else
+                if ((xmlStrEqual
+                     (library,
+                      BAD_CAST
+                      "http://www.w3.org/2001/XMLSchema-datatypes"))
+                    && ((xmlStrEqual(def->name, BAD_CAST "IDREF"))
+                        || (xmlStrEqual(def->name, BAD_CAST "IDREFS")))) {
+                ctxt->idref = 1;
+            }
+        }
+    }
+    content = node->children;
+
+    /*
+     * Handle optional params
+     */
+    while (content != NULL) {
+        if (!xmlStrEqual(content->name, BAD_CAST "param"))
+            break;
+        if (xmlStrEqual(library,
+                        BAD_CAST "http://relaxng.org/ns/structure/1.0")) {
+            xmlRngPErr(ctxt, node, XML_RNGP_PARAM_FORBIDDEN,
+                       "Type library '%s' does not allow type parameters\n",
+                       library, NULL);
+            content = content->next;
+            while ((content != NULL) &&
+                   (xmlStrEqual(content->name, BAD_CAST "param")))
+                content = content->next;
+        } else {
+            param = xmlRelaxNGNewDefine(ctxt, node);
+            if (param != NULL) {
+                param->type = XML_RELAXNG_PARAM;
+                param->name = xmlGetProp(content, BAD_CAST "name");
+                if (param->name == NULL) {
+                    xmlRngPErr(ctxt, node, XML_RNGP_PARAM_NAME_MISSING,
+                               "param has no name\n", NULL, NULL);
+                }
+                param->value = xmlNodeGetContent(content);
+                if (lastparam == NULL) {
+                    def->attrs = lastparam = param;
+                } else {
+                    lastparam->next = param;
+                    lastparam = param;
+                }
+                if (lib != NULL) {
+                }
+            }
+            content = content->next;
+        }
+    }
+    /*
+     * Handle optional except
+     */
+    if ((content != NULL)
+        && (xmlStrEqual(content->name, BAD_CAST "except"))) {
+        xmlNodePtr child;
+        xmlRelaxNGDefinePtr tmp2, last2 = NULL;
+
+        except = xmlRelaxNGNewDefine(ctxt, node);
+        if (except == NULL) {
+            return (def);
+        }
+        except->type = XML_RELAXNG_EXCEPT;
+        child = content->children;
+        if (last == NULL) {
+            def->content = except;
+        } else {
+            last->next = except;
+        }
+        if (child == NULL) {
+            xmlRngPErr(ctxt, content, XML_RNGP_EXCEPT_NO_CONTENT,
+                       "except has no content\n", NULL, NULL);
+        }
+        while (child != NULL) {
+            tmp2 = xmlRelaxNGParsePattern(ctxt, child);
+            if (tmp2 != NULL) {
+                if (last2 == NULL) {
+                    except->content = last2 = tmp2;
+                } else {
+                    last2->next = tmp2;
+                    last2 = tmp2;
+                }
+            }
+            child = child->next;
+        }
+        content = content->next;
+    }
+    /*
+     * Check there is no unhandled data
+     */
+    if (content != NULL) {
+        xmlRngPErr(ctxt, content, XML_RNGP_DATA_CONTENT,
+                   "Element data has unexpected content %s\n",
+                   content->name, NULL);
+    }
+
+    return (def);
+}
+
+static const xmlChar *invalidName = BAD_CAST "\1";
+
+/**
+ * xmlRelaxNGCompareNameClasses:
+ * @defs1:  the first element/attribute defs
+ * @defs2:  the second element/attribute defs
+ * @name:  the restriction on the name
+ * @ns:  the restriction on the namespace
+ *
+ * Compare the 2 lists of element definitions. The comparison is
+ * that if both lists do not accept the same QNames, it returns 1
+ * If the 2 lists can accept the same QName the comparison returns 0
+ *
+ * Returns 1 disttinct, 0 if equal
+ */
+static int
+xmlRelaxNGCompareNameClasses(xmlRelaxNGDefinePtr def1,
+                             xmlRelaxNGDefinePtr def2)
+{
+    int ret = 1;
+    xmlNode node;
+    xmlNs ns;
+    xmlRelaxNGValidCtxt ctxt;
+
+    ctxt.flags = FLAGS_IGNORABLE;
+
+    memset(&ctxt, 0, sizeof(xmlRelaxNGValidCtxt));
+
+    if ((def1->type == XML_RELAXNG_ELEMENT) ||
+        (def1->type == XML_RELAXNG_ATTRIBUTE)) {
+        if (def2->type == XML_RELAXNG_TEXT)
+            return (1);
+        if (def1->name != NULL) {
+            node.name = def1->name;
+        } else {
+            node.name = invalidName;
+        }
+        if (def1->ns != NULL) {
+            if (def1->ns[0] == 0) {
+                node.ns = NULL;
+            } else {
+	        node.ns = &ns;
+                ns.href = def1->ns;
+            }
+        } else {
+            node.ns = NULL;
+        }
+        if (xmlRelaxNGElementMatch(&ctxt, def2, &node)) {
+            if (def1->nameClass != NULL) {
+                ret = xmlRelaxNGCompareNameClasses(def1->nameClass, def2);
+            } else {
+                ret = 0;
+            }
+        } else {
+            ret = 1;
+        }
+    } else if (def1->type == XML_RELAXNG_TEXT) {
+        if (def2->type == XML_RELAXNG_TEXT)
+            return (0);
+        return (1);
+    } else if (def1->type == XML_RELAXNG_EXCEPT) {
+        TODO ret = 0;
+    } else {
+        TODO ret = 0;
+    }
+    if (ret == 0)
+        return (ret);
+    if ((def2->type == XML_RELAXNG_ELEMENT) ||
+        (def2->type == XML_RELAXNG_ATTRIBUTE)) {
+        if (def2->name != NULL) {
+            node.name = def2->name;
+        } else {
+            node.name = invalidName;
+        }
+        node.ns = &ns;
+        if (def2->ns != NULL) {
+            if (def2->ns[0] == 0) {
+                node.ns = NULL;
+            } else {
+                ns.href = def2->ns;
+            }
+        } else {
+            ns.href = invalidName;
+        }
+        if (xmlRelaxNGElementMatch(&ctxt, def1, &node)) {
+            if (def2->nameClass != NULL) {
+                ret = xmlRelaxNGCompareNameClasses(def2->nameClass, def1);
+            } else {
+                ret = 0;
+            }
+        } else {
+            ret = 1;
+        }
+    } else {
+        TODO ret = 0;
+    }
+
+    return (ret);
+}
+
+/**
+ * xmlRelaxNGCompareElemDefLists:
+ * @ctxt:  a Relax-NG parser context
+ * @defs1:  the first list of element/attribute defs
+ * @defs2:  the second list of element/attribute defs
+ *
+ * Compare the 2 lists of element or attribute definitions. The comparison
+ * is that if both lists do not accept the same QNames, it returns 1
+ * If the 2 lists can accept the same QName the comparison returns 0
+ *
+ * Returns 1 disttinct, 0 if equal
+ */
+static int
+xmlRelaxNGCompareElemDefLists(xmlRelaxNGParserCtxtPtr ctxt
+                              ATTRIBUTE_UNUSED, xmlRelaxNGDefinePtr * def1,
+                              xmlRelaxNGDefinePtr * def2)
+{
+    xmlRelaxNGDefinePtr *basedef2 = def2;
+
+    if ((def1 == NULL) || (def2 == NULL))
+        return (1);
+    if ((*def1 == NULL) || (*def2 == NULL))
+        return (1);
+    while (*def1 != NULL) {
+        while ((*def2) != NULL) {
+            if (xmlRelaxNGCompareNameClasses(*def1, *def2) == 0)
+                return (0);
+            def2++;
+        }
+        def2 = basedef2;
+        def1++;
+    }
+    return (1);
+}
+
+/**
+ * xmlRelaxNGGenerateAttributes:
+ * @ctxt:  a Relax-NG parser context
+ * @def:  the definition definition
+ *
+ * Check if the definition can only generate attributes
+ *
+ * Returns 1 if yes, 0 if no and -1 in case of error.
+ */
+static int
+xmlRelaxNGGenerateAttributes(xmlRelaxNGParserCtxtPtr ctxt,
+                             xmlRelaxNGDefinePtr def)
+{
+    xmlRelaxNGDefinePtr parent, cur, tmp;
+
+    /*
+     * Don't run that check in case of error. Infinite recursion
+     * becomes possible.
+     */
+    if (ctxt->nbErrors != 0)
+        return (-1);
+
+    parent = NULL;
+    cur = def;
+    while (cur != NULL) {
+        if ((cur->type == XML_RELAXNG_ELEMENT) ||
+            (cur->type == XML_RELAXNG_TEXT) ||
+            (cur->type == XML_RELAXNG_DATATYPE) ||
+            (cur->type == XML_RELAXNG_PARAM) ||
+            (cur->type == XML_RELAXNG_LIST) ||
+            (cur->type == XML_RELAXNG_VALUE) ||
+            (cur->type == XML_RELAXNG_EMPTY))
+            return (0);
+        if ((cur->type == XML_RELAXNG_CHOICE) ||
+            (cur->type == XML_RELAXNG_INTERLEAVE) ||
+            (cur->type == XML_RELAXNG_GROUP) ||
+            (cur->type == XML_RELAXNG_ONEORMORE) ||
+            (cur->type == XML_RELAXNG_ZEROORMORE) ||
+            (cur->type == XML_RELAXNG_OPTIONAL) ||
+            (cur->type == XML_RELAXNG_PARENTREF) ||
+            (cur->type == XML_RELAXNG_EXTERNALREF) ||
+            (cur->type == XML_RELAXNG_REF) ||
+            (cur->type == XML_RELAXNG_DEF)) {
+            if (cur->content != NULL) {
+                parent = cur;
+                cur = cur->content;
+                tmp = cur;
+                while (tmp != NULL) {
+                    tmp->parent = parent;
+                    tmp = tmp->next;
+                }
+                continue;
+            }
+        }
+        if (cur == def)
+            break;
+        if (cur->next != NULL) {
+            cur = cur->next;
+            continue;
+        }
+        do {
+            cur = cur->parent;
+            if (cur == NULL)
+                break;
+            if (cur == def)
+                return (1);
+            if (cur->next != NULL) {
+                cur = cur->next;
+                break;
+            }
+        } while (cur != NULL);
+    }
+    return (1);
+}
+
+/**
+ * xmlRelaxNGGetElements:
+ * @ctxt:  a Relax-NG parser context
+ * @def:  the definition definition
+ * @eora:  gather elements (0) or attributes (1)
+ *
+ * Compute the list of top elements a definition can generate
+ *
+ * Returns a list of elements or NULL if none was found.
+ */
+static xmlRelaxNGDefinePtr *
+xmlRelaxNGGetElements(xmlRelaxNGParserCtxtPtr ctxt,
+                      xmlRelaxNGDefinePtr def, int eora)
+{
+    xmlRelaxNGDefinePtr *ret = NULL, parent, cur, tmp;
+    int len = 0;
+    int max = 0;
+
+    /*
+     * Don't run that check in case of error. Infinite recursion
+     * becomes possible.
+     */
+    if (ctxt->nbErrors != 0)
+        return (NULL);
+
+    parent = NULL;
+    cur = def;
+    while (cur != NULL) {
+        if (((eora == 0) && ((cur->type == XML_RELAXNG_ELEMENT) ||
+                             (cur->type == XML_RELAXNG_TEXT))) ||
+            ((eora == 1) && (cur->type == XML_RELAXNG_ATTRIBUTE))) {
+            if (ret == NULL) {
+                max = 10;
+                ret = (xmlRelaxNGDefinePtr *)
+                    xmlMalloc((max + 1) * sizeof(xmlRelaxNGDefinePtr));
+                if (ret == NULL) {
+                    xmlRngPErrMemory(ctxt, "getting element list\n");
+                    return (NULL);
+                }
+            } else if (max <= len) {
+                max *= 2;
+                ret =
+                    xmlRealloc(ret,
+                               (max + 1) * sizeof(xmlRelaxNGDefinePtr));
+                if (ret == NULL) {
+                    xmlRngPErrMemory(ctxt, "getting element list\n");
+                    return (NULL);
+                }
+            }
+            ret[len++] = cur;
+            ret[len] = NULL;
+        } else if ((cur->type == XML_RELAXNG_CHOICE) ||
+                   (cur->type == XML_RELAXNG_INTERLEAVE) ||
+                   (cur->type == XML_RELAXNG_GROUP) ||
+                   (cur->type == XML_RELAXNG_ONEORMORE) ||
+                   (cur->type == XML_RELAXNG_ZEROORMORE) ||
+                   (cur->type == XML_RELAXNG_OPTIONAL) ||
+                   (cur->type == XML_RELAXNG_PARENTREF) ||
+                   (cur->type == XML_RELAXNG_REF) ||
+                   (cur->type == XML_RELAXNG_DEF) ||
+		   (cur->type == XML_RELAXNG_EXTERNALREF)) {
+            /*
+             * Don't go within elements or attributes or string values.
+             * Just gather the element top list
+             */
+            if (cur->content != NULL) {
+                parent = cur;
+                cur = cur->content;
+                tmp = cur;
+                while (tmp != NULL) {
+                    tmp->parent = parent;
+                    tmp = tmp->next;
+                }
+                continue;
+            }
+        }
+        if (cur == def)
+            break;
+        if (cur->next != NULL) {
+            cur = cur->next;
+            continue;
+        }
+        do {
+            cur = cur->parent;
+            if (cur == NULL)
+                break;
+            if (cur == def)
+                return (ret);
+            if (cur->next != NULL) {
+                cur = cur->next;
+                break;
+            }
+        } while (cur != NULL);
+    }
+    return (ret);
+}
+
+/**
+ * xmlRelaxNGCheckChoiceDeterminism:
+ * @ctxt:  a Relax-NG parser context
+ * @def:  the choice definition
+ *
+ * Also used to find indeterministic pattern in choice
+ */
+static void
+xmlRelaxNGCheckChoiceDeterminism(xmlRelaxNGParserCtxtPtr ctxt,
+                                 xmlRelaxNGDefinePtr def)
+{
+    xmlRelaxNGDefinePtr **list;
+    xmlRelaxNGDefinePtr cur;
+    int nbchild = 0, i, j, ret;
+    int is_nullable = 0;
+    int is_indeterminist = 0;
+    xmlHashTablePtr triage = NULL;
+    int is_triable = 1;
+
+    if ((def == NULL) || (def->type != XML_RELAXNG_CHOICE))
+        return;
+
+    if (def->dflags & IS_PROCESSED)
+        return;
+
+    /*
+     * Don't run that check in case of error. Infinite recursion
+     * becomes possible.
+     */
+    if (ctxt->nbErrors != 0)
+        return;
+
+    is_nullable = xmlRelaxNGIsNullable(def);
+
+    cur = def->content;
+    while (cur != NULL) {
+        nbchild++;
+        cur = cur->next;
+    }
+
+    list = (xmlRelaxNGDefinePtr **) xmlMalloc(nbchild *
+                                              sizeof(xmlRelaxNGDefinePtr
+                                                     *));
+    if (list == NULL) {
+        xmlRngPErrMemory(ctxt, "building choice\n");
+        return;
+    }
+    i = 0;
+    /*
+     * a bit strong but safe
+     */
+    if (is_nullable == 0) {
+        triage = xmlHashCreate(10);
+    } else {
+        is_triable = 0;
+    }
+    cur = def->content;
+    while (cur != NULL) {
+        list[i] = xmlRelaxNGGetElements(ctxt, cur, 0);
+        if ((list[i] == NULL) || (list[i][0] == NULL)) {
+            is_triable = 0;
+        } else if (is_triable == 1) {
+            xmlRelaxNGDefinePtr *tmp;
+            int res;
+
+            tmp = list[i];
+            while ((*tmp != NULL) && (is_triable == 1)) {
+                if ((*tmp)->type == XML_RELAXNG_TEXT) {
+                    res = xmlHashAddEntry2(triage,
+                                           BAD_CAST "#text", NULL,
+                                           (void *) cur);
+                    if (res != 0)
+                        is_triable = -1;
+                } else if (((*tmp)->type == XML_RELAXNG_ELEMENT) &&
+                           ((*tmp)->name != NULL)) {
+                    if (((*tmp)->ns == NULL) || ((*tmp)->ns[0] == 0))
+                        res = xmlHashAddEntry2(triage,
+                                               (*tmp)->name, NULL,
+                                               (void *) cur);
+                    else
+                        res = xmlHashAddEntry2(triage,
+                                               (*tmp)->name, (*tmp)->ns,
+                                               (void *) cur);
+                    if (res != 0)
+                        is_triable = -1;
+                } else if ((*tmp)->type == XML_RELAXNG_ELEMENT) {
+                    if (((*tmp)->ns == NULL) || ((*tmp)->ns[0] == 0))
+                        res = xmlHashAddEntry2(triage,
+                                               BAD_CAST "#any", NULL,
+                                               (void *) cur);
+                    else
+                        res = xmlHashAddEntry2(triage,
+                                               BAD_CAST "#any", (*tmp)->ns,
+                                               (void *) cur);
+                    if (res != 0)
+                        is_triable = -1;
+                } else {
+                    is_triable = -1;
+                }
+                tmp++;
+            }
+        }
+        i++;
+        cur = cur->next;
+    }
+
+    for (i = 0; i < nbchild; i++) {
+        if (list[i] == NULL)
+            continue;
+        for (j = 0; j < i; j++) {
+            if (list[j] == NULL)
+                continue;
+            ret = xmlRelaxNGCompareElemDefLists(ctxt, list[i], list[j]);
+            if (ret == 0) {
+                is_indeterminist = 1;
+            }
+        }
+    }
+    for (i = 0; i < nbchild; i++) {
+        if (list[i] != NULL)
+            xmlFree(list[i]);
+    }
+
+    xmlFree(list);
+    if (is_indeterminist) {
+        def->dflags |= IS_INDETERMINIST;
+    }
+    if (is_triable == 1) {
+        def->dflags |= IS_TRIABLE;
+        def->data = triage;
+    } else if (triage != NULL) {
+        xmlHashFree(triage, NULL);
+    }
+    def->dflags |= IS_PROCESSED;
+}
+
+/**
+ * xmlRelaxNGCheckGroupAttrs:
+ * @ctxt:  a Relax-NG parser context
+ * @def:  the group definition
+ *
+ * Detects violations of rule 7.3
+ */
+static void
+xmlRelaxNGCheckGroupAttrs(xmlRelaxNGParserCtxtPtr ctxt,
+                          xmlRelaxNGDefinePtr def)
+{
+    xmlRelaxNGDefinePtr **list;
+    xmlRelaxNGDefinePtr cur;
+    int nbchild = 0, i, j, ret;
+
+    if ((def == NULL) ||
+        ((def->type != XML_RELAXNG_GROUP) &&
+         (def->type != XML_RELAXNG_ELEMENT)))
+        return;
+
+    if (def->dflags & IS_PROCESSED)
+        return;
+
+    /*
+     * Don't run that check in case of error. Infinite recursion
+     * becomes possible.
+     */
+    if (ctxt->nbErrors != 0)
+        return;
+
+    cur = def->attrs;
+    while (cur != NULL) {
+        nbchild++;
+        cur = cur->next;
+    }
+    cur = def->content;
+    while (cur != NULL) {
+        nbchild++;
+        cur = cur->next;
+    }
+
+    list = (xmlRelaxNGDefinePtr **) xmlMalloc(nbchild *
+                                              sizeof(xmlRelaxNGDefinePtr
+                                                     *));
+    if (list == NULL) {
+        xmlRngPErrMemory(ctxt, "building group\n");
+        return;
+    }
+    i = 0;
+    cur = def->attrs;
+    while (cur != NULL) {
+        list[i] = xmlRelaxNGGetElements(ctxt, cur, 1);
+        i++;
+        cur = cur->next;
+    }
+    cur = def->content;
+    while (cur != NULL) {
+        list[i] = xmlRelaxNGGetElements(ctxt, cur, 1);
+        i++;
+        cur = cur->next;
+    }
+
+    for (i = 0; i < nbchild; i++) {
+        if (list[i] == NULL)
+            continue;
+        for (j = 0; j < i; j++) {
+            if (list[j] == NULL)
+                continue;
+            ret = xmlRelaxNGCompareElemDefLists(ctxt, list[i], list[j]);
+            if (ret == 0) {
+                xmlRngPErr(ctxt, def->node, XML_RNGP_GROUP_ATTR_CONFLICT,
+                           "Attributes conflicts in group\n", NULL, NULL);
+            }
+        }
+    }
+    for (i = 0; i < nbchild; i++) {
+        if (list[i] != NULL)
+            xmlFree(list[i]);
+    }
+
+    xmlFree(list);
+    def->dflags |= IS_PROCESSED;
+}
+
+/**
+ * xmlRelaxNGComputeInterleaves:
+ * @def:  the interleave definition
+ * @ctxt:  a Relax-NG parser context
+ * @name:  the definition name
+ *
+ * A lot of work for preprocessing interleave definitions
+ * is potentially needed to get a decent execution speed at runtime
+ *   - trying to get a total order on the element nodes generated
+ *     by the interleaves, order the list of interleave definitions
+ *     following that order.
+ *   - if <text/> is used to handle mixed content, it is better to
+ *     flag this in the define and simplify the runtime checking
+ *     algorithm
+ */
+static void
+xmlRelaxNGComputeInterleaves(xmlRelaxNGDefinePtr def,
+                             xmlRelaxNGParserCtxtPtr ctxt,
+                             xmlChar * name ATTRIBUTE_UNUSED)
+{
+    xmlRelaxNGDefinePtr cur, *tmp;
+
+    xmlRelaxNGPartitionPtr partitions = NULL;
+    xmlRelaxNGInterleaveGroupPtr *groups = NULL;
+    xmlRelaxNGInterleaveGroupPtr group;
+    int i, j, ret, res;
+    int nbgroups = 0;
+    int nbchild = 0;
+    int is_mixed = 0;
+    int is_determinist = 1;
+
+    /*
+     * Don't run that check in case of error. Infinite recursion
+     * becomes possible.
+     */
+    if (ctxt->nbErrors != 0)
+        return;
+
+#ifdef DEBUG_INTERLEAVE
+    xmlGenericError(xmlGenericErrorContext,
+                    "xmlRelaxNGComputeInterleaves(%s)\n", name);
+#endif
+    cur = def->content;
+    while (cur != NULL) {
+        nbchild++;
+        cur = cur->next;
+    }
+
+#ifdef DEBUG_INTERLEAVE
+    xmlGenericError(xmlGenericErrorContext, "  %d child\n", nbchild);
+#endif
+    groups = (xmlRelaxNGInterleaveGroupPtr *)
+        xmlMalloc(nbchild * sizeof(xmlRelaxNGInterleaveGroupPtr));
+    if (groups == NULL)
+        goto error;
+    cur = def->content;
+    while (cur != NULL) {
+        groups[nbgroups] = (xmlRelaxNGInterleaveGroupPtr)
+            xmlMalloc(sizeof(xmlRelaxNGInterleaveGroup));
+        if (groups[nbgroups] == NULL)
+            goto error;
+        if (cur->type == XML_RELAXNG_TEXT)
+            is_mixed++;
+        groups[nbgroups]->rule = cur;
+        groups[nbgroups]->defs = xmlRelaxNGGetElements(ctxt, cur, 0);
+        groups[nbgroups]->attrs = xmlRelaxNGGetElements(ctxt, cur, 1);
+        nbgroups++;
+        cur = cur->next;
+    }
+#ifdef DEBUG_INTERLEAVE
+    xmlGenericError(xmlGenericErrorContext, "  %d groups\n", nbgroups);
+#endif
+
+    /*
+     * Let's check that all rules makes a partitions according to 7.4
+     */
+    partitions = (xmlRelaxNGPartitionPtr)
+        xmlMalloc(sizeof(xmlRelaxNGPartition));
+    if (partitions == NULL)
+        goto error;
+    memset(partitions, 0, sizeof(xmlRelaxNGPartition));
+    partitions->nbgroups = nbgroups;
+    partitions->triage = xmlHashCreate(nbgroups);
+    for (i = 0; i < nbgroups; i++) {
+        group = groups[i];
+        for (j = i + 1; j < nbgroups; j++) {
+            if (groups[j] == NULL)
+                continue;
+
+            ret = xmlRelaxNGCompareElemDefLists(ctxt, group->defs,
+                                                groups[j]->defs);
+            if (ret == 0) {
+                xmlRngPErr(ctxt, def->node, XML_RNGP_ELEM_TEXT_CONFLICT,
+                           "Element or text conflicts in interleave\n",
+                           NULL, NULL);
+            }
+            ret = xmlRelaxNGCompareElemDefLists(ctxt, group->attrs,
+                                                groups[j]->attrs);
+            if (ret == 0) {
+                xmlRngPErr(ctxt, def->node, XML_RNGP_ATTR_CONFLICT,
+                           "Attributes conflicts in interleave\n", NULL,
+                           NULL);
+            }
+        }
+        tmp = group->defs;
+        if ((tmp != NULL) && (*tmp != NULL)) {
+            while (*tmp != NULL) {
+                if ((*tmp)->type == XML_RELAXNG_TEXT) {
+                    res = xmlHashAddEntry2(partitions->triage,
+                                           BAD_CAST "#text", NULL,
+                                           (void *) (long) (i + 1));
+                    if (res != 0)
+                        is_determinist = -1;
+                } else if (((*tmp)->type == XML_RELAXNG_ELEMENT) &&
+                           ((*tmp)->name != NULL)) {
+                    if (((*tmp)->ns == NULL) || ((*tmp)->ns[0] == 0))
+                        res = xmlHashAddEntry2(partitions->triage,
+                                               (*tmp)->name, NULL,
+                                               (void *) (long) (i + 1));
+                    else
+                        res = xmlHashAddEntry2(partitions->triage,
+                                               (*tmp)->name, (*tmp)->ns,
+                                               (void *) (long) (i + 1));
+                    if (res != 0)
+                        is_determinist = -1;
+                } else if ((*tmp)->type == XML_RELAXNG_ELEMENT) {
+                    if (((*tmp)->ns == NULL) || ((*tmp)->ns[0] == 0))
+                        res = xmlHashAddEntry2(partitions->triage,
+                                               BAD_CAST "#any", NULL,
+                                               (void *) (long) (i + 1));
+                    else
+                        res = xmlHashAddEntry2(partitions->triage,
+                                               BAD_CAST "#any", (*tmp)->ns,
+                                               (void *) (long) (i + 1));
+                    if ((*tmp)->nameClass != NULL)
+                        is_determinist = 2;
+                    if (res != 0)
+                        is_determinist = -1;
+                } else {
+                    is_determinist = -1;
+                }
+                tmp++;
+            }
+        } else {
+            is_determinist = 0;
+        }
+    }
+    partitions->groups = groups;
+
+    /*
+     * and save the partition list back in the def
+     */
+    def->data = partitions;
+    if (is_mixed != 0)
+        def->dflags |= IS_MIXED;
+    if (is_determinist == 1)
+        partitions->flags = IS_DETERMINIST;
+    if (is_determinist == 2)
+        partitions->flags = IS_DETERMINIST | IS_NEEDCHECK;
+    return;
+
+  error:
+    xmlRngPErrMemory(ctxt, "in interleave computation\n");
+    if (groups != NULL) {
+        for (i = 0; i < nbgroups; i++)
+            if (groups[i] != NULL) {
+                if (groups[i]->defs != NULL)
+                    xmlFree(groups[i]->defs);
+                xmlFree(groups[i]);
+            }
+        xmlFree(groups);
+    }
+    xmlRelaxNGFreePartition(partitions);
+}
+
+/**
+ * xmlRelaxNGParseInterleave:
+ * @ctxt:  a Relax-NG parser context
+ * @node:  the data node.
+ *
+ * parse the content of a RelaxNG interleave node.
+ *
+ * Returns the definition pointer or NULL in case of error
+ */
+static xmlRelaxNGDefinePtr
+xmlRelaxNGParseInterleave(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
+{
+    xmlRelaxNGDefinePtr def = NULL;
+    xmlRelaxNGDefinePtr last = NULL, cur;
+    xmlNodePtr child;
+
+    def = xmlRelaxNGNewDefine(ctxt, node);
+    if (def == NULL) {
+        return (NULL);
+    }
+    def->type = XML_RELAXNG_INTERLEAVE;
+
+    if (ctxt->interleaves == NULL)
+        ctxt->interleaves = xmlHashCreate(10);
+    if (ctxt->interleaves == NULL) {
+        xmlRngPErrMemory(ctxt, "create interleaves\n");
+    } else {
+        char name[32];
+
+        snprintf(name, 32, "interleave%d", ctxt->nbInterleaves++);
+        if (xmlHashAddEntry(ctxt->interleaves, BAD_CAST name, def) < 0) {
+            xmlRngPErr(ctxt, node, XML_RNGP_INTERLEAVE_ADD,
+                       "Failed to add %s to hash table\n",
+		       (const xmlChar *) name, NULL);
+        }
+    }
+    child = node->children;
+    if (child == NULL) {
+        xmlRngPErr(ctxt, node, XML_RNGP_INTERLEAVE_NO_CONTENT,
+                   "Element interleave is empty\n", NULL, NULL);
+    }
+    while (child != NULL) {
+        if (IS_RELAXNG(child, "element")) {
+            cur = xmlRelaxNGParseElement(ctxt, child);
+        } else {
+            cur = xmlRelaxNGParsePattern(ctxt, child);
+        }
+        if (cur != NULL) {
+            cur->parent = def;
+            if (last == NULL) {
+                def->content = last = cur;
+            } else {
+                last->next = cur;
+                last = cur;
+            }
+        }
+        child = child->next;
+    }
+
+    return (def);
+}
+
+/**
+ * xmlRelaxNGParseInclude:
+ * @ctxt:  a Relax-NG parser context
+ * @node:  the include node
+ *
+ * Integrate the content of an include node in the current grammar
+ *
+ * Returns 0 in case of success or -1 in case of error
+ */
+static int
+xmlRelaxNGParseInclude(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
+{
+    xmlRelaxNGIncludePtr incl;
+    xmlNodePtr root;
+    int ret = 0, tmp;
+
+    incl = node->psvi;
+    if (incl == NULL) {
+        xmlRngPErr(ctxt, node, XML_RNGP_INCLUDE_EMPTY,
+                   "Include node has no data\n", NULL, NULL);
+        return (-1);
+    }
+    root = xmlDocGetRootElement(incl->doc);
+    if (root == NULL) {
+        xmlRngPErr(ctxt, node, XML_RNGP_EMPTY, "Include document is empty\n",
+                   NULL, NULL);
+        return (-1);
+    }
+    if (!xmlStrEqual(root->name, BAD_CAST "grammar")) {
+        xmlRngPErr(ctxt, node, XML_RNGP_GRAMMAR_MISSING,
+                   "Include document root is not a grammar\n", NULL, NULL);
+        return (-1);
+    }
+
+    /*
+     * Merge the definition from both the include and the internal list
+     */
+    if (root->children != NULL) {
+        tmp = xmlRelaxNGParseGrammarContent(ctxt, root->children);
+        if (tmp != 0)
+            ret = -1;
+    }
+    if (node->children != NULL) {
+        tmp = xmlRelaxNGParseGrammarContent(ctxt, node->children);
+        if (tmp != 0)
+            ret = -1;
+    }
+    return (ret);
+}
+
+/**
+ * xmlRelaxNGParseDefine:
+ * @ctxt:  a Relax-NG parser context
+ * @node:  the define node
+ *
+ * parse the content of a RelaxNG define element node.
+ *
+ * Returns 0 in case of success or -1 in case of error
+ */
+static int
+xmlRelaxNGParseDefine(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
+{
+    xmlChar *name;
+    int ret = 0, tmp;
+    xmlRelaxNGDefinePtr def;
+    const xmlChar *olddefine;
+
+    name = xmlGetProp(node, BAD_CAST "name");
+    if (name == NULL) {
+        xmlRngPErr(ctxt, node, XML_RNGP_DEFINE_NAME_MISSING,
+                   "define has no name\n", NULL, NULL);
+    } else {
+        xmlRelaxNGNormExtSpace(name);
+        if (xmlValidateNCName(name, 0)) {
+            xmlRngPErr(ctxt, node, XML_RNGP_INVALID_DEFINE_NAME,
+                       "define name '%s' is not an NCName\n", name, NULL);
+        }
+        def = xmlRelaxNGNewDefine(ctxt, node);
+        if (def == NULL) {
+            xmlFree(name);
+            return (-1);
+        }
+        def->type = XML_RELAXNG_DEF;
+        def->name = name;
+        if (node->children == NULL) {
+            xmlRngPErr(ctxt, node, XML_RNGP_DEFINE_EMPTY,
+                       "define has no children\n", NULL, NULL);
+        } else {
+            olddefine = ctxt->define;
+            ctxt->define = name;
+            def->content =
+                xmlRelaxNGParsePatterns(ctxt, node->children, 0);
+            ctxt->define = olddefine;
+        }
+        if (ctxt->grammar->defs == NULL)
+            ctxt->grammar->defs = xmlHashCreate(10);
+        if (ctxt->grammar->defs == NULL) {
+            xmlRngPErr(ctxt, node, XML_RNGP_DEFINE_CREATE_FAILED,
+                       "Could not create definition hash\n", NULL, NULL);
+            ret = -1;
+        } else {
+            tmp = xmlHashAddEntry(ctxt->grammar->defs, name, def);
+            if (tmp < 0) {
+                xmlRelaxNGDefinePtr prev;
+
+                prev = xmlHashLookup(ctxt->grammar->defs, name);
+                if (prev == NULL) {
+                    xmlRngPErr(ctxt, node, XML_RNGP_DEFINE_CREATE_FAILED,
+                               "Internal error on define aggregation of %s\n",
+                               name, NULL);
+                    ret = -1;
+                } else {
+                    while (prev->nextHash != NULL)
+                        prev = prev->nextHash;
+                    prev->nextHash = def;
+                }
+            }
+        }
+    }
+    return (ret);
+}
+
+/**
+ * xmlRelaxNGProcessExternalRef:
+ * @ctxt: the parser context
+ * @node:  the externlRef node
+ *
+ * Process and compile an externlRef node
+ *
+ * Returns the xmlRelaxNGDefinePtr or NULL in case of error
+ */
+static xmlRelaxNGDefinePtr
+xmlRelaxNGProcessExternalRef(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
+{
+    xmlRelaxNGDocumentPtr docu;
+    xmlNodePtr root, tmp;
+    xmlChar *ns;
+    int newNs = 0, oldflags;
+    xmlRelaxNGDefinePtr def;
+
+    docu = node->psvi;
+    if (docu != NULL) {
+        def = xmlRelaxNGNewDefine(ctxt, node);
+        if (def == NULL)
+            return (NULL);
+        def->type = XML_RELAXNG_EXTERNALREF;
+
+        if (docu->content == NULL) {
+            /*
+             * Then do the parsing for good
+             */
+            root = xmlDocGetRootElement(docu->doc);
+            if (root == NULL) {
+                xmlRngPErr(ctxt, node, XML_RNGP_EXTERNALREF_EMTPY,
+                           "xmlRelaxNGParse: %s is empty\n", ctxt->URL,
+                           NULL);
+                return (NULL);
+            }
+            /*
+             * ns transmission rules
+             */
+            ns = xmlGetProp(root, BAD_CAST "ns");
+            if (ns == NULL) {
+                tmp = node;
+                while ((tmp != NULL) && (tmp->type == XML_ELEMENT_NODE)) {
+                    ns = xmlGetProp(tmp, BAD_CAST "ns");
+                    if (ns != NULL) {
+                        break;
+                    }
+                    tmp = tmp->parent;
+                }
+                if (ns != NULL) {
+                    xmlSetProp(root, BAD_CAST "ns", ns);
+                    newNs = 1;
+                    xmlFree(ns);
+                }
+            } else {
+                xmlFree(ns);
+            }
+
+            /*
+             * Parsing to get a precompiled schemas.
+             */
+            oldflags = ctxt->flags;
+            ctxt->flags |= XML_RELAXNG_IN_EXTERNALREF;
+            docu->schema = xmlRelaxNGParseDocument(ctxt, root);
+            ctxt->flags = oldflags;
+            if ((docu->schema != NULL) &&
+                (docu->schema->topgrammar != NULL)) {
+                docu->content = docu->schema->topgrammar->start;
+            }
+
+            /*
+             * the externalRef may be reused in a different ns context
+             */
+            if (newNs == 1) {
+                xmlUnsetProp(root, BAD_CAST "ns");
+            }
+        }
+        def->content = docu->content;
+    } else {
+        def = NULL;
+    }
+    return (def);
+}
+
+/**
+ * xmlRelaxNGParsePattern:
+ * @ctxt:  a Relax-NG parser context
+ * @node:  the pattern node.
+ *
+ * parse the content of a RelaxNG pattern node.
+ *
+ * Returns the definition pointer or NULL in case of error or if no
+ *     pattern is generated.
+ */
+static xmlRelaxNGDefinePtr
+xmlRelaxNGParsePattern(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
+{
+    xmlRelaxNGDefinePtr def = NULL;
+
+    if (node == NULL) {
+        return (NULL);
+    }
+    if (IS_RELAXNG(node, "element")) {
+        def = xmlRelaxNGParseElement(ctxt, node);
+    } else if (IS_RELAXNG(node, "attribute")) {
+        def = xmlRelaxNGParseAttribute(ctxt, node);
+    } else if (IS_RELAXNG(node, "empty")) {
+        def = xmlRelaxNGNewDefine(ctxt, node);
+        if (def == NULL)
+            return (NULL);
+        def->type = XML_RELAXNG_EMPTY;
+        if (node->children != NULL) {
+            xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_NOT_EMPTY,
+                       "empty: had a child node\n", NULL, NULL);
+        }
+    } else if (IS_RELAXNG(node, "text")) {
+        def = xmlRelaxNGNewDefine(ctxt, node);
+        if (def == NULL)
+            return (NULL);
+        def->type = XML_RELAXNG_TEXT;
+        if (node->children != NULL) {
+            xmlRngPErr(ctxt, node, XML_RNGP_TEXT_HAS_CHILD,
+                       "text: had a child node\n", NULL, NULL);
+        }
+    } else if (IS_RELAXNG(node, "zeroOrMore")) {
+        def = xmlRelaxNGNewDefine(ctxt, node);
+        if (def == NULL)
+            return (NULL);
+        def->type = XML_RELAXNG_ZEROORMORE;
+        if (node->children == NULL) {
+            xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT,
+                       "Element %s is empty\n", node->name, NULL);
+        } else {
+            def->content =
+                xmlRelaxNGParsePatterns(ctxt, node->children, 1);
+        }
+    } else if (IS_RELAXNG(node, "oneOrMore")) {
+        def = xmlRelaxNGNewDefine(ctxt, node);
+        if (def == NULL)
+            return (NULL);
+        def->type = XML_RELAXNG_ONEORMORE;
+        if (node->children == NULL) {
+            xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT,
+                       "Element %s is empty\n", node->name, NULL);
+        } else {
+            def->content =
+                xmlRelaxNGParsePatterns(ctxt, node->children, 1);
+        }
+    } else if (IS_RELAXNG(node, "optional")) {
+        def = xmlRelaxNGNewDefine(ctxt, node);
+        if (def == NULL)
+            return (NULL);
+        def->type = XML_RELAXNG_OPTIONAL;
+        if (node->children == NULL) {
+            xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT,
+                       "Element %s is empty\n", node->name, NULL);
+        } else {
+            def->content =
+                xmlRelaxNGParsePatterns(ctxt, node->children, 1);
+        }
+    } else if (IS_RELAXNG(node, "choice")) {
+        def = xmlRelaxNGNewDefine(ctxt, node);
+        if (def == NULL)
+            return (NULL);
+        def->type = XML_RELAXNG_CHOICE;
+        if (node->children == NULL) {
+            xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT,
+                       "Element %s is empty\n", node->name, NULL);
+        } else {
+            def->content =
+                xmlRelaxNGParsePatterns(ctxt, node->children, 0);
+        }
+    } else if (IS_RELAXNG(node, "group")) {
+        def = xmlRelaxNGNewDefine(ctxt, node);
+        if (def == NULL)
+            return (NULL);
+        def->type = XML_RELAXNG_GROUP;
+        if (node->children == NULL) {
+            xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT,
+                       "Element %s is empty\n", node->name, NULL);
+        } else {
+            def->content =
+                xmlRelaxNGParsePatterns(ctxt, node->children, 0);
+        }
+    } else if (IS_RELAXNG(node, "ref")) {
+        def = xmlRelaxNGNewDefine(ctxt, node);
+        if (def == NULL)
+            return (NULL);
+        def->type = XML_RELAXNG_REF;
+        def->name = xmlGetProp(node, BAD_CAST "name");
+        if (def->name == NULL) {
+            xmlRngPErr(ctxt, node, XML_RNGP_REF_NO_NAME, "ref has no name\n",
+                       NULL, NULL);
+        } else {
+            xmlRelaxNGNormExtSpace(def->name);
+            if (xmlValidateNCName(def->name, 0)) {
+                xmlRngPErr(ctxt, node, XML_RNGP_REF_NAME_INVALID,
+                           "ref name '%s' is not an NCName\n", def->name,
+                           NULL);
+            }
+        }
+        if (node->children != NULL) {
+            xmlRngPErr(ctxt, node, XML_RNGP_REF_NOT_EMPTY, "ref is not empty\n",
+                       NULL, NULL);
+        }
+        if (ctxt->grammar->refs == NULL)
+            ctxt->grammar->refs = xmlHashCreate(10);
+        if (ctxt->grammar->refs == NULL) {
+            xmlRngPErr(ctxt, node, XML_RNGP_REF_CREATE_FAILED,
+                       "Could not create references hash\n", NULL, NULL);
+            def = NULL;
+        } else {
+            int tmp;
+
+            tmp = xmlHashAddEntry(ctxt->grammar->refs, def->name, def);
+            if (tmp < 0) {
+                xmlRelaxNGDefinePtr prev;
+
+                prev = (xmlRelaxNGDefinePtr)
+                    xmlHashLookup(ctxt->grammar->refs, def->name);
+                if (prev == NULL) {
+                    if (def->name != NULL) {
+		        xmlRngPErr(ctxt, node, XML_RNGP_REF_CREATE_FAILED,
+				   "Error refs definitions '%s'\n",
+				   def->name, NULL);
+                    } else {
+		        xmlRngPErr(ctxt, node, XML_RNGP_REF_CREATE_FAILED,
+				   "Error refs definitions\n",
+				   NULL, NULL);
+                    }
+                    def = NULL;
+                } else {
+                    def->nextHash = prev->nextHash;
+                    prev->nextHash = def;
+                }
+            }
+        }
+    } else if (IS_RELAXNG(node, "data")) {
+        def = xmlRelaxNGParseData(ctxt, node);
+    } else if (IS_RELAXNG(node, "value")) {
+        def = xmlRelaxNGParseValue(ctxt, node);
+    } else if (IS_RELAXNG(node, "list")) {
+        def = xmlRelaxNGNewDefine(ctxt, node);
+        if (def == NULL)
+            return (NULL);
+        def->type = XML_RELAXNG_LIST;
+        if (node->children == NULL) {
+            xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT,
+                       "Element %s is empty\n", node->name, NULL);
+        } else {
+            def->content =
+                xmlRelaxNGParsePatterns(ctxt, node->children, 0);
+        }
+    } else if (IS_RELAXNG(node, "interleave")) {
+        def = xmlRelaxNGParseInterleave(ctxt, node);
+    } else if (IS_RELAXNG(node, "externalRef")) {
+        def = xmlRelaxNGProcessExternalRef(ctxt, node);
+    } else if (IS_RELAXNG(node, "notAllowed")) {
+        def = xmlRelaxNGNewDefine(ctxt, node);
+        if (def == NULL)
+            return (NULL);
+        def->type = XML_RELAXNG_NOT_ALLOWED;
+        if (node->children != NULL) {
+            xmlRngPErr(ctxt, node, XML_RNGP_NOTALLOWED_NOT_EMPTY,
+                       "xmlRelaxNGParse: notAllowed element is not empty\n",
+                       NULL, NULL);
+        }
+    } else if (IS_RELAXNG(node, "grammar")) {
+        xmlRelaxNGGrammarPtr grammar, old;
+        xmlRelaxNGGrammarPtr oldparent;
+
+#ifdef DEBUG_GRAMMAR
+        xmlGenericError(xmlGenericErrorContext,
+                        "Found <grammar> pattern\n");
+#endif
+
+        oldparent = ctxt->parentgrammar;
+        old = ctxt->grammar;
+        ctxt->parentgrammar = old;
+        grammar = xmlRelaxNGParseGrammar(ctxt, node->children);
+        if (old != NULL) {
+            ctxt->grammar = old;
+            ctxt->parentgrammar = oldparent;
+#if 0
+            if (grammar != NULL) {
+                grammar->next = old->next;
+                old->next = grammar;
+            }
+#endif
+        }
+        if (grammar != NULL)
+            def = grammar->start;
+        else
+            def = NULL;
+    } else if (IS_RELAXNG(node, "parentRef")) {
+        if (ctxt->parentgrammar == NULL) {
+            xmlRngPErr(ctxt, node, XML_RNGP_PARENTREF_NO_PARENT,
+                       "Use of parentRef without a parent grammar\n", NULL,
+                       NULL);
+            return (NULL);
+        }
+        def = xmlRelaxNGNewDefine(ctxt, node);
+        if (def == NULL)
+            return (NULL);
+        def->type = XML_RELAXNG_PARENTREF;
+        def->name = xmlGetProp(node, BAD_CAST "name");
+        if (def->name == NULL) {
+            xmlRngPErr(ctxt, node, XML_RNGP_PARENTREF_NO_NAME,
+                       "parentRef has no name\n", NULL, NULL);
+        } else {
+            xmlRelaxNGNormExtSpace(def->name);
+            if (xmlValidateNCName(def->name, 0)) {
+                xmlRngPErr(ctxt, node, XML_RNGP_PARENTREF_NAME_INVALID,
+                           "parentRef name '%s' is not an NCName\n",
+                           def->name, NULL);
+            }
+        }
+        if (node->children != NULL) {
+            xmlRngPErr(ctxt, node, XML_RNGP_PARENTREF_NOT_EMPTY,
+                       "parentRef is not empty\n", NULL, NULL);
+        }
+        if (ctxt->parentgrammar->refs == NULL)
+            ctxt->parentgrammar->refs = xmlHashCreate(10);
+        if (ctxt->parentgrammar->refs == NULL) {
+            xmlRngPErr(ctxt, node, XML_RNGP_PARENTREF_CREATE_FAILED,
+                       "Could not create references hash\n", NULL, NULL);
+            def = NULL;
+        } else if (def->name != NULL) {
+            int tmp;
+
+            tmp =
+                xmlHashAddEntry(ctxt->parentgrammar->refs, def->name, def);
+            if (tmp < 0) {
+                xmlRelaxNGDefinePtr prev;
+
+                prev = (xmlRelaxNGDefinePtr)
+                    xmlHashLookup(ctxt->parentgrammar->refs, def->name);
+                if (prev == NULL) {
+                    xmlRngPErr(ctxt, node, XML_RNGP_PARENTREF_CREATE_FAILED,
+                               "Internal error parentRef definitions '%s'\n",
+                               def->name, NULL);
+                    def = NULL;
+                } else {
+                    def->nextHash = prev->nextHash;
+                    prev->nextHash = def;
+                }
+            }
+        }
+    } else if (IS_RELAXNG(node, "mixed")) {
+        if (node->children == NULL) {
+            xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT, "Mixed is empty\n",
+                       NULL, NULL);
+            def = NULL;
+        } else {
+            def = xmlRelaxNGParseInterleave(ctxt, node);
+            if (def != NULL) {
+                xmlRelaxNGDefinePtr tmp;
+
+                if ((def->content != NULL) && (def->content->next != NULL)) {
+                    tmp = xmlRelaxNGNewDefine(ctxt, node);
+                    if (tmp != NULL) {
+                        tmp->type = XML_RELAXNG_GROUP;
+                        tmp->content = def->content;
+                        def->content = tmp;
+                    }
+                }
+
+                tmp = xmlRelaxNGNewDefine(ctxt, node);
+                if (tmp == NULL)
+                    return (def);
+                tmp->type = XML_RELAXNG_TEXT;
+                tmp->next = def->content;
+                def->content = tmp;
+            }
+        }
+    } else {
+        xmlRngPErr(ctxt, node, XML_RNGP_UNKNOWN_CONSTRUCT,
+                   "Unexpected node %s is not a pattern\n", node->name,
+                   NULL);
+        def = NULL;
+    }
+    return (def);
+}
+
+/**
+ * xmlRelaxNGParseAttribute:
+ * @ctxt:  a Relax-NG parser context
+ * @node:  the element node
+ *
+ * parse the content of a RelaxNG attribute node.
+ *
+ * Returns the definition pointer or NULL in case of error.
+ */
+static xmlRelaxNGDefinePtr
+xmlRelaxNGParseAttribute(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
+{
+    xmlRelaxNGDefinePtr ret, cur;
+    xmlNodePtr child;
+    int old_flags;
+
+    ret = xmlRelaxNGNewDefine(ctxt, node);
+    if (ret == NULL)
+        return (NULL);
+    ret->type = XML_RELAXNG_ATTRIBUTE;
+    ret->parent = ctxt->def;
+    child = node->children;
+    if (child == NULL) {
+        xmlRngPErr(ctxt, node, XML_RNGP_ATTRIBUTE_EMPTY,
+                   "xmlRelaxNGParseattribute: attribute has no children\n",
+                   NULL, NULL);
+        return (ret);
+    }
+    old_flags = ctxt->flags;
+    ctxt->flags |= XML_RELAXNG_IN_ATTRIBUTE;
+    cur = xmlRelaxNGParseNameClass(ctxt, child, ret);
+    if (cur != NULL)
+        child = child->next;
+
+    if (child != NULL) {
+        cur = xmlRelaxNGParsePattern(ctxt, child);
+        if (cur != NULL) {
+            switch (cur->type) {
+                case XML_RELAXNG_EMPTY:
+                case XML_RELAXNG_NOT_ALLOWED:
+                case XML_RELAXNG_TEXT:
+                case XML_RELAXNG_ELEMENT:
+                case XML_RELAXNG_DATATYPE:
+                case XML_RELAXNG_VALUE:
+                case XML_RELAXNG_LIST:
+                case XML_RELAXNG_REF:
+                case XML_RELAXNG_PARENTREF:
+                case XML_RELAXNG_EXTERNALREF:
+                case XML_RELAXNG_DEF:
+                case XML_RELAXNG_ONEORMORE:
+                case XML_RELAXNG_ZEROORMORE:
+                case XML_RELAXNG_OPTIONAL:
+                case XML_RELAXNG_CHOICE:
+                case XML_RELAXNG_GROUP:
+                case XML_RELAXNG_INTERLEAVE:
+                case XML_RELAXNG_ATTRIBUTE:
+                    ret->content = cur;
+                    cur->parent = ret;
+                    break;
+                case XML_RELAXNG_START:
+                case XML_RELAXNG_PARAM:
+                case XML_RELAXNG_EXCEPT:
+                    xmlRngPErr(ctxt, node, XML_RNGP_ATTRIBUTE_CONTENT,
+                               "attribute has invalid content\n", NULL,
+                               NULL);
+                    break;
+                case XML_RELAXNG_NOOP:
+                    xmlRngPErr(ctxt, node, XML_RNGP_ATTRIBUTE_NOOP,
+                               "RNG Internal error, noop found in attribute\n",
+                               NULL, NULL);
+                    break;
+            }
+        }
+        child = child->next;
+    }
+    if (child != NULL) {
+        xmlRngPErr(ctxt, node, XML_RNGP_ATTRIBUTE_CHILDREN,
+                   "attribute has multiple children\n", NULL, NULL);
+    }
+    ctxt->flags = old_flags;
+    return (ret);
+}
+
+/**
+ * xmlRelaxNGParseExceptNameClass:
+ * @ctxt:  a Relax-NG parser context
+ * @node:  the except node
+ * @attr:  1 if within an attribute, 0 if within an element
+ *
+ * parse the content of a RelaxNG nameClass node.
+ *
+ * Returns the definition pointer or NULL in case of error.
+ */
+static xmlRelaxNGDefinePtr
+xmlRelaxNGParseExceptNameClass(xmlRelaxNGParserCtxtPtr ctxt,
+                               xmlNodePtr node, int attr)
+{
+    xmlRelaxNGDefinePtr ret, cur, last = NULL;
+    xmlNodePtr child;
+
+    if (!IS_RELAXNG(node, "except")) {
+        xmlRngPErr(ctxt, node, XML_RNGP_EXCEPT_MISSING,
+                   "Expecting an except node\n", NULL, NULL);
+        return (NULL);
+    }
+    if (node->next != NULL) {
+        xmlRngPErr(ctxt, node, XML_RNGP_EXCEPT_MULTIPLE,
+                   "exceptNameClass allows only a single except node\n",
+                   NULL, NULL);
+    }
+    if (node->children == NULL) {
+        xmlRngPErr(ctxt, node, XML_RNGP_EXCEPT_EMPTY, "except has no content\n",
+                   NULL, NULL);
+        return (NULL);
+    }
+
+    ret = xmlRelaxNGNewDefine(ctxt, node);
+    if (ret == NULL)
+        return (NULL);
+    ret->type = XML_RELAXNG_EXCEPT;
+    child = node->children;
+    while (child != NULL) {
+        cur = xmlRelaxNGNewDefine(ctxt, child);
+        if (cur == NULL)
+            break;
+        if (attr)
+            cur->type = XML_RELAXNG_ATTRIBUTE;
+        else
+            cur->type = XML_RELAXNG_ELEMENT;
+
+        if (xmlRelaxNGParseNameClass(ctxt, child, cur) != NULL) {
+            if (last == NULL) {
+                ret->content = cur;
+            } else {
+                last->next = cur;
+            }
+            last = cur;
+        }
+        child = child->next;
+    }
+
+    return (ret);
+}
+
+/**
+ * xmlRelaxNGParseNameClass:
+ * @ctxt:  a Relax-NG parser context
+ * @node:  the nameClass node
+ * @def:  the current definition
+ *
+ * parse the content of a RelaxNG nameClass node.
+ *
+ * Returns the definition pointer or NULL in case of error.
+ */
+static xmlRelaxNGDefinePtr
+xmlRelaxNGParseNameClass(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node,
+                         xmlRelaxNGDefinePtr def)
+{
+    xmlRelaxNGDefinePtr ret, tmp;
+    xmlChar *val;
+
+    ret = def;
+    if ((IS_RELAXNG(node, "name")) || (IS_RELAXNG(node, "anyName")) ||
+        (IS_RELAXNG(node, "nsName"))) {
+        if ((def->type != XML_RELAXNG_ELEMENT) &&
+            (def->type != XML_RELAXNG_ATTRIBUTE)) {
+            ret = xmlRelaxNGNewDefine(ctxt, node);
+            if (ret == NULL)
+                return (NULL);
+            ret->parent = def;
+            if (ctxt->flags & XML_RELAXNG_IN_ATTRIBUTE)
+                ret->type = XML_RELAXNG_ATTRIBUTE;
+            else
+                ret->type = XML_RELAXNG_ELEMENT;
+        }
+    }
+    if (IS_RELAXNG(node, "name")) {
+        val = xmlNodeGetContent(node);
+        xmlRelaxNGNormExtSpace(val);
+        if (xmlValidateNCName(val, 0)) {
+	    if (node->parent != NULL)
+		xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_NAME,
+			   "Element %s name '%s' is not an NCName\n",
+			   node->parent->name, val);
+	    else
+		xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_NAME,
+			   "name '%s' is not an NCName\n",
+			   val, NULL);
+        }
+        ret->name = val;
+        val = xmlGetProp(node, BAD_CAST "ns");
+        ret->ns = val;
+        if ((ctxt->flags & XML_RELAXNG_IN_ATTRIBUTE) &&
+            (val != NULL) &&
+            (xmlStrEqual(val, BAD_CAST "http://www.w3.org/2000/xmlns"))) {
+	    xmlRngPErr(ctxt, node, XML_RNGP_XML_NS,
+                        "Attribute with namespace '%s' is not allowed\n",
+                        val, NULL);
+        }
+        if ((ctxt->flags & XML_RELAXNG_IN_ATTRIBUTE) &&
+            (val != NULL) &&
+            (val[0] == 0) && (xmlStrEqual(ret->name, BAD_CAST "xmlns"))) {
+	    xmlRngPErr(ctxt, node, XML_RNGP_XMLNS_NAME,
+                       "Attribute with QName 'xmlns' is not allowed\n",
+                       val, NULL);
+        }
+    } else if (IS_RELAXNG(node, "anyName")) {
+        ret->name = NULL;
+        ret->ns = NULL;
+        if (node->children != NULL) {
+            ret->nameClass =
+                xmlRelaxNGParseExceptNameClass(ctxt, node->children,
+                                               (def->type ==
+                                                XML_RELAXNG_ATTRIBUTE));
+        }
+    } else if (IS_RELAXNG(node, "nsName")) {
+        ret->name = NULL;
+        ret->ns = xmlGetProp(node, BAD_CAST "ns");
+        if (ret->ns == NULL) {
+            xmlRngPErr(ctxt, node, XML_RNGP_NSNAME_NO_NS,
+                       "nsName has no ns attribute\n", NULL, NULL);
+        }
+        if ((ctxt->flags & XML_RELAXNG_IN_ATTRIBUTE) &&
+            (ret->ns != NULL) &&
+            (xmlStrEqual
+             (ret->ns, BAD_CAST "http://www.w3.org/2000/xmlns"))) {
+            xmlRngPErr(ctxt, node, XML_RNGP_XML_NS,
+                       "Attribute with namespace '%s' is not allowed\n",
+                       ret->ns, NULL);
+        }
+        if (node->children != NULL) {
+            ret->nameClass =
+                xmlRelaxNGParseExceptNameClass(ctxt, node->children,
+                                               (def->type ==
+                                                XML_RELAXNG_ATTRIBUTE));
+        }
+    } else if (IS_RELAXNG(node, "choice")) {
+        xmlNodePtr child;
+        xmlRelaxNGDefinePtr last = NULL;
+
+        ret = xmlRelaxNGNewDefine(ctxt, node);
+        if (ret == NULL)
+            return (NULL);
+        ret->parent = def;
+        ret->type = XML_RELAXNG_CHOICE;
+
+        if (node->children == NULL) {
+            xmlRngPErr(ctxt, node, XML_RNGP_CHOICE_EMPTY,
+                       "Element choice is empty\n", NULL, NULL);
+        } else {
+
+            child = node->children;
+            while (child != NULL) {
+                tmp = xmlRelaxNGParseNameClass(ctxt, child, ret);
+                if (tmp != NULL) {
+                    if (last == NULL) {
+                        last = ret->nameClass = tmp;
+                    } else {
+                        last->next = tmp;
+                        last = tmp;
+                    }
+                }
+                child = child->next;
+            }
+        }
+    } else {
+        xmlRngPErr(ctxt, node, XML_RNGP_CHOICE_CONTENT,
+                   "expecting name, anyName, nsName or choice : got %s\n",
+                   node->name, NULL);
+        return (NULL);
+    }
+    if (ret != def) {
+        if (def->nameClass == NULL) {
+            def->nameClass = ret;
+        } else {
+            tmp = def->nameClass;
+            while (tmp->next != NULL) {
+                tmp = tmp->next;
+            }
+            tmp->next = ret;
+        }
+    }
+    return (ret);
+}
+
+/**
+ * xmlRelaxNGParseElement:
+ * @ctxt:  a Relax-NG parser context
+ * @node:  the element node
+ *
+ * parse the content of a RelaxNG element node.
+ *
+ * Returns the definition pointer or NULL in case of error.
+ */
+static xmlRelaxNGDefinePtr
+xmlRelaxNGParseElement(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
+{
+    xmlRelaxNGDefinePtr ret, cur, last;
+    xmlNodePtr child;
+    const xmlChar *olddefine;
+
+    ret = xmlRelaxNGNewDefine(ctxt, node);
+    if (ret == NULL)
+        return (NULL);
+    ret->type = XML_RELAXNG_ELEMENT;
+    ret->parent = ctxt->def;
+    child = node->children;
+    if (child == NULL) {
+        xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_EMPTY,
+                   "xmlRelaxNGParseElement: element has no children\n",
+                   NULL, NULL);
+        return (ret);
+    }
+    cur = xmlRelaxNGParseNameClass(ctxt, child, ret);
+    if (cur != NULL)
+        child = child->next;
+
+    if (child == NULL) {
+        xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_NO_CONTENT,
+                   "xmlRelaxNGParseElement: element has no content\n",
+                   NULL, NULL);
+        return (ret);
+    }
+    olddefine = ctxt->define;
+    ctxt->define = NULL;
+    last = NULL;
+    while (child != NULL) {
+        cur = xmlRelaxNGParsePattern(ctxt, child);
+        if (cur != NULL) {
+            cur->parent = ret;
+            switch (cur->type) {
+                case XML_RELAXNG_EMPTY:
+                case XML_RELAXNG_NOT_ALLOWED:
+                case XML_RELAXNG_TEXT:
+                case XML_RELAXNG_ELEMENT:
+                case XML_RELAXNG_DATATYPE:
+                case XML_RELAXNG_VALUE:
+                case XML_RELAXNG_LIST:
+                case XML_RELAXNG_REF:
+                case XML_RELAXNG_PARENTREF:
+                case XML_RELAXNG_EXTERNALREF:
+                case XML_RELAXNG_DEF:
+                case XML_RELAXNG_ZEROORMORE:
+                case XML_RELAXNG_ONEORMORE:
+                case XML_RELAXNG_OPTIONAL:
+                case XML_RELAXNG_CHOICE:
+                case XML_RELAXNG_GROUP:
+                case XML_RELAXNG_INTERLEAVE:
+                    if (last == NULL) {
+                        ret->content = last = cur;
+                    } else {
+                        if ((last->type == XML_RELAXNG_ELEMENT) &&
+                            (ret->content == last)) {
+                            ret->content = xmlRelaxNGNewDefine(ctxt, node);
+                            if (ret->content != NULL) {
+                                ret->content->type = XML_RELAXNG_GROUP;
+                                ret->content->content = last;
+                            } else {
+                                ret->content = last;
+                            }
+                        }
+                        last->next = cur;
+                        last = cur;
+                    }
+                    break;
+                case XML_RELAXNG_ATTRIBUTE:
+                    cur->next = ret->attrs;
+                    ret->attrs = cur;
+                    break;
+                case XML_RELAXNG_START:
+                    xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_CONTENT,
+                               "RNG Internal error, start found in element\n",
+                               NULL, NULL);
+                    break;
+                case XML_RELAXNG_PARAM:
+                    xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_CONTENT,
+                               "RNG Internal error, param found in element\n",
+                               NULL, NULL);
+                    break;
+                case XML_RELAXNG_EXCEPT:
+                    xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_CONTENT,
+                               "RNG Internal error, except found in element\n",
+                               NULL, NULL);
+                    break;
+                case XML_RELAXNG_NOOP:
+                    xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_CONTENT,
+                               "RNG Internal error, noop found in element\n",
+                               NULL, NULL);
+                    break;
+            }
+        }
+        child = child->next;
+    }
+    ctxt->define = olddefine;
+    return (ret);
+}
+
+/**
+ * xmlRelaxNGParsePatterns:
+ * @ctxt:  a Relax-NG parser context
+ * @nodes:  list of nodes
+ * @group:  use an implicit <group> for elements
+ *
+ * parse the content of a RelaxNG start node.
+ *
+ * Returns the definition pointer or NULL in case of error.
+ */
+static xmlRelaxNGDefinePtr
+xmlRelaxNGParsePatterns(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr nodes,
+                        int group)
+{
+    xmlRelaxNGDefinePtr def = NULL, last = NULL, cur, parent;
+
+    parent = ctxt->def;
+    while (nodes != NULL) {
+        if (IS_RELAXNG(nodes, "element")) {
+            cur = xmlRelaxNGParseElement(ctxt, nodes);
+            if (def == NULL) {
+                def = last = cur;
+            } else {
+                if ((group == 1) && (def->type == XML_RELAXNG_ELEMENT) &&
+                    (def == last)) {
+                    def = xmlRelaxNGNewDefine(ctxt, nodes);
+                    def->type = XML_RELAXNG_GROUP;
+                    def->content = last;
+                }
+                last->next = cur;
+                last = cur;
+            }
+            cur->parent = parent;
+        } else {
+            cur = xmlRelaxNGParsePattern(ctxt, nodes);
+            if (cur != NULL) {
+                if (def == NULL) {
+                    def = last = cur;
+                } else {
+                    last->next = cur;
+                    last = cur;
+                }
+            }
+        }
+        nodes = nodes->next;
+    }
+    return (def);
+}
+
+/**
+ * xmlRelaxNGParseStart:
+ * @ctxt:  a Relax-NG parser context
+ * @nodes:  start children nodes
+ *
+ * parse the content of a RelaxNG start node.
+ *
+ * Returns 0 in case of success, -1 in case of error
+ */
+static int
+xmlRelaxNGParseStart(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr nodes)
+{
+    int ret = 0;
+    xmlRelaxNGDefinePtr def = NULL, last;
+
+    if (nodes == NULL) {
+        xmlRngPErr(ctxt, nodes, XML_RNGP_START_EMPTY, "start has no children\n",
+                   NULL, NULL);
+        return (-1);
+    }
+    if (IS_RELAXNG(nodes, "empty")) {
+        def = xmlRelaxNGNewDefine(ctxt, nodes);
+        if (def == NULL)
+            return (-1);
+        def->type = XML_RELAXNG_EMPTY;
+        if (nodes->children != NULL) {
+            xmlRngPErr(ctxt, nodes, XML_RNGP_EMPTY_CONTENT,
+                       "element empty is not empty\n", NULL, NULL);
+        }
+    } else if (IS_RELAXNG(nodes, "notAllowed")) {
+        def = xmlRelaxNGNewDefine(ctxt, nodes);
+        if (def == NULL)
+            return (-1);
+        def->type = XML_RELAXNG_NOT_ALLOWED;
+        if (nodes->children != NULL) {
+            xmlRngPErr(ctxt, nodes, XML_RNGP_NOTALLOWED_NOT_EMPTY,
+                       "element notAllowed is not empty\n", NULL, NULL);
+        }
+    } else {
+        def = xmlRelaxNGParsePatterns(ctxt, nodes, 1);
+    }
+    if (ctxt->grammar->start != NULL) {
+        last = ctxt->grammar->start;
+        while (last->next != NULL)
+            last = last->next;
+        last->next = def;
+    } else {
+        ctxt->grammar->start = def;
+    }
+    nodes = nodes->next;
+    if (nodes != NULL) {
+        xmlRngPErr(ctxt, nodes, XML_RNGP_START_CONTENT,
+                   "start more than one children\n", NULL, NULL);
+        return (-1);
+    }
+    return (ret);
+}
+
+/**
+ * xmlRelaxNGParseGrammarContent:
+ * @ctxt:  a Relax-NG parser context
+ * @nodes:  grammar children nodes
+ *
+ * parse the content of a RelaxNG grammar node.
+ *
+ * Returns 0 in case of success, -1 in case of error
+ */
+static int
+xmlRelaxNGParseGrammarContent(xmlRelaxNGParserCtxtPtr ctxt,
+                              xmlNodePtr nodes)
+{
+    int ret = 0, tmp;
+
+    if (nodes == NULL) {
+        xmlRngPErr(ctxt, nodes, XML_RNGP_GRAMMAR_EMPTY,
+                   "grammar has no children\n", NULL, NULL);
+        return (-1);
+    }
+    while (nodes != NULL) {
+        if (IS_RELAXNG(nodes, "start")) {
+            if (nodes->children == NULL) {
+                xmlRngPErr(ctxt, nodes, XML_RNGP_START_EMPTY,
+                           "start has no children\n", NULL, NULL);
+            } else {
+                tmp = xmlRelaxNGParseStart(ctxt, nodes->children);
+                if (tmp != 0)
+                    ret = -1;
+            }
+        } else if (IS_RELAXNG(nodes, "define")) {
+            tmp = xmlRelaxNGParseDefine(ctxt, nodes);
+            if (tmp != 0)
+                ret = -1;
+        } else if (IS_RELAXNG(nodes, "include")) {
+            tmp = xmlRelaxNGParseInclude(ctxt, nodes);
+            if (tmp != 0)
+                ret = -1;
+        } else {
+            xmlRngPErr(ctxt, nodes, XML_RNGP_GRAMMAR_CONTENT,
+                       "grammar has unexpected child %s\n", nodes->name,
+                       NULL);
+            ret = -1;
+        }
+        nodes = nodes->next;
+    }
+    return (ret);
+}
+
+/**
+ * xmlRelaxNGCheckReference:
+ * @ref:  the ref
+ * @ctxt:  a Relax-NG parser context
+ * @name:  the name associated to the defines
+ *
+ * Applies the 4.17. combine attribute rule for all the define
+ * element of a given grammar using the same name.
+ */
+static void
+xmlRelaxNGCheckReference(xmlRelaxNGDefinePtr ref,
+                         xmlRelaxNGParserCtxtPtr ctxt,
+                         const xmlChar * name)
+{
+    xmlRelaxNGGrammarPtr grammar;
+    xmlRelaxNGDefinePtr def, cur;
+
+    grammar = ctxt->grammar;
+    if (grammar == NULL) {
+        xmlRngPErr(ctxt, ref->node, XML_ERR_INTERNAL_ERROR,
+                   "Internal error: no grammar in CheckReference %s\n",
+                   name, NULL);
+        return;
+    }
+    if (ref->content != NULL) {
+        xmlRngPErr(ctxt, ref->node, XML_ERR_INTERNAL_ERROR,
+                   "Internal error: reference has content in CheckReference %s\n",
+                   name, NULL);
+        return;
+    }
+    if (grammar->defs != NULL) {
+        def = xmlHashLookup(grammar->defs, name);
+        if (def != NULL) {
+            cur = ref;
+            while (cur != NULL) {
+                cur->content = def;
+                cur = cur->nextHash;
+            }
+        } else {
+            xmlRngPErr(ctxt, ref->node, XML_RNGP_REF_NO_DEF,
+                       "Reference %s has no matching definition\n", name,
+                       NULL);
+        }
+    } else {
+        xmlRngPErr(ctxt, ref->node, XML_RNGP_REF_NO_DEF,
+                   "Reference %s has no matching definition\n", name,
+                   NULL);
+    }
+}
+
+/**
+ * xmlRelaxNGCheckCombine:
+ * @define:  the define(s) list
+ * @ctxt:  a Relax-NG parser context
+ * @name:  the name associated to the defines
+ *
+ * Applies the 4.17. combine attribute rule for all the define
+ * element of a given grammar using the same name.
+ */
+static void
+xmlRelaxNGCheckCombine(xmlRelaxNGDefinePtr define,
+                       xmlRelaxNGParserCtxtPtr ctxt, const xmlChar * name)
+{
+    xmlChar *combine;
+    int choiceOrInterleave = -1;
+    int missing = 0;
+    xmlRelaxNGDefinePtr cur, last, tmp, tmp2;
+
+    if (define->nextHash == NULL)
+        return;
+    cur = define;
+    while (cur != NULL) {
+        combine = xmlGetProp(cur->node, BAD_CAST "combine");
+        if (combine != NULL) {
+            if (xmlStrEqual(combine, BAD_CAST "choice")) {
+                if (choiceOrInterleave == -1)
+                    choiceOrInterleave = 1;
+                else if (choiceOrInterleave == 0) {
+                    xmlRngPErr(ctxt, define->node, XML_RNGP_DEF_CHOICE_AND_INTERLEAVE,
+                               "Defines for %s use both 'choice' and 'interleave'\n",
+                               name, NULL);
+                }
+            } else if (xmlStrEqual(combine, BAD_CAST "interleave")) {
+                if (choiceOrInterleave == -1)
+                    choiceOrInterleave = 0;
+                else if (choiceOrInterleave == 1) {
+                    xmlRngPErr(ctxt, define->node, XML_RNGP_DEF_CHOICE_AND_INTERLEAVE,
+                               "Defines for %s use both 'choice' and 'interleave'\n",
+                               name, NULL);
+                }
+            } else {
+                xmlRngPErr(ctxt, define->node, XML_RNGP_UNKNOWN_COMBINE,
+                           "Defines for %s use unknown combine value '%s''\n",
+                           name, combine);
+            }
+            xmlFree(combine);
+        } else {
+            if (missing == 0)
+                missing = 1;
+            else {
+                xmlRngPErr(ctxt, define->node, XML_RNGP_NEED_COMBINE,
+                           "Some defines for %s needs the combine attribute\n",
+                           name, NULL);
+            }
+        }
+
+        cur = cur->nextHash;
+    }
+#ifdef DEBUG
+    xmlGenericError(xmlGenericErrorContext,
+                    "xmlRelaxNGCheckCombine(): merging %s defines: %d\n",
+                    name, choiceOrInterleave);
+#endif
+    if (choiceOrInterleave == -1)
+        choiceOrInterleave = 0;
+    cur = xmlRelaxNGNewDefine(ctxt, define->node);
+    if (cur == NULL)
+        return;
+    if (choiceOrInterleave == 0)
+        cur->type = XML_RELAXNG_INTERLEAVE;
+    else
+        cur->type = XML_RELAXNG_CHOICE;
+    tmp = define;
+    last = NULL;
+    while (tmp != NULL) {
+        if (tmp->content != NULL) {
+            if (tmp->content->next != NULL) {
+                /*
+                 * we need first to create a wrapper.
+                 */
+                tmp2 = xmlRelaxNGNewDefine(ctxt, tmp->content->node);
+                if (tmp2 == NULL)
+                    break;
+                tmp2->type = XML_RELAXNG_GROUP;
+                tmp2->content = tmp->content;
+            } else {
+                tmp2 = tmp->content;
+            }
+            if (last == NULL) {
+                cur->content = tmp2;
+            } else {
+                last->next = tmp2;
+            }
+            last = tmp2;
+        }
+        tmp->content = cur;
+        tmp = tmp->nextHash;
+    }
+    define->content = cur;
+    if (choiceOrInterleave == 0) {
+        if (ctxt->interleaves == NULL)
+            ctxt->interleaves = xmlHashCreate(10);
+        if (ctxt->interleaves == NULL) {
+            xmlRngPErr(ctxt, define->node, XML_RNGP_INTERLEAVE_CREATE_FAILED,
+                       "Failed to create interleaves hash table\n", NULL,
+                       NULL);
+        } else {
+            char tmpname[32];
+
+            snprintf(tmpname, 32, "interleave%d", ctxt->nbInterleaves++);
+            if (xmlHashAddEntry(ctxt->interleaves, BAD_CAST tmpname, cur) <
+                0) {
+                xmlRngPErr(ctxt, define->node, XML_RNGP_INTERLEAVE_CREATE_FAILED,
+                           "Failed to add %s to hash table\n",
+			   (const xmlChar *) tmpname, NULL);
+            }
+        }
+    }
+}
+
+/**
+ * xmlRelaxNGCombineStart:
+ * @ctxt:  a Relax-NG parser context
+ * @grammar:  the grammar
+ *
+ * Applies the 4.17. combine rule for all the start
+ * element of a given grammar.
+ */
+static void
+xmlRelaxNGCombineStart(xmlRelaxNGParserCtxtPtr ctxt,
+                       xmlRelaxNGGrammarPtr grammar)
+{
+    xmlRelaxNGDefinePtr starts;
+    xmlChar *combine;
+    int choiceOrInterleave = -1;
+    int missing = 0;
+    xmlRelaxNGDefinePtr cur;
+
+    starts = grammar->start;
+    if ((starts == NULL) || (starts->next == NULL))
+        return;
+    cur = starts;
+    while (cur != NULL) {
+        if ((cur->node == NULL) || (cur->node->parent == NULL) ||
+            (!xmlStrEqual(cur->node->parent->name, BAD_CAST "start"))) {
+            combine = NULL;
+            xmlRngPErr(ctxt, cur->node, XML_RNGP_START_MISSING,
+                       "Internal error: start element not found\n", NULL,
+                       NULL);
+        } else {
+            combine = xmlGetProp(cur->node->parent, BAD_CAST "combine");
+        }
+
+        if (combine != NULL) {
+            if (xmlStrEqual(combine, BAD_CAST "choice")) {
+                if (choiceOrInterleave == -1)
+                    choiceOrInterleave = 1;
+                else if (choiceOrInterleave == 0) {
+                    xmlRngPErr(ctxt, cur->node, XML_RNGP_START_CHOICE_AND_INTERLEAVE,
+                               "<start> use both 'choice' and 'interleave'\n",
+                               NULL, NULL);
+                }
+            } else if (xmlStrEqual(combine, BAD_CAST "interleave")) {
+                if (choiceOrInterleave == -1)
+                    choiceOrInterleave = 0;
+                else if (choiceOrInterleave == 1) {
+                    xmlRngPErr(ctxt, cur->node, XML_RNGP_START_CHOICE_AND_INTERLEAVE,
+                               "<start> use both 'choice' and 'interleave'\n",
+                               NULL, NULL);
+                }
+            } else {
+                xmlRngPErr(ctxt, cur->node, XML_RNGP_UNKNOWN_COMBINE,
+                           "<start> uses unknown combine value '%s''\n",
+                           combine, NULL);
+            }
+            xmlFree(combine);
+        } else {
+            if (missing == 0)
+                missing = 1;
+            else {
+                xmlRngPErr(ctxt, cur->node, XML_RNGP_NEED_COMBINE,
+                           "Some <start> element miss the combine attribute\n",
+                           NULL, NULL);
+            }
+        }
+
+        cur = cur->next;
+    }
+#ifdef DEBUG
+    xmlGenericError(xmlGenericErrorContext,
+                    "xmlRelaxNGCombineStart(): merging <start>: %d\n",
+                    choiceOrInterleave);
+#endif
+    if (choiceOrInterleave == -1)
+        choiceOrInterleave = 0;
+    cur = xmlRelaxNGNewDefine(ctxt, starts->node);
+    if (cur == NULL)
+        return;
+    if (choiceOrInterleave == 0)
+        cur->type = XML_RELAXNG_INTERLEAVE;
+    else
+        cur->type = XML_RELAXNG_CHOICE;
+    cur->content = grammar->start;
+    grammar->start = cur;
+    if (choiceOrInterleave == 0) {
+        if (ctxt->interleaves == NULL)
+            ctxt->interleaves = xmlHashCreate(10);
+        if (ctxt->interleaves == NULL) {
+            xmlRngPErr(ctxt, cur->node, XML_RNGP_INTERLEAVE_CREATE_FAILED,
+                       "Failed to create interleaves hash table\n", NULL,
+                       NULL);
+        } else {
+            char tmpname[32];
+
+            snprintf(tmpname, 32, "interleave%d", ctxt->nbInterleaves++);
+            if (xmlHashAddEntry(ctxt->interleaves, BAD_CAST tmpname, cur) <
+                0) {
+                xmlRngPErr(ctxt, cur->node, XML_RNGP_INTERLEAVE_CREATE_FAILED,
+                           "Failed to add %s to hash table\n",
+			   (const xmlChar *) tmpname, NULL);
+            }
+        }
+    }
+}
+
+/**
+ * xmlRelaxNGCheckCycles:
+ * @ctxt:  a Relax-NG parser context
+ * @nodes:  grammar children nodes
+ * @depth:  the counter
+ *
+ * Check for cycles.
+ *
+ * Returns 0 if check passed, and -1 in case of error
+ */
+static int
+xmlRelaxNGCheckCycles(xmlRelaxNGParserCtxtPtr ctxt,
+                      xmlRelaxNGDefinePtr cur, int depth)
+{
+    int ret = 0;
+
+    while ((ret == 0) && (cur != NULL)) {
+        if ((cur->type == XML_RELAXNG_REF) ||
+            (cur->type == XML_RELAXNG_PARENTREF)) {
+            if (cur->depth == -1) {
+                cur->depth = depth;
+                ret = xmlRelaxNGCheckCycles(ctxt, cur->content, depth);
+                cur->depth = -2;
+            } else if (depth == cur->depth) {
+                xmlRngPErr(ctxt, cur->node, XML_RNGP_REF_CYCLE,
+                           "Detected a cycle in %s references\n",
+                           cur->name, NULL);
+                return (-1);
+            }
+        } else if (cur->type == XML_RELAXNG_ELEMENT) {
+            ret = xmlRelaxNGCheckCycles(ctxt, cur->content, depth + 1);
+        } else {
+            ret = xmlRelaxNGCheckCycles(ctxt, cur->content, depth);
+        }
+        cur = cur->next;
+    }
+    return (ret);
+}
+
+/**
+ * xmlRelaxNGTryUnlink:
+ * @ctxt:  a Relax-NG parser context
+ * @cur:  the definition to unlink
+ * @parent:  the parent definition
+ * @prev:  the previous sibling definition
+ *
+ * Try to unlink a definition. If not possble make it a NOOP
+ *
+ * Returns the new prev definition
+ */
+static xmlRelaxNGDefinePtr
+xmlRelaxNGTryUnlink(xmlRelaxNGParserCtxtPtr ctxt ATTRIBUTE_UNUSED,
+                    xmlRelaxNGDefinePtr cur,
+                    xmlRelaxNGDefinePtr parent, xmlRelaxNGDefinePtr prev)
+{
+    if (prev != NULL) {
+        prev->next = cur->next;
+    } else {
+        if (parent != NULL) {
+            if (parent->content == cur)
+                parent->content = cur->next;
+            else if (parent->attrs == cur)
+                parent->attrs = cur->next;
+            else if (parent->nameClass == cur)
+                parent->nameClass = cur->next;
+        } else {
+            cur->type = XML_RELAXNG_NOOP;
+            prev = cur;
+        }
+    }
+    return (prev);
+}
+
+/**
+ * xmlRelaxNGSimplify:
+ * @ctxt:  a Relax-NG parser context
+ * @nodes:  grammar children nodes
+ *
+ * Check for simplification of empty and notAllowed
+ */
+static void
+xmlRelaxNGSimplify(xmlRelaxNGParserCtxtPtr ctxt,
+                   xmlRelaxNGDefinePtr cur, xmlRelaxNGDefinePtr parent)
+{
+    xmlRelaxNGDefinePtr prev = NULL;
+
+    while (cur != NULL) {
+        if ((cur->type == XML_RELAXNG_REF) ||
+            (cur->type == XML_RELAXNG_PARENTREF)) {
+            if (cur->depth != -3) {
+                cur->depth = -3;
+                xmlRelaxNGSimplify(ctxt, cur->content, cur);
+            }
+        } else if (cur->type == XML_RELAXNG_NOT_ALLOWED) {
+            cur->parent = parent;
+            if ((parent != NULL) &&
+                ((parent->type == XML_RELAXNG_ATTRIBUTE) ||
+                 (parent->type == XML_RELAXNG_LIST) ||
+                 (parent->type == XML_RELAXNG_GROUP) ||
+                 (parent->type == XML_RELAXNG_INTERLEAVE) ||
+                 (parent->type == XML_RELAXNG_ONEORMORE) ||
+                 (parent->type == XML_RELAXNG_ZEROORMORE))) {
+                parent->type = XML_RELAXNG_NOT_ALLOWED;
+                break;
+            }
+            if ((parent != NULL) && (parent->type == XML_RELAXNG_CHOICE)) {
+                prev = xmlRelaxNGTryUnlink(ctxt, cur, parent, prev);
+            } else
+                prev = cur;
+        } else if (cur->type == XML_RELAXNG_EMPTY) {
+            cur->parent = parent;
+            if ((parent != NULL) &&
+                ((parent->type == XML_RELAXNG_ONEORMORE) ||
+                 (parent->type == XML_RELAXNG_ZEROORMORE))) {
+                parent->type = XML_RELAXNG_EMPTY;
+                break;
+            }
+            if ((parent != NULL) &&
+                ((parent->type == XML_RELAXNG_GROUP) ||
+                 (parent->type == XML_RELAXNG_INTERLEAVE))) {
+                prev = xmlRelaxNGTryUnlink(ctxt, cur, parent, prev);
+            } else
+                prev = cur;
+        } else {
+            cur->parent = parent;
+            if (cur->content != NULL)
+                xmlRelaxNGSimplify(ctxt, cur->content, cur);
+            if ((cur->type != XML_RELAXNG_VALUE) && (cur->attrs != NULL))
+                xmlRelaxNGSimplify(ctxt, cur->attrs, cur);
+            if (cur->nameClass != NULL)
+                xmlRelaxNGSimplify(ctxt, cur->nameClass, cur);
+            /*
+             * On Elements, try to move attribute only generating rules on
+             * the attrs rules.
+             */
+            if (cur->type == XML_RELAXNG_ELEMENT) {
+                int attronly;
+                xmlRelaxNGDefinePtr tmp, pre;
+
+                while (cur->content != NULL) {
+                    attronly =
+                        xmlRelaxNGGenerateAttributes(ctxt, cur->content);
+                    if (attronly == 1) {
+                        /*
+                         * migrate cur->content to attrs
+                         */
+                        tmp = cur->content;
+                        cur->content = tmp->next;
+                        tmp->next = cur->attrs;
+                        cur->attrs = tmp;
+                    } else {
+                        /*
+                         * cur->content can generate elements or text
+                         */
+                        break;
+                    }
+                }
+                pre = cur->content;
+                while ((pre != NULL) && (pre->next != NULL)) {
+                    tmp = pre->next;
+                    attronly = xmlRelaxNGGenerateAttributes(ctxt, tmp);
+                    if (attronly == 1) {
+                        /*
+                         * migrate tmp to attrs
+                         */
+                        pre->next = tmp->next;
+                        tmp->next = cur->attrs;
+                        cur->attrs = tmp;
+                    } else {
+                        pre = tmp;
+                    }
+                }
+            }
+            /*
+             * This may result in a simplification
+             */
+            if ((cur->type == XML_RELAXNG_GROUP) ||
+                (cur->type == XML_RELAXNG_INTERLEAVE)) {
+                if (cur->content == NULL)
+                    cur->type = XML_RELAXNG_EMPTY;
+                else if (cur->content->next == NULL) {
+                    if ((parent == NULL) && (prev == NULL)) {
+                        cur->type = XML_RELAXNG_NOOP;
+                    } else if (prev == NULL) {
+                        parent->content = cur->content;
+                        cur->content->next = cur->next;
+                        cur = cur->content;
+                    } else {
+                        cur->content->next = cur->next;
+                        prev->next = cur->content;
+                        cur = cur->content;
+                    }
+                }
+            }
+            /*
+             * the current node may have been transformed back
+             */
+            if ((cur->type == XML_RELAXNG_EXCEPT) &&
+                (cur->content != NULL) &&
+                (cur->content->type == XML_RELAXNG_NOT_ALLOWED)) {
+                prev = xmlRelaxNGTryUnlink(ctxt, cur, parent, prev);
+            } else if (cur->type == XML_RELAXNG_NOT_ALLOWED) {
+                if ((parent != NULL) &&
+                    ((parent->type == XML_RELAXNG_ATTRIBUTE) ||
+                     (parent->type == XML_RELAXNG_LIST) ||
+                     (parent->type == XML_RELAXNG_GROUP) ||
+                     (parent->type == XML_RELAXNG_INTERLEAVE) ||
+                     (parent->type == XML_RELAXNG_ONEORMORE) ||
+                     (parent->type == XML_RELAXNG_ZEROORMORE))) {
+                    parent->type = XML_RELAXNG_NOT_ALLOWED;
+                    break;
+                }
+                if ((parent != NULL) &&
+                    (parent->type == XML_RELAXNG_CHOICE)) {
+                    prev = xmlRelaxNGTryUnlink(ctxt, cur, parent, prev);
+                } else
+                    prev = cur;
+            } else if (cur->type == XML_RELAXNG_EMPTY) {
+                if ((parent != NULL) &&
+                    ((parent->type == XML_RELAXNG_ONEORMORE) ||
+                     (parent->type == XML_RELAXNG_ZEROORMORE))) {
+                    parent->type = XML_RELAXNG_EMPTY;
+                    break;
+                }
+                if ((parent != NULL) &&
+                    ((parent->type == XML_RELAXNG_GROUP) ||
+                     (parent->type == XML_RELAXNG_INTERLEAVE) ||
+                     (parent->type == XML_RELAXNG_CHOICE))) {
+                    prev = xmlRelaxNGTryUnlink(ctxt, cur, parent, prev);
+                } else
+                    prev = cur;
+            } else {
+                prev = cur;
+            }
+        }
+        cur = cur->next;
+    }
+}
+
+/**
+ * xmlRelaxNGGroupContentType:
+ * @ct1:  the first content type
+ * @ct2:  the second content type
+ *
+ * Try to group 2 content types
+ *
+ * Returns the content type
+ */
+static xmlRelaxNGContentType
+xmlRelaxNGGroupContentType(xmlRelaxNGContentType ct1,
+                           xmlRelaxNGContentType ct2)
+{
+    if ((ct1 == XML_RELAXNG_CONTENT_ERROR) ||
+        (ct2 == XML_RELAXNG_CONTENT_ERROR))
+        return (XML_RELAXNG_CONTENT_ERROR);
+    if (ct1 == XML_RELAXNG_CONTENT_EMPTY)
+        return (ct2);
+    if (ct2 == XML_RELAXNG_CONTENT_EMPTY)
+        return (ct1);
+    if ((ct1 == XML_RELAXNG_CONTENT_COMPLEX) &&
+        (ct2 == XML_RELAXNG_CONTENT_COMPLEX))
+        return (XML_RELAXNG_CONTENT_COMPLEX);
+    return (XML_RELAXNG_CONTENT_ERROR);
+}
+
+/**
+ * xmlRelaxNGMaxContentType:
+ * @ct1:  the first content type
+ * @ct2:  the second content type
+ *
+ * Compute the max content-type
+ *
+ * Returns the content type
+ */
+static xmlRelaxNGContentType
+xmlRelaxNGMaxContentType(xmlRelaxNGContentType ct1,
+                         xmlRelaxNGContentType ct2)
+{
+    if ((ct1 == XML_RELAXNG_CONTENT_ERROR) ||
+        (ct2 == XML_RELAXNG_CONTENT_ERROR))
+        return (XML_RELAXNG_CONTENT_ERROR);
+    if ((ct1 == XML_RELAXNG_CONTENT_SIMPLE) ||
+        (ct2 == XML_RELAXNG_CONTENT_SIMPLE))
+        return (XML_RELAXNG_CONTENT_SIMPLE);
+    if ((ct1 == XML_RELAXNG_CONTENT_COMPLEX) ||
+        (ct2 == XML_RELAXNG_CONTENT_COMPLEX))
+        return (XML_RELAXNG_CONTENT_COMPLEX);
+    return (XML_RELAXNG_CONTENT_EMPTY);
+}
+
+/**
+ * xmlRelaxNGCheckRules:
+ * @ctxt:  a Relax-NG parser context
+ * @cur:  the current definition
+ * @flags:  some accumulated flags
+ * @ptype:  the parent type
+ *
+ * Check for rules in section 7.1 and 7.2
+ *
+ * Returns the content type of @cur
+ */
+static xmlRelaxNGContentType
+xmlRelaxNGCheckRules(xmlRelaxNGParserCtxtPtr ctxt,
+                     xmlRelaxNGDefinePtr cur, int flags,
+                     xmlRelaxNGType ptype)
+{
+    int nflags = flags;
+    xmlRelaxNGContentType ret, tmp, val = XML_RELAXNG_CONTENT_EMPTY;
+
+    while (cur != NULL) {
+        ret = XML_RELAXNG_CONTENT_EMPTY;
+        if ((cur->type == XML_RELAXNG_REF) ||
+            (cur->type == XML_RELAXNG_PARENTREF)) {
+            if (flags & XML_RELAXNG_IN_LIST) {
+                xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_LIST_REF,
+                           "Found forbidden pattern list//ref\n", NULL,
+                           NULL);
+            }
+            if (flags & XML_RELAXNG_IN_DATAEXCEPT) {
+                xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_REF,
+                           "Found forbidden pattern data/except//ref\n",
+                           NULL, NULL);
+            }
+            if (cur->depth > -4) {
+                cur->depth = -4;
+                ret = xmlRelaxNGCheckRules(ctxt, cur->content,
+                                           flags, cur->type);
+                cur->depth = ret - 15;
+            } else if (cur->depth == -4) {
+                ret = XML_RELAXNG_CONTENT_COMPLEX;
+            } else {
+                ret = (xmlRelaxNGContentType) (cur->depth + 15);
+            }
+        } else if (cur->type == XML_RELAXNG_ELEMENT) {
+            /*
+             * The 7.3 Attribute derivation rule for groups is plugged there
+             */
+            xmlRelaxNGCheckGroupAttrs(ctxt, cur);
+            if (flags & XML_RELAXNG_IN_DATAEXCEPT) {
+                xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_ELEM,
+                           "Found forbidden pattern data/except//element(ref)\n",
+                           NULL, NULL);
+            }
+            if (flags & XML_RELAXNG_IN_LIST) {
+                xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_LIST_ELEM,
+                           "Found forbidden pattern list//element(ref)\n",
+                           NULL, NULL);
+            }
+            if (flags & XML_RELAXNG_IN_ATTRIBUTE) {
+                xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_ATTR_ELEM,
+                           "Found forbidden pattern attribute//element(ref)\n",
+                           NULL, NULL);
+            }
+            if (flags & XML_RELAXNG_IN_ATTRIBUTE) {
+                xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_ATTR_ELEM,
+                           "Found forbidden pattern attribute//element(ref)\n",
+                           NULL, NULL);
+            }
+            /*
+             * reset since in the simple form elements are only child
+             * of grammar/define
+             */
+            nflags = 0;
+            ret =
+                xmlRelaxNGCheckRules(ctxt, cur->attrs, nflags, cur->type);
+            if (ret != XML_RELAXNG_CONTENT_EMPTY) {
+                xmlRngPErr(ctxt, cur->node, XML_RNGP_ELEM_CONTENT_EMPTY,
+                           "Element %s attributes have a content type error\n",
+                           cur->name, NULL);
+            }
+            ret =
+                xmlRelaxNGCheckRules(ctxt, cur->content, nflags,
+                                     cur->type);
+            if (ret == XML_RELAXNG_CONTENT_ERROR) {
+                xmlRngPErr(ctxt, cur->node, XML_RNGP_ELEM_CONTENT_ERROR,
+                           "Element %s has a content type error\n",
+                           cur->name, NULL);
+            } else {
+                ret = XML_RELAXNG_CONTENT_COMPLEX;
+            }
+        } else if (cur->type == XML_RELAXNG_ATTRIBUTE) {
+            if (flags & XML_RELAXNG_IN_ATTRIBUTE) {
+                xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_ATTR_ATTR,
+                           "Found forbidden pattern attribute//attribute\n",
+                           NULL, NULL);
+            }
+            if (flags & XML_RELAXNG_IN_LIST) {
+                xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_LIST_ATTR,
+                           "Found forbidden pattern list//attribute\n",
+                           NULL, NULL);
+            }
+            if (flags & XML_RELAXNG_IN_OOMGROUP) {
+                xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_ONEMORE_GROUP_ATTR,
+                           "Found forbidden pattern oneOrMore//group//attribute\n",
+                           NULL, NULL);
+            }
+            if (flags & XML_RELAXNG_IN_OOMINTERLEAVE) {
+                xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_ONEMORE_INTERLEAVE_ATTR,
+                           "Found forbidden pattern oneOrMore//interleave//attribute\n",
+                           NULL, NULL);
+            }
+            if (flags & XML_RELAXNG_IN_DATAEXCEPT) {
+                xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_ATTR,
+                           "Found forbidden pattern data/except//attribute\n",
+                           NULL, NULL);
+            }
+            if (flags & XML_RELAXNG_IN_START) {
+                xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_ATTR,
+                           "Found forbidden pattern start//attribute\n",
+                           NULL, NULL);
+            }
+            if ((!(flags & XML_RELAXNG_IN_ONEORMORE))
+                && (cur->name == NULL)) {
+                if (cur->ns == NULL) {
+                    xmlRngPErr(ctxt, cur->node, XML_RNGP_ANYNAME_ATTR_ANCESTOR,
+                               "Found anyName attribute without oneOrMore ancestor\n",
+                               NULL, NULL);
+                } else {
+                    xmlRngPErr(ctxt, cur->node, XML_RNGP_NSNAME_ATTR_ANCESTOR,
+                               "Found nsName attribute without oneOrMore ancestor\n",
+                               NULL, NULL);
+                }
+            }
+            nflags = flags | XML_RELAXNG_IN_ATTRIBUTE;
+            xmlRelaxNGCheckRules(ctxt, cur->content, nflags, cur->type);
+            ret = XML_RELAXNG_CONTENT_EMPTY;
+        } else if ((cur->type == XML_RELAXNG_ONEORMORE) ||
+                   (cur->type == XML_RELAXNG_ZEROORMORE)) {
+            if (flags & XML_RELAXNG_IN_DATAEXCEPT) {
+                xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_ONEMORE,
+                           "Found forbidden pattern data/except//oneOrMore\n",
+                           NULL, NULL);
+            }
+            if (flags & XML_RELAXNG_IN_START) {
+                xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_ONEMORE,
+                           "Found forbidden pattern start//oneOrMore\n",
+                           NULL, NULL);
+            }
+            nflags = flags | XML_RELAXNG_IN_ONEORMORE;
+            ret =
+                xmlRelaxNGCheckRules(ctxt, cur->content, nflags,
+                                     cur->type);
+            ret = xmlRelaxNGGroupContentType(ret, ret);
+        } else if (cur->type == XML_RELAXNG_LIST) {
+            if (flags & XML_RELAXNG_IN_LIST) {
+                xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_LIST_LIST,
+                           "Found forbidden pattern list//list\n", NULL,
+                           NULL);
+            }
+            if (flags & XML_RELAXNG_IN_DATAEXCEPT) {
+                xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_LIST,
+                           "Found forbidden pattern data/except//list\n",
+                           NULL, NULL);
+            }
+            if (flags & XML_RELAXNG_IN_START) {
+                xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_LIST,
+                           "Found forbidden pattern start//list\n", NULL,
+                           NULL);
+            }
+            nflags = flags | XML_RELAXNG_IN_LIST;
+            ret =
+                xmlRelaxNGCheckRules(ctxt, cur->content, nflags,
+                                     cur->type);
+        } else if (cur->type == XML_RELAXNG_GROUP) {
+            if (flags & XML_RELAXNG_IN_DATAEXCEPT) {
+                xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_GROUP,
+                           "Found forbidden pattern data/except//group\n",
+                           NULL, NULL);
+            }
+            if (flags & XML_RELAXNG_IN_START) {
+                xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_GROUP,
+                           "Found forbidden pattern start//group\n", NULL,
+                           NULL);
+            }
+            if (flags & XML_RELAXNG_IN_ONEORMORE)
+                nflags = flags | XML_RELAXNG_IN_OOMGROUP;
+            else
+                nflags = flags;
+            ret =
+                xmlRelaxNGCheckRules(ctxt, cur->content, nflags,
+                                     cur->type);
+            /*
+             * The 7.3 Attribute derivation rule for groups is plugged there
+             */
+            xmlRelaxNGCheckGroupAttrs(ctxt, cur);
+        } else if (cur->type == XML_RELAXNG_INTERLEAVE) {
+            if (flags & XML_RELAXNG_IN_LIST) {
+                xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_LIST_INTERLEAVE,
+                           "Found forbidden pattern list//interleave\n",
+                           NULL, NULL);
+            }
+            if (flags & XML_RELAXNG_IN_DATAEXCEPT) {
+                xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_INTERLEAVE,
+                           "Found forbidden pattern data/except//interleave\n",
+                           NULL, NULL);
+            }
+            if (flags & XML_RELAXNG_IN_START) {
+                xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_INTERLEAVE,
+                           "Found forbidden pattern start//interleave\n",
+                           NULL, NULL);
+            }
+            if (flags & XML_RELAXNG_IN_ONEORMORE)
+                nflags = flags | XML_RELAXNG_IN_OOMINTERLEAVE;
+            else
+                nflags = flags;
+            ret =
+                xmlRelaxNGCheckRules(ctxt, cur->content, nflags,
+                                     cur->type);
+        } else if (cur->type == XML_RELAXNG_EXCEPT) {
+            if ((cur->parent != NULL) &&
+                (cur->parent->type == XML_RELAXNG_DATATYPE))
+                nflags = flags | XML_RELAXNG_IN_DATAEXCEPT;
+            else
+                nflags = flags;
+            ret =
+                xmlRelaxNGCheckRules(ctxt, cur->content, nflags,
+                                     cur->type);
+        } else if (cur->type == XML_RELAXNG_DATATYPE) {
+            if (flags & XML_RELAXNG_IN_START) {
+                xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_DATA,
+                           "Found forbidden pattern start//data\n", NULL,
+                           NULL);
+            }
+            xmlRelaxNGCheckRules(ctxt, cur->content, flags, cur->type);
+            ret = XML_RELAXNG_CONTENT_SIMPLE;
+        } else if (cur->type == XML_RELAXNG_VALUE) {
+            if (flags & XML_RELAXNG_IN_START) {
+                xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_VALUE,
+                           "Found forbidden pattern start//value\n", NULL,
+                           NULL);
+            }
+            xmlRelaxNGCheckRules(ctxt, cur->content, flags, cur->type);
+            ret = XML_RELAXNG_CONTENT_SIMPLE;
+        } else if (cur->type == XML_RELAXNG_TEXT) {
+            if (flags & XML_RELAXNG_IN_LIST) {
+                xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_LIST_TEXT,
+                           "Found forbidden pattern list//text\n", NULL,
+                           NULL);
+            }
+            if (flags & XML_RELAXNG_IN_DATAEXCEPT) {
+                xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_TEXT,
+                           "Found forbidden pattern data/except//text\n",
+                           NULL, NULL);
+            }
+            if (flags & XML_RELAXNG_IN_START) {
+                xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_TEXT,
+                           "Found forbidden pattern start//text\n", NULL,
+                           NULL);
+            }
+            ret = XML_RELAXNG_CONTENT_COMPLEX;
+        } else if (cur->type == XML_RELAXNG_EMPTY) {
+            if (flags & XML_RELAXNG_IN_DATAEXCEPT) {
+                xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_EMPTY,
+                           "Found forbidden pattern data/except//empty\n",
+                           NULL, NULL);
+            }
+            if (flags & XML_RELAXNG_IN_START) {
+                xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_EMPTY,
+                           "Found forbidden pattern start//empty\n", NULL,
+                           NULL);
+            }
+            ret = XML_RELAXNG_CONTENT_EMPTY;
+        } else if (cur->type == XML_RELAXNG_CHOICE) {
+            xmlRelaxNGCheckChoiceDeterminism(ctxt, cur);
+            ret =
+                xmlRelaxNGCheckRules(ctxt, cur->content, flags, cur->type);
+        } else {
+            ret =
+                xmlRelaxNGCheckRules(ctxt, cur->content, flags, cur->type);
+        }
+        cur = cur->next;
+        if (ptype == XML_RELAXNG_GROUP) {
+            val = xmlRelaxNGGroupContentType(val, ret);
+        } else if (ptype == XML_RELAXNG_INTERLEAVE) {
+            tmp = xmlRelaxNGGroupContentType(val, ret);
+            if (tmp != XML_RELAXNG_CONTENT_ERROR)
+                tmp = xmlRelaxNGMaxContentType(val, ret);
+        } else if (ptype == XML_RELAXNG_CHOICE) {
+            val = xmlRelaxNGMaxContentType(val, ret);
+        } else if (ptype == XML_RELAXNG_LIST) {
+            val = XML_RELAXNG_CONTENT_SIMPLE;
+        } else if (ptype == XML_RELAXNG_EXCEPT) {
+            if (ret == XML_RELAXNG_CONTENT_ERROR)
+                val = XML_RELAXNG_CONTENT_ERROR;
+            else
+                val = XML_RELAXNG_CONTENT_SIMPLE;
+        } else {
+            val = xmlRelaxNGGroupContentType(val, ret);
+        }
+
+    }
+    return (val);
+}
+
+/**
+ * xmlRelaxNGParseGrammar:
+ * @ctxt:  a Relax-NG parser context
+ * @nodes:  grammar children nodes
+ *
+ * parse a Relax-NG <grammar> node
+ *
+ * Returns the internal xmlRelaxNGGrammarPtr built or
+ *         NULL in case of error
+ */
+static xmlRelaxNGGrammarPtr
+xmlRelaxNGParseGrammar(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr nodes)
+{
+    xmlRelaxNGGrammarPtr ret, tmp, old;
+
+#ifdef DEBUG_GRAMMAR
+    xmlGenericError(xmlGenericErrorContext, "Parsing a new grammar\n");
+#endif
+
+    ret = xmlRelaxNGNewGrammar(ctxt);
+    if (ret == NULL)
+        return (NULL);
+
+    /*
+     * Link the new grammar in the tree
+     */
+    ret->parent = ctxt->grammar;
+    if (ctxt->grammar != NULL) {
+        tmp = ctxt->grammar->children;
+        if (tmp == NULL) {
+            ctxt->grammar->children = ret;
+        } else {
+            while (tmp->next != NULL)
+                tmp = tmp->next;
+            tmp->next = ret;
+        }
+    }
+
+    old = ctxt->grammar;
+    ctxt->grammar = ret;
+    xmlRelaxNGParseGrammarContent(ctxt, nodes);
+    ctxt->grammar = ret;
+    if (ctxt->grammar == NULL) {
+        xmlRngPErr(ctxt, nodes, XML_RNGP_GRAMMAR_CONTENT,
+                   "Failed to parse <grammar> content\n", NULL, NULL);
+    } else if (ctxt->grammar->start == NULL) {
+        xmlRngPErr(ctxt, nodes, XML_RNGP_GRAMMAR_NO_START,
+                   "Element <grammar> has no <start>\n", NULL, NULL);
+    }
+
+    /*
+     * Apply 4.17 mergingd rules to defines and starts
+     */
+    xmlRelaxNGCombineStart(ctxt, ret);
+    if (ret->defs != NULL) {
+        xmlHashScan(ret->defs, (xmlHashScanner) xmlRelaxNGCheckCombine,
+                    ctxt);
+    }
+
+    /*
+     * link together defines and refs in this grammar
+     */
+    if (ret->refs != NULL) {
+        xmlHashScan(ret->refs, (xmlHashScanner) xmlRelaxNGCheckReference,
+                    ctxt);
+    }
+
+    ctxt->grammar = old;
+    return (ret);
+}
+
+/**
+ * xmlRelaxNGParseDocument:
+ * @ctxt:  a Relax-NG parser context
+ * @node:  the root node of the RelaxNG schema
+ *
+ * parse a Relax-NG definition resource and build an internal
+ * xmlRelaxNG struture which can be used to validate instances.
+ *
+ * Returns the internal XML RelaxNG structure built or
+ *         NULL in case of error
+ */
+static xmlRelaxNGPtr
+xmlRelaxNGParseDocument(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
+{
+    xmlRelaxNGPtr schema = NULL;
+    const xmlChar *olddefine;
+    xmlRelaxNGGrammarPtr old;
+
+    if ((ctxt == NULL) || (node == NULL))
+        return (NULL);
+
+    schema = xmlRelaxNGNewRelaxNG(ctxt);
+    if (schema == NULL)
+        return (NULL);
+
+    olddefine = ctxt->define;
+    ctxt->define = NULL;
+    if (IS_RELAXNG(node, "grammar")) {
+        schema->topgrammar = xmlRelaxNGParseGrammar(ctxt, node->children);
+    } else {
+        xmlRelaxNGGrammarPtr tmp, ret;
+
+        schema->topgrammar = ret = xmlRelaxNGNewGrammar(ctxt);
+        if (schema->topgrammar == NULL) {
+            return (schema);
+        }
+        /*
+         * Link the new grammar in the tree
+         */
+        ret->parent = ctxt->grammar;
+        if (ctxt->grammar != NULL) {
+            tmp = ctxt->grammar->children;
+            if (tmp == NULL) {
+                ctxt->grammar->children = ret;
+            } else {
+                while (tmp->next != NULL)
+                    tmp = tmp->next;
+                tmp->next = ret;
+            }
+        }
+        old = ctxt->grammar;
+        ctxt->grammar = ret;
+        xmlRelaxNGParseStart(ctxt, node);
+        if (old != NULL)
+            ctxt->grammar = old;
+    }
+    ctxt->define = olddefine;
+    if (schema->topgrammar->start != NULL) {
+        xmlRelaxNGCheckCycles(ctxt, schema->topgrammar->start, 0);
+        if ((ctxt->flags & XML_RELAXNG_IN_EXTERNALREF) == 0) {
+            xmlRelaxNGSimplify(ctxt, schema->topgrammar->start, NULL);
+            while ((schema->topgrammar->start != NULL) &&
+                   (schema->topgrammar->start->type == XML_RELAXNG_NOOP) &&
+                   (schema->topgrammar->start->next != NULL))
+                schema->topgrammar->start =
+                    schema->topgrammar->start->content;
+            xmlRelaxNGCheckRules(ctxt, schema->topgrammar->start,
+                                 XML_RELAXNG_IN_START, XML_RELAXNG_NOOP);
+        }
+    }
+#ifdef DEBUG
+    if (schema == NULL)
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlRelaxNGParseDocument() failed\n");
+#endif
+
+    return (schema);
+}
+
+/************************************************************************
+ * 									*
+ * 			Reading RelaxNGs				*
+ * 									*
+ ************************************************************************/
+
+/**
+ * xmlRelaxNGNewParserCtxt:
+ * @URL:  the location of the schema
+ *
+ * Create an XML RelaxNGs parse context for that file/resource expected
+ * to contain an XML RelaxNGs file.
+ *
+ * Returns the parser context or NULL in case of error
+ */
+xmlRelaxNGParserCtxtPtr
+xmlRelaxNGNewParserCtxt(const char *URL)
+{
+    xmlRelaxNGParserCtxtPtr ret;
+
+    if (URL == NULL)
+        return (NULL);
+
+    ret =
+        (xmlRelaxNGParserCtxtPtr) xmlMalloc(sizeof(xmlRelaxNGParserCtxt));
+    if (ret == NULL) {
+        xmlRngPErrMemory(NULL, "building parser\n");
+        return (NULL);
+    }
+    memset(ret, 0, sizeof(xmlRelaxNGParserCtxt));
+    ret->URL = xmlStrdup((const xmlChar *) URL);
+    ret->error = xmlGenericError;
+    ret->userData = xmlGenericErrorContext;
+    return (ret);
+}
+
+/**
+ * xmlRelaxNGNewMemParserCtxt:
+ * @buffer:  a pointer to a char array containing the schemas
+ * @size:  the size of the array
+ *
+ * Create an XML RelaxNGs parse context for that memory buffer expected
+ * to contain an XML RelaxNGs file.
+ *
+ * Returns the parser context or NULL in case of error
+ */
+xmlRelaxNGParserCtxtPtr
+xmlRelaxNGNewMemParserCtxt(const char *buffer, int size)
+{
+    xmlRelaxNGParserCtxtPtr ret;
+
+    if ((buffer == NULL) || (size <= 0))
+        return (NULL);
+
+    ret =
+        (xmlRelaxNGParserCtxtPtr) xmlMalloc(sizeof(xmlRelaxNGParserCtxt));
+    if (ret == NULL) {
+        xmlRngPErrMemory(NULL, "building parser\n");
+        return (NULL);
+    }
+    memset(ret, 0, sizeof(xmlRelaxNGParserCtxt));
+    ret->buffer = buffer;
+    ret->size = size;
+    ret->error = xmlGenericError;
+    ret->userData = xmlGenericErrorContext;
+    return (ret);
+}
+
+/**
+ * xmlRelaxNGNewDocParserCtxt:
+ * @doc:  a preparsed document tree
+ *
+ * Create an XML RelaxNGs parser context for that document.
+ * Note: since the process of compiling a RelaxNG schemas modifies the
+ *       document, the @doc parameter is duplicated internally.
+ *
+ * Returns the parser context or NULL in case of error
+ */
+xmlRelaxNGParserCtxtPtr
+xmlRelaxNGNewDocParserCtxt(xmlDocPtr doc)
+{
+    xmlRelaxNGParserCtxtPtr ret;
+    xmlDocPtr copy;
+
+    if (doc == NULL)
+        return (NULL);
+    copy = xmlCopyDoc(doc, 1);
+    if (copy == NULL)
+        return (NULL);
+
+    ret =
+        (xmlRelaxNGParserCtxtPtr) xmlMalloc(sizeof(xmlRelaxNGParserCtxt));
+    if (ret == NULL) {
+        xmlRngPErrMemory(NULL, "building parser\n");
+        return (NULL);
+    }
+    memset(ret, 0, sizeof(xmlRelaxNGParserCtxt));
+    ret->document = copy;
+    ret->userData = xmlGenericErrorContext;
+    return (ret);
+}
+
+/**
+ * xmlRelaxNGFreeParserCtxt:
+ * @ctxt:  the schema parser context
+ *
+ * Free the resources associated to the schema parser context
+ */
+void
+xmlRelaxNGFreeParserCtxt(xmlRelaxNGParserCtxtPtr ctxt)
+{
+    if (ctxt == NULL)
+        return;
+    if (ctxt->URL != NULL)
+        xmlFree(ctxt->URL);
+    if (ctxt->doc != NULL)
+        xmlRelaxNGFreeDocument(ctxt->doc);
+    if (ctxt->interleaves != NULL)
+        xmlHashFree(ctxt->interleaves, NULL);
+    if (ctxt->documents != NULL)
+        xmlRelaxNGFreeDocumentList(ctxt->documents);
+    if (ctxt->includes != NULL)
+        xmlRelaxNGFreeIncludeList(ctxt->includes);
+    if (ctxt->docTab != NULL)
+        xmlFree(ctxt->docTab);
+    if (ctxt->incTab != NULL)
+        xmlFree(ctxt->incTab);
+    if (ctxt->defTab != NULL) {
+        int i;
+
+        for (i = 0; i < ctxt->defNr; i++)
+            xmlRelaxNGFreeDefine(ctxt->defTab[i]);
+        xmlFree(ctxt->defTab);
+    }
+    xmlFree(ctxt);
+}
+
+/**
+ * xmlRelaxNGNormExtSpace:
+ * @value:  a value
+ *
+ * Removes the leading and ending spaces of the value
+ * The string is modified "in situ"
+ */
+static void
+xmlRelaxNGNormExtSpace(xmlChar * value)
+{
+    xmlChar *start = value;
+    xmlChar *cur = value;
+
+    if (value == NULL)
+        return;
+
+    while (IS_BLANK_CH(*cur))
+        cur++;
+    if (cur == start) {
+        do {
+            while ((*cur != 0) && (!IS_BLANK_CH(*cur)))
+                cur++;
+            if (*cur == 0)
+                return;
+            start = cur;
+            while (IS_BLANK_CH(*cur))
+                cur++;
+            if (*cur == 0) {
+                *start = 0;
+                return;
+            }
+        } while (1);
+    } else {
+        do {
+            while ((*cur != 0) && (!IS_BLANK_CH(*cur)))
+                *start++ = *cur++;
+            if (*cur == 0) {
+                *start = 0;
+                return;
+            }
+            /* don't try to normalize the inner spaces */
+            while (IS_BLANK_CH(*cur))
+                cur++;
+            if (*cur == 0) {
+                *start = 0;
+                return;
+            }
+            *start++ = *cur++;
+        } while (1);
+    }
+}
+
+/**
+ * xmlRelaxNGCheckAttributes:
+ * @ctxt:  a Relax-NG parser context
+ * @node:  a Relax-NG node
+ *
+ * Check all the attributes on the given node
+ */
+static void
+xmlRelaxNGCleanupAttributes(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
+{
+    xmlAttrPtr cur, next;
+
+    cur = node->properties;
+    while (cur != NULL) {
+        next = cur->next;
+        if ((cur->ns == NULL) ||
+            (xmlStrEqual(cur->ns->href, xmlRelaxNGNs))) {
+            if (xmlStrEqual(cur->name, BAD_CAST "name")) {
+                if ((!xmlStrEqual(node->name, BAD_CAST "element")) &&
+                    (!xmlStrEqual(node->name, BAD_CAST "attribute")) &&
+                    (!xmlStrEqual(node->name, BAD_CAST "ref")) &&
+                    (!xmlStrEqual(node->name, BAD_CAST "parentRef")) &&
+                    (!xmlStrEqual(node->name, BAD_CAST "param")) &&
+                    (!xmlStrEqual(node->name, BAD_CAST "define"))) {
+                    xmlRngPErr(ctxt, node, XML_RNGP_FORBIDDEN_ATTRIBUTE,
+                               "Attribute %s is not allowed on %s\n",
+                               cur->name, node->name);
+                }
+            } else if (xmlStrEqual(cur->name, BAD_CAST "type")) {
+                if ((!xmlStrEqual(node->name, BAD_CAST "value")) &&
+                    (!xmlStrEqual(node->name, BAD_CAST "data"))) {
+                    xmlRngPErr(ctxt, node, XML_RNGP_FORBIDDEN_ATTRIBUTE,
+                               "Attribute %s is not allowed on %s\n",
+                               cur->name, node->name);
+                }
+            } else if (xmlStrEqual(cur->name, BAD_CAST "href")) {
+                if ((!xmlStrEqual(node->name, BAD_CAST "externalRef")) &&
+                    (!xmlStrEqual(node->name, BAD_CAST "include"))) {
+                    xmlRngPErr(ctxt, node, XML_RNGP_FORBIDDEN_ATTRIBUTE,
+                               "Attribute %s is not allowed on %s\n",
+                               cur->name, node->name);
+                }
+            } else if (xmlStrEqual(cur->name, BAD_CAST "combine")) {
+                if ((!xmlStrEqual(node->name, BAD_CAST "start")) &&
+                    (!xmlStrEqual(node->name, BAD_CAST "define"))) {
+                    xmlRngPErr(ctxt, node, XML_RNGP_FORBIDDEN_ATTRIBUTE,
+                               "Attribute %s is not allowed on %s\n",
+                               cur->name, node->name);
+                }
+            } else if (xmlStrEqual(cur->name, BAD_CAST "datatypeLibrary")) {
+                xmlChar *val;
+                xmlURIPtr uri;
+
+                val = xmlNodeListGetString(node->doc, cur->children, 1);
+                if (val != NULL) {
+                    if (val[0] != 0) {
+                        uri = xmlParseURI((const char *) val);
+                        if (uri == NULL) {
+                            xmlRngPErr(ctxt, node, XML_RNGP_INVALID_URI,
+                                       "Attribute %s contains invalid URI %s\n",
+                                       cur->name, val);
+                        } else {
+                            if (uri->scheme == NULL) {
+                                xmlRngPErr(ctxt, node, XML_RNGP_URI_NOT_ABSOLUTE,
+                                           "Attribute %s URI %s is not absolute\n",
+                                           cur->name, val);
+                            }
+                            if (uri->fragment != NULL) {
+                                xmlRngPErr(ctxt, node, XML_RNGP_URI_FRAGMENT,
+                                           "Attribute %s URI %s has a fragment ID\n",
+                                           cur->name, val);
+                            }
+                            xmlFreeURI(uri);
+                        }
+                    }
+                    xmlFree(val);
+                }
+            } else if (!xmlStrEqual(cur->name, BAD_CAST "ns")) {
+                xmlRngPErr(ctxt, node, XML_RNGP_UNKNOWN_ATTRIBUTE,
+                           "Unknown attribute %s on %s\n", cur->name,
+                           node->name);
+            }
+        }
+        cur = next;
+    }
+}
+
+/**
+ * xmlRelaxNGCleanupTree:
+ * @ctxt:  a Relax-NG parser context
+ * @root:  an xmlNodePtr subtree
+ *
+ * Cleanup the subtree from unwanted nodes for parsing, resolve
+ * Include and externalRef lookups.
+ */
+static void
+xmlRelaxNGCleanupTree(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr root)
+{
+    xmlNodePtr cur, delete;
+
+    delete = NULL;
+    cur = root;
+    while (cur != NULL) {
+        if (delete != NULL) {
+            xmlUnlinkNode(delete);
+            xmlFreeNode(delete);
+            delete = NULL;
+        }
+        if (cur->type == XML_ELEMENT_NODE) {
+            /*
+             * Simplification 4.1. Annotations
+             */
+            if ((cur->ns == NULL) ||
+                (!xmlStrEqual(cur->ns->href, xmlRelaxNGNs))) {
+                if ((cur->parent != NULL) &&
+                    (cur->parent->type == XML_ELEMENT_NODE) &&
+                    ((xmlStrEqual(cur->parent->name, BAD_CAST "name")) ||
+                     (xmlStrEqual(cur->parent->name, BAD_CAST "value")) ||
+                     (xmlStrEqual(cur->parent->name, BAD_CAST "param")))) {
+                    xmlRngPErr(ctxt, cur, XML_RNGP_FOREIGN_ELEMENT,
+                               "element %s doesn't allow foreign elements\n",
+                               cur->parent->name, NULL);
+                }
+                delete = cur;
+                goto skip_children;
+            } else {
+                xmlRelaxNGCleanupAttributes(ctxt, cur);
+                if (xmlStrEqual(cur->name, BAD_CAST "externalRef")) {
+                    xmlChar *href, *ns, *base, *URL;
+                    xmlRelaxNGDocumentPtr docu;
+                    xmlNodePtr tmp;
+		    xmlURIPtr uri;
+
+                    ns = xmlGetProp(cur, BAD_CAST "ns");
+                    if (ns == NULL) {
+                        tmp = cur->parent;
+                        while ((tmp != NULL) &&
+                               (tmp->type == XML_ELEMENT_NODE)) {
+                            ns = xmlGetProp(tmp, BAD_CAST "ns");
+                            if (ns != NULL)
+                                break;
+                            tmp = tmp->parent;
+                        }
+                    }
+                    href = xmlGetProp(cur, BAD_CAST "href");
+                    if (href == NULL) {
+                        xmlRngPErr(ctxt, cur, XML_RNGP_MISSING_HREF,
+                                   "xmlRelaxNGParse: externalRef has no href attribute\n",
+                                   NULL, NULL);
+                        delete = cur;
+                        goto skip_children;
+                    }
+		    uri = xmlParseURI((const char *) href);
+		    if (uri == NULL) {
+                        xmlRngPErr(ctxt, cur, XML_RNGP_HREF_ERROR,
+                                   "Incorrect URI for externalRef %s\n",
+                                   href, NULL);
+                        if (href != NULL)
+                            xmlFree(href);
+                        delete = cur;
+                        goto skip_children;
+		    }
+		    if (uri->fragment != NULL) {
+                        xmlRngPErr(ctxt, cur, XML_RNGP_HREF_ERROR,
+			       "Fragment forbidden in URI for externalRef %s\n",
+                                   href, NULL);
+		        xmlFreeURI(uri);
+                        if (href != NULL)
+                            xmlFree(href);
+                        delete = cur;
+                        goto skip_children;
+		    }
+		    xmlFreeURI(uri);
+                    base = xmlNodeGetBase(cur->doc, cur);
+                    URL = xmlBuildURI(href, base);
+                    if (URL == NULL) {
+                        xmlRngPErr(ctxt, cur, XML_RNGP_HREF_ERROR,
+                                   "Failed to compute URL for externalRef %s\n",
+                                   href, NULL);
+                        if (href != NULL)
+                            xmlFree(href);
+                        if (base != NULL)
+                            xmlFree(base);
+                        delete = cur;
+                        goto skip_children;
+                    }
+                    if (href != NULL)
+                        xmlFree(href);
+                    if (base != NULL)
+                        xmlFree(base);
+                    docu = xmlRelaxNGLoadExternalRef(ctxt, URL, ns);
+                    if (docu == NULL) {
+                        xmlRngPErr(ctxt, cur, XML_RNGP_EXTERNAL_REF_FAILURE,
+                                   "Failed to load externalRef %s\n", URL,
+                                   NULL);
+                        xmlFree(URL);
+                        delete = cur;
+                        goto skip_children;
+                    }
+                    if (ns != NULL)
+                        xmlFree(ns);
+                    xmlFree(URL);
+                    cur->psvi = docu;
+                } else if (xmlStrEqual(cur->name, BAD_CAST "include")) {
+                    xmlChar *href, *ns, *base, *URL;
+                    xmlRelaxNGIncludePtr incl;
+                    xmlNodePtr tmp;
+
+                    href = xmlGetProp(cur, BAD_CAST "href");
+                    if (href == NULL) {
+                        xmlRngPErr(ctxt, cur, XML_RNGP_MISSING_HREF,
+                                   "xmlRelaxNGParse: include has no href attribute\n",
+                                   NULL, NULL);
+                        delete = cur;
+                        goto skip_children;
+                    }
+                    base = xmlNodeGetBase(cur->doc, cur);
+                    URL = xmlBuildURI(href, base);
+                    if (URL == NULL) {
+                        xmlRngPErr(ctxt, cur, XML_RNGP_HREF_ERROR,
+                                   "Failed to compute URL for include %s\n",
+                                   href, NULL);
+                        if (href != NULL)
+                            xmlFree(href);
+                        if (base != NULL)
+                            xmlFree(base);
+                        delete = cur;
+                        goto skip_children;
+                    }
+                    if (href != NULL)
+                        xmlFree(href);
+                    if (base != NULL)
+                        xmlFree(base);
+                    ns = xmlGetProp(cur, BAD_CAST "ns");
+                    if (ns == NULL) {
+                        tmp = cur->parent;
+                        while ((tmp != NULL) &&
+                               (tmp->type == XML_ELEMENT_NODE)) {
+                            ns = xmlGetProp(tmp, BAD_CAST "ns");
+                            if (ns != NULL)
+                                break;
+                            tmp = tmp->parent;
+                        }
+                    }
+                    incl = xmlRelaxNGLoadInclude(ctxt, URL, cur, ns);
+                    if (ns != NULL)
+                        xmlFree(ns);
+                    if (incl == NULL) {
+                        xmlRngPErr(ctxt, cur, XML_RNGP_INCLUDE_FAILURE,
+                                   "Failed to load include %s\n", URL,
+                                   NULL);
+                        xmlFree(URL);
+                        delete = cur;
+                        goto skip_children;
+                    }
+                    xmlFree(URL);
+                    cur->psvi = incl;
+                } else if ((xmlStrEqual(cur->name, BAD_CAST "element")) ||
+                           (xmlStrEqual(cur->name, BAD_CAST "attribute")))
+                {
+                    xmlChar *name, *ns;
+                    xmlNodePtr text = NULL;
+
+                    /*
+                     * Simplification 4.8. name attribute of element
+                     * and attribute elements
+                     */
+                    name = xmlGetProp(cur, BAD_CAST "name");
+                    if (name != NULL) {
+                        if (cur->children == NULL) {
+                            text =
+                                xmlNewChild(cur, cur->ns, BAD_CAST "name",
+                                            name);
+                        } else {
+                            xmlNodePtr node;
+
+                            node = xmlNewNode(cur->ns, BAD_CAST "name");
+                            if (node != NULL) {
+                                xmlAddPrevSibling(cur->children, node);
+                                text = xmlNewText(name);
+                                xmlAddChild(node, text);
+                                text = node;
+                            }
+                        }
+                        if (text == NULL) {
+                            xmlRngPErr(ctxt, cur, XML_RNGP_CREATE_FAILURE,
+                                       "Failed to create a name %s element\n",
+                                       name, NULL);
+                        }
+                        xmlUnsetProp(cur, BAD_CAST "name");
+                        xmlFree(name);
+                        ns = xmlGetProp(cur, BAD_CAST "ns");
+                        if (ns != NULL) {
+                            if (text != NULL) {
+                                xmlSetProp(text, BAD_CAST "ns", ns);
+                                /* xmlUnsetProp(cur, BAD_CAST "ns"); */
+                            }
+                            xmlFree(ns);
+                        } else if (xmlStrEqual(cur->name,
+                                               BAD_CAST "attribute")) {
+                            xmlSetProp(text, BAD_CAST "ns", BAD_CAST "");
+                        }
+                    }
+                } else if ((xmlStrEqual(cur->name, BAD_CAST "name")) ||
+                           (xmlStrEqual(cur->name, BAD_CAST "nsName")) ||
+                           (xmlStrEqual(cur->name, BAD_CAST "value"))) {
+                    /*
+                     * Simplification 4.8. name attribute of element
+                     * and attribute elements
+                     */
+                    if (xmlHasProp(cur, BAD_CAST "ns") == NULL) {
+                        xmlNodePtr node;
+                        xmlChar *ns = NULL;
+
+                        node = cur->parent;
+                        while ((node != NULL) &&
+                               (node->type == XML_ELEMENT_NODE)) {
+                            ns = xmlGetProp(node, BAD_CAST "ns");
+                            if (ns != NULL) {
+                                break;
+                            }
+                            node = node->parent;
+                        }
+                        if (ns == NULL) {
+                            xmlSetProp(cur, BAD_CAST "ns", BAD_CAST "");
+                        } else {
+                            xmlSetProp(cur, BAD_CAST "ns", ns);
+                            xmlFree(ns);
+                        }
+                    }
+                    if (xmlStrEqual(cur->name, BAD_CAST "name")) {
+                        xmlChar *name, *local, *prefix;
+
+                        /*
+                         * Simplification: 4.10. QNames
+                         */
+                        name = xmlNodeGetContent(cur);
+                        if (name != NULL) {
+                            local = xmlSplitQName2(name, &prefix);
+                            if (local != NULL) {
+                                xmlNsPtr ns;
+
+                                ns = xmlSearchNs(cur->doc, cur, prefix);
+                                if (ns == NULL) {
+                                    xmlRngPErr(ctxt, cur,
+                                               XML_RNGP_PREFIX_UNDEFINED,
+                                               "xmlRelaxNGParse: no namespace for prefix %s\n",
+                                               prefix, NULL);
+                                } else {
+                                    xmlSetProp(cur, BAD_CAST "ns",
+                                               ns->href);
+                                    xmlNodeSetContent(cur, local);
+                                }
+                                xmlFree(local);
+                                xmlFree(prefix);
+                            }
+                            xmlFree(name);
+                        }
+                    }
+                    /*
+                     * 4.16
+                     */
+                    if (xmlStrEqual(cur->name, BAD_CAST "nsName")) {
+                        if (ctxt->flags & XML_RELAXNG_IN_NSEXCEPT) {
+                            xmlRngPErr(ctxt, cur,
+                                       XML_RNGP_PAT_NSNAME_EXCEPT_NSNAME,
+                                       "Found nsName/except//nsName forbidden construct\n",
+                                       NULL, NULL);
+                        }
+                    }
+                } else if ((xmlStrEqual(cur->name, BAD_CAST "except")) &&
+                           (cur != root)) {
+                    int oldflags = ctxt->flags;
+
+                    /*
+                     * 4.16
+                     */
+                    if ((cur->parent != NULL) &&
+                        (xmlStrEqual
+                         (cur->parent->name, BAD_CAST "anyName"))) {
+                        ctxt->flags |= XML_RELAXNG_IN_ANYEXCEPT;
+                        xmlRelaxNGCleanupTree(ctxt, cur);
+                        ctxt->flags = oldflags;
+                        goto skip_children;
+                    } else if ((cur->parent != NULL) &&
+                               (xmlStrEqual
+                                (cur->parent->name, BAD_CAST "nsName"))) {
+                        ctxt->flags |= XML_RELAXNG_IN_NSEXCEPT;
+                        xmlRelaxNGCleanupTree(ctxt, cur);
+                        ctxt->flags = oldflags;
+                        goto skip_children;
+                    }
+                } else if (xmlStrEqual(cur->name, BAD_CAST "anyName")) {
+                    /*
+                     * 4.16
+                     */
+                    if (ctxt->flags & XML_RELAXNG_IN_ANYEXCEPT) {
+                        xmlRngPErr(ctxt, cur,
+                                   XML_RNGP_PAT_ANYNAME_EXCEPT_ANYNAME,
+                                   "Found anyName/except//anyName forbidden construct\n",
+                                   NULL, NULL);
+                    } else if (ctxt->flags & XML_RELAXNG_IN_NSEXCEPT) {
+                        xmlRngPErr(ctxt, cur,
+                                   XML_RNGP_PAT_NSNAME_EXCEPT_ANYNAME,
+                                   "Found nsName/except//anyName forbidden construct\n",
+                                   NULL, NULL);
+                    }
+                }
+                /*
+                 * Thisd is not an else since "include" is transformed
+                 * into a div
+                 */
+                if (xmlStrEqual(cur->name, BAD_CAST "div")) {
+                    xmlChar *ns;
+                    xmlNodePtr child, ins, tmp;
+
+                    /*
+                     * implements rule 4.11
+                     */
+
+                    ns = xmlGetProp(cur, BAD_CAST "ns");
+
+                    child = cur->children;
+                    ins = cur;
+                    while (child != NULL) {
+                        if (ns != NULL) {
+                            if (!xmlHasProp(child, BAD_CAST "ns")) {
+                                xmlSetProp(child, BAD_CAST "ns", ns);
+                            }
+                        }
+                        tmp = child->next;
+                        xmlUnlinkNode(child);
+                        ins = xmlAddNextSibling(ins, child);
+                        child = tmp;
+                    }
+                    if (ns != NULL)
+                        xmlFree(ns);
+                    delete = cur;
+                    goto skip_children;
+                }
+            }
+        }
+        /*
+         * Simplification 4.2 whitespaces
+         */
+        else if ((cur->type == XML_TEXT_NODE) ||
+                 (cur->type == XML_CDATA_SECTION_NODE)) {
+            if (IS_BLANK_NODE(cur)) {
+                if (cur->parent->type == XML_ELEMENT_NODE) {
+                    if ((!xmlStrEqual(cur->parent->name, BAD_CAST "value"))
+                        &&
+                        (!xmlStrEqual
+                         (cur->parent->name, BAD_CAST "param")))
+                        delete = cur;
+                } else {
+                    delete = cur;
+                    goto skip_children;
+                }
+            }
+        } else {
+            delete = cur;
+            goto skip_children;
+        }
+
+        /*
+         * Skip to next node
+         */
+        if (cur->children != NULL) {
+            if ((cur->children->type != XML_ENTITY_DECL) &&
+                (cur->children->type != XML_ENTITY_REF_NODE) &&
+                (cur->children->type != XML_ENTITY_NODE)) {
+                cur = cur->children;
+                continue;
+            }
+        }
+      skip_children:
+        if (cur->next != NULL) {
+            cur = cur->next;
+            continue;
+        }
+
+        do {
+            cur = cur->parent;
+            if (cur == NULL)
+                break;
+            if (cur == root) {
+                cur = NULL;
+                break;
+            }
+            if (cur->next != NULL) {
+                cur = cur->next;
+                break;
+            }
+        } while (cur != NULL);
+    }
+    if (delete != NULL) {
+        xmlUnlinkNode(delete);
+        xmlFreeNode(delete);
+        delete = NULL;
+    }
+}
+
+/**
+ * xmlRelaxNGCleanupDoc:
+ * @ctxt:  a Relax-NG parser context
+ * @doc:  an xmldocPtr document pointer
+ *
+ * Cleanup the document from unwanted nodes for parsing, resolve
+ * Include and externalRef lookups.
+ *
+ * Returns the cleaned up document or NULL in case of error
+ */
+static xmlDocPtr
+xmlRelaxNGCleanupDoc(xmlRelaxNGParserCtxtPtr ctxt, xmlDocPtr doc)
+{
+    xmlNodePtr root;
+
+    /*
+     * Extract the root
+     */
+    root = xmlDocGetRootElement(doc);
+    if (root == NULL) {
+        xmlRngPErr(ctxt, (xmlNodePtr) doc, XML_RNGP_EMPTY, "xmlRelaxNGParse: %s is empty\n",
+                   ctxt->URL, NULL);
+        return (NULL);
+    }
+    xmlRelaxNGCleanupTree(ctxt, root);
+    return (doc);
+}
+
+/**
+ * xmlRelaxNGParse:
+ * @ctxt:  a Relax-NG parser context
+ *
+ * parse a schema definition resource and build an internal
+ * XML Shema struture which can be used to validate instances.
+ * *WARNING* this interface is highly subject to change
+ *
+ * Returns the internal XML RelaxNG structure built from the resource or
+ *         NULL in case of error
+ */
+xmlRelaxNGPtr
+xmlRelaxNGParse(xmlRelaxNGParserCtxtPtr ctxt)
+{
+    xmlRelaxNGPtr ret = NULL;
+    xmlDocPtr doc;
+    xmlNodePtr root;
+
+    xmlRelaxNGInitTypes();
+
+    if (ctxt == NULL)
+        return (NULL);
+
+    /*
+     * First step is to parse the input document into an DOM/Infoset
+     */
+    if (ctxt->URL != NULL) {
+        doc = xmlReadFile((const char *) ctxt->URL,NULL,0);
+        if (doc == NULL) {
+            xmlRngPErr(ctxt, NULL, XML_RNGP_PARSE_ERROR,
+                       "xmlRelaxNGParse: could not load %s\n", ctxt->URL,
+                       NULL);
+            return (NULL);
+        }
+    } else if (ctxt->buffer != NULL) {
+        doc = xmlReadMemory(ctxt->buffer, ctxt->size,NULL,NULL,0);
+        if (doc == NULL) {
+            xmlRngPErr(ctxt, NULL, XML_RNGP_PARSE_ERROR,
+                       "xmlRelaxNGParse: could not parse schemas\n", NULL,
+                       NULL);
+            return (NULL);
+        }
+        doc->URL = xmlStrdup(BAD_CAST "in_memory_buffer");
+        ctxt->URL = xmlStrdup(BAD_CAST "in_memory_buffer");
+    } else if (ctxt->document != NULL) {
+        doc = ctxt->document;
+    } else {
+        xmlRngPErr(ctxt, NULL, XML_RNGP_EMPTY,
+                   "xmlRelaxNGParse: nothing to parse\n", NULL, NULL);
+        return (NULL);
+    }
+    ctxt->document = doc;
+
+    /*
+     * Some preprocessing of the document content
+     */
+    doc = xmlRelaxNGCleanupDoc(ctxt, doc);
+    if (doc == NULL) {
+        xmlFreeDoc(ctxt->document);
+        ctxt->document = NULL;
+        return (NULL);
+    }
+
+    /*
+     * Then do the parsing for good
+     */
+    root = xmlDocGetRootElement(doc);
+    if (root == NULL) {
+        xmlRngPErr(ctxt, (xmlNodePtr) doc,
+	           XML_RNGP_EMPTY, "xmlRelaxNGParse: %s is empty\n",
+                   ctxt->URL, NULL);
+        xmlFreeDoc(doc);
+        return (NULL);
+    }
+    ret = xmlRelaxNGParseDocument(ctxt, root);
+    if (ret == NULL) {
+        xmlFreeDoc(doc);
+        return (NULL);
+    }
+
+    /*
+     * Check the ref/defines links
+     */
+    /*
+     * try to preprocess interleaves
+     */
+    if (ctxt->interleaves != NULL) {
+        xmlHashScan(ctxt->interleaves,
+                    (xmlHashScanner) xmlRelaxNGComputeInterleaves, ctxt);
+    }
+
+    /*
+     * if there was a parsing error return NULL
+     */
+    if (ctxt->nbErrors > 0) {
+        xmlRelaxNGFree(ret);
+        ctxt->document = NULL;
+        xmlFreeDoc(doc);
+        return (NULL);
+    }
+
+    /*
+     * try to compile (parts of) the schemas
+     */
+    if ((ret->topgrammar != NULL) && (ret->topgrammar->start != NULL)) {
+        if (ret->topgrammar->start->type != XML_RELAXNG_START) {
+            xmlRelaxNGDefinePtr def;
+
+            def = xmlRelaxNGNewDefine(ctxt, NULL);
+            if (def != NULL) {
+                def->type = XML_RELAXNG_START;
+                def->content = ret->topgrammar->start;
+                ret->topgrammar->start = def;
+            }
+        }
+        xmlRelaxNGTryCompile(ctxt, ret->topgrammar->start);
+    }
+
+    /*
+     * Transfer the pointer for cleanup at the schema level.
+     */
+    ret->doc = doc;
+    ctxt->document = NULL;
+    ret->documents = ctxt->documents;
+    ctxt->documents = NULL;
+
+    ret->includes = ctxt->includes;
+    ctxt->includes = NULL;
+    ret->defNr = ctxt->defNr;
+    ret->defTab = ctxt->defTab;
+    ctxt->defTab = NULL;
+    if (ctxt->idref == 1)
+        ret->idref = 1;
+
+    return (ret);
+}
+
+/**
+ * xmlRelaxNGSetParserErrors:
+ * @ctxt:  a Relax-NG validation context
+ * @err:  the error callback
+ * @warn:  the warning callback
+ * @ctx:  contextual data for the callbacks
+ *
+ * Set the callback functions used to handle errors for a validation context
+ */
+void
+xmlRelaxNGSetParserErrors(xmlRelaxNGParserCtxtPtr ctxt,
+                          xmlRelaxNGValidityErrorFunc err,
+                          xmlRelaxNGValidityWarningFunc warn, void *ctx)
+{
+    if (ctxt == NULL)
+        return;
+    ctxt->error = err;
+    ctxt->warning = warn;
+    ctxt->userData = ctx;
+}
+
+/**
+ * xmlRelaxNGGetParserErrors:
+ * @ctxt:  a Relax-NG validation context
+ * @err:  the error callback result
+ * @warn:  the warning callback result
+ * @ctx:  contextual data for the callbacks result
+ *
+ * Get the callback information used to handle errors for a validation context
+ *
+ * Returns -1 in case of failure, 0 otherwise.
+ */
+int
+xmlRelaxNGGetParserErrors(xmlRelaxNGParserCtxtPtr ctxt,
+                          xmlRelaxNGValidityErrorFunc * err,
+                          xmlRelaxNGValidityWarningFunc * warn, void **ctx)
+{
+    if (ctxt == NULL)
+        return (-1);
+    if (err != NULL)
+        *err = ctxt->error;
+    if (warn != NULL)
+        *warn = ctxt->warning;
+    if (ctx != NULL)
+        *ctx = ctxt->userData;
+    return (0);
+}
+
+#ifdef LIBXML_OUTPUT_ENABLED
+
+/************************************************************************
+ * 									*
+ * 			Dump back a compiled form			*
+ * 									*
+ ************************************************************************/
+static void xmlRelaxNGDumpDefine(FILE * output,
+                                 xmlRelaxNGDefinePtr define);
+
+/**
+ * xmlRelaxNGDumpDefines:
+ * @output:  the file output
+ * @defines:  a list of define structures
+ *
+ * Dump a RelaxNG structure back
+ */
+static void
+xmlRelaxNGDumpDefines(FILE * output, xmlRelaxNGDefinePtr defines)
+{
+    while (defines != NULL) {
+        xmlRelaxNGDumpDefine(output, defines);
+        defines = defines->next;
+    }
+}
+
+/**
+ * xmlRelaxNGDumpDefine:
+ * @output:  the file output
+ * @define:  a define structure
+ *
+ * Dump a RelaxNG structure back
+ */
+static void
+xmlRelaxNGDumpDefine(FILE * output, xmlRelaxNGDefinePtr define)
+{
+    if (define == NULL)
+        return;
+    switch (define->type) {
+        case XML_RELAXNG_EMPTY:
+            fprintf(output, "<empty/>\n");
+            break;
+        case XML_RELAXNG_NOT_ALLOWED:
+            fprintf(output, "<notAllowed/>\n");
+            break;
+        case XML_RELAXNG_TEXT:
+            fprintf(output, "<text/>\n");
+            break;
+        case XML_RELAXNG_ELEMENT:
+            fprintf(output, "<element>\n");
+            if (define->name != NULL) {
+                fprintf(output, "<name");
+                if (define->ns != NULL)
+                    fprintf(output, " ns=\"%s\"", define->ns);
+                fprintf(output, ">%s</name>\n", define->name);
+            }
+            xmlRelaxNGDumpDefines(output, define->attrs);
+            xmlRelaxNGDumpDefines(output, define->content);
+            fprintf(output, "</element>\n");
+            break;
+        case XML_RELAXNG_LIST:
+            fprintf(output, "<list>\n");
+            xmlRelaxNGDumpDefines(output, define->content);
+            fprintf(output, "</list>\n");
+            break;
+        case XML_RELAXNG_ONEORMORE:
+            fprintf(output, "<oneOrMore>\n");
+            xmlRelaxNGDumpDefines(output, define->content);
+            fprintf(output, "</oneOrMore>\n");
+            break;
+        case XML_RELAXNG_ZEROORMORE:
+            fprintf(output, "<zeroOrMore>\n");
+            xmlRelaxNGDumpDefines(output, define->content);
+            fprintf(output, "</zeroOrMore>\n");
+            break;
+        case XML_RELAXNG_CHOICE:
+            fprintf(output, "<choice>\n");
+            xmlRelaxNGDumpDefines(output, define->content);
+            fprintf(output, "</choice>\n");
+            break;
+        case XML_RELAXNG_GROUP:
+            fprintf(output, "<group>\n");
+            xmlRelaxNGDumpDefines(output, define->content);
+            fprintf(output, "</group>\n");
+            break;
+        case XML_RELAXNG_INTERLEAVE:
+            fprintf(output, "<interleave>\n");
+            xmlRelaxNGDumpDefines(output, define->content);
+            fprintf(output, "</interleave>\n");
+            break;
+        case XML_RELAXNG_OPTIONAL:
+            fprintf(output, "<optional>\n");
+            xmlRelaxNGDumpDefines(output, define->content);
+            fprintf(output, "</optional>\n");
+            break;
+        case XML_RELAXNG_ATTRIBUTE:
+            fprintf(output, "<attribute>\n");
+            xmlRelaxNGDumpDefines(output, define->content);
+            fprintf(output, "</attribute>\n");
+            break;
+        case XML_RELAXNG_DEF:
+            fprintf(output, "<define");
+            if (define->name != NULL)
+                fprintf(output, " name=\"%s\"", define->name);
+            fprintf(output, ">\n");
+            xmlRelaxNGDumpDefines(output, define->content);
+            fprintf(output, "</define>\n");
+            break;
+        case XML_RELAXNG_REF:
+            fprintf(output, "<ref");
+            if (define->name != NULL)
+                fprintf(output, " name=\"%s\"", define->name);
+            fprintf(output, ">\n");
+            xmlRelaxNGDumpDefines(output, define->content);
+            fprintf(output, "</ref>\n");
+            break;
+        case XML_RELAXNG_PARENTREF:
+            fprintf(output, "<parentRef");
+            if (define->name != NULL)
+                fprintf(output, " name=\"%s\"", define->name);
+            fprintf(output, ">\n");
+            xmlRelaxNGDumpDefines(output, define->content);
+            fprintf(output, "</parentRef>\n");
+            break;
+        case XML_RELAXNG_EXTERNALREF:
+            fprintf(output, "<externalRef>");
+            xmlRelaxNGDumpDefines(output, define->content);
+            fprintf(output, "</externalRef>\n");
+            break;
+        case XML_RELAXNG_DATATYPE:
+        case XML_RELAXNG_VALUE:
+            TODO break;
+        case XML_RELAXNG_START:
+        case XML_RELAXNG_EXCEPT:
+        case XML_RELAXNG_PARAM:
+            TODO break;
+        case XML_RELAXNG_NOOP:
+            xmlRelaxNGDumpDefines(output, define->content);
+            break;
+    }
+}
+
+/**
+ * xmlRelaxNGDumpGrammar:
+ * @output:  the file output
+ * @grammar:  a grammar structure
+ * @top:  is this a top grammar 
+ *
+ * Dump a RelaxNG structure back
+ */
+static void
+xmlRelaxNGDumpGrammar(FILE * output, xmlRelaxNGGrammarPtr grammar, int top)
+{
+    if (grammar == NULL)
+        return;
+
+    fprintf(output, "<grammar");
+    if (top)
+        fprintf(output, " xmlns=\"http://relaxng.org/ns/structure/1.0\"");
+    switch (grammar->combine) {
+        case XML_RELAXNG_COMBINE_UNDEFINED:
+            break;
+        case XML_RELAXNG_COMBINE_CHOICE:
+            fprintf(output, " combine=\"choice\"");
+            break;
+        case XML_RELAXNG_COMBINE_INTERLEAVE:
+            fprintf(output, " combine=\"interleave\"");
+            break;
+        default:
+            fprintf(output, " <!-- invalid combine value -->");
+    }
+    fprintf(output, ">\n");
+    if (grammar->start == NULL) {
+        fprintf(output, " <!-- grammar had no start -->");
+    } else {
+        fprintf(output, "<start>\n");
+        xmlRelaxNGDumpDefine(output, grammar->start);
+        fprintf(output, "</start>\n");
+    }
+    /* TODO ? Dump the defines ? */
+    fprintf(output, "</grammar>\n");
+}
+
+/**
+ * xmlRelaxNGDump:
+ * @output:  the file output
+ * @schema:  a schema structure
+ *
+ * Dump a RelaxNG structure back
+ */
+void
+xmlRelaxNGDump(FILE * output, xmlRelaxNGPtr schema)
+{
+    if (schema == NULL) {
+        fprintf(output, "RelaxNG empty or failed to compile\n");
+        return;
+    }
+    fprintf(output, "RelaxNG: ");
+    if (schema->doc == NULL) {
+        fprintf(output, "no document\n");
+    } else if (schema->doc->URL != NULL) {
+        fprintf(output, "%s\n", schema->doc->URL);
+    } else {
+        fprintf(output, "\n");
+    }
+    if (schema->topgrammar == NULL) {
+        fprintf(output, "RelaxNG has no top grammar\n");
+        return;
+    }
+    xmlRelaxNGDumpGrammar(output, schema->topgrammar, 1);
+}
+
+/**
+ * xmlRelaxNGDumpTree:
+ * @output:  the file output
+ * @schema:  a schema structure
+ *
+ * Dump the transformed RelaxNG tree.
+ */
+void
+xmlRelaxNGDumpTree(FILE * output, xmlRelaxNGPtr schema)
+{
+    if (schema == NULL) {
+        fprintf(output, "RelaxNG empty or failed to compile\n");
+        return;
+    }
+    if (schema->doc == NULL) {
+        fprintf(output, "no document\n");
+    } else {
+        xmlDocDump(output, schema->doc);
+    }
+}
+#endif /* LIBXML_OUTPUT_ENABLED */
+
+/************************************************************************
+ * 									*
+ * 		Validation of compiled content				*
+ * 									*
+ ************************************************************************/
+static int xmlRelaxNGValidateDefinition(xmlRelaxNGValidCtxtPtr ctxt,
+                                        xmlRelaxNGDefinePtr define);
+
+/**
+ * xmlRelaxNGValidateCompiledCallback:
+ * @exec:  the regular expression instance
+ * @token:  the token which matched
+ * @transdata:  callback data, the define for the subelement if available
+ @ @inputdata:  callback data, the Relax NG validation context
+ *
+ * Handle the callback and if needed validate the element children.
+ */
+static void
+xmlRelaxNGValidateCompiledCallback(xmlRegExecCtxtPtr exec ATTRIBUTE_UNUSED,
+                                   const xmlChar * token,
+                                   void *transdata, void *inputdata)
+{
+    xmlRelaxNGValidCtxtPtr ctxt = (xmlRelaxNGValidCtxtPtr) inputdata;
+    xmlRelaxNGDefinePtr define = (xmlRelaxNGDefinePtr) transdata;
+    int ret;
+
+#ifdef DEBUG_COMPILE
+    xmlGenericError(xmlGenericErrorContext,
+                    "Compiled callback for: '%s'\n", token);
+#endif
+    if (ctxt == NULL) {
+        fprintf(stderr, "callback on %s missing context\n", token);
+        if ((ctxt != NULL) && (ctxt->errNo == XML_RELAXNG_OK))
+            ctxt->errNo = XML_RELAXNG_ERR_INTERNAL;
+        return;
+    }
+    if (define == NULL) {
+        if (token[0] == '#')
+            return;
+        fprintf(stderr, "callback on %s missing define\n", token);
+        if ((ctxt != NULL) && (ctxt->errNo == XML_RELAXNG_OK))
+            ctxt->errNo = XML_RELAXNG_ERR_INTERNAL;
+        return;
+    }
+    if ((ctxt == NULL) || (define == NULL)) {
+        fprintf(stderr, "callback on %s missing info\n", token);
+        if ((ctxt != NULL) && (ctxt->errNo == XML_RELAXNG_OK))
+            ctxt->errNo = XML_RELAXNG_ERR_INTERNAL;
+        return;
+    } else if (define->type != XML_RELAXNG_ELEMENT) {
+        fprintf(stderr, "callback on %s define is not element\n", token);
+        if (ctxt->errNo == XML_RELAXNG_OK)
+            ctxt->errNo = XML_RELAXNG_ERR_INTERNAL;
+        return;
+    }
+    ret = xmlRelaxNGValidateDefinition(ctxt, define);
+    if (ret != 0)
+        ctxt->perr = ret;
+}
+
+/**
+ * xmlRelaxNGValidateCompiledContent:
+ * @ctxt:  the RelaxNG validation context
+ * @regexp:  the regular expression as compiled
+ * @content:  list of children to test against the regexp
+ *
+ * Validate the content model of an element or start using the regexp
+ *
+ * Returns 0 in case of success, -1 in case of error.
+ */
+static int
+xmlRelaxNGValidateCompiledContent(xmlRelaxNGValidCtxtPtr ctxt,
+                                  xmlRegexpPtr regexp, xmlNodePtr content)
+{
+    xmlRegExecCtxtPtr exec;
+    xmlNodePtr cur;
+    int ret = 0;
+    int oldperr = ctxt->perr;
+
+    if ((ctxt == NULL) || (regexp == NULL))
+        return (-1);
+    exec = xmlRegNewExecCtxt(regexp,
+                             xmlRelaxNGValidateCompiledCallback, ctxt);
+    ctxt->perr = 0;
+    cur = content;
+    while (cur != NULL) {
+        ctxt->state->seq = cur;
+        switch (cur->type) {
+            case XML_TEXT_NODE:
+            case XML_CDATA_SECTION_NODE:
+                if (xmlIsBlankNode(cur))
+                    break;
+                ret = xmlRegExecPushString(exec, BAD_CAST "#text", ctxt);
+                if (ret < 0) {
+                    VALID_ERR2(XML_RELAXNG_ERR_TEXTWRONG,
+                               cur->parent->name);
+                }
+                break;
+            case XML_ELEMENT_NODE:
+                if (cur->ns != NULL) {
+                    ret = xmlRegExecPushString2(exec, cur->name,
+                                                cur->ns->href, ctxt);
+                } else {
+                    ret = xmlRegExecPushString(exec, cur->name, ctxt);
+                }
+                if (ret < 0) {
+                    VALID_ERR2(XML_RELAXNG_ERR_ELEMWRONG, cur->name);
+                }
+                break;
+            default:
+                break;
+        }
+        if (ret < 0)
+            break;
+        /*
+         * Switch to next element
+         */
+        cur = cur->next;
+    }
+    ret = xmlRegExecPushString(exec, NULL, NULL);
+    if (ret == 1) {
+        ret = 0;
+        ctxt->state->seq = NULL;
+    } else if (ret == 0) {
+        /*
+         * TODO: get some of the names needed to exit the current state of exec
+         */
+        VALID_ERR2(XML_RELAXNG_ERR_NOELEM, BAD_CAST "");
+        ret = -1;
+        if ((ctxt->flags & FLAGS_IGNORABLE) == 0)
+            xmlRelaxNGDumpValidError(ctxt);
+    } else {
+        ret = -1;
+    }
+    xmlRegFreeExecCtxt(exec);
+    /*
+     * There might be content model errors outside of the pure
+     * regexp validation, e.g. for attribute values.
+     */
+    if ((ret == 0) && (ctxt->perr != 0)) {
+        ret = ctxt->perr;
+    }
+    ctxt->perr = oldperr;
+    return (ret);
+}
+
+/************************************************************************
+ * 									*
+ * 		Progressive validation of when possible			*
+ * 									*
+ ************************************************************************/
+static int xmlRelaxNGValidateAttributeList(xmlRelaxNGValidCtxtPtr ctxt,
+                                           xmlRelaxNGDefinePtr defines);
+static int xmlRelaxNGValidateElementEnd(xmlRelaxNGValidCtxtPtr ctxt,
+                                        int dolog);
+static void xmlRelaxNGLogBestError(xmlRelaxNGValidCtxtPtr ctxt);
+
+/**
+ * xmlRelaxNGElemPush:
+ * @ctxt:  the validation context
+ * @exec:  the regexp runtime for the new content model
+ *
+ * Push a new regexp for the current node content model on the stack
+ *
+ * Returns 0 in case of success and -1 in case of error.
+ */
+static int
+xmlRelaxNGElemPush(xmlRelaxNGValidCtxtPtr ctxt, xmlRegExecCtxtPtr exec)
+{
+    if (ctxt->elemTab == NULL) {
+        ctxt->elemMax = 10;
+        ctxt->elemTab = (xmlRegExecCtxtPtr *) xmlMalloc(ctxt->elemMax *
+                                                        sizeof
+                                                        (xmlRegExecCtxtPtr));
+        if (ctxt->elemTab == NULL) {
+            xmlRngVErrMemory(ctxt, "validating\n");
+            return (-1);
+        }
+    }
+    if (ctxt->elemNr >= ctxt->elemMax) {
+        ctxt->elemMax *= 2;
+        ctxt->elemTab = (xmlRegExecCtxtPtr *) xmlRealloc(ctxt->elemTab,
+                                                         ctxt->elemMax *
+                                                         sizeof
+                                                         (xmlRegExecCtxtPtr));
+        if (ctxt->elemTab == NULL) {
+            xmlRngVErrMemory(ctxt, "validating\n");
+            return (-1);
+        }
+    }
+    ctxt->elemTab[ctxt->elemNr++] = exec;
+    ctxt->elem = exec;
+    return (0);
+}
+
+/**
+ * xmlRelaxNGElemPop:
+ * @ctxt:  the validation context
+ *
+ * Pop the regexp of the current node content model from the stack
+ *
+ * Returns the exec or NULL if empty
+ */
+static xmlRegExecCtxtPtr
+xmlRelaxNGElemPop(xmlRelaxNGValidCtxtPtr ctxt)
+{
+    xmlRegExecCtxtPtr ret;
+
+    if (ctxt->elemNr <= 0)
+        return (NULL);
+    ctxt->elemNr--;
+    ret = ctxt->elemTab[ctxt->elemNr];
+    ctxt->elemTab[ctxt->elemNr] = NULL;
+    if (ctxt->elemNr > 0)
+        ctxt->elem = ctxt->elemTab[ctxt->elemNr - 1];
+    else
+        ctxt->elem = NULL;
+    return (ret);
+}
+
+/**
+ * xmlRelaxNGValidateProgressiveCallback:
+ * @exec:  the regular expression instance
+ * @token:  the token which matched
+ * @transdata:  callback data, the define for the subelement if available
+ @ @inputdata:  callback data, the Relax NG validation context
+ *
+ * Handle the callback and if needed validate the element children.
+ * some of the in/out informations are passed via the context in @inputdata.
+ */
+static void
+xmlRelaxNGValidateProgressiveCallback(xmlRegExecCtxtPtr exec
+                                      ATTRIBUTE_UNUSED,
+                                      const xmlChar * token,
+                                      void *transdata, void *inputdata)
+{
+    xmlRelaxNGValidCtxtPtr ctxt = (xmlRelaxNGValidCtxtPtr) inputdata;
+    xmlRelaxNGDefinePtr define = (xmlRelaxNGDefinePtr) transdata;
+    xmlRelaxNGValidStatePtr state, oldstate;
+    xmlNodePtr node = ctxt->pnode;
+    int ret = 0, oldflags;
+
+#ifdef DEBUG_PROGRESSIVE
+    xmlGenericError(xmlGenericErrorContext,
+                    "Progressive callback for: '%s'\n", token);
+#endif
+    if (ctxt == NULL) {
+        fprintf(stderr, "callback on %s missing context\n", token);
+        return;
+    }
+    ctxt->pstate = 1;
+    if (define == NULL) {
+        if (token[0] == '#')
+            return;
+        fprintf(stderr, "callback on %s missing define\n", token);
+        if ((ctxt != NULL) && (ctxt->errNo == XML_RELAXNG_OK))
+            ctxt->errNo = XML_RELAXNG_ERR_INTERNAL;
+        ctxt->pstate = -1;
+        return;
+    }
+    if ((ctxt == NULL) || (define == NULL)) {
+        fprintf(stderr, "callback on %s missing info\n", token);
+        if ((ctxt != NULL) && (ctxt->errNo == XML_RELAXNG_OK))
+            ctxt->errNo = XML_RELAXNG_ERR_INTERNAL;
+        ctxt->pstate = -1;
+        return;
+    } else if (define->type != XML_RELAXNG_ELEMENT) {
+        fprintf(stderr, "callback on %s define is not element\n", token);
+        if (ctxt->errNo == XML_RELAXNG_OK)
+            ctxt->errNo = XML_RELAXNG_ERR_INTERNAL;
+        ctxt->pstate = -1;
+        return;
+    }
+    if (node->type != XML_ELEMENT_NODE) {
+        VALID_ERR(XML_RELAXNG_ERR_NOTELEM);
+        if ((ctxt->flags & FLAGS_IGNORABLE) == 0)
+            xmlRelaxNGDumpValidError(ctxt);
+        ctxt->pstate = -1;
+        return;
+    }
+    if (define->contModel == NULL) {
+        /*
+         * this node cannot be validated in a streamable fashion
+         */
+#ifdef DEBUG_PROGRESSIVE
+        xmlGenericError(xmlGenericErrorContext,
+                        "Element '%s' validation is not streamable\n",
+                        token);
+#endif
+        ctxt->pstate = 0;
+        ctxt->pdef = define;
+        return;
+    }
+    exec = xmlRegNewExecCtxt(define->contModel,
+                             xmlRelaxNGValidateProgressiveCallback, ctxt);
+    if (exec == NULL) {
+        ctxt->pstate = -1;
+        return;
+    }
+    xmlRelaxNGElemPush(ctxt, exec);
+
+    /*
+     * Validate the attributes part of the content.
+     */
+    state = xmlRelaxNGNewValidState(ctxt, node);
+    if (state == NULL) {
+        ctxt->pstate = -1;
+        return;
+    }
+    oldstate = ctxt->state;
+    ctxt->state = state;
+    if (define->attrs != NULL) {
+        ret = xmlRelaxNGValidateAttributeList(ctxt, define->attrs);
+        if (ret != 0) {
+            ctxt->pstate = -1;
+            VALID_ERR2(XML_RELAXNG_ERR_ATTRVALID, node->name);
+        }
+    }
+    if (ctxt->state != NULL) {
+        ctxt->state->seq = NULL;
+        ret = xmlRelaxNGValidateElementEnd(ctxt, 1);
+        if (ret != 0) {
+            ctxt->pstate = -1;
+        }
+        xmlRelaxNGFreeValidState(ctxt, ctxt->state);
+    } else if (ctxt->states != NULL) {
+        int tmp = -1, i;
+
+        oldflags = ctxt->flags;
+
+        for (i = 0; i < ctxt->states->nbState; i++) {
+            state = ctxt->states->tabState[i];
+            ctxt->state = state;
+            ctxt->state->seq = NULL;
+
+            if (xmlRelaxNGValidateElementEnd(ctxt, 0) == 0) {
+                tmp = 0;
+                break;
+            }
+        }
+        if (tmp != 0) {
+            /*
+             * validation error, log the message for the "best" one
+             */
+            ctxt->flags |= FLAGS_IGNORABLE;
+            xmlRelaxNGLogBestError(ctxt);
+        }
+        for (i = 0; i < ctxt->states->nbState; i++) {
+            xmlRelaxNGFreeValidState(ctxt, ctxt->states->tabState[i]);
+        }
+        xmlRelaxNGFreeStates(ctxt, ctxt->states);
+        ctxt->states = NULL;
+        if ((ret == 0) && (tmp == -1))
+            ctxt->pstate = -1;
+        ctxt->flags = oldflags;
+    }
+    if (ctxt->pstate == -1) {
+        if ((ctxt->flags & FLAGS_IGNORABLE) == 0) {
+            xmlRelaxNGDumpValidError(ctxt);
+        }
+    }
+    ctxt->state = oldstate;
+}
+
+/**
+ * xmlRelaxNGValidatePushElement:
+ * @ctxt:  the validation context
+ * @doc:  a document instance
+ * @elem:  an element instance
+ *
+ * Push a new element start on the RelaxNG validation stack.
+ *
+ * returns 1 if no validation problem was found or 0 if validating the
+ *         element requires a full node, and -1 in case of error.
+ */
+int
+xmlRelaxNGValidatePushElement(xmlRelaxNGValidCtxtPtr ctxt,
+                              xmlDocPtr doc ATTRIBUTE_UNUSED,
+                              xmlNodePtr elem)
+{
+    int ret = 1;
+
+    if ((ctxt == NULL) || (elem == NULL))
+        return (-1);
+
+#ifdef DEBUG_PROGRESSIVE
+    xmlGenericError(xmlGenericErrorContext, "PushElem %s\n", elem->name);
+#endif
+    if (ctxt->elem == 0) {
+        xmlRelaxNGPtr schema;
+        xmlRelaxNGGrammarPtr grammar;
+        xmlRegExecCtxtPtr exec;
+        xmlRelaxNGDefinePtr define;
+
+        schema = ctxt->schema;
+        if (schema == NULL) {
+            VALID_ERR(XML_RELAXNG_ERR_NOGRAMMAR);
+            return (-1);
+        }
+        grammar = schema->topgrammar;
+        if ((grammar == NULL) || (grammar->start == NULL)) {
+            VALID_ERR(XML_RELAXNG_ERR_NOGRAMMAR);
+            return (-1);
+        }
+        define = grammar->start;
+        if (define->contModel == NULL) {
+            ctxt->pdef = define;
+            return (0);
+        }
+        exec = xmlRegNewExecCtxt(define->contModel,
+                                 xmlRelaxNGValidateProgressiveCallback,
+                                 ctxt);
+        if (exec == NULL) {
+            return (-1);
+        }
+        xmlRelaxNGElemPush(ctxt, exec);
+    }
+    ctxt->pnode = elem;
+    ctxt->pstate = 0;
+    if (elem->ns != NULL) {
+        ret =
+            xmlRegExecPushString2(ctxt->elem, elem->name, elem->ns->href,
+                                  ctxt);
+    } else {
+        ret = xmlRegExecPushString(ctxt->elem, elem->name, ctxt);
+    }
+    if (ret < 0) {
+        VALID_ERR2(XML_RELAXNG_ERR_ELEMWRONG, elem->name);
+    } else {
+        if (ctxt->pstate == 0)
+            ret = 0;
+        else if (ctxt->pstate < 0)
+            ret = -1;
+        else
+            ret = 1;
+    }
+#ifdef DEBUG_PROGRESSIVE
+    if (ret < 0)
+        xmlGenericError(xmlGenericErrorContext, "PushElem %s failed\n",
+                        elem->name);
+#endif
+    return (ret);
+}
+
+/**
+ * xmlRelaxNGValidatePushCData:
+ * @ctxt:  the RelaxNG validation context
+ * @data:  some character data read
+ * @len:  the lenght of the data
+ *
+ * check the CData parsed for validation in the current stack
+ *
+ * returns 1 if no validation problem was found or -1 otherwise
+ */
+int
+xmlRelaxNGValidatePushCData(xmlRelaxNGValidCtxtPtr ctxt,
+                            const xmlChar * data, int len ATTRIBUTE_UNUSED)
+{
+    int ret = 1;
+
+    if ((ctxt == NULL) || (ctxt->elem == NULL) || (data == NULL))
+        return (-1);
+
+#ifdef DEBUG_PROGRESSIVE
+    xmlGenericError(xmlGenericErrorContext, "CDATA %s %d\n", data, len);
+#endif
+
+    while (*data != 0) {
+        if (!IS_BLANK_CH(*data))
+            break;
+        data++;
+    }
+    if (*data == 0)
+        return (1);
+
+    ret = xmlRegExecPushString(ctxt->elem, BAD_CAST "#text", ctxt);
+    if (ret < 0) {
+        VALID_ERR2(XML_RELAXNG_ERR_TEXTWRONG, BAD_CAST " TODO ");
+#ifdef DEBUG_PROGRESSIVE
+        xmlGenericError(xmlGenericErrorContext, "CDATA failed\n");
+#endif
+
+        return (-1);
+    }
+    return (1);
+}
+
+/**
+ * xmlRelaxNGValidatePopElement:
+ * @ctxt:  the RelaxNG validation context
+ * @doc:  a document instance
+ * @elem:  an element instance
+ *
+ * Pop the element end from the RelaxNG validation stack.
+ *
+ * returns 1 if no validation problem was found or 0 otherwise
+ */
+int
+xmlRelaxNGValidatePopElement(xmlRelaxNGValidCtxtPtr ctxt,
+                             xmlDocPtr doc ATTRIBUTE_UNUSED,
+                             xmlNodePtr elem)
+{
+    int ret;
+    xmlRegExecCtxtPtr exec;
+
+    if ((ctxt == NULL) || (ctxt->elem == NULL) || (elem == NULL))
+        return (-1);
+#ifdef DEBUG_PROGRESSIVE
+    xmlGenericError(xmlGenericErrorContext, "PopElem %s\n", elem->name);
+#endif
+    /*
+     * verify that we reached a terminal state of the content model.
+     */
+    exec = xmlRelaxNGElemPop(ctxt);
+    ret = xmlRegExecPushString(exec, NULL, NULL);
+    if (ret == 0) {
+        /*
+         * TODO: get some of the names needed to exit the current state of exec
+         */
+        VALID_ERR2(XML_RELAXNG_ERR_NOELEM, BAD_CAST "");
+        ret = -1;
+    } else if (ret < 0) {
+        ret = -1;
+    } else {
+        ret = 1;
+    }
+    xmlRegFreeExecCtxt(exec);
+#ifdef DEBUG_PROGRESSIVE
+    if (ret < 0)
+        xmlGenericError(xmlGenericErrorContext, "PopElem %s failed\n",
+                        elem->name);
+#endif
+    return (ret);
+}
+
+/**
+ * xmlRelaxNGValidateFullElement:
+ * @ctxt:  the validation context
+ * @doc:  a document instance
+ * @elem:  an element instance
+ *
+ * Validate a full subtree when xmlRelaxNGValidatePushElement() returned
+ * 0 and the content of the node has been expanded.
+ *
+ * returns 1 if no validation problem was found or -1 in case of error.
+ */
+int
+xmlRelaxNGValidateFullElement(xmlRelaxNGValidCtxtPtr ctxt,
+                              xmlDocPtr doc ATTRIBUTE_UNUSED,
+                              xmlNodePtr elem)
+{
+    int ret;
+    xmlRelaxNGValidStatePtr state;
+
+    if ((ctxt == NULL) || (ctxt->pdef == NULL) || (elem == NULL))
+        return (-1);
+#ifdef DEBUG_PROGRESSIVE
+    xmlGenericError(xmlGenericErrorContext, "FullElem %s\n", elem->name);
+#endif
+    state = xmlRelaxNGNewValidState(ctxt, elem->parent);
+    if (state == NULL) {
+        return (-1);
+    }
+    state->seq = elem;
+    ctxt->state = state;
+    ctxt->errNo = XML_RELAXNG_OK;
+    ret = xmlRelaxNGValidateDefinition(ctxt, ctxt->pdef);
+    if ((ret != 0) || (ctxt->errNo != XML_RELAXNG_OK))
+        ret = -1;
+    else
+        ret = 1;
+    xmlRelaxNGFreeValidState(ctxt, state);
+    ctxt->state = NULL;
+#ifdef DEBUG_PROGRESSIVE
+    if (ret < 0)
+        xmlGenericError(xmlGenericErrorContext, "FullElem %s failed\n",
+                        elem->name);
+#endif
+    return (ret);
+}
+
+/************************************************************************
+ * 									*
+ * 		Generic interpreted validation implementation		*
+ * 									*
+ ************************************************************************/
+static int xmlRelaxNGValidateValue(xmlRelaxNGValidCtxtPtr ctxt,
+                                   xmlRelaxNGDefinePtr define);
+
+/**
+ * xmlRelaxNGSkipIgnored:
+ * @ctxt:  a schema validation context
+ * @node:  the top node.
+ *
+ * Skip ignorable nodes in that context
+ *
+ * Returns the new sibling or NULL in case of error.
+ */
+static xmlNodePtr
+xmlRelaxNGSkipIgnored(xmlRelaxNGValidCtxtPtr ctxt ATTRIBUTE_UNUSED,
+                      xmlNodePtr node)
+{
+    /*
+     * TODO complete and handle entities
+     */
+    while ((node != NULL) &&
+           ((node->type == XML_COMMENT_NODE) ||
+            (node->type == XML_PI_NODE) ||
+	    (node->type == XML_XINCLUDE_START) ||
+	    (node->type == XML_XINCLUDE_END) ||
+            (((node->type == XML_TEXT_NODE) ||
+              (node->type == XML_CDATA_SECTION_NODE)) &&
+             ((ctxt->flags & FLAGS_MIXED_CONTENT) ||
+              (IS_BLANK_NODE(node)))))) {
+        node = node->next;
+    }
+    return (node);
+}
+
+/**
+ * xmlRelaxNGNormalize:
+ * @ctxt:  a schema validation context
+ * @str:  the string to normalize
+ *
+ * Implements the  normalizeWhiteSpace( s ) function from
+ * section 6.2.9 of the spec
+ *
+ * Returns the new string or NULL in case of error.
+ */
+static xmlChar *
+xmlRelaxNGNormalize(xmlRelaxNGValidCtxtPtr ctxt, const xmlChar * str)
+{
+    xmlChar *ret, *p;
+    const xmlChar *tmp;
+    int len;
+
+    if (str == NULL)
+        return (NULL);
+    tmp = str;
+    while (*tmp != 0)
+        tmp++;
+    len = tmp - str;
+
+    ret = (xmlChar *) xmlMallocAtomic((len + 1) * sizeof(xmlChar));
+    if (ret == NULL) {
+        xmlRngVErrMemory(ctxt, "validating\n");
+        return (NULL);
+    }
+    p = ret;
+    while (IS_BLANK_CH(*str))
+        str++;
+    while (*str != 0) {
+        if (IS_BLANK_CH(*str)) {
+            while (IS_BLANK_CH(*str))
+                str++;
+            if (*str == 0)
+                break;
+            *p++ = ' ';
+        } else
+            *p++ = *str++;
+    }
+    *p = 0;
+    return (ret);
+}
+
+/**
+ * xmlRelaxNGValidateDatatype:
+ * @ctxt:  a Relax-NG validation context
+ * @value:  the string value
+ * @type:  the datatype definition
+ * @node:  the node
+ *
+ * Validate the given value against the dataype
+ *
+ * Returns 0 if the validation succeeded or an error code.
+ */
+static int
+xmlRelaxNGValidateDatatype(xmlRelaxNGValidCtxtPtr ctxt,
+                           const xmlChar * value,
+                           xmlRelaxNGDefinePtr define, xmlNodePtr node)
+{
+    int ret, tmp;
+    xmlRelaxNGTypeLibraryPtr lib;
+    void *result = NULL;
+    xmlRelaxNGDefinePtr cur;
+
+    if ((define == NULL) || (define->data == NULL)) {
+        return (-1);
+    }
+    lib = (xmlRelaxNGTypeLibraryPtr) define->data;
+    if (lib->check != NULL) {
+        if ((define->attrs != NULL) &&
+            (define->attrs->type == XML_RELAXNG_PARAM)) {
+            ret =
+                lib->check(lib->data, define->name, value, &result, node);
+        } else {
+            ret = lib->check(lib->data, define->name, value, NULL, node);
+        }
+    } else
+        ret = -1;
+    if (ret < 0) {
+        VALID_ERR2(XML_RELAXNG_ERR_TYPE, define->name);
+        if ((result != NULL) && (lib != NULL) && (lib->freef != NULL))
+            lib->freef(lib->data, result);
+        return (-1);
+    } else if (ret == 1) {
+        ret = 0;
+    } else if (ret == 2) {
+        VALID_ERR2P(XML_RELAXNG_ERR_DUPID, value);
+    } else {
+        VALID_ERR3P(XML_RELAXNG_ERR_TYPEVAL, define->name, value);
+        ret = -1;
+    }
+    cur = define->attrs;
+    while ((ret == 0) && (cur != NULL) && (cur->type == XML_RELAXNG_PARAM)) {
+        if (lib->facet != NULL) {
+            tmp = lib->facet(lib->data, define->name, cur->name,
+                             cur->value, value, result);
+            if (tmp != 0)
+                ret = -1;
+        }
+        cur = cur->next;
+    }
+    if ((ret == 0) && (define->content != NULL)) {
+        const xmlChar *oldvalue, *oldendvalue;
+
+        oldvalue = ctxt->state->value;
+        oldendvalue = ctxt->state->endvalue;
+        ctxt->state->value = (xmlChar *) value;
+        ctxt->state->endvalue = NULL;
+        ret = xmlRelaxNGValidateValue(ctxt, define->content);
+        ctxt->state->value = (xmlChar *) oldvalue;
+        ctxt->state->endvalue = (xmlChar *) oldendvalue;
+    }
+    if ((result != NULL) && (lib != NULL) && (lib->freef != NULL))
+        lib->freef(lib->data, result);
+    return (ret);
+}
+
+/**
+ * xmlRelaxNGNextValue:
+ * @ctxt:  a Relax-NG validation context
+ *
+ * Skip to the next value when validating within a list
+ *
+ * Returns 0 if the operation succeeded or an error code.
+ */
+static int
+xmlRelaxNGNextValue(xmlRelaxNGValidCtxtPtr ctxt)
+{
+    xmlChar *cur;
+
+    cur = ctxt->state->value;
+    if ((cur == NULL) || (ctxt->state->endvalue == NULL)) {
+        ctxt->state->value = NULL;
+        ctxt->state->endvalue = NULL;
+        return (0);
+    }
+    while (*cur != 0)
+        cur++;
+    while ((cur != ctxt->state->endvalue) && (*cur == 0))
+        cur++;
+    if (cur == ctxt->state->endvalue)
+        ctxt->state->value = NULL;
+    else
+        ctxt->state->value = cur;
+    return (0);
+}
+
+/**
+ * xmlRelaxNGValidateValueList:
+ * @ctxt:  a Relax-NG validation context
+ * @defines:  the list of definitions to verify
+ *
+ * Validate the given set of definitions for the current value
+ *
+ * Returns 0 if the validation succeeded or an error code.
+ */
+static int
+xmlRelaxNGValidateValueList(xmlRelaxNGValidCtxtPtr ctxt,
+                            xmlRelaxNGDefinePtr defines)
+{
+    int ret = 0;
+
+    while (defines != NULL) {
+        ret = xmlRelaxNGValidateValue(ctxt, defines);
+        if (ret != 0)
+            break;
+        defines = defines->next;
+    }
+    return (ret);
+}
+
+/**
+ * xmlRelaxNGValidateValue:
+ * @ctxt:  a Relax-NG validation context
+ * @define:  the definition to verify
+ *
+ * Validate the given definition for the current value
+ *
+ * Returns 0 if the validation succeeded or an error code.
+ */
+static int
+xmlRelaxNGValidateValue(xmlRelaxNGValidCtxtPtr ctxt,
+                        xmlRelaxNGDefinePtr define)
+{
+    int ret = 0, oldflags;
+    xmlChar *value;
+
+    value = ctxt->state->value;
+    switch (define->type) {
+        case XML_RELAXNG_EMPTY:{
+                if ((value != NULL) && (value[0] != 0)) {
+                    int idx = 0;
+
+                    while (IS_BLANK_CH(value[idx]))
+                        idx++;
+                    if (value[idx] != 0)
+                        ret = -1;
+                }
+                break;
+            }
+        case XML_RELAXNG_TEXT:
+            break;
+        case XML_RELAXNG_VALUE:{
+                if (!xmlStrEqual(value, define->value)) {
+                    if (define->name != NULL) {
+                        xmlRelaxNGTypeLibraryPtr lib;
+
+                        lib = (xmlRelaxNGTypeLibraryPtr) define->data;
+                        if ((lib != NULL) && (lib->comp != NULL)) {
+                            ret = lib->comp(lib->data, define->name,
+                                            define->value, define->node,
+                                            (void *) define->attrs,
+                                            value, ctxt->state->node);
+                        } else
+                            ret = -1;
+                        if (ret < 0) {
+                            VALID_ERR2(XML_RELAXNG_ERR_TYPECMP,
+                                       define->name);
+                            return (-1);
+                        } else if (ret == 1) {
+                            ret = 0;
+                        } else {
+                            ret = -1;
+                        }
+                    } else {
+                        xmlChar *nval, *nvalue;
+
+                        /*
+                         * TODO: trivial optimizations are possible by
+                         * computing at compile-time
+                         */
+                        nval = xmlRelaxNGNormalize(ctxt, define->value);
+                        nvalue = xmlRelaxNGNormalize(ctxt, value);
+
+                        if ((nval == NULL) || (nvalue == NULL) ||
+                            (!xmlStrEqual(nval, nvalue)))
+                            ret = -1;
+                        if (nval != NULL)
+                            xmlFree(nval);
+                        if (nvalue != NULL)
+                            xmlFree(nvalue);
+                    }
+                }
+                if (ret == 0)
+                    xmlRelaxNGNextValue(ctxt);
+                break;
+            }
+        case XML_RELAXNG_DATATYPE:{
+                ret = xmlRelaxNGValidateDatatype(ctxt, value, define,
+                                                 ctxt->state->seq);
+                if (ret == 0)
+                    xmlRelaxNGNextValue(ctxt);
+
+                break;
+            }
+        case XML_RELAXNG_CHOICE:{
+                xmlRelaxNGDefinePtr list = define->content;
+                xmlChar *oldvalue;
+
+                oldflags = ctxt->flags;
+                ctxt->flags |= FLAGS_IGNORABLE;
+
+                oldvalue = ctxt->state->value;
+                while (list != NULL) {
+                    ret = xmlRelaxNGValidateValue(ctxt, list);
+                    if (ret == 0) {
+                        break;
+                    }
+                    ctxt->state->value = oldvalue;
+                    list = list->next;
+                }
+                ctxt->flags = oldflags;
+                if (ret != 0) {
+                    if ((ctxt->flags & FLAGS_IGNORABLE) == 0)
+                        xmlRelaxNGDumpValidError(ctxt);
+                } else {
+                    if (ctxt->errNr > 0)
+                        xmlRelaxNGPopErrors(ctxt, 0);
+                }
+                if (ret == 0)
+                    xmlRelaxNGNextValue(ctxt);
+                break;
+            }
+        case XML_RELAXNG_LIST:{
+                xmlRelaxNGDefinePtr list = define->content;
+                xmlChar *oldvalue, *oldend, *val, *cur;
+
+#ifdef DEBUG_LIST
+                int nb_values = 0;
+#endif
+
+                oldvalue = ctxt->state->value;
+                oldend = ctxt->state->endvalue;
+
+                val = xmlStrdup(oldvalue);
+                if (val == NULL) {
+                    val = xmlStrdup(BAD_CAST "");
+                }
+                if (val == NULL) {
+                    VALID_ERR(XML_RELAXNG_ERR_NOSTATE);
+                    return (-1);
+                }
+                cur = val;
+                while (*cur != 0) {
+                    if (IS_BLANK_CH(*cur)) {
+                        *cur = 0;
+                        cur++;
+#ifdef DEBUG_LIST
+                        nb_values++;
+#endif
+                        while (IS_BLANK_CH(*cur))
+                            *cur++ = 0;
+                    } else
+                        cur++;
+                }
+#ifdef DEBUG_LIST
+                xmlGenericError(xmlGenericErrorContext,
+                                "list value: '%s' found %d items\n",
+                                oldvalue, nb_values);
+                nb_values = 0;
+#endif
+                ctxt->state->endvalue = cur;
+                cur = val;
+                while ((*cur == 0) && (cur != ctxt->state->endvalue))
+                    cur++;
+
+                ctxt->state->value = cur;
+
+                while (list != NULL) {
+                    if (ctxt->state->value == ctxt->state->endvalue)
+                        ctxt->state->value = NULL;
+                    ret = xmlRelaxNGValidateValue(ctxt, list);
+                    if (ret != 0) {
+#ifdef DEBUG_LIST
+                        xmlGenericError(xmlGenericErrorContext,
+                                        "Failed to validate value: '%s' with %d rule\n",
+                                        ctxt->state->value, nb_values);
+#endif
+                        break;
+                    }
+#ifdef DEBUG_LIST
+                    nb_values++;
+#endif
+                    list = list->next;
+                }
+
+                if ((ret == 0) && (ctxt->state->value != NULL) &&
+                    (ctxt->state->value != ctxt->state->endvalue)) {
+                    VALID_ERR2(XML_RELAXNG_ERR_LISTEXTRA,
+                               ctxt->state->value);
+                    ret = -1;
+                }
+                xmlFree(val);
+                ctxt->state->value = oldvalue;
+                ctxt->state->endvalue = oldend;
+                break;
+            }
+        case XML_RELAXNG_ONEORMORE:
+            ret = xmlRelaxNGValidateValueList(ctxt, define->content);
+            if (ret != 0) {
+                break;
+            }
+            /* no break on purpose */
+        case XML_RELAXNG_ZEROORMORE:{
+                xmlChar *cur, *temp;
+
+                oldflags = ctxt->flags;
+                ctxt->flags |= FLAGS_IGNORABLE;
+                cur = ctxt->state->value;
+                temp = NULL;
+                while ((cur != NULL) && (cur != ctxt->state->endvalue) &&
+                       (temp != cur)) {
+                    temp = cur;
+                    ret =
+                        xmlRelaxNGValidateValueList(ctxt, define->content);
+                    if (ret != 0) {
+                        ctxt->state->value = temp;
+                        ret = 0;
+                        break;
+                    }
+                    cur = ctxt->state->value;
+                }
+                ctxt->flags = oldflags;
+                if (ret != 0) {
+                    if ((ctxt->flags & FLAGS_IGNORABLE) == 0)
+                        xmlRelaxNGDumpValidError(ctxt);
+                } else {
+                    if (ctxt->errNr > 0)
+                        xmlRelaxNGPopErrors(ctxt, 0);
+                }
+                break;
+            }
+        case XML_RELAXNG_EXCEPT:{
+                xmlRelaxNGDefinePtr list;
+
+                list = define->content;
+                while (list != NULL) {
+                    ret = xmlRelaxNGValidateValue(ctxt, list);
+                    if (ret == 0) {
+                        ret = -1;
+                        break;
+                    } else
+                        ret = 0;
+                    list = list->next;
+                }
+                break;
+            }
+        case XML_RELAXNG_DEF:
+        case XML_RELAXNG_GROUP:{
+                xmlRelaxNGDefinePtr list;
+
+                list = define->content;
+                while (list != NULL) {
+                    ret = xmlRelaxNGValidateValue(ctxt, list);
+                    if (ret != 0) {
+                        ret = -1;
+                        break;
+                    } else
+                        ret = 0;
+                    list = list->next;
+                }
+                break;
+            }
+        case XML_RELAXNG_REF:
+        case XML_RELAXNG_PARENTREF:
+            ret = xmlRelaxNGValidateValue(ctxt, define->content);
+            break;
+        default:
+            TODO ret = -1;
+    }
+    return (ret);
+}
+
+/**
+ * xmlRelaxNGValidateValueContent:
+ * @ctxt:  a Relax-NG validation context
+ * @defines:  the list of definitions to verify
+ *
+ * Validate the given definitions for the current value
+ *
+ * Returns 0 if the validation succeeded or an error code.
+ */
+static int
+xmlRelaxNGValidateValueContent(xmlRelaxNGValidCtxtPtr ctxt,
+                               xmlRelaxNGDefinePtr defines)
+{
+    int ret = 0;
+
+    while (defines != NULL) {
+        ret = xmlRelaxNGValidateValue(ctxt, defines);
+        if (ret != 0)
+            break;
+        defines = defines->next;
+    }
+    return (ret);
+}
+
+/**
+ * xmlRelaxNGAttributeMatch:
+ * @ctxt:  a Relax-NG validation context
+ * @define:  the definition to check
+ * @prop:  the attribute
+ *
+ * Check if the attribute matches the definition nameClass
+ *
+ * Returns 1 if the attribute matches, 0 if no, or -1 in case of error
+ */
+static int
+xmlRelaxNGAttributeMatch(xmlRelaxNGValidCtxtPtr ctxt,
+                         xmlRelaxNGDefinePtr define, xmlAttrPtr prop)
+{
+    int ret;
+
+    if (define->name != NULL) {
+        if (!xmlStrEqual(define->name, prop->name))
+            return (0);
+    }
+    if (define->ns != NULL) {
+        if (define->ns[0] == 0) {
+            if (prop->ns != NULL)
+                return (0);
+        } else {
+            if ((prop->ns == NULL) ||
+                (!xmlStrEqual(define->ns, prop->ns->href)))
+                return (0);
+        }
+    }
+    if (define->nameClass == NULL)
+        return (1);
+    define = define->nameClass;
+    if (define->type == XML_RELAXNG_EXCEPT) {
+        xmlRelaxNGDefinePtr list;
+
+        list = define->content;
+        while (list != NULL) {
+            ret = xmlRelaxNGAttributeMatch(ctxt, list, prop);
+            if (ret == 1)
+                return (0);
+            if (ret < 0)
+                return (ret);
+            list = list->next;
+        }
+    } else {
+    TODO}
+    return (1);
+}
+
+/**
+ * xmlRelaxNGValidateAttribute:
+ * @ctxt:  a Relax-NG validation context
+ * @define:  the definition to verify
+ *
+ * Validate the given attribute definition for that node
+ *
+ * Returns 0 if the validation succeeded or an error code.
+ */
+static int
+xmlRelaxNGValidateAttribute(xmlRelaxNGValidCtxtPtr ctxt,
+                            xmlRelaxNGDefinePtr define)
+{
+    int ret = 0, i;
+    xmlChar *value, *oldvalue;
+    xmlAttrPtr prop = NULL, tmp;
+    xmlNodePtr oldseq;
+
+    if (ctxt->state->nbAttrLeft <= 0)
+        return (-1);
+    if (define->name != NULL) {
+        for (i = 0; i < ctxt->state->nbAttrs; i++) {
+            tmp = ctxt->state->attrs[i];
+            if ((tmp != NULL) && (xmlStrEqual(define->name, tmp->name))) {
+                if ((((define->ns == NULL) || (define->ns[0] == 0)) &&
+                     (tmp->ns == NULL)) ||
+                    ((tmp->ns != NULL) &&
+                     (xmlStrEqual(define->ns, tmp->ns->href)))) {
+                    prop = tmp;
+                    break;
+                }
+            }
+        }
+        if (prop != NULL) {
+            value = xmlNodeListGetString(prop->doc, prop->children, 1);
+            oldvalue = ctxt->state->value;
+            oldseq = ctxt->state->seq;
+            ctxt->state->seq = (xmlNodePtr) prop;
+            ctxt->state->value = value;
+            ctxt->state->endvalue = NULL;
+            ret = xmlRelaxNGValidateValueContent(ctxt, define->content);
+            if (ctxt->state->value != NULL)
+                value = ctxt->state->value;
+            if (value != NULL)
+                xmlFree(value);
+            ctxt->state->value = oldvalue;
+            ctxt->state->seq = oldseq;
+            if (ret == 0) {
+                /*
+                 * flag the attribute as processed
+                 */
+                ctxt->state->attrs[i] = NULL;
+                ctxt->state->nbAttrLeft--;
+            }
+        } else {
+            ret = -1;
+        }
+#ifdef DEBUG
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlRelaxNGValidateAttribute(%s): %d\n",
+                        define->name, ret);
+#endif
+    } else {
+        for (i = 0; i < ctxt->state->nbAttrs; i++) {
+            tmp = ctxt->state->attrs[i];
+            if ((tmp != NULL) &&
+                (xmlRelaxNGAttributeMatch(ctxt, define, tmp) == 1)) {
+                prop = tmp;
+                break;
+            }
+        }
+        if (prop != NULL) {
+            value = xmlNodeListGetString(prop->doc, prop->children, 1);
+            oldvalue = ctxt->state->value;
+            oldseq = ctxt->state->seq;
+            ctxt->state->seq = (xmlNodePtr) prop;
+            ctxt->state->value = value;
+            ret = xmlRelaxNGValidateValueContent(ctxt, define->content);
+            if (ctxt->state->value != NULL)
+                value = ctxt->state->value;
+            if (value != NULL)
+                xmlFree(value);
+            ctxt->state->value = oldvalue;
+            ctxt->state->seq = oldseq;
+            if (ret == 0) {
+                /*
+                 * flag the attribute as processed
+                 */
+                ctxt->state->attrs[i] = NULL;
+                ctxt->state->nbAttrLeft--;
+            }
+        } else {
+            ret = -1;
+        }
+#ifdef DEBUG
+        if (define->ns != NULL) {
+            xmlGenericError(xmlGenericErrorContext,
+                            "xmlRelaxNGValidateAttribute(nsName ns = %s): %d\n",
+                            define->ns, ret);
+        } else {
+            xmlGenericError(xmlGenericErrorContext,
+                            "xmlRelaxNGValidateAttribute(anyName): %d\n",
+                            ret);
+        }
+#endif
+    }
+
+    return (ret);
+}
+
+/**
+ * xmlRelaxNGValidateAttributeList:
+ * @ctxt:  a Relax-NG validation context
+ * @define:  the list of definition to verify
+ *
+ * Validate the given node against the list of attribute definitions
+ *
+ * Returns 0 if the validation succeeded or an error code.
+ */
+static int
+xmlRelaxNGValidateAttributeList(xmlRelaxNGValidCtxtPtr ctxt,
+                                xmlRelaxNGDefinePtr defines)
+{
+    int ret = 0, res;
+    int needmore = 0;
+    xmlRelaxNGDefinePtr cur;
+
+    cur = defines;
+    while (cur != NULL) {
+        if (cur->type == XML_RELAXNG_ATTRIBUTE) {
+            if (xmlRelaxNGValidateAttribute(ctxt, cur) != 0)
+                ret = -1;
+        } else
+            needmore = 1;
+        cur = cur->next;
+    }
+    if (!needmore)
+        return (ret);
+    cur = defines;
+    while (cur != NULL) {
+        if (cur->type != XML_RELAXNG_ATTRIBUTE) {
+            if ((ctxt->state != NULL) || (ctxt->states != NULL)) {
+                res = xmlRelaxNGValidateDefinition(ctxt, cur);
+                if (res < 0)
+                    ret = -1;
+            } else {
+                VALID_ERR(XML_RELAXNG_ERR_NOSTATE);
+                return (-1);
+            }
+            if (res == -1)      /* continues on -2 */
+                break;
+        }
+        cur = cur->next;
+    }
+
+    return (ret);
+}
+
+/**
+ * xmlRelaxNGNodeMatchesList:
+ * @node:  the node
+ * @list:  a NULL terminated array of definitions
+ *
+ * Check if a node can be matched by one of the definitions
+ *
+ * Returns 1 if matches 0 otherwise
+ */
+static int
+xmlRelaxNGNodeMatchesList(xmlNodePtr node, xmlRelaxNGDefinePtr * list)
+{
+    xmlRelaxNGDefinePtr cur;
+    int i = 0, tmp;
+
+    if ((node == NULL) || (list == NULL))
+        return (0);
+
+    cur = list[i++];
+    while (cur != NULL) {
+        if ((node->type == XML_ELEMENT_NODE) &&
+            (cur->type == XML_RELAXNG_ELEMENT)) {
+            tmp = xmlRelaxNGElementMatch(NULL, cur, node);
+            if (tmp == 1)
+                return (1);
+        } else if (((node->type == XML_TEXT_NODE) ||
+                    (node->type == XML_CDATA_SECTION_NODE)) &&
+                   (cur->type == XML_RELAXNG_TEXT)) {
+            return (1);
+        }
+        cur = list[i++];
+    }
+    return (0);
+}
+
+/**
+ * xmlRelaxNGValidateInterleave:
+ * @ctxt:  a Relax-NG validation context
+ * @define:  the definition to verify
+ *
+ * Validate an interleave definition for a node.
+ *
+ * Returns 0 if the validation succeeded or an error code.
+ */
+static int
+xmlRelaxNGValidateInterleave(xmlRelaxNGValidCtxtPtr ctxt,
+                             xmlRelaxNGDefinePtr define)
+{
+    int ret = 0, i, nbgroups;
+    int errNr = ctxt->errNr;
+    int oldflags;
+
+    xmlRelaxNGValidStatePtr oldstate;
+    xmlRelaxNGPartitionPtr partitions;
+    xmlRelaxNGInterleaveGroupPtr group = NULL;
+    xmlNodePtr cur, start, last = NULL, lastchg = NULL, lastelem;
+    xmlNodePtr *list = NULL, *lasts = NULL;
+
+    if (define->data != NULL) {
+        partitions = (xmlRelaxNGPartitionPtr) define->data;
+        nbgroups = partitions->nbgroups;
+    } else {
+        VALID_ERR(XML_RELAXNG_ERR_INTERNODATA);
+        return (-1);
+    }
+    /*
+     * Optimizations for MIXED
+     */
+    oldflags = ctxt->flags;
+    if (define->dflags & IS_MIXED) {
+        ctxt->flags |= FLAGS_MIXED_CONTENT;
+        if (nbgroups == 2) {
+            /*
+             * this is a pure <mixed> case
+             */
+            if (ctxt->state != NULL)
+                ctxt->state->seq = xmlRelaxNGSkipIgnored(ctxt,
+                                                         ctxt->state->seq);
+            if (partitions->groups[0]->rule->type == XML_RELAXNG_TEXT)
+                ret = xmlRelaxNGValidateDefinition(ctxt,
+                                                   partitions->groups[1]->
+                                                   rule);
+            else
+                ret = xmlRelaxNGValidateDefinition(ctxt,
+                                                   partitions->groups[0]->
+                                                   rule);
+            if (ret == 0) {
+                if (ctxt->state != NULL)
+                    ctxt->state->seq = xmlRelaxNGSkipIgnored(ctxt,
+                                                             ctxt->state->
+                                                             seq);
+            }
+            ctxt->flags = oldflags;
+            return (ret);
+        }
+    }
+
+    /*
+     * Build arrays to store the first and last node of the chain
+     * pertaining to each group
+     */
+    list = (xmlNodePtr *) xmlMalloc(nbgroups * sizeof(xmlNodePtr));
+    if (list == NULL) {
+        xmlRngVErrMemory(ctxt, "validating\n");
+        return (-1);
+    }
+    memset(list, 0, nbgroups * sizeof(xmlNodePtr));
+    lasts = (xmlNodePtr *) xmlMalloc(nbgroups * sizeof(xmlNodePtr));
+    if (lasts == NULL) {
+        xmlRngVErrMemory(ctxt, "validating\n");
+        return (-1);
+    }
+    memset(lasts, 0, nbgroups * sizeof(xmlNodePtr));
+
+    /*
+     * Walk the sequence of children finding the right group and
+     * sorting them in sequences.
+     */
+    cur = ctxt->state->seq;
+    cur = xmlRelaxNGSkipIgnored(ctxt, cur);
+    start = cur;
+    while (cur != NULL) {
+        ctxt->state->seq = cur;
+        if ((partitions->triage != NULL) &&
+            (partitions->flags & IS_DETERMINIST)) {
+            void *tmp = NULL;
+
+            if ((cur->type == XML_TEXT_NODE) ||
+                (cur->type == XML_CDATA_SECTION_NODE)) {
+                tmp = xmlHashLookup2(partitions->triage, BAD_CAST "#text",
+                                     NULL);
+            } else if (cur->type == XML_ELEMENT_NODE) {
+                if (cur->ns != NULL) {
+                    tmp = xmlHashLookup2(partitions->triage, cur->name,
+                                         cur->ns->href);
+                    if (tmp == NULL)
+                        tmp = xmlHashLookup2(partitions->triage,
+                                             BAD_CAST "#any",
+                                             cur->ns->href);
+                } else
+                    tmp =
+                        xmlHashLookup2(partitions->triage, cur->name,
+                                       NULL);
+                if (tmp == NULL)
+                    tmp =
+                        xmlHashLookup2(partitions->triage, BAD_CAST "#any",
+                                       NULL);
+            }
+
+            if (tmp == NULL) {
+                i = nbgroups;
+            } else {
+                i = ((long) tmp) - 1;
+                if (partitions->flags & IS_NEEDCHECK) {
+                    group = partitions->groups[i];
+                    if (!xmlRelaxNGNodeMatchesList(cur, group->defs))
+                        i = nbgroups;
+                }
+            }
+        } else {
+            for (i = 0; i < nbgroups; i++) {
+                group = partitions->groups[i];
+                if (group == NULL)
+                    continue;
+                if (xmlRelaxNGNodeMatchesList(cur, group->defs))
+                    break;
+            }
+        }
+        /*
+         * We break as soon as an element not matched is found
+         */
+        if (i >= nbgroups) {
+            break;
+        }
+        if (lasts[i] != NULL) {
+            lasts[i]->next = cur;
+            lasts[i] = cur;
+        } else {
+            list[i] = cur;
+            lasts[i] = cur;
+        }
+        if (cur->next != NULL)
+            lastchg = cur->next;
+        else
+            lastchg = cur;
+        cur = xmlRelaxNGSkipIgnored(ctxt, cur->next);
+    }
+    if (ret != 0) {
+        VALID_ERR(XML_RELAXNG_ERR_INTERSEQ);
+        ret = -1;
+        goto done;
+    }
+    lastelem = cur;
+    oldstate = ctxt->state;
+    for (i = 0; i < nbgroups; i++) {
+        ctxt->state = xmlRelaxNGCopyValidState(ctxt, oldstate);
+        group = partitions->groups[i];
+        if (lasts[i] != NULL) {
+            last = lasts[i]->next;
+            lasts[i]->next = NULL;
+        }
+        ctxt->state->seq = list[i];
+        ret = xmlRelaxNGValidateDefinition(ctxt, group->rule);
+        if (ret != 0)
+            break;
+        if (ctxt->state != NULL) {
+            cur = ctxt->state->seq;
+            cur = xmlRelaxNGSkipIgnored(ctxt, cur);
+            xmlRelaxNGFreeValidState(ctxt, oldstate);
+            oldstate = ctxt->state;
+            ctxt->state = NULL;
+            if (cur != NULL) {
+                VALID_ERR2(XML_RELAXNG_ERR_INTEREXTRA, cur->name);
+                ret = -1;
+                ctxt->state = oldstate;
+                goto done;
+            }
+        } else if (ctxt->states != NULL) {
+            int j;
+            int found = 0;
+
+            for (j = 0; j < ctxt->states->nbState; j++) {
+                cur = ctxt->states->tabState[j]->seq;
+                cur = xmlRelaxNGSkipIgnored(ctxt, cur);
+                if (cur == NULL) {
+                    found = 1;
+                    break;
+                }
+            }
+            if (ctxt->states->nbState > 0) {
+                xmlRelaxNGFreeValidState(ctxt, oldstate);
+                oldstate =
+                    ctxt->states->tabState[ctxt->states->nbState - 1];
+            }
+            for (j = 0; j < ctxt->states->nbState - 1; j++) {
+                xmlRelaxNGFreeValidState(ctxt, ctxt->states->tabState[j]);
+            }
+            xmlRelaxNGFreeStates(ctxt, ctxt->states);
+            ctxt->states = NULL;
+            if (found == 0) {
+                VALID_ERR2(XML_RELAXNG_ERR_INTEREXTRA, cur->name);
+                ret = -1;
+                ctxt->state = oldstate;
+                goto done;
+            }
+        } else {
+            ret = -1;
+            break;
+        }
+        if (lasts[i] != NULL) {
+            lasts[i]->next = last;
+        }
+    }
+    if (ctxt->state != NULL)
+        xmlRelaxNGFreeValidState(ctxt, ctxt->state);
+    ctxt->state = oldstate;
+    ctxt->state->seq = lastelem;
+    if (ret != 0) {
+        VALID_ERR(XML_RELAXNG_ERR_INTERSEQ);
+        ret = -1;
+        goto done;
+    }
+
+  done:
+    ctxt->flags = oldflags;
+    /*
+     * builds the next links chain from the prev one
+     */
+    cur = lastchg;
+    while (cur != NULL) {
+        if ((cur == start) || (cur->prev == NULL))
+            break;
+        cur->prev->next = cur;
+        cur = cur->prev;
+    }
+    if (ret == 0) {
+        if (ctxt->errNr > errNr)
+            xmlRelaxNGPopErrors(ctxt, errNr);
+    }
+
+    xmlFree(list);
+    xmlFree(lasts);
+    return (ret);
+}
+
+/**
+ * xmlRelaxNGValidateDefinitionList:
+ * @ctxt:  a Relax-NG validation context
+ * @define:  the list of definition to verify
+ *
+ * Validate the given node content against the (list) of definitions
+ *
+ * Returns 0 if the validation succeeded or an error code.
+ */
+static int
+xmlRelaxNGValidateDefinitionList(xmlRelaxNGValidCtxtPtr ctxt,
+                                 xmlRelaxNGDefinePtr defines)
+{
+    int ret = 0, res;
+
+
+    if (defines == NULL) {
+        VALID_ERR2(XML_RELAXNG_ERR_INTERNAL,
+                   BAD_CAST "NULL definition list");
+        return (-1);
+    }
+    while (defines != NULL) {
+        if ((ctxt->state != NULL) || (ctxt->states != NULL)) {
+            res = xmlRelaxNGValidateDefinition(ctxt, defines);
+            if (res < 0)
+                ret = -1;
+        } else {
+            VALID_ERR(XML_RELAXNG_ERR_NOSTATE);
+            return (-1);
+        }
+        if (res == -1)          /* continues on -2 */
+            break;
+        defines = defines->next;
+    }
+
+    return (ret);
+}
+
+/**
+ * xmlRelaxNGElementMatch:
+ * @ctxt:  a Relax-NG validation context
+ * @define:  the definition to check
+ * @elem:  the element
+ *
+ * Check if the element matches the definition nameClass
+ *
+ * Returns 1 if the element matches, 0 if no, or -1 in case of error
+ */
+static int
+xmlRelaxNGElementMatch(xmlRelaxNGValidCtxtPtr ctxt,
+                       xmlRelaxNGDefinePtr define, xmlNodePtr elem)
+{
+    int ret = 0, oldflags = 0;
+
+    if (define->name != NULL) {
+        if (!xmlStrEqual(elem->name, define->name)) {
+            VALID_ERR3(XML_RELAXNG_ERR_ELEMNAME, define->name, elem->name);
+            return (0);
+        }
+    }
+    if ((define->ns != NULL) && (define->ns[0] != 0)) {
+        if (elem->ns == NULL) {
+            VALID_ERR2(XML_RELAXNG_ERR_ELEMNONS, elem->name);
+            return (0);
+        } else if (!xmlStrEqual(elem->ns->href, define->ns)) {
+            VALID_ERR3(XML_RELAXNG_ERR_ELEMWRONGNS,
+                       elem->name, define->ns);
+            return (0);
+        }
+    } else if ((elem->ns != NULL) && (define->ns != NULL) &&
+               (define->name == NULL)) {
+        VALID_ERR2(XML_RELAXNG_ERR_ELEMEXTRANS, elem->name);
+        return (0);
+    } else if ((elem->ns != NULL) && (define->name != NULL)) {
+        VALID_ERR2(XML_RELAXNG_ERR_ELEMEXTRANS, define->name);
+        return (0);
+    }
+
+    if (define->nameClass == NULL)
+        return (1);
+
+    define = define->nameClass;
+    if (define->type == XML_RELAXNG_EXCEPT) {
+        xmlRelaxNGDefinePtr list;
+
+        if (ctxt != NULL) {
+            oldflags = ctxt->flags;
+            ctxt->flags |= FLAGS_IGNORABLE;
+        }
+
+        list = define->content;
+        while (list != NULL) {
+            ret = xmlRelaxNGElementMatch(ctxt, list, elem);
+            if (ret == 1) {
+                if (ctxt != NULL)
+                    ctxt->flags = oldflags;
+                return (0);
+            }
+            if (ret < 0) {
+                if (ctxt != NULL)
+                    ctxt->flags = oldflags;
+                return (ret);
+            }
+            list = list->next;
+        }
+        ret = 1;
+        if (ctxt != NULL) {
+            ctxt->flags = oldflags;
+        }
+    } else if (define->type == XML_RELAXNG_CHOICE) {
+        xmlRelaxNGDefinePtr list;
+
+        if (ctxt != NULL) {
+            oldflags = ctxt->flags;
+            ctxt->flags |= FLAGS_IGNORABLE;
+        }
+
+        list = define->nameClass;
+        while (list != NULL) {
+            ret = xmlRelaxNGElementMatch(ctxt, list, elem);
+            if (ret == 1) {
+                if (ctxt != NULL)
+                    ctxt->flags = oldflags;
+                return (1);
+            }
+            if (ret < 0) {
+                if (ctxt != NULL)
+                    ctxt->flags = oldflags;
+                return (ret);
+            }
+            list = list->next;
+        }
+        if (ctxt != NULL) {
+            if (ret != 0) {
+                if ((ctxt->flags & FLAGS_IGNORABLE) == 0)
+                    xmlRelaxNGDumpValidError(ctxt);
+            } else {
+                if (ctxt->errNr > 0)
+                    xmlRelaxNGPopErrors(ctxt, 0);
+            }
+        }
+        ret = 0;
+        if (ctxt != NULL) {
+            ctxt->flags = oldflags;
+        }
+    } else {
+        TODO ret = -1;
+    }
+    return (ret);
+}
+
+/**
+ * xmlRelaxNGBestState:
+ * @ctxt:  a Relax-NG validation context
+ *
+ * Find the "best" state in the ctxt->states list of states to report
+ * errors about. I.e. a state with no element left in the child list
+ * or the one with the less attributes left.
+ * This is called only if a falidation error was detected
+ *
+ * Returns the index of the "best" state or -1 in case of error
+ */
+static int
+xmlRelaxNGBestState(xmlRelaxNGValidCtxtPtr ctxt)
+{
+    xmlRelaxNGValidStatePtr state;
+    int i, tmp;
+    int best = -1;
+    int value = 1000000;
+
+    if ((ctxt == NULL) || (ctxt->states == NULL) ||
+        (ctxt->states->nbState <= 0))
+        return (-1);
+
+    for (i = 0; i < ctxt->states->nbState; i++) {
+        state = ctxt->states->tabState[i];
+        if (state == NULL)
+            continue;
+        if (state->seq != NULL) {
+            if ((best == -1) || (value > 100000)) {
+                value = 100000;
+                best = i;
+            }
+        } else {
+            tmp = state->nbAttrLeft;
+            if ((best == -1) || (value > tmp)) {
+                value = tmp;
+                best = i;
+            }
+        }
+    }
+    return (best);
+}
+
+/**
+ * xmlRelaxNGLogBestError:
+ * @ctxt:  a Relax-NG validation context
+ *
+ * Find the "best" state in the ctxt->states list of states to report
+ * errors about and log it.
+ */
+static void
+xmlRelaxNGLogBestError(xmlRelaxNGValidCtxtPtr ctxt)
+{
+    int best;
+
+    if ((ctxt == NULL) || (ctxt->states == NULL) ||
+        (ctxt->states->nbState <= 0))
+        return;
+
+    best = xmlRelaxNGBestState(ctxt);
+    if ((best >= 0) && (best < ctxt->states->nbState)) {
+        ctxt->state = ctxt->states->tabState[best];
+
+        xmlRelaxNGValidateElementEnd(ctxt, 1);
+    }
+}
+
+/**
+ * xmlRelaxNGValidateElementEnd:
+ * @ctxt:  a Relax-NG validation context
+ * @dolog:  indicate that error logging should be done
+ *
+ * Validate the end of the element, implements check that
+ * there is nothing left not consumed in the element content
+ * or in the attribute list.
+ *
+ * Returns 0 if the validation succeeded or an error code.
+ */
+static int
+xmlRelaxNGValidateElementEnd(xmlRelaxNGValidCtxtPtr ctxt, int dolog)
+{
+    int i;
+    xmlRelaxNGValidStatePtr state;
+
+    state = ctxt->state;
+    if (state->seq != NULL) {
+        state->seq = xmlRelaxNGSkipIgnored(ctxt, state->seq);
+        if (state->seq != NULL) {
+            if (dolog) {
+                VALID_ERR3(XML_RELAXNG_ERR_EXTRACONTENT,
+                           state->node->name, state->seq->name);
+            }
+            return (-1);
+        }
+    }
+    for (i = 0; i < state->nbAttrs; i++) {
+        if (state->attrs[i] != NULL) {
+            if (dolog) {
+                VALID_ERR3(XML_RELAXNG_ERR_INVALIDATTR,
+                           state->attrs[i]->name, state->node->name);
+            }
+            return (-1 - i);
+        }
+    }
+    return (0);
+}
+
+/**
+ * xmlRelaxNGValidateState:
+ * @ctxt:  a Relax-NG validation context
+ * @define:  the definition to verify
+ *
+ * Validate the current state against the definition
+ *
+ * Returns 0 if the validation succeeded or an error code.
+ */
+static int
+xmlRelaxNGValidateState(xmlRelaxNGValidCtxtPtr ctxt,
+                        xmlRelaxNGDefinePtr define)
+{
+    xmlNodePtr node;
+    int ret = 0, i, tmp, oldflags, errNr;
+    xmlRelaxNGValidStatePtr oldstate = NULL, state;
+
+    if (define == NULL) {
+        VALID_ERR(XML_RELAXNG_ERR_NODEFINE);
+        return (-1);
+    }
+
+    if (ctxt->state != NULL) {
+        node = ctxt->state->seq;
+    } else {
+        node = NULL;
+    }
+#ifdef DEBUG
+    for (i = 0; i < ctxt->depth; i++)
+        xmlGenericError(xmlGenericErrorContext, " ");
+    xmlGenericError(xmlGenericErrorContext,
+                    "Start validating %s ", xmlRelaxNGDefName(define));
+    if (define->name != NULL)
+        xmlGenericError(xmlGenericErrorContext, "%s ", define->name);
+    if ((node != NULL) && (node->name != NULL))
+        xmlGenericError(xmlGenericErrorContext, "on %s\n", node->name);
+    else
+        xmlGenericError(xmlGenericErrorContext, "\n");
+#endif
+    ctxt->depth++;
+    switch (define->type) {
+        case XML_RELAXNG_EMPTY:
+            node = xmlRelaxNGSkipIgnored(ctxt, node);
+            ret = 0;
+            break;
+        case XML_RELAXNG_NOT_ALLOWED:
+            ret = -1;
+            break;
+        case XML_RELAXNG_TEXT:
+            while ((node != NULL) &&
+                   ((node->type == XML_TEXT_NODE) ||
+                    (node->type == XML_COMMENT_NODE) ||
+                    (node->type == XML_PI_NODE) ||
+                    (node->type == XML_CDATA_SECTION_NODE)))
+                node = node->next;
+            ctxt->state->seq = node;
+            break;
+        case XML_RELAXNG_ELEMENT:
+            errNr = ctxt->errNr;
+            node = xmlRelaxNGSkipIgnored(ctxt, node);
+            if (node == NULL) {
+                VALID_ERR2(XML_RELAXNG_ERR_NOELEM, define->name);
+                ret = -1;
+                if ((ctxt->flags & FLAGS_IGNORABLE) == 0)
+                    xmlRelaxNGDumpValidError(ctxt);
+                break;
+            }
+            if (node->type != XML_ELEMENT_NODE) {
+                VALID_ERR(XML_RELAXNG_ERR_NOTELEM);
+                ret = -1;
+                if ((ctxt->flags & FLAGS_IGNORABLE) == 0)
+                    xmlRelaxNGDumpValidError(ctxt);
+                break;
+            }
+            /*
+             * This node was already validated successfully against
+             * this definition.
+             */
+            if (node->psvi == define) {
+                ctxt->state->seq = xmlRelaxNGSkipIgnored(ctxt, node->next);
+                if (ctxt->errNr > errNr)
+                    xmlRelaxNGPopErrors(ctxt, errNr);
+                if (ctxt->errNr != 0) {
+                    while ((ctxt->err != NULL) &&
+                           (((ctxt->err->err == XML_RELAXNG_ERR_ELEMNAME)
+                             && (xmlStrEqual(ctxt->err->arg2, node->name)))
+                            ||
+                            ((ctxt->err->err ==
+                              XML_RELAXNG_ERR_ELEMEXTRANS)
+                             && (xmlStrEqual(ctxt->err->arg1, node->name)))
+                            || (ctxt->err->err == XML_RELAXNG_ERR_NOELEM)
+                            || (ctxt->err->err ==
+                                XML_RELAXNG_ERR_NOTELEM)))
+                        xmlRelaxNGValidErrorPop(ctxt);
+                }
+                break;
+            }
+
+            ret = xmlRelaxNGElementMatch(ctxt, define, node);
+            if (ret <= 0) {
+                ret = -1;
+                if ((ctxt->flags & FLAGS_IGNORABLE) == 0)
+                    xmlRelaxNGDumpValidError(ctxt);
+                break;
+            }
+            ret = 0;
+            if (ctxt->errNr != 0) {
+                if (ctxt->errNr > errNr)
+                    xmlRelaxNGPopErrors(ctxt, errNr);
+                while ((ctxt->err != NULL) &&
+                       (((ctxt->err->err == XML_RELAXNG_ERR_ELEMNAME) &&
+                         (xmlStrEqual(ctxt->err->arg2, node->name))) ||
+                        ((ctxt->err->err == XML_RELAXNG_ERR_ELEMEXTRANS) &&
+                         (xmlStrEqual(ctxt->err->arg1, node->name))) ||
+                        (ctxt->err->err == XML_RELAXNG_ERR_NOELEM) ||
+                        (ctxt->err->err == XML_RELAXNG_ERR_NOTELEM)))
+                    xmlRelaxNGValidErrorPop(ctxt);
+            }
+            errNr = ctxt->errNr;
+
+            oldflags = ctxt->flags;
+            if (ctxt->flags & FLAGS_MIXED_CONTENT) {
+                ctxt->flags -= FLAGS_MIXED_CONTENT;
+            }
+            state = xmlRelaxNGNewValidState(ctxt, node);
+            if (state == NULL) {
+                ret = -1;
+                if ((ctxt->flags & FLAGS_IGNORABLE) == 0)
+                    xmlRelaxNGDumpValidError(ctxt);
+                break;
+            }
+
+            oldstate = ctxt->state;
+            ctxt->state = state;
+            if (define->attrs != NULL) {
+                tmp = xmlRelaxNGValidateAttributeList(ctxt, define->attrs);
+                if (tmp != 0) {
+                    ret = -1;
+                    VALID_ERR2(XML_RELAXNG_ERR_ATTRVALID, node->name);
+                }
+            }
+            if (define->contModel != NULL) {
+                xmlRelaxNGValidStatePtr nstate, tmpstate = ctxt->state;
+                xmlRelaxNGStatesPtr tmpstates = ctxt->states;
+                xmlNodePtr nseq;
+
+                nstate = xmlRelaxNGNewValidState(ctxt, node);
+                ctxt->state = nstate;
+                ctxt->states = NULL;
+
+                tmp = xmlRelaxNGValidateCompiledContent(ctxt,
+                                                        define->contModel,
+                                                        ctxt->state->seq);
+                nseq = ctxt->state->seq;
+                ctxt->state = tmpstate;
+                ctxt->states = tmpstates;
+                xmlRelaxNGFreeValidState(ctxt, nstate);
+
+#ifdef DEBUG_COMPILE
+                xmlGenericError(xmlGenericErrorContext,
+                                "Validating content of '%s' : %d\n",
+                                define->name, tmp);
+#endif
+                if (tmp != 0)
+                    ret = -1;
+
+                if (ctxt->states != NULL) {
+                    tmp = -1;
+
+                    for (i = 0; i < ctxt->states->nbState; i++) {
+                        state = ctxt->states->tabState[i];
+                        ctxt->state = state;
+                        ctxt->state->seq = nseq;
+
+                        if (xmlRelaxNGValidateElementEnd(ctxt, 0) == 0) {
+                            tmp = 0;
+                            break;
+                        }
+                    }
+                    if (tmp != 0) {
+                        /*
+                         * validation error, log the message for the "best" one
+                         */
+                        ctxt->flags |= FLAGS_IGNORABLE;
+                        xmlRelaxNGLogBestError(ctxt);
+                    }
+                    for (i = 0; i < ctxt->states->nbState; i++) {
+                        xmlRelaxNGFreeValidState(ctxt,
+                                                 ctxt->states->
+                                                 tabState[i]);
+                    }
+                    xmlRelaxNGFreeStates(ctxt, ctxt->states);
+                    ctxt->flags = oldflags;
+                    ctxt->states = NULL;
+                    if ((ret == 0) && (tmp == -1))
+                        ret = -1;
+                } else {
+                    state = ctxt->state;
+                    ctxt->state->seq = nseq;
+                    if (ret == 0)
+                        ret = xmlRelaxNGValidateElementEnd(ctxt, 1);
+                    xmlRelaxNGFreeValidState(ctxt, state);
+                }
+            } else {
+                if (define->content != NULL) {
+                    tmp = xmlRelaxNGValidateDefinitionList(ctxt,
+                                                           define->
+                                                           content);
+                    if (tmp != 0) {
+                        ret = -1;
+                        if (ctxt->state == NULL) {
+                            ctxt->state = oldstate;
+                            VALID_ERR2(XML_RELAXNG_ERR_CONTENTVALID,
+                                       node->name);
+                            ctxt->state = NULL;
+                        } else {
+                            VALID_ERR2(XML_RELAXNG_ERR_CONTENTVALID,
+                                       node->name);
+                        }
+
+                    }
+                }
+                if (ctxt->states != NULL) {
+                    tmp = -1;
+
+                    for (i = 0; i < ctxt->states->nbState; i++) {
+                        state = ctxt->states->tabState[i];
+                        ctxt->state = state;
+
+                        if (xmlRelaxNGValidateElementEnd(ctxt, 0) == 0) {
+                            tmp = 0;
+                            break;
+                        }
+                    }
+                    if (tmp != 0) {
+                        /*
+                         * validation error, log the message for the "best" one
+                         */
+                        ctxt->flags |= FLAGS_IGNORABLE;
+                        xmlRelaxNGLogBestError(ctxt);
+                    }
+                    for (i = 0; i < ctxt->states->nbState; i++) {
+                        xmlRelaxNGFreeValidState(ctxt,
+                                                 ctxt->states->
+                                                 tabState[i]);
+                    }
+                    xmlRelaxNGFreeStates(ctxt, ctxt->states);
+                    ctxt->flags = oldflags;
+                    ctxt->states = NULL;
+                    if ((ret == 0) && (tmp == -1))
+                        ret = -1;
+                } else {
+                    state = ctxt->state;
+                    if (ret == 0)
+                        ret = xmlRelaxNGValidateElementEnd(ctxt, 1);
+                    xmlRelaxNGFreeValidState(ctxt, state);
+                }
+            }
+            if (ret == 0) {
+                node->psvi = define;
+            }
+            ctxt->flags = oldflags;
+            ctxt->state = oldstate;
+            if (oldstate != NULL)
+                oldstate->seq = xmlRelaxNGSkipIgnored(ctxt, node->next);
+            if (ret != 0) {
+                if ((ctxt->flags & FLAGS_IGNORABLE) == 0) {
+                    xmlRelaxNGDumpValidError(ctxt);
+                    ret = 0;
+                } else {
+                    ret = -2;
+                }
+            } else {
+                if (ctxt->errNr > errNr)
+                    xmlRelaxNGPopErrors(ctxt, errNr);
+            }
+
+#ifdef DEBUG
+            xmlGenericError(xmlGenericErrorContext,
+                            "xmlRelaxNGValidateDefinition(): validated %s : %d",
+                            node->name, ret);
+            if (oldstate == NULL)
+                xmlGenericError(xmlGenericErrorContext, ": no state\n");
+            else if (oldstate->seq == NULL)
+                xmlGenericError(xmlGenericErrorContext, ": done\n");
+            else if (oldstate->seq->type == XML_ELEMENT_NODE)
+                xmlGenericError(xmlGenericErrorContext, ": next elem %s\n",
+                                oldstate->seq->name);
+            else
+                xmlGenericError(xmlGenericErrorContext, ": next %s %d\n",
+                                oldstate->seq->name, oldstate->seq->type);
+#endif
+            break;
+        case XML_RELAXNG_OPTIONAL:{
+                errNr = ctxt->errNr;
+                oldflags = ctxt->flags;
+                ctxt->flags |= FLAGS_IGNORABLE;
+                oldstate = xmlRelaxNGCopyValidState(ctxt, ctxt->state);
+                ret =
+                    xmlRelaxNGValidateDefinitionList(ctxt,
+                                                     define->content);
+                if (ret != 0) {
+                    if (ctxt->state != NULL)
+                        xmlRelaxNGFreeValidState(ctxt, ctxt->state);
+                    ctxt->state = oldstate;
+                    ctxt->flags = oldflags;
+                    ret = 0;
+                    if (ctxt->errNr > errNr)
+                        xmlRelaxNGPopErrors(ctxt, errNr);
+                    break;
+                }
+                if (ctxt->states != NULL) {
+                    xmlRelaxNGAddStates(ctxt, ctxt->states, oldstate);
+                } else {
+                    ctxt->states = xmlRelaxNGNewStates(ctxt, 1);
+                    if (ctxt->states == NULL) {
+                        xmlRelaxNGFreeValidState(ctxt, oldstate);
+                        ctxt->flags = oldflags;
+                        ret = -1;
+                        if (ctxt->errNr > errNr)
+                            xmlRelaxNGPopErrors(ctxt, errNr);
+                        break;
+                    }
+                    xmlRelaxNGAddStates(ctxt, ctxt->states, oldstate);
+                    xmlRelaxNGAddStates(ctxt, ctxt->states, ctxt->state);
+                    ctxt->state = NULL;
+                }
+                ctxt->flags = oldflags;
+                ret = 0;
+                if (ctxt->errNr > errNr)
+                    xmlRelaxNGPopErrors(ctxt, errNr);
+                break;
+            }
+        case XML_RELAXNG_ONEORMORE:
+            errNr = ctxt->errNr;
+            ret = xmlRelaxNGValidateDefinitionList(ctxt, define->content);
+            if (ret != 0) {
+                break;
+            }
+            if (ctxt->errNr > errNr)
+                xmlRelaxNGPopErrors(ctxt, errNr);
+            /* no break on purpose */
+        case XML_RELAXNG_ZEROORMORE:{
+                int progress;
+                xmlRelaxNGStatesPtr states = NULL, res = NULL;
+                int base, j;
+
+                errNr = ctxt->errNr;
+                res = xmlRelaxNGNewStates(ctxt, 1);
+                if (res == NULL) {
+                    ret = -1;
+                    break;
+                }
+                /*
+                 * All the input states are also exit states
+                 */
+                if (ctxt->state != NULL) {
+                    xmlRelaxNGAddStates(ctxt, res,
+                                        xmlRelaxNGCopyValidState(ctxt,
+                                                                 ctxt->
+                                                                 state));
+                } else {
+                    for (j = 0; j < ctxt->states->nbState; j++) {
+                        xmlRelaxNGAddStates(ctxt, res,
+                                            xmlRelaxNGCopyValidState(ctxt,
+                                                                     ctxt->
+                                                                     states->
+                                                                     tabState
+                                                                     [j]));
+                    }
+                }
+                oldflags = ctxt->flags;
+                ctxt->flags |= FLAGS_IGNORABLE;
+                do {
+                    progress = 0;
+                    base = res->nbState;
+
+                    if (ctxt->states != NULL) {
+                        states = ctxt->states;
+                        for (i = 0; i < states->nbState; i++) {
+                            ctxt->state = states->tabState[i];
+                            ctxt->states = NULL;
+                            ret = xmlRelaxNGValidateDefinitionList(ctxt,
+                                                                   define->
+                                                                   content);
+                            if (ret == 0) {
+                                if (ctxt->state != NULL) {
+                                    tmp = xmlRelaxNGAddStates(ctxt, res,
+                                                              ctxt->state);
+                                    ctxt->state = NULL;
+                                    if (tmp == 1)
+                                        progress = 1;
+                                } else if (ctxt->states != NULL) {
+                                    for (j = 0; j < ctxt->states->nbState;
+                                         j++) {
+                                        tmp =
+                                            xmlRelaxNGAddStates(ctxt, res,
+                                                                ctxt->
+                                                                states->
+                                                                tabState
+                                                                [j]);
+                                        if (tmp == 1)
+                                            progress = 1;
+                                    }
+                                    xmlRelaxNGFreeStates(ctxt,
+                                                         ctxt->states);
+                                    ctxt->states = NULL;
+                                }
+                            } else {
+                                if (ctxt->state != NULL) {
+                                    xmlRelaxNGFreeValidState(ctxt,
+                                                             ctxt->state);
+                                    ctxt->state = NULL;
+                                }
+                            }
+                        }
+                    } else {
+                        ret = xmlRelaxNGValidateDefinitionList(ctxt,
+                                                               define->
+                                                               content);
+                        if (ret != 0) {
+                            xmlRelaxNGFreeValidState(ctxt, ctxt->state);
+                            ctxt->state = NULL;
+                        } else {
+                            base = res->nbState;
+                            if (ctxt->state != NULL) {
+                                tmp = xmlRelaxNGAddStates(ctxt, res,
+                                                          ctxt->state);
+                                ctxt->state = NULL;
+                                if (tmp == 1)
+                                    progress = 1;
+                            } else if (ctxt->states != NULL) {
+                                for (j = 0; j < ctxt->states->nbState; j++) {
+                                    tmp = xmlRelaxNGAddStates(ctxt, res,
+                                                              ctxt->
+                                                              states->
+                                                              tabState[j]);
+                                    if (tmp == 1)
+                                        progress = 1;
+                                }
+                                if (states == NULL) {
+                                    states = ctxt->states;
+                                } else {
+                                    xmlRelaxNGFreeStates(ctxt,
+                                                         ctxt->states);
+                                }
+                                ctxt->states = NULL;
+                            }
+                        }
+                    }
+                    if (progress) {
+                        /*
+                         * Collect all the new nodes added at that step
+                         * and make them the new node set
+                         */
+                        if (res->nbState - base == 1) {
+                            ctxt->state = xmlRelaxNGCopyValidState(ctxt,
+                                                                   res->
+                                                                   tabState
+                                                                   [base]);
+                        } else {
+                            if (states == NULL) {
+                                xmlRelaxNGNewStates(ctxt,
+                                                    res->nbState - base);
+                            }
+                            states->nbState = 0;
+                            for (i = base; i < res->nbState; i++)
+                                xmlRelaxNGAddStates(ctxt, states,
+                                                    xmlRelaxNGCopyValidState
+                                                    (ctxt,
+                                                     res->tabState[i]));
+                            ctxt->states = states;
+                        }
+                    }
+                } while (progress == 1);
+                if (states != NULL) {
+                    xmlRelaxNGFreeStates(ctxt, states);
+                }
+                ctxt->states = res;
+                ctxt->flags = oldflags;
+#if 0
+                /*
+                 * errors may have to be propagated back...
+                 */
+                if (ctxt->errNr > errNr)
+                    xmlRelaxNGPopErrors(ctxt, errNr);
+#endif
+                ret = 0;
+                break;
+            }
+        case XML_RELAXNG_CHOICE:{
+                xmlRelaxNGDefinePtr list = NULL;
+                xmlRelaxNGStatesPtr states = NULL;
+
+                node = xmlRelaxNGSkipIgnored(ctxt, node);
+
+                errNr = ctxt->errNr;
+                if ((define->dflags & IS_TRIABLE)
+                    && (define->data != NULL)) {
+                    xmlHashTablePtr triage =
+                        (xmlHashTablePtr) define->data;
+
+                    /*
+                     * Something we can optimize cleanly there is only one
+                     * possble branch out !
+                     */
+                    if (node == NULL) {
+                        ret = -1;
+                        break;
+                    }
+                    if ((node->type == XML_TEXT_NODE) ||
+                        (node->type == XML_CDATA_SECTION_NODE)) {
+                        list =
+                            xmlHashLookup2(triage, BAD_CAST "#text", NULL);
+                    } else if (node->type == XML_ELEMENT_NODE) {
+                        if (node->ns != NULL) {
+                            list = xmlHashLookup2(triage, node->name,
+                                                  node->ns->href);
+                            if (list == NULL)
+                                list =
+                                    xmlHashLookup2(triage, BAD_CAST "#any",
+                                                   node->ns->href);
+                        } else
+                            list =
+                                xmlHashLookup2(triage, node->name, NULL);
+                        if (list == NULL)
+                            list =
+                                xmlHashLookup2(triage, BAD_CAST "#any",
+                                               NULL);
+                    }
+                    if (list == NULL) {
+                        ret = -1;
+			VALID_ERR2(XML_RELAXNG_ERR_ELEMWRONG, node->name);
+                        break;
+                    }
+                    ret = xmlRelaxNGValidateDefinition(ctxt, list);
+                    if (ret == 0) {
+                    }
+                    break;
+                }
+
+                list = define->content;
+                oldflags = ctxt->flags;
+                ctxt->flags |= FLAGS_IGNORABLE;
+
+                while (list != NULL) {
+                    oldstate = xmlRelaxNGCopyValidState(ctxt, ctxt->state);
+                    ret = xmlRelaxNGValidateDefinition(ctxt, list);
+                    if (ret == 0) {
+                        if (states == NULL) {
+                            states = xmlRelaxNGNewStates(ctxt, 1);
+                        }
+                        if (ctxt->state != NULL) {
+                            xmlRelaxNGAddStates(ctxt, states, ctxt->state);
+                        } else if (ctxt->states != NULL) {
+                            for (i = 0; i < ctxt->states->nbState; i++) {
+                                xmlRelaxNGAddStates(ctxt, states,
+                                                    ctxt->states->
+                                                    tabState[i]);
+                            }
+                            xmlRelaxNGFreeStates(ctxt, ctxt->states);
+                            ctxt->states = NULL;
+                        }
+                    } else {
+                        xmlRelaxNGFreeValidState(ctxt, ctxt->state);
+                    }
+                    ctxt->state = oldstate;
+                    list = list->next;
+                }
+                if (states != NULL) {
+                    xmlRelaxNGFreeValidState(ctxt, oldstate);
+                    ctxt->states = states;
+                    ctxt->state = NULL;
+                    ret = 0;
+                } else {
+                    ctxt->states = NULL;
+                }
+                ctxt->flags = oldflags;
+                if (ret != 0) {
+                    if ((ctxt->flags & FLAGS_IGNORABLE) == 0) {
+                        xmlRelaxNGDumpValidError(ctxt);
+                    }
+                } else {
+                    if (ctxt->errNr > errNr)
+                        xmlRelaxNGPopErrors(ctxt, errNr);
+                }
+                break;
+            }
+        case XML_RELAXNG_DEF:
+        case XML_RELAXNG_GROUP:
+            ret = xmlRelaxNGValidateDefinitionList(ctxt, define->content);
+            break;
+        case XML_RELAXNG_INTERLEAVE:
+            ret = xmlRelaxNGValidateInterleave(ctxt, define);
+            break;
+        case XML_RELAXNG_ATTRIBUTE:
+            ret = xmlRelaxNGValidateAttribute(ctxt, define);
+            break;
+        case XML_RELAXNG_START:
+        case XML_RELAXNG_NOOP:
+        case XML_RELAXNG_REF:
+        case XML_RELAXNG_EXTERNALREF:
+        case XML_RELAXNG_PARENTREF:
+            ret = xmlRelaxNGValidateDefinition(ctxt, define->content);
+            break;
+        case XML_RELAXNG_DATATYPE:{
+                xmlNodePtr child;
+                xmlChar *content = NULL;
+
+                child = node;
+                while (child != NULL) {
+                    if (child->type == XML_ELEMENT_NODE) {
+                        VALID_ERR2(XML_RELAXNG_ERR_DATAELEM,
+                                   node->parent->name);
+                        ret = -1;
+                        break;
+                    } else if ((child->type == XML_TEXT_NODE) ||
+                               (child->type == XML_CDATA_SECTION_NODE)) {
+                        content = xmlStrcat(content, child->content);
+                    }
+                    /* TODO: handle entities ... */
+                    child = child->next;
+                }
+                if (ret == -1) {
+                    if (content != NULL)
+                        xmlFree(content);
+                    break;
+                }
+                if (content == NULL) {
+                    content = xmlStrdup(BAD_CAST "");
+                    if (content == NULL) {
+                        xmlRngVErrMemory(ctxt, "validating\n");
+                        ret = -1;
+                        break;
+                    }
+                }
+                ret = xmlRelaxNGValidateDatatype(ctxt, content, define,
+                                                 ctxt->state->seq);
+                if (ret == -1) {
+                    VALID_ERR2(XML_RELAXNG_ERR_DATATYPE, define->name);
+                } else if (ret == 0) {
+                    ctxt->state->seq = NULL;
+                }
+                if (content != NULL)
+                    xmlFree(content);
+                break;
+            }
+        case XML_RELAXNG_VALUE:{
+                xmlChar *content = NULL;
+                xmlChar *oldvalue;
+                xmlNodePtr child;
+
+                child = node;
+                while (child != NULL) {
+                    if (child->type == XML_ELEMENT_NODE) {
+                        VALID_ERR2(XML_RELAXNG_ERR_VALELEM,
+                                   node->parent->name);
+                        ret = -1;
+                        break;
+                    } else if ((child->type == XML_TEXT_NODE) ||
+                               (child->type == XML_CDATA_SECTION_NODE)) {
+                        content = xmlStrcat(content, child->content);
+                    }
+                    /* TODO: handle entities ... */
+                    child = child->next;
+                }
+                if (ret == -1) {
+                    if (content != NULL)
+                        xmlFree(content);
+                    break;
+                }
+                if (content == NULL) {
+                    content = xmlStrdup(BAD_CAST "");
+                    if (content == NULL) {
+                        xmlRngVErrMemory(ctxt, "validating\n");
+                        ret = -1;
+                        break;
+                    }
+                }
+                oldvalue = ctxt->state->value;
+                ctxt->state->value = content;
+                ret = xmlRelaxNGValidateValue(ctxt, define);
+                ctxt->state->value = oldvalue;
+                if (ret == -1) {
+                    VALID_ERR2(XML_RELAXNG_ERR_VALUE, define->name);
+                } else if (ret == 0) {
+                    ctxt->state->seq = NULL;
+                }
+                if (content != NULL)
+                    xmlFree(content);
+                break;
+            }
+        case XML_RELAXNG_LIST:{
+                xmlChar *content;
+                xmlNodePtr child;
+                xmlChar *oldvalue, *oldendvalue;
+                int len;
+
+                /*
+                 * Make sure it's only text nodes
+                 */
+
+                content = NULL;
+                child = node;
+                while (child != NULL) {
+                    if (child->type == XML_ELEMENT_NODE) {
+                        VALID_ERR2(XML_RELAXNG_ERR_LISTELEM,
+                                   node->parent->name);
+                        ret = -1;
+                        break;
+                    } else if ((child->type == XML_TEXT_NODE) ||
+                               (child->type == XML_CDATA_SECTION_NODE)) {
+                        content = xmlStrcat(content, child->content);
+                    }
+                    /* TODO: handle entities ... */
+                    child = child->next;
+                }
+                if (ret == -1) {
+                    if (content != NULL)
+                        xmlFree(content);
+                    break;
+                }
+                if (content == NULL) {
+                    content = xmlStrdup(BAD_CAST "");
+                    if (content == NULL) {
+                        xmlRngVErrMemory(ctxt, "validating\n");
+                        ret = -1;
+                        break;
+                    }
+                }
+                len = xmlStrlen(content);
+                oldvalue = ctxt->state->value;
+                oldendvalue = ctxt->state->endvalue;
+                ctxt->state->value = content;
+                ctxt->state->endvalue = content + len;
+                ret = xmlRelaxNGValidateValue(ctxt, define);
+                ctxt->state->value = oldvalue;
+                ctxt->state->endvalue = oldendvalue;
+                if (ret == -1) {
+                    VALID_ERR(XML_RELAXNG_ERR_LIST);
+                } else if ((ret == 0) && (node != NULL)) {
+                    ctxt->state->seq = node->next;
+                }
+                if (content != NULL)
+                    xmlFree(content);
+                break;
+            }
+        case XML_RELAXNG_EXCEPT:
+        case XML_RELAXNG_PARAM:
+            TODO ret = -1;
+            break;
+    }
+    ctxt->depth--;
+#ifdef DEBUG
+    for (i = 0; i < ctxt->depth; i++)
+        xmlGenericError(xmlGenericErrorContext, " ");
+    xmlGenericError(xmlGenericErrorContext,
+                    "Validating %s ", xmlRelaxNGDefName(define));
+    if (define->name != NULL)
+        xmlGenericError(xmlGenericErrorContext, "%s ", define->name);
+    if (ret == 0)
+        xmlGenericError(xmlGenericErrorContext, "suceeded\n");
+    else
+        xmlGenericError(xmlGenericErrorContext, "failed\n");
+#endif
+    return (ret);
+}
+
+/**
+ * xmlRelaxNGValidateDefinition:
+ * @ctxt:  a Relax-NG validation context
+ * @define:  the definition to verify
+ *
+ * Validate the current node lists against the definition
+ *
+ * Returns 0 if the validation succeeded or an error code.
+ */
+static int
+xmlRelaxNGValidateDefinition(xmlRelaxNGValidCtxtPtr ctxt,
+                             xmlRelaxNGDefinePtr define)
+{
+    xmlRelaxNGStatesPtr states, res;
+    int i, j, k, ret, oldflags;
+
+    /*
+     * We should NOT have both ctxt->state and ctxt->states
+     */
+    if ((ctxt->state != NULL) && (ctxt->states != NULL)) {
+        TODO xmlRelaxNGFreeValidState(ctxt, ctxt->state);
+        ctxt->state = NULL;
+    }
+
+    if ((ctxt->states == NULL) || (ctxt->states->nbState == 1)) {
+        if (ctxt->states != NULL) {
+            ctxt->state = ctxt->states->tabState[0];
+            xmlRelaxNGFreeStates(ctxt, ctxt->states);
+            ctxt->states = NULL;
+        }
+        ret = xmlRelaxNGValidateState(ctxt, define);
+        if ((ctxt->state != NULL) && (ctxt->states != NULL)) {
+            TODO xmlRelaxNGFreeValidState(ctxt, ctxt->state);
+            ctxt->state = NULL;
+        }
+        if ((ctxt->states != NULL) && (ctxt->states->nbState == 1)) {
+            ctxt->state = ctxt->states->tabState[0];
+            xmlRelaxNGFreeStates(ctxt, ctxt->states);
+            ctxt->states = NULL;
+        }
+        return (ret);
+    }
+
+    states = ctxt->states;
+    ctxt->states = NULL;
+    res = NULL;
+    j = 0;
+    oldflags = ctxt->flags;
+    ctxt->flags |= FLAGS_IGNORABLE;
+    for (i = 0; i < states->nbState; i++) {
+        ctxt->state = states->tabState[i];
+        ctxt->states = NULL;
+        ret = xmlRelaxNGValidateState(ctxt, define);
+        /*
+         * We should NOT have both ctxt->state and ctxt->states
+         */
+        if ((ctxt->state != NULL) && (ctxt->states != NULL)) {
+            TODO xmlRelaxNGFreeValidState(ctxt, ctxt->state);
+            ctxt->state = NULL;
+        }
+        if (ret == 0) {
+            if (ctxt->states == NULL) {
+                if (res != NULL) {
+                    /* add the state to the container */
+                    xmlRelaxNGAddStates(ctxt, res, ctxt->state);
+                    ctxt->state = NULL;
+                } else {
+                    /* add the state directly in states */
+                    states->tabState[j++] = ctxt->state;
+                    ctxt->state = NULL;
+                }
+            } else {
+                if (res == NULL) {
+                    /* make it the new container and copy other results */
+                    res = ctxt->states;
+                    ctxt->states = NULL;
+                    for (k = 0; k < j; k++)
+                        xmlRelaxNGAddStates(ctxt, res,
+                                            states->tabState[k]);
+                } else {
+                    /* add all the new results to res and reff the container */
+                    for (k = 0; k < ctxt->states->nbState; k++)
+                        xmlRelaxNGAddStates(ctxt, res,
+                                            ctxt->states->tabState[k]);
+                    xmlRelaxNGFreeStates(ctxt, ctxt->states);
+                    ctxt->states = NULL;
+                }
+            }
+        } else {
+            if (ctxt->state != NULL) {
+                xmlRelaxNGFreeValidState(ctxt, ctxt->state);
+                ctxt->state = NULL;
+            } else if (ctxt->states != NULL) {
+                for (k = 0; k < ctxt->states->nbState; k++)
+                    xmlRelaxNGFreeValidState(ctxt,
+                                             ctxt->states->tabState[k]);
+                xmlRelaxNGFreeStates(ctxt, ctxt->states);
+                ctxt->states = NULL;
+            }
+        }
+    }
+    ctxt->flags = oldflags;
+    if (res != NULL) {
+        xmlRelaxNGFreeStates(ctxt, states);
+        ctxt->states = res;
+        ret = 0;
+    } else if (j > 1) {
+        states->nbState = j;
+        ctxt->states = states;
+        ret = 0;
+    } else if (j == 1) {
+        ctxt->state = states->tabState[0];
+        xmlRelaxNGFreeStates(ctxt, states);
+        ret = 0;
+    } else {
+        ret = -1;
+        xmlRelaxNGFreeStates(ctxt, states);
+        if (ctxt->states != NULL) {
+            xmlRelaxNGFreeStates(ctxt, ctxt->states);
+            ctxt->states = NULL;
+        }
+    }
+    if ((ctxt->state != NULL) && (ctxt->states != NULL)) {
+        TODO xmlRelaxNGFreeValidState(ctxt, ctxt->state);
+        ctxt->state = NULL;
+    }
+    return (ret);
+}
+
+/**
+ * xmlRelaxNGValidateDocument:
+ * @ctxt:  a Relax-NG validation context
+ * @doc:  the document
+ *
+ * Validate the given document
+ *
+ * Returns 0 if the validation succeeded or an error code.
+ */
+static int
+xmlRelaxNGValidateDocument(xmlRelaxNGValidCtxtPtr ctxt, xmlDocPtr doc)
+{
+    int ret;
+    xmlRelaxNGPtr schema;
+    xmlRelaxNGGrammarPtr grammar;
+    xmlRelaxNGValidStatePtr state;
+    xmlNodePtr node;
+
+    if ((ctxt == NULL) || (ctxt->schema == NULL) || (doc == NULL))
+        return (-1);
+
+    ctxt->errNo = XML_RELAXNG_OK;
+    schema = ctxt->schema;
+    grammar = schema->topgrammar;
+    if (grammar == NULL) {
+        VALID_ERR(XML_RELAXNG_ERR_NOGRAMMAR);
+        return (-1);
+    }
+    state = xmlRelaxNGNewValidState(ctxt, NULL);
+    ctxt->state = state;
+    ret = xmlRelaxNGValidateDefinition(ctxt, grammar->start);
+    if ((ctxt->state != NULL) && (state->seq != NULL)) {
+        state = ctxt->state;
+        node = state->seq;
+        node = xmlRelaxNGSkipIgnored(ctxt, node);
+        if (node != NULL) {
+            if (ret != -1) {
+                VALID_ERR(XML_RELAXNG_ERR_EXTRADATA);
+                ret = -1;
+            }
+        }
+    } else if (ctxt->states != NULL) {
+        int i;
+        int tmp = -1;
+
+        for (i = 0; i < ctxt->states->nbState; i++) {
+            state = ctxt->states->tabState[i];
+            node = state->seq;
+            node = xmlRelaxNGSkipIgnored(ctxt, node);
+            if (node == NULL)
+                tmp = 0;
+            xmlRelaxNGFreeValidState(ctxt, state);
+        }
+        if (tmp == -1) {
+            if (ret != -1) {
+                VALID_ERR(XML_RELAXNG_ERR_EXTRADATA);
+                ret = -1;
+            }
+        }
+    }
+    if (ctxt->state != NULL) {
+        xmlRelaxNGFreeValidState(ctxt, ctxt->state);
+        ctxt->state = NULL;
+    }
+    if (ret != 0)
+        xmlRelaxNGDumpValidError(ctxt);
+#ifdef DEBUG
+    else if (ctxt->errNr != 0) {
+        ctxt->error(ctxt->userData,
+                    "%d Extra error messages left on stack !\n",
+                    ctxt->errNr);
+        xmlRelaxNGDumpValidError(ctxt);
+    }
+#endif
+#ifdef LIBXML_VALID_ENABLED
+    if (ctxt->idref == 1) {
+        xmlValidCtxt vctxt;
+
+        memset(&vctxt, 0, sizeof(xmlValidCtxt));
+        vctxt.valid = 1;
+        vctxt.error = ctxt->error;
+        vctxt.warning = ctxt->warning;
+        vctxt.userData = ctxt->userData;
+
+        if (xmlValidateDocumentFinal(&vctxt, doc) != 1)
+            ret = -1;
+    }
+#endif /* LIBXML_VALID_ENABLED */
+    if ((ret == 0) && (ctxt->errNo != XML_RELAXNG_OK))
+        ret = -1;
+
+    return (ret);
+}
+
+/************************************************************************
+ * 									*
+ * 			Validation interfaces				*
+ * 									*
+ ************************************************************************/
+
+/**
+ * xmlRelaxNGNewValidCtxt:
+ * @schema:  a precompiled XML RelaxNGs
+ *
+ * Create an XML RelaxNGs validation context based on the given schema
+ *
+ * Returns the validation context or NULL in case of error
+ */
+xmlRelaxNGValidCtxtPtr
+xmlRelaxNGNewValidCtxt(xmlRelaxNGPtr schema)
+{
+    xmlRelaxNGValidCtxtPtr ret;
+
+    ret = (xmlRelaxNGValidCtxtPtr) xmlMalloc(sizeof(xmlRelaxNGValidCtxt));
+    if (ret == NULL) {
+        xmlRngVErrMemory(NULL, "building context\n");
+        return (NULL);
+    }
+    memset(ret, 0, sizeof(xmlRelaxNGValidCtxt));
+    ret->schema = schema;
+    ret->error = xmlGenericError;
+    ret->userData = xmlGenericErrorContext;
+    ret->errNr = 0;
+    ret->errMax = 0;
+    ret->err = NULL;
+    ret->errTab = NULL;
+    ret->idref = schema->idref;
+    ret->states = NULL;
+    ret->freeState = NULL;
+    ret->freeStates = NULL;
+    ret->errNo = XML_RELAXNG_OK;
+    return (ret);
+}
+
+/**
+ * xmlRelaxNGFreeValidCtxt:
+ * @ctxt:  the schema validation context
+ *
+ * Free the resources associated to the schema validation context
+ */
+void
+xmlRelaxNGFreeValidCtxt(xmlRelaxNGValidCtxtPtr ctxt)
+{
+    int k;
+
+    if (ctxt == NULL)
+        return;
+    if (ctxt->states != NULL)
+        xmlRelaxNGFreeStates(NULL, ctxt->states);
+    if (ctxt->freeState != NULL) {
+        for (k = 0; k < ctxt->freeState->nbState; k++) {
+            xmlRelaxNGFreeValidState(NULL, ctxt->freeState->tabState[k]);
+        }
+        xmlRelaxNGFreeStates(NULL, ctxt->freeState);
+    }
+    if (ctxt->freeStates != NULL) {
+        for (k = 0; k < ctxt->freeStatesNr; k++) {
+            xmlRelaxNGFreeStates(NULL, ctxt->freeStates[k]);
+        }
+        xmlFree(ctxt->freeStates);
+    }
+    if (ctxt->errTab != NULL)
+        xmlFree(ctxt->errTab);
+    if (ctxt->elemTab != NULL) {
+        xmlRegExecCtxtPtr exec;
+
+        exec = xmlRelaxNGElemPop(ctxt);
+        while (exec != NULL) {
+            xmlRegFreeExecCtxt(exec);
+            exec = xmlRelaxNGElemPop(ctxt);
+        }
+        xmlFree(ctxt->elemTab);
+    }
+    xmlFree(ctxt);
+}
+
+/**
+ * xmlRelaxNGSetValidErrors:
+ * @ctxt:  a Relax-NG validation context
+ * @err:  the error function
+ * @warn: the warning function
+ * @ctx: the functions context
+ *
+ * Set the error and warning callback informations
+ */
+void
+xmlRelaxNGSetValidErrors(xmlRelaxNGValidCtxtPtr ctxt,
+                         xmlRelaxNGValidityErrorFunc err,
+                         xmlRelaxNGValidityWarningFunc warn, void *ctx)
+{
+    if (ctxt == NULL)
+        return;
+    ctxt->error = err;
+    ctxt->warning = warn;
+    ctxt->userData = ctx;
+}
+
+/**
+ * xmlRelaxNGGetValidErrors:
+ * @ctxt:  a Relax-NG validation context
+ * @err:  the error function result
+ * @warn: the warning function result
+ * @ctx: the functions context result
+ *
+ * Get the error and warning callback informations
+ *
+ * Returns -1 in case of error and 0 otherwise
+ */
+int
+xmlRelaxNGGetValidErrors(xmlRelaxNGValidCtxtPtr ctxt,
+                         xmlRelaxNGValidityErrorFunc * err,
+                         xmlRelaxNGValidityWarningFunc * warn, void **ctx)
+{
+    if (ctxt == NULL)
+        return (-1);
+    if (err != NULL)
+        *err = ctxt->error;
+    if (warn != NULL)
+        *warn = ctxt->warning;
+    if (ctx != NULL)
+        *ctx = ctxt->userData;
+    return (0);
+}
+
+/**
+ * xmlRelaxNGValidateDoc:
+ * @ctxt:  a Relax-NG validation context
+ * @doc:  a parsed document tree
+ *
+ * Validate a document tree in memory.
+ *
+ * Returns 0 if the document is valid, a positive error code
+ *     number otherwise and -1 in case of internal or API error.
+ */
+int
+xmlRelaxNGValidateDoc(xmlRelaxNGValidCtxtPtr ctxt, xmlDocPtr doc)
+{
+    int ret;
+
+    if ((ctxt == NULL) || (doc == NULL))
+        return (-1);
+
+    ctxt->doc = doc;
+
+    ret = xmlRelaxNGValidateDocument(ctxt, doc);
+    /*
+     * TODO: build error codes
+     */
+    if (ret == -1)
+        return (1);
+    return (ret);
+}
+
+#endif /* LIBXML_SCHEMAS_ENABLED */
diff --git a/src/libxml/src/testAutomata.c b/src/libxml/src/testAutomata.c
new file mode 100644
index 0000000..a168a4b
--- /dev/null
+++ b/src/libxml/src/testAutomata.c
@@ -0,0 +1,307 @@
+/*
+ * testRegexp.c: simple module for testing regular expressions
+ *
+ * See Copyright for the status of this software.
+ *
+ * Daniel Veillard <veillard@redhat.com>
+ */
+
+#include <string.h>
+#include "libxml.h"
+#ifdef LIBXML_AUTOMATA_ENABLED
+
+#include <libxml/tree.h>
+#include <libxml/xmlautomata.h>
+
+static int scanNumber(char **ptr) {
+    int ret = 0;
+    char *cur;
+
+    cur = *ptr;
+    while ((*cur >= '0') && (*cur <= '9')) {
+	ret = ret * 10 + (*cur - '0');
+	cur++;
+    }
+    *ptr = cur;
+    return(ret);
+}
+
+static void
+testRegexpFile(const char *filename) {
+    FILE *input;
+    char expr[5000];
+    int len;
+    int ret;
+    int i;
+    xmlAutomataPtr am;
+    xmlAutomataStatePtr states[1000];
+    xmlRegexpPtr regexp = NULL;
+    xmlRegExecCtxtPtr exec = NULL;
+
+    for (i = 0;i<1000;i++)
+	states[i] = NULL;
+
+    input = fopen(filename, "r");
+    if (input == NULL) {
+        xmlGenericError(xmlGenericErrorContext,
+		"Cannot open %s for reading\n", filename);
+	return;
+    }
+
+    am = xmlNewAutomata();
+    if (am == NULL) {
+        xmlGenericError(xmlGenericErrorContext,
+		"Cannot create automata\n");
+	fclose(input);
+    }
+    states[0] = xmlAutomataGetInitState(am);
+    if (states[0] == NULL) {
+        xmlGenericError(xmlGenericErrorContext,
+		"Cannot get start state\n");
+	xmlFreeAutomata(am);
+	fclose(input);
+    }
+    ret = 0;
+
+    while (fgets(expr, 4500, input) != NULL) {
+	if (expr[0] == '#')
+	    continue;
+	len = strlen(expr);
+	len--;
+	while ((len >= 0) && 
+	       ((expr[len] == '\n') || (expr[len] == '\t') ||
+		(expr[len] == '\r') || (expr[len] == ' '))) len--;
+	expr[len + 1] = 0;      
+	if (len >= 0) {
+	    if ((am != NULL) && (expr[0] == 't') && (expr[1] == ' ')) {
+		char *ptr = &expr[2];
+		int from, to;
+
+		from = scanNumber(&ptr);
+		if (*ptr != ' ') {
+		    xmlGenericError(xmlGenericErrorContext,
+			    "Bad line %s\n", expr);
+		    break;
+		}
+		if (states[from] == NULL)
+		    states[from] = xmlAutomataNewState(am);
+		ptr++;
+		to = scanNumber(&ptr);
+		if (*ptr != ' ') {
+		    xmlGenericError(xmlGenericErrorContext,
+			    "Bad line %s\n", expr);
+		    break;
+		}
+		if (states[to] == NULL)
+		    states[to] = xmlAutomataNewState(am);
+		ptr++;
+		xmlAutomataNewTransition(am, states[from], states[to],
+			                 BAD_CAST ptr, NULL);
+	    } else if ((am != NULL) && (expr[0] == 'e') && (expr[1] == ' ')) {
+		char *ptr = &expr[2];
+		int from, to;
+
+		from = scanNumber(&ptr);
+		if (*ptr != ' ') {
+		    xmlGenericError(xmlGenericErrorContext,
+			    "Bad line %s\n", expr);
+		    break;
+		}
+		if (states[from] == NULL)
+		    states[from] = xmlAutomataNewState(am);
+		ptr++;
+		to = scanNumber(&ptr);
+		if (states[to] == NULL)
+		    states[to] = xmlAutomataNewState(am);
+		xmlAutomataNewEpsilon(am, states[from], states[to]);
+	    } else if ((am != NULL) && (expr[0] == 'f') && (expr[1] == ' ')) {
+		char *ptr = &expr[2];
+		int state;
+
+		state = scanNumber(&ptr);
+		if (states[state] == NULL) {
+		    xmlGenericError(xmlGenericErrorContext,
+			    "Bad state %d : %s\n", state, expr);
+		    break;
+		}
+		xmlAutomataSetFinalState(am, states[state]);
+	    } else if ((am != NULL) && (expr[0] == 'c') && (expr[1] == ' ')) {
+		char *ptr = &expr[2];
+		int from, to;
+		int min, max;
+
+		from = scanNumber(&ptr);
+		if (*ptr != ' ') {
+		    xmlGenericError(xmlGenericErrorContext,
+			    "Bad line %s\n", expr);
+		    break;
+		}
+		if (states[from] == NULL)
+		    states[from] = xmlAutomataNewState(am);
+		ptr++;
+		to = scanNumber(&ptr);
+		if (*ptr != ' ') {
+		    xmlGenericError(xmlGenericErrorContext,
+			    "Bad line %s\n", expr);
+		    break;
+		}
+		if (states[to] == NULL)
+		    states[to] = xmlAutomataNewState(am);
+		ptr++;
+		min = scanNumber(&ptr);
+		if (*ptr != ' ') {
+		    xmlGenericError(xmlGenericErrorContext,
+			    "Bad line %s\n", expr);
+		    break;
+		}
+		ptr++;
+		max = scanNumber(&ptr);
+		if (*ptr != ' ') {
+		    xmlGenericError(xmlGenericErrorContext,
+			    "Bad line %s\n", expr);
+		    break;
+		}
+		ptr++;
+		xmlAutomataNewCountTrans(am, states[from], states[to],
+			                 BAD_CAST ptr, min, max, NULL);
+	    } else if ((am != NULL) && (expr[0] == '-') && (expr[1] == '-')) {
+		/* end of the automata */
+		regexp = xmlAutomataCompile(am);
+		xmlFreeAutomata(am);
+		am = NULL;
+		if (regexp == NULL) {
+		    xmlGenericError(xmlGenericErrorContext,
+			    "Failed to compile the automata");
+		    break;
+		}
+	    } else if ((expr[0] == '=') && (expr[1] == '>')) {
+		if (regexp == NULL) {
+		    printf("=> failed not compiled\n");
+		} else {
+		    if (exec == NULL)
+			exec = xmlRegNewExecCtxt(regexp, NULL, NULL);
+		    if (ret == 0) {
+			ret = xmlRegExecPushString(exec, NULL, NULL);
+		    }
+		    if (ret == 1)
+			printf("=> Passed\n");
+		    else if ((ret == 0) || (ret == -1))
+			printf("=> Failed\n");
+		    else if (ret < 0)
+			printf("=> Error\n");
+		    xmlRegFreeExecCtxt(exec);
+		    exec = NULL;
+		}
+		ret = 0;
+	    } else if (regexp != NULL) {
+		if (exec == NULL)
+		    exec = xmlRegNewExecCtxt(regexp, NULL, NULL);
+		ret = xmlRegExecPushString(exec, BAD_CAST expr, NULL);
+	    } else {
+		xmlGenericError(xmlGenericErrorContext,
+			"Unexpected line %s\n", expr);
+	    }
+	}
+    }
+    fclose(input);
+    if (regexp != NULL)
+	xmlRegFreeRegexp(regexp);
+    if (exec != NULL)
+	xmlRegFreeExecCtxt(exec);
+    if (am != NULL)
+	xmlFreeAutomata(am);
+}
+
+int main(int argc, char **argv) {
+
+    xmlInitMemory();
+
+    if (argc == 1) {
+	int ret;
+	xmlAutomataPtr am;
+	xmlAutomataStatePtr start, cur;
+	xmlRegexpPtr regexp;
+	xmlRegExecCtxtPtr exec;
+
+	am = xmlNewAutomata();
+	start = xmlAutomataGetInitState(am);
+
+	/* generate a[ba]*a */
+	cur = xmlAutomataNewTransition(am, start, NULL, BAD_CAST"a", NULL);
+	xmlAutomataNewTransition(am, cur, cur, BAD_CAST"b", NULL);
+	xmlAutomataNewTransition(am, cur, cur, BAD_CAST"a", NULL);
+	cur = xmlAutomataNewCountTrans(am, cur, NULL, BAD_CAST"a", 2, 3, NULL);
+	xmlAutomataSetFinalState(am, cur);
+
+	/* compile it in a regexp and free the automata */
+	regexp = xmlAutomataCompile(am);
+	xmlFreeAutomata(am);
+
+	/* test the regexp */
+	xmlRegexpPrint(stdout, regexp);
+	exec = xmlRegNewExecCtxt(regexp, NULL, NULL);
+	ret = xmlRegExecPushString(exec, BAD_CAST"a", NULL);
+	if (ret == 1)
+	    printf("final\n");
+	else if (ret < 0)
+	    printf("error\n");
+	ret =xmlRegExecPushString(exec, BAD_CAST"a", NULL);
+	if (ret == 1)
+	    printf("final\n");
+	else if (ret < 0)
+	    printf("error\n");
+	ret =xmlRegExecPushString(exec, BAD_CAST"b", NULL);
+	if (ret == 1)
+	    printf("final\n");
+	else if (ret < 0)
+	    printf("error\n");
+	ret =xmlRegExecPushString(exec, BAD_CAST"a", NULL);
+	if (ret == 1)
+	    printf("final\n");
+	else if (ret < 0)
+	    printf("error\n");
+	ret =xmlRegExecPushString(exec, BAD_CAST"a", NULL);
+	if (ret == 1)
+	    printf("final\n");
+	else if (ret < 0)
+	    printf("error\n");
+	ret =xmlRegExecPushString(exec, BAD_CAST"a", NULL);
+	if (ret == 1)
+	    printf("final\n");
+	else if (ret < 0)
+	    printf("error\n");
+	ret =xmlRegExecPushString(exec, BAD_CAST"a", NULL);
+	if (ret == 1)
+	    printf("final\n");
+	else if (ret < 0)
+	    printf("error\n");
+	if (ret == 0) {
+	    ret = xmlRegExecPushString(exec, NULL, NULL);
+	    if (ret == 1)
+		printf("final\n");
+	    else if (ret < 0)
+		printf("error\n");
+	}
+	xmlRegFreeExecCtxt(exec);
+
+	/* free the regexp */
+	xmlRegFreeRegexp(regexp);
+    } else {
+	int i;
+
+	for (i = 1;i < argc;i++)
+	    testRegexpFile(argv[i]);
+    }
+
+    xmlCleanupParser();
+    xmlMemoryDump();
+    return(0);
+}
+
+#else
+#include <stdio.h>
+int main(int argc ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED) {
+    printf("%s : Automata support not compiled in\n", argv[0]);
+    return(0);
+}
+#endif /* LIBXML_AUTOMATA_ENABLED */
diff --git a/src/libxml/src/testC14N.c b/src/libxml/src/testC14N.c
new file mode 100644
index 0000000..6a36a68
--- /dev/null
+++ b/src/libxml/src/testC14N.c
@@ -0,0 +1,357 @@
+/*
+ * Canonical XML implementation test program
+ * (http://www.w3.org/TR/2001/REC-xml-c14n-20010315)
+ *
+ * See Copyright for the status of this software.
+ * 
+ * Author: Aleksey Sanin <aleksey@aleksey.com>
+ */
+#include "libxml.h"
+#if defined(LIBXML_C14N_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
+
+#include <stdio.h>
+#include <string.h>
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+
+#include <libxml/xmlmemory.h>
+#include <libxml/parser.h>
+#include <libxml/xpath.h>
+#include <libxml/xpathInternals.h>
+
+#include <libxml/c14n.h>
+
+
+static void usage(const char *name) {
+    fprintf(stderr,
+	"Usage: %s <mode> <xml-file> [<xpath-expr>] [<inclusive-ns-list>]\n",
+	    name);
+    fprintf(stderr, "where <mode> is one of following:\n");
+    fprintf(stderr,
+	"--with-comments       \t XML file canonization w comments\n");
+    fprintf(stderr,
+	"--without-comments    \t XML file canonization w/o comments\n");
+    fprintf(stderr,
+    "--exc-with-comments   \t Exclusive XML file canonization w comments\n");
+    fprintf(stderr,
+    "--exc-without-comments\t Exclusive XML file canonization w/o comments\n");
+}
+
+static xmlXPathObjectPtr
+load_xpath_expr (xmlDocPtr parent_doc, const char* filename);
+
+static xmlChar **parse_list(xmlChar *str);
+
+/* static void print_xpath_nodes(xmlNodeSetPtr nodes); */
+
+static int 
+test_c14n(const char* xml_filename, int with_comments, int exclusive,
+	const char* xpath_filename, xmlChar **inclusive_namespaces) {
+    xmlDocPtr doc;
+    xmlXPathObjectPtr xpath = NULL; 
+    xmlChar *result = NULL;
+    int ret;
+
+    /*
+     * build an XML tree from a the file; we need to add default
+     * attributes and resolve all character and entities references
+     */
+    xmlLoadExtDtdDefaultValue = XML_DETECT_IDS | XML_COMPLETE_ATTRS;
+    xmlSubstituteEntitiesDefault(1);
+
+    doc = xmlParseFile(xml_filename);
+    if (doc == NULL) {
+	fprintf(stderr, "Error: unable to parse file \"%s\"\n", xml_filename);
+	return(-1);
+    }
+    
+    /*
+     * Check the document is of the right kind
+     */    
+    if(xmlDocGetRootElement(doc) == NULL) {
+        fprintf(stderr,"Error: empty document for file \"%s\"\n", xml_filename);
+	xmlFreeDoc(doc);
+	return(-1);
+    }
+
+    /* 
+     * load xpath file if specified 
+     */
+    if(xpath_filename) {
+	xpath = load_xpath_expr(doc, xpath_filename);
+	if(xpath == NULL) {
+	    fprintf(stderr,"Error: unable to evaluate xpath expression\n");
+	    xmlFreeDoc(doc); 
+	    return(-1);
+	}
+    }
+
+    /*
+     * Canonical form
+     */      
+    /* fprintf(stderr,"File \"%s\" loaded: start canonization\n", xml_filename); */
+    ret = xmlC14NDocDumpMemory(doc, 
+	    (xpath) ? xpath->nodesetval : NULL, 
+	    exclusive, inclusive_namespaces,
+	    with_comments, &result);
+    if(ret >= 0) {
+	if(result != NULL) {
+	    write(1, result, ret);
+	    xmlFree(result);          
+	}
+    } else {
+	fprintf(stderr,"Error: failed to canonicalize XML file \"%s\" (ret=%d)\n", xml_filename, ret);
+	if(result != NULL) xmlFree(result);
+	xmlFreeDoc(doc); 
+	return(-1);
+    }
+        
+    /*
+     * Cleanup
+     */ 
+    if(xpath != NULL) xmlXPathFreeObject(xpath);
+    xmlFreeDoc(doc);    
+
+    return(ret);
+}
+
+int main(int argc, char **argv) {
+    int ret = -1;
+    
+    /*
+     * Init libxml
+     */     
+    xmlInitParser();
+    LIBXML_TEST_VERSION
+
+    /*
+     * Parse command line and process file
+     */
+    if( argc < 3 ) {
+	fprintf(stderr, "Error: wrong number of arguments.\n");
+	usage(argv[0]);
+    } else if(strcmp(argv[1], "--with-comments") == 0) {
+	ret = test_c14n(argv[2], 1, 0, (argc > 3) ? argv[3] : NULL, NULL);
+    } else if(strcmp(argv[1], "--without-comments") == 0) {
+	ret = test_c14n(argv[2], 0, 0, (argc > 3) ? argv[3] : NULL, NULL);
+    } else if(strcmp(argv[1], "--exc-with-comments") == 0) {
+	xmlChar **list;
+	
+	/* load exclusive namespace from command line */
+	list = (argc > 4) ? parse_list((xmlChar *)argv[4]) : NULL;
+	ret = test_c14n(argv[2], 1, 1, (argc > 3) ? argv[3] : NULL, list);
+	if(list != NULL) xmlFree(list);
+    } else if(strcmp(argv[1], "--exc-without-comments") == 0) {
+	xmlChar **list;
+	
+	/* load exclusive namespace from command line */
+	list = (argc > 4) ? parse_list((xmlChar *)argv[4]) : NULL;
+	ret = test_c14n(argv[2], 0, 1, (argc > 3) ? argv[3] : NULL, list);
+	if(list != NULL) xmlFree(list);
+    } else {
+	fprintf(stderr, "Error: bad option.\n");
+	usage(argv[0]);
+    }
+
+    /* 
+     * Shutdown libxml
+     */
+    xmlCleanupParser();
+    xmlMemoryDump();
+    
+    return((ret >= 0) ? 0 : 1);
+}
+
+/*
+ * Macro used to grow the current buffer.
+ */
+#define growBufferReentrant() {						\
+    buffer_size *= 2;							\
+    buffer = (xmlChar **)						\
+    		xmlRealloc(buffer, buffer_size * sizeof(xmlChar*));	\
+    if (buffer == NULL) {						\
+	perror("realloc failed");					\
+	return(NULL);							\
+    }									\
+}
+
+static xmlChar **
+parse_list(xmlChar *str) {
+    xmlChar **buffer;
+    xmlChar **out = NULL;
+    int buffer_size = 0;
+    int len;
+
+    if(str == NULL) {
+	return(NULL);
+    }
+
+    len = xmlStrlen(str);
+    if((str[0] == '\'') && (str[len - 1] == '\'')) {
+	str[len - 1] = '\0';
+	str++;
+	len -= 2;
+    }
+    /*
+     * allocate an translation buffer.
+     */
+    buffer_size = 1000;
+    buffer = (xmlChar **) xmlMalloc(buffer_size * sizeof(xmlChar*));
+    if (buffer == NULL) {
+	perror("malloc failed");
+	return(NULL);
+    }
+    out = buffer;
+    
+    while(*str != '\0') {
+	if (out - buffer > buffer_size - 10) {
+	    int indx = out - buffer;
+
+	    growBufferReentrant();
+	    out = &buffer[indx];
+	}
+	(*out++) = str;
+	while(*str != ',' && *str != '\0') ++str;
+	if(*str == ',') *(str++) = '\0';
+    }
+    (*out) = NULL;
+    return buffer;
+}
+
+static xmlXPathObjectPtr
+load_xpath_expr (xmlDocPtr parent_doc, const char* filename) {
+    xmlXPathObjectPtr xpath; 
+    xmlDocPtr doc;
+    xmlChar *expr;
+    xmlXPathContextPtr ctx; 
+    xmlNodePtr node;
+    xmlNsPtr ns;
+    
+    /*
+     * load XPath expr as a file
+     */
+    xmlLoadExtDtdDefaultValue = XML_DETECT_IDS | XML_COMPLETE_ATTRS;
+    xmlSubstituteEntitiesDefault(1);
+
+    doc = xmlParseFile(filename);
+    if (doc == NULL) {
+	fprintf(stderr, "Error: unable to parse file \"%s\"\n", filename);
+	return(NULL);
+    }
+    
+    /*
+     * Check the document is of the right kind
+     */    
+    if(xmlDocGetRootElement(doc) == NULL) {
+        fprintf(stderr,"Error: empty document for file \"%s\"\n", filename);
+	xmlFreeDoc(doc);
+	return(NULL);
+    }
+
+    node = doc->children;
+    while(node != NULL && !xmlStrEqual(node->name, (const xmlChar *)"XPath")) {
+	node = node->next;
+    }
+    
+    if(node == NULL) {   
+        fprintf(stderr,"Error: XPath element expected in the file  \"%s\"\n", filename);
+	xmlFreeDoc(doc);
+	return(NULL);
+    }
+
+    expr = xmlNodeGetContent(node);
+    if(expr == NULL) {
+        fprintf(stderr,"Error: XPath content element is NULL \"%s\"\n", filename);
+	xmlFreeDoc(doc);
+	return(NULL);
+    }
+
+    ctx = xmlXPathNewContext(parent_doc);
+    if(ctx == NULL) {
+        fprintf(stderr,"Error: unable to create new context\n");
+        xmlFree(expr); 
+        xmlFreeDoc(doc); 
+        return(NULL);
+    }
+
+    /*
+     * Register namespaces
+     */
+    ns = node->nsDef;
+    while(ns != NULL) {
+	if(xmlXPathRegisterNs(ctx, ns->prefix, ns->href) != 0) {
+	    fprintf(stderr,"Error: unable to register NS with prefix=\"%s\" and href=\"%s\"\n", ns->prefix, ns->href);
+    	    xmlFree(expr); 
+	    xmlXPathFreeContext(ctx); 
+	    xmlFreeDoc(doc); 
+	    return(NULL);
+	}
+	ns = ns->next;
+    }
+
+    /*  
+     * Evaluate xpath
+     */
+    xpath = xmlXPathEvalExpression(expr, ctx);
+    if(xpath == NULL) {
+        fprintf(stderr,"Error: unable to evaluate xpath expression\n");
+    	xmlFree(expr); 
+        xmlXPathFreeContext(ctx); 
+        xmlFreeDoc(doc); 
+        return(NULL);
+    }
+
+    /* print_xpath_nodes(xpath->nodesetval); */
+
+    xmlFree(expr); 
+    xmlXPathFreeContext(ctx); 
+    xmlFreeDoc(doc); 
+    return(xpath);
+}
+
+/*
+static void
+print_xpath_nodes(xmlNodeSetPtr nodes) {
+    xmlNodePtr cur;
+    int i;
+    
+    if(nodes == NULL ){ 
+	fprintf(stderr, "Error: no nodes set defined\n");
+	return;
+    }
+    
+    fprintf(stderr, "Nodes Set:\n-----\n");
+    for(i = 0; i < nodes->nodeNr; ++i) {
+	if(nodes->nodeTab[i]->type == XML_NAMESPACE_DECL) {
+	    xmlNsPtr ns;
+	    
+	    ns = (xmlNsPtr)nodes->nodeTab[i];
+	    cur = (xmlNodePtr)ns->next;
+	    fprintf(stderr, "namespace \"%s\"=\"%s\" for node %s:%s\n", 
+		    ns->prefix, ns->href,
+		    (cur->ns) ? cur->ns->prefix : BAD_CAST "", cur->name);
+	} else if(nodes->nodeTab[i]->type == XML_ELEMENT_NODE) {
+	    cur = nodes->nodeTab[i];    
+	    fprintf(stderr, "element node \"%s:%s\"\n", 
+		    (cur->ns) ? cur->ns->prefix : BAD_CAST "", cur->name);
+	} else {
+	    cur = nodes->nodeTab[i];    
+	    fprintf(stderr, "node \"%s\": type %d\n", cur->name, cur->type);
+	}
+    }
+}
+*/
+
+#else
+#include <stdio.h>
+int main(int argc ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED) {
+    printf("%s : XPath/Canonicalization and output support not compiled in\n", argv[0]);
+    return(0);
+}
+#endif /* LIBXML_C14N_ENABLED */
+
+
diff --git a/src/libxml/src/testHTML.c b/src/libxml/src/testHTML.c
new file mode 100644
index 0000000..c913bb3
--- /dev/null
+++ b/src/libxml/src/testHTML.c
@@ -0,0 +1,868 @@
+/*
+ * testHTML.c : a small tester program for HTML input.
+ *
+ * See Copyright for the status of this software.
+ *
+ * daniel@veillard.com
+ */
+
+#include "libxml.h"
+
+#ifdef LIBXML_HTML_ENABLED
+
+#include <string.h>
+#include <stdarg.h>
+
+
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_STAT_H
+#include <sys/stat.h>
+#endif
+#ifdef HAVE_FCNTL_H
+#include <fcntl.h>
+#endif
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+
+#include <libxml/xmlmemory.h>
+#include <libxml/HTMLparser.h>
+#include <libxml/HTMLtree.h>
+#include <libxml/debugXML.h>
+#include <libxml/xmlerror.h>
+#include <libxml/globals.h>
+
+#ifdef LIBXML_DEBUG_ENABLED
+static int debug = 0;
+#endif
+static int copy = 0;
+static int sax = 0;
+static int repeat = 0;
+static int noout = 0;
+#ifdef LIBXML_PUSH_ENABLED
+static int push = 0;
+#endif /* LIBXML_PUSH_ENABLED */
+static char *encoding = NULL;
+static int options = 0;
+
+xmlSAXHandler emptySAXHandlerStruct = {
+    NULL, /* internalSubset */
+    NULL, /* isStandalone */
+    NULL, /* hasInternalSubset */
+    NULL, /* hasExternalSubset */
+    NULL, /* resolveEntity */
+    NULL, /* getEntity */
+    NULL, /* entityDecl */
+    NULL, /* notationDecl */
+    NULL, /* attributeDecl */
+    NULL, /* elementDecl */
+    NULL, /* unparsedEntityDecl */
+    NULL, /* setDocumentLocator */
+    NULL, /* startDocument */
+    NULL, /* endDocument */
+    NULL, /* startElement */
+    NULL, /* endElement */
+    NULL, /* reference */
+    NULL, /* characters */
+    NULL, /* ignorableWhitespace */
+    NULL, /* processingInstruction */
+    NULL, /* comment */
+    NULL, /* xmlParserWarning */
+    NULL, /* xmlParserError */
+    NULL, /* xmlParserError */
+    NULL, /* getParameterEntity */
+    NULL, /* cdataBlock */
+    NULL, /* externalSubset */
+    1,    /* initialized */
+    NULL, /* private */
+    NULL, /* startElementNsSAX2Func */
+    NULL, /* endElementNsSAX2Func */
+    NULL  /* xmlStructuredErrorFunc */
+};
+
+xmlSAXHandlerPtr emptySAXHandler = &emptySAXHandlerStruct;
+extern xmlSAXHandlerPtr debugSAXHandler;
+
+/************************************************************************
+ *									*
+ *				Debug Handlers				*
+ *									*
+ ************************************************************************/
+
+/**
+ * isStandaloneDebug:
+ * @ctxt:  An XML parser context
+ *
+ * Is this document tagged standalone ?
+ *
+ * Returns 1 if true
+ */
+static int
+isStandaloneDebug(void *ctx ATTRIBUTE_UNUSED)
+{
+    fprintf(stdout, "SAX.isStandalone()\n");
+    return(0);
+}
+
+/**
+ * hasInternalSubsetDebug:
+ * @ctxt:  An XML parser context
+ *
+ * Does this document has an internal subset
+ *
+ * Returns 1 if true
+ */
+static int
+hasInternalSubsetDebug(void *ctx ATTRIBUTE_UNUSED)
+{
+    fprintf(stdout, "SAX.hasInternalSubset()\n");
+    return(0);
+}
+
+/**
+ * hasExternalSubsetDebug:
+ * @ctxt:  An XML parser context
+ *
+ * Does this document has an external subset
+ *
+ * Returns 1 if true
+ */
+static int
+hasExternalSubsetDebug(void *ctx ATTRIBUTE_UNUSED)
+{
+    fprintf(stdout, "SAX.hasExternalSubset()\n");
+    return(0);
+}
+
+/**
+ * hasInternalSubsetDebug:
+ * @ctxt:  An XML parser context
+ *
+ * Does this document has an internal subset
+ */
+static void
+internalSubsetDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name,
+	       const xmlChar *ExternalID, const xmlChar *SystemID)
+{
+    fprintf(stdout, "SAX.internalSubset(%s,", name);
+    if (ExternalID == NULL)
+	fprintf(stdout, " ,");
+    else
+	fprintf(stdout, " %s,", ExternalID);
+    if (SystemID == NULL)
+	fprintf(stdout, " )\n");
+    else
+	fprintf(stdout, " %s)\n", SystemID);
+}
+
+/**
+ * resolveEntityDebug:
+ * @ctxt:  An XML parser context
+ * @publicId: The public ID of the entity
+ * @systemId: The system ID of the entity
+ *
+ * Special entity resolver, better left to the parser, it has
+ * more context than the application layer.
+ * The default behaviour is to NOT resolve the entities, in that case
+ * the ENTITY_REF nodes are built in the structure (and the parameter
+ * values).
+ *
+ * Returns the xmlParserInputPtr if inlined or NULL for DOM behaviour.
+ */
+static xmlParserInputPtr
+resolveEntityDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *publicId, const xmlChar *systemId)
+{
+    /* xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx; */
+
+    
+    fprintf(stdout, "SAX.resolveEntity(");
+    if (publicId != NULL)
+	fprintf(stdout, "%s", (char *)publicId);
+    else
+	fprintf(stdout, " ");
+    if (systemId != NULL)
+	fprintf(stdout, ", %s)\n", (char *)systemId);
+    else
+	fprintf(stdout, ", )\n");
+/*********
+    if (systemId != NULL) {
+        return(xmlNewInputFromFile(ctxt, (char *) systemId));
+    }
+ *********/
+    return(NULL);
+}
+
+/**
+ * getEntityDebug:
+ * @ctxt:  An XML parser context
+ * @name: The entity name
+ *
+ * Get an entity by name
+ *
+ * Returns the xmlParserInputPtr if inlined or NULL for DOM behaviour.
+ */
+static xmlEntityPtr
+getEntityDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name)
+{
+    fprintf(stdout, "SAX.getEntity(%s)\n", name);
+    return(NULL);
+}
+
+/**
+ * getParameterEntityDebug:
+ * @ctxt:  An XML parser context
+ * @name: The entity name
+ *
+ * Get a parameter entity by name
+ *
+ * Returns the xmlParserInputPtr
+ */
+static xmlEntityPtr
+getParameterEntityDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name)
+{
+    fprintf(stdout, "SAX.getParameterEntity(%s)\n", name);
+    return(NULL);
+}
+
+
+/**
+ * entityDeclDebug:
+ * @ctxt:  An XML parser context
+ * @name:  the entity name 
+ * @type:  the entity type 
+ * @publicId: The public ID of the entity
+ * @systemId: The system ID of the entity
+ * @content: the entity value (without processing).
+ *
+ * An entity definition has been parsed
+ */
+static void
+entityDeclDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name, int type,
+          const xmlChar *publicId, const xmlChar *systemId, xmlChar *content)
+{
+    fprintf(stdout, "SAX.entityDecl(%s, %d, %s, %s, %s)\n",
+            name, type, publicId, systemId, content);
+}
+
+/**
+ * attributeDeclDebug:
+ * @ctxt:  An XML parser context
+ * @name:  the attribute name 
+ * @type:  the attribute type 
+ *
+ * An attribute definition has been parsed
+ */
+static void
+attributeDeclDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *elem, const xmlChar *name,
+              int type, int def, const xmlChar *defaultValue,
+	      xmlEnumerationPtr tree ATTRIBUTE_UNUSED)
+{
+    fprintf(stdout, "SAX.attributeDecl(%s, %s, %d, %d, %s, ...)\n",
+            elem, name, type, def, defaultValue);
+}
+
+/**
+ * elementDeclDebug:
+ * @ctxt:  An XML parser context
+ * @name:  the element name 
+ * @type:  the element type 
+ * @content: the element value (without processing).
+ *
+ * An element definition has been parsed
+ */
+static void
+elementDeclDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name, int type,
+	    xmlElementContentPtr content ATTRIBUTE_UNUSED)
+{
+    fprintf(stdout, "SAX.elementDecl(%s, %d, ...)\n",
+            name, type);
+}
+
+/**
+ * notationDeclDebug:
+ * @ctxt:  An XML parser context
+ * @name: The name of the notation
+ * @publicId: The public ID of the entity
+ * @systemId: The system ID of the entity
+ *
+ * What to do when a notation declaration has been parsed.
+ */
+static void
+notationDeclDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name,
+	     const xmlChar *publicId, const xmlChar *systemId)
+{
+    fprintf(stdout, "SAX.notationDecl(%s, %s, %s)\n",
+            (char *) name, (char *) publicId, (char *) systemId);
+}
+
+/**
+ * unparsedEntityDeclDebug:
+ * @ctxt:  An XML parser context
+ * @name: The name of the entity
+ * @publicId: The public ID of the entity
+ * @systemId: The system ID of the entity
+ * @notationName: the name of the notation
+ *
+ * What to do when an unparsed entity declaration is parsed
+ */
+static void
+unparsedEntityDeclDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name,
+		   const xmlChar *publicId, const xmlChar *systemId,
+		   const xmlChar *notationName)
+{
+    fprintf(stdout, "SAX.unparsedEntityDecl(%s, %s, %s, %s)\n",
+            (char *) name, (char *) publicId, (char *) systemId,
+	    (char *) notationName);
+}
+
+/**
+ * setDocumentLocatorDebug:
+ * @ctxt:  An XML parser context
+ * @loc: A SAX Locator
+ *
+ * Receive the document locator at startup, actually xmlDefaultSAXLocator
+ * Everything is available on the context, so this is useless in our case.
+ */
+static void
+setDocumentLocatorDebug(void *ctx ATTRIBUTE_UNUSED, xmlSAXLocatorPtr loc ATTRIBUTE_UNUSED)
+{
+    fprintf(stdout, "SAX.setDocumentLocator()\n");
+}
+
+/**
+ * startDocumentDebug:
+ * @ctxt:  An XML parser context
+ *
+ * called when the document start being processed.
+ */
+static void
+startDocumentDebug(void *ctx ATTRIBUTE_UNUSED)
+{
+    fprintf(stdout, "SAX.startDocument()\n");
+}
+
+/**
+ * endDocumentDebug:
+ * @ctxt:  An XML parser context
+ *
+ * called when the document end has been detected.
+ */
+static void
+endDocumentDebug(void *ctx ATTRIBUTE_UNUSED)
+{
+    fprintf(stdout, "SAX.endDocument()\n");
+}
+
+/**
+ * startElementDebug:
+ * @ctxt:  An XML parser context
+ * @name:  The element name
+ *
+ * called when an opening tag has been processed.
+ */
+static void
+startElementDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name, const xmlChar **atts)
+{
+    int i;
+
+    fprintf(stdout, "SAX.startElement(%s", (char *) name);
+    if (atts != NULL) {
+        for (i = 0;(atts[i] != NULL);i++) {
+	    fprintf(stdout, ", %s", atts[i++]);
+	    if (atts[i] != NULL) {
+		unsigned char output[40];
+		const unsigned char *att = atts[i];
+		int outlen, attlen;
+	        fprintf(stdout, "='");
+		while ((attlen = strlen((char*)att)) > 0) {
+		    outlen = sizeof output - 1;
+		    htmlEncodeEntities(output, &outlen, att, &attlen, '\'');
+		    output[outlen] = 0;
+		    fprintf(stdout, "%s", (char *) output);
+		    att += attlen;
+		}
+		fprintf(stdout, "'");
+	    }
+	}
+    }
+    fprintf(stdout, ")\n");
+}
+
+/**
+ * endElementDebug:
+ * @ctxt:  An XML parser context
+ * @name:  The element name
+ *
+ * called when the end of an element has been detected.
+ */
+static void
+endElementDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name)
+{
+    fprintf(stdout, "SAX.endElement(%s)\n", (char *) name);
+}
+
+/**
+ * charactersDebug:
+ * @ctxt:  An XML parser context
+ * @ch:  a xmlChar string
+ * @len: the number of xmlChar
+ *
+ * receiving some chars from the parser.
+ * Question: how much at a time ???
+ */
+static void
+charactersDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *ch, int len)
+{
+    unsigned char output[40];
+    int inlen = len, outlen = 30;
+
+    htmlEncodeEntities(output, &outlen, ch, &inlen, 0);
+    output[outlen] = 0;
+
+    fprintf(stdout, "SAX.characters(%s, %d)\n", output, len);
+}
+
+/**
+ * cdataDebug:
+ * @ctxt:  An XML parser context
+ * @ch:  a xmlChar string
+ * @len: the number of xmlChar
+ *
+ * receiving some cdata chars from the parser.
+ * Question: how much at a time ???
+ */
+static void
+cdataDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *ch, int len)
+{
+    unsigned char output[40];
+    int inlen = len, outlen = 30;
+
+    htmlEncodeEntities(output, &outlen, ch, &inlen, 0);
+    output[outlen] = 0;
+
+    fprintf(stdout, "SAX.cdata(%s, %d)\n", output, len);
+}
+
+/**
+ * referenceDebug:
+ * @ctxt:  An XML parser context
+ * @name:  The entity name
+ *
+ * called when an entity reference is detected. 
+ */
+static void
+referenceDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name)
+{
+    fprintf(stdout, "SAX.reference(%s)\n", name);
+}
+
+/**
+ * ignorableWhitespaceDebug:
+ * @ctxt:  An XML parser context
+ * @ch:  a xmlChar string
+ * @start: the first char in the string
+ * @len: the number of xmlChar
+ *
+ * receiving some ignorable whitespaces from the parser.
+ * Question: how much at a time ???
+ */
+static void
+ignorableWhitespaceDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *ch, int len)
+{
+    char output[40];
+    int i;
+
+    for (i = 0;(i<len) && (i < 30);i++)
+	output[i] = ch[i];
+    output[i] = 0;
+
+    fprintf(stdout, "SAX.ignorableWhitespace(%s, %d)\n", output, len);
+}
+
+/**
+ * processingInstructionDebug:
+ * @ctxt:  An XML parser context
+ * @target:  the target name
+ * @data: the PI data's
+ * @len: the number of xmlChar
+ *
+ * A processing instruction has been parsed.
+ */
+static void
+processingInstructionDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *target,
+                      const xmlChar *data)
+{
+    fprintf(stdout, "SAX.processingInstruction(%s, %s)\n",
+            (char *) target, (char *) data);
+}
+
+/**
+ * commentDebug:
+ * @ctxt:  An XML parser context
+ * @value:  the comment content
+ *
+ * A comment has been parsed.
+ */
+static void
+commentDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *value)
+{
+    fprintf(stdout, "SAX.comment(%s)\n", value);
+}
+
+/**
+ * warningDebug:
+ * @ctxt:  An XML parser context
+ * @msg:  the message to display/transmit
+ * @...:  extra parameters for the message display
+ *
+ * Display and format a warning messages, gives file, line, position and
+ * extra parameters.
+ */
+static void
+warningDebug(void *ctx ATTRIBUTE_UNUSED, const char *msg, ...)
+{
+    va_list args;
+
+    va_start(args, msg);
+    fprintf(stdout, "SAX.warning: ");
+    vfprintf(stdout, msg, args);
+    va_end(args);
+}
+
+/**
+ * errorDebug:
+ * @ctxt:  An XML parser context
+ * @msg:  the message to display/transmit
+ * @...:  extra parameters for the message display
+ *
+ * Display and format a error messages, gives file, line, position and
+ * extra parameters.
+ */
+static void
+errorDebug(void *ctx ATTRIBUTE_UNUSED, const char *msg, ...)
+{
+    va_list args;
+
+    va_start(args, msg);
+    fprintf(stdout, "SAX.error: ");
+    vfprintf(stdout, msg, args);
+    va_end(args);
+}
+
+/**
+ * fatalErrorDebug:
+ * @ctxt:  An XML parser context
+ * @msg:  the message to display/transmit
+ * @...:  extra parameters for the message display
+ *
+ * Display and format a fatalError messages, gives file, line, position and
+ * extra parameters.
+ */
+static void
+fatalErrorDebug(void *ctx ATTRIBUTE_UNUSED, const char *msg, ...)
+{
+    va_list args;
+
+    va_start(args, msg);
+    fprintf(stdout, "SAX.fatalError: ");
+    vfprintf(stdout, msg, args);
+    va_end(args);
+}
+
+xmlSAXHandler debugSAXHandlerStruct = {
+    internalSubsetDebug,
+    isStandaloneDebug,
+    hasInternalSubsetDebug,
+    hasExternalSubsetDebug,
+    resolveEntityDebug,
+    getEntityDebug,
+    entityDeclDebug,
+    notationDeclDebug,
+    attributeDeclDebug,
+    elementDeclDebug,
+    unparsedEntityDeclDebug,
+    setDocumentLocatorDebug,
+    startDocumentDebug,
+    endDocumentDebug,
+    startElementDebug,
+    endElementDebug,
+    referenceDebug,
+    charactersDebug,
+    ignorableWhitespaceDebug,
+    processingInstructionDebug,
+    commentDebug,
+    warningDebug,
+    errorDebug,
+    fatalErrorDebug,
+    getParameterEntityDebug,
+    cdataDebug,
+    NULL,
+    1,
+    NULL,
+    NULL,
+    NULL,
+    NULL
+};
+
+xmlSAXHandlerPtr debugSAXHandler = &debugSAXHandlerStruct;
+/************************************************************************
+ *									*
+ *				Debug					*
+ *									*
+ ************************************************************************/
+
+static void
+parseSAXFile(char *filename) {
+    htmlDocPtr doc = NULL;
+
+    /*
+     * Empty callbacks for checking
+     */
+#ifdef LIBXML_PUSH_ENABLED
+    if (push) {
+	FILE *f;
+
+	f = fopen(filename, "r");
+	if (f != NULL) {
+	    int res, size = 3;
+	    char chars[4096];
+	    htmlParserCtxtPtr ctxt;
+
+	    /* if (repeat) */
+		size = 4096;
+	    res = fread(chars, 1, 4, f);
+	    if (res > 0) {
+		ctxt = htmlCreatePushParserCtxt(emptySAXHandler, NULL,
+			    chars, res, filename, XML_CHAR_ENCODING_NONE);
+		while ((res = fread(chars, 1, size, f)) > 0) {
+		    htmlParseChunk(ctxt, chars, res, 0);
+		}
+		htmlParseChunk(ctxt, chars, 0, 1);
+		doc = ctxt->myDoc;
+		htmlFreeParserCtxt(ctxt);
+	    }
+	    if (doc != NULL) {
+		fprintf(stdout, "htmlSAXParseFile returned non-NULL\n");
+		xmlFreeDoc(doc);
+	    }
+	    fclose(f);
+	}
+	if (!noout) {
+	    f = fopen(filename, "r");
+	    if (f != NULL) {
+		int res, size = 3;
+		char chars[4096];
+		htmlParserCtxtPtr ctxt;
+
+		/* if (repeat) */
+		    size = 4096;
+		res = fread(chars, 1, 4, f);
+		if (res > 0) {
+		    ctxt = htmlCreatePushParserCtxt(debugSAXHandler, NULL,
+				chars, res, filename, XML_CHAR_ENCODING_NONE);
+		    while ((res = fread(chars, 1, size, f)) > 0) {
+			htmlParseChunk(ctxt, chars, res, 0);
+		    }
+		    htmlParseChunk(ctxt, chars, 0, 1);
+		    doc = ctxt->myDoc;
+		    htmlFreeParserCtxt(ctxt);
+		}
+		if (doc != NULL) {
+		    fprintf(stdout, "htmlSAXParseFile returned non-NULL\n");
+		    xmlFreeDoc(doc);
+		}
+		fclose(f);
+	    }
+	}
+    } else {	
+#endif /* LIBXML_PUSH_ENABLED */
+	doc = htmlSAXParseFile(filename, NULL, emptySAXHandler, NULL);
+	if (doc != NULL) {
+	    fprintf(stdout, "htmlSAXParseFile returned non-NULL\n");
+	    xmlFreeDoc(doc);
+	}
+
+	if (!noout) {
+	    /*
+	     * Debug callback
+	     */
+	    doc = htmlSAXParseFile(filename, NULL, debugSAXHandler, NULL);
+	    if (doc != NULL) {
+		fprintf(stdout, "htmlSAXParseFile returned non-NULL\n");
+		xmlFreeDoc(doc);
+	    }
+	}
+#ifdef LIBXML_PUSH_ENABLED
+    }
+#endif /* LIBXML_PUSH_ENABLED */
+}
+
+static void
+parseAndPrintFile(char *filename) {
+    htmlDocPtr doc = NULL;
+
+    /*
+     * build an HTML tree from a string;
+     */
+#ifdef LIBXML_PUSH_ENABLED
+    if (push) {
+	FILE *f;
+
+	f = fopen(filename, "r");
+	if (f != NULL) {
+	    int res, size = 3;
+	    char chars[4096];
+	    htmlParserCtxtPtr ctxt;
+
+	    /* if (repeat) */
+		size = 4096;
+	    res = fread(chars, 1, 4, f);
+	    if (res > 0) {
+		ctxt = htmlCreatePushParserCtxt(NULL, NULL,
+			    chars, res, filename, XML_CHAR_ENCODING_NONE);
+		while ((res = fread(chars, 1, size, f)) > 0) {
+		    htmlParseChunk(ctxt, chars, res, 0);
+		}
+		htmlParseChunk(ctxt, chars, 0, 1);
+		doc = ctxt->myDoc;
+		htmlFreeParserCtxt(ctxt);
+	    }
+	    fclose(f);
+	}
+    } else {	
+	doc = htmlReadFile(filename, NULL, options);
+    }
+#else
+	doc = htmlReadFile(filename,NULL,options);
+#endif
+    if (doc == NULL) {
+        xmlGenericError(xmlGenericErrorContext,
+		"Could not parse %s\n", filename);
+    }
+
+#ifdef LIBXML_TREE_ENABLED
+    /*
+     * test intermediate copy if needed.
+     */
+    if (copy) {
+        htmlDocPtr tmp;
+
+        tmp = doc;
+	doc = xmlCopyDoc(doc, 1);
+	xmlFreeDoc(tmp);
+    }
+#endif
+
+#ifdef LIBXML_OUTPUT_ENABLED
+    /*
+     * print it.
+     */
+    if (!noout) { 
+#ifdef LIBXML_DEBUG_ENABLED
+	if (!debug) {
+	    if (encoding)
+		htmlSaveFileEnc("-", doc, encoding);
+	    else
+		htmlDocDump(stdout, doc);
+	} else
+	    xmlDebugDumpDocument(stdout, doc);
+#else
+	if (encoding)
+	    htmlSaveFileEnc("-", doc, encoding);
+	else
+	    htmlDocDump(stdout, doc);
+#endif
+    }	
+#endif /* LIBXML_OUTPUT_ENABLED */
+
+    /*
+     * free it.
+     */
+    xmlFreeDoc(doc);
+}
+
+int main(int argc, char **argv) {
+    int i, count;
+    int files = 0;
+
+    for (i = 1; i < argc ; i++) {
+#ifdef LIBXML_DEBUG_ENABLED
+	if ((!strcmp(argv[i], "-debug")) || (!strcmp(argv[i], "--debug")))
+	    debug++;
+	else
+#endif
+	    if ((!strcmp(argv[i], "-copy")) || (!strcmp(argv[i], "--copy")))
+	    copy++;
+#ifdef LIBXML_PUSH_ENABLED
+	else if ((!strcmp(argv[i], "-push")) || (!strcmp(argv[i], "--push")))
+	    push++;
+#endif /* LIBXML_PUSH_ENABLED */
+	else if ((!strcmp(argv[i], "-sax")) || (!strcmp(argv[i], "--sax")))
+	    sax++;
+	else if ((!strcmp(argv[i], "-noout")) || (!strcmp(argv[i], "--noout")))
+	    noout++;
+	else if ((!strcmp(argv[i], "-repeat")) ||
+	         (!strcmp(argv[i], "--repeat")))
+	    repeat++;
+	else if ((!strcmp(argv[i], "-encode")) ||
+	         (!strcmp(argv[i], "--encode"))) {
+	    i++;
+	    encoding = argv[i];
+        }
+    }
+    for (i = 1; i < argc ; i++) {
+	if ((!strcmp(argv[i], "-encode")) ||
+	         (!strcmp(argv[i], "--encode"))) {
+	    i++;
+	    continue;
+        }
+	if (argv[i][0] != '-') {
+	    if (repeat) {
+		for (count = 0;count < 100 * repeat;count++) {
+		    if (sax)
+			parseSAXFile(argv[i]);
+		    else   
+			parseAndPrintFile(argv[i]);
+		}    
+	    } else {
+		if (sax)
+		    parseSAXFile(argv[i]);
+		else   
+		    parseAndPrintFile(argv[i]);
+	    }
+	    files ++;
+	}
+    }
+    if (files == 0) {
+	printf("Usage : %s [--debug] [--copy] [--copy] HTMLfiles ...\n",
+	       argv[0]);
+	printf("\tParse the HTML files and output the result of the parsing\n");
+#ifdef LIBXML_DEBUG_ENABLED
+	printf("\t--debug : dump a debug tree of the in-memory document\n");
+#endif
+	printf("\t--copy : used to test the internal copy implementation\n");
+	printf("\t--sax : debug the sequence of SAX callbacks\n");
+	printf("\t--repeat : parse the file 100 times, for timing\n");
+	printf("\t--noout : do not print the result\n");
+#ifdef LIBXML_PUSH_ENABLED
+	printf("\t--push : use the push mode parser\n");
+#endif /* LIBXML_PUSH_ENABLED */
+	printf("\t--encode encoding : output in the given encoding\n");
+    }
+    xmlCleanupParser();
+    xmlMemoryDump();
+
+    return(0);
+}
+#else /* !LIBXML_HTML_ENABLED */
+#include <stdio.h>
+int main(int argc ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED) {
+    printf("%s : HTML support not compiled in\n", argv[0]);
+    return(0);
+}
+#endif
diff --git a/src/libxml/src/testReader.c b/src/libxml/src/testReader.c
new file mode 100644
index 0000000..a874250
--- /dev/null
+++ b/src/libxml/src/testReader.c
@@ -0,0 +1,139 @@
+/*
+ * testSAX.c : a small tester program for parsing using the SAX API.
+ *
+ * See Copyright for the status of this software.
+ *
+ * daniel@veillard.com
+ */
+
+#include "libxml.h"
+
+#ifdef LIBXML_READER_ENABLED
+#include <string.h>
+#include <stdarg.h>
+
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_STAT_H
+#include <sys/stat.h>
+#endif
+#ifdef HAVE_FCNTL_H
+#include <fcntl.h>
+#endif
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+#ifdef HAVE_STRING_H
+#include <string.h>
+#endif
+
+
+#include <libxml/xmlreader.h>
+
+int debug = 0;
+int dump = 0;
+int noent = 0;
+int count = 0;
+int valid = 0;
+
+static void usage(const char *progname) {
+    printf("Usage : %s [options] XMLfiles ...\n", progname);
+    printf("\tParse the XML files using the xmlTextReader API\n");
+    printf("\t --count: count the number of attribute and elements\n");
+    printf("\t --valid: validate the document\n");
+    exit(1);
+}
+static int elem, attrs;
+
+static void processNode(xmlTextReaderPtr reader) {
+    int type;
+
+    type = xmlTextReaderNodeType(reader);
+    if (count) {
+	if (type == 1) {
+	    elem++;
+	    attrs += xmlTextReaderAttributeCount(reader);
+	}
+    }
+}
+
+static void handleFile(const char *filename) {
+    xmlTextReaderPtr reader;
+    int ret;
+
+    if (count) {
+	elem = 0;
+	attrs = 0;
+    }
+
+    reader = xmlNewTextReaderFilename(filename);
+    if (reader != NULL) {
+	if (valid)
+	    xmlTextReaderSetParserProp(reader, XML_PARSER_VALIDATE, 1);
+
+	/*
+	 * Process all nodes in sequence
+	 */
+	ret = xmlTextReaderRead(reader);
+	while (ret == 1) {
+	    processNode(reader);
+	    ret = xmlTextReaderRead(reader);
+	}
+
+	/*
+	 * Done, cleanup and status
+	 */
+	xmlFreeTextReader(reader);
+	if (ret != 0) {
+	    printf("%s : failed to parse\n", filename);
+	} else if (count)
+	    printf("%s : %d elements, %d attributes\n", filename, elem, attrs);
+    } else {
+	fprintf(stderr, "Unable to open %s\n", filename);
+    }
+}
+
+int main(int argc, char **argv) {
+    int i;
+    int files = 0;
+
+    if (argc <= 1) {
+	usage(argv[0]);
+	return(1);
+    }
+    LIBXML_TEST_VERSION
+    for (i = 1; i < argc ; i++) {
+	if ((!strcmp(argv[i], "-debug")) || (!strcmp(argv[i], "--debug")))
+	    debug++;
+	else if ((!strcmp(argv[i], "-dump")) || (!strcmp(argv[i], "--dump")))
+	    dump++;
+	else if ((!strcmp(argv[i], "-count")) || (!strcmp(argv[i], "--count")))
+	    count++;
+	else if ((!strcmp(argv[i], "-valid")) || (!strcmp(argv[i], "--valid")))
+	    valid++;
+	else if ((!strcmp(argv[i], "-noent")) ||
+	         (!strcmp(argv[i], "--noent")))
+	    noent++;
+    }
+    if (noent != 0) xmlSubstituteEntitiesDefault(1);
+    for (i = 1; i < argc ; i++) {
+	if (argv[i][0] != '-') {
+	    handleFile(argv[i]);
+	    files ++;
+	}
+    }
+    xmlCleanupParser();
+    xmlMemoryDump();
+
+    return(0);
+}
+#else
+int main(int argc ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED) {
+    printf("%s : xmlReader parser support not compiled in\n", argv[0]);
+    return(0);
+}
+#endif /* LIBXML_READER_ENABLED */
diff --git a/src/libxml/src/testRegexp.c b/src/libxml/src/testRegexp.c
new file mode 100644
index 0000000..7f34414
--- /dev/null
+++ b/src/libxml/src/testRegexp.c
@@ -0,0 +1,158 @@
+/*
+ * testRegexp.c: simple module for testing regular expressions
+ *
+ * See Copyright for the status of this software.
+ *
+ * Daniel Veillard <veillard@redhat.com>
+ */
+
+#include <string.h>
+#include "libxml.h"
+#ifdef LIBXML_REGEXP_ENABLED
+#include <libxml/tree.h>
+#include <libxml/xmlregexp.h>
+
+int repeat = 0;
+int debug = 0;
+
+static void testRegexp(xmlRegexpPtr comp, const char *value) {
+    int ret;
+
+    ret = xmlRegexpExec(comp, (const xmlChar *) value);
+    if (ret == 1)
+	printf("%s: Ok\n", value);
+    else if (ret == 0)
+	printf("%s: Fail\n", value);
+    else
+	printf("%s: Error: %d\n", value, ret);
+    if (repeat) {
+	int j;
+	for (j = 0;j < 999999;j++)
+	    xmlRegexpExec(comp, (const xmlChar *) value);
+    }
+}
+
+static void
+testRegexpFile(const char *filename) {
+    xmlRegexpPtr comp = NULL;
+    FILE *input;
+    char expression[5000];
+    int len;
+
+    input = fopen(filename, "r");
+    if (input == NULL) {
+        xmlGenericError(xmlGenericErrorContext,
+		"Cannot open %s for reading\n", filename);
+	return;
+    }
+    while (fgets(expression, 4500, input) != NULL) {
+	len = strlen(expression);
+	len--;
+	while ((len >= 0) && 
+	       ((expression[len] == '\n') || (expression[len] == '\t') ||
+		(expression[len] == '\r') || (expression[len] == ' '))) len--;
+	expression[len + 1] = 0;      
+	if (len >= 0) {
+	    if (expression[0] == '#')
+		continue;
+	    if ((expression[0] == '=') && (expression[1] == '>')) {
+		char *pattern = &expression[2];
+
+		if (comp != NULL) {
+		    xmlRegFreeRegexp(comp);
+		    comp = NULL;
+		}
+		printf("Regexp: %s\n", pattern) ;
+		comp = xmlRegexpCompile((const xmlChar *) pattern);
+		if (comp == NULL) {
+		    printf("   failed to compile\n");
+		    break;
+		}
+	    } else if (comp == NULL) {
+		printf("Regexp: %s\n", expression) ;
+		comp = xmlRegexpCompile((const xmlChar *) expression);
+		if (comp == NULL) {
+		    printf("   failed to compile\n");
+		    break;
+		}
+	    } else if (comp != NULL) {
+		testRegexp(comp, expression);
+	    }
+	}
+    }
+    fclose(input);
+    if (comp != NULL)
+	xmlRegFreeRegexp(comp);
+}
+
+
+static void usage(const char *name) {
+    fprintf(stderr, "Usage: %s\n", name);
+}
+
+int main(int argc, char **argv) {
+    xmlRegexpPtr comp = NULL;
+    const char *pattern = NULL;
+    char *filename = NULL;
+    int i;
+
+    xmlInitMemory();
+
+    if (argc <= 1) {
+	usage(argv[0]);
+	return(1);
+    }
+    for (i = 1; i < argc ; i++) {
+	if (!strcmp(argv[i], "-"))
+	    break;
+
+	if (argv[i][0] != '-')
+	    continue;
+	if ((!strcmp(argv[i], "-debug")) || (!strcmp(argv[i], "--debug"))) {
+	    debug++;
+	} else if ((!strcmp(argv[i], "-repeat")) ||
+	         (!strcmp(argv[i], "--repeat"))) {
+	    repeat++;
+	} else if ((!strcmp(argv[i], "-i")) || (!strcmp(argv[i], "--input")))
+	    filename = argv[++i];
+        else {
+	    fprintf(stderr, "Unknown option %s\n", argv[i]);
+	    usage(argv[0]);
+	}
+    }
+    if (filename != NULL) {
+	testRegexpFile(filename);
+    } else {
+	for (i = 1; i < argc ; i++) {
+	    if ((argv[i][0] != '-') || (strcmp(argv[i], "-") == 0)) {
+		if (pattern == NULL) {
+		    pattern = argv[i];
+		    printf("Testing %s:\n", pattern);
+		    comp = xmlRegexpCompile((const xmlChar *) pattern);
+		    if (comp == NULL) {
+			printf("   failed to compile\n");
+			break;
+		    }
+		    if (debug)
+			xmlRegexpPrint(stdout, comp);
+		} else {
+		    testRegexp(comp, argv[i]);
+		}
+	    }
+	}
+	xmlMemoryDump();
+	if (comp != NULL)
+	    xmlRegFreeRegexp(comp);
+    }
+    xmlCleanupParser();
+    /* xmlMemoryDump(); */
+    return(0);
+}
+
+#else
+#include <stdio.h>
+int main(int argc ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED) {
+    printf("%s : Regexp support not compiled in\n", argv[0]);
+    return(0);
+}
+#endif /* LIBXML_REGEXP_ENABLED */
diff --git a/src/libxml/src/testRelax.c b/src/libxml/src/testRelax.c
new file mode 100644
index 0000000..e18b3c2
--- /dev/null
+++ b/src/libxml/src/testRelax.c
@@ -0,0 +1,194 @@
+/*
+ * testRelax.c : a small tester program for RelaxNG validation
+ *
+ * See Copyright for the status of this software.
+ *
+ * Daniel.Veillard@w3.org
+ */
+
+#include "libxml.h"
+#ifdef LIBXML_SCHEMAS_ENABLED
+
+#include <libxml/xmlversion.h>
+#include <libxml/parser.h>
+
+#include <stdio.h>
+#include <string.h>
+#include <stdarg.h>
+
+
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_STAT_H
+#include <sys/stat.h>
+#endif
+#ifdef HAVE_FCNTL_H
+#include <fcntl.h>
+#endif
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+#ifdef HAVE_SYS_MMAN_H
+#include <sys/mman.h>
+/* seems needed for Solaris */
+#ifndef MAP_FAILED
+#define MAP_FAILED ((void *) -1)
+#endif
+#endif
+
+#include <libxml/xmlmemory.h>
+#include <libxml/debugXML.h>
+#include <libxml/relaxng.h>
+
+#ifdef LIBXML_DEBUG_ENABLED
+static int debug = 0;
+#endif
+static int noout = 0;
+static int tree = 0;
+#ifdef HAVE_SYS_MMAN_H
+static int memory = 0;
+#endif
+
+
+int main(int argc, char **argv) {
+    int i;
+    int files = 0;
+    xmlRelaxNGPtr schema = NULL;
+
+    for (i = 1; i < argc ; i++) {
+#ifdef LIBXML_DEBUG_ENABLED
+	if ((!strcmp(argv[i], "-debug")) || (!strcmp(argv[i], "--debug")))
+	    debug++;
+	else
+#endif
+#ifdef HAVE_SYS_MMAN_H
+	if ((!strcmp(argv[i], "-memory")) || (!strcmp(argv[i], "--memory"))) {
+	    memory++;
+        } else
+#endif
+	if ((!strcmp(argv[i], "-noout")) || (!strcmp(argv[i], "--noout"))) {
+	    noout++;
+        } else
+	if ((!strcmp(argv[i], "-tree")) || (!strcmp(argv[i], "--tree"))) {
+	    tree++;
+        }
+    }
+    xmlLineNumbersDefault(1);
+    xmlSubstituteEntitiesDefault(1);
+    for (i = 1; i < argc ; i++) {
+	if (argv[i][0] != '-') {
+	    if (schema == NULL) {
+		xmlRelaxNGParserCtxtPtr ctxt;
+
+#ifdef HAVE_SYS_MMAN_H
+		if (memory) {
+		    int fd;
+		    struct stat info;
+		    const char *base;
+		    if (stat(argv[i], &info) < 0) 
+			break;
+		    if ((fd = open(argv[i], O_RDONLY)) < 0)
+			break;
+		    base = mmap(NULL, info.st_size, PROT_READ,
+			        MAP_SHARED, fd, 0) ;
+		    if (base == (void *) MAP_FAILED)
+			break;
+
+		    ctxt = xmlRelaxNGNewMemParserCtxt((char *)base,info.st_size);
+
+		    xmlRelaxNGSetParserErrors(ctxt,
+			    (xmlRelaxNGValidityErrorFunc) fprintf,
+			    (xmlRelaxNGValidityWarningFunc) fprintf,
+			    stderr);
+		    schema = xmlRelaxNGParse(ctxt);
+		    xmlRelaxNGFreeParserCtxt(ctxt);
+		    munmap((char *) base, info.st_size);
+		} else
+#endif
+		{
+		    ctxt = xmlRelaxNGNewParserCtxt(argv[i]);
+		    xmlRelaxNGSetParserErrors(ctxt,
+			    (xmlRelaxNGValidityErrorFunc) fprintf,
+			    (xmlRelaxNGValidityWarningFunc) fprintf,
+			    stderr);
+		    schema = xmlRelaxNGParse(ctxt);
+		    xmlRelaxNGFreeParserCtxt(ctxt);
+		}
+		if (schema == NULL) {
+		    printf("Relax-NG schema %s failed to compile\n", argv[i]);
+		    files = -1;
+		    break;
+		}
+#ifdef LIBXML_OUTPUT_ENABLED
+#ifdef LIBXML_DEBUG_ENABLED
+		if (debug)
+		    xmlRelaxNGDump(stdout, schema);
+#endif
+		if (tree)
+		    xmlRelaxNGDumpTree(stdout, schema);
+#endif /* LIBXML_OUTPUT_ENABLED */
+	    } else {
+		xmlDocPtr doc;
+
+		doc = xmlReadFile(argv[i],NULL,0);
+
+		if (doc == NULL) {
+		    fprintf(stderr, "Could not parse %s\n", argv[i]);
+		} else {
+		    xmlRelaxNGValidCtxtPtr ctxt;
+		    int ret;
+
+		    ctxt = xmlRelaxNGNewValidCtxt(schema);
+		    xmlRelaxNGSetValidErrors(ctxt,
+			    (xmlRelaxNGValidityErrorFunc) fprintf,
+			    (xmlRelaxNGValidityWarningFunc) fprintf,
+			    stderr);
+		    ret = xmlRelaxNGValidateDoc(ctxt, doc);
+		    if (ret == 0) {
+			printf("%s validates\n", argv[i]);
+		    } else if (ret > 0) {
+			printf("%s fails to validate\n", argv[i]);
+		    } else {
+			printf("%s validation generated an internal error\n",
+			       argv[i]);
+		    }
+		    xmlRelaxNGFreeValidCtxt(ctxt);
+		    xmlFreeDoc(doc);
+		}
+	    }
+	    files ++;
+	}
+    }
+    if (schema != NULL)
+	xmlRelaxNGFree(schema);
+    if (files == 0) {
+	printf("Usage : %s [--debug] [--noout] schemas XMLfiles ...\n",
+	       argv[0]);
+	printf("\tParse the HTML files and output the result of the parsing\n");
+#ifdef LIBXML_DEBUG_ENABLED
+	printf("\t--debug : dump a debug tree of the in-memory document\n");
+#endif
+	printf("\t--noout : do not print the result\n");
+	printf("\t--tree : print the intermediate Relax-NG document tree\n");
+#ifdef HAVE_SYS_MMAN_H
+	printf("\t--memory : test the schemas in memory parsing\n");
+#endif
+    }
+    xmlRelaxNGCleanupTypes();
+    xmlCleanupParser();
+    xmlMemoryDump();
+
+    return(0);
+}
+
+#else
+#include <stdio.h>
+int main(int argc ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED) {
+    printf("%s : RelaxNG support not compiled in\n", argv[0]);
+    return(0);
+}
+#endif /* LIBXML_SCHEMAS_ENABLED */
diff --git a/src/libxml/src/testSAX.c b/src/libxml/src/testSAX.c
new file mode 100644
index 0000000..f394078
--- /dev/null
+++ b/src/libxml/src/testSAX.c
@@ -0,0 +1,1180 @@
+/*
+ * testSAX.c : a small tester program for parsing using the SAX API.
+ *
+ * See Copyright for the status of this software.
+ *
+ * daniel@veillard.com
+ */
+
+#include "libxml.h"
+
+#ifdef HAVE_SYS_TIME_H
+#include <sys/time.h>
+#endif
+#ifdef HAVE_SYS_TIMEB_H
+#include <sys/timeb.h>
+#endif
+#ifdef HAVE_TIME_H
+#include <time.h>
+#endif
+
+#ifdef LIBXML_SAX1_ENABLED
+#include <string.h>
+#include <stdarg.h>
+
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_STAT_H
+#include <sys/stat.h>
+#endif
+#ifdef HAVE_FCNTL_H
+#include <fcntl.h>
+#endif
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+#ifdef HAVE_STRING_H
+#include <string.h>
+#endif
+
+
+#include <libxml/globals.h>
+#include <libxml/xmlerror.h>
+#include <libxml/parser.h>
+#include <libxml/parserInternals.h> /* only for xmlNewInputFromFile() */
+#include <libxml/tree.h>
+#include <libxml/debugXML.h>
+#include <libxml/xmlmemory.h>
+
+static int debug = 0;
+static int copy = 0;
+static int recovery = 0;
+static int push = 0;
+static int speed = 0;
+static int noent = 0;
+static int quiet = 0;
+static int nonull = 0;
+static int sax2 = 0;
+static int repeat = 0;
+static int callbacks = 0;
+static int timing = 0;
+
+/*
+ * Timing routines.
+ */
+/*
+ * Internal timing routines to remove the necessity to have unix-specific
+ * function calls
+ */
+
+#ifndef HAVE_GETTIMEOFDAY 
+#ifdef HAVE_SYS_TIMEB_H
+#ifdef HAVE_SYS_TIME_H
+#ifdef HAVE_FTIME
+
+static int
+my_gettimeofday(struct timeval *tvp, void *tzp)
+{
+	struct timeb timebuffer;
+
+	ftime(&timebuffer);
+	if (tvp) {
+		tvp->tv_sec = timebuffer.time;
+		tvp->tv_usec = timebuffer.millitm * 1000L;
+	}
+	return (0);
+}
+#define HAVE_GETTIMEOFDAY 1
+#define gettimeofday my_gettimeofday
+
+#endif /* HAVE_FTIME */
+#endif /* HAVE_SYS_TIME_H */
+#endif /* HAVE_SYS_TIMEB_H */
+#endif /* !HAVE_GETTIMEOFDAY */
+
+#if defined(HAVE_GETTIMEOFDAY)
+static struct timeval begin, end;
+
+/*
+ * startTimer: call where you want to start timing
+ */
+static void
+startTimer(void)
+{
+    gettimeofday(&begin, NULL);
+}
+
+/*
+ * endTimer: call where you want to stop timing and to print out a
+ *           message about the timing performed; format is a printf
+ *           type argument
+ */
+static void
+endTimer(const char *fmt, ...)
+{
+    long msec;
+    va_list ap;
+
+    gettimeofday(&end, NULL);
+    msec = end.tv_sec - begin.tv_sec;
+    msec *= 1000;
+    msec += (end.tv_usec - begin.tv_usec) / 1000;
+
+#ifndef HAVE_STDARG_H
+#error "endTimer required stdarg functions"
+#endif
+    va_start(ap, fmt);
+    vfprintf(stderr, fmt, ap);
+    va_end(ap);
+
+    fprintf(stderr, " took %ld ms\n", msec);
+}
+#elif defined(HAVE_TIME_H)
+/*
+ * No gettimeofday function, so we have to make do with calling clock.
+ * This is obviously less accurate, but there's little we can do about
+ * that.
+ */
+#ifndef CLOCKS_PER_SEC
+#define CLOCKS_PER_SEC 100
+#endif
+
+static clock_t begin, end;
+static void
+startTimer(void)
+{
+    begin = clock();
+}
+static void
+endTimer(const char *fmt, ...)
+{
+    long msec;
+    va_list ap;
+
+    end = clock();
+    msec = ((end - begin) * 1000) / CLOCKS_PER_SEC;
+
+#ifndef HAVE_STDARG_H
+#error "endTimer required stdarg functions"
+#endif
+    va_start(ap, fmt);
+    vfprintf(stderr, fmt, ap);
+    va_end(ap);
+    fprintf(stderr, " took %ld ms\n", msec);
+}
+#else
+
+/*
+ * We don't have a gettimeofday or time.h, so we just don't do timing
+ */
+static void
+startTimer(void)
+{
+    /*
+     * Do nothing
+     */
+}
+static void
+endTimer(char *format, ...)
+{
+    /*
+     * We cannot do anything because we don't have a timing function
+     */
+#ifdef HAVE_STDARG_H
+    va_start(ap, format);
+    vfprintf(stderr, format, ap);
+    va_end(ap);
+    fprintf(stderr, " was not timed\n", msec);
+#else
+    /* We don't have gettimeofday, time or stdarg.h, what crazy world is
+     * this ?!
+     */
+#endif
+}
+#endif
+
+/*
+ * empty SAX block
+ */
+xmlSAXHandler emptySAXHandlerStruct = {
+    NULL, /* internalSubset */
+    NULL, /* isStandalone */
+    NULL, /* hasInternalSubset */
+    NULL, /* hasExternalSubset */
+    NULL, /* resolveEntity */
+    NULL, /* getEntity */
+    NULL, /* entityDecl */
+    NULL, /* notationDecl */
+    NULL, /* attributeDecl */
+    NULL, /* elementDecl */
+    NULL, /* unparsedEntityDecl */
+    NULL, /* setDocumentLocator */
+    NULL, /* startDocument */
+    NULL, /* endDocument */
+    NULL, /* startElement */
+    NULL, /* endElement */
+    NULL, /* reference */
+    NULL, /* characters */
+    NULL, /* ignorableWhitespace */
+    NULL, /* processingInstruction */
+    NULL, /* comment */
+    NULL, /* xmlParserWarning */
+    NULL, /* xmlParserError */
+    NULL, /* xmlParserError */
+    NULL, /* getParameterEntity */
+    NULL, /* cdataBlock; */
+    NULL, /* externalSubset; */
+    1,
+    NULL,
+    NULL, /* startElementNs */
+    NULL, /* endElementNs */
+    NULL  /* xmlStructuredErrorFunc */
+};
+
+xmlSAXHandlerPtr emptySAXHandler = &emptySAXHandlerStruct;
+extern xmlSAXHandlerPtr debugSAXHandler;
+
+/************************************************************************
+ *									*
+ *				Debug Handlers				*
+ *									*
+ ************************************************************************/
+
+/**
+ * isStandaloneDebug:
+ * @ctxt:  An XML parser context
+ *
+ * Is this document tagged standalone ?
+ *
+ * Returns 1 if true
+ */
+static int
+isStandaloneDebug(void *ctx ATTRIBUTE_UNUSED)
+{
+    callbacks++;
+    if (quiet)
+	return(0);
+    fprintf(stdout, "SAX.isStandalone()\n");
+    return(0);
+}
+
+/**
+ * hasInternalSubsetDebug:
+ * @ctxt:  An XML parser context
+ *
+ * Does this document has an internal subset
+ *
+ * Returns 1 if true
+ */
+static int
+hasInternalSubsetDebug(void *ctx ATTRIBUTE_UNUSED)
+{
+    callbacks++;
+    if (quiet)
+	return(0);
+    fprintf(stdout, "SAX.hasInternalSubset()\n");
+    return(0);
+}
+
+/**
+ * hasExternalSubsetDebug:
+ * @ctxt:  An XML parser context
+ *
+ * Does this document has an external subset
+ *
+ * Returns 1 if true
+ */
+static int
+hasExternalSubsetDebug(void *ctx ATTRIBUTE_UNUSED)
+{
+    callbacks++;
+    if (quiet)
+	return(0);
+    fprintf(stdout, "SAX.hasExternalSubset()\n");
+    return(0);
+}
+
+/**
+ * internalSubsetDebug:
+ * @ctxt:  An XML parser context
+ *
+ * Does this document has an internal subset
+ */
+static void
+internalSubsetDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name,
+	       const xmlChar *ExternalID, const xmlChar *SystemID)
+{
+    callbacks++;
+    if (quiet)
+	return;
+    fprintf(stdout, "SAX.internalSubset(%s,", name);
+    if (ExternalID == NULL)
+	fprintf(stdout, " ,");
+    else
+	fprintf(stdout, " %s,", ExternalID);
+    if (SystemID == NULL)
+	fprintf(stdout, " )\n");
+    else
+	fprintf(stdout, " %s)\n", SystemID);
+}
+
+/**
+ * externalSubsetDebug:
+ * @ctxt:  An XML parser context
+ *
+ * Does this document has an external subset
+ */
+static void
+externalSubsetDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name,
+	       const xmlChar *ExternalID, const xmlChar *SystemID)
+{
+    callbacks++;
+    if (quiet)
+	return;
+    fprintf(stdout, "SAX.externalSubset(%s,", name);
+    if (ExternalID == NULL)
+	fprintf(stdout, " ,");
+    else
+	fprintf(stdout, " %s,", ExternalID);
+    if (SystemID == NULL)
+	fprintf(stdout, " )\n");
+    else
+	fprintf(stdout, " %s)\n", SystemID);
+}
+
+/**
+ * resolveEntityDebug:
+ * @ctxt:  An XML parser context
+ * @publicId: The public ID of the entity
+ * @systemId: The system ID of the entity
+ *
+ * Special entity resolver, better left to the parser, it has
+ * more context than the application layer.
+ * The default behaviour is to NOT resolve the entities, in that case
+ * the ENTITY_REF nodes are built in the structure (and the parameter
+ * values).
+ *
+ * Returns the xmlParserInputPtr if inlined or NULL for DOM behaviour.
+ */
+static xmlParserInputPtr
+resolveEntityDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *publicId, const xmlChar *systemId)
+{
+    callbacks++;
+    if (quiet)
+	return(NULL);
+    /* xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx; */
+
+    
+    fprintf(stdout, "SAX.resolveEntity(");
+    if (publicId != NULL)
+	fprintf(stdout, "%s", (char *)publicId);
+    else
+	fprintf(stdout, " ");
+    if (systemId != NULL)
+	fprintf(stdout, ", %s)\n", (char *)systemId);
+    else
+	fprintf(stdout, ", )\n");
+/*********
+    if (systemId != NULL) {
+        return(xmlNewInputFromFile(ctxt, (char *) systemId));
+    }
+ *********/
+    return(NULL);
+}
+
+/**
+ * getEntityDebug:
+ * @ctxt:  An XML parser context
+ * @name: The entity name
+ *
+ * Get an entity by name
+ *
+ * Returns the xmlParserInputPtr if inlined or NULL for DOM behaviour.
+ */
+static xmlEntityPtr
+getEntityDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name)
+{
+    callbacks++;
+    if (quiet)
+	return(NULL);
+    fprintf(stdout, "SAX.getEntity(%s)\n", name);
+    return(NULL);
+}
+
+/**
+ * getParameterEntityDebug:
+ * @ctxt:  An XML parser context
+ * @name: The entity name
+ *
+ * Get a parameter entity by name
+ *
+ * Returns the xmlParserInputPtr
+ */
+static xmlEntityPtr
+getParameterEntityDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name)
+{
+    callbacks++;
+    if (quiet)
+	return(NULL);
+    fprintf(stdout, "SAX.getParameterEntity(%s)\n", name);
+    return(NULL);
+}
+
+
+/**
+ * entityDeclDebug:
+ * @ctxt:  An XML parser context
+ * @name:  the entity name 
+ * @type:  the entity type 
+ * @publicId: The public ID of the entity
+ * @systemId: The system ID of the entity
+ * @content: the entity value (without processing).
+ *
+ * An entity definition has been parsed
+ */
+static void
+entityDeclDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name, int type,
+          const xmlChar *publicId, const xmlChar *systemId, xmlChar *content)
+{
+const xmlChar *nullstr = BAD_CAST "(null)";
+    /* not all libraries handle printing null pointers nicely */
+    if (publicId == NULL)
+        publicId = nullstr;
+    if (systemId == NULL)
+        systemId = nullstr;
+    if (content == NULL)
+        content = (xmlChar *)nullstr;
+    callbacks++;
+    if (quiet)
+	return;
+    fprintf(stdout, "SAX.entityDecl(%s, %d, %s, %s, %s)\n",
+            name, type, publicId, systemId, content);
+}
+
+/**
+ * attributeDeclDebug:
+ * @ctxt:  An XML parser context
+ * @name:  the attribute name 
+ * @type:  the attribute type 
+ *
+ * An attribute definition has been parsed
+ */
+static void
+attributeDeclDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar * elem,
+                   const xmlChar * name, int type, int def,
+                   const xmlChar * defaultValue, xmlEnumerationPtr tree)
+{
+    callbacks++;
+    if (quiet)
+        return;
+    if (defaultValue == NULL)
+        fprintf(stdout, "SAX.attributeDecl(%s, %s, %d, %d, NULL, ...)\n",
+                elem, name, type, def);
+    else
+        fprintf(stdout, "SAX.attributeDecl(%s, %s, %d, %d, %s, ...)\n",
+                elem, name, type, def, defaultValue);
+    xmlFreeEnumeration(tree);
+}
+
+/**
+ * elementDeclDebug:
+ * @ctxt:  An XML parser context
+ * @name:  the element name 
+ * @type:  the element type 
+ * @content: the element value (without processing).
+ *
+ * An element definition has been parsed
+ */
+static void
+elementDeclDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name, int type,
+	    xmlElementContentPtr content ATTRIBUTE_UNUSED)
+{
+    callbacks++;
+    if (quiet)
+	return;
+    fprintf(stdout, "SAX.elementDecl(%s, %d, ...)\n",
+            name, type);
+}
+
+/**
+ * notationDeclDebug:
+ * @ctxt:  An XML parser context
+ * @name: The name of the notation
+ * @publicId: The public ID of the entity
+ * @systemId: The system ID of the entity
+ *
+ * What to do when a notation declaration has been parsed.
+ */
+static void
+notationDeclDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name,
+	     const xmlChar *publicId, const xmlChar *systemId)
+{
+    callbacks++;
+    if (quiet)
+	return;
+    fprintf(stdout, "SAX.notationDecl(%s, %s, %s)\n",
+            (char *) name, (char *) publicId, (char *) systemId);
+}
+
+/**
+ * unparsedEntityDeclDebug:
+ * @ctxt:  An XML parser context
+ * @name: The name of the entity
+ * @publicId: The public ID of the entity
+ * @systemId: The system ID of the entity
+ * @notationName: the name of the notation
+ *
+ * What to do when an unparsed entity declaration is parsed
+ */
+static void
+unparsedEntityDeclDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name,
+		   const xmlChar *publicId, const xmlChar *systemId,
+		   const xmlChar *notationName)
+{
+const xmlChar *nullstr = BAD_CAST "(null)";
+
+    if (publicId == NULL)
+        publicId = nullstr;
+    if (systemId == NULL)
+        systemId = nullstr;
+    if (notationName == NULL)
+        notationName = nullstr;
+    callbacks++;
+    if (quiet)
+	return;
+    fprintf(stdout, "SAX.unparsedEntityDecl(%s, %s, %s, %s)\n",
+            (char *) name, (char *) publicId, (char *) systemId,
+	    (char *) notationName);
+}
+
+/**
+ * setDocumentLocatorDebug:
+ * @ctxt:  An XML parser context
+ * @loc: A SAX Locator
+ *
+ * Receive the document locator at startup, actually xmlDefaultSAXLocator
+ * Everything is available on the context, so this is useless in our case.
+ */
+static void
+setDocumentLocatorDebug(void *ctx ATTRIBUTE_UNUSED, xmlSAXLocatorPtr loc ATTRIBUTE_UNUSED)
+{
+    callbacks++;
+    if (quiet)
+	return;
+    fprintf(stdout, "SAX.setDocumentLocator()\n");
+}
+
+/**
+ * startDocumentDebug:
+ * @ctxt:  An XML parser context
+ *
+ * called when the document start being processed.
+ */
+static void
+startDocumentDebug(void *ctx ATTRIBUTE_UNUSED)
+{
+    callbacks++;
+    if (quiet)
+	return;
+    fprintf(stdout, "SAX.startDocument()\n");
+}
+
+/**
+ * endDocumentDebug:
+ * @ctxt:  An XML parser context
+ *
+ * called when the document end has been detected.
+ */
+static void
+endDocumentDebug(void *ctx ATTRIBUTE_UNUSED)
+{
+    callbacks++;
+    if (quiet)
+	return;
+    fprintf(stdout, "SAX.endDocument()\n");
+}
+
+/**
+ * startElementDebug:
+ * @ctxt:  An XML parser context
+ * @name:  The element name
+ *
+ * called when an opening tag has been processed.
+ */
+static void
+startElementDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name, const xmlChar **atts)
+{
+    int i;
+
+    callbacks++;
+    if (quiet)
+	return;
+    fprintf(stdout, "SAX.startElement(%s", (char *) name);
+    if (atts != NULL) {
+        for (i = 0;(atts[i] != NULL);i++) {
+	    fprintf(stdout, ", %s='", atts[i++]);
+	    if (atts[i] != NULL)
+	        fprintf(stdout, "%s'", atts[i]);
+	}
+    }
+    fprintf(stdout, ")\n");
+}
+
+/**
+ * endElementDebug:
+ * @ctxt:  An XML parser context
+ * @name:  The element name
+ *
+ * called when the end of an element has been detected.
+ */
+static void
+endElementDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name)
+{
+    callbacks++;
+    if (quiet)
+	return;
+    fprintf(stdout, "SAX.endElement(%s)\n", (char *) name);
+}
+
+/**
+ * charactersDebug:
+ * @ctxt:  An XML parser context
+ * @ch:  a xmlChar string
+ * @len: the number of xmlChar
+ *
+ * receiving some chars from the parser.
+ * Question: how much at a time ???
+ */
+static void
+charactersDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *ch, int len)
+{
+    char output[40];
+    int i;
+
+    callbacks++;
+    if (quiet)
+	return;
+    for (i = 0;(i<len) && (i < 30);i++)
+	output[i] = ch[i];
+    output[i] = 0;
+
+    fprintf(stdout, "SAX.characters(%s, %d)\n", output, len);
+}
+
+/**
+ * referenceDebug:
+ * @ctxt:  An XML parser context
+ * @name:  The entity name
+ *
+ * called when an entity reference is detected. 
+ */
+static void
+referenceDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name)
+{
+    callbacks++;
+    if (quiet)
+	return;
+    fprintf(stdout, "SAX.reference(%s)\n", name);
+}
+
+/**
+ * ignorableWhitespaceDebug:
+ * @ctxt:  An XML parser context
+ * @ch:  a xmlChar string
+ * @start: the first char in the string
+ * @len: the number of xmlChar
+ *
+ * receiving some ignorable whitespaces from the parser.
+ * Question: how much at a time ???
+ */
+static void
+ignorableWhitespaceDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *ch, int len)
+{
+    char output[40];
+    int i;
+
+    callbacks++;
+    if (quiet)
+	return;
+    for (i = 0;(i<len) && (i < 30);i++)
+	output[i] = ch[i];
+    output[i] = 0;
+    fprintf(stdout, "SAX.ignorableWhitespace(%s, %d)\n", output, len);
+}
+
+/**
+ * processingInstructionDebug:
+ * @ctxt:  An XML parser context
+ * @target:  the target name
+ * @data: the PI data's
+ * @len: the number of xmlChar
+ *
+ * A processing instruction has been parsed.
+ */
+static void
+processingInstructionDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *target,
+                      const xmlChar *data)
+{
+    callbacks++;
+    if (quiet)
+	return;
+    if (data != NULL)
+	fprintf(stdout, "SAX.processingInstruction(%s, %s)\n",
+		(char *) target, (char *) data);
+    else
+	fprintf(stdout, "SAX.processingInstruction(%s, NULL)\n",
+		(char *) target);
+}
+
+/**
+ * cdataBlockDebug:
+ * @ctx: the user data (XML parser context)
+ * @value:  The pcdata content
+ * @len:  the block length
+ *
+ * called when a pcdata block has been parsed
+ */
+static void
+cdataBlockDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *value, int len)
+{
+    callbacks++;
+    if (quiet)
+	return;
+    fprintf(stdout, "SAX.pcdata(%.20s, %d)\n",
+	    (char *) value, len);
+}
+
+/**
+ * commentDebug:
+ * @ctxt:  An XML parser context
+ * @value:  the comment content
+ *
+ * A comment has been parsed.
+ */
+static void
+commentDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *value)
+{
+    callbacks++;
+    if (quiet)
+	return;
+    fprintf(stdout, "SAX.comment(%s)\n", value);
+}
+
+/**
+ * warningDebug:
+ * @ctxt:  An XML parser context
+ * @msg:  the message to display/transmit
+ * @...:  extra parameters for the message display
+ *
+ * Display and format a warning messages, gives file, line, position and
+ * extra parameters.
+ */
+static void
+warningDebug(void *ctx ATTRIBUTE_UNUSED, const char *msg, ...)
+{
+    va_list args;
+
+    callbacks++;
+    if (quiet)
+	return;
+    va_start(args, msg);
+    fprintf(stdout, "SAX.warning: ");
+    vfprintf(stdout, msg, args);
+    va_end(args);
+}
+
+/**
+ * errorDebug:
+ * @ctxt:  An XML parser context
+ * @msg:  the message to display/transmit
+ * @...:  extra parameters for the message display
+ *
+ * Display and format a error messages, gives file, line, position and
+ * extra parameters.
+ */
+static void
+errorDebug(void *ctx ATTRIBUTE_UNUSED, const char *msg, ...)
+{
+    va_list args;
+
+    callbacks++;
+    if (quiet)
+	return;
+    va_start(args, msg);
+    fprintf(stdout, "SAX.error: ");
+    vfprintf(stdout, msg, args);
+    va_end(args);
+}
+
+/**
+ * fatalErrorDebug:
+ * @ctxt:  An XML parser context
+ * @msg:  the message to display/transmit
+ * @...:  extra parameters for the message display
+ *
+ * Display and format a fatalError messages, gives file, line, position and
+ * extra parameters.
+ */
+static void
+fatalErrorDebug(void *ctx ATTRIBUTE_UNUSED, const char *msg, ...)
+{
+    va_list args;
+
+    callbacks++;
+    if (quiet)
+	return;
+    va_start(args, msg);
+    fprintf(stdout, "SAX.fatalError: ");
+    vfprintf(stdout, msg, args);
+    va_end(args);
+}
+
+xmlSAXHandler debugSAXHandlerStruct = {
+    internalSubsetDebug,
+    isStandaloneDebug,
+    hasInternalSubsetDebug,
+    hasExternalSubsetDebug,
+    resolveEntityDebug,
+    getEntityDebug,
+    entityDeclDebug,
+    notationDeclDebug,
+    attributeDeclDebug,
+    elementDeclDebug,
+    unparsedEntityDeclDebug,
+    setDocumentLocatorDebug,
+    startDocumentDebug,
+    endDocumentDebug,
+    startElementDebug,
+    endElementDebug,
+    referenceDebug,
+    charactersDebug,
+    ignorableWhitespaceDebug,
+    processingInstructionDebug,
+    commentDebug,
+    warningDebug,
+    errorDebug,
+    fatalErrorDebug,
+    getParameterEntityDebug,
+    cdataBlockDebug,
+    externalSubsetDebug,
+    1,
+    NULL,
+    NULL,
+    NULL,
+    NULL
+};
+
+xmlSAXHandlerPtr debugSAXHandler = &debugSAXHandlerStruct;
+
+/*
+ * SAX2 specific callbacks
+ */
+/**
+ * startElementNsDebug:
+ * @ctxt:  An XML parser context
+ * @name:  The element name
+ *
+ * called when an opening tag has been processed.
+ */
+static void
+startElementNsDebug(void *ctx ATTRIBUTE_UNUSED,
+                    const xmlChar *localname,
+                    const xmlChar *prefix,
+                    const xmlChar *URI,
+		    int nb_namespaces,
+		    const xmlChar **namespaces,
+		    int nb_attributes,
+		    int nb_defaulted,
+		    const xmlChar **attributes)
+{
+    int i;
+
+    callbacks++;
+    if (quiet)
+	return;
+    fprintf(stdout, "SAX.startElementNs(%s", (char *) localname);
+    if (prefix == NULL)
+	fprintf(stdout, ", NULL");
+    else
+	fprintf(stdout, ", %s", (char *) prefix);
+    if (URI == NULL)
+	fprintf(stdout, ", NULL");
+    else
+	fprintf(stdout, ", '%s'", (char *) URI);
+    fprintf(stdout, ", %d", nb_namespaces);
+    
+    if (namespaces != NULL) {
+        for (i = 0;i < nb_namespaces * 2;i++) {
+	    fprintf(stdout, ", xmlns");
+	    if (namespaces[i] != NULL)
+	        fprintf(stdout, ":%s", namespaces[i]);
+	    i++;
+	    fprintf(stdout, "='%s'", namespaces[i]);
+	}
+    }
+    fprintf(stdout, ", %d, %d", nb_attributes, nb_defaulted);
+    if (attributes != NULL) {
+        for (i = 0;i < nb_attributes;i += 5) {
+	    if (attributes[i + 1] != NULL)
+		fprintf(stdout, ", %s:%s='", attributes[i + 1], attributes[i]);
+	    else
+		fprintf(stdout, ", %s='", attributes[i]);
+	    fprintf(stdout, "%.4s...', %d", attributes[i + 3],
+		    (int)(attributes[i + 4] - attributes[i + 3]));
+	}
+    }
+    fprintf(stdout, ")\n");
+}
+
+/**
+ * endElementDebug:
+ * @ctxt:  An XML parser context
+ * @name:  The element name
+ *
+ * called when the end of an element has been detected.
+ */
+static void
+endElementNsDebug(void *ctx ATTRIBUTE_UNUSED,
+                  const xmlChar *localname,
+                  const xmlChar *prefix,
+                  const xmlChar *URI)
+{
+    callbacks++;
+    if (quiet)
+	return;
+    fprintf(stdout, "SAX.endElementNs(%s", (char *) localname);
+    if (prefix == NULL)
+	fprintf(stdout, ", NULL");
+    else
+	fprintf(stdout, ", %s", (char *) prefix);
+    if (URI == NULL)
+	fprintf(stdout, ", NULL)\n");
+    else
+	fprintf(stdout, ", '%s')\n", (char *) URI);
+}
+
+xmlSAXHandler debugSAX2HandlerStruct = {
+    internalSubsetDebug,
+    isStandaloneDebug,
+    hasInternalSubsetDebug,
+    hasExternalSubsetDebug,
+    resolveEntityDebug,
+    getEntityDebug,
+    entityDeclDebug,
+    notationDeclDebug,
+    attributeDeclDebug,
+    elementDeclDebug,
+    unparsedEntityDeclDebug,
+    setDocumentLocatorDebug,
+    startDocumentDebug,
+    endDocumentDebug,
+    NULL,
+    NULL,
+    referenceDebug,
+    charactersDebug,
+    ignorableWhitespaceDebug,
+    processingInstructionDebug,
+    commentDebug,
+    warningDebug,
+    errorDebug,
+    fatalErrorDebug,
+    getParameterEntityDebug,
+    cdataBlockDebug,
+    externalSubsetDebug,
+    XML_SAX2_MAGIC,
+    NULL,
+    startElementNsDebug,
+    endElementNsDebug,
+    NULL
+};
+
+xmlSAXHandlerPtr debugSAX2Handler = &debugSAX2HandlerStruct;
+
+/************************************************************************
+ *									*
+ *				Debug					*
+ *									*
+ ************************************************************************/
+
+static void
+parseAndPrintFile(char *filename) {
+    int res;
+
+    if (push) {
+	FILE *f;
+
+        if ((!quiet) && (!nonull)) {
+	    /*
+	     * Empty callbacks for checking
+	     */
+	    f = fopen(filename, "r");
+	    if (f != NULL) {
+		int ret;
+		char chars[10];
+		xmlParserCtxtPtr ctxt;
+
+		ret = fread(chars, 1, 4, f);
+		if (ret > 0) {
+		    ctxt = xmlCreatePushParserCtxt(emptySAXHandler, NULL,
+				chars, ret, filename);
+		    while ((ret = fread(chars, 1, 3, f)) > 0) {
+			xmlParseChunk(ctxt, chars, ret, 0);
+		    }
+		    xmlParseChunk(ctxt, chars, 0, 1);
+		    xmlFreeParserCtxt(ctxt);
+		}
+		fclose(f);
+	    } else {
+		xmlGenericError(xmlGenericErrorContext,
+			"Cannot read file %s\n", filename);
+	    }
+	}
+	/*
+	 * Debug callback
+	 */
+	f = fopen(filename, "r");
+	if (f != NULL) {
+	    int ret;
+	    char chars[10];
+	    xmlParserCtxtPtr ctxt;
+
+	    ret = fread(chars, 1, 4, f);
+	    if (ret > 0) {
+	        if (sax2)
+		    ctxt = xmlCreatePushParserCtxt(debugSAX2Handler, NULL,
+				chars, ret, filename);
+		else
+		    ctxt = xmlCreatePushParserCtxt(debugSAXHandler, NULL,
+				chars, ret, filename);
+		while ((ret = fread(chars, 1, 3, f)) > 0) {
+		    xmlParseChunk(ctxt, chars, ret, 0);
+		}
+		ret = xmlParseChunk(ctxt, chars, 0, 1);
+		xmlFreeParserCtxt(ctxt);
+		if (ret != 0) {
+		    fprintf(stdout,
+		            "xmlSAXUserParseFile returned error %d\n", ret);
+		}
+	    }
+	    fclose(f);
+	}
+    } else {
+	if (!speed) {
+	    /*
+	     * Empty callbacks for checking
+	     */
+	    if ((!quiet) && (!nonull)) {
+		res = xmlSAXUserParseFile(emptySAXHandler, NULL, filename);
+		if (res != 0) {
+		    fprintf(stdout, "xmlSAXUserParseFile returned error %d\n", res);
+		}
+	    }
+
+	    /*
+	     * Debug callback
+	     */
+	    callbacks = 0;
+	    if (repeat) {
+	        int i;
+		for (i = 0;i < 99;i++) {
+		    if (sax2)
+			res = xmlSAXUserParseFile(debugSAX2Handler, NULL,
+			                          filename);
+		    else
+			res = xmlSAXUserParseFile(debugSAXHandler, NULL,
+			                          filename);
+		}
+	    }
+	    if (sax2)
+	        res = xmlSAXUserParseFile(debugSAX2Handler, NULL, filename);
+	    else
+		res = xmlSAXUserParseFile(debugSAXHandler, NULL, filename);
+	    if (res != 0) {
+		fprintf(stdout, "xmlSAXUserParseFile returned error %d\n", res);
+	    }
+	    if (quiet)
+		fprintf(stdout, "%d callbacks generated\n", callbacks);
+	} else {
+	    /*
+	     * test 100x the SAX parse
+	     */
+	    int i;
+
+	    for (i = 0; i<100;i++)
+		res = xmlSAXUserParseFile(emptySAXHandler, NULL, filename);
+	    if (res != 0) {
+		fprintf(stdout, "xmlSAXUserParseFile returned error %d\n", res);
+	    }
+	}
+    }
+}
+
+
+int main(int argc, char **argv) {
+    int i;
+    int files = 0;
+
+    for (i = 1; i < argc ; i++) {
+	if ((!strcmp(argv[i], "-debug")) || (!strcmp(argv[i], "--debug")))
+	    debug++;
+	else if ((!strcmp(argv[i], "-copy")) || (!strcmp(argv[i], "--copy")))
+	    copy++;
+	else if ((!strcmp(argv[i], "-recover")) ||
+	         (!strcmp(argv[i], "--recover")))
+	    recovery++;
+	else if ((!strcmp(argv[i], "-push")) ||
+	         (!strcmp(argv[i], "--push")))
+	    push++;
+	else if ((!strcmp(argv[i], "-speed")) ||
+	         (!strcmp(argv[i], "--speed")))
+	    speed++;
+	else if ((!strcmp(argv[i], "-timing")) ||
+	         (!strcmp(argv[i], "--timing"))) {
+	    nonull++;
+	    timing++;
+	    quiet++;
+	} else if ((!strcmp(argv[i], "-repeat")) ||
+	         (!strcmp(argv[i], "--repeat"))) {
+	    repeat++;
+	    quiet++;
+	} else if ((!strcmp(argv[i], "-noent")) ||
+	         (!strcmp(argv[i], "--noent")))
+	    noent++;
+	else if ((!strcmp(argv[i], "-quiet")) ||
+	         (!strcmp(argv[i], "--quiet")))
+	    quiet++;
+	else if ((!strcmp(argv[i], "-sax2")) ||
+	         (!strcmp(argv[i], "--sax2")))
+	    sax2++;
+	else if ((!strcmp(argv[i], "-nonull")) ||
+	         (!strcmp(argv[i], "--nonull")))
+	    nonull++;
+    }
+    if (noent != 0) xmlSubstituteEntitiesDefault(1);
+    for (i = 1; i < argc ; i++) {
+	if (argv[i][0] != '-') {
+	    if (timing) {
+		startTimer();
+	    }
+	    parseAndPrintFile(argv[i]);
+	    if (timing) {
+		endTimer("Parsing");
+	    }
+	    files ++;
+	}
+    }
+    xmlCleanupParser();
+    xmlMemoryDump();
+
+    return(0);
+}
+#else
+int main(int argc ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED) {
+    printf("%s : SAX1 parsing support not compiled in\n", argv[0]);
+    return(0);
+}
+#endif /* LIBXML_SAX1_ENABLED */
diff --git a/src/libxml/src/testSchemas.c b/src/libxml/src/testSchemas.c
new file mode 100644
index 0000000..47f8b39
--- /dev/null
+++ b/src/libxml/src/testSchemas.c
@@ -0,0 +1,185 @@
+/*
+ * testSchemas.c : a small tester program for Schema validation
+ *
+ * See Copyright for the status of this software.
+ *
+ * Daniel.Veillard@w3.org
+ */
+
+#include "libxml.h"
+#ifdef LIBXML_SCHEMAS_ENABLED
+
+#include <libxml/xmlversion.h>
+#include <libxml/parser.h>
+
+#include <stdio.h>
+#include <string.h>
+#include <stdarg.h>
+
+
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_STAT_H
+#include <sys/stat.h>
+#endif
+#ifdef HAVE_FCNTL_H
+#include <fcntl.h>
+#endif
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+#ifdef HAVE_SYS_MMAN_H
+#include <sys/mman.h>
+/* seems needed for Solaris */
+#ifndef MAP_FAILED
+#define MAP_FAILED ((void *) -1)
+#endif
+#endif
+
+#include <libxml/xmlmemory.h>
+#include <libxml/debugXML.h>
+#include <libxml/xmlschemas.h>
+#include <libxml/xmlschemastypes.h>
+
+#ifdef LIBXML_DEBUG_ENABLED
+static int debug = 0;
+#endif
+static int noout = 0;
+#ifdef HAVE_SYS_MMAN_H
+static int memory = 0;
+#endif
+
+
+int main(int argc, char **argv) {
+    int i;
+    int files = 0;
+    xmlSchemaPtr schema = NULL;
+
+    for (i = 1; i < argc ; i++) {
+#ifdef LIBXML_DEBUG_ENABLED
+	if ((!strcmp(argv[i], "-debug")) || (!strcmp(argv[i], "--debug")))
+	    debug++;
+	else
+#endif
+#ifdef HAVE_SYS_MMAN_H
+	if ((!strcmp(argv[i], "-memory")) || (!strcmp(argv[i], "--memory"))) {
+	    memory++;
+        } else
+#endif
+	if ((!strcmp(argv[i], "-noout")) || (!strcmp(argv[i], "--noout"))) {
+	    noout++;
+        }
+    }
+    xmlLineNumbersDefault(1);
+    for (i = 1; i < argc ; i++) {
+	if (argv[i][0] != '-') {
+	    if (schema == NULL) {
+		xmlSchemaParserCtxtPtr ctxt;
+
+#ifdef HAVE_SYS_MMAN_H
+		if (memory) {
+		    int fd;
+		    struct stat info;
+		    const char *base;
+		    if (stat(argv[i], &info) < 0) 
+			break;
+		    if ((fd = open(argv[i], O_RDONLY)) < 0)
+			break;
+		    base = mmap(NULL, info.st_size, PROT_READ,
+			        MAP_SHARED, fd, 0) ;
+		    if (base == (void *) MAP_FAILED)
+			break;
+
+		    ctxt = xmlSchemaNewMemParserCtxt((char *)base,info.st_size);
+
+		    xmlSchemaSetParserErrors(ctxt,
+			    (xmlSchemaValidityErrorFunc) fprintf,
+			    (xmlSchemaValidityWarningFunc) fprintf,
+			    stderr);
+		    schema = xmlSchemaParse(ctxt);
+		    xmlSchemaFreeParserCtxt(ctxt);
+		    munmap((char *) base, info.st_size);
+		} else
+#endif
+		{
+		    ctxt = xmlSchemaNewParserCtxt(argv[i]);
+		    xmlSchemaSetParserErrors(ctxt,
+			    (xmlSchemaValidityErrorFunc) fprintf,
+			    (xmlSchemaValidityWarningFunc) fprintf,
+			    stderr);
+		    schema = xmlSchemaParse(ctxt);
+		    xmlSchemaFreeParserCtxt(ctxt);
+		}
+#ifdef LIBXML_OUTPUT_ENABLED
+#ifdef LIBXML_DEBUG_ENABLED
+		if (debug)
+		    xmlSchemaDump(stdout, schema);
+#endif
+#endif /* LIBXML_OUTPUT_ENABLED */
+		if (schema == NULL)
+		    goto failed_schemas;
+	    } else {
+		xmlDocPtr doc;
+
+		doc = xmlReadFile(argv[i],NULL,0);
+
+		if (doc == NULL) {
+		    fprintf(stderr, "Could not parse %s\n", argv[i]);
+		} else {
+		    xmlSchemaValidCtxtPtr ctxt;
+		    int ret;
+
+		    ctxt = xmlSchemaNewValidCtxt(schema);
+		    xmlSchemaSetValidErrors(ctxt,
+			    (xmlSchemaValidityErrorFunc) fprintf,
+			    (xmlSchemaValidityWarningFunc) fprintf,
+			    stderr);
+		    ret = xmlSchemaValidateDoc(ctxt, doc);
+		    if (ret == 0) {
+			printf("%s validates\n", argv[i]);
+		    } else if (ret > 0) {
+			printf("%s fails to validate\n", argv[i]);
+		    } else {
+			printf("%s validation generated an internal error\n",
+			       argv[i]);
+		    }
+		    xmlSchemaFreeValidCtxt(ctxt);
+		    xmlFreeDoc(doc);
+		}
+	    }
+	    files ++;
+	}
+    }
+    if (schema != NULL)
+	xmlSchemaFree(schema);
+    if (files == 0) {
+	printf("Usage : %s [--debug] [--noout] schemas XMLfiles ...\n",
+	       argv[0]);
+	printf("\tParse the HTML files and output the result of the parsing\n");
+#ifdef LIBXML_DEBUG_ENABLED
+	printf("\t--debug : dump a debug tree of the in-memory document\n");
+#endif
+	printf("\t--noout : do not print the result\n");
+#ifdef HAVE_SYS_MMAN_H
+	printf("\t--memory : test the schemas in memory parsing\n");
+#endif
+    }
+failed_schemas:
+    xmlSchemaCleanupTypes();
+    xmlCleanupParser();
+    xmlMemoryDump();
+
+    return(0);
+}
+
+#else
+#include <stdio.h>
+int main(int argc ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED) {
+    printf("%s : Schemas support not compiled in\n", argv[0]);
+    return(0);
+}
+#endif /* LIBXML_SCHEMAS_ENABLED */
diff --git a/src/libxml/src/testThreads.c b/src/libxml/src/testThreads.c
new file mode 100644
index 0000000..d740a14
--- /dev/null
+++ b/src/libxml/src/testThreads.c
@@ -0,0 +1,201 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include "libxml.h"
+
+#if defined(LIBXML_THREAD_ENABLED) && defined(LIBXML_CATALOG_ENABLED)
+#include <libxml/globals.h>
+#include <libxml/threads.h>
+#include <libxml/parser.h>
+#include <libxml/catalog.h>
+#ifdef HAVE_PTHREAD_H
+#include <pthread.h>
+#elif defined HAVE_BEOS_THREADS
+#include <OS.h>
+#endif
+#include <string.h>
+#if !defined(_MSC_VER)
+#include <unistd.h>
+#endif
+#include <assert.h>
+
+#define	MAX_ARGC	20
+#ifdef HAVE_PTHREAD_H
+static pthread_t tid[MAX_ARGC];
+#elif defined HAVE_BEOS_THREADS
+static thread_id tid[MAX_ARGC];
+#endif
+
+static const char *catalog = "test/threads/complex.xml";
+static const char *testfiles[] = {
+    "test/threads/abc.xml",
+    "test/threads/acb.xml",
+    "test/threads/bac.xml",
+    "test/threads/bca.xml",
+    "test/threads/cab.xml",
+    "test/threads/cba.xml",
+    "test/threads/invalid.xml",
+};
+
+const char *Okay = "OK";
+const char *Failed = "Failed";
+
+#ifndef xmlDoValidityCheckingDefaultValue
+#error xmlDoValidityCheckingDefaultValue is not a macro
+#endif
+#ifndef xmlGenericErrorContext
+#error xmlGenericErrorContext is not a macro
+#endif
+
+static void *
+thread_specific_data(void *private_data)
+{
+    xmlDocPtr myDoc;
+    const char *filename = (const char *) private_data;
+    int okay = 1;
+
+    if (!strcmp(filename, "test/threads/invalid.xml")) {
+        xmlDoValidityCheckingDefaultValue = 0;
+        xmlGenericErrorContext = stdout;
+    } else {
+        xmlDoValidityCheckingDefaultValue = 1;
+        xmlGenericErrorContext = stderr;
+    }
+    myDoc = xmlParseFile(filename);
+    if (myDoc) {
+        xmlFreeDoc(myDoc);
+    } else {
+        printf("parse failed\n");
+	okay = 0;
+    }
+    if (!strcmp(filename, "test/threads/invalid.xml")) {
+        if (xmlDoValidityCheckingDefaultValue != 0) {
+	    printf("ValidityCheckingDefaultValue override failed\n");
+	    okay = 0;
+	}
+        if (xmlGenericErrorContext != stdout) {
+	    printf("xmlGenericErrorContext override failed\n");
+	    okay = 0;
+	}
+    } else {
+        if (xmlDoValidityCheckingDefaultValue != 1) {
+	    printf("ValidityCheckingDefaultValue override failed\n");
+	    okay = 0;
+	}
+        if (xmlGenericErrorContext != stderr) {
+	    printf("xmlGenericErrorContext override failed\n");
+	    okay = 0;
+	}
+    }
+    if (okay == 0)
+	return((void *) Failed);
+    return ((void *) Okay);
+}
+
+#ifdef HAVE_PTHREAD_H
+int
+main(void)
+{
+    unsigned int i, repeat;
+    unsigned int num_threads = sizeof(testfiles) / sizeof(testfiles[0]);
+    void *results[MAX_ARGC];
+    int ret;
+
+    xmlInitParser();
+    for (repeat = 0;repeat < 500;repeat++) {
+	xmlLoadCatalog(catalog);
+
+	for (i = 0; i < num_threads; i++) {
+	    results[i] = NULL;
+	    tid[i] = (pthread_t) -1;
+	}
+
+	for (i = 0; i < num_threads; i++) {
+	    ret = pthread_create(&tid[i], 0, thread_specific_data,
+				 (void *) testfiles[i]);
+	    if (ret != 0) {
+		perror("pthread_create");
+		exit(1);
+	    }
+	}
+	for (i = 0; i < num_threads; i++) {
+	    ret = pthread_join(tid[i], &results[i]);
+	    if (ret != 0) {
+		perror("pthread_join");
+		exit(1);
+	    }
+	}
+
+	xmlCatalogCleanup();
+	for (i = 0; i < num_threads; i++)
+	    if (results[i] != (void *) Okay)
+		printf("Thread %d handling %s failed\n", i, testfiles[i]);
+    }
+    xmlCleanupParser();
+    xmlMemoryDump();
+    return (0);
+}
+#elif defined HAVE_BEOS_THREADS
+int
+main(void)
+{
+    unsigned int i, repeat;
+    unsigned int num_threads = sizeof(testfiles) / sizeof(testfiles[0]);
+    void *results[MAX_ARGC];
+    status_t ret;
+
+    xmlInitParser();
+    printf("Parser initialized\n");
+    for (repeat = 0;repeat < 500;repeat++) {
+    printf("repeat: %d\n",repeat);
+	xmlLoadCatalog(catalog);
+	printf("loaded catalog: %s\n", catalog);
+	for (i = 0; i < num_threads; i++) {
+	    results[i] = NULL;
+	    tid[i] = (thread_id) -1;
+	}
+	printf("cleaned threads\n");
+	for (i = 0; i < num_threads; i++) {
+		tid[i] = spawn_thread(thread_specific_data, "xmlTestThread", B_NORMAL_PRIORITY, (void *) testfiles[i]);
+		if (tid[i] < B_OK) {
+			perror("beos_thread_create");
+			exit(1);
+		}
+		printf("beos_thread_create %d -> %d\n", i, tid[i]);
+	}
+	for (i = 0; i < num_threads; i++) {
+	    ret = wait_for_thread(tid[i], &results[i]);
+	    printf("beos_thread_wait %d -> %d\n", i, ret);
+	    if (ret != B_OK) {
+			perror("beos_thread_wait");
+			exit(1);
+	    }
+	}
+
+	xmlCatalogCleanup();
+	ret = B_OK;
+	for (i = 0; i < num_threads; i++)
+	    if (results[i] != (void *) Okay) {
+			printf("Thread %d handling %s failed\n", i, testfiles[i]);
+			ret = B_ERROR;
+		}
+    }
+    xmlCleanupParser();
+    xmlMemoryDump();
+
+	if (ret == B_OK)
+		printf("testThread : BeOS : SUCCESS!\n");
+	else
+		printf("testThread : BeOS : FAILED!\n");
+
+    return (0);
+}
+#endif /* pthreads or BeOS threads */
+
+#else /* !LIBXML_THREADS_ENABLED */
+int
+main(void)
+{
+    fprintf(stderr, "libxml was not compiled with thread or catalog support\n");
+    return (0);
+}
+#endif
diff --git a/src/libxml/src/testThreadsWin32.c b/src/libxml/src/testThreadsWin32.c
new file mode 100644
index 0000000..24f0006
--- /dev/null
+++ b/src/libxml/src/testThreadsWin32.c
@@ -0,0 +1,150 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include "libxml.h"
+
+#if defined(LIBXML_THREAD_ENABLED) && defined(LIBXML_CATALOG_ENABLED)
+#include <libxml/globals.h>
+#include <libxml/threads.h>
+#include <libxml/parser.h>
+#include <libxml/catalog.h>
+#include <windows.h>
+#include <string.h>
+#include <assert.h>
+
+#define	MAX_ARGC	20
+#define TEST_REPEAT_COUNT 500
+
+static HANDLE tid[MAX_ARGC];
+
+static const char *catalog = "test/threads/complex.xml";
+static char *testfiles[] = {
+    "test/threads/abc.xml",
+    "test/threads/acb.xml",
+    "test/threads/bac.xml",
+    "test/threads/bca.xml",
+    "test/threads/cab.xml",
+    "test/threads/cba.xml",
+    "test/threads/invalid.xml",
+};
+
+const char *Okay = "OK";
+const char *Failed = "Failed";
+
+#ifndef xmlDoValidityCheckingDefaultValue
+#error xmlDoValidityCheckingDefaultValue is not a macro
+#endif
+#ifndef xmlGenericErrorContext
+#error xmlGenericErrorContext is not a macro
+#endif
+
+static DWORD WINAPI
+thread_specific_data(void *private_data)
+{
+    xmlDocPtr myDoc;
+    const char *filename = (const char *) private_data;
+    int okay = 1;
+
+    if (!strcmp(filename, "test/threads/invalid.xml")) {
+        xmlDoValidityCheckingDefaultValue = 0;
+        xmlGenericErrorContext = stdout;
+    } else {
+        xmlDoValidityCheckingDefaultValue = 1;
+        xmlGenericErrorContext = stderr;
+    }
+    myDoc = xmlParseFile(filename);
+    if (myDoc) {
+        xmlFreeDoc(myDoc);
+    } else {
+        printf("parse failed\n");
+	okay = 0;
+    }
+    if (!strcmp(filename, "test/threads/invalid.xml")) {
+        if (xmlDoValidityCheckingDefaultValue != 0) {
+	    printf("ValidityCheckingDefaultValue override failed\n");
+	    okay = 0;
+	}
+        if (xmlGenericErrorContext != stdout) {
+	    printf("xmlGenericErrorContext override failed\n");
+	    okay = 0;
+	}
+    } else {
+        if (xmlDoValidityCheckingDefaultValue != 1) {
+	    printf("ValidityCheckingDefaultValue override failed\n");
+	    okay = 0;
+	}
+        if (xmlGenericErrorContext != stderr) {
+	    printf("xmlGenericErrorContext override failed\n");
+	    okay = 0;
+	}
+    }
+    if (okay == 0)
+	return ((DWORD) Failed);
+    return ((DWORD) Okay);
+}
+
+int
+main()
+{
+	unsigned int i, repeat;
+	unsigned int num_threads = sizeof(testfiles) / sizeof(testfiles[0]);
+	DWORD results[MAX_ARGC];
+	BOOL ret;
+
+	xmlInitParser();
+	for (repeat = 0;repeat < TEST_REPEAT_COUNT;repeat++)
+	{
+		xmlLoadCatalog(catalog);
+
+		for (i = 0; i < num_threads; i++)
+		{
+			results[i] = 0;
+			tid[i] = (HANDLE) -1;
+		}
+
+		for (i = 0; i < num_threads; i++)
+		{
+			DWORD useless;
+			tid[i] = CreateThread(NULL, 0, 
+				thread_specific_data, testfiles[i], 0, &useless);
+			if (tid[i] == NULL)
+			{
+				perror("CreateThread");
+				exit(1);
+			}
+		}
+
+		if (WaitForMultipleObjects (num_threads, tid, TRUE, INFINITE) == WAIT_FAILED) 
+			perror ("WaitForMultipleObjects failed");
+
+		for (i = 0; i < num_threads; i++)
+		{
+			ret = GetExitCodeThread (tid[i], &results[i]);
+			if (ret == 0)
+			{
+				perror("GetExitCodeThread");
+				exit(1);
+			}
+			CloseHandle (tid[i]);
+		}
+
+		xmlCatalogCleanup();
+		for (i = 0; i < num_threads; i++) {
+		    if (results[i] != (DWORD) Okay) 
+			printf("Thread %d handling %s failed\n", i, testfiles[i]);
+		}
+	}
+
+	xmlCleanupParser();
+	xmlMemoryDump();
+
+	return (0);
+}
+
+#else /* !LIBXML_THREADS_ENABLED */
+int
+main()
+{
+    fprintf(stderr, "libxml was not compiled with thread or catalog support\n");
+    return (0);
+}
+#endif
diff --git a/src/libxml/src/testURI.c b/src/libxml/src/testURI.c
new file mode 100644
index 0000000..aa0729d
--- /dev/null
+++ b/src/libxml/src/testURI.c
@@ -0,0 +1,105 @@
+/*
+ * testURI.c : a small tester program for XML input.
+ *
+ * See Copyright for the status of this software.
+ *
+ * daniel@veillard.com
+ */
+
+#include "libxml.h"
+
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+
+#include <libxml/xmlmemory.h>
+#include <libxml/uri.h>
+#include <libxml/globals.h>
+
+static const char *base = NULL;
+static int escape = 0;
+
+static void handleURI(const char *str) {
+    int ret;
+    xmlURIPtr uri;
+    xmlChar *res = NULL, *parsed = NULL;
+
+    uri = xmlCreateURI();
+
+    if (base == NULL) {
+	ret = xmlParseURIReference(uri, str);
+	if (ret != 0)
+	    printf("%s : error %d\n", str, ret);
+	else {
+	    xmlNormalizeURIPath(uri->path);
+	    if (escape != 0) {
+		parsed = xmlSaveUri(uri);
+		res = xmlURIEscape(parsed);
+		printf("%s\n", (char *) res);
+
+	    } else {
+		xmlPrintURI(stdout, uri);
+		printf("\n");
+	    }
+	}
+    } else {
+	res = xmlBuildURI((xmlChar *)str, (xmlChar *) base);
+	if (res != NULL) {
+	    printf("%s\n", (char *) res);
+	}
+	else
+	    printf("::ERROR::\n");
+    }
+    if (res != NULL)
+	xmlFree(res);
+    if (parsed != NULL)
+	xmlFree(parsed);
+    xmlFreeURI(uri);
+}
+
+int main(int argc, char **argv) {
+    int i, arg = 1;
+
+    if ((argc > arg) && (argv[arg] != NULL) &&
+	((!strcmp(argv[arg], "-base")) || (!strcmp(argv[arg], "--base")))) {
+	arg++;
+	base = argv[arg];
+	if (base != NULL)
+	    arg++;
+    }
+    if ((argc > arg) && (argv[arg] != NULL) &&
+	((!strcmp(argv[arg], "-escape")) || (!strcmp(argv[arg], "--escape")))) {
+	arg++;
+	escape++;
+    }
+    if (argv[arg] == NULL) {
+	char str[1024];
+
+        while (1) {
+	    /*
+	     * read one line in string buffer.
+	     */
+	    if (fgets (&str[0], sizeof (str) - 1, stdin) == NULL)
+	       break;
+
+	    /*
+	     * remove the ending spaces
+	     */
+	    i = strlen(str);
+	    while ((i > 0) &&
+		   ((str[i - 1] == '\n') || (str[i - 1] == '\r') ||
+		    (str[i - 1] == ' ') || (str[i - 1] == '\t'))) {
+		i--;
+		str[i] = 0;
+	    }
+	    handleURI(str);
+        }
+    } else {
+	while (argv[arg] != NULL) {
+	    handleURI(argv[arg]);
+	    arg++;
+	}
+    }
+    xmlMemoryDump();
+    return(0);
+}
diff --git a/src/libxml/src/testXPath.c b/src/libxml/src/testXPath.c
new file mode 100644
index 0000000..8086a81
--- /dev/null
+++ b/src/libxml/src/testXPath.c
@@ -0,0 +1,227 @@
+/*
+ * testXPath.c : a small tester program for XPath.
+ *
+ * See Copyright for the status of this software.
+ *
+ * daniel@veillard.com
+ */
+
+#include "libxml.h"
+#if defined(LIBXML_XPATH_ENABLED) && defined(LIBXML_DEBUG_ENABLED)
+
+#include <string.h>
+
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_STAT_H
+#include <sys/stat.h>
+#endif
+#ifdef HAVE_FCNTL_H
+#include <fcntl.h>
+#endif
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+
+
+#include <libxml/xpath.h>
+#include <libxml/tree.h>
+#include <libxml/parser.h>
+#include <libxml/debugXML.h>
+#include <libxml/xmlmemory.h>
+#include <libxml/parserInternals.h>
+#include <libxml/xpathInternals.h>
+#include <libxml/xmlerror.h>
+#include <libxml/globals.h>
+#if defined(LIBXML_XPTR_ENABLED)
+#include <libxml/xpointer.h>
+static int xptr = 0;
+#endif
+static int debug = 0;
+static int valid = 0;
+static int expr = 0;
+static int tree = 0;
+static int nocdata = 0;
+static xmlDocPtr document = NULL;
+
+/*
+ * Default document
+ */
+static xmlChar buffer[] = 
+"<?xml version=\"1.0\"?>\n\
+<EXAMPLE prop1=\"gnome is great\" prop2=\"&amp; linux too\">\n\
+  <head>\n\
+   <title>Welcome to Gnome</title>\n\
+  </head>\n\
+  <chapter>\n\
+   <title>The Linux adventure</title>\n\
+   <p>bla bla bla ...</p>\n\
+   <image href=\"linus.gif\"/>\n\
+   <p>...</p>\n\
+  </chapter>\n\
+  <chapter>\n\
+   <title>Chapter 2</title>\n\
+   <p>this is chapter 2 ...</p>\n\
+  </chapter>\n\
+  <chapter>\n\
+   <title>Chapter 3</title>\n\
+   <p>this is chapter 3 ...</p>\n\
+  </chapter>\n\
+</EXAMPLE>\n\
+";
+
+
+static void
+testXPath(const char *str) {
+    xmlXPathObjectPtr res;
+    xmlXPathContextPtr ctxt;
+    
+#if defined(LIBXML_XPTR_ENABLED)
+    if (xptr) {
+	ctxt = xmlXPtrNewContext(document, NULL, NULL);
+	res = xmlXPtrEval(BAD_CAST str, ctxt);
+    } else {
+#endif
+	ctxt = xmlXPathNewContext(document);
+	ctxt->node = xmlDocGetRootElement(document);
+	if (expr)
+	    res = xmlXPathEvalExpression(BAD_CAST str, ctxt);
+	else {
+	    /* res = xmlXPathEval(BAD_CAST str, ctxt); */
+	    xmlXPathCompExprPtr comp;
+
+	    comp = xmlXPathCompile(BAD_CAST str);
+	    if (comp != NULL) {
+		if (tree) 
+		    xmlXPathDebugDumpCompExpr(stdout, comp, 0);
+
+		res = xmlXPathCompiledEval(comp, ctxt);
+		xmlXPathFreeCompExpr(comp);
+	    } else
+		res = NULL;
+	}
+#if defined(LIBXML_XPTR_ENABLED)
+    }
+#endif
+    xmlXPathDebugDumpObject(stdout, res, 0);
+    xmlXPathFreeObject(res);
+    xmlXPathFreeContext(ctxt);
+}
+
+static void
+testXPathFile(const char *filename) {
+    FILE *input;
+    char expression[5000];
+    int len;
+
+    input = fopen(filename, "r");
+    if (input == NULL) {
+        xmlGenericError(xmlGenericErrorContext,
+		"Cannot open %s for reading\n", filename);
+	return;
+    }
+    while (fgets(expression, 4500, input) != NULL) {
+	len = strlen(expression);
+	len--;
+	while ((len >= 0) && 
+	       ((expression[len] == '\n') || (expression[len] == '\t') ||
+		(expression[len] == '\r') || (expression[len] == ' '))) len--;
+	expression[len + 1] = 0;      
+	if (len >= 0) {
+	    printf("\n========================\nExpression: %s\n", expression) ;
+	    testXPath(expression);
+	}
+    }
+
+    fclose(input);
+}
+
+int main(int argc, char **argv) {
+    int i;
+    int strings = 0;
+    int usefile = 0;
+    char *filename = NULL;
+
+    for (i = 1; i < argc ; i++) {
+#if defined(LIBXML_XPTR_ENABLED)
+	if ((!strcmp(argv[i], "-xptr")) || (!strcmp(argv[i], "--xptr")))
+	    xptr++;
+	else 
+#endif
+	if ((!strcmp(argv[i], "-debug")) || (!strcmp(argv[i], "--debug")))
+	    debug++;
+	else if ((!strcmp(argv[i], "-valid")) || (!strcmp(argv[i], "--valid")))
+	    valid++;
+	else if ((!strcmp(argv[i], "-expr")) || (!strcmp(argv[i], "--expr")))
+	    expr++;
+	else if ((!strcmp(argv[i], "-tree")) || (!strcmp(argv[i], "--tree")))
+	    tree++;
+	else if ((!strcmp(argv[i], "-nocdata")) ||
+		 (!strcmp(argv[i], "--nocdata")))
+	    nocdata++;
+	else if ((!strcmp(argv[i], "-i")) || (!strcmp(argv[i], "--input")))
+	    filename = argv[++i];
+	else if ((!strcmp(argv[i], "-f")) || (!strcmp(argv[i], "--file")))
+	    usefile++;
+    }
+    if (valid != 0) xmlDoValidityCheckingDefaultValue = 1;
+    xmlLoadExtDtdDefaultValue |= XML_DETECT_IDS;
+    xmlLoadExtDtdDefaultValue |= XML_COMPLETE_ATTRS;
+    xmlSubstituteEntitiesDefaultValue = 1;
+    if (nocdata != 0) {
+	xmlDefaultSAXHandlerInit();
+	xmlDefaultSAXHandler.cdataBlock = NULL;
+    }
+    if (document == NULL) {
+        if (filename == NULL)
+	    document = xmlReadDoc(buffer,NULL,NULL,0);
+	else
+	    document = xmlReadFile(filename,NULL,0);
+    }
+    for (i = 1; i < argc ; i++) {
+	if ((!strcmp(argv[i], "-i")) || (!strcmp(argv[i], "--input"))) {
+	    i++; continue;
+	}
+	if (argv[i][0] != '-') {
+	    if (usefile)
+	        testXPathFile(argv[i]);
+	    else
+		testXPath(argv[i]);
+	    strings ++;
+	}
+    }
+    if (strings == 0) {
+	printf("Usage : %s [--debug] [--copy] stringsorfiles ...\n",
+	       argv[0]);
+	printf("\tParse the XPath strings and output the result of the parsing\n");
+	printf("\t--debug : dump a debug version of the result\n");
+	printf("\t--valid : switch on DTD support in the parser\n");
+#if defined(LIBXML_XPTR_ENABLED)
+	printf("\t--xptr : expressions are XPointer expressions\n");
+#endif
+	printf("\t--expr : debug XPath expressions only\n");
+	printf("\t--tree : show the compiled XPath tree\n");
+	printf("\t--nocdata : do not generate CDATA nodes\n");
+	printf("\t--input filename : or\n");
+	printf("\t-i filename      : read the document from filename\n");
+	printf("\t--file : or\n");
+	printf("\t-f     : read queries from files, args\n");
+    }
+    if (document != NULL) 
+	xmlFreeDoc(document);
+    xmlCleanupParser();
+    xmlMemoryDump();
+
+    return(0);
+}
+#else
+#include <stdio.h>
+int main(int argc ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED) {
+    printf("%s : XPath/Debug support not compiled in\n", argv[0]);
+    return(0);
+}
+#endif /* LIBXML_XPATH_ENABLED */
diff --git a/src/libxml/src/threads.c b/src/libxml/src/threads.c
new file mode 100644
index 0000000..ac6c8d6
--- /dev/null
+++ b/src/libxml/src/threads.c
@@ -0,0 +1,759 @@
+/**
+ * threads.c: set of generic threading related routines 
+ *
+ * See Copyright for the status of this software.
+ *
+ * Gary Pennington <Gary.Pennington@uk.sun.com>
+ * daniel@veillard.com
+ */
+
+#define IN_LIBXML
+#include "libxml.h"
+
+#include <string.h>
+
+#include <libxml/threads.h>
+#include <libxml/globals.h>
+
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+#ifdef HAVE_PTHREAD_H
+#include <pthread.h>
+#endif
+
+#ifdef HAVE_WIN32_THREADS
+#include <windows.h>
+#ifndef HAVE_COMPILER_TLS
+#include <process.h>
+#endif
+#endif
+
+#ifdef HAVE_BEOS_THREADS
+#include <OS.h>
+#include <TLS.h>
+#endif
+
+#if defined(SOLARIS)
+#include <note.h>
+#endif
+
+/* #define DEBUG_THREADS */
+
+/*
+ * TODO: this module still uses malloc/free and not xmlMalloc/xmlFree
+ *       to avoid some crazyness since xmlMalloc/xmlFree may actually
+ *       be hosted on allocated blocks needing them for the allocation ...
+ */
+
+/*
+ * xmlMutex are a simple mutual exception locks
+ */
+struct _xmlMutex {
+#ifdef HAVE_PTHREAD_H
+    pthread_mutex_t lock;
+#elif defined HAVE_WIN32_THREADS
+    HANDLE mutex;
+#elif defined HAVE_BEOS_THREADS
+	sem_id sem;
+	thread_id tid;
+#else
+    int empty;
+#endif
+};
+
+/*
+ * xmlRMutex are reentrant mutual exception locks
+ */
+struct _xmlRMutex {
+#ifdef HAVE_PTHREAD_H
+    pthread_mutex_t lock;
+    unsigned int    held;
+    unsigned int    waiters;
+    pthread_t       tid;
+    pthread_cond_t  cv;
+#elif defined HAVE_WIN32_THREADS
+    CRITICAL_SECTION cs;
+    unsigned int count;
+#elif defined HAVE_BEOS_THREADS
+	xmlMutexPtr lock;
+	thread_id tid;
+	int32 count;
+#else
+    int empty;
+#endif
+};
+/*
+ * This module still has some internal static data.
+ *   - xmlLibraryLock a global lock
+ *   - globalkey used for per-thread data
+ */
+
+#ifdef HAVE_PTHREAD_H
+static pthread_key_t	globalkey;
+static pthread_t	mainthread;
+static pthread_once_t once_control = PTHREAD_ONCE_INIT;
+#elif defined HAVE_WIN32_THREADS
+#if defined(HAVE_COMPILER_TLS)
+static __declspec(thread) xmlGlobalState tlstate;
+static __declspec(thread) int tlstate_inited = 0;
+#else /* HAVE_COMPILER_TLS */
+static DWORD globalkey = TLS_OUT_OF_INDEXES;
+#endif /* HAVE_COMPILER_TLS */
+static DWORD mainthread;
+static int run_once_init = 1;
+/* endif HAVE_WIN32_THREADS */
+#elif defined HAVE_BEOS_THREADS
+int32 globalkey = 0;
+thread_id mainthread = 0;
+int32 run_once_init = 0;
+#endif
+
+static xmlRMutexPtr	xmlLibraryLock = NULL;
+#ifdef LIBXML_THREAD_ENABLED
+static void xmlOnceInit(void);
+#endif
+
+/**
+ * xmlNewMutex:
+ *
+ * xmlNewMutex() is used to allocate a libxml2 token struct for use in
+ * synchronizing access to data.
+ *
+ * Returns a new simple mutex pointer or NULL in case of error
+ */
+xmlMutexPtr
+xmlNewMutex(void)
+{
+    xmlMutexPtr tok;
+
+    if ((tok = malloc(sizeof(xmlMutex))) == NULL)
+        return (NULL);
+#ifdef HAVE_PTHREAD_H
+    pthread_mutex_init(&tok->lock, NULL);
+#elif defined HAVE_WIN32_THREADS
+    tok->mutex = CreateMutex(NULL, FALSE, NULL);
+#elif defined HAVE_BEOS_THREADS
+	if ((tok->sem = create_sem(1, "xmlMutex")) < B_OK) {
+		free(tok);
+		return NULL;
+	}
+	tok->tid = -1;
+#endif
+    return (tok);
+}
+
+/**
+ * xmlFreeMutex:
+ * @tok:  the simple mutex
+ *
+ * xmlFreeMutex() is used to reclaim resources associated with a libxml2 token
+ * struct.
+ */
+void
+xmlFreeMutex(xmlMutexPtr tok)
+{
+    if (tok == NULL) return;
+
+#ifdef HAVE_PTHREAD_H
+    pthread_mutex_destroy(&tok->lock);
+#elif defined HAVE_WIN32_THREADS
+    CloseHandle(tok->mutex);
+#elif defined HAVE_BEOS_THREADS
+	delete_sem(tok->sem);
+#endif
+    free(tok);
+}
+
+/**
+ * xmlMutexLock:
+ * @tok:  the simple mutex
+ *
+ * xmlMutexLock() is used to lock a libxml2 token.
+ */
+void
+xmlMutexLock(xmlMutexPtr tok)
+{
+    if (tok == NULL)
+        return;
+#ifdef HAVE_PTHREAD_H
+    pthread_mutex_lock(&tok->lock);
+#elif defined HAVE_WIN32_THREADS
+    WaitForSingleObject(tok->mutex, INFINITE);
+#elif defined HAVE_BEOS_THREADS
+	if (acquire_sem(tok->sem) != B_NO_ERROR) {
+#ifdef DEBUG_THREADS
+		xmlGenericError(xmlGenericErrorContext, "xmlMutexLock():BeOS:Couldn't aquire semaphore\n");
+		exit();
+#endif
+	}
+	tok->tid = find_thread(NULL);
+#endif
+
+}
+
+/**
+ * xmlMutexUnlock:
+ * @tok:  the simple mutex
+ *
+ * xmlMutexUnlock() is used to unlock a libxml2 token.
+ */
+void
+xmlMutexUnlock(xmlMutexPtr tok)
+{
+    if (tok == NULL)
+        return;
+#ifdef HAVE_PTHREAD_H
+    pthread_mutex_unlock(&tok->lock);
+#elif defined HAVE_WIN32_THREADS
+    ReleaseMutex(tok->mutex);
+#elif defined HAVE_BEOS_THREADS
+	if (tok->tid == find_thread(NULL)) {
+		tok->tid = -1;
+		release_sem(tok->sem);
+	}
+#endif
+}
+
+/**
+ * xmlNewRMutex:
+ *
+ * xmlRNewMutex() is used to allocate a reentrant mutex for use in
+ * synchronizing access to data. token_r is a re-entrant lock and thus useful
+ * for synchronizing access to data structures that may be manipulated in a
+ * recursive fashion.
+ *
+ * Returns the new reentrant mutex pointer or NULL in case of error
+ */
+xmlRMutexPtr
+xmlNewRMutex(void)
+{
+    xmlRMutexPtr tok;
+
+    if ((tok = malloc(sizeof(xmlRMutex))) == NULL)
+        return (NULL);
+#ifdef HAVE_PTHREAD_H
+    pthread_mutex_init(&tok->lock, NULL);
+    tok->held = 0;
+    tok->waiters = 0;
+    pthread_cond_init(&tok->cv, NULL);
+#elif defined HAVE_WIN32_THREADS
+    InitializeCriticalSection(&tok->cs);
+    tok->count = 0;
+#elif defined HAVE_BEOS_THREADS
+	if ((tok->lock = xmlNewMutex()) == NULL) {
+		free(tok);
+		return NULL;
+	}
+	tok->count = 0;
+#endif
+    return (tok);
+}
+
+/**
+ * xmlFreeRMutex:
+ * @tok:  the reentrant mutex
+ *
+ * xmlRFreeMutex() is used to reclaim resources associated with a
+ * reentrant mutex.
+ */
+void
+xmlFreeRMutex(xmlRMutexPtr tok ATTRIBUTE_UNUSED)
+{
+#ifdef HAVE_PTHREAD_H
+    pthread_mutex_destroy(&tok->lock);
+#elif defined HAVE_WIN32_THREADS
+    DeleteCriticalSection(&tok->cs);
+#elif defined HAVE_BEOS_THREADS
+	xmlFreeMutex(tok->lock);
+#endif
+    free(tok);
+}
+
+/**
+ * xmlRMutexLock:
+ * @tok:  the reentrant mutex
+ *
+ * xmlRMutexLock() is used to lock a libxml2 token_r.
+ */
+void
+xmlRMutexLock(xmlRMutexPtr tok)
+{
+    if (tok == NULL)
+        return;
+#ifdef HAVE_PTHREAD_H
+    pthread_mutex_lock(&tok->lock);
+    if (tok->held) {
+        if (pthread_equal(tok->tid, pthread_self())) {
+            tok->held++;
+            pthread_mutex_unlock(&tok->lock);
+            return;
+        } else {
+            tok->waiters++;
+            while (tok->held)
+                pthread_cond_wait(&tok->cv, &tok->lock);
+            tok->waiters--;
+        }
+    }
+    tok->tid = pthread_self();
+    tok->held = 1;
+    pthread_mutex_unlock(&tok->lock);
+#elif defined HAVE_WIN32_THREADS
+    EnterCriticalSection(&tok->cs);
+    ++tok->count;
+#elif defined HAVE_BEOS_THREADS
+	if (tok->lock->tid == find_thread(NULL)) {
+		tok->count++;
+		return;
+	} else {
+		xmlMutexLock(tok->lock);
+		tok->count = 1;
+	}
+#endif
+}
+
+/**
+ * xmlRMutexUnlock:
+ * @tok:  the reentrant mutex
+ *
+ * xmlRMutexUnlock() is used to unlock a libxml2 token_r.
+ */
+void
+xmlRMutexUnlock(xmlRMutexPtr tok ATTRIBUTE_UNUSED)
+{
+    if (tok == NULL)
+        return;
+#ifdef HAVE_PTHREAD_H
+    pthread_mutex_lock(&tok->lock);
+    tok->held--;
+    if (tok->held == 0) {
+        if (tok->waiters)
+            pthread_cond_signal(&tok->cv);
+        tok->tid = 0;
+    }
+    pthread_mutex_unlock(&tok->lock);
+#elif defined HAVE_WIN32_THREADS
+    if (!--tok->count) 
+	LeaveCriticalSection(&tok->cs);
+#elif defined HAVE_BEOS_THREADS
+	if (tok->lock->tid == find_thread(NULL)) {
+		tok->count--;
+		if (tok->count == 0) {
+			xmlMutexUnlock(tok->lock);
+		}
+		return;
+	}
+#endif
+}
+
+/************************************************************************
+ *									*
+ *			Per thread global state handling		*
+ *									*
+ ************************************************************************/
+
+#ifdef LIBXML_THREAD_ENABLED
+/**
+ * xmlFreeGlobalState:
+ * @state:  a thread global state
+ *
+ * xmlFreeGlobalState() is called when a thread terminates with a non-NULL
+ * global state. It is is used here to reclaim memory resources.
+ */
+static void
+xmlFreeGlobalState(void *state)
+{
+    free(state);
+}
+
+/**
+ * xmlNewGlobalState:
+ *
+ * xmlNewGlobalState() allocates a global state. This structure is used to
+ * hold all data for use by a thread when supporting backwards compatibility
+ * of libxml2 to pre-thread-safe behaviour.
+ *
+ * Returns the newly allocated xmlGlobalStatePtr or NULL in case of error
+ */
+static xmlGlobalStatePtr
+xmlNewGlobalState(void)
+{
+    xmlGlobalState *gs;
+    
+    gs = malloc(sizeof(xmlGlobalState));
+    if (gs == NULL)
+	return(NULL);
+
+    memset(gs, 0, sizeof(xmlGlobalState));
+    xmlInitializeGlobalState(gs);
+    return (gs);
+}
+#endif /* LIBXML_THREAD_ENABLED */
+
+
+#ifdef HAVE_WIN32_THREADS
+#if !defined(HAVE_COMPILER_TLS)
+#if defined(LIBXML_STATIC) && !defined(LIBXML_STATIC_FOR_DLL)
+typedef struct _xmlGlobalStateCleanupHelperParams
+{
+    HANDLE thread;
+    void *memory;
+} xmlGlobalStateCleanupHelperParams;
+
+static void xmlGlobalStateCleanupHelper (void *p)
+{
+    xmlGlobalStateCleanupHelperParams *params = (xmlGlobalStateCleanupHelperParams *) p;
+    WaitForSingleObject(params->thread, INFINITE);
+    CloseHandle(params->thread);
+    xmlFreeGlobalState(params->memory);
+    free(params);
+    _endthread();
+}
+#else /* LIBXML_STATIC && !LIBXML_STATIC_FOR_DLL */
+
+typedef struct _xmlGlobalStateCleanupHelperParams
+{
+    void *memory;
+    struct _xmlGlobalStateCleanupHelperParams * prev;
+    struct _xmlGlobalStateCleanupHelperParams * next;
+} xmlGlobalStateCleanupHelperParams;
+
+static xmlGlobalStateCleanupHelperParams * cleanup_helpers_head = NULL;
+static CRITICAL_SECTION cleanup_helpers_cs;
+
+#endif /* LIBXMLSTATIC && !LIBXML_STATIC_FOR_DLL */
+#endif /* HAVE_COMPILER_TLS */
+#endif /* HAVE_WIN32_THREADS */
+
+#if defined HAVE_BEOS_THREADS
+/**
+ * xmlGlobalStateCleanup:
+ * @data: unused parameter
+ *
+ * Used for Beos only
+ */
+void xmlGlobalStateCleanup(void *data)
+{
+	void *globalval = tls_get(globalkey);
+	if (globalval != NULL)
+		xmlFreeGlobalState(globalval);
+}
+#endif
+
+/**
+ * xmlGetGlobalState:
+ *
+ * xmlGetGlobalState() is called to retrieve the global state for a thread.
+ *
+ * Returns the thread global state or NULL in case of error
+ */
+xmlGlobalStatePtr
+xmlGetGlobalState(void)
+{
+#ifdef HAVE_PTHREAD_H
+    xmlGlobalState *globalval;
+
+    pthread_once(&once_control, xmlOnceInit);
+
+    if ((globalval = (xmlGlobalState *)
+		pthread_getspecific(globalkey)) == NULL) {
+        xmlGlobalState *tsd = xmlNewGlobalState();
+
+        pthread_setspecific(globalkey, tsd);
+        return (tsd);
+    }
+    return (globalval);
+#elif defined HAVE_WIN32_THREADS
+#if defined(HAVE_COMPILER_TLS)
+    if (!tlstate_inited) {
+	tlstate_inited = 1;
+	xmlInitializeGlobalState(&tlstate);
+    }
+    return &tlstate;
+#else /* HAVE_COMPILER_TLS */
+    xmlGlobalState *globalval;
+    xmlGlobalStateCleanupHelperParams * p;
+
+    if (run_once_init) { 
+	run_once_init = 0; 
+	xmlOnceInit(); 
+    }
+#if defined(LIBXML_STATIC) && !defined(LIBXML_STATIC_FOR_DLL)
+    globalval = (xmlGlobalState *)TlsGetValue(globalkey);
+#else
+    p = (xmlGlobalStateCleanupHelperParams*)TlsGetValue(globalkey);
+    globalval = (xmlGlobalState *)(p ? p->memory : NULL);
+#endif
+    if (globalval == NULL) {
+	xmlGlobalState *tsd = xmlNewGlobalState();
+	p = (xmlGlobalStateCleanupHelperParams *) malloc(sizeof(xmlGlobalStateCleanupHelperParams));
+	p->memory = tsd;
+#if defined(LIBXML_STATIC) && !defined(LIBXML_STATIC_FOR_DLL)
+	DuplicateHandle(GetCurrentProcess(), GetCurrentThread(), 
+		GetCurrentProcess(), &p->thread, 0, TRUE, DUPLICATE_SAME_ACCESS);
+	TlsSetValue(globalkey, tsd);
+	_beginthread(xmlGlobalStateCleanupHelper, 0, p);
+#else
+	EnterCriticalSection(&cleanup_helpers_cs);	
+        if (cleanup_helpers_head != NULL) {
+            cleanup_helpers_head->prev = p;
+        }
+	p->next = cleanup_helpers_head;
+	p->prev = NULL;
+	cleanup_helpers_head = p;
+	TlsSetValue(globalkey, p);
+	LeaveCriticalSection(&cleanup_helpers_cs);	
+#endif
+
+	return (tsd);
+    }
+    return (globalval);
+#endif /* HAVE_COMPILER_TLS */
+#elif defined HAVE_BEOS_THREADS
+    xmlGlobalState *globalval;
+
+    xmlOnceInit();
+
+    if ((globalval = (xmlGlobalState *)
+		tls_get(globalkey)) == NULL) {
+        xmlGlobalState *tsd = xmlNewGlobalState();
+
+        tls_set(globalkey, tsd);
+        on_exit_thread(xmlGlobalStateCleanup, NULL);
+        return (tsd);
+    }
+    return (globalval);
+#else
+    return(NULL);
+#endif
+}
+
+/************************************************************************
+ *									*
+ *			Library wide thread interfaces			*
+ *									*
+ ************************************************************************/
+
+/**
+ * xmlGetThreadId:
+ *
+ * xmlGetThreadId() find the current thread ID number
+ *
+ * Returns the current thread ID number
+ */
+int
+xmlGetThreadId(void)
+{
+#ifdef HAVE_PTHREAD_H
+    return((int) pthread_self());
+#elif defined HAVE_WIN32_THREADS
+    return GetCurrentThreadId();
+#elif defined HAVE_BEOS_THREADS
+	return find_thread(NULL);
+#else
+    return((int) 0);
+#endif
+}
+
+/**
+ * xmlIsMainThread:
+ *
+ * xmlIsMainThread() check whether the current thread is the main thread.
+ *
+ * Returns 1 if the current thread is the main thread, 0 otherwise
+ */
+int
+xmlIsMainThread(void)
+{
+#ifdef HAVE_PTHREAD_H
+    pthread_once(&once_control, xmlOnceInit);
+#elif defined HAVE_WIN32_THREADS
+    if (run_once_init) { 
+	run_once_init = 0; 
+	xmlOnceInit (); 
+    }
+#elif defined HAVE_BEOS_THREADS
+	xmlOnceInit();
+#endif
+        
+#ifdef DEBUG_THREADS
+    xmlGenericError(xmlGenericErrorContext, "xmlIsMainThread()\n");
+#endif
+#ifdef HAVE_PTHREAD_H
+    return(mainthread == pthread_self());
+#elif defined HAVE_WIN32_THREADS
+    return(mainthread == GetCurrentThreadId ());
+#elif defined HAVE_BEOS_THREADS
+	return(mainthread == find_thread(NULL));
+#else
+    return(1);
+#endif
+}
+
+/**
+ * xmlLockLibrary:
+ *
+ * xmlLockLibrary() is used to take out a re-entrant lock on the libxml2
+ * library.
+ */
+void
+xmlLockLibrary(void)
+{
+#ifdef DEBUG_THREADS
+    xmlGenericError(xmlGenericErrorContext, "xmlLockLibrary()\n");
+#endif
+    xmlRMutexLock(xmlLibraryLock);
+}
+
+/**
+ * xmlUnlockLibrary:
+ *
+ * xmlUnlockLibrary() is used to release a re-entrant lock on the libxml2
+ * library.
+ */
+void
+xmlUnlockLibrary(void)
+{
+#ifdef DEBUG_THREADS
+    xmlGenericError(xmlGenericErrorContext, "xmlUnlockLibrary()\n");
+#endif
+    xmlRMutexUnlock(xmlLibraryLock);
+}
+
+/**
+ * xmlInitThreads:
+ *
+ * xmlInitThreads() is used to to initialize all the thread related
+ * data of the libxml2 library.
+ */
+void
+xmlInitThreads(void)
+{
+#ifdef DEBUG_THREADS
+    xmlGenericError(xmlGenericErrorContext, "xmlInitThreads()\n");
+#endif
+#if defined(HAVE_WIN32_THREADS) && !defined(HAVE_COMPILER_TLS) && (!defined(LIBXML_STATIC) || defined(LIBXML_STATIC_FOR_DLL))
+    InitializeCriticalSection(&cleanup_helpers_cs);
+#endif
+}
+
+/**
+ * xmlCleanupThreads:
+ *
+ * xmlCleanupThreads() is used to to cleanup all the thread related
+ * data of the libxml2 library once processing has ended.
+ */
+void
+xmlCleanupThreads(void)
+{
+#ifdef DEBUG_THREADS
+    xmlGenericError(xmlGenericErrorContext, "xmlCleanupThreads()\n");
+#endif
+#if defined(HAVE_WIN32_THREADS) && !defined(HAVE_COMPILER_TLS) && (!defined(LIBXML_STATIC) || defined(LIBXML_STATIC_FOR_DLL))
+    if (globalkey != TLS_OUT_OF_INDEXES) {
+	xmlGlobalStateCleanupHelperParams * p;
+	EnterCriticalSection(&cleanup_helpers_cs);
+	p = cleanup_helpers_head;
+	while (p != NULL) {
+		xmlGlobalStateCleanupHelperParams * temp = p;
+		p = p->next;
+		xmlFreeGlobalState(temp->memory);
+		free(temp);
+	}
+	cleanup_helpers_head = 0;
+	LeaveCriticalSection(&cleanup_helpers_cs);
+	TlsFree(globalkey);
+	globalkey = TLS_OUT_OF_INDEXES;
+    }
+    DeleteCriticalSection(&cleanup_helpers_cs);
+#endif
+}
+
+#ifdef LIBXML_THREAD_ENABLED
+/**
+ * xmlOnceInit
+ *
+ * xmlOnceInit() is used to initialize the value of mainthread for use
+ * in other routines. This function should only be called using
+ * pthread_once() in association with the once_control variable to ensure
+ * that the function is only called once. See man pthread_once for more
+ * details.
+ */
+static void
+xmlOnceInit(void) {
+#ifdef HAVE_PTHREAD_H
+    (void) pthread_key_create(&globalkey, xmlFreeGlobalState);
+    mainthread = pthread_self();
+#endif
+
+#if defined(HAVE_WIN32_THREADS)
+#if !defined(HAVE_COMPILER_TLS)
+    globalkey = TlsAlloc();
+#endif
+    mainthread = GetCurrentThreadId();
+#endif
+
+#ifdef HAVE_BEOS_THREADS
+	if (atomic_add(&run_once_init, 1) == 0) {
+		globalkey = tls_allocate();
+		tls_set(globalkey, NULL);
+		mainthread = find_thread(NULL);
+	} else
+		atomic_add(&run_once_init, -1);
+#endif
+}
+#endif
+
+/**
+ * DllMain:
+ * @hinstDLL: handle to DLL instance
+ * @fdwReason: Reason code for entry
+ * @lpvReserved: generic pointer (depends upon reason code)
+ *
+ * Entry point for Windows library. It is being used to free thread-specific
+ * storage.
+ *
+ * Returns TRUE always
+ */
+#if defined(HAVE_WIN32_THREADS) && !defined(HAVE_COMPILER_TLS) && (!defined(LIBXML_STATIC) || defined(LIBXML_STATIC_FOR_DLL))
+#if defined(LIBXML_STATIC_FOR_DLL)
+BOOL WINAPI xmlDllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved) 
+#else
+BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved) 
+#endif
+{
+    switch(fdwReason) {
+    case DLL_THREAD_DETACH:
+	if (globalkey != TLS_OUT_OF_INDEXES) {
+	    xmlGlobalState *globalval = NULL;
+	    xmlGlobalStateCleanupHelperParams * p =
+		(xmlGlobalStateCleanupHelperParams*)TlsGetValue(globalkey);
+	    globalval = (xmlGlobalState *)(p ? p->memory : NULL);
+            if (globalval) {
+                xmlFreeGlobalState(globalval);
+                TlsSetValue(globalkey,NULL);
+            }
+	    if (p)
+	    {
+		EnterCriticalSection(&cleanup_helpers_cs);
+                if (p == cleanup_helpers_head)
+		    cleanup_helpers_head = p->next;
+                else
+		    p->prev->next = p->next;
+                if (p->next != NULL)
+                    p->next->prev = p->prev;
+		LeaveCriticalSection(&cleanup_helpers_cs);
+		free(p);
+	    }
+	}
+	break;
+    }
+    return TRUE;
+}
+#endif
diff --git a/src/libxml/src/tree.c b/src/libxml/src/tree.c
new file mode 100644
index 0000000..8e9cbf6
--- /dev/null
+++ b/src/libxml/src/tree.c
@@ -0,0 +1,7026 @@
+/*
+ * tree.c : implementation of access function for an XML tree.
+ *
+ * References:
+ *   XHTML 1.0 W3C REC: http://www.w3.org/TR/2002/REC-xhtml1-20020801/
+ *
+ * See Copyright for the status of this software.
+ *
+ * daniel@veillard.com
+ *
+ */
+
+#define IN_LIBXML
+#include "libxml.h"
+
+#include <string.h> /* for memset() only ! */
+
+#ifdef HAVE_CTYPE_H
+#include <ctype.h>
+#endif
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+#ifdef HAVE_ZLIB_H
+#include <zlib.h>
+#endif
+
+#include <libxml/xmlmemory.h>
+#include <libxml/tree.h>
+#include <libxml/parser.h>
+#include <libxml/uri.h>
+#include <libxml/entities.h>
+#include <libxml/valid.h>
+#include <libxml/xmlerror.h>
+#include <libxml/parserInternals.h>
+#include <libxml/globals.h>
+#ifdef LIBXML_HTML_ENABLED
+#include <libxml/HTMLtree.h>
+#endif
+
+int __xmlRegisterCallbacks = 0;
+
+xmlNsPtr xmlNewReconciliedNs(xmlDocPtr doc, xmlNodePtr tree, xmlNsPtr ns);
+
+/************************************************************************
+ *									*
+ * 		Tree memory error handler				*
+ *									*
+ ************************************************************************/
+/**
+ * xmlTreeErrMemory:
+ * @extra:  extra informations
+ *
+ * Handle an out of memory condition
+ */
+static void
+xmlTreeErrMemory(const char *extra)
+{
+    __xmlSimpleError(XML_FROM_TREE, XML_ERR_NO_MEMORY, NULL, NULL, extra);
+}
+
+/**
+ * xmlTreeErr:
+ * @code:  the error number
+ * @extra:  extra informations
+ *
+ * Handle an out of memory condition
+ */
+static void
+xmlTreeErr(int code, xmlNodePtr node, const char *extra)
+{
+    const char *msg = NULL;
+
+    switch(code) {
+        case XML_TREE_INVALID_HEX:
+	    msg = "invalid hexadecimal character value";
+	    break;
+	case XML_TREE_INVALID_DEC:
+	    msg = "invalid decimal character value";
+	    break;
+	case XML_TREE_UNTERMINATED_ENTITY:
+	    msg = "unterminated entity reference %15s";
+	    break;
+	default:
+	    msg = "unexpected error number";
+    }
+    __xmlSimpleError(XML_FROM_TREE, code, node, msg, extra);
+}
+
+/************************************************************************
+ *									*
+ * 		A few static variables and macros			*
+ *									*
+ ************************************************************************/
+/* #undef xmlStringText */
+const xmlChar xmlStringText[] = { 't', 'e', 'x', 't', 0 };
+/* #undef xmlStringTextNoenc */
+const xmlChar xmlStringTextNoenc[] =
+              { 't', 'e', 'x', 't', 'n', 'o', 'e', 'n', 'c', 0 };
+/* #undef xmlStringComment */
+const xmlChar xmlStringComment[] = { 'c', 'o', 'm', 'm', 'e', 'n', 't', 0 };
+
+static int xmlCompressMode = 0;
+static int xmlCheckDTD = 1;
+
+#define UPDATE_LAST_CHILD_AND_PARENT(n) if ((n) != NULL) {		\
+    xmlNodePtr ulccur = (n)->children;					\
+    if (ulccur == NULL) {						\
+        (n)->last = NULL;						\
+    } else {								\
+        while (ulccur->next != NULL) {					\
+	       	ulccur->parent = (n);					\
+		ulccur = ulccur->next;					\
+	}								\
+	ulccur->parent = (n);						\
+	(n)->last = ulccur;						\
+}}
+
+/* #define DEBUG_BUFFER */
+/* #define DEBUG_TREE */
+
+/************************************************************************
+ *									*
+ *		Functions to move to entities.c once the 		*
+ *		API freeze is smoothen and they can be made public.	*
+ *									*
+ ************************************************************************/
+#include <libxml/hash.h>
+ 
+#ifdef LIBXML_TREE_ENABLED
+/**
+ * xmlGetEntityFromDtd:
+ * @dtd:  A pointer to the DTD to search
+ * @name:  The entity name
+ *
+ * Do an entity lookup in the DTD entity hash table and
+ * return the corresponding entity, if found.
+ * 
+ * Returns A pointer to the entity structure or NULL if not found.
+ */
+static xmlEntityPtr
+xmlGetEntityFromDtd(xmlDtdPtr dtd, const xmlChar *name) {
+    xmlEntitiesTablePtr table;
+    
+    if((dtd != NULL) && (dtd->entities != NULL)) {
+	table = (xmlEntitiesTablePtr) dtd->entities;
+	return((xmlEntityPtr) xmlHashLookup(table, name));
+    	/* return(xmlGetEntityFromTable(table, name)); */
+    }
+    return(NULL);
+}
+/**
+ * xmlGetParameterEntityFromDtd:
+ * @dtd:  A pointer to the DTD to search
+ * @name:  The entity name
+ * 
+ * Do an entity lookup in the DTD pararmeter entity hash table and
+ * return the corresponding entity, if found.
+ *
+ * Returns A pointer to the entity structure or NULL if not found.
+ */
+static xmlEntityPtr
+xmlGetParameterEntityFromDtd(xmlDtdPtr dtd, const xmlChar *name) {
+    xmlEntitiesTablePtr table;
+    
+    if ((dtd != NULL) && (dtd->pentities != NULL)) {
+	table = (xmlEntitiesTablePtr) dtd->pentities;
+	return((xmlEntityPtr) xmlHashLookup(table, name));
+	/* return(xmlGetEntityFromTable(table, name)); */
+    }
+    return(NULL);
+}
+#endif /* LIBXML_TREE_ENABLED */
+
+/************************************************************************
+ *									*
+ *			QName handling helper				*
+ *									*
+ ************************************************************************/
+
+/**
+ * xmlBuildQName:
+ * @ncname:  the Name
+ * @prefix:  the prefix
+ * @memory:  preallocated memory
+ * @len:  preallocated memory length
+ *
+ * Builds the QName @prefix:@ncname in @memory if there is enough space
+ * and prefix is not NULL nor empty, otherwise allocate a new string.
+ * If prefix is NULL or empty it returns ncname.
+ *
+ * Returns the new string which must be freed by the caller if different from
+ *         @memory and @ncname or NULL in case of error
+ */
+xmlChar *
+xmlBuildQName(const xmlChar *ncname, const xmlChar *prefix,
+	      xmlChar *memory, int len) {
+    int lenn, lenp;
+    xmlChar *ret;
+
+    if (ncname == NULL) return(NULL);
+    if (prefix == NULL) return((xmlChar *) ncname);
+
+    lenn = strlen((char *) ncname);
+    lenp = strlen((char *) prefix);
+
+    if ((memory == NULL) || (len < lenn + lenp + 2)) {
+	ret = (xmlChar *) xmlMallocAtomic(lenn + lenp + 2);
+	if (ret == NULL) {
+	    xmlTreeErrMemory("building QName");
+	    return(NULL);
+	}
+    } else {
+	ret = memory;
+    }
+    memcpy(&ret[0], prefix, lenp);
+    ret[lenp] = ':';
+    memcpy(&ret[lenp + 1], ncname, lenn);
+    ret[lenn + lenp + 1] = 0;
+    return(ret);
+}
+
+/**
+ * xmlSplitQName2:
+ * @name:  the full QName
+ * @prefix:  a xmlChar ** 
+ *
+ * parse an XML qualified name string
+ *
+ * [NS 5] QName ::= (Prefix ':')? LocalPart
+ *
+ * [NS 6] Prefix ::= NCName
+ *
+ * [NS 7] LocalPart ::= NCName
+ *
+ * Returns NULL if not a QName, otherwise the local part, and prefix
+ *   is updated to get the Prefix if any.
+ */
+
+xmlChar *
+xmlSplitQName2(const xmlChar *name, xmlChar **prefix) {
+    int len = 0;
+    xmlChar *ret = NULL;
+
+    *prefix = NULL;
+    if (name == NULL) return(NULL);
+
+#ifndef XML_XML_NAMESPACE
+    /* xml: prefix is not really a namespace */
+    if ((name[0] == 'x') && (name[1] == 'm') &&
+        (name[2] == 'l') && (name[3] == ':'))
+	return(NULL);
+#endif
+
+    /* nasty but valid */
+    if (name[0] == ':')
+	return(NULL);
+
+    /*
+     * we are not trying to validate but just to cut, and yes it will
+     * work even if this is as set of UTF-8 encoded chars
+     */
+    while ((name[len] != 0) && (name[len] != ':')) 
+	len++;
+    
+    if (name[len] == 0)
+	return(NULL);
+
+    *prefix = xmlStrndup(name, len);
+    if (*prefix == NULL) {
+	xmlTreeErrMemory("QName split");
+	return(NULL);
+    }
+    ret = xmlStrdup(&name[len + 1]);
+    if (ret == NULL) {
+	xmlTreeErrMemory("QName split");
+	if (*prefix != NULL) {
+	    xmlFree(*prefix);
+	    *prefix = NULL;
+	}
+	return(NULL);
+    }
+
+    return(ret);
+}
+
+/**
+ * xmlSplitQName3:
+ * @name:  the full QName
+ * @len: an int *
+ *
+ * parse an XML qualified name string,i
+ *
+ * returns NULL if it is not a Qualified Name, otherwise, update len
+ *         with the lenght in byte of the prefix and return a pointer
+ */
+
+const xmlChar *
+xmlSplitQName3(const xmlChar *name, int *len) {
+    int l = 0;
+
+    if (name == NULL) return(NULL);
+    if (len == NULL) return(NULL);
+
+    /* nasty but valid */
+    if (name[0] == ':')
+	return(NULL);
+
+    /*
+     * we are not trying to validate but just to cut, and yes it will
+     * work even if this is as set of UTF-8 encoded chars
+     */
+    while ((name[l] != 0) && (name[l] != ':')) 
+	l++;
+    
+    if (name[l] == 0)
+	return(NULL);
+
+    *len = l;
+
+    return(&name[l+1]);
+}
+
+/************************************************************************
+ *									*
+ *		Check Name, NCName and QName strings			*
+ *									*
+ ************************************************************************/
+ 
+#define CUR_SCHAR(s, l) xmlStringCurrentChar(NULL, s, &l)
+
+#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
+/**
+ * xmlValidateNCName:
+ * @value: the value to check
+ * @space: allow spaces in front and end of the string
+ *
+ * Check that a value conforms to the lexical space of NCName
+ *
+ * Returns 0 if this validates, a positive error code number otherwise
+ *         and -1 in case of internal or API error.
+ */
+int
+xmlValidateNCName(const xmlChar *value, int space) {
+    const xmlChar *cur = value;
+    int c,l;
+
+    /*
+     * First quick algorithm for ASCII range
+     */
+    if (space)
+	while (IS_BLANK_CH(*cur)) cur++;
+    if (((*cur >= 'a') && (*cur <= 'z')) || ((*cur >= 'A') && (*cur <= 'Z')) ||
+	(*cur == '_'))
+	cur++;
+    else
+	goto try_complex;
+    while (((*cur >= 'a') && (*cur <= 'z')) ||
+	   ((*cur >= 'A') && (*cur <= 'Z')) ||
+	   ((*cur >= '0') && (*cur <= '9')) ||
+	   (*cur == '_') || (*cur == '-') || (*cur == '.'))
+	cur++;
+    if (space)
+	while (IS_BLANK_CH(*cur)) cur++;
+    if (*cur == 0)
+	return(0);
+
+try_complex:
+    /*
+     * Second check for chars outside the ASCII range
+     */
+    cur = value;
+    c = CUR_SCHAR(cur, l);
+    if (space) {
+	while (IS_BLANK(c)) {
+	    cur += l;
+	    c = CUR_SCHAR(cur, l);
+	}
+    }
+    if ((!IS_LETTER(c)) && (c != '_'))
+	return(1);
+    cur += l;
+    c = CUR_SCHAR(cur, l);
+    while (IS_LETTER(c) || IS_DIGIT(c) || (c == '.') ||
+	   (c == '-') || (c == '_') || IS_COMBINING(c) ||
+	   IS_EXTENDER(c)) {
+	cur += l;
+	c = CUR_SCHAR(cur, l);
+    }
+    if (space) {
+	while (IS_BLANK(c)) {
+	    cur += l;
+	    c = CUR_SCHAR(cur, l);
+	}
+    }
+    if (c != 0)
+	return(1);
+
+    return(0);
+}
+#endif
+
+#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
+/**
+ * xmlValidateQName:
+ * @value: the value to check
+ * @space: allow spaces in front and end of the string
+ *
+ * Check that a value conforms to the lexical space of QName
+ *
+ * Returns 0 if this validates, a positive error code number otherwise
+ *         and -1 in case of internal or API error.
+ */
+int
+xmlValidateQName(const xmlChar *value, int space) {
+    const xmlChar *cur = value;
+    int c,l;
+
+    /*
+     * First quick algorithm for ASCII range
+     */
+    if (space)
+	while (IS_BLANK_CH(*cur)) cur++;
+    if (((*cur >= 'a') && (*cur <= 'z')) || ((*cur >= 'A') && (*cur <= 'Z')) ||
+	(*cur == '_'))
+	cur++;
+    else
+	goto try_complex;
+    while (((*cur >= 'a') && (*cur <= 'z')) ||
+	   ((*cur >= 'A') && (*cur <= 'Z')) ||
+	   ((*cur >= '0') && (*cur <= '9')) ||
+	   (*cur == '_') || (*cur == '-') || (*cur == '.'))
+	cur++;
+    if (*cur == ':') {
+	cur++;
+	if (((*cur >= 'a') && (*cur <= 'z')) ||
+	    ((*cur >= 'A') && (*cur <= 'Z')) ||
+	    (*cur == '_'))
+	    cur++;
+	else
+	    goto try_complex;
+	while (((*cur >= 'a') && (*cur <= 'z')) ||
+	       ((*cur >= 'A') && (*cur <= 'Z')) ||
+	       ((*cur >= '0') && (*cur <= '9')) ||
+	       (*cur == '_') || (*cur == '-') || (*cur == '.'))
+	    cur++;
+    }
+    if (space)
+	while (IS_BLANK_CH(*cur)) cur++;
+    if (*cur == 0)
+	return(0);
+
+try_complex:
+    /*
+     * Second check for chars outside the ASCII range
+     */
+    cur = value;
+    c = CUR_SCHAR(cur, l);
+    if (space) {
+	while (IS_BLANK(c)) {
+	    cur += l;
+	    c = CUR_SCHAR(cur, l);
+	}
+    }
+    if ((!IS_LETTER(c)) && (c != '_'))
+	return(1);
+    cur += l;
+    c = CUR_SCHAR(cur, l);
+    while (IS_LETTER(c) || IS_DIGIT(c) || (c == '.') ||
+	   (c == '-') || (c == '_') || IS_COMBINING(c) ||
+	   IS_EXTENDER(c)) {
+	cur += l;
+	c = CUR_SCHAR(cur, l);
+    }
+    if (c == ':') {
+	cur += l;
+	c = CUR_SCHAR(cur, l);
+	if ((!IS_LETTER(c)) && (c != '_'))
+	    return(1);
+	cur += l;
+	c = CUR_SCHAR(cur, l);
+	while (IS_LETTER(c) || IS_DIGIT(c) || (c == '.') ||
+	       (c == '-') || (c == '_') || IS_COMBINING(c) ||
+	       IS_EXTENDER(c)) {
+	    cur += l;
+	    c = CUR_SCHAR(cur, l);
+	}
+    }
+    if (space) {
+	while (IS_BLANK(c)) {
+	    cur += l;
+	    c = CUR_SCHAR(cur, l);
+	}
+    }
+    if (c != 0)
+	return(1);
+    return(0);
+}
+
+/**
+ * xmlValidateName:
+ * @value: the value to check
+ * @space: allow spaces in front and end of the string
+ *
+ * Check that a value conforms to the lexical space of Name
+ *
+ * Returns 0 if this validates, a positive error code number otherwise
+ *         and -1 in case of internal or API error.
+ */
+int
+xmlValidateName(const xmlChar *value, int space) {
+    const xmlChar *cur = value;
+    int c,l;
+
+    /*
+     * First quick algorithm for ASCII range
+     */
+    if (space)
+	while (IS_BLANK_CH(*cur)) cur++;
+    if (((*cur >= 'a') && (*cur <= 'z')) || ((*cur >= 'A') && (*cur <= 'Z')) ||
+	(*cur == '_') || (*cur == ':'))
+	cur++;
+    else
+	goto try_complex;
+    while (((*cur >= 'a') && (*cur <= 'z')) ||
+	   ((*cur >= 'A') && (*cur <= 'Z')) ||
+	   ((*cur >= '0') && (*cur <= '9')) ||
+	   (*cur == '_') || (*cur == '-') || (*cur == '.') || (*cur == ':'))
+	cur++;
+    if (space)
+	while (IS_BLANK_CH(*cur)) cur++;
+    if (*cur == 0)
+	return(0);
+
+try_complex:
+    /*
+     * Second check for chars outside the ASCII range
+     */
+    cur = value;
+    c = CUR_SCHAR(cur, l);
+    if (space) {
+	while (IS_BLANK(c)) {
+	    cur += l;
+	    c = CUR_SCHAR(cur, l);
+	}
+    }
+    if ((!IS_LETTER(c)) && (c != '_') && (c != ':'))
+	return(1);
+    cur += l;
+    c = CUR_SCHAR(cur, l);
+    while (IS_LETTER(c) || IS_DIGIT(c) || (c == '.') || (c == ':') ||
+	   (c == '-') || (c == '_') || IS_COMBINING(c) || IS_EXTENDER(c)) {
+	cur += l;
+	c = CUR_SCHAR(cur, l);
+    }
+    if (space) {
+	while (IS_BLANK(c)) {
+	    cur += l;
+	    c = CUR_SCHAR(cur, l);
+	}
+    }
+    if (c != 0)
+	return(1);
+    return(0);
+}
+
+/**
+ * xmlValidateNMToken:
+ * @value: the value to check
+ * @space: allow spaces in front and end of the string
+ *
+ * Check that a value conforms to the lexical space of NMToken
+ *
+ * Returns 0 if this validates, a positive error code number otherwise
+ *         and -1 in case of internal or API error.
+ */
+int
+xmlValidateNMToken(const xmlChar *value, int space) {
+    const xmlChar *cur = value;
+    int c,l;
+
+    /*
+     * First quick algorithm for ASCII range
+     */
+    if (space)
+	while (IS_BLANK_CH(*cur)) cur++;
+    if (((*cur >= 'a') && (*cur <= 'z')) ||
+        ((*cur >= 'A') && (*cur <= 'Z')) ||
+        ((*cur >= '0') && (*cur <= '9')) ||
+        (*cur == '_') || (*cur == '-') || (*cur == '.') || (*cur == ':'))
+	cur++;
+    else
+	goto try_complex;
+    while (((*cur >= 'a') && (*cur <= 'z')) ||
+	   ((*cur >= 'A') && (*cur <= 'Z')) ||
+	   ((*cur >= '0') && (*cur <= '9')) ||
+	   (*cur == '_') || (*cur == '-') || (*cur == '.') || (*cur == ':'))
+	cur++;
+    if (space)
+	while (IS_BLANK_CH(*cur)) cur++;
+    if (*cur == 0)
+	return(0);
+
+try_complex:
+    /*
+     * Second check for chars outside the ASCII range
+     */
+    cur = value;
+    c = CUR_SCHAR(cur, l);
+    if (space) {
+	while (IS_BLANK(c)) {
+	    cur += l;
+	    c = CUR_SCHAR(cur, l);
+	}
+    }
+    if (!(IS_LETTER(c) || IS_DIGIT(c) || (c == '.') || (c == ':') ||
+        (c == '-') || (c == '_') || IS_COMBINING(c) || IS_EXTENDER(c)))
+	return(1);
+    cur += l;
+    c = CUR_SCHAR(cur, l);
+    while (IS_LETTER(c) || IS_DIGIT(c) || (c == '.') || (c == ':') ||
+	   (c == '-') || (c == '_') || IS_COMBINING(c) || IS_EXTENDER(c)) {
+	cur += l;
+	c = CUR_SCHAR(cur, l);
+    }
+    if (space) {
+	while (IS_BLANK(c)) {
+	    cur += l;
+	    c = CUR_SCHAR(cur, l);
+	}
+    }
+    if (c != 0)
+	return(1);
+    return(0);
+}
+#endif /* LIBXML_TREE_ENABLED */
+
+/************************************************************************
+ *									*
+ *		Allocation and deallocation of basic structures		*
+ *									*
+ ************************************************************************/
+ 
+/**
+ * xmlSetBufferAllocationScheme:
+ * @scheme:  allocation method to use
+ * 
+ * Set the buffer allocation method.  Types are
+ * XML_BUFFER_ALLOC_EXACT - use exact sizes, keeps memory usage down
+ * XML_BUFFER_ALLOC_DOUBLEIT - double buffer when extra needed, 
+ *                             improves performance
+ */
+void
+xmlSetBufferAllocationScheme(xmlBufferAllocationScheme scheme) {
+    xmlBufferAllocScheme = scheme;
+}
+
+/**
+ * xmlGetBufferAllocationScheme:
+ *
+ * Types are
+ * XML_BUFFER_ALLOC_EXACT - use exact sizes, keeps memory usage down
+ * XML_BUFFER_ALLOC_DOUBLEIT - double buffer when extra needed, 
+ *                             improves performance
+ * 
+ * Returns the current allocation scheme
+ */
+xmlBufferAllocationScheme
+xmlGetBufferAllocationScheme(void) {
+    return(xmlBufferAllocScheme);
+}
+
+/**
+ * xmlNewNs:
+ * @node:  the element carrying the namespace
+ * @href:  the URI associated
+ * @prefix:  the prefix for the namespace
+ *
+ * Creation of a new Namespace. This function will refuse to create
+ * a namespace with a similar prefix than an existing one present on this
+ * node.
+ * We use href==NULL in the case of an element creation where the namespace
+ * was not defined.
+ * Returns a new namespace pointer or NULL
+ */
+xmlNsPtr
+xmlNewNs(xmlNodePtr node, const xmlChar *href, const xmlChar *prefix) {
+    xmlNsPtr cur;
+
+    if ((node != NULL) && (node->type != XML_ELEMENT_NODE))
+	return(NULL);
+
+    if ((prefix != NULL) && (xmlStrEqual(prefix, BAD_CAST "xml")))
+	return(NULL);
+
+    /*
+     * Allocate a new Namespace and fill the fields.
+     */
+    cur = (xmlNsPtr) xmlMalloc(sizeof(xmlNs));
+    if (cur == NULL) {
+	xmlTreeErrMemory("building namespace");
+	return(NULL);
+    }
+    memset(cur, 0, sizeof(xmlNs));
+    cur->type = XML_LOCAL_NAMESPACE;
+
+    if (href != NULL)
+	cur->href = xmlStrdup(href); 
+    if (prefix != NULL)
+	cur->prefix = xmlStrdup(prefix); 
+
+    /*
+     * Add it at the end to preserve parsing order ...
+     * and checks for existing use of the prefix
+     */
+    if (node != NULL) {
+	if (node->nsDef == NULL) {
+	    node->nsDef = cur;
+	} else {
+	    xmlNsPtr prev = node->nsDef;
+
+	    if (((prev->prefix == NULL) && (cur->prefix == NULL)) ||
+		(xmlStrEqual(prev->prefix, cur->prefix))) {
+		xmlFreeNs(cur);
+		return(NULL);
+	    }    
+	    while (prev->next != NULL) {
+	        prev = prev->next;
+		if (((prev->prefix == NULL) && (cur->prefix == NULL)) ||
+		    (xmlStrEqual(prev->prefix, cur->prefix))) {
+		    xmlFreeNs(cur);
+		    return(NULL);
+		}    
+	    }
+	    prev->next = cur;
+	}
+    }
+    return(cur);
+}
+
+/**
+ * xmlSetNs:
+ * @node:  a node in the document
+ * @ns:  a namespace pointer
+ *
+ * Associate a namespace to a node, a posteriori.
+ */
+void
+xmlSetNs(xmlNodePtr node, xmlNsPtr ns) {
+    if (node == NULL) {
+#ifdef DEBUG_TREE
+        xmlGenericError(xmlGenericErrorContext,
+		"xmlSetNs: node == NULL\n");
+#endif
+	return;
+    }
+    node->ns = ns;
+}
+
+/**
+ * xmlFreeNs:
+ * @cur:  the namespace pointer
+ *
+ * Free up the structures associated to a namespace
+ */
+void
+xmlFreeNs(xmlNsPtr cur) {
+    if (cur == NULL) {
+#ifdef DEBUG_TREE
+        xmlGenericError(xmlGenericErrorContext,
+		"xmlFreeNs : ns == NULL\n");
+#endif
+	return;
+    }
+    if (cur->href != NULL) xmlFree((char *) cur->href);
+    if (cur->prefix != NULL) xmlFree((char *) cur->prefix);
+    xmlFree(cur);
+}
+
+/**
+ * xmlFreeNsList:
+ * @cur:  the first namespace pointer
+ *
+ * Free up all the structures associated to the chained namespaces.
+ */
+void
+xmlFreeNsList(xmlNsPtr cur) {
+    xmlNsPtr next;
+    if (cur == NULL) {
+#ifdef DEBUG_TREE
+        xmlGenericError(xmlGenericErrorContext,
+		"xmlFreeNsList : ns == NULL\n");
+#endif
+	return;
+    }
+    while (cur != NULL) {
+        next = cur->next;
+        xmlFreeNs(cur);
+	cur = next;
+    }
+}
+
+/**
+ * xmlNewDtd:
+ * @doc:  the document pointer
+ * @name:  the DTD name
+ * @ExternalID:  the external ID
+ * @SystemID:  the system ID
+ *
+ * Creation of a new DTD for the external subset. To create an
+ * internal subset, use xmlCreateIntSubset().
+ *
+ * Returns a pointer to the new DTD structure
+ */
+xmlDtdPtr
+xmlNewDtd(xmlDocPtr doc, const xmlChar *name,
+                    const xmlChar *ExternalID, const xmlChar *SystemID) {
+    xmlDtdPtr cur;
+
+    if ((doc != NULL) && (doc->extSubset != NULL)) {
+#ifdef DEBUG_TREE
+        xmlGenericError(xmlGenericErrorContext,
+		"xmlNewDtd(%s): document %s already have a DTD %s\n",
+	    /* !!! */ (char *) name, doc->name,
+	    /* !!! */ (char *)doc->extSubset->name);
+#endif
+	return(NULL);
+    }
+
+    /*
+     * Allocate a new DTD and fill the fields.
+     */
+    cur = (xmlDtdPtr) xmlMalloc(sizeof(xmlDtd));
+    if (cur == NULL) {
+	xmlTreeErrMemory("building DTD");
+	return(NULL);
+    }
+    memset(cur, 0 , sizeof(xmlDtd));
+    cur->type = XML_DTD_NODE;
+
+    if (name != NULL)
+	cur->name = xmlStrdup(name); 
+    if (ExternalID != NULL)
+	cur->ExternalID = xmlStrdup(ExternalID); 
+    if (SystemID != NULL)
+	cur->SystemID = xmlStrdup(SystemID); 
+    if (doc != NULL)
+	doc->extSubset = cur;
+    cur->doc = doc;
+
+    if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue))
+	xmlRegisterNodeDefaultValue((xmlNodePtr)cur);
+    return(cur);
+}
+
+/**
+ * xmlGetIntSubset:
+ * @doc:  the document pointer
+ *
+ * Get the internal subset of a document
+ * Returns a pointer to the DTD structure or NULL if not found
+ */
+
+xmlDtdPtr
+xmlGetIntSubset(xmlDocPtr doc) {
+    xmlNodePtr cur;
+
+    if (doc == NULL)
+	return(NULL);
+    cur = doc->children;
+    while (cur != NULL) {
+	if (cur->type == XML_DTD_NODE)
+	    return((xmlDtdPtr) cur);
+	cur = cur->next;
+    }
+    return((xmlDtdPtr) doc->intSubset);
+}
+
+/**
+ * xmlCreateIntSubset:
+ * @doc:  the document pointer
+ * @name:  the DTD name
+ * @ExternalID:  the external (PUBLIC) ID
+ * @SystemID:  the system ID
+ *
+ * Create the internal subset of a document
+ * Returns a pointer to the new DTD structure
+ */
+xmlDtdPtr
+xmlCreateIntSubset(xmlDocPtr doc, const xmlChar *name,
+                   const xmlChar *ExternalID, const xmlChar *SystemID) {
+    xmlDtdPtr cur;
+
+    if ((doc != NULL) && (xmlGetIntSubset(doc) != NULL)) {
+#ifdef DEBUG_TREE
+        xmlGenericError(xmlGenericErrorContext,
+
+     "xmlCreateIntSubset(): document %s already have an internal subset\n",
+	    doc->name);
+#endif
+	return(NULL);
+    }
+
+    /*
+     * Allocate a new DTD and fill the fields.
+     */
+    cur = (xmlDtdPtr) xmlMalloc(sizeof(xmlDtd));
+    if (cur == NULL) {
+	xmlTreeErrMemory("building internal subset");
+	return(NULL);
+    }
+    memset(cur, 0, sizeof(xmlDtd));
+    cur->type = XML_DTD_NODE;
+
+    if (name != NULL)
+	cur->name = xmlStrdup(name); 
+    if (ExternalID != NULL)
+	cur->ExternalID = xmlStrdup(ExternalID); 
+    if (SystemID != NULL)
+	cur->SystemID = xmlStrdup(SystemID); 
+    if (doc != NULL) {
+	doc->intSubset = cur;
+	cur->parent = doc;
+	cur->doc = doc;
+	if (doc->children == NULL) {
+	    doc->children = (xmlNodePtr) cur;
+	    doc->last = (xmlNodePtr) cur;
+	} else {
+	    if (doc->type == XML_HTML_DOCUMENT_NODE) {
+		xmlNodePtr prev;
+
+		prev = doc->children;
+		prev->prev = (xmlNodePtr) cur;
+		cur->next = prev;
+		doc->children = (xmlNodePtr) cur;
+	    } else {
+		xmlNodePtr next;
+
+		next = doc->children;
+		while ((next != NULL) && (next->type != XML_ELEMENT_NODE))
+		    next = next->next;
+		if (next == NULL) {
+		    cur->prev = doc->last;
+		    cur->prev->next = (xmlNodePtr) cur;
+		    cur->next = NULL;
+		    doc->last = (xmlNodePtr) cur;
+		} else {
+		    cur->next = next;
+		    cur->prev = next->prev;
+		    if (cur->prev == NULL)
+			doc->children = (xmlNodePtr) cur;
+		    else
+			cur->prev->next = (xmlNodePtr) cur;
+		    next->prev = (xmlNodePtr) cur;
+		}
+	    }
+	}
+    }
+
+    if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue))
+	xmlRegisterNodeDefaultValue((xmlNodePtr)cur);
+    return(cur);
+}
+
+/**
+ * DICT_FREE:
+ * @str:  a string
+ *
+ * Free a string if it is not owned by the "dict" dictionnary in the
+ * current scope
+ */
+#define DICT_FREE(str)						\
+	if ((str) && ((!dict) || 				\
+	    (xmlDictOwns(dict, (const xmlChar *)(str)) == 0)))	\
+	    xmlFree((char *)(str));
+
+/**
+ * xmlFreeDtd:
+ * @cur:  the DTD structure to free up
+ *
+ * Free a DTD structure.
+ */
+void
+xmlFreeDtd(xmlDtdPtr cur) {
+    xmlDictPtr dict = NULL;
+
+    if (cur == NULL) {
+	return;
+    }
+    if (cur->doc != NULL) dict = cur->doc->dict;
+
+    if ((__xmlRegisterCallbacks) && (xmlDeregisterNodeDefaultValue))
+	xmlDeregisterNodeDefaultValue((xmlNodePtr)cur);
+
+    if (cur->children != NULL) {
+	xmlNodePtr next, c = cur->children;
+
+	/*
+	 * Cleanup all the DTD comments they are not in the DTD
+	 * indexes.
+	 */
+        while (c != NULL) {
+	    next = c->next;
+	    if ((c->type == XML_COMMENT_NODE) || (c->type == XML_PI_NODE)) {
+		xmlUnlinkNode(c);
+		xmlFreeNode(c);
+	    }
+	    c = next;
+	}
+    }
+    DICT_FREE(cur->name)
+    DICT_FREE(cur->SystemID)
+    DICT_FREE(cur->ExternalID)
+    /* TODO !!! */
+    if (cur->notations != NULL)
+        xmlFreeNotationTable((xmlNotationTablePtr) cur->notations);
+    
+    if (cur->elements != NULL)
+        xmlFreeElementTable((xmlElementTablePtr) cur->elements);
+    if (cur->attributes != NULL)
+        xmlFreeAttributeTable((xmlAttributeTablePtr) cur->attributes);
+    if (cur->entities != NULL)
+        xmlFreeEntitiesTable((xmlEntitiesTablePtr) cur->entities);
+    if (cur->pentities != NULL)
+        xmlFreeEntitiesTable((xmlEntitiesTablePtr) cur->pentities);
+
+    xmlFree(cur);
+}
+
+/**
+ * xmlNewDoc:
+ * @version:  xmlChar string giving the version of XML "1.0"
+ *
+ * Creates a new XML document
+ *
+ * Returns a new document
+ */
+xmlDocPtr
+xmlNewDoc(const xmlChar *version) {
+    xmlDocPtr cur;
+
+    if (version == NULL)
+	version = (const xmlChar *) "1.0";
+
+    /*
+     * Allocate a new document and fill the fields.
+     */
+    cur = (xmlDocPtr) xmlMalloc(sizeof(xmlDoc));
+    if (cur == NULL) {
+	xmlTreeErrMemory("building doc");
+	return(NULL);
+    }
+    memset(cur, 0, sizeof(xmlDoc));
+    cur->type = XML_DOCUMENT_NODE;
+
+    cur->version = xmlStrdup(version); 
+    cur->standalone = -1;
+    cur->compression = -1; /* not initialized */
+    cur->doc = cur;
+    /*
+     * The in memory encoding is always UTF8
+     * This field will never change and would
+     * be obsolete if not for binary compatibility.
+     */
+    cur->charset = XML_CHAR_ENCODING_UTF8;
+
+    if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue))
+	xmlRegisterNodeDefaultValue((xmlNodePtr)cur);
+    return(cur);
+}
+
+/**
+ * xmlFreeDoc:
+ * @cur:  pointer to the document
+ *
+ * Free up all the structures used by a document, tree included.
+ */
+void
+xmlFreeDoc(xmlDocPtr cur) {
+    xmlDtdPtr extSubset, intSubset;
+    xmlDictPtr dict = NULL;
+
+    if (cur == NULL) {
+#ifdef DEBUG_TREE
+        xmlGenericError(xmlGenericErrorContext,
+		"xmlFreeDoc : document == NULL\n");
+#endif
+	return;
+    }
+    if (cur != NULL) dict = cur->dict;
+
+    if ((__xmlRegisterCallbacks) && (xmlDeregisterNodeDefaultValue))
+	xmlDeregisterNodeDefaultValue((xmlNodePtr)cur);
+
+    /*
+     * Do this before freeing the children list to avoid ID lookups
+     */
+    if (cur->ids != NULL) xmlFreeIDTable((xmlIDTablePtr) cur->ids);
+    cur->ids = NULL;
+    if (cur->refs != NULL) xmlFreeRefTable((xmlRefTablePtr) cur->refs);
+    cur->refs = NULL;
+    extSubset = cur->extSubset;
+    intSubset = cur->intSubset;
+    if (intSubset == extSubset)
+	extSubset = NULL;
+    if (extSubset != NULL) {
+	xmlUnlinkNode((xmlNodePtr) cur->extSubset);
+	cur->extSubset = NULL;
+	xmlFreeDtd(extSubset);
+    }
+    if (intSubset != NULL) {
+	xmlUnlinkNode((xmlNodePtr) cur->intSubset);
+	cur->intSubset = NULL;
+	xmlFreeDtd(intSubset);
+    }
+
+    if (cur->children != NULL) xmlFreeNodeList(cur->children);
+    if (cur->oldNs != NULL) xmlFreeNsList(cur->oldNs);
+
+    DICT_FREE(cur->version)
+    DICT_FREE(cur->name)
+    DICT_FREE(cur->encoding)
+    DICT_FREE(cur->URL)
+    xmlFree(cur);
+    if (dict) xmlDictFree(dict);
+}
+
+/**
+ * xmlStringLenGetNodeList:
+ * @doc:  the document
+ * @value:  the value of the text
+ * @len:  the length of the string value
+ *
+ * Parse the value string and build the node list associated. Should
+ * produce a flat tree with only TEXTs and ENTITY_REFs.
+ * Returns a pointer to the first child
+ */
+xmlNodePtr
+xmlStringLenGetNodeList(xmlDocPtr doc, const xmlChar *value, int len) {
+    xmlNodePtr ret = NULL, last = NULL;
+    xmlNodePtr node;
+    xmlChar *val;
+    const xmlChar *cur = value, *end = cur + len;
+    const xmlChar *q;
+    xmlEntityPtr ent;
+
+    if (value == NULL) return(NULL);
+
+    q = cur;
+    while ((cur < end) && (*cur != 0)) {
+	if (cur[0] == '&') {
+	    int charval = 0;
+	    xmlChar tmp;
+
+	    /*
+	     * Save the current text.
+	     */
+            if (cur != q) {
+		if ((last != NULL) && (last->type == XML_TEXT_NODE)) {
+		    xmlNodeAddContentLen(last, q, cur - q);
+		} else {
+		    node = xmlNewDocTextLen(doc, q, cur - q);
+		    if (node == NULL) return(ret);
+		    if (last == NULL)
+			last = ret = node;
+		    else {
+			last->next = node;
+			node->prev = last;
+			last = node;
+		    }
+		}
+	    }
+	    q = cur;
+	    if ((cur + 2 < end) && (cur[1] == '#') && (cur[2] == 'x')) {
+		cur += 3;
+		if (cur < end)
+		    tmp = *cur;
+		else
+		    tmp = 0;
+		while (tmp != ';') { /* Non input consuming loop */
+		    if ((tmp >= '0') && (tmp <= '9')) 
+			charval = charval * 16 + (tmp - '0');
+		    else if ((tmp >= 'a') && (tmp <= 'f'))
+			charval = charval * 16 + (tmp - 'a') + 10;
+		    else if ((tmp >= 'A') && (tmp <= 'F'))
+			charval = charval * 16 + (tmp - 'A') + 10;
+		    else {
+			xmlTreeErr(XML_TREE_INVALID_HEX, (xmlNodePtr) doc,
+			           NULL);
+			charval = 0;
+			break;
+		    }
+		    cur++;
+		    if (cur < end)
+			tmp = *cur;
+		    else
+			tmp = 0;
+		}
+		if (tmp == ';')
+		    cur++;
+		q = cur;
+	    } else if ((cur + 1 < end) && (cur[1] == '#')) {
+		cur += 2;
+		if (cur < end)
+		    tmp = *cur;
+		else
+		    tmp = 0;
+		while (tmp != ';') { /* Non input consuming loops */
+		    if ((tmp >= '0') && (tmp <= '9')) 
+			charval = charval * 10 + (tmp - '0');
+		    else {
+			xmlTreeErr(XML_TREE_INVALID_DEC, (xmlNodePtr) doc,
+			           NULL);
+			charval = 0;
+			break;
+		    }
+		    cur++;
+		    if (cur < end)
+			tmp = *cur;
+		    else
+			tmp = 0;
+		}
+		if (tmp == ';')
+		    cur++;
+		q = cur;
+	    } else {
+		/*
+		 * Read the entity string
+		 */
+		cur++;
+		q = cur;
+		while ((cur < end) && (*cur != 0) && (*cur != ';')) cur++;
+		if ((cur >= end) || (*cur == 0)) {
+		    xmlTreeErr(XML_TREE_UNTERMINATED_ENTITY, (xmlNodePtr) doc,
+		               (const char *) q);
+		    return(ret);
+		}
+		if (cur != q) {
+		    /*
+		     * Predefined entities don't generate nodes
+		     */
+		    val = xmlStrndup(q, cur - q);
+		    ent = xmlGetDocEntity(doc, val);
+		    if ((ent != NULL) &&
+			(ent->etype == XML_INTERNAL_PREDEFINED_ENTITY)) {
+			if (last == NULL) {
+			    node = xmlNewDocText(doc, ent->content);
+			    last = ret = node;
+			} else if (last->type != XML_TEXT_NODE) {
+			    node = xmlNewDocText(doc, ent->content);
+			    last = xmlAddNextSibling(last, node);
+			} else
+			    xmlNodeAddContent(last, ent->content);
+			    
+		    } else {
+			/*
+			 * Create a new REFERENCE_REF node
+			 */
+			node = xmlNewReference(doc, val);
+			if (node == NULL) {
+			    if (val != NULL) xmlFree(val);
+			    return(ret);
+			}
+			else if ((ent != NULL) && (ent->children == NULL)) {
+			    xmlNodePtr temp;
+
+			    ent->children = xmlStringGetNodeList(doc,
+				    (const xmlChar*)node->content);
+			    ent->owner = 1;
+			    temp = ent->children;
+			    while (temp) {
+				temp->parent = (xmlNodePtr)ent;
+				temp = temp->next;
+			    }
+			}
+			if (last == NULL) {
+			    last = ret = node;
+			} else {
+			    last = xmlAddNextSibling(last, node);
+			}
+		    }
+		    xmlFree(val);
+		}
+		cur++;
+		q = cur;
+	    }
+	    if (charval != 0) {
+		xmlChar buf[10];
+		int l;
+
+		l = xmlCopyCharMultiByte(buf, charval);
+		buf[l] = 0;
+		node = xmlNewDocText(doc, buf);
+		if (node != NULL) {
+		    if (last == NULL) {
+			last = ret = node;
+		    } else {
+			last = xmlAddNextSibling(last, node);
+		    }
+		}
+		charval = 0;
+	    }
+	} else
+	    cur++;
+    }
+    if ((cur != q) || (ret == NULL)) {
+        /*
+	 * Handle the last piece of text.
+	 */
+	if ((last != NULL) && (last->type == XML_TEXT_NODE)) {
+	    xmlNodeAddContentLen(last, q, cur - q);
+	} else {
+	    node = xmlNewDocTextLen(doc, q, cur - q);
+	    if (node == NULL) return(ret);
+	    if (last == NULL) {
+		last = ret = node;
+	    } else {
+		last = xmlAddNextSibling(last, node);
+	    }
+	}
+    }
+    return(ret);
+}
+
+/**
+ * xmlStringGetNodeList:
+ * @doc:  the document
+ * @value:  the value of the attribute
+ *
+ * Parse the value string and build the node list associated. Should
+ * produce a flat tree with only TEXTs and ENTITY_REFs.
+ * Returns a pointer to the first child
+ */
+xmlNodePtr
+xmlStringGetNodeList(xmlDocPtr doc, const xmlChar *value) {
+    xmlNodePtr ret = NULL, last = NULL;
+    xmlNodePtr node;
+    xmlChar *val;
+    const xmlChar *cur = value;
+    const xmlChar *q;
+    xmlEntityPtr ent;
+
+    if (value == NULL) return(NULL);
+
+    q = cur;
+    while (*cur != 0) {
+	if (cur[0] == '&') {
+	    int charval = 0;
+	    xmlChar tmp;
+
+	    /*
+	     * Save the current text.
+	     */
+            if (cur != q) {
+		if ((last != NULL) && (last->type == XML_TEXT_NODE)) {
+		    xmlNodeAddContentLen(last, q, cur - q);
+		} else {
+		    node = xmlNewDocTextLen(doc, q, cur - q);
+		    if (node == NULL) return(ret);
+		    if (last == NULL)
+			last = ret = node;
+		    else {
+			last->next = node;
+			node->prev = last;
+			last = node;
+		    }
+		}
+	    }
+	    q = cur;
+	    if ((cur[1] == '#') && (cur[2] == 'x')) {
+		cur += 3;
+		tmp = *cur;
+		while (tmp != ';') { /* Non input consuming loop */
+		    if ((tmp >= '0') && (tmp <= '9')) 
+			charval = charval * 16 + (tmp - '0');
+		    else if ((tmp >= 'a') && (tmp <= 'f'))
+			charval = charval * 16 + (tmp - 'a') + 10;
+		    else if ((tmp >= 'A') && (tmp <= 'F'))
+			charval = charval * 16 + (tmp - 'A') + 10;
+		    else {
+			xmlTreeErr(XML_TREE_INVALID_HEX, (xmlNodePtr) doc,
+			           NULL);
+			charval = 0;
+			break;
+		    }
+		    cur++;
+		    tmp = *cur;
+		}
+		if (tmp == ';')
+		    cur++;
+		q = cur;
+	    } else if  (cur[1] == '#') {
+		cur += 2;
+		tmp = *cur;
+		while (tmp != ';') { /* Non input consuming loops */
+		    if ((tmp >= '0') && (tmp <= '9')) 
+			charval = charval * 10 + (tmp - '0');
+		    else {
+			xmlTreeErr(XML_TREE_INVALID_DEC, (xmlNodePtr) doc,
+			           NULL);
+			charval = 0;
+			break;
+		    }
+		    cur++;
+		    tmp = *cur;
+		}
+		if (tmp == ';')
+		    cur++;
+		q = cur;
+	    } else {
+		/*
+		 * Read the entity string
+		 */
+		cur++;
+		q = cur;
+		while ((*cur != 0) && (*cur != ';')) cur++;
+		if (*cur == 0) {
+		    xmlTreeErr(XML_TREE_UNTERMINATED_ENTITY,
+		               (xmlNodePtr) doc, (const char *) q);
+		    return(ret);
+		}
+		if (cur != q) {
+		    /*
+		     * Predefined entities don't generate nodes
+		     */
+		    val = xmlStrndup(q, cur - q);
+		    ent = xmlGetDocEntity(doc, val);
+		    if ((ent != NULL) &&
+			(ent->etype == XML_INTERNAL_PREDEFINED_ENTITY)) {
+			if (last == NULL) {
+			    node = xmlNewDocText(doc, ent->content);
+			    last = ret = node;
+			} else if (last->type != XML_TEXT_NODE) {
+			    node = xmlNewDocText(doc, ent->content);
+			    last = xmlAddNextSibling(last, node);
+			} else
+			    xmlNodeAddContent(last, ent->content);
+			    
+		    } else {
+			/*
+			 * Create a new REFERENCE_REF node
+			 */
+			node = xmlNewReference(doc, val);
+			if (node == NULL) {
+			    if (val != NULL) xmlFree(val);
+			    return(ret);
+			}
+			else if ((ent != NULL) && (ent->children == NULL)) {
+			    xmlNodePtr temp;
+
+			    ent->children = xmlStringGetNodeList(doc,
+				    (const xmlChar*)node->content);
+			    ent->owner = 1;
+			    temp = ent->children;
+			    while (temp) {
+				temp->parent = (xmlNodePtr)ent;
+				temp = temp->next;
+			    }
+			}
+			if (last == NULL) {
+			    last = ret = node;
+			} else {
+			    last = xmlAddNextSibling(last, node);
+			}
+		    }
+		    xmlFree(val);
+		}
+		cur++;
+		q = cur;
+	    }
+	    if (charval != 0) {
+		xmlChar buf[10];
+		int len;
+
+		len = xmlCopyCharMultiByte(buf, charval);
+		buf[len] = 0;
+		node = xmlNewDocText(doc, buf);
+		if (node != NULL) {
+		    if (last == NULL) {
+			last = ret = node;
+		    } else {
+			last = xmlAddNextSibling(last, node);
+		    }
+		}
+
+		charval = 0;
+	    }
+	} else
+	    cur++;
+    }
+    if ((cur != q) || (ret == NULL)) {
+        /*
+	 * Handle the last piece of text.
+	 */
+	if ((last != NULL) && (last->type == XML_TEXT_NODE)) {
+	    xmlNodeAddContentLen(last, q, cur - q);
+	} else {
+	    node = xmlNewDocTextLen(doc, q, cur - q);
+	    if (node == NULL) return(ret);
+	    if (last == NULL) {
+		last = ret = node;
+	    } else {
+		last = xmlAddNextSibling(last, node);
+	    }
+	}
+    }
+    return(ret);
+}
+
+/**
+ * xmlNodeListGetString:
+ * @doc:  the document
+ * @list:  a Node list
+ * @inLine:  should we replace entity contents or show their external form
+ *
+ * Build the string equivalent to the text contained in the Node list
+ * made of TEXTs and ENTITY_REFs
+ *
+ * Returns a pointer to the string copy, the caller must free it with xmlFree().
+ */
+xmlChar *
+xmlNodeListGetString(xmlDocPtr doc, xmlNodePtr list, int inLine)
+{
+    xmlNodePtr node = list;
+    xmlChar *ret = NULL;
+    xmlEntityPtr ent;
+
+    if (list == NULL)
+        return (NULL);
+
+    while (node != NULL) {
+        if ((node->type == XML_TEXT_NODE) ||
+            (node->type == XML_CDATA_SECTION_NODE)) {
+            if (inLine) {
+                ret = xmlStrcat(ret, node->content);
+            } else {
+                xmlChar *buffer;
+
+                buffer = xmlEncodeEntitiesReentrant(doc, node->content);
+                if (buffer != NULL) {
+                    ret = xmlStrcat(ret, buffer);
+                    xmlFree(buffer);
+                }
+            }
+        } else if (node->type == XML_ENTITY_REF_NODE) {
+            if (inLine) {
+                ent = xmlGetDocEntity(doc, node->name);
+                if (ent != NULL) {
+                    xmlChar *buffer;
+
+                    /* an entity content can be any "well balanced chunk",
+                     * i.e. the result of the content [43] production:
+                     * http://www.w3.org/TR/REC-xml#NT-content.
+                     * So it can contain text, CDATA section or nested
+                     * entity reference nodes (among others).
+                     * -> we recursive  call xmlNodeListGetString()
+                     * which handles these types */
+                    buffer = xmlNodeListGetString(doc, ent->children, 1);
+                    if (buffer != NULL) {
+                        ret = xmlStrcat(ret, buffer);
+                        xmlFree(buffer);
+                    }
+                } else {
+                    ret = xmlStrcat(ret, node->content);
+                }
+            } else {
+                xmlChar buf[2];
+
+                buf[0] = '&';
+                buf[1] = 0;
+                ret = xmlStrncat(ret, buf, 1);
+                ret = xmlStrcat(ret, node->name);
+                buf[0] = ';';
+                buf[1] = 0;
+                ret = xmlStrncat(ret, buf, 1);
+            }
+        }
+#if 0
+        else {
+            xmlGenericError(xmlGenericErrorContext,
+                            "xmlGetNodeListString : invalid node type %d\n",
+                            node->type);
+        }
+#endif
+        node = node->next;
+    }
+    return (ret);
+}
+
+#ifdef LIBXML_TREE_ENABLED
+/**
+ * xmlNodeListGetRawString:
+ * @doc:  the document
+ * @list:  a Node list
+ * @inLine:  should we replace entity contents or show their external form
+ *
+ * Builds the string equivalent to the text contained in the Node list
+ * made of TEXTs and ENTITY_REFs, contrary to xmlNodeListGetString()
+ * this function doesn't do any character encoding handling.
+ *
+ * Returns a pointer to the string copy, the caller must free it with xmlFree().
+ */
+xmlChar *
+xmlNodeListGetRawString(xmlDocPtr doc, xmlNodePtr list, int inLine)
+{
+    xmlNodePtr node = list;
+    xmlChar *ret = NULL;
+    xmlEntityPtr ent;
+
+    if (list == NULL)
+        return (NULL);
+
+    while (node != NULL) {
+        if ((node->type == XML_TEXT_NODE) ||
+            (node->type == XML_CDATA_SECTION_NODE)) {
+            if (inLine) {
+                ret = xmlStrcat(ret, node->content);
+            } else {
+                xmlChar *buffer;
+
+                buffer = xmlEncodeSpecialChars(doc, node->content);
+                if (buffer != NULL) {
+                    ret = xmlStrcat(ret, buffer);
+                    xmlFree(buffer);
+                }
+            }
+        } else if (node->type == XML_ENTITY_REF_NODE) {
+            if (inLine) {
+                ent = xmlGetDocEntity(doc, node->name);
+                if (ent != NULL) {
+                    xmlChar *buffer;
+
+                    /* an entity content can be any "well balanced chunk",
+                     * i.e. the result of the content [43] production:
+                     * http://www.w3.org/TR/REC-xml#NT-content.
+                     * So it can contain text, CDATA section or nested
+                     * entity reference nodes (among others).
+                     * -> we recursive  call xmlNodeListGetRawString()
+                     * which handles these types */
+                    buffer =
+                        xmlNodeListGetRawString(doc, ent->children, 1);
+                    if (buffer != NULL) {
+                        ret = xmlStrcat(ret, buffer);
+                        xmlFree(buffer);
+                    }
+                } else {
+                    ret = xmlStrcat(ret, node->content);
+                }
+            } else {
+                xmlChar buf[2];
+
+                buf[0] = '&';
+                buf[1] = 0;
+                ret = xmlStrncat(ret, buf, 1);
+                ret = xmlStrcat(ret, node->name);
+                buf[0] = ';';
+                buf[1] = 0;
+                ret = xmlStrncat(ret, buf, 1);
+            }
+        }
+#if 0
+        else {
+            xmlGenericError(xmlGenericErrorContext,
+                            "xmlGetNodeListString : invalid node type %d\n",
+                            node->type);
+        }
+#endif
+        node = node->next;
+    }
+    return (ret);
+}
+#endif /* LIBXML_TREE_ENABLED */
+
+#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_HTML_ENABLED)
+/**
+ * xmlNewProp:
+ * @node:  the holding node
+ * @name:  the name of the attribute
+ * @value:  the value of the attribute
+ *
+ * Create a new property carried by a node.
+ * Returns a pointer to the attribute
+ */
+xmlAttrPtr
+xmlNewProp(xmlNodePtr node, const xmlChar *name, const xmlChar *value) {
+    xmlAttrPtr cur;
+    xmlDocPtr doc = NULL;
+
+    if (name == NULL) {
+#ifdef DEBUG_TREE
+        xmlGenericError(xmlGenericErrorContext,
+		"xmlNewProp : name == NULL\n");
+#endif
+	return(NULL);
+    }
+    if ((node != NULL) && (node->type != XML_ELEMENT_NODE))
+	return(NULL);
+
+    /*
+     * Allocate a new property and fill the fields.
+     */
+    cur = (xmlAttrPtr) xmlMalloc(sizeof(xmlAttr));
+    if (cur == NULL) {
+	xmlTreeErrMemory("building attribute");
+	return(NULL);
+    }
+    memset(cur, 0, sizeof(xmlAttr));
+    cur->type = XML_ATTRIBUTE_NODE;
+
+    cur->parent = node; 
+    if (node != NULL) {
+	doc = node->doc;
+	cur->doc = doc;
+    }
+    cur->name = xmlStrdup(name);
+    if (value != NULL) {
+	xmlChar *buffer;
+	xmlNodePtr tmp;
+
+	buffer = xmlEncodeEntitiesReentrant(doc, value);
+	cur->children = xmlStringGetNodeList(doc, buffer);
+	cur->last = NULL;
+	tmp = cur->children;
+	while (tmp != NULL) {
+	    tmp->parent = (xmlNodePtr) cur;
+	    tmp->doc = doc;
+	    if (tmp->next == NULL)
+		cur->last = tmp;
+	    tmp = tmp->next;
+	}
+	xmlFree(buffer);
+    }	
+
+    /*
+     * Add it at the end to preserve parsing order ...
+     */
+    if (node != NULL) {
+	if (node->properties == NULL) {
+	    node->properties = cur;
+	} else {
+	    xmlAttrPtr prev = node->properties;
+
+	    while (prev->next != NULL) prev = prev->next;
+	    prev->next = cur;
+	    cur->prev = prev;
+	}
+    }
+
+    if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue))
+	xmlRegisterNodeDefaultValue((xmlNodePtr)cur);
+    return(cur);
+}
+#endif /* LIBXML_TREE_ENABLED */
+
+/**
+ * xmlNewNsProp:
+ * @node:  the holding node
+ * @ns:  the namespace
+ * @name:  the name of the attribute
+ * @value:  the value of the attribute
+ *
+ * Create a new property tagged with a namespace and carried by a node.
+ * Returns a pointer to the attribute
+ */
+xmlAttrPtr
+xmlNewNsProp(xmlNodePtr node, xmlNsPtr ns, const xmlChar *name,
+           const xmlChar *value) {
+    xmlAttrPtr cur;
+    xmlDocPtr doc = NULL;
+
+    if (name == NULL) {
+#ifdef DEBUG_TREE
+        xmlGenericError(xmlGenericErrorContext,
+		"xmlNewNsProp : name == NULL\n");
+#endif
+	return(NULL);
+    }
+
+    /*
+     * Allocate a new property and fill the fields.
+     */
+    cur = (xmlAttrPtr) xmlMalloc(sizeof(xmlAttr));
+    if (cur == NULL) {
+	xmlTreeErrMemory("building attribute");
+	return(NULL);
+    }
+    memset(cur, 0, sizeof(xmlAttr));
+    cur->type = XML_ATTRIBUTE_NODE;
+
+    cur->parent = node; 
+    if (node != NULL) {
+	doc = node->doc;
+	cur->doc = doc;
+    }
+    cur->ns = ns;
+    cur->name = xmlStrdup(name);
+    if (value != NULL) {
+	xmlChar *buffer;
+	xmlNodePtr tmp;
+
+	buffer = xmlEncodeEntitiesReentrant(doc, value);
+	cur->children = xmlStringGetNodeList(doc, buffer);
+	cur->last = NULL;
+	tmp = cur->children;
+	while (tmp != NULL) {
+	    tmp->parent = (xmlNodePtr) cur;
+	    if (tmp->next == NULL)
+		cur->last = tmp;
+	    tmp = tmp->next;
+	}
+	xmlFree(buffer);
+    }
+
+    /*
+     * Add it at the end to preserve parsing order ...
+     */
+    if (node != NULL) {
+	if (node->properties == NULL) {
+	    node->properties = cur;
+	} else {
+	    xmlAttrPtr prev = node->properties;
+
+	    while (prev->next != NULL) prev = prev->next;
+	    prev->next = cur;
+	    cur->prev = prev;
+	}
+    }
+
+    if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue))
+	xmlRegisterNodeDefaultValue((xmlNodePtr)cur);
+    return(cur);
+}
+
+/**
+ * xmlNewNsPropEatName:
+ * @node:  the holding node
+ * @ns:  the namespace
+ * @name:  the name of the attribute
+ * @value:  the value of the attribute
+ *
+ * Create a new property tagged with a namespace and carried by a node.
+ * Returns a pointer to the attribute
+ */
+xmlAttrPtr
+xmlNewNsPropEatName(xmlNodePtr node, xmlNsPtr ns, xmlChar *name,
+           const xmlChar *value) {
+    xmlAttrPtr cur;
+    xmlDocPtr doc = NULL;
+
+    if (name == NULL) {
+#ifdef DEBUG_TREE
+        xmlGenericError(xmlGenericErrorContext,
+		"xmlNewNsPropEatName : name == NULL\n");
+#endif
+	return(NULL);
+    }
+
+    /*
+     * Allocate a new property and fill the fields.
+     */
+    cur = (xmlAttrPtr) xmlMalloc(sizeof(xmlAttr));
+    if (cur == NULL) {
+	xmlTreeErrMemory("building attribute");
+        xmlFree(name);
+	return(NULL);
+    }
+    memset(cur, 0, sizeof(xmlAttr));
+    cur->type = XML_ATTRIBUTE_NODE;
+
+    cur->parent = node; 
+    if (node != NULL) {
+	doc = node->doc;
+	cur->doc = doc;
+    }
+    cur->ns = ns;
+    cur->name = name;
+    if (value != NULL) {
+	xmlChar *buffer;
+	xmlNodePtr tmp;
+
+	buffer = xmlEncodeEntitiesReentrant(doc, value);
+	cur->children = xmlStringGetNodeList(doc, buffer);
+	cur->last = NULL;
+	tmp = cur->children;
+	while (tmp != NULL) {
+	    tmp->parent = (xmlNodePtr) cur;
+	    if (tmp->next == NULL)
+		cur->last = tmp;
+	    tmp = tmp->next;
+	}
+	xmlFree(buffer);
+    }
+
+    /*
+     * Add it at the end to preserve parsing order ...
+     */
+    if (node != NULL) {
+	if (node->properties == NULL) {
+	    node->properties = cur;
+	} else {
+	    xmlAttrPtr prev = node->properties;
+
+	    while (prev->next != NULL) prev = prev->next;
+	    prev->next = cur;
+	    cur->prev = prev;
+	}
+    }
+
+    if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue))
+	xmlRegisterNodeDefaultValue((xmlNodePtr)cur);
+    return(cur);
+}
+
+/**
+ * xmlNewDocProp:
+ * @doc:  the document
+ * @name:  the name of the attribute
+ * @value:  the value of the attribute
+ *
+ * Create a new property carried by a document.
+ * Returns a pointer to the attribute
+ */
+xmlAttrPtr
+xmlNewDocProp(xmlDocPtr doc, const xmlChar *name, const xmlChar *value) {
+    xmlAttrPtr cur;
+
+    if (name == NULL) {
+#ifdef DEBUG_TREE
+        xmlGenericError(xmlGenericErrorContext,
+		"xmlNewDocProp : name == NULL\n");
+#endif
+	return(NULL);
+    }
+
+    /*
+     * Allocate a new property and fill the fields.
+     */
+    cur = (xmlAttrPtr) xmlMalloc(sizeof(xmlAttr));
+    if (cur == NULL) {
+	xmlTreeErrMemory("building attribute");
+	return(NULL);
+    }
+    memset(cur, 0, sizeof(xmlAttr));
+    cur->type = XML_ATTRIBUTE_NODE;
+
+    cur->name = xmlStrdup(name);
+    cur->doc = doc; 
+    if (value != NULL) {
+	xmlNodePtr tmp;
+
+	cur->children = xmlStringGetNodeList(doc, value);
+	cur->last = NULL;
+
+	tmp = cur->children;
+	while (tmp != NULL) {
+	    tmp->parent = (xmlNodePtr) cur;
+	    if (tmp->next == NULL)
+		cur->last = tmp;
+	    tmp = tmp->next;
+	}
+    }
+
+    if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue))
+	xmlRegisterNodeDefaultValue((xmlNodePtr)cur);
+    return(cur);
+}
+
+/**
+ * xmlFreePropList:
+ * @cur:  the first property in the list
+ *
+ * Free a property and all its siblings, all the children are freed too.
+ */
+void
+xmlFreePropList(xmlAttrPtr cur) {
+    xmlAttrPtr next;
+    if (cur == NULL) return;
+    while (cur != NULL) {
+        next = cur->next;
+        xmlFreeProp(cur);
+	cur = next;
+    }
+}
+
+/**
+ * xmlFreeProp:
+ * @cur:  an attribute
+ *
+ * Free one attribute, all the content is freed too
+ */
+void
+xmlFreeProp(xmlAttrPtr cur) {
+    xmlDictPtr dict = NULL;
+    if (cur == NULL) return;
+
+    if (cur->doc != NULL) dict = cur->doc->dict;
+
+    if ((__xmlRegisterCallbacks) && (xmlDeregisterNodeDefaultValue))
+	xmlDeregisterNodeDefaultValue((xmlNodePtr)cur);
+
+    /* Check for ID removal -> leading to invalid references ! */
+    if ((cur->parent != NULL) && (cur->parent->doc != NULL) &&
+	((cur->parent->doc->intSubset != NULL) ||
+	 (cur->parent->doc->extSubset != NULL))) {
+        if (xmlIsID(cur->parent->doc, cur->parent, cur))
+	    xmlRemoveID(cur->parent->doc, cur);
+    }
+    if (cur->children != NULL) xmlFreeNodeList(cur->children);
+    DICT_FREE(cur->name)
+    xmlFree(cur);
+}
+
+#ifdef LIBXML_TREE_ENABLED
+/**
+ * xmlRemoveProp:
+ * @cur:  an attribute
+ *
+ * Unlink and free one attribute, all the content is freed too
+ * Note this doesn't work for namespace definition attributes
+ *
+ * Returns 0 if success and -1 in case of error.
+ */
+int
+xmlRemoveProp(xmlAttrPtr cur) {
+    xmlAttrPtr tmp;
+    if (cur == NULL) {
+#ifdef DEBUG_TREE
+        xmlGenericError(xmlGenericErrorContext,
+		"xmlRemoveProp : cur == NULL\n");
+#endif
+	return(-1);
+    }
+    if (cur->parent == NULL) {
+#ifdef DEBUG_TREE
+        xmlGenericError(xmlGenericErrorContext,
+		"xmlRemoveProp : cur->parent == NULL\n");
+#endif
+	return(-1);
+    }
+    tmp = cur->parent->properties;
+    if (tmp == cur) {
+        cur->parent->properties = cur->next;
+	xmlFreeProp(cur);
+	return(0);
+    }
+    while (tmp != NULL) {
+	if (tmp->next == cur) {
+	    tmp->next = cur->next;
+	    if (tmp->next != NULL)
+		tmp->next->prev = tmp;
+	    xmlFreeProp(cur);
+	    return(0);
+	}
+        tmp = tmp->next;
+    }
+#ifdef DEBUG_TREE
+    xmlGenericError(xmlGenericErrorContext,
+	    "xmlRemoveProp : attribute not owned by its node\n");
+#endif
+    return(-1);
+}
+#endif /* LIBXML_TREE_ENABLED */
+
+/**
+ * xmlNewPI:
+ * @name:  the processing instruction name
+ * @content:  the PI content
+ *
+ * Creation of a processing instruction element.
+ * Returns a pointer to the new node object.
+ */
+xmlNodePtr
+xmlNewPI(const xmlChar *name, const xmlChar *content) {
+    xmlNodePtr cur;
+
+    if (name == NULL) {
+#ifdef DEBUG_TREE
+        xmlGenericError(xmlGenericErrorContext,
+		"xmlNewPI : name == NULL\n");
+#endif
+	return(NULL);
+    }
+
+    /*
+     * Allocate a new node and fill the fields.
+     */
+    cur = (xmlNodePtr) xmlMalloc(sizeof(xmlNode));
+    if (cur == NULL) {
+	xmlTreeErrMemory("building PI");
+	return(NULL);
+    }
+    memset(cur, 0, sizeof(xmlNode));
+    cur->type = XML_PI_NODE;
+
+    cur->name = xmlStrdup(name);
+    if (content != NULL) {
+	cur->content = xmlStrdup(content);
+    }
+
+    if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue))
+	xmlRegisterNodeDefaultValue((xmlNodePtr)cur);
+    return(cur);
+}
+
+/**
+ * xmlNewNode:
+ * @ns:  namespace if any
+ * @name:  the node name
+ *
+ * Creation of a new node element. @ns is optional (NULL).
+ *
+ * Returns a pointer to the new node object. Uses xmlStrdup() to make
+ * copy of @name.
+ */
+xmlNodePtr
+xmlNewNode(xmlNsPtr ns, const xmlChar *name) {
+    xmlNodePtr cur;
+
+    if (name == NULL) {
+#ifdef DEBUG_TREE
+        xmlGenericError(xmlGenericErrorContext,
+		"xmlNewNode : name == NULL\n");
+#endif
+	return(NULL);
+    }
+
+    /*
+     * Allocate a new node and fill the fields.
+     */
+    cur = (xmlNodePtr) xmlMalloc(sizeof(xmlNode));
+    if (cur == NULL) {
+	xmlTreeErrMemory("building node");
+	return(NULL);
+    }
+    memset(cur, 0, sizeof(xmlNode));
+    cur->type = XML_ELEMENT_NODE;
+    
+    cur->name = xmlStrdup(name);
+    cur->ns = ns;
+
+    if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue))
+	xmlRegisterNodeDefaultValue(cur);
+    return(cur);
+}
+
+/**
+ * xmlNewNodeEatName:
+ * @ns:  namespace if any
+ * @name:  the node name
+ *
+ * Creation of a new node element. @ns is optional (NULL).
+ *
+ * Returns a pointer to the new node object, with pointer @name as
+ * new node's name. Use xmlNewNode() if a copy of @name string is
+ * is needed as new node's name.
+ */
+xmlNodePtr
+xmlNewNodeEatName(xmlNsPtr ns, xmlChar *name) {
+    xmlNodePtr cur;
+
+    if (name == NULL) {
+#ifdef DEBUG_TREE
+        xmlGenericError(xmlGenericErrorContext,
+		"xmlNewNode : name == NULL\n");
+#endif
+	return(NULL);
+    }
+
+    /*
+     * Allocate a new node and fill the fields.
+     */
+    cur = (xmlNodePtr) xmlMalloc(sizeof(xmlNode));
+    if (cur == NULL) {
+	xmlTreeErrMemory("building node");
+        xmlFree(name);
+	return(NULL);
+    }
+    memset(cur, 0, sizeof(xmlNode));
+    cur->type = XML_ELEMENT_NODE;
+    
+    cur->name = name;
+    cur->ns = ns;
+
+    if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue))
+	xmlRegisterNodeDefaultValue((xmlNodePtr)cur);
+    return(cur);
+}
+
+/**
+ * xmlNewDocNode:
+ * @doc:  the document
+ * @ns:  namespace if any
+ * @name:  the node name
+ * @content:  the XML text content if any
+ *
+ * Creation of a new node element within a document. @ns and @content
+ * are optional (NULL).
+ * NOTE: @content is supposed to be a piece of XML CDATA, so it allow entities
+ *       references, but XML special chars need to be escaped first by using
+ *       xmlEncodeEntitiesReentrant(). Use xmlNewDocRawNode() if you don't
+ *       need entities support.
+ *
+ * Returns a pointer to the new node object.
+ */
+xmlNodePtr
+xmlNewDocNode(xmlDocPtr doc, xmlNsPtr ns,
+              const xmlChar *name, const xmlChar *content) {
+    xmlNodePtr cur;
+
+    cur = xmlNewNode(ns, name);
+    if (cur != NULL) {
+        cur->doc = doc;
+	if (content != NULL) {
+	    cur->children = xmlStringGetNodeList(doc, content);
+	    UPDATE_LAST_CHILD_AND_PARENT(cur)
+	}
+    }
+
+    return(cur);
+}
+
+/**
+ * xmlNewDocNodeEatName:
+ * @doc:  the document
+ * @ns:  namespace if any
+ * @name:  the node name
+ * @content:  the XML text content if any
+ *
+ * Creation of a new node element within a document. @ns and @content
+ * are optional (NULL).
+ * NOTE: @content is supposed to be a piece of XML CDATA, so it allow entities
+ *       references, but XML special chars need to be escaped first by using
+ *       xmlEncodeEntitiesReentrant(). Use xmlNewDocRawNode() if you don't
+ *       need entities support.
+ *
+ * Returns a pointer to the new node object.
+ */
+xmlNodePtr
+xmlNewDocNodeEatName(xmlDocPtr doc, xmlNsPtr ns,
+              xmlChar *name, const xmlChar *content) {
+    xmlNodePtr cur;
+
+    cur = xmlNewNodeEatName(ns, name);
+    if (cur != NULL) {
+        cur->doc = doc;
+	if (content != NULL) {
+	    cur->children = xmlStringGetNodeList(doc, content);
+	    UPDATE_LAST_CHILD_AND_PARENT(cur)
+	}
+    }
+    return(cur);
+}
+
+#ifdef LIBXML_TREE_ENABLED
+/**
+ * xmlNewDocRawNode:
+ * @doc:  the document
+ * @ns:  namespace if any
+ * @name:  the node name
+ * @content:  the text content if any
+ *
+ * Creation of a new node element within a document. @ns and @content
+ * are optional (NULL).
+ *
+ * Returns a pointer to the new node object.
+ */
+xmlNodePtr
+xmlNewDocRawNode(xmlDocPtr doc, xmlNsPtr ns,
+                 const xmlChar *name, const xmlChar *content) {
+    xmlNodePtr cur;
+
+    cur = xmlNewNode(ns, name);
+    if (cur != NULL) {
+        cur->doc = doc;
+	if (content != NULL) {
+	    cur->children = xmlNewDocText(doc, content);
+	    UPDATE_LAST_CHILD_AND_PARENT(cur)
+	}
+    }
+    return(cur);
+}
+
+/**
+ * xmlNewDocFragment:
+ * @doc:  the document owning the fragment
+ *
+ * Creation of a new Fragment node.
+ * Returns a pointer to the new node object.
+ */
+xmlNodePtr
+xmlNewDocFragment(xmlDocPtr doc) {
+    xmlNodePtr cur;
+
+    /*
+     * Allocate a new DocumentFragment node and fill the fields.
+     */
+    cur = (xmlNodePtr) xmlMalloc(sizeof(xmlNode));
+    if (cur == NULL) {
+	xmlTreeErrMemory("building fragment");
+	return(NULL);
+    }
+    memset(cur, 0, sizeof(xmlNode));
+    cur->type = XML_DOCUMENT_FRAG_NODE;
+
+    cur->doc = doc;
+
+    if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue))
+	xmlRegisterNodeDefaultValue(cur);
+    return(cur);
+}
+#endif /* LIBXML_TREE_ENABLED */
+
+/**
+ * xmlNewText:
+ * @content:  the text content
+ *
+ * Creation of a new text node.
+ * Returns a pointer to the new node object.
+ */
+xmlNodePtr
+xmlNewText(const xmlChar *content) {
+    xmlNodePtr cur;
+
+    /*
+     * Allocate a new node and fill the fields.
+     */
+    cur = (xmlNodePtr) xmlMalloc(sizeof(xmlNode));
+    if (cur == NULL) {
+	xmlTreeErrMemory("building text");
+	return(NULL);
+    }
+    memset(cur, 0, sizeof(xmlNode));
+    cur->type = XML_TEXT_NODE;
+
+    cur->name = xmlStringText;
+    if (content != NULL) {
+	cur->content = xmlStrdup(content);
+    }
+
+    if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue))
+	xmlRegisterNodeDefaultValue(cur);
+    return(cur);
+}
+
+#ifdef LIBXML_TREE_ENABLED
+/**
+ * xmlNewTextChild:
+ * @parent:  the parent node
+ * @ns:  a namespace if any
+ * @name:  the name of the child
+ * @content:  the text content of the child if any.
+ *
+ * Creation of a new child element, added at the end of @parent children list.
+ * @ns and @content parameters are optional (NULL). If @ns is NULL, the newly
+ * created element inherits the namespace of @parent. If @content is non NULL,
+ * a child TEXT node will be created containing the string @content.
+ * NOTE: Use xmlNewChild() if @content will contain entities that need to be
+ * preserved. Use this function, xmlNewTextChild(), if you need to ensure that
+ * reserved XML chars that might appear in @content, such as the ampersand, 
+ * greater-than or less-than signs, are automatically replaced by their XML 
+ * escaped entity representations. 
+ *
+ * Returns a pointer to the new node object.
+ */
+xmlNodePtr
+xmlNewTextChild(xmlNodePtr parent, xmlNsPtr ns,
+            const xmlChar *name, const xmlChar *content) {
+    xmlNodePtr cur, prev;
+
+    if (parent == NULL) {
+#ifdef DEBUG_TREE
+        xmlGenericError(xmlGenericErrorContext,
+		"xmlNewTextChild : parent == NULL\n");
+#endif
+	return(NULL);
+    }
+
+    if (name == NULL) {
+#ifdef DEBUG_TREE
+        xmlGenericError(xmlGenericErrorContext,
+		"xmlNewTextChild : name == NULL\n");
+#endif
+	return(NULL);
+    }
+
+    /*
+     * Allocate a new node
+     */
+    if (parent->type == XML_ELEMENT_NODE) {
+	if (ns == NULL)
+	    cur = xmlNewDocRawNode(parent->doc, parent->ns, name, content);
+	else
+	    cur = xmlNewDocRawNode(parent->doc, ns, name, content);
+    } else if ((parent->type == XML_DOCUMENT_NODE) ||
+	       (parent->type == XML_HTML_DOCUMENT_NODE)) {
+	if (ns == NULL)
+	    cur = xmlNewDocRawNode((xmlDocPtr) parent, NULL, name, content);
+	else
+	    cur = xmlNewDocRawNode((xmlDocPtr) parent, ns, name, content);
+    } else if (parent->type == XML_DOCUMENT_FRAG_NODE) {
+	    cur = xmlNewDocRawNode( parent->doc, ns, name, content);
+    } else {
+	return(NULL);
+    }
+    if (cur == NULL) return(NULL);
+
+    /*
+     * add the new element at the end of the children list.
+     */
+    cur->type = XML_ELEMENT_NODE;
+    cur->parent = parent;
+    cur->doc = parent->doc;
+    if (parent->children == NULL) {
+        parent->children = cur;
+	parent->last = cur;
+    } else {
+        prev = parent->last;
+	prev->next = cur;
+	cur->prev = prev;
+	parent->last = cur;
+    }
+
+    return(cur);
+}
+#endif /* LIBXML_TREE_ENABLED */
+
+/**
+ * xmlNewCharRef:
+ * @doc: the document
+ * @name:  the char ref string, starting with # or "&# ... ;"
+ *
+ * Creation of a new character reference node.
+ * Returns a pointer to the new node object.
+ */
+xmlNodePtr
+xmlNewCharRef(xmlDocPtr doc, const xmlChar *name) {
+    xmlNodePtr cur;
+
+    /*
+     * Allocate a new node and fill the fields.
+     */
+    cur = (xmlNodePtr) xmlMalloc(sizeof(xmlNode));
+    if (cur == NULL) {
+	xmlTreeErrMemory("building character reference");
+	return(NULL);
+    }
+    memset(cur, 0, sizeof(xmlNode));
+    cur->type = XML_ENTITY_REF_NODE;
+
+    cur->doc = doc;
+    if (name[0] == '&') {
+        int len;
+        name++;
+	len = xmlStrlen(name);
+	if (name[len - 1] == ';')
+	    cur->name = xmlStrndup(name, len - 1);
+	else
+	    cur->name = xmlStrndup(name, len);
+    } else
+	cur->name = xmlStrdup(name);
+
+    if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue))
+	xmlRegisterNodeDefaultValue(cur);
+    return(cur);
+}
+
+/**
+ * xmlNewReference:
+ * @doc: the document
+ * @name:  the reference name, or the reference string with & and ;
+ *
+ * Creation of a new reference node.
+ * Returns a pointer to the new node object.
+ */
+xmlNodePtr
+xmlNewReference(xmlDocPtr doc, const xmlChar *name) {
+    xmlNodePtr cur;
+    xmlEntityPtr ent;
+
+    /*
+     * Allocate a new node and fill the fields.
+     */
+    cur = (xmlNodePtr) xmlMalloc(sizeof(xmlNode));
+    if (cur == NULL) {
+	xmlTreeErrMemory("building reference");
+	return(NULL);
+    }
+    memset(cur, 0, sizeof(xmlNode));
+    cur->type = XML_ENTITY_REF_NODE;
+
+    cur->doc = doc;
+    if (name[0] == '&') {
+        int len;
+        name++;
+	len = xmlStrlen(name);
+	if (name[len - 1] == ';')
+	    cur->name = xmlStrndup(name, len - 1);
+	else
+	    cur->name = xmlStrndup(name, len);
+    } else
+	cur->name = xmlStrdup(name);
+
+    ent = xmlGetDocEntity(doc, cur->name);
+    if (ent != NULL) {
+	cur->content = ent->content;
+	/*
+	 * The parent pointer in entity is a DTD pointer and thus is NOT
+	 * updated.  Not sure if this is 100% correct.
+	 *  -George
+	 */
+	cur->children = (xmlNodePtr) ent;
+	cur->last = (xmlNodePtr) ent;
+    }
+
+    if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue))
+	xmlRegisterNodeDefaultValue(cur);
+    return(cur);
+}
+
+/**
+ * xmlNewDocText:
+ * @doc: the document
+ * @content:  the text content
+ *
+ * Creation of a new text node within a document.
+ * Returns a pointer to the new node object.
+ */
+xmlNodePtr
+xmlNewDocText(xmlDocPtr doc, const xmlChar *content) {
+    xmlNodePtr cur;
+
+    cur = xmlNewText(content);
+    if (cur != NULL) cur->doc = doc;
+    return(cur);
+}
+
+/**
+ * xmlNewTextLen:
+ * @content:  the text content
+ * @len:  the text len.
+ *
+ * Creation of a new text node with an extra parameter for the content's length
+ * Returns a pointer to the new node object.
+ */
+xmlNodePtr
+xmlNewTextLen(const xmlChar *content, int len) {
+    xmlNodePtr cur;
+
+    /*
+     * Allocate a new node and fill the fields.
+     */
+    cur = (xmlNodePtr) xmlMalloc(sizeof(xmlNode));
+    if (cur == NULL) {
+	xmlTreeErrMemory("building text");
+	return(NULL);
+    }
+    memset(cur, 0, sizeof(xmlNode));
+    cur->type = XML_TEXT_NODE;
+
+    cur->name = xmlStringText;
+    if (content != NULL) {
+	cur->content = xmlStrndup(content, len);
+    }
+
+    if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue))
+	xmlRegisterNodeDefaultValue(cur);
+    return(cur);
+}
+
+/**
+ * xmlNewDocTextLen:
+ * @doc: the document
+ * @content:  the text content
+ * @len:  the text len.
+ *
+ * Creation of a new text node with an extra content length parameter. The
+ * text node pertain to a given document.
+ * Returns a pointer to the new node object.
+ */
+xmlNodePtr
+xmlNewDocTextLen(xmlDocPtr doc, const xmlChar *content, int len) {
+    xmlNodePtr cur;
+
+    cur = xmlNewTextLen(content, len);
+    if (cur != NULL) cur->doc = doc;
+    return(cur);
+}
+
+/**
+ * xmlNewComment:
+ * @content:  the comment content
+ *
+ * Creation of a new node containing a comment.
+ * Returns a pointer to the new node object.
+ */
+xmlNodePtr
+xmlNewComment(const xmlChar *content) {
+    xmlNodePtr cur;
+
+    /*
+     * Allocate a new node and fill the fields.
+     */
+    cur = (xmlNodePtr) xmlMalloc(sizeof(xmlNode));
+    if (cur == NULL) {
+	xmlTreeErrMemory("building comment");
+	return(NULL);
+    }
+    memset(cur, 0, sizeof(xmlNode));
+    cur->type = XML_COMMENT_NODE;
+
+    cur->name = xmlStringComment;
+    if (content != NULL) {
+	cur->content = xmlStrdup(content);
+    }
+
+    if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue))
+	xmlRegisterNodeDefaultValue(cur);
+    return(cur);
+}
+
+/**
+ * xmlNewCDataBlock:
+ * @doc:  the document
+ * @content:  the CDATA block content content
+ * @len:  the length of the block
+ *
+ * Creation of a new node containing a CDATA block.
+ * Returns a pointer to the new node object.
+ */
+xmlNodePtr
+xmlNewCDataBlock(xmlDocPtr doc, const xmlChar *content, int len) {
+    xmlNodePtr cur;
+
+    /*
+     * Allocate a new node and fill the fields.
+     */
+    cur = (xmlNodePtr) xmlMalloc(sizeof(xmlNode));
+    if (cur == NULL) {
+	xmlTreeErrMemory("building CDATA");
+	return(NULL);
+    }
+    memset(cur, 0, sizeof(xmlNode));
+    cur->type = XML_CDATA_SECTION_NODE;
+    cur->doc = doc;
+
+    if (content != NULL) {
+	cur->content = xmlStrndup(content, len);
+    }
+
+    if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue))
+	xmlRegisterNodeDefaultValue(cur);
+    return(cur);
+}
+
+/**
+ * xmlNewDocComment:
+ * @doc:  the document
+ * @content:  the comment content
+ *
+ * Creation of a new node containing a comment within a document.
+ * Returns a pointer to the new node object.
+ */
+xmlNodePtr
+xmlNewDocComment(xmlDocPtr doc, const xmlChar *content) {
+    xmlNodePtr cur;
+
+    cur = xmlNewComment(content);
+    if (cur != NULL) cur->doc = doc;
+    return(cur);
+}
+
+/**
+ * xmlSetTreeDoc:
+ * @tree:  the top element
+ * @doc:  the document
+ *
+ * update all nodes under the tree to point to the right document
+ */
+void
+xmlSetTreeDoc(xmlNodePtr tree, xmlDocPtr doc) {
+    xmlAttrPtr prop;
+
+    if (tree == NULL)
+	return;
+    if (tree->doc != doc) {
+	if(tree->type == XML_ELEMENT_NODE) {
+	    prop = tree->properties;
+	    while (prop != NULL) {
+		prop->doc = doc;
+		xmlSetListDoc(prop->children, doc);
+		prop = prop->next;
+	    }
+	}
+	if (tree->children != NULL)
+	    xmlSetListDoc(tree->children, doc);
+	tree->doc = doc;
+    }
+}
+
+/**
+ * xmlSetListDoc:
+ * @list:  the first element
+ * @doc:  the document
+ *
+ * update all nodes in the list to point to the right document
+ */
+void
+xmlSetListDoc(xmlNodePtr list, xmlDocPtr doc) {
+    xmlNodePtr cur;
+
+    if (list == NULL)
+	return;
+    cur = list;
+    while (cur != NULL) {
+	if (cur->doc != doc)
+	    xmlSetTreeDoc(cur, doc);
+	cur = cur->next;
+    }
+}
+
+#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
+/**
+ * xmlNewChild:
+ * @parent:  the parent node
+ * @ns:  a namespace if any
+ * @name:  the name of the child
+ * @content:  the XML content of the child if any.
+ *
+ * Creation of a new child element, added at the end of @parent children list.
+ * @ns and @content parameters are optional (NULL). If @ns is NULL, the newly
+ * created element inherits the namespace of @parent. If @content is non NULL,
+ * a child list containing the TEXTs and ENTITY_REFs node will be created.
+ * NOTE: @content is supposed to be a piece of XML CDATA, so it allows entity
+ *       references. XML special chars must be escaped first by using
+ *       xmlEncodeEntitiesReentrant(), or xmlNewTextChild() should be used.
+ *
+ * Returns a pointer to the new node object.
+ */
+xmlNodePtr
+xmlNewChild(xmlNodePtr parent, xmlNsPtr ns,
+            const xmlChar *name, const xmlChar *content) {
+    xmlNodePtr cur, prev;
+
+    if (parent == NULL) {
+#ifdef DEBUG_TREE
+        xmlGenericError(xmlGenericErrorContext,
+		"xmlNewChild : parent == NULL\n");
+#endif
+	return(NULL);
+    }
+
+    if (name == NULL) {
+#ifdef DEBUG_TREE
+        xmlGenericError(xmlGenericErrorContext,
+		"xmlNewChild : name == NULL\n");
+#endif
+	return(NULL);
+    }
+
+    /*
+     * Allocate a new node
+     */
+    if (parent->type == XML_ELEMENT_NODE) {
+	if (ns == NULL)
+	    cur = xmlNewDocNode(parent->doc, parent->ns, name, content);
+	else
+	    cur = xmlNewDocNode(parent->doc, ns, name, content);
+    } else if ((parent->type == XML_DOCUMENT_NODE) ||
+	       (parent->type == XML_HTML_DOCUMENT_NODE)) {
+	if (ns == NULL)
+	    cur = xmlNewDocNode((xmlDocPtr) parent, NULL, name, content);
+	else
+	    cur = xmlNewDocNode((xmlDocPtr) parent, ns, name, content);
+    } else if (parent->type == XML_DOCUMENT_FRAG_NODE) {
+	    cur = xmlNewDocNode( parent->doc, ns, name, content);
+    } else {
+	return(NULL);
+    }
+    if (cur == NULL) return(NULL);
+
+    /*
+     * add the new element at the end of the children list.
+     */
+    cur->type = XML_ELEMENT_NODE;
+    cur->parent = parent;
+    cur->doc = parent->doc;
+    if (parent->children == NULL) {
+        parent->children = cur;
+	parent->last = cur;
+    } else {
+        prev = parent->last;
+	prev->next = cur;
+	cur->prev = prev;
+	parent->last = cur;
+    }
+
+    return(cur);
+}
+#endif /* LIBXML_TREE_ENABLED */
+
+/**
+ * xmlAddNextSibling:
+ * @cur:  the child node
+ * @elem:  the new node
+ *
+ * Add a new node @elem as the next sibling of @cur
+ * If the new node was already inserted in a document it is
+ * first unlinked from its existing context.
+ * As a result of text merging @elem may be freed.
+ * If the new node is ATTRIBUTE, it is added into properties instead of children.
+ * If there is an attribute with equal name, it is first destroyed. 
+ *
+ * Returns the new node or NULL in case of error.
+ */
+xmlNodePtr
+xmlAddNextSibling(xmlNodePtr cur, xmlNodePtr elem) {
+    if (cur == NULL) {
+#ifdef DEBUG_TREE
+        xmlGenericError(xmlGenericErrorContext,
+		"xmlAddNextSibling : cur == NULL\n");
+#endif
+	return(NULL);
+    }
+    if (elem == NULL) {
+#ifdef DEBUG_TREE
+        xmlGenericError(xmlGenericErrorContext,
+		"xmlAddNextSibling : elem == NULL\n");
+#endif
+	return(NULL);
+    }
+
+    xmlUnlinkNode(elem);
+
+    if (elem->type == XML_TEXT_NODE) {
+	if (cur->type == XML_TEXT_NODE) {
+	    xmlNodeAddContent(cur, elem->content);
+	    xmlFreeNode(elem);
+	    return(cur);
+	}
+	if ((cur->next != NULL) && (cur->next->type == XML_TEXT_NODE) &&
+            (cur->name == cur->next->name)) {
+	    xmlChar *tmp;
+
+	    tmp = xmlStrdup(elem->content);
+	    tmp = xmlStrcat(tmp, cur->next->content);
+	    xmlNodeSetContent(cur->next, tmp);
+	    xmlFree(tmp);
+	    xmlFreeNode(elem);
+	    return(cur->next);
+	}
+    } else if (elem->type == XML_ATTRIBUTE_NODE) {
+        /* check if an attribute with the same name exists */
+	xmlAttrPtr attr;
+
+	if (elem->ns == NULL)
+	    attr = xmlHasProp(cur->parent, elem->name);
+	else
+	    attr = xmlHasNsProp(cur->parent, elem->name, elem->ns->href);
+	if ((attr != NULL) && (attr != (xmlAttrPtr) elem)) {
+	    /* different instance, destroy it (attributes must be unique) */
+	    xmlFreeProp(attr);
+	}
+    }
+
+    if (elem->doc != cur->doc) {
+	xmlSetTreeDoc(elem, cur->doc);
+    }
+    elem->parent = cur->parent;
+    elem->prev = cur;
+    elem->next = cur->next;
+    cur->next = elem;
+    if (elem->next != NULL)
+	elem->next->prev = elem;
+    if ((elem->parent != NULL) && (elem->parent->last == cur) && (elem->type != XML_ATTRIBUTE_NODE))
+	elem->parent->last = elem;
+    return(elem);
+}
+
+#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_HTML_ENABLED)
+/**
+ * xmlAddPrevSibling:
+ * @cur:  the child node
+ * @elem:  the new node
+ *
+ * Add a new node @elem as the previous sibling of @cur
+ * merging adjacent TEXT nodes (@elem may be freed)
+ * If the new node was already inserted in a document it is
+ * first unlinked from its existing context.
+ * If the new node is ATTRIBUTE, it is added into properties instead of children.
+ * If there is an attribute with equal name, it is first destroyed. 
+ *
+ * Returns the new node or NULL in case of error.
+ */
+xmlNodePtr
+xmlAddPrevSibling(xmlNodePtr cur, xmlNodePtr elem) {
+    if (cur == NULL) {
+#ifdef DEBUG_TREE
+        xmlGenericError(xmlGenericErrorContext,
+		"xmlAddPrevSibling : cur == NULL\n");
+#endif
+	return(NULL);
+    }
+    if (elem == NULL) {
+#ifdef DEBUG_TREE
+        xmlGenericError(xmlGenericErrorContext,
+		"xmlAddPrevSibling : elem == NULL\n");
+#endif
+	return(NULL);
+    }
+
+    xmlUnlinkNode(elem);
+
+    if (elem->type == XML_TEXT_NODE) {
+	if (cur->type == XML_TEXT_NODE) {
+	    xmlChar *tmp;
+
+	    tmp = xmlStrdup(elem->content);
+	    tmp = xmlStrcat(tmp, cur->content);
+	    xmlNodeSetContent(cur, tmp);
+	    xmlFree(tmp);
+	    xmlFreeNode(elem);
+	    return(cur);
+	}
+	if ((cur->prev != NULL) && (cur->prev->type == XML_TEXT_NODE) &&
+            (cur->name == cur->prev->name)) {
+	    xmlNodeAddContent(cur->prev, elem->content);
+	    xmlFreeNode(elem);
+	    return(cur->prev);
+	}
+    } else if (elem->type == XML_ATTRIBUTE_NODE) {
+        /* check if an attribute with the same name exists */
+	xmlAttrPtr attr;
+
+	if (elem->ns == NULL)
+	    attr = xmlHasProp(cur->parent, elem->name);
+	else
+	    attr = xmlHasNsProp(cur->parent, elem->name, elem->ns->href);
+	if ((attr != NULL) && (attr != (xmlAttrPtr) elem)) {
+	    /* different instance, destroy it (attributes must be unique) */
+	    xmlFreeProp(attr);
+	}
+    }
+
+    if (elem->doc != cur->doc) {
+	xmlSetTreeDoc(elem, cur->doc);
+    }
+    elem->parent = cur->parent;
+    elem->next = cur;
+    elem->prev = cur->prev;
+    cur->prev = elem;
+    if (elem->prev != NULL)
+	elem->prev->next = elem;
+    if (elem->parent != NULL) {
+	if (elem->type == XML_ATTRIBUTE_NODE) {
+	    if (elem->parent->properties == (xmlAttrPtr) cur) {
+		elem->parent->properties = (xmlAttrPtr) elem;
+	    }
+	} else {
+	    if (elem->parent->children == cur) {
+		elem->parent->children = elem;
+	    }
+	}
+    }
+    return(elem);
+}
+#endif /* LIBXML_TREE_ENABLED */
+
+/**
+ * xmlAddSibling:
+ * @cur:  the child node
+ * @elem:  the new node
+ *
+ * Add a new element @elem to the list of siblings of @cur
+ * merging adjacent TEXT nodes (@elem may be freed)
+ * If the new element was already inserted in a document it is
+ * first unlinked from its existing context.
+ *
+ * Returns the new element or NULL in case of error.
+ */
+xmlNodePtr
+xmlAddSibling(xmlNodePtr cur, xmlNodePtr elem) {
+    xmlNodePtr parent;
+
+    if (cur == NULL) {
+#ifdef DEBUG_TREE
+        xmlGenericError(xmlGenericErrorContext,
+		"xmlAddSibling : cur == NULL\n");
+#endif
+	return(NULL);
+    }
+
+    if (elem == NULL) {
+#ifdef DEBUG_TREE
+        xmlGenericError(xmlGenericErrorContext,
+		"xmlAddSibling : elem == NULL\n");
+#endif
+	return(NULL);
+    }
+
+    /*
+     * Constant time is we can rely on the ->parent->last to find
+     * the last sibling.
+     */
+    if ((cur->parent != NULL) && 
+	(cur->parent->children != NULL) &&
+	(cur->parent->last != NULL) &&
+	(cur->parent->last->next == NULL)) {
+	cur = cur->parent->last;
+    } else {
+	while (cur->next != NULL) cur = cur->next;
+    }
+
+    xmlUnlinkNode(elem);
+
+    if ((cur->type == XML_TEXT_NODE) && (elem->type == XML_TEXT_NODE) &&
+        (cur->name == elem->name)) {
+	xmlNodeAddContent(cur, elem->content);
+	xmlFreeNode(elem);
+	return(cur);
+    }
+
+    if (elem->doc != cur->doc) {
+	xmlSetTreeDoc(elem, cur->doc);
+    }
+    parent = cur->parent;
+    elem->prev = cur;
+    elem->next = NULL;
+    elem->parent = parent;
+    cur->next = elem;
+    if (parent != NULL)
+	parent->last = elem;
+
+    return(elem);
+}
+
+/**
+ * xmlAddChildList:
+ * @parent:  the parent node
+ * @cur:  the first node in the list
+ *
+ * Add a list of node at the end of the child list of the parent
+ * merging adjacent TEXT nodes (@cur may be freed)
+ *
+ * Returns the last child or NULL in case of error.
+ */
+xmlNodePtr
+xmlAddChildList(xmlNodePtr parent, xmlNodePtr cur) {
+    xmlNodePtr prev;
+
+    if (parent == NULL) {
+#ifdef DEBUG_TREE
+        xmlGenericError(xmlGenericErrorContext,
+		"xmlAddChildList : parent == NULL\n");
+#endif
+	return(NULL);
+    }
+
+    if (cur == NULL) {
+#ifdef DEBUG_TREE
+        xmlGenericError(xmlGenericErrorContext,
+		"xmlAddChildList : child == NULL\n");
+#endif
+	return(NULL);
+    }
+
+    if ((cur->doc != NULL) && (parent->doc != NULL) &&
+        (cur->doc != parent->doc)) {
+#ifdef DEBUG_TREE
+	xmlGenericError(xmlGenericErrorContext,
+		"Elements moved to a different document\n");
+#endif
+    }
+
+    /*
+     * add the first element at the end of the children list.
+     */
+
+    if (parent->children == NULL) {
+        parent->children = cur;
+    } else {
+	/*
+	 * If cur and parent->last both are TEXT nodes, then merge them.
+	 */
+	if ((cur->type == XML_TEXT_NODE) && 
+	    (parent->last->type == XML_TEXT_NODE) &&
+	    (cur->name == parent->last->name)) {
+    	    xmlNodeAddContent(parent->last, cur->content);
+	    /*
+	     * if it's the only child, nothing more to be done.
+	     */
+	    if (cur->next == NULL) {
+		xmlFreeNode(cur);
+		return(parent->last);
+	    }
+	    prev = cur;
+	    cur = cur->next;
+	    xmlFreeNode(prev);
+	}
+        prev = parent->last;
+	prev->next = cur;
+	cur->prev = prev;
+    }
+    while (cur->next != NULL) {
+	cur->parent = parent;
+	if (cur->doc != parent->doc) {
+	    xmlSetTreeDoc(cur, parent->doc);
+	}
+        cur = cur->next;
+    }
+    cur->parent = parent;
+    cur->doc = parent->doc; /* the parent may not be linked to a doc ! */
+    parent->last = cur;
+
+    return(cur);
+}
+
+/**
+ * xmlAddChild:
+ * @parent:  the parent node
+ * @cur:  the child node
+ *
+ * Add a new node to @parent, at the end of the child (or property) list
+ * merging adjacent TEXT nodes (in which case @cur is freed)
+ * If the new node is ATTRIBUTE, it is added into properties instead of children.
+ * If there is an attribute with equal name, it is first destroyed. 
+ *
+ * Returns the child or NULL in case of error.
+ */
+xmlNodePtr
+xmlAddChild(xmlNodePtr parent, xmlNodePtr cur) {
+    xmlNodePtr prev;
+
+    if (parent == NULL) {
+#ifdef DEBUG_TREE
+        xmlGenericError(xmlGenericErrorContext,
+		"xmlAddChild : parent == NULL\n");
+#endif
+	return(NULL);
+    }
+
+    if (cur == NULL) {
+#ifdef DEBUG_TREE
+        xmlGenericError(xmlGenericErrorContext,
+		"xmlAddChild : child == NULL\n");
+#endif
+	return(NULL);
+    }
+
+    /*
+     * If cur is a TEXT node, merge its content with adjacent TEXT nodes
+     * cur is then freed.
+     */
+    if (cur->type == XML_TEXT_NODE) {
+	if ((parent->type == XML_TEXT_NODE) &&
+	    (parent->content != NULL) &&
+	    (parent->name == cur->name) &&
+	    (parent != cur)) {
+	    xmlNodeAddContent(parent, cur->content);
+	    xmlFreeNode(cur);
+	    return(parent);
+	}
+	if ((parent->last != NULL) && (parent->last->type == XML_TEXT_NODE) &&
+	    (parent->last->name == cur->name) &&
+	    (parent->last != cur)) {
+	    xmlNodeAddContent(parent->last, cur->content);
+	    xmlFreeNode(cur);
+	    return(parent->last);
+	}
+    }
+
+    /*
+     * add the new element at the end of the children list.
+     */
+    prev = cur->parent;
+    cur->parent = parent;
+    if (cur->doc != parent->doc) {
+	xmlSetTreeDoc(cur, parent->doc);
+    }
+    /* this check prevents a loop on tree-traversions if a developer
+     * tries to add a node to its parent multiple times
+     */
+    if (prev == parent)
+	return(cur);
+
+    /*
+     * Coalescing
+     */
+    if ((parent->type == XML_TEXT_NODE) &&
+	(parent->content != NULL) &&
+	(parent != cur)) {
+	xmlNodeAddContent(parent, cur->content);
+	xmlFreeNode(cur);
+	return(parent);
+    }
+    if (cur->type == XML_ATTRIBUTE_NODE) {
+	if (parent->properties == NULL) {
+	    parent->properties = (xmlAttrPtr) cur;
+	} else {
+	    /* check if an attribute with the same name exists */
+	    xmlAttrPtr lastattr;
+
+	    if (cur->ns == NULL)
+		lastattr = xmlHasProp(parent, cur->name);
+	    else
+		lastattr = xmlHasNsProp(parent, cur->name, cur->ns->href);
+	    if ((lastattr != NULL) && (lastattr != (xmlAttrPtr) cur)) {
+		/* different instance, destroy it (attributes must be unique) */
+		xmlFreeProp(lastattr);
+	    }
+	    /* find the end */
+	    lastattr = parent->properties;
+	    while (lastattr->next != NULL) {
+		lastattr = lastattr->next;
+	    }
+	    lastattr->next = (xmlAttrPtr) cur;
+	    ((xmlAttrPtr) cur)->prev = lastattr;
+	}
+    } else {
+	if (parent->children == NULL) {
+	    parent->children = cur;
+	    parent->last = cur;
+	} else {
+	    prev = parent->last;
+	    prev->next = cur;
+	    cur->prev = prev;
+	    parent->last = cur;
+	}
+    }
+    return(cur);
+}
+
+/**
+ * xmlGetLastChild:
+ * @parent:  the parent node
+ *
+ * Search the last child of a node.
+ * Returns the last child or NULL if none.
+ */
+xmlNodePtr
+xmlGetLastChild(xmlNodePtr parent) {
+    if (parent == NULL) {
+#ifdef DEBUG_TREE
+        xmlGenericError(xmlGenericErrorContext,
+		"xmlGetLastChild : parent == NULL\n");
+#endif
+	return(NULL);
+    }
+    return(parent->last);
+}
+
+/**
+ * xmlFreeNodeList:
+ * @cur:  the first node in the list
+ *
+ * Free a node and all its siblings, this is a recursive behaviour, all
+ * the children are freed too.
+ */
+void
+xmlFreeNodeList(xmlNodePtr cur) {
+    xmlNodePtr next;
+    xmlDictPtr dict = NULL;
+
+    if (cur == NULL) return;
+    if (cur->type == XML_NAMESPACE_DECL) {
+	xmlFreeNsList((xmlNsPtr) cur);
+	return;
+    }
+    if ((cur->type == XML_DOCUMENT_NODE) ||
+#ifdef LIBXML_DOCB_ENABLED
+	(cur->type == XML_DOCB_DOCUMENT_NODE) ||
+#endif
+	(cur->type == XML_HTML_DOCUMENT_NODE)) {
+	xmlFreeDoc((xmlDocPtr) cur);
+	return;
+    }
+    if (cur->doc != NULL) dict = cur->doc->dict;
+    while (cur != NULL) {
+        next = cur->next;
+	if (cur->type != XML_DTD_NODE) {
+
+	    if ((__xmlRegisterCallbacks) && (xmlDeregisterNodeDefaultValue))
+		xmlDeregisterNodeDefaultValue(cur);
+
+	    if ((cur->children != NULL) &&
+		(cur->type != XML_ENTITY_REF_NODE))
+		xmlFreeNodeList(cur->children);
+	    if (((cur->type == XML_ELEMENT_NODE) ||
+		 (cur->type == XML_XINCLUDE_START) ||
+		 (cur->type == XML_XINCLUDE_END)) &&
+		(cur->properties != NULL))
+		xmlFreePropList(cur->properties);
+	    if ((cur->type != XML_ELEMENT_NODE) &&
+		(cur->type != XML_XINCLUDE_START) &&
+		(cur->type != XML_XINCLUDE_END) &&
+		(cur->type != XML_ENTITY_REF_NODE)) {
+		DICT_FREE(cur->content)
+	    }
+	    if (((cur->type == XML_ELEMENT_NODE) ||
+	         (cur->type == XML_XINCLUDE_START) ||
+		 (cur->type == XML_XINCLUDE_END)) &&
+		(cur->nsDef != NULL))
+		xmlFreeNsList(cur->nsDef);
+
+	    /*
+	     * When a node is a text node or a comment, it uses a global static
+	     * variable for the name of the node.
+	     * Otherwise the node name might come from the document's
+	     * dictionnary
+	     */
+	    if ((cur->name != NULL) &&
+		(cur->type != XML_TEXT_NODE) &&
+		(cur->type != XML_COMMENT_NODE))
+		DICT_FREE(cur->name)
+	    xmlFree(cur);
+	}
+	cur = next;
+    }
+}
+
+/**
+ * xmlFreeNode:
+ * @cur:  the node
+ *
+ * Free a node, this is a recursive behaviour, all the children are freed too.
+ * This doesn't unlink the child from the list, use xmlUnlinkNode() first.
+ */
+void
+xmlFreeNode(xmlNodePtr cur) {
+    xmlDictPtr dict = NULL;
+
+    if (cur == NULL) return;
+
+    /* use xmlFreeDtd for DTD nodes */
+    if (cur->type == XML_DTD_NODE) {
+	xmlFreeDtd((xmlDtdPtr) cur);
+	return;
+    }
+    if (cur->type == XML_NAMESPACE_DECL) {
+	xmlFreeNs((xmlNsPtr) cur);
+        return;
+    }
+    if (cur->type == XML_ATTRIBUTE_NODE) {
+	xmlFreeProp((xmlAttrPtr) cur);
+	return;
+    }
+
+    if ((__xmlRegisterCallbacks) && (xmlDeregisterNodeDefaultValue))
+	xmlDeregisterNodeDefaultValue(cur);
+
+    if (cur->doc != NULL) dict = cur->doc->dict;
+
+    if ((cur->children != NULL) &&
+	(cur->type != XML_ENTITY_REF_NODE))
+	xmlFreeNodeList(cur->children);
+    if (((cur->type == XML_ELEMENT_NODE) ||
+	 (cur->type == XML_XINCLUDE_START) ||
+	 (cur->type == XML_XINCLUDE_END)) &&
+	(cur->properties != NULL))
+	xmlFreePropList(cur->properties);
+    if ((cur->type != XML_ELEMENT_NODE) &&
+	(cur->content != NULL) &&
+	(cur->type != XML_ENTITY_REF_NODE) &&
+	(cur->type != XML_XINCLUDE_END) &&
+	(cur->type != XML_XINCLUDE_START)) {
+	DICT_FREE(cur->content)
+    }
+
+    /*
+     * When a node is a text node or a comment, it uses a global static
+     * variable for the name of the node.
+     * Otherwise the node name might come from the document's dictionnary
+     */
+    if ((cur->name != NULL) &&
+        (cur->type != XML_TEXT_NODE) &&
+        (cur->type != XML_COMMENT_NODE))
+	DICT_FREE(cur->name)
+
+    if (((cur->type == XML_ELEMENT_NODE) ||
+	 (cur->type == XML_XINCLUDE_START) ||
+	 (cur->type == XML_XINCLUDE_END)) &&
+	(cur->nsDef != NULL))
+	xmlFreeNsList(cur->nsDef);
+    xmlFree(cur);
+}
+
+/**
+ * xmlUnlinkNode:
+ * @cur:  the node
+ *
+ * Unlink a node from it's current context, the node is not freed
+ */
+void
+xmlUnlinkNode(xmlNodePtr cur) {
+    if (cur == NULL) {
+#ifdef DEBUG_TREE
+        xmlGenericError(xmlGenericErrorContext,
+		"xmlUnlinkNode : node == NULL\n");
+#endif
+	return;
+    }
+    if (cur->type == XML_DTD_NODE) {
+	xmlDocPtr doc;
+	doc = cur->doc;
+	if (doc != NULL) {
+	    if (doc->intSubset == (xmlDtdPtr) cur)
+		doc->intSubset = NULL;
+	    if (doc->extSubset == (xmlDtdPtr) cur)
+		doc->extSubset = NULL;
+	}
+    }
+    if (cur->parent != NULL) {
+	xmlNodePtr parent;
+	parent = cur->parent;
+	if (cur->type == XML_ATTRIBUTE_NODE) {
+	    if (parent->properties == (xmlAttrPtr) cur)
+		parent->properties = ((xmlAttrPtr) cur)->next;
+	} else {
+	    if (parent->children == cur)
+		parent->children = cur->next;
+	    if (parent->last == cur)
+		parent->last = cur->prev;
+	}
+	cur->parent = NULL;
+    }
+    if (cur->next != NULL)
+        cur->next->prev = cur->prev;
+    if (cur->prev != NULL)
+        cur->prev->next = cur->next;
+    cur->next = cur->prev = NULL;
+}
+
+#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED)
+/**
+ * xmlReplaceNode:
+ * @old:  the old node
+ * @cur:  the node
+ *
+ * Unlink the old node from its current context, prune the new one
+ * at the same place. If @cur was already inserted in a document it is
+ * first unlinked from its existing context.
+ *
+ * Returns the @old node
+ */
+xmlNodePtr
+xmlReplaceNode(xmlNodePtr old, xmlNodePtr cur) {
+    if (old == NULL) {
+#ifdef DEBUG_TREE
+        xmlGenericError(xmlGenericErrorContext,
+		"xmlReplaceNode : old == NULL\n");
+#endif
+	return(NULL);
+    }
+    if (cur == NULL) {
+	xmlUnlinkNode(old);
+	return(old);
+    }
+    if (cur == old) {
+	return(old);
+    }
+    if ((old->type==XML_ATTRIBUTE_NODE) && (cur->type!=XML_ATTRIBUTE_NODE)) {
+#ifdef DEBUG_TREE
+        xmlGenericError(xmlGenericErrorContext,
+		"xmlReplaceNode : Trying to replace attribute node with other node type\n");
+#endif
+	return(old);
+    }
+    if ((cur->type==XML_ATTRIBUTE_NODE) && (old->type!=XML_ATTRIBUTE_NODE)) {
+#ifdef DEBUG_TREE
+        xmlGenericError(xmlGenericErrorContext,
+		"xmlReplaceNode : Trying to replace a non-attribute node with attribute node\n");
+#endif
+	return(old);
+    }
+    xmlUnlinkNode(cur);
+    cur->doc = old->doc;
+    cur->parent = old->parent;
+    cur->next = old->next;
+    if (cur->next != NULL)
+	cur->next->prev = cur;
+    cur->prev = old->prev;
+    if (cur->prev != NULL)
+	cur->prev->next = cur;
+    if (cur->parent != NULL) {
+	if (cur->type == XML_ATTRIBUTE_NODE) {
+	    if (cur->parent->properties == (xmlAttrPtr)old)
+		cur->parent->properties = ((xmlAttrPtr) cur);
+	} else {
+	    if (cur->parent->children == old)
+		cur->parent->children = cur;
+	    if (cur->parent->last == old)
+		cur->parent->last = cur;
+	}
+    }
+    old->next = old->prev = NULL;
+    old->parent = NULL;
+    return(old);
+}
+#endif /* LIBXML_TREE_ENABLED */
+
+/************************************************************************
+ *									*
+ *		Copy operations						*
+ *									*
+ ************************************************************************/
+ 
+/**
+ * xmlCopyNamespace:
+ * @cur:  the namespace
+ *
+ * Do a copy of the namespace.
+ *
+ * Returns: a new #xmlNsPtr, or NULL in case of error.
+ */
+xmlNsPtr
+xmlCopyNamespace(xmlNsPtr cur) {
+    xmlNsPtr ret;
+
+    if (cur == NULL) return(NULL);
+    switch (cur->type) {
+	case XML_LOCAL_NAMESPACE:
+	    ret = xmlNewNs(NULL, cur->href, cur->prefix);
+	    break;
+	default:
+#ifdef DEBUG_TREE
+	    xmlGenericError(xmlGenericErrorContext,
+		    "xmlCopyNamespace: invalid type %d\n", cur->type);
+#endif
+	    return(NULL);
+    }
+    return(ret);
+}
+
+/**
+ * xmlCopyNamespaceList:
+ * @cur:  the first namespace
+ *
+ * Do a copy of an namespace list.
+ *
+ * Returns: a new #xmlNsPtr, or NULL in case of error.
+ */
+xmlNsPtr
+xmlCopyNamespaceList(xmlNsPtr cur) {
+    xmlNsPtr ret = NULL;
+    xmlNsPtr p = NULL,q;
+
+    while (cur != NULL) {
+        q = xmlCopyNamespace(cur);
+	if (p == NULL) {
+	    ret = p = q;
+	} else {
+	    p->next = q;
+	    p = q;
+	}
+	cur = cur->next;
+    }
+    return(ret);
+}
+
+static xmlNodePtr
+xmlStaticCopyNodeList(xmlNodePtr node, xmlDocPtr doc, xmlNodePtr parent);
+/**
+ * xmlCopyProp:
+ * @target:  the element where the attribute will be grafted
+ * @cur:  the attribute
+ *
+ * Do a copy of the attribute.
+ *
+ * Returns: a new #xmlAttrPtr, or NULL in case of error.
+ */
+xmlAttrPtr
+xmlCopyProp(xmlNodePtr target, xmlAttrPtr cur) {
+    xmlAttrPtr ret;
+
+    if (cur == NULL) return(NULL);
+    if (target != NULL)
+	ret = xmlNewDocProp(target->doc, cur->name, NULL);
+    else if (cur->parent != NULL)
+	ret = xmlNewDocProp(cur->parent->doc, cur->name, NULL);
+    else if (cur->children != NULL)
+	ret = xmlNewDocProp(cur->children->doc, cur->name, NULL);
+    else
+	ret = xmlNewDocProp(NULL, cur->name, NULL);
+    if (ret == NULL) return(NULL);
+    ret->parent = target;
+
+    if ((cur->ns != NULL) && (target != NULL)) {
+      xmlNsPtr ns;
+
+      ns = xmlSearchNs(target->doc, target, cur->ns->prefix);
+      if (ns == NULL) {
+        /*
+         * Humm, we are copying an element whose namespace is defined
+         * out of the new tree scope. Search it in the original tree
+         * and add it at the top of the new tree
+         */
+        ns = xmlSearchNs(cur->doc, cur->parent, cur->ns->prefix);
+        if (ns != NULL) {
+          xmlNodePtr root = target;
+          xmlNodePtr pred = NULL;
+
+          while (root->parent != NULL) {
+            pred = root;
+            root = root->parent;
+          }
+          if (root == (xmlNodePtr) target->doc) {
+            /* correct possibly cycling above the document elt */
+            root = pred;
+          }
+          ret->ns = xmlNewNs(root, ns->href, ns->prefix);
+        }
+      } else {
+        /*
+         * we have to find something appropriate here since
+         * we cant be sure, that the namespce we found is identified
+         * by the prefix
+         */
+        if (xmlStrEqual(ns->href, cur->ns->href)) {
+          /* this is the nice case */
+          ret->ns = ns;
+        } else {
+          /*
+           * we are in trouble: we need a new reconcilied namespace.
+           * This is expensive
+           */
+          ret->ns = xmlNewReconciliedNs(target->doc, target, cur->ns);
+        }
+      }
+ 
+    } else
+        ret->ns = NULL;
+
+    if (cur->children != NULL) {
+	xmlNodePtr tmp;
+
+	ret->children = xmlStaticCopyNodeList(cur->children, ret->doc, (xmlNodePtr) ret);
+	ret->last = NULL;
+	tmp = ret->children;
+	while (tmp != NULL) {
+	    /* tmp->parent = (xmlNodePtr)ret; */
+	    if (tmp->next == NULL)
+	        ret->last = tmp;
+	    tmp = tmp->next;
+	}
+    }
+    /*
+     * Try to handle IDs
+     */
+    if ((target!= NULL) && (cur!= NULL) &&
+	(target->doc != NULL) && (cur->doc != NULL) &&
+	(cur->doc->ids != NULL) && (cur->parent != NULL)) {
+	if (xmlIsID(cur->doc, cur->parent, cur)) {
+	    xmlChar *id;
+
+	    id = xmlNodeListGetString(cur->doc, cur->children, 1);
+	    if (id != NULL) {
+		xmlAddID(NULL, target->doc, id, ret);
+		xmlFree(id);
+	    }
+	}
+    }
+    return(ret);
+}
+
+/**
+ * xmlCopyPropList:
+ * @target:  the element where the attributes will be grafted
+ * @cur:  the first attribute
+ *
+ * Do a copy of an attribute list.
+ *
+ * Returns: a new #xmlAttrPtr, or NULL in case of error.
+ */
+xmlAttrPtr
+xmlCopyPropList(xmlNodePtr target, xmlAttrPtr cur) {
+    xmlAttrPtr ret = NULL;
+    xmlAttrPtr p = NULL,q;
+
+    while (cur != NULL) {
+        q = xmlCopyProp(target, cur);
+	if (p == NULL) {
+	    ret = p = q;
+	} else {
+	    p->next = q;
+	    q->prev = p;
+	    p = q;
+	}
+	cur = cur->next;
+    }
+    return(ret);
+}
+
+/*
+ * NOTE about the CopyNode operations !
+ *
+ * They are split into external and internal parts for one
+ * tricky reason: namespaces. Doing a direct copy of a node
+ * say RPM:Copyright without changing the namespace pointer to
+ * something else can produce stale links. One way to do it is
+ * to keep a reference counter but this doesn't work as soon
+ * as one move the element or the subtree out of the scope of
+ * the existing namespace. The actual solution seems to add
+ * a copy of the namespace at the top of the copied tree if
+ * not available in the subtree.
+ * Hence two functions, the public front-end call the inner ones
+ * The argument "recursive" normally indicates a recursive copy
+ * of the node with values 0 (no) and 1 (yes).  For XInclude,
+ * however, we allow a value of 2 to indicate copy properties and
+ * namespace info, but don't recurse on children.
+ */
+
+static xmlNodePtr
+xmlStaticCopyNode(const xmlNodePtr node, xmlDocPtr doc, xmlNodePtr parent,
+                  int extended) {
+    xmlNodePtr ret;
+
+    if (node == NULL) return(NULL);
+    switch (node->type) {
+        case XML_TEXT_NODE:
+        case XML_CDATA_SECTION_NODE:
+        case XML_ELEMENT_NODE:
+        case XML_DOCUMENT_FRAG_NODE:
+        case XML_ENTITY_REF_NODE:
+        case XML_ENTITY_NODE:
+        case XML_PI_NODE:
+        case XML_COMMENT_NODE:
+        case XML_XINCLUDE_START:
+        case XML_XINCLUDE_END:
+	    break;
+        case XML_ATTRIBUTE_NODE:
+	    return((xmlNodePtr) xmlCopyProp(parent, (xmlAttrPtr) node));
+        case XML_NAMESPACE_DECL:
+	    return((xmlNodePtr) xmlCopyNamespaceList((xmlNsPtr) node));
+	    
+        case XML_DOCUMENT_NODE:
+        case XML_HTML_DOCUMENT_NODE:
+#ifdef LIBXML_DOCB_ENABLED
+        case XML_DOCB_DOCUMENT_NODE:
+#endif
+#ifdef LIBXML_TREE_ENABLED
+	    return((xmlNodePtr) xmlCopyDoc((xmlDocPtr) node, extended));
+#endif /* LIBXML_TREE_ENABLED */
+        case XML_DOCUMENT_TYPE_NODE:
+        case XML_NOTATION_NODE:
+        case XML_DTD_NODE:
+        case XML_ELEMENT_DECL:
+        case XML_ATTRIBUTE_DECL:
+        case XML_ENTITY_DECL:
+            return(NULL);
+    }
+
+    /*
+     * Allocate a new node and fill the fields.
+     */
+    ret = (xmlNodePtr) xmlMalloc(sizeof(xmlNode));
+    if (ret == NULL) {
+	xmlTreeErrMemory("copying node");
+	return(NULL);
+    }
+    memset(ret, 0, sizeof(xmlNode));
+    ret->type = node->type;
+
+    ret->doc = doc;
+    ret->parent = parent; 
+    if (node->name == xmlStringText)
+	ret->name = xmlStringText;
+    else if (node->name == xmlStringTextNoenc)
+	ret->name = xmlStringTextNoenc;
+    else if (node->name == xmlStringComment)
+	ret->name = xmlStringComment;
+    else if (node->name != NULL)
+	ret->name = xmlStrdup(node->name);
+    if ((node->type != XML_ELEMENT_NODE) &&
+	(node->content != NULL) &&
+	(node->type != XML_ENTITY_REF_NODE) &&
+	(node->type != XML_XINCLUDE_END) &&
+	(node->type != XML_XINCLUDE_START)) {
+	ret->content = xmlStrdup(node->content);
+    }else{
+      if (node->type == XML_ELEMENT_NODE)
+        ret->line = node->line;
+    }
+    if (parent != NULL) {
+	xmlNodePtr tmp;
+
+	/*
+	 * this is a tricky part for the node register thing:
+	 * in case ret does get coalesced in xmlAddChild
+	 * the deregister-node callback is called; so we register ret now already
+	 */
+	if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue))
+	    xmlRegisterNodeDefaultValue((xmlNodePtr)ret);
+
+        tmp = xmlAddChild(parent, ret);
+	/* node could have coalesced */
+	if (tmp != ret)
+	    return(tmp);
+    }
+    
+    if (!extended)
+	goto out;
+    if (node->nsDef != NULL)
+        ret->nsDef = xmlCopyNamespaceList(node->nsDef);
+
+    if (node->ns != NULL) {
+        xmlNsPtr ns;
+
+	ns = xmlSearchNs(doc, ret, node->ns->prefix);
+	if (ns == NULL) {
+	    /*
+	     * Humm, we are copying an element whose namespace is defined
+	     * out of the new tree scope. Search it in the original tree
+	     * and add it at the top of the new tree
+	     */
+	    ns = xmlSearchNs(node->doc, node, node->ns->prefix);
+	    if (ns != NULL) {
+	        xmlNodePtr root = ret;
+
+		while (root->parent != NULL) root = root->parent;
+		ret->ns = xmlNewNs(root, ns->href, ns->prefix);
+	    }
+	} else {
+	    /*
+	     * reference the existing namespace definition in our own tree.
+	     */
+	    ret->ns = ns;
+	}
+    }
+    if (node->properties != NULL)
+        ret->properties = xmlCopyPropList(ret, node->properties);
+    if (node->type == XML_ENTITY_REF_NODE) {
+	if ((doc == NULL) || (node->doc != doc)) {
+	    /*
+	     * The copied node will go into a separate document, so
+	     * to avoid dangling references to the ENTITY_DECL node
+	     * we cannot keep the reference. Try to find it in the
+	     * target document.
+	     */
+	    ret->children = (xmlNodePtr) xmlGetDocEntity(doc, ret->name);
+	} else {
+            ret->children = node->children;
+	}
+	ret->last = ret->children;
+    } else if ((node->children != NULL) && (extended != 2)) {
+        ret->children = xmlStaticCopyNodeList(node->children, doc, ret);
+	UPDATE_LAST_CHILD_AND_PARENT(ret)
+    }
+
+out:
+    /* if parent != NULL we already registered the node above */
+    if (parent == NULL && xmlRegisterNodeDefaultValue)
+	xmlRegisterNodeDefaultValue((xmlNodePtr)ret);
+    return(ret);
+}
+
+static xmlNodePtr
+xmlStaticCopyNodeList(xmlNodePtr node, xmlDocPtr doc, xmlNodePtr parent) {
+    xmlNodePtr ret = NULL;
+    xmlNodePtr p = NULL,q;
+
+    while (node != NULL) {
+#ifdef LIBXML_TREE_ENABLED
+	if (node->type == XML_DTD_NODE ) {
+	    if (doc == NULL) {
+		node = node->next;
+		continue;
+	    }
+	    if (doc->intSubset == NULL) {
+		q = (xmlNodePtr) xmlCopyDtd( (xmlDtdPtr) node );
+		q->doc = doc;
+		q->parent = parent;
+		doc->intSubset = (xmlDtdPtr) q;
+		xmlAddChild(parent, q);
+	    } else {
+		q = (xmlNodePtr) doc->intSubset;
+		xmlAddChild(parent, q);
+	    }
+	} else
+#endif /* LIBXML_TREE_ENABLED */
+	    q = xmlStaticCopyNode(node, doc, parent, 1);
+	if (ret == NULL) {
+	    q->prev = NULL;
+	    ret = p = q;
+	} else if (p != q) {
+	/* the test is required if xmlStaticCopyNode coalesced 2 text nodes */
+	    p->next = q;
+	    q->prev = p;
+	    p = q;
+	}
+	node = node->next;
+    }
+    return(ret);
+}
+
+/**
+ * xmlCopyNode:
+ * @node:  the node
+ * @extended:   if 1 do a recursive copy (properties, namespaces and children
+ *			when applicable)
+ *		if 2 copy properties and namespaces (when applicable)
+ *
+ * Do a copy of the node.
+ *
+ * Returns: a new #xmlNodePtr, or NULL in case of error.
+ */
+xmlNodePtr
+xmlCopyNode(const xmlNodePtr node, int extended) {
+    xmlNodePtr ret;
+
+    ret = xmlStaticCopyNode(node, NULL, NULL, extended);
+    return(ret);
+}
+
+/**
+ * xmlDocCopyNode:
+ * @node:  the node
+ * @doc:  the document
+ * @extended:   if 1 do a recursive copy (properties, namespaces and children
+ *			when applicable)
+ *		if 2 copy properties and namespaces (when applicable)
+ *
+ * Do a copy of the node to a given document.
+ *
+ * Returns: a new #xmlNodePtr, or NULL in case of error.
+ */
+xmlNodePtr
+xmlDocCopyNode(const xmlNodePtr node, xmlDocPtr doc, int extended) {
+    xmlNodePtr ret;
+
+    ret = xmlStaticCopyNode(node, doc, NULL, extended);
+    return(ret);
+}
+
+/**
+ * xmlCopyNodeList:
+ * @node:  the first node in the list.
+ *
+ * Do a recursive copy of the node list.
+ *
+ * Returns: a new #xmlNodePtr, or NULL in case of error.
+ */
+xmlNodePtr xmlCopyNodeList(const xmlNodePtr node) {
+    xmlNodePtr ret = xmlStaticCopyNodeList(node, NULL, NULL);
+    return(ret);
+}
+
+#if defined(LIBXML_TREE_ENABLED)
+/**
+ * xmlCopyDtd:
+ * @dtd:  the dtd
+ *
+ * Do a copy of the dtd.
+ *
+ * Returns: a new #xmlDtdPtr, or NULL in case of error.
+ */
+xmlDtdPtr
+xmlCopyDtd(xmlDtdPtr dtd) {
+    xmlDtdPtr ret;
+    xmlNodePtr cur, p = NULL, q;
+
+    if (dtd == NULL) return(NULL);
+    ret = xmlNewDtd(NULL, dtd->name, dtd->ExternalID, dtd->SystemID);
+    if (ret == NULL) return(NULL);
+    if (dtd->entities != NULL)
+        ret->entities = (void *) xmlCopyEntitiesTable(
+	                    (xmlEntitiesTablePtr) dtd->entities);
+    if (dtd->notations != NULL)
+        ret->notations = (void *) xmlCopyNotationTable(
+	                    (xmlNotationTablePtr) dtd->notations);
+    if (dtd->elements != NULL)
+        ret->elements = (void *) xmlCopyElementTable(
+	                    (xmlElementTablePtr) dtd->elements);
+    if (dtd->attributes != NULL)
+        ret->attributes = (void *) xmlCopyAttributeTable(
+	                    (xmlAttributeTablePtr) dtd->attributes);
+    if (dtd->pentities != NULL)
+	ret->pentities = (void *) xmlCopyEntitiesTable(
+			    (xmlEntitiesTablePtr) dtd->pentities);
+    
+    cur = dtd->children;
+    while (cur != NULL) {
+	q = NULL;
+
+	if (cur->type == XML_ENTITY_DECL) {
+	    xmlEntityPtr tmp = (xmlEntityPtr) cur;
+	    switch (tmp->etype) {
+		case XML_INTERNAL_GENERAL_ENTITY:
+		case XML_EXTERNAL_GENERAL_PARSED_ENTITY:
+		case XML_EXTERNAL_GENERAL_UNPARSED_ENTITY:
+		    q = (xmlNodePtr) xmlGetEntityFromDtd(ret, tmp->name);
+		    break;
+		case XML_INTERNAL_PARAMETER_ENTITY:
+		case XML_EXTERNAL_PARAMETER_ENTITY:
+    		    q = (xmlNodePtr) 
+			xmlGetParameterEntityFromDtd(ret, tmp->name);
+		    break;
+		case XML_INTERNAL_PREDEFINED_ENTITY:
+		    break;
+	    }
+	} else if (cur->type == XML_ELEMENT_DECL) {
+	    xmlElementPtr tmp = (xmlElementPtr) cur;
+	    q = (xmlNodePtr)
+		xmlGetDtdQElementDesc(ret, tmp->name, tmp->prefix);
+	} else if (cur->type == XML_ATTRIBUTE_DECL) {
+	    xmlAttributePtr tmp = (xmlAttributePtr) cur;
+	    q = (xmlNodePtr) 
+		xmlGetDtdQAttrDesc(ret, tmp->elem, tmp->name, tmp->prefix);
+	} else if (cur->type == XML_COMMENT_NODE) {
+	    q = xmlCopyNode(cur, 0);
+	}
+	
+	if (q == NULL) {
+	    cur = cur->next;
+	    continue;
+	}
+	
+	if (p == NULL)
+	    ret->children = q;
+	else
+    	    p->next = q;
+	
+    	q->prev = p;
+    	q->parent = (xmlNodePtr) ret;
+	q->next = NULL;
+	ret->last = q;
+    	p = q;
+	cur = cur->next;
+    }
+
+    return(ret);
+}
+#endif
+
+#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
+/**
+ * xmlCopyDoc:
+ * @doc:  the document
+ * @recursive:  if not zero do a recursive copy.
+ *
+ * Do a copy of the document info. If recursive, the content tree will
+ * be copied too as well as DTD, namespaces and entities.
+ *
+ * Returns: a new #xmlDocPtr, or NULL in case of error.
+ */
+xmlDocPtr
+xmlCopyDoc(xmlDocPtr doc, int recursive) {
+    xmlDocPtr ret;
+
+    if (doc == NULL) return(NULL);
+    ret = xmlNewDoc(doc->version);
+    if (ret == NULL) return(NULL);
+    if (doc->name != NULL)
+        ret->name = xmlMemStrdup(doc->name);
+    if (doc->encoding != NULL)
+        ret->encoding = xmlStrdup(doc->encoding);
+    ret->charset = doc->charset;
+    ret->compression = doc->compression;
+    ret->standalone = doc->standalone;
+    if (!recursive) return(ret);
+
+    ret->last = NULL;
+    ret->children = NULL;
+#ifdef LIBXML_TREE_ENABLED
+    if (doc->intSubset != NULL) {
+        ret->intSubset = xmlCopyDtd(doc->intSubset);
+	xmlSetTreeDoc((xmlNodePtr)ret->intSubset, ret);
+	ret->intSubset->parent = ret;
+    }
+#endif
+    if (doc->oldNs != NULL)
+        ret->oldNs = xmlCopyNamespaceList(doc->oldNs);
+    if (doc->children != NULL) {
+	xmlNodePtr tmp;
+	
+	ret->children = xmlStaticCopyNodeList(doc->children, ret,
+		                               (xmlNodePtr)ret);
+	ret->last = NULL;
+	tmp = ret->children;
+	while (tmp != NULL) {
+	    if (tmp->next == NULL)
+	        ret->last = tmp;
+	    tmp = tmp->next;
+	}
+    }
+    return(ret);
+}
+#endif /* LIBXML_TREE_ENABLED */
+
+/************************************************************************
+ *									*
+ *		Content access functions				*
+ *									*
+ ************************************************************************/
+ 
+/**
+ * xmlGetLineNo:
+ * @node: valid node
+ *
+ * Get line number of @node. This requires activation of this option
+ * before invoking the parser by calling xmlLineNumbersDefault(1)
+ *
+ * Returns the line number if successful, -1 otherwise
+ */
+long
+xmlGetLineNo(xmlNodePtr node)
+{
+    long result = -1;
+
+    if (!node)
+        return result;
+    if (node->type == XML_ELEMENT_NODE)
+        result = (long) node->line;
+    else if ((node->prev != NULL) &&
+             ((node->prev->type == XML_ELEMENT_NODE) ||
+	      (node->prev->type == XML_TEXT_NODE)))
+        result = xmlGetLineNo(node->prev);
+    else if ((node->parent != NULL) &&
+             ((node->parent->type == XML_ELEMENT_NODE) ||
+      	      (node->parent->type == XML_TEXT_NODE)))
+        result = xmlGetLineNo(node->parent);
+
+    return result;
+}
+
+#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_DEBUG_ENABLED)
+/**
+ * xmlGetNodePath:
+ * @node: a node
+ *
+ * Build a structure based Path for the given node
+ *
+ * Returns the new path or NULL in case of error. The caller must free
+ *     the returned string
+ */
+xmlChar *
+xmlGetNodePath(xmlNodePtr node)
+{
+    xmlNodePtr cur, tmp, next;
+    xmlChar *buffer = NULL, *temp;
+    size_t buf_len;
+    xmlChar *buf;
+    const char *sep;
+    const char *name;
+    char nametemp[100];
+    int occur = 0;
+
+    if (node == NULL)
+        return (NULL);
+
+    buf_len = 500;
+    buffer = (xmlChar *) xmlMallocAtomic(buf_len * sizeof(xmlChar));
+    if (buffer == NULL) {
+	xmlTreeErrMemory("getting node path");
+        return (NULL);
+    }
+    buf = (xmlChar *) xmlMallocAtomic(buf_len * sizeof(xmlChar));
+    if (buf == NULL) {
+	xmlTreeErrMemory("getting node path");
+        xmlFree(buffer);
+        return (NULL);
+    }
+
+    buffer[0] = 0;
+    cur = node;
+    do {
+        name = "";
+        sep = "?";
+        occur = 0;
+        if ((cur->type == XML_DOCUMENT_NODE) ||
+            (cur->type == XML_HTML_DOCUMENT_NODE)) {
+            if (buffer[0] == '/')
+                break;
+            sep = "/";
+            next = NULL;
+        } else if (cur->type == XML_ELEMENT_NODE) {
+            sep = "/";
+            name = (const char *) cur->name;
+            if (cur->ns) {
+	        if (cur->ns->prefix != NULL)
+                    snprintf(nametemp, sizeof(nametemp) - 1,
+                         "%s:%s", cur->ns->prefix, cur->name);
+		else
+		    snprintf(nametemp, sizeof(nametemp) - 1,
+		         "%s", cur->name);
+                nametemp[sizeof(nametemp) - 1] = 0;
+                name = nametemp;
+            }
+            next = cur->parent;
+
+            /*
+             * Thumbler index computation
+	     * TODO: the ocurence test seems bogus for namespaced names
+             */
+            tmp = cur->prev;
+            while (tmp != NULL) {
+                if ((tmp->type == XML_ELEMENT_NODE) &&
+		    (xmlStrEqual(cur->name, tmp->name)))
+                    occur++;
+                tmp = tmp->prev;
+            }
+            if (occur == 0) {
+                tmp = cur->next;
+                while (tmp != NULL && occur == 0) {
+                    if ((tmp->type == XML_ELEMENT_NODE) &&
+			(xmlStrEqual(cur->name, tmp->name)))
+                        occur++;
+                    tmp = tmp->next;
+                }
+                if (occur != 0)
+                    occur = 1;
+            } else
+                occur++;
+        } else if (cur->type == XML_COMMENT_NODE) {
+            sep = "/";
+	    name = "comment()";
+            next = cur->parent;
+
+            /*
+             * Thumbler index computation
+             */
+            tmp = cur->prev;
+            while (tmp != NULL) {
+                if (tmp->type == XML_COMMENT_NODE)
+		    occur++;
+                tmp = tmp->prev;
+            }
+            if (occur == 0) {
+                tmp = cur->next;
+                while (tmp != NULL && occur == 0) {
+		  if (tmp->type == XML_COMMENT_NODE)
+		    occur++;
+                    tmp = tmp->next;
+                }
+                if (occur != 0)
+                    occur = 1;
+            } else
+                occur++;
+        } else if ((cur->type == XML_TEXT_NODE) ||
+                   (cur->type == XML_CDATA_SECTION_NODE)) {
+            sep = "/";
+	    name = "text()";
+            next = cur->parent;
+
+            /*
+             * Thumbler index computation
+             */
+            tmp = cur->prev;
+            while (tmp != NULL) {
+                if ((cur->type == XML_TEXT_NODE) ||
+		    (cur->type == XML_CDATA_SECTION_NODE))
+		    occur++;
+                tmp = tmp->prev;
+            }
+            if (occur == 0) {
+                tmp = cur->next;
+                while (tmp != NULL && occur == 0) {
+		  if ((cur->type == XML_TEXT_NODE) ||
+		      (cur->type == XML_CDATA_SECTION_NODE))
+		    occur++;
+                    tmp = tmp->next;
+                }
+                if (occur != 0)
+                    occur = 1;
+            } else
+                occur++;
+        } else if (cur->type == XML_PI_NODE) {
+            sep = "/";
+	    snprintf(nametemp, sizeof(nametemp) - 1,
+		     "processing-instruction('%s')", cur->name);
+            nametemp[sizeof(nametemp) - 1] = 0;
+            name = nametemp;
+
+	    next = cur->parent;
+
+            /*
+             * Thumbler index computation
+             */
+            tmp = cur->prev;
+            while (tmp != NULL) {
+                if ((tmp->type == XML_PI_NODE) &&
+		    (xmlStrEqual(cur->name, tmp->name)))
+                    occur++;
+                tmp = tmp->prev;
+            }
+            if (occur == 0) {
+                tmp = cur->next;
+                while (tmp != NULL && occur == 0) {
+                    if ((tmp->type == XML_PI_NODE) &&
+			(xmlStrEqual(cur->name, tmp->name)))
+                        occur++;
+                    tmp = tmp->next;
+                }
+                if (occur != 0)
+                    occur = 1;
+            } else
+                occur++;
+
+        } else if (cur->type == XML_ATTRIBUTE_NODE) {
+            sep = "/@";
+            name = (const char *) (((xmlAttrPtr) cur)->name);
+            next = ((xmlAttrPtr) cur)->parent;
+        } else {
+            next = cur->parent;
+        }
+
+        /*
+         * Make sure there is enough room
+         */
+        if (xmlStrlen(buffer) + sizeof(nametemp) + 20 > buf_len) {
+            buf_len =
+                2 * buf_len + xmlStrlen(buffer) + sizeof(nametemp) + 20;
+            temp = (xmlChar *) xmlRealloc(buffer, buf_len);
+            if (temp == NULL) {
+		xmlTreeErrMemory("getting node path");
+                xmlFree(buf);
+                xmlFree(buffer);
+                return (NULL);
+            }
+            buffer = temp;
+            temp = (xmlChar *) xmlRealloc(buf, buf_len);
+            if (temp == NULL) {
+		xmlTreeErrMemory("getting node path");
+                xmlFree(buf);
+                xmlFree(buffer);
+                return (NULL);
+            }
+            buf = temp;
+        }
+        if (occur == 0)
+            snprintf((char *) buf, buf_len, "%s%s%s",
+                     sep, name, (char *) buffer);
+        else
+            snprintf((char *) buf, buf_len, "%s%s[%d]%s",
+                     sep, name, occur, (char *) buffer);
+        snprintf((char *) buffer, buf_len, "%s", buf);
+        cur = next;
+    } while (cur != NULL);
+    xmlFree(buf);
+    return (buffer);
+}
+#endif /* LIBXML_TREE_ENABLED */
+
+/**
+ * xmlDocGetRootElement:
+ * @doc:  the document
+ *
+ * Get the root element of the document (doc->children is a list
+ * containing possibly comments, PIs, etc ...).
+ *
+ * Returns the #xmlNodePtr for the root or NULL
+ */
+xmlNodePtr
+xmlDocGetRootElement(xmlDocPtr doc) {
+    xmlNodePtr ret;
+
+    if (doc == NULL) return(NULL);
+    ret = doc->children;
+    while (ret != NULL) {
+	if (ret->type == XML_ELEMENT_NODE)
+	    return(ret);
+        ret = ret->next;
+    }
+    return(ret);
+}
+ 
+#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED)
+/**
+ * xmlDocSetRootElement:
+ * @doc:  the document
+ * @root:  the new document root element
+ *
+ * Set the root element of the document (doc->children is a list
+ * containing possibly comments, PIs, etc ...).
+ *
+ * Returns the old root element if any was found
+ */
+xmlNodePtr
+xmlDocSetRootElement(xmlDocPtr doc, xmlNodePtr root) {
+    xmlNodePtr old = NULL;
+
+    if (doc == NULL) return(NULL);
+    if (root == NULL)
+	return(NULL);
+    xmlUnlinkNode(root);
+    root->doc = doc;
+    root->parent = (xmlNodePtr) doc;
+    old = doc->children;
+    while (old != NULL) {
+	if (old->type == XML_ELEMENT_NODE)
+	    break;
+        old = old->next;
+    }
+    if (old == NULL) {
+	if (doc->children == NULL) {
+	    doc->children = root;
+	    doc->last = root;
+	} else {
+	    xmlAddSibling(doc->children, root);
+	}
+    } else {
+	xmlReplaceNode(old, root);
+    }
+    return(old);
+}
+#endif
+ 
+#if defined(LIBXML_TREE_ENABLED)
+/**
+ * xmlNodeSetLang:
+ * @cur:  the node being changed
+ * @lang:  the language description
+ *
+ * Set the language of a node, i.e. the values of the xml:lang
+ * attribute.
+ */
+void
+xmlNodeSetLang(xmlNodePtr cur, const xmlChar *lang) {
+    xmlNsPtr ns;
+
+    if (cur == NULL) return;
+    switch(cur->type) {
+        case XML_TEXT_NODE:
+        case XML_CDATA_SECTION_NODE:
+        case XML_COMMENT_NODE:
+        case XML_DOCUMENT_NODE:
+        case XML_DOCUMENT_TYPE_NODE:
+        case XML_DOCUMENT_FRAG_NODE:
+        case XML_NOTATION_NODE:
+        case XML_HTML_DOCUMENT_NODE:
+        case XML_DTD_NODE:
+        case XML_ELEMENT_DECL:
+        case XML_ATTRIBUTE_DECL:
+        case XML_ENTITY_DECL:
+        case XML_PI_NODE:
+        case XML_ENTITY_REF_NODE:
+        case XML_ENTITY_NODE:
+	case XML_NAMESPACE_DECL:
+#ifdef LIBXML_DOCB_ENABLED
+	case XML_DOCB_DOCUMENT_NODE:
+#endif
+	case XML_XINCLUDE_START:
+	case XML_XINCLUDE_END:
+	    return;
+        case XML_ELEMENT_NODE:
+        case XML_ATTRIBUTE_NODE:
+	    break;
+    }
+    ns = xmlSearchNsByHref(cur->doc, cur, XML_XML_NAMESPACE);
+    if (ns == NULL)
+	return;
+    xmlSetNsProp(cur, ns, BAD_CAST "lang", lang);
+}
+#endif /* LIBXML_TREE_ENABLED */
+ 
+/**
+ * xmlNodeGetLang:
+ * @cur:  the node being checked
+ *
+ * Searches the language of a node, i.e. the values of the xml:lang
+ * attribute or the one carried by the nearest ancestor.
+ *
+ * Returns a pointer to the lang value, or NULL if not found
+ *     It's up to the caller to free the memory with xmlFree().
+ */
+xmlChar *
+xmlNodeGetLang(xmlNodePtr cur) {
+    xmlChar *lang;
+
+    while (cur != NULL) {
+        lang = xmlGetNsProp(cur, BAD_CAST "lang", XML_XML_NAMESPACE);
+	if (lang != NULL)
+	    return(lang);
+	cur = cur->parent;
+    }
+    return(NULL);
+}
+ 
+
+#ifdef LIBXML_TREE_ENABLED
+/**
+ * xmlNodeSetSpacePreserve:
+ * @cur:  the node being changed
+ * @val:  the xml:space value ("0": default, 1: "preserve")
+ *
+ * Set (or reset) the space preserving behaviour of a node, i.e. the
+ * value of the xml:space attribute.
+ */
+void
+xmlNodeSetSpacePreserve(xmlNodePtr cur, int val) {
+    xmlNsPtr ns;
+
+    if (cur == NULL) return;
+    switch(cur->type) {
+        case XML_TEXT_NODE:
+        case XML_CDATA_SECTION_NODE:
+        case XML_COMMENT_NODE:
+        case XML_DOCUMENT_NODE:
+        case XML_DOCUMENT_TYPE_NODE:
+        case XML_DOCUMENT_FRAG_NODE:
+        case XML_NOTATION_NODE:
+        case XML_HTML_DOCUMENT_NODE:
+        case XML_DTD_NODE:
+        case XML_ELEMENT_DECL:
+        case XML_ATTRIBUTE_DECL:
+        case XML_ENTITY_DECL:
+        case XML_PI_NODE:
+        case XML_ENTITY_REF_NODE:
+        case XML_ENTITY_NODE:
+	case XML_NAMESPACE_DECL:
+	case XML_XINCLUDE_START:
+	case XML_XINCLUDE_END:
+#ifdef LIBXML_DOCB_ENABLED
+	case XML_DOCB_DOCUMENT_NODE:
+#endif
+	    return;
+        case XML_ELEMENT_NODE:
+        case XML_ATTRIBUTE_NODE:
+	    break;
+    }
+    ns = xmlSearchNsByHref(cur->doc, cur, XML_XML_NAMESPACE);
+    if (ns == NULL)
+	return;
+    switch (val) {
+    case 0:
+	xmlSetNsProp(cur, ns, BAD_CAST "space", BAD_CAST "default");
+	break;
+    case 1:
+	xmlSetNsProp(cur, ns, BAD_CAST "space", BAD_CAST "preserve");
+	break;
+    }
+}
+#endif /* LIBXML_TREE_ENABLED */
+
+/**
+ * xmlNodeGetSpacePreserve:
+ * @cur:  the node being checked
+ *
+ * Searches the space preserving behaviour of a node, i.e. the values
+ * of the xml:space attribute or the one carried by the nearest
+ * ancestor.
+ *
+ * Returns -1 if xml:space is not inherited, 0 if "default", 1 if "preserve"
+ */
+int
+xmlNodeGetSpacePreserve(xmlNodePtr cur) {
+    xmlChar *space;
+
+    while (cur != NULL) {
+	space = xmlGetNsProp(cur, BAD_CAST "space", XML_XML_NAMESPACE);
+	if (space != NULL) {
+	    if (xmlStrEqual(space, BAD_CAST "preserve")) {
+		xmlFree(space);
+		return(1);
+	    }
+	    if (xmlStrEqual(space, BAD_CAST "default")) {
+		xmlFree(space);
+		return(0);
+	    }
+	    xmlFree(space);
+	}
+	cur = cur->parent;
+    }
+    return(-1);
+}
+ 
+#ifdef LIBXML_TREE_ENABLED
+/**
+ * xmlNodeSetName:
+ * @cur:  the node being changed
+ * @name:  the new tag name
+ *
+ * Set (or reset) the name of a node.
+ */
+void
+xmlNodeSetName(xmlNodePtr cur, const xmlChar *name) {
+    if (cur == NULL) return;
+    if (name == NULL) return;
+    switch(cur->type) {
+        case XML_TEXT_NODE:
+        case XML_CDATA_SECTION_NODE:
+        case XML_COMMENT_NODE:
+        case XML_DOCUMENT_TYPE_NODE:
+        case XML_DOCUMENT_FRAG_NODE:
+        case XML_NOTATION_NODE:
+        case XML_HTML_DOCUMENT_NODE:
+	case XML_NAMESPACE_DECL:
+	case XML_XINCLUDE_START:
+	case XML_XINCLUDE_END:
+#ifdef LIBXML_DOCB_ENABLED
+	case XML_DOCB_DOCUMENT_NODE:
+#endif
+	    return;
+        case XML_ELEMENT_NODE:
+        case XML_ATTRIBUTE_NODE:
+        case XML_PI_NODE:
+        case XML_ENTITY_REF_NODE:
+        case XML_ENTITY_NODE:
+        case XML_DTD_NODE:
+        case XML_DOCUMENT_NODE:
+        case XML_ELEMENT_DECL:
+        case XML_ATTRIBUTE_DECL:
+        case XML_ENTITY_DECL:
+	    break;
+    }
+    if (cur->name != NULL) xmlFree((xmlChar *) cur->name);
+    cur->name = xmlStrdup(name);
+}
+#endif
+ 
+#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED)
+/**
+ * xmlNodeSetBase:
+ * @cur:  the node being changed
+ * @uri:  the new base URI
+ *
+ * Set (or reset) the base URI of a node, i.e. the value of the
+ * xml:base attribute.
+ */
+void
+xmlNodeSetBase(xmlNodePtr cur, const xmlChar* uri) {
+    xmlNsPtr ns;
+
+    if (cur == NULL) return;
+    switch(cur->type) {
+        case XML_TEXT_NODE:
+        case XML_CDATA_SECTION_NODE:
+        case XML_COMMENT_NODE:
+        case XML_DOCUMENT_TYPE_NODE:
+        case XML_DOCUMENT_FRAG_NODE:
+        case XML_NOTATION_NODE:
+        case XML_DTD_NODE:
+        case XML_ELEMENT_DECL:
+        case XML_ATTRIBUTE_DECL:
+        case XML_ENTITY_DECL:
+        case XML_PI_NODE:
+        case XML_ENTITY_REF_NODE:
+        case XML_ENTITY_NODE:
+	case XML_NAMESPACE_DECL:
+	case XML_XINCLUDE_START:
+	case XML_XINCLUDE_END:
+	    return;
+        case XML_ELEMENT_NODE:
+        case XML_ATTRIBUTE_NODE:
+	    break;
+        case XML_DOCUMENT_NODE:
+#ifdef LIBXML_DOCB_ENABLED
+	case XML_DOCB_DOCUMENT_NODE:
+#endif
+        case XML_HTML_DOCUMENT_NODE: {
+	    xmlDocPtr doc = (xmlDocPtr) cur;
+
+	    if (doc->URL != NULL)
+		xmlFree((xmlChar *) doc->URL);
+	    if (uri == NULL)
+		doc->URL = NULL;
+	    else
+		doc->URL = xmlStrdup(uri);
+	    return;
+	}
+    }
+    
+    ns = xmlSearchNsByHref(cur->doc, cur, XML_XML_NAMESPACE);
+    if (ns == NULL)
+	return;
+    xmlSetNsProp(cur, ns, BAD_CAST "base", uri);
+}
+#endif /* LIBXML_TREE_ENABLED */
+
+/**
+ * xmlNodeGetBase:
+ * @doc:  the document the node pertains to
+ * @cur:  the node being checked
+ *
+ * Searches for the BASE URL. The code should work on both XML
+ * and HTML document even if base mechanisms are completely different.
+ * It returns the base as defined in RFC 2396 sections
+ * 5.1.1. Base URI within Document Content
+ * and
+ * 5.1.2. Base URI from the Encapsulating Entity
+ * However it does not return the document base (5.1.3), use
+ * xmlDocumentGetBase() for this
+ *
+ * Returns a pointer to the base URL, or NULL if not found
+ *     It's up to the caller to free the memory with xmlFree().
+ */
+xmlChar *
+xmlNodeGetBase(xmlDocPtr doc, xmlNodePtr cur) {
+    xmlChar *oldbase = NULL;
+    xmlChar *base, *newbase;
+
+    if ((cur == NULL) && (doc == NULL)) 
+        return(NULL);
+    if (doc == NULL) doc = cur->doc;	
+    if ((doc != NULL) && (doc->type == XML_HTML_DOCUMENT_NODE)) {
+        cur = doc->children;
+	while ((cur != NULL) && (cur->name != NULL)) {
+	    if (cur->type != XML_ELEMENT_NODE) {
+	        cur = cur->next;
+		continue;
+	    }
+	    if (!xmlStrcasecmp(cur->name, BAD_CAST "html")) {
+	        cur = cur->children;
+		continue;
+	    }
+	    if (!xmlStrcasecmp(cur->name, BAD_CAST "head")) {
+	        cur = cur->children;
+		continue;
+	    }
+	    if (!xmlStrcasecmp(cur->name, BAD_CAST "base")) {
+                return(xmlGetProp(cur, BAD_CAST "href"));
+	    }
+	    cur = cur->next;
+	}
+	return(NULL);
+    }
+    while (cur != NULL) {
+	if (cur->type == XML_ENTITY_DECL) {
+	    xmlEntityPtr ent = (xmlEntityPtr) cur;
+	    return(xmlStrdup(ent->URI));
+	}
+	if (cur->type == XML_ELEMENT_NODE) {
+	    base = xmlGetNsProp(cur, BAD_CAST "base", XML_XML_NAMESPACE);
+	    if (base != NULL) {
+		if (oldbase != NULL) {
+		    newbase = xmlBuildURI(oldbase, base);
+		    if (newbase != NULL) {
+			xmlFree(oldbase);
+			xmlFree(base);
+			oldbase = newbase;
+		    } else {
+			xmlFree(oldbase);
+			xmlFree(base);
+			return(NULL);
+		    }
+		} else {
+		    oldbase = base;
+		}
+		if ((!xmlStrncmp(oldbase, BAD_CAST "http://", 7)) ||
+		    (!xmlStrncmp(oldbase, BAD_CAST "ftp://", 6)) ||
+		    (!xmlStrncmp(oldbase, BAD_CAST "urn:", 4)))
+		    return(oldbase);
+	    }
+	}
+	cur = cur->parent;
+    }
+    if ((doc != NULL) && (doc->URL != NULL)) {
+	if (oldbase == NULL)
+	    return(xmlStrdup(doc->URL));
+	newbase = xmlBuildURI(oldbase, doc->URL);
+	xmlFree(oldbase);
+	return(newbase);
+    }
+    return(oldbase);
+}
+ 
+/**
+ * xmlNodeBufGetContent:
+ * @buffer:  a buffer
+ * @cur:  the node being read
+ *
+ * Read the value of a node @cur, this can be either the text carried
+ * directly by this node if it's a TEXT node or the aggregate string
+ * of the values carried by this node child's (TEXT and ENTITY_REF).
+ * Entity references are substituted.
+ * Fills up the buffer @buffer with this value
+ * 
+ * Returns 0 in case of success and -1 in case of error.
+ */
+int
+xmlNodeBufGetContent(xmlBufferPtr buffer, xmlNodePtr cur)
+{
+    if ((cur == NULL) || (buffer == NULL)) return(-1);
+    switch (cur->type) {
+        case XML_CDATA_SECTION_NODE:
+        case XML_TEXT_NODE:
+	    xmlBufferCat(buffer, cur->content);
+            break;
+        case XML_DOCUMENT_FRAG_NODE:
+        case XML_ELEMENT_NODE:{
+                xmlNodePtr tmp = cur;
+
+                while (tmp != NULL) {
+                    switch (tmp->type) {
+                        case XML_CDATA_SECTION_NODE:
+                        case XML_TEXT_NODE:
+                            if (tmp->content != NULL)
+                                xmlBufferCat(buffer, tmp->content);
+                            break;
+                        case XML_ENTITY_REF_NODE:
+			    xmlNodeBufGetContent(buffer, tmp->children);
+			    break;
+                        default:
+                            break;
+                    }
+                    /*
+                     * Skip to next node
+                     */
+                    if (tmp->children != NULL) {
+                        if (tmp->children->type != XML_ENTITY_DECL) {
+                            tmp = tmp->children;
+                            continue;
+                        }
+                    }
+                    if (tmp == cur)
+                        break;
+
+                    if (tmp->next != NULL) {
+                        tmp = tmp->next;
+                        continue;
+                    }
+
+                    do {
+                        tmp = tmp->parent;
+                        if (tmp == NULL)
+                            break;
+                        if (tmp == cur) {
+                            tmp = NULL;
+                            break;
+                        }
+                        if (tmp->next != NULL) {
+                            tmp = tmp->next;
+                            break;
+                        }
+                    } while (tmp != NULL);
+                }
+		break;
+            }
+        case XML_ATTRIBUTE_NODE:{
+                xmlAttrPtr attr = (xmlAttrPtr) cur;
+		xmlNodePtr tmp = attr->children;
+
+		while (tmp != NULL) {
+		    if (tmp->type == XML_TEXT_NODE)
+		        xmlBufferCat(buffer, tmp->content);
+		    else
+		        xmlNodeBufGetContent(buffer, tmp);
+		    tmp = tmp->next;
+		}
+                break;
+            }
+        case XML_COMMENT_NODE:
+        case XML_PI_NODE:
+	    xmlBufferCat(buffer, cur->content);
+            break;
+        case XML_ENTITY_REF_NODE:{
+                xmlEntityPtr ent;
+                xmlNodePtr tmp;
+
+                /* lookup entity declaration */
+                ent = xmlGetDocEntity(cur->doc, cur->name);
+                if (ent == NULL)
+                    return(-1);
+
+                /* an entity content can be any "well balanced chunk",
+                 * i.e. the result of the content [43] production:
+                 * http://www.w3.org/TR/REC-xml#NT-content
+                 * -> we iterate through child nodes and recursive call
+                 * xmlNodeGetContent() which handles all possible node types */
+                tmp = ent->children;
+                while (tmp) {
+		    xmlNodeBufGetContent(buffer, tmp);
+                    tmp = tmp->next;
+                }
+		break;
+            }
+        case XML_ENTITY_NODE:
+        case XML_DOCUMENT_TYPE_NODE:
+        case XML_NOTATION_NODE:
+        case XML_DTD_NODE:
+        case XML_XINCLUDE_START:
+        case XML_XINCLUDE_END:
+            break;
+        case XML_DOCUMENT_NODE:
+#ifdef LIBXML_DOCB_ENABLED
+        case XML_DOCB_DOCUMENT_NODE:
+#endif
+        case XML_HTML_DOCUMENT_NODE:
+	    cur = cur->children;
+	    while (cur!= NULL) {
+		if ((cur->type == XML_ELEMENT_NODE) ||
+		    (cur->type == XML_TEXT_NODE) ||
+		    (cur->type == XML_CDATA_SECTION_NODE)) {
+		    xmlNodeBufGetContent(buffer, cur);
+		}
+		cur = cur->next;
+	    }
+	    break;
+        case XML_NAMESPACE_DECL:
+	    xmlBufferCat(buffer, ((xmlNsPtr) cur)->href);
+	    break;
+        case XML_ELEMENT_DECL:
+        case XML_ATTRIBUTE_DECL:
+        case XML_ENTITY_DECL:
+            break;
+    }
+    return(0);
+}
+/**
+ * xmlNodeGetContent:
+ * @cur:  the node being read
+ *
+ * Read the value of a node, this can be either the text carried
+ * directly by this node if it's a TEXT node or the aggregate string
+ * of the values carried by this node child's (TEXT and ENTITY_REF).
+ * Entity references are substituted.
+ * Returns a new #xmlChar * or NULL if no content is available.
+ *     It's up to the caller to free the memory with xmlFree().
+ */
+xmlChar *
+xmlNodeGetContent(xmlNodePtr cur)
+{
+    if (cur == NULL)
+        return (NULL);
+    switch (cur->type) {
+        case XML_DOCUMENT_FRAG_NODE:
+        case XML_ELEMENT_NODE:{
+                xmlBufferPtr buffer;
+                xmlChar *ret;
+
+                buffer = xmlBufferCreateSize(64);
+                if (buffer == NULL)
+                    return (NULL);
+		xmlNodeBufGetContent(buffer, cur);
+                ret = buffer->content;
+                buffer->content = NULL;
+                xmlBufferFree(buffer);
+                return (ret);
+            }
+        case XML_ATTRIBUTE_NODE:{
+                xmlAttrPtr attr = (xmlAttrPtr) cur;
+
+                if (attr->parent != NULL)
+                    return (xmlNodeListGetString
+                            (attr->parent->doc, attr->children, 1));
+                else
+                    return (xmlNodeListGetString(NULL, attr->children, 1));
+                break;
+            }
+        case XML_COMMENT_NODE:
+        case XML_PI_NODE:
+            if (cur->content != NULL)
+                return (xmlStrdup(cur->content));
+            return (NULL);
+        case XML_ENTITY_REF_NODE:{
+                xmlEntityPtr ent;
+                xmlBufferPtr buffer;
+                xmlChar *ret;
+
+                /* lookup entity declaration */
+                ent = xmlGetDocEntity(cur->doc, cur->name);
+                if (ent == NULL)
+                    return (NULL);
+
+                buffer = xmlBufferCreate();
+                if (buffer == NULL)
+                    return (NULL);
+
+                xmlNodeBufGetContent(buffer, cur);
+
+                ret = buffer->content;
+                buffer->content = NULL;
+                xmlBufferFree(buffer);
+                return (ret);
+            }
+        case XML_ENTITY_NODE:
+        case XML_DOCUMENT_TYPE_NODE:
+        case XML_NOTATION_NODE:
+        case XML_DTD_NODE:
+        case XML_XINCLUDE_START:
+        case XML_XINCLUDE_END:
+            return (NULL);
+        case XML_DOCUMENT_NODE:
+#ifdef LIBXML_DOCB_ENABLED
+        case XML_DOCB_DOCUMENT_NODE:
+#endif
+        case XML_HTML_DOCUMENT_NODE: {
+	    xmlBufferPtr buffer;
+	    xmlChar *ret;
+
+	    buffer = xmlBufferCreate();
+	    if (buffer == NULL)
+		return (NULL);
+
+	    xmlNodeBufGetContent(buffer, (xmlNodePtr) cur);
+
+	    ret = buffer->content;
+	    buffer->content = NULL;
+	    xmlBufferFree(buffer);
+	    return (ret);
+	}
+        case XML_NAMESPACE_DECL: {
+	    xmlChar *tmp;
+
+	    tmp = xmlStrdup(((xmlNsPtr) cur)->href);
+            return (tmp);
+	}
+        case XML_ELEMENT_DECL:
+            /* TODO !!! */
+            return (NULL);
+        case XML_ATTRIBUTE_DECL:
+            /* TODO !!! */
+            return (NULL);
+        case XML_ENTITY_DECL:
+            /* TODO !!! */
+            return (NULL);
+        case XML_CDATA_SECTION_NODE:
+        case XML_TEXT_NODE:
+            if (cur->content != NULL)
+                return (xmlStrdup(cur->content));
+            return (NULL);
+    }
+    return (NULL);
+}
+
+/**
+ * xmlNodeSetContent:
+ * @cur:  the node being modified
+ * @content:  the new value of the content
+ *
+ * Replace the content of a node.
+ */
+void
+xmlNodeSetContent(xmlNodePtr cur, const xmlChar *content) {
+    if (cur == NULL) {
+#ifdef DEBUG_TREE
+        xmlGenericError(xmlGenericErrorContext,
+		"xmlNodeSetContent : node == NULL\n");
+#endif
+	return;
+    }
+    switch (cur->type) {
+        case XML_DOCUMENT_FRAG_NODE:
+        case XML_ELEMENT_NODE:
+        case XML_ATTRIBUTE_NODE:
+	    if (cur->children != NULL) xmlFreeNodeList(cur->children);
+	    cur->children = xmlStringGetNodeList(cur->doc, content);
+	    UPDATE_LAST_CHILD_AND_PARENT(cur)
+	    break;
+        case XML_TEXT_NODE:
+        case XML_CDATA_SECTION_NODE:
+        case XML_ENTITY_REF_NODE:
+        case XML_ENTITY_NODE:
+        case XML_PI_NODE:
+        case XML_COMMENT_NODE:
+	    if (cur->content != NULL) {
+	        if (!((cur->doc != NULL) && (cur->doc->dict != NULL) &&
+			xmlDictOwns(cur->doc->dict, cur->content)))
+		    xmlFree(cur->content);
+	    }	
+	    if (cur->children != NULL) xmlFreeNodeList(cur->children);
+	    cur->last = cur->children = NULL;
+	    if (content != NULL) {
+		cur->content = xmlStrdup(content);
+	    } else 
+		cur->content = NULL;
+	    break;
+        case XML_DOCUMENT_NODE:
+        case XML_HTML_DOCUMENT_NODE:
+        case XML_DOCUMENT_TYPE_NODE:
+	case XML_XINCLUDE_START:
+	case XML_XINCLUDE_END:
+#ifdef LIBXML_DOCB_ENABLED
+	case XML_DOCB_DOCUMENT_NODE:
+#endif
+	    break;
+        case XML_NOTATION_NODE:
+	    break;
+        case XML_DTD_NODE:
+	    break;
+	case XML_NAMESPACE_DECL:
+	    break;
+        case XML_ELEMENT_DECL:
+	    /* TODO !!! */
+	    break;
+        case XML_ATTRIBUTE_DECL:
+	    /* TODO !!! */
+	    break;
+        case XML_ENTITY_DECL:
+	    /* TODO !!! */
+	    break;
+    }
+}
+
+#ifdef LIBXML_TREE_ENABLED
+/**
+ * xmlNodeSetContentLen:
+ * @cur:  the node being modified
+ * @content:  the new value of the content
+ * @len:  the size of @content
+ *
+ * Replace the content of a node.
+ */
+void
+xmlNodeSetContentLen(xmlNodePtr cur, const xmlChar *content, int len) {
+    if (cur == NULL) {
+#ifdef DEBUG_TREE
+        xmlGenericError(xmlGenericErrorContext,
+		"xmlNodeSetContentLen : node == NULL\n");
+#endif
+	return;
+    }
+    switch (cur->type) {
+        case XML_DOCUMENT_FRAG_NODE:
+        case XML_ELEMENT_NODE:
+        case XML_ATTRIBUTE_NODE:
+	    if (cur->children != NULL) xmlFreeNodeList(cur->children);
+	    cur->children = xmlStringLenGetNodeList(cur->doc, content, len);
+	    UPDATE_LAST_CHILD_AND_PARENT(cur)
+	    break;
+        case XML_TEXT_NODE:
+        case XML_CDATA_SECTION_NODE:
+        case XML_ENTITY_REF_NODE:
+        case XML_ENTITY_NODE:
+        case XML_PI_NODE:
+        case XML_COMMENT_NODE:
+        case XML_NOTATION_NODE:
+	    if (cur->content != NULL) {
+		xmlFree(cur->content);
+	    }	
+	    if (cur->children != NULL) xmlFreeNodeList(cur->children);
+	    cur->children = cur->last = NULL;
+	    if (content != NULL) {
+		cur->content = xmlStrndup(content, len);
+	    } else 
+		cur->content = NULL;
+	    break;
+        case XML_DOCUMENT_NODE:
+        case XML_DTD_NODE:
+        case XML_HTML_DOCUMENT_NODE:
+        case XML_DOCUMENT_TYPE_NODE:
+	case XML_NAMESPACE_DECL:
+	case XML_XINCLUDE_START:
+	case XML_XINCLUDE_END:
+#ifdef LIBXML_DOCB_ENABLED
+	case XML_DOCB_DOCUMENT_NODE:
+#endif
+	    break;
+        case XML_ELEMENT_DECL:
+	    /* TODO !!! */
+	    break;
+        case XML_ATTRIBUTE_DECL:
+	    /* TODO !!! */
+	    break;
+        case XML_ENTITY_DECL:
+	    /* TODO !!! */
+	    break;
+    }
+}
+#endif /* LIBXML_TREE_ENABLED */
+
+/**
+ * xmlNodeAddContentLen:
+ * @cur:  the node being modified
+ * @content:  extra content
+ * @len:  the size of @content
+ * 
+ * Append the extra substring to the node content.
+ */
+void
+xmlNodeAddContentLen(xmlNodePtr cur, const xmlChar *content, int len) {
+    if (cur == NULL) {
+#ifdef DEBUG_TREE
+        xmlGenericError(xmlGenericErrorContext,
+		"xmlNodeAddContentLen : node == NULL\n");
+#endif
+	return;
+    }
+    if (len <= 0) return;
+    switch (cur->type) {
+        case XML_DOCUMENT_FRAG_NODE:
+        case XML_ELEMENT_NODE: {
+	    xmlNodePtr last, newNode, tmp;
+
+	    last = cur->last;
+	    newNode = xmlNewTextLen(content, len);
+	    if (newNode != NULL) {
+		tmp = xmlAddChild(cur, newNode);
+		if (tmp != newNode)
+		    return;
+	        if ((last != NULL) && (last->next == newNode)) {
+		    xmlTextMerge(last, newNode);
+		}
+	    }
+	    break;
+	}
+        case XML_ATTRIBUTE_NODE:
+	    break;
+        case XML_TEXT_NODE:
+        case XML_CDATA_SECTION_NODE:
+        case XML_ENTITY_REF_NODE:
+        case XML_ENTITY_NODE:
+        case XML_PI_NODE:
+        case XML_COMMENT_NODE:
+        case XML_NOTATION_NODE:
+	    if (content != NULL) {
+	        if ((cur->doc != NULL) && (cur->doc->dict != NULL) &&
+			    xmlDictOwns(cur->doc->dict, cur->content)) {
+		    cur->content =
+			    xmlStrncatNew(cur->content, content, len);
+		    break;
+		}
+		cur->content = xmlStrncat(cur->content, content, len);
+            }
+        case XML_DOCUMENT_NODE:
+        case XML_DTD_NODE:
+        case XML_HTML_DOCUMENT_NODE:
+        case XML_DOCUMENT_TYPE_NODE:
+	case XML_NAMESPACE_DECL:
+	case XML_XINCLUDE_START:
+	case XML_XINCLUDE_END:
+#ifdef LIBXML_DOCB_ENABLED
+	case XML_DOCB_DOCUMENT_NODE:
+#endif
+	    break;
+        case XML_ELEMENT_DECL:
+        case XML_ATTRIBUTE_DECL:
+        case XML_ENTITY_DECL:
+	    break;
+    }
+}
+
+/**
+ * xmlNodeAddContent:
+ * @cur:  the node being modified
+ * @content:  extra content
+ * 
+ * Append the extra substring to the node content.
+ */
+void
+xmlNodeAddContent(xmlNodePtr cur, const xmlChar *content) {
+    int len;
+
+    if (cur == NULL) {
+#ifdef DEBUG_TREE
+        xmlGenericError(xmlGenericErrorContext,
+		"xmlNodeAddContent : node == NULL\n");
+#endif
+	return;
+    }
+    if (content == NULL) return;
+    len = xmlStrlen(content);
+    xmlNodeAddContentLen(cur, content, len);
+}
+
+/**
+ * xmlTextMerge:
+ * @first:  the first text node
+ * @second:  the second text node being merged
+ * 
+ * Merge two text nodes into one
+ * Returns the first text node augmented
+ */
+xmlNodePtr
+xmlTextMerge(xmlNodePtr first, xmlNodePtr second) {
+    if (first == NULL) return(second);
+    if (second == NULL) return(first);
+    if (first->type != XML_TEXT_NODE) return(first);
+    if (second->type != XML_TEXT_NODE) return(first);
+    if (second->name != first->name)
+	return(first);
+    xmlNodeAddContent(first, second->content);
+    xmlUnlinkNode(second);
+    xmlFreeNode(second);
+    return(first);
+}
+
+#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XPATH_ENABLED)
+/**
+ * xmlGetNsList:
+ * @doc:  the document
+ * @node:  the current node
+ *
+ * Search all the namespace applying to a given element.
+ * Returns an NULL terminated array of all the #xmlNsPtr found
+ *         that need to be freed by the caller or NULL if no
+ *         namespace if defined
+ */
+xmlNsPtr *
+xmlGetNsList(xmlDocPtr doc ATTRIBUTE_UNUSED, xmlNodePtr node)
+{
+    xmlNsPtr cur;
+    xmlNsPtr *ret = NULL;
+    int nbns = 0;
+    int maxns = 10;
+    int i;
+
+    while (node != NULL) {
+        if (node->type == XML_ELEMENT_NODE) {
+            cur = node->nsDef;
+            while (cur != NULL) {
+                if (ret == NULL) {
+                    ret =
+                        (xmlNsPtr *) xmlMalloc((maxns + 1) *
+                                               sizeof(xmlNsPtr));
+                    if (ret == NULL) {
+			xmlTreeErrMemory("getting namespace list");
+                        return (NULL);
+                    }
+                    ret[nbns] = NULL;
+                }
+                for (i = 0; i < nbns; i++) {
+                    if ((cur->prefix == ret[i]->prefix) ||
+                        (xmlStrEqual(cur->prefix, ret[i]->prefix)))
+                        break;
+                }
+                if (i >= nbns) {
+                    if (nbns >= maxns) {
+                        maxns *= 2;
+                        ret = (xmlNsPtr *) xmlRealloc(ret,
+                                                      (maxns +
+                                                       1) *
+                                                      sizeof(xmlNsPtr));
+                        if (ret == NULL) {
+			    xmlTreeErrMemory("getting namespace list");
+                            return (NULL);
+                        }
+                    }
+                    ret[nbns++] = cur;
+                    ret[nbns] = NULL;
+                }
+
+                cur = cur->next;
+            }
+        }
+        node = node->parent;
+    }
+    return (ret);
+}
+#endif /* LIBXML_TREE_ENABLED */
+
+/**
+ * xmlSearchNs:
+ * @doc:  the document
+ * @node:  the current node
+ * @nameSpace:  the namespace prefix
+ *
+ * Search a Ns registered under a given name space for a document.
+ * recurse on the parents until it finds the defined namespace
+ * or return NULL otherwise.
+ * @nameSpace can be NULL, this is a search for the default namespace.
+ * We don't allow to cross entities boundaries. If you don't declare
+ * the namespace within those you will be in troubles !!! A warning
+ * is generated to cover this case.
+ *
+ * Returns the namespace pointer or NULL.
+ */
+xmlNsPtr
+xmlSearchNs(xmlDocPtr doc, xmlNodePtr node, const xmlChar *nameSpace) {
+	
+    xmlNsPtr cur;
+    xmlNodePtr orig = node;
+
+    if (node == NULL) return(NULL);
+    if ((nameSpace != NULL) &&
+	(xmlStrEqual(nameSpace, (const xmlChar *)"xml"))) {
+	if ((doc == NULL) && (node->type == XML_ELEMENT_NODE)) {
+	    /*
+	     * The XML-1.0 namespace is normally held on the root
+	     * element. In this case exceptionally create it on the
+	     * node element.
+	     */
+	    cur = (xmlNsPtr) xmlMalloc(sizeof(xmlNs));
+	    if (cur == NULL) {
+		xmlTreeErrMemory("searching namespace");
+		return(NULL);
+	    }
+	    memset(cur, 0, sizeof(xmlNs));
+	    cur->type = XML_LOCAL_NAMESPACE;
+	    cur->href = xmlStrdup(XML_XML_NAMESPACE); 
+	    cur->prefix = xmlStrdup((const xmlChar *)"xml"); 
+	    cur->next = node->nsDef;
+	    node->nsDef = cur;
+	    return(cur);
+	}
+	if (doc->oldNs == NULL) {
+	    /*
+	     * Allocate a new Namespace and fill the fields.
+	     */
+	    doc->oldNs = (xmlNsPtr) xmlMalloc(sizeof(xmlNs));
+	    if (doc->oldNs == NULL) {
+		xmlTreeErrMemory("searching namespace");
+		return(NULL);
+	    }
+	    memset(doc->oldNs, 0, sizeof(xmlNs));
+	    doc->oldNs->type = XML_LOCAL_NAMESPACE;
+
+	    doc->oldNs->href = xmlStrdup(XML_XML_NAMESPACE); 
+	    doc->oldNs->prefix = xmlStrdup((const xmlChar *)"xml"); 
+	}
+	return(doc->oldNs);
+    }
+    while (node != NULL) {
+	if ((node->type == XML_ENTITY_REF_NODE) ||
+	    (node->type == XML_ENTITY_NODE) ||
+	    (node->type == XML_ENTITY_DECL))
+	    return(NULL);
+	if (node->type == XML_ELEMENT_NODE) {
+	    cur = node->nsDef;
+	    while (cur != NULL) {
+		if ((cur->prefix == NULL) && (nameSpace == NULL) &&
+		    (cur->href != NULL))
+		    return(cur);
+		if ((cur->prefix != NULL) && (nameSpace != NULL) &&
+		    (cur->href != NULL) &&
+		    (xmlStrEqual(cur->prefix, nameSpace)))
+		    return(cur);
+		cur = cur->next;
+	    }
+	    if (orig != node) { 
+	        cur = node->ns;
+	        if (cur != NULL) {
+		    if ((cur->prefix == NULL) && (nameSpace == NULL) &&
+		        (cur->href != NULL))
+		        return(cur);
+		    if ((cur->prefix != NULL) && (nameSpace != NULL) &&
+		        (cur->href != NULL) &&
+		        (xmlStrEqual(cur->prefix, nameSpace)))
+		        return(cur);
+	        }
+	    }    
+	}
+	node = node->parent;
+    }
+    return(NULL);
+}
+
+/**
+ * xmlNsInScope:
+ * @doc:  the document
+ * @node:  the current node
+ * @ancestor:  the ancestor carrying the namespace
+ * @prefix:  the namespace prefix
+ *
+ * Verify that the given namespace held on @ancestor is still in scope
+ * on node.
+ * 
+ * Returns 1 if true, 0 if false and -1 in case of error.
+ */
+static int
+xmlNsInScope(xmlDocPtr doc ATTRIBUTE_UNUSED, xmlNodePtr node,
+             xmlNodePtr ancestor, const xmlChar * prefix)
+{
+    xmlNsPtr tst;
+
+    while ((node != NULL) && (node != ancestor)) {
+        if ((node->type == XML_ENTITY_REF_NODE) ||
+            (node->type == XML_ENTITY_NODE) ||
+            (node->type == XML_ENTITY_DECL))
+            return (-1);
+        if (node->type == XML_ELEMENT_NODE) {
+            tst = node->nsDef;
+            while (tst != NULL) {
+                if ((tst->prefix == NULL)
+                    && (prefix == NULL))
+                    return (0);
+                if ((tst->prefix != NULL)
+                    && (prefix != NULL)
+                    && (xmlStrEqual(tst->prefix, prefix)))
+                    return (0);
+                tst = tst->next;
+            }
+        }
+        node = node->parent;
+    }
+    if (node != ancestor)
+        return (-1);
+    return (1);
+}
+                  
+/**
+ * xmlSearchNsByHref:
+ * @doc:  the document
+ * @node:  the current node
+ * @href:  the namespace value
+ *
+ * Search a Ns aliasing a given URI. Recurse on the parents until it finds
+ * the defined namespace or return NULL otherwise.
+ * Returns the namespace pointer or NULL.
+ */
+xmlNsPtr
+xmlSearchNsByHref(xmlDocPtr doc, xmlNodePtr node, const xmlChar * href)
+{
+    xmlNsPtr cur;
+    xmlNodePtr orig = node;
+
+    if ((node == NULL) || (href == NULL))
+        return (NULL);
+    if (xmlStrEqual(href, XML_XML_NAMESPACE)) {
+        /*
+         * Only the document can hold the XML spec namespace.
+         */
+        if ((doc == NULL) && (node->type == XML_ELEMENT_NODE)) {
+            /*
+             * The XML-1.0 namespace is normally held on the root
+             * element. In this case exceptionally create it on the
+             * node element.
+             */
+            cur = (xmlNsPtr) xmlMalloc(sizeof(xmlNs));
+            if (cur == NULL) {
+		xmlTreeErrMemory("searching namespace");
+                return (NULL);
+            }
+            memset(cur, 0, sizeof(xmlNs));
+            cur->type = XML_LOCAL_NAMESPACE;
+            cur->href = xmlStrdup(XML_XML_NAMESPACE);
+            cur->prefix = xmlStrdup((const xmlChar *) "xml");
+            cur->next = node->nsDef;
+            node->nsDef = cur;
+            return (cur);
+        }
+        if (doc->oldNs == NULL) {
+            /*
+             * Allocate a new Namespace and fill the fields.
+             */
+            doc->oldNs = (xmlNsPtr) xmlMalloc(sizeof(xmlNs));
+            if (doc->oldNs == NULL) {
+		xmlTreeErrMemory("searching namespace");
+                return (NULL);
+            }
+            memset(doc->oldNs, 0, sizeof(xmlNs));
+            doc->oldNs->type = XML_LOCAL_NAMESPACE;
+
+            doc->oldNs->href = xmlStrdup(XML_XML_NAMESPACE);
+            doc->oldNs->prefix = xmlStrdup((const xmlChar *) "xml");
+        }
+        return (doc->oldNs);
+    }
+    while (node != NULL) {
+        if ((node->type == XML_ENTITY_REF_NODE) ||
+            (node->type == XML_ENTITY_NODE) ||
+            (node->type == XML_ENTITY_DECL))
+            return (NULL);
+        if (node->type == XML_ELEMENT_NODE) {
+            cur = node->nsDef;
+            while (cur != NULL) {
+                if ((cur->href != NULL) && (href != NULL) &&
+                    (xmlStrEqual(cur->href, href))) {
+		    if (xmlNsInScope(doc, orig, node, cur->href) == 1)
+			return (cur);
+                }
+                cur = cur->next;
+            }
+            if (orig != node) {
+                cur = node->ns;
+                if (cur != NULL) {
+                    if ((cur->href != NULL) && (href != NULL) &&
+                        (xmlStrEqual(cur->href, href))) {
+		        if (xmlNsInScope(doc, orig, node, cur->href) == 1)
+			    return (cur);
+                    }
+                }
+            }    
+        }
+        node = node->parent;
+    }
+    return (NULL);
+}
+
+/**
+ * xmlNewReconciliedNs:
+ * @doc:  the document
+ * @tree:  a node expected to hold the new namespace
+ * @ns:  the original namespace
+ *
+ * This function tries to locate a namespace definition in a tree
+ * ancestors, or create a new namespace definition node similar to
+ * @ns trying to reuse the same prefix. However if the given prefix is
+ * null (default namespace) or reused within the subtree defined by
+ * @tree or on one of its ancestors then a new prefix is generated.
+ * Returns the (new) namespace definition or NULL in case of error
+ */
+xmlNsPtr
+xmlNewReconciliedNs(xmlDocPtr doc, xmlNodePtr tree, xmlNsPtr ns) {
+    xmlNsPtr def;
+    xmlChar prefix[50];
+    int counter = 1;
+
+    if (tree == NULL) {
+#ifdef DEBUG_TREE
+        xmlGenericError(xmlGenericErrorContext,
+		"xmlNewReconciliedNs : tree == NULL\n");
+#endif
+	return(NULL);
+    }
+    if (ns == NULL) {
+#ifdef DEBUG_TREE
+        xmlGenericError(xmlGenericErrorContext,
+		"xmlNewReconciliedNs : ns == NULL\n");
+#endif
+	return(NULL);
+    }
+    /*
+     * Search an existing namespace definition inherited.
+     */
+    def = xmlSearchNsByHref(doc, tree, ns->href);
+    if (def != NULL)
+        return(def);
+
+    /*
+     * Find a close prefix which is not already in use.
+     * Let's strip namespace prefixes longer than 20 chars !
+     */
+    if (ns->prefix == NULL)
+	snprintf((char *) prefix, sizeof(prefix), "default");
+    else
+	snprintf((char *) prefix, sizeof(prefix), "%.20s", ns->prefix);
+
+    def = xmlSearchNs(doc, tree, prefix);
+    while (def != NULL) {
+        if (counter > 1000) return(NULL);
+	if (ns->prefix == NULL)
+	    snprintf((char *) prefix, sizeof(prefix), "default%d", counter++);
+	else
+	    snprintf((char *) prefix, sizeof(prefix), "%.20s%d", ns->prefix, counter++);
+	def = xmlSearchNs(doc, tree, prefix);
+    }
+
+    /*
+     * OK, now we are ready to create a new one.
+     */
+    def = xmlNewNs(tree, ns->href, prefix);
+    return(def);
+}
+
+#ifdef LIBXML_TREE_ENABLED
+/**
+ * xmlReconciliateNs:
+ * @doc:  the document
+ * @tree:  a node defining the subtree to reconciliate
+ *
+ * This function checks that all the namespaces declared within the given
+ * tree are properly declared. This is needed for example after Copy or Cut
+ * and then paste operations. The subtree may still hold pointers to
+ * namespace declarations outside the subtree or invalid/masked. As much
+ * as possible the function try to reuse the existing namespaces found in
+ * the new environment. If not possible the new namespaces are redeclared
+ * on @tree at the top of the given subtree.
+ * Returns the number of namespace declarations created or -1 in case of error.
+ */
+int
+xmlReconciliateNs(xmlDocPtr doc, xmlNodePtr tree) {
+    xmlNsPtr *oldNs = NULL;
+    xmlNsPtr *newNs = NULL;
+    int sizeCache = 0;
+    int nbCache = 0;
+
+    xmlNsPtr n;
+    xmlNodePtr node = tree;
+    xmlAttrPtr attr;
+    int ret = 0, i;
+
+    while (node != NULL) {
+        /*
+	 * Reconciliate the node namespace
+	 */
+	if (node->ns != NULL) {
+	    /*
+	     * initialize the cache if needed
+	     */
+	    if (sizeCache == 0) {
+		sizeCache = 10;
+		oldNs = (xmlNsPtr *) xmlMalloc(sizeCache *
+					       sizeof(xmlNsPtr));
+		if (oldNs == NULL) {
+		    xmlTreeErrMemory("fixing namespaces");
+		    return(-1);
+		}
+		newNs = (xmlNsPtr *) xmlMalloc(sizeCache *
+					       sizeof(xmlNsPtr));
+		if (newNs == NULL) {
+		    xmlTreeErrMemory("fixing namespaces");
+		    xmlFree(oldNs);
+		    return(-1);
+		}
+	    }
+	    for (i = 0;i < nbCache;i++) {
+	        if (oldNs[i] == node->ns) {
+		    node->ns = newNs[i];
+		    break;
+		}
+	    }
+	    if (i == nbCache) {
+	        /*
+		 * OK we need to recreate a new namespace definition
+		 */
+		n = xmlNewReconciliedNs(doc, tree, node->ns);
+		if (n != NULL) { /* :-( what if else ??? */
+		    /*
+		     * check if we need to grow the cache buffers.
+		     */
+		    if (sizeCache <= nbCache) {
+		        sizeCache *= 2;
+			oldNs = (xmlNsPtr *) xmlRealloc(oldNs, sizeCache *
+			                               sizeof(xmlNsPtr));
+		        if (oldNs == NULL) {
+			    xmlTreeErrMemory("fixing namespaces");
+			    xmlFree(newNs);
+			    return(-1);
+			}
+			newNs = (xmlNsPtr *) xmlRealloc(newNs, sizeCache *
+			                               sizeof(xmlNsPtr));
+		        if (newNs == NULL) {
+			    xmlTreeErrMemory("fixing namespaces");
+			    xmlFree(oldNs);
+			    return(-1);
+			}
+		    }
+		    newNs[nbCache] = n;
+		    oldNs[nbCache++] = node->ns;
+		    node->ns = n;
+                }
+	    }
+	}
+	/*
+	 * now check for namespace hold by attributes on the node.
+	 */
+	attr = node->properties;
+	while (attr != NULL) {
+	    if (attr->ns != NULL) {
+		/*
+		 * initialize the cache if needed
+		 */
+		if (sizeCache == 0) {
+		    sizeCache = 10;
+		    oldNs = (xmlNsPtr *) xmlMalloc(sizeCache *
+						   sizeof(xmlNsPtr));
+		    if (oldNs == NULL) {
+			xmlTreeErrMemory("fixing namespaces");
+			return(-1);
+		    }
+		    newNs = (xmlNsPtr *) xmlMalloc(sizeCache *
+						   sizeof(xmlNsPtr));
+		    if (newNs == NULL) {
+			xmlTreeErrMemory("fixing namespaces");
+			xmlFree(oldNs);
+			return(-1);
+		    }
+		}
+		for (i = 0;i < nbCache;i++) {
+		    if (oldNs[i] == attr->ns) {
+			attr->ns = newNs[i];
+			break;
+		    }
+		}
+		if (i == nbCache) {
+		    /*
+		     * OK we need to recreate a new namespace definition
+		     */
+		    n = xmlNewReconciliedNs(doc, tree, attr->ns);
+		    if (n != NULL) { /* :-( what if else ??? */
+			/*
+			 * check if we need to grow the cache buffers.
+			 */
+			if (sizeCache <= nbCache) {
+			    sizeCache *= 2;
+			    oldNs = (xmlNsPtr *) xmlRealloc(oldNs, sizeCache *
+							   sizeof(xmlNsPtr));
+			    if (oldNs == NULL) {
+				xmlTreeErrMemory("fixing namespaces");
+				xmlFree(newNs);
+				return(-1);
+			    }
+			    newNs = (xmlNsPtr *) xmlRealloc(newNs, sizeCache *
+							   sizeof(xmlNsPtr));
+			    if (newNs == NULL) {
+				xmlTreeErrMemory("fixing namespaces");
+				xmlFree(oldNs);
+				return(-1);
+			    }
+			}
+			newNs[nbCache] = n;
+			oldNs[nbCache++] = attr->ns;
+			attr->ns = n;
+		    }
+		}
+	    }
+	    attr = attr->next;
+	}
+
+	/*
+	 * Browse the full subtree, deep first
+	 */
+        if (node->children != NULL) {
+	    /* deep first */
+	    node = node->children;
+	} else if ((node != tree) && (node->next != NULL)) {
+	    /* then siblings */
+	    node = node->next;
+	} else if (node != tree) {
+	    /* go up to parents->next if needed */
+	    while (node != tree) {
+	        if (node->parent != NULL)
+		    node = node->parent;
+		if ((node != tree) && (node->next != NULL)) {
+		    node = node->next;
+		    break;
+		}
+		if (node->parent == NULL) {
+		    node = NULL;
+		    break;
+		}
+	    }
+	    /* exit condition */
+	    if (node == tree) 
+	        node = NULL;
+	} else
+	    break;
+    }
+    if (oldNs != NULL)
+	xmlFree(oldNs);
+    if (newNs != NULL)
+	xmlFree(newNs);
+    return(ret);
+}
+#endif /* LIBXML_TREE_ENABLED */
+
+/**
+ * xmlHasProp:
+ * @node:  the node
+ * @name:  the attribute name
+ *
+ * Search an attribute associated to a node
+ * This function also looks in DTD attribute declaration for #FIXED or
+ * default declaration values unless DTD use has been turned off.
+ *
+ * Returns the attribute or the attribute declaration or NULL if 
+ *         neither was found.
+ */
+xmlAttrPtr
+xmlHasProp(xmlNodePtr node, const xmlChar *name) {
+    xmlAttrPtr prop;
+    xmlDocPtr doc;
+
+    if ((node == NULL) || (name == NULL)) return(NULL);
+    /*
+     * Check on the properties attached to the node
+     */
+    prop = node->properties;
+    while (prop != NULL) {
+        if (xmlStrEqual(prop->name, name))  {
+	    return(prop);
+        }
+	prop = prop->next;
+    }
+    if (!xmlCheckDTD) return(NULL);
+
+    /*
+     * Check if there is a default declaration in the internal
+     * or external subsets
+     */
+    doc =  node->doc;
+    if (doc != NULL) {
+        xmlAttributePtr attrDecl;
+        if (doc->intSubset != NULL) {
+	    attrDecl = xmlGetDtdAttrDesc(doc->intSubset, node->name, name);
+	    if ((attrDecl == NULL) && (doc->extSubset != NULL))
+		attrDecl = xmlGetDtdAttrDesc(doc->extSubset, node->name, name);
+            if ((attrDecl != NULL) && (attrDecl->defaultValue != NULL))
+              /* return attribute declaration only if a default value is given
+                 (that includes #FIXED declarations) */
+		return((xmlAttrPtr) attrDecl);
+	}
+    }
+    return(NULL);
+}
+
+/**
+ * xmlHasNsProp:
+ * @node:  the node
+ * @name:  the attribute name
+ * @nameSpace:  the URI of the namespace
+ *
+ * Search for an attribute associated to a node
+ * This attribute has to be anchored in the namespace specified.
+ * This does the entity substitution.
+ * This function looks in DTD attribute declaration for #FIXED or
+ * default declaration values unless DTD use has been turned off.
+ *
+ * Returns the attribute or the attribute declaration or NULL
+ *     if neither was found.
+ */
+xmlAttrPtr
+xmlHasNsProp(xmlNodePtr node, const xmlChar *name, const xmlChar *nameSpace) {
+    xmlAttrPtr prop;
+#ifdef LIBXML_TREE_ENABLED
+    xmlDocPtr doc;
+#endif /* LIBXML_TREE_ENABLED */
+
+    if (node == NULL)
+	return(NULL);
+
+    prop = node->properties;
+    if (nameSpace == NULL)
+	return(xmlHasProp(node, name));
+    while (prop != NULL) {
+	/*
+	 * One need to have
+	 *   - same attribute names
+	 *   - and the attribute carrying that namespace
+	 */
+        if ((xmlStrEqual(prop->name, name)) &&
+	    ((prop->ns != NULL) && (xmlStrEqual(prop->ns->href, nameSpace)))) {
+	    return(prop);
+        }
+	prop = prop->next;
+    }
+    if (!xmlCheckDTD) return(NULL);
+
+#ifdef LIBXML_TREE_ENABLED
+    /*
+     * Check if there is a default declaration in the internal
+     * or external subsets
+     */
+    doc =  node->doc;
+    if (doc != NULL) {
+        if (doc->intSubset != NULL) {
+	    xmlAttributePtr attrDecl = NULL;
+	    xmlNsPtr *nsList, *cur;
+	    xmlChar *ename;
+
+	    nsList = xmlGetNsList(node->doc, node);
+	    if (nsList == NULL)
+		return(NULL);
+	    if ((node->ns != NULL) && (node->ns->prefix != NULL)) {
+		ename = xmlStrdup(node->ns->prefix);
+		ename = xmlStrcat(ename, BAD_CAST ":");
+		ename = xmlStrcat(ename, node->name);
+	    } else {
+		ename = xmlStrdup(node->name);
+	    }
+	    if (ename == NULL) {
+		xmlFree(nsList);
+		return(NULL);
+	    }
+
+	    cur = nsList;
+	    while (*cur != NULL) {
+		if (xmlStrEqual((*cur)->href, nameSpace)) {
+		    attrDecl = xmlGetDtdQAttrDesc(doc->intSubset, ename,
+			                          name, (*cur)->prefix);
+		    if ((attrDecl == NULL) && (doc->extSubset != NULL))
+			attrDecl = xmlGetDtdQAttrDesc(doc->extSubset, ename,
+						      name, (*cur)->prefix);
+		}
+		cur++;
+	    }
+	    xmlFree(nsList);
+	    xmlFree(ename);
+	    return((xmlAttrPtr) attrDecl);
+	}
+    }
+#endif /* LIBXML_TREE_ENABLED */
+    return(NULL);
+}
+
+/**
+ * xmlGetProp:
+ * @node:  the node
+ * @name:  the attribute name
+ *
+ * Search and get the value of an attribute associated to a node
+ * This does the entity substitution.
+ * This function looks in DTD attribute declaration for #FIXED or
+ * default declaration values unless DTD use has been turned off.
+ * NOTE: this function acts independently of namespaces associated
+ *       to the attribute. Use xmlGetNsProp() or xmlGetNoNsProp()
+ *       for namespace aware processing.
+ *
+ * Returns the attribute value or NULL if not found.
+ *     It's up to the caller to free the memory with xmlFree().
+ */
+xmlChar *
+xmlGetProp(xmlNodePtr node, const xmlChar *name) {
+    xmlAttrPtr prop;
+    xmlDocPtr doc;
+
+    if ((node == NULL) || (name == NULL)) return(NULL);
+    /*
+     * Check on the properties attached to the node
+     */
+    prop = node->properties;
+    while (prop != NULL) {
+        if (xmlStrEqual(prop->name, name))  {
+	    xmlChar *ret;
+
+	    ret = xmlNodeListGetString(node->doc, prop->children, 1);
+	    if (ret == NULL) return(xmlStrdup((xmlChar *)""));
+	    return(ret);
+        }
+	prop = prop->next;
+    }
+    if (!xmlCheckDTD) return(NULL);
+
+    /*
+     * Check if there is a default declaration in the internal
+     * or external subsets
+     */
+    doc =  node->doc;
+    if (doc != NULL) {
+        xmlAttributePtr attrDecl;
+        if (doc->intSubset != NULL) {
+	    attrDecl = xmlGetDtdAttrDesc(doc->intSubset, node->name, name);
+	    if ((attrDecl == NULL) && (doc->extSubset != NULL))
+		attrDecl = xmlGetDtdAttrDesc(doc->extSubset, node->name, name);
+            if ((attrDecl != NULL) && (attrDecl->defaultValue != NULL))
+              /* return attribute declaration only if a default value is given
+                 (that includes #FIXED declarations) */
+		return(xmlStrdup(attrDecl->defaultValue));
+	}
+    }
+    return(NULL);
+}
+
+/**
+ * xmlGetNoNsProp:
+ * @node:  the node
+ * @name:  the attribute name
+ *
+ * Search and get the value of an attribute associated to a node
+ * This does the entity substitution.
+ * This function looks in DTD attribute declaration for #FIXED or
+ * default declaration values unless DTD use has been turned off.
+ * This function is similar to xmlGetProp except it will accept only
+ * an attribute in no namespace.
+ *
+ * Returns the attribute value or NULL if not found.
+ *     It's up to the caller to free the memory with xmlFree().
+ */
+xmlChar *
+xmlGetNoNsProp(xmlNodePtr node, const xmlChar *name) {
+    xmlAttrPtr prop;
+    xmlDocPtr doc;
+
+    if ((node == NULL) || (name == NULL)) return(NULL);
+    /*
+     * Check on the properties attached to the node
+     */
+    prop = node->properties;
+    while (prop != NULL) {
+        if ((prop->ns == NULL) && (xmlStrEqual(prop->name, name)))  {
+	    xmlChar *ret;
+
+	    ret = xmlNodeListGetString(node->doc, prop->children, 1);
+	    if (ret == NULL) return(xmlStrdup((xmlChar *)""));
+	    return(ret);
+        }
+	prop = prop->next;
+    }
+    if (!xmlCheckDTD) return(NULL);
+
+    /*
+     * Check if there is a default declaration in the internal
+     * or external subsets
+     */
+    doc =  node->doc;
+    if (doc != NULL) {
+        xmlAttributePtr attrDecl;
+        if (doc->intSubset != NULL) {
+	    attrDecl = xmlGetDtdAttrDesc(doc->intSubset, node->name, name);
+	    if ((attrDecl == NULL) && (doc->extSubset != NULL))
+		attrDecl = xmlGetDtdAttrDesc(doc->extSubset, node->name, name);
+            if ((attrDecl != NULL) && (attrDecl->defaultValue != NULL))
+              /* return attribute declaration only if a default value is given
+                 (that includes #FIXED declarations) */
+		return(xmlStrdup(attrDecl->defaultValue));
+	}
+    }
+    return(NULL);
+}
+
+/**
+ * xmlGetNsProp:
+ * @node:  the node
+ * @name:  the attribute name
+ * @nameSpace:  the URI of the namespace
+ *
+ * Search and get the value of an attribute associated to a node
+ * This attribute has to be anchored in the namespace specified.
+ * This does the entity substitution.
+ * This function looks in DTD attribute declaration for #FIXED or
+ * default declaration values unless DTD use has been turned off.
+ *
+ * Returns the attribute value or NULL if not found.
+ *     It's up to the caller to free the memory with xmlFree().
+ */
+xmlChar *
+xmlGetNsProp(xmlNodePtr node, const xmlChar *name, const xmlChar *nameSpace) {
+    xmlAttrPtr prop;
+    xmlDocPtr doc;
+    xmlNsPtr ns;
+
+    if (node == NULL)
+	return(NULL);
+
+    prop = node->properties;
+    if (nameSpace == NULL)
+	return(xmlGetNoNsProp(node, name));
+    while (prop != NULL) {
+	/*
+	 * One need to have
+	 *   - same attribute names
+	 *   - and the attribute carrying that namespace
+	 */
+        if ((xmlStrEqual(prop->name, name)) &&
+	    ((prop->ns != NULL) &&
+	     (xmlStrEqual(prop->ns->href, nameSpace)))) {
+	    xmlChar *ret;
+
+	    ret = xmlNodeListGetString(node->doc, prop->children, 1);
+	    if (ret == NULL) return(xmlStrdup((xmlChar *)""));
+	    return(ret);
+        }
+	prop = prop->next;
+    }
+    if (!xmlCheckDTD) return(NULL);
+
+    /*
+     * Check if there is a default declaration in the internal
+     * or external subsets
+     */
+    doc =  node->doc;
+    if (doc != NULL) {
+        if (doc->intSubset != NULL) {
+	    xmlAttributePtr attrDecl;
+
+	    attrDecl = xmlGetDtdAttrDesc(doc->intSubset, node->name, name);
+	    if ((attrDecl == NULL) && (doc->extSubset != NULL))
+		attrDecl = xmlGetDtdAttrDesc(doc->extSubset, node->name, name);
+		
+	    if ((attrDecl != NULL) && (attrDecl->prefix != NULL)) {
+	        /*
+		 * The DTD declaration only allows a prefix search
+		 */
+		ns = xmlSearchNs(doc, node, attrDecl->prefix);
+		if ((ns != NULL) && (xmlStrEqual(ns->href, nameSpace)))
+		    return(xmlStrdup(attrDecl->defaultValue));
+	    }
+	}
+    }
+    return(NULL);
+}
+
+#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
+/**
+ * xmlUnsetProp:
+ * @node:  the node
+ * @name:  the attribute name
+ *
+ * Remove an attribute carried by a node.
+ * Returns 0 if successful, -1 if not found
+ */
+int
+xmlUnsetProp(xmlNodePtr node, const xmlChar *name) {
+    xmlAttrPtr prop, prev = NULL;;
+
+    if ((node == NULL) || (name == NULL))
+	return(-1);
+    prop = node->properties;
+    while (prop != NULL) {
+        if ((xmlStrEqual(prop->name, name)) &&
+	    (prop->ns == NULL)) {
+	    if (prev == NULL)
+		node->properties = prop->next;
+	    else
+		prev->next = prop->next;
+	    xmlFreeProp(prop);
+	    return(0);
+	}
+	prev = prop;
+	prop = prop->next;
+    }
+    return(-1);
+}
+
+/**
+ * xmlUnsetNsProp:
+ * @node:  the node
+ * @ns:  the namespace definition
+ * @name:  the attribute name
+ *
+ * Remove an attribute carried by a node.
+ * Returns 0 if successful, -1 if not found
+ */
+int
+xmlUnsetNsProp(xmlNodePtr node, xmlNsPtr ns, const xmlChar *name) {
+    xmlAttrPtr prop = node->properties, prev = NULL;;
+
+    if ((node == NULL) || (name == NULL))
+	return(-1);
+    if (ns == NULL)
+	return(xmlUnsetProp(node, name));
+    if (ns->href == NULL)
+	return(-1);
+    while (prop != NULL) {
+        if ((xmlStrEqual(prop->name, name)) &&
+	    (prop->ns != NULL) && (xmlStrEqual(prop->ns->href, ns->href))) {
+	    if (prev == NULL)
+		node->properties = prop->next;
+	    else
+		prev->next = prop->next;
+	    xmlFreeProp(prop);
+	    return(0);
+	}
+	prev = prop;
+	prop = prop->next;
+    }
+    return(-1);
+}
+#endif
+
+#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_HTML_ENABLED)
+/**
+ * xmlSetProp:
+ * @node:  the node
+ * @name:  the attribute name
+ * @value:  the attribute value
+ *
+ * Set (or reset) an attribute carried by a node.
+ * Returns the attribute pointer.
+ */
+xmlAttrPtr
+xmlSetProp(xmlNodePtr node, const xmlChar *name, const xmlChar *value) {
+    xmlAttrPtr prop;
+    xmlDocPtr doc;
+
+    if ((node == NULL) || (name == NULL) || (node->type != XML_ELEMENT_NODE))
+	return(NULL);
+    doc = node->doc;
+    prop = node->properties;
+    while (prop != NULL) {
+        if ((xmlStrEqual(prop->name, name)) &&
+	    (prop->ns == NULL)){
+	    xmlNodePtr oldprop = prop->children;
+
+	    prop->children = NULL;
+	    prop->last = NULL;
+	    if (value != NULL) {
+	        xmlChar *buffer;
+		xmlNodePtr tmp;
+
+		buffer = xmlEncodeEntitiesReentrant(node->doc, value);
+		prop->children = xmlStringGetNodeList(node->doc, buffer);
+		prop->last = NULL;
+		prop->doc = doc;
+		tmp = prop->children;
+		while (tmp != NULL) {
+		    tmp->parent = (xmlNodePtr) prop;
+		    tmp->doc = doc;
+		    if (tmp->next == NULL)
+			prop->last = tmp;
+		    tmp = tmp->next;
+		}
+		xmlFree(buffer);
+	    }
+	    if (oldprop != NULL) 
+	        xmlFreeNodeList(oldprop);
+	    return(prop);
+	}
+	prop = prop->next;
+    }
+    prop = xmlNewProp(node, name, value);
+    return(prop);
+}
+
+/**
+ * xmlSetNsProp:
+ * @node:  the node
+ * @ns:  the namespace definition
+ * @name:  the attribute name
+ * @value:  the attribute value
+ *
+ * Set (or reset) an attribute carried by a node.
+ * The ns structure must be in scope, this is not checked.
+ *
+ * Returns the attribute pointer.
+ */
+xmlAttrPtr
+xmlSetNsProp(xmlNodePtr node, xmlNsPtr ns, const xmlChar *name,
+	     const xmlChar *value) {
+    xmlAttrPtr prop;
+    
+    if ((node == NULL) || (name == NULL))
+	return(NULL);
+
+    if (ns == NULL)
+	return(xmlSetProp(node, name, value));
+    if (ns->href == NULL)
+	return(NULL);
+    prop = node->properties;
+
+    while (prop != NULL) {
+	/*
+	 * One need to have
+	 *   - same attribute names
+	 *   - and the attribute carrying that namespace
+	 */
+        if ((xmlStrEqual(prop->name, name)) &&
+	    (prop->ns != NULL) && (xmlStrEqual(prop->ns->href, ns->href))) {
+	    if (prop->children != NULL) 
+	        xmlFreeNodeList(prop->children);
+	    prop->children = NULL;
+	    prop->last = NULL;
+	    prop->ns = ns;
+	    if (value != NULL) {
+	        xmlChar *buffer;
+		xmlNodePtr tmp;
+
+		buffer = xmlEncodeEntitiesReentrant(node->doc, value);
+		prop->children = xmlStringGetNodeList(node->doc, buffer);
+		prop->last = NULL;
+		tmp = prop->children;
+		while (tmp != NULL) {
+		    tmp->parent = (xmlNodePtr) prop;
+		    if (tmp->next == NULL)
+			prop->last = tmp;
+		    tmp = tmp->next;
+		}
+		xmlFree(buffer);
+	    }	
+	    return(prop);
+        }
+	prop = prop->next;
+    }
+    prop = xmlNewNsProp(node, ns, name, value);
+    return(prop);
+}
+
+#endif /* LIBXML_TREE_ENABLED */
+
+/**
+ * xmlNodeIsText:
+ * @node:  the node
+ * 
+ * Is this node a Text node ?
+ * Returns 1 yes, 0 no
+ */
+int
+xmlNodeIsText(xmlNodePtr node) {
+    if (node == NULL) return(0);
+
+    if (node->type == XML_TEXT_NODE) return(1);
+    return(0);
+}
+
+/**
+ * xmlIsBlankNode:
+ * @node:  the node
+ * 
+ * Checks whether this node is an empty or whitespace only
+ * (and possibly ignorable) text-node.
+ *
+ * Returns 1 yes, 0 no
+ */
+int
+xmlIsBlankNode(xmlNodePtr node) {
+    const xmlChar *cur;
+    if (node == NULL) return(0);
+
+    if ((node->type != XML_TEXT_NODE) &&
+        (node->type != XML_CDATA_SECTION_NODE))
+	return(0);
+    if (node->content == NULL) return(1);
+    cur = node->content;
+    while (*cur != 0) {
+	if (!IS_BLANK_CH(*cur)) return(0);
+	cur++;
+    }
+
+    return(1);
+}
+
+/**
+ * xmlTextConcat:
+ * @node:  the node
+ * @content:  the content
+ * @len:  @content length
+ * 
+ * Concat the given string at the end of the existing node content
+ *
+ * Returns -1 in case of error, 0 otherwise
+ */
+
+int
+xmlTextConcat(xmlNodePtr node, const xmlChar *content, int len) {
+    if (node == NULL) return(-1);
+
+    if ((node->type != XML_TEXT_NODE) &&
+        (node->type != XML_CDATA_SECTION_NODE)) {
+#ifdef DEBUG_TREE
+	xmlGenericError(xmlGenericErrorContext,
+		"xmlTextConcat: node is not text nor CDATA\n");
+#endif
+        return(-1);
+    }
+    /* need to check if content is currently in the dictionary */
+    if ((node->doc != NULL) && (node->doc->dict != NULL) &&
+		xmlDictOwns(node->doc->dict, node->content)) {
+	node->content = xmlStrncatNew(node->content, content, len);
+    } else {
+        node->content = xmlStrncat(node->content, content, len);
+    }
+    if (node->content == NULL)
+        return(-1);
+    return(0);
+}
+
+/************************************************************************
+ *									*
+ *			Output : to a FILE or in memory			*
+ *									*
+ ************************************************************************/
+
+/**
+ * xmlBufferCreate:
+ *
+ * routine to create an XML buffer.
+ * returns the new structure.
+ */
+xmlBufferPtr
+xmlBufferCreate(void) {
+    xmlBufferPtr ret;
+
+    ret = (xmlBufferPtr) xmlMalloc(sizeof(xmlBuffer));
+    if (ret == NULL) {
+	xmlTreeErrMemory("creating buffer");
+        return(NULL);
+    }
+    ret->use = 0;
+    ret->size = xmlDefaultBufferSize;
+    ret->alloc = xmlBufferAllocScheme;
+    ret->content = (xmlChar *) xmlMallocAtomic(ret->size * sizeof(xmlChar));
+    if (ret->content == NULL) {
+	xmlTreeErrMemory("creating buffer");
+	xmlFree(ret);
+        return(NULL);
+    }
+    ret->content[0] = 0;
+    return(ret);
+}
+
+/**
+ * xmlBufferCreateSize:
+ * @size: initial size of buffer
+ *
+ * routine to create an XML buffer.
+ * returns the new structure.
+ */
+xmlBufferPtr
+xmlBufferCreateSize(size_t size) {
+    xmlBufferPtr ret;
+
+    ret = (xmlBufferPtr) xmlMalloc(sizeof(xmlBuffer));
+    if (ret == NULL) {
+	xmlTreeErrMemory("creating buffer");
+        return(NULL);
+    }
+    ret->use = 0;
+    ret->alloc = xmlBufferAllocScheme;
+    ret->size = (size ? size+2 : 0);         /* +1 for ending null */
+    if (ret->size){
+        ret->content = (xmlChar *) xmlMallocAtomic(ret->size * sizeof(xmlChar));
+        if (ret->content == NULL) {
+	    xmlTreeErrMemory("creating buffer");
+            xmlFree(ret);
+            return(NULL);
+        }
+        ret->content[0] = 0;
+    } else
+	ret->content = NULL;
+    return(ret);
+}
+
+/**
+ * xmlBufferCreateStatic:
+ * @mem: the memory area
+ * @size:  the size in byte
+ *
+ * routine to create an XML buffer from an immutable memory area.
+ * The area won't be modified nor copied, and is expected to be
+ * present until the end of the buffer lifetime.
+ *
+ * returns the new structure.
+ */
+xmlBufferPtr
+xmlBufferCreateStatic(void *mem, size_t size) {
+    xmlBufferPtr ret;
+
+    if ((mem == NULL) || (size == 0))
+        return(NULL);
+
+    ret = (xmlBufferPtr) xmlMalloc(sizeof(xmlBuffer));
+    if (ret == NULL) {
+	xmlTreeErrMemory("creating buffer");
+        return(NULL);
+    }
+    ret->use = size;
+    ret->size = size;
+    ret->alloc = XML_BUFFER_ALLOC_IMMUTABLE;
+    ret->content = (xmlChar *) mem;
+    return(ret);
+}
+
+/**
+ * xmlBufferSetAllocationScheme:
+ * @buf:  the buffer to tune
+ * @scheme:  allocation scheme to use
+ *
+ * Sets the allocation scheme for this buffer
+ */
+void
+xmlBufferSetAllocationScheme(xmlBufferPtr buf, 
+                             xmlBufferAllocationScheme scheme) {
+    if (buf == NULL) {
+#ifdef DEBUG_BUFFER
+        xmlGenericError(xmlGenericErrorContext,
+		"xmlBufferSetAllocationScheme: buf == NULL\n");
+#endif
+        return;
+    }
+    if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE) return;
+
+    buf->alloc = scheme;
+}
+
+/**
+ * xmlBufferFree:
+ * @buf:  the buffer to free
+ *
+ * Frees an XML buffer. It frees both the content and the structure which
+ * encapsulate it.
+ */
+void
+xmlBufferFree(xmlBufferPtr buf) {
+    if (buf == NULL) {
+#ifdef DEBUG_BUFFER
+        xmlGenericError(xmlGenericErrorContext,
+		"xmlBufferFree: buf == NULL\n");
+#endif
+	return;
+    }
+
+    if ((buf->content != NULL) &&
+        (buf->alloc != XML_BUFFER_ALLOC_IMMUTABLE)) {
+        xmlFree(buf->content);
+    }
+    xmlFree(buf);
+}
+
+/**
+ * xmlBufferEmpty:
+ * @buf:  the buffer
+ *
+ * empty a buffer.
+ */
+void
+xmlBufferEmpty(xmlBufferPtr buf) {
+    if (buf->content == NULL) return;
+    buf->use = 0;
+    if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE) {
+        buf->content = BAD_CAST "";
+    } else {
+	memset(buf->content, 0, buf->size);
+    }
+}
+
+/**
+ * xmlBufferShrink:
+ * @buf:  the buffer to dump
+ * @len:  the number of xmlChar to remove
+ *
+ * Remove the beginning of an XML buffer.
+ *
+ * Returns the number of #xmlChar removed, or -1 in case of failure.
+ */
+int
+xmlBufferShrink(xmlBufferPtr buf, unsigned int len) {
+    if (len == 0) return(0);
+    if (len > buf->use) return(-1);
+
+    buf->use -= len;
+    if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE) {
+        buf->content += len;
+    } else {
+	memmove(buf->content, &buf->content[len], buf->use * sizeof(xmlChar));
+	buf->content[buf->use] = 0;
+    }
+    return(len);
+}
+
+/**
+ * xmlBufferGrow:
+ * @buf:  the buffer
+ * @len:  the minimum free size to allocate
+ *
+ * Grow the available space of an XML buffer.
+ *
+ * Returns the new available space or -1 in case of error
+ */
+int
+xmlBufferGrow(xmlBufferPtr buf, unsigned int len) {
+    int size;
+    xmlChar *newbuf;
+
+    if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE) return(0);
+    if (len + buf->use < buf->size) return(0);
+
+    size = buf->use + len + 100;
+
+    newbuf = (xmlChar *) xmlRealloc(buf->content, size);
+    if (newbuf == NULL) {
+	xmlTreeErrMemory("growing buffer");
+        return(-1);
+    }
+    buf->content = newbuf;
+    buf->size = size;
+    return(buf->size - buf->use);
+}
+
+/**
+ * xmlBufferDump:
+ * @file:  the file output
+ * @buf:  the buffer to dump
+ *
+ * Dumps an XML buffer to  a FILE *.
+ * Returns the number of #xmlChar written
+ */
+int
+xmlBufferDump(FILE *file, xmlBufferPtr buf) {
+    int ret;
+
+    if (buf == NULL) {
+#ifdef DEBUG_BUFFER
+        xmlGenericError(xmlGenericErrorContext,
+		"xmlBufferDump: buf == NULL\n");
+#endif
+	return(0);
+    }
+    if (buf->content == NULL) {
+#ifdef DEBUG_BUFFER
+        xmlGenericError(xmlGenericErrorContext,
+		"xmlBufferDump: buf->content == NULL\n");
+#endif
+	return(0);
+    }
+    if (file == NULL)
+	file = stdout;
+    ret = fwrite(buf->content, sizeof(xmlChar), buf->use, file);
+    return(ret);
+}
+
+/**
+ * xmlBufferContent:
+ * @buf:  the buffer
+ *
+ * Function to extract the content of a buffer
+ *
+ * Returns the internal content
+ */
+
+const xmlChar *
+xmlBufferContent(const xmlBufferPtr buf)
+{
+    if(!buf)
+        return NULL;
+
+    return buf->content;
+}
+
+/**
+ * xmlBufferLength:
+ * @buf:  the buffer 
+ *
+ * Function to get the length of a buffer
+ *
+ * Returns the length of data in the internal content
+ */
+
+int
+xmlBufferLength(const xmlBufferPtr buf)
+{
+    if(!buf)
+        return 0;
+
+    return buf->use;
+}
+
+/**
+ * xmlBufferResize:
+ * @buf:  the buffer to resize
+ * @size:  the desired size
+ *
+ * Resize a buffer to accommodate minimum size of @size.
+ *
+ * Returns  0 in case of problems, 1 otherwise
+ */
+int
+xmlBufferResize(xmlBufferPtr buf, unsigned int size)
+{
+    unsigned int newSize;
+    xmlChar* rebuf = NULL;
+
+    if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE) return(0);
+
+    /*take care of empty case*/
+    newSize = (buf->size ? buf->size*2 : size);
+
+    /* Don't resize if we don't have to */
+    if (size < buf->size)
+        return 1;
+
+    /* figure out new size */
+    switch (buf->alloc){
+    case XML_BUFFER_ALLOC_DOUBLEIT:
+        while (size > newSize) newSize *= 2;
+        break;
+    case XML_BUFFER_ALLOC_EXACT:
+        newSize = size+10;
+        break;
+    default:
+        newSize = size+10;
+        break;
+    }
+
+    if (buf->content == NULL)
+	rebuf = (xmlChar *) xmlMallocAtomic(newSize * sizeof(xmlChar));
+    else if (buf->size - buf->use < 100) {
+	rebuf = (xmlChar *) xmlRealloc(buf->content, 
+				       newSize * sizeof(xmlChar));
+   } else {
+        /*
+	 * if we are reallocating a buffer far from being full, it's
+	 * better to make a new allocation and copy only the used range
+	 * and free the old one.
+	 */
+	rebuf = (xmlChar *) xmlMallocAtomic(newSize * sizeof(xmlChar));
+	if (rebuf != NULL) {
+	    memcpy(rebuf, buf->content, buf->use);
+	    xmlFree(buf->content);
+	}
+	rebuf[buf->use] = 0;
+    }
+    if (rebuf == NULL) {
+	xmlTreeErrMemory("growing buffer");
+        return 0;
+    }
+    buf->content = rebuf;
+    buf->size = newSize;
+
+    return 1;
+}
+
+/**
+ * xmlBufferAdd:
+ * @buf:  the buffer to dump
+ * @str:  the #xmlChar string
+ * @len:  the number of #xmlChar to add
+ *
+ * Add a string range to an XML buffer. if len == -1, the length of
+ * str is recomputed.
+ */
+void
+xmlBufferAdd(xmlBufferPtr buf, const xmlChar *str, int len) {
+    unsigned int needSize;
+
+    if (str == NULL) {
+#ifdef DEBUG_BUFFER
+        xmlGenericError(xmlGenericErrorContext,
+		"xmlBufferAdd: str == NULL\n");
+#endif
+	return;
+    }
+    if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE) return;
+    if (len < -1) {
+#ifdef DEBUG_BUFFER
+        xmlGenericError(xmlGenericErrorContext,
+		"xmlBufferAdd: len < 0\n");
+#endif
+	return;
+    }
+    if (len == 0) return;
+
+    if (len < 0)
+        len = xmlStrlen(str);
+
+    if (len <= 0) return;
+
+    needSize = buf->use + len + 2;
+    if (needSize > buf->size){
+        if (!xmlBufferResize(buf, needSize)){
+	    xmlTreeErrMemory("growing buffer");
+            return;
+        }
+    }
+
+    memmove(&buf->content[buf->use], str, len*sizeof(xmlChar));
+    buf->use += len;
+    buf->content[buf->use] = 0;
+}
+
+/**
+ * xmlBufferAddHead:
+ * @buf:  the buffer
+ * @str:  the #xmlChar string
+ * @len:  the number of #xmlChar to add
+ *
+ * Add a string range to the beginning of an XML buffer.
+ * if len == -1, the length of @str is recomputed.
+ */
+void
+xmlBufferAddHead(xmlBufferPtr buf, const xmlChar *str, int len) {
+    unsigned int needSize;
+
+    if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE) return;
+    if (str == NULL) {
+#ifdef DEBUG_BUFFER
+        xmlGenericError(xmlGenericErrorContext,
+		"xmlBufferAddHead: str == NULL\n");
+#endif
+	return;
+    }
+    if (len < -1) {
+#ifdef DEBUG_BUFFER
+        xmlGenericError(xmlGenericErrorContext,
+		"xmlBufferAddHead: len < 0\n");
+#endif
+	return;
+    }
+    if (len == 0) return;
+
+    if (len < 0)
+        len = xmlStrlen(str);
+
+    if (len <= 0) return;
+
+    needSize = buf->use + len + 2;
+    if (needSize > buf->size){
+        if (!xmlBufferResize(buf, needSize)){
+	    xmlTreeErrMemory("growing buffer");
+            return;
+        }
+    }
+
+    memmove(&buf->content[len], &buf->content[0], buf->use * sizeof(xmlChar));
+    memmove(&buf->content[0], str, len * sizeof(xmlChar));
+    buf->use += len;
+    buf->content[buf->use] = 0;
+}
+
+/**
+ * xmlBufferCat:
+ * @buf:  the buffer to dump
+ * @str:  the #xmlChar string
+ *
+ * Append a zero terminated string to an XML buffer.
+ */
+void
+xmlBufferCat(xmlBufferPtr buf, const xmlChar *str) {
+    if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE) return;
+    if (str != NULL)
+	xmlBufferAdd(buf, str, -1);
+}
+
+/**
+ * xmlBufferCCat:
+ * @buf:  the buffer to dump
+ * @str:  the C char string
+ *
+ * Append a zero terminated C string to an XML buffer.
+ */
+void
+xmlBufferCCat(xmlBufferPtr buf, const char *str) {
+    const char *cur;
+
+    if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE) return;
+    if (str == NULL) {
+#ifdef DEBUG_BUFFER
+        xmlGenericError(xmlGenericErrorContext,
+		"xmlBufferCCat: str == NULL\n");
+#endif
+	return;
+    }
+    for (cur = str;*cur != 0;cur++) {
+        if (buf->use  + 10 >= buf->size) {
+            if (!xmlBufferResize(buf, buf->use+10)){
+		xmlTreeErrMemory("growing buffer");
+                return;
+            }
+        }
+        buf->content[buf->use++] = *cur;
+    }
+    buf->content[buf->use] = 0;
+}
+
+/**
+ * xmlBufferWriteCHAR:
+ * @buf:  the XML buffer
+ * @string:  the string to add
+ *
+ * routine which manages and grows an output buffer. This one adds
+ * xmlChars at the end of the buffer.
+ */
+void
+xmlBufferWriteCHAR(xmlBufferPtr buf, const xmlChar *string) {
+    if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE) return;
+    xmlBufferCat(buf, string);
+}
+
+/**
+ * xmlBufferWriteChar:
+ * @buf:  the XML buffer output
+ * @string:  the string to add
+ *
+ * routine which manage and grows an output buffer. This one add
+ * C chars at the end of the array.
+ */
+void
+xmlBufferWriteChar(xmlBufferPtr buf, const char *string) {
+    if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE) return;
+    xmlBufferCCat(buf, string);
+}
+
+
+/**
+ * xmlBufferWriteQuotedString:
+ * @buf:  the XML buffer output
+ * @string:  the string to add
+ *
+ * routine which manage and grows an output buffer. This one writes
+ * a quoted or double quoted #xmlChar string, checking first if it holds
+ * quote or double-quotes internally
+ */
+void
+xmlBufferWriteQuotedString(xmlBufferPtr buf, const xmlChar *string) {
+    const xmlChar *cur, *base;
+    if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE) return;
+    if (xmlStrchr(string, '\"')) {
+        if (xmlStrchr(string, '\'')) {
+#ifdef DEBUG_BUFFER
+	    xmlGenericError(xmlGenericErrorContext,
+ "xmlBufferWriteQuotedString: string contains quote and double-quotes !\n");
+#endif
+	    xmlBufferCCat(buf, "\"");
+            base = cur = string;
+            while(*cur != 0){
+                if(*cur == '"'){
+                    if (base != cur)
+                        xmlBufferAdd(buf, base, cur - base);
+                    xmlBufferAdd(buf, BAD_CAST "&quot;", 6);
+                    cur++;
+                    base = cur;
+                }
+                else {
+                    cur++;
+                }
+            }
+            if (base != cur)
+                xmlBufferAdd(buf, base, cur - base);
+	    xmlBufferCCat(buf, "\"");
+	}
+        else{
+	    xmlBufferCCat(buf, "\'");
+            xmlBufferCat(buf, string);
+	    xmlBufferCCat(buf, "\'");
+        }
+    } else {
+        xmlBufferCCat(buf, "\"");
+        xmlBufferCat(buf, string);
+        xmlBufferCCat(buf, "\"");
+    }
+}
+
+
+/**
+ * xmlGetDocCompressMode:
+ * @doc:  the document
+ *
+ * get the compression ratio for a document, ZLIB based
+ * Returns 0 (uncompressed) to 9 (max compression)
+ */
+int
+xmlGetDocCompressMode (xmlDocPtr doc) {
+    if (doc == NULL) return(-1);
+    return(doc->compression);
+}
+
+/**
+ * xmlSetDocCompressMode:
+ * @doc:  the document
+ * @mode:  the compression ratio
+ *
+ * set the compression ratio for a document, ZLIB based
+ * Correct values: 0 (uncompressed) to 9 (max compression)
+ */
+void
+xmlSetDocCompressMode (xmlDocPtr doc, int mode) {
+    if (doc == NULL) return;
+    if (mode < 0) doc->compression = 0;
+    else if (mode > 9) doc->compression = 9;
+    else doc->compression = mode;
+}
+
+/**
+ * xmlGetCompressMode:
+ *
+ * get the default compression mode used, ZLIB based.
+ * Returns 0 (uncompressed) to 9 (max compression)
+ */
+int
+xmlGetCompressMode(void)
+{
+    return (xmlCompressMode);
+}
+
+/**
+ * xmlSetCompressMode:
+ * @mode:  the compression ratio
+ *
+ * set the default compression mode used, ZLIB based
+ * Correct values: 0 (uncompressed) to 9 (max compression)
+ */
+void
+xmlSetCompressMode(int mode) {
+    if (mode < 0) xmlCompressMode = 0;
+    else if (mode > 9) xmlCompressMode = 9;
+    else xmlCompressMode = mode;
+}
+
diff --git a/src/libxml/src/trio.c b/src/libxml/src/trio.c
new file mode 100644
index 0000000..a36b5ee
--- /dev/null
+++ b/src/libxml/src/trio.c
@@ -0,0 +1,6855 @@
+/*************************************************************************
+ *
+ * $Id: trio.c,v 1.1 2008/11/12 02:25:23 agibert Exp $
+ *
+ * Copyright (C) 1998 Bjorn Reese and Daniel Stenberg.
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
+ * MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE AUTHORS AND
+ * CONTRIBUTORS ACCEPT NO RESPONSIBILITY IN ANY CONCEIVABLE MANNER.
+ *
+ *************************************************************************
+ *
+ * A note to trio contributors:
+ *
+ * Avoid heap allocation at all costs to ensure that the trio functions
+ * are async-safe. The exceptions are the printf/fprintf functions, which
+ * uses fputc, and the asprintf functions and the <alloc> modifier, which
+ * by design are required to allocate form the heap.
+ *
+ ************************************************************************/
+
+/*
+ * TODO:
+ *  - Scan is probably too permissive about its modifiers.
+ *  - C escapes in %#[] ?
+ *  - Multibyte characters (done for format parsing, except scan groups)
+ *  - Complex numbers? (C99 _Complex)
+ *  - Boolean values? (C99 _Bool)
+ *  - C99 NaN(n-char-sequence) missing. The n-char-sequence can be used
+ *    to print the mantissa, e.g. NaN(0xc000000000000000)
+ *  - Should we support the GNU %a alloc modifier? GNU has an ugly hack
+ *    for %a, because C99 used %a for other purposes. If specified as
+ *    %as or %a[ it is interpreted as the alloc modifier, otherwise as
+ *    the C99 hex-float. This means that you cannot scan %as as a hex-float
+ *    immediately followed by an 's'.
+ *  - Scanning of collating symbols.
+ */
+
+/*************************************************************************
+ * Trio include files
+ */
+#include "triodef.h"
+#include "trio.h"
+#include "triop.h"
+#include "trionan.h"
+#if !defined(TRIO_MINIMAL)
+# include "triostr.h"
+#endif
+
+/**************************************************************************
+ *
+ * Definitions
+ *
+ *************************************************************************/
+
+#include <math.h>
+#include <limits.h>
+#include <float.h>
+
+#if defined(__STDC_ISO_10646__) || defined(MB_LEN_MAX) || defined(USE_MULTIBYTE) || TRIO_WIDECHAR
+# define TRIO_COMPILER_SUPPORTS_MULTIBYTE
+# if !defined(MB_LEN_MAX)
+#  define MB_LEN_MAX 6
+# endif
+#endif
+
+#if (defined(TRIO_COMPILER_MSVC) && (_MSC_VER >= 1100)) || defined(TRIO_COMPILER_BCB)
+# define TRIO_COMPILER_SUPPORTS_MSVC_INT
+#endif
+
+/*************************************************************************
+ * Generic definitions
+ */
+
+#if !(defined(DEBUG) || defined(NDEBUG))
+# define NDEBUG
+#endif
+
+#include <assert.h>
+#include <ctype.h>
+#if !defined(TRIO_COMPILER_SUPPORTS_C99)
+# define isblank(x) (((x)==32) || ((x)==9))
+#endif
+#if defined(TRIO_COMPILER_ANCIENT)
+# include <varargs.h>
+#else
+# include <stdarg.h>
+#endif
+#include <stddef.h>
+#include <errno.h>
+
+#ifndef NULL
+# define NULL 0
+#endif
+#define NIL ((char)0)
+#ifndef FALSE
+# define FALSE (1 == 0)
+# define TRUE (! FALSE)
+#endif
+#define BOOLEAN_T int
+
+/* mincore() can be used for debugging purposes */
+#define VALID(x) (NULL != (x))
+
+#if TRIO_ERRORS
+  /*
+   * Encode the error code and the position. This is decoded
+   * with TRIO_ERROR_CODE and TRIO_ERROR_POSITION.
+   */
+# define TRIO_ERROR_RETURN(x,y) (- ((x) + ((y) << 8)))
+#else
+# define TRIO_ERROR_RETURN(x,y) (-1)
+#endif
+
+typedef unsigned long trio_flags_t;
+
+
+/*************************************************************************
+ * Platform specific definitions
+ */
+#if defined(TRIO_PLATFORM_UNIX)
+# include <unistd.h>
+# include <signal.h>
+# include <locale.h>
+# define USE_LOCALE
+#endif /* TRIO_PLATFORM_UNIX */
+#if defined(TRIO_PLATFORM_VMS)
+# include <unistd.h>
+#endif
+#if defined(TRIO_PLATFORM_WIN32)
+# include <io.h>
+# define read _read
+# define write _write
+#endif /* TRIO_PLATFORM_WIN32 */
+
+#if TRIO_WIDECHAR
+# if defined(TRIO_COMPILER_SUPPORTS_ISO94)
+#  include <wchar.h>
+#  include <wctype.h>
+typedef wchar_t trio_wchar_t;
+typedef wint_t trio_wint_t;
+# else
+typedef char trio_wchar_t;
+typedef int trio_wint_t;
+#  define WCONST(x) L ## x
+#  define WEOF EOF
+#  define iswalnum(x) isalnum(x)
+#  define iswalpha(x) isalpha(x)
+#  define iswblank(x) isblank(x)
+#  define iswcntrl(x) iscntrl(x)
+#  define iswdigit(x) isdigit(x)
+#  define iswgraph(x) isgraph(x)
+#  define iswlower(x) islower(x)
+#  define iswprint(x) isprint(x)
+#  define iswpunct(x) ispunct(x)
+#  define iswspace(x) isspace(x)
+#  define iswupper(x) isupper(x)
+#  define iswxdigit(x) isxdigit(x)
+# endif
+#endif
+
+
+/*************************************************************************
+ * Compiler dependent definitions
+ */
+
+/* Support for long long */
+#ifndef __cplusplus
+# if !defined(USE_LONGLONG)
+#  if defined(TRIO_COMPILER_GCC) && !defined(__STRICT_ANSI__)
+#   define USE_LONGLONG
+#  elif defined(TRIO_COMPILER_SUNPRO)
+#   define USE_LONGLONG
+#  elif defined(_LONG_LONG) || defined(_LONGLONG)
+#   define USE_LONGLONG
+#  endif
+# endif
+#endif
+
+/* The extra long numbers */
+#if defined(USE_LONGLONG)
+typedef signed long long int trio_longlong_t;
+typedef unsigned long long int trio_ulonglong_t;
+#elif defined(TRIO_COMPILER_SUPPORTS_MSVC_INT)
+typedef signed __int64 trio_longlong_t;
+typedef unsigned __int64 trio_ulonglong_t;
+#else
+typedef TRIO_SIGNED long int trio_longlong_t;
+typedef unsigned long int trio_ulonglong_t;
+#endif
+
+/* Maximal and fixed integer types */
+#if defined(TRIO_COMPILER_SUPPORTS_C99)
+# include <stdint.h>
+typedef intmax_t trio_intmax_t;
+typedef uintmax_t trio_uintmax_t;
+typedef int8_t trio_int8_t;
+typedef int16_t trio_int16_t;
+typedef int32_t trio_int32_t;
+typedef int64_t trio_int64_t;
+#elif defined(TRIO_COMPILER_SUPPORTS_UNIX98)
+# include <inttypes.h>
+typedef intmax_t trio_intmax_t;
+typedef uintmax_t trio_uintmax_t;
+typedef int8_t trio_int8_t;
+typedef int16_t trio_int16_t;
+typedef int32_t trio_int32_t;
+typedef int64_t trio_int64_t;
+#elif defined(TRIO_COMPILER_SUPPORTS_MSVC_INT)
+typedef trio_longlong_t trio_intmax_t;
+typedef trio_ulonglong_t trio_uintmax_t;
+typedef __int8 trio_int8_t;
+typedef __int16 trio_int16_t;
+typedef __int32 trio_int32_t;
+typedef __int64 trio_int64_t;
+#else
+typedef trio_longlong_t trio_intmax_t;
+typedef trio_ulonglong_t trio_uintmax_t;
+# if defined(TRIO_INT8_T)
+typedef TRIO_INT8_T trio_int8_t;
+# else
+typedef TRIO_SIGNED char trio_int8_t;
+# endif
+# if defined(TRIO_INT16_T)
+typedef TRIO_INT16_T trio_int16_t;
+# else
+typedef TRIO_SIGNED short trio_int16_t;
+# endif
+# if defined(TRIO_INT32_T)
+typedef TRIO_INT32_T trio_int32_t;
+# else
+typedef TRIO_SIGNED int trio_int32_t;
+# endif
+# if defined(TRIO_INT64_T)
+typedef TRIO_INT64_T trio_int64_t;
+# else
+typedef trio_longlong_t trio_int64_t;
+# endif
+#endif
+
+#if !(defined(TRIO_COMPILER_SUPPORTS_C99) \
+ || defined(TRIO_COMPILER_SUPPORTS_UNIX01))
+# define floorl(x) floor((double)(x))
+# define fmodl(x,y) fmod((double)(x),(double)(y))
+# define powl(x,y) pow((double)(x),(double)(y))
+#endif
+
+#define TRIO_FABS(x) (((x) < 0.0) ? -(x) : (x))
+
+/*************************************************************************
+ * Internal Definitions
+ */
+
+#ifndef DECIMAL_DIG
+# define DECIMAL_DIG DBL_DIG
+#endif
+
+/* Long double sizes */
+#ifdef LDBL_DIG
+# define MAX_MANTISSA_DIGITS LDBL_DIG
+# define MAX_EXPONENT_DIGITS 4
+# define MAX_DOUBLE_DIGITS LDBL_MAX_10_EXP
+#else
+# define MAX_MANTISSA_DIGITS DECIMAL_DIG
+# define MAX_EXPONENT_DIGITS 3
+# define MAX_DOUBLE_DIGITS DBL_MAX_10_EXP
+#endif
+
+#if defined(TRIO_COMPILER_ANCIENT) || !defined(LDBL_DIG)
+# undef LDBL_DIG
+# undef LDBL_MANT_DIG
+# undef LDBL_EPSILON
+# define LDBL_DIG DBL_DIG
+# define LDBL_MANT_DIG DBL_MANT_DIG
+# define LDBL_EPSILON DBL_EPSILON
+#endif
+
+/* The maximal number of digits is for base 2 */
+#define MAX_CHARS_IN(x) (sizeof(x) * CHAR_BIT)
+/* The width of a pointer. The number of bits in a hex digit is 4 */
+#define POINTER_WIDTH ((sizeof("0x") - 1) + sizeof(trio_pointer_t) * CHAR_BIT / 4)
+
+/* Infinite and Not-A-Number for floating-point */
+#define INFINITE_LOWER "inf"
+#define INFINITE_UPPER "INF"
+#define LONG_INFINITE_LOWER "infinite"
+#define LONG_INFINITE_UPPER "INFINITE"
+#define NAN_LOWER "nan"
+#define NAN_UPPER "NAN"
+
+/* Various constants */
+enum {
+  TYPE_PRINT = 1,
+  TYPE_SCAN  = 2,
+
+  /* Flags. FLAGS_LAST must be less than ULONG_MAX */
+  FLAGS_NEW                 = 0,
+  FLAGS_STICKY              = 1,
+  FLAGS_SPACE               = 2 * FLAGS_STICKY,
+  FLAGS_SHOWSIGN            = 2 * FLAGS_SPACE,
+  FLAGS_LEFTADJUST          = 2 * FLAGS_SHOWSIGN,
+  FLAGS_ALTERNATIVE         = 2 * FLAGS_LEFTADJUST,
+  FLAGS_SHORT               = 2 * FLAGS_ALTERNATIVE,
+  FLAGS_SHORTSHORT          = 2 * FLAGS_SHORT,
+  FLAGS_LONG                = 2 * FLAGS_SHORTSHORT,
+  FLAGS_QUAD                = 2 * FLAGS_LONG,
+  FLAGS_LONGDOUBLE          = 2 * FLAGS_QUAD,
+  FLAGS_SIZE_T              = 2 * FLAGS_LONGDOUBLE,
+  FLAGS_PTRDIFF_T           = 2 * FLAGS_SIZE_T,
+  FLAGS_INTMAX_T            = 2 * FLAGS_PTRDIFF_T,
+  FLAGS_NILPADDING          = 2 * FLAGS_INTMAX_T,
+  FLAGS_UNSIGNED            = 2 * FLAGS_NILPADDING,
+  FLAGS_UPPER               = 2 * FLAGS_UNSIGNED,
+  FLAGS_WIDTH               = 2 * FLAGS_UPPER,
+  FLAGS_WIDTH_PARAMETER     = 2 * FLAGS_WIDTH,
+  FLAGS_PRECISION           = 2 * FLAGS_WIDTH_PARAMETER,
+  FLAGS_PRECISION_PARAMETER = 2 * FLAGS_PRECISION,
+  FLAGS_BASE                = 2 * FLAGS_PRECISION_PARAMETER,
+  FLAGS_BASE_PARAMETER      = 2 * FLAGS_BASE,
+  FLAGS_FLOAT_E             = 2 * FLAGS_BASE_PARAMETER,
+  FLAGS_FLOAT_G             = 2 * FLAGS_FLOAT_E,
+  FLAGS_QUOTE               = 2 * FLAGS_FLOAT_G,
+  FLAGS_WIDECHAR            = 2 * FLAGS_QUOTE,
+  FLAGS_ALLOC               = 2 * FLAGS_WIDECHAR,
+  FLAGS_IGNORE              = 2 * FLAGS_ALLOC,
+  FLAGS_IGNORE_PARAMETER    = 2 * FLAGS_IGNORE,
+  FLAGS_VARSIZE_PARAMETER   = 2 * FLAGS_IGNORE_PARAMETER,
+  FLAGS_FIXED_SIZE          = 2 * FLAGS_VARSIZE_PARAMETER,
+  FLAGS_LAST                = FLAGS_FIXED_SIZE,
+  /* Reused flags */
+  FLAGS_EXCLUDE             = FLAGS_SHORT,
+  FLAGS_USER_DEFINED        = FLAGS_IGNORE,
+  FLAGS_ROUNDING            = FLAGS_INTMAX_T,
+  /* Compounded flags */
+  FLAGS_ALL_VARSIZES        = FLAGS_LONG | FLAGS_QUAD | FLAGS_INTMAX_T | FLAGS_PTRDIFF_T | FLAGS_SIZE_T,
+  FLAGS_ALL_SIZES           = FLAGS_ALL_VARSIZES | FLAGS_SHORTSHORT | FLAGS_SHORT,
+
+  NO_POSITION  = -1,
+  NO_WIDTH     =  0,
+  NO_PRECISION = -1,
+  NO_SIZE      = -1,
+
+  /* Do not change these */
+  NO_BASE      = -1,
+  MIN_BASE     =  2,
+  MAX_BASE     = 36,
+  BASE_BINARY  =  2,
+  BASE_OCTAL   =  8,
+  BASE_DECIMAL = 10,
+  BASE_HEX     = 16,
+
+  /* Maximal number of allowed parameters */
+  MAX_PARAMETERS = 64,
+  /* Maximal number of characters in class */
+  MAX_CHARACTER_CLASS = UCHAR_MAX + 1,
+
+  /* Maximal string lengths for user-defined specifiers */
+  MAX_USER_NAME = 64,
+  MAX_USER_DATA = 256,
+  
+  /* Maximal length of locale separator strings */
+  MAX_LOCALE_SEPARATOR_LENGTH = MB_LEN_MAX,
+  /* Maximal number of integers in grouping */
+  MAX_LOCALE_GROUPS = 64,
+
+  /* Initial size of asprintf buffer */
+  DYNAMIC_START_SIZE = 32
+};
+
+#define NO_GROUPING ((int)CHAR_MAX)
+
+/* Fundamental formatting parameter types */
+#define FORMAT_UNKNOWN   0
+#define FORMAT_INT       1
+#define FORMAT_DOUBLE    2
+#define FORMAT_CHAR      3
+#define FORMAT_STRING    4
+#define FORMAT_POINTER   5
+#define FORMAT_COUNT     6
+#define FORMAT_PARAMETER 7
+#define FORMAT_GROUP     8
+#if TRIO_GNU
+# define FORMAT_ERRNO    9
+#endif
+#if TRIO_EXTENSION
+# define FORMAT_USER_DEFINED 10
+#endif
+
+/* Character constants */
+#define CHAR_IDENTIFIER '%'
+#define CHAR_BACKSLASH '\\'
+#define CHAR_QUOTE '\"'
+#define CHAR_ADJUST ' '
+
+/* Character class expressions */
+#define CLASS_ALNUM "[:alnum:]"
+#define CLASS_ALPHA "[:alpha:]"
+#define CLASS_BLANK "[:blank:]"
+#define CLASS_CNTRL "[:cntrl:]"
+#define CLASS_DIGIT "[:digit:]"
+#define CLASS_GRAPH "[:graph:]"
+#define CLASS_LOWER "[:lower:]"
+#define CLASS_PRINT "[:print:]"
+#define CLASS_PUNCT "[:punct:]"
+#define CLASS_SPACE "[:space:]"
+#define CLASS_UPPER "[:upper:]"
+#define CLASS_XDIGIT "[:xdigit:]"
+
+/*
+ * SPECIFIERS:
+ *
+ *
+ * a  Hex-float
+ * A  Hex-float
+ * c  Character
+ * C  Widechar character (wint_t)
+ * d  Decimal
+ * e  Float
+ * E  Float
+ * F  Float
+ * F  Float
+ * g  Float
+ * G  Float
+ * i  Integer
+ * m  Error message
+ * n  Count
+ * o  Octal
+ * p  Pointer
+ * s  String
+ * S  Widechar string (wchar_t *)
+ * u  Unsigned
+ * x  Hex
+ * X  Hex
+ * [] Group
+ * <> User-defined
+ *
+ * Reserved:
+ *
+ * D  Binary Coded Decimal %D(length,precision) (OS/390)
+ */
+#define SPECIFIER_CHAR 'c'
+#define SPECIFIER_STRING 's'
+#define SPECIFIER_DECIMAL 'd'
+#define SPECIFIER_INTEGER 'i'
+#define SPECIFIER_UNSIGNED 'u'
+#define SPECIFIER_OCTAL 'o'
+#define SPECIFIER_HEX 'x'
+#define SPECIFIER_HEX_UPPER 'X'
+#define SPECIFIER_FLOAT_E 'e'
+#define SPECIFIER_FLOAT_E_UPPER 'E'
+#define SPECIFIER_FLOAT_F 'f'
+#define SPECIFIER_FLOAT_F_UPPER 'F'
+#define SPECIFIER_FLOAT_G 'g'
+#define SPECIFIER_FLOAT_G_UPPER 'G'
+#define SPECIFIER_POINTER 'p'
+#define SPECIFIER_GROUP '['
+#define SPECIFIER_UNGROUP ']'
+#define SPECIFIER_COUNT 'n'
+#if TRIO_UNIX98
+# define SPECIFIER_CHAR_UPPER 'C'
+# define SPECIFIER_STRING_UPPER 'S'
+#endif
+#if TRIO_C99
+# define SPECIFIER_HEXFLOAT 'a'
+# define SPECIFIER_HEXFLOAT_UPPER 'A'
+#endif
+#if TRIO_GNU
+# define SPECIFIER_ERRNO 'm'
+#endif
+#if TRIO_EXTENSION
+# define SPECIFIER_BINARY 'b'
+# define SPECIFIER_BINARY_UPPER 'B'
+# define SPECIFIER_USER_DEFINED_BEGIN '<'
+# define SPECIFIER_USER_DEFINED_END '>'
+# define SPECIFIER_USER_DEFINED_SEPARATOR ':'
+#endif
+
+/*
+ * QUALIFIERS:
+ *
+ *
+ * Numbers = d,i,o,u,x,X
+ * Float = a,A,e,E,f,F,g,G
+ * String = s
+ * Char = c
+ *
+ *
+ * 9$ Position
+ *      Use the 9th parameter. 9 can be any number between 1 and
+ *      the maximal argument
+ *
+ * 9 Width
+ *      Set width to 9. 9 can be any number, but must not be postfixed
+ *      by '$'
+ *
+ * h  Short
+ *    Numbers:
+ *      (unsigned) short int
+ *
+ * hh Short short
+ *    Numbers:
+ *      (unsigned) char
+ *
+ * l  Long
+ *    Numbers:
+ *      (unsigned) long int
+ *    String:
+ *      as the S specifier
+ *    Char:
+ *      as the C specifier
+ *
+ * ll Long Long
+ *    Numbers:
+ *      (unsigned) long long int
+ *
+ * L  Long Double
+ *    Float
+ *      long double
+ *
+ * #  Alternative
+ *    Float:
+ *      Decimal-point is always present
+ *    String:
+ *      non-printable characters are handled as \number
+ *
+ *    Spacing
+ *
+ * +  Sign
+ *
+ * -  Alignment
+ *
+ * .  Precision
+ *
+ * *  Parameter
+ *    print: use parameter
+ *    scan: no parameter (ignore)
+ *
+ * q  Quad
+ *
+ * Z  size_t
+ *
+ * w  Widechar
+ *
+ * '  Thousands/quote
+ *    Numbers:
+ *      Integer part grouped in thousands
+ *    Binary numbers:
+ *      Number grouped in nibbles (4 bits)
+ *    String:
+ *      Quoted string
+ *
+ * j  intmax_t
+ * t  prtdiff_t
+ * z  size_t
+ *
+ * !  Sticky
+ * @  Parameter (for both print and scan)
+ *
+ * I  n-bit Integer
+ *    Numbers:
+ *      The following options exists
+ *        I8  = 8-bit integer
+ *        I16 = 16-bit integer
+ *        I32 = 32-bit integer
+ *        I64 = 64-bit integer
+ */
+#define QUALIFIER_POSITION '$'
+#define QUALIFIER_SHORT 'h'
+#define QUALIFIER_LONG 'l'
+#define QUALIFIER_LONG_UPPER 'L'
+#define QUALIFIER_ALTERNATIVE '#'
+#define QUALIFIER_SPACE ' '
+#define QUALIFIER_PLUS '+'
+#define QUALIFIER_MINUS '-'
+#define QUALIFIER_DOT '.'
+#define QUALIFIER_STAR '*'
+#define QUALIFIER_CIRCUMFLEX '^' /* For scanlists */
+#if TRIO_C99
+# define QUALIFIER_SIZE_T 'z'
+# define QUALIFIER_PTRDIFF_T 't'
+# define QUALIFIER_INTMAX_T 'j'
+#endif
+#if TRIO_BSD || TRIO_GNU
+# define QUALIFIER_QUAD 'q'
+#endif
+#if TRIO_GNU
+# define QUALIFIER_SIZE_T_UPPER 'Z'
+#endif
+#if TRIO_MISC
+# define QUALIFIER_WIDECHAR 'w'
+#endif
+#if TRIO_MICROSOFT
+# define QUALIFIER_FIXED_SIZE 'I'
+#endif
+#if TRIO_EXTENSION
+# define QUALIFIER_QUOTE '\''
+# define QUALIFIER_STICKY '!'
+# define QUALIFIER_VARSIZE '&' /* This should remain undocumented */
+# define QUALIFIER_PARAM '@' /* Experimental */
+# define QUALIFIER_COLON ':' /* For scanlists */
+# define QUALIFIER_EQUAL '=' /* For scanlists */
+# define QUALIFIER_ROUNDING_UPPER 'R'
+#endif
+
+
+/*************************************************************************
+ *
+ * Internal Structures
+ *
+ *************************************************************************/
+
+/* Parameters */
+typedef struct {
+  /* An indication of which entry in the data union is used */
+  int type;
+  /* The flags */
+  trio_flags_t flags;
+  /* The width qualifier */
+  int width;
+  /* The precision qualifier */
+  int precision;
+  /* The base qualifier */
+  int base;
+  /* The size for the variable size qualifier */
+  int varsize;
+  /* The marker of the end of the specifier */
+  int indexAfterSpecifier;
+  /* The data from the argument list */
+  union {
+    char *string;
+#if TRIO_WIDECHAR
+    trio_wchar_t *wstring;
+#endif
+    trio_pointer_t pointer;
+    union {
+      trio_intmax_t as_signed;
+      trio_uintmax_t as_unsigned;
+    } number;
+    double doubleNumber;
+    double *doublePointer;
+    trio_long_double_t longdoubleNumber;
+    trio_long_double_t *longdoublePointer;
+    int errorNumber;
+  } data;
+  /* For the user-defined specifier */
+  char user_name[MAX_USER_NAME];
+  char user_data[MAX_USER_DATA];
+} trio_parameter_t;
+
+/* Container for customized functions */
+typedef struct {
+  union {
+    trio_outstream_t out;
+    trio_instream_t in;
+  } stream;
+  trio_pointer_t closure;
+} trio_custom_t;
+
+/* General trio "class" */
+typedef struct _trio_class_t {
+  /*
+   * The function to write characters to a stream.
+   */
+  void (*OutStream) TRIO_PROTO((struct _trio_class_t *, int));
+  /*
+   * The function to read characters from a stream.
+   */
+  void (*InStream) TRIO_PROTO((struct _trio_class_t *, int *));
+  /*
+   * The current location in the stream.
+   */
+  trio_pointer_t location;
+  /*
+   * The character currently being processed.
+   */
+  int current;
+  /*
+   * The number of characters that would have been written/read
+   * if there had been sufficient space.
+   */
+  int processed;
+  /*
+   * The number of characters that are actually written/read.
+   * Processed and committed will only differ for the *nprintf
+   * and *nscanf functions.
+   */
+  int committed;
+  /*
+   * The upper limit of characters that may be written/read.
+   */
+  int max;
+  /*
+   * The last output error that was detected.
+   */
+  int error;
+} trio_class_t;
+
+/* References (for user-defined callbacks) */
+typedef struct _trio_reference_t {
+  trio_class_t *data;
+  trio_parameter_t *parameter;
+} trio_reference_t;
+
+/* Registered entries (for user-defined callbacks) */
+typedef struct _trio_userdef_t {
+  struct _trio_userdef_t *next;
+  trio_callback_t callback;
+  char *name;
+} trio_userdef_t;
+
+/*************************************************************************
+ *
+ * Internal Variables
+ *
+ *************************************************************************/
+
+static TRIO_CONST char rcsid[] = "@(#)$Id: trio.c,v 1.1 2008/11/12 02:25:23 agibert Exp $";
+
+/*
+ * Need this to workaround a parser bug in HP C/iX compiler that fails
+ * to resolves macro definitions that includes type 'long double',
+ * e.g: va_arg(arg_ptr, long double)
+ */
+#if defined(TRIO_PLATFORM_MPEIX)
+static TRIO_CONST trio_long_double_t ___dummy_long_double = 0;
+#endif
+
+static TRIO_CONST char internalNullString[] = "(nil)";
+
+#if defined(USE_LOCALE)
+static struct lconv *internalLocaleValues = NULL;
+#endif
+
+/*
+ * UNIX98 says "in a locale where the radix character is not defined,
+ * the radix character defaults to a period (.)"
+ */
+static int internalDecimalPointLength = 1;
+static int internalThousandSeparatorLength = 1;
+static char internalDecimalPoint = '.';
+static char internalDecimalPointString[MAX_LOCALE_SEPARATOR_LENGTH + 1] = ".";
+static char internalThousandSeparator[MAX_LOCALE_SEPARATOR_LENGTH + 1] = ",";
+static char internalGrouping[MAX_LOCALE_GROUPS] = { (char)NO_GROUPING };
+
+static TRIO_CONST char internalDigitsLower[] = "0123456789abcdefghijklmnopqrstuvwxyz";
+static TRIO_CONST char internalDigitsUpper[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+static BOOLEAN_T internalDigitsUnconverted = TRUE;
+static int internalDigitArray[128];
+#if TRIO_EXTENSION
+static BOOLEAN_T internalCollationUnconverted = TRUE;
+static char internalCollationArray[MAX_CHARACTER_CLASS][MAX_CHARACTER_CLASS];
+#endif
+
+#if TRIO_EXTENSION
+static TRIO_VOLATILE trio_callback_t internalEnterCriticalRegion = NULL;
+static TRIO_VOLATILE trio_callback_t internalLeaveCriticalRegion = NULL;
+static trio_userdef_t *internalUserDef = NULL;
+#endif
+
+
+/*************************************************************************
+ *
+ * Internal Functions
+ *
+ ************************************************************************/
+
+#if defined(TRIO_MINIMAL)
+# define TRIO_STRING_PUBLIC static
+# include "triostr.c"
+#endif /* defined(TRIO_MINIMAL) */
+
+/*************************************************************************
+ * TrioIsQualifier
+ *
+ * Description:
+ *  Remember to add all new qualifiers to this function.
+ *  QUALIFIER_POSITION must not be added.
+ */
+TRIO_PRIVATE BOOLEAN_T
+TrioIsQualifier
+TRIO_ARGS1((character),
+	   TRIO_CONST char character)
+{
+  /* QUALIFIER_POSITION is not included */
+  switch (character)
+    {
+    case '0': case '1': case '2': case '3': case '4':
+    case '5': case '6': case '7': case '8': case '9':
+    case QUALIFIER_PLUS:
+    case QUALIFIER_MINUS:
+    case QUALIFIER_SPACE:
+    case QUALIFIER_DOT:
+    case QUALIFIER_STAR:
+    case QUALIFIER_ALTERNATIVE:
+    case QUALIFIER_SHORT:
+    case QUALIFIER_LONG:
+    case QUALIFIER_LONG_UPPER:
+    case QUALIFIER_CIRCUMFLEX:
+#if defined(QUALIFIER_SIZE_T)
+    case QUALIFIER_SIZE_T:
+#endif
+#if defined(QUALIFIER_PTRDIFF_T)
+    case QUALIFIER_PTRDIFF_T:
+#endif
+#if defined(QUALIFIER_INTMAX_T)
+    case QUALIFIER_INTMAX_T:
+#endif
+#if defined(QUALIFIER_QUAD)
+    case QUALIFIER_QUAD:
+#endif
+#if defined(QUALIFIER_SIZE_T_UPPER)
+    case QUALIFIER_SIZE_T_UPPER:
+#endif
+#if defined(QUALIFIER_WIDECHAR)
+    case QUALIFIER_WIDECHAR:
+#endif
+#if defined(QUALIFIER_QUOTE)
+    case QUALIFIER_QUOTE:
+#endif
+#if defined(QUALIFIER_STICKY)
+    case QUALIFIER_STICKY:
+#endif
+#if defined(QUALIFIER_VARSIZE)
+    case QUALIFIER_VARSIZE:
+#endif
+#if defined(QUALIFIER_PARAM)
+    case QUALIFIER_PARAM:
+#endif
+#if defined(QUALIFIER_FIXED_SIZE)
+    case QUALIFIER_FIXED_SIZE:
+#endif
+#if defined(QUALIFIER_ROUNDING_UPPER)
+    case QUALIFIER_ROUNDING_UPPER:
+#endif
+      return TRUE;
+    default:
+      return FALSE;
+    }
+}
+
+/*************************************************************************
+ * TrioSetLocale
+ */
+#if defined(USE_LOCALE)
+TRIO_PRIVATE void
+TrioSetLocale(TRIO_NOARGS)
+{
+  internalLocaleValues = (struct lconv *)localeconv();
+  if (internalLocaleValues)
+    {
+      if ((internalLocaleValues->decimal_point) &&
+	  (internalLocaleValues->decimal_point[0] != NIL))
+	{
+	  internalDecimalPointLength = trio_length(internalLocaleValues->decimal_point);
+	  if (internalDecimalPointLength == 1)
+	    {
+	      internalDecimalPoint = internalLocaleValues->decimal_point[0];
+	    }
+	  else
+	    {
+	      internalDecimalPoint = NIL;
+	      trio_copy_max(internalDecimalPointString,
+			    sizeof(internalDecimalPointString),
+			    internalLocaleValues->decimal_point);
+	    }
+	}
+      if ((internalLocaleValues->thousands_sep) &&
+	  (internalLocaleValues->thousands_sep[0] != NIL))
+	{
+	  trio_copy_max(internalThousandSeparator,
+			sizeof(internalThousandSeparator),
+			internalLocaleValues->thousands_sep);
+	  internalThousandSeparatorLength = trio_length(internalThousandSeparator);
+	}
+      if ((internalLocaleValues->grouping) &&
+	  (internalLocaleValues->grouping[0] != NIL))
+	{
+	  trio_copy_max(internalGrouping,
+			sizeof(internalGrouping),
+			internalLocaleValues->grouping);
+	}
+    }
+}
+#endif /* defined(USE_LOCALE) */
+
+TRIO_PRIVATE int
+TrioCalcThousandSeparatorLength
+TRIO_ARGS1((digits),
+	   int digits)
+{
+#if TRIO_EXTENSION
+  int count = 0;
+  int step = NO_GROUPING;
+  char *groupingPointer = internalGrouping;
+
+  while (digits > 0)
+    {
+      if (*groupingPointer == CHAR_MAX)
+	{
+	  /* Disable grouping */
+	  break; /* while */
+	}
+      else if (*groupingPointer == 0)
+	{
+	  /* Repeat last group */
+	  if (step == NO_GROUPING)
+	    {
+	      /* Error in locale */
+	      break; /* while */
+	    }
+	}
+      else
+	{
+	  step = *groupingPointer++;
+	}
+      if (digits > step)
+	count += internalThousandSeparatorLength;
+      digits -= step;
+    }
+  return count;
+#else
+  return 0;
+#endif
+}
+
+TRIO_PRIVATE BOOLEAN_T
+TrioFollowedBySeparator
+TRIO_ARGS1((position),
+	   int position)
+{
+#if TRIO_EXTENSION
+  int step = 0;
+  char *groupingPointer = internalGrouping;
+
+  position--;
+  if (position == 0)
+    return FALSE;
+  while (position > 0)
+    {
+      if (*groupingPointer == CHAR_MAX)
+	{
+	  /* Disable grouping */
+	  break; /* while */
+	}
+      else if (*groupingPointer != 0)
+	{
+	  step = *groupingPointer++;
+	}
+      if (step == 0)
+	break;
+      position -= step;
+    }
+  return (position == 0);
+#else
+  return FALSE;
+#endif
+}
+
+/*************************************************************************
+ * TrioGetPosition
+ *
+ * Get the %n$ position.
+ */
+TRIO_PRIVATE int
+TrioGetPosition
+TRIO_ARGS2((format, indexPointer),
+	   TRIO_CONST char *format,
+	   int *indexPointer)
+{
+#if TRIO_UNIX98
+  char *tmpformat;
+  int number = 0;
+  int index = *indexPointer;
+
+  number = (int)trio_to_long(&format[index], &tmpformat, BASE_DECIMAL);
+  index = (int)(tmpformat - format);
+  if ((number != 0) && (QUALIFIER_POSITION == format[index++]))
+    {
+      *indexPointer = index;
+      /*
+       * number is decreased by 1, because n$ starts from 1, whereas
+       * the array it is indexing starts from 0.
+       */
+      return number - 1;
+    }
+#endif
+  return NO_POSITION;
+}
+
+#if TRIO_EXTENSION
+/*************************************************************************
+ * TrioFindNamespace
+ *
+ * Find registered user-defined specifier.
+ * The prev argument is used for optimization only.
+ */
+TRIO_PRIVATE trio_userdef_t *
+TrioFindNamespace
+TRIO_ARGS2((name, prev),
+	   TRIO_CONST char *name,
+	   trio_userdef_t **prev)
+{
+  trio_userdef_t *def;
+  
+  if (internalEnterCriticalRegion)
+    (void)internalEnterCriticalRegion(NULL);
+  
+  for (def = internalUserDef; def; def = def->next)
+    {
+      /* Case-sensitive string comparison */
+      if (trio_equal_case(def->name, name))
+	break;
+      
+      if (prev)
+	*prev = def;
+    }
+  
+  if (internalLeaveCriticalRegion)
+    (void)internalLeaveCriticalRegion(NULL);
+  
+  return def;
+}
+#endif
+
+/*************************************************************************
+ * TrioPower
+ *
+ * Description:
+ *  Calculate pow(base, exponent), where number and exponent are integers.
+ */
+TRIO_PRIVATE trio_long_double_t
+TrioPower
+TRIO_ARGS2((number, exponent),
+	   int number,
+	   int exponent)
+{
+  trio_long_double_t result;
+
+  if (number == 10)
+    {
+      switch (exponent)
+	{
+	  /* Speed up calculation of common cases */
+	case 0:
+	  result = (trio_long_double_t)number * TRIO_SUFFIX_LONG(1E-1);
+	  break;
+	case 1:
+	  result = (trio_long_double_t)number * TRIO_SUFFIX_LONG(1E+0);
+	  break;
+	case 2:
+	  result = (trio_long_double_t)number * TRIO_SUFFIX_LONG(1E+1);
+	  break;
+	case 3:
+	  result = (trio_long_double_t)number * TRIO_SUFFIX_LONG(1E+2);
+	  break;
+	case 4:
+	  result = (trio_long_double_t)number * TRIO_SUFFIX_LONG(1E+3);
+	  break;
+	case 5:
+	  result = (trio_long_double_t)number * TRIO_SUFFIX_LONG(1E+4);
+	  break;
+	case 6:
+	  result = (trio_long_double_t)number * TRIO_SUFFIX_LONG(1E+5);
+	  break;
+	case 7:
+	  result = (trio_long_double_t)number * TRIO_SUFFIX_LONG(1E+6);
+	  break;
+	case 8:
+	  result = (trio_long_double_t)number * TRIO_SUFFIX_LONG(1E+7);
+	  break;
+	case 9:
+	  result = (trio_long_double_t)number * TRIO_SUFFIX_LONG(1E+8);
+	  break;
+	default:
+	  result = powl((trio_long_double_t)number,
+			(trio_long_double_t)exponent);
+	  break;
+	}
+    }
+  else
+    {
+      return powl((trio_long_double_t)number, (trio_long_double_t)exponent);
+    }
+  return result;
+}
+
+/*************************************************************************
+ * TrioLogarithm
+ */
+TRIO_PRIVATE double
+TrioLogarithm
+TRIO_ARGS2((number, base),
+	   double number,
+	   int base)
+{
+  double result;
+
+  if (number <= 0.0)
+    {
+      /* xlC crashes on log(0) */
+      result = (number == 0.0) ? trio_ninf() : trio_nan();
+    }
+  else
+    {
+      if (base == 10)
+	{
+	  result = log10(number);
+	}
+      else
+	{
+	  result = log10(number) / log10((double)base);
+	}
+    }
+  return result;
+}
+
+/*************************************************************************
+ * TrioLogarithmBase
+ */
+TRIO_PRIVATE double
+TrioLogarithmBase
+TRIO_ARGS1((base),
+	   int base)
+{
+  switch (base)
+    {
+    case BASE_BINARY : return 1.0;
+    case BASE_OCTAL  : return 3.0;
+    case BASE_DECIMAL: return 3.321928094887362345;
+    case BASE_HEX    : return 4.0;
+    default          : return TrioLogarithm((double)base, 2);
+    }
+}
+
+/*************************************************************************
+ * TrioParse
+ *
+ * Description:
+ *  Parse the format string
+ */
+TRIO_PRIVATE int
+TrioParse
+TRIO_ARGS5((type, format, parameters, arglist, argarray),
+	   int type,
+	   TRIO_CONST char *format,
+	   trio_parameter_t *parameters,
+	   va_list *arglist,
+	   trio_pointer_t *argarray)
+{
+  /* Count the number of times a parameter is referenced */
+  unsigned short usedEntries[MAX_PARAMETERS];
+  /* Parameter counters */
+  int parameterPosition;
+  int currentParam;
+  int maxParam = -1;
+  /* Utility variables */
+  trio_flags_t flags;
+  int width;
+  int precision;
+  int varsize;
+  int base;
+  int index;  /* Index into formatting string */
+  int dots;  /* Count number of dots in modifier part */
+  BOOLEAN_T positional;  /* Does the specifier have a positional? */
+  BOOLEAN_T gotSticky = FALSE;  /* Are there any sticky modifiers at all? */
+  /*
+   * indices specifies the order in which the parameters must be
+   * read from the va_args (this is necessary to handle positionals)
+   */
+  int indices[MAX_PARAMETERS];
+  int pos = 0;
+  /* Various variables */
+  char ch;
+#if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE)
+  int charlen;
+#endif
+  int save_errno;
+  int i = -1;
+  int num;
+  char *tmpformat;
+
+  /* One and only one of arglist and argarray must be used */
+  assert((arglist != NULL) ^ (argarray != NULL));
+  
+  /*
+   * The 'parameters' array is not initialized, but we need to
+   * know which entries we have used.
+   */
+  memset(usedEntries, 0, sizeof(usedEntries));
+
+  save_errno = errno;
+  index = 0;
+  parameterPosition = 0;
+#if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE)
+  (void)mblen(NULL, 0);
+#endif
+  
+  while (format[index])
+    {
+#if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE)
+      if (! isascii(format[index]))
+	{
+	  /*
+	   * Multibyte characters cannot be legal specifiers or
+	   * modifiers, so we skip over them.
+	   */
+	  charlen = mblen(&format[index], MB_LEN_MAX);
+	  index += (charlen > 0) ? charlen : 1;
+	  continue; /* while */
+	}
+#endif /* TRIO_COMPILER_SUPPORTS_MULTIBYTE */
+      if (CHAR_IDENTIFIER == format[index++])
+	{
+	  if (CHAR_IDENTIFIER == format[index])
+	    {
+	      index++;
+	      continue; /* while */
+	    }
+
+	  flags = FLAGS_NEW;
+	  dots = 0;
+	  currentParam = TrioGetPosition(format, &index);
+	  positional = (NO_POSITION != currentParam);
+	  if (!positional)
+	    {
+	      /* We have no positional, get the next counter */
+	      currentParam = parameterPosition;
+	    }
+          if(currentParam >= MAX_PARAMETERS)
+	    {
+	      /* Bail out completely to make the error more obvious */
+	      return TRIO_ERROR_RETURN(TRIO_ETOOMANY, index);
+	    }
+
+	  if (currentParam > maxParam)
+	    maxParam = currentParam;
+
+	  /* Default values */
+	  width = NO_WIDTH;
+	  precision = NO_PRECISION;
+	  base = NO_BASE;
+	  varsize = NO_SIZE;
+
+	  while (TrioIsQualifier(format[index]))
+	    {
+	      ch = format[index++];
+
+	      switch (ch)
+		{
+		case QUALIFIER_SPACE:
+		  flags |= FLAGS_SPACE;
+		  break;
+
+		case QUALIFIER_PLUS:
+		  flags |= FLAGS_SHOWSIGN;
+		  break;
+
+		case QUALIFIER_MINUS:
+		  flags |= FLAGS_LEFTADJUST;
+		  flags &= ~FLAGS_NILPADDING;
+		  break;
+
+		case QUALIFIER_ALTERNATIVE:
+		  flags |= FLAGS_ALTERNATIVE;
+		  break;
+
+		case QUALIFIER_DOT:
+		  if (dots == 0) /* Precision */
+		    {
+		      dots++;
+
+		      /* Skip if no precision */
+		      if (QUALIFIER_DOT == format[index])
+			break;
+		      
+		      /* After the first dot we have the precision */
+		      flags |= FLAGS_PRECISION;
+		      if ((QUALIFIER_STAR == format[index])
+#if defined(QUALIFIER_PARAM)
+			  || (QUALIFIER_PARAM == format[index])
+#endif
+			  )
+			{
+			  index++;
+			  flags |= FLAGS_PRECISION_PARAMETER;
+
+			  precision = TrioGetPosition(format, &index);
+			  if (precision == NO_POSITION)
+			    {
+			      parameterPosition++;
+			      if (positional)
+				precision = parameterPosition;
+			      else
+				{
+				  precision = currentParam;
+				  currentParam = precision + 1;
+				}
+			    }
+			  else
+			    {
+			      if (! positional)
+				currentParam = precision + 1;
+			      if (width > maxParam)
+				maxParam = precision;
+			    }
+			  if (currentParam > maxParam)
+			    maxParam = currentParam;
+			}
+		      else
+			{
+			  precision = trio_to_long(&format[index],
+						   &tmpformat,
+						   BASE_DECIMAL);
+			  index = (int)(tmpformat - format);
+			}
+		    }
+		  else if (dots == 1) /* Base */
+		    {
+		      dots++;
+		      
+		      /* After the second dot we have the base */
+		      flags |= FLAGS_BASE;
+		      if ((QUALIFIER_STAR == format[index])
+#if defined(QUALIFIER_PARAM)
+			  || (QUALIFIER_PARAM == format[index])
+#endif
+			  )
+			{
+			  index++;
+			  flags |= FLAGS_BASE_PARAMETER;
+			  base = TrioGetPosition(format, &index);
+			  if (base == NO_POSITION)
+			    {
+			      parameterPosition++;
+			      if (positional)
+				base = parameterPosition;
+			      else
+				{
+				  base = currentParam;
+				  currentParam = base + 1;
+				}
+			    }
+			  else
+			    {
+			      if (! positional)
+				currentParam = base + 1;
+			      if (base > maxParam)
+				maxParam = base;
+			    }
+			  if (currentParam > maxParam)
+			    maxParam = currentParam;
+			}
+		      else
+			{
+			  base = trio_to_long(&format[index],
+					      &tmpformat,
+					      BASE_DECIMAL);
+			  if (base > MAX_BASE)
+			    return TRIO_ERROR_RETURN(TRIO_EINVAL, index);
+			  index = (int)(tmpformat - format);
+			}
+		    }
+		  else
+		    {
+		      return TRIO_ERROR_RETURN(TRIO_EINVAL, index);
+		    }
+		  break; /* QUALIFIER_DOT */
+
+#if defined(QUALIFIER_PARAM)
+		case QUALIFIER_PARAM:
+		  type = TYPE_PRINT;
+		  /* FALLTHROUGH */
+#endif
+		case QUALIFIER_STAR:
+		  /* This has different meanings for print and scan */
+		  if (TYPE_PRINT == type)
+		    {
+		      /* Read with from parameter */
+		      flags |= (FLAGS_WIDTH | FLAGS_WIDTH_PARAMETER);
+		      width = TrioGetPosition(format, &index);
+		      if (width == NO_POSITION)
+			{
+			  parameterPosition++;
+			  if (positional)
+			    width = parameterPosition;
+			  else
+			    {
+			      width = currentParam;
+			      currentParam = width + 1;
+			    }
+			}
+		      else
+			{
+			  if (! positional)
+			    currentParam = width + 1;
+			  if (width > maxParam)
+			    maxParam = width;
+			}
+		      if (currentParam > maxParam)
+			maxParam = currentParam;
+		    }
+		  else
+		    {
+		      /* Scan, but do not store result */
+		      flags |= FLAGS_IGNORE;
+		    }
+
+		  break; /* QUALIFIER_STAR */
+
+		case '0':
+		  if (! (flags & FLAGS_LEFTADJUST))
+		    flags |= FLAGS_NILPADDING;
+		  /* FALLTHROUGH */
+		case '1': case '2': case '3': case '4':
+		case '5': case '6': case '7': case '8': case '9':
+		  flags |= FLAGS_WIDTH;
+		  /* &format[index - 1] is used to "rewind" the read
+		   * character from format
+		   */
+		  width = trio_to_long(&format[index - 1],
+				       &tmpformat,
+				       BASE_DECIMAL);
+		  index = (int)(tmpformat - format);
+		  break;
+
+		case QUALIFIER_SHORT:
+		  if (flags & FLAGS_SHORTSHORT)
+		    return TRIO_ERROR_RETURN(TRIO_EINVAL, index);
+		  else if (flags & FLAGS_SHORT)
+		    flags |= FLAGS_SHORTSHORT;
+		  else
+		    flags |= FLAGS_SHORT;
+		  break;
+
+		case QUALIFIER_LONG:
+		  if (flags & FLAGS_QUAD)
+		    return TRIO_ERROR_RETURN(TRIO_EINVAL, index);
+		  else if (flags & FLAGS_LONG)
+		    flags |= FLAGS_QUAD;
+		  else
+		    flags |= FLAGS_LONG;
+		  break;
+
+		case QUALIFIER_LONG_UPPER:
+		  flags |= FLAGS_LONGDOUBLE;
+		  break;
+
+#if defined(QUALIFIER_SIZE_T)
+		case QUALIFIER_SIZE_T:
+		  flags |= FLAGS_SIZE_T;
+		  /* Modify flags for later truncation of number */
+		  if (sizeof(size_t) == sizeof(trio_ulonglong_t))
+		    flags |= FLAGS_QUAD;
+		  else if (sizeof(size_t) == sizeof(long))
+		    flags |= FLAGS_LONG;
+		  break;
+#endif
+
+#if defined(QUALIFIER_PTRDIFF_T)
+		case QUALIFIER_PTRDIFF_T:
+		  flags |= FLAGS_PTRDIFF_T;
+		  if (sizeof(ptrdiff_t) == sizeof(trio_ulonglong_t))
+		    flags |= FLAGS_QUAD;
+		  else if (sizeof(ptrdiff_t) == sizeof(long))
+		    flags |= FLAGS_LONG;
+		  break;
+#endif
+
+#if defined(QUALIFIER_INTMAX_T)
+		case QUALIFIER_INTMAX_T:
+		  flags |= FLAGS_INTMAX_T;
+		  if (sizeof(trio_intmax_t) == sizeof(trio_ulonglong_t))
+		    flags |= FLAGS_QUAD;
+		  else if (sizeof(trio_intmax_t) == sizeof(long))
+		    flags |= FLAGS_LONG;
+		  break;
+#endif
+
+#if defined(QUALIFIER_QUAD)
+		case QUALIFIER_QUAD:
+		  flags |= FLAGS_QUAD;
+		  break;
+#endif
+
+#if defined(QUALIFIER_FIXED_SIZE)
+		case QUALIFIER_FIXED_SIZE:
+		  if (flags & FLAGS_FIXED_SIZE)
+		    return TRIO_ERROR_RETURN(TRIO_EINVAL, index);
+
+		  if (flags & (FLAGS_ALL_SIZES | FLAGS_LONGDOUBLE |
+			       FLAGS_WIDECHAR | FLAGS_VARSIZE_PARAMETER))
+		    return TRIO_ERROR_RETURN(TRIO_EINVAL, index);
+
+		  if ((format[index] == '6') &&
+		      (format[index + 1] == '4'))
+		    {
+		      varsize = sizeof(trio_int64_t);
+		      index += 2;
+		    }
+		  else if ((format[index] == '3') &&
+			   (format[index + 1] == '2'))
+		    {
+		      varsize = sizeof(trio_int32_t);
+		      index += 2;
+		    }
+		  else if ((format[index] == '1') &&
+			   (format[index + 1] == '6'))
+		    {
+		      varsize = sizeof(trio_int16_t);
+		      index += 2;
+		    }
+		  else if (format[index] == '8')
+		    {
+		      varsize = sizeof(trio_int8_t);
+		      index++;
+		    }
+		  else
+		    return TRIO_ERROR_RETURN(TRIO_EINVAL, index);
+		  
+		  flags |= FLAGS_FIXED_SIZE;
+		  break;
+#endif
+
+#if defined(QUALIFIER_WIDECHAR)
+		case QUALIFIER_WIDECHAR:
+		  flags |= FLAGS_WIDECHAR;
+		  break;
+#endif
+
+#if defined(QUALIFIER_SIZE_T_UPPER)
+		case QUALIFIER_SIZE_T_UPPER:
+		  break;
+#endif
+
+#if defined(QUALIFIER_QUOTE)
+		case QUALIFIER_QUOTE:
+		  flags |= FLAGS_QUOTE;
+		  break;
+#endif
+
+#if defined(QUALIFIER_STICKY)
+		case QUALIFIER_STICKY:
+		  flags |= FLAGS_STICKY;
+		  gotSticky = TRUE;
+		  break;
+#endif
+		  
+#if defined(QUALIFIER_VARSIZE)
+		case QUALIFIER_VARSIZE:
+		  flags |= FLAGS_VARSIZE_PARAMETER;
+		  parameterPosition++;
+		  if (positional)
+		    varsize = parameterPosition;
+		  else
+		    {
+		      varsize = currentParam;
+		      currentParam = varsize + 1;
+		    }
+		  if (currentParam > maxParam)
+		    maxParam = currentParam;
+		  break;
+#endif
+
+#if defined(QUALIFIER_ROUNDING_UPPER)
+		case QUALIFIER_ROUNDING_UPPER:
+		  flags |= FLAGS_ROUNDING;
+		  break;
+#endif
+
+		default:
+		  /* Bail out completely to make the error more obvious */
+                  return TRIO_ERROR_RETURN(TRIO_EINVAL, index);
+		}
+	    } /* while qualifier */
+
+	  /*
+	   * Parameters only need the type and value. The value is
+	   * read later.
+	   */
+	  if (flags & FLAGS_WIDTH_PARAMETER)
+	    {
+	      usedEntries[width] += 1;
+	      parameters[pos].type = FORMAT_PARAMETER;
+	      parameters[pos].flags = 0;
+	      indices[width] = pos;
+	      width = pos++;
+	    }
+	  if (flags & FLAGS_PRECISION_PARAMETER)
+	    {
+	      usedEntries[precision] += 1;
+	      parameters[pos].type = FORMAT_PARAMETER;
+	      parameters[pos].flags = 0;
+	      indices[precision] = pos;
+	      precision = pos++;
+	    }
+	  if (flags & FLAGS_BASE_PARAMETER)
+	    {
+	      usedEntries[base] += 1;
+	      parameters[pos].type = FORMAT_PARAMETER;
+	      parameters[pos].flags = 0;
+	      indices[base] = pos;
+	      base = pos++;
+	    }
+	  if (flags & FLAGS_VARSIZE_PARAMETER)
+	    {
+	      usedEntries[varsize] += 1;
+	      parameters[pos].type = FORMAT_PARAMETER;
+	      parameters[pos].flags = 0;
+	      indices[varsize] = pos;
+	      varsize = pos++;
+	    }
+	  
+	  indices[currentParam] = pos;
+	  
+	  switch (format[index++])
+	    {
+#if defined(SPECIFIER_CHAR_UPPER)
+	    case SPECIFIER_CHAR_UPPER:
+	      flags |= FLAGS_WIDECHAR;
+	      /* FALLTHROUGH */
+#endif
+	    case SPECIFIER_CHAR:
+	      if (flags & FLAGS_LONG)
+		flags |= FLAGS_WIDECHAR;
+	      else if (flags & FLAGS_SHORT)
+		flags &= ~FLAGS_WIDECHAR;
+	      parameters[pos].type = FORMAT_CHAR;
+	      break;
+
+#if defined(SPECIFIER_STRING_UPPER)
+	    case SPECIFIER_STRING_UPPER:
+	      flags |= FLAGS_WIDECHAR;
+	      /* FALLTHROUGH */
+#endif
+	    case SPECIFIER_STRING:
+	      if (flags & FLAGS_LONG)
+		flags |= FLAGS_WIDECHAR;
+	      else if (flags & FLAGS_SHORT)
+		flags &= ~FLAGS_WIDECHAR;
+	      parameters[pos].type = FORMAT_STRING;
+	      break;
+
+	    case SPECIFIER_GROUP:
+	      if (TYPE_SCAN == type)
+		{
+		  int depth = 1;
+		  parameters[pos].type = FORMAT_GROUP;
+		  if (format[index] == QUALIFIER_CIRCUMFLEX)
+		    index++;
+		  if (format[index] == SPECIFIER_UNGROUP)
+		    index++;
+		  if (format[index] == QUALIFIER_MINUS)
+		    index++;
+		  /* Skip nested brackets */
+		  while (format[index] != NIL)
+		    {
+		      if (format[index] == SPECIFIER_GROUP)
+			{
+			  depth++;
+			}
+		      else if (format[index] == SPECIFIER_UNGROUP)
+			{
+			  if (--depth <= 0)
+			    {
+			      index++;
+			      break;
+			    }
+			}
+		      index++;
+		    }
+		}
+	      break;
+	      
+	    case SPECIFIER_INTEGER:
+	      parameters[pos].type = FORMAT_INT;
+	      break;
+	      
+	    case SPECIFIER_UNSIGNED:
+	      flags |= FLAGS_UNSIGNED;
+	      parameters[pos].type = FORMAT_INT;
+	      break;
+
+	    case SPECIFIER_DECIMAL:
+	      /* Disable base modifier */
+	      flags &= ~FLAGS_BASE_PARAMETER;
+	      base = BASE_DECIMAL;
+	      parameters[pos].type = FORMAT_INT;
+	      break;
+
+	    case SPECIFIER_OCTAL:
+	      flags |= FLAGS_UNSIGNED;
+	      flags &= ~FLAGS_BASE_PARAMETER;
+	      base = BASE_OCTAL;
+	      parameters[pos].type = FORMAT_INT;
+	      break;
+
+#if defined(SPECIFIER_BINARY)
+	    case SPECIFIER_BINARY_UPPER:
+	      flags |= FLAGS_UPPER;
+	      /* FALLTHROUGH */
+	    case SPECIFIER_BINARY:
+	      flags |= FLAGS_NILPADDING;
+	      flags &= ~FLAGS_BASE_PARAMETER;
+	      base = BASE_BINARY;
+	      parameters[pos].type = FORMAT_INT;
+	      break;
+#endif
+
+	    case SPECIFIER_HEX_UPPER:
+	      flags |= FLAGS_UPPER;
+	      /* FALLTHROUGH */
+	    case SPECIFIER_HEX:
+	      flags |= FLAGS_UNSIGNED;
+	      flags &= ~FLAGS_BASE_PARAMETER;
+	      base = BASE_HEX;
+	      parameters[pos].type = FORMAT_INT;
+	      break;
+
+	    case SPECIFIER_FLOAT_E_UPPER:
+	      flags |= FLAGS_UPPER;
+	      /* FALLTHROUGH */
+	    case SPECIFIER_FLOAT_E:
+	      flags |= FLAGS_FLOAT_E;
+	      parameters[pos].type = FORMAT_DOUBLE;
+	      break;
+
+	    case SPECIFIER_FLOAT_G_UPPER:
+	      flags |= FLAGS_UPPER;
+	      /* FALLTHROUGH */
+	    case SPECIFIER_FLOAT_G:
+	      flags |= FLAGS_FLOAT_G;
+	      parameters[pos].type = FORMAT_DOUBLE;
+	      break;
+
+	    case SPECIFIER_FLOAT_F_UPPER:
+	      flags |= FLAGS_UPPER;
+	      /* FALLTHROUGH */
+	    case SPECIFIER_FLOAT_F:
+	      parameters[pos].type = FORMAT_DOUBLE;
+	      break;
+
+	    case SPECIFIER_POINTER:
+	      if (sizeof(trio_pointer_t) == sizeof(trio_ulonglong_t))
+		flags |= FLAGS_QUAD;
+	      else if (sizeof(trio_pointer_t) == sizeof(long))
+		flags |= FLAGS_LONG;
+	      parameters[pos].type = FORMAT_POINTER;
+	      break;
+
+	    case SPECIFIER_COUNT:
+	      parameters[pos].type = FORMAT_COUNT;
+	      break;
+
+#if defined(SPECIFIER_HEXFLOAT)
+# if defined(SPECIFIER_HEXFLOAT_UPPER)
+	    case SPECIFIER_HEXFLOAT_UPPER:
+	      flags |= FLAGS_UPPER;
+	      /* FALLTHROUGH */
+# endif
+	    case SPECIFIER_HEXFLOAT:
+	      base = BASE_HEX;
+	      parameters[pos].type = FORMAT_DOUBLE;
+	      break;
+#endif
+
+#if defined(FORMAT_ERRNO)
+	    case SPECIFIER_ERRNO:
+	      parameters[pos].type = FORMAT_ERRNO;
+	      break;
+#endif
+
+#if defined(SPECIFIER_USER_DEFINED_BEGIN)
+	    case SPECIFIER_USER_DEFINED_BEGIN:
+	      {
+		unsigned int max;
+		int without_namespace = TRUE;
+		
+		parameters[pos].type = FORMAT_USER_DEFINED;
+		parameters[pos].user_name[0] = NIL;
+		tmpformat = (char *)&format[index];
+	      
+		while ((ch = format[index]))
+		  {
+		    index++;
+		    if (ch == SPECIFIER_USER_DEFINED_END)
+		      {
+			if (without_namespace)
+			  {
+			    /* We must get the handle first */
+			    parameters[pos].type = FORMAT_PARAMETER;
+			    parameters[pos].indexAfterSpecifier = index;
+			    parameters[pos].flags = FLAGS_USER_DEFINED;
+			    /* Adjust parameters for insertion of new one */
+			    pos++;
+			    usedEntries[currentParam] += 1;
+			    parameters[pos].type = FORMAT_USER_DEFINED;
+			    currentParam++;
+			    indices[currentParam] = pos;
+			    if (currentParam > maxParam)
+			      maxParam = currentParam;
+			  }
+			/* Copy the user data */
+			max = (unsigned int)(&format[index] - tmpformat);
+			if (max > MAX_USER_DATA)
+			  max = MAX_USER_DATA;
+			trio_copy_max(parameters[pos].user_data,
+				      max,
+				      tmpformat);
+			break; /* while */
+		      }
+		    if (ch == SPECIFIER_USER_DEFINED_SEPARATOR)
+		      {
+			without_namespace = FALSE;
+			/* Copy the namespace for later looking-up */
+			max = (int)(&format[index] - tmpformat);
+			if (max > MAX_USER_NAME)
+			  max = MAX_USER_NAME;
+			trio_copy_max(parameters[pos].user_name,
+				      max,
+				      tmpformat);
+			tmpformat = (char *)&format[index];
+		      }
+		  }
+		if (ch != SPECIFIER_USER_DEFINED_END)
+		  return TRIO_ERROR_RETURN(TRIO_EINVAL, index);
+	      }
+	      break;
+#endif /* defined(SPECIFIER_USER_DEFINED_BEGIN) */
+	      
+	    default:
+	      /* Bail out completely to make the error more obvious */
+              return TRIO_ERROR_RETURN(TRIO_EINVAL, index);
+	    }
+
+	  /*  Count the number of times this entry has been used */
+	  usedEntries[currentParam] += 1;
+	  
+	  /* Find last sticky parameters */
+	  if (gotSticky && !(flags & FLAGS_STICKY))
+	    {
+	      for (i = pos - 1; i >= 0; i--)
+		{
+		  if (parameters[i].type == FORMAT_PARAMETER)
+		    continue;
+		  if ((parameters[i].flags & FLAGS_STICKY) &&
+		      (parameters[i].type == parameters[pos].type))
+		    {
+		      /* Do not overwrite current qualifiers */
+		      flags |= (parameters[i].flags & (unsigned long)~FLAGS_STICKY);
+		      if (width == NO_WIDTH)
+			width = parameters[i].width;
+		      if (precision == NO_PRECISION)
+			precision = parameters[i].precision;
+		      if (base == NO_BASE)
+			base = parameters[i].base;
+		      break;
+		    }
+		}
+	    }
+	  
+	  parameters[pos].indexAfterSpecifier = index;
+	  parameters[pos].flags = flags;
+	  parameters[pos].width = width;
+	  parameters[pos].precision = precision;
+	  parameters[pos].base = (base == NO_BASE) ? BASE_DECIMAL : base;
+	  parameters[pos].varsize = varsize;
+	  pos++;
+	  
+	  if (! positional)
+	    parameterPosition++;
+	  
+	} /* if identifier */
+      
+    } /* while format characters left */
+
+  for (num = 0; num <= maxParam; num++)
+    {
+      if (usedEntries[num] != 1)
+	{
+	  if (usedEntries[num] == 0) /* gap detected */
+	    return TRIO_ERROR_RETURN(TRIO_EGAP, num);
+	  else /* double references detected */
+	    return TRIO_ERROR_RETURN(TRIO_EDBLREF, num);
+	}
+      
+      i = indices[num];
+
+      /*
+       * FORMAT_PARAMETERS are only present if they must be read,
+       * so it makes no sense to check the ignore flag (besides,
+       * the flags variable is not set for that particular type)
+       */
+      if ((parameters[i].type != FORMAT_PARAMETER) &&
+	  (parameters[i].flags & FLAGS_IGNORE))
+	continue; /* for all arguments */
+
+      /*
+       * The stack arguments are read according to ANSI C89
+       * default argument promotions:
+       *
+       *  char           = int
+       *  short          = int
+       *  unsigned char  = unsigned int
+       *  unsigned short = unsigned int
+       *  float          = double
+       *
+       * In addition to the ANSI C89 these types are read (the
+       * default argument promotions of C99 has not been
+       * considered yet)
+       *
+       *  long long
+       *  long double
+       *  size_t
+       *  ptrdiff_t
+       *  intmax_t
+       */
+      switch (parameters[i].type)
+	{
+	case FORMAT_GROUP:
+	case FORMAT_STRING:
+#if TRIO_WIDECHAR
+	  if (flags & FLAGS_WIDECHAR)
+	    {
+	      parameters[i].data.wstring = (argarray == NULL)
+		? va_arg(*arglist, trio_wchar_t *)
+		: (trio_wchar_t *)(argarray[num]);
+	    }
+	  else
+#endif
+	    {
+	      parameters[i].data.string = (argarray == NULL)
+		? va_arg(*arglist, char *)
+		: (char *)(argarray[num]);
+	    }
+	  break;
+
+#if defined(FORMAT_USER_DEFINED)
+	case FORMAT_USER_DEFINED:
+#endif
+	case FORMAT_POINTER:
+	case FORMAT_COUNT:
+	case FORMAT_UNKNOWN:
+	  parameters[i].data.pointer = (argarray == NULL)
+	    ? va_arg(*arglist, trio_pointer_t )
+	    : argarray[num];
+	  break;
+
+	case FORMAT_CHAR:
+	case FORMAT_INT:
+	  if (TYPE_SCAN == type)
+	    {
+              if (argarray == NULL)
+                parameters[i].data.pointer = 
+                  (trio_pointer_t)va_arg(*arglist, trio_pointer_t);
+              else
+                {
+                  if (parameters[i].type == FORMAT_CHAR)
+                    parameters[i].data.pointer =
+                      (trio_pointer_t)((char *)argarray[num]);
+                  else if (parameters[i].flags & FLAGS_SHORT)
+                    parameters[i].data.pointer =
+                      (trio_pointer_t)((short *)argarray[num]);
+                  else
+                    parameters[i].data.pointer =
+                      (trio_pointer_t)((int *)argarray[num]);
+                }
+	    }
+	  else
+	    {
+#if defined(QUALIFIER_VARSIZE) || defined(QUALIFIER_FIXED_SIZE)
+	      if (parameters[i].flags
+		  & (FLAGS_VARSIZE_PARAMETER | FLAGS_FIXED_SIZE))
+		{
+		  if (parameters[i].flags & FLAGS_VARSIZE_PARAMETER)
+		    {
+		      /*
+		       * Variable sizes are mapped onto the fixed sizes, in
+		       * accordance with integer promotion.
+		       *
+		       * Please note that this may not be portable, as we
+		       * only guess the size, not the layout of the numbers.
+		       * For example, if int is little-endian, and long is
+		       * big-endian, then this will fail.
+		       */
+		      varsize = (int)parameters[parameters[i].varsize].data.number.as_unsigned;
+		    }
+		  else
+		    {
+		      /* Used for the I<bits> modifiers */
+		      varsize = parameters[i].varsize;
+		    }
+		  parameters[i].flags &= ~FLAGS_ALL_VARSIZES;
+		  
+		  if (varsize <= (int)sizeof(int))
+		    ;
+		  else if (varsize <= (int)sizeof(long))
+		    parameters[i].flags |= FLAGS_LONG;
+#if defined(QUALIFIER_INTMAX_T)
+		  else if (varsize <= (int)sizeof(trio_longlong_t))
+		    parameters[i].flags |= FLAGS_QUAD;
+		  else
+		    parameters[i].flags |= FLAGS_INTMAX_T;
+#else
+		  else
+		    parameters[i].flags |= FLAGS_QUAD;
+#endif
+		}
+#endif /* defined(QUALIFIER_VARSIZE) */
+#if defined(QUALIFIER_SIZE_T) || defined(QUALIFIER_SIZE_T_UPPER)
+	      if (parameters[i].flags & FLAGS_SIZE_T)
+		parameters[i].data.number.as_unsigned = (argarray == NULL)
+		  ? (trio_uintmax_t)va_arg(*arglist, size_t)
+		  : (trio_uintmax_t)(*((size_t *)argarray[num]));
+	      else
+#endif
+#if defined(QUALIFIER_PTRDIFF_T)
+	      if (parameters[i].flags & FLAGS_PTRDIFF_T)
+		parameters[i].data.number.as_unsigned = (argarray == NULL)
+		  ? (trio_uintmax_t)va_arg(*arglist, ptrdiff_t)
+		  : (trio_uintmax_t)(*((ptrdiff_t *)argarray[num]));
+	      else
+#endif
+#if defined(QUALIFIER_INTMAX_T)
+	      if (parameters[i].flags & FLAGS_INTMAX_T)
+		parameters[i].data.number.as_unsigned = (argarray == NULL)
+		  ? (trio_uintmax_t)va_arg(*arglist, trio_intmax_t)
+		  : (trio_uintmax_t)(*((trio_intmax_t *)argarray[num]));
+	      else
+#endif
+	      if (parameters[i].flags & FLAGS_QUAD)
+		parameters[i].data.number.as_unsigned = (argarray == NULL)
+		  ? (trio_uintmax_t)va_arg(*arglist, trio_ulonglong_t)
+		  : (trio_uintmax_t)(*((trio_ulonglong_t *)argarray[num]));
+	      else if (parameters[i].flags & FLAGS_LONG)
+		parameters[i].data.number.as_unsigned = (argarray == NULL)
+		  ? (trio_uintmax_t)va_arg(*arglist, long)
+		  : (trio_uintmax_t)(*((long *)argarray[num]));
+	      else
+		{
+		  if (argarray == NULL)
+		    parameters[i].data.number.as_unsigned = (trio_uintmax_t)va_arg(*arglist, int);
+		  else
+		    {
+		      if (parameters[i].type == FORMAT_CHAR)
+			parameters[i].data.number.as_unsigned = (trio_uintmax_t)(*((char *)argarray[num]));
+		      else if (parameters[i].flags & FLAGS_SHORT)
+			parameters[i].data.number.as_unsigned = (trio_uintmax_t)(*((short *)argarray[num]));
+		      else
+			parameters[i].data.number.as_unsigned = (trio_uintmax_t)(*((int *)argarray[num]));
+		    }
+		}
+	    }
+	  break;
+
+	case FORMAT_PARAMETER:
+	  /*
+	   * The parameter for the user-defined specifier is a pointer,
+	   * whereas the rest (width, precision, base) uses an integer.
+	   */
+	  if (parameters[i].flags & FLAGS_USER_DEFINED)
+	    parameters[i].data.pointer = (argarray == NULL)
+	      ? va_arg(*arglist, trio_pointer_t )
+	      : argarray[num];
+	  else
+	    parameters[i].data.number.as_unsigned = (argarray == NULL)
+	      ? (trio_uintmax_t)va_arg(*arglist, int)
+	      : (trio_uintmax_t)(*((int *)argarray[num]));
+	  break;
+
+	case FORMAT_DOUBLE:
+	  if (TYPE_SCAN == type)
+	    {
+	      if (parameters[i].flags & FLAGS_LONGDOUBLE)
+		parameters[i].data.longdoublePointer = (argarray == NULL)
+		  ? va_arg(*arglist, trio_long_double_t *)
+		  : (trio_long_double_t *)argarray[num];
+	      else
+                {
+		  if (parameters[i].flags & FLAGS_LONG)
+		    parameters[i].data.doublePointer = (argarray == NULL)
+		      ? va_arg(*arglist, double *)
+		      : (double *)argarray[num];
+		  else
+		    parameters[i].data.doublePointer = (argarray == NULL)
+		      ? (double *)va_arg(*arglist, float *)
+		      : (double *)((float *)argarray[num]);
+                }
+	    }
+	  else
+	    {
+	      if (parameters[i].flags & FLAGS_LONGDOUBLE)
+		parameters[i].data.longdoubleNumber = (argarray == NULL)
+		  ? va_arg(*arglist, trio_long_double_t)
+		  : (trio_long_double_t)(*((trio_long_double_t *)argarray[num]));
+	      else
+		{
+		  if (argarray == NULL)
+		    parameters[i].data.longdoubleNumber =
+		      (trio_long_double_t)va_arg(*arglist, double);
+		  else
+		    {
+		      if (parameters[i].flags & FLAGS_SHORT)
+			parameters[i].data.longdoubleNumber =
+			  (trio_long_double_t)(*((float *)argarray[num]));
+		      else
+			parameters[i].data.longdoubleNumber =
+			  (trio_long_double_t)(*((double *)argarray[num]));
+		    }
+		}
+	    }
+	  break;
+
+#if defined(FORMAT_ERRNO)
+	case FORMAT_ERRNO:
+	  parameters[i].data.errorNumber = save_errno;
+	  break;
+#endif
+
+	default:
+	  break;
+	}
+    } /* for all specifiers */
+  return num;
+}
+
+
+/*************************************************************************
+ *
+ * FORMATTING
+ *
+ ************************************************************************/
+
+
+/*************************************************************************
+ * TrioWriteNumber
+ *
+ * Description:
+ *  Output a number.
+ *  The complexity of this function is a result of the complexity
+ *  of the dependencies of the flags.
+ */
+TRIO_PRIVATE void
+TrioWriteNumber
+TRIO_ARGS6((self, number, flags, width, precision, base),
+	   trio_class_t *self,
+	   trio_uintmax_t number,
+	   trio_flags_t flags,
+	   int width,
+	   int precision,
+	   int base)
+{
+  BOOLEAN_T isNegative;
+  BOOLEAN_T isNumberZero;
+  BOOLEAN_T isPrecisionZero;
+  BOOLEAN_T ignoreNumber;
+  char buffer[MAX_CHARS_IN(trio_uintmax_t) * (1 + MAX_LOCALE_SEPARATOR_LENGTH) + 1];
+  char *bufferend;
+  char *pointer;
+  TRIO_CONST char *digits;
+  int i;
+  int length;
+  char *p;
+  int count;
+
+  assert(VALID(self));
+  assert(VALID(self->OutStream));
+  assert(((base >= MIN_BASE) && (base <= MAX_BASE)) || (base == NO_BASE));
+
+  digits = (flags & FLAGS_UPPER) ? internalDigitsUpper : internalDigitsLower;
+  if (base == NO_BASE)
+    base = BASE_DECIMAL;
+
+  isNumberZero = (number == 0);
+  isPrecisionZero = (precision == 0);
+  ignoreNumber = (isNumberZero
+		  && isPrecisionZero
+		  && !((flags & FLAGS_ALTERNATIVE) && (base == BASE_OCTAL)));
+
+  if (flags & FLAGS_UNSIGNED)
+    {
+      isNegative = FALSE;
+      flags &= ~FLAGS_SHOWSIGN;
+    }
+  else
+    {
+      isNegative = ((trio_intmax_t)number < 0);
+      if (isNegative)
+	number = -((trio_intmax_t)number);
+    }
+
+  if (flags & FLAGS_QUAD)
+    number &= (trio_ulonglong_t)-1;
+  else if (flags & FLAGS_LONG)
+    number &= (unsigned long)-1;
+  else
+    number &= (unsigned int)-1;
+  
+  /* Build number */
+  pointer = bufferend = &buffer[sizeof(buffer) - 1];
+  *pointer-- = NIL;
+  for (i = 1; i < (int)sizeof(buffer); i++)
+    {
+      *pointer-- = digits[number % base];
+      number /= base;
+      if (number == 0)
+	break;
+
+      if ((flags & FLAGS_QUOTE) && TrioFollowedBySeparator(i + 1))
+	{
+	  /*
+	   * We are building the number from the least significant
+	   * to the most significant digit, so we have to copy the
+	   * thousand separator backwards
+	   */
+	  length = internalThousandSeparatorLength;
+	  if (((int)(pointer - buffer) - length) > 0)
+	    {
+	      p = &internalThousandSeparator[length - 1];
+	      while (length-- > 0)
+		*pointer-- = *p--;
+	    }
+	}
+    }
+
+  if (! ignoreNumber)
+    {
+      /* Adjust width */
+      width -= (bufferend - pointer) - 1;
+    }
+
+  /* Adjust precision */
+  if (NO_PRECISION != precision)
+    {
+      precision -= (bufferend - pointer) - 1;
+      if (precision < 0)
+	precision = 0;
+      flags |= FLAGS_NILPADDING;
+    }
+
+  /* Calculate padding */
+  count = (! ((flags & FLAGS_LEFTADJUST) || (precision == NO_PRECISION)))
+    ? precision
+    : 0;
+  
+  /* Adjust width further */
+  if (isNegative || (flags & FLAGS_SHOWSIGN) || (flags & FLAGS_SPACE))
+    width--;
+  if ((flags & FLAGS_ALTERNATIVE) && !isNumberZero)
+    {
+      switch (base)
+	{
+	case BASE_BINARY:
+	case BASE_HEX:
+	  width -= 2;
+	  break;
+	case BASE_OCTAL:
+	  if (!(flags & FLAGS_NILPADDING) || (count == 0))
+	    width--;
+	  break;
+	default:
+	  break;
+	}
+    }
+
+  /* Output prefixes spaces if needed */
+  if (! ((flags & FLAGS_LEFTADJUST) ||
+	 ((flags & FLAGS_NILPADDING) && (precision == NO_PRECISION))))
+    {
+      while (width-- > count)
+	self->OutStream(self, CHAR_ADJUST);
+    }
+
+  /* width has been adjusted for signs and alternatives */
+  if (isNegative)
+    self->OutStream(self, '-');
+  else if (flags & FLAGS_SHOWSIGN)
+    self->OutStream(self, '+');
+  else if (flags & FLAGS_SPACE)
+    self->OutStream(self, ' ');
+
+  /* Prefix is not written when the value is zero */
+  if ((flags & FLAGS_ALTERNATIVE) && !isNumberZero)
+    {
+      switch (base)
+	{
+	case BASE_BINARY:
+	  self->OutStream(self, '0');
+	  self->OutStream(self, (flags & FLAGS_UPPER) ? 'B' : 'b');
+	  break;
+
+	case BASE_OCTAL:
+	  if (!(flags & FLAGS_NILPADDING) || (count == 0))
+	    self->OutStream(self, '0');
+	  break;
+
+	case BASE_HEX:
+	  self->OutStream(self, '0');
+	  self->OutStream(self, (flags & FLAGS_UPPER) ? 'X' : 'x');
+	  break;
+
+	default:
+	  break;
+	} /* switch base */
+    }
+
+  /* Output prefixed zero padding if needed */
+  if (flags & FLAGS_NILPADDING)
+    {
+      if (precision == NO_PRECISION)
+	precision = width;
+      while (precision-- > 0)
+	{
+	  self->OutStream(self, '0');
+	  width--;
+	}
+    }
+
+  if (! ignoreNumber)
+    {
+      /* Output the number itself */
+      while (*(++pointer))
+	{
+	  self->OutStream(self, *pointer);
+	}
+    }
+
+  /* Output trailing spaces if needed */
+  if (flags & FLAGS_LEFTADJUST)
+    {
+      while (width-- > 0)
+	self->OutStream(self, CHAR_ADJUST);
+    }
+}
+
+/*************************************************************************
+ * TrioWriteStringCharacter
+ *
+ * Description:
+ *  Output a single character of a string
+ */
+TRIO_PRIVATE void
+TrioWriteStringCharacter
+TRIO_ARGS3((self, ch, flags),
+	   trio_class_t *self,
+	   int ch,
+	   trio_flags_t flags)
+{
+  if (flags & FLAGS_ALTERNATIVE)
+    {
+      if (! isprint(ch))
+	{
+	  /*
+	   * Non-printable characters are converted to C escapes or
+	   * \number, if no C escape exists.
+	   */
+	  self->OutStream(self, CHAR_BACKSLASH);
+	  switch (ch)
+	    {
+	    case '\007': self->OutStream(self, 'a'); break;
+	    case '\b': self->OutStream(self, 'b'); break;
+	    case '\f': self->OutStream(self, 'f'); break;
+	    case '\n': self->OutStream(self, 'n'); break;
+	    case '\r': self->OutStream(self, 'r'); break;
+	    case '\t': self->OutStream(self, 't'); break;
+	    case '\v': self->OutStream(self, 'v'); break;
+	    case '\\': self->OutStream(self, '\\'); break;
+	    default:
+	      self->OutStream(self, 'x');
+	      TrioWriteNumber(self, (trio_uintmax_t)ch,
+			      FLAGS_UNSIGNED | FLAGS_NILPADDING,
+			      2, 2, BASE_HEX);
+	      break;
+	    }
+	}
+      else if (ch == CHAR_BACKSLASH)
+	{
+	  self->OutStream(self, CHAR_BACKSLASH);
+	  self->OutStream(self, CHAR_BACKSLASH);
+	}
+      else
+	{
+	  self->OutStream(self, ch);
+	}
+    }
+  else
+    {
+      self->OutStream(self, ch);
+    }
+}
+
+/*************************************************************************
+ * TrioWriteString
+ *
+ * Description:
+ *  Output a string
+ */
+TRIO_PRIVATE void
+TrioWriteString
+TRIO_ARGS5((self, string, flags, width, precision),
+	   trio_class_t *self,
+	   TRIO_CONST char *string,
+	   trio_flags_t flags,
+	   int width,
+	   int precision)
+{
+  int length;
+  int ch;
+
+  assert(VALID(self));
+  assert(VALID(self->OutStream));
+
+  if (string == NULL)
+    {
+      string = internalNullString;
+      length = sizeof(internalNullString) - 1;
+      /* Disable quoting for the null pointer */
+      flags &= (~FLAGS_QUOTE);
+      width = 0;
+    }
+  else
+    {
+      length = trio_length(string);
+    }
+  if ((NO_PRECISION != precision) &&
+      (precision < length))
+    {
+      length = precision;
+    }
+  width -= length;
+
+  if (flags & FLAGS_QUOTE)
+    self->OutStream(self, CHAR_QUOTE);
+
+  if (! (flags & FLAGS_LEFTADJUST))
+    {
+      while (width-- > 0)
+	self->OutStream(self, CHAR_ADJUST);
+    }
+
+  while (length-- > 0)
+    {
+      /* The ctype parameters must be an unsigned char (or EOF) */
+      ch = (int)((unsigned char)(*string++));
+      TrioWriteStringCharacter(self, ch, flags);
+    }
+
+  if (flags & FLAGS_LEFTADJUST)
+    {
+      while (width-- > 0)
+	self->OutStream(self, CHAR_ADJUST);
+    }
+  if (flags & FLAGS_QUOTE)
+    self->OutStream(self, CHAR_QUOTE);
+}
+
+/*************************************************************************
+ * TrioWriteWideStringCharacter
+ *
+ * Description:
+ *  Output a wide string as a multi-byte sequence
+ */
+#if TRIO_WIDECHAR
+TRIO_PRIVATE int
+TrioWriteWideStringCharacter
+TRIO_ARGS4((self, wch, flags, width),
+	   trio_class_t *self,
+	   trio_wchar_t wch,
+	   trio_flags_t flags,
+	   int width)
+{
+  int size;
+  int i;
+  int ch;
+  char *string;
+  char buffer[MB_LEN_MAX + 1];
+
+  if (width == NO_WIDTH)
+    width = sizeof(buffer);
+  
+  size = wctomb(buffer, wch);
+  if ((size <= 0) || (size > width) || (buffer[0] == NIL))
+    return 0;
+
+  string = buffer;
+  i = size;
+  while ((width >= i) && (width-- > 0) && (i-- > 0))
+    {
+      /* The ctype parameters must be an unsigned char (or EOF) */
+      ch = (int)((unsigned char)(*string++));
+      TrioWriteStringCharacter(self, ch, flags);
+    }
+  return size;
+}
+#endif /* TRIO_WIDECHAR */
+
+/*************************************************************************
+ * TrioWriteWideString
+ *
+ * Description:
+ *  Output a wide character string as a multi-byte string
+ */
+#if TRIO_WIDECHAR
+TRIO_PRIVATE void
+TrioWriteWideString
+TRIO_ARGS5((self, wstring, flags, width, precision),
+	   trio_class_t *self,
+	   TRIO_CONST trio_wchar_t *wstring,
+	   trio_flags_t flags,
+	   int width,
+	   int precision)
+{
+  int length;
+  int size;
+
+  assert(VALID(self));
+  assert(VALID(self->OutStream));
+
+#if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE)
+  (void)mblen(NULL, 0);
+#endif
+  
+  if (wstring == NULL)
+    {
+      TrioWriteString(self, NULL, flags, width, precision);
+      return;
+    }
+  
+  if (NO_PRECISION == precision)
+    {
+      length = INT_MAX;
+    }
+  else
+    {
+      length = precision;
+      width -= length;
+    }
+
+  if (flags & FLAGS_QUOTE)
+    self->OutStream(self, CHAR_QUOTE);
+
+  if (! (flags & FLAGS_LEFTADJUST))
+    {
+      while (width-- > 0)
+	self->OutStream(self, CHAR_ADJUST);
+    }
+
+  while (length > 0)
+    {
+      size = TrioWriteWideStringCharacter(self, *wstring++, flags, length);
+      if (size == 0)
+	break; /* while */
+      length -= size;
+    }
+
+  if (flags & FLAGS_LEFTADJUST)
+    {
+      while (width-- > 0)
+	self->OutStream(self, CHAR_ADJUST);
+    }
+  if (flags & FLAGS_QUOTE)
+    self->OutStream(self, CHAR_QUOTE);
+}
+#endif /* TRIO_WIDECHAR */
+
+/*************************************************************************
+ * TrioWriteDouble
+ *
+ * http://wwwold.dkuug.dk/JTC1/SC22/WG14/www/docs/dr_211.htm
+ *
+ * "5.2.4.2.2 paragraph #4
+ *
+ *  The accuracy [...] is implementation defined, as is the accuracy
+ *  of the conversion between floating-point internal representations
+ *  and string representations performed by the libray routine in
+ *  <stdio.h>"
+ */
+/* FIXME: handle all instances of constant long-double number (L)
+ *   and *l() math functions.
+ */
+TRIO_PRIVATE void
+TrioWriteDouble
+TRIO_ARGS6((self, number, flags, width, precision, base),
+	   trio_class_t *self,
+	   trio_long_double_t number,
+	   trio_flags_t flags,
+	   int width,
+	   int precision,
+	   int base)
+{
+  trio_long_double_t integerNumber;
+  trio_long_double_t fractionNumber;
+  trio_long_double_t workNumber;
+  int integerDigits;
+  int fractionDigits;
+  int exponentDigits;
+  int baseDigits;
+  int integerThreshold;
+  int fractionThreshold;
+  int expectedWidth;
+  int exponent = 0;
+  unsigned int uExponent = 0;
+  int exponentBase;
+  trio_long_double_t dblBase;
+  trio_long_double_t dblIntegerBase;
+  trio_long_double_t dblFractionBase;
+  trio_long_double_t integerAdjust;
+  trio_long_double_t fractionAdjust;
+  BOOLEAN_T isNegative;
+  BOOLEAN_T isExponentNegative = FALSE;
+  BOOLEAN_T requireTwoDigitExponent;
+  BOOLEAN_T isHex;
+  TRIO_CONST char *digits;
+  char *groupingPointer;
+  int i;
+  int index;
+  BOOLEAN_T hasOnlyZeroes;
+  int zeroes = 0;
+  register int trailingZeroes;
+  BOOLEAN_T keepTrailingZeroes;
+  BOOLEAN_T keepDecimalPoint;
+  trio_long_double_t epsilon;
+  
+  assert(VALID(self));
+  assert(VALID(self->OutStream));
+  assert(((base >= MIN_BASE) && (base <= MAX_BASE)) || (base == NO_BASE));
+
+  /* Determine sign and look for special quantities */
+  switch (trio_fpclassify_and_signbit(number, &isNegative))
+    {
+    case TRIO_FP_NAN:
+      TrioWriteString(self,
+		      (flags & FLAGS_UPPER)
+		      ? NAN_UPPER
+		      : NAN_LOWER,
+		      flags, width, precision);
+      return;
+      
+    case TRIO_FP_INFINITE:
+      if (isNegative)
+	{
+	  /* Negative infinity */
+	  TrioWriteString(self,
+			  (flags & FLAGS_UPPER)
+			  ? "-" INFINITE_UPPER
+			  : "-" INFINITE_LOWER,
+			  flags, width, precision);
+	  return;
+	}
+      else
+	{
+	  /* Positive infinity */
+	  TrioWriteString(self,
+			  (flags & FLAGS_UPPER)
+			  ? INFINITE_UPPER
+			  : INFINITE_LOWER,
+			  flags, width, precision);
+	  return;
+	}
+
+    default:
+      /* Finitude */
+      break;
+    }
+  
+  /* Normal numbers */
+  if (flags & FLAGS_LONGDOUBLE)
+    {
+      baseDigits = (base == 10)
+	? LDBL_DIG
+	: (int)floor(LDBL_MANT_DIG / TrioLogarithmBase(base));
+      epsilon = LDBL_EPSILON;
+    }
+  else if (flags & FLAGS_SHORT)
+    {
+      baseDigits = (base == BASE_DECIMAL)
+	? FLT_DIG
+	: (int)floor(FLT_MANT_DIG / TrioLogarithmBase(base));
+      epsilon = FLT_EPSILON;
+    }
+  else
+    {
+      baseDigits = (base == BASE_DECIMAL)
+	? DBL_DIG
+	: (int)floor(DBL_MANT_DIG / TrioLogarithmBase(base));
+      epsilon = DBL_EPSILON;
+    }
+
+  digits = (flags & FLAGS_UPPER) ? internalDigitsUpper : internalDigitsLower;
+  isHex = (base == BASE_HEX);
+  if (base == NO_BASE)
+    base = BASE_DECIMAL;
+  dblBase = (trio_long_double_t)base;
+  keepTrailingZeroes = !( (flags & FLAGS_ROUNDING) ||
+			  ( (flags & FLAGS_FLOAT_G) &&
+			    !(flags & FLAGS_ALTERNATIVE) ) );
+
+  if (flags & FLAGS_ROUNDING)
+    precision = baseDigits;
+
+  if (precision == NO_PRECISION)
+    {
+      if (isHex)
+	{
+	  keepTrailingZeroes = FALSE;
+	  precision = FLT_MANT_DIG;
+	}
+      else
+	{
+	  precision = FLT_DIG;
+	}
+    }
+  
+  if (isNegative)
+    number = -number;
+
+  if (isHex)
+    flags |= FLAGS_FLOAT_E;
+  
+  if (flags & FLAGS_FLOAT_G)
+    {
+      if (precision == 0)
+	precision = 1;
+
+      if ((number < 1.0E-4) || (number > powl(base,
+					      (trio_long_double_t)precision)))
+	{
+	  /* Use scientific notation */
+	  flags |= FLAGS_FLOAT_E;
+	}
+      else if (number < 1.0)
+	{
+	  /*
+	   * Use normal notation. If the integer part of the number is
+	   * zero, then adjust the precision to include leading fractional
+	   * zeros.
+	   */
+	  workNumber = TrioLogarithm(number, base);
+	  workNumber = TRIO_FABS(workNumber);
+	  if (workNumber - floorl(workNumber) < 0.001)
+	    workNumber--;
+	  zeroes = (int)floorl(workNumber);
+	}
+    }
+
+  if (flags & FLAGS_FLOAT_E)
+    {
+      /* Scale the number */
+      workNumber = TrioLogarithm(number, base);
+      if (trio_isinf(workNumber) == -1)
+	{
+	  exponent = 0;
+	  /* Undo setting */
+	  if (flags & FLAGS_FLOAT_G)
+	    flags &= ~FLAGS_FLOAT_E;
+	}
+      else
+	{
+	  exponent = (int)floorl(workNumber);
+	  number /= powl(dblBase, (trio_long_double_t)exponent);
+	  isExponentNegative = (exponent < 0);
+	  uExponent = (isExponentNegative) ? -exponent : exponent;
+	  if (isHex)
+	    uExponent *= 4; /* log16(2) */
+	  /* No thousand separators */
+	  flags &= ~FLAGS_QUOTE;
+	}
+    }
+
+  integerNumber = floorl(number);
+  fractionNumber = number - integerNumber;
+  
+  /*
+   * Truncated number.
+   *
+   * Precision is number of significant digits for FLOAT_G
+   * and number of fractional digits for others.
+   */
+  integerDigits = (integerNumber > epsilon)
+    ? 1 + (int)TrioLogarithm(integerNumber, base)
+    : 1;
+  fractionDigits = ((flags & FLAGS_FLOAT_G) && (zeroes == 0))
+    ? precision - integerDigits
+    : zeroes + precision;
+
+  dblFractionBase = TrioPower(base, fractionDigits);
+  
+  workNumber = number + 0.5 / dblFractionBase;
+  if (floorl(number) != floorl(workNumber))
+    {
+      if (flags & FLAGS_FLOAT_E)
+	{
+	  /* Adjust if number was rounded up one digit (ie. 0.99 to 1.00) */
+	  exponent++;
+	  isExponentNegative = (exponent < 0);
+	  uExponent = (isExponentNegative) ? -exponent : exponent;
+	  if (isHex)
+	    uExponent *= 4; /* log16(2) */
+	  workNumber = (number + 0.5 / dblFractionBase) / dblBase;
+	  integerNumber = floorl(workNumber);
+	  fractionNumber = workNumber - integerNumber;
+	}
+      else
+	{
+	  /* Adjust if number was rounded up one digit (ie. 99 to 100) */
+	  integerNumber = floorl(number + 0.5);
+	  fractionNumber = 0.0;
+	  integerDigits = (integerNumber > epsilon)
+	    ? 1 + (int)TrioLogarithm(integerNumber, base)
+	    : 1;
+	}
+    }
+
+  /* Estimate accuracy */
+  integerAdjust = fractionAdjust = 0.5;
+  if (flags & FLAGS_ROUNDING)
+    {
+      if (integerDigits > baseDigits)
+	{
+	  integerThreshold = baseDigits;
+	  fractionDigits = 0;
+	  dblFractionBase = 1.0;
+	  fractionThreshold = 0;
+	  precision = 0; /* Disable decimal-point */
+	  integerAdjust = TrioPower(base, integerDigits - integerThreshold - 1);
+	  fractionAdjust = 0.0;
+	}
+      else
+	{
+	  integerThreshold = integerDigits;
+	  fractionThreshold = fractionDigits - integerThreshold;
+	  fractionAdjust = 1.0;
+	}
+    }
+  else
+    {
+      integerThreshold = INT_MAX;
+      fractionThreshold = INT_MAX;
+    }
+  
+  /*
+   * Calculate expected width.
+   *  sign + integer part + thousands separators + decimal point
+   *  + fraction + exponent
+   */
+  fractionAdjust /= dblFractionBase;
+  hasOnlyZeroes = (floorl((fractionNumber + fractionAdjust) * dblFractionBase) < epsilon);
+  keepDecimalPoint = ( (flags & FLAGS_ALTERNATIVE) ||
+		       !((precision == 0) ||
+			 (!keepTrailingZeroes && hasOnlyZeroes)) );
+  if (flags & FLAGS_FLOAT_E)
+    {
+      exponentDigits = (uExponent == 0)
+	? 1
+	: (int)ceil(TrioLogarithm((double)(uExponent + 1),
+				  (isHex) ? 10.0 : base));
+    }
+  else
+    exponentDigits = 0;
+  requireTwoDigitExponent = ((base == BASE_DECIMAL) && (exponentDigits == 1));
+
+  expectedWidth = integerDigits + fractionDigits
+    + (keepDecimalPoint
+       ? internalDecimalPointLength
+       : 0)
+    + ((flags & FLAGS_QUOTE)
+       ? TrioCalcThousandSeparatorLength(integerDigits)
+       : 0);
+  if (isNegative || (flags & FLAGS_SHOWSIGN) || (flags & FLAGS_SPACE))
+    expectedWidth += sizeof("-") - 1;
+  if (exponentDigits > 0)
+    expectedWidth += exponentDigits +
+      ((requireTwoDigitExponent ? sizeof("E+0") : sizeof("E+")) - 1);
+  if (isHex)
+    expectedWidth += sizeof("0X") - 1;
+  
+  /* Output prefixing */
+  if (flags & FLAGS_NILPADDING)
+    {
+      /* Leading zeros must be after sign */
+      if (isNegative)
+	self->OutStream(self, '-');
+      else if (flags & FLAGS_SHOWSIGN)
+	self->OutStream(self, '+');
+      else if (flags & FLAGS_SPACE)
+	self->OutStream(self, ' ');
+      if (isHex)
+	{
+	  self->OutStream(self, '0');
+	  self->OutStream(self, (flags & FLAGS_UPPER) ? 'X' : 'x');
+	}
+      if (!(flags & FLAGS_LEFTADJUST))
+	{
+	  for (i = expectedWidth; i < width; i++)
+	    {
+	      self->OutStream(self, '0');
+	    }
+	}
+    }
+  else
+    {
+      /* Leading spaces must be before sign */
+      if (!(flags & FLAGS_LEFTADJUST))
+	{
+	  for (i = expectedWidth; i < width; i++)
+	    {
+	      self->OutStream(self, CHAR_ADJUST);
+	    }
+	}
+      if (isNegative)
+	self->OutStream(self, '-');
+      else if (flags & FLAGS_SHOWSIGN)
+	self->OutStream(self, '+');
+      else if (flags & FLAGS_SPACE)
+	self->OutStream(self, ' ');
+      if (isHex)
+	{
+	  self->OutStream(self, '0');
+	  self->OutStream(self, (flags & FLAGS_UPPER) ? 'X' : 'x');
+	}
+    }
+  
+  /* Output the integer part and thousand separators */
+  dblIntegerBase = 1.0 / TrioPower(base, integerDigits - 1);
+  for (i = 0; i < integerDigits; i++)
+    {
+      workNumber = floorl(((integerNumber + integerAdjust) * dblIntegerBase));
+      if (i > integerThreshold)
+	{
+	  /* Beyond accuracy */
+	  self->OutStream(self, digits[0]);
+	}
+      else
+	{
+	  self->OutStream(self, digits[(int)fmodl(workNumber, dblBase)]);
+	}
+      dblIntegerBase *= dblBase;
+      
+      if (((flags & (FLAGS_FLOAT_E | FLAGS_QUOTE)) == FLAGS_QUOTE)
+	  && TrioFollowedBySeparator(integerDigits - i))
+	{
+	  for (groupingPointer = internalThousandSeparator;
+	       *groupingPointer != NIL;
+	       groupingPointer++)
+	    {
+	      self->OutStream(self, *groupingPointer);
+	    }
+	}
+    }
+  
+  /* Insert decimal point and build the fraction part */
+  trailingZeroes = 0;
+
+  if (keepDecimalPoint)
+    {
+      if (internalDecimalPoint)
+	{
+	  self->OutStream(self, internalDecimalPoint);
+	}
+      else
+	{
+	  for (i = 0; i < internalDecimalPointLength; i++)
+	    {
+	      self->OutStream(self, internalDecimalPointString[i]);
+	    }
+	}
+    }
+
+  for (i = 0; i < fractionDigits; i++)
+    {
+      if ((integerDigits > integerThreshold) || (i > fractionThreshold))
+	{
+	  /* Beyond accuracy */
+	  trailingZeroes++;
+	}
+      else
+	{
+	  fractionNumber *= dblBase;
+	  fractionAdjust *= dblBase;
+	  workNumber = floorl(fractionNumber + fractionAdjust);
+	  fractionNumber -= workNumber;
+	  index = (int)fmodl(workNumber, dblBase);
+	  if (index == 0)
+	    {
+	      trailingZeroes++;
+	    }
+	  else
+	    {
+	      while (trailingZeroes > 0)
+		{
+		  /* Not trailing zeroes after all */
+		  self->OutStream(self, digits[0]);
+		  trailingZeroes--;
+		}
+	      self->OutStream(self, digits[index]);
+	    }
+	}
+    }
+  
+  if (keepTrailingZeroes)
+    {
+      while (trailingZeroes > 0)
+	{
+	  self->OutStream(self, digits[0]);
+	  trailingZeroes--;
+	}
+    }
+  
+  /* Output exponent */
+  if (exponentDigits > 0)
+    {
+      self->OutStream(self,
+		      isHex
+		      ? ((flags & FLAGS_UPPER) ? 'P' : 'p')
+		      : ((flags & FLAGS_UPPER) ? 'E' : 'e'));
+      self->OutStream(self, (isExponentNegative) ? '-' : '+');
+
+      /* The exponent must contain at least two digits */
+      if (requireTwoDigitExponent)
+        self->OutStream(self, '0');
+
+      if (isHex)
+	base = 10.0;
+      exponentBase = (int)TrioPower(base, exponentDigits - 1);
+      for (i = 0; i < exponentDigits; i++)
+	{
+	  self->OutStream(self, digits[(uExponent / exponentBase) % base]);
+	  exponentBase /= base;
+	}
+    }
+  /* Output trailing spaces */
+  if (flags & FLAGS_LEFTADJUST)
+    {
+      for (i = expectedWidth; i < width; i++)
+	{
+	  self->OutStream(self, CHAR_ADJUST);
+	}
+    }
+}
+
+/*************************************************************************
+ * TrioFormatProcess
+ *
+ * Description:
+ *  This is the main engine for formatting output
+ */
+TRIO_PRIVATE int
+TrioFormatProcess
+TRIO_ARGS3((data, format, parameters),
+	   trio_class_t *data,
+	   TRIO_CONST char *format,
+	   trio_parameter_t *parameters)
+{
+#if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE)
+  int charlen;
+#endif
+  int i;
+  TRIO_CONST char *string;
+  trio_pointer_t pointer;
+  trio_flags_t flags;
+  int width;
+  int precision;
+  int base;
+  int index;
+  
+  index = 0;
+  i = 0;
+#if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE)
+  (void)mblen(NULL, 0);
+#endif
+  
+  while (format[index])
+    {
+#if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE)
+      if (! isascii(format[index]))
+	{
+	  charlen = mblen(&format[index], MB_LEN_MAX);
+	  /*
+	   * Only valid multibyte characters are handled here. Invalid
+	   * multibyte characters (charlen == -1) are handled as normal
+	   * characters.
+	   */
+	  if (charlen != -1)
+	    {
+	      while (charlen-- > 0)
+		{
+		  data->OutStream(data, format[index++]);
+		}
+	      continue; /* while characters left in formatting string */
+	    }
+	}
+#endif /* TRIO_COMPILER_SUPPORTS_MULTIBYTE */
+      if (CHAR_IDENTIFIER == format[index])
+	{
+	  if (CHAR_IDENTIFIER == format[index + 1])
+	    {
+	      data->OutStream(data, CHAR_IDENTIFIER);
+	      index += 2;
+	    }
+	  else
+	    {
+	      /* Skip the parameter entries */
+	      while (parameters[i].type == FORMAT_PARAMETER)
+		i++;
+	      
+	      flags = parameters[i].flags;
+
+	      /* Find width */
+	      width = parameters[i].width;
+	      if (flags & FLAGS_WIDTH_PARAMETER)
+		{
+		  /* Get width from parameter list */
+		  width = (int)parameters[width].data.number.as_signed;
+		  if (width < 0)
+		    {
+		      /*
+		       * A negative width is the same as the - flag and
+		       * a positive width.
+		       */
+		      flags |= FLAGS_LEFTADJUST;
+		      flags &= ~FLAGS_NILPADDING;
+		      width = -width;
+		    }
+		}
+	      
+	      /* Find precision */
+	      if (flags & FLAGS_PRECISION)
+		{
+		  precision = parameters[i].precision;
+		  if (flags & FLAGS_PRECISION_PARAMETER)
+		    {
+		      /* Get precision from parameter list */
+		      precision = (int)parameters[precision].data.number.as_signed;
+		      if (precision < 0)
+			{
+			  /*
+			   * A negative precision is the same as no
+			   * precision
+			   */
+			  precision = NO_PRECISION;
+			}
+		    }
+		}
+	      else
+		{
+		  precision = NO_PRECISION;
+		}
+
+	      /* Find base */
+	      base = parameters[i].base;
+	      if (flags & FLAGS_BASE_PARAMETER)
+		{
+		  /* Get base from parameter list */
+		  base = (int)parameters[base].data.number.as_signed;
+		}
+	      
+	      switch (parameters[i].type)
+		{
+		case FORMAT_CHAR:
+		  if (flags & FLAGS_QUOTE)
+		    data->OutStream(data, CHAR_QUOTE);
+		  if (! (flags & FLAGS_LEFTADJUST))
+		    {
+		      while (--width > 0)
+			data->OutStream(data, CHAR_ADJUST);
+		    }
+#if TRIO_WIDECHAR
+		  if (flags & FLAGS_WIDECHAR)
+		    {
+		      TrioWriteWideStringCharacter(data,
+						   (trio_wchar_t)parameters[i].data.number.as_signed,
+						   flags,
+						   NO_WIDTH);
+		    }
+		  else
+#endif
+		    {
+		      TrioWriteStringCharacter(data,
+					       (int)parameters[i].data.number.as_signed,
+					       flags);
+		    }
+
+		  if (flags & FLAGS_LEFTADJUST)
+		    {
+		      while(--width > 0)
+			data->OutStream(data, CHAR_ADJUST);
+		    }
+		  if (flags & FLAGS_QUOTE)
+		    data->OutStream(data, CHAR_QUOTE);
+
+		  break; /* FORMAT_CHAR */
+
+		case FORMAT_INT:
+		  TrioWriteNumber(data,
+				  parameters[i].data.number.as_unsigned,
+				  flags,
+				  width,
+				  precision,
+				  base);
+
+		  break; /* FORMAT_INT */
+
+		case FORMAT_DOUBLE:
+		  TrioWriteDouble(data,
+				  parameters[i].data.longdoubleNumber,
+				  flags,
+				  width,
+				  precision,
+				  base);
+		  break; /* FORMAT_DOUBLE */
+
+		case FORMAT_STRING:
+#if TRIO_WIDECHAR
+		  if (flags & FLAGS_WIDECHAR)
+		    {
+		      TrioWriteWideString(data,
+					  parameters[i].data.wstring,
+					  flags,
+					  width,
+					  precision);
+		    }
+		  else
+#endif
+		    {
+		      TrioWriteString(data,
+				      parameters[i].data.string,
+				      flags,
+				      width,
+				      precision);
+		    }
+		  break; /* FORMAT_STRING */
+
+		case FORMAT_POINTER:
+		  {
+		    trio_reference_t reference;
+		    
+		    reference.data = data;
+		    reference.parameter = &parameters[i];
+		    trio_print_pointer(&reference, parameters[i].data.pointer);
+		  }
+		  break; /* FORMAT_POINTER */
+
+		case FORMAT_COUNT:
+		  pointer = parameters[i].data.pointer;
+		  if (NULL != pointer)
+		    {
+		      /*
+		       * C99 paragraph 7.19.6.1.8 says "the number of
+		       * characters written to the output stream so far by
+		       * this call", which is data->committed
+		       */
+#if defined(QUALIFIER_SIZE_T) || defined(QUALIFIER_SIZE_T_UPPER)
+		      if (flags & FLAGS_SIZE_T)
+			*(size_t *)pointer = (size_t)data->committed;
+		      else
+#endif
+#if defined(QUALIFIER_PTRDIFF_T)
+		      if (flags & FLAGS_PTRDIFF_T)
+			*(ptrdiff_t *)pointer = (ptrdiff_t)data->committed;
+		      else
+#endif
+#if defined(QUALIFIER_INTMAX_T)
+		      if (flags & FLAGS_INTMAX_T)
+			*(trio_intmax_t *)pointer = (trio_intmax_t)data->committed;
+		      else
+#endif
+		      if (flags & FLAGS_QUAD)
+			{
+			  *(trio_ulonglong_t *)pointer = (trio_ulonglong_t)data->committed;
+			}
+		      else if (flags & FLAGS_LONG)
+			{
+			  *(long int *)pointer = (long int)data->committed;
+			}
+		      else if (flags & FLAGS_SHORT)
+			{
+			  *(short int *)pointer = (short int)data->committed;
+			}
+		      else
+			{
+			  *(int *)pointer = (int)data->committed;
+			}
+		    }
+		  break; /* FORMAT_COUNT */
+
+		case FORMAT_PARAMETER:
+		  break; /* FORMAT_PARAMETER */
+
+#if defined(FORMAT_ERRNO)
+		case FORMAT_ERRNO:
+		  string = trio_error(parameters[i].data.errorNumber);
+		  if (string)
+		    {
+		      TrioWriteString(data,
+				      string,
+				      flags,
+				      width,
+				      precision);
+		    }
+		  else
+		    {
+		      data->OutStream(data, '#');
+		      TrioWriteNumber(data,
+				      (trio_uintmax_t)parameters[i].data.errorNumber,
+				      flags,
+				      width,
+				      precision,
+				      BASE_DECIMAL);
+		    }
+		  break; /* FORMAT_ERRNO */
+#endif /* defined(FORMAT_ERRNO) */
+
+#if defined(FORMAT_USER_DEFINED)
+		case FORMAT_USER_DEFINED:
+		  {
+		    trio_reference_t reference;
+		    trio_userdef_t *def = NULL;
+
+		    if (parameters[i].user_name[0] == NIL)
+		      {
+			/* Use handle */
+			if ((i > 0) ||
+			    (parameters[i - 1].type == FORMAT_PARAMETER))
+			  def = (trio_userdef_t *)parameters[i - 1].data.pointer;
+		      }
+		    else
+		      {
+			/* Look up namespace */
+			def = TrioFindNamespace(parameters[i].user_name, NULL);
+		      }
+		    if (def) {
+		      reference.data = data;
+		      reference.parameter = &parameters[i];
+		      def->callback(&reference);
+		    }
+		  }
+		  break;
+#endif /* defined(FORMAT_USER_DEFINED) */
+		  
+		default:
+		  break;
+		} /* switch parameter type */
+
+	      /* Prepare for next */
+	      index = parameters[i].indexAfterSpecifier;
+	      i++;
+	    }
+	}
+      else /* not identifier */
+	{
+	  data->OutStream(data, format[index++]);
+	}
+    }
+  return data->processed;
+}
+
+/*************************************************************************
+ * TrioFormatRef
+ */
+TRIO_PRIVATE int
+TrioFormatRef
+TRIO_ARGS4((reference, format, arglist, argarray),
+	   trio_reference_t *reference,
+	   TRIO_CONST char *format,
+	   va_list *arglist,
+	   trio_pointer_t *argarray)
+{
+  int status;
+  trio_parameter_t parameters[MAX_PARAMETERS];
+
+  status = TrioParse(TYPE_PRINT, format, parameters, arglist, argarray);
+  if (status < 0)
+    return status;
+
+  status = TrioFormatProcess(reference->data, format, parameters);
+  if (reference->data->error != 0)
+    {
+      status = reference->data->error;
+    }
+  return status;
+}
+
+/*************************************************************************
+ * TrioFormat
+ */
+TRIO_PRIVATE int
+TrioFormat
+TRIO_ARGS6((destination, destinationSize, OutStream, format, arglist, argarray),
+	   trio_pointer_t destination,
+	   size_t destinationSize,
+	   void (*OutStream) TRIO_PROTO((trio_class_t *, int)),
+	   TRIO_CONST char *format,
+	   va_list *arglist,
+	   trio_pointer_t *argarray)
+{
+  int status;
+  trio_class_t data;
+  trio_parameter_t parameters[MAX_PARAMETERS];
+
+  assert(VALID(OutStream));
+  assert(VALID(format));
+
+  memset(&data, 0, sizeof(data));
+  data.OutStream = OutStream;
+  data.location = destination;
+  data.max = destinationSize;
+  data.error = 0;
+
+#if defined(USE_LOCALE)
+  if (NULL == internalLocaleValues)
+    {
+      TrioSetLocale();
+    }
+#endif
+
+  status = TrioParse(TYPE_PRINT, format, parameters, arglist, argarray);
+  if (status < 0)
+    return status;
+
+  status = TrioFormatProcess(&data, format, parameters);
+  if (data.error != 0)
+    {
+      status = data.error;
+    }
+  return status;
+}
+
+/*************************************************************************
+ * TrioOutStreamFile
+ */
+TRIO_PRIVATE void
+TrioOutStreamFile
+TRIO_ARGS2((self, output),
+	   trio_class_t *self,
+	   int output)
+{
+  FILE *file;
+
+  assert(VALID(self));
+  assert(VALID(self->location));
+
+  file = (FILE *)self->location;
+  self->processed++;
+  if (fputc(output, file) == EOF)
+    {
+      self->error = TRIO_ERROR_RETURN(TRIO_EOF, 0);
+    }
+  else
+    {
+      self->committed++;
+    }
+}
+
+/*************************************************************************
+ * TrioOutStreamFileDescriptor
+ */
+TRIO_PRIVATE void
+TrioOutStreamFileDescriptor
+TRIO_ARGS2((self, output),
+	   trio_class_t *self,
+	   int output)
+{
+  int fd;
+  char ch;
+
+  assert(VALID(self));
+
+  fd = *((int *)self->location);
+  ch = (char)output;
+  self->processed++;
+  if (write(fd, &ch, sizeof(char)) == -1)
+    {
+      self->error = TRIO_ERROR_RETURN(TRIO_ERRNO, 0);
+    }
+  else
+    {
+      self->committed++;
+    }
+}
+
+/*************************************************************************
+ * TrioOutStreamCustom
+ */
+TRIO_PRIVATE void
+TrioOutStreamCustom
+TRIO_ARGS2((self, output),
+	   trio_class_t *self,
+	   int output)
+{
+  int status;
+  trio_custom_t *data;
+
+  assert(VALID(self));
+  assert(VALID(self->location));
+
+  data = (trio_custom_t *)self->location;
+  if (data->stream.out)
+    {
+      status = (data->stream.out)(data->closure, output);
+      if (status >= 0)
+	{
+	  self->committed++;
+	}
+      else
+	{
+	  if (self->error == 0)
+	    {
+	      self->error = TRIO_ERROR_RETURN(TRIO_ECUSTOM, -status);
+	    }
+	}
+    }
+  self->processed++;
+}
+
+/*************************************************************************
+ * TrioOutStreamString
+ */
+TRIO_PRIVATE void
+TrioOutStreamString
+TRIO_ARGS2((self, output),
+	   trio_class_t *self,
+	   int output)
+{
+  char **buffer;
+
+  assert(VALID(self));
+  assert(VALID(self->location));
+
+  buffer = (char **)self->location;
+  **buffer = (char)output;
+  (*buffer)++;
+  self->processed++;
+  self->committed++;
+}
+
+/*************************************************************************
+ * TrioOutStreamStringMax
+ */
+TRIO_PRIVATE void
+TrioOutStreamStringMax
+TRIO_ARGS2((self, output),
+	   trio_class_t *self,
+	   int output)
+{
+  char **buffer;
+
+  assert(VALID(self));
+  assert(VALID(self->location));
+  
+  buffer = (char **)self->location;
+
+  if (self->processed < self->max)
+    {
+      **buffer = (char)output;
+      (*buffer)++;
+      self->committed++;
+    }
+  self->processed++;
+}
+
+/*************************************************************************
+ * TrioOutStreamStringDynamic
+ */
+TRIO_PRIVATE void
+TrioOutStreamStringDynamic
+TRIO_ARGS2((self, output),
+	   trio_class_t *self,
+	   int output)
+{
+  assert(VALID(self));
+  assert(VALID(self->location));
+
+  if (self->error == 0)
+    {
+      trio_xstring_append_char((trio_string_t *)self->location,
+			       (char)output);
+      self->committed++;
+    }
+  /* The processed variable must always be increased */
+  self->processed++;
+}
+
+/*************************************************************************
+ *
+ * Formatted printing functions
+ *
+ ************************************************************************/
+
+#if defined(TRIO_DOCUMENTATION)
+# include "doc/doc_printf.h"
+#endif
+/** @addtogroup Printf
+    @{
+*/
+
+/*************************************************************************
+ * printf
+ */
+
+/**
+   Print to standard output stream.
+
+   @param format Formatting string.
+   @param ... Arguments.
+   @return Number of printed characters.
+ */
+TRIO_PUBLIC int
+trio_printf
+TRIO_VARGS2((format, va_alist),
+	    TRIO_CONST char *format,
+	    TRIO_VA_DECL)
+{
+  int status;
+  va_list args;
+
+  assert(VALID(format));
+  
+  TRIO_VA_START(args, format);
+  status = TrioFormat(stdout, 0, TrioOutStreamFile, format, &args, NULL);
+  TRIO_VA_END(args);
+  return status;
+}
+
+/**
+   Print to standard output stream.
+
+   @param format Formatting string.
+   @param args Arguments.
+   @return Number of printed characters.
+ */
+TRIO_PUBLIC int
+trio_vprintf
+TRIO_ARGS2((format, args),
+	   TRIO_CONST char *format,
+	   va_list args)
+{
+  assert(VALID(format));
+
+  return TrioFormat(stdout, 0, TrioOutStreamFile, format, &args, NULL);
+}
+
+/**
+   Print to standard output stream.
+
+   @param format Formatting string.
+   @param args Arguments.
+   @return Number of printed characters.
+ */
+TRIO_PUBLIC int
+trio_printfv
+TRIO_ARGS2((format, args),
+	   TRIO_CONST char *format,
+	   trio_pointer_t * args)
+{
+  assert(VALID(format));
+
+  return TrioFormat(stdout, 0, TrioOutStreamFile, format, NULL, args);
+}
+
+/*************************************************************************
+ * fprintf
+ */
+
+/**
+   Print to file.
+
+   @param file File pointer.
+   @param format Formatting string.
+   @param ... Arguments.
+   @return Number of printed characters.
+ */
+TRIO_PUBLIC int
+trio_fprintf
+TRIO_VARGS3((file, format, va_alist),
+	    FILE *file,
+	    TRIO_CONST char *format,
+	    TRIO_VA_DECL)
+{
+  int status;
+  va_list args;
+
+  assert(VALID(file));
+  assert(VALID(format));
+  
+  TRIO_VA_START(args, format);
+  status = TrioFormat(file, 0, TrioOutStreamFile, format, &args, NULL);
+  TRIO_VA_END(args);
+  return status;
+}
+
+/**
+   Print to file.
+
+   @param file File pointer.
+   @param format Formatting string.
+   @param args Arguments.
+   @return Number of printed characters.
+ */
+TRIO_PUBLIC int
+trio_vfprintf
+TRIO_ARGS3((file, format, args),
+	   FILE *file,
+	   TRIO_CONST char *format,
+	   va_list args)
+{
+  assert(VALID(file));
+  assert(VALID(format));
+  
+  return TrioFormat(file, 0, TrioOutStreamFile, format, &args, NULL);
+}
+
+/**
+   Print to file.
+
+   @param file File pointer.
+   @param format Formatting string.
+   @param args Arguments.
+   @return Number of printed characters.
+ */
+TRIO_PUBLIC int
+trio_fprintfv
+TRIO_ARGS3((file, format, args),
+	   FILE *file,
+	   TRIO_CONST char *format,
+	   trio_pointer_t * args)
+{
+  assert(VALID(file));
+  assert(VALID(format));
+  
+  return TrioFormat(file, 0, TrioOutStreamFile, format, NULL, args);
+}
+
+/*************************************************************************
+ * dprintf
+ */
+
+/**
+   Print to file descriptor.
+
+   @param fd File descriptor.
+   @param format Formatting string.
+   @param ... Arguments.
+   @return Number of printed characters.
+ */
+TRIO_PUBLIC int
+trio_dprintf
+TRIO_VARGS3((fd, format, va_alist),
+	    int fd,
+	    TRIO_CONST char *format,
+	    TRIO_VA_DECL)
+{
+  int status;
+  va_list args;
+
+  assert(VALID(format));
+  
+  TRIO_VA_START(args, format);
+  status = TrioFormat(&fd, 0, TrioOutStreamFileDescriptor, format, &args, NULL);
+  TRIO_VA_END(args);
+  return status;
+}
+
+/**
+   Print to file descriptor.
+
+   @param fd File descriptor.
+   @param format Formatting string.
+   @param args Arguments.
+   @return Number of printed characters.
+ */
+TRIO_PUBLIC int
+trio_vdprintf
+TRIO_ARGS3((fd, format, args),
+	   int fd,
+	   TRIO_CONST char *format,
+	   va_list args)
+{
+  assert(VALID(format));
+  
+  return TrioFormat(&fd, 0, TrioOutStreamFileDescriptor, format, &args, NULL);
+}
+
+/**
+   Print to file descriptor.
+
+   @param fd File descriptor.
+   @param format Formatting string.
+   @param args Arguments.
+   @return Number of printed characters.
+ */
+TRIO_PUBLIC int
+trio_dprintfv
+TRIO_ARGS3((fd, format, args),
+	   int fd,
+	   TRIO_CONST char *format,
+	   trio_pointer_t *args)
+{
+  assert(VALID(format));
+  
+  return TrioFormat(&fd, 0, TrioOutStreamFileDescriptor, format, NULL, args);
+}
+
+/*************************************************************************
+ * cprintf
+ */
+TRIO_PUBLIC int
+trio_cprintf
+TRIO_VARGS4((stream, closure, format, va_alist),
+	    trio_outstream_t stream,
+	    trio_pointer_t closure,
+	    TRIO_CONST char *format,
+	    TRIO_VA_DECL)
+{
+  int status;
+  va_list args;
+  trio_custom_t data;
+
+  assert(VALID(stream));
+  assert(VALID(format));
+
+  TRIO_VA_START(args, format);
+  data.stream.out = stream;
+  data.closure = closure;
+  status = TrioFormat(&data, 0, TrioOutStreamCustom, format, &args, NULL);
+  TRIO_VA_END(args);
+  return status;
+}
+
+TRIO_PUBLIC int
+trio_vcprintf
+TRIO_ARGS4((stream, closure, format, args),
+	   trio_outstream_t stream,
+	   trio_pointer_t closure,
+	   TRIO_CONST char *format,
+	   va_list args)
+{
+  trio_custom_t data;
+
+  assert(VALID(stream));
+  assert(VALID(format));
+
+  data.stream.out = stream;
+  data.closure = closure;
+  return TrioFormat(&data, 0, TrioOutStreamCustom, format, &args, NULL);
+}
+
+TRIO_PUBLIC int
+trio_cprintfv
+TRIO_ARGS4((stream, closure, format, args),
+	   trio_outstream_t stream,
+	   trio_pointer_t closure,
+	   TRIO_CONST char *format,
+	   void **args)
+{
+  trio_custom_t data;
+
+  assert(VALID(stream));
+  assert(VALID(format));
+
+  data.stream.out = stream;
+  data.closure = closure;
+  return TrioFormat(&data, 0, TrioOutStreamCustom, format, NULL, args);
+}
+
+/*************************************************************************
+ * sprintf
+ */
+
+/**
+   Print to string.
+
+   @param buffer Output string.
+   @param format Formatting string.
+   @param ... Arguments.
+   @return Number of printed characters.
+ */
+TRIO_PUBLIC int
+trio_sprintf
+TRIO_VARGS3((buffer, format, va_alist),
+	    char *buffer,
+	    TRIO_CONST char *format,
+	    TRIO_VA_DECL)
+{
+  int status;
+  va_list args;
+
+  assert(VALID(buffer));
+  assert(VALID(format));
+  
+  TRIO_VA_START(args, format);
+  status = TrioFormat(&buffer, 0, TrioOutStreamString, format, &args, NULL);
+  *buffer = NIL; /* Terminate with NIL character */
+  TRIO_VA_END(args);
+  return status;
+}
+
+/**
+   Print to string.
+
+   @param buffer Output string.
+   @param format Formatting string.
+   @param args Arguments.
+   @return Number of printed characters.
+ */
+TRIO_PUBLIC int
+trio_vsprintf
+TRIO_ARGS3((buffer, format, args),
+	   char *buffer,
+	   TRIO_CONST char *format,
+	   va_list args)
+{
+  int status;
+
+  assert(VALID(buffer));
+  assert(VALID(format));
+
+  status = TrioFormat(&buffer, 0, TrioOutStreamString, format, &args, NULL);
+  *buffer = NIL;
+  return status;
+}
+
+/**
+   Print to string.
+
+   @param buffer Output string.
+   @param format Formatting string.
+   @param args Arguments.
+   @return Number of printed characters.
+ */
+TRIO_PUBLIC int
+trio_sprintfv
+TRIO_ARGS3((buffer, format, args),
+	   char *buffer,
+	   TRIO_CONST char *format,
+	   trio_pointer_t *args)
+{
+  int status;
+
+  assert(VALID(buffer));
+  assert(VALID(format));
+
+  status = TrioFormat(&buffer, 0, TrioOutStreamString, format, NULL, args);
+  *buffer = NIL;
+  return status;
+}
+
+/*************************************************************************
+ * snprintf
+ */
+
+/**
+   Print at most @p max characters to string.
+
+   @param buffer Output string.
+   @param max Maximum number of characters to print.
+   @param format Formatting string.
+   @param ... Arguments.
+   @return Number of printed characters.
+ */
+TRIO_PUBLIC int
+trio_snprintf
+TRIO_VARGS4((buffer, max, format, va_alist),
+	    char *buffer,
+	    size_t max,
+	    TRIO_CONST char *format,
+	    TRIO_VA_DECL)
+{
+  int status;
+  va_list args;
+
+  assert(VALID(buffer));
+  assert(VALID(format));
+
+  TRIO_VA_START(args, format);
+  status = TrioFormat(&buffer, max > 0 ? max - 1 : 0,
+		      TrioOutStreamStringMax, format, &args, NULL);
+  if (max > 0)
+    *buffer = NIL;
+  TRIO_VA_END(args);
+  return status;
+}
+
+/**
+   Print at most @p max characters to string.
+
+   @param buffer Output string.
+   @param max Maximum number of characters to print.
+   @param format Formatting string.
+   @param args Arguments.
+   @return Number of printed characters.
+ */
+TRIO_PUBLIC int
+trio_vsnprintf
+TRIO_ARGS4((buffer, max, format, args),
+	   char *buffer,
+	   size_t max,
+	   TRIO_CONST char *format,
+	   va_list args)
+{
+  int status;
+
+  assert(VALID(buffer));
+  assert(VALID(format));
+
+  status = TrioFormat(&buffer, max > 0 ? max - 1 : 0,
+		      TrioOutStreamStringMax, format, &args, NULL);
+  if (max > 0)
+    *buffer = NIL;
+  return status;
+}
+
+/**
+   Print at most @p max characters to string.
+
+   @param buffer Output string.
+   @param max Maximum number of characters to print.
+   @param format Formatting string.
+   @param args Arguments.
+   @return Number of printed characters.
+ */
+TRIO_PUBLIC int
+trio_snprintfv
+TRIO_ARGS4((buffer, max, format, args),
+	   char *buffer,
+	   size_t max,
+	   TRIO_CONST char *format,
+	   trio_pointer_t *args)
+{
+  int status;
+
+  assert(VALID(buffer));
+  assert(VALID(format));
+
+  status = TrioFormat(&buffer, max > 0 ? max - 1 : 0,
+		      TrioOutStreamStringMax, format, NULL, args);
+  if (max > 0)
+    *buffer = NIL;
+  return status;
+}
+
+/*************************************************************************
+ * snprintfcat
+ * Appends the new string to the buffer string overwriting the '\0'
+ * character at the end of buffer.
+ */
+TRIO_PUBLIC int
+trio_snprintfcat
+TRIO_VARGS4((buffer, max, format, va_alist),
+	    char *buffer,
+	    size_t max,
+	    TRIO_CONST char *format,
+	    TRIO_VA_DECL)
+{
+  int status;
+  va_list args;
+  size_t buf_len;
+
+  TRIO_VA_START(args, format);
+
+  assert(VALID(buffer));
+  assert(VALID(format));
+
+  buf_len = trio_length(buffer);
+  buffer = &buffer[buf_len];
+
+  status = TrioFormat(&buffer, max - 1 - buf_len,
+		      TrioOutStreamStringMax, format, &args, NULL);
+  TRIO_VA_END(args);
+  *buffer = NIL;
+  return status;
+}
+
+TRIO_PUBLIC int
+trio_vsnprintfcat
+TRIO_ARGS4((buffer, max, format, args),
+	   char *buffer,
+	   size_t max,
+	   TRIO_CONST char *format,
+	   va_list args)
+{
+  int status;
+  size_t buf_len;
+  
+  assert(VALID(buffer));
+  assert(VALID(format));
+
+  buf_len = trio_length(buffer);
+  buffer = &buffer[buf_len];
+  status = TrioFormat(&buffer, max - 1 - buf_len,
+		      TrioOutStreamStringMax, format, &args, NULL);
+  *buffer = NIL;
+  return status;
+}
+
+/*************************************************************************
+ * trio_aprintf
+ */
+
+/* Deprecated */
+TRIO_PUBLIC char *
+trio_aprintf
+TRIO_VARGS2((format, va_alist),
+	    TRIO_CONST char *format,
+	    TRIO_VA_DECL)
+{
+  va_list args;
+  trio_string_t *info;
+  char *result = NULL;
+
+  assert(VALID(format));
+  
+  info = trio_xstring_duplicate("");
+  if (info)
+    {
+      TRIO_VA_START(args, format);
+      (void)TrioFormat(info, 0, TrioOutStreamStringDynamic,
+		       format, &args, NULL);
+      TRIO_VA_END(args);
+
+      trio_string_terminate(info);
+      result = trio_string_extract(info);
+      trio_string_destroy(info);
+    }
+  return result;
+}
+
+/* Deprecated */
+TRIO_PUBLIC char *
+trio_vaprintf
+TRIO_ARGS2((format, args),
+	   TRIO_CONST char *format,
+	   va_list args)
+{
+  trio_string_t *info;
+  char *result = NULL;
+  
+  assert(VALID(format));
+  
+  info = trio_xstring_duplicate("");
+  if (info)
+    {
+      (void)TrioFormat(info, 0, TrioOutStreamStringDynamic,
+		       format, &args, NULL);
+      trio_string_terminate(info);
+      result = trio_string_extract(info);
+      trio_string_destroy(info);
+    }
+  return result;
+}
+
+TRIO_PUBLIC int
+trio_asprintf
+TRIO_VARGS3((result, format, va_alist),
+	    char **result,
+	    TRIO_CONST char *format,
+	    TRIO_VA_DECL)
+{
+  va_list args;
+  int status;
+  trio_string_t *info;
+
+  assert(VALID(format));
+
+  *result = NULL;
+  
+  info = trio_xstring_duplicate("");
+  if (info == NULL)
+    {
+      status = TRIO_ERROR_RETURN(TRIO_ENOMEM, 0);
+    }
+  else
+    {
+      TRIO_VA_START(args, format);
+      status = TrioFormat(info, 0, TrioOutStreamStringDynamic,
+			  format, &args, NULL);
+      TRIO_VA_END(args);
+      if (status >= 0)
+	{
+	  trio_string_terminate(info);
+	  *result = trio_string_extract(info);
+	}
+      trio_string_destroy(info);
+    }
+  return status;
+}
+
+TRIO_PUBLIC int
+trio_vasprintf
+TRIO_ARGS3((result, format, args),
+	   char **result,
+	   TRIO_CONST char *format,
+	   va_list args)
+{
+  int status;
+  trio_string_t *info;
+  
+  assert(VALID(format));
+
+  *result = NULL;
+  
+  info = trio_xstring_duplicate("");
+  if (info == NULL)
+    {
+      status = TRIO_ERROR_RETURN(TRIO_ENOMEM, 0);
+    }
+  else
+    {
+      status = TrioFormat(info, 0, TrioOutStreamStringDynamic,
+			  format, &args, NULL);
+      if (status >= 0)
+	{
+	  trio_string_terminate(info);
+	  *result = trio_string_extract(info);
+	}
+      trio_string_destroy(info);
+    }
+  return status;
+}
+
+/** @} End of Printf documentation module */
+
+/*************************************************************************
+ *
+ * CALLBACK
+ *
+ ************************************************************************/
+
+#if defined(TRIO_DOCUMENTATION)
+# include "doc/doc_register.h"
+#endif
+/**
+   @addtogroup UserDefined
+   @{
+*/
+
+#if TRIO_EXTENSION
+
+/*************************************************************************
+ * trio_register
+ */
+
+/**
+   Register new user-defined specifier.
+
+   @param callback
+   @param name
+   @return Handle.
+ */
+TRIO_PUBLIC trio_pointer_t 
+trio_register
+TRIO_ARGS2((callback, name),
+	   trio_callback_t callback,
+	   TRIO_CONST char *name)
+{
+  trio_userdef_t *def;
+  trio_userdef_t *prev = NULL;
+
+  if (callback == NULL)
+    return NULL;
+
+  if (name)
+    {
+      /* Handle built-in namespaces */
+      if (name[0] == ':')
+	{
+	  if (trio_equal(name, ":enter"))
+	    {
+	      internalEnterCriticalRegion = callback;
+	    }
+	  else if (trio_equal(name, ":leave"))
+	    {
+	      internalLeaveCriticalRegion = callback;
+	    }
+	  return NULL;
+	}
+      
+      /* Bail out if namespace is too long */
+      if (trio_length(name) >= MAX_USER_NAME)
+	return NULL;
+      
+      /* Bail out if namespace already is registered */
+      def = TrioFindNamespace(name, &prev);
+      if (def)
+	return NULL;
+    }
+  
+  def = (trio_userdef_t *)TRIO_MALLOC(sizeof(trio_userdef_t));
+  if (def)
+    {
+      if (internalEnterCriticalRegion)
+	(void)internalEnterCriticalRegion(NULL);
+      
+      if (name)
+	{
+	  /* Link into internal list */
+	  if (prev == NULL)
+	    internalUserDef = def;
+	  else
+	    prev->next = def;
+	}
+      /* Initialize */
+      def->callback = callback;
+      def->name = (name == NULL)
+	? NULL
+	: trio_duplicate(name);
+      def->next = NULL;
+
+      if (internalLeaveCriticalRegion)
+	(void)internalLeaveCriticalRegion(NULL);
+    }
+  return (trio_pointer_t)def;
+}
+
+/**
+   Unregister an existing user-defined specifier.
+
+   @param handle
+ */
+void
+trio_unregister
+TRIO_ARGS1((handle),
+	   trio_pointer_t handle)
+{
+  trio_userdef_t *self = (trio_userdef_t *)handle;
+  trio_userdef_t *def;
+  trio_userdef_t *prev = NULL;
+
+  assert(VALID(self));
+
+  if (self->name)
+    {
+      def = TrioFindNamespace(self->name, &prev);
+      if (def)
+	{
+	  if (internalEnterCriticalRegion)
+	    (void)internalEnterCriticalRegion(NULL);
+	  
+	  if (prev == NULL)
+	    internalUserDef = NULL;
+	  else
+	    prev->next = def->next;
+	  
+	  if (internalLeaveCriticalRegion)
+	    (void)internalLeaveCriticalRegion(NULL);
+	}
+      trio_destroy(self->name);
+    }
+  TRIO_FREE(self);
+}
+
+/*************************************************************************
+ * trio_get_format [public]
+ */
+TRIO_CONST char *
+trio_get_format
+TRIO_ARGS1((ref),
+	   trio_pointer_t ref)
+{
+#if defined(FORMAT_USER_DEFINED)
+  assert(((trio_reference_t *)ref)->parameter->type == FORMAT_USER_DEFINED);
+#endif
+  
+  return (((trio_reference_t *)ref)->parameter->user_data);
+}
+
+/*************************************************************************
+ * trio_get_argument [public]
+ */
+trio_pointer_t 
+trio_get_argument
+TRIO_ARGS1((ref),
+	   trio_pointer_t ref)
+{
+#if defined(FORMAT_USER_DEFINED)
+  assert(((trio_reference_t *)ref)->parameter->type == FORMAT_USER_DEFINED);
+#endif
+  
+  return ((trio_reference_t *)ref)->parameter->data.pointer;
+}
+
+/*************************************************************************
+ * trio_get_width / trio_set_width [public]
+ */
+int
+trio_get_width
+TRIO_ARGS1((ref),
+	   trio_pointer_t ref)
+{
+  return ((trio_reference_t *)ref)->parameter->width;
+}
+
+void
+trio_set_width
+TRIO_ARGS2((ref, width),
+	   trio_pointer_t ref,
+	   int width)
+{
+  ((trio_reference_t *)ref)->parameter->width = width;
+}
+
+/*************************************************************************
+ * trio_get_precision / trio_set_precision [public]
+ */
+int
+trio_get_precision
+TRIO_ARGS1((ref),
+	   trio_pointer_t ref)
+{
+  return (((trio_reference_t *)ref)->parameter->precision);
+}
+
+void
+trio_set_precision
+TRIO_ARGS2((ref, precision),
+	   trio_pointer_t ref,
+	   int precision)
+{
+  ((trio_reference_t *)ref)->parameter->precision = precision;
+}
+
+/*************************************************************************
+ * trio_get_base / trio_set_base [public]
+ */
+int
+trio_get_base
+TRIO_ARGS1((ref),
+	   trio_pointer_t ref)
+{
+  return (((trio_reference_t *)ref)->parameter->base);
+}
+
+void
+trio_set_base
+TRIO_ARGS2((ref, base),
+	   trio_pointer_t ref,
+	   int base)
+{
+  ((trio_reference_t *)ref)->parameter->base = base;
+}
+
+/*************************************************************************
+ * trio_get_long / trio_set_long [public]
+ */
+int
+trio_get_long
+TRIO_ARGS1((ref),
+	   trio_pointer_t ref)
+{
+  return (((trio_reference_t *)ref)->parameter->flags & FLAGS_LONG)
+    ? TRUE
+    : FALSE;
+}
+
+void
+trio_set_long
+TRIO_ARGS2((ref, is_long),
+	   trio_pointer_t ref,
+	   int is_long)
+{
+  if (is_long)
+    ((trio_reference_t *)ref)->parameter->flags |= FLAGS_LONG;
+  else
+    ((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_LONG;
+}
+
+/*************************************************************************
+ * trio_get_longlong / trio_set_longlong [public]
+ */
+int
+trio_get_longlong
+TRIO_ARGS1((ref),
+	   trio_pointer_t ref)
+{
+  return (((trio_reference_t *)ref)->parameter->flags & FLAGS_QUAD)
+    ? TRUE
+    : FALSE;
+}
+
+void
+trio_set_longlong
+TRIO_ARGS2((ref, is_longlong),
+	   trio_pointer_t ref,
+	   int is_longlong)
+{
+  if (is_longlong)
+    ((trio_reference_t *)ref)->parameter->flags |= FLAGS_QUAD;
+  else
+    ((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_QUAD;
+}
+
+/*************************************************************************
+ * trio_get_longdouble / trio_set_longdouble [public]
+ */
+int
+trio_get_longdouble
+TRIO_ARGS1((ref),
+	   trio_pointer_t ref)
+{
+  return (((trio_reference_t *)ref)->parameter->flags & FLAGS_LONGDOUBLE)
+    ? TRUE
+    : FALSE;
+}
+
+void
+trio_set_longdouble
+TRIO_ARGS2((ref, is_longdouble),
+	   trio_pointer_t ref,
+	   int is_longdouble)
+{
+  if (is_longdouble)
+    ((trio_reference_t *)ref)->parameter->flags |= FLAGS_LONGDOUBLE;
+  else
+    ((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_LONGDOUBLE;
+}
+
+/*************************************************************************
+ * trio_get_short / trio_set_short [public]
+ */
+int
+trio_get_short
+TRIO_ARGS1((ref),
+	   trio_pointer_t ref)
+{
+  return (((trio_reference_t *)ref)->parameter->flags & FLAGS_SHORT)
+    ? TRUE
+    : FALSE;
+}
+
+void
+trio_set_short
+TRIO_ARGS2((ref, is_short),
+	   trio_pointer_t ref,
+	   int is_short)
+{
+  if (is_short)
+    ((trio_reference_t *)ref)->parameter->flags |= FLAGS_SHORT;
+  else
+    ((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_SHORT;
+}
+
+/*************************************************************************
+ * trio_get_shortshort / trio_set_shortshort [public]
+ */
+int
+trio_get_shortshort
+TRIO_ARGS1((ref),
+	   trio_pointer_t ref)
+{
+  return (((trio_reference_t *)ref)->parameter->flags & FLAGS_SHORTSHORT)
+    ? TRUE
+    : FALSE;
+}
+
+void
+trio_set_shortshort
+TRIO_ARGS2((ref, is_shortshort),
+	   trio_pointer_t ref,
+	   int is_shortshort)
+{
+  if (is_shortshort)
+    ((trio_reference_t *)ref)->parameter->flags |= FLAGS_SHORTSHORT;
+  else
+    ((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_SHORTSHORT;
+}
+
+/*************************************************************************
+ * trio_get_alternative / trio_set_alternative [public]
+ */
+int
+trio_get_alternative
+TRIO_ARGS1((ref),
+	   trio_pointer_t ref)
+{
+  return (((trio_reference_t *)ref)->parameter->flags & FLAGS_ALTERNATIVE)
+    ? TRUE
+    : FALSE;
+}
+
+void
+trio_set_alternative
+TRIO_ARGS2((ref, is_alternative),
+	   trio_pointer_t ref,
+	   int is_alternative)
+{
+  if (is_alternative)
+    ((trio_reference_t *)ref)->parameter->flags |= FLAGS_ALTERNATIVE;
+  else
+    ((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_ALTERNATIVE;
+}
+
+/*************************************************************************
+ * trio_get_alignment / trio_set_alignment [public]
+ */
+int
+trio_get_alignment
+TRIO_ARGS1((ref),
+	   trio_pointer_t ref)
+{
+  return (((trio_reference_t *)ref)->parameter->flags & FLAGS_LEFTADJUST)
+    ? TRUE
+    : FALSE;
+}
+
+void
+trio_set_alignment
+TRIO_ARGS2((ref, is_leftaligned),
+	   trio_pointer_t ref,
+	   int is_leftaligned)
+{
+  if (is_leftaligned)
+    ((trio_reference_t *)ref)->parameter->flags |= FLAGS_LEFTADJUST;
+  else
+    ((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_LEFTADJUST;
+}
+
+/*************************************************************************
+ * trio_get_spacing /trio_set_spacing [public]
+ */
+int
+trio_get_spacing
+TRIO_ARGS1((ref),
+	   trio_pointer_t ref)
+{
+  return (((trio_reference_t *)ref)->parameter->flags & FLAGS_SPACE)
+    ? TRUE
+    : FALSE;
+}
+
+void
+trio_set_spacing
+TRIO_ARGS2((ref, is_space),
+	   trio_pointer_t ref,
+	   int is_space)
+{
+  if (is_space)
+    ((trio_reference_t *)ref)->parameter->flags |= FLAGS_SPACE;
+  else
+    ((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_SPACE;
+}
+
+/*************************************************************************
+ * trio_get_sign / trio_set_sign [public]
+ */
+int
+trio_get_sign
+TRIO_ARGS1((ref),
+	   trio_pointer_t ref)
+{
+  return (((trio_reference_t *)ref)->parameter->flags & FLAGS_SHOWSIGN)
+    ? TRUE
+    : FALSE;
+}
+
+void
+trio_set_sign
+TRIO_ARGS2((ref, is_sign),
+	   trio_pointer_t ref,
+	   int is_sign)
+{
+  if (is_sign)
+    ((trio_reference_t *)ref)->parameter->flags |= FLAGS_SHOWSIGN;
+  else
+    ((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_SHOWSIGN;
+}
+
+/*************************************************************************
+ * trio_get_padding / trio_set_padding [public]
+ */
+int
+trio_get_padding
+TRIO_ARGS1((ref),
+	   trio_pointer_t ref)
+{
+  return (((trio_reference_t *)ref)->parameter->flags & FLAGS_NILPADDING)
+    ? TRUE
+    : FALSE;
+}
+
+void
+trio_set_padding
+TRIO_ARGS2((ref, is_padding),
+	   trio_pointer_t ref,
+	   int is_padding)
+{
+  if (is_padding)
+    ((trio_reference_t *)ref)->parameter->flags |= FLAGS_NILPADDING;
+  else
+    ((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_NILPADDING;
+}
+
+/*************************************************************************
+ * trio_get_quote / trio_set_quote [public]
+ */
+int
+trio_get_quote
+TRIO_ARGS1((ref),
+	   trio_pointer_t ref)
+{
+  return (((trio_reference_t *)ref)->parameter->flags & FLAGS_QUOTE)
+    ? TRUE
+    : FALSE;
+}
+
+void
+trio_set_quote
+TRIO_ARGS2((ref, is_quote),
+	   trio_pointer_t ref,
+	   int is_quote)
+{
+  if (is_quote)
+    ((trio_reference_t *)ref)->parameter->flags |= FLAGS_QUOTE;
+  else
+    ((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_QUOTE;
+}
+
+/*************************************************************************
+ * trio_get_upper / trio_set_upper [public]
+ */
+int
+trio_get_upper
+TRIO_ARGS1((ref),
+	   trio_pointer_t ref)
+{
+  return (((trio_reference_t *)ref)->parameter->flags & FLAGS_UPPER)
+    ? TRUE
+    : FALSE;
+}
+
+void
+trio_set_upper
+TRIO_ARGS2((ref, is_upper),
+	   trio_pointer_t ref,
+	   int is_upper)
+{
+  if (is_upper)
+    ((trio_reference_t *)ref)->parameter->flags |= FLAGS_UPPER;
+  else
+    ((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_UPPER;
+}
+
+/*************************************************************************
+ * trio_get_largest / trio_set_largest [public]
+ */
+#if TRIO_C99
+int
+trio_get_largest
+TRIO_ARGS1((ref),
+	   trio_pointer_t ref)
+{
+  return (((trio_reference_t *)ref)->parameter->flags & FLAGS_INTMAX_T)
+    ? TRUE
+    : FALSE;
+}
+
+void
+trio_set_largest
+TRIO_ARGS2((ref, is_largest),
+	   trio_pointer_t ref,
+	   int is_largest)
+{
+  if (is_largest)
+    ((trio_reference_t *)ref)->parameter->flags |= FLAGS_INTMAX_T;
+  else
+    ((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_INTMAX_T;
+}
+#endif
+
+/*************************************************************************
+ * trio_get_ptrdiff / trio_set_ptrdiff [public]
+ */
+int
+trio_get_ptrdiff
+TRIO_ARGS1((ref),
+	   trio_pointer_t ref)
+{
+  return (((trio_reference_t *)ref)->parameter->flags & FLAGS_PTRDIFF_T)
+    ? TRUE
+    : FALSE;
+}
+
+void
+trio_set_ptrdiff
+TRIO_ARGS2((ref, is_ptrdiff),
+	   trio_pointer_t ref,
+	   int is_ptrdiff)
+{
+  if (is_ptrdiff)
+    ((trio_reference_t *)ref)->parameter->flags |= FLAGS_PTRDIFF_T;
+  else
+    ((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_PTRDIFF_T;
+}
+
+/*************************************************************************
+ * trio_get_size / trio_set_size [public]
+ */
+#if TRIO_C99
+int
+trio_get_size
+TRIO_ARGS1((ref),
+	   trio_pointer_t ref)
+{
+  return (((trio_reference_t *)ref)->parameter->flags & FLAGS_SIZE_T)
+    ? TRUE
+    : FALSE;
+}
+
+void
+trio_set_size
+TRIO_ARGS2((ref, is_size),
+	   trio_pointer_t ref,
+	   int is_size)
+{
+  if (is_size)
+    ((trio_reference_t *)ref)->parameter->flags |= FLAGS_SIZE_T;
+  else
+    ((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_SIZE_T;
+}
+#endif
+
+/*************************************************************************
+ * trio_print_int [public]
+ */
+void
+trio_print_int
+TRIO_ARGS2((ref, number),
+	   trio_pointer_t ref,
+	   int number)
+{
+  trio_reference_t *self = (trio_reference_t *)ref;
+
+  TrioWriteNumber(self->data,
+		  (trio_uintmax_t)number,
+		  self->parameter->flags,
+		  self->parameter->width,
+		  self->parameter->precision,
+		  self->parameter->base);
+}
+
+/*************************************************************************
+ * trio_print_uint [public]
+ */
+void
+trio_print_uint
+TRIO_ARGS2((ref, number),
+	   trio_pointer_t ref,
+	   unsigned int number)
+{
+  trio_reference_t *self = (trio_reference_t *)ref;
+
+  TrioWriteNumber(self->data,
+		  (trio_uintmax_t)number,
+		  self->parameter->flags | FLAGS_UNSIGNED,
+		  self->parameter->width,
+		  self->parameter->precision,
+		  self->parameter->base);
+}
+
+/*************************************************************************
+ * trio_print_double [public]
+ */
+void
+trio_print_double
+TRIO_ARGS2((ref, number),
+	   trio_pointer_t ref,
+	   double number)
+{
+  trio_reference_t *self = (trio_reference_t *)ref;
+
+  TrioWriteDouble(self->data,
+		  number,
+		  self->parameter->flags,
+		  self->parameter->width,
+		  self->parameter->precision,
+		  self->parameter->base);
+}
+
+/*************************************************************************
+ * trio_print_string [public]
+ */
+void
+trio_print_string
+TRIO_ARGS2((ref, string),
+	   trio_pointer_t ref,
+	   char *string)
+{
+  trio_reference_t *self = (trio_reference_t *)ref;
+
+  TrioWriteString(self->data,
+		  string,
+		  self->parameter->flags,
+		  self->parameter->width,
+		  self->parameter->precision);
+}
+
+/*************************************************************************
+ * trio_print_ref [public]
+ */
+int
+trio_print_ref
+TRIO_VARGS3((ref, format, va_alist),
+	    trio_pointer_t ref,
+	    TRIO_CONST char *format,
+	    TRIO_VA_DECL)
+{
+  int status;
+  va_list arglist;
+
+  assert(VALID(format));
+  
+  TRIO_VA_START(arglist, format);
+  status = TrioFormatRef((trio_reference_t *)ref, format, &arglist, NULL);
+  TRIO_VA_END(arglist);
+  return status;
+}
+
+/*************************************************************************
+ * trio_vprint_ref [public]
+ */
+int
+trio_vprint_ref
+TRIO_ARGS3((ref, format, arglist),
+	   trio_pointer_t ref,
+	   TRIO_CONST char *format,
+	   va_list arglist)
+{
+  assert(VALID(format));
+  
+  return TrioFormatRef((trio_reference_t *)ref, format, &arglist, NULL);
+}
+
+/*************************************************************************
+ * trio_printv_ref [public]
+ */
+int
+trio_printv_ref
+TRIO_ARGS3((ref, format, argarray),
+	   trio_pointer_t ref,
+	   TRIO_CONST char *format,
+	   trio_pointer_t *argarray)
+{
+  assert(VALID(format));
+  
+  return TrioFormatRef((trio_reference_t *)ref, format, NULL, argarray);
+}
+
+#endif /* TRIO_EXTENSION */
+
+/*************************************************************************
+ * trio_print_pointer [public]
+ */
+void
+trio_print_pointer
+TRIO_ARGS2((ref, pointer),
+	   trio_pointer_t ref,
+	   trio_pointer_t pointer)
+{
+  trio_reference_t *self = (trio_reference_t *)ref;
+  trio_flags_t flags;
+  trio_uintmax_t number;
+
+  if (NULL == pointer)
+    {
+      TRIO_CONST char *string = internalNullString;
+      while (*string)
+	self->data->OutStream(self->data, *string++);
+    }
+  else
+    {
+      /*
+       * The subtraction of the null pointer is a workaround
+       * to avoid a compiler warning. The performance overhead
+       * is negligible (and likely to be removed by an
+       * optimizing compiler). The (char *) casting is done
+       * to please ANSI C++.
+       */
+      number = (trio_uintmax_t)((char *)pointer - (char *)0);
+      /* Shrink to size of pointer */
+      number &= (trio_uintmax_t)-1;
+      flags = self->parameter->flags;
+      flags |= (FLAGS_UNSIGNED | FLAGS_ALTERNATIVE |
+	        FLAGS_NILPADDING);
+      TrioWriteNumber(self->data,
+		      number,
+		      flags,
+		      POINTER_WIDTH,
+		      NO_PRECISION,
+		      BASE_HEX);
+    }
+}
+
+/** @} End of UserDefined documentation module */
+
+/*************************************************************************
+ *
+ * LOCALES
+ *
+ ************************************************************************/
+
+/*************************************************************************
+ * trio_locale_set_decimal_point
+ *
+ * Decimal point can only be one character. The input argument is a
+ * string to enable multibyte characters. At most MB_LEN_MAX characters
+ * will be used.
+ */
+TRIO_PUBLIC void
+trio_locale_set_decimal_point
+TRIO_ARGS1((decimalPoint),
+	   char *decimalPoint)
+{
+#if defined(USE_LOCALE)
+  if (NULL == internalLocaleValues)
+    {
+      TrioSetLocale();
+    }
+#endif
+  internalDecimalPointLength = trio_length(decimalPoint);
+  if (internalDecimalPointLength == 1)
+    {
+      internalDecimalPoint = *decimalPoint;
+    }
+  else
+    {
+      internalDecimalPoint = NIL;
+      trio_copy_max(internalDecimalPointString,
+		    sizeof(internalDecimalPointString),
+		    decimalPoint);
+    }
+}
+
+/*************************************************************************
+ * trio_locale_set_thousand_separator
+ *
+ * See trio_locale_set_decimal_point
+ */
+TRIO_PUBLIC void
+trio_locale_set_thousand_separator
+TRIO_ARGS1((thousandSeparator),
+	   char *thousandSeparator)
+{
+#if defined(USE_LOCALE)
+  if (NULL == internalLocaleValues)
+    {
+      TrioSetLocale();
+    }
+#endif
+  trio_copy_max(internalThousandSeparator,
+		sizeof(internalThousandSeparator),
+		thousandSeparator);
+  internalThousandSeparatorLength = trio_length(internalThousandSeparator);
+}
+
+/*************************************************************************
+ * trio_locale_set_grouping
+ *
+ * Array of bytes. Reversed order.
+ *
+ *  CHAR_MAX : No further grouping
+ *  0        : Repeat last group for the remaining digits (not necessary
+ *             as C strings are zero-terminated)
+ *  n        : Set current group to n
+ *
+ * Same order as the grouping attribute in LC_NUMERIC.
+ */
+TRIO_PUBLIC void
+trio_locale_set_grouping
+TRIO_ARGS1((grouping),
+	   char *grouping)
+{
+#if defined(USE_LOCALE)
+  if (NULL == internalLocaleValues)
+    {
+      TrioSetLocale();
+    }
+#endif
+  trio_copy_max(internalGrouping,
+		sizeof(internalGrouping),
+		grouping);
+}
+
+
+/*************************************************************************
+ *
+ * SCANNING
+ *
+ ************************************************************************/
+
+/*************************************************************************
+ * TrioSkipWhitespaces
+ */
+TRIO_PRIVATE int
+TrioSkipWhitespaces
+TRIO_ARGS1((self),
+	   trio_class_t *self)
+{
+  int ch;
+
+  ch = self->current;
+  while (isspace(ch))
+    {
+      self->InStream(self, &ch);
+    }
+  return ch;
+}
+
+/*************************************************************************
+ * TrioGetCollation
+ */
+#if TRIO_EXTENSION
+TRIO_PRIVATE void
+TrioGetCollation(TRIO_NOARGS)
+{
+  int i;
+  int j;
+  int k;
+  char first[2];
+  char second[2];
+
+  /* This is computationally expensive */
+  first[1] = NIL;
+  second[1] = NIL;
+  for (i = 0; i < MAX_CHARACTER_CLASS; i++)
+    {
+      k = 0;
+      first[0] = (char)i;
+      for (j = 0; j < MAX_CHARACTER_CLASS; j++)
+	{
+	  second[0] = (char)j;
+	  if (trio_equal_locale(first, second))
+	    internalCollationArray[i][k++] = (char)j;
+	}
+      internalCollationArray[i][k] = NIL;
+    }
+}
+#endif
+
+/*************************************************************************
+ * TrioGetCharacterClass
+ *
+ * FIXME:
+ *  multibyte
+ */
+TRIO_PRIVATE int
+TrioGetCharacterClass
+TRIO_ARGS4((format, indexPointer, flagsPointer, characterclass),
+	   TRIO_CONST char *format,
+	   int *indexPointer,
+	   trio_flags_t *flagsPointer,
+	   int *characterclass)
+{
+  int index = *indexPointer;
+  int i;
+  char ch;
+  char range_begin;
+  char range_end;
+
+  *flagsPointer &= ~FLAGS_EXCLUDE;
+
+  if (format[index] == QUALIFIER_CIRCUMFLEX)
+    {
+      *flagsPointer |= FLAGS_EXCLUDE;
+      index++;
+    }
+  /*
+   * If the ungroup character is at the beginning of the scanlist,
+   * it will be part of the class, and a second ungroup character
+   * must follow to end the group.
+   */
+  if (format[index] == SPECIFIER_UNGROUP)
+    {
+      characterclass[(int)SPECIFIER_UNGROUP]++;
+      index++;
+    }
+  /*
+   * Minus is used to specify ranges. To include minus in the class,
+   * it must be at the beginning of the list
+   */
+  if (format[index] == QUALIFIER_MINUS)
+    {
+      characterclass[(int)QUALIFIER_MINUS]++;
+      index++;
+    }
+  /* Collect characters */
+  for (ch = format[index];
+       (ch != SPECIFIER_UNGROUP) && (ch != NIL);
+       ch = format[++index])
+    {
+      switch (ch)
+	{
+	case QUALIFIER_MINUS: /* Scanlist ranges */
+	  
+	  /*
+	   * Both C99 and UNIX98 describes ranges as implementation-
+	   * defined.
+	   *
+	   * We support the following behaviour (although this may
+	   * change as we become wiser)
+	   * - only increasing ranges, ie. [a-b] but not [b-a]
+	   * - transitive ranges, ie. [a-b-c] == [a-c]
+	   * - trailing minus, ie. [a-] is interpreted as an 'a'
+	   *   and a '-'
+	   * - duplicates (although we can easily convert these
+	   *   into errors)
+	   */
+	  range_begin = format[index - 1];
+	  range_end = format[++index];
+	  if (range_end == SPECIFIER_UNGROUP)
+	    {
+	      /* Trailing minus is included */
+	      characterclass[(int)ch]++;
+	      ch = range_end;
+	      break; /* for */
+	    }
+	  if (range_end == NIL)
+	    return TRIO_ERROR_RETURN(TRIO_EINVAL, index);
+	  if (range_begin > range_end)
+	    return TRIO_ERROR_RETURN(TRIO_ERANGE, index);
+	    
+	  for (i = (int)range_begin; i <= (int)range_end; i++)
+	    characterclass[i]++;
+	    
+	  ch = range_end;
+	  break;
+	  
+#if TRIO_EXTENSION
+
+	case SPECIFIER_GROUP:
+	  
+	  switch (format[index + 1])
+	    {
+	    case QUALIFIER_DOT: /* Collating symbol */
+	      /*
+	       * FIXME: This will be easier to implement when multibyte
+	       * characters have been implemented. Until now, we ignore
+	       * this feature.
+	       */
+	      for (i = index + 2; ; i++)
+		{
+		  if (format[i] == NIL)
+		    /* Error in syntax */
+		    return -1;
+		  else if (format[i] == QUALIFIER_DOT)
+		    break; /* for */
+		}
+	      if (format[++i] != SPECIFIER_UNGROUP)
+		return -1;
+	      
+	      index = i;
+	      break;
+	  
+	    case QUALIFIER_EQUAL: /* Equivalence class expressions */
+	      {
+		unsigned int j;
+		unsigned int k;
+	    
+		if (internalCollationUnconverted)
+		  {
+		    /* Lazy evaluation of collation array */
+		    TrioGetCollation();
+		    internalCollationUnconverted = FALSE;
+		  }
+		for (i = index + 2; ; i++)
+		  {
+		    if (format[i] == NIL)
+		      /* Error in syntax */
+		      return -1;
+		    else if (format[i] == QUALIFIER_EQUAL)
+		      break; /* for */
+		    else
+		      {
+			/* Mark any equivalent character */
+			k = (unsigned int)format[i];
+			for (j = 0; internalCollationArray[k][j] != NIL; j++)
+			  characterclass[(int)internalCollationArray[k][j]]++;
+		      }
+		  }
+		if (format[++i] != SPECIFIER_UNGROUP)
+		  return -1;
+		
+		index = i;
+	      }
+	      break;
+	  
+	    case QUALIFIER_COLON: /* Character class expressions */
+	  
+	      if (trio_equal_max(CLASS_ALNUM, sizeof(CLASS_ALNUM) - 1,
+				 &format[index]))
+		{
+		  for (i = 0; i < MAX_CHARACTER_CLASS; i++)
+		    if (isalnum(i))
+		      characterclass[i]++;
+		  index += sizeof(CLASS_ALNUM) - 1;
+		}
+	      else if (trio_equal_max(CLASS_ALPHA, sizeof(CLASS_ALPHA) - 1,
+				      &format[index]))
+		{
+		  for (i = 0; i < MAX_CHARACTER_CLASS; i++)
+		    if (isalpha(i))
+		      characterclass[i]++;
+		  index += sizeof(CLASS_ALPHA) - 1;
+		}
+	      else if (trio_equal_max(CLASS_CNTRL, sizeof(CLASS_CNTRL) - 1,
+				      &format[index]))
+		{
+		  for (i = 0; i < MAX_CHARACTER_CLASS; i++)
+		    if (iscntrl(i))
+		      characterclass[i]++;
+		  index += sizeof(CLASS_CNTRL) - 1;
+		}
+	      else if (trio_equal_max(CLASS_DIGIT, sizeof(CLASS_DIGIT) - 1,
+				      &format[index]))
+		{
+		  for (i = 0; i < MAX_CHARACTER_CLASS; i++)
+		    if (isdigit(i))
+		      characterclass[i]++;
+		  index += sizeof(CLASS_DIGIT) - 1;
+		}
+	      else if (trio_equal_max(CLASS_GRAPH, sizeof(CLASS_GRAPH) - 1,
+				      &format[index]))
+		{
+		  for (i = 0; i < MAX_CHARACTER_CLASS; i++)
+		    if (isgraph(i))
+		      characterclass[i]++;
+		  index += sizeof(CLASS_GRAPH) - 1;
+		}
+	      else if (trio_equal_max(CLASS_LOWER, sizeof(CLASS_LOWER) - 1,
+				      &format[index]))
+		{
+		  for (i = 0; i < MAX_CHARACTER_CLASS; i++)
+		    if (islower(i))
+		      characterclass[i]++;
+		  index += sizeof(CLASS_LOWER) - 1;
+		}
+	      else if (trio_equal_max(CLASS_PRINT, sizeof(CLASS_PRINT) - 1,
+				      &format[index]))
+		{
+		  for (i = 0; i < MAX_CHARACTER_CLASS; i++)
+		    if (isprint(i))
+		      characterclass[i]++;
+		  index += sizeof(CLASS_PRINT) - 1;
+		}
+	      else if (trio_equal_max(CLASS_PUNCT, sizeof(CLASS_PUNCT) - 1,
+				      &format[index]))
+		{
+		  for (i = 0; i < MAX_CHARACTER_CLASS; i++)
+		    if (ispunct(i))
+		      characterclass[i]++;
+		  index += sizeof(CLASS_PUNCT) - 1;
+		}
+	      else if (trio_equal_max(CLASS_SPACE, sizeof(CLASS_SPACE) - 1,
+				      &format[index]))
+		{
+		  for (i = 0; i < MAX_CHARACTER_CLASS; i++)
+		    if (isspace(i))
+		      characterclass[i]++;
+		  index += sizeof(CLASS_SPACE) - 1;
+		}
+	      else if (trio_equal_max(CLASS_UPPER, sizeof(CLASS_UPPER) - 1,
+				      &format[index]))
+		{
+		  for (i = 0; i < MAX_CHARACTER_CLASS; i++)
+		    if (isupper(i))
+		      characterclass[i]++;
+		  index += sizeof(CLASS_UPPER) - 1;
+		}
+	      else if (trio_equal_max(CLASS_XDIGIT, sizeof(CLASS_XDIGIT) - 1,
+				      &format[index]))
+		{
+		  for (i = 0; i < MAX_CHARACTER_CLASS; i++)
+		    if (isxdigit(i))
+		      characterclass[i]++;
+		  index += sizeof(CLASS_XDIGIT) - 1;
+		}
+	      else
+		{
+		  characterclass[(int)ch]++;
+		}
+	      break;
+
+	    default:
+	      characterclass[(int)ch]++;
+	      break;
+	    }
+	  break;
+	  
+#endif /* TRIO_EXTENSION */
+	  
+	default:
+	  characterclass[(int)ch]++;
+	  break;
+	}
+    }
+  return 0;
+}
+
+/*************************************************************************
+ * TrioReadNumber
+ *
+ * We implement our own number conversion in preference of strtol and
+ * strtoul, because we must handle 'long long' and thousand separators.
+ */
+TRIO_PRIVATE BOOLEAN_T
+TrioReadNumber
+TRIO_ARGS5((self, target, flags, width, base),
+	   trio_class_t *self,
+	   trio_uintmax_t *target,
+	   trio_flags_t flags,
+	   int width,
+	   int base)
+{
+  trio_uintmax_t number = 0;
+  int digit;
+  int count;
+  BOOLEAN_T isNegative = FALSE;
+  BOOLEAN_T gotNumber = FALSE;
+  int j;
+
+  assert(VALID(self));
+  assert(VALID(self->InStream));
+  assert((base >= MIN_BASE && base <= MAX_BASE) || (base == NO_BASE));
+
+  if (internalDigitsUnconverted)
+    {
+      /* Lazy evaluation of digits array */
+      memset(internalDigitArray, -1, sizeof(internalDigitArray));
+      for (j = 0; j < (int)sizeof(internalDigitsLower) - 1; j++)
+	{
+	  internalDigitArray[(int)internalDigitsLower[j]] = j;
+	  internalDigitArray[(int)internalDigitsUpper[j]] = j;
+	}
+      internalDigitsUnconverted = FALSE;
+    }
+  
+  TrioSkipWhitespaces(self);
+  
+  if (!(flags & FLAGS_UNSIGNED))
+    {
+      /* Leading sign */
+      if (self->current == '+')
+	{
+	  self->InStream(self, NULL);
+	}
+      else if (self->current == '-')
+	{
+	  self->InStream(self, NULL);
+	  isNegative = TRUE;
+	}
+    }
+  
+  count = self->processed;
+  
+  if (flags & FLAGS_ALTERNATIVE)
+    {
+      switch (base)
+	{
+	case NO_BASE:
+	case BASE_OCTAL:
+	case BASE_HEX:
+	case BASE_BINARY:
+	  if (self->current == '0')
+	    {
+	      self->InStream(self, NULL);
+	      if (self->current)
+		{
+		  if ((base == BASE_HEX) &&
+		      (trio_to_upper(self->current) == 'X'))
+		    {
+		      self->InStream(self, NULL);
+		    }
+		  else if ((base == BASE_BINARY) &&
+			   (trio_to_upper(self->current) == 'B'))
+		    {
+		      self->InStream(self, NULL);
+		    }
+		}
+	    }
+	  else
+	    return FALSE;
+	  break;
+	default:
+	  break;
+	}
+    }
+
+  while (((width == NO_WIDTH) || (self->processed - count < width)) &&
+	 (! ((self->current == EOF) || isspace(self->current))))
+    {
+      if (isascii(self->current))
+	{
+	  digit = internalDigitArray[self->current];
+	  /* Abort if digit is not allowed in the specified base */
+	  if ((digit == -1) || (digit >= base))
+	    break;
+	}
+      else if (flags & FLAGS_QUOTE)
+	{
+	  /* Compare with thousands separator */
+	  for (j = 0; internalThousandSeparator[j] && self->current; j++)
+	    {
+	      if (internalThousandSeparator[j] != self->current)
+		break;
+
+	      self->InStream(self, NULL);
+	    }
+	  if (internalThousandSeparator[j])
+	    break; /* Mismatch */
+	  else
+	    continue; /* Match */
+	}
+      else
+	break;
+            
+      number *= base;
+      number += digit;
+      gotNumber = TRUE; /* we need at least one digit */
+
+      self->InStream(self, NULL);
+    }
+
+  /* Was anything read at all? */
+  if (!gotNumber)
+    return FALSE;
+  
+  if (target)
+    *target = (isNegative) ? -((trio_intmax_t)number) : number;
+  return TRUE;
+}
+
+/*************************************************************************
+ * TrioReadChar
+ */
+TRIO_PRIVATE int
+TrioReadChar
+TRIO_ARGS4((self, target, flags, width),
+	   trio_class_t *self,
+	   char *target,
+	   trio_flags_t flags,
+	   int width)
+{
+  int i;
+  char ch;
+  trio_uintmax_t number;
+  
+  assert(VALID(self));
+  assert(VALID(self->InStream));
+
+  for (i = 0;
+       (self->current != EOF) && (i < width);
+       i++)
+    {
+      ch = (char)self->current;
+      self->InStream(self, NULL);
+      if ((flags & FLAGS_ALTERNATIVE) && (ch == CHAR_BACKSLASH))
+	{
+	  switch (self->current)
+	    {
+	    case '\\': ch = '\\'; break;
+	    case 'a': ch = '\007'; break;
+	    case 'b': ch = '\b'; break;
+	    case 'f': ch = '\f'; break;
+	    case 'n': ch = '\n'; break;
+	    case 'r': ch = '\r'; break;
+	    case 't': ch = '\t'; break;
+	    case 'v': ch = '\v'; break;
+	    default:
+	      if (isdigit(self->current))
+		{
+		  /* Read octal number */
+		  if (!TrioReadNumber(self, &number, 0, 3, BASE_OCTAL))
+		    return 0;
+		  ch = (char)number;
+		}
+	      else if (trio_to_upper(self->current) == 'X')
+		{
+		  /* Read hexadecimal number */
+		  self->InStream(self, NULL);
+		  if (!TrioReadNumber(self, &number, 0, 2, BASE_HEX))
+		    return 0;
+		  ch = (char)number;
+		}
+	      else
+		{
+		  ch = (char)self->current;
+		}
+	      break;
+	    }
+	}
+      
+      if (target)
+	target[i] = ch;
+    }
+  return i + 1;
+}
+
+/*************************************************************************
+ * TrioReadString
+ */
+TRIO_PRIVATE BOOLEAN_T
+TrioReadString
+TRIO_ARGS4((self, target, flags, width),
+	   trio_class_t *self,
+	   char *target,
+	   trio_flags_t flags,
+	   int width)
+{
+  int i;
+  
+  assert(VALID(self));
+  assert(VALID(self->InStream));
+
+  TrioSkipWhitespaces(self);
+    
+  /*
+   * Continue until end of string is reached, a whitespace is encountered,
+   * or width is exceeded
+   */
+  for (i = 0;
+       ((width == NO_WIDTH) || (i < width)) &&
+       (! ((self->current == EOF) || isspace(self->current)));
+       i++)
+    {
+      if (TrioReadChar(self, (target ? &target[i] : 0), flags, 1) == 0)
+	break; /* for */
+    }
+  if (target)
+    target[i] = NIL;
+  return TRUE;
+}
+
+/*************************************************************************
+ * TrioReadWideChar
+ */
+#if TRIO_WIDECHAR
+TRIO_PRIVATE int
+TrioReadWideChar
+TRIO_ARGS4((self, target, flags, width),
+	   trio_class_t *self,
+	   trio_wchar_t *target,
+	   trio_flags_t flags,
+	   int width)
+{
+  int i;
+  int j;
+  int size;
+  int amount = 0;
+  trio_wchar_t wch;
+  char buffer[MB_LEN_MAX + 1];
+  
+  assert(VALID(self));
+  assert(VALID(self->InStream));
+
+  for (i = 0;
+       (self->current != EOF) && (i < width);
+       i++)
+    {
+      if (isascii(self->current))
+	{
+	  if (TrioReadChar(self, buffer, flags, 1) == 0)
+	    return 0;
+	  buffer[1] = NIL;
+	}
+      else
+	{
+	  /*
+	   * Collect a multibyte character, by enlarging buffer until
+	   * it contains a fully legal multibyte character, or the
+	   * buffer is full.
+	   */
+	  j = 0;
+	  do
+	    {
+	      buffer[j++] = (char)self->current;
+	      buffer[j] = NIL;
+	      self->InStream(self, NULL);
+	    }
+	  while ((j < (int)sizeof(buffer)) && (mblen(buffer, (size_t)j) != j));
+	}
+      if (target)
+	{
+	  size = mbtowc(&wch, buffer, sizeof(buffer));
+	  if (size > 0)
+	    target[i] = wch;
+	}
+      amount += size;
+      self->InStream(self, NULL);
+    }
+  return amount;
+}
+#endif /* TRIO_WIDECHAR */
+
+/*************************************************************************
+ * TrioReadWideString
+ */
+#if TRIO_WIDECHAR
+TRIO_PRIVATE BOOLEAN_T
+TrioReadWideString
+TRIO_ARGS4((self, target, flags, width),
+	   trio_class_t *self,
+	   trio_wchar_t *target,
+	   trio_flags_t flags,
+	   int width)
+{
+  int i;
+  int size;
+  
+  assert(VALID(self));
+  assert(VALID(self->InStream));
+
+  TrioSkipWhitespaces(self);
+
+#if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE)
+  (void)mblen(NULL, 0);
+#endif
+  
+  /*
+   * Continue until end of string is reached, a whitespace is encountered,
+   * or width is exceeded
+   */
+  for (i = 0;
+       ((width == NO_WIDTH) || (i < width)) &&
+       (! ((self->current == EOF) || isspace(self->current)));
+       )
+    {
+      size = TrioReadWideChar(self, &target[i], flags, 1);
+      if (size == 0)
+	break; /* for */
+
+      i += size;
+    }
+  if (target)
+    target[i] = WCONST('\0');
+  return TRUE;
+}
+#endif /* TRIO_WIDECHAR */
+
+/*************************************************************************
+ * TrioReadGroup
+ *
+ * FIXME: characterclass does not work with multibyte characters
+ */
+TRIO_PRIVATE BOOLEAN_T
+TrioReadGroup
+TRIO_ARGS5((self, target, characterclass, flags, width),
+	   trio_class_t *self,
+	   char *target,
+	   int *characterclass,
+	   trio_flags_t flags,
+	   int width)
+{
+  int ch;
+  int i;
+  
+  assert(VALID(self));
+  assert(VALID(self->InStream));
+
+  ch = self->current;
+  for (i = 0;
+       ((width == NO_WIDTH) || (i < width)) &&
+       (! ((ch == EOF) ||
+	   (((flags & FLAGS_EXCLUDE) != 0) ^ (characterclass[ch] == 0))));
+       i++)
+    {
+      if (target)
+	target[i] = (char)ch;
+      self->InStream(self, &ch);
+    }
+  
+  if (target)
+    target[i] = NIL;
+  return TRUE;
+}
+
+/*************************************************************************
+ * TrioReadDouble
+ *
+ * FIXME:
+ *  add long double
+ *  handle base
+ */
+TRIO_PRIVATE BOOLEAN_T
+TrioReadDouble
+TRIO_ARGS4((self, target, flags, width),
+	   trio_class_t *self,
+	   trio_pointer_t target,
+	   trio_flags_t flags,
+	   int width)
+{
+  int ch;
+  char doubleString[512];
+  int index = 0;
+  int start;
+  int j;
+  BOOLEAN_T isHex = FALSE;
+
+  doubleString[0] = 0;
+  
+  if ((width == NO_WIDTH) || (width > (int)sizeof(doubleString) - 1))
+    width = sizeof(doubleString) - 1;
+  
+  TrioSkipWhitespaces(self);
+  
+  /*
+   * Read entire double number from stream. trio_to_double requires
+   * a string as input, but InStream can be anything, so we have to
+   * collect all characters.
+   */
+  ch = self->current;
+  if ((ch == '+') || (ch == '-'))
+    {
+      doubleString[index++] = (char)ch;
+      self->InStream(self, &ch);
+      width--;
+    }
+
+  start = index;
+  switch (ch)
+    {
+    case 'n':
+    case 'N':
+      /* Not-a-number */
+      if (index != 0)
+	break;
+      /* FALLTHROUGH */
+    case 'i':
+    case 'I':
+      /* Infinity */
+      while (isalpha(ch) && (index - start < width))
+	{
+	  doubleString[index++] = (char)ch;
+	  self->InStream(self, &ch);
+	}
+      doubleString[index] = NIL;
+
+      /* Case insensitive string comparison */
+      if (trio_equal(&doubleString[start], INFINITE_UPPER) ||
+	  trio_equal(&doubleString[start], LONG_INFINITE_UPPER))
+	{
+	  if (flags & FLAGS_LONGDOUBLE)
+	    {
+	      if ((start == 1) && (doubleString[0] == '-'))
+		{
+		  *((trio_long_double_t *)target) = trio_ninf();
+		}
+	      else
+		{
+		  *((trio_long_double_t *)target) = trio_pinf();
+		}
+	    }
+	  else
+	    {
+	      if ((start == 1) && (doubleString[0] == '-'))
+		{
+		  *((double *)target) = trio_ninf();
+		}
+	      else
+		{
+		  *((double *)target) = trio_pinf();
+		}
+	    }
+	  return TRUE;
+	}
+      if (trio_equal(doubleString, NAN_UPPER))
+	{
+	  /* NaN must not have a preceeding + nor - */
+	  if (flags & FLAGS_LONGDOUBLE)
+	    {
+	      *((trio_long_double_t *)target) = trio_nan();
+	    }
+	  else
+	    {
+	      *((double *)target) = trio_nan();
+	    }
+	  return TRUE;
+	}
+      return FALSE;
+
+    case '0':
+      doubleString[index++] = (char)ch;
+      self->InStream(self, &ch);
+      if (trio_to_upper(ch) == 'X')
+	{
+	  isHex = TRUE;
+	  doubleString[index++] = (char)ch;
+	  self->InStream(self, &ch);
+	}
+      break;
+      
+    default:
+      break;
+    }
+  
+  while ((ch != EOF) && (index - start < width))
+    {
+      /* Integer part */
+      if (isHex ? isxdigit(ch) : isdigit(ch))
+	{
+	  doubleString[index++] = (char)ch;
+	  self->InStream(self, &ch);
+	}
+      else if (flags & FLAGS_QUOTE)
+	{
+	  /* Compare with thousands separator */
+	  for (j = 0; internalThousandSeparator[j] && self->current; j++)
+	    {
+	      if (internalThousandSeparator[j] != self->current)
+		break;
+
+	      self->InStream(self, &ch);
+	    }
+	  if (internalThousandSeparator[j])
+	    break; /* Mismatch */
+	  else
+	    continue; /* Match */
+	}
+      else
+	break; /* while */
+    }
+  if (ch == '.')
+    {
+      /* Decimal part */
+      doubleString[index++] = (char)ch;
+      self->InStream(self, &ch);
+      while ((isHex ? isxdigit(ch) : isdigit(ch)) &&
+	     (index - start < width))
+	{
+	  doubleString[index++] = (char)ch;
+	  self->InStream(self, &ch);
+	}
+      if (isHex ? (trio_to_upper(ch) == 'P') : (trio_to_upper(ch) == 'E'))
+	{
+	  /* Exponent */
+	  doubleString[index++] = (char)ch;
+	  self->InStream(self, &ch);
+	  if ((ch == '+') || (ch == '-'))
+	    {
+	      doubleString[index++] = (char)ch;
+	      self->InStream(self, &ch);
+	    }
+	  while (isdigit(ch) && (index - start < width))
+	    {
+	      doubleString[index++] = (char)ch;
+	      self->InStream(self, &ch);
+	    }
+	}
+    }
+
+  if ((index == start) || (*doubleString == NIL))
+    return FALSE;
+
+  doubleString[index] = 0;
+  
+  if (flags & FLAGS_LONGDOUBLE)
+    {
+      *((trio_long_double_t *)target) = trio_to_long_double(doubleString, NULL);
+    }
+  else
+    {
+      *((double *)target) = trio_to_double(doubleString, NULL);
+    }
+  return TRUE;
+}
+
+/*************************************************************************
+ * TrioReadPointer
+ */
+TRIO_PRIVATE BOOLEAN_T
+TrioReadPointer
+TRIO_ARGS3((self, target, flags),
+	   trio_class_t *self,
+	   trio_pointer_t *target,
+	   trio_flags_t flags)
+{
+  trio_uintmax_t number;
+  char buffer[sizeof(internalNullString)];
+
+  flags |= (FLAGS_UNSIGNED | FLAGS_ALTERNATIVE | FLAGS_NILPADDING);
+  
+  if (TrioReadNumber(self,
+		     &number,
+		     flags,
+		     POINTER_WIDTH,
+		     BASE_HEX))
+    {
+      /*
+       * The strange assignment of number is a workaround for a compiler
+       * warning
+       */
+      if (target)
+	*target = (char *)0 + number;
+      return TRUE;
+    }
+  else if (TrioReadString(self,
+			  (flags & FLAGS_IGNORE)
+			  ? NULL
+			  : buffer,
+			  0,
+			  sizeof(internalNullString) - 1))
+    {  
+      if (trio_equal_case(buffer, internalNullString))
+	{
+	  if (target)
+	    *target = NULL;
+	  return TRUE;
+	}
+    }
+  return FALSE;
+}
+
+/*************************************************************************
+ * TrioScanProcess
+ */
+TRIO_PRIVATE int
+TrioScanProcess
+TRIO_ARGS3((data, format, parameters),
+	   trio_class_t *data,
+	   TRIO_CONST char *format,
+	   trio_parameter_t *parameters)
+{
+#if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE)
+  int charlen;
+  int cnt;
+#endif
+  int assignment;
+  int ch;
+  int index; /* Index of format string */
+  int i; /* Index of current parameter */
+  trio_flags_t flags;
+  int width;
+  int base;
+  trio_pointer_t pointer;
+
+  assignment = 0;
+  i = 0;
+  index = 0;
+  data->InStream(data, &ch);
+
+#if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE)
+  (void)mblen(NULL, 0);
+#endif
+
+  while (format[index])
+    {
+#if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE)
+      if (! isascii(format[index]))
+	{
+	  charlen = mblen(&format[index], MB_LEN_MAX);
+	  if (charlen != -1)
+	    {
+	      /* Compare multibyte characters in format string */
+	      for (cnt = 0; cnt < charlen - 1; cnt++)
+		{
+		  if (ch != format[index + cnt])
+		    {
+		      return TRIO_ERROR_RETURN(TRIO_EINVAL, index);
+		    }
+		  data->InStream(data, &ch);
+		}
+	      continue; /* while characters left in formatting string */
+	    }
+	}
+#endif /* TRIO_COMPILER_SUPPORTS_MULTIBYTE */
+      
+      if ((EOF == ch) && (parameters[i].type != FORMAT_COUNT))
+	{
+	  return (assignment > 0) ? assignment : EOF;
+	}
+      
+      if (CHAR_IDENTIFIER == format[index])
+	{
+	  if (CHAR_IDENTIFIER == format[index + 1])
+	    {
+	      /* Two % in format matches one % in input stream */
+	      if (CHAR_IDENTIFIER == ch)
+		{
+		  data->InStream(data, &ch);
+		  index += 2;
+		  continue; /* while format chars left */
+		}
+	      else
+		return TRIO_ERROR_RETURN(TRIO_EINVAL, index);
+	    }
+
+	  /* Skip the parameter entries */
+	  while (parameters[i].type == FORMAT_PARAMETER)
+	    i++;
+	  
+	  flags = parameters[i].flags;
+	  /* Find width */
+	  width = parameters[i].width;
+	  if (flags & FLAGS_WIDTH_PARAMETER)
+	    {
+	      /* Get width from parameter list */
+	      width = (int)parameters[width].data.number.as_signed;
+	    }
+	  /* Find base */
+	  base = parameters[i].base;
+	  if (flags & FLAGS_BASE_PARAMETER)
+	    {
+	      /* Get base from parameter list */
+	      base = (int)parameters[base].data.number.as_signed;
+	    }
+	  
+	  switch (parameters[i].type)
+	    {
+	    case FORMAT_INT:
+	      {
+		trio_uintmax_t number;
+
+		if (0 == base)
+		  base = BASE_DECIMAL;
+
+		if (!TrioReadNumber(data,
+				    &number,
+				    flags,
+				    width,
+				    base))
+		  return assignment;
+
+		if (!(flags & FLAGS_IGNORE))
+		  {
+		    assignment++;
+
+		    pointer = parameters[i].data.pointer;
+#if defined(QUALIFIER_SIZE_T) || defined(QUALIFIER_SIZE_T_UPPER)
+		    if (flags & FLAGS_SIZE_T)
+		      *(size_t *)pointer = (size_t)number;
+		    else
+#endif
+#if defined(QUALIFIER_PTRDIFF_T)
+		    if (flags & FLAGS_PTRDIFF_T)
+		      *(ptrdiff_t *)pointer = (ptrdiff_t)number;
+		    else
+#endif
+#if defined(QUALIFIER_INTMAX_T)
+		    if (flags & FLAGS_INTMAX_T)
+		      *(trio_intmax_t *)pointer = (trio_intmax_t)number;
+		    else
+#endif
+		    if (flags & FLAGS_QUAD)
+		      *(trio_ulonglong_t *)pointer = (trio_ulonglong_t)number;
+		    else if (flags & FLAGS_LONG)
+		      *(long int *)pointer = (long int)number;
+		    else if (flags & FLAGS_SHORT)
+		      *(short int *)pointer = (short int)number;
+		    else
+		      *(int *)pointer = (int)number;
+		  }
+	      }
+	      break; /* FORMAT_INT */
+	      
+	    case FORMAT_STRING:
+#if TRIO_WIDECHAR
+	      if (flags & FLAGS_WIDECHAR)
+		{
+		  if (!TrioReadWideString(data,
+					  (flags & FLAGS_IGNORE)
+					  ? NULL
+					  : parameters[i].data.wstring,
+					  flags,
+					  width))
+		    return assignment;
+		}
+	      else
+#endif
+		{
+		  if (!TrioReadString(data,
+				      (flags & FLAGS_IGNORE)
+				      ? NULL
+				      : parameters[i].data.string,
+				      flags,
+				      width))
+		    return assignment;
+		}
+	      if (!(flags & FLAGS_IGNORE))
+		assignment++;
+	      break; /* FORMAT_STRING */
+
+	    case FORMAT_DOUBLE:
+	      {
+		trio_pointer_t pointer;
+
+		if (flags & FLAGS_IGNORE)
+		  {
+		    pointer = NULL;
+		  }
+		else
+		  {
+		    pointer = (flags & FLAGS_LONGDOUBLE)
+		      ? (trio_pointer_t)parameters[i].data.longdoublePointer
+		      : (trio_pointer_t)parameters[i].data.doublePointer;
+		  }
+		if (!TrioReadDouble(data, pointer, flags, width))
+		  {
+		    return assignment;
+		  }
+		if (!(flags & FLAGS_IGNORE))
+		  {
+		    assignment++;
+		  }
+		break; /* FORMAT_DOUBLE */
+	      }
+	    case FORMAT_GROUP:
+	      {
+		int characterclass[MAX_CHARACTER_CLASS + 1];
+		int rc;
+
+		/* Skip over modifiers */
+		while (format[index] != SPECIFIER_GROUP)
+		  {
+		    index++;
+		  }
+		/* Skip over group specifier */
+		index++;
+		
+		memset(characterclass, 0, sizeof(characterclass));
+		rc = TrioGetCharacterClass(format,
+					   &index,
+					   &flags,
+					   characterclass);
+		if (rc < 0)
+		  return rc;
+
+		if (!TrioReadGroup(data,
+				   (flags & FLAGS_IGNORE)
+				   ? NULL
+				   : parameters[i].data.string,
+				   characterclass,
+				   flags,
+				   parameters[i].width))
+		  return assignment;
+		if (!(flags & FLAGS_IGNORE))
+		  assignment++;
+	      }
+	      break; /* FORMAT_GROUP */
+
+	    case FORMAT_COUNT:
+	      pointer = parameters[i].data.pointer;
+	      if (NULL != pointer)
+		{
+		  int count = data->committed;
+		  if (ch != EOF)
+		    count--; /* a character is read, but is not consumed yet */
+#if defined(QUALIFIER_SIZE_T) || defined(QUALIFIER_SIZE_T_UPPER)
+		  if (flags & FLAGS_SIZE_T)
+		    *(size_t *)pointer = (size_t)count;
+		  else
+#endif
+#if defined(QUALIFIER_PTRDIFF_T)
+		  if (flags & FLAGS_PTRDIFF_T)
+		    *(ptrdiff_t *)pointer = (ptrdiff_t)count;
+		  else
+#endif
+#if defined(QUALIFIER_INTMAX_T)
+		  if (flags & FLAGS_INTMAX_T)
+		    *(trio_intmax_t *)pointer = (trio_intmax_t)count;
+		  else
+#endif
+		  if (flags & FLAGS_QUAD)
+		    {
+		      *(trio_ulonglong_t *)pointer = (trio_ulonglong_t)count;
+		    }
+		  else if (flags & FLAGS_LONG)
+		    {
+		      *(long int *)pointer = (long int)count;
+		    }
+		  else if (flags & FLAGS_SHORT)
+		    {
+		      *(short int *)pointer = (short int)count;
+		    }
+		  else
+		    {
+		      *(int *)pointer = (int)count;
+		    }
+		}
+	      break; /* FORMAT_COUNT */
+	      
+	    case FORMAT_CHAR:
+#if TRIO_WIDECHAR
+	      if (flags & FLAGS_WIDECHAR)
+		{
+		  if (TrioReadWideChar(data,
+				       (flags & FLAGS_IGNORE)
+				       ? NULL
+				       : parameters[i].data.wstring,
+				       flags,
+				       (width == NO_WIDTH) ? 1 : width) == 0)
+		    return assignment;
+		}
+	      else
+#endif
+		{
+		  if (TrioReadChar(data,
+				   (flags & FLAGS_IGNORE)
+				   ? NULL
+				   : parameters[i].data.string,
+				   flags,
+				   (width == NO_WIDTH) ? 1 : width) == 0)
+		    return assignment;
+		}
+	      if (!(flags & FLAGS_IGNORE))
+		assignment++;
+	      break; /* FORMAT_CHAR */
+
+	    case FORMAT_POINTER:
+	      if (!TrioReadPointer(data,
+				   (flags & FLAGS_IGNORE)
+				   ? NULL
+				   : (trio_pointer_t *)parameters[i].data.pointer,
+				   flags))
+		return assignment;
+	      if (!(flags & FLAGS_IGNORE))
+		assignment++;
+	      break; /* FORMAT_POINTER */
+
+	    case FORMAT_PARAMETER:
+	      break; /* FORMAT_PARAMETER */
+
+	    default:
+	      return TRIO_ERROR_RETURN(TRIO_EINVAL, index);
+	    }
+	  ch = data->current;
+	  index = parameters[i].indexAfterSpecifier;
+	  i++;
+	}
+      else /* Not an % identifier */
+	{
+	  if (isspace((int)format[index]))
+	    {
+	      /* Whitespaces may match any amount of whitespaces */
+	      ch = TrioSkipWhitespaces(data);
+	    }
+	  else if (ch == format[index])
+	    {
+	      data->InStream(data, &ch);
+	    }
+	  else
+	    return assignment;
+	  
+	  index++;
+	}
+    }
+  return assignment;
+}
+
+/*************************************************************************
+ * TrioScan
+ */
+TRIO_PRIVATE int
+TrioScan
+TRIO_ARGS6((source, sourceSize, InStream, format, arglist, argarray),
+	   trio_pointer_t source,
+	   size_t sourceSize,
+	   void (*InStream) TRIO_PROTO((trio_class_t *, int *)),
+	   TRIO_CONST char *format,
+	   va_list *arglist,
+	   trio_pointer_t *argarray)
+{
+  int status;
+  trio_parameter_t parameters[MAX_PARAMETERS];
+  trio_class_t data;
+
+  assert(VALID(InStream));
+  assert(VALID(format));
+
+  memset(&data, 0, sizeof(data));
+  data.InStream = InStream;
+  data.location = (trio_pointer_t)source;
+  data.max = sourceSize;
+  data.error = 0;
+
+#if defined(USE_LOCALE)
+  if (NULL == internalLocaleValues)
+    {
+      TrioSetLocale();
+    }
+#endif
+  
+  status = TrioParse(TYPE_SCAN, format, parameters, arglist, argarray);
+  if (status < 0)
+    return status;
+
+  status = TrioScanProcess(&data, format, parameters);
+  if (data.error != 0)
+    {
+      status = data.error;
+    }
+  return status;
+}
+
+/*************************************************************************
+ * TrioInStreamFile
+ */
+TRIO_PRIVATE void
+TrioInStreamFile
+TRIO_ARGS2((self, intPointer),
+	   trio_class_t *self,
+	   int *intPointer)
+{
+  FILE *file = (FILE *)self->location;
+
+  assert(VALID(self));
+  assert(VALID(file));
+
+  self->current = fgetc(file);
+  if (self->current == EOF)
+    {
+      self->error = (ferror(file))
+	? TRIO_ERROR_RETURN(TRIO_ERRNO, 0)
+	: TRIO_ERROR_RETURN(TRIO_EOF, 0);
+    }
+  else
+    {
+      self->processed++;
+      self->committed++;
+    }
+  
+  if (VALID(intPointer))
+    {
+      *intPointer = self->current;
+    }
+}
+
+/*************************************************************************
+ * TrioInStreamFileDescriptor
+ */
+TRIO_PRIVATE void
+TrioInStreamFileDescriptor
+TRIO_ARGS2((self, intPointer),
+	   trio_class_t *self,
+	   int *intPointer)
+{
+  int fd = *((int *)self->location);
+  int size;
+  unsigned char input;
+
+  assert(VALID(self));
+
+  size = read(fd, &input, sizeof(char));
+  if (size == -1)
+    {
+      self->error = TRIO_ERROR_RETURN(TRIO_ERRNO, 0);
+      self->current = EOF;
+    }
+  else
+    {
+      self->current = (size == 0) ? EOF : input;
+    }
+  if (self->current != EOF)
+    {
+      self->committed++;
+      self->processed++;
+    }
+  
+  if (VALID(intPointer))
+    {
+      *intPointer = self->current;
+    }
+}
+
+/*************************************************************************
+ * TrioInStreamCustom
+ */
+TRIO_PRIVATE void
+TrioInStreamCustom
+TRIO_ARGS2((self, intPointer),
+	   trio_class_t *self,
+	   int *intPointer)
+{
+  trio_custom_t *data;
+  
+  assert(VALID(self));
+  assert(VALID(self->location));
+
+  data = (trio_custom_t *)self->location;
+
+  self->current = (data->stream.in == NULL)
+    ? NIL
+    : (data->stream.in)(data->closure);
+  
+  if (self->current == NIL)
+    {
+      self->current = EOF;
+    }
+  else
+    {
+      self->processed++;
+      self->committed++;
+    }
+  
+  if (VALID(intPointer))
+    {
+      *intPointer = self->current;
+    }
+}
+
+/*************************************************************************
+ * TrioInStreamString
+ */
+TRIO_PRIVATE void
+TrioInStreamString
+TRIO_ARGS2((self, intPointer),
+	   trio_class_t *self,
+	   int *intPointer)
+{
+  unsigned char **buffer;
+
+  assert(VALID(self));
+  assert(VALID(self->location));
+
+  buffer = (unsigned char **)self->location;
+  self->current = (*buffer)[0];
+  if (self->current == NIL)
+    {
+      self->current = EOF;
+    }
+  else
+    {
+      (*buffer)++;
+      self->processed++;
+      self->committed++;
+    }
+  
+  if (VALID(intPointer))
+    {
+      *intPointer = self->current;
+    }
+}
+
+/*************************************************************************
+ *
+ * Formatted scanning functions
+ *
+ ************************************************************************/
+
+#if defined(TRIO_DOCUMENTATION)
+# include "doc/doc_scanf.h"
+#endif
+/** @addtogroup Scanf
+    @{
+*/
+
+/*************************************************************************
+ * scanf
+ */
+
+/**
+   Scan characters from standard input stream.
+
+   @param format Formatting string.
+   @param ... Arguments.
+   @return Number of scanned characters.
+ */
+TRIO_PUBLIC int
+trio_scanf
+TRIO_VARGS2((format, va_alist),
+	    TRIO_CONST char *format,
+	    TRIO_VA_DECL)
+{
+  int status;
+  va_list args;
+
+  assert(VALID(format));
+  
+  TRIO_VA_START(args, format);
+  status = TrioScan((trio_pointer_t)stdin, 0,
+		    TrioInStreamFile,
+		    format, &args, NULL);
+  TRIO_VA_END(args);
+  return status;
+}
+
+TRIO_PUBLIC int
+trio_vscanf
+TRIO_ARGS2((format, args),
+	   TRIO_CONST char *format,
+	   va_list args)
+{
+  assert(VALID(format));
+  
+  return TrioScan((trio_pointer_t)stdin, 0,
+		  TrioInStreamFile,
+		  format, &args, NULL);
+}
+
+TRIO_PUBLIC int
+trio_scanfv
+TRIO_ARGS2((format, args),
+	   TRIO_CONST char *format,
+	   trio_pointer_t *args)
+{
+  assert(VALID(format));
+  
+  return TrioScan((trio_pointer_t)stdin, 0,
+		  TrioInStreamFile,
+		  format, NULL, args);
+}
+
+/*************************************************************************
+ * fscanf
+ */
+TRIO_PUBLIC int
+trio_fscanf
+TRIO_VARGS3((file, format, va_alist),
+	    FILE *file,
+	    TRIO_CONST char *format,
+	    TRIO_VA_DECL)
+{
+  int status;
+  va_list args;
+
+  assert(VALID(file));
+  assert(VALID(format));
+  
+  TRIO_VA_START(args, format);
+  status = TrioScan((trio_pointer_t)file, 0,
+		    TrioInStreamFile,
+		    format, &args, NULL);
+  TRIO_VA_END(args);
+  return status;
+}
+
+TRIO_PUBLIC int
+trio_vfscanf
+TRIO_ARGS3((file, format, args),
+	   FILE *file,
+	   TRIO_CONST char *format,
+	   va_list args)
+{
+  assert(VALID(file));
+  assert(VALID(format));
+  
+  return TrioScan((trio_pointer_t)file, 0,
+		  TrioInStreamFile,
+		  format, &args, NULL);
+}
+
+TRIO_PUBLIC int
+trio_fscanfv
+TRIO_ARGS3((file, format, args),
+	   FILE *file,
+	   TRIO_CONST char *format,
+	   trio_pointer_t *args)
+{
+  assert(VALID(file));
+  assert(VALID(format));
+  
+  return TrioScan((trio_pointer_t)file, 0,
+		  TrioInStreamFile,
+		  format, NULL, args);
+}
+
+/*************************************************************************
+ * dscanf
+ */
+TRIO_PUBLIC int
+trio_dscanf
+TRIO_VARGS3((fd, format, va_alist),
+	    int fd,
+	    TRIO_CONST char *format,
+	    TRIO_VA_DECL)
+{
+  int status;
+  va_list args;
+
+  assert(VALID(format));
+  
+  TRIO_VA_START(args, format);
+  status = TrioScan((trio_pointer_t)&fd, 0,
+		    TrioInStreamFileDescriptor,
+		    format, &args, NULL);
+  TRIO_VA_END(args);
+  return status;
+}
+
+TRIO_PUBLIC int
+trio_vdscanf
+TRIO_ARGS3((fd, format, args),
+	   int fd,
+	   TRIO_CONST char *format,
+	   va_list args)
+{
+  assert(VALID(format));
+  
+  return TrioScan((trio_pointer_t)&fd, 0,
+		  TrioInStreamFileDescriptor,
+		  format, &args, NULL);
+}
+
+TRIO_PUBLIC int
+trio_dscanfv
+TRIO_ARGS3((fd, format, args),
+	   int fd,
+	   TRIO_CONST char *format,
+	   trio_pointer_t *args)
+{
+  assert(VALID(format));
+  
+  return TrioScan((trio_pointer_t)&fd, 0,
+		  TrioInStreamFileDescriptor,
+		  format, NULL, args);
+}
+
+/*************************************************************************
+ * cscanf
+ */
+TRIO_PUBLIC int
+trio_cscanf
+TRIO_VARGS4((stream, closure, format, va_alist),
+	    trio_instream_t stream,
+	    trio_pointer_t closure,
+	    TRIO_CONST char *format,
+	    TRIO_VA_DECL)
+{
+  int status;
+  va_list args;
+  trio_custom_t data;
+
+  assert(VALID(stream));
+  assert(VALID(format));
+  
+  TRIO_VA_START(args, format);
+  data.stream.in = stream;
+  data.closure = closure;
+  status = TrioScan(&data, 0, TrioInStreamCustom, format, &args, NULL);
+  TRIO_VA_END(args);
+  return status;
+}
+
+TRIO_PUBLIC int
+trio_vcscanf
+TRIO_ARGS4((stream, closure, format, args),
+	   trio_instream_t stream,
+	   trio_pointer_t closure,
+	   TRIO_CONST char *format,
+	   va_list args)
+{
+  trio_custom_t data;
+  
+  assert(VALID(stream));
+  assert(VALID(format));
+
+  data.stream.in = stream;
+  data.closure = closure;
+  return TrioScan(&data, 0, TrioInStreamCustom, format, &args, NULL);
+}
+
+TRIO_PUBLIC int
+trio_cscanfv
+TRIO_ARGS4((stream, closure, format, args),
+	   trio_instream_t stream,
+	   trio_pointer_t closure,
+	   TRIO_CONST char *format,
+	   trio_pointer_t *args)
+{
+  trio_custom_t data;
+  
+  assert(VALID(stream));
+  assert(VALID(format));
+
+  data.stream.in = stream;
+  data.closure = closure;
+  return TrioScan(&data, 0, TrioInStreamCustom, format, NULL, args);
+}
+
+/*************************************************************************
+ * sscanf
+ */
+TRIO_PUBLIC int
+trio_sscanf
+TRIO_VARGS3((buffer, format, va_alist),
+	    TRIO_CONST char *buffer,
+	    TRIO_CONST char *format,
+	    TRIO_VA_DECL)
+{
+  int status;
+  va_list args;
+
+  assert(VALID(buffer));
+  assert(VALID(format));
+  
+  TRIO_VA_START(args, format);
+  status = TrioScan((trio_pointer_t)&buffer, 0,
+		    TrioInStreamString,
+		    format, &args, NULL);
+  TRIO_VA_END(args);
+  return status;
+}
+
+TRIO_PUBLIC int
+trio_vsscanf
+TRIO_ARGS3((buffer, format, args),
+	   TRIO_CONST char *buffer,
+	   TRIO_CONST char *format,
+	   va_list args)
+{
+  assert(VALID(buffer));
+  assert(VALID(format));
+  
+  return TrioScan((trio_pointer_t)&buffer, 0,
+		  TrioInStreamString,
+		  format, &args, NULL);
+}
+
+TRIO_PUBLIC int
+trio_sscanfv
+TRIO_ARGS3((buffer, format, args),
+	   TRIO_CONST char *buffer,
+	   TRIO_CONST char *format,
+	   trio_pointer_t *args)
+{
+  assert(VALID(buffer));
+  assert(VALID(format));
+  
+  return TrioScan((trio_pointer_t)&buffer, 0,
+		  TrioInStreamString,
+		  format, NULL, args);
+}
+
+/** @} End of Scanf documentation module */
+
+/*************************************************************************
+ * trio_strerror
+ */
+TRIO_PUBLIC TRIO_CONST char *
+trio_strerror
+TRIO_ARGS1((errorcode),
+	   int errorcode)
+{
+  /* Textual versions of the error codes */
+  switch (TRIO_ERROR_CODE(errorcode))
+    {
+    case TRIO_EOF:
+      return "End of file";
+    case TRIO_EINVAL:
+      return "Invalid argument";
+    case TRIO_ETOOMANY:
+      return "Too many arguments";
+    case TRIO_EDBLREF:
+      return "Double reference";
+    case TRIO_EGAP:
+      return "Reference gap";
+    case TRIO_ENOMEM:
+      return "Out of memory";
+    case TRIO_ERANGE:
+      return "Invalid range";
+    case TRIO_ECUSTOM:
+      return "Custom error";
+    default:
+      return "Unknown";
+    }
+}
diff --git a/src/libxml/src/trio.h b/src/libxml/src/trio.h
new file mode 100644
index 0000000..188bb4c
--- /dev/null
+++ b/src/libxml/src/trio.h
@@ -0,0 +1,216 @@
+/*************************************************************************
+ *
+ * $Id: trio.h,v 1.1 2008/11/12 02:25:23 agibert Exp $
+ *
+ * Copyright (C) 1998 Bjorn Reese and Daniel Stenberg.
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
+ * MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE AUTHORS AND
+ * CONTRIBUTORS ACCEPT NO RESPONSIBILITY IN ANY CONCEIVABLE MANNER.
+ *
+ *************************************************************************
+ *
+ * http://ctrio.sourceforge.net/
+ *
+ ************************************************************************/
+
+#ifndef TRIO_TRIO_H
+#define TRIO_TRIO_H
+
+#if !defined(WITHOUT_TRIO)
+
+/*
+ * Use autoconf defines if present. Packages using trio must define
+ * HAVE_CONFIG_H as a compiler option themselves.
+ */
+#if defined(HAVE_CONFIG_H)
+# include <config.h>
+#endif
+
+#include "triodef.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#if defined(TRIO_COMPILER_ANCIENT)
+# include <varargs.h>
+#else
+# include <stdarg.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * Error codes.
+ *
+ * Remember to add a textual description to trio_strerror.
+ */
+enum {
+  TRIO_EOF      = 1,
+  TRIO_EINVAL   = 2,
+  TRIO_ETOOMANY = 3,
+  TRIO_EDBLREF  = 4,
+  TRIO_EGAP     = 5,
+  TRIO_ENOMEM   = 6,
+  TRIO_ERANGE   = 7,
+  TRIO_ERRNO    = 8,
+  TRIO_ECUSTOM  = 9
+};
+
+/* Error macros */
+#define TRIO_ERROR_CODE(x) ((-(x)) & 0x00FF)
+#define TRIO_ERROR_POSITION(x) ((-(x)) >> 8)
+#define TRIO_ERROR_NAME(x) trio_strerror(x)
+
+typedef int (*trio_outstream_t) TRIO_PROTO((trio_pointer_t, int));
+typedef int (*trio_instream_t) TRIO_PROTO((trio_pointer_t));
+
+TRIO_CONST char *trio_strerror TRIO_PROTO((int));
+
+/*************************************************************************
+ * Print Functions
+ */
+
+int trio_printf TRIO_PROTO((TRIO_CONST char *format, ...));
+int trio_vprintf TRIO_PROTO((TRIO_CONST char *format, va_list args));
+int trio_printfv TRIO_PROTO((TRIO_CONST char *format, void **args));
+
+int trio_fprintf TRIO_PROTO((FILE *file, TRIO_CONST char *format, ...));
+int trio_vfprintf TRIO_PROTO((FILE *file, TRIO_CONST char *format, va_list args));
+int trio_fprintfv TRIO_PROTO((FILE *file, TRIO_CONST char *format, void **args));
+
+int trio_dprintf TRIO_PROTO((int fd, TRIO_CONST char *format, ...));
+int trio_vdprintf TRIO_PROTO((int fd, TRIO_CONST char *format, va_list args));
+int trio_dprintfv TRIO_PROTO((int fd, TRIO_CONST char *format, void **args));
+
+int trio_cprintf TRIO_PROTO((trio_outstream_t stream, trio_pointer_t closure,
+			     TRIO_CONST char *format, ...));
+int trio_vcprintf TRIO_PROTO((trio_outstream_t stream, trio_pointer_t closure,
+			      TRIO_CONST char *format, va_list args));
+int trio_cprintfv TRIO_PROTO((trio_outstream_t stream, trio_pointer_t closure,
+			      TRIO_CONST char *format, void **args));
+
+int trio_sprintf TRIO_PROTO((char *buffer, TRIO_CONST char *format, ...));
+int trio_vsprintf TRIO_PROTO((char *buffer, TRIO_CONST char *format, va_list args));
+int trio_sprintfv TRIO_PROTO((char *buffer, TRIO_CONST char *format, void **args));
+
+int trio_snprintf TRIO_PROTO((char *buffer, size_t max, TRIO_CONST char *format, ...));
+int trio_vsnprintf TRIO_PROTO((char *buffer, size_t bufferSize, TRIO_CONST char *format,
+		   va_list args));
+int trio_snprintfv TRIO_PROTO((char *buffer, size_t bufferSize, TRIO_CONST char *format,
+		   void **args));
+
+int trio_snprintfcat TRIO_PROTO((char *buffer, size_t max, TRIO_CONST char *format, ...));
+int trio_vsnprintfcat TRIO_PROTO((char *buffer, size_t bufferSize, TRIO_CONST char *format,
+                      va_list args));
+
+char *trio_aprintf TRIO_PROTO((TRIO_CONST char *format, ...));
+char *trio_vaprintf TRIO_PROTO((TRIO_CONST char *format, va_list args));
+
+int trio_asprintf TRIO_PROTO((char **ret, TRIO_CONST char *format, ...));
+int trio_vasprintf TRIO_PROTO((char **ret, TRIO_CONST char *format, va_list args));
+
+/*************************************************************************
+ * Scan Functions
+ */
+int trio_scanf TRIO_PROTO((TRIO_CONST char *format, ...));
+int trio_vscanf TRIO_PROTO((TRIO_CONST char *format, va_list args));
+int trio_scanfv TRIO_PROTO((TRIO_CONST char *format, void **args));
+
+int trio_fscanf TRIO_PROTO((FILE *file, TRIO_CONST char *format, ...));
+int trio_vfscanf TRIO_PROTO((FILE *file, TRIO_CONST char *format, va_list args));
+int trio_fscanfv TRIO_PROTO((FILE *file, TRIO_CONST char *format, void **args));
+
+int trio_dscanf TRIO_PROTO((int fd, TRIO_CONST char *format, ...));
+int trio_vdscanf TRIO_PROTO((int fd, TRIO_CONST char *format, va_list args));
+int trio_dscanfv TRIO_PROTO((int fd, TRIO_CONST char *format, void **args));
+
+int trio_cscanf TRIO_PROTO((trio_instream_t stream, trio_pointer_t closure,
+			    TRIO_CONST char *format, ...));
+int trio_vcscanf TRIO_PROTO((trio_instream_t stream, trio_pointer_t closure,
+			     TRIO_CONST char *format, va_list args));
+int trio_cscanfv TRIO_PROTO((trio_instream_t stream, trio_pointer_t closure,
+			     TRIO_CONST char *format, void **args));
+
+int trio_sscanf TRIO_PROTO((TRIO_CONST char *buffer, TRIO_CONST char *format, ...));
+int trio_vsscanf TRIO_PROTO((TRIO_CONST char *buffer, TRIO_CONST char *format, va_list args));
+int trio_sscanfv TRIO_PROTO((TRIO_CONST char *buffer, TRIO_CONST char *format, void **args));
+
+/*************************************************************************
+ * Locale Functions
+ */
+void trio_locale_set_decimal_point TRIO_PROTO((char *decimalPoint));
+void trio_locale_set_thousand_separator TRIO_PROTO((char *thousandSeparator));
+void trio_locale_set_grouping TRIO_PROTO((char *grouping));
+
+/*************************************************************************
+ * Renaming
+ */
+#ifdef TRIO_REPLACE_STDIO
+/* Replace the <stdio.h> functions */
+#ifndef HAVE_PRINTF
+# define printf trio_printf
+#endif
+#ifndef HAVE_VPRINTF
+# define vprintf trio_vprintf
+#endif
+#ifndef HAVE_FPRINTF
+# define fprintf trio_fprintf
+#endif
+#ifndef HAVE_VFPRINTF
+# define vfprintf trio_vfprintf
+#endif
+#ifndef HAVE_SPRINTF
+# define sprintf trio_sprintf
+#endif
+#ifndef HAVE_VSPRINTF
+# define vsprintf trio_vsprintf
+#endif
+#ifndef HAVE_SNPRINTF
+# define snprintf trio_snprintf
+#endif
+#ifndef HAVE_VSNPRINTF
+# define vsnprintf trio_vsnprintf
+#endif
+#ifndef HAVE_SCANF
+# define scanf trio_scanf
+#endif
+#ifndef HAVE_VSCANF
+# define vscanf trio_vscanf
+#endif
+#ifndef HAVE_FSCANF
+# define fscanf trio_fscanf
+#endif
+#ifndef HAVE_VFSCANF
+# define vfscanf trio_vfscanf
+#endif
+#ifndef HAVE_SSCANF
+# define sscanf trio_sscanf
+#endif
+#ifndef HAVE_VSSCANF
+# define vsscanf trio_vsscanf
+#endif
+/* These aren't stdio functions, but we make them look similar */
+#define dprintf trio_dprintf
+#define vdprintf trio_vdprintf
+#define aprintf trio_aprintf
+#define vaprintf trio_vaprintf
+#define asprintf trio_asprintf
+#define vasprintf trio_vasprintf
+#define dscanf trio_dscanf
+#define vdscanf trio_vdscanf
+#endif
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* WITHOUT_TRIO */
+
+#endif /* TRIO_TRIO_H */
diff --git a/src/libxml/src/triodef.h b/src/libxml/src/triodef.h
new file mode 100644
index 0000000..fd6fdea
--- /dev/null
+++ b/src/libxml/src/triodef.h
@@ -0,0 +1,220 @@
+/*************************************************************************
+ *
+ * $Id: triodef.h,v 1.1 2008/11/12 02:25:23 agibert Exp $
+ *
+ * Copyright (C) 2001 Bjorn Reese <breese@users.sourceforge.net>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
+ * MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE AUTHORS AND
+ * CONTRIBUTORS ACCEPT NO RESPONSIBILITY IN ANY CONCEIVABLE MANNER.
+ *
+ ************************************************************************/
+
+#ifndef TRIO_TRIODEF_H
+#define TRIO_TRIODEF_H
+
+/*************************************************************************
+ * Platform and compiler support detection
+ */
+#if defined(__GNUC__)
+# define TRIO_COMPILER_GCC
+#elif defined(__SUNPRO_C)
+# define TRIO_COMPILER_SUNPRO
+#elif defined(__SUNPRO_CC)
+# define TRIO_COMPILER_SUNPRO
+# define __SUNPRO_C __SUNPRO_CC
+#elif defined(__xlC__) || defined(__IBMC__) || defined(__IBMCPP__)
+# define TRIO_COMPILER_XLC
+#elif defined(_AIX) && !defined(__GNUC__)
+# define TRIO_COMPILER_XLC /* Workaround for old xlc */
+#elif defined(__DECC) || defined(__DECCXX)
+# define TRIO_COMPILER_DECC
+#elif defined(__osf__) && defined(__LANGUAGE_C__)
+# define TRIO_COMPILER_DECC /* Workaround for old DEC C compilers */
+#elif defined(_MSC_VER)
+# define TRIO_COMPILER_MSVC
+#elif defined(__BORLANDC__)
+# define TRIO_COMPILER_BCB
+#endif
+
+#if defined(VMS) || defined(__VMS)
+/*
+ * VMS is placed first to avoid identifying the platform as Unix
+ * based on the DECC compiler later on.
+ */
+# define TRIO_PLATFORM_VMS
+#elif defined(unix) || defined(__unix) || defined(__unix__)
+# define TRIO_PLATFORM_UNIX
+#elif defined(TRIO_COMPILER_XLC) || defined(_AIX)
+# define TRIO_PLATFORM_UNIX
+#elif defined(TRIO_COMPILER_DECC) || defined(__osf___)
+# define TRIO_PLATFORM_UNIX
+#elif defined(__NetBSD__)
+# define TRIO_PLATFORM_UNIX
+#elif defined(__QNX__)
+# define TRIO_PLATFORM_UNIX
+# define TRIO_PLATFORM_QNX
+#elif defined(__CYGWIN__)
+# define TRIO_PLATFORM_UNIX
+#elif defined(AMIGA) && defined(TRIO_COMPILER_GCC)
+# define TRIO_PLATFORM_UNIX
+#elif defined(TRIO_COMPILER_MSVC) || defined(WIN32) || defined(_WIN32)
+# define TRIO_PLATFORM_WIN32
+#elif defined(mpeix) || defined(__mpexl)
+# define TRIO_PLATFORM_MPEIX
+#endif
+
+#if defined(_AIX)
+# define TRIO_PLATFORM_AIX
+#elif defined(__hpux)
+# define TRIO_PLATFORM_HPUX
+#elif defined(sun) || defined(__sun__)
+# if defined(__SVR4) || defined(__svr4__)
+#  define TRIO_PLATFORM_SOLARIS
+# else
+#  define TRIO_PLATFORM_SUNOS
+# endif
+#endif
+
+#if defined(__STDC__) || defined(TRIO_COMPILER_MSVC) || defined(TRIO_COMPILER_BCB)
+# define TRIO_COMPILER_SUPPORTS_C89
+# if defined(__STDC_VERSION__)
+#  define TRIO_COMPILER_SUPPORTS_C90
+#  if (__STDC_VERSION__ >= 199409L)
+#   define TRIO_COMPILER_SUPPORTS_C94
+#  endif
+#  if (__STDC_VERSION__ >= 199901L)
+#   define TRIO_COMPILER_SUPPORTS_C99
+#  endif
+# elif defined(TRIO_COMPILER_SUNPRO)
+#  if (__SUNPRO_C >= 0x420)
+#   define TRIO_COMPILER_SUPPORTS_C94
+#  endif
+# endif
+#endif
+
+#if defined(_XOPEN_SOURCE)
+# if defined(_XOPEN_SOURCE_EXTENDED)
+#  define TRIO_COMPILER_SUPPORTS_UNIX95
+# endif
+# if (_XOPEN_VERSION >= 500)
+#  define TRIO_COMPILER_SUPPORTS_UNIX98
+# endif
+# if (_XOPEN_VERSION >= 600)
+#  define TRIO_COMPILER_SUPPORTS_UNIX01
+# endif
+#endif
+
+/*************************************************************************
+ * Generic defines
+ */
+
+#if !defined(TRIO_PUBLIC)
+# define TRIO_PUBLIC
+#endif
+#if !defined(TRIO_PRIVATE)
+# define TRIO_PRIVATE static
+#endif
+
+#if !(defined(TRIO_COMPILER_SUPPORTS_C89) || defined(__cplusplus))
+# define TRIO_COMPILER_ANCIENT
+#endif
+
+#if defined(TRIO_COMPILER_ANCIENT)
+# define TRIO_CONST
+# define TRIO_VOLATILE
+# define TRIO_SIGNED
+typedef double trio_long_double_t;
+typedef char * trio_pointer_t;
+# define TRIO_SUFFIX_LONG(x) x
+# define TRIO_PROTO(x) ()
+# define TRIO_NOARGS
+# define TRIO_ARGS1(list,a1) list a1;
+# define TRIO_ARGS2(list,a1,a2) list a1; a2;
+# define TRIO_ARGS3(list,a1,a2,a3) list a1; a2; a3;
+# define TRIO_ARGS4(list,a1,a2,a3,a4) list a1; a2; a3; a4;
+# define TRIO_ARGS5(list,a1,a2,a3,a4,a5) list a1; a2; a3; a4; a5;
+# define TRIO_ARGS6(list,a1,a2,a3,a4,a5,a6) list a1; a2; a3; a4; a5; a6;
+# define TRIO_VARGS2(list,a1,a2) list a1; a2
+# define TRIO_VARGS3(list,a1,a2,a3) list a1; a2; a3
+# define TRIO_VARGS4(list,a1,a2,a3,a4) list a1; a2; a3; a4
+# define TRIO_VARGS5(list,a1,a2,a3,a4,a5) list a1; a2; a3; a4; a5
+# define TRIO_VA_DECL va_dcl
+# define TRIO_VA_START(x,y) va_start(x)
+# define TRIO_VA_END(x) va_end(x)
+#else /* ANSI C */
+# define TRIO_CONST const
+# define TRIO_VOLATILE volatile
+# define TRIO_SIGNED signed
+typedef long double trio_long_double_t;
+typedef void * trio_pointer_t;
+# define TRIO_SUFFIX_LONG(x) x ## L
+# define TRIO_PROTO(x) x
+# define TRIO_NOARGS void
+# define TRIO_ARGS1(list,a1) (a1)
+# define TRIO_ARGS2(list,a1,a2) (a1,a2)
+# define TRIO_ARGS3(list,a1,a2,a3) (a1,a2,a3)
+# define TRIO_ARGS4(list,a1,a2,a3,a4) (a1,a2,a3,a4)
+# define TRIO_ARGS5(list,a1,a2,a3,a4,a5) (a1,a2,a3,a4,a5)
+# define TRIO_ARGS6(list,a1,a2,a3,a4,a5,a6) (a1,a2,a3,a4,a5,a6)
+# define TRIO_VARGS2 TRIO_ARGS2
+# define TRIO_VARGS3 TRIO_ARGS3
+# define TRIO_VARGS4 TRIO_ARGS4
+# define TRIO_VARGS5 TRIO_ARGS5
+# define TRIO_VA_DECL ...
+# define TRIO_VA_START(x,y) va_start(x,y)
+# define TRIO_VA_END(x) va_end(x)
+#endif
+
+#if defined(TRIO_COMPILER_SUPPORTS_C99) || defined(__cplusplus)
+# define TRIO_INLINE inline
+#elif defined(TRIO_COMPILER_GCC)
+# define TRIO_INLINE __inline__
+#elif defined(TRIO_COMPILER_MSVC)
+# define TRIO_INLINE _inline
+#elif defined(TRIO_COMPILER_BCB)
+# define TRIO_INLINE __inline
+#else
+# define TRIO_INLINE
+#endif
+
+/*************************************************************************
+ * Workarounds
+ */
+
+#if defined(TRIO_PLATFORM_VMS)
+/*
+ * Computations done with constants at compile time can trigger these
+ * even when compiling with IEEE enabled.
+ */
+# pragma message disable (UNDERFLOW, FLOATOVERFL)
+
+# if (__CRTL_VER < 80000000)
+/*
+ * Although the compiler supports C99 language constructs, the C
+ * run-time library does not contain all C99 functions.
+ *
+ * This was the case for 70300022. Update the 80000000 value when
+ * it has been accurately determined what version of the library
+ * supports C99.
+ */
+#  if defined(TRIO_COMPILER_SUPPORTS_C99)
+#   undef TRIO_COMPILER_SUPPORTS_C99
+#  endif
+# endif
+#endif
+
+/*
+ * Not all preprocessors supports the LL token.
+ */
+#if defined(TRIO_COMPILER_BCB)
+#else
+# define TRIO_COMPILER_SUPPORTS_LL
+#endif
+
+#endif /* TRIO_TRIODEF_H */
diff --git a/src/libxml/src/trionan.c b/src/libxml/src/trionan.c
new file mode 100644
index 0000000..411ec18
--- /dev/null
+++ b/src/libxml/src/trionan.c
@@ -0,0 +1,910 @@
+/*************************************************************************
+ *
+ * $Id: trionan.c,v 1.1 2008/11/12 02:25:23 agibert Exp $
+ *
+ * Copyright (C) 2001 Bjorn Reese <breese@users.sourceforge.net>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
+ * MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE AUTHORS AND
+ * CONTRIBUTORS ACCEPT NO RESPONSIBILITY IN ANY CONCEIVABLE MANNER.
+ *
+ ************************************************************************
+ *
+ * Functions to handle special quantities in floating-point numbers
+ * (that is, NaNs and infinity). They provide the capability to detect
+ * and fabricate special quantities.
+ *
+ * Although written to be as portable as possible, it can never be
+ * guaranteed to work on all platforms, as not all hardware supports
+ * special quantities.
+ *
+ * The approach used here (approximately) is to:
+ *
+ *   1. Use C99 functionality when available.
+ *   2. Use IEEE 754 bit-patterns if possible.
+ *   3. Use platform-specific techniques.
+ *
+ ************************************************************************/
+
+/*
+ * TODO:
+ *  o Put all the magic into trio_fpclassify_and_signbit(), and use this from
+ *    trio_isnan() etc.
+ */
+
+/*************************************************************************
+ * Include files
+ */
+#include "triodef.h"
+#include "trionan.h"
+
+#include <math.h>
+#include <string.h>
+#include <limits.h>
+#include <float.h>
+#if defined(TRIO_PLATFORM_UNIX)
+# include <signal.h>
+#endif
+#if defined(TRIO_COMPILER_DECC)
+#  if defined(__linux__)
+#   include <cpml.h>
+#  else
+#   include <fp_class.h>
+#  endif
+#endif
+#include <assert.h>
+
+#if defined(TRIO_DOCUMENTATION)
+# include "doc/doc_nan.h"
+#endif
+/** @addtogroup SpecialQuantities
+    @{
+*/
+
+/*************************************************************************
+ * Definitions
+ */
+
+#define TRIO_TRUE (1 == 1)
+#define TRIO_FALSE (0 == 1)
+
+/*
+ * We must enable IEEE floating-point on Alpha
+ */
+#if defined(__alpha) && !defined(_IEEE_FP)
+# if defined(TRIO_COMPILER_DECC)
+#  if defined(TRIO_PLATFORM_VMS)
+#   error "Must be compiled with option /IEEE_MODE=UNDERFLOW_TO_ZERO/FLOAT=IEEE"
+#  else
+#   if !defined(_CFE)
+#    error "Must be compiled with option -ieee"
+#   endif
+#  endif
+# elif defined(TRIO_COMPILER_GCC) && (defined(__osf__) || defined(__linux__))
+#  error "Must be compiled with option -mieee"
+# endif
+#endif /* __alpha && ! _IEEE_FP */
+
+/*
+ * In ANSI/IEEE 754-1985 64-bits double format numbers have the
+ * following properties (amoungst others)
+ *
+ *   o FLT_RADIX == 2: binary encoding
+ *   o DBL_MAX_EXP == 1024: 11 bits exponent, where one bit is used
+ *     to indicate special numbers (e.g. NaN and Infinity), so the
+ *     maximum exponent is 10 bits wide (2^10 == 1024).
+ *   o DBL_MANT_DIG == 53: The mantissa is 52 bits wide, but because
+ *     numbers are normalized the initial binary 1 is represented
+ *     implicitly (the so-called "hidden bit"), which leaves us with
+ *     the ability to represent 53 bits wide mantissa.
+ */
+#if (FLT_RADIX == 2) && (DBL_MAX_EXP == 1024) && (DBL_MANT_DIG == 53)
+# define USE_IEEE_754
+#endif
+
+
+/*************************************************************************
+ * Constants
+ */
+
+static TRIO_CONST char rcsid[] = "@(#)$Id: trionan.c,v 1.1 2008/11/12 02:25:23 agibert Exp $";
+
+#if defined(USE_IEEE_754)
+
+/*
+ * Endian-agnostic indexing macro.
+ *
+ * The value of internalEndianMagic, when converted into a 64-bit
+ * integer, becomes 0x0706050403020100 (we could have used a 64-bit
+ * integer value instead of a double, but not all platforms supports
+ * that type). The value is automatically encoded with the correct
+ * endianess by the compiler, which means that we can support any
+ * kind of endianess. The individual bytes are then used as an index
+ * for the IEEE 754 bit-patterns and masks.
+ */
+#define TRIO_DOUBLE_INDEX(x) (((unsigned char *)&internalEndianMagic)[7-(x)])
+
+static TRIO_CONST double internalEndianMagic = 7.949928895127363e-275;
+
+/* Mask for the exponent */
+static TRIO_CONST unsigned char ieee_754_exponent_mask[] = {
+  0x7F, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+};
+
+/* Mask for the mantissa */
+static TRIO_CONST unsigned char ieee_754_mantissa_mask[] = {
+  0x00, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
+};
+
+/* Mask for the sign bit */
+static TRIO_CONST unsigned char ieee_754_sign_mask[] = {
+  0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+};
+
+/* Bit-pattern for negative zero */
+static TRIO_CONST unsigned char ieee_754_negzero_array[] = {
+  0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+};
+
+/* Bit-pattern for infinity */
+static TRIO_CONST unsigned char ieee_754_infinity_array[] = {
+  0x7F, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+};
+
+/* Bit-pattern for quiet NaN */
+static TRIO_CONST unsigned char ieee_754_qnan_array[] = {
+  0x7F, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+};
+
+
+/*************************************************************************
+ * Functions
+ */
+
+/*
+ * trio_make_double
+ */
+TRIO_PRIVATE double
+trio_make_double
+TRIO_ARGS1((values),
+	   TRIO_CONST unsigned char *values)
+{
+  TRIO_VOLATILE double result;
+  int i;
+
+  for (i = 0; i < (int)sizeof(double); i++) {
+    ((TRIO_VOLATILE unsigned char *)&result)[TRIO_DOUBLE_INDEX(i)] = values[i];
+  }
+  return result;
+}
+
+/*
+ * trio_is_special_quantity
+ */
+TRIO_PRIVATE int
+trio_is_special_quantity
+TRIO_ARGS2((number, has_mantissa),
+	   double number,
+	   int *has_mantissa)
+{
+  unsigned int i;
+  unsigned char current;
+  int is_special_quantity = TRIO_TRUE;
+
+  *has_mantissa = 0;
+
+  for (i = 0; i < (unsigned int)sizeof(double); i++) {
+    current = ((unsigned char *)&number)[TRIO_DOUBLE_INDEX(i)];
+    is_special_quantity
+      &= ((current & ieee_754_exponent_mask[i]) == ieee_754_exponent_mask[i]);
+    *has_mantissa |= (current & ieee_754_mantissa_mask[i]);
+  }
+  return is_special_quantity;
+}
+
+/*
+ * trio_is_negative
+ */
+TRIO_PRIVATE int
+trio_is_negative
+TRIO_ARGS1((number),
+	   double number)
+{
+  unsigned int i;
+  int is_negative = TRIO_FALSE;
+
+  for (i = 0; i < (unsigned int)sizeof(double); i++) {
+    is_negative |= (((unsigned char *)&number)[TRIO_DOUBLE_INDEX(i)]
+		    & ieee_754_sign_mask[i]);
+  }
+  return is_negative;
+}
+
+#endif /* USE_IEEE_754 */
+
+
+/**
+   Generate negative zero.
+
+   @return Floating-point representation of negative zero.
+*/
+TRIO_PUBLIC double
+trio_nzero(TRIO_NOARGS)
+{
+#if defined(USE_IEEE_754)
+  return trio_make_double(ieee_754_negzero_array);
+#else
+  TRIO_VOLATILE double zero = 0.0;
+
+  return -zero;
+#endif
+}
+
+/**
+   Generate positive infinity.
+
+   @return Floating-point representation of positive infinity.
+*/
+TRIO_PUBLIC double
+trio_pinf(TRIO_NOARGS)
+{
+  /* Cache the result */
+  static double result = 0.0;
+
+  if (result == 0.0) {
+    
+#if defined(INFINITY) && defined(__STDC_IEC_559__)
+    result = (double)INFINITY;
+
+#elif defined(USE_IEEE_754)
+    result = trio_make_double(ieee_754_infinity_array);
+
+#else
+    /*
+     * If HUGE_VAL is different from DBL_MAX, then HUGE_VAL is used
+     * as infinity. Otherwise we have to resort to an overflow
+     * operation to generate infinity.
+     */
+# if defined(TRIO_PLATFORM_UNIX)
+    void (*signal_handler)(int) = signal(SIGFPE, SIG_IGN);
+# endif
+
+    result = HUGE_VAL;
+    if (HUGE_VAL == DBL_MAX) {
+      /* Force overflow */
+      result += HUGE_VAL;
+    }
+    
+# if defined(TRIO_PLATFORM_UNIX)
+    signal(SIGFPE, signal_handler);
+# endif
+
+#endif
+  }
+  return result;
+}
+
+/**
+   Generate negative infinity.
+
+   @return Floating-point value of negative infinity.
+*/
+TRIO_PUBLIC double
+trio_ninf(TRIO_NOARGS)
+{
+  static double result = 0.0;
+
+  if (result == 0.0) {
+    /*
+     * Negative infinity is calculated by negating positive infinity,
+     * which can be done because it is legal to do calculations on
+     * infinity (for example,  1 / infinity == 0).
+     */
+    result = -trio_pinf();
+  }
+  return result;
+}
+
+/**
+   Generate NaN.
+
+   @return Floating-point representation of NaN.
+*/
+TRIO_PUBLIC double
+trio_nan(TRIO_NOARGS)
+{
+  /* Cache the result */
+  static double result = 0.0;
+
+  if (result == 0.0) {
+    
+#if defined(TRIO_COMPILER_SUPPORTS_C99)
+    result = nan("");
+
+#elif defined(NAN) && defined(__STDC_IEC_559__)
+    result = (double)NAN;
+  
+#elif defined(USE_IEEE_754)
+    result = trio_make_double(ieee_754_qnan_array);
+
+#else
+    /*
+     * There are several ways to generate NaN. The one used here is
+     * to divide infinity by infinity. I would have preferred to add
+     * negative infinity to positive infinity, but that yields wrong
+     * result (infinity) on FreeBSD.
+     *
+     * This may fail if the hardware does not support NaN, or if
+     * the Invalid Operation floating-point exception is unmasked.
+     */
+# if defined(TRIO_PLATFORM_UNIX)
+    void (*signal_handler)(int) = signal(SIGFPE, SIG_IGN);
+# endif
+    
+    result = trio_pinf() / trio_pinf();
+    
+# if defined(TRIO_PLATFORM_UNIX)
+    signal(SIGFPE, signal_handler);
+# endif
+    
+#endif
+  }
+  return result;
+}
+
+/**
+   Check for NaN.
+
+   @param number An arbitrary floating-point number.
+   @return Boolean value indicating whether or not the number is a NaN.
+*/
+TRIO_PUBLIC int
+trio_isnan
+TRIO_ARGS1((number),
+	   double number)
+{
+#if (defined(TRIO_COMPILER_SUPPORTS_C99) && defined(isnan)) \
+ || defined(TRIO_COMPILER_SUPPORTS_UNIX95)
+  /*
+   * C99 defines isnan() as a macro. UNIX95 defines isnan() as a
+   * function. This function was already present in XPG4, but this
+   * is a bit tricky to detect with compiler defines, so we choose
+   * the conservative approach and only use it for UNIX95.
+   */
+  return isnan(number);
+  
+#elif defined(TRIO_COMPILER_MSVC) || defined(TRIO_COMPILER_BCB)
+  /*
+   * Microsoft Visual C++ and Borland C++ Builder have an _isnan()
+   * function.
+   */
+  return _isnan(number) ? TRIO_TRUE : TRIO_FALSE;
+
+#elif defined(USE_IEEE_754)
+  /*
+   * Examine IEEE 754 bit-pattern. A NaN must have a special exponent
+   * pattern, and a non-empty mantissa.
+   */
+  int has_mantissa;
+  int is_special_quantity;
+
+  is_special_quantity = trio_is_special_quantity(number, &has_mantissa);
+  
+  return (is_special_quantity && has_mantissa);
+  
+#else
+  /*
+   * Fallback solution
+   */
+  int status;
+  double integral, fraction;
+  
+# if defined(TRIO_PLATFORM_UNIX)
+  void (*signal_handler)(int) = signal(SIGFPE, SIG_IGN);
+# endif
+  
+  status = (/*
+	     * NaN is the only number which does not compare to itself
+	     */
+	    ((TRIO_VOLATILE double)number != (TRIO_VOLATILE double)number) ||
+	    /*
+	     * Fallback solution if NaN compares to NaN
+	     */
+	    ((number != 0.0) &&
+	     (fraction = modf(number, &integral),
+	      integral == fraction)));
+  
+# if defined(TRIO_PLATFORM_UNIX)
+  signal(SIGFPE, signal_handler);
+# endif
+  
+  return status;
+  
+#endif
+}
+
+/**
+   Check for infinity.
+
+   @param number An arbitrary floating-point number.
+   @return 1 if positive infinity, -1 if negative infinity, 0 otherwise.
+*/
+TRIO_PUBLIC int
+trio_isinf
+TRIO_ARGS1((number),
+	   double number)
+{
+#if defined(TRIO_COMPILER_DECC) && !defined(__linux__)
+  /*
+   * DECC has an isinf() macro, but it works differently than that
+   * of C99, so we use the fp_class() function instead.
+   */
+  return ((fp_class(number) == FP_POS_INF)
+	  ? 1
+	  : ((fp_class(number) == FP_NEG_INF) ? -1 : 0));
+
+#elif defined(isinf)
+  /*
+   * C99 defines isinf() as a macro.
+   */
+  return isinf(number)
+    ? ((number > 0.0) ? 1 : -1)
+    : 0;
+  
+#elif defined(TRIO_COMPILER_MSVC) || defined(TRIO_COMPILER_BCB)
+  /*
+   * Microsoft Visual C++ and Borland C++ Builder have an _fpclass()
+   * function that can be used to detect infinity.
+   */
+  return ((_fpclass(number) == _FPCLASS_PINF)
+	  ? 1
+	  : ((_fpclass(number) == _FPCLASS_NINF) ? -1 : 0));
+
+#elif defined(USE_IEEE_754)
+  /*
+   * Examine IEEE 754 bit-pattern. Infinity must have a special exponent
+   * pattern, and an empty mantissa.
+   */
+  int has_mantissa;
+  int is_special_quantity;
+
+  is_special_quantity = trio_is_special_quantity(number, &has_mantissa);
+  
+  return (is_special_quantity && !has_mantissa)
+    ? ((number < 0.0) ? -1 : 1)
+    : 0;
+
+#else
+  /*
+   * Fallback solution.
+   */
+  int status;
+  
+# if defined(TRIO_PLATFORM_UNIX)
+  void (*signal_handler)(int) = signal(SIGFPE, SIG_IGN);
+# endif
+  
+  double infinity = trio_pinf();
+  
+  status = ((number == infinity)
+	    ? 1
+	    : ((number == -infinity) ? -1 : 0));
+  
+# if defined(TRIO_PLATFORM_UNIX)
+  signal(SIGFPE, signal_handler);
+# endif
+  
+  return status;
+  
+#endif
+}
+
+#if 0
+	/* Temporary fix - this routine is not used anywhere */
+/**
+   Check for finity.
+
+   @param number An arbitrary floating-point number.
+   @return Boolean value indicating whether or not the number is a finite.
+*/
+TRIO_PUBLIC int
+trio_isfinite
+TRIO_ARGS1((number),
+	   double number)
+{
+#if defined(TRIO_COMPILER_SUPPORTS_C99) && defined(isfinite)
+  /*
+   * C99 defines isfinite() as a macro.
+   */
+  return isfinite(number);
+  
+#elif defined(TRIO_COMPILER_MSVC) || defined(TRIO_COMPILER_BCB)
+  /*
+   * Microsoft Visual C++ and Borland C++ Builder use _finite().
+   */
+  return _finite(number);
+
+#elif defined(USE_IEEE_754)
+  /*
+   * Examine IEEE 754 bit-pattern. For finity we do not care about the
+   * mantissa.
+   */
+  int dummy;
+
+  return (! trio_is_special_quantity(number, &dummy));
+
+#else
+  /*
+   * Fallback solution.
+   */
+  return ((trio_isinf(number) == 0) && (trio_isnan(number) == 0));
+  
+#endif
+}
+
+#endif
+
+/*
+ * The sign of NaN is always false
+ */
+TRIO_PUBLIC int
+trio_fpclassify_and_signbit
+TRIO_ARGS2((number, is_negative),
+	   double number,
+	   int *is_negative)
+{
+#if defined(fpclassify) && defined(signbit)
+  /*
+   * C99 defines fpclassify() and signbit() as a macros
+   */
+  *is_negative = signbit(number);
+  switch (fpclassify(number)) {
+  case FP_NAN:
+    return TRIO_FP_NAN;
+  case FP_INFINITE:
+    return TRIO_FP_INFINITE;
+  case FP_SUBNORMAL:
+    return TRIO_FP_SUBNORMAL;
+  case FP_ZERO:
+    return TRIO_FP_ZERO;
+  default:
+    return TRIO_FP_NORMAL;
+  }
+
+#else
+# if defined(TRIO_COMPILER_DECC)
+  /*
+   * DECC has an fp_class() function.
+   */
+#  define TRIO_FPCLASSIFY(n) fp_class(n)
+#  define TRIO_QUIET_NAN FP_QNAN
+#  define TRIO_SIGNALLING_NAN FP_SNAN
+#  define TRIO_POSITIVE_INFINITY FP_POS_INF
+#  define TRIO_NEGATIVE_INFINITY FP_NEG_INF
+#  define TRIO_POSITIVE_SUBNORMAL FP_POS_DENORM
+#  define TRIO_NEGATIVE_SUBNORMAL FP_NEG_DENORM
+#  define TRIO_POSITIVE_ZERO FP_POS_ZERO
+#  define TRIO_NEGATIVE_ZERO FP_NEG_ZERO
+#  define TRIO_POSITIVE_NORMAL FP_POS_NORM
+#  define TRIO_NEGATIVE_NORMAL FP_NEG_NORM
+  
+# elif defined(TRIO_COMPILER_MSVC) || defined(TRIO_COMPILER_BCB)
+  /*
+   * Microsoft Visual C++ and Borland C++ Builder have an _fpclass()
+   * function.
+   */
+#  define TRIO_FPCLASSIFY(n) _fpclass(n)
+#  define TRIO_QUIET_NAN _FPCLASS_QNAN
+#  define TRIO_SIGNALLING_NAN _FPCLASS_SNAN
+#  define TRIO_POSITIVE_INFINITY _FPCLASS_PINF
+#  define TRIO_NEGATIVE_INFINITY _FPCLASS_NINF
+#  define TRIO_POSITIVE_SUBNORMAL _FPCLASS_PD
+#  define TRIO_NEGATIVE_SUBNORMAL _FPCLASS_ND
+#  define TRIO_POSITIVE_ZERO _FPCLASS_PZ
+#  define TRIO_NEGATIVE_ZERO _FPCLASS_NZ
+#  define TRIO_POSITIVE_NORMAL _FPCLASS_PN
+#  define TRIO_NEGATIVE_NORMAL _FPCLASS_NN
+  
+# elif defined(FP_PLUS_NORM)
+  /*
+   * HP-UX 9.x and 10.x have an fpclassify() function, that is different
+   * from the C99 fpclassify() macro supported on HP-UX 11.x.
+   *
+   * AIX has class() for C, and _class() for C++, which returns the
+   * same values as the HP-UX fpclassify() function.
+   */
+#  if defined(TRIO_PLATFORM_AIX)
+#   if defined(__cplusplus)
+#    define TRIO_FPCLASSIFY(n) _class(n)
+#   else
+#    define TRIO_FPCLASSIFY(n) class(n)
+#   endif
+#  else
+#   define TRIO_FPCLASSIFY(n) fpclassify(n)
+#  endif
+#  define TRIO_QUIET_NAN FP_QNAN
+#  define TRIO_SIGNALLING_NAN FP_SNAN
+#  define TRIO_POSITIVE_INFINITY FP_PLUS_INF
+#  define TRIO_NEGATIVE_INFINITY FP_MINUS_INF
+#  define TRIO_POSITIVE_SUBNORMAL FP_PLUS_DENORM
+#  define TRIO_NEGATIVE_SUBNORMAL FP_MINUS_DENORM
+#  define TRIO_POSITIVE_ZERO FP_PLUS_ZERO
+#  define TRIO_NEGATIVE_ZERO FP_MINUS_ZERO
+#  define TRIO_POSITIVE_NORMAL FP_PLUS_NORM
+#  define TRIO_NEGATIVE_NORMAL FP_MINUS_NORM
+# endif
+
+# if defined(TRIO_FPCLASSIFY)
+  switch (TRIO_FPCLASSIFY(number)) {
+  case TRIO_QUIET_NAN:
+  case TRIO_SIGNALLING_NAN:
+    *is_negative = TRIO_FALSE; /* NaN has no sign */
+    return TRIO_FP_NAN;
+  case TRIO_POSITIVE_INFINITY:
+    *is_negative = TRIO_FALSE;
+    return TRIO_FP_INFINITE;
+  case TRIO_NEGATIVE_INFINITY:
+    *is_negative = TRIO_TRUE;
+    return TRIO_FP_INFINITE;
+  case TRIO_POSITIVE_SUBNORMAL:
+    *is_negative = TRIO_FALSE;
+    return TRIO_FP_SUBNORMAL;
+  case TRIO_NEGATIVE_SUBNORMAL:
+    *is_negative = TRIO_TRUE;
+    return TRIO_FP_SUBNORMAL;
+  case TRIO_POSITIVE_ZERO:
+    *is_negative = TRIO_FALSE;
+    return TRIO_FP_ZERO;
+  case TRIO_NEGATIVE_ZERO:
+    *is_negative = TRIO_TRUE;
+    return TRIO_FP_ZERO;
+  case TRIO_POSITIVE_NORMAL:
+    *is_negative = TRIO_FALSE;
+    return TRIO_FP_NORMAL;
+  case TRIO_NEGATIVE_NORMAL:
+    *is_negative = TRIO_TRUE;
+    return TRIO_FP_NORMAL;
+  default:
+    /* Just in case... */
+    *is_negative = (number < 0.0);
+    return TRIO_FP_NORMAL;
+  }
+  
+# else
+  /*
+   * Fallback solution.
+   */
+  int rc;
+  
+  if (number == 0.0) {
+    /*
+     * In IEEE 754 the sign of zero is ignored in comparisons, so we
+     * have to handle this as a special case by examining the sign bit
+     * directly.
+     */
+#  if defined(USE_IEEE_754)
+    *is_negative = trio_is_negative(number);
+#  else
+    *is_negative = TRIO_FALSE; /* FIXME */
+#  endif
+    return TRIO_FP_ZERO;
+  }
+  if (trio_isnan(number)) {
+    *is_negative = TRIO_FALSE;
+    return TRIO_FP_NAN;
+  }
+  if ((rc = trio_isinf(number))) {
+    *is_negative = (rc == -1);
+    return TRIO_FP_INFINITE;
+  }
+  if ((number > 0.0) && (number < DBL_MIN)) {
+    *is_negative = TRIO_FALSE;
+    return TRIO_FP_SUBNORMAL;
+  }
+  if ((number < 0.0) && (number > -DBL_MIN)) {
+    *is_negative = TRIO_TRUE;
+    return TRIO_FP_SUBNORMAL;
+  }
+  *is_negative = (number < 0.0);
+  return TRIO_FP_NORMAL;
+  
+# endif
+#endif
+}
+
+/**
+   Examine the sign of a number.
+
+   @param number An arbitrary floating-point number.
+   @return Boolean value indicating whether or not the number has the
+   sign bit set (i.e. is negative).
+*/
+TRIO_PUBLIC int
+trio_signbit
+TRIO_ARGS1((number),
+	   double number)
+{
+  int is_negative;
+  
+  (void)trio_fpclassify_and_signbit(number, &is_negative);
+  return is_negative;
+}
+
+#if 0
+	/* Temporary fix - this routine is not used in libxml */
+/**
+   Examine the class of a number.
+
+   @param number An arbitrary floating-point number.
+   @return Enumerable value indicating the class of @p number
+*/
+TRIO_PUBLIC int
+trio_fpclassify
+TRIO_ARGS1((number),
+	   double number)
+{
+  int dummy;
+  
+  return trio_fpclassify_and_signbit(number, &dummy);
+}
+
+#endif
+
+/** @} SpecialQuantities */
+
+/*************************************************************************
+ * For test purposes.
+ *
+ * Add the following compiler option to include this test code.
+ *
+ *  Unix : -DSTANDALONE
+ *  VMS  : /DEFINE=(STANDALONE)
+ */
+#if defined(STANDALONE)
+# include <stdio.h>
+
+static TRIO_CONST char *
+getClassification
+TRIO_ARGS1((type),
+	   int type)
+{
+  switch (type) {
+  case TRIO_FP_INFINITE:
+    return "FP_INFINITE";
+  case TRIO_FP_NAN:
+    return "FP_NAN";
+  case TRIO_FP_NORMAL:
+    return "FP_NORMAL";
+  case TRIO_FP_SUBNORMAL:
+    return "FP_SUBNORMAL";
+  case TRIO_FP_ZERO:
+    return "FP_ZERO";
+  default:
+    return "FP_UNKNOWN";
+  }
+}
+
+static void
+print_class
+TRIO_ARGS2((prefix, number),
+	   TRIO_CONST char *prefix,
+	   double number)
+{
+  printf("%-6s: %s %-15s %g\n",
+	 prefix,
+	 trio_signbit(number) ? "-" : "+",
+	 getClassification(TRIO_FPCLASSIFY(number)),
+	 number);
+}
+
+int main(TRIO_NOARGS)
+{
+  double my_nan;
+  double my_pinf;
+  double my_ninf;
+# if defined(TRIO_PLATFORM_UNIX)
+  void (*signal_handler) TRIO_PROTO((int));
+# endif
+
+  my_nan = trio_nan();
+  my_pinf = trio_pinf();
+  my_ninf = trio_ninf();
+
+  print_class("Nan", my_nan);
+  print_class("PInf", my_pinf);
+  print_class("NInf", my_ninf);
+  print_class("PZero", 0.0);
+  print_class("NZero", -0.0);
+  print_class("PNorm", 1.0);
+  print_class("NNorm", -1.0);
+  print_class("PSub", 1.01e-307 - 1.00e-307);
+  print_class("NSub", 1.00e-307 - 1.01e-307);
+  
+  printf("NaN : %4g 0x%02x%02x%02x%02x%02x%02x%02x%02x (%2d, %2d)\n",
+	 my_nan,
+	 ((unsigned char *)&my_nan)[0],
+	 ((unsigned char *)&my_nan)[1],
+	 ((unsigned char *)&my_nan)[2],
+	 ((unsigned char *)&my_nan)[3],
+	 ((unsigned char *)&my_nan)[4],
+	 ((unsigned char *)&my_nan)[5],
+	 ((unsigned char *)&my_nan)[6],
+	 ((unsigned char *)&my_nan)[7],
+	 trio_isnan(my_nan), trio_isinf(my_nan));
+  printf("PInf: %4g 0x%02x%02x%02x%02x%02x%02x%02x%02x (%2d, %2d)\n",
+	 my_pinf,
+	 ((unsigned char *)&my_pinf)[0],
+	 ((unsigned char *)&my_pinf)[1],
+	 ((unsigned char *)&my_pinf)[2],
+	 ((unsigned char *)&my_pinf)[3],
+	 ((unsigned char *)&my_pinf)[4],
+	 ((unsigned char *)&my_pinf)[5],
+	 ((unsigned char *)&my_pinf)[6],
+	 ((unsigned char *)&my_pinf)[7],
+	 trio_isnan(my_pinf), trio_isinf(my_pinf));
+  printf("NInf: %4g 0x%02x%02x%02x%02x%02x%02x%02x%02x (%2d, %2d)\n",
+	 my_ninf,
+	 ((unsigned char *)&my_ninf)[0],
+	 ((unsigned char *)&my_ninf)[1],
+	 ((unsigned char *)&my_ninf)[2],
+	 ((unsigned char *)&my_ninf)[3],
+	 ((unsigned char *)&my_ninf)[4],
+	 ((unsigned char *)&my_ninf)[5],
+	 ((unsigned char *)&my_ninf)[6],
+	 ((unsigned char *)&my_ninf)[7],
+	 trio_isnan(my_ninf), trio_isinf(my_ninf));
+  
+# if defined(TRIO_PLATFORM_UNIX)
+  signal_handler = signal(SIGFPE, SIG_IGN);
+# endif
+  
+  my_pinf = DBL_MAX + DBL_MAX;
+  my_ninf = -my_pinf;
+  my_nan = my_pinf / my_pinf;
+
+# if defined(TRIO_PLATFORM_UNIX)
+  signal(SIGFPE, signal_handler);
+# endif
+  
+  printf("NaN : %4g 0x%02x%02x%02x%02x%02x%02x%02x%02x (%2d, %2d)\n",
+	 my_nan,
+	 ((unsigned char *)&my_nan)[0],
+	 ((unsigned char *)&my_nan)[1],
+	 ((unsigned char *)&my_nan)[2],
+	 ((unsigned char *)&my_nan)[3],
+	 ((unsigned char *)&my_nan)[4],
+	 ((unsigned char *)&my_nan)[5],
+	 ((unsigned char *)&my_nan)[6],
+	 ((unsigned char *)&my_nan)[7],
+	 trio_isnan(my_nan), trio_isinf(my_nan));
+  printf("PInf: %4g 0x%02x%02x%02x%02x%02x%02x%02x%02x (%2d, %2d)\n",
+	 my_pinf,
+	 ((unsigned char *)&my_pinf)[0],
+	 ((unsigned char *)&my_pinf)[1],
+	 ((unsigned char *)&my_pinf)[2],
+	 ((unsigned char *)&my_pinf)[3],
+	 ((unsigned char *)&my_pinf)[4],
+	 ((unsigned char *)&my_pinf)[5],
+	 ((unsigned char *)&my_pinf)[6],
+	 ((unsigned char *)&my_pinf)[7],
+	 trio_isnan(my_pinf), trio_isinf(my_pinf));
+  printf("NInf: %4g 0x%02x%02x%02x%02x%02x%02x%02x%02x (%2d, %2d)\n",
+	 my_ninf,
+	 ((unsigned char *)&my_ninf)[0],
+	 ((unsigned char *)&my_ninf)[1],
+	 ((unsigned char *)&my_ninf)[2],
+	 ((unsigned char *)&my_ninf)[3],
+	 ((unsigned char *)&my_ninf)[4],
+	 ((unsigned char *)&my_ninf)[5],
+	 ((unsigned char *)&my_ninf)[6],
+	 ((unsigned char *)&my_ninf)[7],
+	 trio_isnan(my_ninf), trio_isinf(my_ninf));
+  
+  return 0;
+}
+#endif
diff --git a/src/libxml/src/trionan.h b/src/libxml/src/trionan.h
new file mode 100644
index 0000000..2745a78
--- /dev/null
+++ b/src/libxml/src/trionan.h
@@ -0,0 +1,84 @@
+/*************************************************************************
+ *
+ * $Id: trionan.h,v 1.1 2008/11/12 02:25:23 agibert Exp $
+ *
+ * Copyright (C) 2001 Bjorn Reese <breese@users.sourceforge.net>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
+ * MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE AUTHORS AND
+ * CONTRIBUTORS ACCEPT NO RESPONSIBILITY IN ANY CONCEIVABLE MANNER.
+ *
+ ************************************************************************/
+
+#ifndef TRIO_NAN_H
+#define TRIO_NAN_H
+
+#include "triodef.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum {
+  TRIO_FP_INFINITE,
+  TRIO_FP_NAN,
+  TRIO_FP_NORMAL,
+  TRIO_FP_SUBNORMAL,
+  TRIO_FP_ZERO
+};
+
+/*
+ * Return NaN (Not-a-Number).
+ */
+TRIO_PUBLIC double trio_nan TRIO_PROTO((void));
+
+/*
+ * Return positive infinity.
+ */
+TRIO_PUBLIC double trio_pinf TRIO_PROTO((void));
+
+/*
+ * Return negative infinity.
+ */
+TRIO_PUBLIC double trio_ninf TRIO_PROTO((void));
+  
+/*
+ * Return negative zero.
+ */
+TRIO_PUBLIC double trio_nzero TRIO_PROTO((TRIO_NOARGS));
+
+/*
+ * If number is a NaN return non-zero, otherwise return zero.
+ */
+TRIO_PUBLIC int trio_isnan TRIO_PROTO((double number));
+
+/*
+ * If number is positive infinity return 1, if number is negative
+ * infinity return -1, otherwise return 0.
+ */
+TRIO_PUBLIC int trio_isinf TRIO_PROTO((double number));
+
+/*
+ * If number is finite return non-zero, otherwise return zero.
+ */
+#if 0
+	/* Temporary fix - these 2 routines not used in libxml */
+TRIO_PUBLIC int trio_isfinite TRIO_PROTO((double number));
+
+TRIO_PUBLIC int trio_fpclassify TRIO_PROTO((double number));
+#endif
+
+TRIO_PUBLIC int trio_signbit TRIO_PROTO((double number));
+
+TRIO_PUBLIC int trio_fpclassify_and_signbit TRIO_PROTO((double number, int *is_negative));
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* TRIO_NAN_H */
diff --git a/src/libxml/src/triop.h b/src/libxml/src/triop.h
new file mode 100644
index 0000000..575a6e6
--- /dev/null
+++ b/src/libxml/src/triop.h
@@ -0,0 +1,150 @@
+/*************************************************************************
+ *
+ * $Id: triop.h,v 1.1 2008/11/12 02:25:23 agibert Exp $
+ *
+ * Copyright (C) 2000 Bjorn Reese and Daniel Stenberg.
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
+ * MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE AUTHORS AND
+ * CONTRIBUTORS ACCEPT NO RESPONSIBILITY IN ANY CONCEIVABLE MANNER.
+ *
+ ************************************************************************
+ *
+ * Private functions, types, etc. used for callback functions.
+ *
+ * The ref pointer is an opaque type and should remain as such.
+ * Private data must only be accessible through the getter and
+ * setter functions.
+ *
+ ************************************************************************/
+
+#ifndef TRIO_TRIOP_H
+#define TRIO_TRIOP_H
+
+#include "triodef.h"
+
+#include <stdlib.h>
+#if defined(TRIO_COMPILER_ANCIENT)
+# include <varargs.h>
+#else
+# include <stdarg.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef TRIO_C99
+# define TRIO_C99 1
+#endif
+#ifndef TRIO_BSD
+# define TRIO_BSD 1
+#endif
+#ifndef TRIO_GNU
+# define TRIO_GNU 1
+#endif
+#ifndef TRIO_MISC
+# define TRIO_MISC 1
+#endif
+#ifndef TRIO_UNIX98
+# define TRIO_UNIX98 1
+#endif
+#ifndef TRIO_MICROSOFT
+# define TRIO_MICROSOFT 1
+#endif
+#ifndef TRIO_EXTENSION
+# define TRIO_EXTENSION 1
+#endif
+#ifndef TRIO_WIDECHAR /* Does not work yet. Do not enable */
+# define TRIO_WIDECHAR 0
+#endif
+#ifndef TRIO_ERRORS
+# define TRIO_ERRORS 1
+#endif
+
+#ifndef TRIO_MALLOC
+# define TRIO_MALLOC(n) malloc(n)
+#endif
+#ifndef TRIO_REALLOC
+# define TRIO_REALLOC(x,n) realloc((x),(n))
+#endif
+#ifndef TRIO_FREE
+# define TRIO_FREE(x) free(x)
+#endif
+
+
+/*************************************************************************
+ * User-defined specifiers
+ */
+
+typedef int (*trio_callback_t) TRIO_PROTO((trio_pointer_t));
+
+trio_pointer_t trio_register TRIO_PROTO((trio_callback_t callback, const char *name));
+void trio_unregister TRIO_PROTO((trio_pointer_t handle));
+
+TRIO_CONST char *trio_get_format TRIO_PROTO((trio_pointer_t ref));
+trio_pointer_t trio_get_argument TRIO_PROTO((trio_pointer_t ref));
+
+/* Modifiers */
+int  trio_get_width TRIO_PROTO((trio_pointer_t ref));
+void trio_set_width TRIO_PROTO((trio_pointer_t ref, int width));
+int  trio_get_precision TRIO_PROTO((trio_pointer_t ref));
+void trio_set_precision TRIO_PROTO((trio_pointer_t ref, int precision));
+int  trio_get_base TRIO_PROTO((trio_pointer_t ref));
+void trio_set_base TRIO_PROTO((trio_pointer_t ref, int base));
+int  trio_get_padding TRIO_PROTO((trio_pointer_t ref));
+void trio_set_padding TRIO_PROTO((trio_pointer_t ref, int is_padding));
+int  trio_get_short TRIO_PROTO((trio_pointer_t ref)); /* h */
+void trio_set_shortshort TRIO_PROTO((trio_pointer_t ref, int is_shortshort));
+int  trio_get_shortshort TRIO_PROTO((trio_pointer_t ref)); /* hh */
+void trio_set_short TRIO_PROTO((trio_pointer_t ref, int is_short));
+int  trio_get_long TRIO_PROTO((trio_pointer_t ref)); /* l */
+void trio_set_long TRIO_PROTO((trio_pointer_t ref, int is_long));
+int  trio_get_longlong TRIO_PROTO((trio_pointer_t ref)); /* ll */
+void trio_set_longlong TRIO_PROTO((trio_pointer_t ref, int is_longlong));
+int  trio_get_longdouble TRIO_PROTO((trio_pointer_t ref)); /* L */
+void trio_set_longdouble TRIO_PROTO((trio_pointer_t ref, int is_longdouble));
+int  trio_get_alternative TRIO_PROTO((trio_pointer_t ref)); /* # */
+void trio_set_alternative TRIO_PROTO((trio_pointer_t ref, int is_alternative));
+int  trio_get_alignment TRIO_PROTO((trio_pointer_t ref)); /* - */
+void trio_set_alignment TRIO_PROTO((trio_pointer_t ref, int is_leftaligned));
+int  trio_get_spacing TRIO_PROTO((trio_pointer_t ref)); /*  TRIO_PROTO((space) */
+void trio_set_spacing TRIO_PROTO((trio_pointer_t ref, int is_space));
+int  trio_get_sign TRIO_PROTO((trio_pointer_t ref)); /* + */
+void trio_set_sign TRIO_PROTO((trio_pointer_t ref, int is_showsign));
+int  trio_get_quote TRIO_PROTO((trio_pointer_t ref)); /* ' */
+void trio_set_quote TRIO_PROTO((trio_pointer_t ref, int is_quote));
+int  trio_get_upper TRIO_PROTO((trio_pointer_t ref));
+void trio_set_upper TRIO_PROTO((trio_pointer_t ref, int is_upper));
+#if TRIO_C99
+int  trio_get_largest TRIO_PROTO((trio_pointer_t ref)); /* j */
+void trio_set_largest TRIO_PROTO((trio_pointer_t ref, int is_largest));
+int  trio_get_ptrdiff TRIO_PROTO((trio_pointer_t ref)); /* t */
+void trio_set_ptrdiff TRIO_PROTO((trio_pointer_t ref, int is_ptrdiff));
+int  trio_get_size TRIO_PROTO((trio_pointer_t ref)); /* z / Z */
+void trio_set_size TRIO_PROTO((trio_pointer_t ref, int is_size));
+#endif
+
+/* Printing */
+int trio_print_ref TRIO_PROTO((trio_pointer_t ref, const char *format, ...));
+int trio_vprint_ref TRIO_PROTO((trio_pointer_t ref, const char *format, va_list args));
+int trio_printv_ref TRIO_PROTO((trio_pointer_t ref, const char *format, trio_pointer_t *args));
+
+void trio_print_int TRIO_PROTO((trio_pointer_t ref, int number));
+void trio_print_uint TRIO_PROTO((trio_pointer_t ref, unsigned int number));
+/*  void trio_print_long TRIO_PROTO((trio_pointer_t ref, long number)); */
+/*  void trio_print_ulong TRIO_PROTO((trio_pointer_t ref, unsigned long number)); */
+void trio_print_double TRIO_PROTO((trio_pointer_t ref, double number));
+void trio_print_string TRIO_PROTO((trio_pointer_t ref, char *string));
+void trio_print_pointer TRIO_PROTO((trio_pointer_t ref, trio_pointer_t pointer));
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* TRIO_TRIOP_H */
diff --git a/src/libxml/src/triostr.c b/src/libxml/src/triostr.c
new file mode 100644
index 0000000..ff60b42
--- /dev/null
+++ b/src/libxml/src/triostr.c
@@ -0,0 +1,2102 @@
+/*************************************************************************
+ *
+ * $Id: triostr.c,v 1.1 2008/11/12 02:25:23 agibert Exp $
+ *
+ * Copyright (C) 2001 Bjorn Reese and Daniel Stenberg.
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
+ * MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE AUTHORS AND
+ * CONTRIBUTORS ACCEPT NO RESPONSIBILITY IN ANY CONCEIVABLE MANNER.
+ *
+ ************************************************************************/
+
+/*************************************************************************
+ * Include files
+ */
+
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <math.h>
+#include "triodef.h"
+#include "triostr.h"
+
+/*************************************************************************
+ * Definitions
+ */
+
+#if !defined(TRIO_STRING_PUBLIC)
+# define TRIO_STRING_PUBLIC TRIO_PUBLIC
+#endif
+#if !defined(TRIO_STRING_PRIVATE)
+# define TRIO_STRING_PRIVATE TRIO_PRIVATE
+#endif
+
+#if !defined(NULL)
+# define NULL 0
+#endif
+#if !defined(NIL)
+# define NIL ((char)0)
+#endif
+#if !defined(FALSE)
+# define FALSE (1 == 0)
+# define TRUE (! FALSE)
+#endif
+#if !defined(BOOLEAN_T)
+# define BOOLEAN_T int
+#endif
+
+#if defined(TRIO_COMPILER_SUPPORTS_C99)
+# define USE_STRTOD
+# define USE_STRTOF
+#elif defined(TRIO_COMPILER_MSVC)
+# define USE_STRTOD
+#endif
+
+#if defined(TRIO_PLATFORM_UNIX)
+# define USE_STRCASECMP
+# define USE_STRNCASECMP
+# if defined(TRIO_PLATFORM_SUNOS)
+#  define USE_SYS_ERRLIST
+# else
+#  define USE_STRERROR
+# endif
+# if defined(TRIO_PLATFORM_QNX)
+#  define strcasecmp(x,y) stricmp(x,y)
+#  define strncasecmp(x,y,n) strnicmp(x,y,n)
+# endif
+#elif defined(TRIO_PLATFORM_WIN32)
+# define USE_STRCASECMP
+# define strcasecmp(x,y) strcmpi(x,y)
+#endif
+
+#if !(defined(TRIO_PLATFORM_SUNOS))
+# define USE_TOLOWER
+# define USE_TOUPPER
+#endif
+
+/*************************************************************************
+ * Structures
+ */
+
+struct _trio_string_t
+{
+  char *content;
+  size_t length;
+  size_t allocated;
+};
+
+/*************************************************************************
+ * Constants
+ */
+
+#if !defined(TRIO_MINIMAL)
+static TRIO_CONST char rcsid[] = "@(#)$Id: triostr.c,v 1.1 2008/11/12 02:25:23 agibert Exp $";
+#endif
+
+/*************************************************************************
+ * Static String Functions
+ */
+
+#if defined(TRIO_DOCUMENTATION)
+# include "doc/doc_static.h"
+#endif
+/** @addtogroup StaticStrings
+    @{
+*/
+
+/**
+   Create new string.
+
+   @param size Size of new string.
+   @return Pointer to string, or NULL if allocation failed.
+*/
+TRIO_STRING_PUBLIC char *
+trio_create
+TRIO_ARGS1((size),
+	   size_t size)
+{
+  return (char *)TRIO_MALLOC(size);
+}
+
+
+/**
+   Destroy string.
+
+   @param string String to be freed.
+*/
+TRIO_STRING_PUBLIC void
+trio_destroy
+TRIO_ARGS1((string),
+	   char *string)
+{
+  if (string)
+    {
+      TRIO_FREE(string);
+    }
+}
+
+
+/**
+   Count the number of characters in a string.
+
+   @param string String to measure.
+   @return Number of characters in @string.
+*/
+TRIO_STRING_PUBLIC size_t
+trio_length
+TRIO_ARGS1((string),
+	   TRIO_CONST char *string)
+{
+  return strlen(string);
+}
+
+
+#if !defined(TRIO_MINIMAL)
+/**
+   Append @p source at the end of @p target.
+   
+   @param target Target string.
+   @param source Source string.
+   @return Boolean value indicating success or failure.
+   
+   @pre @p target must point to a memory chunk with sufficient room to
+   contain the @p target string and @p source string.
+   @pre No boundary checking is performed, so insufficient memory will
+   result in a buffer overrun.
+   @post @p target will be zero terminated.
+*/
+TRIO_STRING_PUBLIC int
+trio_append
+TRIO_ARGS2((target, source),
+	   char *target,
+	   TRIO_CONST char *source)
+{
+  assert(target);
+  assert(source);
+  
+  return (strcat(target, source) != NULL);
+}
+#endif /* !defined(TRIO_MINIMAL) */
+
+#if !defined(TRIO_MINIMAL)
+/**
+   Append at most @p max characters from @p source to @p target.
+   
+   @param target Target string.
+   @param max Maximum number of characters to append.
+   @param source Source string.
+   @return Boolean value indicating success or failure.
+   
+   @pre @p target must point to a memory chuck with sufficient room to
+   contain the @p target string and the @p source string (at most @p max
+   characters).
+   @pre No boundary checking is performed, so insufficient memory will
+   result in a buffer overrun.
+   @post @p target will be zero terminated.
+*/
+TRIO_STRING_PUBLIC int
+trio_append_max
+TRIO_ARGS3((target, max, source),
+	   char *target,
+	   size_t max,
+	   TRIO_CONST char *source)
+{
+  size_t length;
+  
+  assert(target);
+  assert(source);
+
+  length = trio_length(target);
+  
+  if (max > length)
+    {
+      strncat(target, source, max - length - 1);
+    }
+  return TRUE;
+}
+#endif /* !defined(TRIO_MINIMAL) */
+
+
+#if !defined(TRIO_MINIMAL)
+/**
+   Determine if a string contains a substring.
+
+   @param string String to be searched.
+   @param substring String to be found.
+   @return Boolean value indicating success or failure.
+*/
+TRIO_STRING_PUBLIC int
+trio_contains
+TRIO_ARGS2((string, substring),
+	   TRIO_CONST char *string,
+	   TRIO_CONST char *substring)
+{
+  assert(string);
+  assert(substring);
+  
+  return (0 != strstr(string, substring));
+}
+#endif /* !defined(TRIO_MINIMAL) */
+
+
+#if !defined(TRIO_MINIMAL)
+/**
+   Copy @p source to @p target.
+   
+   @param target Target string.
+   @param source Source string.
+   @return Boolean value indicating success or failure.
+   
+   @pre @p target must point to a memory chunk with sufficient room to
+   contain the @p source string.
+   @pre No boundary checking is performed, so insufficient memory will
+   result in a buffer overrun.
+   @post @p target will be zero terminated.
+*/
+TRIO_STRING_PUBLIC int
+trio_copy
+TRIO_ARGS2((target, source),
+	   char *target,
+	   TRIO_CONST char *source)
+{
+  assert(target);
+  assert(source);
+     
+  (void)strcpy(target, source);
+  return TRUE;
+}
+#endif /* !defined(TRIO_MINIMAL) */
+
+
+/**
+   Copy at most @p max characters from @p source to @p target.
+   
+   @param target Target string.
+   @param max Maximum number of characters to append.
+   @param source Source string.
+   @return Boolean value indicating success or failure.
+   
+   @pre @p target must point to a memory chunk with sufficient room to
+   contain the @p source string (at most @p max characters).
+   @pre No boundary checking is performed, so insufficient memory will
+   result in a buffer overrun.
+   @post @p target will be zero terminated.
+*/
+TRIO_STRING_PUBLIC int
+trio_copy_max
+TRIO_ARGS3((target, max, source),
+	   char *target,
+	   size_t max,
+	   TRIO_CONST char *source)
+{
+  assert(target);
+  assert(source);
+  assert(max > 0); /* Includes != 0 */
+
+  (void)strncpy(target, source, max - 1);
+  target[max - 1] = (char)0;
+  return TRUE;
+}
+
+
+/*
+ * TrioDuplicateMax
+ */
+TRIO_STRING_PRIVATE char *
+TrioDuplicateMax
+TRIO_ARGS2((source, size),
+	   TRIO_CONST char *source,
+	   size_t size)
+{
+  char *target;
+
+  assert(source);
+
+  /* Make room for string plus a terminating zero */
+  size++;
+  target = trio_create(size);
+  if (target)
+    {
+      trio_copy_max(target, size, source);
+    }
+  return target;
+}
+
+
+/**
+   Duplicate @p source.
+   
+   @param source Source string.
+   @return A copy of the @p source string.
+   
+   @post @p target will be zero terminated.
+*/
+TRIO_STRING_PUBLIC char *
+trio_duplicate
+TRIO_ARGS1((source),
+	   TRIO_CONST char *source)
+{
+  return TrioDuplicateMax(source, trio_length(source));
+}
+
+
+#if !defined(TRIO_MINIMAL)
+/**
+   Duplicate at most @p max characters of @p source.
+   
+   @param source Source string.
+   @param max Maximum number of characters to duplicate.
+   @return A copy of the @p source string.
+   
+   @post @p target will be zero terminated.
+*/
+TRIO_STRING_PUBLIC char *
+trio_duplicate_max TRIO_ARGS2((source, max),
+			      TRIO_CONST char *source,
+			      size_t max)
+{
+  size_t length;
+
+  assert(source);
+  assert(max > 0);
+
+  length = trio_length(source);
+  if (length > max)
+    {
+      length = max;
+    }
+  return TrioDuplicateMax(source, length);
+}
+#endif /* !defined(TRIO_MINIMAL) */
+
+
+/**
+   Compare if two strings are equal.
+   
+   @param first First string.
+   @param second Second string.
+   @return Boolean indicating whether the two strings are equal or not.
+   
+   Case-insensitive comparison.
+*/
+TRIO_STRING_PUBLIC int
+trio_equal
+TRIO_ARGS2((first, second),
+	   TRIO_CONST char *first,
+	   TRIO_CONST char *second)
+{
+  assert(first);
+  assert(second);
+
+  if ((first != NULL) && (second != NULL))
+    {
+#if defined(USE_STRCASECMP)
+      return (0 == strcasecmp(first, second));
+#else
+      while ((*first != NIL) && (*second != NIL))
+	{
+	  if (trio_to_upper(*first) != trio_to_upper(*second))
+	    {
+	      break;
+	    }
+	  first++;
+	  second++;
+	}
+      return ((*first == NIL) && (*second == NIL));
+#endif
+    }
+  return FALSE;
+}
+
+
+/**
+   Compare if two strings are equal.
+   
+   @param first First string.
+   @param second Second string.
+   @return Boolean indicating whether the two strings are equal or not.
+   
+   Case-sensitive comparison.
+*/
+TRIO_STRING_PUBLIC int
+trio_equal_case
+TRIO_ARGS2((first, second),
+	   TRIO_CONST char *first,
+	   TRIO_CONST char *second)
+{
+  assert(first);
+  assert(second);
+
+  if ((first != NULL) && (second != NULL))
+    {
+      return (0 == strcmp(first, second));
+    }
+  return FALSE;
+}
+
+
+#if !defined(TRIO_MINIMAL)
+/**
+   Compare if two strings up until the first @p max characters are equal.
+   
+   @param first First string.
+   @param max Maximum number of characters to compare.
+   @param second Second string.
+   @return Boolean indicating whether the two strings are equal or not.
+   
+   Case-sensitive comparison.
+*/
+TRIO_STRING_PUBLIC int
+trio_equal_case_max
+TRIO_ARGS3((first, max, second),
+	   TRIO_CONST char *first,
+	   size_t max,
+	   TRIO_CONST char *second)
+{
+  assert(first);
+  assert(second);
+
+  if ((first != NULL) && (second != NULL))
+    {
+      return (0 == strncmp(first, second, max));
+    }
+  return FALSE;
+}
+#endif /* !defined(TRIO_MINIMAL) */
+
+
+/**
+   Compare if two strings are equal.
+   
+   @param first First string.
+   @param second Second string.
+   @return Boolean indicating whether the two strings are equal or not.
+
+   Collating characters are considered equal.
+*/
+TRIO_STRING_PUBLIC int
+trio_equal_locale
+TRIO_ARGS2((first, second),
+	   TRIO_CONST char *first,
+	   TRIO_CONST char *second)
+{
+  assert(first);
+  assert(second);
+
+#if defined(LC_COLLATE)
+  return (strcoll(first, second) == 0);
+#else
+  return trio_equal(first, second);
+#endif
+}
+
+
+/**
+   Compare if two strings up until the first @p max characters are equal.
+   
+   @param first First string.
+   @param max Maximum number of characters to compare.
+   @param second Second string.
+   @return Boolean indicating whether the two strings are equal or not.
+   
+   Case-insensitive comparison.
+*/
+TRIO_STRING_PUBLIC int
+trio_equal_max
+TRIO_ARGS3((first, max, second),
+	   TRIO_CONST char *first,
+	   size_t max,
+	   TRIO_CONST char *second)
+{
+  assert(first);
+  assert(second);
+
+  if ((first != NULL) && (second != NULL))
+    {
+#if defined(USE_STRNCASECMP)
+      return (0 == strncasecmp(first, second, max));
+#else
+      /* Not adequately tested yet */
+      size_t cnt = 0;
+      while ((*first != NIL) && (*second != NIL) && (cnt <= max))
+	{
+	  if (trio_to_upper(*first) != trio_to_upper(*second))
+	    {
+	      break;
+	    }
+	  first++;
+	  second++;
+	  cnt++;
+	}
+      return ((cnt == max) || ((*first == NIL) && (*second == NIL)));
+#endif
+    }
+  return FALSE;
+}
+
+
+/**
+   Provide a textual description of an error code (errno).
+
+   @param error_number Error number.
+   @return Textual description of @p error_number.
+*/
+TRIO_STRING_PUBLIC TRIO_CONST char *
+trio_error
+TRIO_ARGS1((error_number),
+	   int error_number)
+{
+#if defined(USE_STRERROR)
+  
+  return strerror(error_number);
+
+#elif defined(USE_SYS_ERRLIST)
+
+  extern char *sys_errlist[];
+  extern int sys_nerr;
+
+  return ((error_number < 0) || (error_number >= sys_nerr))
+    ? "unknown"
+    : sys_errlist[error_number];
+ 
+#else
+  
+  return "unknown";
+  
+#endif
+}
+
+
+#if !defined(TRIO_MINIMAL)
+/**
+   Format the date/time according to @p format.
+
+   @param target Target string.
+   @param max Maximum number of characters to format.
+   @param format Formatting string.
+   @param datetime Date/time structure.
+   @return Number of formatted characters.
+
+   The formatting string accepts the same specifiers as the standard C
+   function strftime.
+*/
+TRIO_STRING_PUBLIC size_t
+trio_format_date_max
+TRIO_ARGS4((target, max, format, datetime),
+	   char *target,
+	   size_t max,
+	   TRIO_CONST char *format,
+	   TRIO_CONST struct tm *datetime)
+{
+  assert(target);
+  assert(format);
+  assert(datetime);
+  assert(max > 0);
+  
+  return strftime(target, max, format, datetime);
+}
+#endif /* !defined(TRIO_MINIMAL) */
+
+
+#if !defined(TRIO_MINIMAL)
+/**
+   Calculate a hash value for a string.
+
+   @param string String to be calculated on.
+   @param type Hash function.
+   @return Calculated hash value.
+
+   @p type can be one of the following
+   @li @c TRIO_HASH_PLAIN Plain hash function.
+*/
+TRIO_STRING_PUBLIC unsigned long
+trio_hash
+TRIO_ARGS2((string, type),
+	   TRIO_CONST char *string,
+	   int type)
+{
+  unsigned long value = 0L;
+  char ch;
+
+  assert(string);
+  
+  switch (type)
+    {
+    case TRIO_HASH_PLAIN:
+      while ( (ch = *string++) != NIL )
+	{
+	  value *= 31;
+	  value += (unsigned long)ch;
+	}
+      break;
+    default:
+      assert(FALSE);
+      break;
+    }
+  return value;
+}
+#endif /* !defined(TRIO_MINIMAL) */
+
+
+#if !defined(TRIO_MINIMAL)
+/**
+   Find first occurrence of a character in a string.
+
+   @param string String to be searched.
+   @param character Character to be found.
+   @param A pointer to the found character, or NULL if character was not found.
+ */
+TRIO_STRING_PUBLIC char *
+trio_index
+TRIO_ARGS2((string, character),
+	   TRIO_CONST char *string,
+	   int character)
+{
+  assert(string);
+
+  return strchr(string, character);
+}
+#endif /* !defined(TRIO_MINIMAL) */
+
+
+#if !defined(TRIO_MINIMAL)
+/**
+   Find last occurrence of a character in a string.
+
+   @param string String to be searched.
+   @param character Character to be found.
+   @param A pointer to the found character, or NULL if character was not found.
+ */
+TRIO_STRING_PUBLIC char *
+trio_index_last
+TRIO_ARGS2((string, character),
+	   TRIO_CONST char *string,
+	   int character)
+{
+  assert(string);
+
+  return strchr(string, character);
+}
+#endif /* !defined(TRIO_MINIMAL) */
+
+
+#if !defined(TRIO_MINIMAL)
+/**
+   Convert the alphabetic letters in the string to lower-case.
+
+   @param target String to be converted.
+   @return Number of processed characters (converted or not).
+*/
+TRIO_STRING_PUBLIC int
+trio_lower
+TRIO_ARGS1((target),
+	   char *target)
+{
+  assert(target);
+
+  return trio_span_function(target, target, trio_to_lower);
+}
+#endif /* !defined(TRIO_MINIMAL) */
+
+
+#if !defined(TRIO_MINIMAL)
+/**
+   Compare two strings using wildcards.
+
+   @param string String to be searched.
+   @param pattern Pattern, including wildcards, to search for.
+   @return Boolean value indicating success or failure.
+
+   Case-insensitive comparison.
+   
+   The following wildcards can be used
+   @li @c * Match any number of characters.
+   @li @c ? Match a single character.
+*/
+TRIO_STRING_PUBLIC int
+trio_match
+TRIO_ARGS2((string, pattern),
+	   TRIO_CONST char *string,
+	   TRIO_CONST char *pattern)
+{
+  assert(string);
+  assert(pattern);
+  
+  for (; ('*' != *pattern); ++pattern, ++string)
+    {
+      if (NIL == *string)
+	{
+	  return (NIL == *pattern);
+	}
+      if ((trio_to_upper((int)*string) != trio_to_upper((int)*pattern))
+	  && ('?' != *pattern))
+	{
+	  return FALSE;
+	}
+    }
+  /* two-line patch to prevent *too* much recursiveness: */
+  while ('*' == pattern[1])
+    pattern++;
+
+  do
+    {
+      if ( trio_match(string, &pattern[1]) )
+	{
+	  return TRUE;
+	}
+    }
+  while (*string++);
+  
+  return FALSE;
+}
+#endif /* !defined(TRIO_MINIMAL) */
+
+
+#if !defined(TRIO_MINIMAL)
+/**
+   Compare two strings using wildcards.
+
+   @param string String to be searched.
+   @param pattern Pattern, including wildcards, to search for.
+   @return Boolean value indicating success or failure.
+
+   Case-sensitive comparison.
+   
+   The following wildcards can be used
+   @li @c * Match any number of characters.
+   @li @c ? Match a single character.
+*/
+TRIO_STRING_PUBLIC int
+trio_match_case
+TRIO_ARGS2((string, pattern),
+	   TRIO_CONST char *string,
+	   TRIO_CONST char *pattern)
+{
+  assert(string);
+  assert(pattern);
+  
+  for (; ('*' != *pattern); ++pattern, ++string)
+    {
+      if (NIL == *string)
+	{
+	  return (NIL == *pattern);
+	}
+      if ((*string != *pattern)
+	  && ('?' != *pattern))
+	{
+	  return FALSE;
+	}
+    }
+  /* two-line patch to prevent *too* much recursiveness: */
+  while ('*' == pattern[1])
+    pattern++;
+
+  do
+    {
+      if ( trio_match_case(string, &pattern[1]) )
+	{
+	  return TRUE;
+	}
+    }
+  while (*string++);
+  
+  return FALSE;
+}
+#endif /* !defined(TRIO_MINIMAL) */
+
+
+#if !defined(TRIO_MINIMAL)
+/**
+   Execute a function on each character in string.
+
+   @param target Target string.
+   @param source Source string.
+   @param Function Function to be executed.
+   @return Number of processed characters.
+*/
+TRIO_STRING_PUBLIC size_t
+trio_span_function
+TRIO_ARGS3((target, source, Function),
+	   char *target,
+	   TRIO_CONST char *source,
+	   int (*Function) TRIO_PROTO((int)))
+{
+  size_t count = 0;
+
+  assert(target);
+  assert(source);
+  assert(Function);
+  
+  while (*source != NIL)
+    {
+      *target++ = Function(*source++);
+      count++;
+    }
+  return count;
+}
+#endif /* !defined(TRIO_MINIMAL) */
+
+
+#if !defined(TRIO_MINIMAL)
+/**
+   Search for a substring in a string.
+
+   @param string String to be searched.
+   @param substring String to be found.
+   @return Pointer to first occurrence of @p substring in @p string, or NULL
+   if no match was found.
+*/
+TRIO_STRING_PUBLIC char *
+trio_substring
+TRIO_ARGS2((string, substring),
+	   TRIO_CONST char *string,
+	   TRIO_CONST char *substring)
+{
+  assert(string);
+  assert(substring);
+
+  return strstr(string, substring);
+}
+#endif /* !defined(TRIO_MINIMAL) */
+
+
+#if !defined(TRIO_MINIMAL)
+/**
+   Search for a substring in the first @p max characters of a string.
+
+   @param string String to be searched.
+   @param max Maximum characters to be searched.
+   @param substring String to be found.
+   @return Pointer to first occurrence of @p substring in @p string, or NULL
+   if no match was found.
+*/
+TRIO_STRING_PUBLIC char *
+trio_substring_max
+TRIO_ARGS3((string, max, substring),
+	   TRIO_CONST char *string,
+	   size_t max,
+	   TRIO_CONST char *substring)
+{
+  size_t count;
+  size_t size;
+  char *result = NULL;
+
+  assert(string);
+  assert(substring);
+  
+  size = trio_length(substring);
+  if (size <= max)
+    {
+      for (count = 0; count <= max - size; count++)
+	{
+	  if (trio_equal_max(substring, size, &string[count]))
+	    {
+	      result = (char *)&string[count];
+	      break;
+	    }
+	}
+    }
+  return result;
+}
+#endif /* !defined(TRIO_MINIMAL) */
+
+
+#if !defined(TRIO_MINIMAL)
+/**
+   Tokenize string.
+
+   @param string String to be tokenized.
+   @param tokens String containing list of delimiting characters.
+   @return Start of new token.
+
+   @warning @p string will be destroyed.
+*/
+TRIO_STRING_PUBLIC char *
+trio_tokenize
+TRIO_ARGS2((string, delimiters),
+	   char *string,
+	   TRIO_CONST char *delimiters)
+{
+  assert(delimiters);
+  
+  return strtok(string, delimiters);
+}
+#endif /* !defined(TRIO_MINIMAL) */
+
+
+/**
+   Convert string to floating-point number.
+
+   @param source String to be converted.
+   @param endp Pointer to end of the converted string.
+   @return A floating-point number.
+
+   The following Extended Backus-Naur form is used
+   @verbatim
+   double        ::= [ <sign> ]
+                     ( <number> |
+                       <number> <decimal_point> <number> |
+                       <decimal_point> <number> )
+                     [ <exponential> [ <sign> ] <number> ]
+   number        ::= 1*( <digit> )
+   digit         ::= ( '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' )
+   exponential   ::= ( 'e' | 'E' )
+   sign          ::= ( '-' | '+' )
+   decimal_point ::= '.'
+   @endverbatim
+*/
+/* FIXME: Add EBNF for hex-floats */
+TRIO_STRING_PUBLIC trio_long_double_t
+trio_to_long_double
+TRIO_ARGS2((source, endp),
+	   TRIO_CONST char *source,
+	   char **endp)
+{
+#if defined(USE_STRTOLD)
+  return strtold(source, endp);
+#else
+  int isNegative = FALSE;
+  int isExponentNegative = FALSE;
+  trio_long_double_t integer = 0.0;
+  trio_long_double_t fraction = 0.0;
+  unsigned long exponent = 0;
+  trio_long_double_t base;
+  trio_long_double_t fracdiv = 1.0;
+  trio_long_double_t value = 0.0;
+
+  /* First try hex-floats */
+  if ((source[0] == '0') && ((source[1] == 'x') || (source[1] == 'X')))
+    {
+      base = 16.0;
+      source += 2;
+      while (isxdigit((int)*source))
+	{
+	  integer *= base;
+	  integer += (isdigit((int)*source)
+		      ? (*source - '0')
+		      : 10 + (trio_to_upper((int)*source) - 'A'));
+	  source++;
+	}
+      if (*source == '.')
+	{
+	  source++;
+	  while (isxdigit((int)*source))
+	    {
+	      fracdiv /= base;
+	      fraction += fracdiv * (isdigit((int)*source)
+				     ? (*source - '0')
+				     : 10 + (trio_to_upper((int)*source) - 'A'));
+	      source++;
+	    }
+	  if ((*source == 'p') || (*source == 'P'))
+	    {
+	      source++;
+	      if ((*source == '+') || (*source == '-'))
+		{
+		  isExponentNegative = (*source == '-');
+		  source++;
+		}
+	      while (isdigit((int)*source))
+		{
+		  exponent *= 10;
+		  exponent += (*source - '0');
+		  source++;
+		}
+	    }
+	}
+      /* For later use with exponent */
+      base = 2.0;
+    }
+  else /* Then try normal decimal floats */
+    {
+      base = 10.0;
+      isNegative = (*source == '-');
+      /* Skip sign */
+      if ((*source == '+') || (*source == '-'))
+	source++;
+
+      /* Integer part */
+      while (isdigit((int)*source))
+	{
+	  integer *= base;
+	  integer += (*source - '0');
+	  source++;
+	}
+
+      if (*source == '.')
+	{
+	  source++; /* skip decimal point */
+	  while (isdigit((int)*source))
+	    {
+	      fracdiv /= base;
+	      fraction += (*source - '0') * fracdiv;
+	      source++;
+	    }
+	}
+      if ((*source == 'e')
+	  || (*source == 'E')
+#if TRIO_MICROSOFT
+	  || (*source == 'd')
+	  || (*source == 'D')
+#endif
+	  )
+	{
+	  source++; /* Skip exponential indicator */
+	  isExponentNegative = (*source == '-');
+	  if ((*source == '+') || (*source == '-'))
+	    source++;
+	  while (isdigit((int)*source))
+	    {
+	      exponent *= (int)base;
+	      exponent += (*source - '0');
+	      source++;
+	    }
+	}
+    }
+  
+  value = integer + fraction;
+  if (exponent != 0)
+    {
+      if (isExponentNegative)
+	value /= pow(base, (double)exponent);
+      else
+	value *= pow(base, (double)exponent);
+    }
+  if (isNegative)
+    value = -value;
+
+  if (endp)
+    *endp = (char *)source;
+  return value;
+#endif
+}
+
+
+/**
+   Convert string to floating-point number.
+
+   @param source String to be converted.
+   @param endp Pointer to end of the converted string.
+   @return A floating-point number.
+
+   See @ref trio_to_long_double.
+*/
+TRIO_STRING_PUBLIC double
+trio_to_double
+TRIO_ARGS2((source, endp),
+	   TRIO_CONST char *source,
+	   char **endp)
+{
+#if defined(USE_STRTOD)
+  return strtod(source, endp);
+#else
+  return (double)trio_to_long_double(source, endp);
+#endif
+}
+
+#if !defined(TRIO_MINIMAL)
+/**
+   Convert string to floating-point number.
+
+   @param source String to be converted.
+   @param endp Pointer to end of the converted string.
+   @return A floating-point number.
+
+   See @ref trio_to_long_double.
+*/
+TRIO_STRING_PUBLIC float
+trio_to_float
+TRIO_ARGS2((source, endp),
+	   TRIO_CONST char *source,
+	   char **endp)
+{
+#if defined(USE_STRTOF)
+  return strtof(source, endp);
+#else
+  return (float)trio_to_long_double(source, endp);
+#endif
+}
+#endif /* !defined(TRIO_MINIMAL) */
+
+
+/**
+   Convert string to signed integer.
+
+   @param string String to be converted.
+   @param endp Pointer to end of converted string.
+   @param base Radix number of number.
+*/
+TRIO_STRING_PUBLIC long
+trio_to_long
+TRIO_ARGS3((string, endp, base),
+	   TRIO_CONST char *string,
+	   char **endp,
+	   int base)
+{
+  assert(string);
+  assert((base >= 2) && (base <= 36));
+  
+  return strtol(string, endp, base);
+}
+
+
+#if !defined(TRIO_MINIMAL)
+/**
+   Convert one alphabetic letter to lower-case.
+
+   @param source The letter to be converted.
+   @return The converted letter.
+*/
+TRIO_STRING_PUBLIC int
+trio_to_lower
+TRIO_ARGS1((source),
+	   int source)
+{
+#if defined(USE_TOLOWER)
+  
+  return tolower(source);
+  
+#else
+
+  /* Does not handle locales or non-contiguous alphabetic characters */
+  return ((source >= (int)'A') && (source <= (int)'Z'))
+    ? source - 'A' + 'a'
+    : source;
+  
+#endif
+}
+#endif /* !defined(TRIO_MINIMAL) */
+
+#if !defined(TRIO_MINIMAL)
+/**
+   Convert string to unsigned integer.
+
+   @param string String to be converted.
+   @param endp Pointer to end of converted string.
+   @param base Radix number of number.
+*/
+TRIO_STRING_PUBLIC unsigned long
+trio_to_unsigned_long
+TRIO_ARGS3((string, endp, base),
+	   TRIO_CONST char *string,
+	   char **endp,
+	   int base)
+{
+  assert(string);
+  assert((base >= 2) && (base <= 36));
+  
+  return strtoul(string, endp, base);
+}
+#endif /* !defined(TRIO_MINIMAL) */
+
+
+/**
+   Convert one alphabetic letter to upper-case.
+
+   @param source The letter to be converted.
+   @return The converted letter.
+*/
+TRIO_STRING_PUBLIC int
+trio_to_upper
+TRIO_ARGS1((source),
+	   int source)
+{
+#if defined(USE_TOUPPER)
+  
+  return toupper(source);
+  
+#else
+
+  /* Does not handle locales or non-contiguous alphabetic characters */
+  return ((source >= (int)'a') && (source <= (int)'z'))
+    ? source - 'a' + 'A'
+    : source;
+  
+#endif
+}
+
+#if !defined(TRIO_MINIMAL)
+/**
+   Convert the alphabetic letters in the string to upper-case.
+
+   @param target The string to be converted.
+   @return The number of processed characters (converted or not).
+*/
+TRIO_STRING_PUBLIC int
+trio_upper
+TRIO_ARGS1((target),
+	   char *target)
+{
+  assert(target);
+
+  return trio_span_function(target, target, trio_to_upper);
+}
+#endif /* !defined(TRIO_MINIMAL) */
+
+
+/** @} End of StaticStrings */
+
+
+/*************************************************************************
+ * Dynamic String Functions
+ */
+
+#if defined(TRIO_DOCUMENTATION)
+# include "doc/doc_dynamic.h"
+#endif
+/** @addtogroup DynamicStrings
+    @{
+*/
+
+/*
+ * TrioStringAlloc
+ */
+TRIO_STRING_PRIVATE trio_string_t *
+TrioStringAlloc(TRIO_NOARGS)
+{
+  trio_string_t *self;
+  
+  self = (trio_string_t *)TRIO_MALLOC(sizeof(trio_string_t));
+  if (self)
+    {
+      self->content = NULL;
+      self->length = 0;
+      self->allocated = 0;
+    }
+  return self;
+}
+
+
+/*
+ * TrioStringGrow
+ *
+ * The size of the string will be increased by 'delta' characters. If
+ * 'delta' is zero, the size will be doubled.
+ */
+TRIO_STRING_PRIVATE BOOLEAN_T
+TrioStringGrow
+TRIO_ARGS2((self, delta),
+	   trio_string_t *self,
+	   size_t delta)
+{
+  BOOLEAN_T status = FALSE;
+  char *new_content;
+  size_t new_size;
+
+  new_size = (delta == 0)
+    ? ( (self->allocated == 0) ? 1 : self->allocated * 2 )
+    : self->allocated + delta;
+  
+  new_content = (char *)TRIO_REALLOC(self->content, new_size);
+  if (new_content)
+    {
+      self->content = new_content;
+      self->allocated = new_size;
+      status = TRUE;
+    }
+  return status;
+}
+
+
+#if !defined(TRIO_MINIMAL)
+/*
+ * TrioStringGrowTo
+ *
+ * The size of the string will be increased to 'length' plus one characters.
+ * If 'length' is less than the original size, the original size will be
+ * used (that is, the size of the string is never decreased).
+ */
+TRIO_STRING_PRIVATE BOOLEAN_T
+TrioStringGrowTo
+TRIO_ARGS2((self, length),
+	   trio_string_t *self,
+	   size_t length)
+{
+  length++; /* Room for terminating zero */
+  return (self->allocated < length)
+    ? TrioStringGrow(self, length - self->allocated)
+    : TRUE;
+}
+#endif /* !defined(TRIO_MINIMAL) */
+
+
+#if !defined(TRIO_MINIMAL)
+/**
+   Create a new dynamic string.
+   
+   @param initial_size Initial size of the buffer.
+   @return Newly allocated dynamic string, or NULL if memory allocation failed.
+*/
+TRIO_STRING_PUBLIC trio_string_t *
+trio_string_create
+TRIO_ARGS1((initial_size),
+	   int initial_size)
+{
+  trio_string_t *self;
+
+  self = TrioStringAlloc();
+  if (self)
+    {
+      if (TrioStringGrow(self,
+			 (size_t)((initial_size > 0) ? initial_size : 1)))
+	{
+	  self->content[0] = (char)0;
+	  self->allocated = initial_size;
+	}
+      else
+	{
+	  trio_string_destroy(self);
+	  self = NULL;
+	}
+    }
+  return self;
+}
+#endif /* !defined(TRIO_MINIMAL) */
+
+
+/**
+   Deallocate the dynamic string and its contents.
+   
+   @param self Dynamic string
+*/
+TRIO_STRING_PUBLIC void
+trio_string_destroy
+TRIO_ARGS1((self),
+	   trio_string_t *self)
+{
+  assert(self);
+  
+  if (self)
+    {
+      trio_destroy(self->content);
+      TRIO_FREE(self);
+    }
+}
+
+
+#if !defined(TRIO_MINIMAL)
+/**
+   Get a pointer to the content.
+   
+   @param self Dynamic string.
+   @param offset Offset into content.
+   @return Pointer to the content.
+   
+   @p Offset can be zero, positive, or negative. If @p offset is zero,
+   then the start of the content will be returned. If @p offset is positive,
+   then a pointer to @p offset number of characters from the beginning of the
+   content is returned. If @p offset is negative, then a pointer to @p offset
+   number of characters from the ending of the string, starting at the
+   terminating zero, is returned.
+*/
+TRIO_STRING_PUBLIC char *
+trio_string_get
+TRIO_ARGS2((self, offset),
+	   trio_string_t *self,
+	   int offset)
+{
+  char *result = NULL;
+  
+  assert(self);
+
+  if (self->content != NULL)
+    {
+      if (self->length == 0)
+	{
+	  (void)trio_string_length(self);
+	}
+      if (offset >= 0)
+	{
+	  if (offset > (int)self->length)
+	    {
+	      offset = self->length;
+	    }
+	}
+      else
+	{
+	  offset += self->length + 1;
+	  if (offset < 0)
+	    {
+	      offset = 0;
+	    }
+	}
+      result = &(self->content[offset]);
+    }
+  return result;
+}
+#endif /* !defined(TRIO_MINIMAL) */
+
+
+/**
+   Extract the content.
+   
+   @param self Dynamic String
+   @return Content of dynamic string.
+   
+   The content is removed from the dynamic string. This enables destruction
+   of the dynamic string without deallocation of the content.
+*/
+TRIO_STRING_PUBLIC char *
+trio_string_extract
+TRIO_ARGS1((self),
+	   trio_string_t *self)
+{
+  char *result;
+  
+  assert(self);
+
+  result = self->content;
+  /* FIXME: Allocate new empty buffer? */
+  self->content = NULL;
+  self->length = self->allocated = 0;
+  return result;
+}
+
+
+#if !defined(TRIO_MINIMAL)
+/**
+   Set the content of the dynamic string.
+   
+   @param self Dynamic String
+   @param buffer The new content.
+   
+   Sets the content of the dynamic string to a copy @p buffer.
+   An existing content will be deallocated first, if necessary.
+   
+   @remark
+   This function will make a copy of @p buffer.
+   You are responsible for deallocating @p buffer yourself.
+*/
+TRIO_STRING_PUBLIC void
+trio_xstring_set
+TRIO_ARGS2((self, buffer),
+	   trio_string_t *self,
+	   char *buffer)
+{
+  assert(self);
+
+  trio_destroy(self->content);
+  self->content = trio_duplicate(buffer);
+}
+#endif /* !defined(TRIO_MINIMAL) */
+
+
+/*
+ * trio_string_size
+ */
+TRIO_STRING_PUBLIC int
+trio_string_size
+TRIO_ARGS1((self),
+	   trio_string_t *self)
+{
+  assert(self);
+
+  return self->allocated;
+}
+
+
+/*
+ * trio_string_terminate
+ */
+TRIO_STRING_PUBLIC void
+trio_string_terminate
+TRIO_ARGS1((self),
+	   trio_string_t *self)
+{
+  trio_xstring_append_char(self, 0);
+}
+
+
+#if !defined(TRIO_MINIMAL)
+/**
+   Append the second string to the first.
+   
+   @param self Dynamic string to be modified.
+   @param other Dynamic string to copy from.
+   @return Boolean value indicating success or failure.
+*/
+TRIO_STRING_PUBLIC int
+trio_string_append
+TRIO_ARGS2((self, other),
+	   trio_string_t *self,
+	   trio_string_t *other)
+{
+  size_t length;
+  
+  assert(self);
+  assert(other);
+
+  length = self->length + other->length;
+  if (!TrioStringGrowTo(self, length))
+    goto error;
+  trio_copy(&self->content[self->length], other->content);
+  self->length = length;
+  return TRUE;
+  
+ error:
+  return FALSE;
+}
+#endif /* !defined(TRIO_MINIMAL) */
+
+
+#if !defined(TRIO_MINIMAL)
+/*
+ * trio_xstring_append
+ */
+TRIO_STRING_PUBLIC int
+trio_xstring_append
+TRIO_ARGS2((self, other),
+	   trio_string_t *self,
+	   TRIO_CONST char *other)
+{
+  size_t length;
+  
+  assert(self);
+  assert(other);
+
+  length = self->length + trio_length(other);
+  if (!TrioStringGrowTo(self, length))
+    goto error;
+  trio_copy(&self->content[self->length], other);
+  self->length = length;
+  return TRUE;
+  
+ error:
+  return FALSE;
+}
+#endif /* !defined(TRIO_MINIMAL) */
+
+
+/*
+ * trio_xstring_append_char
+ */
+TRIO_STRING_PUBLIC int
+trio_xstring_append_char
+TRIO_ARGS2((self, character),
+	   trio_string_t *self,
+	   char character)
+{
+  assert(self);
+
+  if ((int)self->length >= trio_string_size(self))
+    {
+      if (!TrioStringGrow(self, 0))
+	goto error;
+    }
+  self->content[self->length] = character;
+  self->length++;
+  return TRUE;
+  
+ error:
+  return FALSE;
+}
+
+
+#if !defined(TRIO_MINIMAL)
+/**
+   Search for the first occurrence of second parameter in the first.
+   
+   @param self Dynamic string to be modified.
+   @param other Dynamic string to copy from.
+   @return Boolean value indicating success or failure.
+*/
+TRIO_STRING_PUBLIC int
+trio_string_contains
+TRIO_ARGS2((self, other),
+	   trio_string_t *self,
+	   trio_string_t *other)
+{
+  assert(self);
+  assert(other);
+
+  return trio_contains(self->content, other->content);
+}
+#endif /* !defined(TRIO_MINIMAL) */
+
+
+#if !defined(TRIO_MINIMAL)
+/*
+ * trio_xstring_contains
+ */
+TRIO_STRING_PUBLIC int
+trio_xstring_contains
+TRIO_ARGS2((self, other),
+	   trio_string_t *self,
+	   TRIO_CONST char *other)
+{
+  assert(self);
+  assert(other);
+
+  return trio_contains(self->content, other);
+}
+#endif /* !defined(TRIO_MINIMAL) */
+
+
+#if !defined(TRIO_MINIMAL)
+/*
+ * trio_string_copy
+ */
+TRIO_STRING_PUBLIC int
+trio_string_copy
+TRIO_ARGS2((self, other),
+	   trio_string_t *self,
+	   trio_string_t *other)
+{
+  assert(self);
+  assert(other);
+
+  self->length = 0;
+  return trio_string_append(self, other);
+}
+#endif /* !defined(TRIO_MINIMAL) */
+
+
+#if !defined(TRIO_MINIMAL)
+/*
+ * trio_xstring_copy
+ */
+TRIO_STRING_PUBLIC int
+trio_xstring_copy
+TRIO_ARGS2((self, other),
+	   trio_string_t *self,
+	   TRIO_CONST char *other)
+{
+  assert(self);
+  assert(other);
+
+  self->length = 0;
+  return trio_xstring_append(self, other);
+}
+#endif /* !defined(TRIO_MINIMAL) */
+
+
+#if !defined(TRIO_MINIMAL)
+/*
+ * trio_string_duplicate
+ */
+TRIO_STRING_PUBLIC trio_string_t *
+trio_string_duplicate
+TRIO_ARGS1((other),
+	   trio_string_t *other)
+{
+  trio_string_t *self;
+  
+  assert(other);
+
+  self = TrioStringAlloc();
+  if (self)
+    {
+      self->content = TrioDuplicateMax(other->content, other->length);
+      if (self->content)
+	{
+	  self->length = other->length;
+	  self->allocated = self->length + 1;
+	}
+      else
+	{
+	  self->length = self->allocated = 0;
+	}
+    }
+  return self;
+}
+#endif /* !defined(TRIO_MINIMAL) */
+
+
+/*
+ * trio_xstring_duplicate
+ */
+TRIO_STRING_PUBLIC trio_string_t *
+trio_xstring_duplicate
+TRIO_ARGS1((other),
+	   TRIO_CONST char *other)
+{
+  trio_string_t *self;
+  
+  assert(other);
+
+  self = TrioStringAlloc();
+  if (self)
+    {
+      self->content = TrioDuplicateMax(other, trio_length(other));
+      if (self->content)
+	{
+	  self->length = trio_length(self->content);
+	  self->allocated = self->length + 1;
+	}
+      else
+	{
+	  self->length = self->allocated = 0;
+	}
+    }
+  return self;
+}
+
+
+#if !defined(TRIO_MINIMAL)
+/*
+ * trio_string_equal
+ */
+TRIO_STRING_PUBLIC int
+trio_string_equal
+TRIO_ARGS2((self, other),
+	   trio_string_t *self,
+	   trio_string_t *other)
+{
+  assert(self);
+  assert(other);
+
+  return trio_equal(self->content, other->content);
+}
+#endif /* !defined(TRIO_MINIMAL) */
+
+
+#if !defined(TRIO_MINIMAL)
+/*
+ * trio_xstring_equal
+ */
+TRIO_STRING_PUBLIC int
+trio_xstring_equal
+TRIO_ARGS2((self, other),
+	   trio_string_t *self,
+	   TRIO_CONST char *other)
+{
+  assert(self);
+  assert(other);
+
+  return trio_equal(self->content, other);
+}
+#endif /* !defined(TRIO_MINIMAL) */
+
+
+#if !defined(TRIO_MINIMAL)
+/*
+ * trio_string_equal_max
+ */
+TRIO_STRING_PUBLIC int
+trio_string_equal_max
+TRIO_ARGS3((self, max, other),
+	   trio_string_t *self,
+	   size_t max,
+	   trio_string_t *other)
+{
+  assert(self);
+  assert(other);
+
+  return trio_equal_max(self->content, max, other->content);
+}
+#endif /* !defined(TRIO_MINIMAL) */
+
+
+#if !defined(TRIO_MINIMAL)
+/*
+ * trio_xstring_equal_max
+ */
+TRIO_STRING_PUBLIC int
+trio_xstring_equal_max
+TRIO_ARGS3((self, max, other),
+	   trio_string_t *self,
+	   size_t max,
+	   TRIO_CONST char *other)
+{
+  assert(self);
+  assert(other);
+
+  return trio_equal_max(self->content, max, other);
+}
+#endif /* !defined(TRIO_MINIMAL) */
+
+
+#if !defined(TRIO_MINIMAL)
+/*
+ * trio_string_equal_case
+ */
+TRIO_STRING_PUBLIC int
+trio_string_equal_case
+TRIO_ARGS2((self, other),
+	   trio_string_t *self,
+	   trio_string_t *other)
+{
+  assert(self);
+  assert(other);
+
+  return trio_equal_case(self->content, other->content);
+}
+#endif /* !defined(TRIO_MINIMAL) */
+
+
+#if !defined(TRIO_MINIMAL)
+/*
+ * trio_xstring_equal_case
+ */
+TRIO_STRING_PUBLIC int
+trio_xstring_equal_case
+TRIO_ARGS2((self, other),
+	   trio_string_t *self,
+	   TRIO_CONST char *other)
+{
+  assert(self);
+  assert(other);
+
+  return trio_equal_case(self->content, other);
+}
+#endif /* !defined(TRIO_MINIMAL) */
+
+
+#if !defined(TRIO_MINIMAL)
+/*
+ * trio_string_equal_case_max
+ */
+TRIO_STRING_PUBLIC int
+trio_string_equal_case_max
+TRIO_ARGS3((self, max, other),
+	   trio_string_t *self,
+	   size_t max,
+	   trio_string_t *other)
+{
+  assert(self);
+  assert(other);
+
+  return trio_equal_case_max(self->content, max, other->content);
+}
+#endif /* !defined(TRIO_MINIMAL) */
+
+
+#if !defined(TRIO_MINIMAL)
+/*
+ * trio_xstring_equal_case_max
+ */
+TRIO_STRING_PUBLIC int
+trio_xstring_equal_case_max
+TRIO_ARGS3((self, max, other),
+	   trio_string_t *self,
+	   size_t max,
+	   TRIO_CONST char *other)
+{
+  assert(self);
+  assert(other);
+
+  return trio_equal_case_max(self->content, max, other);
+}
+#endif /* !defined(TRIO_MINIMAL) */
+
+
+#if !defined(TRIO_MINIMAL)
+/*
+ * trio_string_format_data_max
+ */
+TRIO_STRING_PUBLIC size_t
+trio_string_format_date_max
+TRIO_ARGS4((self, max, format, datetime),
+	   trio_string_t *self,
+	   size_t max,
+	   TRIO_CONST char *format,
+	   TRIO_CONST struct tm *datetime)
+{
+  assert(self);
+
+  return trio_format_date_max(self->content, max, format, datetime);
+}
+#endif /* !defined(TRIO_MINIMAL) */
+
+
+#if !defined(TRIO_MINIMAL)
+/*
+ * trio_string_index
+ */
+TRIO_STRING_PUBLIC char *
+trio_string_index
+TRIO_ARGS2((self, character),
+	   trio_string_t *self,
+	   int character)
+{
+  assert(self);
+
+  return trio_index(self->content, character);
+}
+#endif /* !defined(TRIO_MINIMAL) */
+
+
+#if !defined(TRIO_MINIMAL)
+/*
+ * trio_string_index_last
+ */
+TRIO_STRING_PUBLIC char *
+trio_string_index_last
+TRIO_ARGS2((self, character),
+	   trio_string_t *self,
+	   int character)
+{
+  assert(self);
+
+  return trio_index_last(self->content, character);
+}
+#endif /* !defined(TRIO_MINIMAL) */
+
+
+#if !defined(TRIO_MINIMAL)
+/*
+ * trio_string_length
+ */
+TRIO_STRING_PUBLIC int
+trio_string_length
+TRIO_ARGS1((self),
+	   trio_string_t *self)
+{
+  assert(self);
+
+  if (self->length == 0)
+    {
+      self->length = trio_length(self->content);
+    }
+  return self->length;
+}
+#endif /* !defined(TRIO_MINIMAL) */
+
+
+#if !defined(TRIO_MINIMAL)
+/*
+ * trio_string_lower
+ */
+TRIO_STRING_PUBLIC int
+trio_string_lower
+TRIO_ARGS1((self),
+	   trio_string_t *self)
+{
+  assert(self);
+
+  return trio_lower(self->content);
+}
+#endif /* !defined(TRIO_MINIMAL) */
+
+
+#if !defined(TRIO_MINIMAL)
+/*
+ * trio_string_match
+ */
+TRIO_STRING_PUBLIC int
+trio_string_match
+TRIO_ARGS2((self, other),
+	   trio_string_t *self,
+	   trio_string_t *other)
+{
+  assert(self);
+  assert(other);
+
+  return trio_match(self->content, other->content);
+}
+#endif /* !defined(TRIO_MINIMAL) */
+
+
+#if !defined(TRIO_MINIMAL)
+/*
+ * trio_xstring_match
+ */
+TRIO_STRING_PUBLIC int
+trio_xstring_match
+TRIO_ARGS2((self, other),
+	   trio_string_t *self,
+	   TRIO_CONST char *other)
+{
+  assert(self);
+  assert(other);
+
+  return trio_match(self->content, other);
+}
+#endif /* !defined(TRIO_MINIMAL) */
+
+
+#if !defined(TRIO_MINIMAL)
+/*
+ * trio_string_match_case
+ */
+TRIO_STRING_PUBLIC int
+trio_string_match_case
+TRIO_ARGS2((self, other),
+	   trio_string_t *self,
+	   trio_string_t *other)
+{
+  assert(self);
+  assert(other);
+
+  return trio_match_case(self->content, other->content);
+}
+#endif /* !defined(TRIO_MINIMAL) */
+
+
+#if !defined(TRIO_MINIMAL)
+/*
+ * trio_xstring_match_case
+ */
+TRIO_STRING_PUBLIC int
+trio_xstring_match_case
+TRIO_ARGS2((self, other),
+	   trio_string_t *self,
+	   TRIO_CONST char *other)
+{
+  assert(self);
+  assert(other);
+
+  return trio_match_case(self->content, other);
+}
+#endif /* !defined(TRIO_MINIMAL) */
+
+
+#if !defined(TRIO_MINIMAL)
+/*
+ * trio_string_substring
+ */
+TRIO_STRING_PUBLIC char *
+trio_string_substring
+TRIO_ARGS2((self, other),
+	   trio_string_t *self,
+	   trio_string_t *other)
+{
+  assert(self);
+  assert(other);
+
+  return trio_substring(self->content, other->content);
+}
+#endif /* !defined(TRIO_MINIMAL) */
+
+
+#if !defined(TRIO_MINIMAL)
+/*
+ * trio_xstring_substring
+ */
+TRIO_STRING_PUBLIC char *
+trio_xstring_substring
+TRIO_ARGS2((self, other),
+	   trio_string_t *self,
+	   TRIO_CONST char *other)
+{
+  assert(self);
+  assert(other);
+
+  return trio_substring(self->content, other);
+}
+#endif /* !defined(TRIO_MINIMAL) */
+
+
+#if !defined(TRIO_MINIMAL)
+/*
+ * trio_string_upper
+ */
+TRIO_STRING_PUBLIC int
+trio_string_upper
+TRIO_ARGS1((self),
+	   trio_string_t *self)
+{
+  assert(self);
+
+  return trio_upper(self->content);
+}
+#endif /* !defined(TRIO_MINIMAL) */
+
+/** @} End of DynamicStrings */
diff --git a/src/libxml/src/triostr.h b/src/libxml/src/triostr.h
new file mode 100644
index 0000000..ce87fc3
--- /dev/null
+++ b/src/libxml/src/triostr.h
@@ -0,0 +1,140 @@
+/*************************************************************************
+ *
+ * $Id: triostr.h,v 1.1 2008/11/12 02:25:23 agibert Exp $
+ *
+ * Copyright (C) 2001 Bjorn Reese and Daniel Stenberg.
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
+ * MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE AUTHORS AND
+ * CONTRIBUTORS ACCEPT NO RESPONSIBILITY IN ANY CONCEIVABLE MANNER.
+ *
+ ************************************************************************/
+
+#ifndef TRIO_TRIOSTR_H
+#define TRIO_TRIOSTR_H
+
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include "triodef.h"
+#include "triop.h"
+
+enum {
+  TRIO_HASH_NONE = 0,
+  TRIO_HASH_PLAIN,
+  TRIO_HASH_TWOSIGNED
+};
+
+#if !defined(TRIO_STRING_PUBLIC)
+# if !defined(TRIO_PUBLIC)
+#  define TRIO_PUBLIC
+# endif
+# define TRIO_STRING_PUBLIC TRIO_PUBLIC
+#endif
+
+/*************************************************************************
+ * String functions
+ */
+
+TRIO_STRING_PUBLIC int trio_copy_max TRIO_PROTO((char *target, size_t max, const char *source));
+TRIO_STRING_PUBLIC char *trio_create TRIO_PROTO((size_t size));
+TRIO_STRING_PUBLIC void trio_destroy TRIO_PROTO((char *string));
+TRIO_STRING_PUBLIC char *trio_duplicate TRIO_PROTO((const char *source));
+TRIO_STRING_PUBLIC int trio_equal TRIO_PROTO((const char *first, const char *second));
+TRIO_STRING_PUBLIC int trio_equal_case TRIO_PROTO((const char *first, const char *second));
+TRIO_STRING_PUBLIC int trio_equal_locale TRIO_PROTO((const char *first, const char *second));
+TRIO_STRING_PUBLIC int trio_equal_max TRIO_PROTO((const char *first, size_t max, const char *second));
+TRIO_STRING_PUBLIC TRIO_CONST char *trio_error TRIO_PROTO((int));
+TRIO_STRING_PUBLIC size_t trio_length TRIO_PROTO((const char *string));
+TRIO_STRING_PUBLIC double trio_to_double TRIO_PROTO((const char *source, char **endp));
+TRIO_STRING_PUBLIC long trio_to_long TRIO_PROTO((const char *source, char **endp, int base));
+TRIO_STRING_PUBLIC trio_long_double_t trio_to_long_double TRIO_PROTO((const char *source, char **endp));
+TRIO_STRING_PUBLIC int trio_to_upper TRIO_PROTO((int source));
+
+#if !defined(TRIO_MINIMAL)
+
+TRIO_STRING_PUBLIC int trio_append TRIO_PROTO((char *target, const char *source));
+TRIO_STRING_PUBLIC int trio_append_max TRIO_PROTO((char *target, size_t max, const char *source));
+TRIO_STRING_PUBLIC int trio_contains TRIO_PROTO((const char *string, const char *substring));
+TRIO_STRING_PUBLIC int trio_copy TRIO_PROTO((char *target, const char *source));
+TRIO_STRING_PUBLIC char *trio_duplicate_max TRIO_PROTO((const char *source, size_t max));
+TRIO_STRING_PUBLIC int trio_equal_case_max TRIO_PROTO((const char *first, size_t max, const char *second));
+TRIO_STRING_PUBLIC size_t trio_format_date_max TRIO_PROTO((char *target, size_t max, const char *format, const struct tm *datetime));
+TRIO_STRING_PUBLIC unsigned long trio_hash TRIO_PROTO((const char *string, int type));
+TRIO_STRING_PUBLIC char *trio_index TRIO_PROTO((const char *string, int character));
+TRIO_STRING_PUBLIC char *trio_index_last TRIO_PROTO((const char *string, int character));
+TRIO_STRING_PUBLIC int trio_lower TRIO_PROTO((char *target));
+TRIO_STRING_PUBLIC int trio_match TRIO_PROTO((const char *string, const char *pattern));
+TRIO_STRING_PUBLIC int trio_match_case TRIO_PROTO((const char *string, const char *pattern));
+TRIO_STRING_PUBLIC size_t trio_span_function TRIO_PROTO((char *target, const char *source, int (*Function) TRIO_PROTO((int))));
+TRIO_STRING_PUBLIC char *trio_substring TRIO_PROTO((const char *string, const char *substring));
+TRIO_STRING_PUBLIC char *trio_substring_max TRIO_PROTO((const char *string, size_t max, const char *substring));
+TRIO_STRING_PUBLIC float trio_to_float TRIO_PROTO((const char *source, char **endp));
+TRIO_STRING_PUBLIC int trio_to_lower TRIO_PROTO((int source));
+TRIO_STRING_PUBLIC unsigned long trio_to_unsigned_long TRIO_PROTO((const char *source, char **endp, int base));
+TRIO_STRING_PUBLIC char *trio_tokenize TRIO_PROTO((char *string, const char *delimiters));
+TRIO_STRING_PUBLIC int trio_upper TRIO_PROTO((char *target));
+
+#endif /* !defined(TRIO_MINIMAL) */
+
+/*************************************************************************
+ * Dynamic string functions
+ */
+
+/*
+ * Opaque type for dynamic strings
+ */
+
+typedef struct _trio_string_t trio_string_t;
+
+TRIO_STRING_PUBLIC void trio_string_destroy TRIO_PROTO((trio_string_t *self));
+TRIO_STRING_PUBLIC char *trio_string_extract TRIO_PROTO((trio_string_t *self));
+TRIO_STRING_PUBLIC int trio_string_size TRIO_PROTO((trio_string_t *self));
+TRIO_STRING_PUBLIC void trio_string_terminate TRIO_PROTO((trio_string_t *self));
+TRIO_STRING_PUBLIC int trio_xstring_append_char TRIO_PROTO((trio_string_t *self, char character));
+TRIO_STRING_PUBLIC trio_string_t *trio_xstring_duplicate TRIO_PROTO((const char *other));
+
+#if !defined(TRIO_MINIMAL)
+
+TRIO_STRING_PUBLIC trio_string_t *trio_string_create TRIO_PROTO((int initial_size));
+TRIO_STRING_PUBLIC char *trio_string_get TRIO_PROTO((trio_string_t *self, int offset));
+TRIO_STRING_PUBLIC void trio_xstring_set TRIO_PROTO((trio_string_t *self, char *buffer));
+
+TRIO_STRING_PUBLIC int trio_string_append TRIO_PROTO((trio_string_t *self, trio_string_t *other));
+TRIO_STRING_PUBLIC int trio_string_contains TRIO_PROTO((trio_string_t *self, trio_string_t *other));
+TRIO_STRING_PUBLIC int trio_string_copy TRIO_PROTO((trio_string_t *self, trio_string_t *other));
+TRIO_STRING_PUBLIC trio_string_t *trio_string_duplicate TRIO_PROTO((trio_string_t *other));
+TRIO_STRING_PUBLIC int trio_string_equal TRIO_PROTO((trio_string_t *self, trio_string_t *other));
+TRIO_STRING_PUBLIC int trio_string_equal_max TRIO_PROTO((trio_string_t *self, size_t max, trio_string_t *second));
+TRIO_STRING_PUBLIC int trio_string_equal_case TRIO_PROTO((trio_string_t *self, trio_string_t *other));
+TRIO_STRING_PUBLIC int trio_string_equal_case_max TRIO_PROTO((trio_string_t *self, size_t max, trio_string_t *other));
+TRIO_STRING_PUBLIC size_t trio_string_format_date_max TRIO_PROTO((trio_string_t *self, size_t max, const char *format, const struct tm *datetime));
+TRIO_STRING_PUBLIC char *trio_string_index TRIO_PROTO((trio_string_t *self, int character));
+TRIO_STRING_PUBLIC char *trio_string_index_last TRIO_PROTO((trio_string_t *self, int character));
+TRIO_STRING_PUBLIC int trio_string_length TRIO_PROTO((trio_string_t *self));
+TRIO_STRING_PUBLIC int trio_string_lower TRIO_PROTO((trio_string_t *self));
+TRIO_STRING_PUBLIC int trio_string_match TRIO_PROTO((trio_string_t *self, trio_string_t *other));
+TRIO_STRING_PUBLIC int trio_string_match_case TRIO_PROTO((trio_string_t *self, trio_string_t *other));
+TRIO_STRING_PUBLIC char *trio_string_substring TRIO_PROTO((trio_string_t *self, trio_string_t *other));
+TRIO_STRING_PUBLIC int trio_string_upper TRIO_PROTO((trio_string_t *self));
+
+TRIO_STRING_PUBLIC int trio_xstring_append TRIO_PROTO((trio_string_t *self, const char *other));
+TRIO_STRING_PUBLIC int trio_xstring_contains TRIO_PROTO((trio_string_t *self, const char *other));
+TRIO_STRING_PUBLIC int trio_xstring_copy TRIO_PROTO((trio_string_t *self, const char *other));
+TRIO_STRING_PUBLIC int trio_xstring_equal TRIO_PROTO((trio_string_t *self, const char *other));
+TRIO_STRING_PUBLIC int trio_xstring_equal_max TRIO_PROTO((trio_string_t *self, size_t max, const char *other));
+TRIO_STRING_PUBLIC int trio_xstring_equal_case TRIO_PROTO((trio_string_t *self, const char *other));
+TRIO_STRING_PUBLIC int trio_xstring_equal_case_max TRIO_PROTO((trio_string_t *self, size_t max, const char *other));
+TRIO_STRING_PUBLIC int trio_xstring_match TRIO_PROTO((trio_string_t *self, const char *other));
+TRIO_STRING_PUBLIC int trio_xstring_match_case TRIO_PROTO((trio_string_t *self, const char *other));
+TRIO_STRING_PUBLIC char *trio_xstring_substring TRIO_PROTO((trio_string_t *self, const char *other));
+
+#endif /* !defined(TRIO_MINIMAL) */
+
+#endif /* TRIO_TRIOSTR_H */
diff --git a/src/libxml/src/uri.c b/src/libxml/src/uri.c
new file mode 100644
index 0000000..b89603c
--- /dev/null
+++ b/src/libxml/src/uri.c
@@ -0,0 +1,2030 @@
+/**
+ * uri.c: set of generic URI related routines 
+ *
+ * Reference: RFC 2396
+ *
+ * See Copyright for the status of this software.
+ *
+ * daniel@veillard.com
+ */
+
+#define IN_LIBXML
+#include "libxml.h"
+
+#include <string.h>
+
+#include <libxml/xmlmemory.h>
+#include <libxml/uri.h>
+#include <libxml/globals.h>
+#include <libxml/xmlerror.h>
+
+/************************************************************************
+ *									*
+ *		Macros to differentiate various character type		*
+ *			directly extracted from RFC 2396		*
+ *									*
+ ************************************************************************/
+
+/*
+ * alpha    = lowalpha | upalpha
+ */
+#define IS_ALPHA(x) (IS_LOWALPHA(x) || IS_UPALPHA(x))
+
+
+/*
+ * lowalpha = "a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | "j" |
+ *            "k" | "l" | "m" | "n" | "o" | "p" | "q" | "r" | "s" | "t" |
+ *            "u" | "v" | "w" | "x" | "y" | "z"
+ */
+
+#define IS_LOWALPHA(x) (((x) >= 'a') && ((x) <= 'z'))
+
+/*
+ * upalpha = "A" | "B" | "C" | "D" | "E" | "F" | "G" | "H" | "I" | "J" |
+ *           "K" | "L" | "M" | "N" | "O" | "P" | "Q" | "R" | "S" | "T" |
+ *           "U" | "V" | "W" | "X" | "Y" | "Z"
+ */
+#define IS_UPALPHA(x) (((x) >= 'A') && ((x) <= 'Z'))
+
+/*
+ * digit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9"
+ */
+
+#define IS_DIGIT(x) (((x) >= '0') && ((x) <= '9'))
+
+/*
+ * alphanum = alpha | digit
+ */
+
+#define IS_ALPHANUM(x) (IS_ALPHA(x) || IS_DIGIT(x))
+
+/*
+ * hex = digit | "A" | "B" | "C" | "D" | "E" | "F" |
+ *               "a" | "b" | "c" | "d" | "e" | "f"
+ */
+
+#define IS_HEX(x) ((IS_DIGIT(x)) || (((x) >= 'a') && ((x) <= 'f')) || \
+	    (((x) >= 'A') && ((x) <= 'F')))
+
+/*
+ * mark = "-" | "_" | "." | "!" | "~" | "*" | "'" | "(" | ")"
+ */
+
+#define IS_MARK(x) (((x) == '-') || ((x) == '_') || ((x) == '.') ||	\
+    ((x) == '!') || ((x) == '~') || ((x) == '*') || ((x) == '\'') ||	\
+    ((x) == '(') || ((x) == ')'))
+
+
+/*
+ * reserved = ";" | "/" | "?" | ":" | "@" | "&" | "=" | "+" | "$" | ","
+ */
+
+#define IS_RESERVED(x) (((x) == ';') || ((x) == '/') || ((x) == '?') ||	\
+        ((x) == ':') || ((x) == '@') || ((x) == '&') || ((x) == '=') ||	\
+	((x) == '+') || ((x) == '$') || ((x) == ','))
+
+/*
+ * unreserved = alphanum | mark
+ */
+
+#define IS_UNRESERVED(x) (IS_ALPHANUM(x) || IS_MARK(x))
+
+/*
+ * escaped = "%" hex hex
+ */
+
+#define IS_ESCAPED(p) ((*(p) == '%') && (IS_HEX((p)[1])) &&		\
+	    (IS_HEX((p)[2])))
+
+/*
+ * uric_no_slash = unreserved | escaped | ";" | "?" | ":" | "@" |
+ *                        "&" | "=" | "+" | "$" | ","
+ */
+#define IS_URIC_NO_SLASH(p) ((IS_UNRESERVED(*(p))) || (IS_ESCAPED(p)) ||\
+	        ((*(p) == ';')) || ((*(p) == '?')) || ((*(p) == ':')) ||\
+	        ((*(p) == '@')) || ((*(p) == '&')) || ((*(p) == '=')) ||\
+	        ((*(p) == '+')) || ((*(p) == '$')) || ((*(p) == ',')))
+
+/*
+ * pchar = unreserved | escaped | ":" | "@" | "&" | "=" | "+" | "$" | ","
+ */
+#define IS_PCHAR(p) ((IS_UNRESERVED(*(p))) || (IS_ESCAPED(p)) ||	\
+	        ((*(p) == ':')) || ((*(p) == '@')) || ((*(p) == '&')) ||\
+	        ((*(p) == '=')) || ((*(p) == '+')) || ((*(p) == '$')) ||\
+	        ((*(p) == ',')))
+
+/*
+ * rel_segment   = 1*( unreserved | escaped |
+ *                 ";" | "@" | "&" | "=" | "+" | "$" | "," )
+ */
+
+#define IS_SEGMENT(p) ((IS_UNRESERVED(*(p))) || (IS_ESCAPED(p)) ||	\
+          ((*(p) == ';')) || ((*(p) == '@')) || ((*(p) == '&')) ||	\
+	  ((*(p) == '=')) || ((*(p) == '+')) || ((*(p) == '$')) ||	\
+	  ((*(p) == ',')))
+
+/*
+ * scheme = alpha *( alpha | digit | "+" | "-" | "." )
+ */
+
+#define IS_SCHEME(x) ((IS_ALPHA(x)) || (IS_DIGIT(x)) ||			\
+	              ((x) == '+') || ((x) == '-') || ((x) == '.'))
+
+/*
+ * reg_name = 1*( unreserved | escaped | "$" | "," |
+ *                ";" | ":" | "@" | "&" | "=" | "+" )
+ */
+
+#define IS_REG_NAME(p) ((IS_UNRESERVED(*(p))) || (IS_ESCAPED(p)) ||	\
+       ((*(p) == '$')) || ((*(p) == ',')) || ((*(p) == ';')) ||		\
+       ((*(p) == ':')) || ((*(p) == '@')) || ((*(p) == '&')) ||		\
+       ((*(p) == '=')) || ((*(p) == '+')))
+
+/*
+ * userinfo = *( unreserved | escaped | ";" | ":" | "&" | "=" |
+ *                      "+" | "$" | "," )
+ */
+#define IS_USERINFO(p) ((IS_UNRESERVED(*(p))) || (IS_ESCAPED(p)) ||	\
+       ((*(p) == ';')) || ((*(p) == ':')) || ((*(p) == '&')) ||		\
+       ((*(p) == '=')) || ((*(p) == '+')) || ((*(p) == '$')) ||		\
+       ((*(p) == ',')))
+
+/*
+ * uric = reserved | unreserved | escaped
+ */
+
+#define IS_URIC(p) ((IS_UNRESERVED(*(p))) || (IS_ESCAPED(p)) ||		\
+	            (IS_RESERVED(*(p))))
+
+/*                                                                              
+* unwise = "{" | "}" | "|" | "\" | "^" | "[" | "]" | "`"
+*/                                                                             
+
+#define IS_UNWISE(p)                                                    \
+      (((*(p) == '{')) || ((*(p) == '}')) || ((*(p) == '|')) ||         \
+       ((*(p) == '\\')) || ((*(p) == '^')) || ((*(p) == '[')) ||        \
+       ((*(p) == ']')) || ((*(p) == '`')))  
+
+/*
+ * Skip to next pointer char, handle escaped sequences
+ */
+
+#define NEXT(p) ((*p == '%')? p += 3 : p++)
+
+/*
+ * Productions from the spec.
+ *
+ *    authority     = server | reg_name
+ *    reg_name      = 1*( unreserved | escaped | "$" | "," |
+ *                        ";" | ":" | "@" | "&" | "=" | "+" )
+ *
+ * path          = [ abs_path | opaque_part ]
+ */
+
+/************************************************************************
+ *									*
+ *			Generic URI structure functions			*
+ *									*
+ ************************************************************************/
+
+/**
+ * xmlCreateURI:
+ *
+ * Simply creates an empty xmlURI
+ *
+ * Returns the new structure or NULL in case of error
+ */
+xmlURIPtr
+xmlCreateURI(void) {
+    xmlURIPtr ret;
+
+    ret = (xmlURIPtr) xmlMalloc(sizeof(xmlURI));
+    if (ret == NULL) {
+	xmlGenericError(xmlGenericErrorContext,
+		"xmlCreateURI: out of memory\n");
+	return(NULL);
+    }
+    memset(ret, 0, sizeof(xmlURI));
+    return(ret);
+}
+
+/**
+ * xmlSaveUri:
+ * @uri:  pointer to an xmlURI
+ *
+ * Save the URI as an escaped string
+ *
+ * Returns a new string (to be deallocated by caller)
+ */
+xmlChar *
+xmlSaveUri(xmlURIPtr uri) {
+    xmlChar *ret = NULL;
+    const char *p;
+    int len;
+    int max;
+
+    if (uri == NULL) return(NULL);
+
+
+    max = 80;
+    ret = (xmlChar *) xmlMallocAtomic((max + 1) * sizeof(xmlChar));
+    if (ret == NULL) {
+	xmlGenericError(xmlGenericErrorContext,
+		"xmlSaveUri: out of memory\n");
+	return(NULL);
+    }
+    len = 0;
+
+    if (uri->scheme != NULL) {
+	p = uri->scheme;
+	while (*p != 0) {
+	    if (len >= max) {
+		max *= 2;
+		ret = (xmlChar *) xmlRealloc(ret, (max + 1) * sizeof(xmlChar));
+		if (ret == NULL) {
+		    xmlGenericError(xmlGenericErrorContext,
+			    "xmlSaveUri: out of memory\n");
+		    return(NULL);
+		}
+	    }
+	    ret[len++] = *p++;
+	}
+	if (len >= max) {
+	    max *= 2;
+	    ret = (xmlChar *) xmlRealloc(ret, (max + 1) * sizeof(xmlChar));
+	    if (ret == NULL) {
+		xmlGenericError(xmlGenericErrorContext,
+			"xmlSaveUri: out of memory\n");
+		return(NULL);
+	    }
+	}
+	ret[len++] = ':';
+    }
+    if (uri->opaque != NULL) {
+	p = uri->opaque;
+	while (*p != 0) {
+	    if (len + 3 >= max) {
+		max *= 2;
+		ret = (xmlChar *) xmlRealloc(ret, (max + 1) * sizeof(xmlChar));
+		if (ret == NULL) {
+		    xmlGenericError(xmlGenericErrorContext,
+			    "xmlSaveUri: out of memory\n");
+		    return(NULL);
+		}
+	    }
+	    if (IS_RESERVED(*(p)) || IS_UNRESERVED(*(p)))
+		ret[len++] = *p++;
+	    else {
+		int val = *(unsigned char *)p++;
+		int hi = val / 0x10, lo = val % 0x10;
+		ret[len++] = '%';
+		ret[len++] = hi + (hi > 9? 'A'-10 : '0');
+		ret[len++] = lo + (lo > 9? 'A'-10 : '0');
+	    }
+	}
+    } else {
+	if (uri->server != NULL) {
+	    if (len + 3 >= max) {
+		max *= 2;
+		ret = (xmlChar *) xmlRealloc(ret, (max + 1) * sizeof(xmlChar));
+		if (ret == NULL) {
+		    xmlGenericError(xmlGenericErrorContext,
+			    "xmlSaveUri: out of memory\n");
+		    return(NULL);
+		}
+	    }
+	    ret[len++] = '/';
+	    ret[len++] = '/';
+	    if (uri->user != NULL) {
+		p = uri->user;
+		while (*p != 0) {
+		    if (len + 3 >= max) {
+			max *= 2;
+			ret = (xmlChar *) xmlRealloc(ret,
+				(max + 1) * sizeof(xmlChar));
+			if (ret == NULL) {
+			    xmlGenericError(xmlGenericErrorContext,
+				    "xmlSaveUri: out of memory\n");
+			    return(NULL);
+			}
+		    }
+		    if ((IS_UNRESERVED(*(p))) ||
+			((*(p) == ';')) || ((*(p) == ':')) ||
+			((*(p) == '&')) || ((*(p) == '=')) ||
+			((*(p) == '+')) || ((*(p) == '$')) ||
+			((*(p) == ',')))
+			ret[len++] = *p++;
+		    else {
+			int val = *(unsigned char *)p++;
+			int hi = val / 0x10, lo = val % 0x10;
+			ret[len++] = '%';
+			ret[len++] = hi + (hi > 9? 'A'-10 : '0');
+			ret[len++] = lo + (lo > 9? 'A'-10 : '0');
+		    }
+		}
+		if (len + 3 >= max) {
+		    max *= 2;
+		    ret = (xmlChar *) xmlRealloc(ret,
+			    (max + 1) * sizeof(xmlChar));
+		    if (ret == NULL) {
+			xmlGenericError(xmlGenericErrorContext,
+				"xmlSaveUri: out of memory\n");
+			return(NULL);
+		    }
+		}
+		ret[len++] = '@';
+	    }
+	    p = uri->server;
+	    while (*p != 0) {
+		if (len >= max) {
+		    max *= 2;
+		    ret = (xmlChar *) xmlRealloc(ret,
+			    (max + 1) * sizeof(xmlChar));
+		    if (ret == NULL) {
+			xmlGenericError(xmlGenericErrorContext,
+				"xmlSaveUri: out of memory\n");
+			return(NULL);
+		    }
+		}
+		ret[len++] = *p++;
+	    }
+	    if (uri->port > 0) {
+		if (len + 10 >= max) {
+		    max *= 2;
+		    ret = (xmlChar *) xmlRealloc(ret,
+			    (max + 1) * sizeof(xmlChar));
+		    if (ret == NULL) {
+			xmlGenericError(xmlGenericErrorContext,
+				"xmlSaveUri: out of memory\n");
+			return(NULL);
+		    }
+		}
+		len += snprintf((char *) &ret[len], max - len, ":%d", uri->port);
+	    }
+	} else if (uri->authority != NULL) {
+	    if (len + 3 >= max) {
+		max *= 2;
+		ret = (xmlChar *) xmlRealloc(ret,
+			(max + 1) * sizeof(xmlChar));
+		if (ret == NULL) {
+		    xmlGenericError(xmlGenericErrorContext,
+			    "xmlSaveUri: out of memory\n");
+		    return(NULL);
+		}
+	    }
+	    ret[len++] = '/';
+	    ret[len++] = '/';
+	    p = uri->authority;
+	    while (*p != 0) {
+		if (len + 3 >= max) {
+		    max *= 2;
+		    ret = (xmlChar *) xmlRealloc(ret,
+			    (max + 1) * sizeof(xmlChar));
+		    if (ret == NULL) {
+			xmlGenericError(xmlGenericErrorContext,
+				"xmlSaveUri: out of memory\n");
+			return(NULL);
+		    }
+		}
+		if ((IS_UNRESERVED(*(p))) ||
+                    ((*(p) == '$')) || ((*(p) == ',')) || ((*(p) == ';')) ||
+                    ((*(p) == ':')) || ((*(p) == '@')) || ((*(p) == '&')) ||
+                    ((*(p) == '=')) || ((*(p) == '+')))
+		    ret[len++] = *p++;
+		else {
+		    int val = *(unsigned char *)p++;
+		    int hi = val / 0x10, lo = val % 0x10;
+		    ret[len++] = '%';
+		    ret[len++] = hi + (hi > 9? 'A'-10 : '0');
+		    ret[len++] = lo + (lo > 9? 'A'-10 : '0');
+		}
+	    }
+	} else if (uri->scheme != NULL) {
+	    if (len + 3 >= max) {
+		max *= 2;
+		ret = (xmlChar *) xmlRealloc(ret,
+			(max + 1) * sizeof(xmlChar));
+		if (ret == NULL) {
+		    xmlGenericError(xmlGenericErrorContext,
+			    "xmlSaveUri: out of memory\n");
+		    return(NULL);
+		}
+	    }
+	    ret[len++] = '/';
+	    ret[len++] = '/';
+	}
+	if (uri->path != NULL) {
+	    p = uri->path;
+	    while (*p != 0) {
+		if (len + 3 >= max) {
+		    max *= 2;
+		    ret = (xmlChar *) xmlRealloc(ret,
+			    (max + 1) * sizeof(xmlChar));
+		    if (ret == NULL) {
+			xmlGenericError(xmlGenericErrorContext,
+				"xmlSaveUri: out of memory\n");
+			return(NULL);
+		    }
+		}
+		if ((IS_UNRESERVED(*(p))) || ((*(p) == '/')) ||
+                    ((*(p) == ';')) || ((*(p) == '@')) || ((*(p) == '&')) ||
+	            ((*(p) == '=')) || ((*(p) == '+')) || ((*(p) == '$')) ||
+	            ((*(p) == ',')))
+		    ret[len++] = *p++;
+		else {
+		    int val = *(unsigned char *)p++;
+		    int hi = val / 0x10, lo = val % 0x10;
+		    ret[len++] = '%';
+		    ret[len++] = hi + (hi > 9? 'A'-10 : '0');
+		    ret[len++] = lo + (lo > 9? 'A'-10 : '0');
+		}
+	    }
+	}
+	if (uri->query != NULL) {
+	    if (len + 3 >= max) {
+		max *= 2;
+		ret = (xmlChar *) xmlRealloc(ret,
+			(max + 1) * sizeof(xmlChar));
+		if (ret == NULL) {
+		    xmlGenericError(xmlGenericErrorContext,
+			    "xmlSaveUri: out of memory\n");
+		    return(NULL);
+		}
+	    }
+	    ret[len++] = '?';
+	    p = uri->query;
+	    while (*p != 0) {
+		if (len + 3 >= max) {
+		    max *= 2;
+		    ret = (xmlChar *) xmlRealloc(ret,
+			    (max + 1) * sizeof(xmlChar));
+		    if (ret == NULL) {
+			xmlGenericError(xmlGenericErrorContext,
+				"xmlSaveUri: out of memory\n");
+			return(NULL);
+		    }
+		}
+		if ((IS_UNRESERVED(*(p))) || (IS_RESERVED(*(p)))) 
+		    ret[len++] = *p++;
+		else {
+		    int val = *(unsigned char *)p++;
+		    int hi = val / 0x10, lo = val % 0x10;
+		    ret[len++] = '%';
+		    ret[len++] = hi + (hi > 9? 'A'-10 : '0');
+		    ret[len++] = lo + (lo > 9? 'A'-10 : '0');
+		}
+	    }
+	}
+    }
+    if (uri->fragment != NULL) {
+	if (len + 3 >= max) {
+	    max *= 2;
+	    ret = (xmlChar *) xmlRealloc(ret,
+		    (max + 1) * sizeof(xmlChar));
+	    if (ret == NULL) {
+		xmlGenericError(xmlGenericErrorContext,
+			"xmlSaveUri: out of memory\n");
+		return(NULL);
+	    }
+	}
+	ret[len++] = '#';
+	p = uri->fragment;
+	while (*p != 0) {
+	    if (len + 3 >= max) {
+		max *= 2;
+		ret = (xmlChar *) xmlRealloc(ret,
+			(max + 1) * sizeof(xmlChar));
+		if (ret == NULL) {
+		    xmlGenericError(xmlGenericErrorContext,
+			    "xmlSaveUri: out of memory\n");
+		    return(NULL);
+		}
+	    }
+	    if ((IS_UNRESERVED(*(p))) || (IS_RESERVED(*(p)))) 
+		ret[len++] = *p++;
+	    else {
+		int val = *(unsigned char *)p++;
+		int hi = val / 0x10, lo = val % 0x10;
+		ret[len++] = '%';
+		ret[len++] = hi + (hi > 9? 'A'-10 : '0');
+		ret[len++] = lo + (lo > 9? 'A'-10 : '0');
+	    }
+	}
+    }
+    if (len >= max) {
+	max *= 2;
+	ret = (xmlChar *) xmlRealloc(ret, (max + 1) * sizeof(xmlChar));
+	if (ret == NULL) {
+	    xmlGenericError(xmlGenericErrorContext,
+		    "xmlSaveUri: out of memory\n");
+	    return(NULL);
+	}
+    }
+    ret[len++] = 0;
+    return(ret);
+}
+
+/**
+ * xmlPrintURI:
+ * @stream:  a FILE* for the output
+ * @uri:  pointer to an xmlURI
+ *
+ * Prints the URI in the stream @steam.
+ */
+void
+xmlPrintURI(FILE *stream, xmlURIPtr uri) {
+    xmlChar *out;
+
+    out = xmlSaveUri(uri);
+    if (out != NULL) {
+	fprintf(stream, "%s", (char *) out);
+	xmlFree(out);
+    }
+}
+
+/**
+ * xmlCleanURI:
+ * @uri:  pointer to an xmlURI
+ *
+ * Make sure the xmlURI struct is free of content
+ */
+static void
+xmlCleanURI(xmlURIPtr uri) {
+    if (uri == NULL) return;
+
+    if (uri->scheme != NULL) xmlFree(uri->scheme);
+    uri->scheme = NULL;
+    if (uri->server != NULL) xmlFree(uri->server);
+    uri->server = NULL;
+    if (uri->user != NULL) xmlFree(uri->user);
+    uri->user = NULL;
+    if (uri->path != NULL) xmlFree(uri->path);
+    uri->path = NULL;
+    if (uri->fragment != NULL) xmlFree(uri->fragment);
+    uri->fragment = NULL;
+    if (uri->opaque != NULL) xmlFree(uri->opaque);
+    uri->opaque = NULL;
+    if (uri->authority != NULL) xmlFree(uri->authority);
+    uri->authority = NULL;
+    if (uri->query != NULL) xmlFree(uri->query);
+    uri->query = NULL;
+}
+
+/**
+ * xmlFreeURI:
+ * @uri:  pointer to an xmlURI
+ *
+ * Free up the xmlURI struct
+ */
+void
+xmlFreeURI(xmlURIPtr uri) {
+    if (uri == NULL) return;
+
+    if (uri->scheme != NULL) xmlFree(uri->scheme);
+    if (uri->server != NULL) xmlFree(uri->server);
+    if (uri->user != NULL) xmlFree(uri->user);
+    if (uri->path != NULL) xmlFree(uri->path);
+    if (uri->fragment != NULL) xmlFree(uri->fragment);
+    if (uri->opaque != NULL) xmlFree(uri->opaque);
+    if (uri->authority != NULL) xmlFree(uri->authority);
+    if (uri->query != NULL) xmlFree(uri->query);
+    xmlFree(uri);
+}
+
+/************************************************************************
+ *									*
+ *			Helper functions				*
+ *									*
+ ************************************************************************/
+
+/**
+ * xmlNormalizeURIPath:
+ * @path:  pointer to the path string
+ *
+ * Applies the 5 normalization steps to a path string--that is, RFC 2396
+ * Section 5.2, steps 6.c through 6.g.
+ *
+ * Normalization occurs directly on the string, no new allocation is done
+ *
+ * Returns 0 or an error code
+ */
+int
+xmlNormalizeURIPath(char *path) {
+    char *cur, *out;
+
+    if (path == NULL)
+	return(-1);
+
+    /* Skip all initial "/" chars.  We want to get to the beginning of the
+     * first non-empty segment.
+     */
+    cur = path;
+    while (cur[0] == '/')
+      ++cur;
+    if (cur[0] == '\0')
+      return(0);
+
+    /* Keep everything we've seen so far.  */
+    out = cur;
+
+    /*
+     * Analyze each segment in sequence for cases (c) and (d).
+     */
+    while (cur[0] != '\0') {
+	/*
+	 * c) All occurrences of "./", where "." is a complete path segment,
+	 *    are removed from the buffer string.
+	 */
+	if ((cur[0] == '.') && (cur[1] == '/')) {
+	    cur += 2;
+	    /* '//' normalization should be done at this point too */
+	    while (cur[0] == '/')
+		cur++;
+	    continue;
+	}
+
+	/*
+	 * d) If the buffer string ends with "." as a complete path segment,
+	 *    that "." is removed.
+	 */
+	if ((cur[0] == '.') && (cur[1] == '\0'))
+	    break;
+
+	/* Otherwise keep the segment.  */
+	while (cur[0] != '/') {
+            if (cur[0] == '\0')
+              goto done_cd;
+	    (out++)[0] = (cur++)[0];
+	}
+	/* nomalize // */
+	while ((cur[0] == '/') && (cur[1] == '/'))
+	    cur++;
+
+        (out++)[0] = (cur++)[0];
+    }
+ done_cd:
+    out[0] = '\0';
+
+    /* Reset to the beginning of the first segment for the next sequence.  */
+    cur = path;
+    while (cur[0] == '/')
+      ++cur;
+    if (cur[0] == '\0')
+	return(0);
+
+    /*
+     * Analyze each segment in sequence for cases (e) and (f).
+     *
+     * e) All occurrences of "<segment>/../", where <segment> is a
+     *    complete path segment not equal to "..", are removed from the
+     *    buffer string.  Removal of these path segments is performed
+     *    iteratively, removing the leftmost matching pattern on each
+     *    iteration, until no matching pattern remains.
+     *
+     * f) If the buffer string ends with "<segment>/..", where <segment>
+     *    is a complete path segment not equal to "..", that
+     *    "<segment>/.." is removed.
+     *
+     * To satisfy the "iterative" clause in (e), we need to collapse the
+     * string every time we find something that needs to be removed.  Thus,
+     * we don't need to keep two pointers into the string: we only need a
+     * "current position" pointer.
+     */
+    while (1) {
+        char *segp, *tmp;
+
+        /* At the beginning of each iteration of this loop, "cur" points to
+         * the first character of the segment we want to examine.
+         */
+
+        /* Find the end of the current segment.  */
+        segp = cur;
+        while ((segp[0] != '/') && (segp[0] != '\0'))
+          ++segp;
+
+        /* If this is the last segment, we're done (we need at least two
+         * segments to meet the criteria for the (e) and (f) cases).
+         */
+        if (segp[0] == '\0')
+          break;
+
+        /* If the first segment is "..", or if the next segment _isn't_ "..",
+         * keep this segment and try the next one.
+         */
+        ++segp;
+        if (((cur[0] == '.') && (cur[1] == '.') && (segp == cur+3))
+            || ((segp[0] != '.') || (segp[1] != '.')
+                || ((segp[2] != '/') && (segp[2] != '\0')))) {
+          cur = segp;
+          continue;
+        }
+
+        /* If we get here, remove this segment and the next one and back up
+         * to the previous segment (if there is one), to implement the
+         * "iteratively" clause.  It's pretty much impossible to back up
+         * while maintaining two pointers into the buffer, so just compact
+         * the whole buffer now.
+         */
+
+        /* If this is the end of the buffer, we're done.  */
+        if (segp[2] == '\0') {
+          cur[0] = '\0';
+          break;
+        }
+        /* Valgrind complained, strcpy(cur, segp + 3); */
+	/* string will overlap, do not use strcpy */
+	tmp = cur;
+	segp += 3;
+	while ((*tmp++ = *segp++) != 0);
+
+        /* If there are no previous segments, then keep going from here.  */
+        segp = cur;
+        while ((segp > path) && ((--segp)[0] == '/'))
+          ;
+        if (segp == path)
+          continue;
+
+        /* "segp" is pointing to the end of a previous segment; find it's
+         * start.  We need to back up to the previous segment and start
+         * over with that to handle things like "foo/bar/../..".  If we
+         * don't do this, then on the first pass we'll remove the "bar/..",
+         * but be pointing at the second ".." so we won't realize we can also
+         * remove the "foo/..".
+         */
+        cur = segp;
+        while ((cur > path) && (cur[-1] != '/'))
+          --cur;
+    }
+    out[0] = '\0';
+
+    /*
+     * g) If the resulting buffer string still begins with one or more
+     *    complete path segments of "..", then the reference is
+     *    considered to be in error. Implementations may handle this
+     *    error by retaining these components in the resolved path (i.e.,
+     *    treating them as part of the final URI), by removing them from
+     *    the resolved path (i.e., discarding relative levels above the
+     *    root), or by avoiding traversal of the reference.
+     *
+     * We discard them from the final path.
+     */
+    if (path[0] == '/') {
+      cur = path;
+      while ((cur[0] == '/') && (cur[1] == '.') && (cur[2] == '.')
+             && ((cur[3] == '/') || (cur[3] == '\0')))
+	cur += 3;
+
+      if (cur != path) {
+	out = path;
+	while (cur[0] != '\0')
+          (out++)[0] = (cur++)[0];
+	out[0] = 0;
+      }
+    }
+
+    return(0);
+}
+
+/**
+ * xmlURIUnescapeString:
+ * @str:  the string to unescape
+ * @len:   the length in bytes to unescape (or <= 0 to indicate full string)
+ * @target:  optional destination buffer
+ *
+ * Unescaping routine, does not do validity checks !
+ * Output is direct unsigned char translation of %XX values (no encoding)
+ *
+ * Returns an copy of the string, but unescaped
+ */
+char *
+xmlURIUnescapeString(const char *str, int len, char *target) {
+    char *ret, *out;
+    const char *in;
+
+    if (str == NULL)
+	return(NULL);
+    if (len <= 0) len = strlen(str);
+    if (len < 0) return(NULL);
+
+    if (target == NULL) {
+	ret = (char *) xmlMallocAtomic(len + 1);
+	if (ret == NULL) {
+	    xmlGenericError(xmlGenericErrorContext,
+		    "xmlURIUnescapeString: out of memory\n");
+	    return(NULL);
+	}
+    } else
+	ret = target;
+    in = str;
+    out = ret;
+    while(len > 0) {
+	if (*in == '%') {
+	    in++;
+	    if ((*in >= '0') && (*in <= '9')) 
+	        *out = (*in - '0');
+	    else if ((*in >= 'a') && (*in <= 'f'))
+	        *out = (*in - 'a') + 10;
+	    else if ((*in >= 'A') && (*in <= 'F'))
+	        *out = (*in - 'A') + 10;
+	    in++;
+	    if ((*in >= '0') && (*in <= '9')) 
+	        *out = *out * 16 + (*in - '0');
+	    else if ((*in >= 'a') && (*in <= 'f'))
+	        *out = *out * 16 + (*in - 'a') + 10;
+	    else if ((*in >= 'A') && (*in <= 'F'))
+	        *out = *out * 16 + (*in - 'A') + 10;
+	    in++;
+	    len -= 3;
+	    out++;
+	} else {
+	    *out++ = *in++;
+	    len--;
+	}
+    }
+    *out = 0;
+    return(ret);
+}
+
+/**
+ * xmlURIEscapeStr:
+ * @str:  string to escape
+ * @list: exception list string of chars not to escape
+ *
+ * This routine escapes a string to hex, ignoring reserved characters (a-z)
+ * and the characters in the exception list.
+ *
+ * Returns a new escaped string or NULL in case of error.
+ */
+xmlChar *
+xmlURIEscapeStr(const xmlChar *str, const xmlChar *list) {
+    xmlChar *ret, ch;
+    const xmlChar *in;
+
+    unsigned int len, out;
+
+    if (str == NULL)
+	return(NULL);
+    len = xmlStrlen(str);
+    if (!(len > 0)) return(NULL);
+
+    len += 20;
+    ret = (xmlChar *) xmlMallocAtomic(len);
+    if (ret == NULL) {
+	xmlGenericError(xmlGenericErrorContext,
+		"xmlURIEscapeStr: out of memory\n");
+	return(NULL);
+    }
+    in = (const xmlChar *) str;
+    out = 0;
+    while(*in != 0) {
+	if (len - out <= 3) {
+	    len += 20;
+	    ret = (xmlChar *) xmlRealloc(ret, len);
+	    if (ret == NULL) {
+		xmlGenericError(xmlGenericErrorContext,
+			"xmlURIEscapeStr: out of memory\n");
+		return(NULL);
+	    }
+	}
+
+	ch = *in;
+
+	if ((ch != '@') && (!IS_UNRESERVED(ch)) && (!xmlStrchr(list, ch))) {
+	    unsigned char val;
+	    ret[out++] = '%';
+	    val = ch >> 4;
+	    if (val <= 9)
+		ret[out++] = '0' + val;
+	    else
+		ret[out++] = 'A' + val - 0xA;
+	    val = ch & 0xF;
+	    if (val <= 9)
+		ret[out++] = '0' + val;
+	    else
+		ret[out++] = 'A' + val - 0xA;
+	    in++;
+	} else {
+	    ret[out++] = *in++;
+	}
+
+    }
+    ret[out] = 0;
+    return(ret);
+}
+
+/**
+ * xmlURIEscape:
+ * @str:  the string of the URI to escape
+ *
+ * Escaping routine, does not do validity checks !
+ * It will try to escape the chars needing this, but this is heuristic
+ * based it's impossible to be sure.
+ *
+ * Returns an copy of the string, but escaped
+ *
+ * 25 May 2001
+ * Uses xmlParseURI and xmlURIEscapeStr to try to escape correctly
+ * according to RFC2396.
+ *   - Carl Douglas
+ */
+xmlChar *
+xmlURIEscape(const xmlChar * str)
+{
+    xmlChar *ret, *segment = NULL;
+    xmlURIPtr uri;
+    int ret2;
+
+#define NULLCHK(p) if(!p) { \
+                   xmlGenericError(xmlGenericErrorContext, \
+                        "xmlURIEscape: out of memory\n"); \
+                   return NULL; }
+
+    if (str == NULL)
+        return (NULL);
+
+    uri = xmlCreateURI();
+    if (uri != NULL) {
+	/*
+	 * Allow escaping errors in the unescaped form
+	 */
+        uri->cleanup = 1;
+        ret2 = xmlParseURIReference(uri, (const char *)str);
+        if (ret2) {
+            xmlFreeURI(uri);
+            return (NULL);
+        }
+    }
+
+    if (!uri)
+        return NULL;
+
+    ret = NULL;
+
+    if (uri->scheme) {
+        segment = xmlURIEscapeStr(BAD_CAST uri->scheme, BAD_CAST "+-.");
+        NULLCHK(segment)
+        ret = xmlStrcat(ret, segment);
+        ret = xmlStrcat(ret, BAD_CAST ":");
+        xmlFree(segment);
+    }
+
+    if (uri->authority) {
+        segment =
+            xmlURIEscapeStr(BAD_CAST uri->authority, BAD_CAST "/?;:@");
+        NULLCHK(segment)
+        ret = xmlStrcat(ret, BAD_CAST "//");
+        ret = xmlStrcat(ret, segment);
+        xmlFree(segment);
+    }
+
+    if (uri->user) {
+        segment = xmlURIEscapeStr(BAD_CAST uri->user, BAD_CAST ";:&=+$,");
+        NULLCHK(segment)
+		ret = xmlStrcat(ret,BAD_CAST "//");	
+        ret = xmlStrcat(ret, segment);
+        ret = xmlStrcat(ret, BAD_CAST "@");
+        xmlFree(segment);
+    }
+
+    if (uri->server) {
+        segment = xmlURIEscapeStr(BAD_CAST uri->server, BAD_CAST "/?;:@");
+        NULLCHK(segment)
+		if (uri->user == NULL)
+       		ret = xmlStrcat(ret, BAD_CAST "//");
+        ret = xmlStrcat(ret, segment);
+        xmlFree(segment);
+    }
+
+    if (uri->port) {
+        xmlChar port[10];
+
+        snprintf((char *) port, 10, "%d", uri->port);
+        ret = xmlStrcat(ret, BAD_CAST ":");
+        ret = xmlStrcat(ret, port);
+    }
+
+    if (uri->path) {
+        segment =
+            xmlURIEscapeStr(BAD_CAST uri->path, BAD_CAST ":@&=+$,/?;");
+        NULLCHK(segment)
+        ret = xmlStrcat(ret, segment);
+        xmlFree(segment);
+    }
+
+    if (uri->query) {
+        segment =
+            xmlURIEscapeStr(BAD_CAST uri->query, BAD_CAST ";/?:@&=+,$");
+        NULLCHK(segment)
+        ret = xmlStrcat(ret, BAD_CAST "?");
+        ret = xmlStrcat(ret, segment);
+        xmlFree(segment);
+    }
+
+    if (uri->opaque) {
+        segment = xmlURIEscapeStr(BAD_CAST uri->opaque, BAD_CAST "");
+        NULLCHK(segment)
+        ret = xmlStrcat(ret, segment);
+        xmlFree(segment);
+    }
+
+    if (uri->fragment) {
+        segment = xmlURIEscapeStr(BAD_CAST uri->fragment, BAD_CAST "#");
+        NULLCHK(segment)
+        ret = xmlStrcat(ret, BAD_CAST "#");
+        ret = xmlStrcat(ret, segment);
+        xmlFree(segment);
+    }
+
+    xmlFreeURI(uri);
+#undef NULLCHK
+
+    return (ret);
+}
+
+/************************************************************************
+ *									*
+ *			Escaped URI parsing				*
+ *									*
+ ************************************************************************/
+
+/**
+ * xmlParseURIFragment:
+ * @uri:  pointer to an URI structure
+ * @str:  pointer to the string to analyze
+ *
+ * Parse an URI fragment string and fills in the appropriate fields
+ * of the @uri structure.
+ * 
+ * fragment = *uric
+ *
+ * Returns 0 or the error code
+ */
+static int
+xmlParseURIFragment(xmlURIPtr uri, const char **str)
+{
+    const char *cur = *str;
+
+    if (str == NULL)
+        return (-1);
+
+    while (IS_URIC(cur) || IS_UNWISE(cur))
+        NEXT(cur);
+    if (uri != NULL) {
+        if (uri->fragment != NULL)
+            xmlFree(uri->fragment);
+        uri->fragment = xmlURIUnescapeString(*str, cur - *str, NULL);
+    }
+    *str = cur;
+    return (0);
+}
+
+/**
+ * xmlParseURIQuery:
+ * @uri:  pointer to an URI structure
+ * @str:  pointer to the string to analyze
+ *
+ * Parse the query part of an URI
+ * 
+ * query = *uric
+ *
+ * Returns 0 or the error code
+ */
+static int
+xmlParseURIQuery(xmlURIPtr uri, const char **str)
+{
+    const char *cur = *str;
+
+    if (str == NULL)
+        return (-1);
+
+    while (IS_URIC(cur) || ((uri != NULL) && (uri->cleanup) && (IS_UNWISE(cur))))
+        NEXT(cur);
+    if (uri != NULL) {
+        if (uri->query != NULL)
+            xmlFree(uri->query);
+        uri->query = xmlURIUnescapeString(*str, cur - *str, NULL);
+    }
+    *str = cur;
+    return (0);
+}
+
+/**
+ * xmlParseURIScheme:
+ * @uri:  pointer to an URI structure
+ * @str:  pointer to the string to analyze
+ *
+ * Parse an URI scheme
+ * 
+ * scheme = alpha *( alpha | digit | "+" | "-" | "." )
+ *
+ * Returns 0 or the error code
+ */
+static int
+xmlParseURIScheme(xmlURIPtr uri, const char **str) {
+    const char *cur;
+
+    if (str == NULL)
+	return(-1);
+    
+    cur = *str;
+    if (!IS_ALPHA(*cur))
+	return(2);
+    cur++;
+    while (IS_SCHEME(*cur)) cur++;
+    if (uri != NULL) {
+	if (uri->scheme != NULL) xmlFree(uri->scheme);
+	/* !!! strndup */
+	uri->scheme = xmlURIUnescapeString(*str, cur - *str, NULL);
+    }
+    *str = cur;
+    return(0);
+}
+
+/**
+ * xmlParseURIOpaquePart:
+ * @uri:  pointer to an URI structure
+ * @str:  pointer to the string to analyze
+ *
+ * Parse an URI opaque part
+ * 
+ * opaque_part = uric_no_slash *uric
+ *
+ * Returns 0 or the error code
+ */
+static int
+xmlParseURIOpaquePart(xmlURIPtr uri, const char **str)
+{
+    const char *cur;
+
+    if (str == NULL)
+        return (-1);
+
+    cur = *str;
+    if (!(IS_URIC_NO_SLASH(cur) || ((uri != NULL) && (uri->cleanup) && (IS_UNWISE(cur))))) {
+        return (3);
+    }
+    NEXT(cur);
+    while (IS_URIC(cur) || ((uri != NULL) && (uri->cleanup) && (IS_UNWISE(cur))))
+        NEXT(cur);
+    if (uri != NULL) {
+        if (uri->opaque != NULL)
+            xmlFree(uri->opaque);
+        uri->opaque = xmlURIUnescapeString(*str, cur - *str, NULL);
+    }
+    *str = cur;
+    return (0);
+}
+
+/**
+ * xmlParseURIServer:
+ * @uri:  pointer to an URI structure
+ * @str:  pointer to the string to analyze
+ *
+ * Parse a server subpart of an URI, it's a finer grain analysis
+ * of the authority part.
+ * 
+ * server        = [ [ userinfo "@" ] hostport ]
+ * userinfo      = *( unreserved | escaped |
+ *                       ";" | ":" | "&" | "=" | "+" | "$" | "," )
+ * hostport      = host [ ":" port ]
+ * host          = hostname | IPv4address
+ * hostname      = *( domainlabel "." ) toplabel [ "." ]
+ * domainlabel   = alphanum | alphanum *( alphanum | "-" ) alphanum
+ * toplabel      = alpha | alpha *( alphanum | "-" ) alphanum
+ * IPv4address   = 1*digit "." 1*digit "." 1*digit "." 1*digit
+ * port          = *digit
+ *
+ * Returns 0 or the error code
+ */
+static int
+xmlParseURIServer(xmlURIPtr uri, const char **str) {
+    const char *cur;
+    const char *host, *tmp;
+    const int IPmax = 4;
+    int oct;
+
+    if (str == NULL)
+	return(-1);
+    
+    cur = *str;
+
+    /*
+     * is there an userinfo ?
+     */
+    while (IS_USERINFO(cur)) NEXT(cur);
+    if (*cur == '@') {
+	if (uri != NULL) {
+	    if (uri->user != NULL) xmlFree(uri->user);
+	    uri->user = xmlURIUnescapeString(*str, cur - *str, NULL);
+	}
+	cur++;
+    } else {
+	if (uri != NULL) {
+	    if (uri->user != NULL) xmlFree(uri->user);
+	    uri->user = NULL;
+	}
+        cur = *str;
+    }
+    /*
+     * This can be empty in the case where there is no server
+     */
+    host = cur;
+    if (*cur == '/') {
+	if (uri != NULL) {
+	    if (uri->authority != NULL) xmlFree(uri->authority);
+	    uri->authority = NULL;
+	    if (uri->server != NULL) xmlFree(uri->server);
+	    uri->server = NULL;
+	    uri->port = 0;
+	}
+	return(0);
+    }
+    /*
+     * host part of hostport can derive either an IPV4 address
+     * or an unresolved name. Check the IP first, it easier to detect
+     * errors if wrong one
+     */
+    for (oct = 0; oct < IPmax; ++oct) {
+        if (*cur == '.')
+            return(3); /* e.g. http://.xml/ or http://18.29..30/ */
+        while(IS_DIGIT(*cur)) cur++;
+        if (oct == (IPmax-1))
+            continue;
+        if (*cur != '.')
+	    break;
+        cur++;
+    }
+    if (oct < IPmax || (*cur == '.' && cur++) || IS_ALPHA(*cur)) {
+        /* maybe host_name */
+        if (!IS_ALPHANUM(*cur))
+            return(4); /* e.g. http://xml.$oft */
+        do {
+            do ++cur; while (IS_ALPHANUM(*cur));
+            if (*cur == '-') {
+	        --cur;
+                if (*cur == '.')
+                    return(5); /* e.g. http://xml.-soft */
+	        ++cur;
+		continue;
+            }
+    	    if (*cur == '.') {
+	        --cur;
+                if (*cur == '-')
+                    return(6); /* e.g. http://xml-.soft */
+                if (*cur == '.')
+                    return(7); /* e.g. http://xml..soft */
+	        ++cur;
+		continue;
+            }
+	    break;
+        } while (1);
+        tmp = cur;
+        if (tmp[-1] == '.')
+            --tmp; /* e.g. http://xml.$Oft/ */
+        do --tmp; while (tmp >= host && IS_ALPHANUM(*tmp));
+        if ((++tmp == host || tmp[-1] == '.') && !IS_ALPHA(*tmp))
+            return(8); /* e.g. http://xmlsOft.0rg/ */
+    }
+    if (uri != NULL) {
+	if (uri->authority != NULL) xmlFree(uri->authority);
+	uri->authority = NULL;
+	if (uri->server != NULL) xmlFree(uri->server);
+	uri->server = xmlURIUnescapeString(host, cur - host, NULL);
+    }
+    /*
+     * finish by checking for a port presence.
+     */
+    if (*cur == ':') {
+        cur++;
+	if (IS_DIGIT(*cur)) {
+	    if (uri != NULL)
+	        uri->port = 0;
+	    while (IS_DIGIT(*cur)) {
+	        if (uri != NULL)
+		    uri->port = uri->port * 10 + (*cur - '0');
+		cur++;
+	    }
+	}
+    }
+    *str = cur;
+    return(0);
+}	
+
+/**
+ * xmlParseURIRelSegment:
+ * @uri:  pointer to an URI structure
+ * @str:  pointer to the string to analyze
+ *
+ * Parse an URI relative segment
+ * 
+ * rel_segment = 1*( unreserved | escaped | ";" | "@" | "&" | "=" |
+ *                          "+" | "$" | "," )
+ *
+ * Returns 0 or the error code
+ */
+static int
+xmlParseURIRelSegment(xmlURIPtr uri, const char **str)
+{
+    const char *cur;
+
+    if (str == NULL)
+        return (-1);
+
+    cur = *str;
+    if (!(IS_SEGMENT(cur) || ((uri != NULL) && (uri->cleanup) && (IS_UNWISE(cur))))) {
+        return (3);
+    }
+    NEXT(cur);
+    while (IS_SEGMENT(cur) || ((uri != NULL) && (uri->cleanup) && (IS_UNWISE(cur))))
+        NEXT(cur);
+    if (uri != NULL) {
+        if (uri->path != NULL)
+            xmlFree(uri->path);
+        uri->path = xmlURIUnescapeString(*str, cur - *str, NULL);
+    }
+    *str = cur;
+    return (0);
+}
+
+/**
+ * xmlParseURIPathSegments:
+ * @uri:  pointer to an URI structure
+ * @str:  pointer to the string to analyze
+ * @slash:  should we add a leading slash
+ *
+ * Parse an URI set of path segments
+ * 
+ * path_segments = segment *( "/" segment )
+ * segment       = *pchar *( ";" param )
+ * param         = *pchar
+ *
+ * Returns 0 or the error code
+ */
+static int
+xmlParseURIPathSegments(xmlURIPtr uri, const char **str, int slash)
+{
+    const char *cur;
+
+    if (str == NULL)
+        return (-1);
+
+    cur = *str;
+
+    do {
+        while (IS_PCHAR(cur) || ((uri != NULL) && (uri->cleanup) && (IS_UNWISE(cur))))
+            NEXT(cur);
+        while (*cur == ';') {
+            cur++;
+            while (IS_PCHAR(cur) || ((uri != NULL) && (uri->cleanup) && (IS_UNWISE(cur))))
+                NEXT(cur);
+        }
+        if (*cur != '/')
+            break;
+        cur++;
+    } while (1);
+    if (uri != NULL) {
+        int len, len2 = 0;
+        char *path;
+
+        /*
+         * Concat the set of path segments to the current path
+         */
+        len = cur - *str;
+        if (slash)
+            len++;
+
+        if (uri->path != NULL) {
+            len2 = strlen(uri->path);
+            len += len2;
+        }
+        path = (char *) xmlMallocAtomic(len + 1);
+        if (path == NULL) {
+            xmlGenericError(xmlGenericErrorContext,
+                            "xmlParseURIPathSegments: out of memory\n");
+            *str = cur;
+            return (-1);
+        }
+        if (uri->path != NULL)
+            memcpy(path, uri->path, len2);
+        if (slash) {
+            path[len2] = '/';
+            len2++;
+        }
+        path[len2] = 0;
+        if (cur - *str > 0)
+            xmlURIUnescapeString(*str, cur - *str, &path[len2]);
+        if (uri->path != NULL)
+            xmlFree(uri->path);
+        uri->path = path;
+    }
+    *str = cur;
+    return (0);
+}
+
+/**
+ * xmlParseURIAuthority:
+ * @uri:  pointer to an URI structure
+ * @str:  pointer to the string to analyze
+ *
+ * Parse the authority part of an URI.
+ * 
+ * authority = server | reg_name
+ * server    = [ [ userinfo "@" ] hostport ]
+ * reg_name  = 1*( unreserved | escaped | "$" | "," | ";" | ":" |
+ *                        "@" | "&" | "=" | "+" )
+ *
+ * Note : this is completely ambiguous since reg_name is allowed to
+ *        use the full set of chars in use by server:
+ *
+ *        3.2.1. Registry-based Naming Authority
+ *
+ *        The structure of a registry-based naming authority is specific
+ *        to the URI scheme, but constrained to the allowed characters
+ *        for an authority component.
+ *
+ * Returns 0 or the error code
+ */
+static int
+xmlParseURIAuthority(xmlURIPtr uri, const char **str) {
+    const char *cur;
+    int ret;
+
+    if (str == NULL)
+	return(-1);
+    
+    cur = *str;
+
+    /*
+     * try first to parse it as a server string.
+     */
+    ret = xmlParseURIServer(uri, str);
+    if ((ret == 0) && (*str != NULL) &&
+	((**str == 0) || (**str == '/') || (**str == '?')))
+        return(0);
+    *str = cur;
+
+    /*
+     * failed, fallback to reg_name
+     */
+    if (!IS_REG_NAME(cur)) {
+	return(5);
+    }
+    NEXT(cur);
+    while (IS_REG_NAME(cur)) NEXT(cur);
+    if (uri != NULL) {
+	if (uri->server != NULL) xmlFree(uri->server);
+	uri->server = NULL;
+	if (uri->user != NULL) xmlFree(uri->user);
+	uri->user = NULL;
+	if (uri->authority != NULL) xmlFree(uri->authority);
+	uri->authority = xmlURIUnescapeString(*str, cur - *str, NULL);
+    }
+    *str = cur;
+    return(0);
+}
+
+/**
+ * xmlParseURIHierPart:
+ * @uri:  pointer to an URI structure
+ * @str:  pointer to the string to analyze
+ *
+ * Parse an URI hierarchical part
+ * 
+ * hier_part = ( net_path | abs_path ) [ "?" query ]
+ * abs_path = "/"  path_segments
+ * net_path = "//" authority [ abs_path ]
+ *
+ * Returns 0 or the error code
+ */
+static int
+xmlParseURIHierPart(xmlURIPtr uri, const char **str) {
+    int ret;
+    const char *cur;
+
+    if (str == NULL)
+	return(-1);
+    
+    cur = *str;
+
+    if ((cur[0] == '/') && (cur[1] == '/')) {
+	cur += 2;
+	ret = xmlParseURIAuthority(uri, &cur);
+	if (ret != 0)
+	    return(ret);
+	if (cur[0] == '/') {
+	    cur++;
+	    ret = xmlParseURIPathSegments(uri, &cur, 1);
+	}
+    } else if (cur[0] == '/') {
+	cur++;
+	ret = xmlParseURIPathSegments(uri, &cur, 1);
+    } else {
+	return(4);
+    }
+    if (ret != 0)
+	return(ret);
+    if (*cur == '?') {
+	cur++;
+	ret = xmlParseURIQuery(uri, &cur);
+	if (ret != 0)
+	    return(ret);
+    }
+    *str = cur;
+    return(0);
+}
+
+/**
+ * xmlParseAbsoluteURI:
+ * @uri:  pointer to an URI structure
+ * @str:  pointer to the string to analyze
+ *
+ * Parse an URI reference string and fills in the appropriate fields
+ * of the @uri structure
+ * 
+ * absoluteURI   = scheme ":" ( hier_part | opaque_part )
+ *
+ * Returns 0 or the error code
+ */
+static int
+xmlParseAbsoluteURI(xmlURIPtr uri, const char **str) {
+    int ret;
+    const char *cur;
+
+    if (str == NULL)
+	return(-1);
+    
+    cur = *str;
+
+    ret = xmlParseURIScheme(uri, str);
+    if (ret != 0) return(ret);
+    if (**str != ':') {
+	*str = cur;
+	return(1);
+    }
+    (*str)++;
+    if (**str == '/')
+	return(xmlParseURIHierPart(uri, str));
+    return(xmlParseURIOpaquePart(uri, str));
+}
+
+/**
+ * xmlParseRelativeURI:
+ * @uri:  pointer to an URI structure
+ * @str:  pointer to the string to analyze
+ *
+ * Parse an relative URI string and fills in the appropriate fields
+ * of the @uri structure
+ * 
+ * relativeURI = ( net_path | abs_path | rel_path ) [ "?" query ]
+ * abs_path = "/"  path_segments
+ * net_path = "//" authority [ abs_path ]
+ * rel_path = rel_segment [ abs_path ]
+ *
+ * Returns 0 or the error code
+ */
+static int
+xmlParseRelativeURI(xmlURIPtr uri, const char **str) {
+    int ret = 0;
+    const char *cur;
+
+    if (str == NULL)
+	return(-1);
+    
+    cur = *str;
+    if ((cur[0] == '/') && (cur[1] == '/')) {
+	cur += 2;
+	ret = xmlParseURIAuthority(uri, &cur);
+	if (ret != 0)
+	    return(ret);
+	if (cur[0] == '/') {
+	    cur++;
+	    ret = xmlParseURIPathSegments(uri, &cur, 1);
+	}
+    } else if (cur[0] == '/') {
+	cur++;
+	ret = xmlParseURIPathSegments(uri, &cur, 1);
+    } else if (cur[0] != '#' && cur[0] != '?') {
+	ret = xmlParseURIRelSegment(uri, &cur);
+	if (ret != 0)
+	    return(ret);
+	if (cur[0] == '/') {
+	    cur++;
+	    ret = xmlParseURIPathSegments(uri, &cur, 1);
+	}
+    }
+    if (ret != 0)
+	return(ret);
+    if (*cur == '?') {
+	cur++;
+	ret = xmlParseURIQuery(uri, &cur);
+	if (ret != 0)
+	    return(ret);
+    }
+    *str = cur;
+    return(ret);
+}
+
+/**
+ * xmlParseURIReference:
+ * @uri:  pointer to an URI structure
+ * @str:  the string to analyze
+ *
+ * Parse an URI reference string and fills in the appropriate fields
+ * of the @uri structure
+ * 
+ * URI-reference = [ absoluteURI | relativeURI ] [ "#" fragment ]
+ *
+ * Returns 0 or the error code
+ */
+int
+xmlParseURIReference(xmlURIPtr uri, const char *str) {
+    int ret;
+    const char *tmp = str;
+
+    if (str == NULL)
+	return(-1);
+    xmlCleanURI(uri);
+
+    /*
+     * Try first to parse absolute refs, then fallback to relative if
+     * it fails.
+     */
+    ret = xmlParseAbsoluteURI(uri, &str);
+    if (ret != 0) {
+	xmlCleanURI(uri);
+	str = tmp;
+        ret = xmlParseRelativeURI(uri, &str);
+    }
+    if (ret != 0) {
+	xmlCleanURI(uri);
+	return(ret);
+    }
+
+    if (*str == '#') {
+	str++;
+	ret = xmlParseURIFragment(uri, &str);
+	if (ret != 0) return(ret);
+    }
+    if (*str != 0) {
+	xmlCleanURI(uri);
+	return(1);
+    }
+    return(0);
+}
+
+/**
+ * xmlParseURI:
+ * @str:  the URI string to analyze
+ *
+ * Parse an URI 
+ * 
+ * URI-reference = [ absoluteURI | relativeURI ] [ "#" fragment ]
+ *
+ * Returns a newly build xmlURIPtr or NULL in case of error
+ */
+xmlURIPtr
+xmlParseURI(const char *str) {
+    xmlURIPtr uri;
+    int ret;
+
+    if (str == NULL)
+	return(NULL);
+    uri = xmlCreateURI();
+    if (uri != NULL) {
+	ret = xmlParseURIReference(uri, str);
+        if (ret) {
+	    xmlFreeURI(uri);
+	    return(NULL);
+	}
+    }
+    return(uri);
+}
+
+/************************************************************************
+ *									*
+ *			Public functions				*
+ *									*
+ ************************************************************************/
+
+/**
+ * xmlBuildURI:
+ * @URI:  the URI instance found in the document
+ * @base:  the base value
+ *
+ * Computes he final URI of the reference done by checking that
+ * the given URI is valid, and building the final URI using the
+ * base URI. This is processed according to section 5.2 of the 
+ * RFC 2396
+ *
+ * 5.2. Resolving Relative References to Absolute Form
+ *
+ * Returns a new URI string (to be freed by the caller) or NULL in case
+ *         of error.
+ */
+xmlChar *
+xmlBuildURI(const xmlChar *URI, const xmlChar *base) {
+    xmlChar *val = NULL;
+    int ret, len, indx, cur, out;
+    xmlURIPtr ref = NULL;
+    xmlURIPtr bas = NULL;
+    xmlURIPtr res = NULL;
+
+    /*
+     * 1) The URI reference is parsed into the potential four components and
+     *    fragment identifier, as described in Section 4.3.
+     *
+     *    NOTE that a completely empty URI is treated by modern browsers
+     *    as a reference to "." rather than as a synonym for the current
+     *    URI.  Should we do that here?
+     */
+    if (URI == NULL) 
+	ret = -1;
+    else {
+	if (*URI) {
+	    ref = xmlCreateURI();
+	    if (ref == NULL)
+		goto done;
+	    ret = xmlParseURIReference(ref, (const char *) URI);
+	}
+	else
+	    ret = 0;
+    }
+    if (ret != 0)
+	goto done;
+    if ((ref != NULL) && (ref->scheme != NULL)) {
+	/*
+	 * The URI is absolute don't modify.
+	 */
+	val = xmlStrdup(URI);
+	goto done;
+    }
+    if (base == NULL)
+	ret = -1;
+    else {
+	bas = xmlCreateURI();
+	if (bas == NULL)
+	    goto done;
+	ret = xmlParseURIReference(bas, (const char *) base);
+    }
+    if (ret != 0) {
+	if (ref)
+	    val = xmlSaveUri(ref);
+	goto done;
+    }
+    if (ref == NULL) {
+	/*
+	 * the base fragment must be ignored
+	 */
+	if (bas->fragment != NULL) {
+	    xmlFree(bas->fragment);
+	    bas->fragment = NULL;
+	}
+	val = xmlSaveUri(bas);
+	goto done;
+    }
+
+    /*
+     * 2) If the path component is empty and the scheme, authority, and
+     *    query components are undefined, then it is a reference to the
+     *    current document and we are done.  Otherwise, the reference URI's
+     *    query and fragment components are defined as found (or not found)
+     *    within the URI reference and not inherited from the base URI.
+     *
+     *    NOTE that in modern browsers, the parsing differs from the above
+     *    in the following aspect:  the query component is allowed to be
+     *    defined while still treating this as a reference to the current
+     *    document.
+     */
+    res = xmlCreateURI();
+    if (res == NULL)
+	goto done;
+    if ((ref->scheme == NULL) && (ref->path == NULL) &&
+	((ref->authority == NULL) && (ref->server == NULL))) {
+	if (bas->scheme != NULL)
+	    res->scheme = xmlMemStrdup(bas->scheme);
+	if (bas->authority != NULL)
+	    res->authority = xmlMemStrdup(bas->authority);
+	else if (bas->server != NULL) {
+	    res->server = xmlMemStrdup(bas->server);
+	    if (bas->user != NULL)
+		res->user = xmlMemStrdup(bas->user);
+	    res->port = bas->port;		
+	}
+	if (bas->path != NULL)
+	    res->path = xmlMemStrdup(bas->path);
+	if (ref->query != NULL)
+	    res->query = xmlMemStrdup(ref->query);
+	else if (bas->query != NULL)
+	    res->query = xmlMemStrdup(bas->query);
+	if (ref->fragment != NULL)
+	    res->fragment = xmlMemStrdup(ref->fragment);
+	goto step_7;
+    }
+
+    /*
+     * 3) If the scheme component is defined, indicating that the reference
+     *    starts with a scheme name, then the reference is interpreted as an
+     *    absolute URI and we are done.  Otherwise, the reference URI's
+     *    scheme is inherited from the base URI's scheme component.
+     */
+    if (ref->scheme != NULL) {
+	val = xmlSaveUri(ref);
+	goto done;
+    }
+    if (bas->scheme != NULL)
+	res->scheme = xmlMemStrdup(bas->scheme);
+ 
+    if (ref->query != NULL)
+	res->query = xmlMemStrdup(ref->query);
+    if (ref->fragment != NULL)
+	res->fragment = xmlMemStrdup(ref->fragment);
+
+    /*
+     * 4) If the authority component is defined, then the reference is a
+     *    network-path and we skip to step 7.  Otherwise, the reference
+     *    URI's authority is inherited from the base URI's authority
+     *    component, which will also be undefined if the URI scheme does not
+     *    use an authority component.
+     */
+    if ((ref->authority != NULL) || (ref->server != NULL)) {
+	if (ref->authority != NULL)
+	    res->authority = xmlMemStrdup(ref->authority);
+	else {
+	    res->server = xmlMemStrdup(ref->server);
+	    if (ref->user != NULL)
+		res->user = xmlMemStrdup(ref->user);
+            res->port = ref->port;		
+	}
+	if (ref->path != NULL)
+	    res->path = xmlMemStrdup(ref->path);
+	goto step_7;
+    }
+    if (bas->authority != NULL)
+	res->authority = xmlMemStrdup(bas->authority);
+    else if (bas->server != NULL) {
+	res->server = xmlMemStrdup(bas->server);
+	if (bas->user != NULL)
+	    res->user = xmlMemStrdup(bas->user);
+	res->port = bas->port;		
+    }
+
+    /*
+     * 5) If the path component begins with a slash character ("/"), then
+     *    the reference is an absolute-path and we skip to step 7.
+     */
+    if ((ref->path != NULL) && (ref->path[0] == '/')) {
+	res->path = xmlMemStrdup(ref->path);
+	goto step_7;
+    }
+
+
+    /*
+     * 6) If this step is reached, then we are resolving a relative-path
+     *    reference.  The relative path needs to be merged with the base
+     *    URI's path.  Although there are many ways to do this, we will
+     *    describe a simple method using a separate string buffer.
+     *
+     * Allocate a buffer large enough for the result string.
+     */
+    len = 2; /* extra / and 0 */
+    if (ref->path != NULL)
+	len += strlen(ref->path);
+    if (bas->path != NULL)
+	len += strlen(bas->path);
+    res->path = (char *) xmlMallocAtomic(len);
+    if (res->path == NULL) {
+	xmlGenericError(xmlGenericErrorContext,
+		"xmlBuildURI: out of memory\n");
+	goto done;
+    }
+    res->path[0] = 0;
+
+    /*
+     * a) All but the last segment of the base URI's path component is
+     *    copied to the buffer.  In other words, any characters after the
+     *    last (right-most) slash character, if any, are excluded.
+     */
+    cur = 0;
+    out = 0;
+    if (bas->path != NULL) {
+	while (bas->path[cur] != 0) {
+	    while ((bas->path[cur] != 0) && (bas->path[cur] != '/'))
+		cur++;
+	    if (bas->path[cur] == 0)
+		break;
+
+	    cur++;
+	    while (out < cur) {
+		res->path[out] = bas->path[out];
+		out++;
+	    }
+	}
+    }
+    res->path[out] = 0;
+
+    /*
+     * b) The reference's path component is appended to the buffer
+     *    string.
+     */
+    if (ref->path != NULL && ref->path[0] != 0) {
+	indx = 0;
+	/*
+	 * Ensure the path includes a '/'
+	 */
+	if ((out == 0) && (bas->server != NULL))
+	    res->path[out++] = '/';
+	while (ref->path[indx] != 0) {
+	    res->path[out++] = ref->path[indx++];
+	}
+    }
+    res->path[out] = 0;
+
+    /*
+     * Steps c) to h) are really path normalization steps
+     */
+    xmlNormalizeURIPath(res->path);
+
+step_7:
+
+    /*
+     * 7) The resulting URI components, including any inherited from the
+     *    base URI, are recombined to give the absolute form of the URI
+     *    reference.
+     */
+    val = xmlSaveUri(res);
+
+done:
+    if (ref != NULL)
+	xmlFreeURI(ref);
+    if (bas != NULL)
+	xmlFreeURI(bas);
+    if (res != NULL)
+	xmlFreeURI(res);
+    return(val);
+}
+
+/**
+ * xmlCanonicPath:
+ * @path:  the resource locator in a filesystem notation
+ *
+ * Constructs a canonic path from the specified path. 
+ *
+ * Returns a new canonic path, or a duplicate of the path parameter if the 
+ * construction fails. The caller is responsible for freeing the memory occupied
+ * by the returned string. If there is insufficient memory available, or the 
+ * argument is NULL, the function returns NULL.
+ */
+#define IS_WINDOWS_PATH(p) 					\
+	((p != NULL) &&						\
+	 (((p[0] >= 'a') && (p[0] <= 'z')) ||			\
+	  ((p[0] >= 'A') && (p[0] <= 'Z'))) &&			\
+	 (p[1] == ':') && ((p[2] == '/') || (p[2] == '\\')))
+xmlChar*
+xmlCanonicPath(const xmlChar *path)
+{
+#if defined(_WIN32) && !defined(__CYGWIN__)    
+    int len = 0;
+    int i = 0;
+    xmlChar *p = NULL;
+#endif
+    xmlChar *ret;
+    xmlURIPtr uri;
+
+    if (path == NULL)
+	return(NULL);
+    if ((uri = xmlParseURI((const char *) path)) != NULL) {
+	xmlFreeURI(uri);
+	return xmlStrdup(path);
+    }
+
+    uri = xmlCreateURI();
+    if (uri == NULL) {
+        return(NULL);
+    }
+
+#if defined(_WIN32) && !defined(__CYGWIN__)    
+    len = xmlStrlen(path);
+    if ((len > 2) && IS_WINDOWS_PATH(path)) {
+	uri->scheme = xmlStrdup(BAD_CAST "file");
+	uri->path = xmlMallocAtomic(len + 2);
+	uri->path[0] = '/';
+	p = uri->path + 1;
+	strncpy(p, path, len + 1);
+    } else {
+	uri->path = xmlStrdup(path);
+	p = uri->path;
+    }
+    while (*p != '\0') {
+	if (*p == '\\')
+	    *p = '/';
+	p++;
+    }
+#else
+    uri->path = (char *) xmlStrdup((const xmlChar *) path);
+#endif
+    
+    ret = xmlSaveUri(uri);
+    xmlFreeURI(uri);
+    return(ret);
+}
+
diff --git a/src/libxml/src/valid.c b/src/libxml/src/valid.c
new file mode 100644
index 0000000..378338b
--- /dev/null
+++ b/src/libxml/src/valid.c
@@ -0,0 +1,6712 @@
+/*
+ * valid.c : part of the code use to do the DTD handling and the validity
+ *           checking
+ *
+ * See Copyright for the status of this software.
+ *
+ * daniel@veillard.com
+ */
+
+#define IN_LIBXML
+#include "libxml.h"
+
+#include <string.h>
+
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+
+#include <libxml/xmlmemory.h>
+#include <libxml/hash.h>
+#include <libxml/valid.h>
+#include <libxml/parser.h>
+#include <libxml/parserInternals.h>
+#include <libxml/xmlerror.h>
+#include <libxml/list.h>
+#include <libxml/globals.h>
+
+static xmlElementPtr xmlGetDtdElementDesc2(xmlDtdPtr dtd, const xmlChar *name,
+	                           int create);
+/* #define DEBUG_VALID_ALGO */
+/* #define DEBUG_REGEXP_ALGO */
+
+#define TODO 								\
+    xmlGenericError(xmlGenericErrorContext,				\
+	    "Unimplemented block at %s:%d\n",				\
+            __FILE__, __LINE__);
+
+/************************************************************************
+ *									*
+ *			Error handling routines				*
+ *									*
+ ************************************************************************/
+
+/**
+ * xmlVErrMemory:
+ * @ctxt:  an XML validation parser context
+ * @extra:  extra informations
+ *
+ * Handle an out of memory error
+ */
+static void
+xmlVErrMemory(xmlValidCtxtPtr ctxt, const char *extra)
+{
+    xmlGenericErrorFunc channel = NULL;
+    xmlParserCtxtPtr pctxt = NULL;
+    void *data = NULL;
+
+    if (ctxt != NULL) {
+        channel = ctxt->error;
+        data = ctxt->userData;
+	pctxt = ctxt->userData;
+    }
+    if (extra)
+        __xmlRaiseError(NULL, channel, data,
+                        pctxt, NULL, XML_FROM_VALID, XML_ERR_NO_MEMORY,
+                        XML_ERR_FATAL, NULL, 0, extra, NULL, NULL, 0, 0,
+                        "Memory allocation failed : %s\n", extra);
+    else
+        __xmlRaiseError(NULL, channel, data,
+                        pctxt, NULL, XML_FROM_VALID, XML_ERR_NO_MEMORY,
+                        XML_ERR_FATAL, NULL, 0, NULL, NULL, NULL, 0, 0,
+                        "Memory allocation failed\n");
+}
+
+/**
+ * xmlErrValid:
+ * @ctxt:  an XML validation parser context
+ * @error:  the error number
+ * @extra:  extra informations
+ *
+ * Handle a validation error
+ */
+static void
+xmlErrValid(xmlValidCtxtPtr ctxt, xmlParserErrors error,
+            const char *msg, const char *extra)
+{
+    xmlGenericErrorFunc channel = NULL;
+    xmlParserCtxtPtr pctxt = NULL;
+    void *data = NULL;
+
+    if (ctxt != NULL) {
+        channel = ctxt->error;
+        data = ctxt->userData;
+	pctxt = ctxt->userData;
+    }
+    if (extra)
+        __xmlRaiseError(NULL, channel, data,
+                        pctxt, NULL, XML_FROM_VALID, error,
+                        XML_ERR_ERROR, NULL, 0, extra, NULL, NULL, 0, 0,
+                        msg, extra);
+    else
+        __xmlRaiseError(NULL, channel, data,
+                        pctxt, NULL, XML_FROM_VALID, error,
+                        XML_ERR_ERROR, NULL, 0, NULL, NULL, NULL, 0, 0,
+                        msg);
+}
+
+#if defined(LIBXML_VALID_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
+/**
+ * xmlErrValidNode:
+ * @ctxt:  an XML validation parser context
+ * @node:  the node raising the error
+ * @error:  the error number
+ * @str1:  extra informations
+ * @str2:  extra informations
+ * @str3:  extra informations
+ *
+ * Handle a validation error, provide contextual informations
+ */
+static void
+xmlErrValidNode(xmlValidCtxtPtr ctxt,
+                xmlNodePtr node, xmlParserErrors error,
+                const char *msg, const xmlChar * str1,
+                const xmlChar * str2, const xmlChar * str3)
+{
+    xmlStructuredErrorFunc schannel = NULL;
+    xmlGenericErrorFunc channel = NULL;
+    xmlParserCtxtPtr pctxt = NULL;
+    void *data = NULL;
+
+    if (ctxt != NULL) {
+        channel = ctxt->error;
+        data = ctxt->userData;
+	pctxt = ctxt->userData;
+    }
+    __xmlRaiseError(schannel, channel, data, pctxt, node, XML_FROM_VALID, error,
+                    XML_ERR_ERROR, NULL, 0,
+                    (const char *) str1,
+                    (const char *) str1,
+                    (const char *) str3, 0, 0, msg, str1, str2, str3);
+}
+#endif /* LIBXML_VALID_ENABLED or LIBXML_SCHEMAS_ENABLED */
+
+#ifdef LIBXML_VALID_ENABLED
+/**
+ * xmlErrValidNodeNr:
+ * @ctxt:  an XML validation parser context
+ * @node:  the node raising the error
+ * @error:  the error number
+ * @str1:  extra informations
+ * @int2:  extra informations
+ * @str3:  extra informations
+ *
+ * Handle a validation error, provide contextual informations
+ */
+static void
+xmlErrValidNodeNr(xmlValidCtxtPtr ctxt,
+                xmlNodePtr node, xmlParserErrors error,
+                const char *msg, const xmlChar * str1,
+                int int2, const xmlChar * str3)
+{
+    xmlStructuredErrorFunc schannel = NULL;
+    xmlGenericErrorFunc channel = NULL;
+    xmlParserCtxtPtr pctxt = NULL;
+    void *data = NULL;
+
+    if (ctxt != NULL) {
+        channel = ctxt->error;
+        data = ctxt->userData;
+	pctxt = ctxt->userData;
+    }
+    __xmlRaiseError(schannel, channel, data, pctxt, node, XML_FROM_VALID, error,
+                    XML_ERR_ERROR, NULL, 0,
+                    (const char *) str1,
+                    (const char *) str3,
+                    NULL, int2, 0, msg, str1, int2, str3);
+}
+
+/**
+ * xmlErrValidWarning:
+ * @ctxt:  an XML validation parser context
+ * @node:  the node raising the error
+ * @error:  the error number
+ * @str1:  extra information
+ * @str2:  extra information
+ * @str3:  extra information
+ *
+ * Handle a validation error, provide contextual information
+ */
+static void
+xmlErrValidWarning(xmlValidCtxtPtr ctxt,
+                xmlNodePtr node, xmlParserErrors error,
+                const char *msg, const xmlChar * str1,
+                const xmlChar * str2, const xmlChar * str3)
+{
+    xmlStructuredErrorFunc schannel = NULL;
+    xmlGenericErrorFunc channel = NULL;
+    xmlParserCtxtPtr pctxt = NULL;
+    void *data = NULL;
+
+    if (ctxt != NULL) {
+        channel = ctxt->error;
+        data = ctxt->userData;
+	pctxt = ctxt->userData;
+    }
+    __xmlRaiseError(schannel, channel, data, pctxt, node, XML_FROM_VALID, error,
+                    XML_ERR_WARNING, NULL, 0,
+                    (const char *) str1,
+                    (const char *) str1,
+                    (const char *) str3, 0, 0, msg, str1, str2, str3);
+}
+
+
+
+#ifdef LIBXML_REGEXP_ENABLED
+/*
+ * If regexp are enabled we can do continuous validation without the
+ * need of a tree to validate the content model. this is done in each
+ * callbacks.
+ * Each xmlValidState represent the validation state associated to the
+ * set of nodes currently open from the document root to the current element.
+ */
+
+
+typedef struct _xmlValidState {
+    xmlElementPtr	 elemDecl;	/* pointer to the content model */
+    xmlNodePtr           node;		/* pointer to the current node */
+    xmlRegExecCtxtPtr    exec;		/* regexp runtime */
+} _xmlValidState;
+
+
+static int
+vstateVPush(xmlValidCtxtPtr ctxt, xmlElementPtr elemDecl, xmlNodePtr node) {
+    if ((ctxt->vstateMax == 0) || (ctxt->vstateTab == NULL)) {
+	ctxt->vstateMax = 10;
+	ctxt->vstateTab = (xmlValidState *) xmlMalloc(ctxt->vstateMax *
+		              sizeof(ctxt->vstateTab[0]));
+        if (ctxt->vstateTab == NULL) {
+	    xmlVErrMemory(ctxt, "malloc failed");
+	    return(-1);
+	}
+    }
+
+    if (ctxt->vstateNr >= ctxt->vstateMax) {
+        xmlValidState *tmp;
+
+	tmp = (xmlValidState *) xmlRealloc(ctxt->vstateTab,
+	             2 * ctxt->vstateMax * sizeof(ctxt->vstateTab[0]));
+        if (tmp == NULL) {
+	    xmlVErrMemory(ctxt, "realloc failed");
+	    return(-1);
+	}
+	ctxt->vstateMax *= 2;
+	ctxt->vstateTab = tmp;
+    }
+    ctxt->vstate = &ctxt->vstateTab[ctxt->vstateNr];
+    ctxt->vstateTab[ctxt->vstateNr].elemDecl = elemDecl;
+    ctxt->vstateTab[ctxt->vstateNr].node = node;
+    if ((elemDecl != NULL) && (elemDecl->etype == XML_ELEMENT_TYPE_ELEMENT)) {
+	if (elemDecl->contModel == NULL)
+	    xmlValidBuildContentModel(ctxt, elemDecl);
+	if (elemDecl->contModel != NULL) {
+	    ctxt->vstateTab[ctxt->vstateNr].exec = 
+		xmlRegNewExecCtxt(elemDecl->contModel, NULL, NULL);
+	} else {
+	    ctxt->vstateTab[ctxt->vstateNr].exec = NULL;
+	    xmlErrValidNode(ctxt, (xmlNodePtr) elemDecl,
+	                    XML_ERR_INTERNAL_ERROR,
+			    "Failed to build content model regexp for %s\n",
+			    node->name, NULL, NULL);
+	}
+    }
+    return(ctxt->vstateNr++);
+}
+
+static int
+vstateVPop(xmlValidCtxtPtr ctxt) {
+    xmlElementPtr elemDecl;
+
+    if (ctxt->vstateNr < 1) return(-1);
+    ctxt->vstateNr--;
+    elemDecl = ctxt->vstateTab[ctxt->vstateNr].elemDecl;
+    ctxt->vstateTab[ctxt->vstateNr].elemDecl = NULL;
+    ctxt->vstateTab[ctxt->vstateNr].node = NULL;
+    if ((elemDecl != NULL) && (elemDecl->etype == XML_ELEMENT_TYPE_ELEMENT)) {
+	xmlRegFreeExecCtxt(ctxt->vstateTab[ctxt->vstateNr].exec);
+    }
+    ctxt->vstateTab[ctxt->vstateNr].exec = NULL;
+    if (ctxt->vstateNr >= 1)
+	ctxt->vstate = &ctxt->vstateTab[ctxt->vstateNr - 1];
+    else
+	ctxt->vstate = NULL;
+    return(ctxt->vstateNr);
+}
+
+#else /* not LIBXML_REGEXP_ENABLED */
+/*
+ * If regexp are not enabled, it uses a home made algorithm less
+ * complex and easier to
+ * debug/maintain than a generic NFA -> DFA state based algo. The
+ * only restriction is on the deepness of the tree limited by the
+ * size of the occurs bitfield
+ *
+ * this is the content of a saved state for rollbacks
+ */
+
+#define ROLLBACK_OR	0
+#define ROLLBACK_PARENT	1
+
+typedef struct _xmlValidState {
+    xmlElementContentPtr cont;	/* pointer to the content model subtree */
+    xmlNodePtr           node;	/* pointer to the current node in the list */
+    long                 occurs;/* bitfield for multiple occurrences */
+    unsigned char        depth; /* current depth in the overall tree */
+    unsigned char        state; /* ROLLBACK_XXX */
+} _xmlValidState;
+
+#define MAX_RECURSE 25000
+#define MAX_DEPTH ((sizeof(_xmlValidState.occurs)) * 8)
+#define CONT ctxt->vstate->cont
+#define NODE ctxt->vstate->node
+#define DEPTH ctxt->vstate->depth
+#define OCCURS ctxt->vstate->occurs
+#define STATE ctxt->vstate->state
+
+#define OCCURRENCE (ctxt->vstate->occurs & (1 << DEPTH))
+#define PARENT_OCCURRENCE (ctxt->vstate->occurs & ((1 << DEPTH) - 1))
+
+#define SET_OCCURRENCE ctxt->vstate->occurs |= (1 << DEPTH)
+#define RESET_OCCURRENCE ctxt->vstate->occurs &= ((1 << DEPTH) - 1)
+
+static int
+vstateVPush(xmlValidCtxtPtr ctxt, xmlElementContentPtr cont,
+	    xmlNodePtr node, unsigned char depth, long occurs,
+	    unsigned char state) {
+    int i = ctxt->vstateNr - 1;
+
+    if (ctxt->vstateNr > MAX_RECURSE) {
+	return(-1);
+    }
+    if (ctxt->vstateTab == NULL) {
+	ctxt->vstateMax = 8;
+	ctxt->vstateTab = (xmlValidState *) xmlMalloc(
+		     ctxt->vstateMax * sizeof(ctxt->vstateTab[0]));
+	if (ctxt->vstateTab == NULL) {
+	    xmlVErrMemory(ctxt, "malloc failed");
+	    return(-1);
+	}
+    }
+    if (ctxt->vstateNr >= ctxt->vstateMax) {
+        xmlValidState *tmp;
+
+        tmp = (xmlValidState *) xmlRealloc(ctxt->vstateTab,
+	             2 * ctxt->vstateMax * sizeof(ctxt->vstateTab[0]));
+        if (tmp == NULL) {
+	    xmlVErrMemory(ctxt, "malloc failed");
+	    return(-1);
+	}
+	ctxt->vstateMax *= 2;
+	ctxt->vstateTab = tmp;
+	ctxt->vstate = &ctxt->vstateTab[0];
+    }
+    /*
+     * Don't push on the stack a state already here
+     */
+    if ((i >= 0) && (ctxt->vstateTab[i].cont == cont) &&
+	(ctxt->vstateTab[i].node == node) &&
+	(ctxt->vstateTab[i].depth == depth) &&
+	(ctxt->vstateTab[i].occurs == occurs) &&
+	(ctxt->vstateTab[i].state == state))
+	return(ctxt->vstateNr);
+    ctxt->vstateTab[ctxt->vstateNr].cont = cont;
+    ctxt->vstateTab[ctxt->vstateNr].node = node;
+    ctxt->vstateTab[ctxt->vstateNr].depth = depth;
+    ctxt->vstateTab[ctxt->vstateNr].occurs = occurs;
+    ctxt->vstateTab[ctxt->vstateNr].state = state;
+    return(ctxt->vstateNr++);
+}
+
+static int
+vstateVPop(xmlValidCtxtPtr ctxt) {
+    if (ctxt->vstateNr <= 1) return(-1);
+    ctxt->vstateNr--;
+    ctxt->vstate = &ctxt->vstateTab[0];
+    ctxt->vstate->cont =  ctxt->vstateTab[ctxt->vstateNr].cont;
+    ctxt->vstate->node = ctxt->vstateTab[ctxt->vstateNr].node;
+    ctxt->vstate->depth = ctxt->vstateTab[ctxt->vstateNr].depth;
+    ctxt->vstate->occurs = ctxt->vstateTab[ctxt->vstateNr].occurs;
+    ctxt->vstate->state = ctxt->vstateTab[ctxt->vstateNr].state;
+    return(ctxt->vstateNr);
+}
+
+#endif /* LIBXML_REGEXP_ENABLED */
+
+static int
+nodeVPush(xmlValidCtxtPtr ctxt, xmlNodePtr value)
+{
+    if (ctxt->nodeMax <= 0) {
+        ctxt->nodeMax = 4;
+        ctxt->nodeTab =
+            (xmlNodePtr *) xmlMalloc(ctxt->nodeMax *
+                                     sizeof(ctxt->nodeTab[0]));
+        if (ctxt->nodeTab == NULL) {
+	    xmlVErrMemory(ctxt, "malloc failed");
+            ctxt->nodeMax = 0;
+            return (0);
+        }
+    }
+    if (ctxt->nodeNr >= ctxt->nodeMax) {
+        xmlNodePtr *tmp;
+        tmp = (xmlNodePtr *) xmlRealloc(ctxt->nodeTab,
+			      ctxt->nodeMax * 2 * sizeof(ctxt->nodeTab[0]));
+        if (tmp == NULL) {
+	    xmlVErrMemory(ctxt, "realloc failed");
+            return (0);
+        }
+        ctxt->nodeMax *= 2;
+	ctxt->nodeTab = tmp;
+    }
+    ctxt->nodeTab[ctxt->nodeNr] = value;
+    ctxt->node = value;
+    return (ctxt->nodeNr++);
+}
+static xmlNodePtr
+nodeVPop(xmlValidCtxtPtr ctxt)
+{
+    xmlNodePtr ret;
+
+    if (ctxt->nodeNr <= 0)
+        return (0);
+    ctxt->nodeNr--;
+    if (ctxt->nodeNr > 0)
+        ctxt->node = ctxt->nodeTab[ctxt->nodeNr - 1];
+    else
+        ctxt->node = NULL;
+    ret = ctxt->nodeTab[ctxt->nodeNr];
+    ctxt->nodeTab[ctxt->nodeNr] = 0;
+    return (ret);
+}
+
+#ifdef DEBUG_VALID_ALGO
+static void
+xmlValidPrintNode(xmlNodePtr cur) {
+    if (cur == NULL) {
+	xmlGenericError(xmlGenericErrorContext, "null");
+	return;
+    }
+    switch (cur->type) {
+	case XML_ELEMENT_NODE:
+	    xmlGenericError(xmlGenericErrorContext, "%s ", cur->name);
+	    break;
+	case XML_TEXT_NODE:
+	    xmlGenericError(xmlGenericErrorContext, "text ");
+	    break;
+	case XML_CDATA_SECTION_NODE:
+	    xmlGenericError(xmlGenericErrorContext, "cdata ");
+	    break;
+	case XML_ENTITY_REF_NODE:
+	    xmlGenericError(xmlGenericErrorContext, "&%s; ", cur->name);
+	    break;
+	case XML_PI_NODE:
+	    xmlGenericError(xmlGenericErrorContext, "pi(%s) ", cur->name);
+	    break;
+	case XML_COMMENT_NODE:
+	    xmlGenericError(xmlGenericErrorContext, "comment ");
+	    break;
+	case XML_ATTRIBUTE_NODE:
+	    xmlGenericError(xmlGenericErrorContext, "?attr? ");
+	    break;
+	case XML_ENTITY_NODE:
+	    xmlGenericError(xmlGenericErrorContext, "?ent? ");
+	    break;
+	case XML_DOCUMENT_NODE:
+	    xmlGenericError(xmlGenericErrorContext, "?doc? ");
+	    break;
+	case XML_DOCUMENT_TYPE_NODE:
+	    xmlGenericError(xmlGenericErrorContext, "?doctype? ");
+	    break;
+	case XML_DOCUMENT_FRAG_NODE:
+	    xmlGenericError(xmlGenericErrorContext, "?frag? ");
+	    break;
+	case XML_NOTATION_NODE:
+	    xmlGenericError(xmlGenericErrorContext, "?nota? ");
+	    break;
+	case XML_HTML_DOCUMENT_NODE:
+	    xmlGenericError(xmlGenericErrorContext, "?html? ");
+	    break;
+#ifdef LIBXML_DOCB_ENABLED
+	case XML_DOCB_DOCUMENT_NODE:
+	    xmlGenericError(xmlGenericErrorContext, "?docb? ");
+	    break;
+#endif
+	case XML_DTD_NODE:
+	    xmlGenericError(xmlGenericErrorContext, "?dtd? ");
+	    break;
+	case XML_ELEMENT_DECL:
+	    xmlGenericError(xmlGenericErrorContext, "?edecl? ");
+	    break;
+	case XML_ATTRIBUTE_DECL:
+	    xmlGenericError(xmlGenericErrorContext, "?adecl? ");
+	    break;
+	case XML_ENTITY_DECL:
+	    xmlGenericError(xmlGenericErrorContext, "?entdecl? ");
+	    break;
+	case XML_NAMESPACE_DECL:
+	    xmlGenericError(xmlGenericErrorContext, "?nsdecl? ");
+	    break;
+	case XML_XINCLUDE_START:
+	    xmlGenericError(xmlGenericErrorContext, "incstart ");
+	    break;
+	case XML_XINCLUDE_END:
+	    xmlGenericError(xmlGenericErrorContext, "incend ");
+	    break;
+    }
+}
+
+static void
+xmlValidPrintNodeList(xmlNodePtr cur) {
+    if (cur == NULL)
+	xmlGenericError(xmlGenericErrorContext, "null ");
+    while (cur != NULL) {
+	xmlValidPrintNode(cur);
+	cur = cur->next;
+    }
+}
+
+static void
+xmlValidDebug(xmlNodePtr cur, xmlElementContentPtr cont) {
+    char expr[5000];
+
+    expr[0] = 0;
+    xmlGenericError(xmlGenericErrorContext, "valid: ");
+    xmlValidPrintNodeList(cur);
+    xmlGenericError(xmlGenericErrorContext, "against ");
+    xmlSnprintfElementContent(expr, 5000, cont, 1);
+    xmlGenericError(xmlGenericErrorContext, "%s\n", expr);
+}
+
+static void
+xmlValidDebugState(xmlValidStatePtr state) {
+    xmlGenericError(xmlGenericErrorContext, "(");
+    if (state->cont == NULL)
+	xmlGenericError(xmlGenericErrorContext, "null,");
+    else
+	switch (state->cont->type) {
+            case XML_ELEMENT_CONTENT_PCDATA:
+		xmlGenericError(xmlGenericErrorContext, "pcdata,");
+		break;
+            case XML_ELEMENT_CONTENT_ELEMENT:
+		xmlGenericError(xmlGenericErrorContext, "%s,",
+			        state->cont->name);
+		break;
+            case XML_ELEMENT_CONTENT_SEQ:
+		xmlGenericError(xmlGenericErrorContext, "seq,");
+		break;
+            case XML_ELEMENT_CONTENT_OR:
+		xmlGenericError(xmlGenericErrorContext, "or,");
+		break;
+	}
+    xmlValidPrintNode(state->node);
+    xmlGenericError(xmlGenericErrorContext, ",%d,%X,%d)",
+	    state->depth, state->occurs, state->state);
+}
+
+static void
+xmlValidStateDebug(xmlValidCtxtPtr ctxt) {
+    int i, j;
+
+    xmlGenericError(xmlGenericErrorContext, "state: ");
+    xmlValidDebugState(ctxt->vstate);
+    xmlGenericError(xmlGenericErrorContext, " stack: %d ",
+	    ctxt->vstateNr - 1);
+    for (i = 0, j = ctxt->vstateNr - 1;(i < 3) && (j > 0);i++,j--)
+	xmlValidDebugState(&ctxt->vstateTab[j]);
+    xmlGenericError(xmlGenericErrorContext, "\n");
+}
+
+/*****
+#define DEBUG_VALID_STATE(n,c) xmlValidDebug(n,c);
+ *****/
+
+#define DEBUG_VALID_STATE(n,c) xmlValidStateDebug(ctxt);
+#define DEBUG_VALID_MSG(m)					\
+    xmlGenericError(xmlGenericErrorContext, "%s\n", m);
+        
+#else
+#define DEBUG_VALID_STATE(n,c)
+#define DEBUG_VALID_MSG(m)
+#endif
+
+/* TODO: use hash table for accesses to elem and attribute definitions */
+
+
+#define CHECK_DTD						\
+   if (doc == NULL) return(0);					\
+   else if ((doc->intSubset == NULL) &&				\
+	    (doc->extSubset == NULL)) return(0)
+
+xmlAttributePtr xmlScanAttributeDecl(xmlDtdPtr dtd, const xmlChar *elem);
+
+#ifdef LIBXML_REGEXP_ENABLED
+
+/************************************************************************
+ *									*
+ *		Content model validation based on the regexps		*
+ *									*
+ ************************************************************************/
+
+/**
+ * xmlValidBuildAContentModel:
+ * @content:  the content model
+ * @ctxt:  the schema parser context
+ * @name:  the element name whose content is being built
+ *
+ * Generate the automata sequence needed for that type
+ *
+ * Returns 1 if successful or 0 in case of error.
+ */
+static int
+xmlValidBuildAContentModel(xmlElementContentPtr content,
+		           xmlValidCtxtPtr ctxt,
+		           const xmlChar *name) {
+    if (content == NULL) {
+	xmlErrValidNode(ctxt, NULL, XML_ERR_INTERNAL_ERROR,
+			"Found NULL content in content model of %s\n",
+			name, NULL, NULL);
+	return(0);
+    }
+    switch (content->type) {
+	case XML_ELEMENT_CONTENT_PCDATA:
+	    xmlErrValidNode(ctxt, NULL, XML_ERR_INTERNAL_ERROR,
+			    "Found PCDATA in content model of %s\n",
+		            name, NULL, NULL);
+	    return(0);
+	    break;
+	case XML_ELEMENT_CONTENT_ELEMENT: {
+	    xmlAutomataStatePtr oldstate = ctxt->state;
+	    xmlChar fn[50];
+	    xmlChar *fullname;
+	    
+	    fullname = xmlBuildQName(content->name, content->prefix, fn, 50);
+	    if (fullname == NULL) {
+	        xmlVErrMemory(ctxt, "Building content model");
+		return(0);
+	    }
+
+	    switch (content->ocur) {
+		case XML_ELEMENT_CONTENT_ONCE:
+		    ctxt->state = xmlAutomataNewTransition(ctxt->am,
+			    ctxt->state, NULL, fullname, NULL);
+		    break;
+		case XML_ELEMENT_CONTENT_OPT:
+		    ctxt->state = xmlAutomataNewTransition(ctxt->am,
+			    ctxt->state, NULL, fullname, NULL);
+		    xmlAutomataNewEpsilon(ctxt->am, oldstate, ctxt->state);
+		    break;
+		case XML_ELEMENT_CONTENT_PLUS:
+		    ctxt->state = xmlAutomataNewTransition(ctxt->am,
+			    ctxt->state, NULL, fullname, NULL);
+		    xmlAutomataNewTransition(ctxt->am, ctxt->state,
+			                     ctxt->state, fullname, NULL);
+		    break;
+		case XML_ELEMENT_CONTENT_MULT:
+		    ctxt->state = xmlAutomataNewEpsilon(ctxt->am,
+		    			    ctxt->state, NULL);
+		    xmlAutomataNewTransition(ctxt->am,
+		    	    ctxt->state, ctxt->state, fullname, NULL);
+		    break;
+	    }
+	    if ((fullname != fn) && (fullname != content->name))
+		xmlFree(fullname);
+	    break;
+	}
+	case XML_ELEMENT_CONTENT_SEQ: {
+	    xmlAutomataStatePtr oldstate, oldend;
+	    xmlElementContentOccur ocur;
+
+	    /*
+	     * Simply iterate over the content
+	     */
+	    oldstate = ctxt->state;
+	    ocur = content->ocur;
+	    if (ocur != XML_ELEMENT_CONTENT_ONCE) {
+		ctxt->state = xmlAutomataNewEpsilon(ctxt->am, oldstate, NULL);
+		oldstate = ctxt->state;
+	    }
+	    do {
+		xmlValidBuildAContentModel(content->c1, ctxt, name);
+		content = content->c2;
+	    } while ((content->type == XML_ELEMENT_CONTENT_SEQ) &&
+		     (content->ocur == XML_ELEMENT_CONTENT_ONCE));
+	    xmlValidBuildAContentModel(content, ctxt, name);
+	    oldend = ctxt->state;
+	    ctxt->state = xmlAutomataNewEpsilon(ctxt->am, oldend, NULL);
+	    switch (ocur) {
+		case XML_ELEMENT_CONTENT_ONCE:
+		    break;
+		case XML_ELEMENT_CONTENT_OPT:
+		    xmlAutomataNewEpsilon(ctxt->am, oldstate, ctxt->state);
+		    break;
+		case XML_ELEMENT_CONTENT_MULT:
+		    xmlAutomataNewEpsilon(ctxt->am, oldstate, ctxt->state);
+		    xmlAutomataNewEpsilon(ctxt->am, oldend, oldstate);
+		    break;
+		case XML_ELEMENT_CONTENT_PLUS:
+		    xmlAutomataNewEpsilon(ctxt->am, oldend, oldstate);
+		    break;
+	    }
+	    break;
+	}
+	case XML_ELEMENT_CONTENT_OR: {
+	    xmlAutomataStatePtr oldstate, oldend;
+	    xmlElementContentOccur ocur;
+
+	    ocur = content->ocur;
+	    if ((ocur == XML_ELEMENT_CONTENT_PLUS) || 
+		(ocur == XML_ELEMENT_CONTENT_MULT)) {
+		ctxt->state = xmlAutomataNewEpsilon(ctxt->am,
+			ctxt->state, NULL);
+	    }
+	    oldstate = ctxt->state;
+	    oldend = xmlAutomataNewState(ctxt->am);
+
+	    /*
+	     * iterate over the subtypes and remerge the end with an
+	     * epsilon transition
+	     */
+	    do {
+		ctxt->state = oldstate;
+		xmlValidBuildAContentModel(content->c1, ctxt, name);
+		xmlAutomataNewEpsilon(ctxt->am, ctxt->state, oldend);
+		content = content->c2;
+	    } while ((content->type == XML_ELEMENT_CONTENT_OR) &&
+		     (content->ocur == XML_ELEMENT_CONTENT_ONCE));
+	    ctxt->state = oldstate;
+	    xmlValidBuildAContentModel(content, ctxt, name);
+	    xmlAutomataNewEpsilon(ctxt->am, ctxt->state, oldend);
+	    ctxt->state = xmlAutomataNewEpsilon(ctxt->am, oldend, NULL);
+	    switch (ocur) {
+		case XML_ELEMENT_CONTENT_ONCE:
+		    break;
+		case XML_ELEMENT_CONTENT_OPT:
+		    xmlAutomataNewEpsilon(ctxt->am, oldstate, ctxt->state);
+		    break;
+		case XML_ELEMENT_CONTENT_MULT:
+		    xmlAutomataNewEpsilon(ctxt->am, oldstate, ctxt->state);
+		    xmlAutomataNewEpsilon(ctxt->am, oldend, oldstate);
+		    break;
+		case XML_ELEMENT_CONTENT_PLUS:
+		    xmlAutomataNewEpsilon(ctxt->am, oldend, oldstate);
+		    break;
+	    }
+	    break;
+	}
+	default:
+	    xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR,
+	                "ContentModel broken for element %s\n",
+			(const char *) name);
+	    return(0);
+    }
+    return(1);
+}
+/**
+ * xmlValidBuildContentModel:
+ * @ctxt:  a validation context
+ * @elem:  an element declaration node
+ *
+ * (Re)Build the automata associated to the content model of this
+ * element
+ *
+ * Returns 1 in case of success, 0 in case of error
+ */
+int
+xmlValidBuildContentModel(xmlValidCtxtPtr ctxt, xmlElementPtr elem) {
+
+    if ((ctxt == NULL) || (elem == NULL))
+	return(0);
+    if (elem->type != XML_ELEMENT_DECL)
+	return(0);
+    if (elem->etype != XML_ELEMENT_TYPE_ELEMENT)
+	return(1);
+    /* TODO: should we rebuild in this case ? */
+    if (elem->contModel != NULL) {
+	if (!xmlRegexpIsDeterminist(elem->contModel)) {
+	    ctxt->valid = 0;
+	    return(0);
+	}
+	return(1);
+    }
+
+    ctxt->am = xmlNewAutomata();
+    if (ctxt->am == NULL) {
+	xmlErrValidNode(ctxt, (xmlNodePtr) elem,
+	                XML_ERR_INTERNAL_ERROR,
+	                "Cannot create automata for element %s\n",
+		        elem->name, NULL, NULL);
+	return(0);
+    }
+    ctxt->state = xmlAutomataGetInitState(ctxt->am);
+    xmlValidBuildAContentModel(elem->content, ctxt, elem->name);
+    xmlAutomataSetFinalState(ctxt->am, ctxt->state);
+    elem->contModel = xmlAutomataCompile(ctxt->am);
+    if (xmlRegexpIsDeterminist(elem->contModel) != 1) {
+	char expr[5000];
+	expr[0] = 0;
+	xmlSnprintfElementContent(expr, 5000, elem->content, 1);
+	xmlErrValidNode(ctxt, (xmlNodePtr) elem,
+	                XML_DTD_CONTENT_NOT_DETERMINIST,
+	       "Content model of %s is not determinist: %s\n",
+	       elem->name, BAD_CAST expr, NULL);
+#ifdef DEBUG_REGEXP_ALGO
+        xmlRegexpPrint(stderr, elem->contModel);
+#endif
+        ctxt->valid = 0;
+	ctxt->state = NULL;
+	xmlFreeAutomata(ctxt->am);
+	ctxt->am = NULL;
+	return(0);
+    }
+    ctxt->state = NULL;
+    xmlFreeAutomata(ctxt->am);
+    ctxt->am = NULL;
+    return(1);
+}
+
+#endif /* LIBXML_REGEXP_ENABLED */
+
+/****************************************************************
+ *								*
+ *	Util functions for data allocation/deallocation		*
+ *								*
+ ****************************************************************/
+
+/**
+ * xmlNewValidCtxt:
+ *
+ * Allocate a validation context structure.
+ *
+ * Returns NULL if not, otherwise the new validation context structure
+ */
+xmlValidCtxtPtr xmlNewValidCtxt(void) {
+    xmlValidCtxtPtr ret;
+
+    if ((ret = xmlMalloc(sizeof (xmlValidCtxt))) == NULL) {
+	xmlVErrMemory(NULL, "malloc failed");
+	return (NULL);
+    }
+
+    (void) memset(ret, 0, sizeof (xmlValidCtxt));
+
+    return (ret);
+}
+
+/**
+ * xmlFreeValidCtxt:
+ * @cur:  the validation context to free
+ *
+ * Free a validation context structure.
+ */
+void
+xmlFreeValidCtxt(xmlValidCtxtPtr cur) {
+    xmlFree(cur);
+}
+
+#endif /* LIBXML_VALID_ENABLED */
+
+/**
+ * xmlNewElementContent:
+ * @name:  the subelement name or NULL
+ * @type:  the type of element content decl
+ *
+ * Allocate an element content structure.
+ *
+ * Returns NULL if not, otherwise the new element content structure
+ */
+xmlElementContentPtr
+xmlNewElementContent(const xmlChar *name, xmlElementContentType type) {
+    xmlElementContentPtr ret;
+
+    switch(type) {
+	case XML_ELEMENT_CONTENT_ELEMENT:
+	    if (name == NULL) {
+	        xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
+			"xmlNewElementContent : name == NULL !\n",
+			NULL);
+	    }
+	    break;
+        case XML_ELEMENT_CONTENT_PCDATA:
+	case XML_ELEMENT_CONTENT_SEQ:
+	case XML_ELEMENT_CONTENT_OR:
+	    if (name != NULL) {
+	        xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
+			"xmlNewElementContent : name != NULL !\n",
+			NULL);
+	    }
+	    break;
+	default:
+	    xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR, 
+		    "Internal: ELEMENT content corrupted invalid type\n",
+		    NULL);
+	    return(NULL);
+    }
+    ret = (xmlElementContentPtr) xmlMalloc(sizeof(xmlElementContent));
+    if (ret == NULL) {
+	xmlVErrMemory(NULL, "malloc failed");
+	return(NULL);
+    }
+    memset(ret, 0, sizeof(xmlElementContent));
+    ret->type = type;
+    ret->ocur = XML_ELEMENT_CONTENT_ONCE;
+    if (name != NULL) {
+	xmlChar *prefix = NULL;
+	ret->name = xmlSplitQName2(name, &prefix);
+	if (ret->name == NULL)
+	    ret->name = xmlStrdup(name);
+	ret->prefix = prefix;
+    } else {
+        ret->name = NULL;
+	ret->prefix = NULL;
+    }
+    ret->c1 = ret->c2 = ret->parent = NULL;
+    return(ret);
+}
+
+/**
+ * xmlCopyElementContent:
+ * @cur:  An element content pointer.
+ *
+ * Build a copy of an element content description.
+ * 
+ * Returns the new xmlElementContentPtr or NULL in case of error.
+ */
+xmlElementContentPtr
+xmlCopyElementContent(xmlElementContentPtr cur) {
+    xmlElementContentPtr ret;
+
+    if (cur == NULL) return(NULL);
+    ret = xmlNewElementContent((xmlChar *) cur->name, cur->type);
+    if (ret == NULL) {
+	xmlVErrMemory(NULL, "malloc failed");
+	return(NULL);
+    }
+    if (cur->prefix != NULL)
+	ret->prefix = xmlStrdup(cur->prefix);
+    ret->ocur = cur->ocur;
+    if (cur->c1 != NULL) ret->c1 = xmlCopyElementContent(cur->c1);
+    if (ret->c1 != NULL)
+	ret->c1->parent = ret;
+    if (cur->c2 != NULL) ret->c2 = xmlCopyElementContent(cur->c2);
+    if (ret->c2 != NULL)
+	ret->c2->parent = ret;
+    return(ret);
+}
+
+/**
+ * xmlFreeElementContent:
+ * @cur:  the element content tree to free
+ *
+ * Free an element content structure. This is a recursive call !
+ */
+void
+xmlFreeElementContent(xmlElementContentPtr cur) {
+    if (cur == NULL) return;
+    switch (cur->type) {
+	case XML_ELEMENT_CONTENT_PCDATA:
+	case XML_ELEMENT_CONTENT_ELEMENT:
+	case XML_ELEMENT_CONTENT_SEQ:
+	case XML_ELEMENT_CONTENT_OR:
+	    break;
+	default:
+	    xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR, 
+		    "Internal: ELEMENT content corrupted invalid type\n",
+		    NULL);
+	    return;
+    }
+    if (cur->c1 != NULL) xmlFreeElementContent(cur->c1);
+    if (cur->c2 != NULL) xmlFreeElementContent(cur->c2);
+    if (cur->name != NULL) xmlFree((xmlChar *) cur->name);
+    if (cur->prefix != NULL) xmlFree((xmlChar *) cur->prefix);
+    xmlFree(cur);
+}
+
+#ifdef LIBXML_OUTPUT_ENABLED
+/**
+ * xmlDumpElementContent:
+ * @buf:  An XML buffer
+ * @content:  An element table
+ * @glob: 1 if one must print the englobing parenthesis, 0 otherwise
+ *
+ * This will dump the content of the element table as an XML DTD definition
+ */
+static void
+xmlDumpElementContent(xmlBufferPtr buf, xmlElementContentPtr content, int glob) {
+    if (content == NULL) return;
+
+    if (glob) xmlBufferWriteChar(buf, "(");
+    switch (content->type) {
+        case XML_ELEMENT_CONTENT_PCDATA:
+            xmlBufferWriteChar(buf, "#PCDATA");
+	    break;
+	case XML_ELEMENT_CONTENT_ELEMENT:
+	    if (content->prefix != NULL) {
+		xmlBufferWriteCHAR(buf, content->prefix);
+		xmlBufferWriteChar(buf, ":");
+	    }
+	    xmlBufferWriteCHAR(buf, content->name);
+	    break;
+	case XML_ELEMENT_CONTENT_SEQ:
+	    if ((content->c1->type == XML_ELEMENT_CONTENT_OR) ||
+	        (content->c1->type == XML_ELEMENT_CONTENT_SEQ))
+		xmlDumpElementContent(buf, content->c1, 1);
+	    else
+		xmlDumpElementContent(buf, content->c1, 0);
+            xmlBufferWriteChar(buf, " , ");
+	    if (content->c2->type == XML_ELEMENT_CONTENT_OR)
+		xmlDumpElementContent(buf, content->c2, 1);
+	    else
+		xmlDumpElementContent(buf, content->c2, 0);
+	    break;
+	case XML_ELEMENT_CONTENT_OR:
+	    if ((content->c1->type == XML_ELEMENT_CONTENT_OR) ||
+	        (content->c1->type == XML_ELEMENT_CONTENT_SEQ))
+		xmlDumpElementContent(buf, content->c1, 1);
+	    else
+		xmlDumpElementContent(buf, content->c1, 0);
+            xmlBufferWriteChar(buf, " | ");
+	    if (content->c2->type == XML_ELEMENT_CONTENT_SEQ)
+		xmlDumpElementContent(buf, content->c2, 1);
+	    else
+		xmlDumpElementContent(buf, content->c2, 0);
+	    break;
+	default:
+	    xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR, 
+		    "Internal: ELEMENT content corrupted invalid type\n",
+		    NULL);
+    }
+    if (glob)
+        xmlBufferWriteChar(buf, ")");
+    switch (content->ocur) {
+        case XML_ELEMENT_CONTENT_ONCE:
+	    break;
+        case XML_ELEMENT_CONTENT_OPT:
+	    xmlBufferWriteChar(buf, "?");
+	    break;
+        case XML_ELEMENT_CONTENT_MULT:
+	    xmlBufferWriteChar(buf, "*");
+	    break;
+        case XML_ELEMENT_CONTENT_PLUS:
+	    xmlBufferWriteChar(buf, "+");
+	    break;
+    }
+}
+
+/**
+ * xmlSprintfElementContent:
+ * @buf:  an output buffer
+ * @content:  An element table
+ * @glob: 1 if one must print the englobing parenthesis, 0 otherwise
+ *
+ * Deprecated, unsafe, use xmlSnprintfElementContent
+ */
+void
+xmlSprintfElementContent(char *buf ATTRIBUTE_UNUSED,
+	                 xmlElementContentPtr content ATTRIBUTE_UNUSED,
+			 int glob ATTRIBUTE_UNUSED) {
+}
+#endif /* LIBXML_OUTPUT_ENABLED */
+
+/**
+ * xmlSnprintfElementContent:
+ * @buf:  an output buffer
+ * @size:  the buffer size
+ * @content:  An element table
+ * @glob: 1 if one must print the englobing parenthesis, 0 otherwise
+ *
+ * This will dump the content of the element content definition
+ * Intended just for the debug routine
+ */
+void
+xmlSnprintfElementContent(char *buf, int size, xmlElementContentPtr content, int glob) {
+    int len;
+
+    if (content == NULL) return;
+    len = strlen(buf);
+    if (size - len < 50) {
+	if ((size - len > 4) && (buf[len - 1] != '.'))
+	    strcat(buf, " ...");
+	return;
+    }
+    if (glob) strcat(buf, "(");
+    switch (content->type) {
+        case XML_ELEMENT_CONTENT_PCDATA:
+            strcat(buf, "#PCDATA");
+	    break;
+	case XML_ELEMENT_CONTENT_ELEMENT:
+	    if (content->prefix != NULL) {
+		if (size - len < xmlStrlen(content->prefix) + 10) {
+		    strcat(buf, " ...");
+		    return;
+		}
+		strcat(buf, (char *) content->prefix);
+		strcat(buf, ":");
+	    }
+	    if (size - len < xmlStrlen(content->name) + 10) {
+		strcat(buf, " ...");
+		return;
+	    }
+	    if (content->name != NULL)
+		strcat(buf, (char *) content->name);
+	    break;
+	case XML_ELEMENT_CONTENT_SEQ:
+	    if ((content->c1->type == XML_ELEMENT_CONTENT_OR) ||
+	        (content->c1->type == XML_ELEMENT_CONTENT_SEQ))
+		xmlSnprintfElementContent(buf, size, content->c1, 1);
+	    else
+		xmlSnprintfElementContent(buf, size, content->c1, 0);
+	    len = strlen(buf);
+	    if (size - len < 50) {
+		if ((size - len > 4) && (buf[len - 1] != '.'))
+		    strcat(buf, " ...");
+		return;
+	    }
+            strcat(buf, " , ");
+	    if (((content->c2->type == XML_ELEMENT_CONTENT_OR) ||
+		 (content->c2->ocur != XML_ELEMENT_CONTENT_ONCE)) &&
+		(content->c2->type != XML_ELEMENT_CONTENT_ELEMENT))
+		xmlSnprintfElementContent(buf, size, content->c2, 1);
+	    else
+		xmlSnprintfElementContent(buf, size, content->c2, 0);
+	    break;
+	case XML_ELEMENT_CONTENT_OR:
+	    if ((content->c1->type == XML_ELEMENT_CONTENT_OR) ||
+	        (content->c1->type == XML_ELEMENT_CONTENT_SEQ))
+		xmlSnprintfElementContent(buf, size, content->c1, 1);
+	    else
+		xmlSnprintfElementContent(buf, size, content->c1, 0);
+	    len = strlen(buf);
+	    if (size - len < 50) {
+		if ((size - len > 4) && (buf[len - 1] != '.'))
+		    strcat(buf, " ...");
+		return;
+	    }
+            strcat(buf, " | ");
+	    if (((content->c2->type == XML_ELEMENT_CONTENT_SEQ) ||
+		 (content->c2->ocur != XML_ELEMENT_CONTENT_ONCE)) &&
+		(content->c2->type != XML_ELEMENT_CONTENT_ELEMENT))
+		xmlSnprintfElementContent(buf, size, content->c2, 1);
+	    else
+		xmlSnprintfElementContent(buf, size, content->c2, 0);
+	    break;
+    }
+    if (glob)
+        strcat(buf, ")");
+    switch (content->ocur) {
+        case XML_ELEMENT_CONTENT_ONCE:
+	    break;
+        case XML_ELEMENT_CONTENT_OPT:
+	    strcat(buf, "?");
+	    break;
+        case XML_ELEMENT_CONTENT_MULT:
+	    strcat(buf, "*");
+	    break;
+        case XML_ELEMENT_CONTENT_PLUS:
+	    strcat(buf, "+");
+	    break;
+    }
+}
+
+/****************************************************************
+ *								*
+ *	Registration of DTD declarations			*
+ *								*
+ ****************************************************************/
+
+/**
+ * xmlCreateElementTable:
+ *
+ * create and initialize an empty element hash table.
+ *
+ * Returns the xmlElementTablePtr just created or NULL in case of error.
+ */
+static xmlElementTablePtr
+xmlCreateElementTable(void) {
+    return(xmlHashCreate(0));
+}
+
+/**
+ * xmlFreeElement:
+ * @elem:  An element
+ *
+ * Deallocate the memory used by an element definition
+ */
+static void
+xmlFreeElement(xmlElementPtr elem) {
+    if (elem == NULL) return;
+    xmlUnlinkNode((xmlNodePtr) elem);
+    xmlFreeElementContent(elem->content);
+    if (elem->name != NULL)
+	xmlFree((xmlChar *) elem->name);
+    if (elem->prefix != NULL)
+	xmlFree((xmlChar *) elem->prefix);
+#ifdef LIBXML_REGEXP_ENABLED
+    if (elem->contModel != NULL)
+	xmlRegFreeRegexp(elem->contModel);
+#endif
+    xmlFree(elem);
+}
+
+
+/**
+ * xmlAddElementDecl:
+ * @ctxt:  the validation context
+ * @dtd:  pointer to the DTD
+ * @name:  the entity name
+ * @type:  the element type
+ * @content:  the element content tree or NULL
+ *
+ * Register a new element declaration
+ *
+ * Returns NULL if not, otherwise the entity
+ */
+xmlElementPtr
+xmlAddElementDecl(xmlValidCtxtPtr ctxt,
+                  xmlDtdPtr dtd, const xmlChar *name,
+                  xmlElementTypeVal type,
+		  xmlElementContentPtr content) {
+    xmlElementPtr ret;
+    xmlElementTablePtr table;
+    xmlAttributePtr oldAttributes = NULL;
+    xmlChar *ns, *uqname;
+
+    if (dtd == NULL) {
+	return(NULL);
+    }
+    if (name == NULL) {
+	return(NULL);
+    }
+    switch (type) {
+        case XML_ELEMENT_TYPE_EMPTY:
+	    if (content != NULL) {
+		xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR, 
+		        "xmlAddElementDecl: content != NULL for EMPTY\n",
+			NULL);
+		return(NULL);
+	    }
+	    break;
+	case XML_ELEMENT_TYPE_ANY:
+	    if (content != NULL) {
+		xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR, 
+		        "xmlAddElementDecl: content != NULL for ANY\n",
+			NULL);
+		return(NULL);
+	    }
+	    break;
+	case XML_ELEMENT_TYPE_MIXED:
+	    if (content == NULL) {
+		xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR, 
+		        "xmlAddElementDecl: content == NULL for MIXED\n",
+			NULL);
+		return(NULL);
+	    }
+	    break;
+	case XML_ELEMENT_TYPE_ELEMENT:
+	    if (content == NULL) {
+		xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR, 
+		        "xmlAddElementDecl: content == NULL for ELEMENT\n",
+			NULL);
+		return(NULL);
+	    }
+	    break;
+	default:
+	    xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR, 
+		    "Internal: ELEMENT decl corrupted invalid type\n",
+		    NULL);
+	    return(NULL);
+    }
+
+    /*
+     * check if name is a QName
+     */
+    uqname = xmlSplitQName2(name, &ns);
+    if (uqname != NULL)
+	name = uqname;
+
+    /*
+     * Create the Element table if needed.
+     */
+    table = (xmlElementTablePtr) dtd->elements;
+    if (table == NULL) {
+        table = xmlCreateElementTable();
+	dtd->elements = (void *) table;
+    }
+    if (table == NULL) {
+	xmlVErrMemory(ctxt,
+            "xmlAddElementDecl: Table creation failed!\n");
+	if (uqname != NULL)
+	    xmlFree(uqname);
+	if (ns != NULL)
+	    xmlFree(ns);
+        return(NULL);
+    }
+
+    /*
+     * lookup old attributes inserted on an undefined element in the
+     * internal subset.
+     */
+    if ((dtd->doc != NULL) && (dtd->doc->intSubset != NULL)) {
+	ret = xmlHashLookup2(dtd->doc->intSubset->elements, name, ns);
+	if ((ret != NULL) && (ret->etype == XML_ELEMENT_TYPE_UNDEFINED)) {
+	    oldAttributes = ret->attributes;
+	    ret->attributes = NULL;
+	    xmlHashRemoveEntry2(dtd->doc->intSubset->elements, name, ns, NULL);
+	    xmlFreeElement(ret);
+	}
+    }
+
+    /*
+     * The element may already be present if one of its attribute
+     * was registered first
+     */
+    ret = xmlHashLookup2(table, name, ns);
+    if (ret != NULL) {
+	if (ret->etype != XML_ELEMENT_TYPE_UNDEFINED) {
+#ifdef LIBXML_VALID_ENABLED
+	    /*
+	     * The element is already defined in this DTD.
+	     */
+	    xmlErrValidNode(ctxt, (xmlNodePtr) dtd, XML_DTD_ELEM_REDEFINED,
+	                    "Redefinition of element %s\n",
+			    name, NULL, NULL);
+#endif /* LIBXML_VALID_ENABLED */
+	    if (uqname != NULL)
+		xmlFree(uqname);
+            if (ns != NULL)
+	        xmlFree(ns);
+	    return(NULL);
+	}
+    } else {
+	ret = (xmlElementPtr) xmlMalloc(sizeof(xmlElement));
+	if (ret == NULL) {
+	    xmlVErrMemory(ctxt, "malloc failed");
+	    if (uqname != NULL)
+		xmlFree(uqname);
+            if (ns != NULL)
+	        xmlFree(ns);
+	    return(NULL);
+	}
+	memset(ret, 0, sizeof(xmlElement));
+	ret->type = XML_ELEMENT_DECL;
+
+	/*
+	 * fill the structure.
+	 */
+	ret->name = xmlStrdup(name);
+	if (ret->name == NULL) {
+	    xmlVErrMemory(ctxt, "malloc failed");
+	    if (uqname != NULL)
+		xmlFree(uqname);
+            if (ns != NULL)
+	        xmlFree(ns);
+	    xmlFree(ret);
+	    return(NULL);
+	}
+	ret->prefix = ns;
+
+	/*
+	 * Validity Check:
+	 * Insertion must not fail
+	 */
+	if (xmlHashAddEntry2(table, name, ns, ret)) {
+#ifdef LIBXML_VALID_ENABLED
+	    /*
+	     * The element is already defined in this DTD.
+	     */
+	    xmlErrValidNode(ctxt, (xmlNodePtr) dtd, XML_DTD_ELEM_REDEFINED,
+	                    "Redefinition of element %s\n",
+			    name, NULL, NULL);
+#endif /* LIBXML_VALID_ENABLED */
+	    xmlFreeElement(ret);
+	    if (uqname != NULL)
+		xmlFree(uqname);
+	    return(NULL);
+	}
+	/*
+	 * For new element, may have attributes from earlier
+	 * definition in internal subset
+	 */
+	ret->attributes = oldAttributes;
+    }
+
+    /*
+     * Finish to fill the structure.
+     */
+    ret->etype = type;
+    ret->content = xmlCopyElementContent(content);
+
+    /*
+     * Link it to the DTD
+     */
+    ret->parent = dtd;
+    ret->doc = dtd->doc;
+    if (dtd->last == NULL) {
+	dtd->children = dtd->last = (xmlNodePtr) ret;
+    } else {
+        dtd->last->next = (xmlNodePtr) ret;
+	ret->prev = dtd->last;
+	dtd->last = (xmlNodePtr) ret;
+    }
+    if (uqname != NULL)
+	xmlFree(uqname);
+    return(ret);
+}
+
+/**
+ * xmlFreeElementTable:
+ * @table:  An element table
+ *
+ * Deallocate the memory used by an element hash table.
+ */
+void
+xmlFreeElementTable(xmlElementTablePtr table) {
+    xmlHashFree(table, (xmlHashDeallocator) xmlFreeElement);
+}
+
+#ifdef LIBXML_TREE_ENABLED
+/**
+ * xmlCopyElement:
+ * @elem:  An element
+ *
+ * Build a copy of an element.
+ * 
+ * Returns the new xmlElementPtr or NULL in case of error.
+ */
+static xmlElementPtr
+xmlCopyElement(xmlElementPtr elem) {
+    xmlElementPtr cur;
+
+    cur = (xmlElementPtr) xmlMalloc(sizeof(xmlElement));
+    if (cur == NULL) {
+	xmlVErrMemory(NULL, "malloc failed");
+	return(NULL);
+    }
+    memset(cur, 0, sizeof(xmlElement));
+    cur->type = XML_ELEMENT_DECL;
+    cur->etype = elem->etype;
+    if (elem->name != NULL)
+	cur->name = xmlStrdup(elem->name);
+    else
+	cur->name = NULL;
+    if (elem->prefix != NULL)
+	cur->prefix = xmlStrdup(elem->prefix);
+    else
+	cur->prefix = NULL;
+    cur->content = xmlCopyElementContent(elem->content);
+    /* TODO : rebuild the attribute list on the copy */
+    cur->attributes = NULL;
+    return(cur);
+}
+
+/**
+ * xmlCopyElementTable:
+ * @table:  An element table
+ *
+ * Build a copy of an element table.
+ * 
+ * Returns the new xmlElementTablePtr or NULL in case of error.
+ */
+xmlElementTablePtr
+xmlCopyElementTable(xmlElementTablePtr table) {
+    return((xmlElementTablePtr) xmlHashCopy(table,
+		                            (xmlHashCopier) xmlCopyElement));
+}
+#endif /* LIBXML_TREE_ENABLED */
+
+#ifdef LIBXML_OUTPUT_ENABLED
+/**
+ * xmlDumpElementDecl:
+ * @buf:  the XML buffer output
+ * @elem:  An element table
+ *
+ * This will dump the content of the element declaration as an XML
+ * DTD definition
+ */
+void
+xmlDumpElementDecl(xmlBufferPtr buf, xmlElementPtr elem) {
+    switch (elem->etype) {
+	case XML_ELEMENT_TYPE_EMPTY:
+	    xmlBufferWriteChar(buf, "<!ELEMENT ");
+	    if (elem->prefix != NULL) {
+		xmlBufferWriteCHAR(buf, elem->prefix);
+		xmlBufferWriteChar(buf, ":");
+	    }
+	    xmlBufferWriteCHAR(buf, elem->name);
+	    xmlBufferWriteChar(buf, " EMPTY>\n");
+	    break;
+	case XML_ELEMENT_TYPE_ANY:
+	    xmlBufferWriteChar(buf, "<!ELEMENT ");
+	    if (elem->prefix != NULL) {
+		xmlBufferWriteCHAR(buf, elem->prefix);
+		xmlBufferWriteChar(buf, ":");
+	    }
+	    xmlBufferWriteCHAR(buf, elem->name);
+	    xmlBufferWriteChar(buf, " ANY>\n");
+	    break;
+	case XML_ELEMENT_TYPE_MIXED:
+	    xmlBufferWriteChar(buf, "<!ELEMENT ");
+	    if (elem->prefix != NULL) {
+		xmlBufferWriteCHAR(buf, elem->prefix);
+		xmlBufferWriteChar(buf, ":");
+	    }
+	    xmlBufferWriteCHAR(buf, elem->name);
+	    xmlBufferWriteChar(buf, " ");
+	    xmlDumpElementContent(buf, elem->content, 1);
+	    xmlBufferWriteChar(buf, ">\n");
+	    break;
+	case XML_ELEMENT_TYPE_ELEMENT:
+	    xmlBufferWriteChar(buf, "<!ELEMENT ");
+	    if (elem->prefix != NULL) {
+		xmlBufferWriteCHAR(buf, elem->prefix);
+		xmlBufferWriteChar(buf, ":");
+	    }
+	    xmlBufferWriteCHAR(buf, elem->name);
+	    xmlBufferWriteChar(buf, " ");
+	    xmlDumpElementContent(buf, elem->content, 1);
+	    xmlBufferWriteChar(buf, ">\n");
+	    break;
+	default:
+	    xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR, 
+		    "Internal: ELEMENT struct corrupted invalid type\n",
+		    NULL);
+    }
+}
+
+/**
+ * xmlDumpElementDeclScan:
+ * @elem:  An element table
+ * @buf:  the XML buffer output
+ *
+ * This routine is used by the hash scan function.  It just reverses
+ * the arguments.
+ */
+static void
+xmlDumpElementDeclScan(xmlElementPtr elem, xmlBufferPtr buf) {
+    xmlDumpElementDecl(buf, elem);
+}
+
+/**
+ * xmlDumpElementTable:
+ * @buf:  the XML buffer output
+ * @table:  An element table
+ *
+ * This will dump the content of the element table as an XML DTD definition
+ */
+void
+xmlDumpElementTable(xmlBufferPtr buf, xmlElementTablePtr table) {
+    xmlHashScan(table, (xmlHashScanner) xmlDumpElementDeclScan, buf);
+}
+#endif /* LIBXML_OUTPUT_ENABLED */
+
+/**
+ * xmlCreateEnumeration:
+ * @name:  the enumeration name or NULL
+ *
+ * create and initialize an enumeration attribute node.
+ *
+ * Returns the xmlEnumerationPtr just created or NULL in case
+ *                of error.
+ */
+xmlEnumerationPtr
+xmlCreateEnumeration(const xmlChar *name) {
+    xmlEnumerationPtr ret;
+
+    ret = (xmlEnumerationPtr) xmlMalloc(sizeof(xmlEnumeration));
+    if (ret == NULL) {
+	xmlVErrMemory(NULL, "malloc failed");
+        return(NULL);
+    }
+    memset(ret, 0, sizeof(xmlEnumeration));
+
+    if (name != NULL)
+        ret->name = xmlStrdup(name);
+    return(ret);
+}
+
+/**
+ * xmlFreeEnumeration:
+ * @cur:  the tree to free.
+ *
+ * free an enumeration attribute node (recursive).
+ */
+void
+xmlFreeEnumeration(xmlEnumerationPtr cur) {
+    if (cur == NULL) return;
+
+    if (cur->next != NULL) xmlFreeEnumeration(cur->next);
+
+    if (cur->name != NULL) xmlFree((xmlChar *) cur->name);
+    xmlFree(cur);
+}
+
+#ifdef LIBXML_TREE_ENABLED
+/**
+ * xmlCopyEnumeration:
+ * @cur:  the tree to copy.
+ *
+ * Copy an enumeration attribute node (recursive).
+ *
+ * Returns the xmlEnumerationPtr just created or NULL in case
+ *                of error.
+ */
+xmlEnumerationPtr
+xmlCopyEnumeration(xmlEnumerationPtr cur) {
+    xmlEnumerationPtr ret;
+
+    if (cur == NULL) return(NULL);
+    ret = xmlCreateEnumeration((xmlChar *) cur->name);
+
+    if (cur->next != NULL) ret->next = xmlCopyEnumeration(cur->next);
+    else ret->next = NULL;
+
+    return(ret);
+}
+#endif /* LIBXML_TREE_ENABLED */
+
+#ifdef LIBXML_OUTPUT_ENABLED
+/**
+ * xmlDumpEnumeration:
+ * @buf:  the XML buffer output
+ * @enum:  An enumeration
+ *
+ * This will dump the content of the enumeration
+ */
+static void
+xmlDumpEnumeration(xmlBufferPtr buf, xmlEnumerationPtr cur) {
+    if (cur == NULL)  return;
+    
+    xmlBufferWriteCHAR(buf, cur->name);
+    if (cur->next == NULL)
+	xmlBufferWriteChar(buf, ")");
+    else {
+	xmlBufferWriteChar(buf, " | ");
+	xmlDumpEnumeration(buf, cur->next);
+    }
+}
+#endif /* LIBXML_OUTPUT_ENABLED */
+
+/**
+ * xmlCreateAttributeTable:
+ *
+ * create and initialize an empty attribute hash table.
+ *
+ * Returns the xmlAttributeTablePtr just created or NULL in case
+ *                of error.
+ */
+static xmlAttributeTablePtr
+xmlCreateAttributeTable(void) {
+    return(xmlHashCreate(0));
+}
+
+#ifdef LIBXML_VALID_ENABLED
+/**
+ * xmlScanAttributeDeclCallback:
+ * @attr:  the attribute decl
+ * @list:  the list to update
+ *
+ * Callback called by xmlScanAttributeDecl when a new attribute
+ * has to be entered in the list.
+ */
+static void
+xmlScanAttributeDeclCallback(xmlAttributePtr attr, xmlAttributePtr *list,
+	                     const xmlChar* name ATTRIBUTE_UNUSED) {
+    attr->nexth = *list;
+    *list = attr;
+}
+
+/**
+ * xmlScanAttributeDecl:
+ * @dtd:  pointer to the DTD
+ * @elem:  the element name
+ *
+ * When inserting a new element scan the DtD for existing attributes
+ * for that element and initialize the Attribute chain
+ *
+ * Returns the pointer to the first attribute decl in the chain,
+ *         possibly NULL.
+ */
+xmlAttributePtr
+xmlScanAttributeDecl(xmlDtdPtr dtd, const xmlChar *elem) {
+    xmlAttributePtr ret = NULL;
+    xmlAttributeTablePtr table;
+
+    if (dtd == NULL) {
+	return(NULL);
+    }
+    if (elem == NULL) {
+	return(NULL);
+    }
+    table = (xmlAttributeTablePtr) dtd->attributes;
+    if (table == NULL) 
+        return(NULL);
+
+    /* WRONG !!! */
+    xmlHashScan3(table, NULL, NULL, elem,
+	        (xmlHashScanner) xmlScanAttributeDeclCallback, &ret);
+    return(ret);
+}
+
+/**
+ * xmlScanIDAttributeDecl:
+ * @ctxt:  the validation context
+ * @elem:  the element name
+ *
+ * Verify that the element don't have too many ID attributes
+ * declared.
+ *
+ * Returns the number of ID attributes found.
+ */
+static int
+xmlScanIDAttributeDecl(xmlValidCtxtPtr ctxt, xmlElementPtr elem) {
+    xmlAttributePtr cur;
+    int ret = 0;
+
+    if (elem == NULL) return(0);
+    cur = elem->attributes;
+    while (cur != NULL) {
+        if (cur->atype == XML_ATTRIBUTE_ID) {
+	    ret ++;
+	    if (ret > 1)
+		xmlErrValidNode(ctxt, (xmlNodePtr) elem, XML_DTD_MULTIPLE_ID,
+	       "Element %s has too many ID attributes defined : %s\n",
+		       elem->name, cur->name, NULL);
+	}
+	cur = cur->nexth;
+    }
+    return(ret);
+}
+#endif /* LIBXML_VALID_ENABLED */
+
+/**
+ * xmlFreeAttribute:
+ * @elem:  An attribute
+ *
+ * Deallocate the memory used by an attribute definition
+ */
+static void
+xmlFreeAttribute(xmlAttributePtr attr) {
+    if (attr == NULL) return;
+    xmlUnlinkNode((xmlNodePtr) attr);
+    if (attr->tree != NULL)
+        xmlFreeEnumeration(attr->tree);
+    if (attr->elem != NULL)
+	xmlFree((xmlChar *) attr->elem);
+    if (attr->name != NULL)
+	xmlFree((xmlChar *) attr->name);
+    if (attr->defaultValue != NULL)
+	xmlFree((xmlChar *) attr->defaultValue);
+    if (attr->prefix != NULL)
+	xmlFree((xmlChar *) attr->prefix);
+    xmlFree(attr);
+}
+
+
+/**
+ * xmlAddAttributeDecl:
+ * @ctxt:  the validation context
+ * @dtd:  pointer to the DTD
+ * @elem:  the element name
+ * @name:  the attribute name
+ * @ns:  the attribute namespace prefix
+ * @type:  the attribute type
+ * @def:  the attribute default type
+ * @defaultValue:  the attribute default value
+ * @tree:  if it's an enumeration, the associated list
+ *
+ * Register a new attribute declaration
+ * Note that @tree becomes the ownership of the DTD
+ *
+ * Returns NULL if not new, otherwise the attribute decl
+ */
+xmlAttributePtr
+xmlAddAttributeDecl(xmlValidCtxtPtr ctxt,
+                    xmlDtdPtr dtd, const xmlChar *elem,
+                    const xmlChar *name, const xmlChar *ns,
+		    xmlAttributeType type, xmlAttributeDefault def,
+		    const xmlChar *defaultValue, xmlEnumerationPtr tree) {
+    xmlAttributePtr ret;
+    xmlAttributeTablePtr table;
+    xmlElementPtr elemDef;
+
+    if (dtd == NULL) {
+	xmlFreeEnumeration(tree);
+	return(NULL);
+    }
+    if (name == NULL) {
+	xmlFreeEnumeration(tree);
+	return(NULL);
+    }
+    if (elem == NULL) {
+	xmlFreeEnumeration(tree);
+	return(NULL);
+    }
+
+#ifdef LIBXML_VALID_ENABLED
+    /*
+     * Check the type and possibly the default value.
+     */
+    switch (type) {
+        case XML_ATTRIBUTE_CDATA:
+	    break;
+        case XML_ATTRIBUTE_ID:
+	    break;
+        case XML_ATTRIBUTE_IDREF:
+	    break;
+        case XML_ATTRIBUTE_IDREFS:
+	    break;
+        case XML_ATTRIBUTE_ENTITY:
+	    break;
+        case XML_ATTRIBUTE_ENTITIES:
+	    break;
+        case XML_ATTRIBUTE_NMTOKEN:
+	    break;
+        case XML_ATTRIBUTE_NMTOKENS:
+	    break;
+        case XML_ATTRIBUTE_ENUMERATION:
+	    break;
+        case XML_ATTRIBUTE_NOTATION:
+	    break;
+	default:
+	    xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR, 
+		    "Internal: ATTRIBUTE struct corrupted invalid type\n",
+		    NULL);
+	    xmlFreeEnumeration(tree);
+	    return(NULL);
+    }
+    if ((defaultValue != NULL) && 
+        (!xmlValidateAttributeValue(type, defaultValue))) {
+	xmlErrValidNode(ctxt, (xmlNodePtr) dtd, XML_DTD_ATTRIBUTE_DEFAULT,
+	                "Attribute %s of %s: invalid default value\n",
+	                elem, name, defaultValue);
+	defaultValue = NULL;
+	ctxt->valid = 0;
+    }
+#endif /* LIBXML_VALID_ENABLED */
+
+    /*
+     * Check first that an attribute defined in the external subset wasn't
+     * already defined in the internal subset
+     */
+    if ((dtd->doc != NULL) && (dtd->doc->extSubset == dtd) &&
+	(dtd->doc->intSubset != NULL) &&
+	(dtd->doc->intSubset->attributes != NULL)) {
+        ret = xmlHashLookup3(dtd->doc->intSubset->attributes, name, ns, elem);
+	if (ret != NULL)
+	    return(NULL);
+    }
+
+    /*
+     * Create the Attribute table if needed.
+     */
+    table = (xmlAttributeTablePtr) dtd->attributes;
+    if (table == NULL) {
+        table = xmlCreateAttributeTable();
+	dtd->attributes = (void *) table;
+    }
+    if (table == NULL) {
+	xmlVErrMemory(ctxt,
+            "xmlAddAttributeDecl: Table creation failed!\n");
+        return(NULL);
+    }
+
+
+    ret = (xmlAttributePtr) xmlMalloc(sizeof(xmlAttribute));
+    if (ret == NULL) {
+	xmlVErrMemory(ctxt, "malloc failed");
+	return(NULL);
+    }
+    memset(ret, 0, sizeof(xmlAttribute));
+    ret->type = XML_ATTRIBUTE_DECL;
+
+    /*
+     * fill the structure.
+     */
+    ret->atype = type;
+    ret->name = xmlStrdup(name);
+    ret->prefix = xmlStrdup(ns);
+    ret->elem = xmlStrdup(elem);
+    ret->def = def;
+    ret->tree = tree;
+    if (defaultValue != NULL)
+	ret->defaultValue = xmlStrdup(defaultValue);
+
+    /*
+     * Validity Check:
+     * Search the DTD for previous declarations of the ATTLIST
+     */
+    if (xmlHashAddEntry3(table, name, ns, elem, ret) < 0) {
+#ifdef LIBXML_VALID_ENABLED
+	/*
+	 * The attribute is already defined in this DTD.
+	 */
+	xmlErrValidWarning(ctxt, (xmlNodePtr) dtd, XML_DTD_ATTRIBUTE_REDEFINED,
+		 "Attribute %s of element %s: already defined\n",
+		 name, elem, NULL);
+#endif /* LIBXML_VALID_ENABLED */
+	xmlFreeAttribute(ret);
+	return(NULL);
+    }
+
+    /*
+     * Validity Check:
+     * Multiple ID per element
+     */
+    elemDef = xmlGetDtdElementDesc2(dtd, elem, 1);
+    if (elemDef != NULL) {
+
+#ifdef LIBXML_VALID_ENABLED
+        if ((type == XML_ATTRIBUTE_ID) &&
+	    (xmlScanIDAttributeDecl(NULL, elemDef) != 0)) {
+	    xmlErrValidNode(ctxt, (xmlNodePtr) dtd, XML_DTD_MULTIPLE_ID,
+	   "Element %s has too may ID attributes defined : %s\n",
+		   elem, name, NULL);
+	    ctxt->valid = 0;
+	}
+#endif /* LIBXML_VALID_ENABLED */
+
+	/*
+	 * Insert namespace default def first they need to be
+	 * processed first.
+	 */
+	if ((xmlStrEqual(ret->name, BAD_CAST "xmlns")) ||
+	    ((ret->prefix != NULL &&
+	     (xmlStrEqual(ret->prefix, BAD_CAST "xmlns"))))) {
+	    ret->nexth = elemDef->attributes;
+	    elemDef->attributes = ret;
+	} else {
+	    xmlAttributePtr tmp = elemDef->attributes;
+
+	    while ((tmp != NULL) &&
+		   ((xmlStrEqual(tmp->name, BAD_CAST "xmlns")) ||
+		    ((ret->prefix != NULL &&
+		     (xmlStrEqual(ret->prefix, BAD_CAST "xmlns")))))) {
+		if (tmp->nexth == NULL)
+		    break;
+		tmp = tmp->nexth;
+	    }
+	    if (tmp != NULL) {
+		ret->nexth = tmp->nexth;
+	        tmp->nexth = ret;
+	    } else {
+		ret->nexth = elemDef->attributes;
+		elemDef->attributes = ret;
+	    }
+	}
+    }
+
+    /*
+     * Link it to the DTD
+     */
+    ret->parent = dtd;
+    ret->doc = dtd->doc;
+    if (dtd->last == NULL) {
+	dtd->children = dtd->last = (xmlNodePtr) ret;
+    } else {
+        dtd->last->next = (xmlNodePtr) ret;
+	ret->prev = dtd->last;
+	dtd->last = (xmlNodePtr) ret;
+    }
+    return(ret);
+}
+
+/**
+ * xmlFreeAttributeTable:
+ * @table:  An attribute table
+ *
+ * Deallocate the memory used by an entities hash table.
+ */
+void
+xmlFreeAttributeTable(xmlAttributeTablePtr table) {
+    xmlHashFree(table, (xmlHashDeallocator) xmlFreeAttribute);
+}
+
+#ifdef LIBXML_TREE_ENABLED
+/**
+ * xmlCopyAttribute:
+ * @attr:  An attribute
+ *
+ * Build a copy of an attribute.
+ * 
+ * Returns the new xmlAttributePtr or NULL in case of error.
+ */
+static xmlAttributePtr
+xmlCopyAttribute(xmlAttributePtr attr) {
+    xmlAttributePtr cur;
+
+    cur = (xmlAttributePtr) xmlMalloc(sizeof(xmlAttribute));
+    if (cur == NULL) {
+	xmlVErrMemory(NULL, "malloc failed");
+	return(NULL);
+    }
+    memset(cur, 0, sizeof(xmlAttribute));
+    cur->type = XML_ATTRIBUTE_DECL;
+    cur->atype = attr->atype;
+    cur->def = attr->def;
+    cur->tree = xmlCopyEnumeration(attr->tree);
+    if (attr->elem != NULL)
+	cur->elem = xmlStrdup(attr->elem);
+    if (attr->name != NULL)
+	cur->name = xmlStrdup(attr->name);
+    if (attr->prefix != NULL)
+	cur->prefix = xmlStrdup(attr->prefix);
+    if (attr->defaultValue != NULL)
+	cur->defaultValue = xmlStrdup(attr->defaultValue);
+    return(cur);
+}
+
+/**
+ * xmlCopyAttributeTable:
+ * @table:  An attribute table
+ *
+ * Build a copy of an attribute table.
+ * 
+ * Returns the new xmlAttributeTablePtr or NULL in case of error.
+ */
+xmlAttributeTablePtr
+xmlCopyAttributeTable(xmlAttributeTablePtr table) {
+    return((xmlAttributeTablePtr) xmlHashCopy(table,
+				    (xmlHashCopier) xmlCopyAttribute));
+}
+#endif /* LIBXML_TREE_ENABLED */
+
+#ifdef LIBXML_OUTPUT_ENABLED
+/**
+ * xmlDumpAttributeDecl:
+ * @buf:  the XML buffer output
+ * @attr:  An attribute declaration
+ *
+ * This will dump the content of the attribute declaration as an XML
+ * DTD definition
+ */
+void
+xmlDumpAttributeDecl(xmlBufferPtr buf, xmlAttributePtr attr) {
+    xmlBufferWriteChar(buf, "<!ATTLIST ");
+    xmlBufferWriteCHAR(buf, attr->elem);
+    xmlBufferWriteChar(buf, " ");
+    if (attr->prefix != NULL) {
+	xmlBufferWriteCHAR(buf, attr->prefix);
+	xmlBufferWriteChar(buf, ":");
+    }
+    xmlBufferWriteCHAR(buf, attr->name);
+    switch (attr->atype) {
+	case XML_ATTRIBUTE_CDATA:
+	    xmlBufferWriteChar(buf, " CDATA");
+	    break;
+	case XML_ATTRIBUTE_ID:
+	    xmlBufferWriteChar(buf, " ID");
+	    break;
+	case XML_ATTRIBUTE_IDREF:
+	    xmlBufferWriteChar(buf, " IDREF");
+	    break;
+	case XML_ATTRIBUTE_IDREFS:
+	    xmlBufferWriteChar(buf, " IDREFS");
+	    break;
+	case XML_ATTRIBUTE_ENTITY:
+	    xmlBufferWriteChar(buf, " ENTITY");
+	    break;
+	case XML_ATTRIBUTE_ENTITIES:
+	    xmlBufferWriteChar(buf, " ENTITIES");
+	    break;
+	case XML_ATTRIBUTE_NMTOKEN:
+	    xmlBufferWriteChar(buf, " NMTOKEN");
+	    break;
+	case XML_ATTRIBUTE_NMTOKENS:
+	    xmlBufferWriteChar(buf, " NMTOKENS");
+	    break;
+	case XML_ATTRIBUTE_ENUMERATION:
+	    xmlBufferWriteChar(buf, " (");
+	    xmlDumpEnumeration(buf, attr->tree);
+	    break;
+	case XML_ATTRIBUTE_NOTATION:
+	    xmlBufferWriteChar(buf, " NOTATION (");
+	    xmlDumpEnumeration(buf, attr->tree);
+	    break;
+	default:
+	    xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR, 
+		    "Internal: ATTRIBUTE struct corrupted invalid type\n",
+		    NULL);
+    }
+    switch (attr->def) {
+	case XML_ATTRIBUTE_NONE:
+	    break;
+	case XML_ATTRIBUTE_REQUIRED:
+	    xmlBufferWriteChar(buf, " #REQUIRED");
+	    break;
+	case XML_ATTRIBUTE_IMPLIED:
+	    xmlBufferWriteChar(buf, " #IMPLIED");
+	    break;
+	case XML_ATTRIBUTE_FIXED:
+	    xmlBufferWriteChar(buf, " #FIXED");
+	    break;
+	default:
+	    xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR, 
+		    "Internal: ATTRIBUTE struct corrupted invalid def\n",
+		    NULL);
+    }
+    if (attr->defaultValue != NULL) {
+	xmlBufferWriteChar(buf, " ");
+	xmlBufferWriteQuotedString(buf, attr->defaultValue);
+    }
+    xmlBufferWriteChar(buf, ">\n");
+}
+
+/**
+ * xmlDumpAttributeDeclScan:
+ * @attr:  An attribute declaration
+ * @buf:  the XML buffer output
+ *
+ * This is used with the hash scan function - just reverses arguments
+ */
+static void
+xmlDumpAttributeDeclScan(xmlAttributePtr attr, xmlBufferPtr buf) {
+    xmlDumpAttributeDecl(buf, attr);
+}
+
+/**
+ * xmlDumpAttributeTable:
+ * @buf:  the XML buffer output
+ * @table:  An attribute table
+ *
+ * This will dump the content of the attribute table as an XML DTD definition
+ */
+void
+xmlDumpAttributeTable(xmlBufferPtr buf, xmlAttributeTablePtr table) {
+    xmlHashScan(table, (xmlHashScanner) xmlDumpAttributeDeclScan, buf);
+}
+#endif /* LIBXML_OUTPUT_ENABLED */
+
+/************************************************************************
+ *									*
+ *				NOTATIONs				*
+ *									*
+ ************************************************************************/
+/**
+ * xmlCreateNotationTable:
+ *
+ * create and initialize an empty notation hash table.
+ *
+ * Returns the xmlNotationTablePtr just created or NULL in case
+ *                of error.
+ */
+static xmlNotationTablePtr
+xmlCreateNotationTable(void) {
+    return(xmlHashCreate(0));
+}
+
+/**
+ * xmlFreeNotation:
+ * @not:  A notation
+ *
+ * Deallocate the memory used by an notation definition
+ */
+static void
+xmlFreeNotation(xmlNotationPtr nota) {
+    if (nota == NULL) return;
+    if (nota->name != NULL)
+	xmlFree((xmlChar *) nota->name);
+    if (nota->PublicID != NULL)
+	xmlFree((xmlChar *) nota->PublicID);
+    if (nota->SystemID != NULL)
+	xmlFree((xmlChar *) nota->SystemID);
+    xmlFree(nota);
+}
+
+
+/**
+ * xmlAddNotationDecl:
+ * @dtd:  pointer to the DTD
+ * @ctxt:  the validation context
+ * @name:  the entity name
+ * @PublicID:  the public identifier or NULL
+ * @SystemID:  the system identifier or NULL
+ *
+ * Register a new notation declaration
+ *
+ * Returns NULL if not, otherwise the entity
+ */
+xmlNotationPtr
+xmlAddNotationDecl(xmlValidCtxtPtr ctxt, xmlDtdPtr dtd,
+	           const xmlChar *name,
+                   const xmlChar *PublicID, const xmlChar *SystemID) {
+    xmlNotationPtr ret;
+    xmlNotationTablePtr table;
+
+    if (dtd == NULL) {
+	return(NULL);
+    }
+    if (name == NULL) {
+	return(NULL);
+    }
+    if ((PublicID == NULL) && (SystemID == NULL)) {
+	return(NULL);
+    }
+
+    /*
+     * Create the Notation table if needed.
+     */
+    table = (xmlNotationTablePtr) dtd->notations;
+    if (table == NULL) 
+        dtd->notations = table = xmlCreateNotationTable();
+    if (table == NULL) {
+	xmlVErrMemory(ctxt,
+		"xmlAddNotationDecl: Table creation failed!\n");
+        return(NULL);
+    }
+
+    ret = (xmlNotationPtr) xmlMalloc(sizeof(xmlNotation));
+    if (ret == NULL) {
+	xmlVErrMemory(ctxt, "malloc failed");
+	return(NULL);
+    }
+    memset(ret, 0, sizeof(xmlNotation));
+
+    /*
+     * fill the structure.
+     */
+    ret->name = xmlStrdup(name);
+    if (SystemID != NULL)
+        ret->SystemID = xmlStrdup(SystemID);
+    if (PublicID != NULL)
+        ret->PublicID = xmlStrdup(PublicID);
+
+    /*
+     * Validity Check:
+     * Check the DTD for previous declarations of the ATTLIST
+     */
+    if (xmlHashAddEntry(table, name, ret)) {
+#ifdef LIBXML_VALID_ENABLED
+	xmlErrValid(NULL, XML_DTD_NOTATION_REDEFINED, 
+		    "xmlAddNotationDecl: %s already defined\n",
+		    (const char *) name);
+#endif /* LIBXML_VALID_ENABLED */
+	xmlFreeNotation(ret);
+	return(NULL);
+    }
+    return(ret);
+}
+
+/**
+ * xmlFreeNotationTable:
+ * @table:  An notation table
+ *
+ * Deallocate the memory used by an entities hash table.
+ */
+void
+xmlFreeNotationTable(xmlNotationTablePtr table) {
+    xmlHashFree(table, (xmlHashDeallocator) xmlFreeNotation);
+}
+
+#ifdef LIBXML_TREE_ENABLED
+/**
+ * xmlCopyNotation:
+ * @nota:  A notation
+ *
+ * Build a copy of a notation.
+ * 
+ * Returns the new xmlNotationPtr or NULL in case of error.
+ */
+static xmlNotationPtr
+xmlCopyNotation(xmlNotationPtr nota) {
+    xmlNotationPtr cur;
+
+    cur = (xmlNotationPtr) xmlMalloc(sizeof(xmlNotation));
+    if (cur == NULL) {
+	xmlVErrMemory(NULL, "malloc failed");
+	return(NULL);
+    }
+    if (nota->name != NULL)
+	cur->name = xmlStrdup(nota->name);
+    else
+	cur->name = NULL;
+    if (nota->PublicID != NULL)
+	cur->PublicID = xmlStrdup(nota->PublicID);
+    else
+	cur->PublicID = NULL;
+    if (nota->SystemID != NULL)
+	cur->SystemID = xmlStrdup(nota->SystemID);
+    else
+	cur->SystemID = NULL;
+    return(cur);
+}
+
+/**
+ * xmlCopyNotationTable:
+ * @table:  A notation table
+ *
+ * Build a copy of a notation table.
+ * 
+ * Returns the new xmlNotationTablePtr or NULL in case of error.
+ */
+xmlNotationTablePtr
+xmlCopyNotationTable(xmlNotationTablePtr table) {
+    return((xmlNotationTablePtr) xmlHashCopy(table,
+				    (xmlHashCopier) xmlCopyNotation));
+}
+#endif /* LIBXML_TREE_ENABLED */
+
+#ifdef LIBXML_OUTPUT_ENABLED
+/**
+ * xmlDumpNotationDecl:
+ * @buf:  the XML buffer output
+ * @nota:  A notation declaration
+ *
+ * This will dump the content the notation declaration as an XML DTD definition
+ */
+void
+xmlDumpNotationDecl(xmlBufferPtr buf, xmlNotationPtr nota) {
+    xmlBufferWriteChar(buf, "<!NOTATION ");
+    xmlBufferWriteCHAR(buf, nota->name);
+    if (nota->PublicID != NULL) {
+	xmlBufferWriteChar(buf, " PUBLIC ");
+	xmlBufferWriteQuotedString(buf, nota->PublicID);
+	if (nota->SystemID != NULL) {
+	    xmlBufferWriteChar(buf, " ");
+	    xmlBufferWriteCHAR(buf, nota->SystemID);
+	}
+    } else {
+	xmlBufferWriteChar(buf, " SYSTEM ");
+	xmlBufferWriteCHAR(buf, nota->SystemID);
+    }
+    xmlBufferWriteChar(buf, " >\n");
+}
+
+/**
+ * xmlDumpNotationDeclScan:
+ * @nota:  A notation declaration
+ * @buf:  the XML buffer output
+ *
+ * This is called with the hash scan function, and just reverses args
+ */
+static void
+xmlDumpNotationDeclScan(xmlNotationPtr nota, xmlBufferPtr buf) {
+    xmlDumpNotationDecl(buf, nota);
+}
+
+/**
+ * xmlDumpNotationTable:
+ * @buf:  the XML buffer output
+ * @table:  A notation table
+ *
+ * This will dump the content of the notation table as an XML DTD definition
+ */
+void
+xmlDumpNotationTable(xmlBufferPtr buf, xmlNotationTablePtr table) {
+    xmlHashScan(table, (xmlHashScanner) xmlDumpNotationDeclScan, buf);
+}
+#endif /* LIBXML_OUTPUT_ENABLED */
+
+/************************************************************************
+ *									*
+ *				IDs					*
+ *									*
+ ************************************************************************/
+/**
+ * DICT_FREE:
+ * @str:  a string
+ *
+ * Free a string if it is not owned by the "dict" dictionnary in the
+ * current scope
+ */
+#define DICT_FREE(str)						\
+	if ((str) && ((!dict) || 				\
+	    (xmlDictOwns(dict, (const xmlChar *)(str)) == 0)))	\
+	    xmlFree((char *)(str));
+
+/**
+ * xmlCreateIDTable:
+ *
+ * create and initialize an empty id hash table.
+ *
+ * Returns the xmlIDTablePtr just created or NULL in case
+ *                of error.
+ */
+static xmlIDTablePtr
+xmlCreateIDTable(void) {
+    return(xmlHashCreate(0));
+}
+
+/**
+ * xmlFreeID:
+ * @not:  A id
+ *
+ * Deallocate the memory used by an id definition
+ */
+static void
+xmlFreeID(xmlIDPtr id) {
+    xmlDictPtr dict = NULL;
+
+    if (id == NULL) return;
+
+    if (id->doc != NULL)
+        dict = id->doc->dict;
+
+    if (id->value != NULL)
+	DICT_FREE(id->value)
+    if (id->name != NULL)
+	DICT_FREE(id->name)
+    xmlFree(id);
+}
+
+
+/**
+ * xmlAddID:
+ * @ctxt:  the validation context
+ * @doc:  pointer to the document
+ * @value:  the value name
+ * @attr:  the attribute holding the ID
+ *
+ * Register a new id declaration
+ *
+ * Returns NULL if not, otherwise the new xmlIDPtr
+ */
+xmlIDPtr 
+xmlAddID(xmlValidCtxtPtr ctxt, xmlDocPtr doc, const xmlChar *value,
+         xmlAttrPtr attr) {
+    xmlIDPtr ret;
+    xmlIDTablePtr table;
+
+    if (doc == NULL) {
+	return(NULL);
+    }
+    if (value == NULL) {
+	return(NULL);
+    }
+    if (attr == NULL) {
+	return(NULL);
+    }
+
+    /*
+     * Create the ID table if needed.
+     */
+    table = (xmlIDTablePtr) doc->ids;
+    if (table == NULL) 
+        doc->ids = table = xmlCreateIDTable();
+    if (table == NULL) {
+	xmlVErrMemory(ctxt,
+		"xmlAddID: Table creation failed!\n");
+        return(NULL);
+    }
+
+    ret = (xmlIDPtr) xmlMalloc(sizeof(xmlID));
+    if (ret == NULL) {
+	xmlVErrMemory(ctxt, "malloc failed");
+	return(NULL);
+    }
+
+    /*
+     * fill the structure.
+     */
+    ret->value = xmlStrdup(value);
+    ret->doc = doc;
+    if ((ctxt != NULL) && (ctxt->vstateNr != 0)) {
+	/*
+	 * Operating in streaming mode, attr is gonna disapear
+	 */
+	if (doc->dict != NULL)
+	    ret->name = xmlDictLookup(doc->dict, attr->name, -1);
+	else
+	    ret->name = xmlStrdup(attr->name);
+	ret->attr = NULL;
+    } else {
+	ret->attr = attr;
+	ret->name = NULL;
+    }
+    ret->lineno = xmlGetLineNo(attr->parent);
+
+    if (xmlHashAddEntry(table, value, ret) < 0) {
+#ifdef LIBXML_VALID_ENABLED
+	/*
+	 * The id is already defined in this DTD.
+	 */
+	if ((ctxt != NULL) && (ctxt->error != NULL)) {
+	    xmlErrValidNode(ctxt, attr->parent, XML_DTD_ID_REDEFINED,
+	                    "ID %s already defined\n",
+			    value, NULL, NULL);
+	}
+#endif /* LIBXML_VALID_ENABLED */
+	xmlFreeID(ret);
+	return(NULL);
+    }
+    if (attr != NULL)
+	attr->atype = XML_ATTRIBUTE_ID;
+    return(ret);
+}
+
+/**
+ * xmlFreeIDTable:
+ * @table:  An id table
+ *
+ * Deallocate the memory used by an ID hash table.
+ */
+void
+xmlFreeIDTable(xmlIDTablePtr table) {
+    xmlHashFree(table, (xmlHashDeallocator) xmlFreeID);
+}
+
+/**
+ * xmlIsID:
+ * @doc:  the document
+ * @elem:  the element carrying the attribute
+ * @attr:  the attribute
+ *
+ * Determine whether an attribute is of type ID. In case we have DTD(s)
+ * then this is done if DTD loading has been requested. In the case
+ * of HTML documents parsed with the HTML parser, then ID detection is
+ * done systematically.
+ *
+ * Returns 0 or 1 depending on the lookup result
+ */
+int
+xmlIsID(xmlDocPtr doc, xmlNodePtr elem, xmlAttrPtr attr) {
+    if (doc == NULL) return(0);
+    if (attr == NULL) return(0);
+    if ((doc->intSubset == NULL) && (doc->extSubset == NULL)) {
+	return(0);
+    } else if (doc->type == XML_HTML_DOCUMENT_NODE) {
+        if (((xmlStrEqual(BAD_CAST "id", attr->name)) ||
+	    (xmlStrEqual(BAD_CAST "name", attr->name))) &&
+	    ((elem != NULL) && (!xmlStrEqual(elem->name, BAD_CAST "input"))))
+	    return(1);
+	return(0);    
+    } else {
+	xmlAttributePtr attrDecl;
+
+	if (elem == NULL) return(0);
+	if ((elem->ns != NULL) && (elem->ns->prefix != NULL)) {
+	    xmlChar fn[50];
+	    xmlChar *fullname;
+	    
+	    fullname = xmlBuildQName(elem->name, elem->ns->prefix, fn, 50);
+	    if (fullname == NULL)
+		return(0);
+	    attrDecl = xmlGetDtdAttrDesc(doc->intSubset, fullname,
+		                         attr->name);
+	    if ((attrDecl == NULL) && (doc->extSubset != NULL))
+		attrDecl = xmlGetDtdAttrDesc(doc->extSubset, fullname,
+					     attr->name);
+	    if ((fullname != fn) && (fullname != elem->name))
+		xmlFree(fullname);
+	} else {
+	    attrDecl = xmlGetDtdAttrDesc(doc->intSubset, elem->name,
+		                         attr->name);
+	    if ((attrDecl == NULL) && (doc->extSubset != NULL))
+		attrDecl = xmlGetDtdAttrDesc(doc->extSubset, elem->name,
+					     attr->name);
+	}
+
+        if ((attrDecl != NULL) && (attrDecl->atype == XML_ATTRIBUTE_ID))
+	    return(1);
+    }
+    return(0);
+}
+
+/**
+ * xmlRemoveID:
+ * @doc:  the document
+ * @attr:  the attribute
+ *
+ * Remove the given attribute from the ID table maintained internally.
+ *
+ * Returns -1 if the lookup failed and 0 otherwise
+ */
+int
+xmlRemoveID(xmlDocPtr doc, xmlAttrPtr attr) {
+    xmlIDTablePtr table;
+    xmlIDPtr id;
+    xmlChar *ID;
+
+    if (doc == NULL) return(-1);
+    if (attr == NULL) return(-1);
+    table = (xmlIDTablePtr) doc->ids;
+    if (table == NULL) 
+        return(-1);
+
+    if (attr == NULL)
+	return(-1);
+    ID = xmlNodeListGetString(doc, attr->children, 1);
+    if (ID == NULL)
+	return(-1);
+    id = xmlHashLookup(table, ID);
+    if (id == NULL || id->attr != attr) {
+	xmlFree(ID);
+	return(-1);
+    }
+    xmlHashUpdateEntry(table, ID, NULL, (xmlHashDeallocator) xmlFreeID);
+    xmlFree(ID);
+    return(0);
+}
+
+/**
+ * xmlGetID:
+ * @doc:  pointer to the document
+ * @ID:  the ID value
+ *
+ * Search the attribute declaring the given ID
+ *
+ * Returns NULL if not found, otherwise the xmlAttrPtr defining the ID
+ */
+xmlAttrPtr 
+xmlGetID(xmlDocPtr doc, const xmlChar *ID) {
+    xmlIDTablePtr table;
+    xmlIDPtr id;
+
+    if (doc == NULL) {
+	return(NULL);
+    }
+
+    if (ID == NULL) {
+	return(NULL);
+    }
+
+    table = (xmlIDTablePtr) doc->ids;
+    if (table == NULL) 
+        return(NULL);
+
+    id = xmlHashLookup(table, ID);
+    if (id == NULL)
+	return(NULL);
+    if (id->attr == NULL) {
+	/*
+	 * We are operating on a stream, return a well known reference
+	 * since the attribute node doesn't exist anymore
+	 */
+	return((xmlAttrPtr) doc);
+    }
+    return(id->attr);
+}
+
+/************************************************************************
+ *									*
+ *				Refs					*
+ *									*
+ ************************************************************************/
+typedef struct xmlRemoveMemo_t 
+{
+	xmlListPtr l;
+	xmlAttrPtr ap;
+} xmlRemoveMemo;
+
+typedef xmlRemoveMemo *xmlRemoveMemoPtr;
+
+typedef struct xmlValidateMemo_t 
+{
+    xmlValidCtxtPtr ctxt;
+    const xmlChar *name;
+} xmlValidateMemo;
+
+typedef xmlValidateMemo *xmlValidateMemoPtr;
+
+/**
+ * xmlCreateRefTable:
+ *
+ * create and initialize an empty ref hash table.
+ *
+ * Returns the xmlRefTablePtr just created or NULL in case
+ *                of error.
+ */
+static xmlRefTablePtr
+xmlCreateRefTable(void) {
+    return(xmlHashCreate(0));
+}
+
+/**
+ * xmlFreeRef:
+ * @lk:  A list link
+ *
+ * Deallocate the memory used by a ref definition
+ */
+static void
+xmlFreeRef(xmlLinkPtr lk) {
+    xmlRefPtr ref = (xmlRefPtr)xmlLinkGetData(lk);
+    if (ref == NULL) return;
+    if (ref->value != NULL)
+        xmlFree((xmlChar *)ref->value);
+    if (ref->name != NULL)
+        xmlFree((xmlChar *)ref->name);
+    xmlFree(ref);
+}
+
+/**
+ * xmlFreeRefList:
+ * @list_ref:  A list of references.
+ *
+ * Deallocate the memory used by a list of references
+ */
+static void
+xmlFreeRefList(xmlListPtr list_ref) {
+    if (list_ref == NULL) return;
+    xmlListDelete(list_ref);
+}
+
+/**
+ * xmlWalkRemoveRef:
+ * @data:  Contents of current link
+ * @user:  Value supplied by the user
+ *
+ * Returns 0 to abort the walk or 1 to continue
+ */
+static int
+xmlWalkRemoveRef(const void *data, const void *user)
+{
+    xmlAttrPtr attr0 = ((xmlRefPtr)data)->attr;
+    xmlAttrPtr attr1 = ((xmlRemoveMemoPtr)user)->ap;
+    xmlListPtr ref_list = ((xmlRemoveMemoPtr)user)->l;
+
+    if (attr0 == attr1) { /* Matched: remove and terminate walk */
+        xmlListRemoveFirst(ref_list, (void *)data);
+        return 0;
+    }
+    return 1;
+}
+
+/**
+ * xmlDummyCompare
+ * @data0:  Value supplied by the user
+ * @data1:  Value supplied by the user
+ *
+ * Do nothing, return 0. Used to create unordered lists.
+ */
+static int
+xmlDummyCompare(const void *data0 ATTRIBUTE_UNUSED,
+                const void *data1 ATTRIBUTE_UNUSED)
+{
+    return (0);
+}
+
+/**
+ * xmlAddRef:
+ * @ctxt:  the validation context
+ * @doc:  pointer to the document
+ * @value:  the value name
+ * @attr:  the attribute holding the Ref
+ *
+ * Register a new ref declaration
+ *
+ * Returns NULL if not, otherwise the new xmlRefPtr
+ */
+xmlRefPtr 
+xmlAddRef(xmlValidCtxtPtr ctxt, xmlDocPtr doc, const xmlChar *value,
+    xmlAttrPtr attr) {
+    xmlRefPtr ret;
+    xmlRefTablePtr table;
+    xmlListPtr ref_list;
+
+    if (doc == NULL) {
+        return(NULL);
+    }
+    if (value == NULL) {
+        return(NULL);
+    }
+    if (attr == NULL) {
+        return(NULL);
+    }
+
+    /*
+     * Create the Ref table if needed.
+     */
+    table = (xmlRefTablePtr) doc->refs;
+    if (table == NULL) 
+        doc->refs = table = xmlCreateRefTable();
+    if (table == NULL) {
+	xmlVErrMemory(ctxt,
+            "xmlAddRef: Table creation failed!\n");
+        return(NULL);
+    }
+
+    ret = (xmlRefPtr) xmlMalloc(sizeof(xmlRef));
+    if (ret == NULL) {
+	xmlVErrMemory(ctxt, "malloc failed");
+        return(NULL);
+    }
+
+    /*
+     * fill the structure.
+     */
+    ret->value = xmlStrdup(value);
+    if ((ctxt != NULL) && (ctxt->vstateNr != 0)) {
+	/*
+	 * Operating in streaming mode, attr is gonna disapear
+	 */
+	ret->name = xmlStrdup(attr->name);
+	ret->attr = NULL;
+    } else {
+	ret->name = NULL;
+	ret->attr = attr;
+    }
+    ret->lineno = xmlGetLineNo(attr->parent);
+
+    /* To add a reference :-
+     * References are maintained as a list of references,
+     * Lookup the entry, if no entry create new nodelist
+     * Add the owning node to the NodeList
+     * Return the ref
+     */
+
+    if (NULL == (ref_list = xmlHashLookup(table, value))) {
+        if (NULL == (ref_list = xmlListCreate(xmlFreeRef, xmlDummyCompare))) {
+	    xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
+		    "xmlAddRef: Reference list creation failed!\n",
+		    NULL);
+            return(NULL);
+        }
+        if (xmlHashAddEntry(table, value, ref_list) < 0) {
+            xmlListDelete(ref_list);
+	    xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
+		    "xmlAddRef: Reference list insertion failed!\n",
+		    NULL);
+            return(NULL);
+        }
+    }
+/*    xmlListInsert(ref_list, ret); */
+    xmlListAppend(ref_list, ret);
+    return(ret);
+}
+
+/**
+ * xmlFreeRefTable:
+ * @table:  An ref table
+ *
+ * Deallocate the memory used by an Ref hash table.
+ */
+void
+xmlFreeRefTable(xmlRefTablePtr table) {
+    xmlHashFree(table, (xmlHashDeallocator) xmlFreeRefList);
+}
+
+/**
+ * xmlIsRef:
+ * @doc:  the document
+ * @elem:  the element carrying the attribute
+ * @attr:  the attribute
+ *
+ * Determine whether an attribute is of type Ref. In case we have DTD(s)
+ * then this is simple, otherwise we use an heuristic: name Ref (upper
+ * or lowercase).
+ *
+ * Returns 0 or 1 depending on the lookup result
+ */
+int
+xmlIsRef(xmlDocPtr doc, xmlNodePtr elem, xmlAttrPtr attr) {
+    if ((doc->intSubset == NULL) && (doc->extSubset == NULL)) {
+        return(0);
+    } else if (doc->type == XML_HTML_DOCUMENT_NODE) {
+        /* TODO @@@ */
+        return(0);    
+    } else {
+        xmlAttributePtr attrDecl;
+
+        attrDecl = xmlGetDtdAttrDesc(doc->intSubset, elem->name, attr->name);
+        if ((attrDecl == NULL) && (doc->extSubset != NULL))
+            attrDecl = xmlGetDtdAttrDesc(doc->extSubset,
+		                         elem->name, attr->name);
+
+	if ((attrDecl != NULL) &&
+	    (attrDecl->atype == XML_ATTRIBUTE_IDREF ||
+	     attrDecl->atype == XML_ATTRIBUTE_IDREFS))
+	return(1);
+    }
+    return(0);
+}
+
+/**
+ * xmlRemoveRef:
+ * @doc:  the document
+ * @attr:  the attribute
+ *
+ * Remove the given attribute from the Ref table maintained internally.
+ *
+ * Returns -1 if the lookup failed and 0 otherwise
+ */
+int
+xmlRemoveRef(xmlDocPtr doc, xmlAttrPtr attr) {
+    xmlListPtr ref_list;
+    xmlRefTablePtr table;
+    xmlChar *ID;
+    xmlRemoveMemo target;
+
+    if (doc == NULL) return(-1);
+    if (attr == NULL) return(-1);
+    table = (xmlRefTablePtr) doc->refs;
+    if (table == NULL) 
+        return(-1);
+
+    if (attr == NULL)
+        return(-1);
+    ID = xmlNodeListGetString(doc, attr->children, 1);
+    if (ID == NULL)
+        return(-1);
+    ref_list = xmlHashLookup(table, ID);
+
+    if(ref_list == NULL) {
+        xmlFree(ID);
+        return (-1);
+    }
+    /* At this point, ref_list refers to a list of references which
+     * have the same key as the supplied attr. Our list of references
+     * is ordered by reference address and we don't have that information
+     * here to use when removing. We'll have to walk the list and
+     * check for a matching attribute, when we find one stop the walk
+     * and remove the entry.
+     * The list is ordered by reference, so that means we don't have the
+     * key. Passing the list and the reference to the walker means we
+     * will have enough data to be able to remove the entry.
+     */
+    target.l = ref_list;
+    target.ap = attr;
+    
+    /* Remove the supplied attr from our list */
+    xmlListWalk(ref_list, xmlWalkRemoveRef, &target);
+
+    /*If the list is empty then remove the list entry in the hash */
+    if (xmlListEmpty(ref_list))
+        xmlHashUpdateEntry(table, ID, NULL, (xmlHashDeallocator)
+        xmlFreeRefList);
+    xmlFree(ID);
+    return(0);
+}
+
+/**
+ * xmlGetRefs:
+ * @doc:  pointer to the document
+ * @ID:  the ID value
+ *
+ * Find the set of references for the supplied ID. 
+ *
+ * Returns NULL if not found, otherwise node set for the ID.
+ */
+xmlListPtr 
+xmlGetRefs(xmlDocPtr doc, const xmlChar *ID) {
+    xmlRefTablePtr table;
+
+    if (doc == NULL) {
+        return(NULL);
+    }
+
+    if (ID == NULL) {
+        return(NULL);
+    }
+
+    table = (xmlRefTablePtr) doc->refs;
+    if (table == NULL) 
+        return(NULL);
+
+    return (xmlHashLookup(table, ID));
+}
+
+/************************************************************************
+ *									*
+ *		Routines for validity checking				*
+ *									*
+ ************************************************************************/
+
+/**
+ * xmlGetDtdElementDesc:
+ * @dtd:  a pointer to the DtD to search
+ * @name:  the element name
+ *
+ * Search the DTD for the description of this element
+ *
+ * returns the xmlElementPtr if found or NULL
+ */
+
+xmlElementPtr
+xmlGetDtdElementDesc(xmlDtdPtr dtd, const xmlChar *name) {
+    xmlElementTablePtr table;
+    xmlElementPtr cur;
+    xmlChar *uqname = NULL, *prefix = NULL;
+
+    if ((dtd == NULL) || (name == NULL)) return(NULL);
+    if (dtd->elements == NULL)
+	return(NULL);
+    table = (xmlElementTablePtr) dtd->elements;
+
+    uqname = xmlSplitQName2(name, &prefix);
+    if (uqname != NULL)
+        name = uqname;
+    cur = xmlHashLookup2(table, name, prefix);
+    if (prefix != NULL) xmlFree(prefix);
+    if (uqname != NULL) xmlFree(uqname);
+    return(cur);
+}
+/**
+ * xmlGetDtdElementDesc2:
+ * @dtd:  a pointer to the DtD to search
+ * @name:  the element name
+ * @create:  create an empty description if not found
+ *
+ * Search the DTD for the description of this element
+ *
+ * returns the xmlElementPtr if found or NULL
+ */
+
+static xmlElementPtr
+xmlGetDtdElementDesc2(xmlDtdPtr dtd, const xmlChar *name, int create) {
+    xmlElementTablePtr table;
+    xmlElementPtr cur;
+    xmlChar *uqname = NULL, *prefix = NULL;
+
+    if (dtd == NULL) return(NULL);
+    if (dtd->elements == NULL) {
+	if (!create) 
+	    return(NULL);
+	/*
+	 * Create the Element table if needed.
+	 */
+	table = (xmlElementTablePtr) dtd->elements;
+	if (table == NULL) {
+	    table = xmlCreateElementTable();
+	    dtd->elements = (void *) table;
+	}
+	if (table == NULL) {
+	    xmlVErrMemory(NULL, "element table allocation failed");
+	    return(NULL);
+	}
+    }
+    table = (xmlElementTablePtr) dtd->elements;
+
+    uqname = xmlSplitQName2(name, &prefix);
+    if (uqname != NULL)
+        name = uqname;
+    cur = xmlHashLookup2(table, name, prefix);
+    if ((cur == NULL) && (create)) {
+	cur = (xmlElementPtr) xmlMalloc(sizeof(xmlElement));
+	if (cur == NULL) {
+	    xmlVErrMemory(NULL, "malloc failed");
+	    return(NULL);
+	}
+	memset(cur, 0, sizeof(xmlElement));
+	cur->type = XML_ELEMENT_DECL;
+
+	/*
+	 * fill the structure.
+	 */
+	cur->name = xmlStrdup(name);
+	cur->prefix = xmlStrdup(prefix);
+	cur->etype = XML_ELEMENT_TYPE_UNDEFINED;
+
+	xmlHashAddEntry2(table, name, prefix, cur);
+    }
+    if (prefix != NULL) xmlFree(prefix);
+    if (uqname != NULL) xmlFree(uqname);
+    return(cur);
+}
+
+/**
+ * xmlGetDtdQElementDesc:
+ * @dtd:  a pointer to the DtD to search
+ * @name:  the element name
+ * @prefix:  the element namespace prefix
+ *
+ * Search the DTD for the description of this element
+ *
+ * returns the xmlElementPtr if found or NULL
+ */
+
+xmlElementPtr
+xmlGetDtdQElementDesc(xmlDtdPtr dtd, const xmlChar *name,
+	              const xmlChar *prefix) {
+    xmlElementTablePtr table;
+
+    if (dtd == NULL) return(NULL);
+    if (dtd->elements == NULL) return(NULL);
+    table = (xmlElementTablePtr) dtd->elements;
+
+    return(xmlHashLookup2(table, name, prefix));
+}
+
+/**
+ * xmlGetDtdAttrDesc:
+ * @dtd:  a pointer to the DtD to search
+ * @elem:  the element name
+ * @name:  the attribute name
+ *
+ * Search the DTD for the description of this attribute on
+ * this element.
+ *
+ * returns the xmlAttributePtr if found or NULL
+ */
+
+xmlAttributePtr
+xmlGetDtdAttrDesc(xmlDtdPtr dtd, const xmlChar *elem, const xmlChar *name) {
+    xmlAttributeTablePtr table;
+    xmlAttributePtr cur;
+    xmlChar *uqname = NULL, *prefix = NULL;
+
+    if (dtd == NULL) return(NULL);
+    if (dtd->attributes == NULL) return(NULL);
+
+    table = (xmlAttributeTablePtr) dtd->attributes;
+    if (table == NULL)
+	return(NULL);
+
+    uqname = xmlSplitQName2(name, &prefix);
+
+    if (uqname != NULL) {
+	cur = xmlHashLookup3(table, uqname, prefix, elem);
+	if (prefix != NULL) xmlFree(prefix);
+	if (uqname != NULL) xmlFree(uqname);
+    } else
+	cur = xmlHashLookup3(table, name, NULL, elem);
+    return(cur);
+}
+
+/**
+ * xmlGetDtdQAttrDesc:
+ * @dtd:  a pointer to the DtD to search
+ * @elem:  the element name
+ * @name:  the attribute name
+ * @prefix:  the attribute namespace prefix
+ *
+ * Search the DTD for the description of this qualified attribute on
+ * this element.
+ *
+ * returns the xmlAttributePtr if found or NULL
+ */
+
+xmlAttributePtr
+xmlGetDtdQAttrDesc(xmlDtdPtr dtd, const xmlChar *elem, const xmlChar *name,
+	          const xmlChar *prefix) {
+    xmlAttributeTablePtr table;
+
+    if (dtd == NULL) return(NULL);
+    if (dtd->attributes == NULL) return(NULL);
+    table = (xmlAttributeTablePtr) dtd->attributes;
+
+    return(xmlHashLookup3(table, name, prefix, elem));
+}
+
+/**
+ * xmlGetDtdNotationDesc:
+ * @dtd:  a pointer to the DtD to search
+ * @name:  the notation name
+ *
+ * Search the DTD for the description of this notation
+ *
+ * returns the xmlNotationPtr if found or NULL
+ */
+
+xmlNotationPtr
+xmlGetDtdNotationDesc(xmlDtdPtr dtd, const xmlChar *name) {
+    xmlNotationTablePtr table;
+
+    if (dtd == NULL) return(NULL);
+    if (dtd->notations == NULL) return(NULL);
+    table = (xmlNotationTablePtr) dtd->notations;
+
+    return(xmlHashLookup(table, name));
+}
+
+#if defined(LIBXML_VALID_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
+/**
+ * xmlValidateNotationUse:
+ * @ctxt:  the validation context
+ * @doc:  the document
+ * @notationName:  the notation name to check
+ *
+ * Validate that the given name match a notation declaration.
+ * - [ VC: Notation Declared ]
+ *
+ * returns 1 if valid or 0 otherwise
+ */
+
+int
+xmlValidateNotationUse(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
+                       const xmlChar *notationName) {
+    xmlNotationPtr notaDecl;
+    if ((doc == NULL) || (doc->intSubset == NULL)) return(-1);
+
+    notaDecl = xmlGetDtdNotationDesc(doc->intSubset, notationName);
+    if ((notaDecl == NULL) && (doc->extSubset != NULL))
+	notaDecl = xmlGetDtdNotationDesc(doc->extSubset, notationName);
+
+    if ((notaDecl == NULL) && (ctxt != NULL)) {
+	xmlErrValidNode(ctxt, (xmlNodePtr) doc, XML_DTD_UNKNOWN_NOTATION,
+	                "NOTATION %s is not declared\n",
+		        notationName, NULL, NULL);
+	return(0);
+    }
+    return(1);
+}
+#endif /* LIBXML_VALID_ENABLED or LIBXML_SCHEMAS_ENABLED */
+
+/**
+ * xmlIsMixedElement:
+ * @doc:  the document
+ * @name:  the element name
+ *
+ * Search in the DtDs whether an element accept Mixed content (or ANY)
+ * basically if it is supposed to accept text childs
+ *
+ * returns 0 if no, 1 if yes, and -1 if no element description is available
+ */
+
+int
+xmlIsMixedElement(xmlDocPtr doc, const xmlChar *name) {
+    xmlElementPtr elemDecl;
+
+    if ((doc == NULL) || (doc->intSubset == NULL)) return(-1);
+
+    elemDecl = xmlGetDtdElementDesc(doc->intSubset, name);
+    if ((elemDecl == NULL) && (doc->extSubset != NULL))
+	elemDecl = xmlGetDtdElementDesc(doc->extSubset, name);
+    if (elemDecl == NULL) return(-1);
+    switch (elemDecl->etype) {
+	case XML_ELEMENT_TYPE_UNDEFINED:
+	    return(-1);
+	case XML_ELEMENT_TYPE_ELEMENT:
+	    return(0);
+        case XML_ELEMENT_TYPE_EMPTY:
+	    /*
+	     * return 1 for EMPTY since we want VC error to pop up
+	     * on <empty>     </empty> for example
+	     */
+	case XML_ELEMENT_TYPE_ANY:
+	case XML_ELEMENT_TYPE_MIXED:
+	    return(1);
+    }
+    return(1);
+}
+
+#ifdef LIBXML_VALID_ENABLED
+/**
+ * xmlValidateNameValue:
+ * @value:  an Name value
+ *
+ * Validate that the given value match Name production
+ *
+ * returns 1 if valid or 0 otherwise
+ */
+
+int
+xmlValidateNameValue(const xmlChar *value) {
+    const xmlChar *cur;
+    int val, len;
+
+    if (value == NULL) return(0);
+    cur = value;
+    val = xmlStringCurrentChar(NULL, cur, &len);
+    cur += len;
+    if (!IS_LETTER(val) && (val != '_') &&
+        (val != ':')) {
+	return(0);
+    }
+
+    val = xmlStringCurrentChar(NULL, cur, &len);
+    cur += len;
+    while ((IS_LETTER(val)) || (IS_DIGIT(val)) ||
+           (val == '.') || (val == '-') ||
+	   (val == '_') || (val == ':') || 
+	   (IS_COMBINING(val)) ||
+	   (IS_EXTENDER(val))) {
+	val = xmlStringCurrentChar(NULL, cur, &len);
+	cur += len;
+    }
+
+    if (val != 0) return(0);
+
+    return(1);
+}
+
+/**
+ * xmlValidateNamesValue:
+ * @value:  an Names value
+ *
+ * Validate that the given value match Names production
+ *
+ * returns 1 if valid or 0 otherwise
+ */
+
+int
+xmlValidateNamesValue(const xmlChar *value) {
+    const xmlChar *cur;
+    int val, len;
+
+    if (value == NULL) return(0);
+    cur = value;
+    val = xmlStringCurrentChar(NULL, cur, &len);
+    cur += len;
+    
+    if (!IS_LETTER(val) && (val != '_') &&
+        (val != ':')) {
+	return(0);
+    }
+
+    val = xmlStringCurrentChar(NULL, cur, &len);
+    cur += len;
+    while ((IS_LETTER(val)) || (IS_DIGIT(val)) ||
+           (val == '.') || (val == '-') ||
+	   (val == '_') || (val == ':') || 
+	   (IS_COMBINING(val)) ||
+	   (IS_EXTENDER(val))) {
+	val = xmlStringCurrentChar(NULL, cur, &len);
+	cur += len;
+    }
+
+    while (IS_BLANK(val)) {
+	while (IS_BLANK(val)) {
+	    val = xmlStringCurrentChar(NULL, cur, &len);
+	    cur += len;
+	}
+
+	if (!IS_LETTER(val) && (val != '_') &&
+	    (val != ':')) {
+	    return(0);
+	}
+	val = xmlStringCurrentChar(NULL, cur, &len);
+	cur += len;
+
+	while ((IS_LETTER(val)) || (IS_DIGIT(val)) ||
+	       (val == '.') || (val == '-') ||
+	       (val == '_') || (val == ':') || 
+	       (IS_COMBINING(val)) ||
+	       (IS_EXTENDER(val))) {
+	    val = xmlStringCurrentChar(NULL, cur, &len);
+	    cur += len;
+	}
+    }
+
+    if (val != 0) return(0);
+
+    return(1);
+}
+
+/**
+ * xmlValidateNmtokenValue:
+ * @value:  an Nmtoken value
+ *
+ * Validate that the given value match Nmtoken production
+ *
+ * [ VC: Name Token ]
+ * 
+ * returns 1 if valid or 0 otherwise
+ */
+
+int
+xmlValidateNmtokenValue(const xmlChar *value) {
+    const xmlChar *cur;
+    int val, len;
+
+    if (value == NULL) return(0);
+    cur = value;
+    val = xmlStringCurrentChar(NULL, cur, &len);
+    cur += len;
+    
+    if (!IS_LETTER(val) && !IS_DIGIT(val) &&
+        (val != '.') && (val != '-') &&
+        (val != '_') && (val != ':') && 
+        (!IS_COMBINING(val)) &&
+        (!IS_EXTENDER(val)))
+	return(0);
+
+    while ((IS_LETTER(val)) || (IS_DIGIT(val)) ||
+           (val == '.') || (val == '-') ||
+	   (val == '_') || (val == ':') || 
+	   (IS_COMBINING(val)) ||
+	   (IS_EXTENDER(val))) {
+	val = xmlStringCurrentChar(NULL, cur, &len);
+	cur += len;
+    }
+
+    if (val != 0) return(0);
+
+    return(1);
+}
+
+/**
+ * xmlValidateNmtokensValue:
+ * @value:  an Nmtokens value
+ *
+ * Validate that the given value match Nmtokens production
+ *
+ * [ VC: Name Token ]
+ * 
+ * returns 1 if valid or 0 otherwise
+ */
+
+int
+xmlValidateNmtokensValue(const xmlChar *value) {
+    const xmlChar *cur;
+    int val, len;
+
+    if (value == NULL) return(0);
+    cur = value;
+    val = xmlStringCurrentChar(NULL, cur, &len);
+    cur += len;
+    
+    while (IS_BLANK(val)) {
+	val = xmlStringCurrentChar(NULL, cur, &len);
+	cur += len;
+    }
+
+    if (!IS_LETTER(val) && !IS_DIGIT(val) &&
+        (val != '.') && (val != '-') &&
+        (val != '_') && (val != ':') && 
+        (!IS_COMBINING(val)) &&
+        (!IS_EXTENDER(val)))
+	return(0);
+
+    while ((IS_LETTER(val)) || (IS_DIGIT(val)) ||
+           (val == '.') || (val == '-') ||
+	   (val == '_') || (val == ':') || 
+	   (IS_COMBINING(val)) ||
+	   (IS_EXTENDER(val))) {
+	val = xmlStringCurrentChar(NULL, cur, &len);
+	cur += len;
+    }
+
+    while (IS_BLANK(val)) {
+	while (IS_BLANK(val)) {
+	    val = xmlStringCurrentChar(NULL, cur, &len);
+	    cur += len;
+	}
+	if (val == 0) return(1);
+
+	if (!IS_LETTER(val) && !IS_DIGIT(val) &&
+	    (val != '.') && (val != '-') &&
+	    (val != '_') && (val != ':') && 
+	    (!IS_COMBINING(val)) &&
+	    (!IS_EXTENDER(val)))
+	    return(0);
+
+	while ((IS_LETTER(val)) || (IS_DIGIT(val)) ||
+	       (val == '.') || (val == '-') ||
+	       (val == '_') || (val == ':') || 
+	       (IS_COMBINING(val)) ||
+	       (IS_EXTENDER(val))) {
+	    val = xmlStringCurrentChar(NULL, cur, &len);
+	    cur += len;
+	}
+    }
+
+    if (val != 0) return(0);
+
+    return(1);
+}
+
+/**
+ * xmlValidateNotationDecl:
+ * @ctxt:  the validation context
+ * @doc:  a document instance
+ * @nota:  a notation definition
+ *
+ * Try to validate a single notation definition
+ * basically it does the following checks as described by the
+ * XML-1.0 recommendation:
+ *  - it seems that no validity constraint exists on notation declarations
+ * But this function get called anyway ...
+ *
+ * returns 1 if valid or 0 otherwise
+ */
+
+int
+xmlValidateNotationDecl(xmlValidCtxtPtr ctxt ATTRIBUTE_UNUSED, xmlDocPtr doc ATTRIBUTE_UNUSED,
+                         xmlNotationPtr nota ATTRIBUTE_UNUSED) {
+    int ret = 1;
+
+    return(ret);
+}
+
+/**
+ * xmlValidateAttributeValue:
+ * @type:  an attribute type
+ * @value:  an attribute value
+ *
+ * Validate that the given attribute value match  the proper production
+ *
+ * [ VC: ID ]
+ * Values of type ID must match the Name production....
+ *
+ * [ VC: IDREF ]
+ * Values of type IDREF must match the Name production, and values
+ * of type IDREFS must match Names ...
+ *
+ * [ VC: Entity Name ]
+ * Values of type ENTITY must match the Name production, values
+ * of type ENTITIES must match Names ...
+ *
+ * [ VC: Name Token ]
+ * Values of type NMTOKEN must match the Nmtoken production; values
+ * of type NMTOKENS must match Nmtokens. 
+ *
+ * returns 1 if valid or 0 otherwise
+ */
+
+int
+xmlValidateAttributeValue(xmlAttributeType type, const xmlChar *value) {
+    switch (type) {
+	case XML_ATTRIBUTE_ENTITIES:
+	case XML_ATTRIBUTE_IDREFS:
+	    return(xmlValidateNamesValue(value));
+	case XML_ATTRIBUTE_ENTITY:
+	case XML_ATTRIBUTE_IDREF:
+	case XML_ATTRIBUTE_ID:
+	case XML_ATTRIBUTE_NOTATION:
+	    return(xmlValidateNameValue(value));
+	case XML_ATTRIBUTE_NMTOKENS:
+	case XML_ATTRIBUTE_ENUMERATION:
+	    return(xmlValidateNmtokensValue(value));
+	case XML_ATTRIBUTE_NMTOKEN:
+	    return(xmlValidateNmtokenValue(value));
+        case XML_ATTRIBUTE_CDATA:
+	    break;
+    }
+    return(1);
+}
+
+/**
+ * xmlValidateAttributeValue2:
+ * @ctxt:  the validation context
+ * @doc:  the document
+ * @name:  the attribute name (used for error reporting only)
+ * @type:  the attribute type
+ * @value:  the attribute value
+ *
+ * Validate that the given attribute value match a given type.
+ * This typically cannot be done before having finished parsing
+ * the subsets.
+ *
+ * [ VC: IDREF ]
+ * Values of type IDREF must match one of the declared IDs
+ * Values of type IDREFS must match a sequence of the declared IDs
+ * each Name must match the value of an ID attribute on some element
+ * in the XML document; i.e. IDREF values must match the value of
+ * some ID attribute
+ *
+ * [ VC: Entity Name ]
+ * Values of type ENTITY must match one declared entity
+ * Values of type ENTITIES must match a sequence of declared entities
+ *
+ * [ VC: Notation Attributes ]
+ * all notation names in the declaration must be declared.
+ *
+ * returns 1 if valid or 0 otherwise
+ */
+
+static int
+xmlValidateAttributeValue2(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
+      const xmlChar *name, xmlAttributeType type, const xmlChar *value) {
+    int ret = 1;
+    switch (type) {
+	case XML_ATTRIBUTE_IDREFS:
+	case XML_ATTRIBUTE_IDREF:
+	case XML_ATTRIBUTE_ID:
+	case XML_ATTRIBUTE_NMTOKENS:
+	case XML_ATTRIBUTE_ENUMERATION:
+	case XML_ATTRIBUTE_NMTOKEN:
+        case XML_ATTRIBUTE_CDATA:
+	    break;
+	case XML_ATTRIBUTE_ENTITY: {
+	    xmlEntityPtr ent;
+
+	    ent = xmlGetDocEntity(doc, value);
+	    /* yeah it's a bit messy... */
+	    if ((ent == NULL) && (doc->standalone == 1)) {
+		doc->standalone = 0;
+		ent = xmlGetDocEntity(doc, value);
+	    } 
+	    if (ent == NULL) {
+		xmlErrValidNode(ctxt, (xmlNodePtr) doc,
+				XML_DTD_UNKNOWN_ENTITY,
+   "ENTITY attribute %s reference an unknown entity \"%s\"\n",
+		       name, value, NULL);
+		ret = 0;
+	    } else if (ent->etype != XML_EXTERNAL_GENERAL_UNPARSED_ENTITY) {
+		xmlErrValidNode(ctxt, (xmlNodePtr) doc,
+				XML_DTD_ENTITY_TYPE,
+   "ENTITY attribute %s reference an entity \"%s\" of wrong type\n",
+		       name, value, NULL);
+		ret = 0;
+	    }
+	    break;
+        }
+	case XML_ATTRIBUTE_ENTITIES: {
+	    xmlChar *dup, *nam = NULL, *cur, save;
+	    xmlEntityPtr ent;
+
+	    dup = xmlStrdup(value);
+	    if (dup == NULL)
+		return(0);
+	    cur = dup;
+	    while (*cur != 0) {
+		nam = cur;
+		while ((*cur != 0) && (!IS_BLANK_CH(*cur))) cur++;
+		save = *cur;
+		*cur = 0;
+		ent = xmlGetDocEntity(doc, nam);
+		if (ent == NULL) {
+		    xmlErrValidNode(ctxt, (xmlNodePtr) doc,
+				    XML_DTD_UNKNOWN_ENTITY,
+       "ENTITIES attribute %s reference an unknown entity \"%s\"\n",
+			   name, nam, NULL);
+		    ret = 0;
+		} else if (ent->etype != XML_EXTERNAL_GENERAL_UNPARSED_ENTITY) {
+		    xmlErrValidNode(ctxt, (xmlNodePtr) doc,
+				    XML_DTD_ENTITY_TYPE,
+       "ENTITIES attribute %s reference an entity \"%s\" of wrong type\n",
+			   name, nam, NULL);
+		    ret = 0;
+		}
+		if (save == 0)
+		    break;
+		*cur = save;
+		while (IS_BLANK_CH(*cur)) cur++;
+	    }
+	    xmlFree(dup);
+	    break;
+	}
+	case XML_ATTRIBUTE_NOTATION: {
+	    xmlNotationPtr nota;
+
+	    nota = xmlGetDtdNotationDesc(doc->intSubset, value);
+	    if ((nota == NULL) && (doc->extSubset != NULL))
+		nota = xmlGetDtdNotationDesc(doc->extSubset, value);
+
+	    if (nota == NULL) {
+		xmlErrValidNode(ctxt, (xmlNodePtr) doc,
+		                XML_DTD_UNKNOWN_NOTATION,
+       "NOTATION attribute %s reference an unknown notation \"%s\"\n",
+		       name, value, NULL);
+		ret = 0;
+	    }
+	    break;
+        }
+    }
+    return(ret);
+}
+
+/**
+ * xmlValidCtxtNormalizeAttributeValue:
+ * @ctxt: the validation context
+ * @doc:  the document
+ * @elem:  the parent
+ * @name:  the attribute name
+ * @value:  the attribute value
+ * @ctxt:  the validation context or NULL
+ *
+ * Does the validation related extra step of the normalization of attribute
+ * values:
+ *
+ * If the declared value is not CDATA, then the XML processor must further
+ * process the normalized attribute value by discarding any leading and
+ * trailing space (#x20) characters, and by replacing sequences of space
+ * (#x20) characters by single space (#x20) character.
+ *
+ * Also  check VC: Standalone Document Declaration in P32, and update
+ *  ctxt->valid accordingly
+ *
+ * returns a new normalized string if normalization is needed, NULL otherwise
+ *      the caller must free the returned value.
+ */
+
+xmlChar *
+xmlValidCtxtNormalizeAttributeValue(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
+	     xmlNodePtr elem, const xmlChar *name, const xmlChar *value) {
+    xmlChar *ret, *dst;
+    const xmlChar *src;
+    xmlAttributePtr attrDecl = NULL;
+    int extsubset = 0;
+
+    if (doc == NULL) return(NULL);
+    if (elem == NULL) return(NULL);
+    if (name == NULL) return(NULL);
+    if (value == NULL) return(NULL);
+
+    if ((elem->ns != NULL) && (elem->ns->prefix != NULL)) {
+	xmlChar fn[50];
+	xmlChar *fullname;
+	
+	fullname = xmlBuildQName(elem->name, elem->ns->prefix, fn, 50);
+	if (fullname == NULL)
+	    return(0);
+	attrDecl = xmlGetDtdAttrDesc(doc->intSubset, fullname, name);
+	if ((attrDecl == NULL) && (doc->extSubset != NULL)) {
+	    attrDecl = xmlGetDtdAttrDesc(doc->extSubset, fullname, name);
+	    if (attrDecl != NULL)
+		extsubset = 1;
+	}
+	if ((fullname != fn) && (fullname != elem->name))
+	    xmlFree(fullname);
+    }
+    if ((attrDecl == NULL) && (doc->intSubset != NULL))
+	attrDecl = xmlGetDtdAttrDesc(doc->intSubset, elem->name, name);
+    if ((attrDecl == NULL) && (doc->extSubset != NULL)) {
+	attrDecl = xmlGetDtdAttrDesc(doc->extSubset, elem->name, name);
+	if (attrDecl != NULL)
+	    extsubset = 1;
+    }
+
+    if (attrDecl == NULL)
+	return(NULL);
+    if (attrDecl->atype == XML_ATTRIBUTE_CDATA)
+	return(NULL);
+
+    ret = xmlStrdup(value);
+    if (ret == NULL)
+	return(NULL);
+    src = value;
+    dst = ret;
+    while (*src == 0x20) src++;
+    while (*src != 0) {
+	if (*src == 0x20) {
+	    while (*src == 0x20) src++;
+	    if (*src != 0)
+		*dst++ = 0x20;
+	} else {
+	    *dst++ = *src++;
+	}
+    }
+    *dst = 0;
+    if ((doc->standalone) && (extsubset == 1) && (!xmlStrEqual(value, ret))) {
+	xmlErrValidNode(ctxt, elem, XML_DTD_NOT_STANDALONE,
+"standalone: %s on %s value had to be normalized based on external subset declaration\n",
+	       name, elem->name, NULL);
+	ctxt->valid = 0;
+    }
+    return(ret);
+}
+
+/**
+ * xmlValidNormalizeAttributeValue:
+ * @doc:  the document
+ * @elem:  the parent
+ * @name:  the attribute name
+ * @value:  the attribute value
+ *
+ * Does the validation related extra step of the normalization of attribute
+ * values:
+ *
+ * If the declared value is not CDATA, then the XML processor must further
+ * process the normalized attribute value by discarding any leading and
+ * trailing space (#x20) characters, and by replacing sequences of space
+ * (#x20) characters by single space (#x20) character.
+ *
+ * Returns a new normalized string if normalization is needed, NULL otherwise
+ *      the caller must free the returned value.
+ */
+
+xmlChar *
+xmlValidNormalizeAttributeValue(xmlDocPtr doc, xmlNodePtr elem,
+			        const xmlChar *name, const xmlChar *value) {
+    xmlChar *ret, *dst;
+    const xmlChar *src;
+    xmlAttributePtr attrDecl = NULL;
+
+    if (doc == NULL) return(NULL);
+    if (elem == NULL) return(NULL);
+    if (name == NULL) return(NULL);
+    if (value == NULL) return(NULL);
+
+    if ((elem->ns != NULL) && (elem->ns->prefix != NULL)) {
+	xmlChar fn[50];
+	xmlChar *fullname;
+	
+	fullname = xmlBuildQName(elem->name, elem->ns->prefix, fn, 50);
+	if (fullname == NULL)
+	    return(0);
+	attrDecl = xmlGetDtdAttrDesc(doc->intSubset, fullname, name);
+	if ((attrDecl == NULL) && (doc->extSubset != NULL))
+	    attrDecl = xmlGetDtdAttrDesc(doc->extSubset, fullname, name);
+	if ((fullname != fn) && (fullname != elem->name))
+	    xmlFree(fullname);
+    }
+    attrDecl = xmlGetDtdAttrDesc(doc->intSubset, elem->name, name);
+    if ((attrDecl == NULL) && (doc->extSubset != NULL))
+	attrDecl = xmlGetDtdAttrDesc(doc->extSubset, elem->name, name);
+
+    if (attrDecl == NULL)
+	return(NULL);
+    if (attrDecl->atype == XML_ATTRIBUTE_CDATA)
+	return(NULL);
+
+    ret = xmlStrdup(value);
+    if (ret == NULL)
+	return(NULL);
+    src = value;
+    dst = ret;
+    while (*src == 0x20) src++;
+    while (*src != 0) {
+	if (*src == 0x20) {
+	    while (*src == 0x20) src++;
+	    if (*src != 0)
+		*dst++ = 0x20;
+	} else {
+	    *dst++ = *src++;
+	}
+    }
+    *dst = 0;
+    return(ret);
+}
+
+static void
+xmlValidateAttributeIdCallback(xmlAttributePtr attr, int *count,
+	                       const xmlChar* name ATTRIBUTE_UNUSED) {
+    if (attr->atype == XML_ATTRIBUTE_ID) (*count)++;
+}
+
+/**
+ * xmlValidateAttributeDecl:
+ * @ctxt:  the validation context
+ * @doc:  a document instance
+ * @attr:  an attribute definition
+ *
+ * Try to validate a single attribute definition
+ * basically it does the following checks as described by the
+ * XML-1.0 recommendation:
+ *  - [ VC: Attribute Default Legal ]
+ *  - [ VC: Enumeration ]
+ *  - [ VC: ID Attribute Default ]
+ *
+ * The ID/IDREF uniqueness and matching are done separately
+ *
+ * returns 1 if valid or 0 otherwise
+ */
+
+int
+xmlValidateAttributeDecl(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
+                         xmlAttributePtr attr) {
+    int ret = 1;
+    int val;
+    CHECK_DTD;
+    if(attr == NULL) return(1);
+    
+    /* Attribute Default Legal */
+    /* Enumeration */
+    if (attr->defaultValue != NULL) {
+	val = xmlValidateAttributeValue(attr->atype, attr->defaultValue);
+	if (val == 0) {
+	    xmlErrValidNode(ctxt, (xmlNodePtr) attr, XML_DTD_ATTRIBUTE_DEFAULT,
+	       "Syntax of default value for attribute %s of %s is not valid\n",
+	           attr->name, attr->elem, NULL);
+	}
+        ret &= val;
+    }
+
+    /* ID Attribute Default */
+    if ((attr->atype == XML_ATTRIBUTE_ID)&&
+        (attr->def != XML_ATTRIBUTE_IMPLIED) &&
+	(attr->def != XML_ATTRIBUTE_REQUIRED)) {
+	xmlErrValidNode(ctxt, (xmlNodePtr) attr, XML_DTD_ID_FIXED,
+          "ID attribute %s of %s is not valid must be #IMPLIED or #REQUIRED\n",
+	       attr->name, attr->elem, NULL);
+	ret = 0;
+    }
+
+    /* One ID per Element Type */
+    if (attr->atype == XML_ATTRIBUTE_ID) {
+        int nbId;
+
+	/* the trick is that we parse DtD as their own internal subset */
+        xmlElementPtr elem = xmlGetDtdElementDesc(doc->intSubset,
+	                                          attr->elem);
+	if (elem != NULL) {
+	    nbId = xmlScanIDAttributeDecl(NULL, elem);
+	} else {
+	    xmlAttributeTablePtr table;
+
+	    /*
+	     * The attribute may be declared in the internal subset and the
+	     * element in the external subset.
+	     */
+	    nbId = 0;
+	    table = (xmlAttributeTablePtr) doc->intSubset->attributes;
+	    xmlHashScan3(table, NULL, NULL, attr->elem, (xmlHashScanner)
+		         xmlValidateAttributeIdCallback, &nbId);
+	}
+	if (nbId > 1) {
+	    
+	    xmlErrValidNodeNr(ctxt, (xmlNodePtr) attr, XML_DTD_ID_SUBSET,
+       "Element %s has %d ID attribute defined in the internal subset : %s\n",
+		   attr->elem, nbId, attr->name);
+	} else if (doc->extSubset != NULL) {
+	    int extId = 0;
+	    elem = xmlGetDtdElementDesc(doc->extSubset, attr->elem);
+	    if (elem != NULL) {
+		extId = xmlScanIDAttributeDecl(NULL, elem);
+	    }
+	    if (extId > 1) {
+		xmlErrValidNodeNr(ctxt, (xmlNodePtr) attr, XML_DTD_ID_SUBSET,
+       "Element %s has %d ID attribute defined in the external subset : %s\n",
+		       attr->elem, extId, attr->name);
+	    } else if (extId + nbId > 1) {
+		xmlErrValidNode(ctxt, (xmlNodePtr) attr, XML_DTD_ID_SUBSET,
+"Element %s has ID attributes defined in the internal and external subset : %s\n",
+		       attr->elem, attr->name, NULL);
+	    }
+	}
+    }
+
+    /* Validity Constraint: Enumeration */
+    if ((attr->defaultValue != NULL) && (attr->tree != NULL)) {
+        xmlEnumerationPtr tree = attr->tree;
+	while (tree != NULL) {
+	    if (xmlStrEqual(tree->name, attr->defaultValue)) break;
+	    tree = tree->next;
+	}
+	if (tree == NULL) {
+	    xmlErrValidNode(ctxt, (xmlNodePtr) attr, XML_DTD_ATTRIBUTE_VALUE,
+"Default value \"%s\" for attribute %s of %s is not among the enumerated set\n",
+		   attr->defaultValue, attr->name, attr->elem);
+	    ret = 0;
+	}
+    }
+
+    return(ret);
+}
+
+/**
+ * xmlValidateElementDecl:
+ * @ctxt:  the validation context
+ * @doc:  a document instance
+ * @elem:  an element definition
+ *
+ * Try to validate a single element definition
+ * basically it does the following checks as described by the
+ * XML-1.0 recommendation:
+ *  - [ VC: One ID per Element Type ]
+ *  - [ VC: No Duplicate Types ]
+ *  - [ VC: Unique Element Type Declaration ]
+ *
+ * returns 1 if valid or 0 otherwise
+ */
+
+int
+xmlValidateElementDecl(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
+                       xmlElementPtr elem) {
+    int ret = 1;
+    xmlElementPtr tst;
+
+    CHECK_DTD;
+    
+    if (elem == NULL) return(1);
+
+#if 0
+#ifdef LIBXML_REGEXP_ENABLED
+    /* Build the regexp associated to the content model */
+    ret = xmlValidBuildContentModel(ctxt, elem);
+#endif
+#endif
+
+    /* No Duplicate Types */
+    if (elem->etype == XML_ELEMENT_TYPE_MIXED) {
+	xmlElementContentPtr cur, next;
+        const xmlChar *name;
+
+	cur = elem->content;
+	while (cur != NULL) {
+	    if (cur->type != XML_ELEMENT_CONTENT_OR) break;
+	    if (cur->c1 == NULL) break;
+	    if (cur->c1->type == XML_ELEMENT_CONTENT_ELEMENT) {
+		name = cur->c1->name;
+		next = cur->c2;
+		while (next != NULL) {
+		    if (next->type == XML_ELEMENT_CONTENT_ELEMENT) {
+		        if ((xmlStrEqual(next->name, name)) &&
+			    (xmlStrEqual(next->prefix, cur->prefix))) {
+			    if (cur->prefix == NULL) {
+				xmlErrValidNode(ctxt, (xmlNodePtr) elem, XML_DTD_CONTENT_ERROR,
+		   "Definition of %s has duplicate references of %s\n",
+				       elem->name, name, NULL);
+			    } else {
+				xmlErrValidNode(ctxt, (xmlNodePtr) elem, XML_DTD_CONTENT_ERROR,
+		   "Definition of %s has duplicate references of %s:%s\n",
+				       elem->name, cur->prefix, name);
+			    }
+			    ret = 0;
+			}
+			break;
+		    }
+		    if (next->c1 == NULL) break;
+		    if (next->c1->type != XML_ELEMENT_CONTENT_ELEMENT) break;
+		    if ((xmlStrEqual(next->c1->name, name)) &&
+		        (xmlStrEqual(next->c1->prefix, cur->prefix))) {
+			if (cur->prefix == NULL) {
+			    xmlErrValidNode(ctxt, (xmlNodePtr) elem, XML_DTD_CONTENT_ERROR,
+	       "Definition of %s has duplicate references to %s\n",
+				   elem->name, name, NULL);
+			} else {
+			    xmlErrValidNode(ctxt, (xmlNodePtr) elem, XML_DTD_CONTENT_ERROR,
+	       "Definition of %s has duplicate references to %s:%s\n",
+				   elem->name, cur->prefix, name);
+			}
+			ret = 0;
+		    }
+		    next = next->c2;
+		}
+	    }
+	    cur = cur->c2;
+	}
+    }
+
+    /* VC: Unique Element Type Declaration */
+    tst = xmlGetDtdElementDesc(doc->intSubset, elem->name);
+    if ((tst != NULL ) && (tst != elem) &&
+	((tst->prefix == elem->prefix) ||
+	 (xmlStrEqual(tst->prefix, elem->prefix))) &&
+	(tst->etype != XML_ELEMENT_TYPE_UNDEFINED)) {
+	xmlErrValidNode(ctxt, (xmlNodePtr) elem, XML_DTD_ELEM_REDEFINED,
+	                "Redefinition of element %s\n",
+		       elem->name, NULL, NULL);
+	ret = 0;
+    }
+    tst = xmlGetDtdElementDesc(doc->extSubset, elem->name);
+    if ((tst != NULL ) && (tst != elem) &&
+	((tst->prefix == elem->prefix) ||
+	 (xmlStrEqual(tst->prefix, elem->prefix))) &&
+	(tst->etype != XML_ELEMENT_TYPE_UNDEFINED)) {
+	xmlErrValidNode(ctxt, (xmlNodePtr) elem, XML_DTD_ELEM_REDEFINED,
+	                "Redefinition of element %s\n",
+		       elem->name, NULL, NULL);
+	ret = 0;
+    }
+    /* One ID per Element Type
+     * already done when registering the attribute
+    if (xmlScanIDAttributeDecl(ctxt, elem) > 1) {
+	ret = 0;
+    } */
+    return(ret);
+}
+
+/**
+ * xmlValidateOneAttribute:
+ * @ctxt:  the validation context
+ * @doc:  a document instance
+ * @elem:  an element instance
+ * @attr:  an attribute instance
+ * @value:  the attribute value (without entities processing)
+ *
+ * Try to validate a single attribute for an element
+ * basically it does the following checks as described by the
+ * XML-1.0 recommendation:
+ *  - [ VC: Attribute Value Type ]
+ *  - [ VC: Fixed Attribute Default ]
+ *  - [ VC: Entity Name ]
+ *  - [ VC: Name Token ]
+ *  - [ VC: ID ]
+ *  - [ VC: IDREF ]
+ *  - [ VC: Entity Name ]
+ *  - [ VC: Notation Attributes ]
+ *
+ * The ID/IDREF uniqueness and matching are done separately
+ *
+ * returns 1 if valid or 0 otherwise
+ */
+
+int
+xmlValidateOneAttribute(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
+                        xmlNodePtr elem, xmlAttrPtr attr, const xmlChar *value) 
+{
+    xmlAttributePtr attrDecl =  NULL;
+    int val;
+    int ret = 1;
+
+    CHECK_DTD;
+    if ((elem == NULL) || (elem->name == NULL)) return(0);
+    if ((attr == NULL) || (attr->name == NULL)) return(0);
+
+    if ((elem->ns != NULL) && (elem->ns->prefix != NULL)) {
+	xmlChar fn[50];
+	xmlChar *fullname;
+	
+	fullname = xmlBuildQName(elem->name, elem->ns->prefix, fn, 50);
+	if (fullname == NULL)
+	    return(0);
+	if (attr->ns != NULL) {
+	    attrDecl = xmlGetDtdQAttrDesc(doc->intSubset, fullname,
+		                          attr->name, attr->ns->prefix);
+	    if ((attrDecl == NULL) && (doc->extSubset != NULL))
+		attrDecl = xmlGetDtdQAttrDesc(doc->extSubset, fullname,
+					      attr->name, attr->ns->prefix);
+	} else {
+	    attrDecl = xmlGetDtdAttrDesc(doc->intSubset, fullname, attr->name);
+	    if ((attrDecl == NULL) && (doc->extSubset != NULL))
+		attrDecl = xmlGetDtdAttrDesc(doc->extSubset,
+					     fullname, attr->name);
+	}
+	if ((fullname != fn) && (fullname != elem->name))
+	    xmlFree(fullname);
+    }
+    if (attrDecl == NULL) {
+	if (attr->ns != NULL) {
+	    attrDecl = xmlGetDtdQAttrDesc(doc->intSubset, elem->name,
+		                          attr->name, attr->ns->prefix);
+	    if ((attrDecl == NULL) && (doc->extSubset != NULL))
+		attrDecl = xmlGetDtdQAttrDesc(doc->extSubset, elem->name,
+					      attr->name, attr->ns->prefix);
+	} else {
+	    attrDecl = xmlGetDtdAttrDesc(doc->intSubset,
+		                         elem->name, attr->name);
+	    if ((attrDecl == NULL) && (doc->extSubset != NULL))
+		attrDecl = xmlGetDtdAttrDesc(doc->extSubset,
+					     elem->name, attr->name);
+	}
+    }
+
+
+    /* Validity Constraint: Attribute Value Type */
+    if (attrDecl == NULL) {
+	xmlErrValidNode(ctxt, elem, XML_DTD_UNKNOWN_ATTRIBUTE,
+	       "No declaration for attribute %s of element %s\n",
+	       attr->name, elem->name, NULL);
+	return(0);
+    }
+    attr->atype = attrDecl->atype;
+
+    val = xmlValidateAttributeValue(attrDecl->atype, value);
+    if (val == 0) {
+	    xmlErrValidNode(ctxt, elem, XML_DTD_ATTRIBUTE_VALUE,
+	   "Syntax of value for attribute %s of %s is not valid\n",
+	       attr->name, elem->name, NULL);
+        ret = 0;
+    }
+
+    /* Validity constraint: Fixed Attribute Default */
+    if (attrDecl->def == XML_ATTRIBUTE_FIXED) {
+	if (!xmlStrEqual(value, attrDecl->defaultValue)) {
+	    xmlErrValidNode(ctxt, elem, XML_DTD_ATTRIBUTE_DEFAULT,
+	   "Value for attribute %s of %s is different from default \"%s\"\n",
+		   attr->name, elem->name, attrDecl->defaultValue);
+	    ret = 0;
+	}
+    }
+
+    /* Validity Constraint: ID uniqueness */
+    if (attrDecl->atype == XML_ATTRIBUTE_ID) {
+        if (xmlAddID(ctxt, doc, value, attr) == NULL)
+	    ret = 0;
+    }
+
+    if ((attrDecl->atype == XML_ATTRIBUTE_IDREF) ||
+	(attrDecl->atype == XML_ATTRIBUTE_IDREFS)) {
+        if (xmlAddRef(ctxt, doc, value, attr) == NULL)
+	    ret = 0;
+    }
+
+    /* Validity Constraint: Notation Attributes */
+    if (attrDecl->atype == XML_ATTRIBUTE_NOTATION) {
+        xmlEnumerationPtr tree = attrDecl->tree;
+        xmlNotationPtr nota;
+
+        /* First check that the given NOTATION was declared */
+	nota = xmlGetDtdNotationDesc(doc->intSubset, value);
+	if (nota == NULL)
+	    nota = xmlGetDtdNotationDesc(doc->extSubset, value);
+	
+	if (nota == NULL) {
+	    xmlErrValidNode(ctxt, elem, XML_DTD_UNKNOWN_NOTATION,
+       "Value \"%s\" for attribute %s of %s is not a declared Notation\n",
+		   value, attr->name, elem->name);
+	    ret = 0;
+        }
+
+	/* Second, verify that it's among the list */
+	while (tree != NULL) {
+	    if (xmlStrEqual(tree->name, value)) break;
+	    tree = tree->next;
+	}
+	if (tree == NULL) {
+	    xmlErrValidNode(ctxt, elem, XML_DTD_NOTATION_VALUE,
+"Value \"%s\" for attribute %s of %s is not among the enumerated notations\n",
+		   value, attr->name, elem->name);
+	    ret = 0;
+	}
+    }
+
+    /* Validity Constraint: Enumeration */
+    if (attrDecl->atype == XML_ATTRIBUTE_ENUMERATION) {
+        xmlEnumerationPtr tree = attrDecl->tree;
+	while (tree != NULL) {
+	    if (xmlStrEqual(tree->name, value)) break;
+	    tree = tree->next;
+	}
+	if (tree == NULL) {
+	    xmlErrValidNode(ctxt, elem, XML_DTD_ATTRIBUTE_VALUE,
+       "Value \"%s\" for attribute %s of %s is not among the enumerated set\n",
+		   value, attr->name, elem->name);
+	    ret = 0;
+	}
+    }
+
+    /* Fixed Attribute Default */
+    if ((attrDecl->def == XML_ATTRIBUTE_FIXED) &&
+        (!xmlStrEqual(attrDecl->defaultValue, value))) {
+	xmlErrValidNode(ctxt, elem, XML_DTD_ATTRIBUTE_VALUE,
+	   "Value for attribute %s of %s must be \"%s\"\n",
+	       attr->name, elem->name, attrDecl->defaultValue);
+        ret = 0;
+    }
+
+    /* Extra check for the attribute value */
+    ret &= xmlValidateAttributeValue2(ctxt, doc, attr->name,
+				      attrDecl->atype, value);
+
+    return(ret);
+}
+
+/**
+ * xmlValidateOneNamespace:
+ * @ctxt:  the validation context
+ * @doc:  a document instance
+ * @elem:  an element instance
+ * @prefix:  the namespace prefix
+ * @ns:  an namespace declaration instance
+ * @value:  the attribute value (without entities processing)
+ *
+ * Try to validate a single namespace declaration for an element
+ * basically it does the following checks as described by the
+ * XML-1.0 recommendation:
+ *  - [ VC: Attribute Value Type ]
+ *  - [ VC: Fixed Attribute Default ]
+ *  - [ VC: Entity Name ]
+ *  - [ VC: Name Token ]
+ *  - [ VC: ID ]
+ *  - [ VC: IDREF ]
+ *  - [ VC: Entity Name ]
+ *  - [ VC: Notation Attributes ]
+ *
+ * The ID/IDREF uniqueness and matching are done separately
+ *
+ * returns 1 if valid or 0 otherwise
+ */
+
+int
+xmlValidateOneNamespace(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
+xmlNodePtr elem, const xmlChar *prefix, xmlNsPtr ns, const xmlChar *value) {
+    /* xmlElementPtr elemDecl; */
+    xmlAttributePtr attrDecl =  NULL;
+    int val;
+    int ret = 1;
+
+    CHECK_DTD;
+    if ((elem == NULL) || (elem->name == NULL)) return(0);
+    if ((ns == NULL) || (ns->href == NULL)) return(0);
+
+    if (prefix != NULL) {
+	xmlChar fn[50];
+	xmlChar *fullname;
+	
+	fullname = xmlBuildQName(elem->name, prefix, fn, 50);
+	if (fullname == NULL) {
+	    xmlVErrMemory(ctxt, "Validating namespace");
+	    return(0);
+	}
+	if (ns->prefix != NULL) {
+	    attrDecl = xmlGetDtdQAttrDesc(doc->intSubset, fullname,
+		                          ns->prefix, BAD_CAST "xmlns");
+	    if ((attrDecl == NULL) && (doc->extSubset != NULL))
+		attrDecl = xmlGetDtdQAttrDesc(doc->extSubset, fullname,
+					  ns->prefix, BAD_CAST "xmlns");
+	} else {
+	    attrDecl = xmlGetDtdAttrDesc(doc->intSubset, fullname,
+		                         BAD_CAST "xmlns");
+	    if ((attrDecl == NULL) && (doc->extSubset != NULL))
+		attrDecl = xmlGetDtdAttrDesc(doc->extSubset, fullname,
+			                 BAD_CAST "xmlns");
+	}
+	if ((fullname != fn) && (fullname != elem->name))
+	    xmlFree(fullname);
+    }
+    if (attrDecl == NULL) {
+	if (ns->prefix != NULL) {
+	    attrDecl = xmlGetDtdQAttrDesc(doc->intSubset, elem->name,
+		                          ns->prefix, BAD_CAST "xmlns");
+	    if ((attrDecl == NULL) && (doc->extSubset != NULL))
+		attrDecl = xmlGetDtdQAttrDesc(doc->extSubset, elem->name,
+					      ns->prefix, BAD_CAST "xmlns");
+	} else {
+	    attrDecl = xmlGetDtdAttrDesc(doc->intSubset,
+		                         elem->name, BAD_CAST "xmlns");
+	    if ((attrDecl == NULL) && (doc->extSubset != NULL))
+		attrDecl = xmlGetDtdAttrDesc(doc->extSubset,
+					     elem->name, BAD_CAST "xmlns");
+	}
+    }
+
+
+    /* Validity Constraint: Attribute Value Type */
+    if (attrDecl == NULL) {
+	if (ns->prefix != NULL) {
+	    xmlErrValidNode(ctxt, elem, XML_DTD_UNKNOWN_ATTRIBUTE,
+		   "No declaration for attribute xmlns:%s of element %s\n",
+		   ns->prefix, elem->name, NULL);
+	} else {
+	    xmlErrValidNode(ctxt, elem, XML_DTD_UNKNOWN_ATTRIBUTE,
+		   "No declaration for attribute xmlns of element %s\n",
+		   elem->name, NULL, NULL);
+	}
+	return(0);
+    }
+
+    val = xmlValidateAttributeValue(attrDecl->atype, value);
+    if (val == 0) {
+	if (ns->prefix != NULL) {
+	    xmlErrValidNode(ctxt, elem, XML_DTD_INVALID_DEFAULT,
+	       "Syntax of value for attribute xmlns:%s of %s is not valid\n",
+		   ns->prefix, elem->name, NULL);
+	} else {
+	    xmlErrValidNode(ctxt, elem, XML_DTD_INVALID_DEFAULT,
+	       "Syntax of value for attribute xmlns of %s is not valid\n",
+		   elem->name, NULL, NULL);
+	}
+        ret = 0;
+    }
+
+    /* Validity constraint: Fixed Attribute Default */
+    if (attrDecl->def == XML_ATTRIBUTE_FIXED) {
+	if (!xmlStrEqual(value, attrDecl->defaultValue)) {
+	    if (ns->prefix != NULL) {
+		xmlErrValidNode(ctxt, elem, XML_DTD_ATTRIBUTE_DEFAULT,
+       "Value for attribute xmlns:%s of %s is different from default \"%s\"\n",
+		       ns->prefix, elem->name, attrDecl->defaultValue);
+	    } else {
+		xmlErrValidNode(ctxt, elem, XML_DTD_ATTRIBUTE_DEFAULT,
+       "Value for attribute xmlns of %s is different from default \"%s\"\n",
+		       elem->name, attrDecl->defaultValue, NULL);
+	    }
+	    ret = 0;
+	}
+    }
+
+    /* Validity Constraint: ID uniqueness */
+    if (attrDecl->atype == XML_ATTRIBUTE_ID) {
+        if (xmlAddID(ctxt, doc, value, (xmlAttrPtr) ns) == NULL)
+	    ret = 0;
+    }
+
+    if ((attrDecl->atype == XML_ATTRIBUTE_IDREF) ||
+	(attrDecl->atype == XML_ATTRIBUTE_IDREFS)) {
+        if (xmlAddRef(ctxt, doc, value, (xmlAttrPtr) ns) == NULL)
+	    ret = 0;
+    }
+
+    /* Validity Constraint: Notation Attributes */
+    if (attrDecl->atype == XML_ATTRIBUTE_NOTATION) {
+        xmlEnumerationPtr tree = attrDecl->tree;
+        xmlNotationPtr nota;
+
+        /* First check that the given NOTATION was declared */
+	nota = xmlGetDtdNotationDesc(doc->intSubset, value);
+	if (nota == NULL)
+	    nota = xmlGetDtdNotationDesc(doc->extSubset, value);
+	
+	if (nota == NULL) {
+	    if (ns->prefix != NULL) {
+		xmlErrValidNode(ctxt, elem, XML_DTD_UNKNOWN_NOTATION,
+       "Value \"%s\" for attribute xmlns:%s of %s is not a declared Notation\n",
+		       value, ns->prefix, elem->name);
+	    } else {
+		xmlErrValidNode(ctxt, elem, XML_DTD_UNKNOWN_NOTATION,
+       "Value \"%s\" for attribute xmlns of %s is not a declared Notation\n",
+		       value, elem->name, NULL);
+	    }
+	    ret = 0;
+        }
+
+	/* Second, verify that it's among the list */
+	while (tree != NULL) {
+	    if (xmlStrEqual(tree->name, value)) break;
+	    tree = tree->next;
+	}
+	if (tree == NULL) {
+	    if (ns->prefix != NULL) {
+		xmlErrValidNode(ctxt, elem, XML_DTD_NOTATION_VALUE,
+"Value \"%s\" for attribute xmlns:%s of %s is not among the enumerated notations\n",
+		       value, ns->prefix, elem->name);
+	    } else {
+		xmlErrValidNode(ctxt, elem, XML_DTD_NOTATION_VALUE,
+"Value \"%s\" for attribute xmlns of %s is not among the enumerated notations\n",
+		       value, elem->name, NULL);
+	    }
+	    ret = 0;
+	}
+    }
+
+    /* Validity Constraint: Enumeration */
+    if (attrDecl->atype == XML_ATTRIBUTE_ENUMERATION) {
+        xmlEnumerationPtr tree = attrDecl->tree;
+	while (tree != NULL) {
+	    if (xmlStrEqual(tree->name, value)) break;
+	    tree = tree->next;
+	}
+	if (tree == NULL) {
+	    if (ns->prefix != NULL) {
+		xmlErrValidNode(ctxt, elem, XML_DTD_ATTRIBUTE_VALUE,
+"Value \"%s\" for attribute xmlns:%s of %s is not among the enumerated set\n",
+		       value, ns->prefix, elem->name);
+	    } else {
+		xmlErrValidNode(ctxt, elem, XML_DTD_ATTRIBUTE_VALUE,
+"Value \"%s\" for attribute xmlns of %s is not among the enumerated set\n",
+		       value, elem->name, NULL);
+	    }
+	    ret = 0;
+	}
+    }
+
+    /* Fixed Attribute Default */
+    if ((attrDecl->def == XML_ATTRIBUTE_FIXED) &&
+        (!xmlStrEqual(attrDecl->defaultValue, value))) {
+	if (ns->prefix != NULL) {
+	    xmlErrValidNode(ctxt, elem, XML_DTD_ELEM_NAMESPACE,
+		   "Value for attribute xmlns:%s of %s must be \"%s\"\n",
+		   ns->prefix, elem->name, attrDecl->defaultValue);
+	} else {
+	    xmlErrValidNode(ctxt, elem, XML_DTD_ELEM_NAMESPACE,
+		   "Value for attribute xmlns of %s must be \"%s\"\n",
+		   elem->name, attrDecl->defaultValue, NULL);
+	}
+        ret = 0;
+    }
+
+    /* Extra check for the attribute value */
+    if (ns->prefix != NULL) {
+	ret &= xmlValidateAttributeValue2(ctxt, doc, ns->prefix,
+					  attrDecl->atype, value);
+    } else {
+	ret &= xmlValidateAttributeValue2(ctxt, doc, BAD_CAST "xmlns",
+					  attrDecl->atype, value);
+    }
+
+    return(ret);
+}
+
+#ifndef  LIBXML_REGEXP_ENABLED
+/**
+ * xmlValidateSkipIgnorable:
+ * @ctxt:  the validation context
+ * @child:  the child list
+ *
+ * Skip ignorable elements w.r.t. the validation process
+ *
+ * returns the first element to consider for validation of the content model
+ */
+
+static xmlNodePtr
+xmlValidateSkipIgnorable(xmlNodePtr child) {
+    while (child != NULL) {
+	switch (child->type) {
+	    /* These things are ignored (skipped) during validation.  */
+	    case XML_PI_NODE:
+	    case XML_COMMENT_NODE:
+	    case XML_XINCLUDE_START:
+	    case XML_XINCLUDE_END:
+		child = child->next;
+		break;
+	    case XML_TEXT_NODE:
+		if (xmlIsBlankNode(child))
+		    child = child->next;
+		else
+		    return(child);
+		break;
+	    /* keep current node */
+	    default:
+		return(child);
+	}
+    }
+    return(child);
+}
+
+/**
+ * xmlValidateElementType:
+ * @ctxt:  the validation context
+ *
+ * Try to validate the content model of an element internal function
+ *
+ * returns 1 if valid or 0 ,-1 in case of error, -2 if an entity
+ *           reference is found and -3 if the validation succeeded but
+ *           the content model is not determinist.
+ */
+
+static int
+xmlValidateElementType(xmlValidCtxtPtr ctxt) {
+    int ret = -1;
+    int determinist = 1;
+
+    NODE = xmlValidateSkipIgnorable(NODE);
+    if ((NODE == NULL) && (CONT == NULL))
+	return(1);
+    if ((NODE == NULL) && 
+	((CONT->ocur == XML_ELEMENT_CONTENT_MULT) ||
+	 (CONT->ocur == XML_ELEMENT_CONTENT_OPT))) {
+	return(1);
+    }
+    if (CONT == NULL) return(-1);
+    if ((NODE != NULL) && (NODE->type == XML_ENTITY_REF_NODE))
+	return(-2);
+
+    /*
+     * We arrive here when more states need to be examined
+     */
+cont:
+
+    /*
+     * We just recovered from a rollback generated by a possible
+     * epsilon transition, go directly to the analysis phase
+     */
+    if (STATE == ROLLBACK_PARENT) {
+	DEBUG_VALID_MSG("restored parent branch");
+	DEBUG_VALID_STATE(NODE, CONT)
+	ret = 1;
+	goto analyze;
+    }
+
+    DEBUG_VALID_STATE(NODE, CONT)
+    /*
+     * we may have to save a backup state here. This is the equivalent
+     * of handling epsilon transition in NFAs.
+     */
+    if ((CONT != NULL) &&
+	((CONT->parent == NULL) ||
+	 (CONT->parent->type != XML_ELEMENT_CONTENT_OR)) &&
+	((CONT->ocur == XML_ELEMENT_CONTENT_MULT) ||
+	 (CONT->ocur == XML_ELEMENT_CONTENT_OPT) ||
+	 ((CONT->ocur == XML_ELEMENT_CONTENT_PLUS) && (OCCURRENCE)))) {
+	DEBUG_VALID_MSG("saving parent branch");
+	if (vstateVPush(ctxt, CONT, NODE, DEPTH, OCCURS, ROLLBACK_PARENT) < 0)
+	    return(0);
+    }
+
+
+    /*
+     * Check first if the content matches
+     */
+    switch (CONT->type) {
+	case XML_ELEMENT_CONTENT_PCDATA:
+	    if (NODE == NULL) {
+		DEBUG_VALID_MSG("pcdata failed no node");
+		ret = 0;
+		break;
+	    }
+	    if (NODE->type == XML_TEXT_NODE) {
+		DEBUG_VALID_MSG("pcdata found, skip to next");
+		/*
+		 * go to next element in the content model
+		 * skipping ignorable elems
+		 */
+		do {
+		    NODE = NODE->next;
+		    NODE = xmlValidateSkipIgnorable(NODE);
+		    if ((NODE != NULL) &&
+			(NODE->type == XML_ENTITY_REF_NODE))
+			return(-2);
+		} while ((NODE != NULL) &&
+			 ((NODE->type != XML_ELEMENT_NODE) &&
+			  (NODE->type != XML_TEXT_NODE) &&
+			  (NODE->type != XML_CDATA_SECTION_NODE)));
+                ret = 1;
+		break;
+	    } else {
+		DEBUG_VALID_MSG("pcdata failed");
+		ret = 0;
+		break;
+	    }
+	    break;
+	case XML_ELEMENT_CONTENT_ELEMENT:
+	    if (NODE == NULL) {
+		DEBUG_VALID_MSG("element failed no node");
+		ret = 0;
+		break;
+	    }
+	    ret = ((NODE->type == XML_ELEMENT_NODE) &&
+		   (xmlStrEqual(NODE->name, CONT->name)));
+	    if (ret == 1) {
+		if ((NODE->ns == NULL) || (NODE->ns->prefix == NULL)) {
+		    ret = (CONT->prefix == NULL);
+		} else if (CONT->prefix == NULL) {
+		    ret = 0;
+		} else {
+		    ret = xmlStrEqual(NODE->ns->prefix, CONT->prefix);
+		}
+	    }
+	    if (ret == 1) {
+		DEBUG_VALID_MSG("element found, skip to next");
+		/*
+		 * go to next element in the content model
+		 * skipping ignorable elems
+		 */
+		do {
+		    NODE = NODE->next;
+		    NODE = xmlValidateSkipIgnorable(NODE);
+		    if ((NODE != NULL) &&
+			(NODE->type == XML_ENTITY_REF_NODE))
+			return(-2);
+		} while ((NODE != NULL) &&
+			 ((NODE->type != XML_ELEMENT_NODE) &&
+			  (NODE->type != XML_TEXT_NODE) &&
+			  (NODE->type != XML_CDATA_SECTION_NODE)));
+	    } else {
+		DEBUG_VALID_MSG("element failed");
+		ret = 0;
+		break;
+	    }
+	    break;
+	case XML_ELEMENT_CONTENT_OR:
+	    /*
+	     * Small optimization.
+	     */
+	    if (CONT->c1->type == XML_ELEMENT_CONTENT_ELEMENT) {
+		if ((NODE == NULL) ||
+		    (!xmlStrEqual(NODE->name, CONT->c1->name))) {
+		    DEPTH++;
+		    CONT = CONT->c2;
+		    goto cont;
+		}
+		if ((NODE->ns == NULL) || (NODE->ns->prefix == NULL)) {
+		    ret = (CONT->c1->prefix == NULL);
+		} else if (CONT->c1->prefix == NULL) {
+		    ret = 0;
+		} else {
+		    ret = xmlStrEqual(NODE->ns->prefix, CONT->c1->prefix);
+		}
+		if (ret == 0) {
+		    DEPTH++;
+		    CONT = CONT->c2;
+		    goto cont;
+		}
+	    }
+
+	    /*
+	     * save the second branch 'or' branch
+	     */
+	    DEBUG_VALID_MSG("saving 'or' branch");
+	    if (vstateVPush(ctxt, CONT->c2, NODE, (unsigned char)(DEPTH + 1),
+			    OCCURS, ROLLBACK_OR) < 0)
+		return(-1);
+	    DEPTH++;
+	    CONT = CONT->c1;
+	    goto cont;
+	case XML_ELEMENT_CONTENT_SEQ:
+	    /*
+	     * Small optimization.
+	     */
+	    if ((CONT->c1->type == XML_ELEMENT_CONTENT_ELEMENT) &&
+		((CONT->c1->ocur == XML_ELEMENT_CONTENT_OPT) ||
+		 (CONT->c1->ocur == XML_ELEMENT_CONTENT_MULT))) {
+		if ((NODE == NULL) ||
+		    (!xmlStrEqual(NODE->name, CONT->c1->name))) {
+		    DEPTH++;
+		    CONT = CONT->c2;
+		    goto cont;
+		}
+		if ((NODE->ns == NULL) || (NODE->ns->prefix == NULL)) {
+		    ret = (CONT->c1->prefix == NULL);
+		} else if (CONT->c1->prefix == NULL) {
+		    ret = 0;
+		} else {
+		    ret = xmlStrEqual(NODE->ns->prefix, CONT->c1->prefix);
+		}
+		if (ret == 0) {
+		    DEPTH++;
+		    CONT = CONT->c2;
+		    goto cont;
+		}
+	    }
+	    DEPTH++;
+	    CONT = CONT->c1;
+	    goto cont;
+    }
+
+    /*
+     * At this point handle going up in the tree
+     */
+    if (ret == -1) {
+	DEBUG_VALID_MSG("error found returning");
+	return(ret);
+    }
+analyze:
+    while (CONT != NULL) {
+	/*
+	 * First do the analysis depending on the occurrence model at
+	 * this level.
+	 */
+	if (ret == 0) {
+	    switch (CONT->ocur) {
+		xmlNodePtr cur;
+
+		case XML_ELEMENT_CONTENT_ONCE:
+		    cur = ctxt->vstate->node;
+		    DEBUG_VALID_MSG("Once branch failed, rollback");
+		    if (vstateVPop(ctxt) < 0 ) {
+			DEBUG_VALID_MSG("exhaustion, failed");
+			return(0);
+		    }
+		    if (cur != ctxt->vstate->node)
+			determinist = -3;
+		    goto cont;
+		case XML_ELEMENT_CONTENT_PLUS:
+		    if (OCCURRENCE == 0) {
+			cur = ctxt->vstate->node;
+			DEBUG_VALID_MSG("Plus branch failed, rollback");
+			if (vstateVPop(ctxt) < 0 ) {
+			    DEBUG_VALID_MSG("exhaustion, failed");
+			    return(0);
+			}
+			if (cur != ctxt->vstate->node)
+			    determinist = -3;
+			goto cont;
+		    }
+		    DEBUG_VALID_MSG("Plus branch found");
+		    ret = 1;
+		    break;
+		case XML_ELEMENT_CONTENT_MULT:
+#ifdef DEBUG_VALID_ALGO
+		    if (OCCURRENCE == 0) {
+			DEBUG_VALID_MSG("Mult branch failed");
+		    } else {
+			DEBUG_VALID_MSG("Mult branch found");
+		    }
+#endif
+		    ret = 1;
+		    break;
+		case XML_ELEMENT_CONTENT_OPT:
+		    DEBUG_VALID_MSG("Option branch failed");
+		    ret = 1;
+		    break;
+	    }
+	} else {
+	    switch (CONT->ocur) {
+		case XML_ELEMENT_CONTENT_OPT:
+		    DEBUG_VALID_MSG("Option branch succeeded");
+		    ret = 1;
+		    break;
+		case XML_ELEMENT_CONTENT_ONCE:
+		    DEBUG_VALID_MSG("Once branch succeeded");
+		    ret = 1;
+		    break;
+		case XML_ELEMENT_CONTENT_PLUS:
+		    if (STATE == ROLLBACK_PARENT) {
+			DEBUG_VALID_MSG("Plus branch rollback");
+			ret = 1;
+			break;
+		    }
+		    if (NODE == NULL) {
+			DEBUG_VALID_MSG("Plus branch exhausted");
+			ret = 1;
+			break;
+		    }
+		    DEBUG_VALID_MSG("Plus branch succeeded, continuing");
+		    SET_OCCURRENCE;
+		    goto cont;
+		case XML_ELEMENT_CONTENT_MULT:
+		    if (STATE == ROLLBACK_PARENT) {
+			DEBUG_VALID_MSG("Mult branch rollback");
+			ret = 1;
+			break;
+		    }
+		    if (NODE == NULL) {
+			DEBUG_VALID_MSG("Mult branch exhausted");
+			ret = 1;
+			break;
+		    }
+		    DEBUG_VALID_MSG("Mult branch succeeded, continuing");
+		    /* SET_OCCURRENCE; */
+		    goto cont;
+	    }
+	}
+	STATE = 0;
+
+	/*
+	 * Then act accordingly at the parent level
+	 */
+	RESET_OCCURRENCE;
+	if (CONT->parent == NULL)
+	    break;
+
+	switch (CONT->parent->type) {
+	    case XML_ELEMENT_CONTENT_PCDATA:
+		DEBUG_VALID_MSG("Error: parent pcdata");
+		return(-1);
+	    case XML_ELEMENT_CONTENT_ELEMENT:
+		DEBUG_VALID_MSG("Error: parent element");
+		return(-1);
+	    case XML_ELEMENT_CONTENT_OR:
+		if (ret == 1) {
+		    DEBUG_VALID_MSG("Or succeeded");
+		    CONT = CONT->parent;
+		    DEPTH--;
+		} else {
+		    DEBUG_VALID_MSG("Or failed");
+		    CONT = CONT->parent;
+		    DEPTH--;
+		}
+		break;
+	    case XML_ELEMENT_CONTENT_SEQ:
+		if (ret == 0) {
+		    DEBUG_VALID_MSG("Sequence failed");
+		    CONT = CONT->parent;
+		    DEPTH--;
+		} else if (CONT == CONT->parent->c1) {
+		    DEBUG_VALID_MSG("Sequence testing 2nd branch");
+		    CONT = CONT->parent->c2;
+		    goto cont;
+		} else {
+		    DEBUG_VALID_MSG("Sequence succeeded");
+		    CONT = CONT->parent;
+		    DEPTH--;
+		}
+	}
+    }
+    if (NODE != NULL) {
+	xmlNodePtr cur;
+
+	cur = ctxt->vstate->node;
+	DEBUG_VALID_MSG("Failed, remaining input, rollback");
+	if (vstateVPop(ctxt) < 0 ) {
+	    DEBUG_VALID_MSG("exhaustion, failed");
+	    return(0);
+	}
+	if (cur != ctxt->vstate->node)
+	    determinist = -3;
+	goto cont;
+    }
+    if (ret == 0) {
+	xmlNodePtr cur;
+
+	cur = ctxt->vstate->node;
+	DEBUG_VALID_MSG("Failure, rollback");
+	if (vstateVPop(ctxt) < 0 ) {
+	    DEBUG_VALID_MSG("exhaustion, failed");
+	    return(0);
+	}
+	if (cur != ctxt->vstate->node)
+	    determinist = -3;
+	goto cont;
+    }
+    return(determinist);
+}
+#endif
+
+/**
+ * xmlSnprintfElements:
+ * @buf:  an output buffer
+ * @size:  the size of the buffer
+ * @content:  An element
+ * @glob: 1 if one must print the englobing parenthesis, 0 otherwise
+ *
+ * This will dump the list of elements to the buffer
+ * Intended just for the debug routine
+ */
+static void
+xmlSnprintfElements(char *buf, int size, xmlNodePtr node, int glob) {
+    xmlNodePtr cur;
+    int len;
+
+    if (node == NULL) return;
+    if (glob) strcat(buf, "(");
+    cur = node;
+    while (cur != NULL) {
+	len = strlen(buf);
+	if (size - len < 50) {
+	    if ((size - len > 4) && (buf[len - 1] != '.'))
+		strcat(buf, " ...");
+	    return;
+	}
+        switch (cur->type) {
+            case XML_ELEMENT_NODE:
+		if ((cur->ns != NULL) && (cur->ns->prefix != NULL)) {
+		    if (size - len < xmlStrlen(cur->ns->prefix) + 10) {
+			if ((size - len > 4) && (buf[len - 1] != '.'))
+			    strcat(buf, " ...");
+			return;
+		    }
+		    strcat(buf, (char *) cur->ns->prefix);
+		    strcat(buf, ":");
+		}
+                if (size - len < xmlStrlen(cur->name) + 10) {
+		    if ((size - len > 4) && (buf[len - 1] != '.'))
+			strcat(buf, " ...");
+		    return;
+		}
+	        strcat(buf, (char *) cur->name);
+		if (cur->next != NULL)
+		    strcat(buf, " ");
+		break;
+            case XML_TEXT_NODE:
+		if (xmlIsBlankNode(cur))
+		    break;
+            case XML_CDATA_SECTION_NODE:
+            case XML_ENTITY_REF_NODE:
+	        strcat(buf, "CDATA");
+		if (cur->next != NULL)
+		    strcat(buf, " ");
+		break;
+            case XML_ATTRIBUTE_NODE:
+            case XML_DOCUMENT_NODE:
+#ifdef LIBXML_DOCB_ENABLED
+	    case XML_DOCB_DOCUMENT_NODE:
+#endif
+	    case XML_HTML_DOCUMENT_NODE:
+            case XML_DOCUMENT_TYPE_NODE:
+            case XML_DOCUMENT_FRAG_NODE:
+            case XML_NOTATION_NODE:
+	    case XML_NAMESPACE_DECL:
+	        strcat(buf, "???");
+		if (cur->next != NULL)
+		    strcat(buf, " ");
+		break;
+            case XML_ENTITY_NODE:
+            case XML_PI_NODE:
+            case XML_DTD_NODE:
+            case XML_COMMENT_NODE:
+	    case XML_ELEMENT_DECL:
+	    case XML_ATTRIBUTE_DECL:
+	    case XML_ENTITY_DECL:
+	    case XML_XINCLUDE_START:
+	    case XML_XINCLUDE_END:
+		break;
+	}
+	cur = cur->next;
+    }
+    if (glob) strcat(buf, ")");
+}
+
+/**
+ * xmlValidateElementContent:
+ * @ctxt:  the validation context
+ * @child:  the child list
+ * @elemDecl:  pointer to the element declaration
+ * @warn:  emit the error message
+ * @parent: the parent element (for error reporting)
+ *
+ * Try to validate the content model of an element
+ *
+ * returns 1 if valid or 0 if not and -1 in case of error
+ */
+
+static int
+xmlValidateElementContent(xmlValidCtxtPtr ctxt, xmlNodePtr child,
+       xmlElementPtr elemDecl, int warn, xmlNodePtr parent) {
+    int ret = 1;
+#ifndef  LIBXML_REGEXP_ENABLED
+    xmlNodePtr repl = NULL, last = NULL, tmp;
+#endif
+    xmlNodePtr cur;
+    xmlElementContentPtr cont;
+    const xmlChar *name;
+
+    if (elemDecl == NULL)
+	return(-1);
+    cont = elemDecl->content;
+    name = elemDecl->name;
+
+#ifdef LIBXML_REGEXP_ENABLED
+    /* Build the regexp associated to the content model */
+    if (elemDecl->contModel == NULL)
+	ret = xmlValidBuildContentModel(ctxt, elemDecl);
+    if (elemDecl->contModel == NULL) {
+	return(-1);
+    } else {
+	xmlRegExecCtxtPtr exec;
+
+	if (!xmlRegexpIsDeterminist(elemDecl->contModel)) {
+	    return(-1);
+	}
+	ctxt->nodeMax = 0;
+	ctxt->nodeNr = 0;
+	ctxt->nodeTab = NULL;
+	exec = xmlRegNewExecCtxt(elemDecl->contModel, NULL, NULL);
+	if (exec != NULL) {
+	    cur = child;
+	    while (cur != NULL) {
+		switch (cur->type) {
+		    case XML_ENTITY_REF_NODE:
+			/*
+			 * Push the current node to be able to roll back
+			 * and process within the entity
+			 */
+			if ((cur->children != NULL) &&
+			    (cur->children->children != NULL)) {
+			    nodeVPush(ctxt, cur);
+			    cur = cur->children->children;
+			    continue;
+			}
+			break;
+		    case XML_TEXT_NODE:
+			if (xmlIsBlankNode(cur))
+			    break;
+			ret = 0;
+			goto fail;
+		    case XML_CDATA_SECTION_NODE:
+			/* TODO */
+			ret = 0;
+			goto fail;
+		    case XML_ELEMENT_NODE:
+			if ((cur->ns != NULL) && (cur->ns->prefix != NULL)) {
+			    xmlChar fn[50];
+			    xmlChar *fullname;
+			    
+			    fullname = xmlBuildQName(cur->name,
+				                     cur->ns->prefix, fn, 50);
+			    if (fullname == NULL) {
+				ret = -1;
+				goto fail;
+			    }
+                            ret = xmlRegExecPushString(exec, fullname, NULL);
+			    if ((fullname != fn) && (fullname != cur->name))
+				xmlFree(fullname);
+			} else {
+			    ret = xmlRegExecPushString(exec, cur->name, NULL);
+			}
+			break;
+		    default:
+			break;
+		}
+		/*
+		 * Switch to next element
+		 */
+		cur = cur->next;
+		while (cur == NULL) {
+		    cur = nodeVPop(ctxt);
+		    if (cur == NULL)
+			break;
+		    cur = cur->next;
+		}
+	    }
+	    ret = xmlRegExecPushString(exec, NULL, NULL);
+fail:
+	    xmlRegFreeExecCtxt(exec);
+	}
+    }
+#else  /* LIBXML_REGEXP_ENABLED */
+    /*
+     * Allocate the stack
+     */
+    ctxt->vstateMax = 8;
+    ctxt->vstateTab = (xmlValidState *) xmlMalloc(
+		 ctxt->vstateMax * sizeof(ctxt->vstateTab[0]));
+    if (ctxt->vstateTab == NULL) {
+	xmlVErrMemory(ctxt, "malloc failed");
+	return(-1);
+    }
+    /*
+     * The first entry in the stack is reserved to the current state
+     */
+    ctxt->nodeMax = 0;
+    ctxt->nodeNr = 0;
+    ctxt->nodeTab = NULL;
+    ctxt->vstate = &ctxt->vstateTab[0];
+    ctxt->vstateNr = 1;
+    CONT = cont;
+    NODE = child;
+    DEPTH = 0;
+    OCCURS = 0;
+    STATE = 0;
+    ret = xmlValidateElementType(ctxt);
+    if ((ret == -3) && (warn)) {
+	xmlErrValidWarning(ctxt, child, XML_DTD_CONTENT_NOT_DETERMINIST,
+	       "Content model for Element %s is ambiguous\n",
+	                   name, NULL, NULL);
+    } else if (ret == -2) {
+	/*
+	 * An entities reference appeared at this level.
+	 * Buid a minimal representation of this node content
+	 * sufficient to run the validation process on it
+	 */
+	DEBUG_VALID_MSG("Found an entity reference, linearizing");
+	cur = child;
+	while (cur != NULL) {
+	    switch (cur->type) {
+		case XML_ENTITY_REF_NODE:
+		    /*
+		     * Push the current node to be able to roll back
+		     * and process within the entity
+		     */
+		    if ((cur->children != NULL) &&
+			(cur->children->children != NULL)) {
+			nodeVPush(ctxt, cur);
+			cur = cur->children->children;
+			continue;
+		    }
+		    break;
+		case XML_TEXT_NODE:
+		    if (xmlIsBlankNode(cur))
+			break;
+		    /* no break on purpose */
+		case XML_CDATA_SECTION_NODE:
+		    /* no break on purpose */
+		case XML_ELEMENT_NODE:
+		    /*
+		     * Allocate a new node and minimally fills in
+		     * what's required
+		     */
+		    tmp = (xmlNodePtr) xmlMalloc(sizeof(xmlNode));
+		    if (tmp == NULL) {
+			xmlVErrMemory(ctxt, "malloc failed");
+			xmlFreeNodeList(repl);
+			ret = -1;
+			goto done;
+		    }
+		    tmp->type = cur->type;
+		    tmp->name = cur->name;
+		    tmp->ns = cur->ns;
+		    tmp->next = NULL;
+		    tmp->content = NULL;
+		    if (repl == NULL)
+			repl = last = tmp;
+		    else {
+			last->next = tmp;
+			last = tmp;
+		    }
+		    if (cur->type == XML_CDATA_SECTION_NODE) {
+			/* 
+			 * E59 spaces in CDATA does not match the
+			 * nonterminal S
+			 */
+			tmp->content = xmlStrdup(BAD_CAST "CDATA");
+		    }
+		    break;
+		default:
+		    break;
+	    }
+	    /*
+	     * Switch to next element
+	     */
+	    cur = cur->next;
+	    while (cur == NULL) {
+		cur = nodeVPop(ctxt);
+		if (cur == NULL)
+		    break;
+		cur = cur->next;
+	    }
+	}
+
+	/*
+	 * Relaunch the validation
+	 */
+	ctxt->vstate = &ctxt->vstateTab[0];
+	ctxt->vstateNr = 1;
+	CONT = cont;
+	NODE = repl;
+	DEPTH = 0;
+	OCCURS = 0;
+	STATE = 0;
+	ret = xmlValidateElementType(ctxt);
+    }
+#endif /* LIBXML_REGEXP_ENABLED */
+    if ((warn) && ((ret != 1) && (ret != -3))) {
+	if ((ctxt != NULL) && (ctxt->warning != NULL)) {
+	    char expr[5000];
+	    char list[5000];
+
+	    expr[0] = 0;
+	    xmlSnprintfElementContent(&expr[0], 5000, cont, 1);
+	    list[0] = 0;
+#ifndef LIBXML_REGEXP_ENABLED
+	    if (repl != NULL)
+		xmlSnprintfElements(&list[0], 5000, repl, 1);
+	    else
+#endif /* LIBXML_REGEXP_ENABLED */
+		xmlSnprintfElements(&list[0], 5000, child, 1);
+
+	    if (name != NULL) {
+		xmlErrValidNode(ctxt, parent, XML_DTD_CONTENT_MODEL,
+	   "Element %s content does not follow the DTD, expecting %s, got %s\n",
+		       name, BAD_CAST expr, BAD_CAST list);
+	    } else {
+		xmlErrValidNode(ctxt, parent, XML_DTD_CONTENT_MODEL,
+	   "Element content does not follow the DTD, expecting %s, got %s\n",
+		       BAD_CAST expr, BAD_CAST list, NULL);
+	    }
+	} else {
+	    if (name != NULL) {
+		xmlErrValidNode(ctxt, parent, XML_DTD_CONTENT_MODEL,
+		       "Element %s content does not follow the DTD\n",
+		       name, NULL, NULL);
+	    } else {
+		xmlErrValidNode(ctxt, parent, XML_DTD_CONTENT_MODEL,
+		       "Element content does not follow the DTD\n",
+		                NULL, NULL, NULL);
+	    }
+	}
+	ret = 0;
+    }
+    if (ret == -3)
+	ret = 1;
+
+#ifndef  LIBXML_REGEXP_ENABLED
+done:
+    /*
+     * Deallocate the copy if done, and free up the validation stack
+     */
+    while (repl != NULL) {
+	tmp = repl->next;
+	xmlFree(repl);
+	repl = tmp;
+    }
+    ctxt->vstateMax = 0;
+    if (ctxt->vstateTab != NULL) {
+	xmlFree(ctxt->vstateTab);
+	ctxt->vstateTab = NULL;
+    }
+#endif
+    ctxt->nodeMax = 0;
+    ctxt->nodeNr = 0;
+    if (ctxt->nodeTab != NULL) {
+	xmlFree(ctxt->nodeTab);
+	ctxt->nodeTab = NULL;
+    }
+    return(ret);
+
+}
+
+/**
+ * xmlValidateCdataElement:
+ * @ctxt:  the validation context
+ * @doc:  a document instance
+ * @elem:  an element instance
+ *
+ * Check that an element follows #CDATA
+ *
+ * returns 1 if valid or 0 otherwise
+ */
+static int
+xmlValidateOneCdataElement(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
+                           xmlNodePtr elem) {
+    int ret = 1;
+    xmlNodePtr cur, child;
+
+    if ((ctxt == NULL) || (doc == NULL) || (elem == NULL))
+	return(0);
+
+    child = elem->children;
+
+    cur = child;
+    while (cur != NULL) {
+	switch (cur->type) {
+	    case XML_ENTITY_REF_NODE:
+		/*
+		 * Push the current node to be able to roll back
+		 * and process within the entity
+		 */
+		if ((cur->children != NULL) &&
+		    (cur->children->children != NULL)) {
+		    nodeVPush(ctxt, cur);
+		    cur = cur->children->children;
+		    continue;
+		}
+		break;
+	    case XML_COMMENT_NODE:
+	    case XML_PI_NODE:
+	    case XML_TEXT_NODE:
+	    case XML_CDATA_SECTION_NODE:
+		break;
+	    default:
+		ret = 0;
+		goto done;
+	}
+	/*
+	 * Switch to next element
+	 */
+	cur = cur->next;
+	while (cur == NULL) {
+	    cur = nodeVPop(ctxt);
+	    if (cur == NULL)
+		break;
+	    cur = cur->next;
+	}
+    }
+done:
+    ctxt->nodeMax = 0;
+    ctxt->nodeNr = 0;
+    if (ctxt->nodeTab != NULL) {
+	xmlFree(ctxt->nodeTab);
+	ctxt->nodeTab = NULL;
+    }
+    return(ret);
+}
+
+/**
+ * xmlValidateCheckMixed:
+ * @ctxt:  the validation context
+ * @cont:  the mixed content model
+ * @qname:  the qualified name as appearing in the serialization
+ *
+ * Check if the given node is part of the content model.
+ *
+ * Returns 1 if yes, 0 if no, -1 in case of error
+ */
+static int
+xmlValidateCheckMixed(xmlValidCtxtPtr ctxt,
+	              xmlElementContentPtr cont, const xmlChar *qname) {
+    const xmlChar *name;
+    int plen;
+    name = xmlSplitQName3(qname, &plen);
+
+    if (name == NULL) {
+	while (cont != NULL) {
+	    if (cont->type == XML_ELEMENT_CONTENT_ELEMENT) {
+		if ((cont->prefix == NULL) && (xmlStrEqual(cont->name, qname)))
+		    return(1);
+	    } else if ((cont->type == XML_ELEMENT_CONTENT_OR) &&
+	       (cont->c1 != NULL) &&
+	       (cont->c1->type == XML_ELEMENT_CONTENT_ELEMENT)){
+		if ((cont->c1->prefix == NULL) &&
+		    (xmlStrEqual(cont->c1->name, qname)))
+		    return(1);
+	    } else if ((cont->type != XML_ELEMENT_CONTENT_OR) ||
+		(cont->c1 == NULL) ||
+		(cont->c1->type != XML_ELEMENT_CONTENT_PCDATA)){
+		xmlErrValid(NULL, XML_DTD_MIXED_CORRUPT, 
+			"Internal: MIXED struct corrupted\n",
+			NULL);
+		break;
+	    }
+	    cont = cont->c2;
+	}
+    } else {
+	while (cont != NULL) {
+	    if (cont->type == XML_ELEMENT_CONTENT_ELEMENT) {
+		if ((cont->prefix != NULL) &&
+		    (xmlStrncmp(cont->prefix, qname, plen) == 0) &&
+		    (xmlStrEqual(cont->name, name)))
+		    return(1);
+	    } else if ((cont->type == XML_ELEMENT_CONTENT_OR) &&
+	       (cont->c1 != NULL) &&
+	       (cont->c1->type == XML_ELEMENT_CONTENT_ELEMENT)){
+		if ((cont->c1->prefix != NULL) &&
+		    (xmlStrncmp(cont->c1->prefix, qname, plen) == 0) &&
+		    (xmlStrEqual(cont->c1->name, name)))
+		    return(1);
+	    } else if ((cont->type != XML_ELEMENT_CONTENT_OR) ||
+		(cont->c1 == NULL) ||
+		(cont->c1->type != XML_ELEMENT_CONTENT_PCDATA)){
+		xmlErrValid(ctxt, XML_DTD_MIXED_CORRUPT, 
+			"Internal: MIXED struct corrupted\n",
+			NULL);
+		break;
+	    }
+	    cont = cont->c2;
+	}
+    }
+    return(0);
+}
+
+/**
+ * xmlValidGetElemDecl:
+ * @ctxt:  the validation context
+ * @doc:  a document instance
+ * @elem:  an element instance
+ * @extsubset:  pointer, (out) indicate if the declaration was found
+ *              in the external subset.
+ *
+ * Finds a declaration associated to an element in the document.
+ *
+ * returns the pointer to the declaration or NULL if not found.
+ */
+static xmlElementPtr
+xmlValidGetElemDecl(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
+	            xmlNodePtr elem, int *extsubset) {
+    xmlElementPtr elemDecl = NULL;
+    const xmlChar *prefix = NULL;
+
+    if ((elem == NULL) || (elem->name == NULL)) return(NULL);
+    if (extsubset != NULL)
+	*extsubset = 0;
+
+    /*
+     * Fetch the declaration for the qualified name
+     */
+    if ((elem->ns != NULL) && (elem->ns->prefix != NULL))
+	prefix = elem->ns->prefix;
+
+    if (prefix != NULL) {
+	elemDecl = xmlGetDtdQElementDesc(doc->intSubset,
+		                         elem->name, prefix);
+	if ((elemDecl == NULL) && (doc->extSubset != NULL)) {
+	    elemDecl = xmlGetDtdQElementDesc(doc->extSubset,
+		                             elem->name, prefix);
+	    if ((elemDecl != NULL) && (extsubset != NULL))
+		*extsubset = 1;
+	}
+    }
+
+    /*
+     * Fetch the declaration for the non qualified name
+     * This is "non-strict" validation should be done on the
+     * full QName but in that case being flexible makes sense.
+     */
+    if (elemDecl == NULL) {
+	elemDecl = xmlGetDtdElementDesc(doc->intSubset, elem->name);
+	if ((elemDecl == NULL) && (doc->extSubset != NULL)) {
+	    elemDecl = xmlGetDtdElementDesc(doc->extSubset, elem->name);
+	    if ((elemDecl != NULL) && (extsubset != NULL))
+		*extsubset = 1;
+	}
+    }
+    if (elemDecl == NULL) {
+	xmlErrValidNode(ctxt, elem,
+			XML_DTD_UNKNOWN_ELEM,
+	       "No declaration for element %s\n",
+	       elem->name, NULL, NULL);
+    }
+    return(elemDecl);
+}
+
+#ifdef LIBXML_REGEXP_ENABLED
+/**
+ * xmlValidatePushElement:
+ * @ctxt:  the validation context
+ * @doc:  a document instance
+ * @elem:  an element instance
+ * @qname:  the qualified name as appearing in the serialization
+ *
+ * Push a new element start on the validation stack.
+ *
+ * returns 1 if no validation problem was found or 0 otherwise
+ */
+int
+xmlValidatePushElement(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
+                       xmlNodePtr elem, const xmlChar *qname) {
+    int ret = 1;
+    xmlElementPtr eDecl;
+    int extsubset = 0;
+
+/* printf("PushElem %s\n", qname); */
+    if ((ctxt->vstateNr > 0) && (ctxt->vstate != NULL)) {
+	xmlValidStatePtr state = ctxt->vstate;
+	xmlElementPtr elemDecl;
+
+	/*
+	 * Check the new element agaisnt the content model of the new elem.
+	 */
+	if (state->elemDecl != NULL) {
+	    elemDecl = state->elemDecl;
+
+	    switch(elemDecl->etype) {
+		case XML_ELEMENT_TYPE_UNDEFINED:
+		    ret = 0;
+		    break;
+		case XML_ELEMENT_TYPE_EMPTY:
+		    xmlErrValidNode(ctxt, state->node,
+				    XML_DTD_NOT_EMPTY,
+	       "Element %s was declared EMPTY this one has content\n",
+			   state->node->name, NULL, NULL);
+		    ret = 0;
+		    break;
+		case XML_ELEMENT_TYPE_ANY:
+		    /* I don't think anything is required then */
+		    break;
+		case XML_ELEMENT_TYPE_MIXED:
+		    /* simple case of declared as #PCDATA */
+		    if ((elemDecl->content != NULL) &&
+			(elemDecl->content->type ==
+			 XML_ELEMENT_CONTENT_PCDATA)) {
+			xmlErrValidNode(ctxt, state->node,
+					XML_DTD_NOT_PCDATA,
+	       "Element %s was declared #PCDATA but contains non text nodes\n",
+				state->node->name, NULL, NULL);
+			ret = 0;
+		    } else {
+			ret = xmlValidateCheckMixed(ctxt, elemDecl->content,
+				                    qname);
+			if (ret != 1) {
+			    xmlErrValidNode(ctxt, state->node,
+					    XML_DTD_INVALID_CHILD,
+	       "Element %s is not declared in %s list of possible children\n",
+				    qname, state->node->name, NULL);
+			}
+		    }
+		    break;
+		case XML_ELEMENT_TYPE_ELEMENT:
+		    /*
+		     * TODO:
+		     * VC: Standalone Document Declaration
+		     *     - element types with element content, if white space
+		     *       occurs directly within any instance of those types.
+		     */
+		    if (state->exec != NULL) {
+			ret = xmlRegExecPushString(state->exec, qname, NULL);
+			if (ret < 0) {
+			    xmlErrValidNode(ctxt, state->node,
+					    XML_DTD_CONTENT_MODEL,
+	       "Element %s content does not follow the DTD, Misplaced %s\n",
+				   state->node->name, qname, NULL);
+			    ret = 0;
+			} else {
+			    ret = 1;
+			}
+		    }
+		    break;
+	    }
+	}
+    }
+    eDecl = xmlValidGetElemDecl(ctxt, doc, elem, &extsubset);
+    vstateVPush(ctxt, eDecl, elem);
+    return(ret);
+}
+
+/**
+ * xmlValidatePushCData:
+ * @ctxt:  the validation context
+ * @data:  some character data read
+ * @len:  the lenght of the data
+ *
+ * check the CData parsed for validation in the current stack
+ *
+ * returns 1 if no validation problem was found or 0 otherwise
+ */
+int
+xmlValidatePushCData(xmlValidCtxtPtr ctxt, const xmlChar *data, int len) {
+    int ret = 1;
+
+/* printf("CDATA %s %d\n", data, len); */
+    if (len <= 0)
+	return(ret);
+    if ((ctxt->vstateNr > 0) && (ctxt->vstate != NULL)) {
+	xmlValidStatePtr state = ctxt->vstate;
+	xmlElementPtr elemDecl;
+
+	/*
+	 * Check the new element agaisnt the content model of the new elem.
+	 */
+	if (state->elemDecl != NULL) {
+	    elemDecl = state->elemDecl;
+
+	    switch(elemDecl->etype) {
+		case XML_ELEMENT_TYPE_UNDEFINED:
+		    ret = 0;
+		    break;
+		case XML_ELEMENT_TYPE_EMPTY:
+		    xmlErrValidNode(ctxt, state->node,
+				    XML_DTD_NOT_EMPTY,
+	       "Element %s was declared EMPTY this one has content\n",
+			   state->node->name, NULL, NULL);
+		    ret = 0;
+		    break;
+		case XML_ELEMENT_TYPE_ANY:
+		    break;
+		case XML_ELEMENT_TYPE_MIXED:
+		    break;
+		case XML_ELEMENT_TYPE_ELEMENT:
+		    if (len > 0) {
+			int i;
+
+			for (i = 0;i < len;i++) {
+			    if (!IS_BLANK_CH(data[i])) {
+				xmlErrValidNode(ctxt, state->node,
+						XML_DTD_CONTENT_MODEL,
+	   "Element %s content does not follow the DTD, Text not allowed\n",
+				       state->node->name, NULL, NULL);
+				ret = 0;
+				goto done;
+			    }
+			}
+			/*
+			 * TODO:
+			 * VC: Standalone Document Declaration
+			 *  element types with element content, if white space
+			 *  occurs directly within any instance of those types.
+			 */
+		    }
+		    break;
+	    }
+	}
+    }
+done:
+    return(ret);
+}
+
+/**
+ * xmlValidatePopElement:
+ * @ctxt:  the validation context
+ * @doc:  a document instance
+ * @elem:  an element instance
+ * @qname:  the qualified name as appearing in the serialization
+ *
+ * Pop the element end from the validation stack.
+ *
+ * returns 1 if no validation problem was found or 0 otherwise
+ */
+int
+xmlValidatePopElement(xmlValidCtxtPtr ctxt, xmlDocPtr doc ATTRIBUTE_UNUSED,
+                      xmlNodePtr elem ATTRIBUTE_UNUSED,
+		      const xmlChar *qname ATTRIBUTE_UNUSED) {
+    int ret = 1;
+
+/* printf("PopElem %s\n", qname); */
+    if ((ctxt->vstateNr > 0) && (ctxt->vstate != NULL)) {
+	xmlValidStatePtr state = ctxt->vstate;
+	xmlElementPtr elemDecl;
+
+	/*
+	 * Check the new element agaisnt the content model of the new elem.
+	 */
+	if (state->elemDecl != NULL) {
+	    elemDecl = state->elemDecl;
+
+	    if (elemDecl->etype == XML_ELEMENT_TYPE_ELEMENT) {
+		if (state->exec != NULL) {
+		    ret = xmlRegExecPushString(state->exec, NULL, NULL);
+		    if (ret == 0) {
+			xmlErrValidNode(ctxt, state->node,
+			                XML_DTD_CONTENT_MODEL,
+	   "Element %s content does not follow the DTD, Expecting more child\n",
+			       state->node->name, NULL,NULL);
+		    } else {
+			/*
+			 * previous validation errors should not generate
+			 * a new one here
+			 */
+			ret = 1;
+		    }
+		}
+	    }
+	}
+	vstateVPop(ctxt);
+    }
+    return(ret);
+}
+#endif /* LIBXML_REGEXP_ENABLED */
+
+/**
+ * xmlValidateOneElement:
+ * @ctxt:  the validation context
+ * @doc:  a document instance
+ * @elem:  an element instance
+ *
+ * Try to validate a single element and it's attributes,
+ * basically it does the following checks as described by the
+ * XML-1.0 recommendation:
+ *  - [ VC: Element Valid ]
+ *  - [ VC: Required Attribute ]
+ * Then call xmlValidateOneAttribute() for each attribute present.
+ *
+ * The ID/IDREF checkings are done separately
+ *
+ * returns 1 if valid or 0 otherwise
+ */
+
+int
+xmlValidateOneElement(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
+                      xmlNodePtr elem) {
+    xmlElementPtr elemDecl = NULL;
+    xmlElementContentPtr cont;
+    xmlAttributePtr attr;
+    xmlNodePtr child;
+    int ret = 1, tmp;
+    const xmlChar *name;
+    int extsubset = 0;
+
+    CHECK_DTD;
+
+    if (elem == NULL) return(0);
+    switch (elem->type) {
+        case XML_ATTRIBUTE_NODE:
+	    xmlErrValidNode(ctxt, elem, XML_ERR_INTERNAL_ERROR,
+		   "Attribute element not expected\n", NULL, NULL ,NULL);
+	    return(0);
+        case XML_TEXT_NODE:
+	    if (elem->children != NULL) {
+		xmlErrValidNode(ctxt, elem, XML_ERR_INTERNAL_ERROR,
+		                "Text element has children !\n",
+				NULL,NULL,NULL);
+		return(0);
+	    }
+	    if (elem->properties != NULL) {
+		xmlErrValidNode(ctxt, elem, XML_ERR_INTERNAL_ERROR,
+		                "Text element has attribute !\n",
+				NULL,NULL,NULL);
+		return(0);
+	    }
+	    if (elem->ns != NULL) {
+		xmlErrValidNode(ctxt, elem, XML_ERR_INTERNAL_ERROR,
+		                "Text element has namespace !\n",
+				NULL,NULL,NULL);
+		return(0);
+	    }
+	    if (elem->nsDef != NULL) {
+		xmlErrValidNode(ctxt, elem, XML_ERR_INTERNAL_ERROR,
+		                "Text element has namespace !\n",
+				NULL,NULL,NULL);
+		return(0);
+	    }
+	    if (elem->content == NULL) {
+		xmlErrValidNode(ctxt, elem, XML_ERR_INTERNAL_ERROR,
+		                "Text element has no content !\n",
+				NULL,NULL,NULL);
+		return(0);
+	    }
+	    return(1);
+        case XML_XINCLUDE_START:
+        case XML_XINCLUDE_END:
+            return(1);
+        case XML_CDATA_SECTION_NODE:
+        case XML_ENTITY_REF_NODE:
+        case XML_PI_NODE:
+        case XML_COMMENT_NODE:
+	    return(1);
+        case XML_ENTITY_NODE:
+	    xmlErrValidNode(ctxt, elem, XML_ERR_INTERNAL_ERROR,
+		   "Entity element not expected\n", NULL, NULL ,NULL);
+	    return(0);
+        case XML_NOTATION_NODE:
+	    xmlErrValidNode(ctxt, elem, XML_ERR_INTERNAL_ERROR,
+		   "Notation element not expected\n", NULL, NULL ,NULL);
+	    return(0);
+        case XML_DOCUMENT_NODE:
+        case XML_DOCUMENT_TYPE_NODE:
+        case XML_DOCUMENT_FRAG_NODE:
+	    xmlErrValidNode(ctxt, elem, XML_ERR_INTERNAL_ERROR,
+		   "Document element not expected\n", NULL, NULL ,NULL);
+	    return(0);
+        case XML_HTML_DOCUMENT_NODE:
+	    xmlErrValidNode(ctxt, elem, XML_ERR_INTERNAL_ERROR,
+		   "HTML Document not expected\n", NULL, NULL ,NULL);
+	    return(0);
+        case XML_ELEMENT_NODE:
+	    break;
+	default:
+	    xmlErrValidNode(ctxt, elem, XML_ERR_INTERNAL_ERROR,
+		   "unknown element type\n", NULL, NULL ,NULL);
+	    return(0);
+    }
+
+    /*
+     * Fetch the declaration
+     */
+    elemDecl = xmlValidGetElemDecl(ctxt, doc, elem, &extsubset);
+    if (elemDecl == NULL)
+	return(0);
+
+    /*
+     * If vstateNr is not zero that means continuous validation is 
+     * activated, do not try to check the content model at that level.
+     */
+    if (ctxt->vstateNr == 0) {
+    /* Check that the element content matches the definition */
+    switch (elemDecl->etype) {
+        case XML_ELEMENT_TYPE_UNDEFINED:
+	    xmlErrValidNode(ctxt, elem, XML_DTD_UNKNOWN_ELEM,
+	                    "No declaration for element %s\n",
+		   elem->name, NULL, NULL);
+	    return(0);
+        case XML_ELEMENT_TYPE_EMPTY:
+	    if (elem->children != NULL) {
+		xmlErrValidNode(ctxt, elem, XML_DTD_NOT_EMPTY,
+	       "Element %s was declared EMPTY this one has content\n",
+	               elem->name, NULL, NULL);
+		ret = 0;
+	    }
+	    break;
+        case XML_ELEMENT_TYPE_ANY:
+	    /* I don't think anything is required then */
+	    break;
+        case XML_ELEMENT_TYPE_MIXED:
+
+	    /* simple case of declared as #PCDATA */
+	    if ((elemDecl->content != NULL) &&
+		(elemDecl->content->type == XML_ELEMENT_CONTENT_PCDATA)) {
+		ret = xmlValidateOneCdataElement(ctxt, doc, elem);
+		if (!ret) {
+		    xmlErrValidNode(ctxt, elem, XML_DTD_NOT_PCDATA,
+	       "Element %s was declared #PCDATA but contains non text nodes\n",
+			   elem->name, NULL, NULL);
+		}
+		break;
+	    }
+	    child = elem->children;
+	    /* Hum, this start to get messy */
+	    while (child != NULL) {
+	        if (child->type == XML_ELEMENT_NODE) {
+		    name = child->name;
+		    if ((child->ns != NULL) && (child->ns->prefix != NULL)) {
+			xmlChar fn[50];
+			xmlChar *fullname;
+			
+			fullname = xmlBuildQName(child->name, child->ns->prefix,
+				                 fn, 50);
+			if (fullname == NULL)
+			    return(0);
+			cont = elemDecl->content;
+			while (cont != NULL) {
+			    if (cont->type == XML_ELEMENT_CONTENT_ELEMENT) {
+				if (xmlStrEqual(cont->name, fullname))
+				    break;
+			    } else if ((cont->type == XML_ELEMENT_CONTENT_OR) &&
+			       (cont->c1 != NULL) &&
+			       (cont->c1->type == XML_ELEMENT_CONTENT_ELEMENT)){
+				if (xmlStrEqual(cont->c1->name, fullname))
+				    break;
+			    } else if ((cont->type != XML_ELEMENT_CONTENT_OR) ||
+				(cont->c1 == NULL) ||
+				(cont->c1->type != XML_ELEMENT_CONTENT_PCDATA)){
+				xmlErrValid(NULL, XML_DTD_MIXED_CORRUPT, 
+					"Internal: MIXED struct corrupted\n",
+					NULL);
+				break;
+			    }
+			    cont = cont->c2;
+			}
+			if ((fullname != fn) && (fullname != child->name))
+			    xmlFree(fullname);
+			if (cont != NULL)
+			    goto child_ok;
+		    }
+		    cont = elemDecl->content;
+		    while (cont != NULL) {
+		        if (cont->type == XML_ELEMENT_CONTENT_ELEMENT) {
+			    if (xmlStrEqual(cont->name, name)) break;
+			} else if ((cont->type == XML_ELEMENT_CONTENT_OR) &&
+			   (cont->c1 != NULL) &&
+			   (cont->c1->type == XML_ELEMENT_CONTENT_ELEMENT)) {
+			    if (xmlStrEqual(cont->c1->name, name)) break;
+			} else if ((cont->type != XML_ELEMENT_CONTENT_OR) ||
+			    (cont->c1 == NULL) ||
+			    (cont->c1->type != XML_ELEMENT_CONTENT_PCDATA)) {
+			    xmlErrValid(ctxt, XML_DTD_MIXED_CORRUPT, 
+				    "Internal: MIXED struct corrupted\n",
+				    NULL);
+			    break;
+			}
+			cont = cont->c2;
+		    }
+		    if (cont == NULL) {
+			xmlErrValidNode(ctxt, elem, XML_DTD_INVALID_CHILD,
+	       "Element %s is not declared in %s list of possible children\n",
+			       name, elem->name, NULL);
+			ret = 0;
+		    }
+		}
+child_ok:
+	        child = child->next;
+	    }
+	    break;
+        case XML_ELEMENT_TYPE_ELEMENT:
+	    if ((doc->standalone == 1) && (extsubset == 1)) {
+		/*
+		 * VC: Standalone Document Declaration
+		 *     - element types with element content, if white space
+		 *       occurs directly within any instance of those types.
+		 */
+		child = elem->children;
+		while (child != NULL) {
+		    if (child->type == XML_TEXT_NODE) {
+			const xmlChar *content = child->content;
+
+			while (IS_BLANK_CH(*content))
+			    content++;
+			if (*content == 0) {
+			    xmlErrValidNode(ctxt, elem,
+			                    XML_DTD_STANDALONE_WHITE_SPACE,
+"standalone: %s declared in the external subset contains white spaces nodes\n",
+				   elem->name, NULL, NULL);
+			    ret = 0;
+			    break;
+			}
+		    }
+		    child =child->next;
+		}
+	    }
+	    child = elem->children;
+	    cont = elemDecl->content;
+	    tmp = xmlValidateElementContent(ctxt, child, elemDecl, 1, elem);
+	    if (tmp <= 0)
+		ret = tmp;
+	    break;
+    }
+    } /* not continuous */
+
+    /* [ VC: Required Attribute ] */
+    attr = elemDecl->attributes;
+    while (attr != NULL) {
+	if (attr->def == XML_ATTRIBUTE_REQUIRED) {
+	    int qualified = -1;
+
+	    if ((attr->prefix == NULL) &&
+		(xmlStrEqual(attr->name, BAD_CAST "xmlns"))) {
+		xmlNsPtr ns;
+
+		ns = elem->nsDef;
+		while (ns != NULL) {
+		    if (ns->prefix == NULL)
+			goto found;
+		    ns = ns->next;
+		}
+	    } else if (xmlStrEqual(attr->prefix, BAD_CAST "xmlns")) {
+		xmlNsPtr ns;
+
+		ns = elem->nsDef;
+		while (ns != NULL) {
+		    if (xmlStrEqual(attr->name, ns->prefix))
+			goto found;
+		    ns = ns->next;
+		}
+	    } else {
+		xmlAttrPtr attrib;
+		
+		attrib = elem->properties;
+		while (attrib != NULL) {
+		    if (xmlStrEqual(attrib->name, attr->name)) {
+			if (attr->prefix != NULL) {
+			    xmlNsPtr nameSpace = attrib->ns;
+
+			    if (nameSpace == NULL)
+				nameSpace = elem->ns;
+			    /*
+			     * qualified names handling is problematic, having a
+			     * different prefix should be possible but DTDs don't
+			     * allow to define the URI instead of the prefix :-(
+			     */
+			    if (nameSpace == NULL) {
+				if (qualified < 0) 
+				    qualified = 0;
+			    } else if (!xmlStrEqual(nameSpace->prefix,
+						    attr->prefix)) {
+				if (qualified < 1) 
+				    qualified = 1;
+			    } else
+				goto found;
+			} else {
+			    /*
+			     * We should allow applications to define namespaces
+			     * for their application even if the DTD doesn't 
+			     * carry one, otherwise, basically we would always
+			     * break.
+			     */
+			    goto found;
+			}
+		    }
+		    attrib = attrib->next;
+		}
+	    }
+	    if (qualified == -1) {
+		if (attr->prefix == NULL) {
+		    xmlErrValidNode(ctxt, elem, XML_DTD_MISSING_ATTRIBUTE,
+		       "Element %s does not carry attribute %s\n",
+			   elem->name, attr->name, NULL);
+		    ret = 0;
+	        } else {
+		    xmlErrValidNode(ctxt, elem, XML_DTD_MISSING_ATTRIBUTE,
+		       "Element %s does not carry attribute %s:%s\n",
+			   elem->name, attr->prefix,attr->name);
+		    ret = 0;
+		}
+	    } else if (qualified == 0) {
+		xmlErrValidWarning(ctxt, elem, XML_DTD_NO_PREFIX,
+		   "Element %s required attribute %s:%s has no prefix\n",
+		       elem->name, attr->prefix, attr->name);
+	    } else if (qualified == 1) {
+		xmlErrValidWarning(ctxt, elem, XML_DTD_DIFFERENT_PREFIX,
+		   "Element %s required attribute %s:%s has different prefix\n",
+		       elem->name, attr->prefix, attr->name);
+	    }
+	} else if (attr->def == XML_ATTRIBUTE_FIXED) {
+	    /*
+	     * Special tests checking #FIXED namespace declarations
+	     * have the right value since this is not done as an
+	     * attribute checking
+	     */
+	    if ((attr->prefix == NULL) &&
+		(xmlStrEqual(attr->name, BAD_CAST "xmlns"))) {
+		xmlNsPtr ns;
+
+		ns = elem->nsDef;
+		while (ns != NULL) {
+		    if (ns->prefix == NULL) {
+			if (!xmlStrEqual(attr->defaultValue, ns->href)) {
+			    xmlErrValidNode(ctxt, elem,
+			           XML_DTD_ELEM_DEFAULT_NAMESPACE,
+   "Element %s namespace name for default namespace does not match the DTD\n",
+				   elem->name, NULL, NULL);
+			    ret = 0;
+			}
+			goto found;
+		    }
+		    ns = ns->next;
+		}
+	    } else if (xmlStrEqual(attr->prefix, BAD_CAST "xmlns")) {
+		xmlNsPtr ns;
+
+		ns = elem->nsDef;
+		while (ns != NULL) {
+		    if (xmlStrEqual(attr->name, ns->prefix)) {
+			if (!xmlStrEqual(attr->defaultValue, ns->href)) {
+			    xmlErrValidNode(ctxt, elem, XML_DTD_ELEM_NAMESPACE,
+		   "Element %s namespace name for %s does not match the DTD\n",
+				   elem->name, ns->prefix, NULL);
+			    ret = 0;
+			}
+			goto found;
+		    }
+		    ns = ns->next;
+		}
+	    }
+	}
+found:	    
+        attr = attr->nexth;
+    }
+    return(ret);
+}
+
+/**
+ * xmlValidateRoot:
+ * @ctxt:  the validation context
+ * @doc:  a document instance
+ *
+ * Try to validate a the root element
+ * basically it does the following check as described by the
+ * XML-1.0 recommendation:
+ *  - [ VC: Root Element Type ]
+ * it doesn't try to recurse or apply other check to the element
+ *
+ * returns 1 if valid or 0 otherwise
+ */
+
+int
+xmlValidateRoot(xmlValidCtxtPtr ctxt, xmlDocPtr doc) {
+    xmlNodePtr root;
+    int ret;
+
+    if (doc == NULL) return(0);
+
+    root = xmlDocGetRootElement(doc);
+    if ((root == NULL) || (root->name == NULL)) {
+	xmlErrValid(ctxt, XML_DTD_NO_ROOT,
+	            "no root element\n", NULL);
+        return(0);
+    }
+
+    /*
+     * When doing post validation against a separate DTD, those may
+     * no internal subset has been generated
+     */
+    if ((doc->intSubset != NULL) &&
+	(doc->intSubset->name != NULL)) {
+	/*
+	 * Check first the document root against the NQName
+	 */
+	if (!xmlStrEqual(doc->intSubset->name, root->name)) {
+	    if ((root->ns != NULL) && (root->ns->prefix != NULL)) {
+		xmlChar fn[50];
+		xmlChar *fullname;
+		
+		fullname = xmlBuildQName(root->name, root->ns->prefix, fn, 50);
+		if (fullname == NULL) {
+		    xmlVErrMemory(ctxt, NULL);
+		    return(0);
+		}
+		ret = xmlStrEqual(doc->intSubset->name, fullname);
+		if ((fullname != fn) && (fullname != root->name))
+		    xmlFree(fullname);
+		if (ret == 1)
+		    goto name_ok;
+	    } 
+	    if ((xmlStrEqual(doc->intSubset->name, BAD_CAST "HTML")) &&
+		(xmlStrEqual(root->name, BAD_CAST "html")))
+		goto name_ok;
+	    xmlErrValidNode(ctxt, root, XML_DTD_ROOT_NAME,
+		   "root and DTD name do not match '%s' and '%s'\n",
+		   root->name, doc->intSubset->name, NULL);
+	    return(0);
+	}
+    }
+name_ok:
+    return(1);
+}
+
+
+/**
+ * xmlValidateElement:
+ * @ctxt:  the validation context
+ * @doc:  a document instance
+ * @elem:  an element instance
+ *
+ * Try to validate the subtree under an element 
+ *
+ * returns 1 if valid or 0 otherwise
+ */
+
+int
+xmlValidateElement(xmlValidCtxtPtr ctxt, xmlDocPtr doc, xmlNodePtr elem) {
+    xmlNodePtr child;
+    xmlAttrPtr attr;
+    xmlNsPtr ns;
+    const xmlChar *value;
+    int ret = 1;
+
+    if (elem == NULL) return(0);
+
+    /*
+     * XInclude elements were added after parsing in the infoset,
+     * they don't really mean anything validation wise.
+     */
+    if ((elem->type == XML_XINCLUDE_START) ||
+	(elem->type == XML_XINCLUDE_END))
+	return(1);
+
+    CHECK_DTD;
+
+    /*
+     * Entities references have to be handled separately
+     */
+    if (elem->type == XML_ENTITY_REF_NODE) {
+	return(1);
+    }
+
+    ret &= xmlValidateOneElement(ctxt, doc, elem);
+    attr = elem->properties;
+    while (attr != NULL) {
+        value = xmlNodeListGetString(doc, attr->children, 0);
+	ret &= xmlValidateOneAttribute(ctxt, doc, elem, attr, value);
+	if (value != NULL)
+	    xmlFree((char *)value);
+	attr= attr->next;
+    }
+    ns = elem->nsDef;
+    while (ns != NULL) {
+        if (elem->ns == NULL)
+	    ret &= xmlValidateOneNamespace(ctxt, doc, elem, NULL,
+					   ns, ns->href);
+	else
+	    ret &= xmlValidateOneNamespace(ctxt, doc, elem, elem->ns->prefix,
+					   ns, ns->href);
+        ns = ns->next;
+    }
+    child = elem->children;
+    while (child != NULL) {
+        ret &= xmlValidateElement(ctxt, doc, child);
+        child = child->next;
+    }
+
+    return(ret);
+}
+
+/**
+ * xmlValidateRef:
+ * @ref:   A reference to be validated
+ * @ctxt:  Validation context
+ * @name:  Name of ID we are searching for
+ *
+ */
+static void
+xmlValidateRef(xmlRefPtr ref, xmlValidCtxtPtr ctxt,
+	                   const xmlChar *name) {
+    xmlAttrPtr id;
+    xmlAttrPtr attr;
+
+    if (ref == NULL)
+	return;
+    if ((ref->attr == NULL) && (ref->name == NULL))
+	return;
+    attr = ref->attr;
+    if (attr == NULL) {
+	xmlChar *dup, *str = NULL, *cur, save;
+
+	dup = xmlStrdup(name);
+	if (dup == NULL) {
+	    ctxt->valid = 0;
+	    return;
+	}
+	cur = dup;
+	while (*cur != 0) {
+	    str = cur;
+	    while ((*cur != 0) && (!IS_BLANK_CH(*cur))) cur++;
+	    save = *cur;
+	    *cur = 0;
+	    id = xmlGetID(ctxt->doc, str);
+	    if (id == NULL) {
+		xmlErrValidNodeNr(ctxt, NULL, XML_DTD_UNKNOWN_ID,
+	   "attribute %s line %d references an unknown ID \"%s\"\n",
+		       ref->name, ref->lineno, str);
+		ctxt->valid = 0;
+	    }
+	    if (save == 0)
+		break;
+	    *cur = save;
+	    while (IS_BLANK_CH(*cur)) cur++;
+	}
+	xmlFree(dup);
+    } else if (attr->atype == XML_ATTRIBUTE_IDREF) {
+	id = xmlGetID(ctxt->doc, name);
+	if (id == NULL) {
+	    xmlErrValidNode(ctxt, attr->parent, XML_DTD_UNKNOWN_ID,
+	   "IDREF attribute %s references an unknown ID \"%s\"\n",
+		   attr->name, name, NULL);
+	    ctxt->valid = 0;
+	}
+    } else if (attr->atype == XML_ATTRIBUTE_IDREFS) {
+	xmlChar *dup, *str = NULL, *cur, save;
+
+	dup = xmlStrdup(name);
+	if (dup == NULL) {
+	    xmlVErrMemory(ctxt, "IDREFS split");
+	    ctxt->valid = 0;
+	    return;
+	}
+	cur = dup;
+	while (*cur != 0) {
+	    str = cur;
+	    while ((*cur != 0) && (!IS_BLANK_CH(*cur))) cur++;
+	    save = *cur;
+	    *cur = 0;
+	    id = xmlGetID(ctxt->doc, str);
+	    if (id == NULL) {
+		xmlErrValidNode(ctxt, attr->parent, XML_DTD_UNKNOWN_ID,
+	   "IDREFS attribute %s references an unknown ID \"%s\"\n",
+			     attr->name, str, NULL);
+		ctxt->valid = 0;
+	    }
+	    if (save == 0)
+		break;
+	    *cur = save;
+	    while (IS_BLANK_CH(*cur)) cur++;
+	}
+	xmlFree(dup);
+    }
+}
+
+/**
+ * xmlWalkValidateList:
+ * @data:  Contents of current link
+ * @user:  Value supplied by the user
+ *
+ * Returns 0 to abort the walk or 1 to continue
+ */
+static int
+xmlWalkValidateList(const void *data, const void *user)
+{
+	xmlValidateMemoPtr memo = (xmlValidateMemoPtr)user;
+	xmlValidateRef((xmlRefPtr)data, memo->ctxt, memo->name);
+	return 1;
+}
+
+/**
+ * xmlValidateCheckRefCallback:
+ * @ref_list:  List of references
+ * @ctxt:  Validation context
+ * @name:  Name of ID we are searching for
+ *
+ */
+static void
+xmlValidateCheckRefCallback(xmlListPtr ref_list, xmlValidCtxtPtr ctxt,
+	                   const xmlChar *name) {
+    xmlValidateMemo memo;
+
+    if (ref_list == NULL)
+	return;
+    memo.ctxt = ctxt;
+    memo.name = name;
+
+    xmlListWalk(ref_list, xmlWalkValidateList, &memo);
+    
+}
+
+/**
+ * xmlValidateDocumentFinal:
+ * @ctxt:  the validation context
+ * @doc:  a document instance
+ *
+ * Does the final step for the document validation once all the
+ * incremental validation steps have been completed
+ *
+ * basically it does the following checks described by the XML Rec
+ * 
+ * Check all the IDREF/IDREFS attributes definition for validity
+ *
+ * returns 1 if valid or 0 otherwise
+ */
+
+int
+xmlValidateDocumentFinal(xmlValidCtxtPtr ctxt, xmlDocPtr doc) {
+    xmlRefTablePtr table;
+
+    if (doc == NULL) {
+        xmlErrValid(ctxt, XML_DTD_NO_DOC, 
+		"xmlValidateDocumentFinal: doc == NULL\n", NULL);
+	return(0);
+    }
+
+    /*
+     * Check all the NOTATION/NOTATIONS attributes
+     */
+    /*
+     * Check all the ENTITY/ENTITIES attributes definition for validity
+     */
+    /*
+     * Check all the IDREF/IDREFS attributes definition for validity
+     */
+    table = (xmlRefTablePtr) doc->refs;
+    ctxt->doc = doc;
+    ctxt->valid = 1;
+    xmlHashScan(table, (xmlHashScanner) xmlValidateCheckRefCallback, ctxt);
+    return(ctxt->valid);
+}
+
+/**
+ * xmlValidateDtd:
+ * @ctxt:  the validation context
+ * @doc:  a document instance
+ * @dtd:  a dtd instance
+ *
+ * Try to validate the document against the dtd instance
+ *
+ * basically it does check all the definitions in the DtD.
+ *
+ * returns 1 if valid or 0 otherwise
+ */
+
+int
+xmlValidateDtd(xmlValidCtxtPtr ctxt, xmlDocPtr doc, xmlDtdPtr dtd) {
+    int ret;
+    xmlDtdPtr oldExt;
+    xmlNodePtr root;
+
+    if (dtd == NULL) return(0);
+    if (doc == NULL) return(0);
+    oldExt = doc->extSubset;
+    doc->extSubset = dtd;
+    ret = xmlValidateRoot(ctxt, doc);
+    if (ret == 0) {
+	doc->extSubset = oldExt;
+	return(ret);
+    }
+    if (doc->ids != NULL) {
+          xmlFreeIDTable(doc->ids);
+          doc->ids = NULL;
+    }
+    if (doc->refs != NULL) {
+          xmlFreeRefTable(doc->refs);
+          doc->refs = NULL;
+    }
+    root = xmlDocGetRootElement(doc);
+    ret = xmlValidateElement(ctxt, doc, root);
+    ret &= xmlValidateDocumentFinal(ctxt, doc);
+    doc->extSubset = oldExt;
+    return(ret);
+}
+
+static void
+xmlValidateNotationCallback(xmlEntityPtr cur, xmlValidCtxtPtr ctxt,
+	                    const xmlChar *name ATTRIBUTE_UNUSED) {
+    if (cur == NULL)
+	return;
+    if (cur->etype == XML_EXTERNAL_GENERAL_UNPARSED_ENTITY) {
+	xmlChar *notation = cur->content;
+
+	if (notation != NULL) {
+	    int ret;
+
+	    ret = xmlValidateNotationUse(ctxt, cur->doc, notation);
+	    if (ret != 1) {
+		ctxt->valid = 0;
+	    }
+	}
+    }
+}
+
+static void
+xmlValidateAttributeCallback(xmlAttributePtr cur, xmlValidCtxtPtr ctxt,
+	                    const xmlChar *name ATTRIBUTE_UNUSED) {
+    int ret;
+    xmlDocPtr doc;
+    xmlElementPtr elem = NULL;
+
+    if (cur == NULL)
+	return;
+    switch (cur->atype) {
+	case XML_ATTRIBUTE_CDATA:
+	case XML_ATTRIBUTE_ID:
+	case XML_ATTRIBUTE_IDREF	:
+	case XML_ATTRIBUTE_IDREFS:
+	case XML_ATTRIBUTE_NMTOKEN:
+	case XML_ATTRIBUTE_NMTOKENS:
+	case XML_ATTRIBUTE_ENUMERATION:
+	    break;
+	case XML_ATTRIBUTE_ENTITY:
+	case XML_ATTRIBUTE_ENTITIES:
+	case XML_ATTRIBUTE_NOTATION:
+	    if (cur->defaultValue != NULL) {
+		
+		ret = xmlValidateAttributeValue2(ctxt, ctxt->doc, cur->name,
+			                         cur->atype, cur->defaultValue);
+		if ((ret == 0) && (ctxt->valid == 1))
+		    ctxt->valid = 0;
+	    }
+	    if (cur->tree != NULL) {
+		xmlEnumerationPtr tree = cur->tree;
+		while (tree != NULL) {
+		    ret = xmlValidateAttributeValue2(ctxt, ctxt->doc,
+				    cur->name, cur->atype, tree->name);
+		    if ((ret == 0) && (ctxt->valid == 1))
+			ctxt->valid = 0;
+		    tree = tree->next;
+		}
+	    }
+    }
+    if (cur->atype == XML_ATTRIBUTE_NOTATION) {
+	doc = cur->doc;
+	if (cur->elem == NULL) {
+	    xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR,
+		   "xmlValidateAttributeCallback(%s): internal error\n",
+		   (const char *) cur->name);
+	    return;
+	}
+
+	if (doc != NULL)
+	    elem = xmlGetDtdElementDesc(doc->intSubset, cur->elem);
+	if ((elem == NULL) && (doc != NULL))
+	    elem = xmlGetDtdElementDesc(doc->extSubset, cur->elem);
+	if ((elem == NULL) && (cur->parent != NULL) &&
+	    (cur->parent->type == XML_DTD_NODE))
+	    elem = xmlGetDtdElementDesc((xmlDtdPtr) cur->parent, cur->elem);
+	if (elem == NULL) {
+	    xmlErrValidNode(ctxt, NULL, XML_DTD_UNKNOWN_ELEM,
+		   "attribute %s: could not find decl for element %s\n",
+		   cur->name, cur->elem, NULL);
+	    return;
+	}
+	if (elem->etype == XML_ELEMENT_TYPE_EMPTY) {
+	    xmlErrValidNode(ctxt, NULL, XML_DTD_EMPTY_NOTATION,
+		   "NOTATION attribute %s declared for EMPTY element %s\n",
+		   cur->name, cur->elem, NULL);
+	    ctxt->valid = 0;
+	}
+    }
+}
+
+/**
+ * xmlValidateDtdFinal:
+ * @ctxt:  the validation context
+ * @doc:  a document instance
+ *
+ * Does the final step for the dtds validation once all the
+ * subsets have been parsed
+ *
+ * basically it does the following checks described by the XML Rec
+ * - check that ENTITY and ENTITIES type attributes default or 
+ *   possible values matches one of the defined entities.
+ * - check that NOTATION type attributes default or 
+ *   possible values matches one of the defined notations.
+ *
+ * returns 1 if valid or 0 if invalid and -1 if not well-formed
+ */
+
+int
+xmlValidateDtdFinal(xmlValidCtxtPtr ctxt, xmlDocPtr doc) {
+    xmlDtdPtr dtd;
+    xmlAttributeTablePtr table;
+    xmlEntitiesTablePtr entities;
+
+    if (doc == NULL) return(0);
+    if ((doc->intSubset == NULL) && (doc->extSubset == NULL))
+	return(0);
+    ctxt->doc = doc;
+    ctxt->valid = 1;
+    dtd = doc->intSubset;
+    if ((dtd != NULL) && (dtd->attributes != NULL)) {
+	table = (xmlAttributeTablePtr) dtd->attributes;
+	xmlHashScan(table, (xmlHashScanner) xmlValidateAttributeCallback, ctxt);
+    }
+    if ((dtd != NULL) && (dtd->entities != NULL)) {
+	entities = (xmlEntitiesTablePtr) dtd->entities;
+	xmlHashScan(entities, (xmlHashScanner) xmlValidateNotationCallback,
+		    ctxt);
+    }
+    dtd = doc->extSubset;
+    if ((dtd != NULL) && (dtd->attributes != NULL)) {
+	table = (xmlAttributeTablePtr) dtd->attributes;
+	xmlHashScan(table, (xmlHashScanner) xmlValidateAttributeCallback, ctxt);
+    }
+    if ((dtd != NULL) && (dtd->entities != NULL)) {
+	entities = (xmlEntitiesTablePtr) dtd->entities;
+	xmlHashScan(entities, (xmlHashScanner) xmlValidateNotationCallback,
+		    ctxt);
+    }
+    return(ctxt->valid);
+}
+
+/**
+ * xmlValidateDocument:
+ * @ctxt:  the validation context
+ * @doc:  a document instance
+ *
+ * Try to validate the document instance
+ *
+ * basically it does the all the checks described by the XML Rec
+ * i.e. validates the internal and external subset (if present)
+ * and validate the document tree.
+ *
+ * returns 1 if valid or 0 otherwise
+ */
+
+int
+xmlValidateDocument(xmlValidCtxtPtr ctxt, xmlDocPtr doc) {
+    int ret;
+    xmlNodePtr root;
+
+    if ((doc->intSubset == NULL) && (doc->extSubset == NULL)) {
+        xmlErrValid(ctxt, XML_DTD_NO_DTD,
+	            "no DTD found!\n", NULL);
+	return(0);
+    }
+    if ((doc->intSubset != NULL) && ((doc->intSubset->SystemID != NULL) ||
+	(doc->intSubset->ExternalID != NULL)) && (doc->extSubset == NULL)) {
+        doc->extSubset = xmlParseDTD(doc->intSubset->ExternalID,
+		                     doc->intSubset->SystemID);
+        if (doc->extSubset == NULL) {
+	    if (doc->intSubset->SystemID != NULL) {
+		xmlErrValid(ctxt, XML_DTD_LOAD_ERROR,
+		       "Could not load the external subset \"%s\"\n",
+		       (const char *) doc->intSubset->SystemID);
+	    } else {
+		xmlErrValid(ctxt, XML_DTD_LOAD_ERROR,
+		       "Could not load the external subset \"%s\"\n",
+		       (const char *) doc->intSubset->ExternalID);
+	    }
+	    return(0);
+	}
+    }
+
+    if (doc->ids != NULL) {
+          xmlFreeIDTable(doc->ids);
+          doc->ids = NULL;
+    }
+    if (doc->refs != NULL) {
+          xmlFreeRefTable(doc->refs);
+          doc->refs = NULL;
+    }
+    ret = xmlValidateDtdFinal(ctxt, doc);
+    if (!xmlValidateRoot(ctxt, doc)) return(0);
+
+    root = xmlDocGetRootElement(doc);
+    ret &= xmlValidateElement(ctxt, doc, root);
+    ret &= xmlValidateDocumentFinal(ctxt, doc);
+    return(ret);
+}
+
+/************************************************************************
+ *									*
+ *		Routines for dynamic validation editing			*
+ *									*
+ ************************************************************************/
+
+/**
+ * xmlValidGetPotentialChildren:
+ * @ctree:  an element content tree
+ * @list:  an array to store the list of child names
+ * @len:  a pointer to the number of element in the list
+ * @max:  the size of the array
+ *
+ * Build/extend a list of  potential children allowed by the content tree
+ *
+ * returns the number of element in the list, or -1 in case of error.
+ */
+
+int
+xmlValidGetPotentialChildren(xmlElementContent *ctree, const xmlChar **list,
+                             int *len, int max) {
+    int i;
+
+    if ((ctree == NULL) || (list == NULL) || (len == NULL))
+        return(-1);
+    if (*len >= max) return(*len);
+
+    switch (ctree->type) {
+	case XML_ELEMENT_CONTENT_PCDATA: 
+	    for (i = 0; i < *len;i++)
+		if (xmlStrEqual(BAD_CAST "#PCDATA", list[i])) return(*len);
+	    list[(*len)++] = BAD_CAST "#PCDATA";
+	    break;
+	case XML_ELEMENT_CONTENT_ELEMENT: 
+	    for (i = 0; i < *len;i++)
+		if (xmlStrEqual(ctree->name, list[i])) return(*len);
+	    list[(*len)++] = ctree->name;
+	    break;
+	case XML_ELEMENT_CONTENT_SEQ: 
+	    xmlValidGetPotentialChildren(ctree->c1, list, len, max);
+	    xmlValidGetPotentialChildren(ctree->c2, list, len, max);
+	    break;
+	case XML_ELEMENT_CONTENT_OR:
+	    xmlValidGetPotentialChildren(ctree->c1, list, len, max);
+	    xmlValidGetPotentialChildren(ctree->c2, list, len, max);
+	    break;
+   }
+   
+   return(*len);
+}
+
+/**
+ * xmlValidGetValidElements:
+ * @prev:  an element to insert after
+ * @next:  an element to insert next
+ * @list:  an array to store the list of child names
+ * @max:  the size of the array
+ *
+ * This function returns the list of authorized children to insert
+ * within an existing tree while respecting the validity constraints
+ * forced by the Dtd. The insertion point is defined using @prev and
+ * @next in the following ways:
+ *  to insert before 'node': xmlValidGetValidElements(node->prev, node, ...
+ *  to insert next 'node': xmlValidGetValidElements(node, node->next, ...
+ *  to replace 'node': xmlValidGetValidElements(node->prev, node->next, ...
+ *  to prepend a child to 'node': xmlValidGetValidElements(NULL, node->childs,
+ *  to append a child to 'node': xmlValidGetValidElements(node->last, NULL, ...
+ *
+ * pointers to the element names are inserted at the beginning of the array
+ * and do not need to be freed.
+ *
+ * returns the number of element in the list, or -1 in case of error. If
+ *    the function returns the value @max the caller is invited to grow the
+ *    receiving array and retry.
+ */
+
+int
+xmlValidGetValidElements(xmlNode *prev, xmlNode *next, const xmlChar **list,
+                         int max) {
+    xmlValidCtxt vctxt;
+    int nb_valid_elements = 0;
+    const xmlChar *elements[256];
+    int nb_elements = 0, i;
+    const xmlChar *name;
+    
+    xmlNode *ref_node;
+    xmlNode *parent;
+    xmlNode *test_node;
+    
+    xmlNode *prev_next;
+    xmlNode *next_prev;
+    xmlNode *parent_childs;
+    xmlNode *parent_last;
+    
+    xmlElement *element_desc;
+
+    memset(&vctxt, 0, sizeof (xmlValidCtxt));
+
+    if (prev == NULL && next == NULL)
+        return(-1);
+
+    if (list == NULL) return(-1);
+    if (max <= 0) return(-1);
+
+    nb_valid_elements = 0;
+    ref_node = prev ? prev : next;
+    parent = ref_node->parent;
+
+    /*
+     * Retrieves the parent element declaration
+     */
+    element_desc = xmlGetDtdElementDesc(parent->doc->intSubset,
+                                         parent->name);
+    if ((element_desc == NULL) && (parent->doc->extSubset != NULL))
+        element_desc = xmlGetDtdElementDesc(parent->doc->extSubset,
+                                             parent->name);
+    if (element_desc == NULL) return(-1);
+	
+    /*
+     * Do a backup of the current tree structure
+     */
+    prev_next = prev ? prev->next : NULL;
+    next_prev = next ? next->prev : NULL;
+    parent_childs = parent->children;
+    parent_last = parent->last;
+
+    /*
+     * Creates a dummy node and insert it into the tree
+     */    
+    test_node = xmlNewNode (NULL, BAD_CAST "<!dummy?>");
+    test_node->doc = ref_node->doc;
+    test_node->parent = parent;
+    test_node->prev = prev;
+    test_node->next = next;
+    name = test_node->name;
+    
+    if (prev) prev->next = test_node;
+    else parent->children = test_node;
+		
+    if (next) next->prev = test_node;
+    else parent->last = test_node;
+
+    /*
+     * Insert each potential child node and check if the parent is
+     * still valid
+     */
+    nb_elements = xmlValidGetPotentialChildren(element_desc->content,
+		       elements, &nb_elements, 256);
+    
+    for (i = 0;i < nb_elements;i++) {
+	test_node->name = elements[i];
+	if (xmlValidateOneElement(&vctxt, parent->doc, parent)) {
+	    int j;
+
+	    for (j = 0; j < nb_valid_elements;j++)
+		if (xmlStrEqual(elements[i], list[j])) break;
+	    list[nb_valid_elements++] = elements[i];
+	    if (nb_valid_elements >= max) break;
+	}
+    }
+
+    /*
+     * Restore the tree structure
+     */
+    if (prev) prev->next = prev_next;
+    if (next) next->prev = next_prev;
+    parent->children = parent_childs;
+    parent->last = parent_last;
+
+    /*
+     * Free up the dummy node
+     */
+    test_node->name = name;
+    xmlFreeNode(test_node);
+
+    return(nb_valid_elements);
+}
+#endif /* LIBXML_VALID_ENABLED */
+
diff --git a/src/libxml/src/xinclude.c b/src/libxml/src/xinclude.c
new file mode 100644
index 0000000..484cd6d
--- /dev/null
+++ b/src/libxml/src/xinclude.c
@@ -0,0 +1,2388 @@
+/*
+ * xinclude.c : Code to implement XInclude processing
+ *
+ * World Wide Web Consortium W3C Last Call Working Draft 10 November 2003
+ * http://www.w3.org/TR/2003/WD-xinclude-20031110
+ *
+ * See Copyright for the status of this software.
+ *
+ * daniel@veillard.com
+ */
+
+#define IN_LIBXML
+#include "libxml.h"
+
+#include <string.h>
+#include <libxml/xmlmemory.h>
+#include <libxml/tree.h>
+#include <libxml/parser.h>
+#include <libxml/uri.h>
+#include <libxml/xpointer.h>
+#include <libxml/parserInternals.h>
+#include <libxml/xmlerror.h>
+#include <libxml/encoding.h>
+#include <libxml/globals.h>
+
+#ifdef LIBXML_XINCLUDE_ENABLED
+#include <libxml/xinclude.h>
+
+
+#define XINCLUDE_MAX_DEPTH 40
+
+/* #define DEBUG_XINCLUDE */
+#ifdef DEBUG_XINCLUDE
+#ifdef LIBXML_DEBUG_ENABLED
+#include <libxml/debugXML.h>
+#endif
+#endif
+
+/************************************************************************
+ *									*
+ *			XInclude context handling			*
+ *									*
+ ************************************************************************/
+
+/*
+ * An XInclude context
+ */
+typedef xmlChar *xmlURL;
+
+typedef struct _xmlXIncludeRef xmlXIncludeRef;
+typedef xmlXIncludeRef *xmlXIncludeRefPtr;
+struct _xmlXIncludeRef {
+    xmlChar              *URI; /* the fully resolved resource URL */
+    xmlChar         *fragment; /* the fragment in the URI */
+    xmlDocPtr		  doc; /* the parsed document */
+    xmlNodePtr            ref; /* the node making the reference in the source */
+    xmlNodePtr            inc; /* the included copy */
+    int                   xml; /* xml or txt */
+    int                 count; /* how many refs use that specific doc */
+    xmlXPathObjectPtr    xptr; /* the xpointer if needed */
+    int		      emptyFb; /* flag to show fallback empty */
+};
+
+struct _xmlXIncludeCtxt {
+    xmlDocPtr             doc; /* the source document */
+    int               incBase; /* the first include for this document */
+    int                 incNr; /* number of includes */
+    int                incMax; /* size of includes tab */
+    xmlXIncludeRefPtr *incTab; /* array of included references */
+
+    int                 txtNr; /* number of unparsed documents */
+    int                txtMax; /* size of unparsed documents tab */
+    xmlNodePtr        *txtTab; /* array of unparsed text nodes */
+    xmlURL         *txturlTab; /* array of unparsed text URLs */
+
+    xmlChar *             url; /* the current URL processed */
+    int                 urlNr; /* number of URLs stacked */
+    int                urlMax; /* size of URL stack */
+    xmlChar *         *urlTab; /* URL stack */
+
+    int              nbErrors; /* the number of errors detected */
+    int                legacy; /* using XINCLUDE_OLD_NS */
+    int            parseFlags; /* the flags used for parsing XML documents */
+};
+
+static int
+xmlXIncludeDoProcess(xmlXIncludeCtxtPtr ctxt, xmlDocPtr doc, xmlNodePtr tree);
+
+
+/************************************************************************
+ *									*
+ * 			XInclude error handler				*
+ *									*
+ ************************************************************************/
+
+/**
+ * xmlXIncludeErrMemory:
+ * @extra:  extra information
+ *
+ * Handle an out of memory condition
+ */
+static void
+xmlXIncludeErrMemory(xmlXIncludeCtxtPtr ctxt, xmlNodePtr node,
+                     const char *extra)
+{
+    if (ctxt != NULL)
+	ctxt->nbErrors++;
+    __xmlRaiseError(NULL, NULL, NULL, ctxt, node, XML_FROM_XINCLUDE,
+                    XML_ERR_NO_MEMORY, XML_ERR_ERROR, NULL, 0,
+		    extra, NULL, NULL, 0, 0,
+		    "Memory allocation failed : %s\n", extra);
+}
+
+/**
+ * xmlXIncludeErr:
+ * @ctxt: the XInclude context
+ * @node: the context node
+ * @msg:  the error message
+ * @extra:  extra information
+ *
+ * Handle an XInclude error
+ */
+static void
+xmlXIncludeErr(xmlXIncludeCtxtPtr ctxt, xmlNodePtr node, int error,
+               const char *msg, const xmlChar *extra)
+{
+    if (ctxt != NULL)
+	ctxt->nbErrors++;
+    __xmlRaiseError(NULL, NULL, NULL, ctxt, node, XML_FROM_XINCLUDE,
+                    error, XML_ERR_ERROR, NULL, 0,
+		    (const char *) extra, NULL, NULL, 0, 0,
+		    msg, (const char *) extra);
+}
+
+#if 0
+/**
+ * xmlXIncludeWarn:
+ * @ctxt: the XInclude context
+ * @node: the context node
+ * @msg:  the error message
+ * @extra:  extra information
+ *
+ * Emit an XInclude warning.
+ */
+static void
+xmlXIncludeWarn(xmlXIncludeCtxtPtr ctxt, xmlNodePtr node, int error,
+               const char *msg, const xmlChar *extra)
+{
+    __xmlRaiseError(NULL, NULL, NULL, ctxt, node, XML_FROM_XINCLUDE,
+                    error, XML_ERR_WARNING, NULL, 0,
+		    (const char *) extra, NULL, NULL, 0, 0,
+		    msg, (const char *) extra);
+}
+#endif
+
+/**
+ * xmlXIncludeGetProp:
+ * @ctxt:  the XInclude context
+ * @cur:  the node
+ * @name:  the attribute name
+ *
+ * Get an XInclude attribute
+ *
+ * Returns the value (to be freed) or NULL if not found
+ */
+static xmlChar *
+xmlXIncludeGetProp(xmlXIncludeCtxtPtr ctxt, xmlNodePtr cur,
+                   const xmlChar *name) {
+    xmlChar *ret;
+
+    ret = xmlGetNsProp(cur, XINCLUDE_NS, name);
+    if (ret != NULL)
+        return(ret);
+    if (ctxt->legacy != 0) {
+	ret = xmlGetNsProp(cur, XINCLUDE_OLD_NS, name);
+	if (ret != NULL)
+	    return(ret);
+    }
+    ret = xmlGetProp(cur, name);
+    return(ret);
+}
+/**
+ * xmlXIncludeFreeRef:
+ * @ref: the XInclude reference
+ *
+ * Free an XInclude reference
+ */
+static void
+xmlXIncludeFreeRef(xmlXIncludeRefPtr ref) {
+    if (ref == NULL)
+	return;
+#ifdef DEBUG_XINCLUDE
+    xmlGenericError(xmlGenericErrorContext, "Freeing ref\n");
+#endif
+    if (ref->doc != NULL) {
+#ifdef DEBUG_XINCLUDE
+	xmlGenericError(xmlGenericErrorContext, "Freeing doc %s\n", ref->URI);
+#endif
+	xmlFreeDoc(ref->doc);
+    }
+    if (ref->URI != NULL)
+	xmlFree(ref->URI);
+    if (ref->fragment != NULL)
+	xmlFree(ref->fragment);
+    if (ref->xptr != NULL)
+	xmlXPathFreeObject(ref->xptr);
+    xmlFree(ref);
+}
+
+/**
+ * xmlXIncludeNewRef:
+ * @ctxt: the XInclude context
+ * @URI:  the resource URI
+ *
+ * Creates a new reference within an XInclude context
+ *
+ * Returns the new set
+ */
+static xmlXIncludeRefPtr
+xmlXIncludeNewRef(xmlXIncludeCtxtPtr ctxt, const xmlChar *URI,
+	          xmlNodePtr ref) {
+    xmlXIncludeRefPtr ret;
+
+#ifdef DEBUG_XINCLUDE
+    xmlGenericError(xmlGenericErrorContext, "New ref %s\n", URI);
+#endif
+    ret = (xmlXIncludeRefPtr) xmlMalloc(sizeof(xmlXIncludeRef));
+    if (ret == NULL) {
+        xmlXIncludeErrMemory(ctxt, ref, "growing XInclude context");
+	return(NULL);
+    }
+    memset(ret, 0, sizeof(xmlXIncludeRef));
+    if (URI == NULL)
+	ret->URI = NULL;
+    else
+	ret->URI = xmlStrdup(URI);
+    ret->fragment = NULL;
+    ret->ref = ref;
+    ret->doc = 0;
+    ret->count = 0;
+    ret->xml = 0;
+    ret->inc = NULL;
+    if (ctxt->incMax == 0) {
+	ctxt->incMax = 4;
+        ctxt->incTab = (xmlXIncludeRefPtr *) xmlMalloc(ctxt->incMax *
+					      sizeof(ctxt->incTab[0]));
+        if (ctxt->incTab == NULL) {
+	    xmlXIncludeErrMemory(ctxt, ref, "growing XInclude context");
+	    xmlXIncludeFreeRef(ret);
+	    return(NULL);
+	}
+    }
+    if (ctxt->incNr >= ctxt->incMax) {
+	ctxt->incMax *= 2;
+        ctxt->incTab = (xmlXIncludeRefPtr *) xmlRealloc(ctxt->incTab,
+	             ctxt->incMax * sizeof(ctxt->incTab[0]));
+        if (ctxt->incTab == NULL) {
+	    xmlXIncludeErrMemory(ctxt, ref, "growing XInclude context");
+	    xmlXIncludeFreeRef(ret);
+	    return(NULL);
+	}
+    }
+    ctxt->incTab[ctxt->incNr++] = ret;
+    return(ret);
+}
+
+/**
+ * xmlXIncludeNewContext:
+ * @doc:  an XML Document
+ *
+ * Creates a new XInclude context
+ *
+ * Returns the new set
+ */
+xmlXIncludeCtxtPtr
+xmlXIncludeNewContext(xmlDocPtr doc) {
+    xmlXIncludeCtxtPtr ret;
+
+#ifdef DEBUG_XINCLUDE
+    xmlGenericError(xmlGenericErrorContext, "New context\n");
+#endif
+    if (doc == NULL)
+	return(NULL);
+    ret = (xmlXIncludeCtxtPtr) xmlMalloc(sizeof(xmlXIncludeCtxt));
+    if (ret == NULL) {
+	xmlXIncludeErrMemory(NULL, (xmlNodePtr) doc,
+	                     "creating XInclude context");
+	return(NULL);
+    }
+    memset(ret, 0, sizeof(xmlXIncludeCtxt));
+    ret->doc = doc;
+    ret->incNr = 0;
+    ret->incBase = 0;
+    ret->incMax = 0;
+    ret->incTab = NULL;
+    ret->nbErrors = 0;
+    return(ret);
+}
+
+/**
+ * xmlXIncludeURLPush:
+ * @ctxt:  the parser context
+ * @value:  the url
+ *
+ * Pushes a new url on top of the url stack
+ *
+ * Returns -1 in case of error, the index in the stack otherwise
+ */
+static int
+xmlXIncludeURLPush(xmlXIncludeCtxtPtr ctxt,
+	           const xmlChar *value)
+{
+    if (ctxt->urlNr > XINCLUDE_MAX_DEPTH) {
+	xmlXIncludeErr(ctxt, NULL, XML_XINCLUDE_RECURSION,
+	               "detected a recursion in %s\n", value);
+	return(-1);
+    }
+    if (ctxt->urlTab == NULL) {
+	ctxt->urlMax = 4;
+	ctxt->urlNr = 0;
+	ctxt->urlTab = (xmlChar * *) xmlMalloc(
+		        ctxt->urlMax * sizeof(ctxt->urlTab[0]));
+        if (ctxt->urlTab == NULL) {
+	    xmlXIncludeErrMemory(ctxt, NULL, "adding URL");
+            return (-1);
+        }
+    }
+    if (ctxt->urlNr >= ctxt->urlMax) {
+        ctxt->urlMax *= 2;
+        ctxt->urlTab =
+            (xmlChar * *) xmlRealloc(ctxt->urlTab,
+                                      ctxt->urlMax *
+                                      sizeof(ctxt->urlTab[0]));
+        if (ctxt->urlTab == NULL) {
+	    xmlXIncludeErrMemory(ctxt, NULL, "adding URL");
+            return (-1);
+        }
+    }
+    ctxt->url = ctxt->urlTab[ctxt->urlNr] = xmlStrdup(value);
+    return (ctxt->urlNr++);
+}
+
+/**
+ * xmlXIncludeURLPop:
+ * @ctxt: the parser context
+ *
+ * Pops the top URL from the URL stack
+ */
+static void
+xmlXIncludeURLPop(xmlXIncludeCtxtPtr ctxt)
+{
+    xmlChar * ret;
+
+    if (ctxt->urlNr <= 0)
+        return;
+    ctxt->urlNr--;
+    if (ctxt->urlNr > 0)
+        ctxt->url = ctxt->urlTab[ctxt->urlNr - 1];
+    else
+        ctxt->url = NULL;
+    ret = ctxt->urlTab[ctxt->urlNr];
+    ctxt->urlTab[ctxt->urlNr] = 0;
+    if (ret != NULL)
+	xmlFree(ret);
+}
+
+/**
+ * xmlXIncludeFreeContext:
+ * @ctxt: the XInclude context
+ *
+ * Free an XInclude context
+ */
+void
+xmlXIncludeFreeContext(xmlXIncludeCtxtPtr ctxt) {
+    int i;
+
+#ifdef DEBUG_XINCLUDE
+    xmlGenericError(xmlGenericErrorContext, "Freeing context\n");
+#endif
+    if (ctxt == NULL)
+	return;
+    while (ctxt->urlNr > 0)
+	xmlXIncludeURLPop(ctxt);
+    if (ctxt->urlTab != NULL)
+	xmlFree(ctxt->urlTab);
+    for (i = 0;i < ctxt->incNr;i++) {
+	if (ctxt->incTab[i] != NULL)
+	    xmlXIncludeFreeRef(ctxt->incTab[i]);
+    }
+    for (i = 0;i < ctxt->txtNr;i++) {
+	if (ctxt->txturlTab[i] != NULL)
+	    xmlFree(ctxt->txturlTab[i]);
+    }
+    if (ctxt->incTab != NULL)
+	xmlFree(ctxt->incTab);
+    if (ctxt->txtTab != NULL)
+	xmlFree(ctxt->txtTab);
+    if (ctxt->txturlTab != NULL)
+	xmlFree(ctxt->txturlTab);
+    xmlFree(ctxt);
+}
+
+/**
+ * xmlXIncludeParseFile:
+ * @ctxt:  the XInclude context
+ * @URL:  the URL or file path
+ * 
+ * parse a document for XInclude
+ */
+static xmlDocPtr
+xmlXIncludeParseFile(xmlXIncludeCtxtPtr ctxt, const char *URL) {
+    xmlDocPtr ret;
+    xmlParserCtxtPtr pctxt;
+    char *directory = NULL;
+    xmlParserInputPtr inputStream;
+
+    xmlInitParser();
+
+    pctxt = xmlNewParserCtxt();
+    if (pctxt == NULL) {
+	xmlXIncludeErrMemory(ctxt, NULL, "cannot allocate parser context");
+	return(NULL);
+    }
+    /*
+     * try to ensure that new documents included are actually
+     * built with the same dictionary as the including document.
+     */
+    if ((ctxt->doc != NULL) && (ctxt->doc->dict != NULL) &&
+        (pctxt->dict != NULL)) {
+	xmlDictFree(pctxt->dict);
+	pctxt->dict = ctxt->doc->dict;
+	xmlDictReference(pctxt->dict);
+    }
+
+    xmlCtxtUseOptions(pctxt, ctxt->parseFlags | XML_PARSE_DTDLOAD);
+    
+    inputStream = xmlLoadExternalEntity(URL, NULL, pctxt);
+    if (inputStream == NULL) {
+	xmlFreeParserCtxt(pctxt);
+	return(NULL);
+    }
+
+    inputPush(pctxt, inputStream);
+
+    if ((pctxt->directory == NULL) && (directory == NULL))
+        directory = xmlParserGetDirectory(URL);
+    if ((pctxt->directory == NULL) && (directory != NULL))
+        pctxt->directory = (char *) xmlStrdup((xmlChar *) directory);
+
+    pctxt->loadsubset = XML_DETECT_IDS;
+
+    xmlParseDocument(pctxt);
+
+    if (pctxt->wellFormed) {
+        ret = pctxt->myDoc;
+    }
+    else {
+        ret = NULL;
+	if (pctxt->myDoc != NULL)
+	    xmlFreeDoc(pctxt->myDoc);
+        pctxt->myDoc = NULL;
+    }
+    xmlFreeParserCtxt(pctxt);
+    
+    return(ret);
+}
+
+/**
+ * xmlXIncludeAddNode:
+ * @ctxt:  the XInclude context
+ * @cur:  the new node
+ * 
+ * Add a new node to process to an XInclude context
+ */
+static int
+xmlXIncludeAddNode(xmlXIncludeCtxtPtr ctxt, xmlNodePtr cur) {
+    xmlXIncludeRefPtr ref;
+    xmlURIPtr uri;
+    xmlChar *URL;
+    xmlChar *fragment = NULL;
+    xmlChar *href;
+    xmlChar *parse;
+    xmlChar *base;
+    xmlChar *URI;
+    int xml = 1, i; /* default Issue 64 */
+    int local = 0;
+
+
+    if (ctxt == NULL)
+	return(-1);
+    if (cur == NULL)
+	return(-1);
+
+#ifdef DEBUG_XINCLUDE
+    xmlGenericError(xmlGenericErrorContext, "Add node\n");
+#endif
+    /*
+     * read the attributes
+     */
+    href = xmlXIncludeGetProp(ctxt, cur, XINCLUDE_HREF);
+    if (href == NULL) {
+	href = xmlStrdup(BAD_CAST ""); /* @@@@ href is now optional */
+	if (href == NULL) 
+	    return(-1);
+	local = 1;
+    }
+    if (href[0] == '#')
+	local = 1;
+    parse = xmlXIncludeGetProp(ctxt, cur, XINCLUDE_PARSE);
+    if (parse != NULL) {
+	if (xmlStrEqual(parse, XINCLUDE_PARSE_XML))
+	    xml = 1;
+	else if (xmlStrEqual(parse, XINCLUDE_PARSE_TEXT))
+	    xml = 0;
+	else {
+	    xmlXIncludeErr(ctxt, cur, XML_XINCLUDE_PARSE_VALUE,
+	                   "invalid value %s for 'parse'\n", parse);
+	    if (href != NULL)
+		xmlFree(href);
+	    if (parse != NULL)
+		xmlFree(parse);
+	    return(-1);
+	}
+    }
+
+    /*
+     * compute the URI
+     */
+    base = xmlNodeGetBase(ctxt->doc, cur);
+    if (base == NULL) {
+	URI = xmlBuildURI(href, ctxt->doc->URL);
+    } else {
+	URI = xmlBuildURI(href, base);
+    }
+    if (URI == NULL) {
+	xmlChar *escbase;
+	xmlChar *eschref;
+	/*
+	 * Some escaping may be needed
+	 */
+	escbase = xmlURIEscape(base);
+	eschref = xmlURIEscape(href);
+	URI = xmlBuildURI(eschref, escbase);
+	if (escbase != NULL)
+	    xmlFree(escbase);
+	if (eschref != NULL)
+	    xmlFree(eschref);
+    }
+    if (parse != NULL)
+	xmlFree(parse);
+    if (href != NULL)
+	xmlFree(href);
+    if (base != NULL)
+	xmlFree(base);
+    if (URI == NULL) {
+	xmlXIncludeErr(ctxt, cur, XML_XINCLUDE_HREF_URI,
+	               "failed build URL\n", NULL);
+	return(-1);
+    }
+    fragment = xmlXIncludeGetProp(ctxt, cur, XINCLUDE_PARSE_XPOINTER);
+
+    /*
+     * Check the URL and remove any fragment identifier
+     */
+    uri = xmlParseURI((const char *)URI);
+    if (uri == NULL) {
+	xmlXIncludeErr(ctxt, cur, XML_XINCLUDE_HREF_URI,
+	               "invalid value URI %s\n", URI);
+	if (fragment != NULL)
+	    xmlFree(fragment);
+	xmlFree(URI);
+	return(-1);
+    }
+
+    if (uri->fragment != NULL) {
+        if (ctxt->legacy != 0) {
+	    if (fragment == NULL) {
+		fragment = (xmlChar *) uri->fragment;
+	    } else {
+		xmlFree(uri->fragment);
+	    }
+	} else {
+	    xmlXIncludeErr(ctxt, cur, XML_XINCLUDE_FRAGMENT_ID,
+       "Invalid fragment identifier in URI %s use the xpointer attribute\n",
+                           URI);
+	    if (fragment != NULL)
+	        xmlFree(fragment);
+	    xmlFreeURI(uri);
+	    xmlFree(URI);
+	    return(-1);
+	}
+	uri->fragment = NULL;
+    }
+    URL = xmlSaveUri(uri);
+    xmlFreeURI(uri);
+    xmlFree(URI);
+    if (URL == NULL) {
+	xmlXIncludeErr(ctxt, cur, XML_XINCLUDE_HREF_URI,
+	               "invalid value URI %s\n", URI);
+	if (fragment != NULL)
+	    xmlFree(fragment);
+	return(-1);
+    }
+
+    /*
+     * Check the URL against the stack for recursions
+     */
+    if (!local) {
+	for (i = 0;i < ctxt->urlNr;i++) {
+	    if (xmlStrEqual(URL, ctxt->urlTab[i])) {
+		xmlXIncludeErr(ctxt, cur, XML_XINCLUDE_RECURSION,
+		               "detected a recursion in %s\n", URL);
+		return(-1);
+	    }
+	}
+    }
+
+    ref = xmlXIncludeNewRef(ctxt, URL, cur);
+    if (ref == NULL) {
+	return(-1);
+    }
+    ref->fragment = fragment;
+    ref->doc = NULL;
+    ref->xml = xml;
+    ref->count = 1;
+    xmlFree(URL);
+    return(0);
+}
+
+/**
+ * xmlXIncludeRecurseDoc:
+ * @ctxt:  the XInclude context
+ * @doc:  the new document
+ * @url:  the associated URL
+ * 
+ * The XInclude recursive nature is handled at this point.
+ */
+static void
+xmlXIncludeRecurseDoc(xmlXIncludeCtxtPtr ctxt, xmlDocPtr doc,
+	              const xmlURL url ATTRIBUTE_UNUSED) {
+    xmlXIncludeCtxtPtr newctxt;
+    int i;
+
+    /*
+     * Avoid recursion in already substitued resources
+    for (i = 0;i < ctxt->urlNr;i++) {
+	if (xmlStrEqual(doc->URL, ctxt->urlTab[i]))
+	    return;
+    }
+     */
+
+#ifdef DEBUG_XINCLUDE
+    xmlGenericError(xmlGenericErrorContext, "Recursing in doc %s\n", doc->URL);
+#endif
+    /*
+     * Handle recursion here.
+     */
+
+    newctxt = xmlXIncludeNewContext(doc);
+    if (newctxt != NULL) {
+	/*
+	 * Copy the existing document set
+	 */
+	newctxt->incMax = ctxt->incMax;
+	newctxt->incNr = ctxt->incNr;
+        newctxt->incTab = (xmlXIncludeRefPtr *) xmlMalloc(newctxt->incMax *
+		                          sizeof(newctxt->incTab[0]));
+        if (newctxt->incTab == NULL) {
+	    xmlXIncludeErrMemory(ctxt, (xmlNodePtr) doc, "processing doc");
+	    xmlFree(newctxt);
+	    return;
+	}
+	/*
+	 * copy the urlTab
+	 */
+	newctxt->urlMax = ctxt->urlMax;
+	newctxt->urlNr = ctxt->urlNr;
+	newctxt->urlTab = ctxt->urlTab;
+
+	/*
+	 * Inherit the documents already in use by other includes
+	 */
+	newctxt->incBase = ctxt->incNr;
+	for (i = 0;i < ctxt->incNr;i++) {
+	    newctxt->incTab[i] = ctxt->incTab[i];
+	    newctxt->incTab[i]->count++; /* prevent the recursion from
+					    freeing it */
+	}
+	/*
+	 * The new context should also inherit the Parse Flags
+	 * (bug 132597)
+	 */
+	newctxt->parseFlags = ctxt->parseFlags;
+	xmlXIncludeDoProcess(newctxt, doc, xmlDocGetRootElement(doc));
+	for (i = 0;i < ctxt->incNr;i++) {
+	    newctxt->incTab[i]->count--;
+	    newctxt->incTab[i] = NULL;
+	}
+
+	/* urlTab may have been reallocated */
+	ctxt->urlTab = newctxt->urlTab;
+	ctxt->urlMax = newctxt->urlMax;
+
+	newctxt->urlMax = 0;
+	newctxt->urlNr = 0;
+	newctxt->urlTab = NULL;
+
+	xmlXIncludeFreeContext(newctxt);
+    }
+#ifdef DEBUG_XINCLUDE
+    xmlGenericError(xmlGenericErrorContext, "Done recursing in doc %s\n", url);
+#endif
+}
+
+/**
+ * xmlXIncludeAddTxt:
+ * @ctxt:  the XInclude context
+ * @txt:  the new text node
+ * @url:  the associated URL
+ * 
+ * Add a new txtument to the list
+ */
+static void
+xmlXIncludeAddTxt(xmlXIncludeCtxtPtr ctxt, xmlNodePtr txt, const xmlURL url) {
+#ifdef DEBUG_XINCLUDE
+    xmlGenericError(xmlGenericErrorContext, "Adding text %s\n", url);
+#endif
+    if (ctxt->txtMax == 0) {
+	ctxt->txtMax = 4;
+        ctxt->txtTab = (xmlNodePtr *) xmlMalloc(ctxt->txtMax *
+		                          sizeof(ctxt->txtTab[0]));
+        if (ctxt->txtTab == NULL) {
+	    xmlXIncludeErrMemory(ctxt, NULL, "processing text");
+	    return;
+	}
+        ctxt->txturlTab = (xmlURL *) xmlMalloc(ctxt->txtMax *
+		                          sizeof(ctxt->txturlTab[0]));
+        if (ctxt->txturlTab == NULL) {
+	    xmlXIncludeErrMemory(ctxt, NULL, "processing text");
+	    return;
+	}
+    }
+    if (ctxt->txtNr >= ctxt->txtMax) {
+	ctxt->txtMax *= 2;
+        ctxt->txtTab = (xmlNodePtr *) xmlRealloc(ctxt->txtTab,
+	             ctxt->txtMax * sizeof(ctxt->txtTab[0]));
+        if (ctxt->txtTab == NULL) {
+	    xmlXIncludeErrMemory(ctxt, NULL, "processing text");
+	    return;
+	}
+        ctxt->txturlTab = (xmlURL *) xmlRealloc(ctxt->txturlTab,
+	             ctxt->txtMax * sizeof(ctxt->txturlTab[0]));
+        if (ctxt->txturlTab == NULL) {
+	    xmlXIncludeErrMemory(ctxt, NULL, "processing text");
+	    return;
+	}
+    }
+    ctxt->txtTab[ctxt->txtNr] = txt;
+    ctxt->txturlTab[ctxt->txtNr] = xmlStrdup(url);
+    ctxt->txtNr++;
+}
+
+/************************************************************************
+ *									*
+ *			Node copy with specific semantic		*
+ *									*
+ ************************************************************************/
+
+/**
+ * xmlXIncludeCopyNode:
+ * @ctxt:  the XInclude context
+ * @target:  the document target
+ * @source:  the document source
+ * @elem:  the element
+ * 
+ * Make a copy of the node while preserving the XInclude semantic
+ * of the Infoset copy
+ */
+static xmlNodePtr
+xmlXIncludeCopyNode(xmlXIncludeCtxtPtr ctxt, xmlDocPtr target,
+	            xmlDocPtr source, xmlNodePtr elem) {
+    xmlNodePtr result = NULL;
+
+    if ((ctxt == NULL) || (target == NULL) || (source == NULL) ||
+	(elem == NULL))
+	return(NULL);
+    if (elem->type == XML_DTD_NODE)
+	return(NULL);
+    result = xmlDocCopyNode(elem, target, 1);
+    return(result);
+}
+
+/**
+ * xmlXIncludeCopyNodeList:
+ * @ctxt:  the XInclude context
+ * @target:  the document target
+ * @source:  the document source
+ * @elem:  the element list
+ * 
+ * Make a copy of the node list while preserving the XInclude semantic
+ * of the Infoset copy
+ */
+static xmlNodePtr
+xmlXIncludeCopyNodeList(xmlXIncludeCtxtPtr ctxt, xmlDocPtr target,
+	                xmlDocPtr source, xmlNodePtr elem) {
+    xmlNodePtr cur, res, result = NULL, last = NULL;
+
+    if ((ctxt == NULL) || (target == NULL) || (source == NULL) ||
+	(elem == NULL))
+	return(NULL);
+    cur = elem;
+    while (cur != NULL) {
+	res = xmlXIncludeCopyNode(ctxt, target, source, cur);
+	if (res != NULL) {
+	    if (result == NULL) {
+		result = last = res;
+	    } else {
+		last->next = res;
+		res->prev = last;
+		last = res;
+	    }
+	}
+	cur = cur->next;
+    }
+    return(result);
+}
+
+/**
+ * xmlXIncludeGetNthChild:
+ * @cur:  the node
+ * @no:  the child number
+ *
+ * Returns the @n'th element child of @cur or NULL
+ */
+static xmlNodePtr
+xmlXIncludeGetNthChild(xmlNodePtr cur, int no) {
+    int i;
+    if (cur == NULL) 
+	return(cur);
+    cur = cur->children;
+    for (i = 0;i <= no;cur = cur->next) {
+	if (cur == NULL) 
+	    return(cur);
+	if ((cur->type == XML_ELEMENT_NODE) ||
+	    (cur->type == XML_DOCUMENT_NODE) ||
+	    (cur->type == XML_HTML_DOCUMENT_NODE)) {
+	    i++;
+	    if (i == no)
+		break;
+	}
+    }
+    return(cur);
+}
+
+xmlNodePtr xmlXPtrAdvanceNode(xmlNodePtr cur, int *level); /* in xpointer.c */
+/**
+ * xmlXIncludeCopyRange:
+ * @ctxt:  the XInclude context
+ * @target:  the document target
+ * @source:  the document source
+ * @obj:  the XPointer result from the evaluation.
+ *
+ * Build a node list tree copy of the XPointer result.
+ *
+ * Returns an xmlNodePtr list or NULL.
+ *         The caller has to free the node tree.
+ */
+static xmlNodePtr
+xmlXIncludeCopyRange(xmlXIncludeCtxtPtr ctxt, xmlDocPtr target,
+	                xmlDocPtr source, xmlXPathObjectPtr range) {
+    /* pointers to generated nodes */
+    xmlNodePtr list = NULL, last = NULL, listParent = NULL;
+    xmlNodePtr tmp, tmp2;
+    /* pointers to traversal nodes */
+    xmlNodePtr start, cur, end;
+    int index1, index2;
+    int level = 0, lastLevel = 0, endLevel = 0, endFlag = 0;
+
+    if ((ctxt == NULL) || (target == NULL) || (source == NULL) ||
+	(range == NULL))
+	return(NULL);
+    if (range->type != XPATH_RANGE)
+	return(NULL);
+    start = (xmlNodePtr) range->user;
+
+    if (start == NULL)
+	return(NULL);
+    end = range->user2;
+    if (end == NULL)
+	return(xmlDocCopyNode(start, target, 1));
+
+    cur = start;
+    index1 = range->index;
+    index2 = range->index2;
+    /*
+     * level is depth of the current node under consideration
+     * list is the pointer to the root of the output tree
+     * listParent is a pointer to the parent of output tree (within
+       the included file) in case we need to add another level
+     * last is a pointer to the last node added to the output tree
+     * lastLevel is the depth of last (relative to the root)
+     */
+    while (cur != NULL) {
+	/*
+	 * Check if our output tree needs a parent
+	 */
+	if (level < 0) {
+	    while (level < 0) {
+	        /* copy must include namespaces and properties */
+	        tmp2 = xmlDocCopyNode(listParent, target, 2);
+	        xmlAddChild(tmp2, list);
+	        list = tmp2;
+	        listParent = listParent->parent;
+	        level++;
+	    }
+	    last = list;
+	    lastLevel = 0;
+	}
+	/*
+	 * Check whether we need to change our insertion point
+	 */
+	while (level < lastLevel) {
+	    last = last->parent;
+	    lastLevel --;
+	}
+	if (cur == end) {	/* Are we at the end of the range? */
+	    if (cur->type == XML_TEXT_NODE) {
+		const xmlChar *content = cur->content;
+		int len;
+
+		if (content == NULL) {
+		    tmp = xmlNewTextLen(NULL, 0);
+		} else {
+		    len = index2;
+		    if ((cur == start) && (index1 > 1)) {
+			content += (index1 - 1);
+			len -= (index1 - 1);
+			index1 = 0;
+		    } else {
+			len = index2;
+		    }
+		    tmp = xmlNewTextLen(content, len);
+		}
+		/* single sub text node selection */
+		if (list == NULL)
+		    return(tmp);
+		/* prune and return full set */
+		if (level == lastLevel)
+		    xmlAddNextSibling(last, tmp);
+		else 
+		    xmlAddChild(last, tmp);
+		return(list);
+	    } else {	/* ending node not a text node */
+	        endLevel = level;	/* remember the level of the end node */
+		endFlag = 1;
+		/* last node - need to take care of properties + namespaces */
+		tmp = xmlDocCopyNode(cur, target, 2);
+		if (list == NULL) {
+		    list = tmp;
+		    listParent = cur->parent;
+		} else {
+		    if (level == lastLevel)
+			xmlAddNextSibling(last, tmp);
+		    else {
+			xmlAddChild(last, tmp);
+			lastLevel = level;
+		    }
+		}
+		last = tmp;
+
+		if (index2 > 1) {
+		    end = xmlXIncludeGetNthChild(cur, index2 - 1);
+		    index2 = 0;
+		}
+		if ((cur == start) && (index1 > 1)) {
+		    cur = xmlXIncludeGetNthChild(cur, index1 - 1);
+		    index1 = 0;
+		}  else {
+		    cur = cur->children;
+		}
+		level++;	/* increment level to show change */
+		/*
+		 * Now gather the remaining nodes from cur to end
+		 */
+		continue;	/* while */
+	    }
+	} else if (cur == start) {	/* Not at the end, are we at start? */
+	    if ((cur->type == XML_TEXT_NODE) ||
+		(cur->type == XML_CDATA_SECTION_NODE)) {
+		const xmlChar *content = cur->content;
+
+		if (content == NULL) {
+		    tmp = xmlNewTextLen(NULL, 0);
+		} else {
+		    if (index1 > 1) {
+			content += (index1 - 1);
+			index1 = 0;
+		    }
+		    tmp = xmlNewText(content);
+		}
+		last = list = tmp;
+		listParent = cur->parent;
+	    } else {		/* Not text node */
+	        /*
+		 * start of the range - need to take care of
+		 * properties and namespaces
+		 */
+		tmp = xmlDocCopyNode(cur, target, 2);
+		list = last = tmp;
+		listParent = cur->parent;
+		if (index1 > 1) {	/* Do we need to position? */
+		    cur = xmlXIncludeGetNthChild(cur, index1 - 1);
+		    level = lastLevel = 1;
+		    index1 = 0;
+		    /*
+		     * Now gather the remaining nodes from cur to end
+		     */
+		    continue; /* while */
+		}
+	    }
+	} else {
+	    tmp = NULL;
+	    switch (cur->type) {
+		case XML_DTD_NODE:
+		case XML_ELEMENT_DECL:
+		case XML_ATTRIBUTE_DECL:
+		case XML_ENTITY_NODE:
+		    /* Do not copy DTD informations */
+		    break;
+		case XML_ENTITY_DECL:
+		    /* handle crossing entities -> stack needed */
+		    break;
+		case XML_XINCLUDE_START:
+		case XML_XINCLUDE_END:
+		    /* don't consider it part of the tree content */
+		    break;
+		case XML_ATTRIBUTE_NODE:
+		    /* Humm, should not happen ! */
+		    break;
+		default:
+		    /*
+		     * Middle of the range - need to take care of
+		     * properties and namespaces
+		     */
+		    tmp = xmlDocCopyNode(cur, target, 2);
+		    break;
+	    }
+	    if (tmp != NULL) {
+		if (level == lastLevel)
+		    xmlAddNextSibling(last, tmp);
+		else {
+		    xmlAddChild(last, tmp);
+		    lastLevel = level;
+		}
+		last = tmp;
+	    }
+	}
+	/*
+	 * Skip to next node in document order
+	 */
+	cur = xmlXPtrAdvanceNode(cur, &level);
+	if (endFlag && (level >= endLevel))
+	    break;
+    }
+    return(list);
+}
+
+/**
+ * xmlXIncludeBuildNodeList:
+ * @ctxt:  the XInclude context
+ * @target:  the document target
+ * @source:  the document source
+ * @obj:  the XPointer result from the evaluation.
+ *
+ * Build a node list tree copy of the XPointer result.
+ * This will drop Attributes and Namespace declarations.
+ *
+ * Returns an xmlNodePtr list or NULL.
+ *         the caller has to free the node tree.
+ */
+static xmlNodePtr
+xmlXIncludeCopyXPointer(xmlXIncludeCtxtPtr ctxt, xmlDocPtr target,
+	                xmlDocPtr source, xmlXPathObjectPtr obj) {
+    xmlNodePtr list = NULL, last = NULL;
+    int i;
+
+    if (source == NULL)
+	source = ctxt->doc;
+    if ((ctxt == NULL) || (target == NULL) || (source == NULL) ||
+	(obj == NULL))
+	return(NULL);
+    switch (obj->type) {
+        case XPATH_NODESET: {
+	    xmlNodeSetPtr set = obj->nodesetval;
+	    if (set == NULL)
+		return(NULL);
+	    for (i = 0;i < set->nodeNr;i++) {
+		if (set->nodeTab[i] == NULL)
+		    continue;
+		switch (set->nodeTab[i]->type) {
+		    case XML_TEXT_NODE:
+		    case XML_CDATA_SECTION_NODE:
+		    case XML_ELEMENT_NODE:
+		    case XML_ENTITY_REF_NODE:
+		    case XML_ENTITY_NODE:
+		    case XML_PI_NODE:
+		    case XML_COMMENT_NODE:
+		    case XML_DOCUMENT_NODE:
+		    case XML_HTML_DOCUMENT_NODE:
+#ifdef LIBXML_DOCB_ENABLED
+		    case XML_DOCB_DOCUMENT_NODE:
+#endif
+		    case XML_XINCLUDE_END:
+			break;
+		    case XML_XINCLUDE_START: {
+	                xmlNodePtr tmp, cur = set->nodeTab[i];
+
+			cur = cur->next;
+			while (cur != NULL) {
+			    switch(cur->type) {
+				case XML_TEXT_NODE:
+				case XML_CDATA_SECTION_NODE:
+				case XML_ELEMENT_NODE:
+				case XML_ENTITY_REF_NODE:
+				case XML_ENTITY_NODE:
+				case XML_PI_NODE:
+				case XML_COMMENT_NODE:
+				    tmp = xmlXIncludeCopyNode(ctxt, target,
+							      source, cur);
+				    if (last == NULL) {
+					list = last = tmp;
+				    } else {
+					xmlAddNextSibling(last, tmp);
+					last = tmp;
+				    }
+				    cur = cur->next;
+				    continue;
+				default:
+				    break;
+			    }
+			    break;
+			}
+			continue;
+		    }
+		    case XML_ATTRIBUTE_NODE:
+		    case XML_NAMESPACE_DECL:
+		    case XML_DOCUMENT_TYPE_NODE:
+		    case XML_DOCUMENT_FRAG_NODE:
+		    case XML_NOTATION_NODE:
+		    case XML_DTD_NODE:
+		    case XML_ELEMENT_DECL:
+		    case XML_ATTRIBUTE_DECL:
+		    case XML_ENTITY_DECL:
+			continue; /* for */
+		}
+		if (last == NULL)
+		    list = last = xmlXIncludeCopyNode(ctxt, target, source,
+			                              set->nodeTab[i]);
+		else {
+		    xmlAddNextSibling(last,
+			    xmlXIncludeCopyNode(ctxt, target, source,
+				                set->nodeTab[i]));
+		    if (last->next != NULL)
+			last = last->next;
+		}
+	    }
+	    break;
+	}
+	case XPATH_LOCATIONSET: {
+	    xmlLocationSetPtr set = (xmlLocationSetPtr) obj->user;
+	    if (set == NULL)
+		return(NULL);
+	    for (i = 0;i < set->locNr;i++) {
+		if (last == NULL)
+		    list = last = xmlXIncludeCopyXPointer(ctxt, target, source,
+			                                  set->locTab[i]);
+		else
+		    xmlAddNextSibling(last,
+			    xmlXIncludeCopyXPointer(ctxt, target, source,
+				                    set->locTab[i]));
+		if (last != NULL) {
+		    while (last->next != NULL)
+			last = last->next;
+		}
+	    }
+	    break;
+	}
+#ifdef LIBXML_XPTR_ENABLED
+	case XPATH_RANGE:
+	    return(xmlXIncludeCopyRange(ctxt, target, source, obj));
+#endif
+	case XPATH_POINT:
+	    /* points are ignored in XInclude */
+	    break;
+	default:
+	    break;
+    }
+    return(list);
+}
+/************************************************************************
+ *									*
+ *			XInclude I/O handling				*
+ *									*
+ ************************************************************************/
+
+typedef struct _xmlXIncludeMergeData xmlXIncludeMergeData;
+typedef xmlXIncludeMergeData *xmlXIncludeMergeDataPtr;
+struct _xmlXIncludeMergeData {
+    xmlDocPtr doc;
+    xmlXIncludeCtxtPtr ctxt;
+};
+
+/**
+ * xmlXIncludeMergeOneEntity:
+ * @ent: the entity
+ * @doc:  the including doc
+ * @nr: the entity name
+ *
+ * Inplements the merge of one entity
+ */
+static void
+xmlXIncludeMergeEntity(xmlEntityPtr ent, xmlXIncludeMergeDataPtr data,
+	               xmlChar *name ATTRIBUTE_UNUSED) {
+    xmlEntityPtr ret, prev;
+    xmlDocPtr doc;
+    xmlXIncludeCtxtPtr ctxt;
+
+    if ((ent == NULL) || (data == NULL))
+	return;
+    ctxt = data->ctxt;
+    doc = data->doc;
+    if ((ctxt == NULL) || (doc == NULL))
+	return;
+    switch (ent->etype) {
+        case XML_INTERNAL_PARAMETER_ENTITY:
+        case XML_EXTERNAL_PARAMETER_ENTITY:
+        case XML_INTERNAL_PREDEFINED_ENTITY:
+	    return;
+        case XML_INTERNAL_GENERAL_ENTITY:
+        case XML_EXTERNAL_GENERAL_PARSED_ENTITY:
+        case XML_EXTERNAL_GENERAL_UNPARSED_ENTITY:
+	    break;
+    }
+    ret = xmlAddDocEntity(doc, ent->name, ent->etype, ent->ExternalID,
+			  ent->SystemID, ent->content);
+    if (ret != NULL) {
+	if (ent->URI != NULL)
+	    ret->URI = xmlStrdup(ent->URI);
+    } else {
+	prev = xmlGetDocEntity(doc, ent->name);
+	if (prev != NULL) {
+	    if (ent->etype != prev->etype)
+		goto error;
+	
+	    if ((ent->SystemID != NULL) && (prev->SystemID != NULL)) {
+		if (!xmlStrEqual(ent->SystemID, prev->SystemID))
+		    goto error;
+	    } else if ((ent->ExternalID != NULL) &&
+		       (prev->ExternalID != NULL)) {
+		if (!xmlStrEqual(ent->ExternalID, prev->ExternalID))
+		    goto error;
+	    } else if ((ent->content != NULL) && (prev->content != NULL)) {
+		if (!xmlStrEqual(ent->content, prev->content))
+		    goto error;
+	    } else {
+		goto error;
+	    }
+
+	}
+    }
+    return;
+error:
+    switch (ent->etype) {
+        case XML_INTERNAL_PARAMETER_ENTITY:
+        case XML_EXTERNAL_PARAMETER_ENTITY:
+        case XML_INTERNAL_PREDEFINED_ENTITY:
+        case XML_INTERNAL_GENERAL_ENTITY:
+        case XML_EXTERNAL_GENERAL_PARSED_ENTITY:
+	    return;
+        case XML_EXTERNAL_GENERAL_UNPARSED_ENTITY:
+	    break;
+    }
+    xmlXIncludeErr(ctxt, (xmlNodePtr) ent, XML_XINCLUDE_ENTITY_DEF_MISMATCH,
+                   "mismatch in redefinition of entity %s\n",
+		   ent->name);
+}
+
+/**
+ * xmlXIncludeMergeEntities:
+ * @ctxt: an XInclude context
+ * @doc:  the including doc
+ * @from:  the included doc
+ *
+ * Inplements the entity merge
+ *
+ * Returns 0 if merge succeeded, -1 if some processing failed
+ */
+static int
+xmlXIncludeMergeEntities(xmlXIncludeCtxtPtr ctxt, xmlDocPtr doc,
+	                 xmlDocPtr from) {
+    xmlNodePtr cur;
+    xmlDtdPtr target, source;
+
+    if (ctxt == NULL)
+	return(-1);
+
+    if ((from == NULL) || (from->intSubset == NULL))
+	return(0);
+
+    target = doc->intSubset;
+    if (target == NULL) {
+	cur = xmlDocGetRootElement(doc);
+	if (cur == NULL)
+	    return(-1);
+        target = xmlCreateIntSubset(doc, cur->name, NULL, NULL);
+	if (target == NULL)
+	    return(-1);
+    }
+
+    source = from->intSubset;
+    if ((source != NULL) && (source->entities != NULL)) {
+	xmlXIncludeMergeData data;
+
+	data.ctxt = ctxt;
+	data.doc = doc;
+
+	xmlHashScan((xmlHashTablePtr) source->entities,
+		    (xmlHashScanner) xmlXIncludeMergeEntity, &data);
+    }
+    source = from->extSubset;
+    if ((source != NULL) && (source->entities != NULL)) {
+	xmlXIncludeMergeData data;
+
+	data.ctxt = ctxt;
+	data.doc = doc;
+
+	/*
+	 * don't duplicate existing stuff when external subsets are the same
+	 */
+	if ((!xmlStrEqual(target->ExternalID, source->ExternalID)) &&
+	    (!xmlStrEqual(target->SystemID, source->SystemID))) {
+	    xmlHashScan((xmlHashTablePtr) source->entities,
+			(xmlHashScanner) xmlXIncludeMergeEntity, &data);
+	}
+    }
+    return(0);
+}
+
+/**
+ * xmlXIncludeLoadDoc:
+ * @ctxt:  the XInclude context
+ * @url:  the associated URL
+ * @nr:  the xinclude node number
+ * 
+ * Load the document, and store the result in the XInclude context
+ *
+ * Returns 0 in case of success, -1 in case of failure
+ */
+static int
+xmlXIncludeLoadDoc(xmlXIncludeCtxtPtr ctxt, const xmlChar *url, int nr) {
+    xmlDocPtr doc;
+    xmlURIPtr uri;
+    xmlChar *URL;
+    xmlChar *fragment = NULL;
+    int i = 0;
+#ifdef LIBXML_XPTR_ENABLED
+    int saveFlags;
+#endif
+
+#ifdef DEBUG_XINCLUDE
+    xmlGenericError(xmlGenericErrorContext, "Loading doc %s:%d\n", url, nr);
+#endif
+    /*
+     * Check the URL and remove any fragment identifier
+     */
+    uri = xmlParseURI((const char *)url);
+    if (uri == NULL) {
+	xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref, 
+	               XML_XINCLUDE_HREF_URI,
+		       "invalid value URI %s\n", url);
+	return(-1);
+    }
+    if (uri->fragment != NULL) {
+	fragment = (xmlChar *) uri->fragment;
+	uri->fragment = NULL;
+    }
+    if ((ctxt->incTab != NULL) && (ctxt->incTab[nr] != NULL) &&
+        (ctxt->incTab[nr]->fragment != NULL)) {
+	if (fragment != NULL) xmlFree(fragment);
+	fragment = xmlStrdup(ctxt->incTab[nr]->fragment);
+    }
+    URL = xmlSaveUri(uri);
+    xmlFreeURI(uri);
+    if (URL == NULL) {
+	xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref, 
+	               XML_XINCLUDE_HREF_URI,
+		       "invalid value URI %s\n", url);
+	if (fragment != NULL)
+	    xmlFree(fragment);
+	return(-1);
+    }
+
+    /*
+     * Handling of references to the local document are done
+     * directly through ctxt->doc.
+     */
+    if ((URL[0] == 0) || (URL[0] == '#') ||
+	((ctxt->doc != NULL) && (xmlStrEqual(URL, ctxt->doc->URL)))) {
+	doc = NULL;
+        goto loaded;
+    }
+
+    /*
+     * Prevent reloading twice the document.
+     */
+    for (i = 0; i < ctxt->incNr; i++) {
+	if ((xmlStrEqual(URL, ctxt->incTab[i]->URI)) &&
+	    (ctxt->incTab[i]->doc != NULL)) {
+	    doc = ctxt->incTab[i]->doc;
+#ifdef DEBUG_XINCLUDE
+	    printf("Already loaded %s\n", URL);
+#endif
+	    goto loaded;
+	}
+    }
+
+    /*
+     * Load it.
+     */
+#ifdef DEBUG_XINCLUDE
+    printf("loading %s\n", URL);
+#endif
+#ifdef LIBXML_XPTR_ENABLED
+    /*
+     * If this is an XPointer evaluation, we want to assure that
+     * all entities have been resolved prior to processing the
+     * referenced document
+     */
+    saveFlags = ctxt->parseFlags;
+    if (fragment != NULL) {	/* if this is an XPointer eval */
+	ctxt->parseFlags |= XML_PARSE_NOENT;
+    }
+#endif
+
+    doc = xmlXIncludeParseFile(ctxt, (const char *)URL);
+#ifdef LIBXML_XPTR_ENABLED
+    ctxt->parseFlags = saveFlags;
+#endif
+    if (doc == NULL) {
+	xmlFree(URL);
+	if (fragment != NULL)
+	    xmlFree(fragment);
+	return(-1);
+    }
+    ctxt->incTab[nr]->doc = doc;
+    for (i = nr + 1; i < ctxt->incNr; i++) {
+	if (xmlStrEqual(URL, ctxt->incTab[i]->URI)) {
+	    ctxt->incTab[nr]->count++;
+#ifdef DEBUG_XINCLUDE
+	    printf("Increasing %s count since reused\n", URL);
+#endif
+            break;
+	}
+    }
+
+    /*
+     * Make sure we have all entities fixed up
+     */
+    xmlXIncludeMergeEntities(ctxt, ctxt->doc, doc);
+
+    /*
+     * We don't need the DTD anymore, free up space
+    if (doc->intSubset != NULL) {
+	xmlUnlinkNode((xmlNodePtr) doc->intSubset);
+	xmlFreeNode((xmlNodePtr) doc->intSubset);
+	doc->intSubset = NULL;
+    }
+    if (doc->extSubset != NULL) {
+	xmlUnlinkNode((xmlNodePtr) doc->extSubset);
+	xmlFreeNode((xmlNodePtr) doc->extSubset);
+	doc->extSubset = NULL;
+    }
+     */
+    xmlXIncludeRecurseDoc(ctxt, doc, URL);
+
+loaded:
+    if (fragment == NULL) {
+	/*
+	 * Add the top children list as the replacement copy.
+	 */
+	if (doc == NULL)
+	{
+	    /* Hopefully a DTD declaration won't be copied from
+	     * the same document */
+	    ctxt->incTab[nr]->inc = xmlCopyNodeList(ctxt->doc->children);
+	} else {
+	    ctxt->incTab[nr]->inc = xmlXIncludeCopyNodeList(ctxt, ctxt->doc,
+		                                       doc, doc->children);
+	}
+    } 
+#ifdef LIBXML_XPTR_ENABLED
+    else {
+	/*
+	 * Computes the XPointer expression and make a copy used
+	 * as the replacement copy.
+	 */
+	xmlXPathObjectPtr xptr;
+	xmlXPathContextPtr xptrctxt;
+	xmlNodeSetPtr set;
+
+	if (doc == NULL) {
+	    xptrctxt = xmlXPtrNewContext(ctxt->doc, ctxt->incTab[nr]->ref,
+		                         NULL);
+	} else {
+	    xptrctxt = xmlXPtrNewContext(doc, NULL, NULL);
+	}
+	if (xptrctxt == NULL) {
+	    xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref, 
+	                   XML_XINCLUDE_XPTR_FAILED,
+			   "could not create XPointer context\n", NULL);
+	    xmlFree(URL);
+	    xmlFree(fragment);
+	    return(-1);
+	}
+	xptr = xmlXPtrEval(fragment, xptrctxt);
+	if (xptr == NULL) {
+	    xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
+	                   XML_XINCLUDE_XPTR_FAILED,
+			   "XPointer evaluation failed: #%s\n",
+			   fragment);
+	    xmlXPathFreeContext(xptrctxt);
+	    xmlFree(URL);
+	    xmlFree(fragment);
+	    return(-1);
+	}
+	switch (xptr->type) {
+	    case XPATH_UNDEFINED:
+	    case XPATH_BOOLEAN:
+	    case XPATH_NUMBER:
+	    case XPATH_STRING:
+	    case XPATH_POINT:
+	    case XPATH_USERS:
+	    case XPATH_XSLT_TREE:
+		xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref, 
+		               XML_XINCLUDE_XPTR_RESULT,
+			       "XPointer is not a range: #%s\n",
+			       fragment);
+		xmlXPathFreeContext(xptrctxt);
+		xmlFree(URL);
+		xmlFree(fragment);
+		return(-1);
+	    case XPATH_NODESET:
+	        if ((xptr->nodesetval == NULL) ||
+		    (xptr->nodesetval->nodeNr <= 0)) {
+		    xmlXPathFreeContext(xptrctxt);
+		    xmlFree(URL);
+		    xmlFree(fragment);
+		    return(-1);
+		}
+	    case XPATH_RANGE:
+	    case XPATH_LOCATIONSET:
+		break;
+	}
+	set = xptr->nodesetval;
+	if (set != NULL) {
+	    for (i = 0;i < set->nodeNr;i++) {
+		if (set->nodeTab[i] == NULL)
+		    continue;
+		switch (set->nodeTab[i]->type) {
+		    case XML_TEXT_NODE:
+		    case XML_CDATA_SECTION_NODE:
+		    case XML_ELEMENT_NODE:
+		    case XML_ENTITY_REF_NODE:
+		    case XML_ENTITY_NODE:
+		    case XML_PI_NODE:
+		    case XML_COMMENT_NODE:
+		    case XML_DOCUMENT_NODE:
+		    case XML_HTML_DOCUMENT_NODE:
+#ifdef LIBXML_DOCB_ENABLED
+		    case XML_DOCB_DOCUMENT_NODE:
+#endif
+			continue;
+		    case XML_ATTRIBUTE_NODE:
+			xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref, 
+			               XML_XINCLUDE_XPTR_RESULT,
+				       "XPointer selects an attribute: #%s\n",
+				       fragment);
+			set->nodeTab[i] = NULL;
+			continue;
+		    case XML_NAMESPACE_DECL:
+			xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref, 
+			               XML_XINCLUDE_XPTR_RESULT,
+				       "XPointer selects a namespace: #%s\n",
+				       fragment);
+			set->nodeTab[i] = NULL;
+			continue;
+		    case XML_DOCUMENT_TYPE_NODE:
+		    case XML_DOCUMENT_FRAG_NODE:
+		    case XML_NOTATION_NODE:
+		    case XML_DTD_NODE:
+		    case XML_ELEMENT_DECL:
+		    case XML_ATTRIBUTE_DECL:
+		    case XML_ENTITY_DECL:
+		    case XML_XINCLUDE_START:
+		    case XML_XINCLUDE_END:
+			xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref, 
+			               XML_XINCLUDE_XPTR_RESULT,
+				   "XPointer selects unexpected nodes: #%s\n",
+				       fragment);
+			set->nodeTab[i] = NULL;
+			set->nodeTab[i] = NULL;
+			continue; /* for */
+		}
+	    }
+	}
+	if (doc == NULL) {
+	    ctxt->incTab[nr]->xptr = xptr;
+	    ctxt->incTab[nr]->inc = NULL;
+	} else {
+	    ctxt->incTab[nr]->inc =
+		xmlXIncludeCopyXPointer(ctxt, ctxt->doc, doc, xptr);
+	    xmlXPathFreeObject(xptr);
+	}
+	xmlXPathFreeContext(xptrctxt);
+	xmlFree(fragment);
+    }
+#endif
+
+    /*
+     * Do the xml:base fixup if needed
+     */
+    if ((doc != NULL) && (URL != NULL) && (xmlStrchr(URL, (xmlChar) '/'))) {
+	xmlNodePtr node;
+
+	node = ctxt->incTab[nr]->inc;
+	while (node != NULL) {
+	    if (node->type == XML_ELEMENT_NODE)
+		xmlNodeSetBase(node, URL);
+	    node = node->next;
+	}
+    }
+    if ((nr < ctxt->incNr) && (ctxt->incTab[nr]->doc != NULL) &&
+	(ctxt->incTab[nr]->count <= 1)) {
+#ifdef DEBUG_XINCLUDE
+        printf("freeing %s\n", ctxt->incTab[nr]->doc->URL);
+#endif
+	xmlFreeDoc(ctxt->incTab[nr]->doc);
+	ctxt->incTab[nr]->doc = NULL;
+    }
+    xmlFree(URL);
+    return(0);
+}
+
+/**
+ * xmlXIncludeLoadTxt:
+ * @ctxt:  the XInclude context
+ * @url:  the associated URL
+ * @nr:  the xinclude node number
+ * 
+ * Load the content, and store the result in the XInclude context
+ *
+ * Returns 0 in case of success, -1 in case of failure
+ */
+static int
+xmlXIncludeLoadTxt(xmlXIncludeCtxtPtr ctxt, const xmlChar *url, int nr) {
+    xmlParserInputBufferPtr buf;
+    xmlNodePtr node;
+    xmlURIPtr uri;
+    xmlChar *URL;
+    int i;
+    xmlChar *encoding = NULL;
+    xmlCharEncoding enc = (xmlCharEncoding) 0;
+
+    /*
+     * Check the URL and remove any fragment identifier
+     */
+    uri = xmlParseURI((const char *)url);
+    if (uri == NULL) {
+	xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref, XML_XINCLUDE_HREF_URI,
+	               "invalid value URI %s\n", url);
+	return(-1);
+    }
+    if (uri->fragment != NULL) {
+	xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref, XML_XINCLUDE_TEXT_FRAGMENT,
+	               "fragment identifier forbidden for text: %s\n",
+		       (const xmlChar *) uri->fragment);
+	xmlFreeURI(uri);
+	return(-1);
+    }
+    URL = xmlSaveUri(uri);
+    xmlFreeURI(uri);
+    if (URL == NULL) {
+	xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref, XML_XINCLUDE_HREF_URI,
+	               "invalid value URI %s\n", url);
+	return(-1);
+    }
+
+    /*
+     * Handling of references to the local document are done
+     * directly through ctxt->doc.
+     */
+    if (URL[0] == 0) {
+	xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref, 
+	               XML_XINCLUDE_TEXT_DOCUMENT,
+		       "text serialization of document not available\n", NULL);
+	xmlFree(URL);
+	return(-1);
+    }
+
+    /*
+     * Prevent reloading twice the document.
+     */
+    for (i = 0; i < ctxt->txtNr; i++) {
+	if (xmlStrEqual(URL, ctxt->txturlTab[i])) {
+	    node = xmlCopyNode(ctxt->txtTab[i], 1);
+	    goto loaded;
+	}
+    }
+    /*
+     * Try to get the encoding if available
+     */
+    if ((ctxt->incTab[nr] != NULL) && (ctxt->incTab[nr]->ref != NULL)) {
+	encoding = xmlGetProp(ctxt->incTab[nr]->ref, XINCLUDE_PARSE_ENCODING);
+    }
+    if (encoding != NULL) {
+	/*
+	 * TODO: we should not have to remap to the xmlCharEncoding
+	 *       predefined set, a better interface than
+	 *       xmlParserInputBufferCreateFilename should allow any
+	 *       encoding supported by iconv
+	 */
+        enc = xmlParseCharEncoding((const char *) encoding);
+	if (enc == XML_CHAR_ENCODING_ERROR) {
+	    xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
+	                   XML_XINCLUDE_UNKNOWN_ENCODING,
+			   "encoding %s not supported\n", encoding);
+	    xmlFree(encoding);
+	    xmlFree(URL);
+	    return(-1);
+	}
+	xmlFree(encoding);
+    }
+
+    /*
+     * Load it.
+     */
+    buf = xmlParserInputBufferCreateFilename((const char *)URL, enc);
+    if (buf == NULL) {
+	xmlFree(URL);
+	return(-1);
+    }
+    node = xmlNewText(NULL);
+
+    /*
+     * Scan all chars from the resource and add the to the node
+     */
+    while (xmlParserInputBufferRead(buf, 128) > 0) {
+	int len;
+	const xmlChar *content;
+
+	content = xmlBufferContent(buf->buffer);
+	len = xmlBufferLength(buf->buffer);
+	for (i = 0;i < len;) {
+	    int cur;
+	    int l;
+
+	    cur = xmlStringCurrentChar(NULL, &content[i], &l);
+	    if (!IS_CHAR(cur)) {
+		xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
+		               XML_XINCLUDE_INVALID_CHAR,
+			       "%s contains invalid char\n", URL);
+	    } else {
+		xmlNodeAddContentLen(node, &content[i], l);
+	    }
+	    i += l;
+	}
+	xmlBufferShrink(buf->buffer, len);
+    }
+    xmlFreeParserInputBuffer(buf);
+    xmlXIncludeAddTxt(ctxt, node, URL);
+
+loaded:
+    /*
+     * Add the element as the replacement copy.
+     */
+    ctxt->incTab[nr]->inc = node;
+    xmlFree(URL);
+    return(0);
+}
+
+/**
+ * xmlXIncludeLoadFallback:
+ * @ctxt:  the XInclude context
+ * @fallback:  the fallback node
+ * @nr:  the xinclude node number
+ * 
+ * Load the content of the fallback node, and store the result
+ * in the XInclude context
+ *
+ * Returns 0 in case of success, -1 in case of failure
+ */
+static int
+xmlXIncludeLoadFallback(xmlXIncludeCtxtPtr ctxt, xmlNodePtr fallback, int nr) {
+    xmlXIncludeCtxtPtr newctxt;
+    int ret = 0;
+    
+    if ((fallback == NULL) || (ctxt == NULL))
+	return(-1);
+    if (fallback->children != NULL) {
+	/*
+	 * It's possible that the fallback also has 'includes'
+	 * (Bug 129969), so we re-process the fallback just in case
+	 */
+	newctxt = xmlXIncludeNewContext(ctxt->doc);
+	if (newctxt == NULL)
+	    return (-1);
+	xmlXIncludeSetFlags(newctxt, ctxt->parseFlags);
+	ret = xmlXIncludeDoProcess(newctxt, ctxt->doc, fallback->children);
+	if (ctxt->nbErrors > 0)
+	    ret = -1;
+	else if (ret > 0)
+	    ret = 0;	/* xmlXIncludeDoProcess can return +ve number */
+	xmlXIncludeFreeContext(newctxt);
+
+	ctxt->incTab[nr]->inc = xmlCopyNodeList(fallback->children);
+    } else {
+        ctxt->incTab[nr]->inc = NULL;
+	ctxt->incTab[nr]->emptyFb = 1;	/* flag empty callback */
+    }
+    return(ret);
+}
+
+/************************************************************************
+ *									*
+ *			XInclude Processing				*
+ *									*
+ ************************************************************************/
+
+/**
+ * xmlXIncludePreProcessNode:
+ * @ctxt: an XInclude context
+ * @node: an XInclude node
+ *
+ * Implement the XInclude preprocessing, currently just adding the element
+ * for further processing.
+ *
+ * Returns the result list or NULL in case of error
+ */
+static xmlNodePtr
+xmlXIncludePreProcessNode(xmlXIncludeCtxtPtr ctxt, xmlNodePtr node) {
+    xmlXIncludeAddNode(ctxt, node);
+    return(0);
+}
+
+/**
+ * xmlXIncludeLoadNode:
+ * @ctxt: an XInclude context
+ * @nr: the node number
+ *
+ * Find and load the infoset replacement for the given node.
+ *
+ * Returns 0 if substitution succeeded, -1 if some processing failed
+ */
+static int
+xmlXIncludeLoadNode(xmlXIncludeCtxtPtr ctxt, int nr) {
+    xmlNodePtr cur;
+    xmlChar *href;
+    xmlChar *parse;
+    xmlChar *base;
+    xmlChar *URI;
+    int xml = 1; /* default Issue 64 */
+    int ret;
+
+    if (ctxt == NULL)
+	return(-1);
+    if ((nr < 0) || (nr >= ctxt->incNr))
+	return(-1);
+    cur = ctxt->incTab[nr]->ref;
+    if (cur == NULL)
+	return(-1);
+
+    /*
+     * read the attributes
+     */
+    href = xmlXIncludeGetProp(ctxt, cur, XINCLUDE_HREF);
+    if (href == NULL) {
+	href = xmlStrdup(BAD_CAST ""); /* @@@@ href is now optional */
+	if (href == NULL) 
+	    return(-1);
+    }
+    parse = xmlXIncludeGetProp(ctxt, cur, XINCLUDE_PARSE);
+    if (parse != NULL) {
+	if (xmlStrEqual(parse, XINCLUDE_PARSE_XML))
+	    xml = 1;
+	else if (xmlStrEqual(parse, XINCLUDE_PARSE_TEXT))
+	    xml = 0;
+	else {
+	    xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref,
+	                   XML_XINCLUDE_PARSE_VALUE,
+			   "invalid value %s for 'parse'\n", parse);
+	    if (href != NULL)
+		xmlFree(href);
+	    if (parse != NULL)
+		xmlFree(parse);
+	    return(-1);
+	}
+    }
+
+    /*
+     * compute the URI
+     */
+    base = xmlNodeGetBase(ctxt->doc, cur);
+    if (base == NULL) {
+	URI = xmlBuildURI(href, ctxt->doc->URL);
+    } else {
+	URI = xmlBuildURI(href, base);
+    }
+    if (URI == NULL) {
+	xmlChar *escbase;
+	xmlChar *eschref;
+	/*
+	 * Some escaping may be needed
+	 */
+	escbase = xmlURIEscape(base);
+	eschref = xmlURIEscape(href);
+	URI = xmlBuildURI(eschref, escbase);
+	if (escbase != NULL)
+	    xmlFree(escbase);
+	if (eschref != NULL)
+	    xmlFree(eschref);
+    }
+    if (URI == NULL) {
+	xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref, 
+	               XML_XINCLUDE_HREF_URI, "failed build URL\n", NULL);
+	if (parse != NULL)
+	    xmlFree(parse);
+	if (href != NULL)
+	    xmlFree(href);
+	if (base != NULL)
+	    xmlFree(base);
+	return(-1);
+    }
+#ifdef DEBUG_XINCLUDE
+    xmlGenericError(xmlGenericErrorContext, "parse: %s\n",
+	    xml ? "xml": "text");
+    xmlGenericError(xmlGenericErrorContext, "URI: %s\n", URI);
+#endif
+
+    /*
+     * Cleanup
+     */
+    if (xml) {
+	ret = xmlXIncludeLoadDoc(ctxt, URI, nr);
+	/* xmlXIncludeGetFragment(ctxt, cur, URI); */
+    } else {
+	ret = xmlXIncludeLoadTxt(ctxt, URI, nr);
+    }
+    if (ret < 0) {
+	xmlNodePtr children;
+
+	/*
+	 * Time to try a fallback if availble
+	 */
+#ifdef DEBUG_XINCLUDE
+	xmlGenericError(xmlGenericErrorContext, "error looking for fallback\n");
+#endif
+	children = cur->children;
+	while (children != NULL) {
+	    if ((children->type == XML_ELEMENT_NODE) &&
+		(children->ns != NULL) &&
+		(xmlStrEqual(children->name, XINCLUDE_FALLBACK)) &&
+		((xmlStrEqual(children->ns->href, XINCLUDE_NS)) ||
+		 (xmlStrEqual(children->ns->href, XINCLUDE_OLD_NS)))) {
+		ret = xmlXIncludeLoadFallback(ctxt, children, nr);
+		if (ret == 0) 
+		    break;
+	    }
+	    children = children->next;
+	}
+    }
+    if (ret < 0) {
+	xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref, 
+	               XML_XINCLUDE_NO_FALLBACK,
+		       "could not load %s, and no fallback was found\n",
+		       URI);
+    }
+
+    /*
+     * Cleanup
+     */
+    if (URI != NULL)
+	xmlFree(URI);
+    if (parse != NULL)
+	xmlFree(parse);
+    if (href != NULL)
+	xmlFree(href);
+    if (base != NULL)
+	xmlFree(base);
+    return(0);
+}
+
+/**
+ * xmlXIncludeIncludeNode:
+ * @ctxt: an XInclude context
+ * @nr: the node number
+ *
+ * Inplement the infoset replacement for the given node
+ *
+ * Returns 0 if substitution succeeded, -1 if some processing failed
+ */
+static int
+xmlXIncludeIncludeNode(xmlXIncludeCtxtPtr ctxt, int nr) {
+    xmlNodePtr cur, end, list, tmp;
+
+    if (ctxt == NULL)
+	return(-1);
+    if ((nr < 0) || (nr >= ctxt->incNr))
+	return(-1);
+    cur = ctxt->incTab[nr]->ref;
+    if (cur == NULL)
+	return(-1);
+
+    /*
+     * If we stored an XPointer a late computation may be needed
+     */
+    if ((ctxt->incTab[nr]->inc == NULL) &&
+	(ctxt->incTab[nr]->xptr != NULL)) {
+	ctxt->incTab[nr]->inc =
+	    xmlXIncludeCopyXPointer(ctxt, ctxt->doc, ctxt->doc,
+		                    ctxt->incTab[nr]->xptr);
+	xmlXPathFreeObject(ctxt->incTab[nr]->xptr);
+	ctxt->incTab[nr]->xptr = NULL;
+    }
+    list = ctxt->incTab[nr]->inc;
+    ctxt->incTab[nr]->inc = NULL;
+
+    /*
+     * Check against the risk of generating a multi-rooted document
+     */
+    if ((cur->parent != NULL) &&
+	(cur->parent->type != XML_ELEMENT_NODE)) {
+	int nb_elem = 0;
+
+	tmp = list;
+	while (tmp != NULL) {
+	    if (tmp->type == XML_ELEMENT_NODE)
+		nb_elem++;
+	    tmp = tmp->next;
+	}
+	if (nb_elem > 1) {
+	    xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref, 
+	                   XML_XINCLUDE_MULTIPLE_ROOT,
+		       "XInclude error: would result in multiple root nodes\n",
+			   NULL);
+	    return(-1);
+	}
+    }
+
+    /*
+     * Change the current node as an XInclude start one, and add an
+     * entity end one
+     */
+    cur->type = XML_XINCLUDE_START;
+    end = xmlNewNode(cur->ns, cur->name);
+    if (end == NULL) {
+	xmlXIncludeErr(ctxt, ctxt->incTab[nr]->ref, XML_XINCLUDE_BUILD_FAILED,
+	               "failed to build node\n", NULL);
+	return(-1);
+    }
+    end->type = XML_XINCLUDE_END;
+    xmlAddNextSibling(cur, end);
+
+    /*
+     * Add the list of nodes
+     */
+    while (list != NULL) {
+	cur = list;
+	list = list->next;
+
+        xmlAddPrevSibling(end, cur);
+    }
+
+    
+    return(0);
+}
+
+/**
+ * xmlXIncludeTestNode:
+ * @ctxt: the XInclude processing context
+ * @node: an XInclude node
+ *
+ * test if the node is an XInclude node
+ *
+ * Returns 1 true, 0 otherwise
+ */
+static int
+xmlXIncludeTestNode(xmlXIncludeCtxtPtr ctxt, xmlNodePtr node) {
+    if (node == NULL)
+	return(0);
+    if (node->type != XML_ELEMENT_NODE)
+	return(0);
+    if (node->ns == NULL)
+	return(0);
+    if ((xmlStrEqual(node->ns->href, XINCLUDE_NS)) ||
+        (xmlStrEqual(node->ns->href, XINCLUDE_OLD_NS))) {
+	if (xmlStrEqual(node->ns->href, XINCLUDE_OLD_NS)) {
+	    if (ctxt->legacy == 0) {
+#if 0 /* wait for the XML Core Working Group to get something stable ! */
+		xmlXIncludeWarn(ctxt, node, XML_XINCLUDE_DEPRECATED_NS,
+	               "Deprecated XInclude namespace found, use %s",
+		                XINCLUDE_NS);
+#endif
+	        ctxt->legacy = 1;
+	    }
+	}
+	if (xmlStrEqual(node->name, XINCLUDE_NODE)) {
+	    xmlNodePtr child = node->children;
+	    int nb_fallback = 0;
+
+	    while (child != NULL) {
+		if ((child->type == XML_ELEMENT_NODE) &&
+		    (child->ns != NULL) &&
+		    ((xmlStrEqual(child->ns->href, XINCLUDE_NS)) ||
+		     (xmlStrEqual(child->ns->href, XINCLUDE_OLD_NS)))) {
+		    if (xmlStrEqual(child->name, XINCLUDE_NODE)) {
+			xmlXIncludeErr(ctxt, node,
+			               XML_XINCLUDE_INCLUDE_IN_INCLUDE,
+				       "%s has an 'include' child\n",
+				       XINCLUDE_NODE);
+			return(0);
+		    }
+		    if (xmlStrEqual(child->name, XINCLUDE_FALLBACK)) {
+			nb_fallback++;
+		    }
+		}
+		child = child->next;
+	    }
+	    if (nb_fallback > 1) {
+		xmlXIncludeErr(ctxt, node, XML_XINCLUDE_FALLBACKS_IN_INCLUDE,
+			       "%s has multiple fallback children\n",
+		               XINCLUDE_NODE);
+		return(0);
+	    }
+	    return(1);
+	}
+	if (xmlStrEqual(node->name, XINCLUDE_FALLBACK)) {
+	    if ((node->parent == NULL) ||
+		(node->parent->type != XML_ELEMENT_NODE) ||
+		(node->parent->ns == NULL) ||
+		((!xmlStrEqual(node->parent->ns->href, XINCLUDE_NS)) &&
+		 (!xmlStrEqual(node->parent->ns->href, XINCLUDE_OLD_NS))) ||
+		(!xmlStrEqual(node->parent->name, XINCLUDE_NODE))) {
+		xmlXIncludeErr(ctxt, node,
+		               XML_XINCLUDE_FALLBACK_NOT_IN_INCLUDE,
+			       "%s is not the child of an 'include'\n",
+			       XINCLUDE_FALLBACK);
+	    }
+	}
+    }
+    return(0);
+}
+
+/**
+ * xmlXIncludeDoProcess:
+ * @ctxt: the XInclude processing context
+ * @doc: an XML document
+ * @tree: the top of the tree to process
+ *
+ * Implement the XInclude substitution on the XML document @doc
+ *
+ * Returns 0 if no substitution were done, -1 if some processing failed
+ *    or the number of substitutions done.
+ */
+static int
+xmlXIncludeDoProcess(xmlXIncludeCtxtPtr ctxt, xmlDocPtr doc, xmlNodePtr tree) {
+    xmlNodePtr cur;
+    int ret = 0;
+    int i;
+
+    if ((doc == NULL) || (tree == NULL))
+	return(-1);
+    if (ctxt == NULL)
+	return(-1);
+
+    if (doc->URL != NULL) {
+	ret = xmlXIncludeURLPush(ctxt, doc->URL);
+	if (ret < 0)
+	    return(-1);
+    }
+
+    /*
+     * First phase: lookup the elements in the document
+     */
+    cur = tree;
+    if (xmlXIncludeTestNode(ctxt, cur) == 1)
+	xmlXIncludePreProcessNode(ctxt, cur);
+    while (cur != NULL) {
+	/* TODO: need to work on entities -> stack */
+	if ((cur->children != NULL) &&
+	    (cur->children->type != XML_ENTITY_DECL) &&
+	    (cur->children->type != XML_XINCLUDE_START) &&
+	    (cur->children->type != XML_XINCLUDE_END)) {
+	    cur = cur->children;
+	    if (xmlXIncludeTestNode(ctxt, cur))
+		xmlXIncludePreProcessNode(ctxt, cur);
+	} else if (cur->next != NULL) {
+	    cur = cur->next;
+	    if (xmlXIncludeTestNode(ctxt, cur))
+		xmlXIncludePreProcessNode(ctxt, cur);
+	} else {
+	    if (cur == tree)
+	        break;
+	    do {
+		cur = cur->parent;
+		if (cur == NULL) break; /* do */
+		if (cur->next != NULL) {
+		    cur = cur->next;
+		    if (xmlXIncludeTestNode(ctxt, cur))
+			xmlXIncludePreProcessNode(ctxt, cur);
+		    break; /* do */
+		}
+	    } while (cur != NULL);
+	}
+    }
+
+    /*
+     * Second Phase : collect the infosets fragments
+     */
+    for (i = ctxt->incBase;i < ctxt->incNr; i++) {
+        xmlXIncludeLoadNode(ctxt, i);
+	ret++;
+    }
+
+    /*
+     * Third phase: extend the original document infoset.
+     *
+     * Originally we bypassed the inclusion if there were any errors
+     * encountered on any of the XIncludes.  A bug was raised (bug
+     * 132588) requesting that we output the XIncludes without error,
+     * so the check for inc!=NULL || xptr!=NULL was put in.  This may
+     * give some other problems in the future, but for now it seems to
+     * work ok.
+     *
+     */
+    for (i = ctxt->incBase;i < ctxt->incNr; i++) {
+	if ((ctxt->incTab[i]->inc != NULL) ||
+		(ctxt->incTab[i]->xptr != NULL) ||
+		(ctxt->incTab[i]->emptyFb != 0))	/* (empty fallback) */
+	    xmlXIncludeIncludeNode(ctxt, i);
+    }
+
+    if (doc->URL != NULL)
+	xmlXIncludeURLPop(ctxt);
+    return(ret);
+}
+
+/**
+ * xmlXIncludeSetFlags:
+ * @ctxt:  an XInclude processing context
+ * @flags: a set of xmlParserOption used for parsing XML includes
+ *
+ * Set the flags used for further processing of XML resources.
+ *
+ * Returns 0 in case of success and -1 in case of error.
+ */
+int
+xmlXIncludeSetFlags(xmlXIncludeCtxtPtr ctxt, int flags) {
+    if (ctxt == NULL)
+        return(-1);
+    ctxt->parseFlags = flags;
+    return(0);
+}
+ 
+/**
+ * xmlXIncludeProcessFlags:
+ * @doc: an XML document
+ * @flags: a set of xmlParserOption used for parsing XML includes
+ *
+ * Implement the XInclude substitution on the XML document @doc
+ *
+ * Returns 0 if no substitution were done, -1 if some processing failed
+ *    or the number of substitutions done.
+ */
+int
+xmlXIncludeProcessFlags(xmlDocPtr doc, int flags) {
+    xmlXIncludeCtxtPtr ctxt;
+    xmlNodePtr tree;
+    int ret = 0;
+
+    if (doc == NULL)
+	return(-1);
+    tree = xmlDocGetRootElement(doc);
+    if (tree == NULL)
+	return(-1);
+    ctxt = xmlXIncludeNewContext(doc);
+    if (ctxt == NULL)
+	return(-1);
+    xmlXIncludeSetFlags(ctxt, flags);
+    ret = xmlXIncludeDoProcess(ctxt, doc, tree);
+    if ((ret >= 0) && (ctxt->nbErrors > 0))
+	ret = -1;
+
+    xmlXIncludeFreeContext(ctxt);
+    return(ret);
+}
+
+/**
+ * xmlXIncludeProcess:
+ * @doc: an XML document
+ *
+ * Implement the XInclude substitution on the XML document @doc
+ *
+ * Returns 0 if no substitution were done, -1 if some processing failed
+ *    or the number of substitutions done.
+ */
+int
+xmlXIncludeProcess(xmlDocPtr doc) {
+    return(xmlXIncludeProcessFlags(doc, 0));
+}
+
+/**
+ * xmlXIncludeProcessTreeFlags:
+ * @tree: a node in an XML document
+ * @flags: a set of xmlParserOption used for parsing XML includes
+ *
+ * Implement the XInclude substitution for the given subtree
+ *
+ * Returns 0 if no substitution were done, -1 if some processing failed
+ *    or the number of substitutions done.
+ */
+int
+xmlXIncludeProcessTreeFlags(xmlNodePtr tree, int flags) {
+    xmlXIncludeCtxtPtr ctxt;
+    int ret = 0;
+
+    if ((tree == NULL) || (tree->doc == NULL))
+	return(-1);
+    ctxt = xmlXIncludeNewContext(tree->doc);
+    if (ctxt == NULL)
+	return(-1);
+    xmlXIncludeSetFlags(ctxt, flags);
+    ret = xmlXIncludeDoProcess(ctxt, tree->doc, tree);
+    if ((ret >= 0) && (ctxt->nbErrors > 0))
+	ret = -1;
+
+    xmlXIncludeFreeContext(ctxt);
+    return(ret);
+}
+
+/**
+ * xmlXIncludeProcessTree:
+ * @tree: a node in an XML document
+ *
+ * Implement the XInclude substitution for the given subtree
+ *
+ * Returns 0 if no substitution were done, -1 if some processing failed
+ *    or the number of substitutions done.
+ */
+int
+xmlXIncludeProcessTree(xmlNodePtr tree) {
+    return(xmlXIncludeProcessTreeFlags(tree, 0));
+}
+
+/**
+ * xmlXIncludeProcessNode:
+ * @ctxt: an existing XInclude context
+ * @node: a node in an XML document
+ *
+ * Implement the XInclude substitution for the given subtree reusing
+ * the informations and data coming from the given context.
+ *
+ * Returns 0 if no substitution were done, -1 if some processing failed
+ *    or the number of substitutions done.
+ */
+int
+xmlXIncludeProcessNode(xmlXIncludeCtxtPtr ctxt, xmlNodePtr node) {
+    int ret = 0;
+
+    if ((node == NULL) || (node->doc == NULL) || (ctxt == NULL))
+	return(-1);
+    ret = xmlXIncludeDoProcess(ctxt, node->doc, node);
+    if ((ret >= 0) && (ctxt->nbErrors > 0))
+	ret = -1;
+    return(ret);
+}
+
+#else /* !LIBXML_XINCLUDE_ENABLED */
+#endif
diff --git a/src/libxml/src/xlink.c b/src/libxml/src/xlink.c
new file mode 100644
index 0000000..4454d17
--- /dev/null
+++ b/src/libxml/src/xlink.c
@@ -0,0 +1,181 @@
+/*
+ * xlink.c : implementation of the hyperlinks detection module
+ *           This version supports both XML XLinks and HTML simple links
+ *
+ * See Copyright for the status of this software.
+ *
+ * daniel@veillard.com
+ */
+
+
+#define IN_LIBXML
+#include "libxml.h"
+
+#ifdef LIBXML_XPTR_ENABLED
+#include <string.h> /* for memset() only */
+#ifdef HAVE_CTYPE_H
+#include <ctype.h>
+#endif
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+#ifdef HAVE_SYS_STAT_H
+#include <sys/stat.h>
+#endif
+#ifdef HAVE_FCNTL_H
+#include <fcntl.h>
+#endif
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#ifdef HAVE_ZLIB_H
+#include <zlib.h>
+#endif
+
+#include <libxml/xmlmemory.h>
+#include <libxml/tree.h>
+#include <libxml/parser.h>
+#include <libxml/valid.h>
+#include <libxml/xlink.h>
+#include <libxml/globals.h>
+
+#define XLINK_NAMESPACE (BAD_CAST "http://www.w3.org/1999/xlink/namespace/")
+#define XHTML_NAMESPACE (BAD_CAST "http://www.w3.org/1999/xhtml/")
+
+/****************************************************************
+ *								*
+ *           Default setting and related functions		*
+ *								*
+ ****************************************************************/
+ 
+static xlinkHandlerPtr xlinkDefaultHandler = NULL;
+static xlinkNodeDetectFunc	xlinkDefaultDetect = NULL;
+
+/**
+ * xlinkGetDefaultHandler:
+ *
+ * Get the default xlink handler.
+ *
+ * Returns the current xlinkHandlerPtr value.
+ */
+xlinkHandlerPtr
+xlinkGetDefaultHandler(void) {
+    return(xlinkDefaultHandler);
+}
+
+
+/**
+ * xlinkSetDefaultHandler:
+ * @handler:  the new value for the xlink handler block
+ *
+ * Set the default xlink handlers
+ */
+void
+xlinkSetDefaultHandler(xlinkHandlerPtr handler) {
+    xlinkDefaultHandler = handler;
+}
+
+/**
+ * xlinkGetDefaultDetect:
+ *
+ * Get the default xlink detection routine
+ *
+ * Returns the current function or NULL;
+ */
+xlinkNodeDetectFunc
+xlinkGetDefaultDetect	(void) {
+    return(xlinkDefaultDetect);
+}
+
+/**
+ * xlinkSetDefaultDetect:
+ * @func: pointer to the new detection routine.
+ *
+ * Set the default xlink detection routine
+ */
+void 
+xlinkSetDefaultDetect	(xlinkNodeDetectFunc func) {
+    xlinkDefaultDetect = func;
+}
+
+/****************************************************************
+ *								*
+ *                  The detection routines			*
+ *								*
+ ****************************************************************/
+
+ 
+/**
+ * xlinkIsLink:
+ * @doc:  the document containing the node
+ * @node:  the node pointer itself
+ *
+ * Check whether the given node carries the attributes needed
+ * to be a link element (or is one of the linking elements issued
+ * from the (X)HTML DtDs).
+ * This routine don't try to do full checking of the link validity
+ * but tries to detect and return the appropriate link type.
+ *
+ * Returns the xlinkType of the node (XLINK_TYPE_NONE if there is no
+ *         link detected.
+ */
+xlinkType 
+xlinkIsLink	(xmlDocPtr doc, xmlNodePtr node) {
+    xmlChar *type = NULL, *role = NULL;
+    xlinkType ret = XLINK_TYPE_NONE;
+
+    if (node == NULL) return(XLINK_TYPE_NONE);
+    if (doc == NULL) doc = node->doc;
+    if ((doc != NULL) && (doc->type == XML_HTML_DOCUMENT_NODE)) {
+        /*
+	 * This is an HTML document.
+	 */
+    } else if ((node->ns != NULL) &&
+               (xmlStrEqual(node->ns->href, XHTML_NAMESPACE))) {
+	/*
+	 * !!!! We really need an IS_XHTML_ELEMENT function from HTMLtree.h @@@
+	 */
+        /*
+	 * This is an XHTML element within an XML document
+	 * Check whether it's one of the element able to carry links
+	 * and in that case if it holds the attributes.
+	 */
+    }
+
+    /*
+     * We don't prevent a-priori having XML Linking constructs on
+     * XHTML elements
+     */
+    type = xmlGetNsProp(node, BAD_CAST"type", XLINK_NAMESPACE);
+    if (type != NULL) {
+	if (xmlStrEqual(type, BAD_CAST "simple")) {
+            ret = XLINK_TYPE_SIMPLE;
+	} if (xmlStrEqual(type, BAD_CAST "extended")) {
+	    role = xmlGetNsProp(node, BAD_CAST "role", XLINK_NAMESPACE);
+	    if (role != NULL) {
+		xmlNsPtr xlink;
+		xlink = xmlSearchNs(doc, node, XLINK_NAMESPACE);
+		if (xlink == NULL) {
+		    /* Humm, fallback method */
+		    if (xmlStrEqual(role, BAD_CAST"xlink:external-linkset")) 
+			ret = XLINK_TYPE_EXTENDED_SET;
+		} else {
+		    xmlChar buf[200];
+		    snprintf((char *) buf, sizeof(buf), "%s:external-linkset",
+			     (char *) xlink->prefix);
+                    buf[sizeof(buf) - 1] = 0;
+		    if (xmlStrEqual(role, buf))
+			ret = XLINK_TYPE_EXTENDED_SET;
+
+		}
+
+	    }
+	    ret = XLINK_TYPE_EXTENDED;
+	}
+    }
+
+    if (type != NULL) xmlFree(type);
+    if (role != NULL) xmlFree(role);
+    return(ret);
+}
+#endif /* LIBXML_XPTR_ENABLED */
diff --git a/src/libxml/src/xmlIO.c b/src/libxml/src/xmlIO.c
new file mode 100644
index 0000000..8c4b68f
--- /dev/null
+++ b/src/libxml/src/xmlIO.c
@@ -0,0 +1,3372 @@
+/*
+ * xmlIO.c : implementation of the I/O interfaces used by the parser
+ *
+ * See Copyright for the status of this software.
+ *
+ * daniel@veillard.com
+ *
+ * 14 Nov 2000 ht - for VMS, truncated name of long functions to under 32 char
+ */
+
+#define IN_LIBXML
+#include "libxml.h"
+
+#include <string.h>
+#ifdef HAVE_ERRNO_H
+#include <errno.h>
+#endif
+
+
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_STAT_H
+#include <sys/stat.h>
+#endif
+#ifdef HAVE_FCNTL_H
+#include <fcntl.h>
+#endif
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+#ifdef HAVE_ZLIB_H
+#include <zlib.h>
+#endif
+
+/* Figure a portable way to know if a file is a directory. */
+#ifndef HAVE_STAT
+#  ifdef HAVE__STAT
+     /* MS C library seems to define stat and _stat. The definition
+        is identical. Still, mapping them to each other causes a warning. */
+#    ifndef _MSC_VER
+#      define stat(x,y) _stat(x,y)
+#    endif
+#    define HAVE_STAT
+#  endif
+#endif
+#ifdef HAVE_STAT
+#  ifndef S_ISDIR
+#    ifdef _S_ISDIR
+#      define S_ISDIR(x) _S_ISDIR(x)
+#    else
+#      ifdef S_IFDIR
+#        ifndef S_IFMT
+#          ifdef _S_IFMT
+#            define S_IFMT _S_IFMT
+#          endif
+#        endif
+#        ifdef S_IFMT
+#          define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
+#        endif
+#      endif
+#    endif
+#  endif
+#endif
+
+#include <libxml/xmlmemory.h>
+#include <libxml/parser.h>
+#include <libxml/parserInternals.h>
+#include <libxml/xmlIO.h>
+#include <libxml/uri.h>
+#include <libxml/nanohttp.h>
+#include <libxml/nanoftp.h>
+#include <libxml/xmlerror.h>
+#ifdef LIBXML_CATALOG_ENABLED
+#include <libxml/catalog.h>
+#endif
+#include <libxml/globals.h>
+
+/* #define VERBOSE_FAILURE */
+/* #define DEBUG_EXTERNAL_ENTITIES */
+/* #define DEBUG_INPUT */
+
+#ifdef DEBUG_INPUT
+#define MINLEN 40
+#else
+#define MINLEN 4000
+#endif
+
+/*
+ * Input I/O callback sets
+ */
+typedef struct _xmlInputCallback {
+    xmlInputMatchCallback matchcallback;
+    xmlInputOpenCallback opencallback;
+    xmlInputReadCallback readcallback;
+    xmlInputCloseCallback closecallback;
+} xmlInputCallback;
+
+#define MAX_INPUT_CALLBACK 15
+
+static xmlInputCallback xmlInputCallbackTable[MAX_INPUT_CALLBACK];
+static int xmlInputCallbackNr = 0;
+static int xmlInputCallbackInitialized = 0;
+
+#ifdef LIBXML_OUTPUT_ENABLED
+/*
+ * Output I/O callback sets
+ */
+typedef struct _xmlOutputCallback {
+    xmlOutputMatchCallback matchcallback;
+    xmlOutputOpenCallback opencallback;
+    xmlOutputWriteCallback writecallback;
+    xmlOutputCloseCallback closecallback;
+} xmlOutputCallback;
+
+#define MAX_OUTPUT_CALLBACK 15
+
+static xmlOutputCallback xmlOutputCallbackTable[MAX_OUTPUT_CALLBACK];
+static int xmlOutputCallbackNr = 0;
+static int xmlOutputCallbackInitialized = 0;
+#endif /* LIBXML_OUTPUT_ENABLED */
+
+/************************************************************************
+ *									*
+ * 		Tree memory error handler				*
+ *									*
+ ************************************************************************/
+
+static const char *IOerr[] = {
+    "Unknown IO error",         /* UNKNOWN */
+    "Permission denied",	/* EACCES */
+    "Resource temporarily unavailable",/* EAGAIN */
+    "Bad file descriptor",	/* EBADF */
+    "Bad message",		/* EBADMSG */
+    "Resource busy",		/* EBUSY */
+    "Operation canceled",	/* ECANCELED */
+    "No child processes",	/* ECHILD */
+    "Resource deadlock avoided",/* EDEADLK */
+    "Domain error",		/* EDOM */
+    "File exists",		/* EEXIST */
+    "Bad address",		/* EFAULT */
+    "File too large",		/* EFBIG */
+    "Operation in progress",	/* EINPROGRESS */
+    "Interrupted function call",/* EINTR */
+    "Invalid argument",		/* EINVAL */
+    "Input/output error",	/* EIO */
+    "Is a directory",		/* EISDIR */
+    "Too many open files",	/* EMFILE */
+    "Too many links",		/* EMLINK */
+    "Inappropriate message buffer length",/* EMSGSIZE */
+    "Filename too long",	/* ENAMETOOLONG */
+    "Too many open files in system",/* ENFILE */
+    "No such device",		/* ENODEV */
+    "No such file or directory",/* ENOENT */
+    "Exec format error",	/* ENOEXEC */
+    "No locks available",	/* ENOLCK */
+    "Not enough space",		/* ENOMEM */
+    "No space left on device",	/* ENOSPC */
+    "Function not implemented",	/* ENOSYS */
+    "Not a directory",		/* ENOTDIR */
+    "Directory not empty",	/* ENOTEMPTY */
+    "Not supported",		/* ENOTSUP */
+    "Inappropriate I/O control operation",/* ENOTTY */
+    "No such device or address",/* ENXIO */
+    "Operation not permitted",	/* EPERM */
+    "Broken pipe",		/* EPIPE */
+    "Result too large",		/* ERANGE */
+    "Read-only file system",	/* EROFS */
+    "Invalid seek",		/* ESPIPE */
+    "No such process",		/* ESRCH */
+    "Operation timed out",	/* ETIMEDOUT */
+    "Improper link",		/* EXDEV */
+    "Attempt to load network entity %s", /* XML_IO_NETWORK_ATTEMPT */
+    "encoder error",		/* XML_IO_ENCODER */
+    "flush error",
+    "write error",
+    "no input",
+    "buffer full",
+    "loading error",
+    "not a socket",		/* ENOTSOCK */
+    "already connected",	/* EISCONN */
+    "connection refuxed",	/* ECONNREFUSED */
+    "unreachable network",	/* ENETUNREACH */
+    "adddress in use",		/* EADDRINUSE */
+    "already in use",		/* EALREADY */
+    "unknown address familly",	/* EAFNOSUPPORT */
+};
+
+/**
+ * xmlIOErrMemory:
+ * @extra:  extra informations
+ *
+ * Handle an out of memory condition
+ */
+static void
+xmlIOErrMemory(const char *extra)
+{
+    __xmlSimpleError(XML_FROM_IO, XML_ERR_NO_MEMORY, NULL, NULL, extra);
+}
+
+/**
+ * __xmlIOErr:
+ * @code:  the error number
+ * @
+ * @extra:  extra informations
+ *
+ * Handle an I/O error
+ */
+void
+__xmlIOErr(int domain, int code, const char *extra)
+{
+    unsigned int idx;
+
+    if (code == 0) {
+#ifdef HAVE_ERRNO_H
+	if (errno == 0) code = 0;
+#ifdef EACCES
+        else if (errno == EACCES) code = XML_IO_EACCES;
+#endif
+#ifdef EAGAIN
+        else if (errno == EAGAIN) code = XML_IO_EAGAIN;
+#endif
+#ifdef EBADF
+        else if (errno == EBADF) code = XML_IO_EBADF;
+#endif
+#ifdef EBADMSG
+        else if (errno == EBADMSG) code = XML_IO_EBADMSG;
+#endif
+#ifdef EBUSY
+        else if (errno == EBUSY) code = XML_IO_EBUSY;
+#endif
+#ifdef ECANCELED
+        else if (errno == ECANCELED) code = XML_IO_ECANCELED;
+#endif
+#ifdef ECHILD
+        else if (errno == ECHILD) code = XML_IO_ECHILD;
+#endif
+#ifdef EDEADLK
+        else if (errno == EDEADLK) code = XML_IO_EDEADLK;
+#endif
+#ifdef EDOM
+        else if (errno == EDOM) code = XML_IO_EDOM;
+#endif
+#ifdef EEXIST
+        else if (errno == EEXIST) code = XML_IO_EEXIST;
+#endif
+#ifdef EFAULT
+        else if (errno == EFAULT) code = XML_IO_EFAULT;
+#endif
+#ifdef EFBIG
+        else if (errno == EFBIG) code = XML_IO_EFBIG;
+#endif
+#ifdef EINPROGRESS
+        else if (errno == EINPROGRESS) code = XML_IO_EINPROGRESS;
+#endif
+#ifdef EINTR
+        else if (errno == EINTR) code = XML_IO_EINTR;
+#endif
+#ifdef EINVAL
+        else if (errno == EINVAL) code = XML_IO_EINVAL;
+#endif
+#ifdef EIO
+        else if (errno == EIO) code = XML_IO_EIO;
+#endif
+#ifdef EISDIR
+        else if (errno == EISDIR) code = XML_IO_EISDIR;
+#endif
+#ifdef EMFILE
+        else if (errno == EMFILE) code = XML_IO_EMFILE;
+#endif
+#ifdef EMLINK
+        else if (errno == EMLINK) code = XML_IO_EMLINK;
+#endif
+#ifdef EMSGSIZE
+        else if (errno == EMSGSIZE) code = XML_IO_EMSGSIZE;
+#endif
+#ifdef ENAMETOOLONG
+        else if (errno == ENAMETOOLONG) code = XML_IO_ENAMETOOLONG;
+#endif
+#ifdef ENFILE
+        else if (errno == ENFILE) code = XML_IO_ENFILE;
+#endif
+#ifdef ENODEV
+        else if (errno == ENODEV) code = XML_IO_ENODEV;
+#endif
+#ifdef ENOENT
+        else if (errno == ENOENT) code = XML_IO_ENOENT;
+#endif
+#ifdef ENOEXEC
+        else if (errno == ENOEXEC) code = XML_IO_ENOEXEC;
+#endif
+#ifdef ENOLCK
+        else if (errno == ENOLCK) code = XML_IO_ENOLCK;
+#endif
+#ifdef ENOMEM
+        else if (errno == ENOMEM) code = XML_IO_ENOMEM;
+#endif
+#ifdef ENOSPC
+        else if (errno == ENOSPC) code = XML_IO_ENOSPC;
+#endif
+#ifdef ENOSYS
+        else if (errno == ENOSYS) code = XML_IO_ENOSYS;
+#endif
+#ifdef ENOTDIR
+        else if (errno == ENOTDIR) code = XML_IO_ENOTDIR;
+#endif
+#ifdef ENOTEMPTY
+        else if (errno == ENOTEMPTY) code = XML_IO_ENOTEMPTY;
+#endif
+#ifdef ENOTSUP
+        else if (errno == ENOTSUP) code = XML_IO_ENOTSUP;
+#endif
+#ifdef ENOTTY
+        else if (errno == ENOTTY) code = XML_IO_ENOTTY;
+#endif
+#ifdef ENXIO
+        else if (errno == ENXIO) code = XML_IO_ENXIO;
+#endif
+#ifdef EPERM
+        else if (errno == EPERM) code = XML_IO_EPERM;
+#endif
+#ifdef EPIPE
+        else if (errno == EPIPE) code = XML_IO_EPIPE;
+#endif
+#ifdef ERANGE
+        else if (errno == ERANGE) code = XML_IO_ERANGE;
+#endif
+#ifdef EROFS
+        else if (errno == EROFS) code = XML_IO_EROFS;
+#endif
+#ifdef ESPIPE
+        else if (errno == ESPIPE) code = XML_IO_ESPIPE;
+#endif
+#ifdef ESRCH
+        else if (errno == ESRCH) code = XML_IO_ESRCH;
+#endif
+#ifdef ETIMEDOUT
+        else if (errno == ETIMEDOUT) code = XML_IO_ETIMEDOUT;
+#endif
+#ifdef EXDEV
+        else if (errno == EXDEV) code = XML_IO_EXDEV;
+#endif
+#ifdef ENOTSOCK
+        else if (errno == ENOTSOCK) code = XML_IO_ENOTSOCK;
+#endif
+#ifdef EISCONN
+        else if (errno == EISCONN) code = XML_IO_EISCONN;
+#endif
+#ifdef ECONNREFUSED
+        else if (errno == ECONNREFUSED) code = XML_IO_ECONNREFUSED;
+#endif
+#ifdef ETIMEDOUT
+        else if (errno == ETIMEDOUT) code = XML_IO_ETIMEDOUT;
+#endif
+#ifdef ENETUNREACH
+        else if (errno == ENETUNREACH) code = XML_IO_ENETUNREACH;
+#endif
+#ifdef EADDRINUSE
+        else if (errno == EADDRINUSE) code = XML_IO_EADDRINUSE;
+#endif
+#ifdef EINPROGRESS
+        else if (errno == EINPROGRESS) code = XML_IO_EINPROGRESS;
+#endif
+#ifdef EALREADY
+        else if (errno == EALREADY) code = XML_IO_EALREADY;
+#endif
+#ifdef EAFNOSUPPORT
+        else if (errno == EAFNOSUPPORT) code = XML_IO_EAFNOSUPPORT;
+#endif
+        else code = XML_IO_UNKNOWN;
+#endif /* HAVE_ERRNO_H */
+    }
+    idx = 0;
+    if (code >= XML_IO_UNKNOWN) idx = code - XML_IO_UNKNOWN;
+    if (idx >= (sizeof(IOerr) / sizeof(IOerr[0]))) idx = 0;
+    
+    __xmlSimpleError(domain, code, NULL, IOerr[idx], extra);
+}
+
+/**
+ * xmlIOErr:
+ * @code:  the error number
+ * @extra:  extra informations
+ *
+ * Handle an I/O error
+ */
+static void
+xmlIOErr(int code, const char *extra)
+{
+    __xmlIOErr(XML_FROM_IO, code, extra);
+}
+
+/**
+ * __xmlLoaderErr:
+ * @ctx: the parser context
+ * @extra:  extra informations
+ *
+ * Handle a resource access error
+ */
+void
+__xmlLoaderErr(void *ctx, const char *msg, const char *filename)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+    xmlStructuredErrorFunc schannel = NULL;
+    xmlGenericErrorFunc channel = NULL;
+    void *data = NULL;
+    xmlErrorLevel level = XML_ERR_ERROR;
+
+    if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
+        (ctxt->instate == XML_PARSER_EOF))
+	return;
+    if ((ctxt != NULL) && (ctxt->sax != NULL)) {
+        if (ctxt->validate) {
+	    channel = ctxt->sax->error;
+	    level = XML_ERR_ERROR;
+	} else {
+	    channel = ctxt->sax->warning;
+	    level = XML_ERR_WARNING;
+	}
+	schannel = ctxt->sax->serror;
+	data = ctxt->userData;
+    }
+    __xmlRaiseError(schannel, channel, data, ctxt, NULL, XML_FROM_IO,
+                    XML_IO_LOAD_ERROR, level, NULL, 0,
+		    filename, NULL, NULL, 0, 0,
+		    msg, filename);
+                    
+}
+
+/************************************************************************
+ *									*
+ * 		Tree memory error handler				*
+ *									*
+ ************************************************************************/
+/**
+ * xmlNormalizeWindowsPath:
+ * @path: the input file path
+ *
+ * This function is obsolete. Please see xmlURIFromPath in uri.c for
+ * a better solution.
+ *
+ * Returns a canonicalized version of the path
+ */
+xmlChar *
+xmlNormalizeWindowsPath(const xmlChar *path)
+{
+    return xmlCanonicPath(path);
+}
+
+/**
+ * xmlCleanupInputCallbacks:
+ *
+ * clears the entire input callback table. this includes the
+ * compiled-in I/O. 
+ */
+void
+xmlCleanupInputCallbacks(void)
+{
+    int i;
+
+    if (!xmlInputCallbackInitialized)
+        return;
+
+    for (i = xmlInputCallbackNr - 1; i >= 0; i--) {
+        xmlInputCallbackTable[i].matchcallback = NULL;
+        xmlInputCallbackTable[i].opencallback = NULL;
+        xmlInputCallbackTable[i].readcallback = NULL;
+        xmlInputCallbackTable[i].closecallback = NULL;
+    }
+
+    xmlInputCallbackNr = 0;
+    xmlInputCallbackInitialized = 0;
+}
+
+#ifdef LIBXML_OUTPUT_ENABLED
+/**
+ * xmlCleanupOutputCallbacks:
+ *
+ * clears the entire output callback table. this includes the
+ * compiled-in I/O callbacks. 
+ */
+void
+xmlCleanupOutputCallbacks(void)
+{
+    int i;
+
+    if (!xmlOutputCallbackInitialized)
+        return;
+
+    for (i = xmlOutputCallbackNr - 1; i >= 0; i--) {
+        xmlOutputCallbackTable[i].matchcallback = NULL;
+        xmlOutputCallbackTable[i].opencallback = NULL;
+        xmlOutputCallbackTable[i].writecallback = NULL;
+        xmlOutputCallbackTable[i].closecallback = NULL;
+    }
+
+    xmlOutputCallbackNr = 0;
+    xmlOutputCallbackInitialized = 0;
+}
+#endif /* LIBXML_OUTPUT_ENABLED */
+
+/************************************************************************
+ *									*
+ *		Standard I/O for file accesses				*
+ *									*
+ ************************************************************************/
+
+/**
+ * xmlCheckFilename:
+ * @path:  the path to check
+ *
+ * function checks to see if @path is a valid source
+ * (file, socket...) for XML.
+ *
+ * if stat is not available on the target machine,
+ * returns 1.  if stat fails, returns 0 (if calling
+ * stat on the filename fails, it can't be right).
+ * if stat succeeds and the file is a directory,
+ * returns 2.  otherwise returns 1.
+ */
+
+int
+xmlCheckFilename (const char *path)
+{
+#ifdef HAVE_STAT
+    struct stat stat_buffer;
+
+    if (stat(path, &stat_buffer) == -1)
+        return 0;
+
+#ifdef S_ISDIR
+    if (S_ISDIR(stat_buffer.st_mode)) {
+        return 2;
+    }
+#endif
+#endif
+    return 1;
+}
+
+static int
+xmlNop(void) {
+    return(0);
+}
+
+/**
+ * xmlFdRead:
+ * @context:  the I/O context
+ * @buffer:  where to drop data
+ * @len:  number of bytes to read
+ *
+ * Read @len bytes to @buffer from the I/O channel.
+ *
+ * Returns the number of bytes written
+ */
+static int
+xmlFdRead (void * context, char * buffer, int len) {
+    int ret;
+
+    ret = read((int) (long) context, &buffer[0], len);
+    if (ret < 0) xmlIOErr(0, "read()");
+    return(ret);
+}
+
+#ifdef LIBXML_OUTPUT_ENABLED
+/**
+ * xmlFdWrite:
+ * @context:  the I/O context
+ * @buffer:  where to get data
+ * @len:  number of bytes to write
+ *
+ * Write @len bytes from @buffer to the I/O channel.
+ *
+ * Returns the number of bytes written
+ */
+static int
+xmlFdWrite (void * context, const char * buffer, int len) {
+    int ret;
+
+    ret = write((int) (long) context, &buffer[0], len);
+    if (ret < 0) xmlIOErr(0, "write()");
+    return(ret);
+}
+#endif /* LIBXML_OUTPUT_ENABLED */
+
+/**
+ * xmlFdClose:
+ * @context:  the I/O context
+ *
+ * Close an I/O channel
+ *
+ * Returns 0 in case of success and error code otherwise
+ */
+static int
+xmlFdClose (void * context) {
+    int ret;
+    ret = close((int) (long) context);
+    if (ret < 0) xmlIOErr(0, "close()");
+    return(ret);
+}
+
+/**
+ * xmlFileMatch:
+ * @filename:  the URI for matching
+ *
+ * input from FILE *
+ *
+ * Returns 1 if matches, 0 otherwise
+ */
+int
+xmlFileMatch (const char *filename ATTRIBUTE_UNUSED) {
+    return(1);
+}
+
+/**
+ * xmlFileOpen_real:
+ * @filename:  the URI for matching
+ *
+ * input from FILE *, supports compressed input
+ * if @filename is " " then the standard input is used
+ *
+ * Returns an I/O context or NULL in case of error
+ */
+static void *
+xmlFileOpen_real (const char *filename) {
+    const char *path = NULL;
+    FILE *fd;
+
+    if (!strcmp(filename, "-")) {
+	fd = stdin;
+	return((void *) fd);
+    }
+
+    if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "file://localhost/", 17))
+#if defined (_WIN32) || defined (__DJGPP__) && !defined(__CYGWIN__)
+	path = &filename[17];
+#else
+	path = &filename[16];
+#endif
+    else if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "file:///", 8)) {
+#if defined (_WIN32) || defined (__DJGPP__) && !defined(__CYGWIN__)
+	path = &filename[8];
+#else
+	path = &filename[7];
+#endif
+    } else 
+	path = filename;
+
+    if (path == NULL)
+	return(NULL);
+    if (!xmlCheckFilename(path))
+        return(NULL);
+
+#if defined(WIN32) || defined (__DJGPP__) && !defined (__CYGWIN__)
+    fd = fopen(path, "rb");
+#else
+    fd = fopen(path, "r");
+#endif /* WIN32 */
+    if (fd == NULL) xmlIOErr(0, path);
+    return((void *) fd);
+}
+
+/**
+ * xmlFileOpen:
+ * @filename:  the URI for matching
+ *
+ * Wrapper around xmlFileOpen_real that try it with an unescaped
+ * version of @filename, if this fails fallback to @filename
+ *
+ * Returns a handler or NULL in case or failure
+ */
+void *
+xmlFileOpen (const char *filename) {
+    char *unescaped;
+    void *retval;
+    unescaped = xmlURIUnescapeString(filename, 0, NULL);
+    if (unescaped != NULL) {
+	retval = xmlFileOpen_real(unescaped);
+    } else {
+	retval = xmlFileOpen_real(filename);
+    }
+    xmlFree(unescaped);
+    return retval;
+}
+
+#ifdef LIBXML_OUTPUT_ENABLED
+/**
+ * xmlFileOpenW:
+ * @filename:  the URI for matching
+ *
+ * output to from FILE *,
+ * if @filename is "-" then the standard output is used
+ *
+ * Returns an I/O context or NULL in case of error
+ */
+static void *
+xmlFileOpenW (const char *filename) {
+    const char *path = NULL;
+    FILE *fd;
+
+    if (!strcmp(filename, "-")) {
+	fd = stdout;
+	return((void *) fd);
+    }
+
+    if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "file://localhost/", 17))
+#if defined (_WIN32) || defined (__DJGPP__) && !defined(__CYGWIN__)
+	path = &filename[17];
+#else
+	path = &filename[16];
+#endif
+    else if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "file:///", 8)) {
+#if defined (_WIN32) || defined (__DJGPP__) && !defined(__CYGWIN__)
+	path = &filename[8];
+#else
+	path = &filename[7];
+#endif
+    } else 
+	path = filename;
+
+    if (path == NULL)
+	return(NULL);
+
+    fd = fopen(path, "wb");
+    if (fd == NULL) xmlIOErr(0, path);
+    return((void *) fd);
+}
+#endif /* LIBXML_OUTPUT_ENABLED */
+
+/**
+ * xmlFileRead:
+ * @context:  the I/O context
+ * @buffer:  where to drop data
+ * @len:  number of bytes to write
+ *
+ * Read @len bytes to @buffer from the I/O channel.
+ *
+ * Returns the number of bytes written
+ */
+int
+xmlFileRead (void * context, char * buffer, int len) {
+    int ret;
+    ret = fread(&buffer[0], 1,  len, (FILE *) context);
+    if (ret < 0) xmlIOErr(0, "fread()");
+    return(ret);
+}
+
+#ifdef LIBXML_OUTPUT_ENABLED
+/**
+ * xmlFileWrite:
+ * @context:  the I/O context
+ * @buffer:  where to drop data
+ * @len:  number of bytes to write
+ *
+ * Write @len bytes from @buffer to the I/O channel.
+ *
+ * Returns the number of bytes written
+ */
+static int
+xmlFileWrite (void * context, const char * buffer, int len) {
+    int items;
+
+    items = fwrite(&buffer[0], len, 1, (FILE *) context);
+    if ((items == 0) && (ferror((FILE *) context))) {
+        xmlIOErr(0, "fwrite()");
+	return(-1);
+    }
+    return(items * len);
+}
+#endif /* LIBXML_OUTPUT_ENABLED */
+
+/**
+ * xmlFileClose:
+ * @context:  the I/O context
+ *
+ * Close an I/O channel
+ *
+ * Returns 0 or -1 in case of error
+ */
+int
+xmlFileClose (void * context) {
+    FILE *fil;
+    int ret;
+
+    fil = (FILE *) context;
+    if ((fil == stdout) || (fil == stderr)) {
+        ret = fflush(fil);
+	if (ret < 0)
+	    xmlIOErr(0, "fflush()");
+	return(0);
+    }
+    if (fil == stdin)
+	return(0);
+    ret = ( fclose((FILE *) context) == EOF ) ? -1 : 0;
+    if (ret < 0)
+        xmlIOErr(0, "fclose()");
+    return(ret);
+}
+
+/**
+ * xmlFileFlush:
+ * @context:  the I/O context
+ *
+ * Flush an I/O channel
+ */
+static int
+xmlFileFlush (void * context) {
+    int ret;
+    ret = ( fflush((FILE *) context) == EOF ) ? -1 : 0;
+    if (ret < 0)
+        xmlIOErr(0, "fflush()");
+    return(ret);
+}
+
+#ifdef HAVE_ZLIB_H
+/************************************************************************
+ *									*
+ *		I/O for compressed file accesses			*
+ *									*
+ ************************************************************************/
+/**
+ * xmlGzfileMatch:
+ * @filename:  the URI for matching
+ *
+ * input from compressed file test
+ *
+ * Returns 1 if matches, 0 otherwise
+ */
+static int
+xmlGzfileMatch (const char *filename ATTRIBUTE_UNUSED) {
+    return(1);
+}
+
+/**
+ * xmlGzfileOpen_real:
+ * @filename:  the URI for matching
+ *
+ * input from compressed file open
+ * if @filename is " " then the standard input is used
+ *
+ * Returns an I/O context or NULL in case of error
+ */
+static void *
+xmlGzfileOpen_real (const char *filename) {
+    const char *path = NULL;
+    gzFile fd;
+
+    if (!strcmp(filename, "-")) {
+        fd = gzdopen(dup(0), "rb");
+	return((void *) fd);
+    }
+
+    if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "file://localhost/", 17))
+#if defined (_WIN32) || defined (__DJGPP__) && !defined(__CYGWIN__)
+	path = &filename[17];
+#else
+	path = &filename[16];
+#endif
+    else if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "file:///", 8)) {
+#if defined (_WIN32) || defined (__DJGPP__) && !defined(__CYGWIN__)
+	path = &filename[8];
+#else
+	path = &filename[7];
+#endif
+    } else 
+	path = filename;
+
+    if (path == NULL)
+	return(NULL);
+    if (!xmlCheckFilename(path))
+        return(NULL);
+
+    fd = gzopen(path, "rb");
+    return((void *) fd);
+}
+
+/**
+ * xmlGzfileOpen:
+ * @filename:  the URI for matching
+ *
+ * Wrapper around xmlGzfileOpen if the open fais, it will
+ * try to unescape @filename
+ */
+static void *
+xmlGzfileOpen (const char *filename) {
+    char *unescaped;
+    void *retval;
+
+    retval = xmlGzfileOpen_real(filename);
+    if (retval == NULL) {
+	unescaped = xmlURIUnescapeString(filename, 0, NULL);
+	if (unescaped != NULL) {
+	    retval = xmlGzfileOpen_real(unescaped);
+	}
+	xmlFree(unescaped);
+    }
+    return retval;
+}
+
+#ifdef LIBXML_OUTPUT_ENABLED
+/**
+ * xmlGzfileOpenW:
+ * @filename:  the URI for matching
+ * @compression:  the compression factor (0 - 9 included)
+ *
+ * input from compressed file open
+ * if @filename is " " then the standard input is used
+ *
+ * Returns an I/O context or NULL in case of error
+ */
+static void *
+xmlGzfileOpenW (const char *filename, int compression) {
+    const char *path = NULL;
+    char mode[15];
+    gzFile fd;
+
+    snprintf(mode, sizeof(mode), "wb%d", compression);
+    if (!strcmp(filename, "-")) {
+        fd = gzdopen(dup(1), mode);
+	return((void *) fd);
+    }
+
+    if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "file://localhost/", 17))
+#if defined (_WIN32) || defined (__DJGPP__) && !defined(__CYGWIN__)
+	path = &filename[17];
+#else
+	path = &filename[16];
+#endif
+    else if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "file:///", 8)) {
+#if defined (_WIN32) || defined (__DJGPP__) && !defined(__CYGWIN__)
+	path = &filename[8];
+#else
+	path = &filename[7];
+#endif
+    } else 
+	path = filename;
+
+    if (path == NULL)
+	return(NULL);
+
+    fd = gzopen(path, mode);
+    return((void *) fd);
+}
+#endif /* LIBXML_OUTPUT_ENABLED */
+
+/**
+ * xmlGzfileRead:
+ * @context:  the I/O context
+ * @buffer:  where to drop data
+ * @len:  number of bytes to write
+ *
+ * Read @len bytes to @buffer from the compressed I/O channel.
+ *
+ * Returns the number of bytes written
+ */
+static int
+xmlGzfileRead (void * context, char * buffer, int len) {
+    int ret;
+
+    ret = gzread((gzFile) context, &buffer[0], len);
+    if (ret < 0) xmlIOErr(0, "gzread()");
+    return(ret);
+}
+
+#ifdef LIBXML_OUTPUT_ENABLED
+/**
+ * xmlGzfileWrite:
+ * @context:  the I/O context
+ * @buffer:  where to drop data
+ * @len:  number of bytes to write
+ *
+ * Write @len bytes from @buffer to the compressed I/O channel.
+ *
+ * Returns the number of bytes written
+ */
+static int
+xmlGzfileWrite (void * context, const char * buffer, int len) {
+    int ret;
+
+    ret = gzwrite((gzFile) context, (char *) &buffer[0], len);
+    if (ret < 0) xmlIOErr(0, "gzwrite()");
+    return(ret);
+}
+#endif /* LIBXML_OUTPUT_ENABLED */
+
+/**
+ * xmlGzfileClose:
+ * @context:  the I/O context
+ *
+ * Close a compressed I/O channel
+ */
+static int
+xmlGzfileClose (void * context) {
+    int ret;
+
+    ret =  (gzclose((gzFile) context) == Z_OK ) ? 0 : -1;
+    if (ret < 0) xmlIOErr(0, "gzclose()");
+    return(ret);
+}
+#endif /* HAVE_ZLIB_H */
+
+#ifdef LIBXML_HTTP_ENABLED
+/************************************************************************
+ *									*
+ *			I/O for HTTP file accesses			*
+ *									*
+ ************************************************************************/
+
+#ifdef LIBXML_OUTPUT_ENABLED
+typedef struct xmlIOHTTPWriteCtxt_
+{
+    int			compression;
+
+    char *		uri;
+
+    void *		doc_buff;
+
+} xmlIOHTTPWriteCtxt, *xmlIOHTTPWriteCtxtPtr;
+
+#ifdef HAVE_ZLIB_H
+
+#define DFLT_WBITS		( -15 )
+#define DFLT_MEM_LVL		( 8 )
+#define GZ_MAGIC1		( 0x1f )
+#define GZ_MAGIC2		( 0x8b )
+#define LXML_ZLIB_OS_CODE	( 0x03 )
+#define INIT_HTTP_BUFF_SIZE	( 32768 )
+#define DFLT_ZLIB_RATIO		( 5 )
+
+/*
+**  Data structure and functions to work with sending compressed data
+**  via HTTP.
+*/
+
+typedef struct xmlZMemBuff_
+{
+   unsigned long	size;
+   unsigned long	crc;
+
+   unsigned char *	zbuff;
+   z_stream		zctrl;
+
+} xmlZMemBuff, *xmlZMemBuffPtr;
+
+/**
+ * append_reverse_ulong
+ * @buff:  Compressed memory buffer
+ * @data:  Unsigned long to append
+ *
+ * Append a unsigned long in reverse byte order to the end of the
+ * memory buffer.
+ */
+static void
+append_reverse_ulong( xmlZMemBuff * buff, unsigned long data ) {
+
+    int		idx;
+
+    if ( buff == NULL )
+	return;
+
+    /*
+    **  This is plagiarized from putLong in gzio.c (zlib source) where
+    **  the number "4" is hardcoded.  If zlib is ever patched to 
+    **  support 64 bit file sizes, this code would need to be patched
+    **  as well.
+    */
+
+    for ( idx = 0; idx < 4; idx++ ) {
+	*buff->zctrl.next_out = ( data & 0xff );
+	data >>= 8;
+	buff->zctrl.next_out++;
+    }
+
+    return;
+}
+
+/**
+ *
+ * xmlFreeZMemBuff
+ * @buff:  The memory buffer context to clear
+ *
+ * Release all the resources associated with the compressed memory buffer.
+ */
+static void
+xmlFreeZMemBuff( xmlZMemBuffPtr buff ) {
+
+#ifdef DEBUG_HTTP
+    int z_err;
+#endif
+
+    if ( buff == NULL )
+	return;
+
+    xmlFree( buff->zbuff );
+#ifdef DEBUG_HTTP
+    z_err = deflateEnd( &buff->zctrl );
+    if ( z_err != Z_OK )
+	xmlGenericError( xmlGenericErrorContext,
+			"xmlFreeZMemBuff:  Error releasing zlib context:  %d\n",
+			z_err );
+#else
+    deflateEnd( &buff->zctrl );
+#endif
+
+    xmlFree( buff );
+    return;
+}
+
+/**
+ * xmlCreateZMemBuff
+ *@compression:	Compression value to use
+ *
+ * Create a memory buffer to hold the compressed XML document.  The
+ * compressed document in memory will end up being identical to what
+ * would be created if gzopen/gzwrite/gzclose were being used to 
+ * write the document to disk.  The code for the header/trailer data to
+ * the compression is plagiarized from the zlib source files.
+ */
+static void *
+xmlCreateZMemBuff( int compression ) {
+
+    int			z_err;
+    int			hdr_lgth;
+    xmlZMemBuffPtr	buff = NULL;
+
+    if ( ( compression < 1 ) || ( compression > 9 ) )
+	return ( NULL );
+
+    /*  Create the control and data areas  */
+
+    buff = xmlMalloc( sizeof( xmlZMemBuff ) );
+    if ( buff == NULL ) {
+	xmlIOErrMemory("creating buffer context");
+	return ( NULL );
+    }
+
+    (void)memset( buff, 0, sizeof( xmlZMemBuff ) );
+    buff->size = INIT_HTTP_BUFF_SIZE;
+    buff->zbuff = xmlMalloc( buff->size );
+    if ( buff->zbuff == NULL ) {
+	xmlFreeZMemBuff( buff );
+	xmlIOErrMemory("creating buffer");
+	return ( NULL );
+    }
+
+    z_err = deflateInit2( &buff->zctrl, compression, Z_DEFLATED,
+			    DFLT_WBITS, DFLT_MEM_LVL, Z_DEFAULT_STRATEGY );
+    if ( z_err != Z_OK ) {
+	xmlChar msg[500];
+	xmlFreeZMemBuff( buff );
+	buff = NULL;
+	xmlStrPrintf(msg, 500,
+		    (const xmlChar *) "xmlCreateZMemBuff:  %s %d\n",
+		    "Error initializing compression context.  ZLIB error:",
+		    z_err );
+	xmlIOErr(XML_IO_WRITE, (const char *) msg);
+	return ( NULL );
+    }
+
+    /*  Set the header data.  The CRC will be needed for the trailer  */
+    buff->crc = crc32( 0L, Z_NULL, 0 );
+    hdr_lgth = snprintf( (char *)buff->zbuff, buff->size,
+			"%c%c%c%c%c%c%c%c%c%c",
+			GZ_MAGIC1, GZ_MAGIC2, Z_DEFLATED, 
+			0, 0, 0, 0, 0, 0, LXML_ZLIB_OS_CODE );
+    buff->zctrl.next_out  = buff->zbuff + hdr_lgth;
+    buff->zctrl.avail_out = buff->size - hdr_lgth;
+
+    return ( buff );
+}
+
+/**
+ * xmlZMemBuffExtend
+ * @buff:  Buffer used to compress and consolidate data.
+ * @ext_amt:   Number of bytes to extend the buffer.
+ *
+ * Extend the internal buffer used to store the compressed data by the
+ * specified amount.
+ *
+ * Returns 0 on success or -1 on failure to extend the buffer.  On failure
+ * the original buffer still exists at the original size.
+ */
+static int
+xmlZMemBuffExtend( xmlZMemBuffPtr buff, size_t ext_amt ) {
+
+    int			rc = -1;
+    size_t		new_size;
+    size_t		cur_used;
+
+    unsigned char *	tmp_ptr = NULL;
+
+    if ( buff == NULL )
+	return ( -1 );
+
+    else if ( ext_amt == 0 )
+	return ( 0 );
+
+    cur_used = buff->zctrl.next_out - buff->zbuff;
+    new_size = buff->size + ext_amt;
+
+#ifdef DEBUG_HTTP
+    if ( cur_used > new_size ) 
+	xmlGenericError( xmlGenericErrorContext,
+			"xmlZMemBuffExtend:  %s\n%s %d bytes.\n",
+			"Buffer overwrite detected during compressed memory",
+			"buffer extension.  Overflowed by", 
+			(cur_used - new_size ) );
+#endif
+
+    tmp_ptr = xmlRealloc( buff->zbuff, new_size );
+    if ( tmp_ptr != NULL ) {
+	rc = 0;
+	buff->size  = new_size;
+	buff->zbuff = tmp_ptr;
+	buff->zctrl.next_out  = tmp_ptr + cur_used;
+	buff->zctrl.avail_out = new_size - cur_used;
+    }
+    else {
+	xmlChar msg[500];
+	xmlStrPrintf(msg, 500,
+		    (const xmlChar *) "xmlZMemBuffExtend:  %s %lu bytes.\n",
+		    "Allocation failure extending output buffer to",
+		    new_size );
+	xmlIOErr(XML_IO_WRITE, (const char *) msg);
+    }
+
+    return ( rc );
+}
+
+/**
+ * xmlZMemBuffAppend
+ * @buff:  Buffer used to compress and consolidate data
+ * @src:   Uncompressed source content to append to buffer
+ * @len:   Length of source data to append to buffer
+ *
+ * Compress and append data to the internal buffer.  The data buffer
+ * will be expanded if needed to store the additional data.
+ *
+ * Returns the number of bytes appended to the buffer or -1 on error.
+ */
+static int
+xmlZMemBuffAppend( xmlZMemBuffPtr buff, const char * src, int len ) {
+
+    int		z_err;
+    size_t	min_accept;
+
+    if ( ( buff == NULL ) || ( src == NULL ) )
+	return ( -1 );
+
+    buff->zctrl.avail_in = len;
+    buff->zctrl.next_in  = (unsigned char *)src;
+    while ( buff->zctrl.avail_in > 0 ) {
+	/*
+	**  Extend the buffer prior to deflate call if a reasonable amount
+	**  of output buffer space is not available.
+	*/
+	min_accept = buff->zctrl.avail_in / DFLT_ZLIB_RATIO;
+	if ( buff->zctrl.avail_out <= min_accept ) {
+	    if ( xmlZMemBuffExtend( buff, buff->size ) == -1 )
+		return ( -1 );
+	}
+
+	z_err = deflate( &buff->zctrl, Z_NO_FLUSH );
+	if ( z_err != Z_OK ) {
+	    xmlChar msg[500];
+	    xmlStrPrintf(msg, 500,
+			(const xmlChar *) "xmlZMemBuffAppend:  %s %d %s - %d",
+			"Compression error while appending",
+			len, "bytes to buffer.  ZLIB error", z_err );
+	    xmlIOErr(XML_IO_WRITE, (const char *) msg);
+	    return ( -1 );
+	}
+    }
+
+    buff->crc = crc32( buff->crc, (unsigned char *)src, len );
+
+    return ( len );
+}
+
+/**
+ * xmlZMemBuffGetContent
+ * @buff:  Compressed memory content buffer
+ * @data_ref:  Pointer reference to point to compressed content
+ *
+ * Flushes the compression buffers, appends gzip file trailers and
+ * returns the compressed content and length of the compressed data.
+ * NOTE:  The gzip trailer code here is plagiarized from zlib source.
+ *
+ * Returns the length of the compressed data or -1 on error.
+ */
+static int
+xmlZMemBuffGetContent( xmlZMemBuffPtr buff, char ** data_ref ) {
+
+    int		zlgth = -1;
+    int		z_err;
+
+    if ( ( buff == NULL ) || ( data_ref == NULL ) )
+	return ( -1 );
+
+    /*  Need to loop until compression output buffers are flushed  */
+
+    do
+    {
+	z_err = deflate( &buff->zctrl, Z_FINISH );
+	if ( z_err == Z_OK ) {
+	    /*  In this case Z_OK means more buffer space needed  */
+
+	    if ( xmlZMemBuffExtend( buff, buff->size ) == -1 )
+		return ( -1 );
+	}
+    }
+    while ( z_err == Z_OK );
+
+    /*  If the compression state is not Z_STREAM_END, some error occurred  */
+
+    if ( z_err == Z_STREAM_END ) {
+
+	/*  Need to append the gzip data trailer  */
+
+	if ( buff->zctrl.avail_out < ( 2 * sizeof( unsigned long ) ) ) {
+	    if ( xmlZMemBuffExtend(buff, (2 * sizeof(unsigned long))) == -1 )
+		return ( -1 );
+	}
+
+	/*
+	**  For whatever reason, the CRC and length data are pushed out
+	**  in reverse byte order.  So a memcpy can't be used here.
+	*/
+
+	append_reverse_ulong( buff, buff->crc );
+	append_reverse_ulong( buff, buff->zctrl.total_in );
+
+	zlgth = buff->zctrl.next_out - buff->zbuff;
+	*data_ref = (char *)buff->zbuff;
+    }
+
+    else {
+	xmlChar msg[500];
+	xmlStrPrintf(msg, 500,
+		    (const xmlChar *) "xmlZMemBuffGetContent:  %s - %d\n",
+		    "Error flushing zlib buffers.  Error code", z_err );
+	xmlIOErr(XML_IO_WRITE, (const char *) msg);
+    }
+    
+    return ( zlgth );
+}
+#endif /* LIBXML_OUTPUT_ENABLED */
+#endif  /*  HAVE_ZLIB_H  */
+
+#ifdef LIBXML_OUTPUT_ENABLED
+/**
+ * xmlFreeHTTPWriteCtxt
+ * @ctxt:  Context to cleanup
+ *
+ * Free allocated memory and reclaim system resources.
+ *
+ * No return value.
+ */
+static void
+xmlFreeHTTPWriteCtxt( xmlIOHTTPWriteCtxtPtr ctxt )
+{
+    if ( ctxt->uri != NULL )
+	xmlFree( ctxt->uri );
+
+    if ( ctxt->doc_buff != NULL ) {
+
+#ifdef HAVE_ZLIB_H
+	if ( ctxt->compression > 0 ) {
+	    xmlFreeZMemBuff( ctxt->doc_buff );
+	}
+	else
+#endif
+	{
+	    xmlOutputBufferClose( ctxt->doc_buff );
+	}
+    }
+
+    xmlFree( ctxt );
+    return;
+}
+#endif /* LIBXML_OUTPUT_ENABLED */
+
+
+/**
+ * xmlIOHTTPMatch:
+ * @filename:  the URI for matching
+ *
+ * check if the URI matches an HTTP one
+ *
+ * Returns 1 if matches, 0 otherwise
+ */
+int
+xmlIOHTTPMatch (const char *filename) {
+    if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "http://", 7))
+	return(1);
+    return(0);
+}
+
+/**
+ * xmlIOHTTPOpen:
+ * @filename:  the URI for matching
+ *
+ * open an HTTP I/O channel
+ *
+ * Returns an I/O context or NULL in case of error
+ */
+void *
+xmlIOHTTPOpen (const char *filename) {
+    return(xmlNanoHTTPOpen(filename, NULL));
+}
+
+#ifdef LIBXML_OUTPUT_ENABLED
+/**
+ * xmlIOHTTPOpenW:
+ * @post_uri:  The destination URI for the document
+ * @compression:  The compression desired for the document.
+ *
+ * Open a temporary buffer to collect the document for a subsequent HTTP POST
+ * request.  Non-static as is called from the output buffer creation routine.
+ *
+ * Returns an I/O context or NULL in case of error.
+ */
+
+void *
+xmlIOHTTPOpenW(const char *post_uri, int compression)
+{
+
+    xmlIOHTTPWriteCtxtPtr ctxt = NULL;
+
+    if (post_uri == NULL)
+        return (NULL);
+
+    ctxt = xmlMalloc(sizeof(xmlIOHTTPWriteCtxt));
+    if (ctxt == NULL) {
+	xmlIOErrMemory("creating HTTP output context");
+        return (NULL);
+    }
+
+    (void) memset(ctxt, 0, sizeof(xmlIOHTTPWriteCtxt));
+
+    ctxt->uri = (char *) xmlStrdup((const xmlChar *)post_uri);
+    if (ctxt->uri == NULL) {
+	xmlIOErrMemory("copying URI");
+        xmlFreeHTTPWriteCtxt(ctxt);
+        return (NULL);
+    }
+
+    /*
+     * **  Since the document length is required for an HTTP post,
+     * **  need to put the document into a buffer.  A memory buffer
+     * **  is being used to avoid pushing the data to disk and back.
+     */
+
+#ifdef HAVE_ZLIB_H
+    if ((compression > 0) && (compression <= 9)) {
+
+        ctxt->compression = compression;
+        ctxt->doc_buff = xmlCreateZMemBuff(compression);
+    } else
+#endif
+    {
+        /*  Any character conversions should have been done before this  */
+
+        ctxt->doc_buff = xmlAllocOutputBuffer(NULL);
+    }
+
+    if (ctxt->doc_buff == NULL) {
+        xmlFreeHTTPWriteCtxt(ctxt);
+        ctxt = NULL;
+    }
+
+    return (ctxt);
+}
+#endif /* LIBXML_OUTPUT_ENABLED */
+				
+#ifdef LIBXML_OUTPUT_ENABLED
+/**
+ * xmlIOHTTPDfltOpenW
+ * @post_uri:  The destination URI for this document.
+ *
+ * Calls xmlIOHTTPOpenW with no compression to set up for a subsequent
+ * HTTP post command.  This function should generally not be used as
+ * the open callback is short circuited in xmlOutputBufferCreateFile.
+ *
+ * Returns a pointer to the new IO context.
+ */
+static void *
+xmlIOHTTPDfltOpenW( const char * post_uri ) {
+    return ( xmlIOHTTPOpenW( post_uri, 0 ) );
+}
+#endif /* LIBXML_OUTPUT_ENABLED */
+
+/**
+ * xmlIOHTTPRead:
+ * @context:  the I/O context
+ * @buffer:  where to drop data
+ * @len:  number of bytes to write
+ *
+ * Read @len bytes to @buffer from the I/O channel.
+ *
+ * Returns the number of bytes written
+ */
+int 
+xmlIOHTTPRead(void * context, char * buffer, int len) {
+    return(xmlNanoHTTPRead(context, &buffer[0], len));
+}
+
+#ifdef LIBXML_OUTPUT_ENABLED
+/**
+ * xmlIOHTTPWrite
+ * @context:  previously opened writing context
+ * @buffer:   data to output to temporary buffer
+ * @len:      bytes to output
+ *
+ * Collect data from memory buffer into a temporary file for later
+ * processing.
+ *
+ * Returns number of bytes written.
+ */
+
+static int
+xmlIOHTTPWrite( void * context, const char * buffer, int len ) { 
+
+    xmlIOHTTPWriteCtxtPtr	ctxt = context;
+
+    if ( ( ctxt == NULL ) || ( ctxt->doc_buff == NULL ) || ( buffer == NULL ) )
+	return ( -1 );
+
+    if ( len > 0 ) {
+
+	/*  Use gzwrite or fwrite as previously setup in the open call  */
+
+#ifdef HAVE_ZLIB_H
+	if ( ctxt->compression > 0 ) 
+	    len = xmlZMemBuffAppend( ctxt->doc_buff, buffer, len );
+
+	else
+#endif
+	    len = xmlOutputBufferWrite( ctxt->doc_buff, len, buffer );
+
+	if ( len < 0 ) {
+	    xmlChar msg[500];
+	    xmlStrPrintf(msg, 500,
+			(const xmlChar *) "xmlIOHTTPWrite:  %s\n%s '%s'.\n",
+			"Error appending to internal buffer.",
+			"Error sending document to URI",
+			ctxt->uri );
+	    xmlIOErr(XML_IO_WRITE, (const char *) msg);
+	}
+    }
+
+    return ( len );
+}
+#endif /* LIBXML_OUTPUT_ENABLED */
+
+
+/**
+ * xmlIOHTTPClose:
+ * @context:  the I/O context
+ *
+ * Close an HTTP I/O channel
+ *
+ * Returns 0
+ */
+int
+xmlIOHTTPClose (void * context) {
+    xmlNanoHTTPClose(context);
+    return 0;
+}
+
+#ifdef LIBXML_OUTPUT_ENABLED
+/**
+ * xmlIOHTTCloseWrite
+ * @context:  The I/O context
+ * @http_mthd: The HTTP method to be used when sending the data
+ *
+ * Close the transmit HTTP I/O channel and actually send the data.
+ */
+static int
+xmlIOHTTPCloseWrite( void * context, const char * http_mthd ) {
+
+    int				close_rc = -1;
+    int				http_rtn = 0;
+    int				content_lgth = 0;
+    xmlIOHTTPWriteCtxtPtr	ctxt = context;
+
+    char *			http_content = NULL;
+    char *			content_encoding = NULL;
+    char *			content_type = (char *) "text/xml";
+    void *			http_ctxt = NULL;
+
+    if ( ( ctxt == NULL ) || ( http_mthd == NULL ) )
+	return ( -1 );
+
+    /*  Retrieve the content from the appropriate buffer  */
+
+#ifdef HAVE_ZLIB_H
+
+    if ( ctxt->compression > 0 ) {
+	content_lgth = xmlZMemBuffGetContent( ctxt->doc_buff, &http_content );
+	content_encoding = (char *) "Content-Encoding: gzip";
+    }
+    else
+#endif
+    {
+	/*  Pull the data out of the memory output buffer  */
+
+	xmlOutputBufferPtr	dctxt = ctxt->doc_buff;
+	http_content = (char *)dctxt->buffer->content;
+	content_lgth = dctxt->buffer->use;
+    }
+
+    if ( http_content == NULL ) {
+	xmlChar msg[500];
+	xmlStrPrintf(msg, 500,
+		     (const xmlChar *) "xmlIOHTTPCloseWrite:  %s '%s' %s '%s'.\n",
+		     "Error retrieving content.\nUnable to",
+		     http_mthd, "data to URI", ctxt->uri );
+	xmlIOErr(XML_IO_WRITE, (const char *) msg);
+    }
+
+    else {
+
+	http_ctxt = xmlNanoHTTPMethod( ctxt->uri, http_mthd, http_content,
+					&content_type, content_encoding, 
+					content_lgth );
+
+	if ( http_ctxt != NULL ) {
+#ifdef DEBUG_HTTP
+	    /*  If testing/debugging - dump reply with request content  */
+
+	    FILE *	tst_file = NULL;
+	    char	buffer[ 4096 ];
+	    char *	dump_name = NULL;
+	    int		avail;
+
+	    xmlGenericError( xmlGenericErrorContext,
+			"xmlNanoHTTPCloseWrite:  HTTP %s to\n%s returned %d.\n",
+			http_mthd, ctxt->uri,
+			xmlNanoHTTPReturnCode( http_ctxt ) );
+
+	    /*
+	    **  Since either content or reply may be gzipped,
+	    **  dump them to separate files instead of the 
+	    **  standard error context.
+	    */
+
+	    dump_name = tempnam( NULL, "lxml" );
+	    if ( dump_name != NULL ) {
+		(void)snprintf( buffer, sizeof(buffer), "%s.content", dump_name );
+
+		tst_file = fopen( buffer, "wb" );
+		if ( tst_file != NULL ) {
+		    xmlGenericError( xmlGenericErrorContext,
+			"Transmitted content saved in file:  %s\n", buffer );
+
+		    fwrite( http_content, sizeof( char ),
+					content_lgth, tst_file );
+		    fclose( tst_file );
+		}
+
+		(void)snprintf( buffer, sizeof(buffer), "%s.reply", dump_name );
+		tst_file = fopen( buffer, "wb" );
+		if ( tst_file != NULL ) {
+		    xmlGenericError( xmlGenericErrorContext,
+			"Reply content saved in file:  %s\n", buffer );
+
+
+		    while ( (avail = xmlNanoHTTPRead( http_ctxt,
+					buffer, sizeof( buffer ) )) > 0 ) {
+
+			fwrite( buffer, sizeof( char ), avail, tst_file );
+		    }
+
+		    fclose( tst_file );
+		}
+
+		free( dump_name );
+	    }
+#endif  /*  DEBUG_HTTP  */
+
+	    http_rtn = xmlNanoHTTPReturnCode( http_ctxt );
+	    if ( ( http_rtn >= 200 ) && ( http_rtn < 300 ) )
+		close_rc = 0;
+	    else {
+                xmlChar msg[500];
+                xmlStrPrintf(msg, 500,
+    (const xmlChar *) "xmlIOHTTPCloseWrite: HTTP '%s' of %d %s\n'%s' %s %d\n",
+			    http_mthd, content_lgth,
+			    "bytes to URI", ctxt->uri,
+			    "failed.  HTTP return code:", http_rtn );
+		xmlIOErr(XML_IO_WRITE, (const char *) msg);
+            }
+
+	    xmlNanoHTTPClose( http_ctxt );
+	    xmlFree( content_type );
+	}
+    }
+
+    /*  Final cleanups  */
+
+    xmlFreeHTTPWriteCtxt( ctxt );
+
+    return ( close_rc );
+}
+
+/**
+ * xmlIOHTTPClosePut
+ *
+ * @context:  The I/O context
+ *
+ * Close the transmit HTTP I/O channel and actually send data using a PUT
+ * HTTP method.
+ */
+static int
+xmlIOHTTPClosePut( void * ctxt ) {
+    return ( xmlIOHTTPCloseWrite( ctxt, "PUT" ) );
+}
+
+
+/**
+ * xmlIOHTTPClosePost
+ *
+ * @context:  The I/O context
+ *
+ * Close the transmit HTTP I/O channel and actually send data using a POST
+ * HTTP method.
+ */
+static int
+xmlIOHTTPClosePost( void * ctxt ) {
+    return ( xmlIOHTTPCloseWrite( ctxt, "POST" ) );
+}
+#endif /* LIBXML_OUTPUT_ENABLED */
+
+#endif /* LIBXML_HTTP_ENABLED */
+
+#ifdef LIBXML_FTP_ENABLED
+/************************************************************************
+ *									*
+ *			I/O for FTP file accesses			*
+ *									*
+ ************************************************************************/
+/**
+ * xmlIOFTPMatch:
+ * @filename:  the URI for matching
+ *
+ * check if the URI matches an FTP one
+ *
+ * Returns 1 if matches, 0 otherwise
+ */
+int
+xmlIOFTPMatch (const char *filename) {
+    if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "ftp://", 6))
+	return(1);
+    return(0);
+}
+
+/**
+ * xmlIOFTPOpen:
+ * @filename:  the URI for matching
+ *
+ * open an FTP I/O channel
+ *
+ * Returns an I/O context or NULL in case of error
+ */
+void *
+xmlIOFTPOpen (const char *filename) {
+    return(xmlNanoFTPOpen(filename));
+}
+
+/**
+ * xmlIOFTPRead:
+ * @context:  the I/O context
+ * @buffer:  where to drop data
+ * @len:  number of bytes to write
+ *
+ * Read @len bytes to @buffer from the I/O channel.
+ *
+ * Returns the number of bytes written
+ */
+int 
+xmlIOFTPRead(void * context, char * buffer, int len) {
+    return(xmlNanoFTPRead(context, &buffer[0], len));
+}
+
+/**
+ * xmlIOFTPClose:
+ * @context:  the I/O context
+ *
+ * Close an FTP I/O channel
+ *
+ * Returns 0
+ */
+int
+xmlIOFTPClose (void * context) {
+    return ( xmlNanoFTPClose(context) );
+}
+#endif /* LIBXML_FTP_ENABLED */
+
+
+/**
+ * xmlRegisterInputCallbacks:
+ * @matchFunc:  the xmlInputMatchCallback
+ * @openFunc:  the xmlInputOpenCallback
+ * @readFunc:  the xmlInputReadCallback
+ * @closeFunc:  the xmlInputCloseCallback
+ *
+ * Register a new set of I/O callback for handling parser input.
+ *
+ * Returns the registered handler number or -1 in case of error
+ */
+int
+xmlRegisterInputCallbacks(xmlInputMatchCallback matchFunc,
+	xmlInputOpenCallback openFunc, xmlInputReadCallback readFunc,
+	xmlInputCloseCallback closeFunc) {
+    if (xmlInputCallbackNr >= MAX_INPUT_CALLBACK) {
+	return(-1);
+    }
+    xmlInputCallbackTable[xmlInputCallbackNr].matchcallback = matchFunc;
+    xmlInputCallbackTable[xmlInputCallbackNr].opencallback = openFunc;
+    xmlInputCallbackTable[xmlInputCallbackNr].readcallback = readFunc;
+    xmlInputCallbackTable[xmlInputCallbackNr].closecallback = closeFunc;
+    xmlInputCallbackInitialized = 1;
+    return(xmlInputCallbackNr++);
+}
+
+#ifdef LIBXML_OUTPUT_ENABLED
+/**
+ * xmlRegisterOutputCallbacks:
+ * @matchFunc:  the xmlOutputMatchCallback
+ * @openFunc:  the xmlOutputOpenCallback
+ * @writeFunc:  the xmlOutputWriteCallback
+ * @closeFunc:  the xmlOutputCloseCallback
+ *
+ * Register a new set of I/O callback for handling output.
+ *
+ * Returns the registered handler number or -1 in case of error
+ */
+int
+xmlRegisterOutputCallbacks(xmlOutputMatchCallback matchFunc,
+	xmlOutputOpenCallback openFunc, xmlOutputWriteCallback writeFunc,
+	xmlOutputCloseCallback closeFunc) {
+    if (xmlOutputCallbackNr >= MAX_INPUT_CALLBACK) {
+	return(-1);
+    }
+    xmlOutputCallbackTable[xmlOutputCallbackNr].matchcallback = matchFunc;
+    xmlOutputCallbackTable[xmlOutputCallbackNr].opencallback = openFunc;
+    xmlOutputCallbackTable[xmlOutputCallbackNr].writecallback = writeFunc;
+    xmlOutputCallbackTable[xmlOutputCallbackNr].closecallback = closeFunc;
+    xmlOutputCallbackInitialized = 1;
+    return(xmlOutputCallbackNr++);
+}
+#endif /* LIBXML_OUTPUT_ENABLED */
+
+/**
+ * xmlRegisterDefaultInputCallbacks:
+ *
+ * Registers the default compiled-in I/O handlers.
+ */
+void
+xmlRegisterDefaultInputCallbacks
+(void) {
+    if (xmlInputCallbackInitialized)
+	return;
+
+    xmlRegisterInputCallbacks(xmlFileMatch, xmlFileOpen,
+	                      xmlFileRead, xmlFileClose);
+#ifdef HAVE_ZLIB_H
+    xmlRegisterInputCallbacks(xmlGzfileMatch, xmlGzfileOpen,
+	                      xmlGzfileRead, xmlGzfileClose);
+#endif /* HAVE_ZLIB_H */
+
+#ifdef LIBXML_HTTP_ENABLED
+    xmlRegisterInputCallbacks(xmlIOHTTPMatch, xmlIOHTTPOpen,
+	                      xmlIOHTTPRead, xmlIOHTTPClose);
+#endif /* LIBXML_HTTP_ENABLED */
+
+#ifdef LIBXML_FTP_ENABLED
+    xmlRegisterInputCallbacks(xmlIOFTPMatch, xmlIOFTPOpen,
+	                      xmlIOFTPRead, xmlIOFTPClose);
+#endif /* LIBXML_FTP_ENABLED */
+    xmlInputCallbackInitialized = 1;
+}
+
+#ifdef LIBXML_OUTPUT_ENABLED
+/**
+ * xmlRegisterDefaultOutputCallbacks:
+ *
+ * Registers the default compiled-in I/O handlers.
+ */
+void
+xmlRegisterDefaultOutputCallbacks
+(void) {
+    if (xmlOutputCallbackInitialized)
+	return;
+
+    xmlRegisterOutputCallbacks(xmlFileMatch, xmlFileOpenW,
+	                      xmlFileWrite, xmlFileClose);
+
+#ifdef LIBXML_HTTP_ENABLED
+    xmlRegisterOutputCallbacks(xmlIOHTTPMatch, xmlIOHTTPDfltOpenW,
+	                       xmlIOHTTPWrite, xmlIOHTTPClosePut);
+#endif
+
+/*********************************
+ No way a-priori to distinguish between gzipped files from
+ uncompressed ones except opening if existing then closing
+ and saving with same compression ratio ... a pain.
+
+#ifdef HAVE_ZLIB_H
+    xmlRegisterOutputCallbacks(xmlGzfileMatch, xmlGzfileOpen,
+	                       xmlGzfileWrite, xmlGzfileClose);
+#endif
+
+ Nor FTP PUT ....
+#ifdef LIBXML_FTP_ENABLED
+    xmlRegisterOutputCallbacks(xmlIOFTPMatch, xmlIOFTPOpen,
+	                       xmlIOFTPWrite, xmlIOFTPClose);
+#endif
+ **********************************/
+    xmlOutputCallbackInitialized = 1;
+}
+
+#ifdef LIBXML_HTTP_ENABLED
+/**
+ * xmlRegisterHTTPPostCallbacks:
+ *
+ * By default, libxml submits HTTP output requests using the "PUT" method.
+ * Calling this method changes the HTTP output method to use the "POST"
+ * method instead.
+ *
+ */
+void
+xmlRegisterHTTPPostCallbacks( void ) {
+
+    /*  Register defaults if not done previously  */
+
+    if ( xmlOutputCallbackInitialized == 0 )
+	xmlRegisterDefaultOutputCallbacks( );
+
+    xmlRegisterOutputCallbacks(xmlIOHTTPMatch, xmlIOHTTPDfltOpenW,
+	                       xmlIOHTTPWrite, xmlIOHTTPClosePost);
+    return;
+}
+#endif
+#endif /* LIBXML_OUTPUT_ENABLED */
+
+/**
+ * xmlAllocParserInputBuffer:
+ * @enc:  the charset encoding if known
+ *
+ * Create a buffered parser input for progressive parsing
+ *
+ * Returns the new parser input or NULL
+ */
+xmlParserInputBufferPtr
+xmlAllocParserInputBuffer(xmlCharEncoding enc) {
+    xmlParserInputBufferPtr ret;
+
+    ret = (xmlParserInputBufferPtr) xmlMalloc(sizeof(xmlParserInputBuffer));
+    if (ret == NULL) {
+	xmlIOErrMemory("creating input buffer");
+	return(NULL);
+    }
+    memset(ret, 0, (size_t) sizeof(xmlParserInputBuffer));
+    ret->buffer = xmlBufferCreateSize(2 * xmlDefaultBufferSize);
+    if (ret->buffer == NULL) {
+        xmlFree(ret);
+	return(NULL);
+    }
+    ret->buffer->alloc = XML_BUFFER_ALLOC_DOUBLEIT;
+    ret->encoder = xmlGetCharEncodingHandler(enc);
+    if (ret->encoder != NULL)
+        ret->raw = xmlBufferCreateSize(2 * xmlDefaultBufferSize);
+    else
+        ret->raw = NULL;
+    ret->readcallback = NULL;
+    ret->closecallback = NULL;
+    ret->context = NULL;
+    ret->compressed = -1;
+    ret->rawconsumed = 0;
+
+    return(ret);
+}
+
+#ifdef LIBXML_OUTPUT_ENABLED
+/**
+ * xmlAllocOutputBuffer:
+ * @encoder:  the encoding converter or NULL
+ *
+ * Create a buffered parser output
+ *
+ * Returns the new parser output or NULL
+ */
+xmlOutputBufferPtr
+xmlAllocOutputBuffer(xmlCharEncodingHandlerPtr encoder) {
+    xmlOutputBufferPtr ret;
+
+    ret = (xmlOutputBufferPtr) xmlMalloc(sizeof(xmlOutputBuffer));
+    if (ret == NULL) {
+	xmlIOErrMemory("creating output buffer");
+	return(NULL);
+    }
+    memset(ret, 0, (size_t) sizeof(xmlOutputBuffer));
+    ret->buffer = xmlBufferCreate();
+    if (ret->buffer == NULL) {
+        xmlFree(ret);
+	return(NULL);
+    }
+    ret->buffer->alloc = XML_BUFFER_ALLOC_DOUBLEIT;
+    ret->encoder = encoder;
+    if (encoder != NULL) {
+        ret->conv = xmlBufferCreateSize(4000);
+	/*
+	 * This call is designed to initiate the encoder state
+	 */
+	xmlCharEncOutFunc(encoder, ret->conv, NULL); 
+    } else
+        ret->conv = NULL;
+    ret->writecallback = NULL;
+    ret->closecallback = NULL;
+    ret->context = NULL;
+    ret->written = 0;
+
+    return(ret);
+}
+#endif /* LIBXML_OUTPUT_ENABLED */
+
+/**
+ * xmlFreeParserInputBuffer:
+ * @in:  a buffered parser input
+ *
+ * Free up the memory used by a buffered parser input
+ */
+void
+xmlFreeParserInputBuffer(xmlParserInputBufferPtr in) {
+    if (in == NULL) return;
+
+    if (in->raw) {
+        xmlBufferFree(in->raw);
+	in->raw = NULL;
+    }
+    if (in->encoder != NULL) {
+        xmlCharEncCloseFunc(in->encoder);
+    }
+    if (in->closecallback != NULL) {
+	in->closecallback(in->context);
+    }
+    if (in->buffer != NULL) {
+        xmlBufferFree(in->buffer);
+	in->buffer = NULL;
+    }
+
+    xmlFree(in);
+}
+
+#ifdef LIBXML_OUTPUT_ENABLED
+/**
+ * xmlOutputBufferClose:
+ * @out:  a buffered output
+ *
+ * flushes and close the output I/O channel
+ * and free up all the associated resources
+ *
+ * Returns the number of byte written or -1 in case of error.
+ */
+int
+xmlOutputBufferClose(xmlOutputBufferPtr out)
+{
+    int written;
+    int err_rc = 0;
+
+    if (out == NULL)
+        return (-1);
+    if (out->writecallback != NULL)
+        xmlOutputBufferFlush(out);
+    if (out->closecallback != NULL) {
+        err_rc = out->closecallback(out->context);
+    }
+    written = out->written;
+    if (out->conv) {
+        xmlBufferFree(out->conv);
+        out->conv = NULL;
+    }
+    if (out->encoder != NULL) {
+        xmlCharEncCloseFunc(out->encoder);
+    }
+    if (out->buffer != NULL) {
+        xmlBufferFree(out->buffer);
+        out->buffer = NULL;
+    }
+
+    if (out->error)
+        err_rc = -1;
+    xmlFree(out);
+    return ((err_rc == 0) ? written : err_rc);
+}
+#endif /* LIBXML_OUTPUT_ENABLED */
+
+/**
+ * xmlParserInputBufferCreateFilename:
+ * @URI:  a C string containing the URI or filename
+ * @enc:  the charset encoding if known
+ *
+ * Create a buffered parser input for the progressive parsing of a file
+ * If filename is "-' then we use stdin as the input.
+ * Automatic support for ZLIB/Compress compressed document is provided
+ * by default if found at compile-time.
+ * Do an encoding check if enc == XML_CHAR_ENCODING_NONE
+ *
+ * Returns the new parser input or NULL
+ */
+xmlParserInputBufferPtr
+xmlParserInputBufferCreateFilename(const char *URI, xmlCharEncoding enc) {
+    xmlParserInputBufferPtr ret;
+    int i = 0;
+    void *context = NULL;
+
+    if (xmlInputCallbackInitialized == 0)
+	xmlRegisterDefaultInputCallbacks();
+
+    if (URI == NULL) return(NULL);
+
+    /*
+     * Try to find one of the input accept method accepting that scheme
+     * Go in reverse to give precedence to user defined handlers.
+     */
+    if (context == NULL) {
+	for (i = xmlInputCallbackNr - 1;i >= 0;i--) {
+	    if ((xmlInputCallbackTable[i].matchcallback != NULL) &&
+		(xmlInputCallbackTable[i].matchcallback(URI) != 0)) {
+		context = xmlInputCallbackTable[i].opencallback(URI);
+		if (context != NULL) {
+		    break;
+		}
+	    }
+	}
+    }
+    if (context == NULL) {
+	return(NULL);
+    }
+
+    /*
+     * Allocate the Input buffer front-end.
+     */
+    ret = xmlAllocParserInputBuffer(enc);
+    if (ret != NULL) {
+	ret->context = context;
+	ret->readcallback = xmlInputCallbackTable[i].readcallback;
+	ret->closecallback = xmlInputCallbackTable[i].closecallback;
+#ifdef HAVE_ZLIB_H
+	if ((xmlInputCallbackTable[i].opencallback == xmlGzfileOpen) &&
+		(strcmp(URI, "-") != 0)) {
+	    if (((z_stream *)context)->avail_in > 4) {
+	        char *cptr, buff4[4];
+		cptr = (char *) ((z_stream *)context)->next_in;
+		if (gzread(context, buff4, 4) == 4) {
+		    if (strncmp(buff4, cptr, 4) == 0)
+		        ret->compressed = 0;
+		    else
+		        ret->compressed = 1;
+		    gzrewind(context);
+		}
+	    }
+	}
+#endif
+    }
+    return(ret);
+}
+
+#ifdef LIBXML_OUTPUT_ENABLED
+/**
+ * xmlOutputBufferCreateFilename:
+ * @URI:  a C string containing the URI or filename
+ * @encoder:  the encoding converter or NULL
+ * @compression:  the compression ration (0 none, 9 max).
+ *
+ * Create a buffered  output for the progressive saving of a file
+ * If filename is "-' then we use stdout as the output.
+ * Automatic support for ZLIB/Compress compressed document is provided
+ * by default if found at compile-time.
+ * TODO: currently if compression is set, the library only support
+ *       writing to a local file.
+ *
+ * Returns the new output or NULL
+ */
+xmlOutputBufferPtr
+xmlOutputBufferCreateFilename(const char *URI,
+                              xmlCharEncodingHandlerPtr encoder,
+			      int compression ATTRIBUTE_UNUSED) {
+    xmlOutputBufferPtr ret;
+    int i = 0;
+    void *context = NULL;
+    char *unescaped;
+
+    int is_http_uri = 0;	/*   Can't change if HTTP disabled  */
+
+    if (xmlOutputCallbackInitialized == 0)
+	xmlRegisterDefaultOutputCallbacks();
+
+    if (URI == NULL) return(NULL);
+
+#ifdef LIBXML_HTTP_ENABLED
+    /*  Need to prevent HTTP URI's from falling into zlib short circuit  */
+
+    is_http_uri = xmlIOHTTPMatch( URI );
+#endif
+
+
+    /*
+     * Try to find one of the output accept method accepting that scheme
+     * Go in reverse to give precedence to user defined handlers.
+     * try with an unescaped version of the URI
+     */
+    unescaped = xmlURIUnescapeString(URI, 0, NULL);
+    if (unescaped != NULL) {
+#ifdef HAVE_ZLIB_H
+	if ((compression > 0) && (compression <= 9) && (is_http_uri == 0)) {
+	    context = xmlGzfileOpenW(unescaped, compression);
+	    if (context != NULL) {
+		ret = xmlAllocOutputBuffer(encoder);
+		if (ret != NULL) {
+		    ret->context = context;
+		    ret->writecallback = xmlGzfileWrite;
+		    ret->closecallback = xmlGzfileClose;
+		}
+		xmlFree(unescaped);
+		return(ret);
+	    }
+	}
+#endif
+	for (i = xmlOutputCallbackNr - 1;i >= 0;i--) {
+	    if ((xmlOutputCallbackTable[i].matchcallback != NULL) &&
+		(xmlOutputCallbackTable[i].matchcallback(unescaped) != 0)) {
+#if defined(LIBXML_HTTP_ENABLED) && defined(HAVE_ZLIB_H)
+		/*  Need to pass compression parameter into HTTP open calls  */
+		if (xmlOutputCallbackTable[i].matchcallback == xmlIOHTTPMatch)
+		    context = xmlIOHTTPOpenW(unescaped, compression);
+		else
+#endif
+		    context = xmlOutputCallbackTable[i].opencallback(unescaped);
+		if (context != NULL)
+		    break;
+	    }
+	}
+	xmlFree(unescaped);
+    }
+
+    /*
+     * If this failed try with a non-escaped URI this may be a strange
+     * filename
+     */
+    if (context == NULL) {
+#ifdef HAVE_ZLIB_H
+	if ((compression > 0) && (compression <= 9) && (is_http_uri == 0)) {
+	    context = xmlGzfileOpenW(URI, compression);
+	    if (context != NULL) {
+		ret = xmlAllocOutputBuffer(encoder);
+		if (ret != NULL) {
+		    ret->context = context;
+		    ret->writecallback = xmlGzfileWrite;
+		    ret->closecallback = xmlGzfileClose;
+		}
+		return(ret);
+	    }
+	}
+#endif
+	for (i = xmlOutputCallbackNr - 1;i >= 0;i--) {
+	    if ((xmlOutputCallbackTable[i].matchcallback != NULL) &&
+		(xmlOutputCallbackTable[i].matchcallback(URI) != 0)) {
+#if defined(LIBXML_HTTP_ENABLED) && defined(HAVE_ZLIB_H)
+		/*  Need to pass compression parameter into HTTP open calls  */
+		if (xmlOutputCallbackTable[i].matchcallback == xmlIOHTTPMatch)
+		    context = xmlIOHTTPOpenW(URI, compression);
+		else
+#endif
+		    context = xmlOutputCallbackTable[i].opencallback(URI);
+		if (context != NULL)
+		    break;
+	    }
+	}
+    }
+
+    if (context == NULL) {
+	return(NULL);
+    }
+
+    /*
+     * Allocate the Output buffer front-end.
+     */
+    ret = xmlAllocOutputBuffer(encoder);
+    if (ret != NULL) {
+	ret->context = context;
+	ret->writecallback = xmlOutputCallbackTable[i].writecallback;
+	ret->closecallback = xmlOutputCallbackTable[i].closecallback;
+    }
+    return(ret);
+}
+#endif /* LIBXML_OUTPUT_ENABLED */
+
+/**
+ * xmlParserInputBufferCreateFile:
+ * @file:  a FILE* 
+ * @enc:  the charset encoding if known
+ *
+ * Create a buffered parser input for the progressive parsing of a FILE *
+ * buffered C I/O
+ *
+ * Returns the new parser input or NULL
+ */
+xmlParserInputBufferPtr
+xmlParserInputBufferCreateFile(FILE *file, xmlCharEncoding enc) {
+    xmlParserInputBufferPtr ret;
+
+    if (xmlInputCallbackInitialized == 0)
+	xmlRegisterDefaultInputCallbacks();
+
+    if (file == NULL) return(NULL);
+
+    ret = xmlAllocParserInputBuffer(enc);
+    if (ret != NULL) {
+        ret->context = file;
+	ret->readcallback = xmlFileRead;
+	ret->closecallback = xmlFileFlush;
+    }
+
+    return(ret);
+}
+
+#ifdef LIBXML_OUTPUT_ENABLED
+/**
+ * xmlOutputBufferCreateFile:
+ * @file:  a FILE* 
+ * @encoder:  the encoding converter or NULL
+ *
+ * Create a buffered output for the progressive saving to a FILE *
+ * buffered C I/O
+ *
+ * Returns the new parser output or NULL
+ */
+xmlOutputBufferPtr
+xmlOutputBufferCreateFile(FILE *file, xmlCharEncodingHandlerPtr encoder) {
+    xmlOutputBufferPtr ret;
+
+    if (xmlOutputCallbackInitialized == 0)
+	xmlRegisterDefaultOutputCallbacks();
+
+    if (file == NULL) return(NULL);
+
+    ret = xmlAllocOutputBuffer(encoder);
+    if (ret != NULL) {
+        ret->context = file;
+	ret->writecallback = xmlFileWrite;
+	ret->closecallback = xmlFileFlush;
+    }
+
+    return(ret);
+}
+#endif /* LIBXML_OUTPUT_ENABLED */
+
+/**
+ * xmlParserInputBufferCreateFd:
+ * @fd:  a file descriptor number
+ * @enc:  the charset encoding if known
+ *
+ * Create a buffered parser input for the progressive parsing for the input
+ * from a file descriptor
+ *
+ * Returns the new parser input or NULL
+ */
+xmlParserInputBufferPtr
+xmlParserInputBufferCreateFd(int fd, xmlCharEncoding enc) {
+    xmlParserInputBufferPtr ret;
+
+    if (fd < 0) return(NULL);
+
+    ret = xmlAllocParserInputBuffer(enc);
+    if (ret != NULL) {
+        ret->context = (void *) (long) fd;
+	ret->readcallback = xmlFdRead;
+	ret->closecallback = xmlFdClose;
+    }
+
+    return(ret);
+}
+
+/**
+ * xmlParserInputBufferCreateMem:
+ * @mem:  the memory input
+ * @size:  the length of the memory block
+ * @enc:  the charset encoding if known
+ *
+ * Create a buffered parser input for the progressive parsing for the input
+ * from a memory area.
+ *
+ * Returns the new parser input or NULL
+ */
+xmlParserInputBufferPtr
+xmlParserInputBufferCreateMem(const char *mem, int size, xmlCharEncoding enc) {
+    xmlParserInputBufferPtr ret;
+
+    if (size <= 0) return(NULL);
+    if (mem == NULL) return(NULL);
+
+    ret = xmlAllocParserInputBuffer(enc);
+    if (ret != NULL) {
+        ret->context = (void *) mem;
+	ret->readcallback = (xmlInputReadCallback) xmlNop;
+	ret->closecallback = NULL;
+	xmlBufferAdd(ret->buffer, (const xmlChar *) mem, size);
+    }
+
+    return(ret);
+}
+
+/**
+ * xmlParserInputBufferCreateStatic:
+ * @mem:  the memory input
+ * @size:  the length of the memory block
+ * @enc:  the charset encoding if known
+ *
+ * Create a buffered parser input for the progressive parsing for the input
+ * from an immutable memory area. This will not copy the memory area to
+ * the buffer, but the memory is expected to be available until the end of
+ * the parsing, this is useful for example when using mmap'ed file.
+ *
+ * Returns the new parser input or NULL
+ */
+xmlParserInputBufferPtr
+xmlParserInputBufferCreateStatic(const char *mem, int size,
+                                 xmlCharEncoding enc) {
+    xmlParserInputBufferPtr ret;
+
+    if (size <= 0) return(NULL);
+    if (mem == NULL) return(NULL);
+
+    ret = (xmlParserInputBufferPtr) xmlMalloc(sizeof(xmlParserInputBuffer));
+    if (ret == NULL) {
+	xmlIOErrMemory("creating input buffer");
+	return(NULL);
+    }
+    memset(ret, 0, (size_t) sizeof(xmlParserInputBuffer));
+    ret->buffer = xmlBufferCreateStatic((void *)mem, (size_t) size);
+    if (ret->buffer == NULL) {
+        xmlFree(ret);
+	return(NULL);
+    }
+    ret->encoder = xmlGetCharEncodingHandler(enc);
+    if (ret->encoder != NULL)
+        ret->raw = xmlBufferCreateSize(2 * xmlDefaultBufferSize);
+    else
+        ret->raw = NULL;
+    ret->compressed = -1;
+    ret->context = (void *) mem;
+    ret->readcallback = NULL;
+    ret->closecallback = NULL;
+
+    return(ret);
+}
+
+#ifdef LIBXML_OUTPUT_ENABLED
+/**
+ * xmlOutputBufferCreateFd:
+ * @fd:  a file descriptor number
+ * @encoder:  the encoding converter or NULL
+ *
+ * Create a buffered output for the progressive saving 
+ * to a file descriptor
+ *
+ * Returns the new parser output or NULL
+ */
+xmlOutputBufferPtr
+xmlOutputBufferCreateFd(int fd, xmlCharEncodingHandlerPtr encoder) {
+    xmlOutputBufferPtr ret;
+
+    if (fd < 0) return(NULL);
+
+    ret = xmlAllocOutputBuffer(encoder);
+    if (ret != NULL) {
+        ret->context = (void *) (long) fd;
+	ret->writecallback = xmlFdWrite;
+	ret->closecallback = NULL;
+    }
+
+    return(ret);
+}
+#endif /* LIBXML_OUTPUT_ENABLED */
+
+/**
+ * xmlParserInputBufferCreateIO:
+ * @ioread:  an I/O read function
+ * @ioclose:  an I/O close function
+ * @ioctx:  an I/O handler
+ * @enc:  the charset encoding if known
+ *
+ * Create a buffered parser input for the progressive parsing for the input
+ * from an I/O handler
+ *
+ * Returns the new parser input or NULL
+ */
+xmlParserInputBufferPtr
+xmlParserInputBufferCreateIO(xmlInputReadCallback   ioread,
+	 xmlInputCloseCallback  ioclose, void *ioctx, xmlCharEncoding enc) {
+    xmlParserInputBufferPtr ret;
+
+    if (ioread == NULL) return(NULL);
+
+    ret = xmlAllocParserInputBuffer(enc);
+    if (ret != NULL) {
+        ret->context = (void *) ioctx;
+	ret->readcallback = ioread;
+	ret->closecallback = ioclose;
+    }
+
+    return(ret);
+}
+
+#ifdef LIBXML_OUTPUT_ENABLED
+/**
+ * xmlOutputBufferCreateIO:
+ * @iowrite:  an I/O write function
+ * @ioclose:  an I/O close function
+ * @ioctx:  an I/O handler
+ * @encoder:  the charset encoding if known
+ *
+ * Create a buffered output for the progressive saving
+ * to an I/O handler
+ *
+ * Returns the new parser output or NULL
+ */
+xmlOutputBufferPtr
+xmlOutputBufferCreateIO(xmlOutputWriteCallback   iowrite,
+	 xmlOutputCloseCallback  ioclose, void *ioctx,
+	 xmlCharEncodingHandlerPtr encoder) {
+    xmlOutputBufferPtr ret;
+
+    if (iowrite == NULL) return(NULL);
+
+    ret = xmlAllocOutputBuffer(encoder);
+    if (ret != NULL) {
+        ret->context = (void *) ioctx;
+	ret->writecallback = iowrite;
+	ret->closecallback = ioclose;
+    }
+
+    return(ret);
+}
+#endif /* LIBXML_OUTPUT_ENABLED */
+
+/**
+ * xmlParserInputBufferPush:
+ * @in:  a buffered parser input
+ * @len:  the size in bytes of the array.
+ * @buf:  an char array
+ *
+ * Push the content of the arry in the input buffer
+ * This routine handle the I18N transcoding to internal UTF-8
+ * This is used when operating the parser in progressive (push) mode.
+ *
+ * Returns the number of chars read and stored in the buffer, or -1
+ *         in case of error.
+ */
+int
+xmlParserInputBufferPush(xmlParserInputBufferPtr in,
+	                 int len, const char *buf) {
+    int nbchars = 0;
+
+    if (len < 0) return(0);
+    if ((in == NULL) || (in->error)) return(-1);
+    if (in->encoder != NULL) {
+        unsigned int use;
+
+        /*
+	 * Store the data in the incoming raw buffer
+	 */
+        if (in->raw == NULL) {
+	    in->raw = xmlBufferCreate();
+	}
+	xmlBufferAdd(in->raw, (const xmlChar *) buf, len);
+
+	/*
+	 * convert as much as possible to the parser reading buffer.
+	 */
+	use = in->raw->use;
+	nbchars = xmlCharEncInFunc(in->encoder, in->buffer, in->raw);
+	if (nbchars < 0) {
+	    xmlIOErr(XML_IO_ENCODER, NULL);
+	    in->error = XML_IO_ENCODER;
+	    return(-1);
+	}
+	in->rawconsumed += (use - in->raw->use);
+    } else {
+	nbchars = len;
+        xmlBufferAdd(in->buffer, (xmlChar *) buf, nbchars);
+    }
+#ifdef DEBUG_INPUT
+    xmlGenericError(xmlGenericErrorContext,
+	    "I/O: pushed %d chars, buffer %d/%d\n",
+            nbchars, in->buffer->use, in->buffer->size);
+#endif
+    return(nbchars);
+}
+
+/**
+ * endOfInput:
+ *
+ * When reading from an Input channel indicated end of file or error
+ * don't reread from it again.
+ */
+static int
+endOfInput (void * context ATTRIBUTE_UNUSED,
+	    char * buffer ATTRIBUTE_UNUSED,
+	    int len ATTRIBUTE_UNUSED) {
+    return(0);
+}
+
+/**
+ * xmlParserInputBufferGrow:
+ * @in:  a buffered parser input
+ * @len:  indicative value of the amount of chars to read
+ *
+ * Grow up the content of the input buffer, the old data are preserved
+ * This routine handle the I18N transcoding to internal UTF-8
+ * This routine is used when operating the parser in normal (pull) mode
+ *
+ * TODO: one should be able to remove one extra copy by copying directly
+ *       onto in->buffer or in->raw
+ *
+ * Returns the number of chars read and stored in the buffer, or -1
+ *         in case of error.
+ */
+int
+xmlParserInputBufferGrow(xmlParserInputBufferPtr in, int len) {
+    char *buffer = NULL;
+    int res = 0;
+    int nbchars = 0;
+    int buffree;
+    unsigned int needSize;
+
+    if ((in == NULL) || (in->error)) return(-1);
+    if ((len <= MINLEN) && (len != 4))
+        len = MINLEN;
+
+    buffree = in->buffer->size - in->buffer->use;
+    if (buffree <= 0) {
+	xmlIOErr(XML_IO_BUFFER_FULL, NULL);
+	in->error = XML_IO_BUFFER_FULL;
+	return(0);
+    }
+
+    needSize = in->buffer->use + len + 1;
+    if (needSize > in->buffer->size){
+        if (!xmlBufferResize(in->buffer, needSize)){
+	    xmlIOErrMemory("growing input buffer");
+	    in->error = XML_ERR_NO_MEMORY;
+            return(0);
+        }
+    }
+    buffer = (char *)&in->buffer->content[in->buffer->use];
+
+    /*
+     * Call the read method for this I/O type.
+     */
+    if (in->readcallback != NULL) {
+	res = in->readcallback(in->context, &buffer[0], len);
+	if (res <= 0)
+	    in->readcallback = endOfInput;
+    } else {
+	xmlIOErr(XML_IO_NO_INPUT, NULL);
+	in->error = XML_IO_NO_INPUT;
+	return(-1);
+    }
+    if (res < 0) {
+	return(-1);
+    }
+    len = res;
+    if (in->encoder != NULL) {
+        unsigned int use;
+
+        /*
+	 * Store the data in the incoming raw buffer
+	 */
+        if (in->raw == NULL) {
+	    in->raw = xmlBufferCreate();
+	}
+	xmlBufferAdd(in->raw, (const xmlChar *) buffer, len);
+
+	/*
+	 * convert as much as possible to the parser reading buffer.
+	 */
+	use = in->raw->use;
+	nbchars = xmlCharEncInFunc(in->encoder, in->buffer, in->raw);
+	if (nbchars < 0) {
+	    xmlIOErr(XML_IO_ENCODER, NULL);
+	    in->error = XML_IO_ENCODER;
+	    return(-1);
+	}
+	in->rawconsumed += (use - in->raw->use);
+    } else {
+	nbchars = len;
+    	in->buffer->use += nbchars;
+	buffer[nbchars] = 0;
+    }
+#ifdef DEBUG_INPUT
+    xmlGenericError(xmlGenericErrorContext,
+	    "I/O: read %d chars, buffer %d/%d\n",
+            nbchars, in->buffer->use, in->buffer->size);
+#endif
+    return(nbchars);
+}
+
+/**
+ * xmlParserInputBufferRead:
+ * @in:  a buffered parser input
+ * @len:  indicative value of the amount of chars to read
+ *
+ * Refresh the content of the input buffer, the old data are considered
+ * consumed
+ * This routine handle the I18N transcoding to internal UTF-8
+ *
+ * Returns the number of chars read and stored in the buffer, or -1
+ *         in case of error.
+ */
+int
+xmlParserInputBufferRead(xmlParserInputBufferPtr in, int len) {
+    if ((in == NULL) || (in->error)) return(-1);
+    if (in->readcallback != NULL)
+	return(xmlParserInputBufferGrow(in, len));
+    else if ((in->buffer != NULL) &&
+             (in->buffer->alloc == XML_BUFFER_ALLOC_IMMUTABLE))
+	return(0);
+    else
+        return(-1);
+}
+
+#ifdef LIBXML_OUTPUT_ENABLED
+/**
+ * xmlOutputBufferWrite:
+ * @out:  a buffered parser output
+ * @len:  the size in bytes of the array.
+ * @buf:  an char array
+ *
+ * Write the content of the array in the output I/O buffer
+ * This routine handle the I18N transcoding from internal UTF-8
+ * The buffer is lossless, i.e. will store in case of partial
+ * or delayed writes.
+ *
+ * Returns the number of chars immediately written, or -1
+ *         in case of error.
+ */
+int
+xmlOutputBufferWrite(xmlOutputBufferPtr out, int len, const char *buf) {
+    int nbchars = 0; /* number of chars to output to I/O */
+    int ret;         /* return from function call */
+    int written = 0; /* number of char written to I/O so far */
+    int chunk;       /* number of byte curreent processed from buf */
+
+    if ((out == NULL) || (out->error)) return(-1);
+    if (len < 0) return(0);
+    if (out->error) return(-1);
+
+    do {
+	chunk = len;
+	if (chunk > 4 * MINLEN)
+	    chunk = 4 * MINLEN;
+
+	/*
+	 * first handle encoding stuff.
+	 */
+	if (out->encoder != NULL) {
+	    /*
+	     * Store the data in the incoming raw buffer
+	     */
+	    if (out->conv == NULL) {
+		out->conv = xmlBufferCreate();
+	    }
+	    xmlBufferAdd(out->buffer, (const xmlChar *) buf, chunk);
+
+	    if ((out->buffer->use < MINLEN) && (chunk == len))
+		goto done;
+
+	    /*
+	     * convert as much as possible to the parser reading buffer.
+	     */
+	    ret = xmlCharEncOutFunc(out->encoder, out->conv, out->buffer);
+	    if ((ret < 0) && (ret != -3)) {
+		xmlIOErr(XML_IO_ENCODER, NULL);
+		out->error = XML_IO_ENCODER;
+		return(-1);
+	    }
+	    nbchars = out->conv->use;
+	} else {
+	    xmlBufferAdd(out->buffer, (const xmlChar *) buf, chunk);
+	    nbchars = out->buffer->use;
+	}
+	buf += chunk;
+	len -= chunk;
+
+	if ((nbchars < MINLEN) && (len <= 0))
+	    goto done;
+
+	if (out->writecallback) {
+	    /*
+	     * second write the stuff to the I/O channel
+	     */
+	    if (out->encoder != NULL) {
+		ret = out->writecallback(out->context, 
+				 (const char *)out->conv->content, nbchars);
+		if (ret >= 0)
+		    xmlBufferShrink(out->conv, ret);
+	    } else {
+		ret = out->writecallback(out->context, 
+				 (const char *)out->buffer->content, nbchars);
+		if (ret >= 0)
+		    xmlBufferShrink(out->buffer, ret);
+	    }
+	    if (ret < 0) {
+		xmlIOErr(XML_IO_WRITE, NULL);
+		out->error = XML_IO_WRITE;
+		return(ret);
+	    }
+	    out->written += ret;
+	}
+	written += nbchars;
+    } while (len > 0);
+
+done:
+#ifdef DEBUG_INPUT
+    xmlGenericError(xmlGenericErrorContext,
+	    "I/O: wrote %d chars\n", written);
+#endif
+    return(written);
+}
+
+/**
+ * xmlOutputBufferWriteString:
+ * @out:  a buffered parser output
+ * @str:  a zero terminated C string
+ *
+ * Write the content of the string in the output I/O buffer
+ * This routine handle the I18N transcoding from internal UTF-8
+ * The buffer is lossless, i.e. will store in case of partial
+ * or delayed writes.
+ *
+ * Returns the number of chars immediately written, or -1
+ *         in case of error.
+ */
+int
+xmlOutputBufferWriteString(xmlOutputBufferPtr out, const char *str) {
+    int len;
+    
+    if ((out == NULL) || (out->error)) return(-1);
+    if (str == NULL)
+        return(-1);
+    len = strlen(str);
+
+    if (len > 0)
+	return(xmlOutputBufferWrite(out, len, str));
+    return(len);
+}
+
+/**
+ * xmlOutputBufferFlush:
+ * @out:  a buffered output
+ *
+ * flushes the output I/O channel
+ *
+ * Returns the number of byte written or -1 in case of error.
+ */
+int
+xmlOutputBufferFlush(xmlOutputBufferPtr out) {
+    int nbchars = 0, ret = 0;
+
+    if ((out == NULL) || (out->error)) return(-1);
+    /*
+     * first handle encoding stuff.
+     */
+    if ((out->conv != NULL) && (out->encoder != NULL)) {
+	/*
+	 * convert as much as possible to the parser reading buffer.
+	 */
+	nbchars = xmlCharEncOutFunc(out->encoder, out->conv, out->buffer);
+	if (nbchars < 0) {
+	    xmlIOErr(XML_IO_ENCODER, NULL);
+	    out->error = XML_IO_ENCODER;
+	    return(-1);
+	}
+    }
+
+    /*
+     * second flush the stuff to the I/O channel
+     */
+    if ((out->conv != NULL) && (out->encoder != NULL) &&
+	(out->writecallback != NULL)) {
+	ret = out->writecallback(out->context,
+	           (const char *)out->conv->content, out->conv->use);
+	if (ret >= 0)
+	    xmlBufferShrink(out->conv, ret);
+    } else if (out->writecallback != NULL) {
+	ret = out->writecallback(out->context,
+	           (const char *)out->buffer->content, out->buffer->use);
+	if (ret >= 0)
+	    xmlBufferShrink(out->buffer, ret);
+    }
+    if (ret < 0) {
+	xmlIOErr(XML_IO_FLUSH, NULL);
+	out->error = XML_IO_FLUSH;
+	return(ret);
+    }
+    out->written += ret;
+
+#ifdef DEBUG_INPUT
+    xmlGenericError(xmlGenericErrorContext,
+	    "I/O: flushed %d chars\n", ret);
+#endif
+    return(ret);
+}
+#endif /* LIBXML_OUTPUT_ENABLED */
+
+/**
+ * xmlParserGetDirectory:
+ * @filename:  the path to a file
+ *
+ * lookup the directory for that file
+ *
+ * Returns a new allocated string containing the directory, or NULL.
+ */
+char *
+xmlParserGetDirectory(const char *filename) {
+    char *ret = NULL;
+    char dir[1024];
+    char *cur;
+    char sep = '/';
+
+#ifdef _WIN32_WCE  /* easy way by now ... wince does not have dirs! */
+    return NULL;
+#endif
+
+    if (xmlInputCallbackInitialized == 0)
+	xmlRegisterDefaultInputCallbacks();
+
+    if (filename == NULL) return(NULL);
+#if defined(WIN32) && !defined(__CYGWIN__)
+    sep = '\\';
+#endif
+
+    strncpy(dir, filename, 1023);
+    dir[1023] = 0;
+    cur = &dir[strlen(dir)];
+    while (cur > dir) {
+         if (*cur == sep) break;
+	 cur --;
+    }
+    if (*cur == sep) {
+        if (cur == dir) dir[1] = 0;
+	else *cur = 0;
+	ret = xmlMemStrdup(dir);
+    } else {
+        if (getcwd(dir, 1024) != NULL) {
+	    dir[1023] = 0;
+	    ret = xmlMemStrdup(dir);
+	}
+    }
+    return(ret);
+}
+
+/****************************************************************
+ *								*
+ *		External entities loading			*
+ *								*
+ ****************************************************************/
+
+/**
+ * xmlCheckHTTPInput:
+ * @ctxt: an XML parser context
+ * @ret: an XML parser input
+ *
+ * Check an input in case it was created from an HTTP stream, in that
+ * case it will handle encoding and update of the base URL in case of
+ * redirection. It also checks for HTTP errors in which case the input
+ * is cleanly freed up and an appropriate error is raised in context
+ *
+ * Returns the input or NULL in case of HTTP error.
+ */
+xmlParserInputPtr
+xmlCheckHTTPInput(xmlParserCtxtPtr ctxt, xmlParserInputPtr ret) {
+#ifdef LIBXML_HTTP_ENABLED
+    if ((ret != NULL) && (ret->buf != NULL) &&
+        (ret->buf->readcallback == xmlIOHTTPRead) &&
+        (ret->buf->context != NULL)) {
+        const char *encoding;
+        const char *redir;
+        const char *mime;
+        int code;
+
+        code = xmlNanoHTTPReturnCode(ret->buf->context);
+        if (code >= 400) {
+            /* fatal error */
+	    if (ret->filename != NULL)
+		__xmlLoaderErr(ctxt, "failed to load HTTP resource \"%s\"\n",
+                         (const char *) ret->filename);
+	    else
+		__xmlLoaderErr(ctxt, "failed to load HTTP resource\n", NULL);
+            xmlFreeInputStream(ret);
+            ret = NULL;
+        } else {
+
+            mime = xmlNanoHTTPMimeType(ret->buf->context);
+            if ((xmlStrstr(BAD_CAST mime, BAD_CAST "/xml")) ||
+                (xmlStrstr(BAD_CAST mime, BAD_CAST "+xml"))) {
+                encoding = xmlNanoHTTPEncoding(ret->buf->context);
+                if (encoding != NULL) {
+                    xmlCharEncodingHandlerPtr handler;
+
+                    handler = xmlFindCharEncodingHandler(encoding);
+                    if (handler != NULL) {
+                        xmlSwitchInputEncoding(ctxt, ret, handler);
+                    } else {
+                        __xmlErrEncoding(ctxt, XML_ERR_UNKNOWN_ENCODING,
+                                         "Unknown encoding %s",
+                                         BAD_CAST encoding, NULL);
+                    }
+                    if (ret->encoding == NULL)
+                        ret->encoding = xmlStrdup(BAD_CAST encoding);
+                }
+#if 0
+            } else if (xmlStrstr(BAD_CAST mime, BAD_CAST "html")) {
+#endif
+            }
+            redir = xmlNanoHTTPRedir(ret->buf->context);
+            if (redir != NULL) {
+                if (ret->filename != NULL)
+                    xmlFree((xmlChar *) ret->filename);
+                if (ret->directory != NULL) {
+                    xmlFree((xmlChar *) ret->directory);
+                    ret->directory = NULL;
+                }
+                ret->filename =
+                    (char *) xmlStrdup((const xmlChar *) redir);
+            }
+        }
+    }
+#endif
+    return(ret);
+}
+
+static int xmlSysIDExists(const char *URL) {
+#ifdef HAVE_STAT
+    int ret;
+    struct stat info;
+    const char *path;
+
+    if (URL == NULL)
+	return(0);
+
+    if (!xmlStrncasecmp(BAD_CAST URL, BAD_CAST "file://localhost/", 17))
+#if defined (_WIN32) || defined (__DJGPP__) && !defined(__CYGWIN__)
+	path = &URL[17];
+#else
+	path = &URL[16];
+#endif
+    else if (!xmlStrncasecmp(BAD_CAST URL, BAD_CAST "file:///", 8)) {
+#if defined (_WIN32) || defined (__DJGPP__) && !defined(__CYGWIN__)
+	path = &URL[8];
+#else
+	path = &URL[7];
+#endif
+    } else 
+	path = URL;
+    ret = stat(path, &info);
+    if (ret == 0)
+	return(1);
+#endif
+    return(0);
+}
+
+/**
+ * xmlDefaultExternalEntityLoader:
+ * @URL:  the URL for the entity to load
+ * @ID:  the System ID for the entity to load
+ * @ctxt:  the context in which the entity is called or NULL
+ *
+ * By default we don't load external entitites, yet.
+ *
+ * Returns a new allocated xmlParserInputPtr, or NULL.
+ */
+static xmlParserInputPtr
+xmlDefaultExternalEntityLoader(const char *URL, const char *ID,
+                               xmlParserCtxtPtr ctxt)
+{
+    xmlParserInputPtr ret = NULL;
+    xmlChar *resource = NULL;
+
+#ifdef LIBXML_CATALOG_ENABLED
+    xmlCatalogAllow pref;
+#endif
+
+#ifdef DEBUG_EXTERNAL_ENTITIES
+    xmlGenericError(xmlGenericErrorContext,
+                    "xmlDefaultExternalEntityLoader(%s, xxx)\n", URL);
+#endif
+#ifdef LIBXML_CATALOG_ENABLED
+    if ((ctxt != NULL) && (ctxt->options & XML_PARSE_NONET)) {
+        int options = ctxt->options;
+
+	ctxt->options -= XML_PARSE_NONET;
+        ret = xmlNoNetExternalEntityLoader(URL, ID, ctxt);
+	ctxt->options = options;
+	return(ret);
+    }
+
+    /*
+     * If the resource doesn't exists as a file,
+     * try to load it from the resource pointed in the catalogs
+     */
+    pref = xmlCatalogGetDefaults();
+
+    if ((pref != XML_CATA_ALLOW_NONE) && (!xmlSysIDExists(URL))) {
+        /*
+         * Do a local lookup
+         */
+        if ((ctxt->catalogs != NULL) &&
+            ((pref == XML_CATA_ALLOW_ALL) ||
+             (pref == XML_CATA_ALLOW_DOCUMENT))) {
+            resource = xmlCatalogLocalResolve(ctxt->catalogs,
+                                              (const xmlChar *) ID,
+                                              (const xmlChar *) URL);
+        }
+        /*
+         * Try a global lookup
+         */
+        if ((resource == NULL) &&
+            ((pref == XML_CATA_ALLOW_ALL) ||
+             (pref == XML_CATA_ALLOW_GLOBAL))) {
+            resource = xmlCatalogResolve((const xmlChar *) ID,
+                                         (const xmlChar *) URL);
+        }
+        if ((resource == NULL) && (URL != NULL))
+            resource = xmlStrdup((const xmlChar *) URL);
+
+        /*
+         * TODO: do an URI lookup on the reference
+         */
+        if ((resource != NULL)
+            && (!xmlSysIDExists((const char *) resource))) {
+            xmlChar *tmp = NULL;
+
+            if ((ctxt->catalogs != NULL) &&
+                ((pref == XML_CATA_ALLOW_ALL) ||
+                 (pref == XML_CATA_ALLOW_DOCUMENT))) {
+                tmp = xmlCatalogLocalResolveURI(ctxt->catalogs, resource);
+            }
+            if ((tmp == NULL) &&
+                ((pref == XML_CATA_ALLOW_ALL) ||
+                 (pref == XML_CATA_ALLOW_GLOBAL))) {
+                tmp = xmlCatalogResolveURI(resource);
+            }
+
+            if (tmp != NULL) {
+                xmlFree(resource);
+                resource = tmp;
+            }
+        }
+    }
+#endif
+
+    if (resource == NULL)
+        resource = (xmlChar *) URL;
+
+    if (resource == NULL) {
+        if (ID == NULL)
+            ID = "NULL";
+        __xmlLoaderErr(ctxt, "failed to load external entity \"%s\"\n", ID);
+        return (NULL);
+    }
+    ret = xmlNewInputFromFile(ctxt, (const char *) resource);
+    if ((resource != NULL) && (resource != (xmlChar *) URL))
+        xmlFree(resource);
+    return (ret);
+}
+
+static xmlExternalEntityLoader xmlCurrentExternalEntityLoader =
+       xmlDefaultExternalEntityLoader;
+
+/**
+ * xmlSetExternalEntityLoader:
+ * @f:  the new entity resolver function
+ *
+ * Changes the defaultexternal entity resolver function for the application
+ */
+void
+xmlSetExternalEntityLoader(xmlExternalEntityLoader f) {
+    xmlCurrentExternalEntityLoader = f;
+}
+
+/**
+ * xmlGetExternalEntityLoader:
+ *
+ * Get the default external entity resolver function for the application
+ *
+ * Returns the xmlExternalEntityLoader function pointer
+ */
+xmlExternalEntityLoader
+xmlGetExternalEntityLoader(void) {
+    return(xmlCurrentExternalEntityLoader);
+}
+
+/**
+ * xmlLoadExternalEntity:
+ * @URL:  the URL for the entity to load
+ * @ID:  the Public ID for the entity to load
+ * @ctxt:  the context in which the entity is called or NULL
+ *
+ * Load an external entity, note that the use of this function for
+ * unparsed entities may generate problems
+ * TODO: a more generic External entity API must be designed
+ *
+ * Returns the xmlParserInputPtr or NULL
+ */
+xmlParserInputPtr
+xmlLoadExternalEntity(const char *URL, const char *ID,
+                      xmlParserCtxtPtr ctxt) {
+    if ((URL != NULL) && (xmlSysIDExists(URL) == 0)) {
+	char *canonicFilename;
+	xmlParserInputPtr ret;
+
+	canonicFilename = (char *) xmlCanonicPath((const xmlChar *) URL);
+	if (canonicFilename == NULL) {
+            xmlIOErrMemory("building canonical path\n");
+	    return(NULL);
+	}
+
+	ret = xmlCurrentExternalEntityLoader(canonicFilename, ID, ctxt);
+	xmlFree(canonicFilename);
+	return(ret);
+    }
+    return(xmlCurrentExternalEntityLoader(URL, ID, ctxt));
+}
+
+/************************************************************************
+ * 									*
+ * 		Disabling Network access				*
+ * 									*
+ ************************************************************************/
+
+#ifdef LIBXML_CATALOG_ENABLED
+static int
+xmlNoNetExists(const char *URL)
+{
+#ifdef HAVE_STAT
+    int ret;
+    struct stat info;
+    const char *path;
+
+    if (URL == NULL)
+        return (0);
+
+    if (!xmlStrncasecmp(BAD_CAST URL, BAD_CAST "file://localhost/", 17))
+#if defined (_WIN32) || defined (__DJGPP__) && !defined(__CYGWIN__)
+	path = &URL[17];
+#else
+	path = &URL[16];
+#endif
+    else if (!xmlStrncasecmp(BAD_CAST URL, BAD_CAST "file:///", 8)) {
+#if defined (_WIN32) || defined (__DJGPP__) && !defined(__CYGWIN__)
+        path = &URL[8];
+#else
+        path = &URL[7];
+#endif
+    } else
+        path = URL;
+    ret = stat(path, &info);
+    if (ret == 0)
+        return (1);
+#endif
+    return (0);
+}
+#endif
+
+/**
+ * xmlNoNetExternalEntityLoader:
+ * @URL:  the URL for the entity to load
+ * @ID:  the System ID for the entity to load
+ * @ctxt:  the context in which the entity is called or NULL
+ *
+ * A specific entity loader disabling network accesses, though still
+ * allowing local catalog accesses for resolution.
+ *
+ * Returns a new allocated xmlParserInputPtr, or NULL.
+ */
+xmlParserInputPtr
+xmlNoNetExternalEntityLoader(const char *URL, const char *ID,
+                             xmlParserCtxtPtr ctxt) {
+    xmlParserInputPtr input = NULL;
+    xmlChar *resource = NULL;
+
+#ifdef LIBXML_CATALOG_ENABLED
+    xmlCatalogAllow pref;
+
+    /*
+     * If the resource doesn't exists as a file,
+     * try to load it from the resource pointed in the catalogs
+     */
+    pref = xmlCatalogGetDefaults();
+
+    if ((pref != XML_CATA_ALLOW_NONE) && (!xmlNoNetExists(URL))) {
+	/*
+	 * Do a local lookup
+	 */
+	if ((ctxt->catalogs != NULL) &&
+	    ((pref == XML_CATA_ALLOW_ALL) ||
+	     (pref == XML_CATA_ALLOW_DOCUMENT))) {
+	    resource = xmlCatalogLocalResolve(ctxt->catalogs,
+					      (const xmlChar *)ID,
+					      (const xmlChar *)URL);
+        }
+	/*
+	 * Try a global lookup
+	 */
+	if ((resource == NULL) &&
+	    ((pref == XML_CATA_ALLOW_ALL) ||
+	     (pref == XML_CATA_ALLOW_GLOBAL))) {
+	    resource = xmlCatalogResolve((const xmlChar *)ID,
+					 (const xmlChar *)URL);
+	}
+	if ((resource == NULL) && (URL != NULL))
+	    resource = xmlStrdup((const xmlChar *) URL);
+
+	/*
+	 * TODO: do an URI lookup on the reference
+	 */
+	if ((resource != NULL) && (!xmlNoNetExists((const char *)resource))) {
+	    xmlChar *tmp = NULL;
+
+	    if ((ctxt->catalogs != NULL) &&
+		((pref == XML_CATA_ALLOW_ALL) ||
+		 (pref == XML_CATA_ALLOW_DOCUMENT))) {
+		tmp = xmlCatalogLocalResolveURI(ctxt->catalogs, resource);
+	    }
+	    if ((tmp == NULL) &&
+		((pref == XML_CATA_ALLOW_ALL) ||
+	         (pref == XML_CATA_ALLOW_GLOBAL))) {
+		tmp = xmlCatalogResolveURI(resource);
+	    }
+
+	    if (tmp != NULL) {
+		xmlFree(resource);
+		resource = tmp;
+	    }
+	}
+    }
+#endif
+    if (resource == NULL)
+	resource = (xmlChar *) URL;
+
+    if (resource != NULL) {
+        if ((!xmlStrncasecmp(BAD_CAST resource, BAD_CAST "ftp://", 6)) ||
+            (!xmlStrncasecmp(BAD_CAST resource, BAD_CAST "http://", 7))) {
+            xmlIOErr(XML_IO_NETWORK_ATTEMPT, (const char *) resource);
+	    if (resource != (xmlChar *) URL)
+		xmlFree(resource);
+	    return(NULL);
+	}
+    }
+    input = xmlDefaultExternalEntityLoader((const char *) resource, ID, ctxt);
+    if (resource != (xmlChar *) URL)
+	xmlFree(resource);
+    return(input);
+}
+
diff --git a/src/libxml/src/xmlcatalog.c b/src/libxml/src/xmlcatalog.c
new file mode 100644
index 0000000..5fcb417
--- /dev/null
+++ b/src/libxml/src/xmlcatalog.c
@@ -0,0 +1,594 @@
+/*
+ * xmlcatalog.c : a small utility program to handle XML catalogs
+ *
+ * See Copyright for the status of this software.
+ *
+ * daniel@veillard.com
+ */
+
+#include "libxml.h"
+
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+
+#ifdef HAVE_LIBREADLINE
+#include <readline/readline.h>
+#ifdef HAVE_LIBHISTORY
+#include <readline/history.h>
+#endif
+#endif
+
+#include <libxml/xmlmemory.h>
+#include <libxml/uri.h>
+#include <libxml/catalog.h>
+#include <libxml/parser.h>
+#include <libxml/globals.h>
+
+#if defined(LIBXML_CATALOG_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
+static int shell = 0;
+static int sgml = 0;
+static int noout = 0;
+static int create = 0;
+static int add = 0;
+static int del = 0;
+static int convert = 0;
+static int verbose = 0;
+static char *filename = NULL;
+
+
+#ifndef XML_SGML_DEFAULT_CATALOG
+#define XML_SGML_DEFAULT_CATALOG "/etc/sgml/catalog"
+#endif
+
+/************************************************************************
+ * 									*
+ * 			Shell Interface					*
+ * 									*
+ ************************************************************************/
+/**
+ * xmlShellReadline:
+ * @prompt:  the prompt value
+ *
+ * Read a string
+ * 
+ * Returns a pointer to it or NULL on EOF the caller is expected to
+ *     free the returned string.
+ */
+static char *
+xmlShellReadline(const char *prompt) {
+#ifdef HAVE_LIBREADLINE
+    char *line_read;
+
+    /* Get a line from the user. */
+    line_read = readline (prompt);
+
+    /* If the line has any text in it, save it on the history. */
+    if (line_read && *line_read)
+	add_history (line_read);
+
+    return (line_read);
+#else
+    char line_read[501];
+    char *ret;
+    int len;
+
+    if (prompt != NULL)
+	fprintf(stdout, "%s", prompt);
+    if (!fgets(line_read, 500, stdin))
+        return(NULL);
+    line_read[500] = 0;
+    len = strlen(line_read);
+    ret = (char *) malloc(len + 1);
+    if (ret != NULL) {
+	memcpy (ret, line_read, len + 1);
+    }
+    return(ret);
+#endif
+}
+
+static void usershell(void) {
+    char *cmdline = NULL, *cur;
+    int nbargs;
+    char command[100];
+    char arg[400];
+    char *argv[20];
+    int i, ret;
+    xmlChar *ans;
+
+    while (1) {
+	cmdline = xmlShellReadline("> ");
+	if (cmdline == NULL)
+	    return;
+
+	/*
+	 * Parse the command itself
+	 */
+	cur = cmdline;
+	nbargs = 0;
+	while ((*cur == ' ') || (*cur == '\t')) cur++;
+	i = 0;
+	while ((*cur != ' ') && (*cur != '\t') &&
+	       (*cur != '\n') && (*cur != '\r')) {
+	    if (*cur == 0)
+		break;
+	    command[i++] = *cur++;
+	}
+	command[i] = 0;
+	if (i == 0) continue;
+	nbargs++;
+
+	/*
+	 * Parse the argument string
+	 */
+	memset(arg, 0, sizeof(arg));
+	while ((*cur == ' ') || (*cur == '\t')) cur++;
+	i = 0;
+	while ((*cur != '\n') && (*cur != '\r') && (*cur != 0)) {
+	    if (*cur == 0)
+		break;
+	    arg[i++] = *cur++;
+	}
+	arg[i] = 0;
+	if (i != 0) 
+	    nbargs++;
+
+	/*
+	 * Parse the arguments
+	 */
+	i = 0;
+	nbargs = 0;
+	cur = arg;
+	memset(argv, 0, sizeof(argv));
+	while (*cur != 0) {
+	    while ((*cur == ' ') || (*cur == '\t')) cur++;
+	    if (*cur == '\'') {
+		cur++;
+		argv[i] = cur;
+		while ((*cur != 0) && (*cur != '\'')) cur++;
+		if (*cur == '\'') {
+		    *cur = 0;
+		    nbargs++;
+		    i++;
+		    cur++;
+		}
+	    } else if (*cur == '"') { 
+		cur++;
+		argv[i] = cur;
+		while ((*cur != 0) && (*cur != '"')) cur++;
+		if (*cur == '"') {
+		    *cur = 0;
+		    nbargs++;
+		    i++;
+		    cur++;
+		}
+	    } else {
+		argv[i] = cur;
+		while ((*cur != 0) && (*cur != ' ') && (*cur != '\t'))
+		    cur++;
+		*cur = 0;
+		nbargs++;
+		i++;
+		cur++;
+	    }
+	}
+
+	/*
+	 * start interpreting the command
+	 */
+        if (!strcmp(command, "exit"))
+	    break;
+        if (!strcmp(command, "quit"))
+	    break;
+        if (!strcmp(command, "bye"))
+	    break;
+	if (!strcmp(command, "public")) {
+	    if (nbargs != 1) {
+		printf("public requires 1 arguments\n");
+	    } else {
+		ans = xmlCatalogResolvePublic((const xmlChar *) argv[0]);
+		if (ans == NULL) {
+		    printf("No entry for PUBLIC %s\n", argv[0]);
+		} else {
+		    printf("%s\n", (char *) ans);
+		    xmlFree(ans);
+		}
+	    }
+	} else if (!strcmp(command, "system")) {
+	    if (nbargs != 1) {
+		printf("system requires 1 arguments\n");
+	    } else {
+		ans = xmlCatalogResolveSystem((const xmlChar *) argv[0]);
+		if (ans == NULL) {
+		    printf("No entry for SYSTEM %s\n", argv[0]);
+		} else {
+		    printf("%s\n", (char *) ans);
+		    xmlFree(ans);
+		}
+	    }
+	} else if (!strcmp(command, "add")) {
+	    if (sgml) {
+		if ((nbargs != 3) && (nbargs != 2)) {
+		    printf("add requires 2 or 3 arguments\n");
+		} else {
+		    if (argv[2] == NULL)
+			ret = xmlCatalogAdd(BAD_CAST argv[0], NULL,
+					    BAD_CAST argv[1]);
+		    else
+			ret = xmlCatalogAdd(BAD_CAST argv[0], BAD_CAST argv[1],
+					    BAD_CAST argv[2]);
+		    if (ret != 0)
+			printf("add command failed\n");
+		}
+	    } else {
+		if ((nbargs != 3) && (nbargs != 2)) {
+		    printf("add requires 2 or 3 arguments\n");
+		} else {
+		    if (argv[2] == NULL)
+			ret = xmlCatalogAdd(BAD_CAST argv[0], NULL,
+					    BAD_CAST argv[1]);
+		    else
+			ret = xmlCatalogAdd(BAD_CAST argv[0], BAD_CAST argv[1],
+					    BAD_CAST argv[2]);
+		    if (ret != 0)
+			printf("add command failed\n");
+		}
+	    }
+	} else if (!strcmp(command, "del")) {
+	    if (nbargs != 1) {
+		printf("del requires 1\n");
+	    } else {
+		ret = xmlCatalogRemove(BAD_CAST argv[0]);
+		if (ret <= 0)
+		    printf("del command failed\n");
+
+	    }
+	} else if (!strcmp(command, "resolve")) {
+	    if (nbargs != 2) {
+		printf("resolve requires 2 arguments\n");
+	    } else {
+		ans = xmlCatalogResolve(BAD_CAST argv[0],
+			                BAD_CAST argv[1]);
+		if (ans == NULL) {
+		    printf("Resolver failed to find an answer\n");
+		} else {
+		    printf("%s\n", (char *) ans);
+		    xmlFree(ans);
+		}
+	    }
+	} else if (!strcmp(command, "dump")) {
+	    if (nbargs != 0) {
+		printf("dump has no arguments\n");
+	    } else {
+		xmlCatalogDump(stdout);
+	    }
+	} else if (!strcmp(command, "debug")) {
+	    if (nbargs != 0) {
+		printf("debug has no arguments\n");
+	    } else {
+		verbose++;
+		xmlCatalogSetDebug(verbose);
+	    }
+	} else if (!strcmp(command, "quiet")) {
+	    if (nbargs != 0) {
+		printf("quiet has no arguments\n");
+	    } else {
+		if (verbose > 0)
+		    verbose--;
+		xmlCatalogSetDebug(verbose);
+	    }
+	} else {
+	    if (strcmp(command, "help")) {
+		printf("Unrecognized command %s\n", command);
+	    }
+	    printf("Commands available:\n");
+	    printf("\tpublic PublicID: make a PUBLIC identifier lookup\n");
+	    printf("\tsystem SystemID: make a SYSTEM identifier lookup\n");
+	    printf("\tresolve PublicID SystemID: do a full resolver lookup\n");
+	    printf("\tadd 'type' 'orig' 'replace' : add an entry\n");
+	    printf("\tdel 'values' : remove values\n");
+	    printf("\tdump: print the current catalog state\n");
+	    printf("\tdebug: increase the verbosity level\n");
+	    printf("\tquiet: decrease the verbosity level\n");
+	    printf("\texit:  quit the shell\n");
+	} 
+	free(cmdline); /* not xmlFree here ! */
+    }
+}
+
+/************************************************************************
+ * 									*
+ * 			Main						*
+ * 									*
+ ************************************************************************/
+static void usage(const char *name) {
+    printf("Usage : %s [options] catalogfile entities...\n", name);
+    printf("\tParse the catalog file and query it for the entities\n");
+    printf("\t--sgml : handle SGML Super catalogs for --add and --del\n");
+    printf("\t--shell : run a shell allowing interactive queries\n");
+    printf("\t--create : create a new catalog\n");
+    printf("\t--add 'type' 'orig' 'replace' : add an entry\n");
+    printf("\t--del 'values' : remove values\n");
+    printf("\t--noout: avoid dumping the result on stdout\n");
+    printf("\t         used with add or del, it saves the catalog changes\n");
+    printf("\t         and with --sgml it also updates the super catalog\n");
+    printf("\t-v --verbose : provide debug informations\n");
+}
+int main(int argc, char **argv) {
+    int i;
+    int ret;
+    int exit_value = 0;
+
+
+    if (argc <= 1) {
+	usage(argv[0]);
+	return(1);
+    }
+
+    LIBXML_TEST_VERSION
+    for (i = 1; i < argc ; i++) {
+	if (!strcmp(argv[i], "-"))
+	    break;
+
+	if (argv[i][0] != '-')
+	    break;
+	if ((!strcmp(argv[i], "-verbose")) ||
+	    (!strcmp(argv[i], "-v")) ||
+	    (!strcmp(argv[i], "--verbose"))) {
+	    verbose++;
+	    xmlCatalogSetDebug(verbose);
+	} else if ((!strcmp(argv[i], "-noout")) ||
+	    (!strcmp(argv[i], "--noout"))) {
+            noout = 1;
+	} else if ((!strcmp(argv[i], "-shell")) ||
+	    (!strcmp(argv[i], "--shell"))) {
+	    shell++;
+            noout = 1;
+	} else if ((!strcmp(argv[i], "-sgml")) ||
+	    (!strcmp(argv[i], "--sgml"))) {
+	    sgml++;
+	} else if ((!strcmp(argv[i], "-create")) ||
+	    (!strcmp(argv[i], "--create"))) {
+	    create++;
+	} else if ((!strcmp(argv[i], "-convert")) ||
+	    (!strcmp(argv[i], "--convert"))) {
+	    convert++;
+	} else if ((!strcmp(argv[i], "-add")) ||
+	    (!strcmp(argv[i], "--add"))) {
+	    if (sgml)
+		i += 2;
+	    else
+		i += 3;
+	    add++;
+	} else if ((!strcmp(argv[i], "-del")) ||
+	    (!strcmp(argv[i], "--del"))) {
+	    i += 1;
+	    del++;
+	} else {
+	    fprintf(stderr, "Unknown option %s\n", argv[i]);
+	    usage(argv[0]);
+	    return(1);
+	}
+    }
+
+    for (i = 1; i < argc; i++) {
+	if ((!strcmp(argv[i], "-add")) ||
+	    (!strcmp(argv[i], "--add"))) {
+	    if (sgml)
+		i += 2;
+	    else
+		i += 3;
+	    continue;
+	} else if ((!strcmp(argv[i], "-del")) ||
+	    (!strcmp(argv[i], "--del"))) {
+	    i += 1;
+	    continue;
+	} else if (argv[i][0] == '-')
+	    continue;
+	filename = argv[i];
+	    ret = xmlLoadCatalog(argv[i]);
+	    if ((ret < 0) && (create)) {
+		xmlCatalogAdd(BAD_CAST "catalog", BAD_CAST argv[i], NULL);
+	    }
+	break;
+    }
+
+    if (convert)
+        ret = xmlCatalogConvert();
+
+    if ((add) || (del)) {
+	for (i = 1; i < argc ; i++) {
+	    if (!strcmp(argv[i], "-"))
+		break;
+
+	    if (argv[i][0] != '-')
+		continue;
+	    if (strcmp(argv[i], "-add") && strcmp(argv[i], "--add") &&
+		strcmp(argv[i], "-del") && strcmp(argv[i], "--del"))
+		continue;
+
+	    if (sgml) {
+		/*
+		 * Maintenance of SGML catalogs.
+		 */
+		xmlCatalogPtr catal = NULL;
+		xmlCatalogPtr super = NULL;
+
+		catal = xmlLoadSGMLSuperCatalog(argv[i + 1]);
+
+		if ((!strcmp(argv[i], "-add")) ||
+		    (!strcmp(argv[i], "--add"))) {
+		    if (catal == NULL)
+			catal = xmlNewCatalog(1);
+		    super = xmlLoadSGMLSuperCatalog(XML_SGML_DEFAULT_CATALOG);
+		    if (super == NULL)
+			super = xmlNewCatalog(1);
+
+		    xmlACatalogAdd(catal, BAD_CAST "CATALOG",
+					 BAD_CAST argv[i + 2], NULL);
+		    xmlACatalogAdd(super, BAD_CAST "CATALOG",
+					 BAD_CAST argv[i + 1], NULL);
+		} else {
+		    if (catal != NULL)
+			ret = xmlACatalogRemove(catal, BAD_CAST argv[i + 2]);
+		    else
+			ret = -1;
+		    if (ret < 0) {
+			fprintf(stderr, "Failed to remove entry from %s\n",
+				argv[i + 1]);
+			exit_value = 1;
+		    }
+		    if ((noout) && (catal != NULL) &&
+			(xmlCatalogIsEmpty(catal))) {
+			super = xmlLoadSGMLSuperCatalog(
+				   XML_SGML_DEFAULT_CATALOG);
+			if (super != NULL) {
+			    ret = xmlACatalogRemove(super,
+				    BAD_CAST argv[i + 1]);
+			    if (ret < 0) {
+				fprintf(stderr,
+					"Failed to remove entry from %s\n",
+					XML_SGML_DEFAULT_CATALOG);
+				exit_value = 1;
+			    }
+			}
+		    }
+		}
+		if (noout) {
+		    FILE *out;
+
+		    if (xmlCatalogIsEmpty(catal)) {
+			remove(argv[i + 1]);
+		    } else {
+			out = fopen(argv[i + 1], "w");
+			if (out == NULL) {
+			    fprintf(stderr, "could not open %s for saving\n",
+				    argv[i + 1]);
+			    exit_value = 2;
+			    noout = 0;
+			} else {
+			    xmlACatalogDump(catal, out);
+			    fclose(out);
+			}
+		    }
+		    if (super != NULL) {
+			if (xmlCatalogIsEmpty(super)) {
+			    remove(XML_SGML_DEFAULT_CATALOG);
+			} else {
+			    out = fopen(XML_SGML_DEFAULT_CATALOG, "w");
+			    if (out == NULL) {
+				fprintf(stderr,
+					"could not open %s for saving\n",
+					XML_SGML_DEFAULT_CATALOG);
+				exit_value = 2;
+				noout = 0;
+			    } else {
+				
+				xmlACatalogDump(super, out);
+				fclose(out);
+			    }
+			}
+		    }
+		} else {
+		    xmlACatalogDump(catal, stdout);
+		}
+		i += 2;
+	    } else {
+		if ((!strcmp(argv[i], "-add")) ||
+		    (!strcmp(argv[i], "--add"))) {
+			if ((argv[i + 3] == NULL) || (argv[i + 3][0] == 0))
+			    ret = xmlCatalogAdd(BAD_CAST argv[i + 1], NULL,
+						BAD_CAST argv[i + 2]);
+			else
+			    ret = xmlCatalogAdd(BAD_CAST argv[i + 1],
+						BAD_CAST argv[i + 2],
+						BAD_CAST argv[i + 3]);
+			if (ret != 0) {
+			    printf("add command failed\n");
+			    exit_value = 3;
+			}
+			i += 3;
+		} else if ((!strcmp(argv[i], "-del")) ||
+		    (!strcmp(argv[i], "--del"))) {
+		    ret = xmlCatalogRemove(BAD_CAST argv[i + 1]);
+		    if (ret < 0) {
+			fprintf(stderr, "Failed to remove entry %s\n",
+				argv[i + 1]);
+			exit_value = 1;
+		    }
+		    i += 1;
+		}
+	    }
+	}
+	
+    } else if (shell) {
+	usershell();
+    } else {
+	for (i++; i < argc; i++) {
+	    xmlURIPtr uri;
+	    xmlChar *ans;
+	    
+	    uri = xmlParseURI(argv[i]);
+	    if (uri == NULL) {
+		ans = xmlCatalogResolvePublic((const xmlChar *) argv[i]);
+		if (ans == NULL) {
+		    printf("No entry for PUBLIC %s\n", argv[i]);
+		    exit_value = 4;
+		} else {
+		    printf("%s\n", (char *) ans);
+		    xmlFree(ans);
+		}
+	    } else {
+                xmlFreeURI(uri);
+		ans = xmlCatalogResolveSystem((const xmlChar *) argv[i]);
+		if (ans == NULL) {
+		    printf("No entry for SYSTEM %s\n", argv[i]);
+		    ans = xmlCatalogResolveURI ((const xmlChar *) argv[i]);
+		    if (ans == NULL) {
+			printf ("No entry for URI %s\n", argv[i]);
+		        exit_value = 4;
+		    } else {
+		        printf("%s\n", (char *) ans);
+			xmlFree (ans);
+		    }
+		} else {
+		    printf("%s\n", (char *) ans);
+		    xmlFree(ans);
+		}
+	    }
+	}
+    }
+    if ((!sgml) && ((add) || (del) || (create) || (convert))) {
+	if (noout && filename && *filename) {
+	    FILE *out;
+
+	    out = fopen(filename, "w");
+	    if (out == NULL) {
+		fprintf(stderr, "could not open %s for saving\n", filename);
+		exit_value = 2;
+		noout = 0;
+	    } else {
+		xmlCatalogDump(out);
+	    }
+	} else {
+	    xmlCatalogDump(stdout);
+	}
+    }
+
+    /*
+     * Cleanup and check for memory leaks
+     */
+    xmlCleanupParser();
+    xmlMemoryDump();
+    return(exit_value);
+}
+#else
+int main(int argc ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED) {
+    fprintf(stderr, "libxml was not compiled with catalog and output support\n");
+    return(1);
+}
+#endif
diff --git a/src/libxml/src/xmllint.c b/src/libxml/src/xmllint.c
new file mode 100644
index 0000000..31fc262
--- /dev/null
+++ b/src/libxml/src/xmllint.c
@@ -0,0 +1,2015 @@
+/*
+ * xmllint.c : a small tester program for XML input.
+ *
+ * See Copyright for the status of this software.
+ *
+ * daniel@veillard.com
+ */
+
+#include "libxml.h"
+
+#include <string.h>
+#include <stdarg.h>
+#include <assert.h>
+
+#if defined (_WIN32) && !defined(__CYGWIN__)
+#if defined (_MSC_VER) || defined(__BORLANDC__)
+#include <winsock2.h>
+#pragma comment(lib, "ws2_32.lib")
+#define gettimeofday(p1,p2)
+#endif /* _MSC_VER */
+#endif /* _WIN32 */
+
+#ifdef HAVE_SYS_TIME_H
+#include <sys/time.h>
+#endif
+#ifdef HAVE_TIME_H
+#include <time.h>
+#endif
+
+#ifdef __MINGW32__
+#define _WINSOCKAPI_
+#include <wsockcompat.h>
+#include <winsock2.h>
+#undef SOCKLEN_T
+#define SOCKLEN_T unsigned int
+#endif
+
+#ifdef HAVE_SYS_TIMEB_H
+#include <sys/timeb.h>
+#endif
+
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_STAT_H
+#include <sys/stat.h>
+#endif
+#ifdef HAVE_FCNTL_H
+#include <fcntl.h>
+#endif
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#ifdef HAVE_SYS_MMAN_H
+#include <sys/mman.h>
+/* seems needed for Solaris */
+#ifndef MAP_FAILED
+#define MAP_FAILED ((void *) -1)
+#endif
+#endif
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+#ifdef HAVE_LIBREADLINE
+#include <readline/readline.h>
+#ifdef HAVE_LIBHISTORY
+#include <readline/history.h>
+#endif
+#endif
+
+#include <libxml/xmlmemory.h>
+#include <libxml/parser.h>
+#include <libxml/parserInternals.h>
+#include <libxml/HTMLparser.h>
+#include <libxml/HTMLtree.h>
+#include <libxml/tree.h>
+#include <libxml/xpath.h>
+#include <libxml/debugXML.h>
+#include <libxml/xmlerror.h>
+#ifdef LIBXML_XINCLUDE_ENABLED
+#include <libxml/xinclude.h>
+#endif
+#ifdef LIBXML_CATALOG_ENABLED
+#include <libxml/catalog.h>
+#endif
+#include <libxml/globals.h>
+#include <libxml/xmlreader.h>
+#ifdef LIBXML_SCHEMAS_ENABLED
+#include <libxml/relaxng.h>
+#include <libxml/xmlschemas.h>
+#endif
+#ifdef LIBXML_PATTERN_ENABLED
+#include <libxml/pattern.h>
+#endif
+
+#ifndef XML_XML_DEFAULT_CATALOG
+#define XML_XML_DEFAULT_CATALOG "file:///etc/xml/catalog"
+#endif
+
+#ifdef LIBXML_DEBUG_ENABLED
+static int shell = 0;
+static int debugent = 0;
+#endif
+static int debug = 0;
+#ifdef LIBXML_TREE_ENABLED
+static int copy = 0;
+#endif /* LIBXML_TREE_ENABLED */
+static int recovery = 0;
+static int noent = 0;
+static int noblanks = 0;
+static int noout = 0;
+static int nowrap = 0;
+#ifdef LIBXML_OUTPUT_ENABLED
+static int format = 0;
+static const char *output = NULL;
+static int compress = 0;
+#endif /* LIBXML_OUTPUT_ENABLED */
+#ifdef LIBXML_VALID_ENABLED
+static int valid = 0;
+static int postvalid = 0;
+static char * dtdvalid = NULL;
+static char * dtdvalidfpi = NULL;
+#endif
+#ifdef LIBXML_SCHEMAS_ENABLED
+static char * relaxng = NULL;
+static xmlRelaxNGPtr relaxngschemas = NULL;
+static char * schema = NULL;
+static xmlSchemaPtr wxschemas = NULL;
+#endif
+static int repeat = 0;
+static int insert = 0;
+#ifdef  LIBXML_HTML_ENABLED
+static int html = 0;
+static int xmlout = 0;
+#endif
+static int htmlout = 0;
+#ifdef LIBXML_PUSH_ENABLED
+static int push = 0;
+#endif /* LIBXML_PUSH_ENABLED */
+#ifdef HAVE_SYS_MMAN_H
+static int memory = 0;
+#endif
+static int testIO = 0;
+static char *encoding = NULL;
+#ifdef LIBXML_XINCLUDE_ENABLED
+static int xinclude = 0;
+#endif
+static int dtdattrs = 0;
+static int loaddtd = 0;
+static int progresult = 0;
+static int timing = 0;
+static int generate = 0;
+static int dropdtd = 0;
+#ifdef LIBXML_CATALOG_ENABLED
+static int catalogs = 0;
+static int nocatalogs = 0;
+#endif
+#ifdef LIBXML_READER_ENABLED
+static int stream = 0;
+static int walker = 0;
+#endif /* LIBXML_READER_ENABLED */
+static int chkregister = 0;
+#ifdef LIBXML_SAX1_ENABLED
+static int sax1 = 0;
+#endif /* LIBXML_SAX1_ENABLED */
+#ifdef LIBXML_PATTERN_ENABLED
+static const char *pattern = NULL;
+static xmlPatternPtr patternc = NULL;
+#endif
+static int options = 0;
+
+/*
+ * Internal timing routines to remove the necessity to have unix-specific
+ * function calls
+ */
+
+#ifndef HAVE_GETTIMEOFDAY 
+#ifdef HAVE_SYS_TIMEB_H
+#ifdef HAVE_SYS_TIME_H
+#ifdef HAVE_FTIME
+
+static int
+my_gettimeofday(struct timeval *tvp, void *tzp)
+{
+	struct timeb timebuffer;
+
+	ftime(&timebuffer);
+	if (tvp) {
+		tvp->tv_sec = timebuffer.time;
+		tvp->tv_usec = timebuffer.millitm * 1000L;
+	}
+	return (0);
+}
+#define HAVE_GETTIMEOFDAY 1
+#define gettimeofday my_gettimeofday
+
+#endif /* HAVE_FTIME */
+#endif /* HAVE_SYS_TIME_H */
+#endif /* HAVE_SYS_TIMEB_H */
+#endif /* !HAVE_GETTIMEOFDAY */
+
+#if defined(HAVE_GETTIMEOFDAY)
+static struct timeval begin, end;
+
+/*
+ * startTimer: call where you want to start timing
+ */
+static void
+startTimer(void)
+{
+    gettimeofday(&begin, NULL);
+}
+
+/*
+ * endTimer: call where you want to stop timing and to print out a
+ *           message about the timing performed; format is a printf
+ *           type argument
+ */
+static void
+endTimer(const char *fmt, ...)
+{
+    long msec;
+    va_list ap;
+
+    gettimeofday(&end, NULL);
+    msec = end.tv_sec - begin.tv_sec;
+    msec *= 1000;
+    msec += (end.tv_usec - begin.tv_usec) / 1000;
+
+#ifndef HAVE_STDARG_H
+#error "endTimer required stdarg functions"
+#endif
+    va_start(ap, fmt);
+    vfprintf(stderr, fmt, ap);
+    va_end(ap);
+
+    fprintf(stderr, " took %ld ms\n", msec);
+}
+#elif defined(HAVE_TIME_H)
+/*
+ * No gettimeofday function, so we have to make do with calling clock.
+ * This is obviously less accurate, but there's little we can do about
+ * that.
+ */
+#ifndef CLOCKS_PER_SEC
+#define CLOCKS_PER_SEC 100
+#endif
+
+static clock_t begin, end;
+static void
+startTimer(void)
+{
+    begin = clock();
+}
+static void
+endTimer(const char *fmt, ...)
+{
+    long msec;
+    va_list ap;
+
+    end = clock();
+    msec = ((end - begin) * 1000) / CLOCKS_PER_SEC;
+
+#ifndef HAVE_STDARG_H
+#error "endTimer required stdarg functions"
+#endif
+    va_start(ap, fmt);
+    vfprintf(stderr, fmt, ap);
+    va_end(ap);
+    fprintf(stderr, " took %ld ms\n", msec);
+}
+#else
+
+/*
+ * We don't have a gettimeofday or time.h, so we just don't do timing
+ */
+static void
+startTimer(void)
+{
+    /*
+     * Do nothing
+     */
+}
+static void
+endTimer(char *format, ...)
+{
+    /*
+     * We cannot do anything because we don't have a timing function
+     */
+#ifdef HAVE_STDARG_H
+    va_start(ap, format);
+    vfprintf(stderr, format, ap);
+    va_end(ap);
+    fprintf(stderr, " was not timed\n", msec);
+#else
+    /* We don't have gettimeofday, time or stdarg.h, what crazy world is
+     * this ?!
+     */
+#endif
+}
+#endif
+/************************************************************************
+ * 									*
+ * 			HTML ouput					*
+ * 									*
+ ************************************************************************/
+char buffer[50000];
+
+static void
+xmlHTMLEncodeSend(void) {
+    char *result;
+
+    result = (char *) xmlEncodeEntitiesReentrant(NULL, BAD_CAST buffer);
+    if (result) {
+	xmlGenericError(xmlGenericErrorContext, "%s", result);
+	xmlFree(result);
+    }
+    buffer[0] = 0;
+}
+
+/**
+ * xmlHTMLPrintFileInfo:
+ * @input:  an xmlParserInputPtr input
+ * 
+ * Displays the associated file and line informations for the current input
+ */
+
+static void
+xmlHTMLPrintFileInfo(xmlParserInputPtr input) {
+    int len;
+    xmlGenericError(xmlGenericErrorContext, "<p>");
+
+    len = strlen(buffer);
+    if (input != NULL) {
+	if (input->filename) {
+	    snprintf(&buffer[len], sizeof(buffer) - len, "%s:%d: ", input->filename,
+		    input->line);
+	} else {
+	    snprintf(&buffer[len], sizeof(buffer) - len, "Entity: line %d: ", input->line);
+	}
+    }
+    xmlHTMLEncodeSend();
+}
+
+/**
+ * xmlHTMLPrintFileContext:
+ * @input:  an xmlParserInputPtr input
+ * 
+ * Displays current context within the input content for error tracking
+ */
+
+static void
+xmlHTMLPrintFileContext(xmlParserInputPtr input) {
+    const xmlChar *cur, *base;
+    int len;
+    int n;
+
+    if (input == NULL) return;
+    xmlGenericError(xmlGenericErrorContext, "<pre>\n");
+    cur = input->cur;
+    base = input->base;
+    while ((cur > base) && ((*cur == '\n') || (*cur == '\r'))) {
+	cur--;
+    }
+    n = 0;
+    while ((n++ < 80) && (cur > base) && (*cur != '\n') && (*cur != '\r'))
+        cur--;
+    if ((*cur == '\n') || (*cur == '\r')) cur++;
+    base = cur;
+    n = 0;
+    while ((*cur != 0) && (*cur != '\n') && (*cur != '\r') && (n < 79)) {
+	len = strlen(buffer);
+        snprintf(&buffer[len], sizeof(buffer) - len, "%c", 
+		    (unsigned char) *cur++);
+	n++;
+    }
+    len = strlen(buffer);
+    snprintf(&buffer[len], sizeof(buffer) - len, "\n");
+    cur = input->cur;
+    while ((*cur == '\n') || (*cur == '\r'))
+	cur--;
+    n = 0;
+    while ((cur != base) && (n++ < 80)) {
+	len = strlen(buffer);
+        snprintf(&buffer[len], sizeof(buffer) - len, " ");
+        base++;
+    }
+    len = strlen(buffer);
+    snprintf(&buffer[len], sizeof(buffer) - len, "^\n");
+    xmlHTMLEncodeSend();
+    xmlGenericError(xmlGenericErrorContext, "</pre>");
+}
+
+/**
+ * xmlHTMLError:
+ * @ctx:  an XML parser context
+ * @msg:  the message to display/transmit
+ * @...:  extra parameters for the message display
+ * 
+ * Display and format an error messages, gives file, line, position and
+ * extra parameters.
+ */
+static void
+xmlHTMLError(void *ctx, const char *msg, ...)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+    xmlParserInputPtr input;
+    va_list args;
+    int len;
+
+    buffer[0] = 0;
+    input = ctxt->input;
+    if ((input != NULL) && (input->filename == NULL) && (ctxt->inputNr > 1)) {
+        input = ctxt->inputTab[ctxt->inputNr - 2];
+    }
+        
+    xmlHTMLPrintFileInfo(input);
+
+    xmlGenericError(xmlGenericErrorContext, "<b>error</b>: ");
+    va_start(args, msg);
+    len = strlen(buffer);
+    vsnprintf(&buffer[len],  sizeof(buffer) - len, msg, args);
+    va_end(args);
+    xmlHTMLEncodeSend();
+    xmlGenericError(xmlGenericErrorContext, "</p>\n");
+
+    xmlHTMLPrintFileContext(input);
+    xmlHTMLEncodeSend();
+}
+
+/**
+ * xmlHTMLWarning:
+ * @ctx:  an XML parser context
+ * @msg:  the message to display/transmit
+ * @...:  extra parameters for the message display
+ * 
+ * Display and format a warning messages, gives file, line, position and
+ * extra parameters.
+ */
+static void
+xmlHTMLWarning(void *ctx, const char *msg, ...)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+    xmlParserInputPtr input;
+    va_list args;
+    int len;
+
+    buffer[0] = 0;
+    input = ctxt->input;
+    if ((input != NULL) && (input->filename == NULL) && (ctxt->inputNr > 1)) {
+        input = ctxt->inputTab[ctxt->inputNr - 2];
+    }
+        
+
+    xmlHTMLPrintFileInfo(input);
+        
+    xmlGenericError(xmlGenericErrorContext, "<b>warning</b>: ");
+    va_start(args, msg);
+    len = strlen(buffer);    
+    vsnprintf(&buffer[len],  sizeof(buffer) - len, msg, args);
+    va_end(args);
+    xmlHTMLEncodeSend();
+    xmlGenericError(xmlGenericErrorContext, "</p>\n");
+
+    xmlHTMLPrintFileContext(input);
+    xmlHTMLEncodeSend();
+}
+
+/**
+ * xmlHTMLValidityError:
+ * @ctx:  an XML parser context
+ * @msg:  the message to display/transmit
+ * @...:  extra parameters for the message display
+ * 
+ * Display and format an validity error messages, gives file,
+ * line, position and extra parameters.
+ */
+static void
+xmlHTMLValidityError(void *ctx, const char *msg, ...)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+    xmlParserInputPtr input;
+    va_list args;
+    int len;
+
+    buffer[0] = 0;
+    input = ctxt->input;
+    if ((input->filename == NULL) && (ctxt->inputNr > 1))
+        input = ctxt->inputTab[ctxt->inputNr - 2];
+        
+    xmlHTMLPrintFileInfo(input);
+
+    xmlGenericError(xmlGenericErrorContext, "<b>validity error</b>: ");
+    len = strlen(buffer);
+    va_start(args, msg);
+    vsnprintf(&buffer[len],  sizeof(buffer) - len, msg, args);
+    va_end(args);
+    xmlHTMLEncodeSend();
+    xmlGenericError(xmlGenericErrorContext, "</p>\n");
+
+    xmlHTMLPrintFileContext(input);
+    xmlHTMLEncodeSend();
+}
+
+/**
+ * xmlHTMLValidityWarning:
+ * @ctx:  an XML parser context
+ * @msg:  the message to display/transmit
+ * @...:  extra parameters for the message display
+ * 
+ * Display and format a validity warning messages, gives file, line,
+ * position and extra parameters.
+ */
+static void
+xmlHTMLValidityWarning(void *ctx, const char *msg, ...)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+    xmlParserInputPtr input;
+    va_list args;
+    int len;
+
+    buffer[0] = 0;
+    input = ctxt->input;
+    if ((input->filename == NULL) && (ctxt->inputNr > 1))
+        input = ctxt->inputTab[ctxt->inputNr - 2];
+
+    xmlHTMLPrintFileInfo(input);
+        
+    xmlGenericError(xmlGenericErrorContext, "<b>validity warning</b>: ");
+    va_start(args, msg);
+    len = strlen(buffer); 
+    vsnprintf(&buffer[len],  sizeof(buffer) - len, msg, args);
+    va_end(args);
+    xmlHTMLEncodeSend();
+    xmlGenericError(xmlGenericErrorContext, "</p>\n");
+
+    xmlHTMLPrintFileContext(input);
+    xmlHTMLEncodeSend();
+}
+
+/************************************************************************
+ * 									*
+ * 			Shell Interface					*
+ * 									*
+ ************************************************************************/
+#ifdef LIBXML_DEBUG_ENABLED
+/**
+ * xmlShellReadline:
+ * @prompt:  the prompt value
+ *
+ * Read a string
+ * 
+ * Returns a pointer to it or NULL on EOF the caller is expected to
+ *     free the returned string.
+ */
+static char *
+xmlShellReadline(char *prompt) {
+#ifdef HAVE_LIBREADLINE
+    char *line_read;
+
+    /* Get a line from the user. */
+    line_read = readline (prompt);
+
+    /* If the line has any text in it, save it on the history. */
+    if (line_read && *line_read)
+	add_history (line_read);
+
+    return (line_read);
+#else
+    char line_read[501];
+    char *ret;
+    int len;
+
+    if (prompt != NULL)
+	fprintf(stdout, "%s", prompt);
+    if (!fgets(line_read, 500, stdin))
+        return(NULL);
+    line_read[500] = 0;
+    len = strlen(line_read);
+    ret = (char *) malloc(len + 1);
+    if (ret != NULL) {
+	memcpy (ret, line_read, len + 1);
+    }
+    return(ret);
+#endif
+}
+#endif /* LIBXML_DEBUG_ENABLED */
+
+/************************************************************************
+ * 									*
+ * 			I/O Interfaces					*
+ * 									*
+ ************************************************************************/
+
+static int myRead(FILE *f, char * buf, int len) {
+    return(fread(buf, 1, len, f));
+}
+static void myClose(FILE *f) {
+  if (f != stdin) {
+    fclose(f);
+  }
+}
+
+#ifdef LIBXML_READER_ENABLED
+/************************************************************************
+ * 									*
+ * 			Stream Test processing				*
+ * 									*
+ ************************************************************************/
+static void processNode(xmlTextReaderPtr reader) {
+    const xmlChar *name, *value;
+
+    name = xmlTextReaderConstName(reader);
+    if (name == NULL)
+	name = BAD_CAST "--";
+
+    value = xmlTextReaderConstValue(reader);
+
+    printf("%d %d %s %d %d", 
+	    xmlTextReaderDepth(reader),
+	    xmlTextReaderNodeType(reader),
+	    name,
+	    xmlTextReaderIsEmptyElement(reader),
+	    xmlTextReaderHasValue(reader));
+    if (value == NULL)
+	printf("\n");
+    else {
+	printf(" %s\n", value);
+    }
+#ifdef LIBXML_PATTERN_ENABLED
+    if (patternc) {
+        if (xmlPatternMatch(patternc, xmlTextReaderCurrentNode(reader)) == 1) {
+	    printf("Node matches pattern %s\n", pattern);
+	}
+    }
+#endif
+}
+
+static void streamFile(char *filename) {
+    xmlTextReaderPtr reader;
+    int ret;
+#ifdef HAVE_SYS_MMAN_H
+    int fd = -1;
+    struct stat info;
+    const char *base = NULL;
+    xmlParserInputBufferPtr input = NULL;
+
+    if (memory) {
+	if (stat(filename, &info) < 0) 
+	    return;
+	if ((fd = open(filename, O_RDONLY)) < 0)
+	    return;
+	base = mmap(NULL, info.st_size, PROT_READ, MAP_SHARED, fd, 0) ;
+	if (base == (void *) MAP_FAILED)
+	    return;
+
+	reader = xmlReaderForMemory(base, info.st_size, filename,
+	                            NULL, options);
+    } else
+#endif
+	reader = xmlReaderForFile(filename, NULL, options);
+
+
+    if (reader != NULL) {
+#ifdef LIBXML_VALID_ENABLED
+	if (valid)
+	    xmlTextReaderSetParserProp(reader, XML_PARSER_VALIDATE, 1);
+	else
+#endif /* LIBXML_VALID_ENABLED */
+	    xmlTextReaderSetParserProp(reader, XML_PARSER_LOADDTD, 1);
+#ifdef LIBXML_SCHEMAS_ENABLED
+	if (relaxng != NULL) {
+	    if ((timing) && (!repeat)) {
+		startTimer();
+	    }
+	    ret = xmlTextReaderRelaxNGValidate(reader, relaxng);
+	    if (ret < 0) {
+		xmlGenericError(xmlGenericErrorContext,
+			"Relax-NG schema %s failed to compile\n", relaxng);
+		progresult = 5;
+		relaxng = NULL;
+	    }
+	    if ((timing) && (!repeat)) {
+		endTimer("Compiling the schemas");
+	    }
+	}
+#endif
+
+	/*
+	 * Process all nodes in sequence
+	 */
+	if ((timing) && (!repeat)) {
+	    startTimer();
+	}
+	ret = xmlTextReaderRead(reader);
+	while (ret == 1) {
+	    if ((debug)
+#ifdef LIBXML_PATTERN_ENABLED
+	        || (patternc)
+#endif
+	       )
+		processNode(reader);
+	    ret = xmlTextReaderRead(reader);
+	}
+	if ((timing) && (!repeat)) {
+#ifdef LIBXML_SCHEMAS_ENABLED
+	    if (relaxng != NULL)
+		endTimer("Parsing and validating");
+	    else
+#endif
+#ifdef LIBXML_VALID_ENABLED
+	    if (valid)
+		endTimer("Parsing and validating");
+	    else
+#endif
+	    endTimer("Parsing");
+	}
+
+#ifdef LIBXML_VALID_ENABLED
+	if (valid) {
+	    if (xmlTextReaderIsValid(reader) != 1) {
+		xmlGenericError(xmlGenericErrorContext,
+			"Document %s does not validate\n", filename);
+		progresult = 3;
+	    }
+	}
+#endif /* LIBXML_VALID_ENABLED */
+#ifdef LIBXML_SCHEMAS_ENABLED
+	if (relaxng != NULL) {
+	    if (xmlTextReaderIsValid(reader) != 1) {
+		fprintf(stderr, "%s fails to validate\n", filename);
+		progresult = 3;
+	    } else {
+		fprintf(stderr, "%s validates\n", filename);
+	    }
+	}
+#endif
+	/*
+	 * Done, cleanup and status
+	 */
+	xmlFreeTextReader(reader);
+	if (ret != 0) {
+	    fprintf(stderr, "%s : failed to parse\n", filename);
+	    progresult = 1;
+	}
+    } else {
+	fprintf(stderr, "Unable to open %s\n", filename);
+	progresult = 1;
+    }
+#ifdef HAVE_SYS_MMAN_H
+    if (memory) {
+        xmlFreeParserInputBuffer(input);
+	munmap((char *) base, info.st_size);
+	close(fd);
+    }
+#endif
+}
+
+static void walkDoc(xmlDocPtr doc) {
+    xmlTextReaderPtr reader;
+    int ret;
+
+    reader = xmlReaderWalker(doc);
+    if (reader != NULL) {
+	if ((timing) && (!repeat)) {
+	    startTimer();
+	}
+	ret = xmlTextReaderRead(reader);
+	while (ret == 1) {
+	    if ((debug)
+#ifdef LIBXML_PATTERN_ENABLED
+	        || (patternc)
+#endif
+	       )
+		processNode(reader);
+	    ret = xmlTextReaderRead(reader);
+	}
+	if ((timing) && (!repeat)) {
+	    endTimer("walking through the doc");
+	}
+	xmlFreeTextReader(reader);
+	if (ret != 0) {
+	    fprintf(stderr, "failed to walk through the doc\n");
+	    progresult = 1;
+	}
+    } else {
+	fprintf(stderr, "Failed to crate a reader from the document\n");
+	progresult = 1;
+    }
+}
+#endif /* LIBXML_READER_ENABLED */
+
+/************************************************************************
+ * 									*
+ * 			Tree Test processing				*
+ * 									*
+ ************************************************************************/
+static void parseAndPrintFile(char *filename, xmlParserCtxtPtr rectxt) {
+    xmlDocPtr doc = NULL;
+#ifdef LIBXML_TREE_ENABLED
+    xmlDocPtr tmp;
+#endif /* LIBXML_TREE_ENABLED */
+
+    if ((timing) && (!repeat))
+	startTimer();
+    
+
+#ifdef LIBXML_TREE_ENABLED
+    if (filename == NULL) {
+	if (generate) {
+	    xmlNodePtr n;
+
+	    doc = xmlNewDoc(BAD_CAST "1.0");
+	    n = xmlNewNode(NULL, BAD_CAST "info");
+	    xmlNodeSetContent(n, BAD_CAST "abc");
+	    xmlDocSetRootElement(doc, n);
+	}
+    }
+#endif /* LIBXML_TREE_ENABLED */
+#ifdef LIBXML_HTML_ENABLED
+#ifdef LIBXML_PUSH_ENABLED
+    else if ((html) && (push)) {
+        FILE *f;
+
+        f = fopen(filename, "r");
+        if (f != NULL) {
+            int res, size = 3;
+            char chars[4096];
+            htmlParserCtxtPtr ctxt;
+
+            /* if (repeat) */
+                size = 4096;
+            res = fread(chars, 1, 4, f);
+            if (res > 0) {
+                ctxt = htmlCreatePushParserCtxt(NULL, NULL,
+                            chars, res, filename, XML_CHAR_ENCODING_NONE);
+                while ((res = fread(chars, 1, size, f)) > 0) {
+                    htmlParseChunk(ctxt, chars, res, 0);
+                }
+                htmlParseChunk(ctxt, chars, 0, 1);
+                doc = ctxt->myDoc;
+                htmlFreeParserCtxt(ctxt);
+            }
+            fclose(f);
+        }
+    }
+#endif /* LIBXML_PUSH_ENABLED */
+    else if (html) {
+	doc = htmlReadFile(filename, NULL, options);
+    }
+#endif /* LIBXML_HTML_ENABLED */
+    else {
+#ifdef LIBXML_PUSH_ENABLED
+	/*
+	 * build an XML tree from a string;
+	 */
+	if (push) {
+	    FILE *f;
+
+	    /* '-' Usually means stdin -<sven@zen.org> */
+	    if ((filename[0] == '-') && (filename[1] == 0)) {
+	      f = stdin;
+	    } else {
+	      f = fopen(filename, "r");
+	    }
+	    if (f != NULL) {
+		int ret;
+	        int res, size = 1024;
+	        char chars[1024];
+                xmlParserCtxtPtr ctxt;
+
+		/* if (repeat) size = 1024; */
+		res = fread(chars, 1, 4, f);
+		if (res > 0) {
+		    ctxt = xmlCreatePushParserCtxt(NULL, NULL,
+		                chars, res, filename);
+		    xmlCtxtUseOptions(ctxt, options);
+		    while ((res = fread(chars, 1, size, f)) > 0) {
+			xmlParseChunk(ctxt, chars, res, 0);
+		    }
+		    xmlParseChunk(ctxt, chars, 0, 1);
+		    doc = ctxt->myDoc;
+		    ret = ctxt->wellFormed;
+		    xmlFreeParserCtxt(ctxt);
+		    if (!ret) {
+			xmlFreeDoc(doc);
+			doc = NULL;
+		    }
+	        }
+	    }
+	} else
+#endif /* LIBXML_PUSH_ENABLED */
+        if (testIO) {
+	    if ((filename[0] == '-') && (filename[1] == 0)) {
+	        doc = xmlReadFd(0, NULL, NULL, options);
+	    } else {
+	        FILE *f;
+
+		f = fopen(filename, "r");
+		if (f != NULL) {
+		    if (rectxt == NULL)
+			doc = xmlReadIO((xmlInputReadCallback) myRead,
+					(xmlInputCloseCallback) myClose, f,
+					filename, NULL, options);
+		    else
+			doc = xmlCtxtReadIO(rectxt,
+			                (xmlInputReadCallback) myRead,
+					(xmlInputCloseCallback) myClose, f,
+					filename, NULL, options);
+		} else
+		    doc = NULL;
+	    }
+	} else if (htmlout) {
+	    xmlParserCtxtPtr ctxt;
+
+	    if (rectxt == NULL)
+		ctxt = xmlNewParserCtxt();
+	    else
+	        ctxt = rectxt;
+	    if (ctxt == NULL) {	      
+	        doc = NULL;
+	    } else {
+	        ctxt->sax->error = xmlHTMLError;
+	        ctxt->sax->warning = xmlHTMLWarning;
+	        ctxt->vctxt.error = xmlHTMLValidityError;
+	        ctxt->vctxt.warning = xmlHTMLValidityWarning;
+
+		doc = xmlCtxtReadFile(ctxt, filename, NULL, options);
+
+		if (rectxt == NULL)
+		    xmlFreeParserCtxt(ctxt);
+	    }
+#ifdef HAVE_SYS_MMAN_H
+	} else if (memory) {
+	    int fd;
+	    struct stat info;
+	    const char *base;
+	    if (stat(filename, &info) < 0) 
+		return;
+	    if ((fd = open(filename, O_RDONLY)) < 0)
+		return;
+	    base = mmap(NULL, info.st_size, PROT_READ, MAP_SHARED, fd, 0) ;
+	    if (base == (void *) MAP_FAILED)
+	        return;
+
+	    if (rectxt == NULL)
+		doc = xmlReadMemory((char *) base, info.st_size,
+		                    filename, NULL, options);
+	    else
+		doc = xmlCtxtReadMemory(rectxt, (char *) base, info.st_size,
+			                filename, NULL, options);
+	        
+	    munmap((char *) base, info.st_size);
+#endif
+#ifdef LIBXML_VALID_ENABLED
+	} else if (valid) {
+	    xmlParserCtxtPtr ctxt = NULL;
+
+	    if (rectxt == NULL)
+		ctxt = xmlNewParserCtxt();
+	    else
+	        ctxt = rectxt;
+	    if (ctxt == NULL) {	      
+	        doc = NULL;
+	    } else {
+		doc = xmlCtxtReadFile(ctxt, filename, NULL, options);
+
+		if (ctxt->valid == 0)
+		    progresult = 4;
+		if (rectxt == NULL)
+		    xmlFreeParserCtxt(ctxt);
+	    }
+#endif /* LIBXML_VALID_ENABLED */
+	} else {
+	    if (rectxt != NULL)
+	        doc = xmlCtxtReadFile(rectxt, filename, NULL, options);
+	    else
+		doc = xmlReadFile(filename, NULL, options);
+	}
+    }
+
+    /*
+     * If we don't have a document we might as well give up.  Do we
+     * want an error message here?  <sven@zen.org> */
+    if (doc == NULL) {
+	progresult = 1;
+	return;
+    }
+
+    if ((timing) && (!repeat)) {
+	endTimer("Parsing");
+    }
+
+    /*
+     * Remove DOCTYPE nodes
+     */
+    if (dropdtd) {
+	xmlDtdPtr dtd;
+
+	dtd = xmlGetIntSubset(doc);
+	if (dtd != NULL) {
+	    xmlUnlinkNode((xmlNodePtr)dtd);
+	    xmlFreeDtd(dtd);
+	}
+    }
+
+#ifdef LIBXML_XINCLUDE_ENABLED
+    if (xinclude) {
+	if ((timing) && (!repeat)) {
+	    startTimer();
+	}
+	xmlXIncludeProcessFlags(doc, options);
+	if ((timing) && (!repeat)) {
+	    endTimer("Xinclude processing");
+	}
+    }
+#endif
+
+#ifdef LIBXML_DEBUG_ENABLED
+    /*
+     * shell interaction
+     */
+    if (shell)  
+        xmlShell(doc, filename, xmlShellReadline, stdout);
+#endif
+
+#ifdef LIBXML_TREE_ENABLED
+    /*
+     * test intermediate copy if needed.
+     */
+    if (copy) {
+        tmp = doc;
+	doc = xmlCopyDoc(doc, 1);
+	xmlFreeDoc(tmp);
+    }
+#endif /* LIBXML_TREE_ENABLED */
+
+#ifdef LIBXML_VALID_ENABLED
+    if ((insert) && (!html)) {
+        const xmlChar* list[256];
+	int nb, i;
+	xmlNodePtr node;
+
+	if (doc->children != NULL) {
+	    node = doc->children;
+	    while ((node != NULL) && (node->last == NULL)) node = node->next;
+	    if (node != NULL) {
+		nb = xmlValidGetValidElements(node->last, NULL, list, 256);
+		if (nb < 0) {
+		    fprintf(stderr, "could not get valid list of elements\n");
+		} else if (nb == 0) {
+		    fprintf(stderr, "No element can be inserted under root\n");
+		} else {
+		    fprintf(stderr, "%d element types can be inserted under root:\n",
+		           nb);
+		    for (i = 0;i < nb;i++) {
+			 fprintf(stderr, "%s\n", (char *) list[i]);
+		    }
+		}
+	    }
+	}    
+    }else
+#endif /* LIBXML_VALID_ENABLED */
+#ifdef LIBXML_READER_ENABLED
+    if (walker) {
+        walkDoc(doc);
+    }
+#endif /* LIBXML_READER_ENABLED */
+#ifdef LIBXML_OUTPUT_ENABLED
+    if (noout == 0) {
+        int ret;
+
+	/*
+	 * print it.
+	 */
+#ifdef LIBXML_DEBUG_ENABLED
+	if (!debug) {
+#endif
+	    if ((timing) && (!repeat)) {
+		startTimer();
+	    }
+#ifdef LIBXML_VALID_ENABLED
+            if ((html) && (!xmlout)) {
+		if (compress) {
+		    htmlSaveFile(output ? output : "-", doc);
+		}
+		else if (encoding != NULL) {
+		    if ( format ) {
+			htmlSaveFileFormat(output ? output : "-", doc, encoding, 1);
+		    }
+		    else {
+			htmlSaveFileFormat(output ? output : "-", doc, encoding, 0);
+		    }
+		}
+		else if (format) {
+		    htmlSaveFileFormat(output ? output : "-", doc, NULL, 1);
+		}
+		else {
+		    FILE *out;
+		    if (output == NULL)
+			out = stdout;
+		    else {
+			out = fopen(output,"wb");
+		    }
+		    if (out != NULL) {
+			if (htmlDocDump(out, doc) < 0)
+			    progresult = 6;
+
+			if (output != NULL)
+			    fclose(out);
+		    } else {
+			fprintf(stderr, "failed to open %s\n", output);
+			progresult = 6;
+		    }
+		}
+		if ((timing) && (!repeat)) {
+		    endTimer("Saving");
+		}
+	    } else
+#endif
+#ifdef HAVE_SYS_MMAN_H
+	    if (memory) {
+		xmlChar *result;
+		int len;
+
+		if (encoding != NULL) {
+		    if ( format ) {
+		        xmlDocDumpFormatMemoryEnc(doc, &result, &len, encoding, 1);
+		    } else { 
+			xmlDocDumpMemoryEnc(doc, &result, &len, encoding);
+		    }
+		} else {
+		    if (format)
+			xmlDocDumpFormatMemory(doc, &result, &len, 1);
+		    else
+			xmlDocDumpMemory(doc, &result, &len);
+		}
+		if (result == NULL) {
+		    fprintf(stderr, "Failed to save\n");
+		} else {
+		    write(1, result, len);
+		    xmlFree(result);
+		}
+	    } else
+#endif /* HAVE_SYS_MMAN_H */
+	    if (compress) {
+		xmlSaveFile(output ? output : "-", doc);
+	    }
+	    else if (encoding != NULL) {
+	        if ( format ) {
+		    ret = xmlSaveFormatFileEnc(output ? output : "-", doc,
+		                               encoding, 1);
+		}
+		else {
+		    ret = xmlSaveFileEnc(output ? output : "-", doc, encoding);
+		}
+		if (ret < 0) {
+		    fprintf(stderr, "failed save to %s\n",
+		            output ? output : "-");
+		    progresult = 6;
+		}
+	    }
+	    else if (format) {
+		ret = xmlSaveFormatFile(output ? output : "-", doc, 1);
+		if (ret < 0) {
+		    fprintf(stderr, "failed save to %s\n",
+		            output ? output : "-");
+		    progresult = 6;
+		}
+	    }
+	    else {
+		FILE *out;
+		if (output == NULL)
+		    out = stdout;
+		else {
+		    out = fopen(output,"wb");
+		}
+		if (out != NULL) {
+		    if (xmlDocDump(out, doc) < 0)
+		        progresult = 6;
+
+		    if (output != NULL)
+			fclose(out);
+		} else {
+		    fprintf(stderr, "failed to open %s\n", output);
+		    progresult = 6;
+		}
+	    }
+	    if ((timing) && (!repeat)) {
+		endTimer("Saving");
+	    }
+#ifdef LIBXML_DEBUG_ENABLED
+	} else {
+	    FILE *out;
+	    if (output == NULL)
+	        out = stdout;
+	    else {
+		out = fopen(output,"wb");
+	    }
+	    if (out != NULL) {
+		xmlDebugDumpDocument(out, doc);
+
+		if (output != NULL)
+		    fclose(out);
+	    } else {
+		fprintf(stderr, "failed to open %s\n", output);
+		progresult = 6;
+	    }
+	}
+#endif
+    }
+#endif /* LIBXML_OUTPUT_ENABLED */
+
+#ifdef LIBXML_VALID_ENABLED
+    /*
+     * A posteriori validation test
+     */
+    if ((dtdvalid != NULL) || (dtdvalidfpi != NULL)) {
+	xmlDtdPtr dtd;
+
+	if ((timing) && (!repeat)) {
+	    startTimer();
+	}
+	if (dtdvalid != NULL)
+	    dtd = xmlParseDTD(NULL, (const xmlChar *)dtdvalid); 
+	else
+	    dtd = xmlParseDTD((const xmlChar *)dtdvalidfpi, NULL); 
+	if ((timing) && (!repeat)) {
+	    endTimer("Parsing DTD");
+	}
+	if (dtd == NULL) {
+	    if (dtdvalid != NULL)
+		xmlGenericError(xmlGenericErrorContext,
+			"Could not parse DTD %s\n", dtdvalid);
+	    else
+		xmlGenericError(xmlGenericErrorContext,
+			"Could not parse DTD %s\n", dtdvalidfpi);
+	    progresult = 2;
+	} else {
+	    xmlValidCtxtPtr cvp;
+
+	    if ((cvp = xmlNewValidCtxt()) == NULL) {
+		xmlGenericError(xmlGenericErrorContext,
+			"Couldn't allocate validation context\n");
+		exit(-1);
+	    }
+	    cvp->userData = (void *) stderr;
+	    cvp->error    = (xmlValidityErrorFunc) fprintf;
+	    cvp->warning  = (xmlValidityWarningFunc) fprintf;
+
+	    if ((timing) && (!repeat)) {
+		startTimer();
+	    }
+	    if (!xmlValidateDtd(cvp, doc, dtd)) {
+		if (dtdvalid != NULL)
+		    xmlGenericError(xmlGenericErrorContext,
+			    "Document %s does not validate against %s\n",
+			    filename, dtdvalid);
+		else
+		    xmlGenericError(xmlGenericErrorContext,
+			    "Document %s does not validate against %s\n",
+			    filename, dtdvalidfpi);
+		progresult = 3;
+	    }
+	    if ((timing) && (!repeat)) {
+		endTimer("Validating against DTD");
+	    }
+	    xmlFreeValidCtxt(cvp);
+	    xmlFreeDtd(dtd);
+	}
+    } else if (postvalid) {
+	xmlValidCtxtPtr cvp;
+
+	if ((cvp = xmlNewValidCtxt()) == NULL) {
+	    xmlGenericError(xmlGenericErrorContext,
+		    "Couldn't allocate validation context\n");
+	    exit(-1);
+	}
+
+	if ((timing) && (!repeat)) {
+	    startTimer();
+	}
+	cvp->userData = (void *) stderr;
+	cvp->error    = (xmlValidityErrorFunc) fprintf;
+	cvp->warning  = (xmlValidityWarningFunc) fprintf;
+	if (!xmlValidateDocument(cvp, doc)) {
+	    xmlGenericError(xmlGenericErrorContext,
+		    "Document %s does not validate\n", filename);
+	    progresult = 3;
+	}
+	if ((timing) && (!repeat)) {
+	    endTimer("Validating");
+	}
+	xmlFreeValidCtxt(cvp);
+    }
+#endif /* LIBXML_VALID_ENABLED */
+#ifdef LIBXML_SCHEMAS_ENABLED
+    if (relaxngschemas != NULL) {
+	xmlRelaxNGValidCtxtPtr ctxt;
+	int ret;
+
+	if ((timing) && (!repeat)) {
+	    startTimer();
+	}
+
+	ctxt = xmlRelaxNGNewValidCtxt(relaxngschemas);
+	xmlRelaxNGSetValidErrors(ctxt,
+		(xmlRelaxNGValidityErrorFunc) fprintf,
+		(xmlRelaxNGValidityWarningFunc) fprintf,
+		stderr);
+	ret = xmlRelaxNGValidateDoc(ctxt, doc);
+	if (ret == 0) {
+	    fprintf(stderr, "%s validates\n", filename);
+	} else if (ret > 0) {
+	    fprintf(stderr, "%s fails to validate\n", filename);
+	} else {
+	    fprintf(stderr, "%s validation generated an internal error\n",
+		   filename);
+	}
+	xmlRelaxNGFreeValidCtxt(ctxt);
+	if ((timing) && (!repeat)) {
+	    endTimer("Validating");
+	}
+    } else if (wxschemas != NULL) {
+	xmlSchemaValidCtxtPtr ctxt;
+	int ret;
+
+	if ((timing) && (!repeat)) {
+	    startTimer();
+	}
+
+	ctxt = xmlSchemaNewValidCtxt(wxschemas);
+	xmlSchemaSetValidErrors(ctxt,
+		(xmlSchemaValidityErrorFunc) fprintf,
+		(xmlSchemaValidityWarningFunc) fprintf,
+		stderr);
+	ret = xmlSchemaValidateDoc(ctxt, doc);
+	if (ret == 0) {
+	    fprintf(stderr, "%s validates\n", filename);
+	} else if (ret > 0) {
+	    fprintf(stderr, "%s fails to validate\n", filename);
+	} else {
+	    fprintf(stderr, "%s validation generated an internal error\n",
+		   filename);
+	}
+	xmlSchemaFreeValidCtxt(ctxt);
+	if ((timing) && (!repeat)) {
+	    endTimer("Validating");
+	}
+    }
+#endif
+
+#ifdef LIBXML_DEBUG_ENABLED
+    if ((debugent) && (!html))
+	xmlDebugDumpEntities(stderr, doc);
+#endif
+
+    /*
+     * free it.
+     */
+    if ((timing) && (!repeat)) {
+	startTimer();
+    }
+    xmlFreeDoc(doc);
+    if ((timing) && (!repeat)) {
+	endTimer("Freeing");
+    }
+}
+
+/************************************************************************
+ * 									*
+ * 			Usage and Main					*
+ * 									*
+ ************************************************************************/
+
+static void showVersion(const char *name) {
+    fprintf(stderr, "%s: using libxml version %s\n", name, xmlParserVersion);
+    fprintf(stderr, "   compiled with: ");
+#ifdef LIBXML_VALID_ENABLED
+    fprintf(stderr, "DTDValid ");
+#endif
+#ifdef LIBXML_FTP_ENABLED
+    fprintf(stderr, "FTP ");
+#endif
+#ifdef LIBXML_HTTP_ENABLED
+    fprintf(stderr, "HTTP ");
+#endif
+#ifdef LIBXML_HTML_ENABLED
+    fprintf(stderr, "HTML ");
+#endif
+#ifdef LIBXML_C14N_ENABLED
+    fprintf(stderr, "C14N ");
+#endif
+#ifdef LIBXML_CATALOG_ENABLED
+    fprintf(stderr, "Catalog ");
+#endif
+#ifdef LIBXML_XPATH_ENABLED
+    fprintf(stderr, "XPath ");
+#endif
+#ifdef LIBXML_XPTR_ENABLED
+    fprintf(stderr, "XPointer ");
+#endif
+#ifdef LIBXML_XINCLUDE_ENABLED
+    fprintf(stderr, "XInclude ");
+#endif
+#ifdef LIBXML_ICONV_ENABLED
+    fprintf(stderr, "Iconv ");
+#endif
+#ifdef DEBUG_MEMORY_LOCATION
+    fprintf(stderr, "MemDebug ");
+#endif
+#ifdef LIBXML_UNICODE_ENABLED
+    fprintf(stderr, "Unicode ");
+#endif
+#ifdef LIBXML_REGEXP_ENABLED
+    fprintf(stderr, "Regexps ");
+#endif
+#ifdef LIBXML_AUTOMATA_ENABLED
+    fprintf(stderr, "Automata ");
+#endif
+#ifdef LIBXML_SCHEMAS_ENABLED
+    fprintf(stderr, "Schemas ");
+#endif
+    fprintf(stderr, "\n");
+}
+
+static void usage(const char *name) {
+    printf("Usage : %s [options] XMLfiles ...\n", name);
+#ifdef LIBXML_OUTPUT_ENABLED
+    printf("\tParse the XML files and output the result of the parsing\n");
+#else
+    printf("\tParse the XML files\n");
+#endif /* LIBXML_OUTPUT_ENABLED */
+    printf("\t--version : display the version of the XML library used\n");
+#ifdef LIBXML_DEBUG_ENABLED
+    printf("\t--debug : dump a debug tree of the in-memory document\n");
+    printf("\t--shell : run a navigating shell\n");
+    printf("\t--debugent : debug the entities defined in the document\n");
+#else
+#ifdef LIBXML_READER_ENABLED
+    printf("\t--debug : dump the nodes content when using --stream\n");
+#endif /* LIBXML_READER_ENABLED */
+#endif
+#ifdef LIBXML_TREE_ENABLED
+    printf("\t--copy : used to test the internal copy implementation\n");
+#endif /* LIBXML_TREE_ENABLED */
+    printf("\t--recover : output what was parsable on broken XML documents\n");
+    printf("\t--noent : substitute entity references by their value\n");
+    printf("\t--noout : don't output the result tree\n");
+    printf("\t--nonet : refuse to fetch DTDs or entities over network\n");
+    printf("\t--htmlout : output results as HTML\n");
+    printf("\t--nowrap : do not put HTML doc wrapper\n");
+#ifdef LIBXML_VALID_ENABLED
+    printf("\t--valid : validate the document in addition to std well-formed check\n");
+    printf("\t--postvalid : do a posteriori validation, i.e after parsing\n");
+    printf("\t--dtdvalid URL : do a posteriori validation against a given DTD\n");
+    printf("\t--dtdvalidfpi FPI : same but name the DTD with a Public Identifier\n");
+#endif /* LIBXML_VALID_ENABLED */
+    printf("\t--timing : print some timings\n");
+    printf("\t--output file or -o file: save to a given file\n");
+    printf("\t--repeat : repeat 100 times, for timing or profiling\n");
+    printf("\t--insert : ad-hoc test for valid insertions\n");
+#ifdef LIBXML_OUTPUT_ENABLED
+#ifdef HAVE_ZLIB_H
+    printf("\t--compress : turn on gzip compression of output\n");
+#endif
+#endif /* LIBXML_OUTPUT_ENABLED */
+#ifdef LIBXML_HTML_ENABLED
+    printf("\t--html : use the HTML parser\n");
+    printf("\t--xmlout : force to use the XML serializer when using --html\n");
+#endif
+#ifdef LIBXML_PUSH_ENABLED
+    printf("\t--push : use the push mode of the parser\n");
+#endif /* LIBXML_PUSH_ENABLED */
+#ifdef HAVE_SYS_MMAN_H
+    printf("\t--memory : parse from memory\n");
+#endif
+    printf("\t--nowarning : do not emit warnings from parser/validator\n");
+    printf("\t--noblanks : drop (ignorable?) blanks spaces\n");
+    printf("\t--nocdata : replace cdata section with text nodes\n");
+#ifdef LIBXML_OUTPUT_ENABLED
+    printf("\t--format : reformat/reindent the input\n");
+    printf("\t--encode encoding : output in the given encoding\n");
+    printf("\t--dropdtd : remove the DOCTYPE of the input docs\n");
+#endif /* LIBXML_OUTPUT_ENABLED */
+    printf("\t--nsclean : remove redundant namespace declarations\n");
+    printf("\t--testIO : test user I/O support\n");
+#ifdef LIBXML_CATALOG_ENABLED
+    printf("\t--catalogs : use SGML catalogs from $SGML_CATALOG_FILES\n");
+    printf("\t             otherwise XML Catalogs starting from \n");
+    printf("\t         %s are activated by default\n", XML_XML_DEFAULT_CATALOG);
+    printf("\t--nocatalogs: deactivate all catalogs\n");
+#endif
+    printf("\t--auto : generate a small doc on the fly\n");
+#ifdef LIBXML_XINCLUDE_ENABLED
+    printf("\t--xinclude : do XInclude processing\n");
+#endif
+    printf("\t--loaddtd : fetch external DTD\n");
+    printf("\t--dtdattr : loaddtd + populate the tree with inherited attributes \n");
+#ifdef LIBXML_READER_ENABLED
+    printf("\t--stream : use the streaming interface to process very large files\n");
+    printf("\t--walker : create a reader and walk though the resulting doc\n");
+#endif /* LIBXML_READER_ENABLED */
+#ifdef LIBXML_PATTERN_ENABLED
+    printf("\t--pattern pattern_value : test the pattern support\n");
+#endif
+    printf("\t--chkregister : verify the node registration code\n");
+#ifdef LIBXML_SCHEMAS_ENABLED
+    printf("\t--relaxng schema : do RelaxNG validation against the schema\n");
+    printf("\t--schema schema : do validation against the WXS schema\n");
+#endif
+    printf("\nLibxml project home page: http://xmlsoft.org/\n");
+    printf("To report bugs or get some help check: http://xmlsoft.org/bugs.html\n");
+}
+
+static void registerNode(xmlNodePtr node)
+{
+    node->_private = malloc(sizeof(long));
+    *(long*)node->_private = (long) 0x81726354;
+}
+
+static void deregisterNode(xmlNodePtr node)
+{
+    assert(node->_private != NULL);
+    assert(*(long*)node->_private == (long) 0x81726354);
+    free(node->_private);
+}
+
+int
+main(int argc, char **argv) {
+    int i, acount;
+    int files = 0;
+    int version = 0;
+    const char* indent;
+    
+    if (argc <= 1) {
+	usage(argv[0]);
+	return(1);
+    }
+    LIBXML_TEST_VERSION
+    for (i = 1; i < argc ; i++) {
+	if (!strcmp(argv[i], "-"))
+	    break;
+
+	if (argv[i][0] != '-')
+	    continue;
+	if ((!strcmp(argv[i], "-debug")) || (!strcmp(argv[i], "--debug")))
+	    debug++;
+	else
+#ifdef LIBXML_DEBUG_ENABLED
+	if ((!strcmp(argv[i], "-shell")) ||
+	         (!strcmp(argv[i], "--shell"))) {
+	    shell++;
+            noout = 1;
+        } else 
+#endif
+#ifdef LIBXML_TREE_ENABLED
+	if ((!strcmp(argv[i], "-copy")) || (!strcmp(argv[i], "--copy")))
+	    copy++;
+	else
+#endif /* LIBXML_TREE_ENABLED */
+	if ((!strcmp(argv[i], "-recover")) ||
+	         (!strcmp(argv[i], "--recover"))) {
+	    recovery++;
+	    options |= XML_PARSE_RECOVER;
+	} else if ((!strcmp(argv[i], "-noent")) ||
+	         (!strcmp(argv[i], "--noent"))) {
+	    noent++;
+	    options |= XML_PARSE_NOENT;
+	} else if ((!strcmp(argv[i], "-nsclean")) ||
+	         (!strcmp(argv[i], "--nsclean"))) {
+	    options |= XML_PARSE_NSCLEAN;
+	} else if ((!strcmp(argv[i], "-nocdata")) ||
+	         (!strcmp(argv[i], "--nocdata"))) {
+	    options |= XML_PARSE_NOCDATA;
+	} else if ((!strcmp(argv[i], "-nodict")) ||
+	         (!strcmp(argv[i], "--nodict"))) {
+	    options |= XML_PARSE_NODICT;
+	} else if ((!strcmp(argv[i], "-version")) ||
+	         (!strcmp(argv[i], "--version"))) {
+	    showVersion(argv[0]);
+	    version = 1;
+	} else if ((!strcmp(argv[i], "-noout")) ||
+	         (!strcmp(argv[i], "--noout")))
+	    noout++;
+#ifdef LIBXML_OUTPUT_ENABLED
+	else if ((!strcmp(argv[i], "-o")) ||
+	         (!strcmp(argv[i], "-output")) ||
+	         (!strcmp(argv[i], "--output"))) {
+	    i++;
+	    output = argv[i];
+	}
+#endif /* LIBXML_OUTPUT_ENABLED */
+	else if ((!strcmp(argv[i], "-htmlout")) ||
+	         (!strcmp(argv[i], "--htmlout")))
+	    htmlout++;
+	else if ((!strcmp(argv[i], "-nowrap")) ||
+	         (!strcmp(argv[i], "--nowrap")))
+	    nowrap++;
+#ifdef LIBXML_HTML_ENABLED
+	else if ((!strcmp(argv[i], "-html")) ||
+	         (!strcmp(argv[i], "--html"))) {
+	    html++;
+        }
+	else if ((!strcmp(argv[i], "-xmlout")) ||
+	         (!strcmp(argv[i], "--xmlout"))) {
+	    xmlout++;
+        }
+#endif /* LIBXML_HTML_ENABLED */
+	else if ((!strcmp(argv[i], "-loaddtd")) ||
+	         (!strcmp(argv[i], "--loaddtd"))) {
+	    loaddtd++;
+	    options |= XML_PARSE_DTDLOAD;
+	} else if ((!strcmp(argv[i], "-dtdattr")) ||
+	         (!strcmp(argv[i], "--dtdattr"))) {
+	    loaddtd++;
+	    dtdattrs++;
+	    options |= XML_PARSE_DTDATTR;
+	}
+#ifdef LIBXML_VALID_ENABLED
+	else if ((!strcmp(argv[i], "-valid")) ||
+	         (!strcmp(argv[i], "--valid"))) {
+	    valid++;
+	    options |= XML_PARSE_DTDVALID;
+	} else if ((!strcmp(argv[i], "-postvalid")) ||
+	         (!strcmp(argv[i], "--postvalid"))) {
+	    postvalid++;
+	    loaddtd++;
+	    options |= XML_PARSE_DTDLOAD;
+	} else if ((!strcmp(argv[i], "-dtdvalid")) ||
+	         (!strcmp(argv[i], "--dtdvalid"))) {
+	    i++;
+	    dtdvalid = argv[i];
+	    loaddtd++;
+	    options |= XML_PARSE_DTDLOAD;
+	} else if ((!strcmp(argv[i], "-dtdvalidfpi")) ||
+	         (!strcmp(argv[i], "--dtdvalidfpi"))) {
+	    i++;
+	    dtdvalidfpi = argv[i];
+	    loaddtd++;
+	    options |= XML_PARSE_DTDLOAD;
+        }
+#endif /* LIBXML_VALID_ENABLED */
+	else if ((!strcmp(argv[i], "-dropdtd")) ||
+	         (!strcmp(argv[i], "--dropdtd")))
+	    dropdtd++;
+	else if ((!strcmp(argv[i], "-insert")) ||
+	         (!strcmp(argv[i], "--insert")))
+	    insert++;
+	else if ((!strcmp(argv[i], "-timing")) ||
+	         (!strcmp(argv[i], "--timing")))
+	    timing++;
+	else if ((!strcmp(argv[i], "-auto")) ||
+	         (!strcmp(argv[i], "--auto")))
+	    generate++;
+	else if ((!strcmp(argv[i], "-repeat")) ||
+	         (!strcmp(argv[i], "--repeat"))) {
+	    if (repeat)
+	        repeat *= 10;
+	    else
+	        repeat = 100;
+	}
+#ifdef LIBXML_PUSH_ENABLED
+	else if ((!strcmp(argv[i], "-push")) ||
+	         (!strcmp(argv[i], "--push")))
+	    push++;
+#endif /* LIBXML_PUSH_ENABLED */
+#ifdef HAVE_SYS_MMAN_H
+	else if ((!strcmp(argv[i], "-memory")) ||
+	         (!strcmp(argv[i], "--memory")))
+	    memory++;
+#endif
+	else if ((!strcmp(argv[i], "-testIO")) ||
+	         (!strcmp(argv[i], "--testIO")))
+	    testIO++;
+#ifdef LIBXML_XINCLUDE_ENABLED
+	else if ((!strcmp(argv[i], "-xinclude")) ||
+	         (!strcmp(argv[i], "--xinclude"))) {
+	    xinclude++;
+	    options |= XML_PARSE_XINCLUDE;
+	}
+#endif
+#ifdef LIBXML_OUTPUT_ENABLED
+#ifdef HAVE_ZLIB_H
+	else if ((!strcmp(argv[i], "-compress")) ||
+	         (!strcmp(argv[i], "--compress"))) {
+	    compress++;
+	    xmlSetCompressMode(9);
+        }
+#endif
+#endif /* LIBXML_OUTPUT_ENABLED */
+	else if ((!strcmp(argv[i], "-nowarning")) ||
+	         (!strcmp(argv[i], "--nowarning"))) {
+	    xmlGetWarningsDefaultValue = 0;
+	    xmlPedanticParserDefault(0);
+	    options |= XML_PARSE_NOWARNING;
+        }
+	else if ((!strcmp(argv[i], "-pedantic")) ||
+	         (!strcmp(argv[i], "--pedantic"))) {
+	    xmlGetWarningsDefaultValue = 1;
+	    xmlPedanticParserDefault(1);
+	    options |= XML_PARSE_PEDANTIC;
+        }
+#ifdef LIBXML_DEBUG_ENABLED
+	else if ((!strcmp(argv[i], "-debugent")) ||
+		 (!strcmp(argv[i], "--debugent"))) {
+	    debugent++;
+	    xmlParserDebugEntities = 1;
+	} 
+#endif
+#ifdef LIBXML_CATALOG_ENABLED
+	else if ((!strcmp(argv[i], "-catalogs")) ||
+		 (!strcmp(argv[i], "--catalogs"))) {
+	    catalogs++;
+	} else if ((!strcmp(argv[i], "-nocatalogs")) ||
+		 (!strcmp(argv[i], "--nocatalogs"))) {
+	    nocatalogs++;
+	} 
+#endif
+	else if ((!strcmp(argv[i], "-encode")) ||
+	         (!strcmp(argv[i], "--encode"))) {
+	    i++;
+	    encoding = argv[i];
+	    /*
+	     * OK it's for testing purposes
+	     */
+	    xmlAddEncodingAlias("UTF-8", "DVEnc");
+        }
+	else if ((!strcmp(argv[i], "-noblanks")) ||
+	         (!strcmp(argv[i], "--noblanks"))) {
+	     noblanks++;
+	     xmlKeepBlanksDefault(0);
+        }
+	else if ((!strcmp(argv[i], "-format")) ||
+	         (!strcmp(argv[i], "--format"))) {
+	     noblanks++;
+#ifdef LIBXML_OUTPUT_ENABLED
+	     format++;
+#endif /* LIBXML_OUTPUT_ENABLED */
+	     xmlKeepBlanksDefault(0);
+	}
+#ifdef LIBXML_READER_ENABLED
+	else if ((!strcmp(argv[i], "-stream")) ||
+	         (!strcmp(argv[i], "--stream"))) {
+	     stream++;
+	}
+	else if ((!strcmp(argv[i], "-walker")) ||
+	         (!strcmp(argv[i], "--walker"))) {
+	     walker++;
+             noout++;
+	}
+#endif /* LIBXML_READER_ENABLED */
+#ifdef LIBXML_SAX1_ENABLED
+	else if ((!strcmp(argv[i], "-sax1")) ||
+	         (!strcmp(argv[i], "--sax1"))) {
+	     sax1++;
+	}
+#endif /* LIBXML_SAX1_ENABLED */
+	else if ((!strcmp(argv[i], "-chkregister")) ||
+	         (!strcmp(argv[i], "--chkregister"))) {
+	     chkregister++;
+#ifdef LIBXML_SCHEMAS_ENABLED
+	} else if ((!strcmp(argv[i], "-relaxng")) ||
+	         (!strcmp(argv[i], "--relaxng"))) {
+	    i++;
+	    relaxng = argv[i];
+	    noent++;
+	    options |= XML_PARSE_NOENT;
+	} else if ((!strcmp(argv[i], "-schema")) ||
+	         (!strcmp(argv[i], "--schema"))) {
+	    i++;
+	    schema = argv[i];
+	    noent++;
+#endif
+        } else if ((!strcmp(argv[i], "-nonet")) ||
+                   (!strcmp(argv[i], "--nonet"))) {
+	    options |= XML_PARSE_NONET;
+#ifdef LIBXML_PATTERN_ENABLED
+        } else if ((!strcmp(argv[i], "-pattern")) ||
+                   (!strcmp(argv[i], "--pattern"))) {
+	    i++;
+	    pattern = argv[i];
+#endif
+	} else {
+	    fprintf(stderr, "Unknown option %s\n", argv[i]);
+	    usage(argv[0]);
+	    return(1);
+	}
+    }
+
+#ifdef LIBXML_CATALOG_ENABLED
+    if (nocatalogs == 0) {
+	if (catalogs) {
+	    const char *catal;
+
+	    catal = getenv("SGML_CATALOG_FILES");
+	    if (catal != NULL) {
+		xmlLoadCatalogs(catal);
+	    } else {
+		fprintf(stderr, "Variable $SGML_CATALOG_FILES not set\n");
+	    }
+	}
+    }
+#endif
+
+#ifdef LIBXML_SAX1_ENABLED
+    if (sax1)
+        xmlSAXDefaultVersion(1);
+    else
+        xmlSAXDefaultVersion(2);
+#endif /* LIBXML_SAX1_ENABLED */
+
+    if (chkregister) {
+	xmlRegisterNodeDefault(registerNode);
+	xmlDeregisterNodeDefault(deregisterNode);
+    }
+    
+    indent = getenv("XMLLINT_INDENT");
+    if(indent != NULL) {
+	xmlTreeIndentString = indent;
+    }
+    
+
+    xmlLineNumbersDefault(1);
+    if (loaddtd != 0)
+	xmlLoadExtDtdDefaultValue |= XML_DETECT_IDS;
+    if (dtdattrs)
+	xmlLoadExtDtdDefaultValue |= XML_COMPLETE_ATTRS;
+    if (noent != 0) xmlSubstituteEntitiesDefault(1);
+#ifdef LIBXML_VALID_ENABLED
+    if (valid != 0) xmlDoValidityCheckingDefaultValue = 1;
+#endif /* LIBXML_VALID_ENABLED */
+    if ((htmlout) && (!nowrap)) {
+	xmlGenericError(xmlGenericErrorContext,
+         "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 Transitional//EN\"\n");
+	xmlGenericError(xmlGenericErrorContext,
+		"\t\"http://www.w3.org/TR/REC-html40/loose.dtd\">\n");
+	xmlGenericError(xmlGenericErrorContext,
+	 "<html><head><title>%s output</title></head>\n",
+		argv[0]);
+	xmlGenericError(xmlGenericErrorContext, 
+	 "<body bgcolor=\"#ffffff\"><h1 align=\"center\">%s output</h1>\n",
+		argv[0]);
+    }
+
+#ifdef LIBXML_SCHEMAS_ENABLED
+    if ((relaxng != NULL)
+#ifdef LIBXML_READER_ENABLED
+        && (stream == 0)
+#endif /* LIBXML_READER_ENABLED */
+	) {
+	xmlRelaxNGParserCtxtPtr ctxt;
+
+        /* forces loading the DTDs */
+        xmlLoadExtDtdDefaultValue |= 1; 
+	options |= XML_PARSE_DTDLOAD;
+	if (timing) {
+	    startTimer();
+	}
+	ctxt = xmlRelaxNGNewParserCtxt(relaxng);
+	xmlRelaxNGSetParserErrors(ctxt,
+		(xmlRelaxNGValidityErrorFunc) fprintf,
+		(xmlRelaxNGValidityWarningFunc) fprintf,
+		stderr);
+	relaxngschemas = xmlRelaxNGParse(ctxt);
+	if (relaxngschemas == NULL) {
+	    xmlGenericError(xmlGenericErrorContext,
+		    "Relax-NG schema %s failed to compile\n", relaxng);
+            progresult = 5;
+	    relaxng = NULL;
+	}
+	xmlRelaxNGFreeParserCtxt(ctxt);
+	if (timing) {
+	    endTimer("Compiling the schemas");
+	}
+    } else if ((schema != NULL)
+#ifdef LIBXML_READER_ENABLED
+		   	&& (stream == 0)
+#endif
+	) {
+	xmlSchemaParserCtxtPtr ctxt;
+
+	if (timing) {
+	    startTimer();
+	}
+	ctxt = xmlSchemaNewParserCtxt(schema);
+	xmlSchemaSetParserErrors(ctxt,
+		(xmlSchemaValidityErrorFunc) fprintf,
+		(xmlSchemaValidityWarningFunc) fprintf,
+		stderr);
+	wxschemas = xmlSchemaParse(ctxt);
+	if (wxschemas == NULL) {
+	    xmlGenericError(xmlGenericErrorContext,
+		    "WXS schema %s failed to compile\n", schema);
+            progresult = 5;
+	    schema = NULL;
+	}
+	xmlSchemaFreeParserCtxt(ctxt);
+	if (timing) {
+	    endTimer("Compiling the schemas");
+	}
+    }
+#endif /* LIBXML_SCHEMAS_ENABLED */
+#ifdef LIBXML_PATTERN_ENABLED
+    if (pattern != NULL) {
+        patternc = xmlPatterncompile((const xmlChar *) pattern, NULL, 0, NULL);
+	if (patternc == NULL) {
+	    xmlGenericError(xmlGenericErrorContext,
+		    "Pattern %s failed to compile\n", pattern);
+            progresult = 7;
+	    pattern = NULL;
+	}
+    }
+#endif /* LIBXML_PATTERN_ENABLED */
+    for (i = 1; i < argc ; i++) {
+	if ((!strcmp(argv[i], "-encode")) ||
+	         (!strcmp(argv[i], "--encode"))) {
+	    i++;
+	    continue;
+        } else if ((!strcmp(argv[i], "-o")) ||
+                   (!strcmp(argv[i], "-output")) ||
+                   (!strcmp(argv[i], "--output"))) {
+            i++;
+	    continue;
+        }
+#ifdef LIBXML_VALID_ENABLED
+	if ((!strcmp(argv[i], "-dtdvalid")) ||
+	         (!strcmp(argv[i], "--dtdvalid"))) {
+	    i++;
+	    continue;
+        }
+	if ((!strcmp(argv[i], "-dtdvalidfpi")) ||
+	         (!strcmp(argv[i], "--dtdvalidfpi"))) {
+	    i++;
+	    continue;
+        }
+#endif /* LIBXML_VALID_ENABLED */
+	if ((!strcmp(argv[i], "-relaxng")) ||
+	         (!strcmp(argv[i], "--relaxng"))) {
+	    i++;
+	    continue;
+        }
+	if ((!strcmp(argv[i], "-schema")) ||
+	         (!strcmp(argv[i], "--schema"))) {
+	    i++;
+	    continue;
+        }
+#ifdef LIBXML_PATTERN_ENABLED
+        if ((!strcmp(argv[i], "-pattern")) ||
+	    (!strcmp(argv[i], "--pattern"))) {
+	    i++;
+	    continue;
+	}
+#endif
+	if ((timing) && (repeat))
+	    startTimer();
+	/* Remember file names.  "-" means stdin.  <sven@zen.org> */
+	if ((argv[i][0] != '-') || (strcmp(argv[i], "-") == 0)) {
+	    if (repeat) {
+		xmlParserCtxtPtr ctxt = NULL;
+
+		for (acount = 0;acount < repeat;acount++) {
+#ifdef LIBXML_READER_ENABLED
+		    if (stream != 0) {
+			streamFile(argv[i]);
+		    } else {
+#endif /* LIBXML_READER_ENABLED */
+		        if (ctxt == NULL)
+			    ctxt = xmlNewParserCtxt();
+			parseAndPrintFile(argv[i], ctxt);
+#ifdef LIBXML_READER_ENABLED
+		    }
+#endif /* LIBXML_READER_ENABLED */
+		}
+		if (ctxt != NULL)
+		    xmlFreeParserCtxt(ctxt);
+	    } else {
+#ifdef LIBXML_READER_ENABLED
+		if (stream != 0)
+		    streamFile(argv[i]);
+		else
+#endif /* LIBXML_READER_ENABLED */
+		    parseAndPrintFile(argv[i], NULL);
+	    }
+	    files ++;
+	    if ((timing) && (repeat)) {
+		endTimer("%d iterations", repeat);
+	    }
+	}
+    }
+    if (generate) 
+	parseAndPrintFile(NULL, NULL);
+    if ((htmlout) && (!nowrap)) {
+	xmlGenericError(xmlGenericErrorContext, "</body></html>\n");
+    }
+    if ((files == 0) && (!generate) && (version == 0)) {
+	usage(argv[0]);
+    }
+#ifdef LIBXML_SCHEMAS_ENABLED
+    if (relaxngschemas != NULL)
+	xmlRelaxNGFree(relaxngschemas);
+    if (wxschemas != NULL)
+	xmlSchemaFree(wxschemas);
+    xmlRelaxNGCleanupTypes();
+#endif
+#ifdef LIBXML_PATTERN_ENABLED
+    if (patternc != NULL)
+        xmlFreePattern(patternc);
+#endif
+    xmlCleanupParser();
+    xmlMemoryDump();
+
+    return(progresult);
+}
+
diff --git a/src/libxml/src/xmlmemory.c b/src/libxml/src/xmlmemory.c
new file mode 100644
index 0000000..927d078
--- /dev/null
+++ b/src/libxml/src/xmlmemory.c
@@ -0,0 +1,950 @@
+/*
+ * xmlmemory.c:  libxml memory allocator wrapper.
+ *
+ * daniel@veillard.com
+ */
+
+#define IN_LIBXML
+#include "libxml.h"
+
+#include <string.h>
+
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+
+#ifdef HAVE_TIME_H
+#include <time.h>
+#endif
+
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#else
+#ifdef HAVE_MALLOC_H
+#include <malloc.h>
+#endif
+#endif
+
+#ifdef HAVE_CTYPE_H
+#include <ctype.h>
+#endif
+
+
+/**
+ * MEM_LIST:
+ *
+ * keep track of all allocated blocks for error reporting 
+ * Always build the memory list !
+ */
+#ifdef DEBUG_MEMORY_LOCATION
+#ifndef MEM_LIST
+#define MEM_LIST /* keep a list of all the allocated memory blocks */
+#endif
+#endif
+
+#include <libxml/xmlmemory.h>
+#include <libxml/globals.h>
+#include <libxml/xmlerror.h>
+#include <libxml/threads.h>
+
+static int xmlMemInitialized = 0;
+static unsigned long  debugMemSize = 0;
+static unsigned long  debugMaxMemSize = 0;
+static xmlMutexPtr xmlMemMutex = NULL;
+
+void xmlMallocBreakpoint(void);
+
+/************************************************************************
+ *									*
+ * 		Macros, variables and associated types			*
+ *									*
+ ************************************************************************/
+
+
+#ifdef xmlMalloc
+#undef xmlMalloc
+#endif
+#ifdef xmlRealloc
+#undef xmlRealloc
+#endif
+#ifdef xmlMemStrdup
+#undef xmlMemStrdup
+#endif
+
+
+/*
+ * Each of the blocks allocated begin with a header containing informations
+ */
+
+#define MEMTAG 0x5aa5
+
+#define MALLOC_TYPE 1
+#define REALLOC_TYPE 2
+#define STRDUP_TYPE 3
+#define MALLOC_ATOMIC_TYPE 4
+#define REALLOC_ATOMIC_TYPE 5
+
+typedef struct memnod {
+    unsigned int   mh_tag;
+    unsigned int   mh_type;
+    unsigned long  mh_number;
+    size_t         mh_size;
+#ifdef MEM_LIST
+   struct memnod *mh_next;
+   struct memnod *mh_prev;
+#endif
+   const char    *mh_file;
+   unsigned int   mh_line;
+}  MEMHDR;
+
+
+#ifdef SUN4
+#define ALIGN_SIZE  16
+#else
+#define ALIGN_SIZE  sizeof(double)
+#endif
+#define HDR_SIZE    sizeof(MEMHDR)
+#define RESERVE_SIZE (((HDR_SIZE + (ALIGN_SIZE-1)) \
+		      / ALIGN_SIZE ) * ALIGN_SIZE)
+
+
+#define CLIENT_2_HDR(a) ((MEMHDR *) (((char *) (a)) - RESERVE_SIZE))
+#define HDR_2_CLIENT(a)    ((void *) (((char *) (a)) + RESERVE_SIZE))
+
+
+static unsigned int block=0;
+static unsigned int xmlMemStopAtBlock = 0;
+static void *xmlMemTraceBlockAt = NULL;
+#ifdef MEM_LIST
+static MEMHDR *memlist = NULL;
+#endif
+
+static void debugmem_tag_error(void *addr);
+#ifdef MEM_LIST
+static void  debugmem_list_add(MEMHDR *);
+static void debugmem_list_delete(MEMHDR *);
+#endif
+#define Mem_Tag_Err(a) debugmem_tag_error(a);
+
+#ifndef TEST_POINT
+#define TEST_POINT
+#endif
+
+/**
+ * xmlMallocBreakpoint:
+ *
+ * Breakpoint to use in conjunction with xmlMemStopAtBlock. When the block
+ * number reaches the specified value this function is called. One need to add a breakpoint
+ * to it to get the context in which the given block is allocated.
+ */
+
+void
+xmlMallocBreakpoint(void) {
+    xmlGenericError(xmlGenericErrorContext,
+	    "xmlMallocBreakpoint reached on block %d\n", xmlMemStopAtBlock);
+}
+
+/**
+ * xmlMallocLoc:
+ * @size:  an int specifying the size in byte to allocate.
+ * @file:  the file name or NULL
+ * @line:  the line number
+ *
+ * a malloc() equivalent, with logging of the allocation info.
+ *
+ * Returns a pointer to the allocated area or NULL in case of lack of memory.
+ */
+
+void *
+xmlMallocLoc(size_t size, const char * file, int line)
+{
+    MEMHDR *p;
+    void *ret;
+    
+    if (!xmlMemInitialized) xmlInitMemory();
+#ifdef DEBUG_MEMORY
+    xmlGenericError(xmlGenericErrorContext,
+	    "Malloc(%d)\n",size);
+#endif
+
+    TEST_POINT
+    
+    p = (MEMHDR *) malloc(RESERVE_SIZE+size);
+
+    if (!p) {
+	xmlGenericError(xmlGenericErrorContext,
+		"xmlMallocLoc : Out of free space\n");
+	xmlMemoryDump();
+	return(NULL);
+    }   
+    p->mh_tag = MEMTAG;
+    p->mh_size = size;
+    p->mh_type = MALLOC_TYPE;
+    p->mh_file = file;
+    p->mh_line = line;
+    xmlMutexLock(xmlMemMutex);
+    p->mh_number = ++block;
+    debugMemSize += size;
+    if (debugMemSize > debugMaxMemSize) debugMaxMemSize = debugMemSize;
+#ifdef MEM_LIST
+    debugmem_list_add(p);
+#endif
+    xmlMutexUnlock(xmlMemMutex);
+    
+#ifdef DEBUG_MEMORY
+    xmlGenericError(xmlGenericErrorContext,
+	    "Malloc(%d) Ok\n",size);
+#endif
+    
+    if (xmlMemStopAtBlock == p->mh_number) xmlMallocBreakpoint();
+
+    ret = HDR_2_CLIENT(p);
+
+    if (xmlMemTraceBlockAt == ret) {
+	xmlGenericError(xmlGenericErrorContext,
+			"%p : Malloc(%d) Ok\n", xmlMemTraceBlockAt, size);
+	xmlMallocBreakpoint();
+    }
+
+    TEST_POINT
+
+    return(ret);
+}
+
+/**
+ * xmlMallocAtomicLoc:
+ * @size:  an int specifying the size in byte to allocate.
+ * @file:  the file name or NULL
+ * @line:  the line number
+ *
+ * a malloc() equivalent, with logging of the allocation info.
+ *
+ * Returns a pointer to the allocated area or NULL in case of lack of memory.
+ */
+
+void *
+xmlMallocAtomicLoc(size_t size, const char * file, int line)
+{
+    MEMHDR *p;
+    void *ret;
+    
+    if (!xmlMemInitialized) xmlInitMemory();
+#ifdef DEBUG_MEMORY
+    xmlGenericError(xmlGenericErrorContext,
+	    "Malloc(%d)\n",size);
+#endif
+
+    TEST_POINT
+    
+    p = (MEMHDR *) malloc(RESERVE_SIZE+size);
+
+    if (!p) {
+	xmlGenericError(xmlGenericErrorContext,
+		"xmlMallocLoc : Out of free space\n");
+	xmlMemoryDump();
+	return(NULL);
+    }   
+    p->mh_tag = MEMTAG;
+    p->mh_size = size;
+    p->mh_type = MALLOC_ATOMIC_TYPE;
+    p->mh_file = file;
+    p->mh_line = line;
+    xmlMutexLock(xmlMemMutex);
+    p->mh_number = ++block;
+    debugMemSize += size;
+    if (debugMemSize > debugMaxMemSize) debugMaxMemSize = debugMemSize;
+#ifdef MEM_LIST
+    debugmem_list_add(p);
+#endif
+    xmlMutexUnlock(xmlMemMutex);
+
+#ifdef DEBUG_MEMORY
+    xmlGenericError(xmlGenericErrorContext,
+	    "Malloc(%d) Ok\n",size);
+#endif
+    
+    if (xmlMemStopAtBlock == p->mh_number) xmlMallocBreakpoint();
+
+    ret = HDR_2_CLIENT(p);
+
+    if (xmlMemTraceBlockAt == ret) {
+	xmlGenericError(xmlGenericErrorContext,
+			"%p : Malloc(%d) Ok\n", xmlMemTraceBlockAt, size);
+	xmlMallocBreakpoint();
+    }
+
+    TEST_POINT
+
+    return(ret);
+}
+/**
+ * xmlMemMalloc:
+ * @size:  an int specifying the size in byte to allocate.
+ *
+ * a malloc() equivalent, with logging of the allocation info.
+ *
+ * Returns a pointer to the allocated area or NULL in case of lack of memory.
+ */
+
+void *
+xmlMemMalloc(size_t size)
+{
+    return(xmlMallocLoc(size, "none", 0));
+}
+
+/**
+ * xmlReallocLoc:
+ * @ptr:  the initial memory block pointer
+ * @size:  an int specifying the size in byte to allocate.
+ * @file:  the file name or NULL
+ * @line:  the line number
+ *
+ * a realloc() equivalent, with logging of the allocation info.
+ *
+ * Returns a pointer to the allocated area or NULL in case of lack of memory.
+ */
+
+void *
+xmlReallocLoc(void *ptr,size_t size, const char * file, int line)
+{
+    MEMHDR *p;
+    unsigned long number;
+
+    if (ptr == NULL)
+        return(xmlMallocLoc(size, file, line));
+
+    if (!xmlMemInitialized) xmlInitMemory();
+    TEST_POINT
+
+    p = CLIENT_2_HDR(ptr);
+    number = p->mh_number;
+    if (p->mh_tag != MEMTAG) {
+       Mem_Tag_Err(p);
+	 goto error;
+    }
+    p->mh_tag = ~MEMTAG;
+    xmlMutexLock(xmlMemMutex);
+    debugMemSize -= p->mh_size;
+#ifdef MEM_LIST
+    debugmem_list_delete(p);
+#endif
+    xmlMutexUnlock(xmlMemMutex);
+    
+    p = (MEMHDR *) realloc(p,RESERVE_SIZE+size);
+    if (!p) {
+	 goto error;
+    }
+    if (xmlMemTraceBlockAt == ptr) {
+	xmlGenericError(xmlGenericErrorContext,
+			"%p : Realloced(%d -> %d) Ok\n",
+			xmlMemTraceBlockAt, p->mh_size, size);
+	xmlMallocBreakpoint();
+    }
+    p->mh_tag = MEMTAG;
+    p->mh_number = number;
+    p->mh_type = REALLOC_TYPE;
+    p->mh_size = size;
+    p->mh_file = file;
+    p->mh_line = line;
+    xmlMutexLock(xmlMemMutex);
+    debugMemSize += size;
+    if (debugMemSize > debugMaxMemSize) debugMaxMemSize = debugMemSize;
+#ifdef MEM_LIST
+    debugmem_list_add(p);
+#endif
+    xmlMutexUnlock(xmlMemMutex);
+
+    TEST_POINT
+
+    return(HDR_2_CLIENT(p));
+    
+error:    
+    return(NULL);
+}
+
+/**
+ * xmlMemRealloc:
+ * @ptr:  the initial memory block pointer
+ * @size:  an int specifying the size in byte to allocate.
+ *
+ * a realloc() equivalent, with logging of the allocation info.
+ *
+ * Returns a pointer to the allocated area or NULL in case of lack of memory.
+ */
+
+void *
+xmlMemRealloc(void *ptr,size_t size) {
+    return(xmlReallocLoc(ptr, size, "none", 0));
+}
+
+/**
+ * xmlMemFree:
+ * @ptr:  the memory block pointer
+ *
+ * a free() equivalent, with error checking.
+ */
+void
+xmlMemFree(void *ptr)
+{
+    MEMHDR *p;
+    char *target;
+
+    if (ptr == (void *) -1) {
+	xmlGenericError(xmlGenericErrorContext,
+	    "trying to free pointer from freed area\n");
+        goto error;
+    }
+
+    if (xmlMemTraceBlockAt == ptr) {
+	xmlGenericError(xmlGenericErrorContext,
+			"%p : Freed()\n", xmlMemTraceBlockAt);
+	xmlMallocBreakpoint();
+    }
+
+    TEST_POINT
+
+    target = (char *) ptr;
+
+    p = CLIENT_2_HDR(ptr);
+    if (p->mh_tag != MEMTAG) {
+        Mem_Tag_Err(p);
+        goto error;
+    }
+    p->mh_tag = ~MEMTAG;
+    memset(target, -1, p->mh_size);
+    xmlMutexLock(xmlMemMutex);
+    debugMemSize -= p->mh_size;
+#ifdef MEM_LIST
+    debugmem_list_delete(p);
+#endif
+    xmlMutexUnlock(xmlMemMutex);
+
+    free(p);
+
+    TEST_POINT
+
+    return;
+    
+error:    
+    xmlGenericError(xmlGenericErrorContext,
+	    "xmlMemFree(%lX) error\n", (unsigned long) ptr);
+    xmlMallocBreakpoint();
+    return;
+}
+
+/**
+ * xmlMemStrdupLoc:
+ * @str:  the initial string pointer
+ * @file:  the file name or NULL
+ * @line:  the line number
+ *
+ * a strdup() equivalent, with logging of the allocation info.
+ *
+ * Returns a pointer to the new string or NULL if allocation error occurred.
+ */
+
+char *
+xmlMemStrdupLoc(const char *str, const char *file, int line)
+{
+    char *s;
+    size_t size = strlen(str) + 1;
+    MEMHDR *p;
+
+    if (!xmlMemInitialized) xmlInitMemory();
+    TEST_POINT
+
+    p = (MEMHDR *) malloc(RESERVE_SIZE+size);
+    if (!p) {
+      goto error;
+    }
+    p->mh_tag = MEMTAG;
+    p->mh_size = size;
+    p->mh_type = STRDUP_TYPE;
+    p->mh_file = file;
+    p->mh_line = line;
+    xmlMutexLock(xmlMemMutex);
+    p->mh_number = ++block;
+    debugMemSize += size;
+    if (debugMemSize > debugMaxMemSize) debugMaxMemSize = debugMemSize;
+#ifdef MEM_LIST
+    debugmem_list_add(p);
+#endif
+    xmlMutexUnlock(xmlMemMutex);
+    
+    s = (char *) HDR_2_CLIENT(p);
+    
+    if (xmlMemStopAtBlock == p->mh_number) xmlMallocBreakpoint();
+
+    if (s != NULL)
+      strcpy(s,str);
+    else
+      goto error;
+    
+    TEST_POINT
+
+    if (xmlMemTraceBlockAt == s) {
+	xmlGenericError(xmlGenericErrorContext,
+			"%p : Strdup() Ok\n", xmlMemTraceBlockAt);
+	xmlMallocBreakpoint();
+    }
+
+    return(s);
+
+error:
+    return(NULL);
+}
+
+/**
+ * xmlMemoryStrdup:
+ * @str:  the initial string pointer
+ *
+ * a strdup() equivalent, with logging of the allocation info.
+ *
+ * Returns a pointer to the new string or NULL if allocation error occurred.
+ */
+
+char *
+xmlMemoryStrdup(const char *str) {
+    return(xmlMemStrdupLoc(str, "none", 0));
+}
+
+/**
+ * xmlMemUsed:
+ *
+ * Provides the amount of memory currently allocated
+ *
+ * Returns an int representing the amount of memory allocated.
+ */
+
+int
+xmlMemUsed(void) {
+     return(debugMemSize);
+}
+
+#ifdef MEM_LIST
+/**
+ * xmlMemContentShow:
+ * @fp:  a FILE descriptor used as the output file
+ * @p:  a memory block header
+ *
+ * tries to show some content from the memory block
+ */
+
+static void
+xmlMemContentShow(FILE *fp, MEMHDR *p)
+{
+    int i,j,len = p->mh_size;
+    const char *buf = (const char *) HDR_2_CLIENT(p);
+
+    if (p == NULL) {
+	fprintf(fp, " NULL");
+	return;
+    }
+
+    for (i = 0;i < len;i++) {
+        if (buf[i] == 0) break;
+	if (!isprint((unsigned char) buf[i])) break;
+    }
+    if ((i < 4) && ((buf[i] != 0) || (i == 0))) {
+        if (len >= 4) {
+	    MEMHDR *q;
+	    void *cur;
+
+            for (j = 0;j < len -3;j += 4) {
+		cur = *((void **) &buf[j]);
+		q = CLIENT_2_HDR(cur);
+		p = memlist;
+		while (p != NULL) {
+		    if (p == q) break;
+		    p = p->mh_next;
+		}
+		if ((p != NULL) && (p == q)) {
+		    fprintf(fp, " pointer to #%lu at index %d",
+		            p->mh_number, j);
+		    return;
+		}
+	    }
+	}
+    } else if ((i == 0) && (buf[i] == 0)) {
+        fprintf(fp," null");
+    } else {
+        if (buf[i] == 0) fprintf(fp," \"%.25s\"", buf); 
+	else {
+            fprintf(fp," [");
+	    for (j = 0;j < i;j++)
+                fprintf(fp,"%c", buf[j]);
+            fprintf(fp,"]");
+	}
+    }
+}
+#endif
+
+/**
+ * xmlMemDisplay:
+ * @fp:  a FILE descriptor used as the output file, if NULL, the result is
+ *       written to the file .memorylist
+ *
+ * show in-extenso the memory blocks allocated
+ */
+
+void
+xmlMemDisplay(FILE *fp)
+{
+#ifdef MEM_LIST
+    MEMHDR *p;
+    unsigned idx;
+    int     nb = 0;
+#if defined(HAVE_LOCALTIME) && defined(HAVE_STRFTIME)
+    time_t currentTime;
+    char buf[500];
+    struct tm * tstruct;
+
+    currentTime = time(NULL);
+    tstruct = localtime(&currentTime);
+    strftime(buf, sizeof(buf) - 1, "%I:%M:%S %p", tstruct);
+    fprintf(fp,"      %s\n\n", buf);
+#endif
+
+    
+    fprintf(fp,"      MEMORY ALLOCATED : %lu, MAX was %lu\n",
+            debugMemSize, debugMaxMemSize);
+    fprintf(fp,"BLOCK  NUMBER   SIZE  TYPE\n");
+    idx = 0;
+    xmlMutexLock(xmlMemMutex);
+    p = memlist;
+    while (p) {
+	  fprintf(fp,"%-5u  %6lu %6lu ",idx++,p->mh_number,
+		  (unsigned long)p->mh_size);
+        switch (p->mh_type) {
+           case STRDUP_TYPE:fprintf(fp,"strdup()  in ");break;
+           case MALLOC_TYPE:fprintf(fp,"malloc()  in ");break;
+          case REALLOC_TYPE:fprintf(fp,"realloc() in ");break;
+           case MALLOC_ATOMIC_TYPE:fprintf(fp,"atomicmalloc()  in ");break;
+          case REALLOC_ATOMIC_TYPE:fprintf(fp,"atomicrealloc() in ");break;
+                    default:fprintf(fp,"   ???    in ");break;
+        }
+	  if (p->mh_file != NULL) fprintf(fp,"%s(%d)", p->mh_file, p->mh_line);
+        if (p->mh_tag != MEMTAG)
+	      fprintf(fp,"  INVALID");
+        nb++;
+	if (nb < 100)
+	    xmlMemContentShow(fp, p);
+	else
+	    fprintf(fp," skip");
+
+        fprintf(fp,"\n");
+        p = p->mh_next;
+    }
+    xmlMutexUnlock(xmlMemMutex);
+#else
+    fprintf(fp,"Memory list not compiled (MEM_LIST not defined !)\n");
+#endif
+}
+
+#ifdef MEM_LIST
+
+static void debugmem_list_add(MEMHDR *p)
+{
+     p->mh_next = memlist;
+     p->mh_prev = NULL;
+     if (memlist) memlist->mh_prev = p;
+     memlist = p;
+#ifdef MEM_LIST_DEBUG
+     if (stderr)
+     Mem_Display(stderr);
+#endif
+}
+
+static void debugmem_list_delete(MEMHDR *p)
+{
+     if (p->mh_next)
+     p->mh_next->mh_prev = p->mh_prev;
+     if (p->mh_prev)
+     p->mh_prev->mh_next = p->mh_next;
+     else memlist = p->mh_next;
+#ifdef MEM_LIST_DEBUG
+     if (stderr)
+     Mem_Display(stderr);
+#endif
+}
+
+#endif
+
+/*
+ * debugmem_tag_error:
+ *
+ * internal error function.
+ */
+ 
+static void debugmem_tag_error(void *p)
+{
+     xmlGenericError(xmlGenericErrorContext,
+	     "Memory tag error occurs :%p \n\t bye\n", p);
+#ifdef MEM_LIST
+     if (stderr)
+     xmlMemDisplay(stderr);
+#endif
+}
+
+#ifdef MEM_LIST
+static FILE *xmlMemoryDumpFile = NULL;
+#endif
+
+/**
+ * xmlMemShow:
+ * @fp:  a FILE descriptor used as the output file
+ * @nr:  number of entries to dump
+ *
+ * show a show display of the memory allocated, and dump
+ * the @nr last allocated areas which were not freed
+ */
+
+void
+xmlMemShow(FILE *fp, int nr ATTRIBUTE_UNUSED)
+{
+#ifdef MEM_LIST
+    MEMHDR *p;
+#endif
+
+    if (fp != NULL)
+	fprintf(fp,"      MEMORY ALLOCATED : %lu, MAX was %lu\n",
+		debugMemSize, debugMaxMemSize);
+#ifdef MEM_LIST
+    xmlMutexLock(xmlMemMutex);
+    if (nr > 0) {
+	fprintf(fp,"NUMBER   SIZE  TYPE   WHERE\n");
+	p = memlist;
+	while ((p) && nr > 0) {
+	      fprintf(fp,"%6lu %6lu ",p->mh_number,(unsigned long)p->mh_size);
+	    switch (p->mh_type) {
+	       case STRDUP_TYPE:fprintf(fp,"strdup()  in ");break;
+	       case MALLOC_TYPE:fprintf(fp,"malloc()  in ");break;
+	       case MALLOC_ATOMIC_TYPE:fprintf(fp,"atomicmalloc()  in ");break;
+	      case REALLOC_TYPE:fprintf(fp,"realloc() in ");break;
+	      case REALLOC_ATOMIC_TYPE:fprintf(fp,"atomicrealloc() in ");break;
+		default:fprintf(fp,"   ???    in ");break;
+	    }
+	    if (p->mh_file != NULL)
+	        fprintf(fp,"%s(%d)", p->mh_file, p->mh_line);
+	    if (p->mh_tag != MEMTAG)
+		fprintf(fp,"  INVALID");
+	    xmlMemContentShow(fp, p);
+	    fprintf(fp,"\n");
+	    nr--;
+	    p = p->mh_next;
+	}
+    }
+    xmlMutexUnlock(xmlMemMutex);
+#endif /* MEM_LIST */    
+}
+
+/**
+ * xmlMemoryDump:
+ *
+ * Dump in-extenso the memory blocks allocated to the file .memorylist
+ */
+
+void
+xmlMemoryDump(void)
+{
+#ifdef MEM_LIST
+    FILE *dump;
+
+    if (debugMaxMemSize == 0)
+	return;
+    dump = fopen(".memdump", "w");
+    if (dump == NULL)
+	xmlMemoryDumpFile = stderr;
+    else xmlMemoryDumpFile = dump;
+
+    xmlMemDisplay(xmlMemoryDumpFile);
+
+    if (dump != NULL) fclose(dump);
+#endif /* MEM_LIST */
+}
+
+
+/****************************************************************
+ *								*
+ *		Initialization Routines				*
+ *								*
+ ****************************************************************/
+
+/**
+ * xmlInitMemory:
+ *
+ * Initialize the memory layer.
+ *
+ * Returns 0 on success
+ */
+int
+xmlInitMemory(void)
+{
+#ifdef HAVE_STDLIB_H
+     char *breakpoint;
+#endif     
+    /*
+     This is really not good code (see Bug 130419).  Suggestions for
+     improvement will be welcome!
+    */
+     if (xmlMemInitialized) return(-1);
+     xmlMemInitialized = 1;
+     xmlMemMutex = xmlNewMutex();
+
+#ifdef HAVE_STDLIB_H
+     breakpoint = getenv("XML_MEM_BREAKPOINT");
+     if (breakpoint != NULL) {
+         sscanf(breakpoint, "%ud", &xmlMemStopAtBlock);
+     }
+#endif     
+#ifdef HAVE_STDLIB_H
+     breakpoint = getenv("XML_MEM_TRACE");
+     if (breakpoint != NULL) {
+         sscanf(breakpoint, "%p", &xmlMemTraceBlockAt);
+     }
+#endif     
+    
+#ifdef DEBUG_MEMORY
+     xmlGenericError(xmlGenericErrorContext,
+	     "xmlInitMemory() Ok\n");
+#endif     
+
+     return(0);
+}
+
+/**
+ * xmlCleanupMemory:
+ *
+ * Free up all the memory associated with memorys
+ */
+void
+xmlCleanupMemory(void) {
+    if (xmlMemInitialized == 0)
+        return;
+
+    xmlFreeMutex(xmlMemMutex);
+    xmlMemMutex = NULL;
+    xmlMemInitialized = 0;
+}
+
+/**
+ * xmlMemSetup:
+ * @freeFunc: the free() function to use
+ * @mallocFunc: the malloc() function to use
+ * @reallocFunc: the realloc() function to use
+ * @strdupFunc: the strdup() function to use
+ *
+ * Override the default memory access functions with a new set
+ * This has to be called before any other libxml routines !
+ *
+ * Should this be blocked if there was already some allocations
+ * done ?
+ *
+ * Returns 0 on success
+ */
+int
+xmlMemSetup(xmlFreeFunc freeFunc, xmlMallocFunc mallocFunc,
+            xmlReallocFunc reallocFunc, xmlStrdupFunc strdupFunc) {
+    if (freeFunc == NULL)
+	return(-1);
+    if (mallocFunc == NULL)
+	return(-1);
+    if (reallocFunc == NULL)
+	return(-1);
+    if (strdupFunc == NULL)
+	return(-1);
+    xmlFree = freeFunc;
+    xmlMalloc = mallocFunc;
+    xmlMallocAtomic = mallocFunc;
+    xmlRealloc = reallocFunc;
+    xmlMemStrdup = strdupFunc;
+    return(0);
+}
+
+/**
+ * xmlMemGet:
+ * @freeFunc: place to save the free() function in use
+ * @mallocFunc: place to save the malloc() function in use
+ * @reallocFunc: place to save the realloc() function in use
+ * @strdupFunc: place to save the strdup() function in use
+ *
+ * Provides the memory access functions set currently in use
+ *
+ * Returns 0 on success
+ */
+int
+xmlMemGet(xmlFreeFunc *freeFunc, xmlMallocFunc *mallocFunc,
+	  xmlReallocFunc *reallocFunc, xmlStrdupFunc *strdupFunc) {
+    if (freeFunc != NULL) *freeFunc = xmlFree;
+    if (mallocFunc != NULL) *mallocFunc = xmlMalloc;
+    if (reallocFunc != NULL) *reallocFunc = xmlRealloc;
+    if (strdupFunc != NULL) *strdupFunc = xmlMemStrdup;
+    return(0);
+}
+
+/**
+ * xmlGcMemSetup:
+ * @freeFunc: the free() function to use
+ * @mallocFunc: the malloc() function to use
+ * @mallocAtomicFunc: the malloc() function to use for atomic allocations
+ * @reallocFunc: the realloc() function to use
+ * @strdupFunc: the strdup() function to use
+ *
+ * Override the default memory access functions with a new set
+ * This has to be called before any other libxml routines !
+ * The mallocAtomicFunc is specialized for atomic block
+ * allocations (i.e. of areas  useful for garbage collected memory allocators
+ *
+ * Should this be blocked if there was already some allocations
+ * done ?
+ *
+ * Returns 0 on success
+ */
+int
+xmlGcMemSetup(xmlFreeFunc freeFunc, xmlMallocFunc mallocFunc,
+              xmlMallocFunc mallocAtomicFunc, xmlReallocFunc reallocFunc,
+	      xmlStrdupFunc strdupFunc) {
+    if (freeFunc == NULL)
+	return(-1);
+    if (mallocFunc == NULL)
+	return(-1);
+    if (mallocAtomicFunc == NULL)
+	return(-1);
+    if (reallocFunc == NULL)
+	return(-1);
+    if (strdupFunc == NULL)
+	return(-1);
+    xmlFree = freeFunc;
+    xmlMalloc = mallocFunc;
+    xmlMallocAtomic = mallocAtomicFunc;
+    xmlRealloc = reallocFunc;
+    xmlMemStrdup = strdupFunc;
+    return(0);
+}
+
+/**
+ * xmlGcMemGet:
+ * @freeFunc: place to save the free() function in use
+ * @mallocFunc: place to save the malloc() function in use
+ * @mallocAtomicFunc: place to save the atomic malloc() function in use
+ * @reallocFunc: place to save the realloc() function in use
+ * @strdupFunc: place to save the strdup() function in use
+ *
+ * Provides the memory access functions set currently in use
+ * The mallocAtomicFunc is specialized for atomic block
+ * allocations (i.e. of areas  useful for garbage collected memory allocators
+ *
+ * Returns 0 on success
+ */
+int
+xmlGcMemGet(xmlFreeFunc *freeFunc, xmlMallocFunc *mallocFunc,
+            xmlMallocFunc *mallocAtomicFunc, xmlReallocFunc *reallocFunc,
+	    xmlStrdupFunc *strdupFunc) {
+    if (freeFunc != NULL) *freeFunc = xmlFree;
+    if (mallocFunc != NULL) *mallocFunc = xmlMalloc;
+    if (mallocAtomicFunc != NULL) *mallocAtomicFunc = xmlMallocAtomic;
+    if (reallocFunc != NULL) *reallocFunc = xmlRealloc;
+    if (strdupFunc != NULL) *strdupFunc = xmlMemStrdup;
+    return(0);
+}
+
diff --git a/src/libxml/src/xmlreader.c b/src/libxml/src/xmlreader.c
new file mode 100644
index 0000000..41083ad
--- /dev/null
+++ b/src/libxml/src/xmlreader.c
@@ -0,0 +1,4854 @@
+/*
+ * xmlreader.c: implements the xmlTextReader streaming node API
+ *
+ * NOTE: 
+ *   XmlTextReader.Normalization Property won't be supported, since
+ *     it makes the parser non compliant to the XML recommendation
+ *
+ * See Copyright for the status of this software.
+ *
+ * daniel@veillard.com
+ */
+
+/*
+ * TODOs:
+ *   - XML Schemas validation
+ *   - setting(s) for NoBlanks
+ *   - performances and tuning ...
+ */
+#define IN_LIBXML
+#include "libxml.h"
+
+#ifdef LIBXML_READER_ENABLED
+#include <string.h> /* for memset() only ! */
+#include <stdarg.h>
+
+#ifdef HAVE_CTYPE_H
+#include <ctype.h>
+#endif
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+
+#include <libxml/xmlmemory.h>
+#include <libxml/xmlIO.h>
+#include <libxml/xmlreader.h>
+#include <libxml/parserInternals.h>
+#include <libxml/relaxng.h>
+#include <libxml/uri.h>
+#ifdef LIBXML_XINCLUDE_ENABLED
+#include <libxml/xinclude.h>
+#endif
+#ifdef LIBXML_PATTERN_ENABLED
+#include <libxml/pattern.h>
+#endif
+
+/* #define DEBUG_CALLBACKS */
+/* #define DEBUG_READER */
+
+/**
+ * TODO:
+ *
+ * macro to flag unimplemented blocks
+ */
+#define TODO 								\
+    xmlGenericError(xmlGenericErrorContext,				\
+	    "Unimplemented block at %s:%d\n",				\
+            __FILE__, __LINE__);
+
+#ifdef DEBUG_READER
+#define DUMP_READER xmlTextReaderDebug(reader);
+#else
+#define DUMP_READER
+#endif
+
+#define CHUNK_SIZE 512
+/************************************************************************
+ *									*
+ *	The parser: maps the Text Reader API on top of the existing	*
+ *		parsing routines building a tree			*
+ *									*
+ ************************************************************************/
+
+#define XML_TEXTREADER_INPUT	1
+#define XML_TEXTREADER_CTXT	2
+
+typedef enum {
+    XML_TEXTREADER_MODE_INITIAL = 0,
+    XML_TEXTREADER_MODE_INTERACTIVE = 1,
+    XML_TEXTREADER_MODE_ERROR = 2,
+    XML_TEXTREADER_MODE_EOF =3,
+    XML_TEXTREADER_MODE_CLOSED = 4,
+    XML_TEXTREADER_MODE_READING = 5
+} xmlTextReaderMode;
+
+typedef enum {
+    XML_TEXTREADER_NONE = -1,
+    XML_TEXTREADER_START= 0,
+    XML_TEXTREADER_ELEMENT= 1,
+    XML_TEXTREADER_END= 2,
+    XML_TEXTREADER_EMPTY= 3,
+    XML_TEXTREADER_BACKTRACK= 4,
+    XML_TEXTREADER_DONE= 5,
+    XML_TEXTREADER_ERROR= 6
+} xmlTextReaderState;
+
+typedef enum {
+    XML_TEXTREADER_NOT_VALIDATE = 0,
+    XML_TEXTREADER_VALIDATE_DTD = 1,
+    XML_TEXTREADER_VALIDATE_RNG = 2
+} xmlTextReaderValidate;
+
+struct _xmlTextReader {
+    int				mode;	/* the parsing mode */
+    xmlDocPtr			doc;    /* when walking an existing doc */
+    xmlTextReaderValidate       validate;/* is there any validation */
+    int				allocs;	/* what structure were deallocated */
+    xmlTextReaderState		state;
+    xmlParserCtxtPtr		ctxt;	/* the parser context */
+    xmlSAXHandlerPtr		sax;	/* the parser SAX callbacks */
+    xmlParserInputBufferPtr	input;	/* the input */
+    startElementSAXFunc		startElement;/* initial SAX callbacks */
+    endElementSAXFunc		endElement;  /* idem */
+    startElementNsSAX2Func	startElementNs;/* idem */
+    endElementNsSAX2Func	endElementNs;  /* idem */
+    charactersSAXFunc		characters;
+    cdataBlockSAXFunc		cdataBlock;
+    unsigned int 		base;	/* base of the segment in the input */
+    unsigned int 		cur;	/* current position in the input */
+    xmlNodePtr			node;	/* current node */
+    xmlNodePtr			curnode;/* current attribute node */
+    int				depth;  /* depth of the current node */
+    xmlNodePtr			faketext;/* fake xmlNs chld */
+    int				preserve;/* preserve the resulting document */
+    xmlBufferPtr		buffer; /* used to return const xmlChar * */
+    xmlDictPtr			dict;	/* the context dictionnary */
+
+    /* entity stack when traversing entities content */
+    xmlNodePtr         ent;          /* Current Entity Ref Node */
+    int                entNr;        /* Depth of the entities stack */
+    int                entMax;       /* Max depth of the entities stack */
+    xmlNodePtr        *entTab;       /* array of entities */
+
+    /* error handling */
+    xmlTextReaderErrorFunc errorFunc;    /* callback function */
+    void                  *errorFuncArg; /* callback function user argument */
+
+#ifdef LIBXML_SCHEMAS_ENABLED
+    /* Handling of RelaxNG validation */
+    xmlRelaxNGPtr          rngSchemas;	/* The Relax NG schemas */
+    xmlRelaxNGValidCtxtPtr rngValidCtxt;/* The Relax NG validation context */
+    int                  rngValidErrors;/* The number of errors detected */
+    xmlNodePtr             rngFullNode;	/* the node if RNG not progressive */
+#endif
+#ifdef LIBXML_XINCLUDE_ENABLED
+    /* Handling of XInclude processing */
+    int                xinclude;	/* is xinclude asked for */
+    const xmlChar *    xinclude_name;	/* the xinclude name from dict */
+    xmlXIncludeCtxtPtr xincctxt;	/* the xinclude context */
+    int                in_xinclude;	/* counts for xinclude */
+#endif
+#ifdef LIBXML_PATTERN_ENABLED
+    int                patternNr;       /* number of preserve patterns */
+    int                patternMax;      /* max preserve patterns */
+    xmlPatternPtr     *patternTab;      /* array of preserve patterns */
+#endif
+    int                preserves;	/* level of preserves */
+    int                parserFlags;	/* the set of options set */
+    /* Structured error handling */
+    xmlStructuredErrorFunc sErrorFunc;  /* callback function */
+};
+
+#define NODE_IS_EMPTY		0x1
+#define NODE_IS_PRESERVED	0x2
+#define NODE_IS_SPRESERVED	0x4
+
+/**
+ * CONSTSTR:
+ *
+ * Macro used to return an interned string
+ */
+#define CONSTSTR(str) xmlDictLookup(reader->dict, (str), -1)
+#define CONSTQSTR(p, str) xmlDictQLookup(reader->dict, (p), (str))
+
+static int xmlTextReaderReadTree(xmlTextReaderPtr reader);
+static int xmlTextReaderNextTree(xmlTextReaderPtr reader);
+
+/************************************************************************
+ *									*
+ *	Our own version of the freeing routines as we recycle nodes	*
+ *									*
+ ************************************************************************/
+/**
+ * DICT_FREE:
+ * @str:  a string
+ *
+ * Free a string if it is not owned by the "dict" dictionnary in the
+ * current scope
+ */
+#define DICT_FREE(str)						\
+	if ((str) && ((!dict) || 				\
+	    (xmlDictOwns(dict, (const xmlChar *)(str)) == 0)))	\
+	    xmlFree((char *)(str));
+
+static void xmlTextReaderFreeNode(xmlTextReaderPtr reader, xmlNodePtr cur);
+static void xmlTextReaderFreeNodeList(xmlTextReaderPtr reader, xmlNodePtr cur);
+
+/**
+ * xmlFreeID:
+ * @not:  A id
+ *
+ * Deallocate the memory used by an id definition
+ */
+static void
+xmlFreeID(xmlIDPtr id) {
+    xmlDictPtr dict = NULL;
+
+    if (id == NULL) return;
+
+    if (id->doc != NULL)
+        dict = id->doc->dict;
+
+    if (id->value != NULL)
+	DICT_FREE(id->value)
+    xmlFree(id);
+}
+
+/**
+ * xmlTextReaderRemoveID:
+ * @doc:  the document
+ * @attr:  the attribute
+ *
+ * Remove the given attribute from the ID table maintained internally.
+ *
+ * Returns -1 if the lookup failed and 0 otherwise
+ */
+static int
+xmlTextReaderRemoveID(xmlDocPtr doc, xmlAttrPtr attr) {
+    xmlIDTablePtr table;
+    xmlIDPtr id;
+    xmlChar *ID;
+
+    if (doc == NULL) return(-1);
+    if (attr == NULL) return(-1);
+    table = (xmlIDTablePtr) doc->ids;
+    if (table == NULL) 
+        return(-1);
+
+    if (attr == NULL)
+	return(-1);
+    ID = xmlNodeListGetString(doc, attr->children, 1);
+    if (ID == NULL)
+	return(-1);
+    id = xmlHashLookup(table, ID);
+    xmlFree(ID);
+    if (id == NULL || id->attr != attr) {
+	return(-1);
+    }
+    id->name = attr->name;
+    id->attr = NULL;
+    return(0);
+}
+
+/**
+ * xmlTextReaderFreeProp:
+ * @reader:  the xmlTextReaderPtr used
+ * @cur:  the node
+ *
+ * Free a node.
+ */
+static void
+xmlTextReaderFreeProp(xmlTextReaderPtr reader, xmlAttrPtr cur) {
+    xmlDictPtr dict;
+
+    dict = reader->ctxt->dict;
+    if (cur == NULL) return;
+
+    /* Check for ID removal -> leading to invalid references ! */
+    if ((cur->parent != NULL) && (cur->parent->doc != NULL) &&
+	((cur->parent->doc->intSubset != NULL) ||
+	 (cur->parent->doc->extSubset != NULL))) {
+        if (xmlIsID(cur->parent->doc, cur->parent, cur))
+	    xmlTextReaderRemoveID(cur->parent->doc, cur);
+    }
+    if (cur->children != NULL)
+        xmlTextReaderFreeNodeList(reader, cur->children);
+
+    DICT_FREE(cur->name);
+    if ((reader != NULL) && (reader->ctxt != NULL) &&
+        (reader->ctxt->freeAttrsNr < 100)) {
+        cur->next = reader->ctxt->freeAttrs;
+	reader->ctxt->freeAttrs = cur;
+	reader->ctxt->freeAttrsNr++;
+    } else {
+	xmlFree(cur);
+    }
+}
+
+/**
+ * xmlTextReaderFreePropList:
+ * @reader:  the xmlTextReaderPtr used
+ * @cur:  the first property in the list
+ *
+ * Free a property and all its siblings, all the children are freed too.
+ */
+static void
+xmlTextReaderFreePropList(xmlTextReaderPtr reader, xmlAttrPtr cur) {
+    xmlAttrPtr next;
+    if (cur == NULL) return;
+    while (cur != NULL) {
+        next = cur->next;
+        xmlTextReaderFreeProp(reader, cur);
+	cur = next;
+    }
+}
+
+/**
+ * xmlTextReaderFreeNodeList:
+ * @reader:  the xmlTextReaderPtr used
+ * @cur:  the first node in the list
+ *
+ * Free a node and all its siblings, this is a recursive behaviour, all
+ * the children are freed too.
+ */
+static void
+xmlTextReaderFreeNodeList(xmlTextReaderPtr reader, xmlNodePtr cur) {
+    xmlNodePtr next;
+    xmlDictPtr dict;
+
+    dict = reader->ctxt->dict;
+    if (cur == NULL) return;
+    if (cur->type == XML_NAMESPACE_DECL) {
+	xmlFreeNsList((xmlNsPtr) cur);
+	return;
+    }
+    if ((cur->type == XML_DOCUMENT_NODE) ||
+	(cur->type == XML_HTML_DOCUMENT_NODE)) {
+	xmlFreeDoc((xmlDocPtr) cur);
+	return;
+    }
+    while (cur != NULL) {
+        next = cur->next;
+	/* unroll to speed up freeing the document */
+	if (cur->type != XML_DTD_NODE) {
+
+	    if ((cur->children != NULL) &&
+		(cur->type != XML_ENTITY_REF_NODE)) {
+		if (cur->children->parent == cur)
+		    xmlTextReaderFreeNodeList(reader, cur->children);
+		cur->children = NULL;
+	    }
+	    if (((cur->type == XML_ELEMENT_NODE) ||
+		 (cur->type == XML_XINCLUDE_START) ||
+		 (cur->type == XML_XINCLUDE_END)) &&
+		(cur->properties != NULL))
+		xmlTextReaderFreePropList(reader, cur->properties);
+	    if ((cur->type != XML_ELEMENT_NODE) &&
+		(cur->type != XML_XINCLUDE_START) &&
+		(cur->type != XML_XINCLUDE_END) &&
+		(cur->type != XML_ENTITY_REF_NODE)) {
+		DICT_FREE(cur->content);
+	    }
+	    if (((cur->type == XML_ELEMENT_NODE) ||
+	         (cur->type == XML_XINCLUDE_START) ||
+		 (cur->type == XML_XINCLUDE_END)) &&
+		(cur->nsDef != NULL))
+		xmlFreeNsList(cur->nsDef);
+
+	    /*
+	     * we don't free element names here they are interned now
+	     */
+	    if ((cur->type != XML_TEXT_NODE) &&
+		(cur->type != XML_COMMENT_NODE))
+		DICT_FREE(cur->name);
+	    if (((cur->type == XML_ELEMENT_NODE) ||
+		 (cur->type == XML_TEXT_NODE)) &&
+	        (reader != NULL) && (reader->ctxt != NULL) &&
+		(reader->ctxt->freeElemsNr < 100)) {
+	        cur->next = reader->ctxt->freeElems;
+		reader->ctxt->freeElems = cur;
+		reader->ctxt->freeElemsNr++;
+	    } else {
+		xmlFree(cur);
+	    }
+	}
+	cur = next;
+    }
+}
+
+/**
+ * xmlTextReaderFreeNode:
+ * @reader:  the xmlTextReaderPtr used
+ * @cur:  the node
+ *
+ * Free a node, this is a recursive behaviour, all the children are freed too.
+ * This doesn't unlink the child from the list, use xmlUnlinkNode() first.
+ */
+static void
+xmlTextReaderFreeNode(xmlTextReaderPtr reader, xmlNodePtr cur) {
+    xmlDictPtr dict;
+
+    dict = reader->ctxt->dict;
+    if (cur->type == XML_DTD_NODE) {
+	xmlFreeDtd((xmlDtdPtr) cur);
+	return;
+    }
+    if (cur->type == XML_NAMESPACE_DECL) {
+	xmlFreeNs((xmlNsPtr) cur);
+        return;
+    }
+    if (cur->type == XML_ATTRIBUTE_NODE) {
+	xmlTextReaderFreeProp(reader, (xmlAttrPtr) cur);
+	return;
+    }
+
+    if ((cur->children != NULL) &&
+	(cur->type != XML_ENTITY_REF_NODE)) {
+	if (cur->children->parent == cur)
+	    xmlTextReaderFreeNodeList(reader, cur->children);
+	cur->children = NULL;
+    }
+    if (((cur->type == XML_ELEMENT_NODE) ||
+	 (cur->type == XML_XINCLUDE_START) ||
+	 (cur->type == XML_XINCLUDE_END)) &&
+	(cur->properties != NULL))
+	xmlTextReaderFreePropList(reader, cur->properties);
+    if ((cur->type != XML_ELEMENT_NODE) &&
+	(cur->type != XML_XINCLUDE_START) &&
+	(cur->type != XML_XINCLUDE_END) &&
+	(cur->type != XML_ENTITY_REF_NODE)) {
+	DICT_FREE(cur->content);
+    }
+    if (((cur->type == XML_ELEMENT_NODE) ||
+	 (cur->type == XML_XINCLUDE_START) ||
+	 (cur->type == XML_XINCLUDE_END)) &&
+	(cur->nsDef != NULL))
+	xmlFreeNsList(cur->nsDef);
+
+    /*
+     * we don't free names here they are interned now
+     */
+    if ((cur->type != XML_TEXT_NODE) &&
+        (cur->type != XML_COMMENT_NODE))
+	DICT_FREE(cur->name);
+    if (((cur->type == XML_ELEMENT_NODE) ||
+	 (cur->type == XML_TEXT_NODE)) &&
+	(reader != NULL) && (reader->ctxt != NULL) &&
+	(reader->ctxt->freeElemsNr < 100)) {
+	cur->next = reader->ctxt->freeElems;
+	reader->ctxt->freeElems = cur;
+	reader->ctxt->freeElemsNr++;
+    } else {
+	xmlFree(cur);
+    }
+}
+
+/**
+ * xmlTextReaderFreeIDTable:
+ * @table:  An id table
+ *
+ * Deallocate the memory used by an ID hash table.
+ */
+static void
+xmlTextReaderFreeIDTable(xmlIDTablePtr table) {
+    xmlHashFree(table, (xmlHashDeallocator) xmlFreeID);
+}
+
+/**
+ * xmlTextReaderFreeDoc:
+ * @reader:  the xmlTextReaderPtr used
+ * @cur:  pointer to the document
+ *
+ * Free up all the structures used by a document, tree included.
+ */
+static void
+xmlTextReaderFreeDoc(xmlTextReaderPtr reader, xmlDocPtr cur) {
+    xmlDtdPtr extSubset, intSubset;
+
+    if (cur == NULL) return;
+
+    /*
+     * Do this before freeing the children list to avoid ID lookups
+     */
+    if (cur->ids != NULL) xmlTextReaderFreeIDTable((xmlIDTablePtr) cur->ids);
+    cur->ids = NULL;
+    if (cur->refs != NULL) xmlFreeRefTable((xmlRefTablePtr) cur->refs);
+    cur->refs = NULL;
+    extSubset = cur->extSubset;
+    intSubset = cur->intSubset;
+    if (intSubset == extSubset)
+	extSubset = NULL;
+    if (extSubset != NULL) {
+	xmlUnlinkNode((xmlNodePtr) cur->extSubset);
+	cur->extSubset = NULL;
+	xmlFreeDtd(extSubset);
+    }
+    if (intSubset != NULL) {
+	xmlUnlinkNode((xmlNodePtr) cur->intSubset);
+	cur->intSubset = NULL;
+	xmlFreeDtd(intSubset);
+    }
+
+    if (cur->children != NULL) xmlTextReaderFreeNodeList(reader, cur->children);
+
+    if (cur->version != NULL) xmlFree((char *) cur->version);
+    if (cur->name != NULL) xmlFree((char *) cur->name);
+    if (cur->encoding != NULL) xmlFree((char *) cur->encoding);
+    if (cur->oldNs != NULL) xmlFreeNsList(cur->oldNs);
+    if (cur->URL != NULL) xmlFree((char *) cur->URL);
+    if (cur->dict != NULL) xmlDictFree(cur->dict);
+    xmlFree(cur);
+}
+
+/************************************************************************
+ *									*
+ *			The reader core parser				*
+ *									*
+ ************************************************************************/
+#ifdef DEBUG_READER
+static void
+xmlTextReaderDebug(xmlTextReaderPtr reader) {
+    if ((reader == NULL) || (reader->ctxt == NULL)) {
+	fprintf(stderr, "xmlTextReader NULL\n");
+	return;
+    }
+    fprintf(stderr, "xmlTextReader: state %d depth %d ",
+	    reader->state, reader->depth);
+    if (reader->node == NULL) {
+	fprintf(stderr, "node = NULL\n");
+    } else {
+	fprintf(stderr, "node %s\n", reader->node->name);
+    }
+    fprintf(stderr, "  input: base %d, cur %d, depth %d: ",
+	    reader->base, reader->cur, reader->ctxt->nodeNr);
+    if (reader->input->buffer == NULL) {
+	fprintf(stderr, "buffer is NULL\n");
+    } else {
+#ifdef LIBXML_DEBUG_ENABLED
+	xmlDebugDumpString(stderr,
+		&reader->input->buffer->content[reader->cur]);
+#endif
+	fprintf(stderr, "\n");
+    }
+}
+#endif
+
+/**
+ * xmlTextReaderEntPush:
+ * @reader:  the xmlTextReaderPtr used
+ * @value:  the entity reference node
+ *
+ * Pushes a new entity reference node on top of the entities stack
+ *
+ * Returns 0 in case of error, the index in the stack otherwise
+ */
+static int
+xmlTextReaderEntPush(xmlTextReaderPtr reader, xmlNodePtr value)
+{
+    if (reader->entMax <= 0) {
+	reader->entMax = 10;
+	reader->entTab = (xmlNodePtr *) xmlMalloc(reader->entMax *
+		                                  sizeof(reader->entTab[0]));
+        if (reader->entTab == NULL) {
+            xmlGenericError(xmlGenericErrorContext, "xmlMalloc failed !\n");
+            return (0);
+        }
+    }
+    if (reader->entNr >= reader->entMax) {
+        reader->entMax *= 2;
+        reader->entTab =
+            (xmlNodePtr *) xmlRealloc(reader->entTab,
+                                      reader->entMax *
+                                      sizeof(reader->entTab[0]));
+        if (reader->entTab == NULL) {
+            xmlGenericError(xmlGenericErrorContext, "xmlRealloc failed !\n");
+            return (0);
+        }
+    }
+    reader->entTab[reader->entNr] = value;
+    reader->ent = value;
+    return (reader->entNr++);
+}
+
+/**
+ * xmlTextReaderEntPop:
+ * @reader:  the xmlTextReaderPtr used
+ *
+ * Pops the top element entity from the entities stack
+ *
+ * Returns the entity just removed
+ */
+static xmlNodePtr
+xmlTextReaderEntPop(xmlTextReaderPtr reader)
+{
+    xmlNodePtr ret;
+
+    if (reader->entNr <= 0)
+        return (0);
+    reader->entNr--;
+    if (reader->entNr > 0)
+        reader->ent = reader->entTab[reader->entNr - 1];
+    else
+        reader->ent = NULL;
+    ret = reader->entTab[reader->entNr];
+    reader->entTab[reader->entNr] = 0;
+    return (ret);
+}
+
+/**
+ * xmlTextReaderStartElement:
+ * @ctx: the user data (XML parser context)
+ * @fullname:  The element name, including namespace prefix
+ * @atts:  An array of name/value attributes pairs, NULL terminated
+ *
+ * called when an opening tag has been processed.
+ */
+static void
+xmlTextReaderStartElement(void *ctx, const xmlChar *fullname,
+	                  const xmlChar **atts) {
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+    xmlTextReaderPtr reader = ctxt->_private;
+
+#ifdef DEBUG_CALLBACKS
+    printf("xmlTextReaderStartElement(%s)\n", fullname);
+#endif
+    if ((reader != NULL) && (reader->startElement != NULL)) {
+	reader->startElement(ctx, fullname, atts);
+	if ((ctxt->node != NULL) && (ctxt->input != NULL) &&
+	    (ctxt->input->cur != NULL) && (ctxt->input->cur[0] == '/') &&
+	    (ctxt->input->cur[1] == '>'))
+	    ctxt->node->extra = NODE_IS_EMPTY;
+    }
+    if (reader != NULL)
+	reader->state = XML_TEXTREADER_ELEMENT;
+}
+
+/**
+ * xmlTextReaderEndElement:
+ * @ctx: the user data (XML parser context)
+ * @fullname:  The element name, including namespace prefix
+ *
+ * called when an ending tag has been processed.
+ */
+static void
+xmlTextReaderEndElement(void *ctx, const xmlChar *fullname) {
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+    xmlTextReaderPtr reader = ctxt->_private;
+
+#ifdef DEBUG_CALLBACKS
+    printf("xmlTextReaderEndElement(%s)\n", fullname);
+#endif
+    if ((reader != NULL) && (reader->endElement != NULL)) {
+	reader->endElement(ctx, fullname);
+    }
+}
+
+/**
+ * xmlTextReaderStartElementNs:
+ * @ctx: the user data (XML parser context)
+ * @localname:  the local name of the element
+ * @prefix:  the element namespace prefix if available
+ * @URI:  the element namespace name if available
+ * @nb_namespaces:  number of namespace definitions on that node
+ * @namespaces:  pointer to the array of prefix/URI pairs namespace definitions
+ * @nb_attributes:  the number of attributes on that node
+ * nb_defaulted:  the number of defaulted attributes.
+ * @attributes:  pointer to the array of (localname/prefix/URI/value/end)
+ *               attribute values.
+ *
+ * called when an opening tag has been processed.
+ */
+static void
+xmlTextReaderStartElementNs(void *ctx,
+                      const xmlChar *localname,
+		      const xmlChar *prefix,
+		      const xmlChar *URI,
+		      int nb_namespaces,
+		      const xmlChar **namespaces,
+		      int nb_attributes,
+		      int nb_defaulted,
+		      const xmlChar **attributes)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+    xmlTextReaderPtr reader = ctxt->_private;
+
+#ifdef DEBUG_CALLBACKS
+    printf("xmlTextReaderStartElementNs(%s)\n", localname);
+#endif
+    if ((reader != NULL) && (reader->startElementNs != NULL)) {
+	reader->startElementNs(ctx, localname, prefix, URI, nb_namespaces,
+	                       namespaces, nb_attributes, nb_defaulted,
+			       attributes);
+	if ((ctxt->node != NULL) && (ctxt->input != NULL) &&
+	    (ctxt->input->cur != NULL) && (ctxt->input->cur[0] == '/') &&
+	    (ctxt->input->cur[1] == '>'))
+	    ctxt->node->extra = NODE_IS_EMPTY;
+    }
+    if (reader != NULL)
+	reader->state = XML_TEXTREADER_ELEMENT;
+}
+
+/**
+ * xmlTextReaderEndElementNs:
+ * @ctx: the user data (XML parser context)
+ * @localname:  the local name of the element
+ * @prefix:  the element namespace prefix if available
+ * @URI:  the element namespace name if available
+ *
+ * called when an ending tag has been processed.
+ */
+static void
+xmlTextReaderEndElementNs(void *ctx,
+                          const xmlChar * localname,
+                          const xmlChar * prefix,
+		          const xmlChar * URI)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+    xmlTextReaderPtr reader = ctxt->_private;
+
+#ifdef DEBUG_CALLBACKS
+    printf("xmlTextReaderEndElementNs(%s)\n", localname);
+#endif
+    if ((reader != NULL) && (reader->endElementNs != NULL)) {
+	reader->endElementNs(ctx, localname, prefix, URI);
+    }
+}
+
+
+/**
+ * xmlTextReaderCharacters:
+ * @ctx: the user data (XML parser context)
+ * @ch:  a xmlChar string
+ * @len: the number of xmlChar
+ *
+ * receiving some chars from the parser.
+ */
+static void
+xmlTextReaderCharacters(void *ctx, const xmlChar *ch, int len)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+    xmlTextReaderPtr reader = ctxt->_private;
+
+#ifdef DEBUG_CALLBACKS
+    printf("xmlTextReaderCharacters()\n");
+#endif
+    if ((reader != NULL) && (reader->characters != NULL)) {
+	reader->characters(ctx, ch, len);
+    }
+}
+
+/**
+ * xmlTextReaderCDataBlock:
+ * @ctx: the user data (XML parser context)
+ * @value:  The pcdata content
+ * @len:  the block length
+ *
+ * called when a pcdata block has been parsed
+ */
+static void
+xmlTextReaderCDataBlock(void *ctx, const xmlChar *ch, int len)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+    xmlTextReaderPtr reader = ctxt->_private;
+
+#ifdef DEBUG_CALLBACKS
+    printf("xmlTextReaderCDataBlock()\n");
+#endif
+    if ((reader != NULL) && (reader->cdataBlock != NULL)) {
+	reader->cdataBlock(ctx, ch, len);
+    }
+}
+
+/**
+ * xmlTextReaderPushData:
+ * @reader:  the xmlTextReaderPtr used
+ *
+ * Push data down the progressive parser until a significant callback
+ * got raised.
+ *
+ * Returns -1 in case of failure, 0 otherwise
+ */
+static int
+xmlTextReaderPushData(xmlTextReaderPtr reader) {
+    xmlBufferPtr inbuf;
+    int val, s;
+    xmlTextReaderState oldstate;
+
+    if ((reader->input == NULL) || (reader->input->buffer == NULL))
+	return(-1);
+
+    oldstate = reader->state;
+    reader->state = XML_TEXTREADER_NONE;
+    inbuf = reader->input->buffer;
+
+    while (reader->state == XML_TEXTREADER_NONE) {
+	if (inbuf->use < reader->cur + CHUNK_SIZE) {
+	    /*
+	     * Refill the buffer unless we are at the end of the stream
+	     */
+	    if (reader->mode != XML_TEXTREADER_MODE_EOF) {
+		val = xmlParserInputBufferRead(reader->input, 4096);
+		if ((val == 0) &&
+		    (inbuf->alloc == XML_BUFFER_ALLOC_IMMUTABLE)) {
+		    if (inbuf->use == reader->cur) {
+			reader->mode = XML_TEXTREADER_MODE_EOF;
+			reader->state = oldstate;
+		    }
+		} else if (val < 0) {
+		    reader->mode = XML_TEXTREADER_MODE_EOF;
+		    reader->state = oldstate;
+		    if ((oldstate != XML_TEXTREADER_START) ||
+			(reader->ctxt->myDoc != NULL))
+			return(val);
+		} else if (val == 0) {
+		    /* mark the end of the stream and process the remains */
+		    reader->mode = XML_TEXTREADER_MODE_EOF;
+		    break;
+		}
+
+	    } else 
+		break;
+	}
+	/*
+	 * parse by block of CHUNK_SIZE bytes, various tests show that
+	 * it's the best tradeoff at least on a 1.2GH Duron
+	 */
+	if (inbuf->use >= reader->cur + CHUNK_SIZE) {
+	    val = xmlParseChunk(reader->ctxt,
+		          (const char *) &inbuf->content[reader->cur],
+			  CHUNK_SIZE, 0);
+	    reader->cur += CHUNK_SIZE;
+	    if ((val != 0) && (reader->ctxt->wellFormed == 0))
+		return(-1);
+	} else {
+	    s = inbuf->use - reader->cur;
+	    val = xmlParseChunk(reader->ctxt,
+		          (const char *) &inbuf->content[reader->cur],
+			  s, 0);
+	    reader->cur += s;
+	    if ((val != 0) && (reader->ctxt->wellFormed == 0))
+		return(-1);
+	    break;
+	}
+    }
+
+    /*
+     * Discard the consumed input when needed and possible
+     */
+    if (reader->mode == XML_TEXTREADER_MODE_INTERACTIVE) {
+        if (inbuf->alloc != XML_BUFFER_ALLOC_IMMUTABLE) {
+	    if ((reader->cur >= 4096) &&
+		(inbuf->use - reader->cur <= CHUNK_SIZE)) {
+		val = xmlBufferShrink(inbuf, reader->cur);
+		if (val >= 0) {
+		    reader->cur -= val;
+		}
+	    }
+	}
+    }
+
+    /*
+     * At the end of the stream signal that the work is done to the Push
+     * parser.
+     */
+    else if (reader->mode == XML_TEXTREADER_MODE_EOF) {
+	if (reader->mode != XML_TEXTREADER_DONE) {
+	    s = inbuf->use - reader->cur;
+	    val = xmlParseChunk(reader->ctxt,
+		    (const char *) &inbuf->content[reader->cur], 
+		    s, 1);
+	    reader->cur = inbuf->use;
+	    reader->mode = XML_TEXTREADER_DONE;
+	    if ((val != 0) && (reader->ctxt->wellFormed == 0))
+	        return(-1);
+	}
+    }
+    reader->state = oldstate;
+    return(0);
+}
+
+#ifdef LIBXML_REGEXP_ENABLED
+/**
+ * xmlTextReaderValidatePush:
+ * @reader:  the xmlTextReaderPtr used
+ *
+ * Push the current node for validation
+ */
+static void
+xmlTextReaderValidatePush(xmlTextReaderPtr reader ATTRIBUTE_UNUSED) {
+    xmlNodePtr node = reader->node;
+
+#ifdef LIBXML_VALID_ENABLED
+    if ((reader->validate == XML_TEXTREADER_VALIDATE_DTD) &&
+        (reader->ctxt != NULL) && (reader->ctxt->validate == 1)) {
+	if ((node->ns == NULL) || (node->ns->prefix == NULL)) {
+	    reader->ctxt->valid &= xmlValidatePushElement(&reader->ctxt->vctxt,
+				    reader->ctxt->myDoc, node, node->name);
+	} else {
+	    /* TODO use the BuildQName interface */
+	    xmlChar *qname;
+
+	    qname = xmlStrdup(node->ns->prefix);
+	    qname = xmlStrcat(qname, BAD_CAST ":");
+	    qname = xmlStrcat(qname, node->name);
+	    reader->ctxt->valid &= xmlValidatePushElement(&reader->ctxt->vctxt,
+				    reader->ctxt->myDoc, node, qname);
+	    if (qname != NULL)
+		xmlFree(qname);
+	}
+    }
+#endif /* LIBXML_VALID_ENABLED */
+#ifdef LIBXML_SCHEMAS_ENABLED
+    if ((reader->validate == XML_TEXTREADER_VALIDATE_RNG) &&
+               (reader->rngValidCtxt != NULL)) {
+	int ret;
+
+	if (reader->rngFullNode != NULL) return;
+	ret = xmlRelaxNGValidatePushElement(reader->rngValidCtxt,
+	                                    reader->ctxt->myDoc,
+					    node);
+	if (ret == 0) {
+	    /*
+	     * this element requires a full tree
+	     */
+	    node = xmlTextReaderExpand(reader);
+	    if (node == NULL) {
+printf("Expand failed !\n");
+	        ret = -1;
+	    } else {
+		ret = xmlRelaxNGValidateFullElement(reader->rngValidCtxt,
+						    reader->ctxt->myDoc,
+						    node);
+		reader->rngFullNode = node;
+	    }
+	}
+	if (ret != 1)
+	    reader->rngValidErrors++;
+    }
+#endif
+}
+
+/**
+ * xmlTextReaderValidateCData:
+ * @reader:  the xmlTextReaderPtr used
+ * @data:  pointer to the CData
+ * @len:  lenght of the CData block in bytes.
+ *
+ * Push some CData for validation
+ */
+static void
+xmlTextReaderValidateCData(xmlTextReaderPtr reader,
+                           const xmlChar *data, int len) {
+#ifdef LIBXML_VALID_ENABLED
+    if ((reader->validate == XML_TEXTREADER_VALIDATE_DTD) &&
+        (reader->ctxt != NULL) && (reader->ctxt->validate == 1)) {
+	reader->ctxt->valid &= xmlValidatePushCData(&reader->ctxt->vctxt,
+	                                            data, len);
+    }
+#endif /* LIBXML_VALID_ENABLED */
+#ifdef LIBXML_SCHEMAS_ENABLED
+    if ((reader->validate == XML_TEXTREADER_VALIDATE_RNG) &&
+               (reader->rngValidCtxt != NULL)) {
+	int ret;
+
+	if (reader->rngFullNode != NULL) return;
+	ret = xmlRelaxNGValidatePushCData(reader->rngValidCtxt, data, len);
+	if (ret != 1)
+	    reader->rngValidErrors++;
+    }
+#endif
+}
+
+/**
+ * xmlTextReaderValidatePop:
+ * @reader:  the xmlTextReaderPtr used
+ *
+ * Pop the current node from validation
+ */
+static void
+xmlTextReaderValidatePop(xmlTextReaderPtr reader) {
+    xmlNodePtr node = reader->node;
+
+#ifdef LIBXML_VALID_ENABLED
+    if ((reader->validate == XML_TEXTREADER_VALIDATE_DTD) &&
+        (reader->ctxt != NULL) && (reader->ctxt->validate == 1)) {
+	if ((node->ns == NULL) || (node->ns->prefix == NULL)) {
+	    reader->ctxt->valid &= xmlValidatePopElement(&reader->ctxt->vctxt,
+				    reader->ctxt->myDoc, node, node->name);
+	} else {
+	    /* TODO use the BuildQName interface */
+	    xmlChar *qname;
+
+	    qname = xmlStrdup(node->ns->prefix);
+	    qname = xmlStrcat(qname, BAD_CAST ":");
+	    qname = xmlStrcat(qname, node->name);
+	    reader->ctxt->valid &= xmlValidatePopElement(&reader->ctxt->vctxt,
+				    reader->ctxt->myDoc, node, qname);
+	    if (qname != NULL)
+		xmlFree(qname);
+	}
+    }
+#endif /* LIBXML_VALID_ENABLED */
+#ifdef LIBXML_SCHEMAS_ENABLED
+    if ((reader->validate == XML_TEXTREADER_VALIDATE_RNG) &&
+               (reader->rngValidCtxt != NULL)) {
+	int ret;
+
+	if (reader->rngFullNode != NULL) {
+	    if (node == reader->rngFullNode) 
+	        reader->rngFullNode = NULL;
+	    return;
+	}
+	ret = xmlRelaxNGValidatePopElement(reader->rngValidCtxt,
+	                                   reader->ctxt->myDoc,
+					   node);
+	if (ret != 1)
+	    reader->rngValidErrors++;
+    }
+#endif
+}
+
+/**
+ * xmlTextReaderValidateEntity:
+ * @reader:  the xmlTextReaderPtr used
+ *
+ * Handle the validation when an entity reference is encountered and
+ * entity substitution is not activated. As a result the parser interface
+ * must walk through the entity and do the validation calls
+ */
+static void
+xmlTextReaderValidateEntity(xmlTextReaderPtr reader) {
+    xmlNodePtr oldnode = reader->node;
+    xmlNodePtr node = reader->node;
+    xmlParserCtxtPtr ctxt = reader->ctxt;
+
+    do {
+	if (node->type == XML_ENTITY_REF_NODE) {
+	    /*
+	     * Case where the underlying tree is not availble, lookup the entity
+	     * and walk it.
+	     */
+	    if ((node->children == NULL) && (ctxt->sax != NULL) &&
+		(ctxt->sax->getEntity != NULL)) {
+		node->children = (xmlNodePtr) 
+		    ctxt->sax->getEntity(ctxt, node->name);
+	    }
+
+	    if ((node->children != NULL) &&
+		(node->children->type == XML_ENTITY_DECL) &&
+		(node->children->children != NULL)) {
+		xmlTextReaderEntPush(reader, node);
+		node = node->children->children;
+		continue;
+	    } else {
+		/*
+		 * The error has probably be raised already.
+		 */
+		if (node == oldnode)
+		    break;
+		node = node->next;
+	    }
+#ifdef LIBXML_REGEXP_ENABLED
+	} else if (node->type == XML_ELEMENT_NODE) {
+	    reader->node = node;
+	    xmlTextReaderValidatePush(reader);
+	} else if ((node->type == XML_TEXT_NODE) ||
+		   (node->type == XML_CDATA_SECTION_NODE)) {
+            xmlTextReaderValidateCData(reader, node->content,
+	                               xmlStrlen(node->content));
+#endif
+	}
+
+	/*
+	 * go to next node
+	 */
+	if (node->children != NULL) {
+	    node = node->children;
+	    continue;
+	} else if (node->type == XML_ELEMENT_NODE) {
+	    xmlTextReaderValidatePop(reader);
+	}
+	if (node->next != NULL) {
+	    node = node->next;
+	    continue;
+	}
+	do {
+	    node = node->parent;
+	    if (node->type == XML_ELEMENT_NODE) {
+	        xmlNodePtr tmp;
+		if (reader->entNr == 0) {
+		    while ((tmp = node->last) != NULL) {
+			if ((tmp->extra & NODE_IS_PRESERVED) == 0) {
+			    xmlUnlinkNode(tmp);
+			    xmlTextReaderFreeNode(reader, tmp);
+			} else
+			    break;
+		    }
+		}
+		reader->node = node;
+		xmlTextReaderValidatePop(reader);
+	    }
+	    if ((node->type == XML_ENTITY_DECL) &&
+		(reader->ent != NULL) && (reader->ent->children == node)) {
+		node = xmlTextReaderEntPop(reader);
+	    }
+	    if (node == oldnode)
+		break;
+	    if (node->next != NULL) {
+		node = node->next;
+		break;
+	    }
+	} while ((node != NULL) && (node != oldnode));
+    } while ((node != NULL) && (node != oldnode));
+    reader->node = oldnode;
+}
+#endif /* LIBXML_REGEXP_ENABLED */
+
+
+/**
+ * xmlTextReaderGetSuccessor:
+ * @cur:  the current node
+ *
+ * Get the successor of a node if available.
+ *
+ * Returns the successor node or NULL
+ */
+static xmlNodePtr
+xmlTextReaderGetSuccessor(xmlNodePtr cur) {
+    if (cur == NULL) return(NULL) ; /* ERROR */
+    if (cur->next != NULL) return(cur->next) ;
+    do {
+        cur = cur->parent;
+        if (cur == NULL) return(NULL);
+        if (cur->next != NULL) return(cur->next);
+    } while (cur != NULL);
+    return(cur);
+}
+
+/**
+ * xmlTextReaderDoExpand:
+ * @reader:  the xmlTextReaderPtr used
+ *
+ * Makes sure that the current node is fully read as well as all its
+ * descendant. It means the full DOM subtree must be available at the
+ * end of the call.
+ *
+ * Returns 1 if the node was expanded successfully, 0 if there is no more
+ *          nodes to read, or -1 in case of error
+ */
+static int
+xmlTextReaderDoExpand(xmlTextReaderPtr reader) {
+    int val;
+
+    if ((reader == NULL) || (reader->node == NULL) || (reader->ctxt == NULL))
+        return(-1);
+    do {
+	if (reader->ctxt->instate == XML_PARSER_EOF) return(1);
+
+        if (xmlTextReaderGetSuccessor(reader->node) != NULL)
+	    return(1);
+	if (reader->ctxt->nodeNr < reader->depth)
+	    return(1);
+	if (reader->mode == XML_TEXTREADER_MODE_EOF)
+	    return(1);
+	val = xmlTextReaderPushData(reader);
+	if (val < 0)
+	    return(-1);
+    } while(reader->mode != XML_TEXTREADER_MODE_EOF);
+    return(1);
+}
+
+/**
+ * xmlTextReaderRead:
+ * @reader:  the xmlTextReaderPtr used
+ *
+ *  Moves the position of the current instance to the next node in
+ *  the stream, exposing its properties.
+ *
+ *  Returns 1 if the node was read successfully, 0 if there is no more
+ *          nodes to read, or -1 in case of error
+ */
+int
+xmlTextReaderRead(xmlTextReaderPtr reader) {
+    int val, olddepth = 0;
+    xmlTextReaderState oldstate = XML_TEXTREADER_START;
+    xmlNodePtr oldnode = NULL;
+
+    
+    if (reader == NULL)
+	return(-1);
+    if (reader->doc != NULL)
+        return(xmlTextReaderReadTree(reader));
+    if (reader->ctxt == NULL)
+	return(-1);
+    if (reader->ctxt->wellFormed != 1)
+	return(-1);
+
+#ifdef DEBUG_READER
+    fprintf(stderr, "\nREAD ");
+    DUMP_READER
+#endif
+    reader->curnode = NULL;
+    if (reader->mode == XML_TEXTREADER_MODE_INITIAL) {
+	reader->mode = XML_TEXTREADER_MODE_INTERACTIVE;
+	/*
+	 * Initial state
+	 */
+	do {
+	    val = xmlTextReaderPushData(reader);
+	    if (val < 0)
+		return(-1);
+	} while ((reader->ctxt->node == NULL) &&
+		 ((reader->mode != XML_TEXTREADER_MODE_EOF) &&
+		  (reader->mode != XML_TEXTREADER_DONE)));
+	if (reader->ctxt->node == NULL) {
+	    if (reader->ctxt->myDoc != NULL) {
+		reader->node = reader->ctxt->myDoc->children;
+	    }
+	    if (reader->node == NULL)
+		return(-1);
+	    reader->state = XML_TEXTREADER_ELEMENT;
+	} else {
+	    if (reader->ctxt->myDoc != NULL) {
+		reader->node = reader->ctxt->myDoc->children;
+	    }
+	    if (reader->node == NULL)
+		reader->node = reader->ctxt->nodeTab[0];
+	    reader->state = XML_TEXTREADER_ELEMENT;
+	}
+	reader->depth = 0;
+	goto node_found;
+    }
+    oldstate = reader->state;
+    olddepth = reader->ctxt->nodeNr;
+    oldnode = reader->node;
+
+get_next_node:
+    /*
+     * If we are not backtracking on ancestors or examined nodes,
+     * that the parser didn't finished or that we arent at the end
+     * of stream, continue processing.
+     */
+    while ((reader->node->next == NULL) &&
+	   (reader->ctxt->nodeNr == olddepth) &&
+           ((oldstate == XML_TEXTREADER_BACKTRACK) ||
+            (reader->node->children == NULL) ||
+	    (reader->node->type == XML_ENTITY_REF_NODE) ||
+	    ((reader->node->children != NULL) &&
+	     (reader->node->children->type == XML_TEXT_NODE) &&
+	     (reader->node->children->next == NULL)) ||
+	    (reader->node->type == XML_DTD_NODE) ||
+	    (reader->node->type == XML_DOCUMENT_NODE) ||
+	    (reader->node->type == XML_HTML_DOCUMENT_NODE)) &&
+	   ((reader->ctxt->node == NULL) ||
+	    (reader->ctxt->node == reader->node) ||
+	    (reader->ctxt->node == reader->node->parent)) &&
+	   (reader->ctxt->instate != XML_PARSER_EOF)) {
+	val = xmlTextReaderPushData(reader);
+	if (val < 0)
+	    return(-1);
+	if (reader->node == NULL)
+	    goto node_end;
+    }
+    if (oldstate != XML_TEXTREADER_BACKTRACK) {
+	if ((reader->node->children != NULL) &&
+	    (reader->node->type != XML_ENTITY_REF_NODE) &&
+	    (reader->node->type != XML_XINCLUDE_START) &&
+	    (reader->node->type != XML_DTD_NODE)) {
+	    reader->node = reader->node->children;
+	    reader->depth++;
+	    reader->state = XML_TEXTREADER_ELEMENT;
+	    goto node_found;
+	}
+    }
+    if (reader->node->next != NULL) {
+	if ((oldstate == XML_TEXTREADER_ELEMENT) &&
+            (reader->node->type == XML_ELEMENT_NODE) &&
+	    (reader->node->children == NULL) &&
+	    ((reader->node->extra & NODE_IS_EMPTY) == 0)
+#ifdef LIBXML_XINCLUDE_ENABLED
+	    && (reader->in_xinclude <= 0)
+#endif
+	    ) {
+	    reader->state = XML_TEXTREADER_END;
+	    goto node_found;
+	}
+#ifdef LIBXML_REGEXP_ENABLED
+	if ((reader->validate) &&
+	    (reader->node->type == XML_ELEMENT_NODE))
+	    xmlTextReaderValidatePop(reader);
+#endif /* LIBXML_REGEXP_ENABLED */
+        if ((reader->preserves > 0) &&
+	    (reader->node->extra & NODE_IS_SPRESERVED))
+	    reader->preserves--;
+	reader->node = reader->node->next;
+	reader->state = XML_TEXTREADER_ELEMENT;
+
+	/*
+	 * Cleanup of the old node
+	 */
+	if ((reader->preserves == 0) &&
+#ifdef LIBXML_XINCLUDE_ENABLED
+	    (reader->in_xinclude == 0) &&
+#endif
+	    (reader->entNr == 0) &&
+	    (reader->node->prev != NULL) &&
+            (reader->node->prev->type != XML_DTD_NODE) &&
+	    (reader->entNr == 0)) {
+	    xmlNodePtr tmp = reader->node->prev;
+	    if ((tmp->extra & NODE_IS_PRESERVED) == 0) {
+		xmlUnlinkNode(tmp);
+		xmlTextReaderFreeNode(reader, tmp);
+	    }
+	}
+
+	goto node_found;
+    }
+    if ((oldstate == XML_TEXTREADER_ELEMENT) &&
+	(reader->node->type == XML_ELEMENT_NODE) &&
+	(reader->node->children == NULL) &&
+	((reader->node->extra & NODE_IS_EMPTY) == 0)) {;
+	reader->state = XML_TEXTREADER_END;
+	goto node_found;
+    }
+#ifdef LIBXML_REGEXP_ENABLED
+    if ((reader->validate) && (reader->node->type == XML_ELEMENT_NODE))
+	xmlTextReaderValidatePop(reader);
+#endif /* LIBXML_REGEXP_ENABLED */
+    if ((reader->preserves > 0) &&
+	(reader->node->extra & NODE_IS_SPRESERVED))
+	reader->preserves--;
+    reader->node = reader->node->parent;
+    if ((reader->node == NULL) ||
+	(reader->node->type == XML_DOCUMENT_NODE) ||
+#ifdef LIBXML_DOCB_ENABLED
+	(reader->node->type == XML_DOCB_DOCUMENT_NODE) ||
+#endif
+	(reader->node->type == XML_HTML_DOCUMENT_NODE)) {
+	if (reader->mode != XML_TEXTREADER_DONE) {
+	    val = xmlParseChunk(reader->ctxt, "", 0, 1);
+	    reader->mode = XML_TEXTREADER_DONE;
+	}
+	reader->node = NULL;
+	reader->depth = -1;
+
+	/*
+	 * Cleanup of the old node
+	 */
+	if ((reader->preserves == 0) &&
+#ifdef LIBXML_XINCLUDE_ENABLED
+	    (reader->in_xinclude == 0) &&
+#endif
+	    (reader->entNr == 0) &&
+	    (oldnode->type != XML_DTD_NODE) &&
+	    ((oldnode->extra & NODE_IS_PRESERVED) == 0) &&
+	    (reader->entNr == 0)) {
+	    xmlUnlinkNode(oldnode);
+	    xmlTextReaderFreeNode(reader, oldnode);
+	}
+
+	goto node_end;
+    }
+    if ((reader->preserves == 0) &&
+#ifdef LIBXML_XINCLUDE_ENABLED
+        (reader->in_xinclude == 0) &&
+#endif
+	(reader->entNr == 0) &&
+        (reader->node->last != NULL) &&
+        ((reader->node->last->extra & NODE_IS_PRESERVED) == 0)) {
+	xmlNodePtr tmp = reader->node->last;
+	xmlUnlinkNode(tmp);
+	xmlTextReaderFreeNode(reader, tmp);
+    }
+    reader->depth--;
+    reader->state = XML_TEXTREADER_BACKTRACK;
+
+node_found:
+    DUMP_READER
+
+    /*
+     * If we are in the middle of a piece of CDATA make sure it's finished
+     */
+    if ((reader->node != NULL) &&
+        (reader->node->next == NULL) &&
+        ((reader->node->type == XML_TEXT_NODE) ||
+	 (reader->node->type == XML_CDATA_SECTION_NODE))) {
+            xmlTextReaderExpand(reader);
+    }
+
+#ifdef LIBXML_XINCLUDE_ENABLED
+    /*
+     * Handle XInclude if asked for
+     */
+    if ((reader->xinclude) && (reader->node != NULL) &&
+	(reader->node->type == XML_ELEMENT_NODE) &&
+	(reader->node->ns != NULL) &&
+	((xmlStrEqual(reader->node->ns->href, XINCLUDE_NS)) ||
+	 (xmlStrEqual(reader->node->ns->href, XINCLUDE_OLD_NS)))) {
+	if (reader->xincctxt == NULL) {
+	    reader->xincctxt = xmlXIncludeNewContext(reader->ctxt->myDoc);
+	    xmlXIncludeSetFlags(reader->xincctxt, reader->parserFlags);
+	}
+	/*
+	 * expand that node and process it
+	 */
+	xmlTextReaderExpand(reader);
+	xmlXIncludeProcessNode(reader->xincctxt, reader->node);
+    }
+    if (reader->node->type == XML_XINCLUDE_START) {
+        reader->in_xinclude++;
+	goto get_next_node;
+    } 
+    if (reader->node->type == XML_XINCLUDE_END) {
+        reader->in_xinclude--;
+	goto get_next_node;
+    }
+#endif
+    /*
+     * Handle entities enter and exit when in entity replacement mode
+     */
+    if ((reader->node != NULL) &&
+	(reader->node->type == XML_ENTITY_REF_NODE) &&
+	(reader->ctxt != NULL) && (reader->ctxt->replaceEntities == 1)) {
+	/*
+	 * Case where the underlying tree is not availble, lookup the entity
+	 * and walk it.
+	 */
+	if ((reader->node->children == NULL) && (reader->ctxt->sax != NULL) &&
+	    (reader->ctxt->sax->getEntity != NULL)) {
+	    reader->node->children = (xmlNodePtr) 
+		reader->ctxt->sax->getEntity(reader->ctxt, reader->node->name);
+	}
+
+	if ((reader->node->children != NULL) &&
+	    (reader->node->children->type == XML_ENTITY_DECL) &&
+	    (reader->node->children->children != NULL)) {
+	    xmlTextReaderEntPush(reader, reader->node);
+	    reader->node = reader->node->children->children;
+	}
+#ifdef LIBXML_REGEXP_ENABLED
+    } else if ((reader->node != NULL) &&
+	       (reader->node->type == XML_ENTITY_REF_NODE) &&
+	       (reader->ctxt != NULL) && (reader->validate)) {
+	xmlTextReaderValidateEntity(reader);
+#endif /* LIBXML_REGEXP_ENABLED */
+    }
+    if ((reader->node != NULL) &&
+	(reader->node->type == XML_ENTITY_DECL) &&
+	(reader->ent != NULL) && (reader->ent->children == reader->node)) {
+	reader->node = xmlTextReaderEntPop(reader);
+	reader->depth++;
+        goto get_next_node;
+    }
+#ifdef LIBXML_REGEXP_ENABLED
+    if ((reader->validate) && (reader->node != NULL)) {
+	xmlNodePtr node = reader->node;
+
+	if ((node->type == XML_ELEMENT_NODE) && 
+            ((reader->state != XML_TEXTREADER_END) &&
+	     (reader->state != XML_TEXTREADER_BACKTRACK))) {
+	    xmlTextReaderValidatePush(reader);
+	} else if ((node->type == XML_TEXT_NODE) ||
+		   (node->type == XML_CDATA_SECTION_NODE)) {
+            xmlTextReaderValidateCData(reader, node->content,
+	                               xmlStrlen(node->content));
+	}
+    }
+#endif /* LIBXML_REGEXP_ENABLED */
+#ifdef LIBXML_PATTERN_ENABLED
+    if ((reader->patternNr > 0) && (reader->state != XML_TEXTREADER_END) &&
+        (reader->state != XML_TEXTREADER_BACKTRACK)) {
+        int i;
+	for (i = 0;i < reader->patternNr;i++) {
+	     if (xmlPatternMatch(reader->patternTab[i], reader->node) == 1) {
+	         xmlTextReaderPreserve(reader);
+		 break;
+             }
+	}
+    }
+#endif /* LIBXML_PATTERN_ENABLED */
+    return(1);
+node_end:
+    reader->mode = XML_TEXTREADER_DONE;
+    return(0);
+}
+
+/**
+ * xmlTextReaderReadState:
+ * @reader:  the xmlTextReaderPtr used
+ *
+ * Gets the read state of the reader.
+ *
+ * Returns the state value, or -1 in case of error
+ */
+int
+xmlTextReaderReadState(xmlTextReaderPtr reader) {
+    if (reader == NULL)
+	return(-1);
+    return(reader->mode);
+}
+
+/**
+ * xmlTextReaderExpand:
+ * @reader:  the xmlTextReaderPtr used
+ *
+ * Reads the contents of the current node and the full subtree. It then makes
+ * the subtree available until the next xmlTextReaderRead() call
+ *
+ * Returns a node pointer valid until the next xmlTextReaderRead() call
+ *         or NULL in case of error.
+ */
+xmlNodePtr
+xmlTextReaderExpand(xmlTextReaderPtr reader) {
+    if ((reader == NULL) || (reader->node == NULL))
+        return(NULL);
+    if (reader->doc != NULL)
+        return(reader->node);
+    if (reader->ctxt == NULL)
+        return(NULL);
+    if (xmlTextReaderDoExpand(reader) < 0)
+        return(NULL);
+    return(reader->node);
+}
+
+/**
+ * xmlTextReaderNext:
+ * @reader:  the xmlTextReaderPtr used
+ *
+ * Skip to the node following the current one in document order while
+ * avoiding the subtree if any.
+ *
+ * Returns 1 if the node was read successfully, 0 if there is no more
+ *          nodes to read, or -1 in case of error
+ */
+int
+xmlTextReaderNext(xmlTextReaderPtr reader) {
+    int ret;
+    xmlNodePtr cur;
+
+    if (reader == NULL)
+	return(-1);
+    if (reader->doc != NULL)
+        return(xmlTextReaderNextTree(reader));
+    cur = reader->node;
+    if ((cur == NULL) || (cur->type != XML_ELEMENT_NODE))
+        return(xmlTextReaderRead(reader));
+    if (reader->state == XML_TEXTREADER_END)
+        return(xmlTextReaderRead(reader));
+    if (cur->extra & NODE_IS_EMPTY)
+        return(xmlTextReaderRead(reader));
+    do {
+        ret = xmlTextReaderRead(reader);
+	if (ret != 1)
+	    return(ret);
+    } while (reader->node != cur);
+    return(xmlTextReaderRead(reader));
+}
+
+/**
+ * xmlTextReaderReadInnerXml:
+ * @reader:  the xmlTextReaderPtr used
+ *
+ * Reads the contents of the current node, including child nodes and markup.
+ *
+ * Returns a string containing the XML content, or NULL if the current node
+ *         is neither an element nor attribute, or has no child nodes. The 
+ *         string must be deallocated by the caller.
+ */
+xmlChar *
+xmlTextReaderReadInnerXml(xmlTextReaderPtr reader ATTRIBUTE_UNUSED) {
+    TODO
+    return(NULL);
+}
+
+/**
+ * xmlTextReaderReadOuterXml:
+ * @reader:  the xmlTextReaderPtr used
+ *
+ * Reads the contents of the current node, including child nodes and markup.
+ *
+ * Returns a string containing the XML content, or NULL if the current node
+ *         is neither an element nor attribute, or has no child nodes. The 
+ *         string must be deallocated by the caller.
+ */
+xmlChar *
+xmlTextReaderReadOuterXml(xmlTextReaderPtr reader ATTRIBUTE_UNUSED) {
+    TODO
+    return(NULL);
+}
+
+/**
+ * xmlTextReaderReadString:
+ * @reader:  the xmlTextReaderPtr used
+ *
+ * Reads the contents of an element or a text node as a string.
+ *
+ * Returns a string containing the contents of the Element or Text node,
+ *         or NULL if the reader is positioned on any other type of node.
+ *         The string must be deallocated by the caller.
+ */
+xmlChar *
+xmlTextReaderReadString(xmlTextReaderPtr reader ATTRIBUTE_UNUSED) {
+    TODO
+    return(NULL);
+}
+
+#if 0
+/**
+ * xmlTextReaderReadBase64:
+ * @reader:  the xmlTextReaderPtr used
+ * @array:  a byte array to store the content.
+ * @offset:  the zero-based index into array where the method should
+ *           begin to write.
+ * @len:  the number of bytes to write.
+ *
+ * Reads and decodes the Base64 encoded contents of an element and
+ * stores the result in a byte buffer.
+ *
+ * Returns the number of bytes written to array, or zero if the current
+ *         instance is not positioned on an element or -1 in case of error.
+ */
+int
+xmlTextReaderReadBase64(xmlTextReaderPtr reader,
+                        unsigned char *array ATTRIBUTE_UNUSED,
+	                int offset ATTRIBUTE_UNUSED,
+			int len ATTRIBUTE_UNUSED) {
+    if ((reader == NULL) || (reader->ctxt == NULL))
+	return(-1);
+    if (reader->ctxt->wellFormed != 1)
+	return(-1);
+
+    if ((reader->node == NULL) || (reader->node->type == XML_ELEMENT_NODE))
+	return(0);
+    TODO
+    return(0);
+}
+
+/**
+ * xmlTextReaderReadBinHex:
+ * @reader:  the xmlTextReaderPtr used
+ * @array:  a byte array to store the content.
+ * @offset:  the zero-based index into array where the method should
+ *           begin to write.
+ * @len:  the number of bytes to write.
+ *
+ * Reads and decodes the BinHex encoded contents of an element and
+ * stores the result in a byte buffer.
+ *
+ * Returns the number of bytes written to array, or zero if the current
+ *         instance is not positioned on an element or -1 in case of error.
+ */
+int
+xmlTextReaderReadBinHex(xmlTextReaderPtr reader,
+                        unsigned char *array ATTRIBUTE_UNUSED,
+	                int offset ATTRIBUTE_UNUSED,
+			int len ATTRIBUTE_UNUSED) {
+    if ((reader == NULL) || (reader->ctxt == NULL))
+	return(-1);
+    if (reader->ctxt->wellFormed != 1)
+	return(-1);
+
+    if ((reader->node == NULL) || (reader->node->type == XML_ELEMENT_NODE))
+	return(0);
+    TODO
+    return(0);
+}
+#endif
+
+/************************************************************************
+ *									*
+ *			Operating on a preparsed tree			*
+ *									*
+ ************************************************************************/
+static int
+xmlTextReaderNextTree(xmlTextReaderPtr reader)
+{
+    if (reader == NULL)
+        return(-1);
+
+    if (reader->state == XML_TEXTREADER_END)
+        return(0);
+
+    if (reader->node == NULL) {
+        if (reader->doc->children == NULL) {
+            reader->state = XML_TEXTREADER_END;
+            return(0);
+        }
+
+        reader->node = reader->doc->children;
+        reader->state = XML_TEXTREADER_START;
+        return(1);
+    }
+
+    if (reader->state != XML_TEXTREADER_BACKTRACK) {
+        if (reader->node->children != 0) {
+            reader->node = reader->node->children;
+            reader->depth++;
+            reader->state = XML_TEXTREADER_START;
+            return(1);
+        }
+
+        if ((reader->node->type == XML_ELEMENT_NODE) ||
+            (reader->node->type == XML_ATTRIBUTE_NODE)) {
+            reader->state = XML_TEXTREADER_BACKTRACK;
+            return(1);
+        }
+    }
+
+    if (reader->node->next != 0) {
+        reader->node = reader->node->next;
+        reader->state = XML_TEXTREADER_START;
+        return(1);
+    }
+
+    if (reader->node->parent != 0) {
+        if (reader->node->parent->type == XML_DOCUMENT_NODE) {
+            reader->state = XML_TEXTREADER_END;
+            return(0);
+        }
+
+        reader->node = reader->node->parent;
+        reader->depth--;
+        reader->state = XML_TEXTREADER_BACKTRACK;
+        return(1);
+    }
+
+    reader->state = XML_TEXTREADER_END;
+
+    return(1);
+}
+
+/**
+ * xmlTextReaderReadTree:
+ * @reader:  the xmlTextReaderPtr used
+ *
+ *  Moves the position of the current instance to the next node in
+ *  the stream, exposing its properties.
+ *
+ *  Returns 1 if the node was read successfully, 0 if there is no more
+ *          nodes to read, or -1 in case of error
+ */
+static int
+xmlTextReaderReadTree(xmlTextReaderPtr reader) {
+    if (reader->state == XML_TEXTREADER_END)
+        return(0);
+
+next_node:
+    if (reader->node == NULL) {
+        if (reader->doc->children == NULL) {
+            reader->state = XML_TEXTREADER_END;
+            return(0);
+        }
+
+        reader->node = reader->doc->children;
+        reader->state = XML_TEXTREADER_START;
+        goto found_node;
+    }
+
+    if ((reader->state != XML_TEXTREADER_BACKTRACK) &&
+        (reader->node->type != XML_DTD_NODE) &&
+        (reader->node->type != XML_XINCLUDE_START) &&
+	(reader->node->type != XML_ENTITY_REF_NODE)) {
+        if (reader->node->children != NULL) {
+            reader->node = reader->node->children;
+            reader->depth++;
+            reader->state = XML_TEXTREADER_START;
+            goto found_node;
+        }
+
+        if (reader->node->type == XML_ATTRIBUTE_NODE) {
+            reader->state = XML_TEXTREADER_BACKTRACK;
+            goto found_node;
+        }
+    }
+
+    if (reader->node->next != NULL) {
+        reader->node = reader->node->next;
+        reader->state = XML_TEXTREADER_START;
+        goto found_node;
+    }
+
+    if (reader->node->parent != NULL) {
+        if ((reader->node->parent->type == XML_DOCUMENT_NODE) ||
+	    (reader->node->parent->type == XML_HTML_DOCUMENT_NODE)) {
+            reader->state = XML_TEXTREADER_END;
+            return(0);
+        }
+
+        reader->node = reader->node->parent;
+        reader->depth--;
+        reader->state = XML_TEXTREADER_BACKTRACK;
+        goto found_node;
+    }
+
+    reader->state = XML_TEXTREADER_END;
+
+found_node:
+    if ((reader->node->type == XML_XINCLUDE_START) ||
+        (reader->node->type == XML_XINCLUDE_END))
+	goto next_node;
+
+    return(1);
+}
+
+/**
+ * xmlTextReaderNextSibling:
+ * @reader:  the xmlTextReaderPtr used
+ *
+ * Skip to the node following the current one in document order while
+ * avoiding the subtree if any.
+ * Currently implemented only for Readers built on a document
+ *
+ * Returns 1 if the node was read successfully, 0 if there is no more
+ *          nodes to read, or -1 in case of error
+ */
+int
+xmlTextReaderNextSibling(xmlTextReaderPtr reader) {
+    if (reader == NULL)
+        return(-1);
+    if (reader->doc == NULL) {
+        TODO
+	return(-1);
+    }
+
+    if (reader->state == XML_TEXTREADER_END)
+        return(0);
+
+    if (reader->node == NULL)
+        return(xmlTextReaderNextTree(reader));
+
+    if (reader->node->next != NULL) {
+        reader->node = reader->node->next;
+        reader->state = XML_TEXTREADER_START;
+        return(1);
+    }
+
+    return(0);
+}
+
+/************************************************************************
+ *									*
+ *			Constructor and destructors			*
+ *									*
+ ************************************************************************/
+/**
+ * xmlNewTextReader:
+ * @input: the xmlParserInputBufferPtr used to read data
+ * @URI: the URI information for the source if available
+ *
+ * Create an xmlTextReader structure fed with @input
+ *
+ * Returns the new xmlTextReaderPtr or NULL in case of error
+ */
+xmlTextReaderPtr
+xmlNewTextReader(xmlParserInputBufferPtr input, const char *URI) {
+    xmlTextReaderPtr ret;
+
+    if (input == NULL)
+	return(NULL);
+    ret = xmlMalloc(sizeof(xmlTextReader));
+    if (ret == NULL) {
+        xmlGenericError(xmlGenericErrorContext,
+		"xmlNewTextReader : malloc failed\n");
+	return(NULL);
+    }
+    memset(ret, 0, sizeof(xmlTextReader));
+    ret->doc = NULL;
+    ret->entTab = NULL;
+    ret->entMax = 0;
+    ret->entNr = 0;
+    ret->input = input;
+    ret->buffer = xmlBufferCreateSize(100);
+    ret->sax = (xmlSAXHandler *) xmlMalloc(sizeof(xmlSAXHandler));
+    if (ret->sax == NULL) {
+	xmlFree(ret);
+        xmlGenericError(xmlGenericErrorContext,
+		"xmlNewTextReader : malloc failed\n");
+	return(NULL);
+    }
+    xmlSAXVersion(ret->sax, 2);
+    ret->startElement = ret->sax->startElement;
+    ret->sax->startElement = xmlTextReaderStartElement;
+    ret->endElement = ret->sax->endElement;
+    ret->sax->endElement = xmlTextReaderEndElement;
+#ifdef LIBXML_SAX1_ENABLED
+    if (ret->sax->initialized == XML_SAX2_MAGIC) {
+#endif /* LIBXML_SAX1_ENABLED */
+	ret->startElementNs = ret->sax->startElementNs;
+	ret->sax->startElementNs = xmlTextReaderStartElementNs;
+	ret->endElementNs = ret->sax->endElementNs;
+	ret->sax->endElementNs = xmlTextReaderEndElementNs;
+#ifdef LIBXML_SAX1_ENABLED
+    } else {
+	ret->startElementNs = NULL;
+	ret->endElementNs = NULL;
+    }
+#endif /* LIBXML_SAX1_ENABLED */
+    ret->characters = ret->sax->characters;
+    ret->sax->characters = xmlTextReaderCharacters;
+    ret->sax->ignorableWhitespace = xmlTextReaderCharacters;
+    ret->cdataBlock = ret->sax->cdataBlock;
+    ret->sax->cdataBlock = xmlTextReaderCDataBlock;
+
+    ret->mode = XML_TEXTREADER_MODE_INITIAL;
+    ret->node = NULL;
+    ret->curnode = NULL;
+    if (ret->input->buffer->use < 4) {
+	xmlParserInputBufferRead(input, 4);
+    }
+    if (ret->input->buffer->use >= 4) {
+	ret->ctxt = xmlCreatePushParserCtxt(ret->sax, NULL,
+			(const char *) ret->input->buffer->content, 4, URI);
+	ret->base = 0;
+	ret->cur = 4;
+    } else {
+	ret->ctxt = xmlCreatePushParserCtxt(ret->sax, NULL, NULL, 0, URI);
+	ret->base = 0;
+	ret->cur = 0;
+    }
+    if (ret->ctxt == NULL) {
+        xmlGenericError(xmlGenericErrorContext,
+		"xmlNewTextReader : malloc failed\n");
+	xmlFree(ret->sax);
+	xmlFree(ret);
+	return(NULL);
+    }
+    ret->ctxt->_private = ret;
+    ret->ctxt->linenumbers = 1;
+    ret->ctxt->dictNames = 1;
+    ret->allocs = XML_TEXTREADER_CTXT;
+    /*
+     * use the parser dictionnary to allocate all elements and attributes names
+     */
+    ret->ctxt->docdict = 1;
+    ret->dict = ret->ctxt->dict;
+#ifdef LIBXML_XINCLUDE_ENABLED
+    ret->xinclude = 0;
+#endif
+#ifdef LIBXML_PATTERN_ENABLED
+    ret->patternMax = 0;
+    ret->patternTab = NULL;
+#endif
+    return(ret);
+}
+
+/**
+ * xmlNewTextReaderFilename:
+ * @URI: the URI of the resource to process
+ *
+ * Create an xmlTextReader structure fed with the resource at @URI
+ *
+ * Returns the new xmlTextReaderPtr or NULL in case of error
+ */
+xmlTextReaderPtr
+xmlNewTextReaderFilename(const char *URI) {
+    xmlParserInputBufferPtr input;
+    xmlTextReaderPtr ret;
+    char *directory = NULL;
+
+    input = xmlParserInputBufferCreateFilename(URI, XML_CHAR_ENCODING_NONE);
+    if (input == NULL)
+	return(NULL);
+    ret = xmlNewTextReader(input, URI);
+    if (ret == NULL) {
+	xmlFreeParserInputBuffer(input);
+	return(NULL);
+    }
+    ret->allocs |= XML_TEXTREADER_INPUT;
+    if (ret->ctxt->directory == NULL)
+        directory = xmlParserGetDirectory(URI);
+    if ((ret->ctxt->directory == NULL) && (directory != NULL))
+        ret->ctxt->directory = (char *) xmlStrdup((xmlChar *) directory);
+    if (directory != NULL)
+	xmlFree(directory);
+    return(ret);
+}
+
+/**
+ * xmlFreeTextReader:
+ * @reader:  the xmlTextReaderPtr
+ *
+ * Deallocate all the resources associated to the reader
+ */
+void
+xmlFreeTextReader(xmlTextReaderPtr reader) {
+    if (reader == NULL)
+	return;
+#ifdef LIBXML_SCHEMAS_ENABLED
+    if (reader->rngSchemas != NULL) {
+	xmlRelaxNGFree(reader->rngSchemas);
+	reader->rngSchemas = NULL;
+    }
+    if (reader->rngValidCtxt != NULL) {
+	xmlRelaxNGFreeValidCtxt(reader->rngValidCtxt);
+	reader->rngValidCtxt = NULL;
+    }
+#endif
+#ifdef LIBXML_XINCLUDE_ENABLED
+    if (reader->xincctxt != NULL)
+	xmlXIncludeFreeContext(reader->xincctxt);
+#endif
+#ifdef LIBXML_PATTERN_ENABLED
+    if (reader->patternTab != NULL) {
+        int i;
+	for (i = 0;i < reader->patternNr;i++) {
+	    if (reader->patternTab[i] != NULL)
+	        xmlFreePattern(reader->patternTab[i]);
+	}
+	xmlFree(reader->patternTab);
+    }
+#endif
+    if (reader->ctxt != NULL) {
+        if (reader->dict == reader->ctxt->dict)
+	    reader->dict = NULL;
+	if (reader->ctxt->myDoc != NULL) {
+	    if (reader->preserve == 0)
+		xmlTextReaderFreeDoc(reader, reader->ctxt->myDoc);
+	    reader->ctxt->myDoc = NULL;
+	}
+	if ((reader->ctxt->vctxt.vstateTab != NULL) &&
+	    (reader->ctxt->vctxt.vstateMax > 0)){
+	    xmlFree(reader->ctxt->vctxt.vstateTab);
+	    reader->ctxt->vctxt.vstateTab = 0;
+	    reader->ctxt->vctxt.vstateMax = 0;
+	}
+	if (reader->allocs & XML_TEXTREADER_CTXT)
+	    xmlFreeParserCtxt(reader->ctxt);
+    }
+    if (reader->sax != NULL)
+	xmlFree(reader->sax);
+    if ((reader->input != NULL)  && (reader->allocs & XML_TEXTREADER_INPUT))
+	xmlFreeParserInputBuffer(reader->input);
+    if (reader->faketext != NULL) {
+	xmlFreeNode(reader->faketext);
+    }
+    if (reader->buffer != NULL)
+        xmlBufferFree(reader->buffer);
+    if (reader->entTab != NULL)
+	xmlFree(reader->entTab);
+    if (reader->dict != NULL)
+        xmlDictFree(reader->dict);
+    xmlFree(reader);
+}
+
+/************************************************************************
+ *									*
+ *			Methods for XmlTextReader			*
+ *									*
+ ************************************************************************/
+/**
+ * xmlTextReaderClose:
+ * @reader:  the xmlTextReaderPtr used
+ *
+ * This method releases any resources allocated by the current instance
+ * changes the state to Closed and close any underlying input.
+ *
+ * Returns 0 or -1 in case of error
+ */
+int
+xmlTextReaderClose(xmlTextReaderPtr reader) {
+    if (reader == NULL)
+	return(-1);
+    reader->node = NULL;
+    reader->curnode = NULL;
+    reader->mode = XML_TEXTREADER_MODE_CLOSED;
+    if (reader->ctxt != NULL) {
+	xmlStopParser(reader->ctxt);
+	if (reader->ctxt->myDoc != NULL) {
+	    if (reader->preserve == 0)
+		xmlTextReaderFreeDoc(reader, reader->ctxt->myDoc);
+	    reader->ctxt->myDoc = NULL;
+	}
+    }
+    if ((reader->input != NULL)  && (reader->allocs & XML_TEXTREADER_INPUT)) {
+	xmlFreeParserInputBuffer(reader->input);
+	reader->allocs -= XML_TEXTREADER_INPUT;
+    }
+    return(0);
+}
+
+/**
+ * xmlTextReaderGetAttributeNo:
+ * @reader:  the xmlTextReaderPtr used
+ * @no: the zero-based index of the attribute relative to the containing element
+ *
+ * Provides the value of the attribute with the specified index relative
+ * to the containing element.
+ *
+ * Returns a string containing the value of the specified attribute, or NULL
+ *    in case of error. The string must be deallocated by the caller.
+ */
+xmlChar *
+xmlTextReaderGetAttributeNo(xmlTextReaderPtr reader, int no) {
+    xmlChar *ret;
+    int i;
+    xmlAttrPtr cur;
+    xmlNsPtr ns;
+
+    if (reader == NULL)
+	return(NULL);
+    if (reader->node == NULL)
+	return(NULL);
+    if (reader->curnode != NULL)
+	return(NULL);
+    /* TODO: handle the xmlDecl */
+    if (reader->node->type != XML_ELEMENT_NODE) 
+	return(NULL);
+
+    ns = reader->node->nsDef;
+    for (i = 0;(i < no) && (ns != NULL);i++) {
+	ns = ns->next;
+    }
+    if (ns != NULL)
+	return(xmlStrdup(ns->href));
+
+    cur = reader->node->properties;
+    if (cur == NULL)
+	return(NULL);
+    for (;i < no;i++) {
+	cur = cur->next;
+	if (cur == NULL)
+	    return(NULL);
+    }
+    /* TODO walk the DTD if present */
+
+    ret = xmlNodeListGetString(reader->node->doc, cur->children, 1);
+    if (ret == NULL) return(xmlStrdup((xmlChar *)""));
+    return(ret);
+}
+
+/**
+ * xmlTextReaderGetAttribute:
+ * @reader:  the xmlTextReaderPtr used
+ * @name: the qualified name of the attribute.
+ *
+ * Provides the value of the attribute with the specified qualified name.
+ *
+ * Returns a string containing the value of the specified attribute, or NULL
+ *    in case of error. The string must be deallocated by the caller.
+ */
+xmlChar *
+xmlTextReaderGetAttribute(xmlTextReaderPtr reader, const xmlChar *name) {
+    xmlChar *prefix = NULL;
+    xmlChar *localname;
+    xmlNsPtr ns;
+    xmlChar *ret = NULL;
+
+    if ((reader == NULL) || (name == NULL))
+	return(NULL);
+    if (reader->node == NULL)
+	return(NULL);
+    if (reader->curnode != NULL)
+	return(NULL);
+
+    /* TODO: handle the xmlDecl */
+    if (reader->node->type != XML_ELEMENT_NODE)
+	return(NULL);
+
+    localname = xmlSplitQName2(name, &prefix);
+    if (localname == NULL)
+	return(xmlGetProp(reader->node, name));
+    
+    ns = xmlSearchNs(reader->node->doc, reader->node, prefix);
+    if (ns != NULL)
+        ret = xmlGetNsProp(reader->node, localname, ns->href);
+
+    if (localname != NULL)
+        xmlFree(localname);
+    if (prefix != NULL)
+        xmlFree(prefix);
+    return(ret);
+}
+
+
+/**
+ * xmlTextReaderGetAttributeNs:
+ * @reader:  the xmlTextReaderPtr used
+ * @localName: the local name of the attribute.
+ * @namespaceURI: the namespace URI of the attribute.
+ *
+ * Provides the value of the specified attribute
+ *
+ * Returns a string containing the value of the specified attribute, or NULL
+ *    in case of error. The string must be deallocated by the caller.
+ */
+xmlChar *
+xmlTextReaderGetAttributeNs(xmlTextReaderPtr reader, const xmlChar *localName,
+			    const xmlChar *namespaceURI) {
+    if ((reader == NULL) || (localName == NULL))
+	return(NULL);
+    if (reader->node == NULL)
+	return(NULL);
+    if (reader->curnode != NULL)
+	return(NULL);
+
+    /* TODO: handle the xmlDecl */
+    if (reader->node->type != XML_ELEMENT_NODE)
+	return(NULL);
+
+    return(xmlGetNsProp(reader->node, localName, namespaceURI));
+}
+
+/**
+ * xmlTextReaderGetRemainder:
+ * @reader:  the xmlTextReaderPtr used
+ *
+ * Method to get the remainder of the buffered XML. this method stops the
+ * parser, set its state to End Of File and return the input stream with
+ * what is left that the parser did not use.
+ *
+ * The implementation is not good, the parser certainly procgressed past
+ * what's left in reader->input, and there is an allocation problem. Best
+ * would be to rewrite it differently.
+ *
+ * Returns the xmlParserInputBufferPtr attached to the XML or NULL
+ *    in case of error.
+ */
+xmlParserInputBufferPtr
+xmlTextReaderGetRemainder(xmlTextReaderPtr reader) {
+    xmlParserInputBufferPtr ret = NULL;
+
+    if (reader == NULL)
+	return(NULL);
+    if (reader->node == NULL)
+	return(NULL);
+
+    reader->node = NULL;
+    reader->curnode = NULL;
+    reader->mode = XML_TEXTREADER_MODE_EOF;
+    if (reader->ctxt != NULL) {
+	xmlStopParser(reader->ctxt);
+	if (reader->ctxt->myDoc != NULL) {
+	    if (reader->preserve == 0)
+		xmlTextReaderFreeDoc(reader, reader->ctxt->myDoc);
+	    reader->ctxt->myDoc = NULL;
+	}
+    }
+    if (reader->allocs & XML_TEXTREADER_INPUT) {
+	ret = reader->input;
+	reader->input = NULL;
+	reader->allocs -= XML_TEXTREADER_INPUT;
+    } else {
+	/*
+	 * Hum, one may need to duplicate the data structure because
+	 * without reference counting the input may be freed twice:
+	 *   - by the layer which allocated it.
+	 *   - by the layer to which would have been returned to.
+	 */
+	TODO
+	return(NULL);
+    }
+    return(ret);
+}
+
+/**
+ * xmlTextReaderLookupNamespace:
+ * @reader:  the xmlTextReaderPtr used
+ * @prefix: the prefix whose namespace URI is to be resolved. To return
+ *          the default namespace, specify NULL
+ *
+ * Resolves a namespace prefix in the scope of the current element.
+ *
+ * Returns a string containing the namespace URI to which the prefix maps
+ *    or NULL in case of error. The string must be deallocated by the caller.
+ */
+xmlChar *
+xmlTextReaderLookupNamespace(xmlTextReaderPtr reader, const xmlChar *prefix) {
+    xmlNsPtr ns;
+
+    if (reader == NULL)
+	return(NULL);
+    if (reader->node == NULL)
+	return(NULL);
+
+    ns = xmlSearchNs(reader->node->doc, reader->node, prefix);
+    if (ns == NULL)
+	return(NULL);
+    return(xmlStrdup(ns->href));
+}
+
+/**
+ * xmlTextReaderMoveToAttributeNo:
+ * @reader:  the xmlTextReaderPtr used
+ * @no: the zero-based index of the attribute relative to the containing
+ *      element.
+ *
+ * Moves the position of the current instance to the attribute with
+ * the specified index relative to the containing element.
+ *
+ * Returns 1 in case of success, -1 in case of error, 0 if not found
+ */
+int
+xmlTextReaderMoveToAttributeNo(xmlTextReaderPtr reader, int no) {
+    int i;
+    xmlAttrPtr cur;
+    xmlNsPtr ns;
+
+    if (reader == NULL)
+	return(-1);
+    if (reader->node == NULL)
+	return(-1);
+    /* TODO: handle the xmlDecl */
+    if (reader->node->type != XML_ELEMENT_NODE) 
+	return(-1);
+
+    reader->curnode = NULL;
+
+    ns = reader->node->nsDef;
+    for (i = 0;(i < no) && (ns != NULL);i++) {
+	ns = ns->next;
+    }
+    if (ns != NULL) {
+	reader->curnode = (xmlNodePtr) ns;
+	return(1);
+    }
+
+    cur = reader->node->properties;
+    if (cur == NULL)
+	return(0);
+    for (;i < no;i++) {
+	cur = cur->next;
+	if (cur == NULL)
+	    return(0);
+    }
+    /* TODO walk the DTD if present */
+
+    reader->curnode = (xmlNodePtr) cur;
+    return(1);
+}
+
+/**
+ * xmlTextReaderMoveToAttribute:
+ * @reader:  the xmlTextReaderPtr used
+ * @name: the qualified name of the attribute.
+ *
+ * Moves the position of the current instance to the attribute with
+ * the specified qualified name.
+ *
+ * Returns 1 in case of success, -1 in case of error, 0 if not found
+ */
+int
+xmlTextReaderMoveToAttribute(xmlTextReaderPtr reader, const xmlChar *name) {
+    xmlChar *prefix = NULL;
+    xmlChar *localname;
+    xmlNsPtr ns;
+    xmlAttrPtr prop;
+
+    if ((reader == NULL) || (name == NULL))
+	return(-1);
+    if (reader->node == NULL)
+	return(-1);
+
+    /* TODO: handle the xmlDecl */
+    if (reader->node->type != XML_ELEMENT_NODE)
+	return(0);
+
+    localname = xmlSplitQName2(name, &prefix);
+    if (localname == NULL) {
+	/*
+	 * Namespace default decl
+	 */
+	if (xmlStrEqual(name, BAD_CAST "xmlns")) {
+	    ns = reader->node->nsDef;
+	    while (ns != NULL) {
+		if (ns->prefix == NULL) {
+		    reader->curnode = (xmlNodePtr) ns;
+		    return(1);
+		}
+		ns = ns->next;
+	    }
+	    return(0);
+	}
+
+	prop = reader->node->properties;
+	while (prop != NULL) {
+	    /*
+	     * One need to have
+	     *   - same attribute names
+	     *   - and the attribute carrying that namespace
+	     */
+	    if ((xmlStrEqual(prop->name, name)) &&
+		((prop->ns == NULL) || (prop->ns->prefix == NULL))) {
+		reader->curnode = (xmlNodePtr) prop;
+		return(1);
+	    }
+	    prop = prop->next;
+	}
+	return(0);
+    }
+    
+    /*
+     * Namespace default decl
+     */
+    if (xmlStrEqual(prefix, BAD_CAST "xmlns")) {
+	ns = reader->node->nsDef;
+	while (ns != NULL) {
+	    if ((ns->prefix != NULL) && (xmlStrEqual(ns->prefix, localname))) {
+		reader->curnode = (xmlNodePtr) ns;
+		goto found;
+	    }
+	    ns = ns->next;
+	}
+	goto not_found;
+    }
+    prop = reader->node->properties;
+    while (prop != NULL) {
+	/*
+	 * One need to have
+	 *   - same attribute names
+	 *   - and the attribute carrying that namespace
+	 */
+	if ((xmlStrEqual(prop->name, localname)) &&
+	    (prop->ns != NULL) && (xmlStrEqual(prop->ns->prefix, prefix))) {
+	    reader->curnode = (xmlNodePtr) prop;
+	    goto found;
+	}
+	prop = prop->next;
+    }
+not_found:
+    if (localname != NULL)
+        xmlFree(localname);
+    if (prefix != NULL)
+        xmlFree(prefix);
+    return(0);
+
+found:
+    if (localname != NULL)
+        xmlFree(localname);
+    if (prefix != NULL)
+        xmlFree(prefix);
+    return(1);
+}
+
+/**
+ * xmlTextReaderMoveToAttributeNs:
+ * @reader:  the xmlTextReaderPtr used
+ * @localName:  the local name of the attribute.
+ * @namespaceURI:  the namespace URI of the attribute.
+ *
+ * Moves the position of the current instance to the attribute with the
+ * specified local name and namespace URI.
+ *
+ * Returns 1 in case of success, -1 in case of error, 0 if not found
+ */
+int
+xmlTextReaderMoveToAttributeNs(xmlTextReaderPtr reader,
+	const xmlChar *localName, const xmlChar *namespaceURI) {
+    xmlAttrPtr prop;
+    xmlNodePtr node;
+
+    if ((reader == NULL) || (localName == NULL) || (namespaceURI == NULL))
+	return(-1);
+    if (reader->node == NULL)
+	return(-1);
+    if (reader->node->type != XML_ELEMENT_NODE)
+	return(0);
+    node = reader->node;
+
+    /*
+     * A priori reading http://www.w3.org/TR/REC-xml-names/ there is no
+     * namespace name associated to "xmlns"
+     */
+    prop = node->properties;
+    while (prop != NULL) {
+	/*
+	 * One need to have
+	 *   - same attribute names
+	 *   - and the attribute carrying that namespace
+	 */
+        if (xmlStrEqual(prop->name, localName) &&
+	    ((prop->ns != NULL) &&
+	     (xmlStrEqual(prop->ns->href, namespaceURI)))) {
+	    reader->curnode = (xmlNodePtr) prop;
+	    return(1);
+        }
+	prop = prop->next;
+    }
+    return(0);
+}
+
+/**
+ * xmlTextReaderMoveToFirstAttribute:
+ * @reader:  the xmlTextReaderPtr used
+ *
+ * Moves the position of the current instance to the first attribute
+ * associated with the current node.
+ *
+ * Returns 1 in case of success, -1 in case of error, 0 if not found
+ */
+int
+xmlTextReaderMoveToFirstAttribute(xmlTextReaderPtr reader) {
+    if (reader == NULL)
+	return(-1);
+    if (reader->node == NULL)
+	return(-1);
+    if (reader->node->type != XML_ELEMENT_NODE)
+	return(0);
+
+    if (reader->node->nsDef != NULL) {
+	reader->curnode = (xmlNodePtr) reader->node->nsDef;
+	return(1);
+    }
+    if (reader->node->properties != NULL) {
+	reader->curnode = (xmlNodePtr) reader->node->properties;
+	return(1);
+    }
+    return(0);
+}
+
+/**
+ * xmlTextReaderMoveToNextAttribute:
+ * @reader:  the xmlTextReaderPtr used
+ *
+ * Moves the position of the current instance to the next attribute
+ * associated with the current node.
+ *
+ * Returns 1 in case of success, -1 in case of error, 0 if not found
+ */
+int
+xmlTextReaderMoveToNextAttribute(xmlTextReaderPtr reader) {
+    if (reader == NULL)
+	return(-1);
+    if (reader->node == NULL)
+	return(-1);
+    if (reader->node->type != XML_ELEMENT_NODE)
+	return(0);
+    if (reader->curnode == NULL)
+	return(xmlTextReaderMoveToFirstAttribute(reader));
+
+    if (reader->curnode->type == XML_NAMESPACE_DECL) {
+	xmlNsPtr ns = (xmlNsPtr) reader->curnode;
+	if (ns->next != NULL) {
+	    reader->curnode = (xmlNodePtr) ns->next;
+	    return(1);
+	}
+	if (reader->node->properties != NULL) {
+	    reader->curnode = (xmlNodePtr) reader->node->properties;
+	    return(1);
+	}
+	return(0);
+    } else if ((reader->curnode->type == XML_ATTRIBUTE_NODE) &&
+	       (reader->curnode->next != NULL)) {
+	reader->curnode = reader->curnode->next;
+	return(1);
+    }
+    return(0);
+}
+
+/**
+ * xmlTextReaderMoveToElement:
+ * @reader:  the xmlTextReaderPtr used
+ *
+ * Moves the position of the current instance to the node that
+ * contains the current Attribute  node.
+ *
+ * Returns 1 in case of success, -1 in case of error, 0 if not moved
+ */
+int
+xmlTextReaderMoveToElement(xmlTextReaderPtr reader) {
+    if (reader == NULL)
+	return(-1);
+    if (reader->node == NULL)
+	return(-1);
+    if (reader->node->type != XML_ELEMENT_NODE)
+	return(0);
+    if (reader->curnode != NULL) {
+	reader->curnode = NULL;
+	return(1);
+    }
+    return(0);
+}
+
+/**
+ * xmlTextReaderReadAttributeValue:
+ * @reader:  the xmlTextReaderPtr used
+ *
+ * Parses an attribute value into one or more Text and EntityReference nodes.
+ *
+ * Returns 1 in case of success, 0 if the reader was not positionned on an
+ *         ttribute node or all the attribute values have been read, or -1
+ *         in case of error.
+ */
+int
+xmlTextReaderReadAttributeValue(xmlTextReaderPtr reader) {
+    if (reader == NULL)
+	return(-1);
+    if (reader->node == NULL)
+	return(-1);
+    if (reader->curnode == NULL)
+	return(0);
+    if (reader->curnode->type == XML_ATTRIBUTE_NODE) {
+	if (reader->curnode->children == NULL)
+	    return(0);
+	reader->curnode = reader->curnode->children;
+    } else if (reader->curnode->type == XML_NAMESPACE_DECL) {
+	xmlNsPtr ns = (xmlNsPtr) reader->curnode;
+
+	if (reader->faketext == NULL) {
+	    reader->faketext = xmlNewDocText(reader->node->doc, 
+		                             ns->href);
+	} else {
+            if (reader->faketext->content != NULL)
+		xmlFree(reader->faketext->content);
+	    reader->faketext->content = xmlStrdup(ns->href);
+	}
+	reader->curnode = reader->faketext;
+    } else {
+	if (reader->curnode->next == NULL)
+	    return(0);
+	reader->curnode = reader->curnode->next;
+    }
+    return(1);
+}
+
+/************************************************************************
+ *									*
+ *			Acces API to the current node			*
+ *									*
+ ************************************************************************/
+/**
+ * xmlTextReaderAttributeCount:
+ * @reader:  the xmlTextReaderPtr used
+ *
+ * Provides the number of attributes of the current node
+ *
+ * Returns 0 i no attributes, -1 in case of error or the attribute count
+ */
+int
+xmlTextReaderAttributeCount(xmlTextReaderPtr reader) {
+    int ret;
+    xmlAttrPtr attr;
+    xmlNsPtr ns;
+    xmlNodePtr node;
+
+    if (reader == NULL)
+	return(-1);
+    if (reader->node == NULL)
+	return(0);
+    
+    if (reader->curnode != NULL)
+	node = reader->curnode;
+    else
+	node = reader->node;
+
+    if (node->type != XML_ELEMENT_NODE)
+	return(0);
+    if ((reader->state == XML_TEXTREADER_END) ||
+	(reader->state == XML_TEXTREADER_BACKTRACK))
+	return(0);
+    ret = 0;
+    attr = node->properties;
+    while (attr != NULL) {
+	ret++;
+	attr = attr->next;
+    }
+    ns = node->nsDef;
+    while (ns != NULL) {
+	ret++;
+	ns = ns->next;
+    }
+    return(ret);
+}
+
+/**
+ * xmlTextReaderNodeType:
+ * @reader:  the xmlTextReaderPtr used
+ *
+ * Get the node type of the current node
+ * Reference:
+ * http://dotgnu.org/pnetlib-doc/System/Xml/XmlNodeType.html
+ *
+ * Returns the xmlNodeType of the current node or -1 in case of error
+ */
+int
+xmlTextReaderNodeType(xmlTextReaderPtr reader) {
+    xmlNodePtr node;
+    
+    if (reader == NULL)
+	return(-1);
+    if (reader->node == NULL)
+	return(XML_READER_TYPE_NONE);
+    if (reader->curnode != NULL)
+	node = reader->curnode;
+    else
+	node = reader->node;
+    switch (node->type) {
+        case XML_ELEMENT_NODE:
+	    if ((reader->state == XML_TEXTREADER_END) ||
+		(reader->state == XML_TEXTREADER_BACKTRACK))
+		return(XML_READER_TYPE_END_ELEMENT);
+	    return(XML_READER_TYPE_ELEMENT);
+        case XML_NAMESPACE_DECL:
+        case XML_ATTRIBUTE_NODE:
+	    return(XML_READER_TYPE_ATTRIBUTE);
+        case XML_TEXT_NODE:
+	    if (xmlIsBlankNode(reader->node)) {
+		if (xmlNodeGetSpacePreserve(reader->node))
+		    return(XML_READER_TYPE_SIGNIFICANT_WHITESPACE);
+		else
+		    return(XML_READER_TYPE_WHITESPACE);
+	    } else {
+		return(XML_READER_TYPE_TEXT);
+	    }
+        case XML_CDATA_SECTION_NODE:
+	    return(XML_READER_TYPE_CDATA);
+        case XML_ENTITY_REF_NODE:
+	    return(XML_READER_TYPE_ENTITY_REFERENCE);
+        case XML_ENTITY_NODE:
+	    return(XML_READER_TYPE_ENTITY);
+        case XML_PI_NODE:
+	    return(XML_READER_TYPE_PROCESSING_INSTRUCTION);
+        case XML_COMMENT_NODE:
+	    return(XML_READER_TYPE_COMMENT);
+        case XML_DOCUMENT_NODE:
+        case XML_HTML_DOCUMENT_NODE:
+#ifdef LIBXML_DOCB_ENABLED
+        case XML_DOCB_DOCUMENT_NODE:
+#endif
+	    return(XML_READER_TYPE_DOCUMENT);
+        case XML_DOCUMENT_FRAG_NODE:
+	    return(XML_READER_TYPE_DOCUMENT_FRAGMENT);
+        case XML_NOTATION_NODE:
+	    return(XML_READER_TYPE_NOTATION);
+        case XML_DOCUMENT_TYPE_NODE:
+        case XML_DTD_NODE:
+	    return(XML_READER_TYPE_DOCUMENT_TYPE);
+
+        case XML_ELEMENT_DECL:
+        case XML_ATTRIBUTE_DECL:
+        case XML_ENTITY_DECL:
+        case XML_XINCLUDE_START:
+        case XML_XINCLUDE_END:
+	    return(XML_READER_TYPE_NONE);
+    }
+    return(-1);
+}
+
+/**
+ * xmlTextReaderIsEmptyElement:
+ * @reader:  the xmlTextReaderPtr used
+ *
+ * Check if the current node is empty
+ *
+ * Returns 1 if empty, 0 if not and -1 in case of error
+ */
+int
+xmlTextReaderIsEmptyElement(xmlTextReaderPtr reader) {
+    if ((reader == NULL) || (reader->node == NULL))
+	return(-1);
+    if (reader->node->type != XML_ELEMENT_NODE)
+	return(0);
+    if (reader->curnode != NULL)
+	return(0);
+    if (reader->node->children != NULL)
+	return(0);
+    if (reader->state == XML_TEXTREADER_END)
+	return(0);
+    if (reader->doc != NULL)
+        return(1);
+#ifdef LIBXML_XINCLUDE_ENABLED
+    if (reader->in_xinclude > 0)
+        return(1);
+#endif
+    return((reader->node->extra & NODE_IS_EMPTY) != 0);
+}
+
+/**
+ * xmlTextReaderLocalName:
+ * @reader:  the xmlTextReaderPtr used
+ *
+ * The local name of the node.
+ *
+ * Returns the local name or NULL if not available
+ */
+xmlChar *
+xmlTextReaderLocalName(xmlTextReaderPtr reader) {
+    xmlNodePtr node;
+    if ((reader == NULL) || (reader->node == NULL))
+	return(NULL);
+    if (reader->curnode != NULL)
+	node = reader->curnode;
+    else
+	node = reader->node;
+    if (node->type == XML_NAMESPACE_DECL) {
+	xmlNsPtr ns = (xmlNsPtr) node;
+	if (ns->prefix == NULL)
+	    return(xmlStrdup(BAD_CAST "xmlns"));
+	else
+	    return(xmlStrdup(ns->prefix));
+    }
+    if ((node->type != XML_ELEMENT_NODE) &&
+	(node->type != XML_ATTRIBUTE_NODE))
+	return(xmlTextReaderName(reader));
+    return(xmlStrdup(node->name));
+}
+
+/**
+ * xmlTextReaderConstLocalName:
+ * @reader:  the xmlTextReaderPtr used
+ *
+ * The local name of the node.
+ *
+ * Returns the local name or NULL if not available, the
+ *         string will be deallocated with the reader.
+ */
+const xmlChar *
+xmlTextReaderConstLocalName(xmlTextReaderPtr reader) {
+    xmlNodePtr node;
+    if ((reader == NULL) || (reader->node == NULL))
+	return(NULL);
+    if (reader->curnode != NULL)
+	node = reader->curnode;
+    else
+	node = reader->node;
+    if (node->type == XML_NAMESPACE_DECL) {
+	xmlNsPtr ns = (xmlNsPtr) node;
+	if (ns->prefix == NULL)
+	    return(CONSTSTR(BAD_CAST "xmlns"));
+	else
+	    return(ns->prefix);
+    }
+    if ((node->type != XML_ELEMENT_NODE) &&
+	(node->type != XML_ATTRIBUTE_NODE))
+	return(xmlTextReaderConstName(reader));
+    return(node->name);
+}
+
+/**
+ * xmlTextReaderName:
+ * @reader:  the xmlTextReaderPtr used
+ *
+ * The qualified name of the node, equal to Prefix :LocalName.
+ *
+ * Returns the local name or NULL if not available
+ */
+xmlChar *
+xmlTextReaderName(xmlTextReaderPtr reader) {
+    xmlNodePtr node;
+    xmlChar *ret;
+
+    if ((reader == NULL) || (reader->node == NULL))
+	return(NULL);
+    if (reader->curnode != NULL)
+	node = reader->curnode;
+    else
+	node = reader->node;
+    switch (node->type) {
+        case XML_ELEMENT_NODE:
+        case XML_ATTRIBUTE_NODE:
+	    if ((node->ns == NULL) ||
+		(node->ns->prefix == NULL))
+		return(xmlStrdup(node->name));
+	    
+	    ret = xmlStrdup(node->ns->prefix);
+	    ret = xmlStrcat(ret, BAD_CAST ":");
+	    ret = xmlStrcat(ret, node->name);
+	    return(ret);
+        case XML_TEXT_NODE:
+	    return(xmlStrdup(BAD_CAST "#text"));
+        case XML_CDATA_SECTION_NODE:
+	    return(xmlStrdup(BAD_CAST "#cdata-section"));
+        case XML_ENTITY_NODE:
+        case XML_ENTITY_REF_NODE:
+	    return(xmlStrdup(node->name));
+        case XML_PI_NODE:
+	    return(xmlStrdup(node->name));
+        case XML_COMMENT_NODE:
+	    return(xmlStrdup(BAD_CAST "#comment"));
+        case XML_DOCUMENT_NODE:
+        case XML_HTML_DOCUMENT_NODE:
+#ifdef LIBXML_DOCB_ENABLED
+        case XML_DOCB_DOCUMENT_NODE:
+#endif
+	    return(xmlStrdup(BAD_CAST "#document"));
+        case XML_DOCUMENT_FRAG_NODE:
+	    return(xmlStrdup(BAD_CAST "#document-fragment"));
+        case XML_NOTATION_NODE:
+	    return(xmlStrdup(node->name));
+        case XML_DOCUMENT_TYPE_NODE:
+        case XML_DTD_NODE:
+	    return(xmlStrdup(node->name));
+        case XML_NAMESPACE_DECL: {
+	    xmlNsPtr ns = (xmlNsPtr) node;
+
+	    ret = xmlStrdup(BAD_CAST "xmlns");
+	    if (ns->prefix == NULL)
+		return(ret);
+	    ret = xmlStrcat(ret, BAD_CAST ":");
+	    ret = xmlStrcat(ret, ns->prefix);
+	    return(ret);
+	}
+
+        case XML_ELEMENT_DECL:
+        case XML_ATTRIBUTE_DECL:
+        case XML_ENTITY_DECL:
+        case XML_XINCLUDE_START:
+        case XML_XINCLUDE_END:
+	    return(NULL);
+    }
+    return(NULL);
+}
+
+/**
+ * xmlTextReaderConstName:
+ * @reader:  the xmlTextReaderPtr used
+ *
+ * The qualified name of the node, equal to Prefix :LocalName.
+ *
+ * Returns the local name or NULL if not available, the string is
+ *         deallocated with the reader.
+ */
+const xmlChar *
+xmlTextReaderConstName(xmlTextReaderPtr reader) {
+    xmlNodePtr node;
+
+    if ((reader == NULL) || (reader->node == NULL))
+	return(NULL);
+    if (reader->curnode != NULL)
+	node = reader->curnode;
+    else
+	node = reader->node;
+    switch (node->type) {
+        case XML_ELEMENT_NODE:
+        case XML_ATTRIBUTE_NODE:
+	    if ((node->ns == NULL) ||
+		(node->ns->prefix == NULL))
+		return(node->name);
+	    return(CONSTQSTR(node->ns->prefix, node->name));
+        case XML_TEXT_NODE:
+	    return(CONSTSTR(BAD_CAST "#text"));
+        case XML_CDATA_SECTION_NODE:
+	    return(CONSTSTR(BAD_CAST "#cdata-section"));
+        case XML_ENTITY_NODE:
+        case XML_ENTITY_REF_NODE:
+	    return(CONSTSTR(node->name));
+        case XML_PI_NODE:
+	    return(CONSTSTR(node->name));
+        case XML_COMMENT_NODE:
+	    return(CONSTSTR(BAD_CAST "#comment"));
+        case XML_DOCUMENT_NODE:
+        case XML_HTML_DOCUMENT_NODE:
+#ifdef LIBXML_DOCB_ENABLED
+        case XML_DOCB_DOCUMENT_NODE:
+#endif
+	    return(CONSTSTR(BAD_CAST "#document"));
+        case XML_DOCUMENT_FRAG_NODE:
+	    return(CONSTSTR(BAD_CAST "#document-fragment"));
+        case XML_NOTATION_NODE:
+	    return(CONSTSTR(node->name));
+        case XML_DOCUMENT_TYPE_NODE:
+        case XML_DTD_NODE:
+	    return(CONSTSTR(node->name));
+        case XML_NAMESPACE_DECL: {
+	    xmlNsPtr ns = (xmlNsPtr) node;
+
+	    if (ns->prefix == NULL)
+		return(CONSTSTR(BAD_CAST "xmlns"));
+	    return(CONSTQSTR(BAD_CAST "xmlns", ns->prefix));
+	}
+
+        case XML_ELEMENT_DECL:
+        case XML_ATTRIBUTE_DECL:
+        case XML_ENTITY_DECL:
+        case XML_XINCLUDE_START:
+        case XML_XINCLUDE_END:
+	    return(NULL);
+    }
+    return(NULL);
+}
+
+/**
+ * xmlTextReaderPrefix:
+ * @reader:  the xmlTextReaderPtr used
+ *
+ * A shorthand reference to the namespace associated with the node.
+ *
+ * Returns the prefix or NULL if not available
+ */
+xmlChar *
+xmlTextReaderPrefix(xmlTextReaderPtr reader) {
+    xmlNodePtr node;
+    if ((reader == NULL) || (reader->node == NULL))
+	return(NULL);
+    if (reader->curnode != NULL)
+	node = reader->curnode;
+    else
+	node = reader->node;
+    if (node->type == XML_NAMESPACE_DECL) {
+	xmlNsPtr ns = (xmlNsPtr) node;
+	if (ns->prefix == NULL)
+	    return(NULL);
+	return(xmlStrdup(BAD_CAST "xmlns"));
+    }
+    if ((node->type != XML_ELEMENT_NODE) &&
+	(node->type != XML_ATTRIBUTE_NODE))
+	return(NULL);
+    if ((node->ns != NULL) && (node->ns->prefix != NULL))
+	return(xmlStrdup(node->ns->prefix));
+    return(NULL);
+}
+
+/**
+ * xmlTextReaderConstPrefix:
+ * @reader:  the xmlTextReaderPtr used
+ *
+ * A shorthand reference to the namespace associated with the node.
+ *
+ * Returns the prefix or NULL if not available, the string is deallocated
+ *         with the reader.
+ */
+const xmlChar *
+xmlTextReaderConstPrefix(xmlTextReaderPtr reader) {
+    xmlNodePtr node;
+    if ((reader == NULL) || (reader->node == NULL))
+	return(NULL);
+    if (reader->curnode != NULL)
+	node = reader->curnode;
+    else
+	node = reader->node;
+    if (node->type == XML_NAMESPACE_DECL) {
+	xmlNsPtr ns = (xmlNsPtr) node;
+	if (ns->prefix == NULL)
+	    return(NULL);
+	return(CONSTSTR(BAD_CAST "xmlns"));
+    }
+    if ((node->type != XML_ELEMENT_NODE) &&
+	(node->type != XML_ATTRIBUTE_NODE))
+	return(NULL);
+    if ((node->ns != NULL) && (node->ns->prefix != NULL))
+	return(CONSTSTR(node->ns->prefix));
+    return(NULL);
+}
+
+/**
+ * xmlTextReaderNamespaceUri:
+ * @reader:  the xmlTextReaderPtr used
+ *
+ * The URI defining the namespace associated with the node.
+ *
+ * Returns the namespace URI or NULL if not available
+ */
+xmlChar *
+xmlTextReaderNamespaceUri(xmlTextReaderPtr reader) {
+    xmlNodePtr node;
+    if ((reader == NULL) || (reader->node == NULL))
+	return(NULL);
+    if (reader->curnode != NULL)
+	node = reader->curnode;
+    else
+	node = reader->node;
+    if (node->type == XML_NAMESPACE_DECL)
+	return(xmlStrdup(BAD_CAST "http://www.w3.org/2000/xmlns/"));
+    if ((node->type != XML_ELEMENT_NODE) &&
+	(node->type != XML_ATTRIBUTE_NODE))
+	return(NULL);
+    if (node->ns != NULL)
+	return(xmlStrdup(node->ns->href));
+    return(NULL);
+}
+
+/**
+ * xmlTextReaderConstNamespaceUri:
+ * @reader:  the xmlTextReaderPtr used
+ *
+ * The URI defining the namespace associated with the node.
+ *
+ * Returns the namespace URI or NULL if not available, the string
+ *         will be deallocated with the reader
+ */
+const xmlChar *
+xmlTextReaderConstNamespaceUri(xmlTextReaderPtr reader) {
+    xmlNodePtr node;
+    if ((reader == NULL) || (reader->node == NULL))
+	return(NULL);
+    if (reader->curnode != NULL)
+	node = reader->curnode;
+    else
+	node = reader->node;
+    if (node->type == XML_NAMESPACE_DECL)
+	return(CONSTSTR(BAD_CAST "http://www.w3.org/2000/xmlns/"));
+    if ((node->type != XML_ELEMENT_NODE) &&
+	(node->type != XML_ATTRIBUTE_NODE))
+	return(NULL);
+    if (node->ns != NULL)
+	return(CONSTSTR(node->ns->href));
+    return(NULL);
+}
+
+/**
+ * xmlTextReaderBaseUri:
+ * @reader:  the xmlTextReaderPtr used
+ *
+ * The base URI of the node.
+ *
+ * Returns the base URI or NULL if not available
+ */
+xmlChar *
+xmlTextReaderBaseUri(xmlTextReaderPtr reader) {
+    if ((reader == NULL) || (reader->node == NULL))
+	return(NULL);
+    return(xmlNodeGetBase(NULL, reader->node));
+}
+
+/**
+ * xmlTextReaderConstBaseUri:
+ * @reader:  the xmlTextReaderPtr used
+ *
+ * The base URI of the node.
+ *
+ * Returns the base URI or NULL if not available, the string
+ *         will be deallocated with the reader
+ */
+const xmlChar *
+xmlTextReaderConstBaseUri(xmlTextReaderPtr reader) {
+    xmlChar *tmp;
+    const xmlChar *ret;
+
+    if ((reader == NULL) || (reader->node == NULL))
+	return(NULL);
+    tmp = xmlNodeGetBase(NULL, reader->node);
+    if (tmp == NULL)
+        return(NULL);
+    ret = CONSTSTR(tmp);
+    xmlFree(tmp);
+    return(ret);
+}
+
+/**
+ * xmlTextReaderDepth:
+ * @reader:  the xmlTextReaderPtr used
+ *
+ * The depth of the node in the tree.
+ *
+ * Returns the depth or -1 in case of error
+ */
+int
+xmlTextReaderDepth(xmlTextReaderPtr reader) {
+    if (reader == NULL)
+	return(-1);
+    if (reader->node == NULL)
+	return(0);
+
+    if (reader->curnode != NULL) {
+	if ((reader->curnode->type == XML_ATTRIBUTE_NODE) ||
+	    (reader->curnode->type == XML_NAMESPACE_DECL))
+	    return(reader->depth + 1);
+	return(reader->depth + 2);
+    }
+    return(reader->depth);
+}
+
+/**
+ * xmlTextReaderHasAttributes:
+ * @reader:  the xmlTextReaderPtr used
+ *
+ * Whether the node has attributes.
+ *
+ * Returns 1 if true, 0 if false, and -1 in case or error
+ */
+int
+xmlTextReaderHasAttributes(xmlTextReaderPtr reader) {
+    xmlNodePtr node;
+    if (reader == NULL)
+	return(-1);
+    if (reader->node == NULL)
+	return(0);
+    if (reader->curnode != NULL)
+	node = reader->curnode;
+    else
+	node = reader->node;
+
+    if ((node->type == XML_ELEMENT_NODE) &&
+	(node->properties != NULL))
+	return(1);
+    /* TODO: handle the xmlDecl */
+    return(0);
+}
+
+/**
+ * xmlTextReaderHasValue:
+ * @reader:  the xmlTextReaderPtr used
+ *
+ * Whether the node can have a text value.
+ *
+ * Returns 1 if true, 0 if false, and -1 in case or error
+ */
+int
+xmlTextReaderHasValue(xmlTextReaderPtr reader) {
+    xmlNodePtr node;
+    if (reader == NULL)
+	return(-1);
+    if (reader->node == NULL)
+	return(0);
+    if (reader->curnode != NULL)
+	node = reader->curnode;
+    else
+	node = reader->node;
+
+    switch (node->type) {
+        case XML_ATTRIBUTE_NODE:
+        case XML_TEXT_NODE:
+        case XML_CDATA_SECTION_NODE:
+        case XML_PI_NODE:
+        case XML_COMMENT_NODE:
+        case XML_NAMESPACE_DECL:
+	    return(1);
+	default:
+	    break;
+    }
+    return(0);
+}
+
+/**
+ * xmlTextReaderValue:
+ * @reader:  the xmlTextReaderPtr used
+ *
+ * Provides the text value of the node if present
+ *
+ * Returns the string or NULL if not available. The result must be deallocated
+ *     with xmlFree()
+ */
+xmlChar *
+xmlTextReaderValue(xmlTextReaderPtr reader) {
+    xmlNodePtr node;
+    if (reader == NULL)
+	return(NULL);
+    if (reader->node == NULL)
+	return(NULL);
+    if (reader->curnode != NULL)
+	node = reader->curnode;
+    else
+	node = reader->node;
+
+    switch (node->type) {
+        case XML_NAMESPACE_DECL:
+	    return(xmlStrdup(((xmlNsPtr) node)->href));
+        case XML_ATTRIBUTE_NODE:{
+	    xmlAttrPtr attr = (xmlAttrPtr) node;
+
+	    if (attr->parent != NULL)
+		return (xmlNodeListGetString
+			(attr->parent->doc, attr->children, 1));
+	    else
+		return (xmlNodeListGetString(NULL, attr->children, 1));
+	    break;
+	}
+        case XML_TEXT_NODE:
+        case XML_CDATA_SECTION_NODE:
+        case XML_PI_NODE:
+        case XML_COMMENT_NODE:
+            if (node->content != NULL)
+                return (xmlStrdup(node->content));
+	default:
+	    break;
+    }
+    return(NULL);
+}
+
+/**
+ * xmlTextReaderConstValue:
+ * @reader:  the xmlTextReaderPtr used
+ *
+ * Provides the text value of the node if present
+ *
+ * Returns the string or NULL if not available. The result will be
+ *     deallocated on the next Read() operation.
+ */
+const xmlChar *
+xmlTextReaderConstValue(xmlTextReaderPtr reader) {
+    xmlNodePtr node;
+    if (reader == NULL)
+	return(NULL);
+    if (reader->node == NULL)
+	return(NULL);
+    if (reader->curnode != NULL)
+	node = reader->curnode;
+    else
+	node = reader->node;
+
+    switch (node->type) {
+        case XML_NAMESPACE_DECL:
+	    return(((xmlNsPtr) node)->href);
+        case XML_ATTRIBUTE_NODE:{
+	    xmlAttrPtr attr = (xmlAttrPtr) node;
+
+	    if ((attr->children != NULL) &&
+	        (attr->children->type == XML_TEXT_NODE) &&
+		(attr->children->next == NULL))
+		return(attr->children->content);
+	    else {
+	        reader->buffer->use = 0;
+	        xmlNodeBufGetContent(reader->buffer, node);
+		return(reader->buffer->content);
+	    }
+	    break;
+	}
+        case XML_TEXT_NODE:
+        case XML_CDATA_SECTION_NODE:
+        case XML_PI_NODE:
+        case XML_COMMENT_NODE:
+	    return(node->content);
+	default:
+	    break;
+    }
+    return(NULL);
+}
+
+/**
+ * xmlTextReaderIsDefault:
+ * @reader:  the xmlTextReaderPtr used
+ *
+ * Whether an Attribute  node was generated from the default value
+ * defined in the DTD or schema.
+ *
+ * Returns 0 if not defaulted, 1 if defaulted, and -1 in case of error
+ */
+int
+xmlTextReaderIsDefault(xmlTextReaderPtr reader) {
+    if (reader == NULL)
+	return(-1);
+    return(0);
+}
+
+/**
+ * xmlTextReaderQuoteChar:
+ * @reader:  the xmlTextReaderPtr used
+ *
+ * The quotation mark character used to enclose the value of an attribute.
+ *
+ * Returns " or ' and -1 in case of error
+ */
+int
+xmlTextReaderQuoteChar(xmlTextReaderPtr reader) {
+    if (reader == NULL)
+	return(-1);
+    /* TODO maybe lookup the attribute value for " first */
+    return((int) '"');
+}
+
+/**
+ * xmlTextReaderXmlLang:
+ * @reader:  the xmlTextReaderPtr used
+ *
+ * The xml:lang scope within which the node resides.
+ *
+ * Returns the xml:lang value or NULL if none exists.
+ */
+xmlChar *
+xmlTextReaderXmlLang(xmlTextReaderPtr reader) {
+    if (reader == NULL)
+	return(NULL);
+    if (reader->node == NULL)
+	return(NULL);
+    return(xmlNodeGetLang(reader->node));
+}
+
+/**
+ * xmlTextReaderConstXmlLang:
+ * @reader:  the xmlTextReaderPtr used
+ *
+ * The xml:lang scope within which the node resides.
+ *
+ * Returns the xml:lang value or NULL if none exists.
+ */
+const xmlChar *
+xmlTextReaderConstXmlLang(xmlTextReaderPtr reader) {
+    xmlChar *tmp;
+    const xmlChar *ret;
+
+    if (reader == NULL)
+	return(NULL);
+    if (reader->node == NULL)
+	return(NULL);
+    tmp = xmlNodeGetLang(reader->node);
+    if (tmp == NULL)
+        return(NULL);
+    ret = CONSTSTR(tmp);
+    xmlFree(tmp);
+    return(ret);
+}
+
+/**
+ * xmlTextReaderConstString:
+ * @reader:  the xmlTextReaderPtr used
+ * @str:  the string to intern.
+ *
+ * Get an interned string from the reader, allows for example to
+ * speedup string name comparisons
+ *
+ * Returns an interned copy of the string or NULL in case of error. The
+ *         string will be deallocated with the reader.
+ */
+const xmlChar *
+xmlTextReaderConstString(xmlTextReaderPtr reader, const xmlChar *str) {
+    if (reader == NULL)
+	return(NULL);
+    return(CONSTSTR(str));
+}
+
+/**
+ * xmlTextReaderNormalization:
+ * @reader:  the xmlTextReaderPtr used
+ *
+ * The value indicating whether to normalize white space and attribute values.
+ * Since attribute value and end of line normalizations are a MUST in the XML
+ * specification only the value true is accepted. The broken bahaviour of
+ * accepting out of range character entities like &#0; is of course not
+ * supported either.
+ *
+ * Returns 1 or -1 in case of error.
+ */
+int
+xmlTextReaderNormalization(xmlTextReaderPtr reader) {
+    if (reader == NULL)
+	return(-1);
+    return(1);
+}
+
+/************************************************************************
+ *									*
+ *			Extensions to the base APIs			*
+ *									*
+ ************************************************************************/
+
+/**
+ * xmlTextReaderSetParserProp:
+ * @reader:  the xmlTextReaderPtr used
+ * @prop:  the xmlParserProperties to set
+ * @value:  usually 0 or 1 to (de)activate it
+ *
+ * Change the parser processing behaviour by changing some of its internal
+ * properties. Note that some properties can only be changed before any
+ * read has been done.
+ *
+ * Returns 0 if the call was successful, or -1 in case of error
+ */
+int
+xmlTextReaderSetParserProp(xmlTextReaderPtr reader, int prop, int value) {
+    xmlParserProperties p = (xmlParserProperties) prop;
+    xmlParserCtxtPtr ctxt;
+
+    if ((reader == NULL) || (reader->ctxt == NULL))
+	return(-1);
+    ctxt = reader->ctxt;
+
+    switch (p) {
+        case XML_PARSER_LOADDTD:
+	    if (value != 0) {
+		if (ctxt->loadsubset == 0) {
+		    if (reader->mode != XML_TEXTREADER_MODE_INITIAL)
+			return(-1);
+		    ctxt->loadsubset = XML_DETECT_IDS;
+		}
+	    } else {
+		ctxt->loadsubset = 0;
+	    }
+	    return(0);
+        case XML_PARSER_DEFAULTATTRS:
+	    if (value != 0) {
+		ctxt->loadsubset |= XML_COMPLETE_ATTRS;
+	    } else {
+		if (ctxt->loadsubset & XML_COMPLETE_ATTRS)
+		    ctxt->loadsubset -= XML_COMPLETE_ATTRS;
+	    }
+	    return(0);
+        case XML_PARSER_VALIDATE:
+	    if (value != 0) {
+		ctxt->validate = 1;
+		reader->validate = XML_TEXTREADER_VALIDATE_DTD;
+	    } else {
+		ctxt->validate = 0;
+	    }
+	    return(0);
+        case XML_PARSER_SUBST_ENTITIES:
+	    if (value != 0) {
+		ctxt->replaceEntities = 1;
+	    } else {
+		ctxt->replaceEntities = 0;
+	    }
+	    return(0);
+    }
+    return(-1);
+}
+
+/**
+ * xmlTextReaderGetParserProp:
+ * @reader:  the xmlTextReaderPtr used
+ * @prop:  the xmlParserProperties to get
+ *
+ * Read the parser internal property.
+ *
+ * Returns the value, usually 0 or 1, or -1 in case of error.
+ */
+int
+xmlTextReaderGetParserProp(xmlTextReaderPtr reader, int prop) {
+    xmlParserProperties p = (xmlParserProperties) prop;
+    xmlParserCtxtPtr ctxt;
+
+    if ((reader == NULL) || (reader->ctxt == NULL))
+	return(-1);
+    ctxt = reader->ctxt;
+
+    switch (p) {
+        case XML_PARSER_LOADDTD:
+	    if ((ctxt->loadsubset != 0) || (ctxt->validate != 0))
+		return(1);
+	    return(0);
+        case XML_PARSER_DEFAULTATTRS:
+	    if (ctxt->loadsubset & XML_COMPLETE_ATTRS)
+		return(1);
+	    return(0);
+        case XML_PARSER_VALIDATE:
+	    return(reader->validate);
+	case XML_PARSER_SUBST_ENTITIES:
+	    return(ctxt->replaceEntities);
+    }
+    return(-1);
+}
+
+/**
+ * xmlTextReaderCurrentNode:
+ * @reader:  the xmlTextReaderPtr used
+ *
+ * Hacking interface allowing to get the xmlNodePtr correponding to the
+ * current node being accessed by the xmlTextReader. This is dangerous
+ * because the underlying node may be destroyed on the next Reads.
+ *
+ * Returns the xmlNodePtr or NULL in case of error.
+ */
+xmlNodePtr
+xmlTextReaderCurrentNode(xmlTextReaderPtr reader) {
+    if (reader == NULL)
+	return(NULL);
+    
+    if (reader->curnode != NULL)
+	return(reader->curnode);
+    return(reader->node);
+}
+
+/**
+ * xmlTextReaderPreserve:
+ * @reader:  the xmlTextReaderPtr used
+ *
+ * 
+ * current node being accessed by the xmlTextReader. This is dangerous
+ * because the underlying node may be destroyed on the next Reads.
+ *
+ * Returns the xmlNodePtr or NULL in case of error.
+ */
+xmlNodePtr
+xmlTextReaderPreserve(xmlTextReaderPtr reader) {
+    xmlNodePtr cur, parent;
+
+    if (reader == NULL)
+	return(NULL);
+    
+    if (reader->curnode != NULL)
+        cur = reader->curnode;
+    else
+        cur = reader->node;
+    if (cur == NULL)
+        return(NULL);
+
+    if (cur->type != XML_DOCUMENT_NODE) {
+	cur->extra |= NODE_IS_PRESERVED;
+	cur->extra |= NODE_IS_SPRESERVED;
+    }
+    reader->preserves++;
+        
+    parent = cur->parent;;
+    while (parent != NULL) {
+        if (parent->type == XML_ELEMENT_NODE)
+	    parent->extra |= NODE_IS_PRESERVED;
+	parent = parent->parent;
+    }
+    return(cur);
+}
+
+#ifdef LIBXML_PATTERN_ENABLED
+/**
+ * xmlTextReaderPreservePattern:
+ * @reader:  the xmlTextReaderPtr used
+ * @pattern:  an XPath subset pattern
+ * @namespaces: the prefix definitions, array of [URI, prefix] or NULL
+ * 
+ * This tells the XML Reader to preserve all nodes matched by the
+ * pattern. The caller must also use xmlTextReaderCurrentDoc() to
+ * keep an handle on the resulting document once parsing has finished
+ *
+ * Returns a positive number in case of success and -1 in case of error
+ */
+int
+xmlTextReaderPreservePattern(xmlTextReaderPtr reader, const xmlChar *pattern,
+                             const xmlChar **namespaces)
+{
+    xmlPatternPtr comp;
+
+    if ((reader == NULL) || (pattern == NULL))
+	return(-1);
+    
+    comp = xmlPatterncompile(pattern, reader->dict, 0, namespaces);
+    if (comp == NULL)
+        return(-1);
+
+    if (reader->patternMax <= 0) {
+	reader->patternMax = 4;
+	reader->patternTab = (xmlPatternPtr *) xmlMalloc(reader->patternMax *
+					      sizeof(reader->patternTab[0]));
+        if (reader->patternTab == NULL) {
+            xmlGenericError(xmlGenericErrorContext, "xmlMalloc failed !\n");
+            return (-1);
+        }
+    }
+    if (reader->patternNr >= reader->patternMax) {
+        xmlPatternPtr *tmp;
+        reader->patternMax *= 2;
+	tmp = (xmlPatternPtr *) xmlRealloc(reader->patternTab,
+                                      reader->patternMax *
+                                      sizeof(reader->patternTab[0]));
+        if (tmp == NULL) {
+            xmlGenericError(xmlGenericErrorContext, "xmlRealloc failed !\n");
+	    reader->patternMax /= 2;
+            return (-1);
+        }
+	reader->patternTab = tmp;
+    }
+    reader->patternTab[reader->patternNr] = comp;
+    return(reader->patternNr++);
+}
+#endif
+
+/**
+ * xmlTextReaderCurrentDoc:
+ * @reader:  the xmlTextReaderPtr used
+ *
+ * Hacking interface allowing to get the xmlDocPtr correponding to the
+ * current document being accessed by the xmlTextReader. 
+ * NOTE: as a result of this call, the reader will not destroy the
+ *       associated XML document and calling xmlFreeDoc() on the result
+ *       is needed once the reader parsing has finished.
+ *
+ * Returns the xmlDocPtr or NULL in case of error.
+ */
+xmlDocPtr
+xmlTextReaderCurrentDoc(xmlTextReaderPtr reader) {
+    if (reader == NULL)
+	return(NULL);
+    if (reader->doc != NULL)
+        return(reader->doc);
+    if ((reader == NULL) || (reader->ctxt == NULL) ||
+        (reader->ctxt->myDoc == NULL))
+	return(NULL);
+    
+    reader->preserve = 1;
+    return(reader->ctxt->myDoc);
+}
+
+#ifdef LIBXML_SCHEMAS_ENABLED
+/**
+ * xmlTextReaderRelaxNGSetSchema:
+ * @reader:  the xmlTextReaderPtr used
+ * @schema:  a precompiled RelaxNG schema
+ *
+ * Use RelaxNG to validate the document as it is processed.
+ * Activation is only possible before the first Read().
+ * if @schema is NULL, then RelaxNG validation is desactivated.
+ @ The @schema should not be freed until the reader is deallocated
+ * or its use has been deactivated.
+ *
+ * Returns 0 in case the RelaxNG validation could be (des)activated and
+ *         -1 in case of error.
+ */
+int
+xmlTextReaderRelaxNGSetSchema(xmlTextReaderPtr reader, xmlRelaxNGPtr schema) {
+    if (schema == NULL) {
+        if (reader->rngSchemas != NULL) {
+	    xmlRelaxNGFree(reader->rngSchemas);
+	    reader->rngSchemas = NULL;
+	}
+        if (reader->rngValidCtxt != NULL) {
+	    xmlRelaxNGFreeValidCtxt(reader->rngValidCtxt);
+	    reader->rngValidCtxt = NULL;
+        }
+	return(0);
+    }
+    if (reader->mode != XML_TEXTREADER_MODE_INITIAL)
+	return(-1);
+    if (reader->rngSchemas != NULL) {
+	xmlRelaxNGFree(reader->rngSchemas);
+	reader->rngSchemas = NULL;
+    }
+    if (reader->rngValidCtxt != NULL) {
+	xmlRelaxNGFreeValidCtxt(reader->rngValidCtxt);
+	reader->rngValidCtxt = NULL;
+    }
+    reader->rngValidCtxt = xmlRelaxNGNewValidCtxt(schema);
+    if (reader->rngValidCtxt == NULL)
+        return(-1);
+    if (reader->errorFunc != NULL) {
+	xmlRelaxNGSetValidErrors(reader->rngValidCtxt,
+			 (xmlRelaxNGValidityErrorFunc)reader->errorFunc,
+			 (xmlRelaxNGValidityWarningFunc) reader->errorFunc,
+			 reader->errorFuncArg);
+    }
+    reader->rngValidErrors = 0;
+    reader->rngFullNode = NULL;
+    reader->validate = XML_TEXTREADER_VALIDATE_RNG;
+    return(0);
+}
+
+/**
+ * xmlTextReaderRelaxNGValidate:
+ * @reader:  the xmlTextReaderPtr used
+ * @rng:  the path to a RelaxNG schema or NULL
+ *
+ * Use RelaxNG to validate the document as it is processed.
+ * Activation is only possible before the first Read().
+ * if @rng is NULL, then RelaxNG validation is desactivated.
+ *
+ * Returns 0 in case the RelaxNG validation could be (des)activated and
+ *         -1 in case of error.
+ */
+int
+xmlTextReaderRelaxNGValidate(xmlTextReaderPtr reader, const char *rng) {
+    xmlRelaxNGParserCtxtPtr ctxt;
+
+    if (reader == NULL)
+        return(-1);
+    
+    if (rng == NULL) {
+        if (reader->rngSchemas != NULL) {
+	    xmlRelaxNGFree(reader->rngSchemas);
+	    reader->rngSchemas = NULL;
+	}
+        if (reader->rngValidCtxt != NULL) {
+	    xmlRelaxNGFreeValidCtxt(reader->rngValidCtxt);
+	    reader->rngValidCtxt = NULL;
+        }
+	return(0);
+    }
+    if (reader->mode != XML_TEXTREADER_MODE_INITIAL)
+	return(-1);
+    if (reader->rngSchemas != NULL) {
+	xmlRelaxNGFree(reader->rngSchemas);
+	reader->rngSchemas = NULL;
+    }
+    if (reader->rngValidCtxt != NULL) {
+	xmlRelaxNGFreeValidCtxt(reader->rngValidCtxt);
+	reader->rngValidCtxt = NULL;
+    }
+    ctxt = xmlRelaxNGNewParserCtxt(rng);
+    if (reader->errorFunc != NULL) {
+	xmlRelaxNGSetParserErrors(ctxt,
+			 (xmlRelaxNGValidityErrorFunc) reader->errorFunc,
+			 (xmlRelaxNGValidityWarningFunc) reader->errorFunc,
+			 reader->errorFuncArg);
+    }
+    reader->rngSchemas = xmlRelaxNGParse(ctxt);
+    xmlRelaxNGFreeParserCtxt(ctxt);
+    if (reader->rngSchemas == NULL)
+        return(-1);
+    reader->rngValidCtxt = xmlRelaxNGNewValidCtxt(reader->rngSchemas);
+    if (reader->rngValidCtxt == NULL)
+        return(-1);
+    if (reader->errorFunc != NULL) {
+	xmlRelaxNGSetValidErrors(reader->rngValidCtxt,
+			 (xmlRelaxNGValidityErrorFunc)reader->errorFunc,
+			 (xmlRelaxNGValidityWarningFunc) reader->errorFunc,
+			 reader->errorFuncArg);
+    }
+    reader->rngValidErrors = 0;
+    reader->rngFullNode = NULL;
+    reader->validate = XML_TEXTREADER_VALIDATE_RNG;
+    return(0);
+}
+#endif
+
+/************************************************************************
+ *									*
+ *			Error Handling Extensions                       *
+ *									*
+ ************************************************************************/
+
+/* helper to build a xmlMalloc'ed string from a format and va_list */
+static char *
+xmlTextReaderBuildMessage(const char *msg, va_list ap) {
+    int size;
+    int chars;
+    char *larger;
+    char *str;
+
+    str = (char *) xmlMallocAtomic(150);
+    if (str == NULL) {
+	xmlGenericError(xmlGenericErrorContext, "xmlMalloc failed !\n");
+        return NULL;
+    }
+
+    size = 150;
+
+    while (1) {
+        chars = vsnprintf(str, size, msg, ap);
+        if ((chars > -1) && (chars < size))
+            break;
+        if (chars > -1)
+            size += chars + 1;
+        else
+            size += 100;
+        if ((larger = (char *) xmlRealloc(str, size)) == NULL) {
+	    xmlGenericError(xmlGenericErrorContext, "xmlRealloc failed !\n");
+            xmlFree(str);
+            return NULL;
+        }
+        str = larger;
+    }
+
+    return str;
+}
+
+/**
+ * xmlTextReaderLocatorLineNumber:
+ * @locator: the xmlTextReaderLocatorPtr used
+ *
+ * Obtain the line number for the given locator.
+ *
+ * Returns the line number or -1 in case of error.
+ */
+int
+xmlTextReaderLocatorLineNumber(xmlTextReaderLocatorPtr locator) {
+    /* we know that locator is a xmlParserCtxtPtr */
+    xmlParserCtxtPtr ctx = (xmlParserCtxtPtr)locator;
+    int ret = -1;
+
+    if (ctx->node != NULL) {
+	ret = xmlGetLineNo(ctx->node);
+    }
+    else {
+	/* inspired from error.c */
+	xmlParserInputPtr input;
+	input = ctx->input;
+	if ((input->filename == NULL) && (ctx->inputNr > 1))
+	    input = ctx->inputTab[ctx->inputNr - 2];
+	if (input != NULL) {
+	    ret = input->line;
+	} 
+	else {
+	    ret = -1;
+	}
+    }
+
+    return ret;
+}
+
+/**
+ * xmlTextReaderLocatorBaseURI:
+ * @locator: the xmlTextReaderLocatorPtr used
+ *
+ * Obtain the base URI for the given locator.
+ *
+ * Returns the base URI or NULL in case of error.
+ */
+xmlChar *
+xmlTextReaderLocatorBaseURI(xmlTextReaderLocatorPtr locator) {
+    /* we know that locator is a xmlParserCtxtPtr */
+    xmlParserCtxtPtr ctx = (xmlParserCtxtPtr)locator;
+    xmlChar *ret = NULL;
+
+    if (ctx->node != NULL) {
+	ret = xmlNodeGetBase(NULL,ctx->node);
+    }
+    else {
+	/* inspired from error.c */
+	xmlParserInputPtr input;
+	input = ctx->input;
+	if ((input->filename == NULL) && (ctx->inputNr > 1))
+	    input = ctx->inputTab[ctx->inputNr - 2];
+	if (input != NULL) {
+	    ret = xmlStrdup(BAD_CAST input->filename);
+	} 
+	else {
+	    ret = NULL;
+	}
+    }
+
+    return ret;
+}
+
+static void
+xmlTextReaderGenericError(void *ctxt, xmlParserSeverities severity, char *str) {
+    xmlParserCtxtPtr ctx = (xmlParserCtxtPtr)ctxt;
+    xmlTextReaderPtr reader = (xmlTextReaderPtr)ctx->_private;
+
+    if (str != NULL) {
+	reader->errorFunc(reader->errorFuncArg,
+			  str,
+			  severity,
+			  (xmlTextReaderLocatorPtr)ctx);
+	xmlFree(str);
+    }
+}
+
+static void 
+xmlTextReaderStructuredError(void *ctxt, xmlErrorPtr error) {
+  xmlParserCtxtPtr ctx = (xmlParserCtxtPtr) ctxt;
+  xmlTextReaderPtr reader = (xmlTextReaderPtr) ctx->_private;
+
+  if (error && reader->sErrorFunc) {
+	reader->sErrorFunc(reader->errorFuncArg,
+			   (xmlErrorPtr) error);
+  }
+}
+
+static void 
+xmlTextReaderError(void *ctxt, const char *msg, ...) {
+    va_list ap;
+
+    va_start(ap,msg);
+    xmlTextReaderGenericError(ctxt,
+                              XML_PARSER_SEVERITY_ERROR,
+	                      xmlTextReaderBuildMessage(msg,ap));
+    va_end(ap);
+
+}
+
+static void 
+xmlTextReaderWarning(void *ctxt, const char *msg, ...) {
+    va_list ap;
+
+    va_start(ap,msg);
+    xmlTextReaderGenericError(ctxt,
+                              XML_PARSER_SEVERITY_WARNING,
+	                      xmlTextReaderBuildMessage(msg,ap));
+    va_end(ap);
+}
+
+static void 
+xmlTextReaderValidityError(void *ctxt, const char *msg, ...) {
+    va_list ap;
+    int len = xmlStrlen((const xmlChar *) msg);
+
+    if ((len > 1) && (msg[len - 2] != ':')) {
+	/* 
+	 * some callbacks only report locator information: 
+	 * skip them (mimicking behaviour in error.c) 
+	 */
+	va_start(ap,msg);
+	xmlTextReaderGenericError(ctxt,
+				  XML_PARSER_SEVERITY_VALIDITY_ERROR,
+				  xmlTextReaderBuildMessage(msg,ap));
+	va_end(ap);
+    }
+}
+
+static void 
+xmlTextReaderValidityWarning(void *ctxt, const char *msg, ...) {
+    va_list ap;
+    int len = xmlStrlen((const xmlChar *) msg);
+
+    if ((len != 0) && (msg[len - 1] != ':')) {
+	/* 
+	 * some callbacks only report locator information: 
+	 * skip them (mimicking behaviour in error.c) 
+	 */
+	va_start(ap,msg);
+	xmlTextReaderGenericError(ctxt,
+				  XML_PARSER_SEVERITY_VALIDITY_WARNING,
+				  xmlTextReaderBuildMessage(msg,ap));
+	va_end(ap);
+    }
+}
+
+/**
+ * xmlTextReaderSetErrorHandler:
+ * @reader:  the xmlTextReaderPtr used
+ * @f:	the callback function to call on error and warnings
+ * @arg:    a user argument to pass to the callback function
+ *
+ * Register a callback function that will be called on error and warnings.
+ *
+ * If @f is NULL, the default error and warning handlers are restored.
+ */
+void
+xmlTextReaderSetErrorHandler(xmlTextReaderPtr reader, 
+			     xmlTextReaderErrorFunc f, 
+			     void *arg) {
+    if (f != NULL) {
+	reader->ctxt->sax->error = xmlTextReaderError;
+	reader->ctxt->sax->serror = NULL;
+	reader->ctxt->vctxt.error = xmlTextReaderValidityError;
+	reader->ctxt->sax->warning = xmlTextReaderWarning;
+	reader->ctxt->vctxt.warning = xmlTextReaderValidityWarning;
+	reader->errorFunc = f;
+	reader->errorFuncArg = arg;
+    }
+    else {
+	/* restore defaults */
+	reader->ctxt->sax->error = xmlParserError;
+	reader->ctxt->vctxt.error = xmlParserValidityError;
+	reader->ctxt->sax->warning = xmlParserWarning;
+	reader->ctxt->vctxt.warning = xmlParserValidityWarning;
+	reader->errorFunc = NULL;
+	reader->sErrorFunc = NULL;
+	reader->errorFuncArg = NULL;
+    }
+}
+
+/**
+* xmlTextReaderSetStructuredErrorHandler:
+ * @reader:  the xmlTextReaderPtr used
+ * @f:	the callback function to call on error and warnings
+ * @arg:    a user argument to pass to the callback function
+ *
+ * Register a callback function that will be called on error and warnings.
+ *
+ * If @f is NULL, the default error and warning handlers are restored.
+ */
+void
+xmlTextReaderSetStructuredErrorHandler(xmlTextReaderPtr reader, 
+					 xmlStructuredErrorFunc f, 
+					 void *arg) {
+  if (f != NULL) {
+	reader->ctxt->sax->serror = xmlTextReaderStructuredError;
+	reader->ctxt->vctxt.error = xmlTextReaderValidityError;
+	reader->ctxt->sax->warning = xmlTextReaderWarning;
+	reader->ctxt->vctxt.warning = xmlTextReaderValidityWarning;
+	reader->sErrorFunc = f;
+	reader->errorFunc = NULL;
+	reader->errorFuncArg = arg;
+  }
+  else {
+	/* restore defaults */
+	reader->ctxt->sax->error = xmlParserError;
+	reader->ctxt->sax->serror = NULL;
+	reader->ctxt->vctxt.error = xmlParserValidityError;
+	reader->ctxt->sax->warning = xmlParserWarning;
+	reader->ctxt->vctxt.warning = xmlParserValidityWarning;
+	reader->errorFunc = NULL;
+	reader->sErrorFunc = NULL;
+	reader->errorFuncArg = NULL;
+  }
+}
+
+/**
+ * xmlTextReaderIsValid:
+ * @reader:  the xmlTextReaderPtr used
+ *
+ * Retrieve the validity status from the parser context
+ *
+ * Returns the flag value 1 if valid, 0 if no, and -1 in case of error
+ */
+int
+xmlTextReaderIsValid(xmlTextReaderPtr reader) {
+    if (reader == NULL) return(-1);
+#ifdef LIBXML_SCHEMAS_ENABLED
+    if (reader->validate == XML_TEXTREADER_VALIDATE_RNG)
+        return(reader->rngValidErrors == 0);
+#endif
+    if ((reader->ctxt != NULL) && (reader->ctxt->validate == 1))
+	return(reader->ctxt->valid);
+    return(0);
+}
+
+/**
+ * xmlTextReaderGetErrorHandler:
+ * @reader:  the xmlTextReaderPtr used
+ * @f:	the callback function or NULL is no callback has been registered
+ * @arg:    a user argument
+ *
+ * Retrieve the error callback function and user argument.
+ */
+void
+xmlTextReaderGetErrorHandler(xmlTextReaderPtr reader, 
+			     xmlTextReaderErrorFunc *f, 
+			     void **arg) {
+    *f = reader->errorFunc;
+    *arg = reader->errorFuncArg;
+}
+
+
+/************************************************************************
+ *									*
+ *	New set (2.6.0) of simpler and more flexible APIs		*
+ *									*
+ ************************************************************************/
+
+/**
+ * xmlTextReaderSetup:
+ * @reader:  an XML reader
+ * @URL:  the base URL to use for the document
+ * @encoding:  the document encoding, or NULL
+ * @options:  a combination of xmlParserOption
+ * @reuse:  keep the context for reuse
+ *
+ * Setup an XML reader with new options
+ * 
+ * Returns 0 in case of success and -1 in case of error.
+ */
+static int
+xmlTextReaderSetup(xmlTextReaderPtr reader,
+                   xmlParserInputBufferPtr input, const char *URL,
+                   const char *encoding, int options)
+{
+    if (reader == NULL)
+        return (-1);
+
+    reader->doc = NULL;
+    reader->entNr = 0;
+    reader->parserFlags = options;
+    reader->validate = XML_TEXTREADER_NOT_VALIDATE;
+    if ((input != NULL) && (reader->input != NULL) &&
+        (reader->allocs & XML_TEXTREADER_INPUT)) {
+	xmlFreeParserInputBuffer(reader->input);
+	reader->input = NULL;
+	reader->allocs -= XML_TEXTREADER_INPUT;
+    }
+    if (input != NULL) {
+	reader->input = input;
+	reader->allocs |= XML_TEXTREADER_INPUT;
+    }
+    if (reader->buffer == NULL)
+        reader->buffer = xmlBufferCreateSize(100);
+    if (reader->buffer == NULL) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlTextReaderSetup : malloc failed\n");
+        return (-1);
+    }
+    if (reader->sax == NULL)
+	reader->sax = (xmlSAXHandler *) xmlMalloc(sizeof(xmlSAXHandler));
+    if (reader->sax == NULL) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlTextReaderSetup : malloc failed\n");
+        return (-1);
+    }
+    xmlSAXVersion(reader->sax, 2);
+    reader->startElement = reader->sax->startElement;
+    reader->sax->startElement = xmlTextReaderStartElement;
+    reader->endElement = reader->sax->endElement;
+    reader->sax->endElement = xmlTextReaderEndElement;
+#ifdef LIBXML_SAX1_ENABLED
+    if (reader->sax->initialized == XML_SAX2_MAGIC) {
+#endif /* LIBXML_SAX1_ENABLED */
+        reader->startElementNs = reader->sax->startElementNs;
+        reader->sax->startElementNs = xmlTextReaderStartElementNs;
+        reader->endElementNs = reader->sax->endElementNs;
+        reader->sax->endElementNs = xmlTextReaderEndElementNs;
+#ifdef LIBXML_SAX1_ENABLED
+    } else {
+        reader->startElementNs = NULL;
+        reader->endElementNs = NULL;
+    }
+#endif /* LIBXML_SAX1_ENABLED */
+    reader->characters = reader->sax->characters;
+    reader->sax->characters = xmlTextReaderCharacters;
+    reader->sax->ignorableWhitespace = xmlTextReaderCharacters;
+    reader->cdataBlock = reader->sax->cdataBlock;
+    reader->sax->cdataBlock = xmlTextReaderCDataBlock;
+
+    reader->mode = XML_TEXTREADER_MODE_INITIAL;
+    reader->node = NULL;
+    reader->curnode = NULL;
+    if (input != NULL) {
+        if (reader->input->buffer->use < 4) {
+            xmlParserInputBufferRead(input, 4);
+        }
+        if (reader->ctxt == NULL) {
+            if (reader->input->buffer->use >= 4) {
+                reader->ctxt = xmlCreatePushParserCtxt(reader->sax, NULL,
+		       (const char *) reader->input->buffer->content, 4, URL);
+                reader->base = 0;
+                reader->cur = 4;
+            } else {
+                reader->ctxt =
+                    xmlCreatePushParserCtxt(reader->sax, NULL, NULL, 0, URL);
+                reader->base = 0;
+                reader->cur = 0;
+            }
+        } else {
+	    xmlParserInputPtr inputStream;
+	    xmlParserInputBufferPtr buf;
+	    xmlCharEncoding enc = XML_CHAR_ENCODING_NONE;
+
+	    xmlCtxtReset(reader->ctxt);
+	    buf = xmlAllocParserInputBuffer(enc);
+	    if (buf == NULL) return(-1);
+	    inputStream = xmlNewInputStream(reader->ctxt);
+	    if (inputStream == NULL) {
+		xmlFreeParserInputBuffer(buf);
+		return(-1);
+	    }
+
+	    if (URL == NULL)
+		inputStream->filename = NULL;
+	    else
+		inputStream->filename = (char *)
+		    xmlCanonicPath((const xmlChar *) URL);
+	    inputStream->buf = buf;
+	    inputStream->base = inputStream->buf->buffer->content;
+	    inputStream->cur = inputStream->buf->buffer->content;
+	    inputStream->end = 
+		&inputStream->buf->buffer->content[inputStream->buf->buffer->use];
+
+	    inputPush(reader->ctxt, inputStream);
+	    reader->cur = 0;
+	}
+        if (reader->ctxt == NULL) {
+            xmlGenericError(xmlGenericErrorContext,
+                            "xmlTextReaderSetup : malloc failed\n");
+            return (-1);
+        }
+    }
+    if (reader->dict != NULL) {
+        if (reader->ctxt->dict != NULL) {
+	    if (reader->dict != reader->ctxt->dict) {
+		xmlDictFree(reader->dict);
+		reader->dict = reader->ctxt->dict;
+	    }
+	} else {
+	    reader->ctxt->dict = reader->dict;
+	}
+    } else {
+	if (reader->ctxt->dict == NULL)
+	    reader->ctxt->dict = xmlDictCreate();
+        reader->dict = reader->ctxt->dict;
+    }
+    reader->ctxt->_private = reader;
+    reader->ctxt->linenumbers = 1;
+    reader->ctxt->dictNames = 1;
+    /*
+     * use the parser dictionnary to allocate all elements and attributes names
+     */
+    reader->ctxt->docdict = 1;
+
+#ifdef LIBXML_XINCLUDE_ENABLED
+    if (reader->xincctxt != NULL) {
+	xmlXIncludeFreeContext(reader->xincctxt);
+	reader->xincctxt = NULL;
+    }
+    if (options & XML_PARSE_XINCLUDE) {
+        reader->xinclude = 1;
+	reader->xinclude_name = xmlDictLookup(reader->dict, XINCLUDE_NODE, -1);
+	options -= XML_PARSE_XINCLUDE;
+    } else
+        reader->xinclude = 0;
+    reader->in_xinclude = 0;
+#endif
+#ifdef LIBXML_PATTERN_ENABLED
+    if (reader->patternTab == NULL) {
+        reader->patternNr = 0;
+	reader->patternMax = 0;
+    }
+    while (reader->patternNr > 0) {
+        reader->patternNr--;
+	if (reader->patternTab[reader->patternNr] != NULL) {
+	    xmlFreePattern(reader->patternTab[reader->patternNr]);
+            reader->patternTab[reader->patternNr] = NULL;
+	}
+    }
+#endif
+
+    if (options & XML_PARSE_DTDVALID)
+        reader->validate = XML_TEXTREADER_VALIDATE_DTD;
+
+    xmlCtxtUseOptions(reader->ctxt, options);
+    if (encoding != NULL) {
+        xmlCharEncodingHandlerPtr hdlr;
+
+        hdlr = xmlFindCharEncodingHandler(encoding);
+        if (hdlr != NULL)
+            xmlSwitchToEncoding(reader->ctxt, hdlr);
+    }
+    if ((URL != NULL) && (reader->ctxt->input != NULL) &&
+        (reader->ctxt->input->filename == NULL))
+        reader->ctxt->input->filename = (char *)
+            xmlStrdup((const xmlChar *) URL);
+
+    reader->doc = NULL;
+
+    return (0);
+}
+
+/**
+ * xmlReaderWalker:
+ * @doc:  a preparsed document
+ *
+ * Create an xmltextReader for a preparsed document.
+ * 
+ * Returns the new reader or NULL in case of error.
+ */
+xmlTextReaderPtr
+xmlReaderWalker(xmlDocPtr doc)
+{
+    xmlTextReaderPtr ret;
+
+    if (doc == NULL)
+        return(NULL);
+
+    ret = xmlMalloc(sizeof(xmlTextReader));
+    if (ret == NULL) {
+        xmlGenericError(xmlGenericErrorContext,
+		"xmlNewTextReader : malloc failed\n");
+	return(NULL);
+    }
+    memset(ret, 0, sizeof(xmlTextReader));
+    ret->entNr = 0;
+    ret->input = NULL;
+    ret->mode = XML_TEXTREADER_MODE_INITIAL;
+    ret->node = NULL;
+    ret->curnode = NULL;
+    ret->base = 0;
+    ret->cur = 0;
+    ret->allocs = XML_TEXTREADER_CTXT;
+    ret->doc = doc;
+    ret->state = XML_TEXTREADER_START;
+    ret->dict = xmlDictCreate();
+    return(ret);
+}
+
+/**
+ * xmlReaderForDoc:
+ * @cur:  a pointer to a zero terminated string
+ * @URL:  the base URL to use for the document
+ * @encoding:  the document encoding, or NULL
+ * @options:  a combination of xmlParserOption
+ *
+ * Create an xmltextReader for an XML in-memory document.
+ * The parsing flags @options are a combination of xmlParserOption.
+ * 
+ * Returns the new reader or NULL in case of error.
+ */
+xmlTextReaderPtr
+xmlReaderForDoc(const xmlChar * cur, const char *URL, const char *encoding,
+                int options)
+{
+    int len;
+
+    if (cur == NULL)
+        return (NULL);
+    len = xmlStrlen(cur);
+
+    return (xmlReaderForMemory
+            ((const char *) cur, len, URL, encoding, options));
+}
+
+/**
+ * xmlReaderForFile:
+ * @filename:  a file or URL
+ * @encoding:  the document encoding, or NULL
+ * @options:  a combination of xmlParserOption
+ *
+ * parse an XML file from the filesystem or the network.
+ * The parsing flags @options are a combination of xmlParserOption.
+ * 
+ * Returns the new reader or NULL in case of error.
+ */
+xmlTextReaderPtr
+xmlReaderForFile(const char *filename, const char *encoding, int options)
+{
+    xmlTextReaderPtr reader;
+
+    reader = xmlNewTextReaderFilename(filename);
+    if (reader == NULL)
+        return (NULL);
+    xmlTextReaderSetup(reader, NULL, NULL, encoding, options);
+    return (reader);
+}
+
+/**
+ * xmlReaderForMemory:
+ * @buffer:  a pointer to a char array
+ * @size:  the size of the array
+ * @URL:  the base URL to use for the document
+ * @encoding:  the document encoding, or NULL
+ * @options:  a combination of xmlParserOption
+ *
+ * Create an xmltextReader for an XML in-memory document.
+ * The parsing flags @options are a combination of xmlParserOption.
+ * 
+ * Returns the new reader or NULL in case of error.
+ */
+xmlTextReaderPtr
+xmlReaderForMemory(const char *buffer, int size, const char *URL,
+                   const char *encoding, int options)
+{
+    xmlTextReaderPtr reader;
+    xmlParserInputBufferPtr buf;
+
+    buf = xmlParserInputBufferCreateStatic(buffer, size,
+                                      XML_CHAR_ENCODING_NONE);
+    if (buf == NULL) {
+        return (NULL);
+    }
+    reader = xmlNewTextReader(buf, URL);
+    if (reader == NULL) {
+        xmlFreeParserInputBuffer(buf);
+        return (NULL);
+    }
+    reader->allocs |= XML_TEXTREADER_INPUT;
+    xmlTextReaderSetup(reader, NULL, URL, encoding, options);
+    return (reader);
+}
+
+/**
+ * xmlReaderForFd:
+ * @fd:  an open file descriptor
+ * @URL:  the base URL to use for the document
+ * @encoding:  the document encoding, or NULL
+ * @options:  a combination of xmlParserOption
+ *
+ * Create an xmltextReader for an XML from a file descriptor.
+ * The parsing flags @options are a combination of xmlParserOption.
+ * NOTE that the file descriptor will not be closed when the
+ *      reader is closed or reset.
+ * 
+ * Returns the new reader or NULL in case of error.
+ */
+xmlTextReaderPtr
+xmlReaderForFd(int fd, const char *URL, const char *encoding, int options)
+{
+    xmlTextReaderPtr reader;
+    xmlParserInputBufferPtr input;
+
+    if (fd < 0)
+        return (NULL);
+
+    input = xmlParserInputBufferCreateFd(fd, XML_CHAR_ENCODING_NONE);
+    if (input == NULL)
+        return (NULL);
+    input->closecallback = NULL;
+    reader = xmlNewTextReader(input, URL);
+    if (reader == NULL) {
+        xmlFreeParserInputBuffer(input);
+        return (NULL);
+    }
+    reader->allocs |= XML_TEXTREADER_INPUT;
+    xmlTextReaderSetup(reader, NULL, URL, encoding, options);
+    return (reader);
+}
+
+/**
+ * xmlReaderForIO:
+ * @ioread:  an I/O read function
+ * @ioclose:  an I/O close function
+ * @ioctx:  an I/O handler
+ * @URL:  the base URL to use for the document
+ * @encoding:  the document encoding, or NULL
+ * @options:  a combination of xmlParserOption
+ *
+ * Create an xmltextReader for an XML document from I/O functions and source.
+ * The parsing flags @options are a combination of xmlParserOption.
+ * 
+ * Returns the new reader or NULL in case of error.
+ */
+xmlTextReaderPtr
+xmlReaderForIO(xmlInputReadCallback ioread, xmlInputCloseCallback ioclose,
+               void *ioctx, const char *URL, const char *encoding,
+               int options)
+{
+    xmlTextReaderPtr reader;
+    xmlParserInputBufferPtr input;
+
+    if (ioread == NULL)
+        return (NULL);
+
+    input = xmlParserInputBufferCreateIO(ioread, ioclose, ioctx,
+                                         XML_CHAR_ENCODING_NONE);
+    if (input == NULL)
+        return (NULL);
+    reader = xmlNewTextReader(input, URL);
+    if (reader == NULL) {
+        xmlFreeParserInputBuffer(input);
+        return (NULL);
+    }
+    reader->allocs |= XML_TEXTREADER_INPUT;
+    xmlTextReaderSetup(reader, NULL, URL, encoding, options);
+    return (reader);
+}
+
+/**
+ * xmlReaderNewWalker:
+ * @reader:  an XML reader
+ * @doc:  a preparsed document
+ *
+ * Setup an xmltextReader to parse a preparsed XML document.
+ * This reuses the existing @reader xmlTextReader.
+ * 
+ * Returns 0 in case of success and -1 in case of error
+ */
+int
+xmlReaderNewWalker(xmlTextReaderPtr reader, xmlDocPtr doc)
+{
+    if (doc == NULL)
+        return (-1);
+    if (reader == NULL)
+        return (-1);
+
+    if (reader->ctxt != NULL) {
+	xmlCtxtReset(reader->ctxt);
+    }
+
+    reader->entNr = 0;
+    reader->input = NULL;
+    reader->mode = XML_TEXTREADER_MODE_INITIAL;
+    reader->node = NULL;
+    reader->curnode = NULL;
+    reader->base = 0;
+    reader->cur = 0;
+    reader->allocs = XML_TEXTREADER_CTXT;
+    reader->doc = doc;
+    reader->state = XML_TEXTREADER_START;
+    if (reader->dict == NULL) {
+        if ((reader->ctxt != NULL) && (reader->ctxt->dict != NULL))
+	    reader->dict = reader->ctxt->dict;
+	else
+	    reader->dict = xmlDictCreate();
+    }
+    return(0);
+}
+
+/**
+ * xmlReaderNewDoc:
+ * @reader:  an XML reader
+ * @cur:  a pointer to a zero terminated string
+ * @URL:  the base URL to use for the document
+ * @encoding:  the document encoding, or NULL
+ * @options:  a combination of xmlParserOption
+ *
+ * Setup an xmltextReader to parse an XML in-memory document.
+ * The parsing flags @options are a combination of xmlParserOption.
+ * This reuses the existing @reader xmlTextReader.
+ * 
+ * Returns 0 in case of success and -1 in case of error
+ */
+int
+xmlReaderNewDoc(xmlTextReaderPtr reader, const xmlChar * cur,
+                const char *URL, const char *encoding, int options)
+{
+
+    int len;
+
+    if (cur == NULL)
+        return (-1);
+    if (reader == NULL)
+        return (-1);
+
+    len = xmlStrlen(cur);
+    return (xmlReaderNewMemory(reader, (const char *)cur, len,
+                               URL, encoding, options));
+}
+
+/**
+ * xmlReaderNewFile:
+ * @reader:  an XML reader
+ * @filename:  a file or URL
+ * @encoding:  the document encoding, or NULL
+ * @options:  a combination of xmlParserOption
+ *
+ * parse an XML file from the filesystem or the network.
+ * The parsing flags @options are a combination of xmlParserOption.
+ * This reuses the existing @reader xmlTextReader.
+ * 
+ * Returns 0 in case of success and -1 in case of error
+ */
+int
+xmlReaderNewFile(xmlTextReaderPtr reader, const char *filename,
+                 const char *encoding, int options)
+{
+    xmlParserInputBufferPtr input;
+
+    if (filename == NULL)
+        return (-1);
+    if (reader == NULL)
+        return (-1);
+
+    input =
+        xmlParserInputBufferCreateFilename(filename,
+                                           XML_CHAR_ENCODING_NONE);
+    if (input == NULL)
+        return (-1);
+    return (xmlTextReaderSetup(reader, input, filename, encoding, options));
+}
+
+/**
+ * xmlReaderNewMemory:
+ * @reader:  an XML reader
+ * @buffer:  a pointer to a char array
+ * @size:  the size of the array
+ * @URL:  the base URL to use for the document
+ * @encoding:  the document encoding, or NULL
+ * @options:  a combination of xmlParserOption
+ *
+ * Setup an xmltextReader to parse an XML in-memory document.
+ * The parsing flags @options are a combination of xmlParserOption.
+ * This reuses the existing @reader xmlTextReader.
+ * 
+ * Returns 0 in case of success and -1 in case of error
+ */
+int
+xmlReaderNewMemory(xmlTextReaderPtr reader, const char *buffer, int size,
+                   const char *URL, const char *encoding, int options)
+{
+    xmlParserInputBufferPtr input;
+
+    if (reader == NULL)
+        return (-1);
+    if (buffer == NULL)
+        return (-1);
+
+    input = xmlParserInputBufferCreateStatic(buffer, size,
+                                      XML_CHAR_ENCODING_NONE);
+    if (input == NULL) {
+        return (-1);
+    }
+    return (xmlTextReaderSetup(reader, input, URL, encoding, options));
+}
+
+/**
+ * xmlReaderNewFd:
+ * @reader:  an XML reader
+ * @fd:  an open file descriptor
+ * @URL:  the base URL to use for the document
+ * @encoding:  the document encoding, or NULL
+ * @options:  a combination of xmlParserOption
+ *
+ * Setup an xmltextReader to parse an XML from a file descriptor.
+ * NOTE that the file descriptor will not be closed when the
+ *      reader is closed or reset.
+ * The parsing flags @options are a combination of xmlParserOption.
+ * This reuses the existing @reader xmlTextReader.
+ * 
+ * Returns 0 in case of success and -1 in case of error
+ */
+int
+xmlReaderNewFd(xmlTextReaderPtr reader, int fd,
+               const char *URL, const char *encoding, int options)
+{
+    xmlParserInputBufferPtr input;
+
+    if (fd < 0)
+        return (-1);
+    if (reader == NULL)
+        return (-1);
+
+    input = xmlParserInputBufferCreateFd(fd, XML_CHAR_ENCODING_NONE);
+    if (input == NULL)
+        return (-1);
+    input->closecallback = NULL;
+    return (xmlTextReaderSetup(reader, input, URL, encoding, options));
+}
+
+/**
+ * xmlReaderNewIO:
+ * @reader:  an XML reader
+ * @ioread:  an I/O read function
+ * @ioclose:  an I/O close function
+ * @ioctx:  an I/O handler
+ * @URL:  the base URL to use for the document
+ * @encoding:  the document encoding, or NULL
+ * @options:  a combination of xmlParserOption
+ *
+ * Setup an xmltextReader to parse an XML document from I/O functions
+ * and source.
+ * The parsing flags @options are a combination of xmlParserOption.
+ * This reuses the existing @reader xmlTextReader.
+ * 
+ * Returns 0 in case of success and -1 in case of error
+ */
+int
+xmlReaderNewIO(xmlTextReaderPtr reader, xmlInputReadCallback ioread,
+               xmlInputCloseCallback ioclose, void *ioctx,
+               const char *URL, const char *encoding, int options)
+{
+    xmlParserInputBufferPtr input;
+
+    if (ioread == NULL)
+        return (-1);
+    if (reader == NULL)
+        return (-1);
+
+    input = xmlParserInputBufferCreateIO(ioread, ioclose, ioctx,
+                                         XML_CHAR_ENCODING_NONE);
+    if (input == NULL)
+        return (-1);
+    return (xmlTextReaderSetup(reader, input, URL, encoding, options));
+}
+/************************************************************************
+ *									*
+ *			Utilities					*
+ *									*
+ ************************************************************************/
+#ifdef NOT_USED_YET
+/**
+ * xmlBase64Decode:
+ * @in:  the input buffer
+ * @inlen:  the size of the input (in), the size read from it (out)
+ * @to:  the output buffer
+ * @tolen:  the size of the output (in), the size written to (out)
+ *
+ * Base64 decoder, reads from @in and save in @to
+ * TODO: tell jody when this is actually exported
+ *
+ * Returns 0 if all the input was consumer, 1 if the Base64 end was reached,
+ *         2 if there wasn't enough space on the output or -1 in case of error.
+ */
+static int
+xmlBase64Decode(const unsigned char *in, unsigned long *inlen,
+	        unsigned char *to, unsigned long *tolen) {
+    unsigned long incur;		/* current index in in[] */
+    unsigned long inblk;		/* last block index in in[] */
+    unsigned long outcur;		/* current index in out[] */
+    unsigned long inmax;		/* size of in[] */
+    unsigned long outmax;		/* size of out[] */
+    unsigned char cur;			/* the current value read from in[] */
+    unsigned char intmp[4], outtmp[4];	/* temporary buffers for the convert */
+    int nbintmp;			/* number of byte in intmp[] */
+    int is_ignore;			/* cur should be ignored */
+    int is_end = 0;			/* the end of the base64 was found */
+    int retval = 1;
+    int i;
+
+    if ((in == NULL) || (inlen == NULL) || (to == NULL) || (tolen == NULL))
+	return(-1);
+
+    incur = 0;
+    inblk = 0;
+    outcur = 0;
+    inmax = *inlen;
+    outmax = *tolen;
+    nbintmp = 0;
+
+    while (1) {
+        if (incur >= inmax)
+            break;
+        cur = in[incur++];
+        is_ignore = 0;
+        if ((cur >= 'A') && (cur <= 'Z'))
+            cur = cur - 'A';
+        else if ((cur >= 'a') && (cur <= 'z'))
+            cur = cur - 'a' + 26;
+        else if ((cur >= '0') && (cur <= '9'))
+            cur = cur - '0' + 52;
+        else if (cur == '+')
+            cur = 62;
+        else if (cur == '/')
+            cur = 63;
+        else if (cur == '.')
+            cur = 0;
+        else if (cur == '=') /*no op , end of the base64 stream */
+            is_end = 1;
+        else {
+            is_ignore = 1;
+	    if (nbintmp == 0)
+		inblk = incur;
+	}
+
+        if (!is_ignore) {
+            int nbouttmp = 3;
+            int is_break = 0;
+
+            if (is_end) {
+                if (nbintmp == 0)
+                    break;
+                if ((nbintmp == 1) || (nbintmp == 2))
+                    nbouttmp = 1;
+                else
+                    nbouttmp = 2;
+                nbintmp = 3;
+                is_break = 1;
+            }
+            intmp[nbintmp++] = cur;
+	    /*
+	     * if intmp is full, push the 4byte sequence as a 3 byte
+	     * sequence out
+	     */
+            if (nbintmp == 4) {
+                nbintmp = 0;
+                outtmp[0] = (intmp[0] << 2) | ((intmp[1] & 0x30) >> 4);
+                outtmp[1] =
+                    ((intmp[1] & 0x0F) << 4) | ((intmp[2] & 0x3C) >> 2);
+                outtmp[2] = ((intmp[2] & 0x03) << 6) | (intmp[3] & 0x3F);
+		if (outcur + 3 >= outmax) {
+		    retval = 2;
+		    break;
+		}
+
+                for (i = 0; i < nbouttmp; i++)
+		    to[outcur++] = outtmp[i];
+		inblk = incur;
+            }
+
+            if (is_break) {
+		retval = 0;
+                break;
+	    }
+        }
+    }
+
+    *tolen = outcur;
+    *inlen = inblk;
+    return (retval);
+}
+
+/*
+ * Test routine for the xmlBase64Decode function
+ */
+#if 0
+int main(int argc, char **argv) {
+    char *input = "  VW4 gcGV0        \n      aXQgdGVzdCAuCg== ";
+    char output[100];
+    char output2[100];
+    char output3[100];
+    unsigned long inlen = strlen(input);
+    unsigned long outlen = 100;
+    int ret;
+    unsigned long cons, tmp, tmp2, prod;
+
+    /*
+     * Direct
+     */
+    ret = xmlBase64Decode(input, &inlen, output, &outlen);
+
+    output[outlen] = 0;
+    printf("ret: %d, inlen: %ld , outlen: %ld, output: '%s'\n", ret, inlen, outlen, output);
+    
+    /*
+     * output chunking
+     */
+    cons = 0;
+    prod = 0;
+    while (cons < inlen) {
+	tmp = 5;
+	tmp2 = inlen - cons;
+
+	printf("%ld %ld\n", cons, prod);
+	ret = xmlBase64Decode(&input[cons], &tmp2, &output2[prod], &tmp);
+	cons += tmp2;
+	prod += tmp;
+	printf("%ld %ld\n", cons, prod);
+    }
+    output2[outlen] = 0;
+    printf("ret: %d, cons: %ld , prod: %ld, output: '%s'\n", ret, cons, prod, output2);
+
+    /*
+     * input chunking
+     */
+    cons = 0;
+    prod = 0;
+    while (cons < inlen) {
+	tmp = 100 - prod;
+	tmp2 = inlen - cons;
+	if (tmp2 > 5)
+	    tmp2 = 5;
+
+	printf("%ld %ld\n", cons, prod);
+	ret = xmlBase64Decode(&input[cons], &tmp2, &output3[prod], &tmp);
+	cons += tmp2;
+	prod += tmp;
+	printf("%ld %ld\n", cons, prod);
+    }
+    output3[outlen] = 0;
+    printf("ret: %d, cons: %ld , prod: %ld, output: '%s'\n", ret, cons, prod, output3);
+    return(0);
+
+}
+#endif
+#endif /* NOT_USED_YET */
+#endif /* LIBXML_READER_ENABLED */
diff --git a/src/libxml/src/xmlregexp.c b/src/libxml/src/xmlregexp.c
new file mode 100644
index 0000000..d1e6f38
--- /dev/null
+++ b/src/libxml/src/xmlregexp.c
@@ -0,0 +1,4615 @@
+/*
+ * regexp.c: generic and extensible Regular Expression engine
+ *
+ * Basically designed with the purpose of compiling regexps for 
+ * the variety of validation/shemas mechanisms now available in
+ * XML related specifications thise includes:
+ *    - XML-1.0 DTD validation
+ *    - XML Schemas structure part 1
+ *    - XML Schemas Datatypes part 2 especially Appendix F
+ *    - RELAX-NG/TREX i.e. the counter proposal
+ *
+ * See Copyright for the status of this software.
+ *
+ * Daniel Veillard <veillard@redhat.com>
+ */
+
+#define IN_LIBXML
+#include "libxml.h"
+
+#ifdef LIBXML_REGEXP_ENABLED
+
+#include <stdio.h>
+#include <string.h>
+#ifdef HAVE_LIMITS_H
+#include <limits.h>
+#endif
+
+#include <libxml/tree.h>
+#include <libxml/parserInternals.h>
+#include <libxml/xmlregexp.h>
+#include <libxml/xmlautomata.h>
+#include <libxml/xmlunicode.h>
+
+#ifndef INT_MAX
+#define INT_MAX 123456789 /* easy to flag and big enough for our needs */
+#endif
+
+/* #define DEBUG_REGEXP_GRAPH  */
+/* #define DEBUG_REGEXP_EXEC */
+/* #define DEBUG_PUSH */
+/* #define DEBUG_COMPACTION */
+
+#define ERROR(str)							\
+    ctxt->error = XML_REGEXP_COMPILE_ERROR;				\
+    xmlRegexpErrCompile(ctxt, str);
+#define NEXT ctxt->cur++
+#define CUR (*(ctxt->cur))
+#define NXT(index) (ctxt->cur[index])
+
+#define CUR_SCHAR(s, l) xmlStringCurrentChar(NULL, s, &l)
+#define NEXTL(l) ctxt->cur += l;
+
+/**
+ * TODO:
+ *
+ * macro to flag unimplemented blocks
+ */
+#define TODO 								\
+    xmlGenericError(xmlGenericErrorContext,				\
+	    "Unimplemented block at %s:%d\n",				\
+            __FILE__, __LINE__);
+
+/************************************************************************
+ * 									*
+ * 			Datatypes and structures			*
+ * 									*
+ ************************************************************************/
+
+typedef enum {
+    XML_REGEXP_EPSILON = 1,
+    XML_REGEXP_CHARVAL,
+    XML_REGEXP_RANGES,
+    XML_REGEXP_SUBREG,
+    XML_REGEXP_STRING,
+    XML_REGEXP_ANYCHAR, /* . */
+    XML_REGEXP_ANYSPACE, /* \s */
+    XML_REGEXP_NOTSPACE, /* \S */
+    XML_REGEXP_INITNAME, /* \l */
+    XML_REGEXP_NOTINITNAME, /* \l */
+    XML_REGEXP_NAMECHAR, /* \c */
+    XML_REGEXP_NOTNAMECHAR, /* \C */
+    XML_REGEXP_DECIMAL, /* \d */
+    XML_REGEXP_NOTDECIMAL, /* \d */
+    XML_REGEXP_REALCHAR, /* \w */
+    XML_REGEXP_NOTREALCHAR, /* \w */
+    XML_REGEXP_LETTER,
+    XML_REGEXP_LETTER_UPPERCASE,
+    XML_REGEXP_LETTER_LOWERCASE,
+    XML_REGEXP_LETTER_TITLECASE,
+    XML_REGEXP_LETTER_MODIFIER,
+    XML_REGEXP_LETTER_OTHERS,
+    XML_REGEXP_MARK,
+    XML_REGEXP_MARK_NONSPACING,
+    XML_REGEXP_MARK_SPACECOMBINING,
+    XML_REGEXP_MARK_ENCLOSING,
+    XML_REGEXP_NUMBER,
+    XML_REGEXP_NUMBER_DECIMAL,
+    XML_REGEXP_NUMBER_LETTER,
+    XML_REGEXP_NUMBER_OTHERS,
+    XML_REGEXP_PUNCT,
+    XML_REGEXP_PUNCT_CONNECTOR,
+    XML_REGEXP_PUNCT_DASH,
+    XML_REGEXP_PUNCT_OPEN,
+    XML_REGEXP_PUNCT_CLOSE,
+    XML_REGEXP_PUNCT_INITQUOTE,
+    XML_REGEXP_PUNCT_FINQUOTE,
+    XML_REGEXP_PUNCT_OTHERS,
+    XML_REGEXP_SEPAR,
+    XML_REGEXP_SEPAR_SPACE,
+    XML_REGEXP_SEPAR_LINE,
+    XML_REGEXP_SEPAR_PARA,
+    XML_REGEXP_SYMBOL,
+    XML_REGEXP_SYMBOL_MATH,
+    XML_REGEXP_SYMBOL_CURRENCY,
+    XML_REGEXP_SYMBOL_MODIFIER,
+    XML_REGEXP_SYMBOL_OTHERS,
+    XML_REGEXP_OTHER,
+    XML_REGEXP_OTHER_CONTROL,
+    XML_REGEXP_OTHER_FORMAT,
+    XML_REGEXP_OTHER_PRIVATE,
+    XML_REGEXP_OTHER_NA,
+    XML_REGEXP_BLOCK_NAME
+} xmlRegAtomType;
+
+typedef enum {
+    XML_REGEXP_QUANT_EPSILON = 1,
+    XML_REGEXP_QUANT_ONCE,
+    XML_REGEXP_QUANT_OPT,
+    XML_REGEXP_QUANT_MULT,
+    XML_REGEXP_QUANT_PLUS,
+    XML_REGEXP_QUANT_ONCEONLY,
+    XML_REGEXP_QUANT_ALL,
+    XML_REGEXP_QUANT_RANGE
+} xmlRegQuantType;
+
+typedef enum {
+    XML_REGEXP_START_STATE = 1,
+    XML_REGEXP_FINAL_STATE,
+    XML_REGEXP_TRANS_STATE
+} xmlRegStateType;
+
+typedef enum {
+    XML_REGEXP_MARK_NORMAL = 0,
+    XML_REGEXP_MARK_START,
+    XML_REGEXP_MARK_VISITED
+} xmlRegMarkedType;
+
+typedef struct _xmlRegRange xmlRegRange;
+typedef xmlRegRange *xmlRegRangePtr;
+
+struct _xmlRegRange {
+    int neg;		/* 0 normal, 1 not, 2 exclude */
+    xmlRegAtomType type;
+    int start;
+    int end;
+    xmlChar *blockName;
+};
+
+typedef struct _xmlRegAtom xmlRegAtom;
+typedef xmlRegAtom *xmlRegAtomPtr;
+
+typedef struct _xmlAutomataState xmlRegState;
+typedef xmlRegState *xmlRegStatePtr;
+
+struct _xmlRegAtom {
+    int no;
+    xmlRegAtomType type;
+    xmlRegQuantType quant;
+    int min;
+    int max;
+
+    void *valuep;
+    void *valuep2;
+    int neg;
+    int codepoint;
+    xmlRegStatePtr start;
+    xmlRegStatePtr stop;
+    int maxRanges;
+    int nbRanges;
+    xmlRegRangePtr *ranges;
+    void *data;
+};
+
+typedef struct _xmlRegCounter xmlRegCounter;
+typedef xmlRegCounter *xmlRegCounterPtr;
+
+struct _xmlRegCounter {
+    int min;
+    int max;
+};
+
+typedef struct _xmlRegTrans xmlRegTrans;
+typedef xmlRegTrans *xmlRegTransPtr;
+
+struct _xmlRegTrans {
+    xmlRegAtomPtr atom;
+    int to;
+    int counter;
+    int count;
+};
+
+struct _xmlAutomataState {
+    xmlRegStateType type;
+    xmlRegMarkedType mark;
+    xmlRegMarkedType reached;
+    int no;
+
+    int maxTrans;
+    int nbTrans;
+    xmlRegTrans *trans;
+};
+
+typedef struct _xmlAutomata xmlRegParserCtxt;
+typedef xmlRegParserCtxt *xmlRegParserCtxtPtr;
+
+struct _xmlAutomata {
+    xmlChar *string;
+    xmlChar *cur;
+
+    int error;
+    int neg;
+
+    xmlRegStatePtr start;
+    xmlRegStatePtr end;
+    xmlRegStatePtr state;
+
+    xmlRegAtomPtr atom;
+
+    int maxAtoms;
+    int nbAtoms;
+    xmlRegAtomPtr *atoms;
+
+    int maxStates;
+    int nbStates;
+    xmlRegStatePtr *states;
+
+    int maxCounters;
+    int nbCounters;
+    xmlRegCounter *counters;
+
+    int determinist;
+};
+
+struct _xmlRegexp {
+    xmlChar *string;
+    int nbStates;
+    xmlRegStatePtr *states;
+    int nbAtoms;
+    xmlRegAtomPtr *atoms;
+    int nbCounters;
+    xmlRegCounter *counters;
+    int determinist;
+    /*
+     * That's the compact form for determinists automatas
+     */
+    int nbstates;
+    int *compact;
+    void **transdata;
+    int nbstrings;
+    xmlChar **stringMap;
+};
+
+typedef struct _xmlRegExecRollback xmlRegExecRollback;
+typedef xmlRegExecRollback *xmlRegExecRollbackPtr;
+
+struct _xmlRegExecRollback {
+    xmlRegStatePtr state;/* the current state */
+    int index;		/* the index in the input stack */
+    int nextbranch;	/* the next transition to explore in that state */
+    int *counts;	/* save the automate state if it has some */
+};
+
+typedef struct _xmlRegInputToken xmlRegInputToken;
+typedef xmlRegInputToken *xmlRegInputTokenPtr;
+
+struct _xmlRegInputToken {
+    xmlChar *value;
+    void *data;
+};
+
+struct _xmlRegExecCtxt {
+    int status;		/* execution status != 0 indicate an error */
+    int determinist;	/* did we found an inderterministic behaviour */
+    xmlRegexpPtr comp;	/* the compiled regexp */
+    xmlRegExecCallbacks callback;
+    void *data;
+
+    xmlRegStatePtr state;/* the current state */
+    int transno;	/* the current transition on that state */
+    int transcount;	/* the number of char in char counted transitions */
+
+    /*
+     * A stack of rollback states
+     */
+    int maxRollbacks;
+    int nbRollbacks;
+    xmlRegExecRollback *rollbacks;
+
+    /*
+     * The state of the automata if any
+     */
+    int *counts;
+
+    /*
+     * The input stack
+     */
+    int inputStackMax;
+    int inputStackNr;
+    int index;
+    int *charStack;
+    const xmlChar *inputString; /* when operating on characters */
+    xmlRegInputTokenPtr inputStack;/* when operating on strings */
+
+};
+
+#define REGEXP_ALL_COUNTER	0x123456
+#define REGEXP_ALL_LAX_COUNTER	0x123457
+
+static void xmlFAParseRegExp(xmlRegParserCtxtPtr ctxt, int top);
+static void xmlRegFreeState(xmlRegStatePtr state);
+static void xmlRegFreeAtom(xmlRegAtomPtr atom);
+
+/************************************************************************
+ *									*
+ * 		Regexp memory error handler				*
+ *									*
+ ************************************************************************/
+/**
+ * xmlRegexpErrMemory:
+ * @extra:  extra informations
+ *
+ * Handle an out of memory condition
+ */
+static void
+xmlRegexpErrMemory(xmlRegParserCtxtPtr ctxt, const char *extra)
+{
+    const char *regexp = NULL;
+    if (ctxt != NULL) {
+        regexp = (const char *) ctxt->string;
+	ctxt->error = XML_ERR_NO_MEMORY;
+    }
+    __xmlRaiseError(NULL, NULL, NULL, NULL, NULL, XML_FROM_REGEXP,
+		    XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0, extra,
+		    regexp, NULL, 0, 0,
+		    "Memory allocation failed : %s\n", extra);
+}
+
+/**
+ * xmlRegexpErrCompile:
+ * @extra:  extra informations
+ *
+ * Handle an compilation failure
+ */
+static void
+xmlRegexpErrCompile(xmlRegParserCtxtPtr ctxt, const char *extra)
+{
+    const char *regexp = NULL;
+    int idx = 0;
+
+    if (ctxt != NULL) {
+        regexp = (const char *) ctxt->string;
+	idx = ctxt->cur - ctxt->string;
+	ctxt->error = XML_REGEXP_COMPILE_ERROR;
+    }
+    __xmlRaiseError(NULL, NULL, NULL, NULL, NULL, XML_FROM_REGEXP,
+		    XML_REGEXP_COMPILE_ERROR, XML_ERR_FATAL, NULL, 0, extra,
+		    regexp, NULL, idx, 0,
+		    "failed to compile: %s\n", extra);
+}
+
+/************************************************************************
+ * 									*
+ * 			Allocation/Deallocation				*
+ * 									*
+ ************************************************************************/
+
+static int xmlFAComputesDeterminism(xmlRegParserCtxtPtr ctxt);
+/**
+ * xmlRegEpxFromParse:
+ * @ctxt:  the parser context used to build it
+ *
+ * Allocate a new regexp and fill it with the reult from the parser
+ *
+ * Returns the new regexp or NULL in case of error
+ */
+static xmlRegexpPtr
+xmlRegEpxFromParse(xmlRegParserCtxtPtr ctxt) {
+    xmlRegexpPtr ret;
+
+    ret = (xmlRegexpPtr) xmlMalloc(sizeof(xmlRegexp));
+    if (ret == NULL) {
+	xmlRegexpErrMemory(ctxt, "compiling regexp");
+	return(NULL);
+    }
+    memset(ret, 0, sizeof(xmlRegexp));
+    ret->string = ctxt->string;
+    ret->nbStates = ctxt->nbStates;
+    ret->states = ctxt->states;
+    ret->nbAtoms = ctxt->nbAtoms;
+    ret->atoms = ctxt->atoms;
+    ret->nbCounters = ctxt->nbCounters;
+    ret->counters = ctxt->counters;
+    ret->determinist = ctxt->determinist;
+
+    if ((ret->determinist != 0) &&
+	(ret->nbCounters == 0) &&
+	(ret->atoms != NULL) &&
+	(ret->atoms[0] != NULL) &&
+	(ret->atoms[0]->type == XML_REGEXP_STRING)) {
+	int i, j, nbstates = 0, nbatoms = 0;
+	int *stateRemap;
+	int *stringRemap;
+	int *transitions;
+	void **transdata;
+	xmlChar **stringMap;
+        xmlChar *value;
+
+	/*
+	 * Switch to a compact representation
+	 * 1/ counting the effective number of states left
+	 * 2/ conting the unique number of atoms, and check that
+	 *    they are all of the string type
+	 * 3/ build a table state x atom for the transitions
+	 */
+
+	stateRemap = xmlMalloc(ret->nbStates * sizeof(int));
+	if (stateRemap == NULL) {
+	    xmlRegexpErrMemory(ctxt, "compiling regexp");
+	    xmlFree(ret);
+	    return(NULL);
+	}
+	for (i = 0;i < ret->nbStates;i++) {
+	    if (ret->states[i] != NULL) {
+		stateRemap[i] = nbstates;
+		nbstates++;
+	    } else {
+		stateRemap[i] = -1;
+	    }
+	}
+#ifdef DEBUG_COMPACTION
+	printf("Final: %d states\n", nbstates);
+#endif
+	stringMap = xmlMalloc(ret->nbAtoms * sizeof(char *));
+	if (stringMap == NULL) {
+	    xmlRegexpErrMemory(ctxt, "compiling regexp");
+	    xmlFree(stateRemap);
+	    xmlFree(ret);
+	    return(NULL);
+	}
+	stringRemap = xmlMalloc(ret->nbAtoms * sizeof(int));
+	if (stringRemap == NULL) {
+	    xmlRegexpErrMemory(ctxt, "compiling regexp");
+	    xmlFree(stringMap);
+	    xmlFree(stateRemap);
+	    xmlFree(ret);
+	    return(NULL);
+	}
+	for (i = 0;i < ret->nbAtoms;i++) {
+	    if ((ret->atoms[i]->type == XML_REGEXP_STRING) &&
+		(ret->atoms[i]->quant == XML_REGEXP_QUANT_ONCE)) {
+		value = ret->atoms[i]->valuep;
+                for (j = 0;j < nbatoms;j++) {
+		    if (xmlStrEqual(stringMap[j], value)) {
+			stringRemap[i] = j;
+			break;
+		    }
+		}
+		if (j >= nbatoms) {
+		    stringRemap[i] = nbatoms;
+		    stringMap[nbatoms] = xmlStrdup(value);
+		    if (stringMap[nbatoms] == NULL) {
+			for (i = 0;i < nbatoms;i++)
+			    xmlFree(stringMap[i]);
+			xmlFree(stringRemap);
+			xmlFree(stringMap);
+			xmlFree(stateRemap);
+			xmlFree(ret);
+			return(NULL);
+		    }
+		    nbatoms++;
+		}
+	    } else {
+		xmlFree(stateRemap);
+		xmlFree(stringRemap);
+		for (i = 0;i < nbatoms;i++)
+		    xmlFree(stringMap[i]);
+		xmlFree(stringMap);
+		xmlFree(ret);
+		return(NULL);
+	    }
+	}
+#ifdef DEBUG_COMPACTION
+	printf("Final: %d atoms\n", nbatoms);
+#endif
+	transitions = (int *) xmlMalloc((nbstates + 1) *
+	                                (nbatoms + 1) * sizeof(int));
+	if (transitions == NULL) {
+	    xmlFree(stateRemap);
+	    xmlFree(stringRemap);
+	    xmlFree(stringMap);
+	    xmlFree(ret);
+	    return(NULL);
+	}
+	memset(transitions, 0, (nbstates + 1) * (nbatoms + 1) * sizeof(int));
+
+	/*
+	 * Allocate the transition table. The first entry for each
+	 * state correspond to the state type.
+	 */
+	transdata = NULL;
+
+	for (i = 0;i < ret->nbStates;i++) {
+	    int stateno, atomno, targetno, prev;
+	    xmlRegStatePtr state;
+	    xmlRegTransPtr trans;
+
+	    stateno = stateRemap[i];
+	    if (stateno == -1)
+		continue;
+	    state = ret->states[i];
+
+	    transitions[stateno * (nbatoms + 1)] = state->type;
+
+	    for (j = 0;j < state->nbTrans;j++) {
+		trans = &(state->trans[j]);
+		if ((trans->to == -1) || (trans->atom == NULL))
+		    continue;
+                atomno = stringRemap[trans->atom->no];
+		if ((trans->atom->data != NULL) && (transdata == NULL)) {
+		    transdata = (void **) xmlMalloc(nbstates * nbatoms *
+			                            sizeof(void *));
+		    if (transdata != NULL)
+			memset(transdata, 0,
+			       nbstates * nbatoms * sizeof(void *));
+		    else {
+			xmlRegexpErrMemory(ctxt, "compiling regexp");
+			break;
+		    }
+		}
+		targetno = stateRemap[trans->to];
+		/*
+		 * if the same atome can generate transition to 2 different
+		 * states then it means the automata is not determinist and
+		 * the compact form can't be used !
+		 */
+		prev = transitions[stateno * (nbatoms + 1) + atomno + 1];
+		if (prev != 0) {
+		    if (prev != targetno + 1) {
+			ret->determinist = 0;
+#ifdef DEBUG_COMPACTION
+			printf("Indet: state %d trans %d, atom %d to %d : %d to %d\n",
+			       i, j, trans->atom->no, trans->to, atomno, targetno);
+			printf("       previous to is %d\n", prev);
+#endif
+			ret->determinist = 0;
+			if (transdata != NULL)
+			    xmlFree(transdata);
+			xmlFree(transitions);
+			xmlFree(stateRemap);
+			xmlFree(stringRemap);
+			for (i = 0;i < nbatoms;i++)
+			    xmlFree(stringMap[i]);
+			xmlFree(stringMap);
+			goto not_determ;
+		    }
+		} else {
+#if 0
+		    printf("State %d trans %d: atom %d to %d : %d to %d\n",
+			   i, j, trans->atom->no, trans->to, atomno, targetno);
+#endif
+		    transitions[stateno * (nbatoms + 1) + atomno + 1] =
+			targetno + 1; /* to avoid 0 */
+		    if (transdata != NULL)
+			transdata[stateno * nbatoms + atomno] =
+			    trans->atom->data;
+		}
+	    }
+	}
+	ret->determinist = 1;
+#ifdef DEBUG_COMPACTION
+	/*
+	 * Debug
+	 */
+	for (i = 0;i < nbstates;i++) {
+	    for (j = 0;j < nbatoms + 1;j++) {
+                printf("%02d ", transitions[i * (nbatoms + 1) + j]);
+	    }
+	    printf("\n");
+	}
+	printf("\n");
+#endif
+	/*
+	 * Cleanup of the old data
+	 */
+	if (ret->states != NULL) {
+	    for (i = 0;i < ret->nbStates;i++)
+		xmlRegFreeState(ret->states[i]);
+	    xmlFree(ret->states);
+	}
+	ret->states = NULL;
+	ret->nbStates = 0;
+	if (ret->atoms != NULL) {
+	    for (i = 0;i < ret->nbAtoms;i++)
+		xmlRegFreeAtom(ret->atoms[i]);
+	    xmlFree(ret->atoms);
+	}
+	ret->atoms = NULL;
+	ret->nbAtoms = 0;
+
+	ret->compact = transitions;
+	ret->transdata = transdata;
+	ret->stringMap = stringMap;
+	ret->nbstrings = nbatoms;
+	ret->nbstates = nbstates;
+	xmlFree(stateRemap);
+	xmlFree(stringRemap);
+    }
+not_determ:
+    ctxt->string = NULL;
+    ctxt->nbStates = 0;
+    ctxt->states = NULL;
+    ctxt->nbAtoms = 0;
+    ctxt->atoms = NULL;
+    ctxt->nbCounters = 0;
+    ctxt->counters = NULL;
+    return(ret);
+}
+
+/**
+ * xmlRegNewParserCtxt:
+ * @string:  the string to parse
+ *
+ * Allocate a new regexp parser context
+ *
+ * Returns the new context or NULL in case of error
+ */
+static xmlRegParserCtxtPtr
+xmlRegNewParserCtxt(const xmlChar *string) {
+    xmlRegParserCtxtPtr ret;
+
+    ret = (xmlRegParserCtxtPtr) xmlMalloc(sizeof(xmlRegParserCtxt));
+    if (ret == NULL)
+	return(NULL);
+    memset(ret, 0, sizeof(xmlRegParserCtxt));
+    if (string != NULL)
+	ret->string = xmlStrdup(string);
+    ret->cur = ret->string;
+    ret->neg = 0;
+    ret->error = 0;
+    ret->determinist = -1;
+    return(ret);
+}
+
+/**
+ * xmlRegNewRange:
+ * @ctxt:  the regexp parser context
+ * @neg:  is that negative
+ * @type:  the type of range
+ * @start:  the start codepoint
+ * @end:  the end codepoint
+ *
+ * Allocate a new regexp range
+ *
+ * Returns the new range or NULL in case of error
+ */
+static xmlRegRangePtr
+xmlRegNewRange(xmlRegParserCtxtPtr ctxt,
+	       int neg, xmlRegAtomType type, int start, int end) {
+    xmlRegRangePtr ret;
+
+    ret = (xmlRegRangePtr) xmlMalloc(sizeof(xmlRegRange));
+    if (ret == NULL) {
+	xmlRegexpErrMemory(ctxt, "allocating range");
+	return(NULL);
+    }
+    ret->neg = neg;
+    ret->type = type;
+    ret->start = start;
+    ret->end = end;
+    return(ret);
+}
+
+/**
+ * xmlRegFreeRange:
+ * @range:  the regexp range
+ *
+ * Free a regexp range
+ */
+static void
+xmlRegFreeRange(xmlRegRangePtr range) {
+    if (range == NULL)
+	return;
+
+    if (range->blockName != NULL)
+	xmlFree(range->blockName);
+    xmlFree(range);
+}
+
+/**
+ * xmlRegNewAtom:
+ * @ctxt:  the regexp parser context
+ * @type:  the type of atom
+ *
+ * Allocate a new regexp range
+ *
+ * Returns the new atom or NULL in case of error
+ */
+static xmlRegAtomPtr
+xmlRegNewAtom(xmlRegParserCtxtPtr ctxt, xmlRegAtomType type) {
+    xmlRegAtomPtr ret;
+
+    ret = (xmlRegAtomPtr) xmlMalloc(sizeof(xmlRegAtom));
+    if (ret == NULL) {
+	xmlRegexpErrMemory(ctxt, "allocating atom");
+	return(NULL);
+    }
+    memset(ret, 0, sizeof(xmlRegAtom));
+    ret->type = type;
+    ret->quant = XML_REGEXP_QUANT_ONCE;
+    ret->min = 0;
+    ret->max = 0;
+    return(ret);
+}
+
+/**
+ * xmlRegFreeAtom:
+ * @atom:  the regexp atom
+ *
+ * Free a regexp atom
+ */
+static void
+xmlRegFreeAtom(xmlRegAtomPtr atom) {
+    int i;
+
+    if (atom == NULL)
+	return;
+
+    for (i = 0;i < atom->nbRanges;i++)
+	xmlRegFreeRange(atom->ranges[i]);
+    if (atom->ranges != NULL)
+	xmlFree(atom->ranges);
+    if (atom->type == XML_REGEXP_STRING)
+	xmlFree(atom->valuep);
+    xmlFree(atom);
+}
+
+static xmlRegStatePtr
+xmlRegNewState(xmlRegParserCtxtPtr ctxt) {
+    xmlRegStatePtr ret;
+
+    ret = (xmlRegStatePtr) xmlMalloc(sizeof(xmlRegState));
+    if (ret == NULL) {
+	xmlRegexpErrMemory(ctxt, "allocating state");
+	return(NULL);
+    }
+    memset(ret, 0, sizeof(xmlRegState));
+    ret->type = XML_REGEXP_TRANS_STATE;
+    ret->mark = XML_REGEXP_MARK_NORMAL;
+    return(ret);
+}
+
+/**
+ * xmlRegFreeState:
+ * @state:  the regexp state
+ *
+ * Free a regexp state
+ */
+static void
+xmlRegFreeState(xmlRegStatePtr state) {
+    if (state == NULL)
+	return;
+
+    if (state->trans != NULL)
+	xmlFree(state->trans);
+    xmlFree(state);
+}
+
+/**
+ * xmlRegFreeParserCtxt:
+ * @ctxt:  the regexp parser context
+ *
+ * Free a regexp parser context
+ */
+static void
+xmlRegFreeParserCtxt(xmlRegParserCtxtPtr ctxt) {
+    int i;
+    if (ctxt == NULL)
+	return;
+
+    if (ctxt->string != NULL)
+	xmlFree(ctxt->string);
+    if (ctxt->states != NULL) {
+	for (i = 0;i < ctxt->nbStates;i++)
+	    xmlRegFreeState(ctxt->states[i]);
+	xmlFree(ctxt->states);
+    }
+    if (ctxt->atoms != NULL) {
+	for (i = 0;i < ctxt->nbAtoms;i++)
+	    xmlRegFreeAtom(ctxt->atoms[i]);
+	xmlFree(ctxt->atoms);
+    }
+    if (ctxt->counters != NULL)
+	xmlFree(ctxt->counters);
+    xmlFree(ctxt);
+}
+
+/************************************************************************
+ * 									*
+ * 			Display of Data structures			*
+ * 									*
+ ************************************************************************/
+
+static void
+xmlRegPrintAtomType(FILE *output, xmlRegAtomType type) {
+    switch (type) {
+        case XML_REGEXP_EPSILON:
+	    fprintf(output, "epsilon "); break;
+        case XML_REGEXP_CHARVAL:
+	    fprintf(output, "charval "); break;
+        case XML_REGEXP_RANGES:
+	    fprintf(output, "ranges "); break;
+        case XML_REGEXP_SUBREG:
+	    fprintf(output, "subexpr "); break;
+        case XML_REGEXP_STRING:
+	    fprintf(output, "string "); break;
+        case XML_REGEXP_ANYCHAR:
+	    fprintf(output, "anychar "); break;
+        case XML_REGEXP_ANYSPACE:
+	    fprintf(output, "anyspace "); break;
+        case XML_REGEXP_NOTSPACE:
+	    fprintf(output, "notspace "); break;
+        case XML_REGEXP_INITNAME:
+	    fprintf(output, "initname "); break;
+        case XML_REGEXP_NOTINITNAME:
+	    fprintf(output, "notinitname "); break;
+        case XML_REGEXP_NAMECHAR:
+	    fprintf(output, "namechar "); break;
+        case XML_REGEXP_NOTNAMECHAR:
+	    fprintf(output, "notnamechar "); break;
+        case XML_REGEXP_DECIMAL:
+	    fprintf(output, "decimal "); break;
+        case XML_REGEXP_NOTDECIMAL:
+	    fprintf(output, "notdecimal "); break;
+        case XML_REGEXP_REALCHAR:
+	    fprintf(output, "realchar "); break;
+        case XML_REGEXP_NOTREALCHAR:
+	    fprintf(output, "notrealchar "); break;
+        case XML_REGEXP_LETTER:
+            fprintf(output, "LETTER "); break;
+        case XML_REGEXP_LETTER_UPPERCASE:
+            fprintf(output, "LETTER_UPPERCASE "); break;
+        case XML_REGEXP_LETTER_LOWERCASE:
+            fprintf(output, "LETTER_LOWERCASE "); break;
+        case XML_REGEXP_LETTER_TITLECASE:
+            fprintf(output, "LETTER_TITLECASE "); break;
+        case XML_REGEXP_LETTER_MODIFIER:
+            fprintf(output, "LETTER_MODIFIER "); break;
+        case XML_REGEXP_LETTER_OTHERS:
+            fprintf(output, "LETTER_OTHERS "); break;
+        case XML_REGEXP_MARK:
+            fprintf(output, "MARK "); break;
+        case XML_REGEXP_MARK_NONSPACING:
+            fprintf(output, "MARK_NONSPACING "); break;
+        case XML_REGEXP_MARK_SPACECOMBINING:
+            fprintf(output, "MARK_SPACECOMBINING "); break;
+        case XML_REGEXP_MARK_ENCLOSING:
+            fprintf(output, "MARK_ENCLOSING "); break;
+        case XML_REGEXP_NUMBER:
+            fprintf(output, "NUMBER "); break;
+        case XML_REGEXP_NUMBER_DECIMAL:
+            fprintf(output, "NUMBER_DECIMAL "); break;
+        case XML_REGEXP_NUMBER_LETTER:
+            fprintf(output, "NUMBER_LETTER "); break;
+        case XML_REGEXP_NUMBER_OTHERS:
+            fprintf(output, "NUMBER_OTHERS "); break;
+        case XML_REGEXP_PUNCT:
+            fprintf(output, "PUNCT "); break;
+        case XML_REGEXP_PUNCT_CONNECTOR:
+            fprintf(output, "PUNCT_CONNECTOR "); break;
+        case XML_REGEXP_PUNCT_DASH:
+            fprintf(output, "PUNCT_DASH "); break;
+        case XML_REGEXP_PUNCT_OPEN:
+            fprintf(output, "PUNCT_OPEN "); break;
+        case XML_REGEXP_PUNCT_CLOSE:
+            fprintf(output, "PUNCT_CLOSE "); break;
+        case XML_REGEXP_PUNCT_INITQUOTE:
+            fprintf(output, "PUNCT_INITQUOTE "); break;
+        case XML_REGEXP_PUNCT_FINQUOTE:
+            fprintf(output, "PUNCT_FINQUOTE "); break;
+        case XML_REGEXP_PUNCT_OTHERS:
+            fprintf(output, "PUNCT_OTHERS "); break;
+        case XML_REGEXP_SEPAR:
+            fprintf(output, "SEPAR "); break;
+        case XML_REGEXP_SEPAR_SPACE:
+            fprintf(output, "SEPAR_SPACE "); break;
+        case XML_REGEXP_SEPAR_LINE:
+            fprintf(output, "SEPAR_LINE "); break;
+        case XML_REGEXP_SEPAR_PARA:
+            fprintf(output, "SEPAR_PARA "); break;
+        case XML_REGEXP_SYMBOL:
+            fprintf(output, "SYMBOL "); break;
+        case XML_REGEXP_SYMBOL_MATH:
+            fprintf(output, "SYMBOL_MATH "); break;
+        case XML_REGEXP_SYMBOL_CURRENCY:
+            fprintf(output, "SYMBOL_CURRENCY "); break;
+        case XML_REGEXP_SYMBOL_MODIFIER:
+            fprintf(output, "SYMBOL_MODIFIER "); break;
+        case XML_REGEXP_SYMBOL_OTHERS:
+            fprintf(output, "SYMBOL_OTHERS "); break;
+        case XML_REGEXP_OTHER:
+            fprintf(output, "OTHER "); break;
+        case XML_REGEXP_OTHER_CONTROL:
+            fprintf(output, "OTHER_CONTROL "); break;
+        case XML_REGEXP_OTHER_FORMAT:
+            fprintf(output, "OTHER_FORMAT "); break;
+        case XML_REGEXP_OTHER_PRIVATE:
+            fprintf(output, "OTHER_PRIVATE "); break;
+        case XML_REGEXP_OTHER_NA:
+            fprintf(output, "OTHER_NA "); break;
+        case XML_REGEXP_BLOCK_NAME:
+	    fprintf(output, "BLOCK "); break;
+    }
+}
+
+static void
+xmlRegPrintQuantType(FILE *output, xmlRegQuantType type) {
+    switch (type) {
+        case XML_REGEXP_QUANT_EPSILON:
+	    fprintf(output, "epsilon "); break;
+        case XML_REGEXP_QUANT_ONCE:
+	    fprintf(output, "once "); break;
+        case XML_REGEXP_QUANT_OPT:
+	    fprintf(output, "? "); break;
+        case XML_REGEXP_QUANT_MULT:
+	    fprintf(output, "* "); break;
+        case XML_REGEXP_QUANT_PLUS:
+	    fprintf(output, "+ "); break;
+	case XML_REGEXP_QUANT_RANGE:
+	    fprintf(output, "range "); break;
+	case XML_REGEXP_QUANT_ONCEONLY:
+	    fprintf(output, "onceonly "); break;
+	case XML_REGEXP_QUANT_ALL:
+	    fprintf(output, "all "); break;
+    }
+}
+static void
+xmlRegPrintRange(FILE *output, xmlRegRangePtr range) {
+    fprintf(output, "  range: ");
+    if (range->neg)
+	fprintf(output, "negative ");
+    xmlRegPrintAtomType(output, range->type);
+    fprintf(output, "%c - %c\n", range->start, range->end);
+}
+
+static void
+xmlRegPrintAtom(FILE *output, xmlRegAtomPtr atom) {
+    fprintf(output, " atom: ");
+    if (atom == NULL) {
+	fprintf(output, "NULL\n");
+	return;
+    }
+    xmlRegPrintAtomType(output, atom->type);
+    xmlRegPrintQuantType(output, atom->quant);
+    if (atom->quant == XML_REGEXP_QUANT_RANGE)
+	fprintf(output, "%d-%d ", atom->min, atom->max);
+    if (atom->type == XML_REGEXP_STRING)
+	fprintf(output, "'%s' ", (char *) atom->valuep);
+    if (atom->type == XML_REGEXP_CHARVAL)
+	fprintf(output, "char %c\n", atom->codepoint);
+    else if (atom->type == XML_REGEXP_RANGES) {
+	int i;
+	fprintf(output, "%d entries\n", atom->nbRanges);
+	for (i = 0; i < atom->nbRanges;i++)
+	    xmlRegPrintRange(output, atom->ranges[i]);
+    } else if (atom->type == XML_REGEXP_SUBREG) {
+	fprintf(output, "start %d end %d\n", atom->start->no, atom->stop->no);
+    } else {
+	fprintf(output, "\n");
+    }
+}
+
+static void
+xmlRegPrintTrans(FILE *output, xmlRegTransPtr trans) {
+    fprintf(output, "  trans: ");
+    if (trans == NULL) {
+	fprintf(output, "NULL\n");
+	return;
+    }
+    if (trans->to < 0) {
+	fprintf(output, "removed\n");
+	return;
+    }
+    if (trans->counter >= 0) {
+	fprintf(output, "counted %d, ", trans->counter);
+    }
+    if (trans->count == REGEXP_ALL_COUNTER) {
+	fprintf(output, "all transition, ");
+    } else if (trans->count >= 0) {
+	fprintf(output, "count based %d, ", trans->count);
+    }
+    if (trans->atom == NULL) {
+	fprintf(output, "epsilon to %d\n", trans->to);
+	return;
+    }
+    if (trans->atom->type == XML_REGEXP_CHARVAL)
+	fprintf(output, "char %c ", trans->atom->codepoint);
+    fprintf(output, "atom %d, to %d\n", trans->atom->no, trans->to);
+}
+    
+static void
+xmlRegPrintState(FILE *output, xmlRegStatePtr state) {
+    int i;
+
+    fprintf(output, " state: ");
+    if (state == NULL) {
+	fprintf(output, "NULL\n");
+	return;
+    }
+    if (state->type == XML_REGEXP_START_STATE)
+	fprintf(output, "START ");
+    if (state->type == XML_REGEXP_FINAL_STATE)
+	fprintf(output, "FINAL ");
+    
+    fprintf(output, "%d, %d transitions:\n", state->no, state->nbTrans);
+    for (i = 0;i < state->nbTrans; i++) {
+	xmlRegPrintTrans(output, &(state->trans[i]));
+    }
+}
+
+#ifdef DEBUG_REGEXP_GRAPH
+static void
+xmlRegPrintCtxt(FILE *output, xmlRegParserCtxtPtr ctxt) {
+    int i;
+
+    fprintf(output, " ctxt: ");
+    if (ctxt == NULL) {
+	fprintf(output, "NULL\n");
+	return;
+    }
+    fprintf(output, "'%s' ", ctxt->string);
+    if (ctxt->error)
+	fprintf(output, "error ");
+    if (ctxt->neg)
+	fprintf(output, "neg ");
+    fprintf(output, "\n");
+    fprintf(output, "%d atoms:\n", ctxt->nbAtoms);
+    for (i = 0;i < ctxt->nbAtoms; i++) {
+	fprintf(output, " %02d ", i);
+	xmlRegPrintAtom(output, ctxt->atoms[i]);
+    }
+    if (ctxt->atom != NULL) {
+	fprintf(output, "current atom:\n");
+	xmlRegPrintAtom(output, ctxt->atom);
+    }
+    fprintf(output, "%d states:", ctxt->nbStates);
+    if (ctxt->start != NULL)
+	fprintf(output, " start: %d", ctxt->start->no);
+    if (ctxt->end != NULL)
+	fprintf(output, " end: %d", ctxt->end->no);
+    fprintf(output, "\n");
+    for (i = 0;i < ctxt->nbStates; i++) {
+	xmlRegPrintState(output, ctxt->states[i]);
+    }
+    fprintf(output, "%d counters:\n", ctxt->nbCounters);
+    for (i = 0;i < ctxt->nbCounters; i++) {
+	fprintf(output, " %d: min %d max %d\n", i, ctxt->counters[i].min,
+		                                ctxt->counters[i].max);
+    }
+}
+#endif
+
+/************************************************************************
+ * 									*
+ *		 Finite Automata structures manipulations		*
+ * 									*
+ ************************************************************************/
+
+static void 
+xmlRegAtomAddRange(xmlRegParserCtxtPtr ctxt, xmlRegAtomPtr atom,
+	           int neg, xmlRegAtomType type, int start, int end,
+		   xmlChar *blockName) {
+    xmlRegRangePtr range;
+
+    if (atom == NULL) {
+	ERROR("add range: atom is NULL");
+	return;
+    }
+    if (atom->type != XML_REGEXP_RANGES) {
+	ERROR("add range: atom is not ranges");
+	return;
+    }
+    if (atom->maxRanges == 0) {
+	atom->maxRanges = 4;
+	atom->ranges = (xmlRegRangePtr *) xmlMalloc(atom->maxRanges *
+		                             sizeof(xmlRegRangePtr));
+	if (atom->ranges == NULL) {
+	    xmlRegexpErrMemory(ctxt, "adding ranges");
+	    atom->maxRanges = 0;
+	    return;
+	}
+    } else if (atom->nbRanges >= atom->maxRanges) {
+	xmlRegRangePtr *tmp;
+	atom->maxRanges *= 2;
+	tmp = (xmlRegRangePtr *) xmlRealloc(atom->ranges, atom->maxRanges *
+		                             sizeof(xmlRegRangePtr));
+	if (tmp == NULL) {
+	    xmlRegexpErrMemory(ctxt, "adding ranges");
+	    atom->maxRanges /= 2;
+	    return;
+	}
+	atom->ranges = tmp;
+    }
+    range = xmlRegNewRange(ctxt, neg, type, start, end);
+    if (range == NULL)
+	return;
+    range->blockName = blockName;
+    atom->ranges[atom->nbRanges++] = range;
+    
+}
+
+static int
+xmlRegGetCounter(xmlRegParserCtxtPtr ctxt) {
+    if (ctxt->maxCounters == 0) {
+	ctxt->maxCounters = 4;
+	ctxt->counters = (xmlRegCounter *) xmlMalloc(ctxt->maxCounters *
+		                             sizeof(xmlRegCounter));
+	if (ctxt->counters == NULL) {
+	    xmlRegexpErrMemory(ctxt, "allocating counter");
+	    ctxt->maxCounters = 0;
+	    return(-1);
+	}
+    } else if (ctxt->nbCounters >= ctxt->maxCounters) {
+	xmlRegCounter *tmp;
+	ctxt->maxCounters *= 2;
+	tmp = (xmlRegCounter *) xmlRealloc(ctxt->counters, ctxt->maxCounters *
+		                           sizeof(xmlRegCounter));
+	if (tmp == NULL) {
+	    xmlRegexpErrMemory(ctxt, "allocating counter");
+	    ctxt->maxCounters /= 2;
+	    return(-1);
+	}
+	ctxt->counters = tmp;
+    }
+    ctxt->counters[ctxt->nbCounters].min = -1;
+    ctxt->counters[ctxt->nbCounters].max = -1;
+    return(ctxt->nbCounters++);
+}
+
+static int 
+xmlRegAtomPush(xmlRegParserCtxtPtr ctxt, xmlRegAtomPtr atom) {
+    if (atom == NULL) {
+	ERROR("atom push: atom is NULL");
+	return(-1);
+    }
+    if (ctxt->maxAtoms == 0) {
+	ctxt->maxAtoms = 4;
+	ctxt->atoms = (xmlRegAtomPtr *) xmlMalloc(ctxt->maxAtoms *
+		                             sizeof(xmlRegAtomPtr));
+	if (ctxt->atoms == NULL) {
+	    xmlRegexpErrMemory(ctxt, "pushing atom");
+	    ctxt->maxAtoms = 0;
+	    return(-1);
+	}
+    } else if (ctxt->nbAtoms >= ctxt->maxAtoms) {
+	xmlRegAtomPtr *tmp;
+	ctxt->maxAtoms *= 2;
+	tmp = (xmlRegAtomPtr *) xmlRealloc(ctxt->atoms, ctxt->maxAtoms *
+		                             sizeof(xmlRegAtomPtr));
+	if (tmp == NULL) {
+	    xmlRegexpErrMemory(ctxt, "allocating counter");
+	    ctxt->maxAtoms /= 2;
+	    return(-1);
+	}
+	ctxt->atoms = tmp;
+    }
+    atom->no = ctxt->nbAtoms;
+    ctxt->atoms[ctxt->nbAtoms++] = atom;
+    return(0);
+}
+
+static void 
+xmlRegStateAddTrans(xmlRegParserCtxtPtr ctxt, xmlRegStatePtr state,
+	            xmlRegAtomPtr atom, xmlRegStatePtr target,
+		    int counter, int count) {
+    if (state == NULL) {
+	ERROR("add state: state is NULL");
+	return;
+    }
+    if (target == NULL) {
+	ERROR("add state: target is NULL");
+	return;
+    }
+    if (state->maxTrans == 0) {
+	state->maxTrans = 4;
+	state->trans = (xmlRegTrans *) xmlMalloc(state->maxTrans *
+		                             sizeof(xmlRegTrans));
+	if (state->trans == NULL) {
+	    xmlRegexpErrMemory(ctxt, "adding transition");
+	    state->maxTrans = 0;
+	    return;
+	}
+    } else if (state->nbTrans >= state->maxTrans) {
+	xmlRegTrans *tmp;
+	state->maxTrans *= 2;
+	tmp = (xmlRegTrans *) xmlRealloc(state->trans, state->maxTrans *
+		                             sizeof(xmlRegTrans));
+	if (tmp == NULL) {
+	    xmlRegexpErrMemory(ctxt, "adding transition");
+	    state->maxTrans /= 2;
+	    return;
+	}
+	state->trans = tmp;
+    }
+#ifdef DEBUG_REGEXP_GRAPH
+    printf("Add trans from %d to %d ", state->no, target->no);
+    if (count == REGEXP_ALL_COUNTER)
+	printf("all transition\n");
+    else if (count >= 0)
+	printf("count based %d\n", count);
+    else if (counter >= 0)
+	printf("counted %d\n", counter);
+    else if (atom == NULL)
+	printf("epsilon transition\n");
+    else if (atom != NULL) 
+        xmlRegPrintAtom(stdout, atom);
+#endif
+
+    state->trans[state->nbTrans].atom = atom;
+    state->trans[state->nbTrans].to = target->no;
+    state->trans[state->nbTrans].counter = counter;
+    state->trans[state->nbTrans].count = count;
+    state->nbTrans++;
+}
+
+static int
+xmlRegStatePush(xmlRegParserCtxtPtr ctxt, xmlRegStatePtr state) {
+    if (state == NULL) return(-1);
+    if (ctxt->maxStates == 0) {
+	ctxt->maxStates = 4;
+	ctxt->states = (xmlRegStatePtr *) xmlMalloc(ctxt->maxStates *
+		                             sizeof(xmlRegStatePtr));
+	if (ctxt->states == NULL) {
+	    xmlRegexpErrMemory(ctxt, "adding state");
+	    ctxt->maxStates = 0;
+	    return(-1);
+	}
+    } else if (ctxt->nbStates >= ctxt->maxStates) {
+	xmlRegStatePtr *tmp;
+	ctxt->maxStates *= 2;
+	tmp = (xmlRegStatePtr *) xmlRealloc(ctxt->states, ctxt->maxStates *
+		                             sizeof(xmlRegStatePtr));
+	if (tmp == NULL) {
+	    xmlRegexpErrMemory(ctxt, "adding state");
+	    ctxt->maxStates /= 2;
+	    return(-1);
+	}
+	ctxt->states = tmp;
+    }
+    state->no = ctxt->nbStates;
+    ctxt->states[ctxt->nbStates++] = state;
+    return(0);
+}
+
+/**
+ * xmlFAGenerateAllTransition:
+ * @ctxt:  a regexp parser context
+ * @from:  the from state
+ * @to:  the target state or NULL for building a new one
+ * @lax:
+ *
+ */
+static void
+xmlFAGenerateAllTransition(xmlRegParserCtxtPtr ctxt,
+			   xmlRegStatePtr from, xmlRegStatePtr to,
+			   int lax) {
+    if (to == NULL) {
+	to = xmlRegNewState(ctxt);
+	xmlRegStatePush(ctxt, to);
+	ctxt->state = to;
+    }
+    if (lax)
+	xmlRegStateAddTrans(ctxt, from, NULL, to, -1, REGEXP_ALL_LAX_COUNTER);
+    else
+	xmlRegStateAddTrans(ctxt, from, NULL, to, -1, REGEXP_ALL_COUNTER);
+}
+
+/**
+ * xmlFAGenerateEpsilonTransition:
+ * @ctxt:  a regexp parser context
+ * @from:  the from state
+ * @to:  the target state or NULL for building a new one
+ *
+ */
+static void
+xmlFAGenerateEpsilonTransition(xmlRegParserCtxtPtr ctxt,
+			       xmlRegStatePtr from, xmlRegStatePtr to) {
+    if (to == NULL) {
+	to = xmlRegNewState(ctxt);
+	xmlRegStatePush(ctxt, to);
+	ctxt->state = to;
+    }
+    xmlRegStateAddTrans(ctxt, from, NULL, to, -1, -1);
+}
+
+/**
+ * xmlFAGenerateCountedEpsilonTransition:
+ * @ctxt:  a regexp parser context
+ * @from:  the from state
+ * @to:  the target state or NULL for building a new one
+ * counter:  the counter for that transition
+ *
+ */
+static void
+xmlFAGenerateCountedEpsilonTransition(xmlRegParserCtxtPtr ctxt,
+	    xmlRegStatePtr from, xmlRegStatePtr to, int counter) {
+    if (to == NULL) {
+	to = xmlRegNewState(ctxt);
+	xmlRegStatePush(ctxt, to);
+	ctxt->state = to;
+    }
+    xmlRegStateAddTrans(ctxt, from, NULL, to, counter, -1);
+}
+
+/**
+ * xmlFAGenerateCountedTransition:
+ * @ctxt:  a regexp parser context
+ * @from:  the from state
+ * @to:  the target state or NULL for building a new one
+ * counter:  the counter for that transition
+ *
+ */
+static void
+xmlFAGenerateCountedTransition(xmlRegParserCtxtPtr ctxt,
+	    xmlRegStatePtr from, xmlRegStatePtr to, int counter) {
+    if (to == NULL) {
+	to = xmlRegNewState(ctxt);
+	xmlRegStatePush(ctxt, to);
+	ctxt->state = to;
+    }
+    xmlRegStateAddTrans(ctxt, from, NULL, to, -1, counter);
+}
+
+/**
+ * xmlFAGenerateTransitions:
+ * @ctxt:  a regexp parser context
+ * @from:  the from state
+ * @to:  the target state or NULL for building a new one
+ * @atom:  the atom generating the transition
+ *
+ * Returns 0 if succes and -1 in case of error.
+ */
+static int
+xmlFAGenerateTransitions(xmlRegParserCtxtPtr ctxt, xmlRegStatePtr from,
+	                 xmlRegStatePtr to, xmlRegAtomPtr atom) {
+    if (atom == NULL) {
+	ERROR("genrate transition: atom == NULL");
+	return(-1);
+    }
+    if (atom->type == XML_REGEXP_SUBREG) {
+	/*
+	 * this is a subexpression handling one should not need to
+	 * create a new node excep for XML_REGEXP_QUANT_RANGE.
+	 */
+	if (xmlRegAtomPush(ctxt, atom) < 0) {
+	    return(-1);
+	}
+	if ((to != NULL) && (atom->stop != to) &&
+	    (atom->quant != XML_REGEXP_QUANT_RANGE)) {
+	    /*
+	     * Generate an epsilon transition to link to the target
+	     */
+	    xmlFAGenerateEpsilonTransition(ctxt, atom->stop, to);
+	}
+	switch (atom->quant) {
+	    case XML_REGEXP_QUANT_OPT:
+		atom->quant = XML_REGEXP_QUANT_ONCE;
+		xmlFAGenerateEpsilonTransition(ctxt, atom->start, atom->stop);
+		break;
+	    case XML_REGEXP_QUANT_MULT:
+		atom->quant = XML_REGEXP_QUANT_ONCE;
+		xmlFAGenerateEpsilonTransition(ctxt, atom->start, atom->stop);
+		xmlFAGenerateEpsilonTransition(ctxt, atom->stop, atom->start);
+		break;
+	    case XML_REGEXP_QUANT_PLUS:
+		atom->quant = XML_REGEXP_QUANT_ONCE;
+		xmlFAGenerateEpsilonTransition(ctxt, atom->stop, atom->start);
+		break;
+	    case XML_REGEXP_QUANT_RANGE: {
+		int counter;
+		xmlRegStatePtr newstate;
+
+		/*
+		 * This one is nasty:
+		 *   1/ register a new counter
+		 *   2/ register an epsilon transition associated to
+		 *      this counter going from atom->stop to atom->start
+		 *   3/ create a new state
+		 *   4/ generate a counted transition from atom->stop to
+		 *      that state
+		 */
+		counter = xmlRegGetCounter(ctxt);
+		ctxt->counters[counter].min = atom->min - 1;
+		ctxt->counters[counter].max = atom->max - 1;
+		atom->min = 0;
+		atom->max = 0;
+		atom->quant = XML_REGEXP_QUANT_ONCE;
+		xmlFAGenerateCountedEpsilonTransition(ctxt, atom->stop,
+			                              atom->start, counter);
+		if (to != NULL) {
+		    newstate = to;
+		} else {
+		    newstate = xmlRegNewState(ctxt);
+		    xmlRegStatePush(ctxt, newstate);
+		    ctxt->state = newstate;
+		}
+		xmlFAGenerateCountedTransition(ctxt, atom->stop,
+			                       newstate, counter);
+	    }
+	    default:
+		break;
+	}
+	return(0);
+    } else {
+	if (to == NULL) {
+	    to = xmlRegNewState(ctxt);
+	    if (to != NULL)
+		xmlRegStatePush(ctxt, to);
+	    else {
+		return(-1);
+	    }
+	}
+	if (xmlRegAtomPush(ctxt, atom) < 0) {
+	    return(-1);
+	}
+	xmlRegStateAddTrans(ctxt, from, atom, to, -1, -1);
+	ctxt->state = to;
+    }
+    switch (atom->quant) {
+	case XML_REGEXP_QUANT_OPT:
+	    atom->quant = XML_REGEXP_QUANT_ONCE;
+	    xmlFAGenerateEpsilonTransition(ctxt, from, to);
+	    break;
+	case XML_REGEXP_QUANT_MULT:
+	    atom->quant = XML_REGEXP_QUANT_ONCE;
+	    xmlFAGenerateEpsilonTransition(ctxt, from, to);
+	    xmlRegStateAddTrans(ctxt, to, atom, to, -1, -1);
+	    break;
+	case XML_REGEXP_QUANT_PLUS:
+	    atom->quant = XML_REGEXP_QUANT_ONCE;
+	    xmlRegStateAddTrans(ctxt, to, atom, to, -1, -1);
+	    break;
+	default:
+	    break;
+    }
+    return(0);
+}
+
+/**
+ * xmlFAReduceEpsilonTransitions:
+ * @ctxt:  a regexp parser context
+ * @fromnr:  the from state
+ * @tonr:  the to state 
+ * @cpunter:  should that transition be associted to a counted
+ *
+ */
+static void
+xmlFAReduceEpsilonTransitions(xmlRegParserCtxtPtr ctxt, int fromnr,
+	                      int tonr, int counter) {
+    int transnr;
+    xmlRegStatePtr from;
+    xmlRegStatePtr to;
+
+#ifdef DEBUG_REGEXP_GRAPH
+    printf("xmlFAReduceEpsilonTransitions(%d, %d)\n", fromnr, tonr);
+#endif
+    from = ctxt->states[fromnr];
+    if (from == NULL)
+	return;
+    to = ctxt->states[tonr];
+    if (to == NULL)
+	return;
+    if ((to->mark == XML_REGEXP_MARK_START) ||
+	(to->mark == XML_REGEXP_MARK_VISITED))
+	return;
+
+    to->mark = XML_REGEXP_MARK_VISITED;
+    if (to->type == XML_REGEXP_FINAL_STATE) {
+#ifdef DEBUG_REGEXP_GRAPH
+	printf("State %d is final, so %d becomes final\n", tonr, fromnr);
+#endif
+	from->type = XML_REGEXP_FINAL_STATE;
+    }
+    for (transnr = 0;transnr < to->nbTrans;transnr++) {
+	if (to->trans[transnr].atom == NULL) {
+	    /*
+	     * Don't remove counted transitions
+	     * Don't loop either
+	     */
+	    if (to->trans[transnr].to != fromnr) {
+		if (to->trans[transnr].count >= 0) {
+		    int newto = to->trans[transnr].to;
+
+		    xmlRegStateAddTrans(ctxt, from, NULL,
+					ctxt->states[newto], 
+					-1, to->trans[transnr].count);
+		} else {
+#ifdef DEBUG_REGEXP_GRAPH
+		    printf("Found epsilon trans %d from %d to %d\n",
+			   transnr, tonr, to->trans[transnr].to);
+#endif
+		    if (to->trans[transnr].counter >= 0) {
+			xmlFAReduceEpsilonTransitions(ctxt, fromnr,
+					      to->trans[transnr].to,
+					      to->trans[transnr].counter);
+		    } else {
+			xmlFAReduceEpsilonTransitions(ctxt, fromnr,
+					      to->trans[transnr].to,
+					      counter);
+		    }
+		}
+	    }
+	} else {
+	    int newto = to->trans[transnr].to;
+
+	    if (to->trans[transnr].counter >= 0) {
+		xmlRegStateAddTrans(ctxt, from, to->trans[transnr].atom, 
+				    ctxt->states[newto], 
+				    to->trans[transnr].counter, -1);
+	    } else {
+		xmlRegStateAddTrans(ctxt, from, to->trans[transnr].atom, 
+				    ctxt->states[newto], counter, -1);
+	    }
+	}
+    }
+    to->mark = XML_REGEXP_MARK_NORMAL;
+}
+
+/**
+ * xmlFAEliminateEpsilonTransitions:
+ * @ctxt:  a regexp parser context
+ *
+ */
+static void
+xmlFAEliminateEpsilonTransitions(xmlRegParserCtxtPtr ctxt) {
+    int statenr, transnr;
+    xmlRegStatePtr state;
+
+    if (ctxt->states == NULL) return;
+
+
+    /*
+     * build the completed transitions bypassing the epsilons
+     * Use a marking algorithm to avoid loops
+     */
+    for (statenr = 0;statenr < ctxt->nbStates;statenr++) {
+	state = ctxt->states[statenr];
+	if (state == NULL)
+	    continue;
+	for (transnr = 0;transnr < state->nbTrans;transnr++) {
+	    if ((state->trans[transnr].atom == NULL) &&
+		(state->trans[transnr].to >= 0)) {
+		if (state->trans[transnr].to == statenr) {
+		    state->trans[transnr].to = -1;
+#ifdef DEBUG_REGEXP_GRAPH
+		    printf("Removed loopback epsilon trans %d on %d\n",
+			   transnr, statenr);
+#endif
+		} else if (state->trans[transnr].count < 0) {
+		    int newto = state->trans[transnr].to;
+
+#ifdef DEBUG_REGEXP_GRAPH
+		    printf("Found epsilon trans %d from %d to %d\n",
+			   transnr, statenr, newto);
+#endif
+		    state->mark = XML_REGEXP_MARK_START;
+		    xmlFAReduceEpsilonTransitions(ctxt, statenr,
+				      newto, state->trans[transnr].counter);
+		    state->mark = XML_REGEXP_MARK_NORMAL;
+#ifdef DEBUG_REGEXP_GRAPH
+		} else {
+		    printf("Found counted transition %d on %d\n",
+			   transnr, statenr);
+#endif
+	        }
+	    }
+	}
+    }
+    /*
+     * Eliminate the epsilon transitions
+     */
+    for (statenr = 0;statenr < ctxt->nbStates;statenr++) {
+	state = ctxt->states[statenr];
+	if (state == NULL)
+	    continue;
+	for (transnr = 0;transnr < state->nbTrans;transnr++) {
+	    if ((state->trans[transnr].atom == NULL) &&
+		(state->trans[transnr].count < 0) &&
+		(state->trans[transnr].to >= 0)) {
+		state->trans[transnr].to = -1;
+	    }
+	}
+    }
+
+    /*
+     * Use this pass to detect unreachable states too
+     */
+    for (statenr = 0;statenr < ctxt->nbStates;statenr++) {
+	state = ctxt->states[statenr];
+	if (state != NULL)
+	    state->reached = XML_REGEXP_MARK_NORMAL;
+    }
+    state = ctxt->states[0];
+    if (state != NULL)
+	state->reached = XML_REGEXP_MARK_START;
+    while (state != NULL) {
+	xmlRegStatePtr target = NULL;
+	state->reached = XML_REGEXP_MARK_VISITED;
+	/*
+	 * Mark all state reachable from the current reachable state
+	 */
+	for (transnr = 0;transnr < state->nbTrans;transnr++) {
+	    if ((state->trans[transnr].to >= 0) &&
+		((state->trans[transnr].atom != NULL) ||
+		 (state->trans[transnr].count >= 0))) {
+		int newto = state->trans[transnr].to;
+
+		if (ctxt->states[newto] == NULL)
+		    continue;
+		if (ctxt->states[newto]->reached == XML_REGEXP_MARK_NORMAL) {
+		    ctxt->states[newto]->reached = XML_REGEXP_MARK_START;
+		    target = ctxt->states[newto];
+		}
+	    }
+	}
+	/*
+	 * find the next accessible state not explored
+	 */
+	if (target == NULL) {
+	    for (statenr = 1;statenr < ctxt->nbStates;statenr++) {
+		state = ctxt->states[statenr];
+		if ((state != NULL) && (state->reached ==
+			XML_REGEXP_MARK_START)) {
+		    target = state;
+		    break;
+		}
+	    }
+	}
+	state = target;
+    }
+    for (statenr = 0;statenr < ctxt->nbStates;statenr++) {
+	state = ctxt->states[statenr];
+	if ((state != NULL) && (state->reached == XML_REGEXP_MARK_NORMAL)) {
+#ifdef DEBUG_REGEXP_GRAPH
+	    printf("Removed unreachable state %d\n", statenr);
+#endif
+	    xmlRegFreeState(state);
+	    ctxt->states[statenr] = NULL;
+	}
+    }
+
+}
+
+/**
+ * xmlFACompareAtoms:
+ * @atom1:  an atom
+ * @atom2:  an atom
+ *
+ * Compares two atoms to check whether they are equivatents
+ *
+ * Returns 1 if yes and 0 otherwise
+ */
+static int
+xmlFACompareAtoms(xmlRegAtomPtr atom1, xmlRegAtomPtr atom2) {
+    if (atom1 == atom2)
+	return(1);
+    if ((atom1 == NULL) || (atom2 == NULL))
+	return(0);
+
+    if (atom1->type != atom2->type)
+	return(0);
+    switch (atom1->type) {
+        case XML_REGEXP_STRING:
+	    return(xmlStrEqual((xmlChar *)atom1->valuep,
+			       (xmlChar *)atom2->valuep));
+        case XML_REGEXP_EPSILON:
+	    return(1);
+        case XML_REGEXP_CHARVAL:
+	    return(atom1->codepoint == atom2->codepoint);
+        case XML_REGEXP_RANGES:
+	    TODO;
+	    return(0);
+	default:
+	    break;
+    }
+    return(1);
+}
+
+/**
+ * xmlFARecurseDeterminism:
+ * @ctxt:  a regexp parser context
+ *
+ * Check whether the associated regexp is determinist,
+ * should be called after xmlFAEliminateEpsilonTransitions()
+ *
+ */
+static int
+xmlFARecurseDeterminism(xmlRegParserCtxtPtr ctxt, xmlRegStatePtr state,
+	                 int to, xmlRegAtomPtr atom) {
+    int ret = 1;
+    int transnr;
+    xmlRegTransPtr t1;
+
+    if (state == NULL)
+	return(ret);
+    for (transnr = 0;transnr < state->nbTrans;transnr++) {
+	t1 = &(state->trans[transnr]);
+	/*
+	 * check transitions conflicting with the one looked at
+	 */
+	if (t1->atom == NULL) {
+	    if (t1->to == -1)
+		continue;
+	    ret = xmlFARecurseDeterminism(ctxt, ctxt->states[t1->to],
+		                           to, atom);
+	    if (ret == 0)
+		return(0);
+	    continue;
+	}
+	if (t1->to != to)
+	    continue;
+	if (xmlFACompareAtoms(t1->atom, atom))
+	    return(0);
+    }
+    return(ret);
+}
+
+/**
+ * xmlFAComputesDeterminism:
+ * @ctxt:  a regexp parser context
+ *
+ * Check whether the associated regexp is determinist,
+ * should be called after xmlFAEliminateEpsilonTransitions()
+ *
+ */
+static int
+xmlFAComputesDeterminism(xmlRegParserCtxtPtr ctxt) {
+    int statenr, transnr;
+    xmlRegStatePtr state;
+    xmlRegTransPtr t1, t2;
+    int i;
+    int ret = 1;
+
+#ifdef DEBUG_REGEXP_GRAPH
+    printf("xmlFAComputesDeterminism\n");
+    xmlRegPrintCtxt(stdout, ctxt);
+#endif
+    if (ctxt->determinist != -1)
+	return(ctxt->determinist);
+
+    /*
+     * Check for all states that there isn't 2 transitions
+     * with the same atom and a different target.
+     */
+    for (statenr = 0;statenr < ctxt->nbStates;statenr++) {
+	state = ctxt->states[statenr];
+	if (state == NULL)
+	    continue;
+	for (transnr = 0;transnr < state->nbTrans;transnr++) {
+	    t1 = &(state->trans[transnr]);
+	    /*
+	     * Determinism checks in case of counted or all transitions
+	     * will have to be handled separately
+	     */
+	    if (t1->atom == NULL)
+		continue;
+	    if (t1->to == -1) /* eliminated */
+		continue;
+	    for (i = 0;i < transnr;i++) {
+		t2 = &(state->trans[i]);
+		if (t2->to == -1) /* eliminated */
+		    continue;
+		if (t2->atom != NULL) {
+		    if (t1->to == t2->to) {
+			if (xmlFACompareAtoms(t1->atom, t2->atom))
+			    t2->to = -1; /* eliminate */
+		    } else {
+			/* not determinist ! */
+			if (xmlFACompareAtoms(t1->atom, t2->atom))
+			    ret = 0;
+		    }
+		} else if (t1->to != -1) {
+		    /*
+		     * do the closure in case of remaining specific
+		     * epsilon transitions like choices or all
+		     */
+		    ret = xmlFARecurseDeterminism(ctxt, ctxt->states[t1->to],
+						   t2->to, t2->atom);
+		    if (ret == 0)
+			return(0);
+		}
+	    }
+	    if (ret == 0)
+		break;
+	}
+	if (ret == 0)
+	    break;
+    }
+    ctxt->determinist = ret;
+    return(ret);
+}
+
+/************************************************************************
+ * 									*
+ *	Routines to check input against transition atoms		*
+ * 									*
+ ************************************************************************/
+
+static int
+xmlRegCheckCharacterRange(xmlRegAtomType type, int codepoint, int neg,
+	                  int start, int end, const xmlChar *blockName) {
+    int ret = 0;
+
+    switch (type) {
+        case XML_REGEXP_STRING:
+        case XML_REGEXP_SUBREG:
+        case XML_REGEXP_RANGES:
+        case XML_REGEXP_EPSILON:
+	    return(-1);
+        case XML_REGEXP_ANYCHAR:
+	    ret = ((codepoint != '\n') && (codepoint != '\r'));
+	    break;
+        case XML_REGEXP_CHARVAL:
+	    ret = ((codepoint >= start) && (codepoint <= end));
+	    break;
+        case XML_REGEXP_NOTSPACE:
+	    neg = !neg;
+        case XML_REGEXP_ANYSPACE:
+	    ret = ((codepoint == '\n') || (codepoint == '\r') ||
+		   (codepoint == '\t') || (codepoint == ' '));
+	    break;
+        case XML_REGEXP_NOTINITNAME:
+	    neg = !neg;
+        case XML_REGEXP_INITNAME:
+	    ret = (IS_LETTER(codepoint) || 
+		   (codepoint == '_') || (codepoint == ':'));
+	    break;
+        case XML_REGEXP_NOTNAMECHAR:
+	    neg = !neg;
+        case XML_REGEXP_NAMECHAR:
+	    ret = (IS_LETTER(codepoint) || IS_DIGIT(codepoint) ||
+		   (codepoint == '.') || (codepoint == '-') ||
+		   (codepoint == '_') || (codepoint == ':') ||
+		   IS_COMBINING(codepoint) || IS_EXTENDER(codepoint));
+	    break;
+        case XML_REGEXP_NOTDECIMAL:
+	    neg = !neg;
+        case XML_REGEXP_DECIMAL:
+	    ret = xmlUCSIsCatNd(codepoint);
+	    break;
+        case XML_REGEXP_REALCHAR:
+	    neg = !neg;
+        case XML_REGEXP_NOTREALCHAR:
+	    ret = xmlUCSIsCatP(codepoint);
+	    if (ret == 0)
+		ret = xmlUCSIsCatZ(codepoint);
+	    if (ret == 0)
+		ret = xmlUCSIsCatC(codepoint);
+	    break;
+        case XML_REGEXP_LETTER:
+	    ret = xmlUCSIsCatL(codepoint);
+	    break;
+        case XML_REGEXP_LETTER_UPPERCASE:
+	    ret = xmlUCSIsCatLu(codepoint);
+	    break;
+        case XML_REGEXP_LETTER_LOWERCASE:
+	    ret = xmlUCSIsCatLl(codepoint);
+	    break;
+        case XML_REGEXP_LETTER_TITLECASE:
+	    ret = xmlUCSIsCatLt(codepoint);
+	    break;
+        case XML_REGEXP_LETTER_MODIFIER:
+	    ret = xmlUCSIsCatLm(codepoint);
+	    break;
+        case XML_REGEXP_LETTER_OTHERS:
+	    ret = xmlUCSIsCatLo(codepoint);
+	    break;
+        case XML_REGEXP_MARK:
+	    ret = xmlUCSIsCatM(codepoint);
+	    break;
+        case XML_REGEXP_MARK_NONSPACING:
+	    ret = xmlUCSIsCatMn(codepoint);
+	    break;
+        case XML_REGEXP_MARK_SPACECOMBINING:
+	    ret = xmlUCSIsCatMc(codepoint);
+	    break;
+        case XML_REGEXP_MARK_ENCLOSING:
+	    ret = xmlUCSIsCatMe(codepoint);
+	    break;
+        case XML_REGEXP_NUMBER:
+	    ret = xmlUCSIsCatN(codepoint);
+	    break;
+        case XML_REGEXP_NUMBER_DECIMAL:
+	    ret = xmlUCSIsCatNd(codepoint);
+	    break;
+        case XML_REGEXP_NUMBER_LETTER:
+	    ret = xmlUCSIsCatNl(codepoint);
+	    break;
+        case XML_REGEXP_NUMBER_OTHERS:
+	    ret = xmlUCSIsCatNo(codepoint);
+	    break;
+        case XML_REGEXP_PUNCT:
+	    ret = xmlUCSIsCatP(codepoint);
+	    break;
+        case XML_REGEXP_PUNCT_CONNECTOR:
+	    ret = xmlUCSIsCatPc(codepoint);
+	    break;
+        case XML_REGEXP_PUNCT_DASH:
+	    ret = xmlUCSIsCatPd(codepoint);
+	    break;
+        case XML_REGEXP_PUNCT_OPEN:
+	    ret = xmlUCSIsCatPs(codepoint);
+	    break;
+        case XML_REGEXP_PUNCT_CLOSE:
+	    ret = xmlUCSIsCatPe(codepoint);
+	    break;
+        case XML_REGEXP_PUNCT_INITQUOTE:
+	    ret = xmlUCSIsCatPi(codepoint);
+	    break;
+        case XML_REGEXP_PUNCT_FINQUOTE:
+	    ret = xmlUCSIsCatPf(codepoint);
+	    break;
+        case XML_REGEXP_PUNCT_OTHERS:
+	    ret = xmlUCSIsCatPo(codepoint);
+	    break;
+        case XML_REGEXP_SEPAR:
+	    ret = xmlUCSIsCatZ(codepoint);
+	    break;
+        case XML_REGEXP_SEPAR_SPACE:
+	    ret = xmlUCSIsCatZs(codepoint);
+	    break;
+        case XML_REGEXP_SEPAR_LINE:
+	    ret = xmlUCSIsCatZl(codepoint);
+	    break;
+        case XML_REGEXP_SEPAR_PARA:
+	    ret = xmlUCSIsCatZp(codepoint);
+	    break;
+        case XML_REGEXP_SYMBOL:
+	    ret = xmlUCSIsCatS(codepoint);
+	    break;
+        case XML_REGEXP_SYMBOL_MATH:
+	    ret = xmlUCSIsCatSm(codepoint);
+	    break;
+        case XML_REGEXP_SYMBOL_CURRENCY:
+	    ret = xmlUCSIsCatSc(codepoint);
+	    break;
+        case XML_REGEXP_SYMBOL_MODIFIER:
+	    ret = xmlUCSIsCatSk(codepoint);
+	    break;
+        case XML_REGEXP_SYMBOL_OTHERS:
+	    ret = xmlUCSIsCatSo(codepoint);
+	    break;
+        case XML_REGEXP_OTHER:
+	    ret = xmlUCSIsCatC(codepoint);
+	    break;
+        case XML_REGEXP_OTHER_CONTROL:
+	    ret = xmlUCSIsCatCc(codepoint);
+	    break;
+        case XML_REGEXP_OTHER_FORMAT:
+	    ret = xmlUCSIsCatCf(codepoint);
+	    break;
+        case XML_REGEXP_OTHER_PRIVATE:
+	    ret = xmlUCSIsCatCo(codepoint);
+	    break;
+        case XML_REGEXP_OTHER_NA:
+	    /* ret = xmlUCSIsCatCn(codepoint); */
+	    /* Seems it doesn't exist anymore in recent Unicode releases */
+	    ret = 0;
+	    break;
+        case XML_REGEXP_BLOCK_NAME:
+	    ret = xmlUCSIsBlock(codepoint, (const char *) blockName);
+	    break;
+    }
+    if (neg)
+	return(!ret);
+    return(ret);
+}
+
+static int
+xmlRegCheckCharacter(xmlRegAtomPtr atom, int codepoint) {
+    int i, ret = 0;
+    xmlRegRangePtr range;
+
+    if ((atom == NULL) || (!IS_CHAR(codepoint)))
+	return(-1);
+
+    switch (atom->type) {
+        case XML_REGEXP_SUBREG:
+        case XML_REGEXP_EPSILON:
+	    return(-1);
+        case XML_REGEXP_CHARVAL:
+            return(codepoint == atom->codepoint);
+        case XML_REGEXP_RANGES: {
+	    int accept = 0;
+
+	    for (i = 0;i < atom->nbRanges;i++) {
+		range = atom->ranges[i];
+		if (range->neg == 2) {
+		    ret = xmlRegCheckCharacterRange(range->type, codepoint,
+						0, range->start, range->end,
+						range->blockName);
+		    if (ret != 0)
+			return(0); /* excluded char */
+		} else if (range->neg) {
+		    ret = xmlRegCheckCharacterRange(range->type, codepoint,
+						0, range->start, range->end,
+						range->blockName);
+		    if (ret == 0)
+		        accept = 1;
+		    else
+		        return(0);
+		} else {
+		    ret = xmlRegCheckCharacterRange(range->type, codepoint,
+						0, range->start, range->end,
+						range->blockName);
+		    if (ret != 0)
+			accept = 1; /* might still be excluded */
+		}
+	    }
+	    return(accept);
+	}
+        case XML_REGEXP_STRING:
+	    printf("TODO: XML_REGEXP_STRING\n");
+	    return(-1);
+        case XML_REGEXP_ANYCHAR:
+        case XML_REGEXP_ANYSPACE:
+        case XML_REGEXP_NOTSPACE:
+        case XML_REGEXP_INITNAME:
+        case XML_REGEXP_NOTINITNAME:
+        case XML_REGEXP_NAMECHAR:
+        case XML_REGEXP_NOTNAMECHAR:
+        case XML_REGEXP_DECIMAL:
+        case XML_REGEXP_NOTDECIMAL:
+        case XML_REGEXP_REALCHAR:
+        case XML_REGEXP_NOTREALCHAR:
+        case XML_REGEXP_LETTER:
+        case XML_REGEXP_LETTER_UPPERCASE:
+        case XML_REGEXP_LETTER_LOWERCASE:
+        case XML_REGEXP_LETTER_TITLECASE:
+        case XML_REGEXP_LETTER_MODIFIER:
+        case XML_REGEXP_LETTER_OTHERS:
+        case XML_REGEXP_MARK:
+        case XML_REGEXP_MARK_NONSPACING:
+        case XML_REGEXP_MARK_SPACECOMBINING:
+        case XML_REGEXP_MARK_ENCLOSING:
+        case XML_REGEXP_NUMBER:
+        case XML_REGEXP_NUMBER_DECIMAL:
+        case XML_REGEXP_NUMBER_LETTER:
+        case XML_REGEXP_NUMBER_OTHERS:
+        case XML_REGEXP_PUNCT:
+        case XML_REGEXP_PUNCT_CONNECTOR:
+        case XML_REGEXP_PUNCT_DASH:
+        case XML_REGEXP_PUNCT_OPEN:
+        case XML_REGEXP_PUNCT_CLOSE:
+        case XML_REGEXP_PUNCT_INITQUOTE:
+        case XML_REGEXP_PUNCT_FINQUOTE:
+        case XML_REGEXP_PUNCT_OTHERS:
+        case XML_REGEXP_SEPAR:
+        case XML_REGEXP_SEPAR_SPACE:
+        case XML_REGEXP_SEPAR_LINE:
+        case XML_REGEXP_SEPAR_PARA:
+        case XML_REGEXP_SYMBOL:
+        case XML_REGEXP_SYMBOL_MATH:
+        case XML_REGEXP_SYMBOL_CURRENCY:
+        case XML_REGEXP_SYMBOL_MODIFIER:
+        case XML_REGEXP_SYMBOL_OTHERS:
+        case XML_REGEXP_OTHER:
+        case XML_REGEXP_OTHER_CONTROL:
+        case XML_REGEXP_OTHER_FORMAT:
+        case XML_REGEXP_OTHER_PRIVATE:
+        case XML_REGEXP_OTHER_NA:
+	case XML_REGEXP_BLOCK_NAME:
+	    ret = xmlRegCheckCharacterRange(atom->type, codepoint, 0, 0, 0,
+		                            (const xmlChar *)atom->valuep);
+	    if (atom->neg)
+		ret = !ret;
+	    break;
+    }
+    return(ret);
+}
+
+/************************************************************************
+ * 									*
+ *	Saving an restoring state of an execution context		*
+ * 									*
+ ************************************************************************/
+
+#ifdef DEBUG_REGEXP_EXEC
+static void
+xmlFARegDebugExec(xmlRegExecCtxtPtr exec) {
+    printf("state: %d:%d:idx %d", exec->state->no, exec->transno, exec->index);
+    if (exec->inputStack != NULL) {
+	int i;
+	printf(": ");
+	for (i = 0;(i < 3) && (i < exec->inputStackNr);i++)
+	    printf("%s ", exec->inputStack[exec->inputStackNr - (i + 1)]);
+    } else {
+	printf(": %s", &(exec->inputString[exec->index]));
+    }
+    printf("\n");
+}
+#endif
+
+static void
+xmlFARegExecSave(xmlRegExecCtxtPtr exec) {
+#ifdef DEBUG_REGEXP_EXEC
+    printf("saving ");
+    exec->transno++;
+    xmlFARegDebugExec(exec);
+    exec->transno--;
+#endif
+
+    if (exec->maxRollbacks == 0) {
+	exec->maxRollbacks = 4;
+	exec->rollbacks = (xmlRegExecRollback *) xmlMalloc(exec->maxRollbacks *
+		                             sizeof(xmlRegExecRollback));
+	if (exec->rollbacks == NULL) {
+	    xmlRegexpErrMemory(NULL, "saving regexp");
+	    exec->maxRollbacks = 0;
+	    return;
+	}
+	memset(exec->rollbacks, 0,
+	       exec->maxRollbacks * sizeof(xmlRegExecRollback));
+    } else if (exec->nbRollbacks >= exec->maxRollbacks) {
+	xmlRegExecRollback *tmp;
+	int len = exec->maxRollbacks;
+
+	exec->maxRollbacks *= 2;
+	tmp = (xmlRegExecRollback *) xmlRealloc(exec->rollbacks,
+			exec->maxRollbacks * sizeof(xmlRegExecRollback));
+	if (tmp == NULL) {
+	    xmlRegexpErrMemory(NULL, "saving regexp");
+	    exec->maxRollbacks /= 2;
+	    return;
+	}
+	exec->rollbacks = tmp;
+	tmp = &exec->rollbacks[len];
+	memset(tmp, 0, (exec->maxRollbacks - len) * sizeof(xmlRegExecRollback));
+    }
+    exec->rollbacks[exec->nbRollbacks].state = exec->state;
+    exec->rollbacks[exec->nbRollbacks].index = exec->index;
+    exec->rollbacks[exec->nbRollbacks].nextbranch = exec->transno + 1;
+    if (exec->comp->nbCounters > 0) {
+	if (exec->rollbacks[exec->nbRollbacks].counts == NULL) {
+	    exec->rollbacks[exec->nbRollbacks].counts = (int *)
+		xmlMalloc(exec->comp->nbCounters * sizeof(int));
+	    if (exec->rollbacks[exec->nbRollbacks].counts == NULL) {
+		xmlRegexpErrMemory(NULL, "saving regexp");
+		exec->status = -5;
+		return;
+	    }
+	}
+	memcpy(exec->rollbacks[exec->nbRollbacks].counts, exec->counts,
+	       exec->comp->nbCounters * sizeof(int));
+    }
+    exec->nbRollbacks++;
+}
+
+static void
+xmlFARegExecRollBack(xmlRegExecCtxtPtr exec) {
+    if (exec->nbRollbacks <= 0) {
+	exec->status = -1;
+#ifdef DEBUG_REGEXP_EXEC
+	printf("rollback failed on empty stack\n");
+#endif
+	return;
+    }
+    exec->nbRollbacks--;
+    exec->state = exec->rollbacks[exec->nbRollbacks].state;
+    exec->index = exec->rollbacks[exec->nbRollbacks].index;
+    exec->transno = exec->rollbacks[exec->nbRollbacks].nextbranch;
+    if (exec->comp->nbCounters > 0) {
+	if (exec->rollbacks[exec->nbRollbacks].counts == NULL) {
+	    fprintf(stderr, "exec save: allocation failed");
+	    exec->status = -6;
+	    return;
+	}
+	memcpy(exec->counts, exec->rollbacks[exec->nbRollbacks].counts,
+	       exec->comp->nbCounters * sizeof(int));
+    }
+
+#ifdef DEBUG_REGEXP_EXEC
+    printf("restored ");
+    xmlFARegDebugExec(exec);
+#endif
+}
+
+/************************************************************************
+ * 									*
+ *	Verifyer, running an input against a compiled regexp		*
+ * 									*
+ ************************************************************************/
+
+static int
+xmlFARegExec(xmlRegexpPtr comp, const xmlChar *content) {
+    xmlRegExecCtxt execval;
+    xmlRegExecCtxtPtr exec = &execval;
+    int ret, codepoint, len;
+
+    exec->inputString = content;
+    exec->index = 0;
+    exec->determinist = 1;
+    exec->maxRollbacks = 0;
+    exec->nbRollbacks = 0;
+    exec->rollbacks = NULL;
+    exec->status = 0;
+    exec->comp = comp;
+    exec->state = comp->states[0];
+    exec->transno = 0;
+    exec->transcount = 0;
+    exec->inputStack = NULL;
+    exec->inputStackMax = 0;
+    if (comp->nbCounters > 0) {
+	exec->counts = (int *) xmlMalloc(comp->nbCounters * sizeof(int));
+	if (exec->counts == NULL) {
+	    xmlRegexpErrMemory(NULL, "running regexp");
+	    return(-1);
+	}
+        memset(exec->counts, 0, comp->nbCounters * sizeof(int));
+    } else
+	exec->counts = NULL;
+    while ((exec->status == 0) &&
+	   ((exec->inputString[exec->index] != 0) ||
+	    (exec->state->type != XML_REGEXP_FINAL_STATE))) {
+	xmlRegTransPtr trans;
+	xmlRegAtomPtr atom;
+
+	/*
+	 * End of input on non-terminal state, rollback, however we may
+	 * still have epsilon like transition for counted transitions
+	 * on counters, in that case don't break too early.
+	 */
+	if ((exec->inputString[exec->index] == 0) && (exec->counts == NULL))
+	    goto rollback;
+
+	exec->transcount = 0;
+	for (;exec->transno < exec->state->nbTrans;exec->transno++) {
+	    trans = &exec->state->trans[exec->transno];
+	    if (trans->to < 0)
+		continue;
+	    atom = trans->atom;
+	    ret = 0;
+	    if (trans->count >= 0) {
+		int count;
+		xmlRegCounterPtr counter;
+
+		/*
+		 * A counted transition.
+		 */
+
+		count = exec->counts[trans->count];
+		counter = &exec->comp->counters[trans->count];
+#ifdef DEBUG_REGEXP_EXEC
+		printf("testing count %d: val %d, min %d, max %d\n",
+		       trans->count, count, counter->min,  counter->max);
+#endif
+		ret = ((count >= counter->min) && (count <= counter->max));
+	    } else if (atom == NULL) {
+		fprintf(stderr, "epsilon transition left at runtime\n");
+		exec->status = -2;
+		break;
+	    } else if (exec->inputString[exec->index] != 0) {
+                codepoint = CUR_SCHAR(&(exec->inputString[exec->index]), len);
+		ret = xmlRegCheckCharacter(atom, codepoint);
+		if ((ret == 1) && (atom->min > 0) && (atom->max > 0)) {
+		    xmlRegStatePtr to = comp->states[trans->to];
+
+		    /*
+		     * this is a multiple input sequence
+		     */
+		    if (exec->state->nbTrans > exec->transno + 1) {
+			xmlFARegExecSave(exec);
+		    }
+		    exec->transcount = 1;
+		    do {
+			/*
+			 * Try to progress as much as possible on the input
+			 */
+			if (exec->transcount == atom->max) {
+			    break;
+			}
+			exec->index += len;
+			/*
+			 * End of input: stop here
+			 */
+			if (exec->inputString[exec->index] == 0) {
+			    exec->index -= len;
+			    break;
+			}
+			if (exec->transcount >= atom->min) {
+			    int transno = exec->transno;
+			    xmlRegStatePtr state = exec->state;
+
+			    /*
+			     * The transition is acceptable save it
+			     */
+			    exec->transno = -1; /* trick */
+			    exec->state = to;
+			    xmlFARegExecSave(exec);
+			    exec->transno = transno;
+			    exec->state = state;
+			}
+			codepoint = CUR_SCHAR(&(exec->inputString[exec->index]),
+				              len);
+			ret = xmlRegCheckCharacter(atom, codepoint);
+			exec->transcount++;
+		    } while (ret == 1);
+		    if (exec->transcount < atom->min)
+			ret = 0;
+
+		    /*
+		     * If the last check failed but one transition was found
+		     * possible, rollback
+		     */
+		    if (ret < 0)
+			ret = 0;
+		    if (ret == 0) {
+			goto rollback;
+		    }
+		}
+	    }
+	    if (ret == 1) {
+		if (exec->state->nbTrans > exec->transno + 1) {
+		    xmlFARegExecSave(exec);
+		}
+		if (trans->counter >= 0) {
+#ifdef DEBUG_REGEXP_EXEC
+		    printf("Increasing count %d\n", trans->counter);
+#endif
+		    exec->counts[trans->counter]++;
+		}
+#ifdef DEBUG_REGEXP_EXEC
+		printf("entering state %d\n", trans->to);
+#endif
+		exec->state = comp->states[trans->to];
+		exec->transno = 0;
+		if (trans->atom != NULL) {
+		    exec->index += len;
+		}
+		goto progress;
+	    } else if (ret < 0) {
+		exec->status = -4;
+		break;
+	    }
+	}
+	if ((exec->transno != 0) || (exec->state->nbTrans == 0)) {
+rollback:
+	    /*
+	     * Failed to find a way out
+	     */
+	    exec->determinist = 0;
+	    xmlFARegExecRollBack(exec);
+	}
+progress:
+	continue;
+    }
+    if (exec->rollbacks != NULL) {
+	if (exec->counts != NULL) {
+	    int i;
+
+	    for (i = 0;i < exec->maxRollbacks;i++)
+		if (exec->rollbacks[i].counts != NULL)
+		    xmlFree(exec->rollbacks[i].counts);
+	}
+	xmlFree(exec->rollbacks);
+    }
+    if (exec->counts != NULL)
+	xmlFree(exec->counts);
+    if (exec->status == 0)
+	return(1);
+    if (exec->status == -1)
+	return(0);
+    return(exec->status);
+}
+
+/************************************************************************
+ * 									*
+ *	Progressive interface to the verifyer one atom at a time	*
+ * 									*
+ ************************************************************************/
+
+/**
+ * xmlRegNewExecCtxt:
+ * @comp: a precompiled regular expression
+ * @callback: a callback function used for handling progresses in the
+ *            automata matching phase
+ * @data: the context data associated to the callback in this context
+ *
+ * Build a context used for progressive evaluation of a regexp.
+ *
+ * Returns the new context
+ */
+xmlRegExecCtxtPtr
+xmlRegNewExecCtxt(xmlRegexpPtr comp, xmlRegExecCallbacks callback, void *data) {
+    xmlRegExecCtxtPtr exec;
+
+    if (comp == NULL)
+	return(NULL);
+    if ((comp->compact == NULL) && (comp->states == NULL))
+        return(NULL);
+    exec = (xmlRegExecCtxtPtr) xmlMalloc(sizeof(xmlRegExecCtxt));
+    if (exec == NULL) {
+	xmlRegexpErrMemory(NULL, "creating execution context");
+	return(NULL);
+    }
+    memset(exec, 0, sizeof(xmlRegExecCtxt));
+    exec->inputString = NULL;
+    exec->index = 0;
+    exec->determinist = 1;
+    exec->maxRollbacks = 0;
+    exec->nbRollbacks = 0;
+    exec->rollbacks = NULL;
+    exec->status = 0;
+    exec->comp = comp;
+    if (comp->compact == NULL)
+	exec->state = comp->states[0];
+    exec->transno = 0;
+    exec->transcount = 0;
+    exec->callback = callback;
+    exec->data = data;
+    if (comp->nbCounters > 0) {
+	exec->counts = (int *) xmlMalloc(comp->nbCounters * sizeof(int));
+	if (exec->counts == NULL) {
+	    xmlRegexpErrMemory(NULL, "creating execution context");
+	    xmlFree(exec);
+	    return(NULL);
+	}
+        memset(exec->counts, 0, comp->nbCounters * sizeof(int));
+    } else
+	exec->counts = NULL;
+    exec->inputStackMax = 0;
+    exec->inputStackNr = 0;
+    exec->inputStack = NULL;
+    return(exec);
+}
+
+/**
+ * xmlRegFreeExecCtxt:
+ * @exec: a regular expression evaulation context
+ *
+ * Free the structures associated to a regular expression evaulation context.
+ */
+void
+xmlRegFreeExecCtxt(xmlRegExecCtxtPtr exec) {
+    if (exec == NULL)
+	return;
+
+    if (exec->rollbacks != NULL) {
+	if (exec->counts != NULL) {
+	    int i;
+
+	    for (i = 0;i < exec->maxRollbacks;i++)
+		if (exec->rollbacks[i].counts != NULL)
+		    xmlFree(exec->rollbacks[i].counts);
+	}
+	xmlFree(exec->rollbacks);
+    }
+    if (exec->counts != NULL)
+	xmlFree(exec->counts);
+    if (exec->inputStack != NULL) {
+	int i;
+
+	for (i = 0;i < exec->inputStackNr;i++) {
+	    if (exec->inputStack[i].value != NULL)
+		xmlFree(exec->inputStack[i].value);
+	}
+	xmlFree(exec->inputStack);
+    }
+    xmlFree(exec);
+}
+
+static void
+xmlFARegExecSaveInputString(xmlRegExecCtxtPtr exec, const xmlChar *value,
+	                    void *data) {
+#ifdef DEBUG_PUSH
+    printf("saving value: %d:%s\n", exec->inputStackNr, value);
+#endif
+    if (exec->inputStackMax == 0) {
+	exec->inputStackMax = 4;
+	exec->inputStack = (xmlRegInputTokenPtr) 
+	    xmlMalloc(exec->inputStackMax * sizeof(xmlRegInputToken));
+	if (exec->inputStack == NULL) {
+	    xmlRegexpErrMemory(NULL, "pushing input string");
+	    exec->inputStackMax = 0;
+	    return;
+	}
+    } else if (exec->inputStackNr + 1 >= exec->inputStackMax) {
+	xmlRegInputTokenPtr tmp;
+
+	exec->inputStackMax *= 2;
+	tmp = (xmlRegInputTokenPtr) xmlRealloc(exec->inputStack,
+			exec->inputStackMax * sizeof(xmlRegInputToken));
+	if (tmp == NULL) {
+	    xmlRegexpErrMemory(NULL, "pushing input string");
+	    exec->inputStackMax /= 2;
+	    return;
+	}
+	exec->inputStack = tmp;
+    }
+    exec->inputStack[exec->inputStackNr].value = xmlStrdup(value);
+    exec->inputStack[exec->inputStackNr].data = data;
+    exec->inputStackNr++;
+    exec->inputStack[exec->inputStackNr].value = NULL;
+    exec->inputStack[exec->inputStackNr].data = NULL;
+}
+
+
+/**
+ * xmlRegCompactPushString:
+ * @exec: a regexp execution context
+ * @comp:  the precompiled exec with a compact table
+ * @value: a string token input
+ * @data: data associated to the token to reuse in callbacks
+ *
+ * Push one input token in the execution context
+ *
+ * Returns: 1 if the regexp reached a final state, 0 if non-final, and
+ *     a negative value in case of error.
+ */
+static int
+xmlRegCompactPushString(xmlRegExecCtxtPtr exec,
+	                xmlRegexpPtr comp,
+	                const xmlChar *value,
+	                void *data) {
+    int state = exec->index;
+    int i, target;
+
+    if ((comp == NULL) || (comp->compact == NULL) || (comp->stringMap == NULL))
+	return(-1);
+    
+    if (value == NULL) {
+	/*
+	 * are we at a final state ?
+	 */
+	if (comp->compact[state * (comp->nbstrings + 1)] ==
+            XML_REGEXP_FINAL_STATE)
+	    return(1);
+	return(0);
+    }
+
+#ifdef DEBUG_PUSH
+    printf("value pushed: %s\n", value);
+#endif
+
+    /*
+     * Examine all outside transition from current state
+     */
+    for (i = 0;i < comp->nbstrings;i++) {
+	target = comp->compact[state * (comp->nbstrings + 1) + i + 1];
+	if ((target > 0) && (target <= comp->nbstates)) {
+	    target--; /* to avoid 0 */
+	    if (xmlStrEqual(comp->stringMap[i], value)) {
+		exec->index = target;
+		if ((exec->callback != NULL) && (comp->transdata != NULL)) {
+		    exec->callback(exec->data, value,
+			  comp->transdata[state * comp->nbstrings + i], data);
+		}
+#ifdef DEBUG_PUSH
+		printf("entering state %d\n", target);
+#endif
+		if (comp->compact[target * (comp->nbstrings + 1)] ==
+		    XML_REGEXP_FINAL_STATE)
+		    return(1);
+		return(0);
+	    }
+	}
+    }
+    /*
+     * Failed to find an exit transition out from current state for the
+     * current token
+     */
+#ifdef DEBUG_PUSH
+    printf("failed to find a transition for %s on state %d\n", value, state);
+#endif
+    exec->status = -1;
+    return(-1);
+}
+
+/**
+ * xmlRegExecPushString:
+ * @exec: a regexp execution context or NULL to indicate the end
+ * @value: a string token input
+ * @data: data associated to the token to reuse in callbacks
+ *
+ * Push one input token in the execution context
+ *
+ * Returns: 1 if the regexp reached a final state, 0 if non-final, and
+ *     a negative value in case of error.
+ */
+int
+xmlRegExecPushString(xmlRegExecCtxtPtr exec, const xmlChar *value,
+	             void *data) {
+    xmlRegTransPtr trans;
+    xmlRegAtomPtr atom;
+    int ret;
+    int final = 0;
+
+    if (exec == NULL)
+	return(-1);
+    if (exec->comp == NULL)
+	return(-1);
+    if (exec->status != 0)
+	return(exec->status);
+
+    if (exec->comp->compact != NULL)
+	return(xmlRegCompactPushString(exec, exec->comp, value, data));
+
+    if (value == NULL) {
+        if (exec->state->type == XML_REGEXP_FINAL_STATE)
+	    return(1);
+	final = 1;
+    }
+
+#ifdef DEBUG_PUSH
+    printf("value pushed: %s\n", value);
+#endif
+    /*
+     * If we have an active rollback stack push the new value there
+     * and get back to where we were left
+     */
+    if ((value != NULL) && (exec->inputStackNr > 0)) {
+	xmlFARegExecSaveInputString(exec, value, data);
+	value = exec->inputStack[exec->index].value;
+	data = exec->inputStack[exec->index].data;
+#ifdef DEBUG_PUSH
+	printf("value loaded: %s\n", value);
+#endif
+    }
+
+    while ((exec->status == 0) &&
+	   ((value != NULL) ||
+	    ((final == 1) &&
+	     (exec->state->type != XML_REGEXP_FINAL_STATE)))) {
+
+	/*
+	 * End of input on non-terminal state, rollback, however we may
+	 * still have epsilon like transition for counted transitions
+	 * on counters, in that case don't break too early.
+	 */
+	if ((value == NULL) && (exec->counts == NULL))
+	    goto rollback;
+
+	exec->transcount = 0;
+	for (;exec->transno < exec->state->nbTrans;exec->transno++) {
+	    trans = &exec->state->trans[exec->transno];
+	    if (trans->to < 0)
+		continue;
+	    atom = trans->atom;
+	    ret = 0;
+	    if (trans->count == REGEXP_ALL_LAX_COUNTER) {
+		int i;
+		int count;
+		xmlRegTransPtr t;
+		xmlRegCounterPtr counter;
+
+		ret = 0;
+
+#ifdef DEBUG_PUSH
+		printf("testing all lax %d\n", trans->count);
+#endif
+		/*
+		 * Check all counted transitions from the current state
+		 */
+		if ((value == NULL) && (final)) {
+		    ret = 1;
+		} else if (value != NULL) {
+		    for (i = 0;i < exec->state->nbTrans;i++) {
+			t = &exec->state->trans[i];
+			if ((t->counter < 0) || (t == trans))
+			    continue;
+			counter = &exec->comp->counters[t->counter];
+			count = exec->counts[t->counter];
+			if ((count < counter->max) && 
+		            (t->atom != NULL) &&
+			    (xmlStrEqual(value, t->atom->valuep))) {
+			    ret = 0;
+			    break;
+			}
+			if ((count >= counter->min) &&
+			    (count < counter->max) &&
+			    (xmlStrEqual(value, t->atom->valuep))) {
+			    ret = 1;
+			    break;
+			}
+		    }
+		}
+	    } else if (trans->count == REGEXP_ALL_COUNTER) {
+		int i;
+		int count;
+		xmlRegTransPtr t;
+		xmlRegCounterPtr counter;
+
+		ret = 1;
+
+#ifdef DEBUG_PUSH
+		printf("testing all %d\n", trans->count);
+#endif
+		/*
+		 * Check all counted transitions from the current state
+		 */
+		for (i = 0;i < exec->state->nbTrans;i++) {
+                    t = &exec->state->trans[i];
+		    if ((t->counter < 0) || (t == trans))
+			continue;
+                    counter = &exec->comp->counters[t->counter];
+		    count = exec->counts[t->counter];
+		    if ((count < counter->min) || (count > counter->max)) {
+			ret = 0;
+			break;
+		    }
+		}
+	    } else if (trans->count >= 0) {
+		int count;
+		xmlRegCounterPtr counter;
+
+		/*
+		 * A counted transition.
+		 */
+
+		count = exec->counts[trans->count];
+		counter = &exec->comp->counters[trans->count];
+#ifdef DEBUG_PUSH
+		printf("testing count %d: val %d, min %d, max %d\n",
+		       trans->count, count, counter->min,  counter->max);
+#endif
+		ret = ((count >= counter->min) && (count <= counter->max));
+	    } else if (atom == NULL) {
+		fprintf(stderr, "epsilon transition left at runtime\n");
+		exec->status = -2;
+		break;
+	    } else if (value != NULL) {
+		ret = xmlStrEqual(value, atom->valuep);
+		if ((ret == 1) && (trans->counter >= 0)) {
+		    xmlRegCounterPtr counter;
+		    int count;
+
+		    count = exec->counts[trans->counter];
+		    counter = &exec->comp->counters[trans->counter];
+		    if (count >= counter->max)
+			ret = 0;
+		}
+
+		if ((ret == 1) && (atom->min > 0) && (atom->max > 0)) {
+		    xmlRegStatePtr to = exec->comp->states[trans->to];
+
+		    /*
+		     * this is a multiple input sequence
+		     */
+		    if (exec->state->nbTrans > exec->transno + 1) {
+			if (exec->inputStackNr <= 0) {
+			    xmlFARegExecSaveInputString(exec, value, data);
+			}
+			xmlFARegExecSave(exec);
+		    }
+		    exec->transcount = 1;
+		    do {
+			/*
+			 * Try to progress as much as possible on the input
+			 */
+			if (exec->transcount == atom->max) {
+			    break;
+			}
+			exec->index++;
+			value = exec->inputStack[exec->index].value;
+			data = exec->inputStack[exec->index].data;
+#ifdef DEBUG_PUSH
+			printf("value loaded: %s\n", value);
+#endif
+
+			/*
+			 * End of input: stop here
+			 */
+			if (value == NULL) {
+			    exec->index --;
+			    break;
+			}
+			if (exec->transcount >= atom->min) {
+			    int transno = exec->transno;
+			    xmlRegStatePtr state = exec->state;
+
+			    /*
+			     * The transition is acceptable save it
+			     */
+			    exec->transno = -1; /* trick */
+			    exec->state = to;
+			    if (exec->inputStackNr <= 0) {
+				xmlFARegExecSaveInputString(exec, value, data);
+			    }
+			    xmlFARegExecSave(exec);
+			    exec->transno = transno;
+			    exec->state = state;
+			}
+			ret = xmlStrEqual(value, atom->valuep);
+			exec->transcount++;
+		    } while (ret == 1);
+		    if (exec->transcount < atom->min)
+			ret = 0;
+
+		    /*
+		     * If the last check failed but one transition was found
+		     * possible, rollback
+		     */
+		    if (ret < 0)
+			ret = 0;
+		    if (ret == 0) {
+			goto rollback;
+		    }
+		}
+	    }
+	    if (ret == 1) {
+		if ((exec->callback != NULL) && (atom != NULL) &&
+			(data != NULL)) {
+		    exec->callback(exec->data, atom->valuep,
+			           atom->data, data);
+		}
+		if (exec->state->nbTrans > exec->transno + 1) {
+		    if (exec->inputStackNr <= 0) {
+			xmlFARegExecSaveInputString(exec, value, data);
+		    }
+		    xmlFARegExecSave(exec);
+		}
+		if (trans->counter >= 0) {
+#ifdef DEBUG_PUSH
+		    printf("Increasing count %d\n", trans->counter);
+#endif
+		    exec->counts[trans->counter]++;
+		}
+#ifdef DEBUG_PUSH
+		printf("entering state %d\n", trans->to);
+#endif
+		exec->state = exec->comp->states[trans->to];
+		exec->transno = 0;
+		if (trans->atom != NULL) {
+		    if (exec->inputStack != NULL) {
+			exec->index++;
+			if (exec->index < exec->inputStackNr) {
+			    value = exec->inputStack[exec->index].value;
+			    data = exec->inputStack[exec->index].data;
+#ifdef DEBUG_PUSH
+			    printf("value loaded: %s\n", value);
+#endif
+			} else {
+			    value = NULL;
+			    data = NULL;
+#ifdef DEBUG_PUSH
+			    printf("end of input\n");
+#endif
+			}
+		    } else {
+			value = NULL;
+			data = NULL;
+#ifdef DEBUG_PUSH
+			printf("end of input\n");
+#endif
+		    }
+		}
+		goto progress;
+	    } else if (ret < 0) {
+		exec->status = -4;
+		break;
+	    }
+	}
+	if ((exec->transno != 0) || (exec->state->nbTrans == 0)) {
+rollback:
+	    /*
+	     * Failed to find a way out
+	     */
+	    exec->determinist = 0;
+	    xmlFARegExecRollBack(exec);
+	    if (exec->status == 0) {
+		value = exec->inputStack[exec->index].value;
+		data = exec->inputStack[exec->index].data;
+#ifdef DEBUG_PUSH
+		printf("value loaded: %s\n", value);
+#endif
+	    }
+	}
+progress:
+	continue;
+    }
+    if (exec->status == 0) {
+        return(exec->state->type == XML_REGEXP_FINAL_STATE);
+    }
+    return(exec->status);
+}
+
+/**
+ * xmlRegExecPushString2:
+ * @exec: a regexp execution context or NULL to indicate the end
+ * @value: the first string token input
+ * @value2: the second string token input
+ * @data: data associated to the token to reuse in callbacks
+ *
+ * Push one input token in the execution context
+ *
+ * Returns: 1 if the regexp reached a final state, 0 if non-final, and
+ *     a negative value in case of error.
+ */
+int
+xmlRegExecPushString2(xmlRegExecCtxtPtr exec, const xmlChar *value,
+                      const xmlChar *value2, void *data) {
+    xmlChar buf[150];
+    int lenn, lenp, ret;
+    xmlChar *str;
+
+    if (exec == NULL)
+	return(-1);
+    if (exec->comp == NULL)
+	return(-1);
+    if (exec->status != 0)
+	return(exec->status);
+
+    if (value2 == NULL)
+        return(xmlRegExecPushString(exec, value, data));
+
+    lenn = strlen((char *) value2);
+    lenp = strlen((char *) value);
+
+    if (150 < lenn + lenp + 2) {
+	str = (xmlChar *) xmlMallocAtomic(lenn + lenp + 2);
+	if (str == NULL) {
+	    exec->status = -1;
+	    return(-1);
+	}
+    } else {
+	str = buf;
+    }
+    memcpy(&str[0], value, lenp);
+    str[lenp] = '|';
+    memcpy(&str[lenp + 1], value2, lenn);
+    str[lenn + lenp + 1] = 0;
+
+    if (exec->comp->compact != NULL)
+	ret = xmlRegCompactPushString(exec, exec->comp, str, data);
+    else
+        ret = xmlRegExecPushString(exec, str, data);
+
+    if (str != buf)
+        xmlFree(buf);
+    return(ret);
+}
+
+#if 0
+static int
+xmlRegExecPushChar(xmlRegExecCtxtPtr exec, int UCS) {
+    xmlRegTransPtr trans;
+    xmlRegAtomPtr atom;
+    int ret;
+    int codepoint, len;
+
+    if (exec == NULL)
+	return(-1);
+    if (exec->status != 0)
+	return(exec->status);
+
+    while ((exec->status == 0) &&
+	   ((exec->inputString[exec->index] != 0) ||
+	    (exec->state->type != XML_REGEXP_FINAL_STATE))) {
+
+	/*
+	 * End of input on non-terminal state, rollback, however we may
+	 * still have epsilon like transition for counted transitions
+	 * on counters, in that case don't break too early.
+	 */
+	if ((exec->inputString[exec->index] == 0) && (exec->counts == NULL))
+	    goto rollback;
+
+	exec->transcount = 0;
+	for (;exec->transno < exec->state->nbTrans;exec->transno++) {
+	    trans = &exec->state->trans[exec->transno];
+	    if (trans->to < 0)
+		continue;
+	    atom = trans->atom;
+	    ret = 0;
+	    if (trans->count >= 0) {
+		int count;
+		xmlRegCounterPtr counter;
+
+		/*
+		 * A counted transition.
+		 */
+
+		count = exec->counts[trans->count];
+		counter = &exec->comp->counters[trans->count];
+#ifdef DEBUG_REGEXP_EXEC
+		printf("testing count %d: val %d, min %d, max %d\n",
+		       trans->count, count, counter->min,  counter->max);
+#endif
+		ret = ((count >= counter->min) && (count <= counter->max));
+	    } else if (atom == NULL) {
+		fprintf(stderr, "epsilon transition left at runtime\n");
+		exec->status = -2;
+		break;
+	    } else if (exec->inputString[exec->index] != 0) {
+                codepoint = CUR_SCHAR(&(exec->inputString[exec->index]), len);
+		ret = xmlRegCheckCharacter(atom, codepoint);
+		if ((ret == 1) && (atom->min > 0) && (atom->max > 0)) {
+		    xmlRegStatePtr to = exec->comp->states[trans->to];
+
+		    /*
+		     * this is a multiple input sequence
+		     */
+		    if (exec->state->nbTrans > exec->transno + 1) {
+			xmlFARegExecSave(exec);
+		    }
+		    exec->transcount = 1;
+		    do {
+			/*
+			 * Try to progress as much as possible on the input
+			 */
+			if (exec->transcount == atom->max) {
+			    break;
+			}
+			exec->index += len;
+			/*
+			 * End of input: stop here
+			 */
+			if (exec->inputString[exec->index] == 0) {
+			    exec->index -= len;
+			    break;
+			}
+			if (exec->transcount >= atom->min) {
+			    int transno = exec->transno;
+			    xmlRegStatePtr state = exec->state;
+
+			    /*
+			     * The transition is acceptable save it
+			     */
+			    exec->transno = -1; /* trick */
+			    exec->state = to;
+			    xmlFARegExecSave(exec);
+			    exec->transno = transno;
+			    exec->state = state;
+			}
+			codepoint = CUR_SCHAR(&(exec->inputString[exec->index]),
+				              len);
+			ret = xmlRegCheckCharacter(atom, codepoint);
+			exec->transcount++;
+		    } while (ret == 1);
+		    if (exec->transcount < atom->min)
+			ret = 0;
+
+		    /*
+		     * If the last check failed but one transition was found
+		     * possible, rollback
+		     */
+		    if (ret < 0)
+			ret = 0;
+		    if (ret == 0) {
+			goto rollback;
+		    }
+		}
+	    }
+	    if (ret == 1) {
+		if (exec->state->nbTrans > exec->transno + 1) {
+		    xmlFARegExecSave(exec);
+		}
+		if (trans->counter >= 0) {
+#ifdef DEBUG_REGEXP_EXEC
+		    printf("Increasing count %d\n", trans->counter);
+#endif
+		    exec->counts[trans->counter]++;
+		}
+#ifdef DEBUG_REGEXP_EXEC
+		printf("entering state %d\n", trans->to);
+#endif
+		exec->state = exec->comp->states[trans->to];
+		exec->transno = 0;
+		if (trans->atom != NULL) {
+		    exec->index += len;
+		}
+		goto progress;
+	    } else if (ret < 0) {
+		exec->status = -4;
+		break;
+	    }
+	}
+	if ((exec->transno != 0) || (exec->state->nbTrans == 0)) {
+rollback:
+	    /*
+	     * Failed to find a way out
+	     */
+	    exec->determinist = 0;
+	    xmlFARegExecRollBack(exec);
+	}
+progress:
+	continue;
+    }
+}
+#endif
+/************************************************************************
+ * 									*
+ *	Parser for the Shemas Datatype Regular Expressions		*
+ *	http://www.w3.org/TR/2001/REC-xmlschema-2-20010502/#regexs	*
+ * 									*
+ ************************************************************************/
+
+/**
+ * xmlFAIsChar:
+ * @ctxt:  a regexp parser context
+ *
+ * [10]   Char   ::=   [^.\?*+()|#x5B#x5D]
+ */
+static int
+xmlFAIsChar(xmlRegParserCtxtPtr ctxt) {
+    int cur;
+    int len;
+
+    cur = CUR_SCHAR(ctxt->cur, len);
+    if ((cur == '.') || (cur == '\\') || (cur == '?') ||
+	(cur == '*') || (cur == '+') || (cur == '(') ||
+	(cur == ')') || (cur == '|') || (cur == 0x5B) ||
+	(cur == 0x5D) || (cur == 0))
+	return(-1);
+    return(cur);
+}
+
+/**
+ * xmlFAParseCharProp:
+ * @ctxt:  a regexp parser context
+ *
+ * [27]   charProp   ::=   IsCategory | IsBlock
+ * [28]   IsCategory ::= Letters | Marks | Numbers | Punctuation |
+ *                       Separators | Symbols | Others 
+ * [29]   Letters   ::=   'L' [ultmo]?
+ * [30]   Marks   ::=   'M' [nce]?
+ * [31]   Numbers   ::=   'N' [dlo]?
+ * [32]   Punctuation   ::=   'P' [cdseifo]?
+ * [33]   Separators   ::=   'Z' [slp]?
+ * [34]   Symbols   ::=   'S' [mcko]?
+ * [35]   Others   ::=   'C' [cfon]?
+ * [36]   IsBlock   ::=   'Is' [a-zA-Z0-9#x2D]+
+ */
+static void
+xmlFAParseCharProp(xmlRegParserCtxtPtr ctxt) {
+    int cur;
+    xmlRegAtomType type = (xmlRegAtomType) 0;
+    xmlChar *blockName = NULL;
+    
+    cur = CUR;
+    if (cur == 'L') {
+	NEXT;
+	cur = CUR;
+	if (cur == 'u') {
+	    NEXT;
+	    type = XML_REGEXP_LETTER_UPPERCASE;
+	} else if (cur == 'l') {
+	    NEXT;
+	    type = XML_REGEXP_LETTER_LOWERCASE;
+	} else if (cur == 't') {
+	    NEXT;
+	    type = XML_REGEXP_LETTER_TITLECASE;
+	} else if (cur == 'm') {
+	    NEXT;
+	    type = XML_REGEXP_LETTER_MODIFIER;
+	} else if (cur == 'o') {
+	    NEXT;
+	    type = XML_REGEXP_LETTER_OTHERS;
+	} else {
+	    type = XML_REGEXP_LETTER;
+	}
+    } else if (cur == 'M') {
+	NEXT;
+	cur = CUR;
+	if (cur == 'n') {
+	    NEXT;
+	    /* nonspacing */
+	    type = XML_REGEXP_MARK_NONSPACING;
+	} else if (cur == 'c') {
+	    NEXT;
+	    /* spacing combining */
+	    type = XML_REGEXP_MARK_SPACECOMBINING;
+	} else if (cur == 'e') {
+	    NEXT;
+	    /* enclosing */
+	    type = XML_REGEXP_MARK_ENCLOSING;
+	} else {
+	    /* all marks */
+	    type = XML_REGEXP_MARK;
+	}
+    } else if (cur == 'N') {
+	NEXT;
+	cur = CUR;
+	if (cur == 'd') {
+	    NEXT;
+	    /* digital */
+	    type = XML_REGEXP_NUMBER_DECIMAL;
+	} else if (cur == 'l') {
+	    NEXT;
+	    /* letter */
+	    type = XML_REGEXP_NUMBER_LETTER;
+	} else if (cur == 'o') {
+	    NEXT;
+	    /* other */
+	    type = XML_REGEXP_NUMBER_OTHERS;
+	} else {
+	    /* all numbers */
+	    type = XML_REGEXP_NUMBER;
+	}
+    } else if (cur == 'P') {
+	NEXT;
+	cur = CUR;
+	if (cur == 'c') {
+	    NEXT;
+	    /* connector */
+	    type = XML_REGEXP_PUNCT_CONNECTOR;
+	} else if (cur == 'd') {
+	    NEXT;
+	    /* dash */
+	    type = XML_REGEXP_PUNCT_DASH;
+	} else if (cur == 's') {
+	    NEXT;
+	    /* open */
+	    type = XML_REGEXP_PUNCT_OPEN;
+	} else if (cur == 'e') {
+	    NEXT;
+	    /* close */
+	    type = XML_REGEXP_PUNCT_CLOSE;
+	} else if (cur == 'i') {
+	    NEXT;
+	    /* initial quote */
+	    type = XML_REGEXP_PUNCT_INITQUOTE;
+	} else if (cur == 'f') {
+	    NEXT;
+	    /* final quote */
+	    type = XML_REGEXP_PUNCT_FINQUOTE;
+	} else if (cur == 'o') {
+	    NEXT;
+	    /* other */
+	    type = XML_REGEXP_PUNCT_OTHERS;
+	} else {
+	    /* all punctuation */
+	    type = XML_REGEXP_PUNCT;
+	}
+    } else if (cur == 'Z') {
+	NEXT;
+	cur = CUR;
+	if (cur == 's') {
+	    NEXT;
+	    /* space */
+	    type = XML_REGEXP_SEPAR_SPACE;
+	} else if (cur == 'l') {
+	    NEXT;
+	    /* line */
+	    type = XML_REGEXP_SEPAR_LINE;
+	} else if (cur == 'p') {
+	    NEXT;
+	    /* paragraph */
+	    type = XML_REGEXP_SEPAR_PARA;
+	} else {
+	    /* all separators */
+	    type = XML_REGEXP_SEPAR;
+	}
+    } else if (cur == 'S') {
+	NEXT;
+	cur = CUR;
+	if (cur == 'm') {
+	    NEXT;
+	    type = XML_REGEXP_SYMBOL_MATH;
+	    /* math */
+	} else if (cur == 'c') {
+	    NEXT;
+	    type = XML_REGEXP_SYMBOL_CURRENCY;
+	    /* currency */
+	} else if (cur == 'k') {
+	    NEXT;
+	    type = XML_REGEXP_SYMBOL_MODIFIER;
+	    /* modifiers */
+	} else if (cur == 'o') {
+	    NEXT;
+	    type = XML_REGEXP_SYMBOL_OTHERS;
+	    /* other */
+	} else {
+	    /* all symbols */
+	    type = XML_REGEXP_SYMBOL;
+	}
+    } else if (cur == 'C') {
+	NEXT;
+	cur = CUR;
+	if (cur == 'c') {
+	    NEXT;
+	    /* control */
+	    type = XML_REGEXP_OTHER_CONTROL;
+	} else if (cur == 'f') {
+	    NEXT;
+	    /* format */
+	    type = XML_REGEXP_OTHER_FORMAT;
+	} else if (cur == 'o') {
+	    NEXT;
+	    /* private use */
+	    type = XML_REGEXP_OTHER_PRIVATE;
+	} else if (cur == 'n') {
+	    NEXT;
+	    /* not assigned */
+	    type = XML_REGEXP_OTHER_NA;
+	} else {
+	    /* all others */
+	    type = XML_REGEXP_OTHER;
+	}
+    } else if (cur == 'I') {
+	const xmlChar *start;
+	NEXT;
+	cur = CUR;
+	if (cur != 's') {
+	    ERROR("IsXXXX expected");
+	    return;
+	}
+	NEXT;
+	start = ctxt->cur;
+	cur = CUR;
+	if (((cur >= 'a') && (cur <= 'z')) || 
+	    ((cur >= 'A') && (cur <= 'Z')) || 
+	    ((cur >= '0') && (cur <= '9')) || 
+	    (cur == 0x2D)) {
+	    NEXT;
+	    cur = CUR;
+	    while (((cur >= 'a') && (cur <= 'z')) || 
+		((cur >= 'A') && (cur <= 'Z')) || 
+		((cur >= '0') && (cur <= '9')) || 
+		(cur == 0x2D)) {
+		NEXT;
+		cur = CUR;
+	    }
+	}
+	type = XML_REGEXP_BLOCK_NAME;
+	blockName = xmlStrndup(start, ctxt->cur - start);
+    } else {
+	ERROR("Unknown char property");
+	return;
+    }
+    if (ctxt->atom == NULL) {
+	ctxt->atom = xmlRegNewAtom(ctxt, type);
+	if (ctxt->atom != NULL)
+	    ctxt->atom->valuep = blockName;
+    } else if (ctxt->atom->type == XML_REGEXP_RANGES) {
+        xmlRegAtomAddRange(ctxt, ctxt->atom, ctxt->neg,
+		           type, 0, 0, blockName);
+    }
+}
+
+/**
+ * xmlFAParseCharClassEsc:
+ * @ctxt:  a regexp parser context
+ *
+ * [23] charClassEsc ::= ( SingleCharEsc | MultiCharEsc | catEsc | complEsc ) 
+ * [24] SingleCharEsc ::= '\' [nrt\|.?*+(){}#x2D#x5B#x5D#x5E]
+ * [25] catEsc   ::=   '\p{' charProp '}'
+ * [26] complEsc ::=   '\P{' charProp '}'
+ * [37] MultiCharEsc ::= '.' | ('\' [sSiIcCdDwW])
+ */
+static void
+xmlFAParseCharClassEsc(xmlRegParserCtxtPtr ctxt) {
+    int cur;
+
+    if (CUR == '.') {
+	if (ctxt->atom == NULL) {
+	    ctxt->atom = xmlRegNewAtom(ctxt, XML_REGEXP_ANYCHAR);
+	} else if (ctxt->atom->type == XML_REGEXP_RANGES) {
+	    xmlRegAtomAddRange(ctxt, ctxt->atom, ctxt->neg,
+			       XML_REGEXP_ANYCHAR, 0, 0, NULL);
+	}
+	NEXT;
+	return;
+    }
+    if (CUR != '\\') {
+	ERROR("Escaped sequence: expecting \\");
+	return;
+    }
+    NEXT;
+    cur = CUR;
+    if (cur == 'p') {
+	NEXT;
+	if (CUR != '{') {
+	    ERROR("Expecting '{'");
+	    return;
+	}
+	NEXT;
+	xmlFAParseCharProp(ctxt);
+	if (CUR != '}') {
+	    ERROR("Expecting '}'");
+	    return;
+	}
+	NEXT;
+    } else if (cur == 'P') {
+	NEXT;
+	if (CUR != '{') {
+	    ERROR("Expecting '{'");
+	    return;
+	}
+	NEXT;
+	xmlFAParseCharProp(ctxt);
+	ctxt->atom->neg = 1;
+	if (CUR != '}') {
+	    ERROR("Expecting '}'");
+	    return;
+	}
+	NEXT;
+    } else if ((cur == 'n') || (cur == 'r') || (cur == 't') || (cur == '\\') ||
+	(cur == '|') || (cur == '.') || (cur == '?') || (cur == '*') ||
+	(cur == '+') || (cur == '(') || (cur == ')') || (cur == '{') ||
+	(cur == '}') || (cur == 0x2D) || (cur == 0x5B) || (cur == 0x5D) ||
+	(cur == 0x5E)) {
+	if (ctxt->atom == NULL) {
+	    ctxt->atom = xmlRegNewAtom(ctxt, XML_REGEXP_CHARVAL);
+	    if (ctxt->atom != NULL)
+		ctxt->atom->codepoint = cur;
+	} else if (ctxt->atom->type == XML_REGEXP_RANGES) {
+	    xmlRegAtomAddRange(ctxt, ctxt->atom, ctxt->neg,
+			       XML_REGEXP_CHARVAL, cur, cur, NULL);
+	}
+	NEXT;
+    } else if ((cur == 's') || (cur == 'S') || (cur == 'i') || (cur == 'I') ||
+	(cur == 'c') || (cur == 'C') || (cur == 'd') || (cur == 'D') ||
+	(cur == 'w') || (cur == 'W')) {
+	xmlRegAtomType type = XML_REGEXP_ANYSPACE;
+
+	switch (cur) {
+	    case 's': 
+		type = XML_REGEXP_ANYSPACE;
+		break;
+	    case 'S': 
+		type = XML_REGEXP_NOTSPACE;
+		break;
+	    case 'i': 
+		type = XML_REGEXP_INITNAME;
+		break;
+	    case 'I': 
+		type = XML_REGEXP_NOTINITNAME;
+		break;
+	    case 'c': 
+		type = XML_REGEXP_NAMECHAR;
+		break;
+	    case 'C': 
+		type = XML_REGEXP_NOTNAMECHAR;
+		break;
+	    case 'd': 
+		type = XML_REGEXP_DECIMAL;
+		break;
+	    case 'D': 
+		type = XML_REGEXP_NOTDECIMAL;
+		break;
+	    case 'w': 
+		type = XML_REGEXP_REALCHAR;
+		break;
+	    case 'W': 
+		type = XML_REGEXP_NOTREALCHAR;
+		break;
+	}
+	NEXT;
+	if (ctxt->atom == NULL) {
+	    ctxt->atom = xmlRegNewAtom(ctxt, type);
+	} else if (ctxt->atom->type == XML_REGEXP_RANGES) {
+	    xmlRegAtomAddRange(ctxt, ctxt->atom, ctxt->neg,
+			       type, 0, 0, NULL);
+	}
+    }
+}
+
+/**
+ * xmlFAParseCharRef:
+ * @ctxt:  a regexp parser context
+ *
+ * [19]   XmlCharRef   ::=   ( '&#' [0-9]+ ';' ) | (' &#x' [0-9a-fA-F]+ ';' )
+ */
+static int
+xmlFAParseCharRef(xmlRegParserCtxtPtr ctxt) {
+    int ret = 0, cur;
+
+    if ((CUR != '&') || (NXT(1) != '#'))
+	return(-1);
+    NEXT;
+    NEXT;
+    cur = CUR;
+    if (cur == 'x') {
+	NEXT;
+	cur = CUR;
+	if (((cur >= '0') && (cur <= '9')) ||
+	    ((cur >= 'a') && (cur <= 'f')) ||
+	    ((cur >= 'A') && (cur <= 'F'))) {
+	    while (((cur >= '0') && (cur <= '9')) ||
+		   ((cur >= 'A') && (cur <= 'F'))) {
+		if ((cur >= '0') && (cur <= '9'))
+		    ret = ret * 16 + cur - '0';
+		else if ((cur >= 'a') && (cur <= 'f'))
+		    ret = ret * 16 + 10 + (cur - 'a');
+		else
+		    ret = ret * 16 + 10 + (cur - 'A');
+		NEXT;
+		cur = CUR;
+	    }
+	} else {
+	    ERROR("Char ref: expecting [0-9A-F]");
+	    return(-1);
+	}
+    } else {
+	if ((cur >= '0') && (cur <= '9')) {
+	    while ((cur >= '0') && (cur <= '9')) {
+		ret = ret * 10 + cur - '0';
+		NEXT;
+		cur = CUR;
+	    }
+	} else {
+	    ERROR("Char ref: expecting [0-9]");
+	    return(-1);
+	}
+    }
+    if (cur != ';') {
+	ERROR("Char ref: expecting ';'");
+	return(-1);
+    } else {
+	NEXT;
+    }
+    return(ret);
+}
+
+/**
+ * xmlFAParseCharRange:
+ * @ctxt:  a regexp parser context
+ *
+ * [17]   charRange   ::=     seRange | XmlCharRef | XmlCharIncDash 
+ * [18]   seRange   ::=   charOrEsc '-' charOrEsc
+ * [20]   charOrEsc   ::=   XmlChar | SingleCharEsc
+ * [21]   XmlChar   ::=   [^\#x2D#x5B#x5D]
+ * [22]   XmlCharIncDash   ::=   [^\#x5B#x5D]
+ */
+static void
+xmlFAParseCharRange(xmlRegParserCtxtPtr ctxt) {
+    int cur, len;
+    int start = -1;
+    int end = -1;
+
+    if ((CUR == '&') && (NXT(1) == '#')) {
+	end = start = xmlFAParseCharRef(ctxt);
+        xmlRegAtomAddRange(ctxt, ctxt->atom, ctxt->neg,
+	                   XML_REGEXP_CHARVAL, start, end, NULL);
+	return;
+    }
+    cur = CUR;
+    if (cur == '\\') {
+	NEXT;
+	cur = CUR;
+	switch (cur) {
+	    case 'n': start = 0xA; break;
+	    case 'r': start = 0xD; break;
+	    case 't': start = 0x9; break;
+	    case '\\': case '|': case '.': case '-': case '^': case '?':
+	    case '*': case '+': case '{': case '}': case '(': case ')':
+	    case '[': case ']':
+		start = cur; break;
+	    default:
+		ERROR("Invalid escape value");
+		return;
+	}
+	end = start;
+        len = 1;
+    } else if ((cur != 0x5B) && (cur != 0x5D)) {
+        end = start = CUR_SCHAR(ctxt->cur, len);
+    } else {
+	ERROR("Expecting a char range");
+	return;
+    }
+    NEXTL(len);
+    if (start == '-') {
+	return;
+    }
+    cur = CUR;
+    if ((cur != '-') || (NXT(1) == ']')) {
+        xmlRegAtomAddRange(ctxt, ctxt->atom, ctxt->neg,
+		              XML_REGEXP_CHARVAL, start, end, NULL);
+	return;
+    }
+    NEXT;
+    cur = CUR;
+    if (cur == '\\') {
+	NEXT;
+	cur = CUR;
+	switch (cur) {
+	    case 'n': end = 0xA; break;
+	    case 'r': end = 0xD; break;
+	    case 't': end = 0x9; break;
+	    case '\\': case '|': case '.': case '-': case '^': case '?':
+	    case '*': case '+': case '{': case '}': case '(': case ')':
+	    case '[': case ']':
+		end = cur; break;
+	    default:
+		ERROR("Invalid escape value");
+		return;
+	}
+        len = 1;
+    } else if ((cur != 0x5B) && (cur != 0x5D)) {
+        end = CUR_SCHAR(ctxt->cur, len);
+    } else {
+	ERROR("Expecting the end of a char range");
+	return;
+    }
+    NEXTL(len);
+    /* TODO check that the values are acceptable character ranges for XML */
+    if (end < start) {
+	ERROR("End of range is before start of range");
+    } else {
+        xmlRegAtomAddRange(ctxt, ctxt->atom, ctxt->neg,
+		           XML_REGEXP_CHARVAL, start, end, NULL);
+    }
+    return;
+}
+
+/**
+ * xmlFAParsePosCharGroup:
+ * @ctxt:  a regexp parser context
+ *
+ * [14]   posCharGroup ::= ( charRange | charClassEsc  )+
+ */
+static void
+xmlFAParsePosCharGroup(xmlRegParserCtxtPtr ctxt) {
+    do {
+	if ((CUR == '\\') || (CUR == '.')) {
+	    xmlFAParseCharClassEsc(ctxt);
+	} else {
+	    xmlFAParseCharRange(ctxt);
+	}
+    } while ((CUR != ']') && (CUR != '^') && (CUR != '-') &&
+	     (ctxt->error == 0));
+}
+
+/**
+ * xmlFAParseCharGroup:
+ * @ctxt:  a regexp parser context
+ *
+ * [13]   charGroup    ::= posCharGroup | negCharGroup | charClassSub
+ * [15]   negCharGroup ::= '^' posCharGroup
+ * [16]   charClassSub ::= ( posCharGroup | negCharGroup ) '-' charClassExpr  
+ * [12]   charClassExpr ::= '[' charGroup ']'
+ */
+static void
+xmlFAParseCharGroup(xmlRegParserCtxtPtr ctxt) {
+    int n = ctxt->neg;
+    while ((CUR != ']') && (ctxt->error == 0)) {
+	if (CUR == '^') {
+	    int neg = ctxt->neg;
+
+	    NEXT;
+	    ctxt->neg = !ctxt->neg;
+	    xmlFAParsePosCharGroup(ctxt);
+	    ctxt->neg = neg;
+	} else if ((CUR == '-') && (NXT(1) == '[')) {
+	    int neg = ctxt->neg;
+	    ctxt->neg = 2;
+	    NEXT;	/* eat the '-' */
+	    NEXT;	/* eat the '[' */
+	    xmlFAParseCharGroup(ctxt);
+	    if (CUR == ']') {
+		NEXT;
+	    } else {
+		ERROR("charClassExpr: ']' expected");
+		break;
+	    }
+	    ctxt->neg = neg;
+	    break;
+	} else if (CUR != ']') {
+	    xmlFAParsePosCharGroup(ctxt);
+	}
+    }
+    ctxt->neg = n;
+}
+
+/**
+ * xmlFAParseCharClass:
+ * @ctxt:  a regexp parser context
+ *
+ * [11]   charClass   ::=     charClassEsc | charClassExpr
+ * [12]   charClassExpr   ::=   '[' charGroup ']'
+ */
+static void
+xmlFAParseCharClass(xmlRegParserCtxtPtr ctxt) {
+    if (CUR == '[') {
+	NEXT;
+	ctxt->atom = xmlRegNewAtom(ctxt, XML_REGEXP_RANGES);
+	if (ctxt->atom == NULL)
+	    return;
+	xmlFAParseCharGroup(ctxt);
+	if (CUR == ']') {
+	    NEXT;
+	} else {
+	    ERROR("xmlFAParseCharClass: ']' expected");
+	}
+    } else {
+	xmlFAParseCharClassEsc(ctxt);
+    }
+}
+
+/**
+ * xmlFAParseQuantExact:
+ * @ctxt:  a regexp parser context
+ *
+ * [8]   QuantExact   ::=   [0-9]+
+ *
+ * Returns 0 if success or -1 in case of error
+ */
+static int
+xmlFAParseQuantExact(xmlRegParserCtxtPtr ctxt) {
+    int ret = 0;
+    int ok = 0;
+
+    while ((CUR >= '0') && (CUR <= '9')) {
+	ret = ret * 10 + (CUR - '0');
+	ok = 1;
+	NEXT;
+    }
+    if (ok != 1) {
+	return(-1);
+    }
+    return(ret);
+}
+
+/**
+ * xmlFAParseQuantifier:
+ * @ctxt:  a regexp parser context
+ *
+ * [4]   quantifier   ::=   [?*+] | ( '{' quantity '}' )
+ * [5]   quantity   ::=   quantRange | quantMin | QuantExact
+ * [6]   quantRange   ::=   QuantExact ',' QuantExact
+ * [7]   quantMin   ::=   QuantExact ','
+ * [8]   QuantExact   ::=   [0-9]+
+ */
+static int
+xmlFAParseQuantifier(xmlRegParserCtxtPtr ctxt) {
+    int cur;
+
+    cur = CUR;
+    if ((cur == '?') || (cur == '*') || (cur == '+')) {
+	if (ctxt->atom != NULL) {
+	    if (cur == '?')
+		ctxt->atom->quant = XML_REGEXP_QUANT_OPT;
+	    else if (cur == '*')
+		ctxt->atom->quant = XML_REGEXP_QUANT_MULT;
+	    else if (cur == '+')
+		ctxt->atom->quant = XML_REGEXP_QUANT_PLUS;
+	}
+	NEXT;
+	return(1);
+    }
+    if (cur == '{') {
+	int min = 0, max = 0;
+
+	NEXT;
+	cur = xmlFAParseQuantExact(ctxt);
+	if (cur >= 0)
+	    min = cur;
+	if (CUR == ',') {
+	    NEXT;
+	    if (CUR == '}')
+	        max = INT_MAX;
+	    else {
+	        cur = xmlFAParseQuantExact(ctxt);
+	        if (cur >= 0)
+		    max = cur;
+		else {
+		    ERROR("Improper quantifier");
+		}
+	    }
+	}
+	if (CUR == '}') {
+	    NEXT;
+	} else {
+	    ERROR("Unterminated quantifier");
+	}
+	if (max == 0)
+	    max = min;
+	if (ctxt->atom != NULL) {
+	    ctxt->atom->quant = XML_REGEXP_QUANT_RANGE;
+	    ctxt->atom->min = min;
+	    ctxt->atom->max = max;
+	}
+	return(1);
+    }
+    return(0);
+}
+
+/**
+ * xmlFAParseAtom:
+ * @ctxt:  a regexp parser context
+ *
+ * [9]   atom   ::=   Char | charClass | ( '(' regExp ')' )
+ */
+static int
+xmlFAParseAtom(xmlRegParserCtxtPtr ctxt) {
+    int codepoint, len;
+
+    codepoint = xmlFAIsChar(ctxt);
+    if (codepoint > 0) {
+	ctxt->atom = xmlRegNewAtom(ctxt, XML_REGEXP_CHARVAL);
+	if (ctxt->atom == NULL)
+	    return(-1);
+	codepoint = CUR_SCHAR(ctxt->cur, len);
+	ctxt->atom->codepoint = codepoint;
+	NEXTL(len);
+	return(1);
+    } else if (CUR == '|') {
+	return(0);
+    } else if (CUR == 0) {
+	return(0);
+    } else if (CUR == ')') {
+	return(0);
+    } else if (CUR == '(') {
+	xmlRegStatePtr start, oldend;
+
+	NEXT;
+	xmlFAGenerateEpsilonTransition(ctxt, ctxt->state, NULL);
+	start = ctxt->state;
+	oldend = ctxt->end;
+	ctxt->end = NULL;
+	ctxt->atom = NULL;
+	xmlFAParseRegExp(ctxt, 0);
+	if (CUR == ')') {
+	    NEXT;
+	} else {
+	    ERROR("xmlFAParseAtom: expecting ')'");
+	}
+	ctxt->atom = xmlRegNewAtom(ctxt, XML_REGEXP_SUBREG);
+	if (ctxt->atom == NULL)
+	    return(-1);
+	ctxt->atom->start = start;
+	ctxt->atom->stop = ctxt->state;
+	ctxt->end = oldend;
+	return(1);
+    } else if ((CUR == '[') || (CUR == '\\') || (CUR == '.')) {
+	xmlFAParseCharClass(ctxt);
+	return(1);
+    }
+    return(0);
+}
+
+/**
+ * xmlFAParsePiece:
+ * @ctxt:  a regexp parser context
+ *
+ * [3]   piece   ::=   atom quantifier?
+ */
+static int
+xmlFAParsePiece(xmlRegParserCtxtPtr ctxt) {
+    int ret;
+
+    ctxt->atom = NULL;
+    ret = xmlFAParseAtom(ctxt);
+    if (ret == 0)
+	return(0);
+    if (ctxt->atom == NULL) {
+	ERROR("internal: no atom generated");
+    }
+    xmlFAParseQuantifier(ctxt);
+    return(1);
+}
+
+/**
+ * xmlFAParseBranch:
+ * @ctxt:  a regexp parser context
+ *
+ * [2]   branch   ::=   piece*
+ 8
+ */
+static int
+xmlFAParseBranch(xmlRegParserCtxtPtr ctxt) {
+    xmlRegStatePtr previous;
+    int ret;
+
+    previous = ctxt->state;
+    ret = xmlFAParsePiece(ctxt);
+    if (ret != 0) {
+	if (xmlFAGenerateTransitions(ctxt, previous, NULL, ctxt->atom) < 0)
+	    return(-1);
+	previous = ctxt->state;
+	ctxt->atom = NULL;
+    }
+    while ((ret != 0) && (ctxt->error == 0)) {
+	ret = xmlFAParsePiece(ctxt);
+	if (ret != 0) {
+	    if (xmlFAGenerateTransitions(ctxt, previous, NULL,
+					 ctxt->atom) < 0)
+		    return(-1);
+	    previous = ctxt->state;
+	    ctxt->atom = NULL;
+	}
+    }
+    return(0);
+}
+
+/**
+ * xmlFAParseRegExp:
+ * @ctxt:  a regexp parser context
+ * @top:  is that the top-level expressions ?
+ *
+ * [1]   regExp   ::=     branch  ( '|' branch )*
+ */
+static void
+xmlFAParseRegExp(xmlRegParserCtxtPtr ctxt, int top) {
+    xmlRegStatePtr start, end, oldend, oldstart;
+
+    oldend = ctxt->end;
+
+    oldstart = ctxt->state;
+    /* if not top start should have been generated by an epsilon trans */
+    start = ctxt->state;
+    ctxt->end = NULL;
+    xmlFAParseBranch(ctxt);
+    if (top) {
+#ifdef DEBUG_REGEXP_GRAPH
+	printf("State %d is final\n", ctxt->state->no);
+#endif
+	ctxt->state->type = XML_REGEXP_FINAL_STATE;
+    }
+    if (CUR != '|') {
+	ctxt->end = ctxt->state;
+	return;
+    }
+    end = ctxt->state;
+    while ((CUR == '|') && (ctxt->error == 0)) {
+	NEXT;
+	ctxt->state = start;
+	ctxt->end = NULL;
+	xmlFAParseBranch(ctxt);
+	if (top) {
+	    ctxt->state->type = XML_REGEXP_FINAL_STATE;
+#ifdef DEBUG_REGEXP_GRAPH
+	    printf("State %d is final\n", ctxt->state->no);
+#endif
+	} else {
+	    xmlFAGenerateEpsilonTransition(ctxt, ctxt->state, end);
+	}
+    }
+    if (!top) {
+	ctxt->state = end;
+	ctxt->end = end;
+    }
+}
+
+/************************************************************************
+ * 									*
+ * 			The basic API					*
+ * 									*
+ ************************************************************************/
+
+/**
+ * xmlRegexpPrint:
+ * @output: the file for the output debug
+ * @regexp: the compiled regexp
+ *
+ * Print the content of the compiled regular expression
+ */
+void
+xmlRegexpPrint(FILE *output, xmlRegexpPtr regexp) {
+    int i;
+
+    fprintf(output, " regexp: ");
+    if (regexp == NULL) {
+	fprintf(output, "NULL\n");
+	return;
+    }
+    fprintf(output, "'%s' ", regexp->string);
+    fprintf(output, "\n");
+    fprintf(output, "%d atoms:\n", regexp->nbAtoms);
+    for (i = 0;i < regexp->nbAtoms; i++) {
+	fprintf(output, " %02d ", i);
+	xmlRegPrintAtom(output, regexp->atoms[i]);
+    }
+    fprintf(output, "%d states:", regexp->nbStates);
+    fprintf(output, "\n");
+    for (i = 0;i < regexp->nbStates; i++) {
+	xmlRegPrintState(output, regexp->states[i]);
+    }
+    fprintf(output, "%d counters:\n", regexp->nbCounters);
+    for (i = 0;i < regexp->nbCounters; i++) {
+	fprintf(output, " %d: min %d max %d\n", i, regexp->counters[i].min,
+		                                regexp->counters[i].max);
+    }
+}
+
+/**
+ * xmlRegexpCompile:
+ * @regexp:  a regular expression string
+ *
+ * Parses a regular expression conforming to XML Schemas Part 2 Datatype
+ * Appendix F and build an automata suitable for testing strings against
+ * that regular expression
+ *
+ * Returns the compiled expression or NULL in case of error
+ */
+xmlRegexpPtr
+xmlRegexpCompile(const xmlChar *regexp) {
+    xmlRegexpPtr ret;
+    xmlRegParserCtxtPtr ctxt;
+
+    ctxt = xmlRegNewParserCtxt(regexp);
+    if (ctxt == NULL)
+	return(NULL);
+
+    /* initialize the parser */
+    ctxt->end = NULL;
+    ctxt->start = ctxt->state = xmlRegNewState(ctxt);
+    xmlRegStatePush(ctxt, ctxt->start);
+
+    /* parse the expression building an automata */
+    xmlFAParseRegExp(ctxt, 1);
+    if (CUR != 0) {
+	ERROR("xmlFAParseRegExp: extra characters");
+    }
+    ctxt->end = ctxt->state;
+    ctxt->start->type = XML_REGEXP_START_STATE;
+    ctxt->end->type = XML_REGEXP_FINAL_STATE;
+
+    /* remove the Epsilon except for counted transitions */
+    xmlFAEliminateEpsilonTransitions(ctxt);
+
+
+    if (ctxt->error != 0) {
+	xmlRegFreeParserCtxt(ctxt);
+	return(NULL);
+    }
+    ret = xmlRegEpxFromParse(ctxt);
+    xmlRegFreeParserCtxt(ctxt);
+    return(ret);
+}
+
+/**
+ * xmlRegexpExec:
+ * @comp:  the compiled regular expression
+ * @content:  the value to check against the regular expression
+ *
+ * Check if the regular expression generate the value
+ *
+ * Returns 1 if it matches, 0 if not and a negativa value in case of error
+ */
+int
+xmlRegexpExec(xmlRegexpPtr comp, const xmlChar *content) {
+    if ((comp == NULL) || (content == NULL))
+	return(-1);
+    return(xmlFARegExec(comp, content));
+}
+
+/**
+ * xmlRegexpIsDeterminist:
+ * @comp:  the compiled regular expression
+ *
+ * Check if the regular expression is determinist
+ *
+ * Returns 1 if it yes, 0 if not and a negativa value in case of error
+ */
+int
+xmlRegexpIsDeterminist(xmlRegexpPtr comp) {
+    xmlAutomataPtr am;
+    int ret;
+
+    if (comp == NULL)
+	return(-1);
+    if (comp->determinist != -1)
+	return(comp->determinist);
+
+    am = xmlNewAutomata();
+    if (am->states != NULL) {
+	int i;
+
+	for (i = 0;i < am->nbStates;i++)
+	    xmlRegFreeState(am->states[i]);
+	xmlFree(am->states);
+    }
+    am->nbAtoms = comp->nbAtoms;
+    am->atoms = comp->atoms;
+    am->nbStates = comp->nbStates;
+    am->states = comp->states;
+    am->determinist = -1;
+    ret = xmlFAComputesDeterminism(am);
+    am->atoms = NULL;
+    am->states = NULL;
+    xmlFreeAutomata(am);
+    return(ret);
+}
+
+/**
+ * xmlRegFreeRegexp:
+ * @regexp:  the regexp
+ *
+ * Free a regexp
+ */
+void
+xmlRegFreeRegexp(xmlRegexpPtr regexp) {
+    int i;
+    if (regexp == NULL)
+	return;
+
+    if (regexp->string != NULL)
+	xmlFree(regexp->string);
+    if (regexp->states != NULL) {
+	for (i = 0;i < regexp->nbStates;i++)
+	    xmlRegFreeState(regexp->states[i]);
+	xmlFree(regexp->states);
+    }
+    if (regexp->atoms != NULL) {
+	for (i = 0;i < regexp->nbAtoms;i++)
+	    xmlRegFreeAtom(regexp->atoms[i]);
+	xmlFree(regexp->atoms);
+    }
+    if (regexp->counters != NULL)
+	xmlFree(regexp->counters);
+    if (regexp->compact != NULL)
+	xmlFree(regexp->compact);
+    if (regexp->transdata != NULL)
+	xmlFree(regexp->transdata);
+    if (regexp->stringMap != NULL) {
+	for (i = 0; i < regexp->nbstrings;i++)
+	    xmlFree(regexp->stringMap[i]);
+	xmlFree(regexp->stringMap);
+    }
+
+    xmlFree(regexp);
+}
+
+#ifdef LIBXML_AUTOMATA_ENABLED
+/************************************************************************
+ * 									*
+ * 			The Automata interface				*
+ * 									*
+ ************************************************************************/
+
+/**
+ * xmlNewAutomata:
+ *
+ * Create a new automata
+ *
+ * Returns the new object or NULL in case of failure
+ */
+xmlAutomataPtr
+xmlNewAutomata(void) {
+    xmlAutomataPtr ctxt;
+
+    ctxt = xmlRegNewParserCtxt(NULL);
+    if (ctxt == NULL)
+	return(NULL);
+
+    /* initialize the parser */
+    ctxt->end = NULL;
+    ctxt->start = ctxt->state = xmlRegNewState(ctxt);
+    if (ctxt->start == NULL) {
+	xmlFreeAutomata(ctxt);
+	return(NULL);
+    }
+    if (xmlRegStatePush(ctxt, ctxt->start) < 0) {
+        xmlRegFreeState(ctxt->start);
+	xmlFreeAutomata(ctxt);
+	return(NULL);
+    }
+
+    return(ctxt);
+}
+
+/**
+ * xmlFreeAutomata:
+ * @am: an automata
+ *
+ * Free an automata
+ */
+void
+xmlFreeAutomata(xmlAutomataPtr am) {
+    if (am == NULL)
+	return;
+    xmlRegFreeParserCtxt(am);
+}
+
+/**
+ * xmlAutomataGetInitState:
+ * @am: an automata
+ *
+ * Initial state lookup
+ *
+ * Returns the initial state of the automata
+ */
+xmlAutomataStatePtr
+xmlAutomataGetInitState(xmlAutomataPtr am) {
+    if (am == NULL)
+	return(NULL);
+    return(am->start);
+}
+
+/**
+ * xmlAutomataSetFinalState:
+ * @am: an automata
+ * @state: a state in this automata
+ *
+ * Makes that state a final state
+ *
+ * Returns 0 or -1 in case of error
+ */
+int
+xmlAutomataSetFinalState(xmlAutomataPtr am, xmlAutomataStatePtr state) {
+    if ((am == NULL) || (state == NULL))
+	return(-1);
+    state->type = XML_REGEXP_FINAL_STATE;
+    return(0);
+}
+
+/**
+ * xmlAutomataNewTransition:
+ * @am: an automata
+ * @from: the starting point of the transition
+ * @to: the target point of the transition or NULL
+ * @token: the input string associated to that transition
+ * @data: data passed to the callback function if the transition is activated
+ *
+ * If @to is NULL, this create first a new target state in the automata
+ * and then adds a transition from the @from state to the target state
+ * activated by the value of @token
+ *
+ * Returns the target state or NULL in case of error
+ */
+xmlAutomataStatePtr
+xmlAutomataNewTransition(xmlAutomataPtr am, xmlAutomataStatePtr from,
+			 xmlAutomataStatePtr to, const xmlChar *token,
+			 void *data) {
+    xmlRegAtomPtr atom;
+
+    if ((am == NULL) || (from == NULL) || (token == NULL))
+	return(NULL);
+    atom = xmlRegNewAtom(am, XML_REGEXP_STRING);
+    if (atom == NULL)
+        return(NULL);
+    atom->data = data;
+    if (atom == NULL)
+	return(NULL);
+    atom->valuep = xmlStrdup(token);
+
+    if (xmlFAGenerateTransitions(am, from, to, atom) < 0) {
+        xmlRegFreeAtom(atom);
+	return(NULL);
+    }
+    if (to == NULL)
+	return(am->state);
+    return(to);
+}
+
+/**
+ * xmlAutomataNewTransition2:
+ * @am: an automata
+ * @from: the starting point of the transition
+ * @to: the target point of the transition or NULL
+ * @token: the first input string associated to that transition
+ * @token2: the second input string associated to that transition
+ * @data: data passed to the callback function if the transition is activated
+ *
+ * If @to is NULL, this create first a new target state in the automata
+ * and then adds a transition from the @from state to the target state
+ * activated by the value of @token
+ *
+ * Returns the target state or NULL in case of error
+ */
+xmlAutomataStatePtr
+xmlAutomataNewTransition2(xmlAutomataPtr am, xmlAutomataStatePtr from,
+			  xmlAutomataStatePtr to, const xmlChar *token,
+			  const xmlChar *token2, void *data) {
+    xmlRegAtomPtr atom;
+
+    if ((am == NULL) || (from == NULL) || (token == NULL))
+	return(NULL);
+    atom = xmlRegNewAtom(am, XML_REGEXP_STRING);
+    atom->data = data;
+    if (atom == NULL)
+	return(NULL);
+    if ((token2 == NULL) || (*token2 == 0)) {
+	atom->valuep = xmlStrdup(token);
+    } else {
+	int lenn, lenp;
+	xmlChar *str;
+
+	lenn = strlen((char *) token2);
+	lenp = strlen((char *) token);
+
+	str = (xmlChar *) xmlMallocAtomic(lenn + lenp + 2);
+	if (str == NULL) {
+	    xmlRegFreeAtom(atom);
+	    return(NULL);
+	}
+	memcpy(&str[0], token, lenp);
+	str[lenp] = '|';
+	memcpy(&str[lenp + 1], token2, lenn);
+	str[lenn + lenp + 1] = 0;
+
+	atom->valuep = str;
+    }
+
+    if (xmlFAGenerateTransitions(am, from, to, atom) < 0) {
+        xmlRegFreeAtom(atom);
+	return(NULL);
+    }
+    if (to == NULL)
+	return(am->state);
+    return(to);
+}
+
+/**
+ * xmlAutomataNewCountTrans:
+ * @am: an automata
+ * @from: the starting point of the transition
+ * @to: the target point of the transition or NULL
+ * @token: the input string associated to that transition
+ * @min:  the minimum successive occurences of token
+ * @max:  the maximum successive occurences of token
+ * @data:  data associated to the transition
+ *
+ * If @to is NULL, this create first a new target state in the automata
+ * and then adds a transition from the @from state to the target state
+ * activated by a succession of input of value @token and whose number
+ * is between @min and @max
+ *
+ * Returns the target state or NULL in case of error
+ */
+xmlAutomataStatePtr
+xmlAutomataNewCountTrans(xmlAutomataPtr am, xmlAutomataStatePtr from,
+			 xmlAutomataStatePtr to, const xmlChar *token,
+			 int min, int max, void *data) {
+    xmlRegAtomPtr atom;
+    int counter;
+
+    if ((am == NULL) || (from == NULL) || (token == NULL))
+	return(NULL);
+    if (min < 0)
+	return(NULL);
+    if ((max < min) || (max < 1))
+	return(NULL);
+    atom = xmlRegNewAtom(am, XML_REGEXP_STRING);
+    if (atom == NULL)
+	return(NULL);
+    atom->valuep = xmlStrdup(token);
+    atom->data = data;
+    if (min == 0)
+	atom->min = 1;
+    else
+	atom->min = min;
+    atom->max = max;
+
+    /*
+     * associate a counter to the transition.
+     */
+    counter = xmlRegGetCounter(am);
+    am->counters[counter].min = min;
+    am->counters[counter].max = max;
+
+    /* xmlFAGenerateTransitions(am, from, to, atom); */
+    if (to == NULL) {
+        to = xmlRegNewState(am);
+	xmlRegStatePush(am, to);
+    }
+    xmlRegStateAddTrans(am, from, atom, to, counter, -1);
+    xmlRegAtomPush(am, atom);
+    am->state = to;
+
+    if (to == NULL)
+	to = am->state;
+    if (to == NULL)
+	return(NULL);
+    if (min == 0)
+	xmlFAGenerateEpsilonTransition(am, from, to);
+    return(to);
+}
+
+/**
+ * xmlAutomataNewOnceTrans:
+ * @am: an automata
+ * @from: the starting point of the transition
+ * @to: the target point of the transition or NULL
+ * @token: the input string associated to that transition
+ * @min:  the minimum successive occurences of token
+ * @max:  the maximum successive occurences of token
+ * @data:  data associated to the transition
+ *
+ * If @to is NULL, this create first a new target state in the automata
+ * and then adds a transition from the @from state to the target state
+ * activated by a succession of input of value @token and whose number
+ * is between @min and @max, moreover that transistion can only be crossed
+ * once.
+ *
+ * Returns the target state or NULL in case of error
+ */
+xmlAutomataStatePtr
+xmlAutomataNewOnceTrans(xmlAutomataPtr am, xmlAutomataStatePtr from,
+			 xmlAutomataStatePtr to, const xmlChar *token,
+			 int min, int max, void *data) {
+    xmlRegAtomPtr atom;
+    int counter;
+
+    if ((am == NULL) || (from == NULL) || (token == NULL))
+	return(NULL);
+    if (min < 1)
+	return(NULL);
+    if ((max < min) || (max < 1))
+	return(NULL);
+    atom = xmlRegNewAtom(am, XML_REGEXP_STRING);
+    if (atom == NULL)
+	return(NULL);
+    atom->valuep = xmlStrdup(token);
+    atom->data = data;
+    atom->quant = XML_REGEXP_QUANT_ONCEONLY;
+    if (min == 0)
+	atom->min = 1;
+    else
+	atom->min = min;
+    atom->max = max;
+    /*
+     * associate a counter to the transition.
+     */
+    counter = xmlRegGetCounter(am);
+    am->counters[counter].min = 1;
+    am->counters[counter].max = 1;
+
+    /* xmlFAGenerateTransitions(am, from, to, atom); */
+    if (to == NULL) {
+	to = xmlRegNewState(am);
+	xmlRegStatePush(am, to);
+    }
+    xmlRegStateAddTrans(am, from, atom, to, counter, -1);
+    xmlRegAtomPush(am, atom);
+    am->state = to;
+    if (to == NULL)
+	to = am->state;
+    if (to == NULL)
+	return(NULL);
+    return(to);
+}
+
+/**
+ * xmlAutomataNewState:
+ * @am: an automata
+ *
+ * Create a new disconnected state in the automata
+ *
+ * Returns the new state or NULL in case of error
+ */
+xmlAutomataStatePtr
+xmlAutomataNewState(xmlAutomataPtr am) {
+    xmlAutomataStatePtr to; 
+
+    if (am == NULL)
+	return(NULL);
+    to = xmlRegNewState(am);
+    xmlRegStatePush(am, to);
+    return(to);
+}
+
+/**
+ * xmlAutomataNewEpsilon:
+ * @am: an automata
+ * @from: the starting point of the transition
+ * @to: the target point of the transition or NULL
+ *
+ * If @to is NULL, this create first a new target state in the automata
+ * and then adds a an epsilon transition from the @from state to the
+ * target state
+ *
+ * Returns the target state or NULL in case of error
+ */
+xmlAutomataStatePtr
+xmlAutomataNewEpsilon(xmlAutomataPtr am, xmlAutomataStatePtr from,
+		      xmlAutomataStatePtr to) {
+    if ((am == NULL) || (from == NULL))
+	return(NULL);
+    xmlFAGenerateEpsilonTransition(am, from, to);
+    if (to == NULL)
+	return(am->state);
+    return(to);
+}
+
+/**
+ * xmlAutomataNewAllTrans:
+ * @am: an automata
+ * @from: the starting point of the transition
+ * @to: the target point of the transition or NULL
+ * @lax: allow to transition if not all all transitions have been activated
+ *
+ * If @to is NULL, this create first a new target state in the automata
+ * and then adds a an ALL transition from the @from state to the
+ * target state. That transition is an epsilon transition allowed only when
+ * all transitions from the @from node have been activated.
+ *
+ * Returns the target state or NULL in case of error
+ */
+xmlAutomataStatePtr
+xmlAutomataNewAllTrans(xmlAutomataPtr am, xmlAutomataStatePtr from,
+		       xmlAutomataStatePtr to, int lax) {
+    if ((am == NULL) || (from == NULL))
+	return(NULL);
+    xmlFAGenerateAllTransition(am, from, to, lax);
+    if (to == NULL)
+	return(am->state);
+    return(to);
+}
+
+/**
+ * xmlAutomataNewCounter:
+ * @am: an automata
+ * @min:  the minimal value on the counter
+ * @max:  the maximal value on the counter
+ *
+ * Create a new counter
+ *
+ * Returns the counter number or -1 in case of error
+ */
+int		
+xmlAutomataNewCounter(xmlAutomataPtr am, int min, int max) {
+    int ret;
+
+    if (am == NULL)
+	return(-1);
+
+    ret = xmlRegGetCounter(am);
+    if (ret < 0)
+	return(-1);
+    am->counters[ret].min = min;
+    am->counters[ret].max = max;
+    return(ret);
+}
+
+/**
+ * xmlAutomataNewCountedTrans:
+ * @am: an automata
+ * @from: the starting point of the transition
+ * @to: the target point of the transition or NULL
+ * @counter: the counter associated to that transition
+ *
+ * If @to is NULL, this create first a new target state in the automata
+ * and then adds an epsilon transition from the @from state to the target state
+ * which will increment the counter provided
+ *
+ * Returns the target state or NULL in case of error
+ */
+xmlAutomataStatePtr
+xmlAutomataNewCountedTrans(xmlAutomataPtr am, xmlAutomataStatePtr from,
+		xmlAutomataStatePtr to, int counter) {
+    if ((am == NULL) || (from == NULL) || (counter < 0))
+	return(NULL);
+    xmlFAGenerateCountedEpsilonTransition(am, from, to, counter);
+    if (to == NULL)
+	return(am->state);
+    return(to);
+}
+
+/**
+ * xmlAutomataNewCounterTrans:
+ * @am: an automata
+ * @from: the starting point of the transition
+ * @to: the target point of the transition or NULL
+ * @counter: the counter associated to that transition
+ *
+ * If @to is NULL, this create first a new target state in the automata
+ * and then adds an epsilon transition from the @from state to the target state
+ * which will be allowed only if the counter is within the right range.
+ *
+ * Returns the target state or NULL in case of error
+ */
+xmlAutomataStatePtr
+xmlAutomataNewCounterTrans(xmlAutomataPtr am, xmlAutomataStatePtr from,
+		xmlAutomataStatePtr to, int counter) {
+    if ((am == NULL) || (from == NULL) || (counter < 0))
+	return(NULL);
+    xmlFAGenerateCountedTransition(am, from, to, counter);
+    if (to == NULL)
+	return(am->state);
+    return(to);
+}
+
+/**
+ * xmlAutomataCompile:
+ * @am: an automata
+ *
+ * Compile the automata into a Reg Exp ready for being executed.
+ * The automata should be free after this point.
+ *
+ * Returns the compiled regexp or NULL in case of error
+ */
+xmlRegexpPtr          
+xmlAutomataCompile(xmlAutomataPtr am) {
+    xmlRegexpPtr ret;
+
+    if ((am == NULL) || (am->error != 0)) return(NULL);
+    xmlFAEliminateEpsilonTransitions(am);
+    /* xmlFAComputesDeterminism(am); */
+    ret = xmlRegEpxFromParse(am);
+
+    return(ret);
+}
+
+/**
+ * xmlAutomataIsDeterminist:
+ * @am: an automata
+ *
+ * Checks if an automata is determinist.
+ *
+ * Returns 1 if true, 0 if not, and -1 in case of error
+ */
+int          
+xmlAutomataIsDeterminist(xmlAutomataPtr am) {
+    int ret;
+
+    if (am == NULL)
+	return(-1);
+
+    ret = xmlFAComputesDeterminism(am);
+    return(ret);
+}
+#endif /* LIBXML_AUTOMATA_ENABLED */
+#endif /* LIBXML_REGEXP_ENABLED */
diff --git a/src/libxml/src/xmlsave.c b/src/libxml/src/xmlsave.c
new file mode 100644
index 0000000..1a60a31
--- /dev/null
+++ b/src/libxml/src/xmlsave.c
@@ -0,0 +1,2011 @@
+/*
+ * xmlsave.c: Implemetation of the document serializer
+ *
+ * See Copyright for the status of this software.
+ *
+ * daniel@veillard.com
+ */
+
+#define IN_LIBXML
+#include "libxml.h"
+
+#include <string.h>
+#include <libxml/xmlmemory.h>
+#include <libxml/parserInternals.h>
+#include <libxml/tree.h>
+#include <libxml/xmlsave.h>
+#ifdef LIBXML_HTML_ENABLED
+#include <libxml/HTMLtree.h>
+
+#define MAX_INDENT 60
+
+/************************************************************************
+ *									*
+ *			XHTML detection					*
+ *									*
+ ************************************************************************/
+#define XHTML_STRICT_PUBLIC_ID BAD_CAST \
+   "-//W3C//DTD XHTML 1.0 Strict//EN"
+#define XHTML_STRICT_SYSTEM_ID BAD_CAST \
+   "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"
+#define XHTML_FRAME_PUBLIC_ID BAD_CAST \
+   "-//W3C//DTD XHTML 1.0 Frameset//EN"
+#define XHTML_FRAME_SYSTEM_ID BAD_CAST \
+   "http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd"
+#define XHTML_TRANS_PUBLIC_ID BAD_CAST \
+   "-//W3C//DTD XHTML 1.0 Transitional//EN"
+#define XHTML_TRANS_SYSTEM_ID BAD_CAST \
+   "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"
+
+#define XHTML_NS_NAME BAD_CAST "http://www.w3.org/1999/xhtml"
+/**
+ * xmlIsXHTML:
+ * @systemID:  the system identifier
+ * @publicID:  the public identifier
+ *
+ * Try to find if the document correspond to an XHTML DTD
+ *
+ * Returns 1 if true, 0 if not and -1 in case of error
+ */
+int
+xmlIsXHTML(const xmlChar *systemID, const xmlChar *publicID) {
+    if ((systemID == NULL) && (publicID == NULL))
+	return(-1);
+    if (publicID != NULL) {
+	if (xmlStrEqual(publicID, XHTML_STRICT_PUBLIC_ID)) return(1);
+	if (xmlStrEqual(publicID, XHTML_FRAME_PUBLIC_ID)) return(1);
+	if (xmlStrEqual(publicID, XHTML_TRANS_PUBLIC_ID)) return(1);
+    }
+    if (systemID != NULL) {
+	if (xmlStrEqual(systemID, XHTML_STRICT_SYSTEM_ID)) return(1);
+	if (xmlStrEqual(systemID, XHTML_FRAME_SYSTEM_ID)) return(1);
+	if (xmlStrEqual(systemID, XHTML_TRANS_SYSTEM_ID)) return(1);
+    }
+    return(0);
+}
+#endif /* LIBXML_HTML_ENABLED */
+
+
+#ifdef LIBXML_OUTPUT_ENABLED
+
+#define TODO 								\
+    xmlGenericError(xmlGenericErrorContext,				\
+	    "Unimplemented block at %s:%d\n",				\
+            __FILE__, __LINE__);
+
+struct _xmlSaveCtxt {
+    void *_private;
+    int type;
+    int fd;
+    const xmlChar *filename;
+    const xmlChar *encoding;
+    xmlCharEncodingHandlerPtr handler;
+    xmlOutputBufferPtr buf;
+    xmlDocPtr doc;
+    int options;
+    int level;
+    int format;
+    char indent[MAX_INDENT + 1];
+    int indent_nr;
+    int indent_size;
+};
+
+/************************************************************************
+ *									*
+ * 			Output error handlers				*
+ *									*
+ ************************************************************************/
+/**
+ * xmlSaveErrMemory:
+ * @extra:  extra informations
+ *
+ * Handle an out of memory condition
+ */
+static void
+xmlSaveErrMemory(const char *extra)
+{
+    __xmlSimpleError(XML_FROM_OUTPUT, XML_ERR_NO_MEMORY, NULL, NULL, extra);
+}
+
+/**
+ * xmlSaveErr:
+ * @code:  the error number
+ * @node:  the location of the error.
+ * @extra:  extra informations
+ *
+ * Handle an out of memory condition
+ */
+static void
+xmlSaveErr(int code, xmlNodePtr node, const char *extra)
+{
+    const char *msg = NULL;
+
+    switch(code) {
+        case XML_SAVE_NOT_UTF8:
+	    msg = "string is not in UTF-8";
+	    break;
+	case XML_SAVE_CHAR_INVALID:
+	    msg = "invalid character value";
+	    break;
+	case XML_SAVE_UNKNOWN_ENCODING:
+	    msg = "unknown encoding %s";
+	    break;
+	case XML_SAVE_NO_DOCTYPE:
+	    msg = "document has no DOCTYPE";
+	    break;
+	default:
+	    msg = "unexpected error number";
+    }
+    __xmlSimpleError(XML_FROM_OUTPUT, code, node, msg, extra);
+}
+
+/************************************************************************
+ *									*
+ *			Allocation and deallocation			*
+ *									*
+ ************************************************************************/
+/**
+ * xmlSaveCtxtInit:
+ * @ctxt: the saving context
+ *
+ * Initialize a saving context
+ */
+static void
+xmlSaveCtxtInit(xmlSaveCtxtPtr ctxt)
+{
+    int i;
+
+    if (ctxt == NULL) return;
+    if (xmlTreeIndentString == NULL) {
+        memset(&ctxt->indent[0], 0, MAX_INDENT + 1);
+    } else {
+	ctxt->indent_size = xmlStrlen((const xmlChar *) xmlTreeIndentString);
+	ctxt->indent_nr = MAX_INDENT / ctxt->indent_size;
+	for (i = 0;i < ctxt->indent_nr;i++)
+	    memcpy(&ctxt->indent[i * ctxt->indent_size], xmlTreeIndentString,
+		   ctxt->indent_size);
+        ctxt->indent[ctxt->indent_nr * ctxt->indent_size] = 0;
+    }
+}
+
+/**
+ * xmlFreeSaveCtxt:
+ *
+ * Free a saving context, destroying the ouptut in any remaining buffer
+ */
+static void
+xmlFreeSaveCtxt(xmlSaveCtxtPtr ctxt)
+{
+    if (ctxt == NULL) return;
+    if (ctxt->encoding != NULL)
+        xmlFree((char *) ctxt->encoding);
+    xmlFree(ctxt);
+}
+
+/**
+ * xmlNewSaveCtxt:
+ *
+ * Create a new saving context
+ *
+ * Returns the new structure or NULL in case of error
+ */
+static xmlSaveCtxtPtr
+xmlNewSaveCtxt(const char *encoding, int options)
+{
+    xmlSaveCtxtPtr ret;
+
+    ret = (xmlSaveCtxtPtr) xmlMalloc(sizeof(xmlSaveCtxt));
+    if (ret == NULL) {
+	xmlSaveErrMemory("creating saving context");
+	return ( NULL );
+    }
+    memset(ret, 0, sizeof(xmlSaveCtxt));
+    ret->options = options;
+    if (encoding != NULL) {
+        ret->handler = xmlFindCharEncodingHandler(encoding);
+	if (ret->handler == NULL) {
+	    xmlSaveErr(XML_SAVE_UNKNOWN_ENCODING, NULL, encoding);
+            xmlFreeSaveCtxt(ret);
+	    return(NULL);
+	}
+        ret->encoding = xmlStrdup((const xmlChar *)encoding);
+    }
+    xmlSaveCtxtInit(ret);
+
+    return(ret);
+}
+
+/************************************************************************
+ *									*
+ *   		Dumping XML tree content to a simple buffer		*
+ *									*
+ ************************************************************************/
+/**
+ * xmlAttrSerializeContent:
+ * @buf:  the XML buffer output
+ * @doc:  the document
+ * @attr:  the attribute pointer
+ *
+ * Serialize the attribute in the buffer
+ */
+static void
+xmlAttrSerializeContent(xmlBufferPtr buf, xmlDocPtr doc, xmlAttrPtr attr)
+{
+    xmlNodePtr children;
+
+    children = attr->children;
+    while (children != NULL) {
+        switch (children->type) {
+            case XML_TEXT_NODE:
+		xmlAttrSerializeTxtContent(buf, doc, attr, children->content);
+		break;
+            case XML_ENTITY_REF_NODE:
+                xmlBufferAdd(buf, BAD_CAST "&", 1);
+                xmlBufferAdd(buf, children->name,
+                             xmlStrlen(children->name));
+                xmlBufferAdd(buf, BAD_CAST ";", 1);
+                break;
+            default:
+                /* should not happen unless we have a badly built tree */
+                break;
+        }
+        children = children->next;
+    }
+}
+
+/************************************************************************
+ *									*
+ *   		Dumping XML tree content to an I/O output buffer	*
+ *									*
+ ************************************************************************/
+
+#ifdef LIBXML_HTML_ENABLED
+static void
+xhtmlNodeDumpOutput(xmlSaveCtxtPtr ctxt, xmlNodePtr cur);
+#endif
+static void xmlNodeListDumpOutput(xmlSaveCtxtPtr ctxt, xmlNodePtr cur);
+static void xmlNodeDumpOutputInternal(xmlSaveCtxtPtr ctxt, xmlNodePtr cur);
+void xmlNsListDumpOutput(xmlOutputBufferPtr buf, xmlNsPtr cur);
+
+/**
+ * xmlNsDumpOutput:
+ * @buf:  the XML buffer output
+ * @cur:  a namespace
+ *
+ * Dump a local Namespace definition.
+ * Should be called in the context of attributes dumps.
+ */
+static void
+xmlNsDumpOutput(xmlOutputBufferPtr buf, xmlNsPtr cur) {
+    if (cur == NULL) return;
+    if ((cur->type == XML_LOCAL_NAMESPACE) && (cur->href != NULL)) {
+	if (xmlStrEqual(cur->prefix, BAD_CAST "xml"))
+	    return;
+
+        /* Within the context of an element attributes */
+	if (cur->prefix != NULL) {
+	    xmlOutputBufferWriteString(buf, " xmlns:");
+	    xmlOutputBufferWriteString(buf, (const char *)cur->prefix);
+	} else
+	    xmlOutputBufferWriteString(buf, " xmlns");
+	xmlOutputBufferWriteString(buf, "=");
+	xmlBufferWriteQuotedString(buf->buffer, cur->href);
+    }
+}
+
+/**
+ * xmlNsListDumpOutput:
+ * @buf:  the XML buffer output
+ * @cur:  the first namespace
+ *
+ * Dump a list of local Namespace definitions.
+ * Should be called in the context of attributes dumps.
+ */
+void
+xmlNsListDumpOutput(xmlOutputBufferPtr buf, xmlNsPtr cur) {
+    while (cur != NULL) {
+        xmlNsDumpOutput(buf, cur);
+	cur = cur->next;
+    }
+}
+
+/**
+ * xmlDtdDumpOutput:
+ * @buf:  the XML buffer output
+ * @dtd:  the pointer to the DTD
+ * 
+ * Dump the XML document DTD, if any.
+ */
+static void
+xmlDtdDumpOutput(xmlSaveCtxtPtr ctxt, xmlDtdPtr dtd) {
+    xmlOutputBufferPtr buf;
+    int format, level;
+    xmlDocPtr doc;
+
+    if (dtd == NULL) return;
+    if ((ctxt == NULL) || (ctxt->buf == NULL))
+        return;
+    buf = ctxt->buf;
+    xmlOutputBufferWriteString(buf, "<!DOCTYPE ");
+    xmlOutputBufferWriteString(buf, (const char *)dtd->name);
+    if (dtd->ExternalID != NULL) {
+	xmlOutputBufferWriteString(buf, " PUBLIC ");
+	xmlBufferWriteQuotedString(buf->buffer, dtd->ExternalID);
+	xmlOutputBufferWriteString(buf, " ");
+	xmlBufferWriteQuotedString(buf->buffer, dtd->SystemID);
+    }  else if (dtd->SystemID != NULL) {
+	xmlOutputBufferWriteString(buf, " SYSTEM ");
+	xmlBufferWriteQuotedString(buf->buffer, dtd->SystemID);
+    }
+    if ((dtd->entities == NULL) && (dtd->elements == NULL) &&
+            (dtd->attributes == NULL) && (dtd->notations == NULL) &&
+	    (dtd->pentities == NULL)) {
+	xmlOutputBufferWriteString(buf, ">");
+	return;
+    }
+    xmlOutputBufferWriteString(buf, " [\n");
+    format = ctxt->format;
+    level = ctxt->level;
+    doc = ctxt->doc;
+    ctxt->format = 0;
+    ctxt->level = -1;
+    ctxt->doc = dtd->doc;
+    xmlNodeListDumpOutput(ctxt, dtd->children);
+    ctxt->format = format;
+    ctxt->level = level;
+    ctxt->doc = doc;
+    xmlOutputBufferWriteString(buf, "]>");
+}
+
+/**
+ * xmlAttrDumpOutput:
+ * @buf:  the XML buffer output
+ * @cur:  the attribute pointer
+ *
+ * Dump an XML attribute
+ */
+static void
+xmlAttrDumpOutput(xmlSaveCtxtPtr ctxt, xmlAttrPtr cur) {
+    xmlOutputBufferPtr buf;
+    if (cur == NULL) return;
+    buf = ctxt->buf;
+    xmlOutputBufferWriteString(buf, " ");
+    if ((cur->ns != NULL) && (cur->ns->prefix != NULL)) {
+        xmlOutputBufferWriteString(buf, (const char *)cur->ns->prefix);
+	xmlOutputBufferWriteString(buf, ":");
+    }
+    xmlOutputBufferWriteString(buf, (const char *)cur->name);
+    xmlOutputBufferWriteString(buf, "=\"");
+    xmlAttrSerializeContent(buf->buffer, ctxt->doc, cur);
+    xmlOutputBufferWriteString(buf, "\"");
+}
+
+/**
+ * xmlAttrListDumpOutput:
+ * @buf:  the XML buffer output
+ * @doc:  the document
+ * @cur:  the first attribute pointer
+ * @encoding:  an optional encoding string
+ *
+ * Dump a list of XML attributes
+ */
+static void
+xmlAttrListDumpOutput(xmlSaveCtxtPtr ctxt, xmlAttrPtr cur) {
+    if (cur == NULL) return;
+    while (cur != NULL) {
+        xmlAttrDumpOutput(ctxt, cur);
+	cur = cur->next;
+    }
+}
+
+
+
+/**
+ * xmlNodeListDumpOutput:
+ * @cur:  the first node
+ *
+ * Dump an XML node list, recursive behaviour, children are printed too.
+ */
+static void
+xmlNodeListDumpOutput(xmlSaveCtxtPtr ctxt, xmlNodePtr cur) {
+    xmlOutputBufferPtr buf;
+
+    if (cur == NULL) return;
+    buf = ctxt->buf;
+    while (cur != NULL) {
+	if ((ctxt->format) && (xmlIndentTreeOutput) &&
+	    (cur->type == XML_ELEMENT_NODE))
+	    xmlOutputBufferWrite(buf, ctxt->indent_size *
+	                         (ctxt->level > ctxt->indent_nr ? 
+				  ctxt->indent_nr : ctxt->level),
+				 ctxt->indent);
+        xmlNodeDumpOutputInternal(ctxt, cur);
+	if (ctxt->format) {
+	    xmlOutputBufferWriteString(buf, "\n");
+	}
+	cur = cur->next;
+    }
+}
+
+/**
+ * xmlNodeDumpOutputInternal:
+ * @cur:  the current node
+ *
+ * Dump an XML node, recursive behaviour, children are printed too.
+ */
+static void
+xmlNodeDumpOutputInternal(xmlSaveCtxtPtr ctxt, xmlNodePtr cur) {
+    int format;
+    xmlNodePtr tmp;
+    xmlChar *start, *end;
+    xmlOutputBufferPtr buf;
+
+    if (cur == NULL) return;
+    buf = ctxt->buf;
+    if (cur->type == XML_XINCLUDE_START)
+	return;
+    if (cur->type == XML_XINCLUDE_END)
+	return;
+    if (cur->type == XML_DTD_NODE) {
+        xmlDtdDumpOutput(ctxt, (xmlDtdPtr) cur);
+	return;
+    }
+    if (cur->type == XML_DOCUMENT_FRAG_NODE) {
+        xmlNodeListDumpOutput(ctxt, cur->children);
+	return;
+    }
+    if (cur->type == XML_ELEMENT_DECL) {
+        xmlDumpElementDecl(buf->buffer, (xmlElementPtr) cur);
+	return;
+    }
+    if (cur->type == XML_ATTRIBUTE_DECL) {
+        xmlDumpAttributeDecl(buf->buffer, (xmlAttributePtr) cur);
+	return;
+    }
+    if (cur->type == XML_ENTITY_DECL) {
+        xmlDumpEntityDecl(buf->buffer, (xmlEntityPtr) cur);
+	return;
+    }
+    if (cur->type == XML_TEXT_NODE) {
+	if (cur->content != NULL) {
+	    if ((cur->name == xmlStringText) ||
+		(cur->name != xmlStringTextNoenc)) {
+		xmlChar *buffer;
+
+		if (ctxt->encoding == NULL)
+		    buffer = xmlEncodeEntitiesReentrant(ctxt->doc,
+		                                        cur->content);
+		else
+		    buffer = xmlEncodeSpecialChars(ctxt->doc, cur->content);
+		if (buffer != NULL) {
+		    xmlOutputBufferWriteString(buf, (const char *)buffer);
+		    xmlFree(buffer);
+		}
+	    } else {
+		/*
+		 * Disable escaping, needed for XSLT
+		 */
+		xmlOutputBufferWriteString(buf, (const char *) cur->content);
+	    }
+	}
+
+	return;
+    }
+    if (cur->type == XML_PI_NODE) {
+	if (cur->content != NULL) {
+	    xmlOutputBufferWriteString(buf, "<?");
+	    xmlOutputBufferWriteString(buf, (const char *)cur->name);
+	    if (cur->content != NULL) {
+		xmlOutputBufferWriteString(buf, " ");
+		xmlOutputBufferWriteString(buf, (const char *)cur->content);
+	    }
+	    xmlOutputBufferWriteString(buf, "?>");
+	} else {
+	    xmlOutputBufferWriteString(buf, "<?");
+	    xmlOutputBufferWriteString(buf, (const char *)cur->name);
+	    xmlOutputBufferWriteString(buf, "?>");
+	}
+	return;
+    }
+    if (cur->type == XML_COMMENT_NODE) {
+	if (cur->content != NULL) {
+	    xmlOutputBufferWriteString(buf, "<!--");
+	    xmlOutputBufferWriteString(buf, (const char *)cur->content);
+	    xmlOutputBufferWriteString(buf, "-->");
+	}
+	return;
+    }
+    if (cur->type == XML_ENTITY_REF_NODE) {
+        xmlOutputBufferWriteString(buf, "&");
+	xmlOutputBufferWriteString(buf, (const char *)cur->name);
+        xmlOutputBufferWriteString(buf, ";");
+	return;
+    }
+    if (cur->type == XML_CDATA_SECTION_NODE) {
+	start = end = cur->content;
+	while (*end != '\0') {
+	    if ((*end == ']') && (*(end + 1) == ']') && (*(end + 2) == '>')) {
+		end = end + 2;
+		xmlOutputBufferWriteString(buf, "<![CDATA[");
+		xmlOutputBufferWrite(buf, end - start, (const char *)start);
+		xmlOutputBufferWriteString(buf, "]]>");
+		start = end;
+	    }
+	    end++;
+	}
+	if (start != end) {
+	    xmlOutputBufferWriteString(buf, "<![CDATA[");
+	    xmlOutputBufferWriteString(buf, (const char *)start);
+	    xmlOutputBufferWriteString(buf, "]]>");
+	}
+	return;
+    }
+    if (cur->type == XML_ATTRIBUTE_NODE) {
+	xmlAttrDumpOutput(ctxt, (xmlAttrPtr) cur);
+	return;
+    }
+    if (cur->type == XML_NAMESPACE_DECL) {
+	xmlNsDumpOutput(buf, (xmlNsPtr) cur);
+	return;
+    }
+
+    format = ctxt->format;
+    if (format == 1) {
+	tmp = cur->children;
+	while (tmp != NULL) {
+	    if ((tmp->type == XML_TEXT_NODE) ||
+		(tmp->type == XML_CDATA_SECTION_NODE) ||
+		(tmp->type == XML_ENTITY_REF_NODE)) {
+		ctxt->format = 0;
+		break;
+	    }
+	    tmp = tmp->next;
+	}
+    }
+    xmlOutputBufferWriteString(buf, "<");
+    if ((cur->ns != NULL) && (cur->ns->prefix != NULL)) {
+        xmlOutputBufferWriteString(buf, (const char *)cur->ns->prefix);
+	xmlOutputBufferWriteString(buf, ":");
+    }
+
+    xmlOutputBufferWriteString(buf, (const char *)cur->name);
+    if (cur->nsDef)
+        xmlNsListDumpOutput(buf, cur->nsDef);
+    if (cur->properties != NULL)
+        xmlAttrListDumpOutput(ctxt, cur->properties);
+
+    if (((cur->type == XML_ELEMENT_NODE) || (cur->content == NULL)) &&
+	(cur->children == NULL) && (!xmlSaveNoEmptyTags)) {
+        xmlOutputBufferWriteString(buf, "/>");
+	ctxt->format = format;
+	return;
+    }
+    xmlOutputBufferWriteString(buf, ">");
+    if ((cur->type != XML_ELEMENT_NODE) && (cur->content != NULL)) {
+	xmlChar *buffer;
+
+	if (ctxt->encoding == NULL)
+	    buffer = xmlEncodeEntitiesReentrant(ctxt->doc, cur->content);
+	else
+	    buffer = xmlEncodeSpecialChars(ctxt->doc, cur->content);
+	if (buffer != NULL) {
+	    xmlOutputBufferWriteString(buf, (const char *)buffer);
+	    xmlFree(buffer);
+	}
+    }
+    if (cur->children != NULL) {
+	if (ctxt->format) xmlOutputBufferWriteString(buf, "\n");
+	if (ctxt->level >= 0) ctxt->level++;
+	xmlNodeListDumpOutput(ctxt, cur->children);
+	if (ctxt->level > 0) ctxt->level--;
+	if ((xmlIndentTreeOutput) && (ctxt->format))
+	    xmlOutputBufferWrite(buf, ctxt->indent_size *
+	                         (ctxt->level > ctxt->indent_nr ? 
+				  ctxt->indent_nr : ctxt->level),
+				 ctxt->indent);
+    }
+    xmlOutputBufferWriteString(buf, "</");
+    if ((cur->ns != NULL) && (cur->ns->prefix != NULL)) {
+        xmlOutputBufferWriteString(buf, (const char *)cur->ns->prefix);
+	xmlOutputBufferWriteString(buf, ":");
+    }
+
+    xmlOutputBufferWriteString(buf, (const char *)cur->name);
+    xmlOutputBufferWriteString(buf, ">");
+    ctxt->format = format;
+}
+
+/**
+ * xmlDocContentDumpOutput:
+ * @cur:  the document
+ *
+ * Dump an XML document.
+ */
+static void
+xmlDocContentDumpOutput(xmlSaveCtxtPtr ctxt, xmlDocPtr cur) {
+#ifdef LIBXML_HTML_ENABLED
+    xmlDtdPtr dtd;
+    int is_xhtml = 0;
+#endif
+    const xmlChar *oldenc = cur->encoding;
+    const xmlChar *encoding = ctxt->encoding;
+    xmlOutputBufferPtr buf;
+
+    xmlInitParser();
+
+    if (ctxt->encoding != NULL)
+        cur->encoding = BAD_CAST ctxt->encoding;
+
+    buf = ctxt->buf;
+    xmlOutputBufferWriteString(buf, "<?xml version=");
+    if (cur->version != NULL) 
+	xmlBufferWriteQuotedString(buf->buffer, cur->version);
+    else
+	xmlOutputBufferWriteString(buf, "\"1.0\"");
+    if (ctxt->encoding == NULL) {
+	if (cur->encoding != NULL)
+	    encoding = cur->encoding;
+	else if (cur->charset != XML_CHAR_ENCODING_UTF8)
+	    encoding = (const xmlChar *)
+	         xmlGetCharEncodingName((xmlCharEncoding) cur->charset);
+    }
+    if (encoding != NULL) {
+        xmlOutputBufferWriteString(buf, " encoding=");
+	xmlBufferWriteQuotedString(buf->buffer, (xmlChar *) encoding);
+    }
+    switch (cur->standalone) {
+        case 0:
+	    xmlOutputBufferWriteString(buf, " standalone=\"no\"");
+	    break;
+        case 1:
+	    xmlOutputBufferWriteString(buf, " standalone=\"yes\"");
+	    break;
+    }
+    xmlOutputBufferWriteString(buf, "?>\n");
+
+#ifdef LIBXML_HTML_ENABLED
+    dtd = xmlGetIntSubset(cur);
+    if (dtd != NULL) {
+	is_xhtml = xmlIsXHTML(dtd->SystemID, dtd->ExternalID);
+	if (is_xhtml < 0) is_xhtml = 0;
+    }
+    if (is_xhtml) {
+	if (encoding != NULL)
+	    htmlSetMetaEncoding(cur, (const xmlChar *) ctxt->encoding);
+	else
+	    htmlSetMetaEncoding(cur, BAD_CAST "UTF-8");
+    }
+#endif
+    if (cur->children != NULL) {
+        xmlNodePtr child = cur->children;
+
+	while (child != NULL) {
+	    ctxt->level = 0;
+#ifdef LIBXML_HTML_ENABLED
+	    if (is_xhtml)
+		xhtmlNodeDumpOutput(ctxt, child);
+	    else
+#endif
+		xmlNodeDumpOutputInternal(ctxt, child);
+	    xmlOutputBufferWriteString(buf, "\n");
+	    child = child->next;
+	}
+    }
+    if (ctxt->encoding != NULL)
+        cur->encoding = oldenc;
+}
+
+#ifdef LIBXML_HTML_ENABLED
+/************************************************************************
+ *									*
+ *		Functions specific to XHTML serialization		*
+ *									*
+ ************************************************************************/
+
+/**
+ * xhtmlIsEmpty:
+ * @node:  the node
+ *
+ * Check if a node is an empty xhtml node
+ *
+ * Returns 1 if the node is an empty node, 0 if not and -1 in case of error
+ */
+static int
+xhtmlIsEmpty(xmlNodePtr node) {
+    if (node == NULL)
+	return(-1);
+    if (node->type != XML_ELEMENT_NODE)
+	return(0);
+    if ((node->ns != NULL) && (!xmlStrEqual(node->ns->href, XHTML_NS_NAME)))
+	return(0);
+    if (node->children != NULL)
+	return(0);
+    switch (node->name[0]) {
+	case 'a':
+	    if (xmlStrEqual(node->name, BAD_CAST "area"))
+		return(1);
+	    return(0);
+	case 'b':
+	    if (xmlStrEqual(node->name, BAD_CAST "br"))
+		return(1);
+	    if (xmlStrEqual(node->name, BAD_CAST "base"))
+		return(1);
+	    if (xmlStrEqual(node->name, BAD_CAST "basefont"))
+		return(1);
+	    return(0);
+	case 'c':
+	    if (xmlStrEqual(node->name, BAD_CAST "col"))
+		return(1);
+	    return(0);
+	case 'f':
+	    if (xmlStrEqual(node->name, BAD_CAST "frame"))
+		return(1);
+	    return(0);
+	case 'h':
+	    if (xmlStrEqual(node->name, BAD_CAST "hr"))
+		return(1);
+	    return(0);
+	case 'i':
+	    if (xmlStrEqual(node->name, BAD_CAST "img"))
+		return(1);
+	    if (xmlStrEqual(node->name, BAD_CAST "input"))
+		return(1);
+	    if (xmlStrEqual(node->name, BAD_CAST "isindex"))
+		return(1);
+	    return(0);
+	case 'l':
+	    if (xmlStrEqual(node->name, BAD_CAST "link"))
+		return(1);
+	    return(0);
+	case 'm':
+	    if (xmlStrEqual(node->name, BAD_CAST "meta"))
+		return(1);
+	    return(0);
+	case 'p':
+	    if (xmlStrEqual(node->name, BAD_CAST "param"))
+		return(1);
+	    return(0);
+    }
+    return(0);
+}
+
+/**
+ * xhtmlAttrListDumpOutput:
+ * @cur:  the first attribute pointer
+ *
+ * Dump a list of XML attributes
+ */
+static void
+xhtmlAttrListDumpOutput(xmlSaveCtxtPtr ctxt, xmlAttrPtr cur) {
+    xmlAttrPtr xml_lang = NULL;
+    xmlAttrPtr lang = NULL;
+    xmlAttrPtr name = NULL;
+    xmlAttrPtr id = NULL;
+    xmlNodePtr parent;
+    xmlOutputBufferPtr buf;
+
+    if (cur == NULL) return;
+    buf = ctxt->buf;
+    parent = cur->parent;
+    while (cur != NULL) {
+	if ((cur->ns == NULL) && (xmlStrEqual(cur->name, BAD_CAST "id")))
+	    id = cur;
+	else
+	if ((cur->ns == NULL) && (xmlStrEqual(cur->name, BAD_CAST "name")))
+	    name = cur;
+	else
+	if ((cur->ns == NULL) && (xmlStrEqual(cur->name, BAD_CAST "lang")))
+	    lang = cur;
+	else
+	if ((cur->ns != NULL) && (xmlStrEqual(cur->name, BAD_CAST "lang")) &&
+	    (xmlStrEqual(cur->ns->prefix, BAD_CAST "xml")))
+	    xml_lang = cur;
+	else if ((cur->ns == NULL) && 
+		 ((cur->children == NULL) ||
+		  (cur->children->content == NULL) ||
+		  (cur->children->content[0] == 0)) &&
+		 (htmlIsBooleanAttr(cur->name))) {
+	    if (cur->children != NULL)
+		xmlFreeNode(cur->children);
+	    cur->children = xmlNewText(cur->name);
+	    if (cur->children != NULL)
+		cur->children->parent = (xmlNodePtr) cur;
+	}
+        xmlAttrDumpOutput(ctxt, cur);
+	cur = cur->next;
+    }
+    /*
+     * C.8
+     */
+    if ((name != NULL) && (id == NULL)) {
+	if ((parent != NULL) && (parent->name != NULL) &&
+	    ((xmlStrEqual(parent->name, BAD_CAST "a")) ||
+	     (xmlStrEqual(parent->name, BAD_CAST "p")) ||
+	     (xmlStrEqual(parent->name, BAD_CAST "div")) ||
+	     (xmlStrEqual(parent->name, BAD_CAST "img")) ||
+	     (xmlStrEqual(parent->name, BAD_CAST "map")) ||
+	     (xmlStrEqual(parent->name, BAD_CAST "applet")) ||
+	     (xmlStrEqual(parent->name, BAD_CAST "form")) ||
+	     (xmlStrEqual(parent->name, BAD_CAST "frame")) ||
+	     (xmlStrEqual(parent->name, BAD_CAST "iframe")))) {
+	    xmlOutputBufferWriteString(buf, " id=\"");
+	    xmlAttrSerializeContent(buf->buffer, ctxt->doc, name);
+	    xmlOutputBufferWriteString(buf, "\"");
+	}
+    }
+    /*
+     * C.7.
+     */
+    if ((lang != NULL) && (xml_lang == NULL)) {
+	xmlOutputBufferWriteString(buf, " xml:lang=\"");
+	xmlAttrSerializeContent(buf->buffer, ctxt->doc, lang);
+	xmlOutputBufferWriteString(buf, "\"");
+    } else 
+    if ((xml_lang != NULL) && (lang == NULL)) {
+	xmlOutputBufferWriteString(buf, " lang=\"");
+	xmlAttrSerializeContent(buf->buffer, ctxt->doc, xml_lang);
+	xmlOutputBufferWriteString(buf, "\"");
+    }
+}
+
+/**
+ * xhtmlNodeListDumpOutput:
+ * @buf:  the XML buffer output
+ * @doc:  the XHTML document
+ * @cur:  the first node
+ * @level: the imbrication level for indenting
+ * @format: is formatting allowed
+ * @encoding:  an optional encoding string
+ *
+ * Dump an XML node list, recursive behaviour, children are printed too.
+ * Note that @format = 1 provide node indenting only if xmlIndentTreeOutput = 1
+ * or xmlKeepBlanksDefault(0) was called
+ */
+static void
+xhtmlNodeListDumpOutput(xmlSaveCtxtPtr ctxt, xmlNodePtr cur) {
+    xmlOutputBufferPtr buf;
+
+    if (cur == NULL) return;
+    buf = ctxt->buf;
+    while (cur != NULL) {
+	if ((ctxt->format) && (xmlIndentTreeOutput) &&
+	    (cur->type == XML_ELEMENT_NODE))
+	    xmlOutputBufferWrite(buf, ctxt->indent_size *
+	                         (ctxt->level > ctxt->indent_nr ? 
+				  ctxt->indent_nr : ctxt->level),
+				 ctxt->indent);
+        xhtmlNodeDumpOutput(ctxt, cur);
+	if (ctxt->format) {
+	    xmlOutputBufferWriteString(buf, "\n");
+	}
+	cur = cur->next;
+    }
+}
+
+/**
+ * xhtmlNodeDumpOutput:
+ * @buf:  the XML buffer output
+ * @doc:  the XHTML document
+ * @cur:  the current node
+ * @level: the imbrication level for indenting
+ * @format: is formatting allowed
+ * @encoding:  an optional encoding string
+ *
+ * Dump an XHTML node, recursive behaviour, children are printed too.
+ */
+static void
+xhtmlNodeDumpOutput(xmlSaveCtxtPtr ctxt, xmlNodePtr cur) {
+    int format;
+    xmlNodePtr tmp;
+    xmlChar *start, *end;
+    xmlOutputBufferPtr buf;
+
+    if (cur == NULL) return;
+    if (cur->type == XML_XINCLUDE_START)
+	return;
+    if (cur->type == XML_XINCLUDE_END)
+	return;
+    if (cur->type == XML_DTD_NODE) {
+        xmlDtdDumpOutput(ctxt, (xmlDtdPtr) cur);
+	return;
+    }
+    buf = ctxt->buf;
+    if (cur->type == XML_ELEMENT_DECL) {
+        xmlDumpElementDecl(buf->buffer, (xmlElementPtr) cur);
+	return;
+    }
+    if (cur->type == XML_ATTRIBUTE_DECL) {
+        xmlDumpAttributeDecl(buf->buffer, (xmlAttributePtr) cur);
+	return;
+    }
+    if (cur->type == XML_ENTITY_DECL) {
+        xmlDumpEntityDecl(buf->buffer, (xmlEntityPtr) cur);
+	return;
+    }
+    if (cur->type == XML_TEXT_NODE) {
+	if (cur->content != NULL) {
+	    if ((cur->name == xmlStringText) ||
+		(cur->name != xmlStringTextNoenc)) {
+		xmlChar *buffer;
+
+		if (ctxt->encoding == NULL)
+		    buffer = xmlEncodeEntitiesReentrant(ctxt->doc,
+		                                        cur->content);
+		else
+		    buffer = xmlEncodeSpecialChars(ctxt->doc, cur->content);
+		if (buffer != NULL) {
+		    xmlOutputBufferWriteString(buf, (const char *)buffer);
+		    xmlFree(buffer);
+		}
+	    } else {
+		/*
+		 * Disable escaping, needed for XSLT
+		 */
+		xmlOutputBufferWriteString(buf, (const char *) cur->content);
+	    }
+	}
+
+	return;
+    }
+    if (cur->type == XML_PI_NODE) {
+	if (cur->content != NULL) {
+	    xmlOutputBufferWriteString(buf, "<?");
+	    xmlOutputBufferWriteString(buf, (const char *)cur->name);
+	    if (cur->content != NULL) {
+		xmlOutputBufferWriteString(buf, " ");
+		xmlOutputBufferWriteString(buf, (const char *)cur->content);
+	    }
+	    xmlOutputBufferWriteString(buf, "?>");
+	} else {
+	    xmlOutputBufferWriteString(buf, "<?");
+	    xmlOutputBufferWriteString(buf, (const char *)cur->name);
+	    xmlOutputBufferWriteString(buf, "?>");
+	}
+	return;
+    }
+    if (cur->type == XML_COMMENT_NODE) {
+	if (cur->content != NULL) {
+	    xmlOutputBufferWriteString(buf, "<!--");
+	    xmlOutputBufferWriteString(buf, (const char *)cur->content);
+	    xmlOutputBufferWriteString(buf, "-->");
+	}
+	return;
+    }
+    if (cur->type == XML_ENTITY_REF_NODE) {
+        xmlOutputBufferWriteString(buf, "&");
+	xmlOutputBufferWriteString(buf, (const char *)cur->name);
+        xmlOutputBufferWriteString(buf, ";");
+	return;
+    }
+    if (cur->type == XML_CDATA_SECTION_NODE) {
+	start = end = cur->content;
+	while (*end != '\0') {
+	    if (*end == ']' && *(end + 1) == ']' && *(end + 2) == '>') {
+		end = end + 2;
+		xmlOutputBufferWriteString(buf, "<![CDATA[");
+		xmlOutputBufferWrite(buf, end - start, (const char *)start);
+		xmlOutputBufferWriteString(buf, "]]>");
+		start = end;
+	    }
+	    end++;
+	}
+	if (start != end) {
+	    xmlOutputBufferWriteString(buf, "<![CDATA[");
+	    xmlOutputBufferWriteString(buf, (const char *)start);
+	    xmlOutputBufferWriteString(buf, "]]>");
+	}
+	return;
+    }
+
+    format = ctxt->format;
+    if (format == 1) {
+	tmp = cur->children;
+	while (tmp != NULL) {
+	    if ((tmp->type == XML_TEXT_NODE) || 
+		(tmp->type == XML_ENTITY_REF_NODE)) {
+		format = 0;
+		break;
+	    }
+	    tmp = tmp->next;
+	}
+    }
+    xmlOutputBufferWriteString(buf, "<");
+    if ((cur->ns != NULL) && (cur->ns->prefix != NULL)) {
+        xmlOutputBufferWriteString(buf, (const char *)cur->ns->prefix);
+	xmlOutputBufferWriteString(buf, ":");
+    }
+
+    xmlOutputBufferWriteString(buf, (const char *)cur->name);
+    if (cur->nsDef)
+        xmlNsListDumpOutput(buf, cur->nsDef);
+    if ((xmlStrEqual(cur->name, BAD_CAST "html") &&
+	(cur->ns == NULL) && (cur->nsDef == NULL))) {
+	/*
+	 * 3.1.1. Strictly Conforming Documents A.3.1.1 3/
+	 */
+	xmlOutputBufferWriteString(buf,
+		" xmlns=\"http://www.w3.org/1999/xhtml\"");
+    }
+    if (cur->properties != NULL)
+        xhtmlAttrListDumpOutput(ctxt, cur->properties);
+
+    if ((cur->type == XML_ELEMENT_NODE) && (cur->children == NULL)) {
+	if (((cur->ns == NULL) || (cur->ns->prefix == NULL)) &&
+	    (xhtmlIsEmpty(cur) == 1)) {
+	    /*
+	     * C.2. Empty Elements
+	     */
+	    xmlOutputBufferWriteString(buf, " />");
+	} else {
+	    /*
+	     * C.3. Element Minimization and Empty Element Content
+	     */
+	    xmlOutputBufferWriteString(buf, "></");
+	    if ((cur->ns != NULL) && (cur->ns->prefix != NULL)) {
+		xmlOutputBufferWriteString(buf, (const char *)cur->ns->prefix);
+		xmlOutputBufferWriteString(buf, ":");
+	    }
+	    xmlOutputBufferWriteString(buf, (const char *)cur->name);
+	    xmlOutputBufferWriteString(buf, ">");
+	}
+	return;
+    }
+    xmlOutputBufferWriteString(buf, ">");
+    if ((cur->type != XML_ELEMENT_NODE) && (cur->content != NULL)) {
+	xmlChar *buffer;
+
+	if (ctxt->encoding == NULL)
+	    buffer = xmlEncodeEntitiesReentrant(ctxt->doc, cur->content);
+	else
+	    buffer = xmlEncodeSpecialChars(ctxt->doc, cur->content);
+	if (buffer != NULL) {
+	    xmlOutputBufferWriteString(buf, (const char *)buffer);
+	    xmlFree(buffer);
+	}
+    }
+
+    /*
+     * 4.8. Script and Style elements
+     */
+    if ((cur->type == XML_ELEMENT_NODE) &&
+	((xmlStrEqual(cur->name, BAD_CAST "script")) ||
+	 (xmlStrEqual(cur->name, BAD_CAST "style"))) &&
+	((cur->ns == NULL) ||
+	 (xmlStrEqual(cur->ns->href, XHTML_NS_NAME)))) {
+	xmlNodePtr child = cur->children;
+
+	while (child != NULL) {
+	    if ((child->type == XML_TEXT_NODE) ||
+		(child->type == XML_CDATA_SECTION_NODE)) {
+		/*
+		 * Apparently CDATA escaping for style just break on IE,
+		 * mozilla and galeon, so ...
+		 */
+		if (xmlStrEqual(cur->name, BAD_CAST "style") &&
+		    (xmlStrchr(child->content, '<') == NULL) &&
+		    (xmlStrchr(child->content, '>') == NULL) &&
+		    (xmlStrchr(child->content, '&') == NULL)) {
+		    int level = ctxt->level;
+		    int indent = ctxt->format;
+
+		    ctxt->level = 0;
+		    ctxt->format = 0;
+		    xhtmlNodeDumpOutput(ctxt, child);
+		    ctxt->level = level;
+		    ctxt->format = indent;
+		} else {
+		    start = end = child->content;
+		    while (*end != '\0') {
+			if (*end == ']' &&
+			    *(end + 1) == ']' &&
+			    *(end + 2) == '>') {
+			    end = end + 2;
+			    xmlOutputBufferWriteString(buf, "<![CDATA[");
+			    xmlOutputBufferWrite(buf, end - start,
+						 (const char *)start);
+			    xmlOutputBufferWriteString(buf, "]]>");
+			    start = end;
+			}
+			end++;
+		    }
+		    if (start != end) {
+			xmlOutputBufferWriteString(buf, "<![CDATA[");
+			xmlOutputBufferWriteString(buf, (const char *)start);
+			xmlOutputBufferWriteString(buf, "]]>");
+		    }
+		}
+	    } else {
+		int level = ctxt->level;
+		int indent = ctxt->format;
+
+		ctxt->level = 0;
+		ctxt->format = 0;
+		xhtmlNodeDumpOutput(ctxt, child);
+		ctxt->level = level;
+		ctxt->format = indent;
+	    }
+	    child = child->next;
+	}
+    } else if (cur->children != NULL) {
+	if (format) xmlOutputBufferWriteString(buf, "\n");
+	if (ctxt->level >= 0) ctxt->level++;
+	xhtmlNodeListDumpOutput(ctxt, cur->children);
+	if (ctxt->level > 0) ctxt->level--;
+	if ((xmlIndentTreeOutput) && (format))
+	    xmlOutputBufferWrite(buf, ctxt->indent_size *
+	                         (ctxt->level > ctxt->indent_nr ? 
+				  ctxt->indent_nr : ctxt->level),
+				 ctxt->indent);
+    }
+    xmlOutputBufferWriteString(buf, "</");
+    if ((cur->ns != NULL) && (cur->ns->prefix != NULL)) {
+        xmlOutputBufferWriteString(buf, (const char *)cur->ns->prefix);
+	xmlOutputBufferWriteString(buf, ":");
+    }
+
+    xmlOutputBufferWriteString(buf, (const char *)cur->name);
+    xmlOutputBufferWriteString(buf, ">");
+}
+#endif
+
+/************************************************************************
+ *									*
+ *			Public entry points				*
+ *									*
+ ************************************************************************/
+
+/**
+ * xmlSaveToFd:
+ * @fd:  a file descriptor number
+ * @encoding:  the encoding name to use or NULL
+ * @options:  a set of xmlSaveOptions
+ *
+ * Create a document saving context serializing to a file descriptor
+ * with the encoding and the options given.
+ *
+ * Returns a new serialization context or NULL in case of error.
+ */
+xmlSaveCtxtPtr
+xmlSaveToFd(int fd, const char *encoding, int options)
+{
+    xmlSaveCtxtPtr ret;
+
+    ret = xmlNewSaveCtxt(encoding, options);
+    if (ret == NULL) return(NULL);
+    ret->buf = xmlOutputBufferCreateFd(fd, ret->handler);
+    if (ret->buf == NULL) {
+	xmlFreeSaveCtxt(ret);
+	return(NULL);
+    }
+    return(ret);
+}
+
+/**
+ * xmlSaveToFilename:
+ * @filename:  a file name or an URL
+ * @encoding:  the encoding name to use or NULL
+ * @options:  a set of xmlSaveOptions
+ *
+ * Create a document saving context serializing to a filename or possibly
+ * to an URL (but this is less reliable) with the encoding and the options
+ * given.
+ *
+ * Returns a new serialization context or NULL in case of error.
+ */
+xmlSaveCtxtPtr
+xmlSaveToFilename(const char *filename, const char *encoding, int options)
+{
+    xmlSaveCtxtPtr ret;
+    int compression = 0; /* TODO handle compression option */
+
+    ret = xmlNewSaveCtxt(encoding, options);
+    if (ret == NULL) return(NULL);
+    ret->buf = xmlOutputBufferCreateFilename(filename, ret->handler,
+                                             compression);
+    if (ret->buf == NULL) {
+	xmlFreeSaveCtxt(ret);
+	return(NULL);
+    }
+    return(ret);
+}
+
+#if 0
+/**
+ * xmlSaveToBuffer:
+ * @buffer:  a buffer
+ * @encoding:  the encoding name to use or NULL
+ * @options:  a set of xmlSaveOptions
+ *
+ * Create a document saving context serializing to a buffer
+ * with the encoding and the options given
+ *
+ * Returns a new serialization context or NULL in case of error.
+ */
+xmlSaveCtxtPtr
+xmlSaveToBuffer(xmlBufferPtr buffer, const char *encoding, int options)
+{
+    TODO
+    return(NULL);
+}
+#endif
+
+/**
+ * xmlSaveToIO:
+ * @iowrite:  an I/O write function
+ * @ioclose:  an I/O close function
+ * @ioctx:  an I/O handler
+ * @encoding:  the encoding name to use or NULL
+ * @options:  a set of xmlSaveOptions
+ *
+ * Create a document saving context serializing to a file descriptor
+ * with the encoding and the options given
+ *
+ * Returns a new serialization context or NULL in case of error.
+ */
+xmlSaveCtxtPtr
+xmlSaveToIO(xmlOutputWriteCallback iowrite,
+            xmlOutputCloseCallback ioclose,
+            void *ioctx, const char *encoding, int options)
+{
+    xmlSaveCtxtPtr ret;
+
+    ret = xmlNewSaveCtxt(encoding, options);
+    if (ret == NULL) return(NULL);
+    ret->buf = xmlOutputBufferCreateIO(iowrite, ioclose, ioctx, ret->handler);
+    if (ret->buf == NULL) {
+	xmlFreeSaveCtxt(ret);
+	return(NULL);
+    }
+    return(ret);
+}
+
+/**
+ * xmlSaveDoc:
+ * @ctxt:  a document saving context
+ * @doc:  a document
+ *
+ * Save a full document to a saving context
+ * TODO: The function is not fully implemented yet as it does not return the
+ * byte count but 0 instead
+ *
+ * Returns the number of byte written or -1 in case of error
+ */
+long
+xmlSaveDoc(xmlSaveCtxtPtr ctxt, xmlDocPtr doc)
+{
+    long ret = 0;
+
+    xmlDocContentDumpOutput(ctxt, doc);
+    return(ret);
+}
+
+/**
+ * xmlSaveTree:
+ * @ctxt:  a document saving context
+ * @node:  a document
+ *
+ * Save a subtree starting at the node parameter to a saving context
+ * TODO: The function is not fully implemented yet as it does not return the
+ * byte count but 0 instead
+ *
+ * Returns the number of byte written or -1 in case of error
+ */
+long
+xmlSaveTree(xmlSaveCtxtPtr ctxt, xmlNodePtr node)
+{
+    long ret = 0;
+
+    xmlNodeDumpOutputInternal(ctxt, node);
+    return(ret);
+}
+
+/**
+ * xmlSaveFlush:
+ * @ctxt:  a document saving context
+ *
+ * Flush a document saving context, i.e. make sure that all bytes have
+ * been output.
+ *
+ * Returns the number of byte written or -1 in case of error.
+ */
+int
+xmlSaveFlush(xmlSaveCtxtPtr ctxt)
+{
+    if (ctxt == NULL) return(-1);
+    if (ctxt->buf == NULL) return(-1);
+    return(xmlOutputBufferFlush(ctxt->buf));
+}
+
+/**
+ * xmlSaveClose:
+ * @ctxt:  a document saving context
+ *
+ * Close a document saving context, i.e. make sure that all bytes have
+ * been output and free the associated data.
+ *
+ * Returns the number of byte written or -1 in case of error.
+ */
+int
+xmlSaveClose(xmlSaveCtxtPtr ctxt)
+{
+    int ret;
+
+    if (ctxt == NULL) return(-1);
+    ret = xmlSaveFlush(ctxt);
+    xmlFreeSaveCtxt(ctxt);
+    return(ret);
+}
+
+/************************************************************************
+ *									*
+ *		Public entry points based on buffers			*
+ *									*
+ ************************************************************************/
+/**
+ * xmlAttrSerializeTxtContent:
+ * @buf:  the XML buffer output
+ * @doc:  the document
+ * @attr: the attribute node
+ * @string: the text content
+ *
+ * Serialize text attribute values to an xml simple buffer
+ */
+void
+xmlAttrSerializeTxtContent(xmlBufferPtr buf, xmlDocPtr doc,
+        xmlAttrPtr attr, const xmlChar *string) {
+    xmlChar *base, *cur;
+
+    if (string == NULL) return;
+    base = cur = (xmlChar *)string;
+    while (*cur != 0) {
+        if (*cur == '\n') {
+            if (base != cur)
+                xmlBufferAdd(buf, base, cur - base);
+            xmlBufferAdd(buf, BAD_CAST "&#10;", 5);
+            cur++;
+            base = cur;
+            } else if (*cur == '\r') {
+                if (base != cur)
+                    xmlBufferAdd(buf, base, cur - base);
+                xmlBufferAdd(buf, BAD_CAST "&#13;", 5);
+                cur++;
+                base = cur;
+            } else if (*cur == '\t') {
+                if (base != cur)
+                    xmlBufferAdd(buf, base, cur - base);
+                xmlBufferAdd(buf, BAD_CAST "&#9;", 4);
+                cur++;
+                base = cur;
+            } else if (*cur == '"') {
+                if (base != cur)
+                    xmlBufferAdd(buf, base, cur - base);
+                xmlBufferAdd(buf, BAD_CAST "&quot;", 6);
+                cur++;
+                base = cur;
+            } else if (*cur == '<') {
+                if (base != cur)
+                    xmlBufferAdd(buf, base, cur - base);
+                xmlBufferAdd(buf, BAD_CAST "&lt;", 4);
+                cur++;
+                base = cur;
+            } else if (*cur == '>') {
+                if (base != cur)
+                    xmlBufferAdd(buf, base, cur - base);
+                xmlBufferAdd(buf, BAD_CAST "&gt;", 4);
+                cur++;
+                base = cur;
+            } else if (*cur == '&') {
+                if (base != cur)
+                    xmlBufferAdd(buf, base, cur - base);
+                xmlBufferAdd(buf, BAD_CAST "&amp;", 5);
+                cur++;
+                base = cur;
+            } else if ((*cur >= 0x80) && ((doc == NULL) ||
+                          (doc->encoding == NULL))) {
+                /*
+                 * We assume we have UTF-8 content.
+                 */
+                char tmp[10];
+                int val = 0, l = 1;
+
+                if (base != cur)
+                    xmlBufferAdd(buf, base, cur - base);
+                if (*cur < 0xC0) {
+		    xmlSaveErr(XML_SAVE_NOT_UTF8, (xmlNodePtr) attr, NULL);
+                    if (doc != NULL)
+                        doc->encoding = xmlStrdup(BAD_CAST "ISO-8859-1");
+                    snprintf(tmp, sizeof(tmp), "&#%d;", *cur);
+                    tmp[sizeof(tmp) - 1] = 0;
+                    xmlBufferAdd(buf, (xmlChar *) tmp, -1);
+                    cur++;
+                    base = cur;
+                    continue;
+                } else if (*cur < 0xE0) {
+                    val = (cur[0]) & 0x1F;
+                    val <<= 6;
+                    val |= (cur[1]) & 0x3F;
+                    l = 2;
+                } else if (*cur < 0xF0) {
+                    val = (cur[0]) & 0x0F;
+                    val <<= 6;
+                    val |= (cur[1]) & 0x3F;
+                    val <<= 6;
+                    val |= (cur[2]) & 0x3F;
+                    l = 3;
+                } else if (*cur < 0xF8) {
+                    val = (cur[0]) & 0x07;
+                    val <<= 6;
+                    val |= (cur[1]) & 0x3F;
+                    val <<= 6;
+                    val |= (cur[2]) & 0x3F;
+                    val <<= 6;
+                    val |= (cur[3]) & 0x3F;
+                    l = 4;
+                }
+                if ((l == 1) || (!IS_CHAR(val))) {
+		    xmlSaveErr(XML_SAVE_CHAR_INVALID, (xmlNodePtr) attr, NULL);
+                    if (doc != NULL)
+                        doc->encoding = xmlStrdup(BAD_CAST "ISO-8859-1");
+                    snprintf(tmp, sizeof(tmp), "&#%d;", *cur);
+                    tmp[sizeof(tmp) - 1] = 0;
+                    xmlBufferAdd(buf, (xmlChar *) tmp, -1);
+                    cur++;
+                    base = cur;
+                    continue;
+                }
+                /*
+                 * We could do multiple things here. Just save
+                 * as a char ref
+                 */
+                snprintf(tmp, sizeof(tmp), "&#x%X;", val);
+                tmp[sizeof(tmp) - 1] = 0;
+                xmlBufferAdd(buf, (xmlChar *) tmp, -1);
+                cur += l;
+                base = cur;
+            } else {
+                cur++;
+            }
+        }
+        if (base != cur)
+            xmlBufferAdd(buf, base, cur - base);
+}
+
+/**
+ * xmlNodeDump:
+ * @buf:  the XML buffer output
+ * @doc:  the document
+ * @cur:  the current node
+ * @level: the imbrication level for indenting
+ * @format: is formatting allowed
+ *
+ * Dump an XML node, recursive behaviour,children are printed too.
+ * Note that @format = 1 provide node indenting only if xmlIndentTreeOutput = 1
+ * or xmlKeepBlanksDefault(0) was called
+ *
+ * Returns the number of bytes written to the buffer or -1 in case of error
+ */
+int
+xmlNodeDump(xmlBufferPtr buf, xmlDocPtr doc, xmlNodePtr cur, int level,
+            int format)
+{
+    unsigned int use;
+    int ret;
+    xmlOutputBufferPtr outbuf;
+
+    xmlInitParser();
+
+    if (cur == NULL) {
+#ifdef DEBUG_TREE
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlNodeDump : node == NULL\n");
+#endif
+        return (-1);
+    }
+    if (buf == NULL) {
+#ifdef DEBUG_TREE
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlNodeDump : buf == NULL\n");
+#endif
+        return (-1);
+    }
+    outbuf = (xmlOutputBufferPtr) xmlMalloc(sizeof(xmlOutputBuffer));
+    if (outbuf == NULL) {
+        xmlSaveErrMemory("creating buffer");
+        return (-1);
+    }
+    memset(outbuf, 0, (size_t) sizeof(xmlOutputBuffer));
+    outbuf->buffer = buf;
+    outbuf->encoder = NULL;
+    outbuf->writecallback = NULL;
+    outbuf->closecallback = NULL;
+    outbuf->context = NULL;
+    outbuf->written = 0;
+
+    use = buf->use;
+    xmlNodeDumpOutput(outbuf, doc, cur, level, format, NULL);
+    xmlFree(outbuf);
+    ret = buf->use - use;
+    return (ret);
+}
+
+/**
+ * xmlElemDump:
+ * @f:  the FILE * for the output
+ * @doc:  the document
+ * @cur:  the current node
+ *
+ * Dump an XML/HTML node, recursive behaviour, children are printed too.
+ */
+void
+xmlElemDump(FILE * f, xmlDocPtr doc, xmlNodePtr cur)
+{
+    xmlOutputBufferPtr outbuf;
+
+    xmlInitParser();
+
+    if (cur == NULL) {
+#ifdef DEBUG_TREE
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlElemDump : cur == NULL\n");
+#endif
+        return;
+    }
+#ifdef DEBUG_TREE
+    if (doc == NULL) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlElemDump : doc == NULL\n");
+    }
+#endif
+
+    outbuf = xmlOutputBufferCreateFile(f, NULL);
+    if (outbuf == NULL)
+        return;
+    if ((doc != NULL) && (doc->type == XML_HTML_DOCUMENT_NODE)) {
+#ifdef LIBXML_HTML_ENABLED
+        htmlNodeDumpOutput(outbuf, doc, cur, NULL);
+#else
+	xmlSaveErr(XML_ERR_INTERNAL_ERROR, cur, "HTML support not compiled in\n");
+#endif /* LIBXML_HTML_ENABLED */
+    } else
+        xmlNodeDumpOutput(outbuf, doc, cur, 0, 1, NULL);
+    xmlOutputBufferClose(outbuf);
+}
+
+/************************************************************************
+ *									*
+ *		Saving functions front-ends				*
+ *									*
+ ************************************************************************/
+
+/**
+ * xmlNodeDumpOutput:
+ * @buf:  the XML buffer output
+ * @doc:  the document
+ * @cur:  the current node
+ * @level: the imbrication level for indenting
+ * @format: is formatting allowed
+ * @encoding:  an optional encoding string
+ *
+ * Dump an XML node, recursive behaviour, children are printed too.
+ * Note that @format = 1 provide node indenting only if xmlIndentTreeOutput = 1
+ * or xmlKeepBlanksDefault(0) was called
+ */
+void
+xmlNodeDumpOutput(xmlOutputBufferPtr buf, xmlDocPtr doc, xmlNodePtr cur,
+                  int level, int format, const char *encoding)
+{
+    xmlSaveCtxt ctxt;
+#ifdef LIBXML_HTML_ENABLED
+    xmlDtdPtr dtd;
+    int is_xhtml = 0;
+#endif
+
+    xmlInitParser();
+
+    memset(&ctxt, 0, sizeof(ctxt));
+    ctxt.doc = doc;
+    ctxt.buf = buf;
+    ctxt.level = level;
+    ctxt.format = format;
+    ctxt.encoding = (const xmlChar *) encoding;
+    xmlSaveCtxtInit(&ctxt);
+
+#ifdef LIBXML_HTML_ENABLED
+    dtd = xmlGetIntSubset(doc);
+    if (dtd != NULL) {
+        is_xhtml = xmlIsXHTML(dtd->SystemID, dtd->ExternalID);
+        if (is_xhtml < 0)
+            is_xhtml = 0;
+        if ((is_xhtml) && (cur->parent == (xmlNodePtr) doc) &&
+            (cur->type == XML_ELEMENT_NODE) &&
+            (xmlStrEqual(cur->name, BAD_CAST "html"))) {
+            if (encoding != NULL)
+                htmlSetMetaEncoding((htmlDocPtr) doc,
+                                    (const xmlChar *) encoding);
+            else
+                htmlSetMetaEncoding((htmlDocPtr) doc, BAD_CAST "UTF-8");
+        }
+    }
+
+    if (is_xhtml)
+        xhtmlNodeDumpOutput(&ctxt, cur);
+    else
+#endif
+        xmlNodeDumpOutputInternal(&ctxt, cur);
+}
+
+/**
+ * xmlDocDumpFormatMemoryEnc:
+ * @out_doc:  Document to generate XML text from
+ * @doc_txt_ptr:  Memory pointer for allocated XML text
+ * @doc_txt_len:  Length of the generated XML text
+ * @txt_encoding:  Character encoding to use when generating XML text
+ * @format:  should formatting spaces been added
+ *
+ * Dump the current DOM tree into memory using the character encoding specified
+ * by the caller.  Note it is up to the caller of this function to free the
+ * allocated memory with xmlFree().
+ * Note that @format = 1 provide node indenting only if xmlIndentTreeOutput = 1
+ * or xmlKeepBlanksDefault(0) was called
+ */
+
+void
+xmlDocDumpFormatMemoryEnc(xmlDocPtr out_doc, xmlChar **doc_txt_ptr,
+		int * doc_txt_len, const char * txt_encoding,
+		int format) {
+    xmlSaveCtxt ctxt;
+    int                         dummy = 0;
+    xmlOutputBufferPtr          out_buff = NULL;
+    xmlCharEncodingHandlerPtr   conv_hdlr = NULL;
+
+    if (doc_txt_len == NULL) {
+        doc_txt_len = &dummy;   /*  Continue, caller just won't get length */
+    }
+
+    if (doc_txt_ptr == NULL) {
+        *doc_txt_len = 0;
+        return;
+    }
+
+    *doc_txt_ptr = NULL;
+    *doc_txt_len = 0;
+
+    if (out_doc == NULL) {
+        /*  No document, no output  */
+        return;
+    }
+
+    /*
+     *  Validate the encoding value, if provided.
+     *  This logic is copied from xmlSaveFileEnc.
+     */
+
+    if (txt_encoding == NULL)
+	txt_encoding = (const char *) out_doc->encoding;
+    if (txt_encoding != NULL) {
+	conv_hdlr = xmlFindCharEncodingHandler(txt_encoding);
+	if ( conv_hdlr == NULL ) {
+	    xmlSaveErr(XML_SAVE_UNKNOWN_ENCODING, (xmlNodePtr) out_doc,
+		       txt_encoding);
+	    return;
+	}
+    }
+
+    if ((out_buff = xmlAllocOutputBuffer(conv_hdlr)) == NULL ) {
+        xmlSaveErrMemory("creating buffer");
+        return;
+    }
+
+    memset(&ctxt, 0, sizeof(ctxt));
+    ctxt.doc = out_doc;
+    ctxt.buf = out_buff;
+    ctxt.level = 0;
+    ctxt.format = format;
+    ctxt.encoding = (const xmlChar *) txt_encoding;
+    xmlSaveCtxtInit(&ctxt);
+    xmlDocContentDumpOutput(&ctxt, out_doc);
+    xmlOutputBufferFlush(out_buff);
+    if (out_buff->conv != NULL) {
+	*doc_txt_len = out_buff->conv->use;
+	*doc_txt_ptr = xmlStrndup(out_buff->conv->content, *doc_txt_len);
+    } else {
+	*doc_txt_len = out_buff->buffer->use;
+	*doc_txt_ptr = xmlStrndup(out_buff->buffer->content, *doc_txt_len);
+    }
+    (void)xmlOutputBufferClose(out_buff);
+
+    if ((*doc_txt_ptr == NULL) && (*doc_txt_len > 0)) {
+        *doc_txt_len = 0;
+        xmlSaveErrMemory("creating output");
+    }
+
+    return;
+}
+
+/**
+ * xmlDocDumpMemory:
+ * @cur:  the document
+ * @mem:  OUT: the memory pointer
+ * @size:  OUT: the memory length
+ *
+ * Dump an XML document in memory and return the #xmlChar * and it's size
+ * in bytes. It's up to the caller to free the memory with xmlFree().
+ * The resulting byte array is zero terminated, though the last 0 is not
+ * included in the returned size.
+ */
+void
+xmlDocDumpMemory(xmlDocPtr cur, xmlChar**mem, int *size) {
+    xmlDocDumpFormatMemoryEnc(cur, mem, size, NULL, 0);
+}
+
+/**
+ * xmlDocDumpFormatMemory:
+ * @cur:  the document
+ * @mem:  OUT: the memory pointer
+ * @size:  OUT: the memory length
+ * @format:  should formatting spaces been added
+ *
+ *
+ * Dump an XML document in memory and return the #xmlChar * and it's size.
+ * It's up to the caller to free the memory with xmlFree().
+ * Note that @format = 1 provide node indenting only if xmlIndentTreeOutput = 1
+ * or xmlKeepBlanksDefault(0) was called
+ */
+void
+xmlDocDumpFormatMemory(xmlDocPtr cur, xmlChar**mem, int *size, int format) {
+    xmlDocDumpFormatMemoryEnc(cur, mem, size, NULL, format);
+}
+
+/**
+ * xmlDocDumpMemoryEnc:
+ * @out_doc:  Document to generate XML text from
+ * @doc_txt_ptr:  Memory pointer for allocated XML text
+ * @doc_txt_len:  Length of the generated XML text
+ * @txt_encoding:  Character encoding to use when generating XML text
+ *
+ * Dump the current DOM tree into memory using the character encoding specified
+ * by the caller.  Note it is up to the caller of this function to free the
+ * allocated memory with xmlFree().
+ */
+
+void
+xmlDocDumpMemoryEnc(xmlDocPtr out_doc, xmlChar **doc_txt_ptr,
+	            int * doc_txt_len, const char * txt_encoding) {
+    xmlDocDumpFormatMemoryEnc(out_doc, doc_txt_ptr, doc_txt_len,
+	                      txt_encoding, 0);
+}
+
+/**
+ * xmlDocFormatDump:
+ * @f:  the FILE*
+ * @cur:  the document
+ * @format: should formatting spaces been added
+ *
+ * Dump an XML document to an open FILE.
+ *
+ * returns: the number of bytes written or -1 in case of failure.
+ * Note that @format = 1 provide node indenting only if xmlIndentTreeOutput = 1
+ * or xmlKeepBlanksDefault(0) was called
+ */
+int
+xmlDocFormatDump(FILE *f, xmlDocPtr cur, int format) {
+    xmlSaveCtxt ctxt;
+    xmlOutputBufferPtr buf;
+    const char * encoding;
+    xmlCharEncodingHandlerPtr handler = NULL;
+    int ret;
+
+    if (cur == NULL) {
+#ifdef DEBUG_TREE
+        xmlGenericError(xmlGenericErrorContext,
+		"xmlDocDump : document == NULL\n");
+#endif
+	return(-1);
+    }
+    encoding = (const char *) cur->encoding;
+
+    if (encoding != NULL) {
+		handler = xmlFindCharEncodingHandler(encoding);
+	    if (handler == NULL) {
+		xmlFree((char *) cur->encoding);
+		cur->encoding = NULL;
+	    }
+	}
+    buf = xmlOutputBufferCreateFile(f, handler);
+    if (buf == NULL) return(-1);
+    memset(&ctxt, 0, sizeof(ctxt));
+    ctxt.doc = cur;
+    ctxt.buf = buf;
+    ctxt.level = 0;
+    ctxt.format = format;
+    ctxt.encoding = (const xmlChar *) encoding;
+    xmlSaveCtxtInit(&ctxt);
+    xmlDocContentDumpOutput(&ctxt, cur);
+
+    ret = xmlOutputBufferClose(buf);
+    return(ret);
+}
+
+/**
+ * xmlDocDump:
+ * @f:  the FILE*
+ * @cur:  the document
+ *
+ * Dump an XML document to an open FILE.
+ *
+ * returns: the number of bytes written or -1 in case of failure.
+ */
+int
+xmlDocDump(FILE *f, xmlDocPtr cur) {
+    return(xmlDocFormatDump (f, cur, 0));
+}
+
+/**
+ * xmlSaveFileTo:
+ * @buf:  an output I/O buffer
+ * @cur:  the document
+ * @encoding:  the encoding if any assuming the I/O layer handles the trancoding
+ *
+ * Dump an XML document to an I/O buffer.
+ *
+ * returns: the number of bytes written or -1 in case of failure.
+ */
+int
+xmlSaveFileTo(xmlOutputBufferPtr buf, xmlDocPtr cur, const char *encoding) {
+    xmlSaveCtxt ctxt;
+    int ret;
+
+    if (buf == NULL) return(0);
+    memset(&ctxt, 0, sizeof(ctxt));
+    ctxt.doc = cur;
+    ctxt.buf = buf;
+    ctxt.level = 0;
+    ctxt.format = 0;
+    ctxt.encoding = (const xmlChar *) encoding;
+    xmlSaveCtxtInit(&ctxt);
+    xmlDocContentDumpOutput(&ctxt, cur);
+    ret = xmlOutputBufferClose(buf);
+    return(ret);
+}
+
+/**
+ * xmlSaveFormatFileTo:
+ * @buf:  an output I/O buffer
+ * @cur:  the document
+ * @encoding:  the encoding if any assuming the I/O layer handles the trancoding
+ * @format: should formatting spaces been added
+ *
+ * Dump an XML document to an I/O buffer.
+ * NOTE: the I/O buffer is closed as part of the call.
+ *
+ * returns: the number of bytes written or -1 in case of failure.
+ */
+int
+xmlSaveFormatFileTo(xmlOutputBufferPtr buf, xmlDocPtr cur,
+                    const char *encoding, int format)
+{
+    xmlSaveCtxt ctxt;
+    int ret;
+
+    if (buf == NULL)
+        return (0);
+    memset(&ctxt, 0, sizeof(ctxt));
+    ctxt.doc = cur;
+    ctxt.buf = buf;
+    ctxt.level = 0;
+    ctxt.format = format;
+    ctxt.encoding = (const xmlChar *) encoding;
+    xmlSaveCtxtInit(&ctxt);
+    xmlDocContentDumpOutput(&ctxt, cur);
+    ret = xmlOutputBufferClose(buf);
+    return (ret);
+}
+
+/**
+ * xmlSaveFormatFileEnc:
+ * @filename:  the filename or URL to output
+ * @cur:  the document being saved
+ * @encoding:  the name of the encoding to use or NULL.
+ * @format:  should formatting spaces be added.
+ *
+ * Dump an XML document to a file or an URL.
+ *
+ * Returns the number of bytes written or -1 in case of error.
+ * Note that @format = 1 provide node indenting only if xmlIndentTreeOutput = 1
+ * or xmlKeepBlanksDefault(0) was called
+ */
+int
+xmlSaveFormatFileEnc( const char * filename, xmlDocPtr cur,
+			const char * encoding, int format ) {
+    xmlSaveCtxt ctxt;
+    xmlOutputBufferPtr buf;
+    xmlCharEncodingHandlerPtr handler = NULL;
+    int ret;
+
+    if (cur == NULL)
+	return(-1);
+
+    if (encoding == NULL)
+	encoding = (const char *) cur->encoding;
+
+    if (encoding != NULL) {
+
+	    handler = xmlFindCharEncodingHandler(encoding);
+	    if (handler == NULL)
+		return(-1);
+    }
+
+#ifdef HAVE_ZLIB_H
+    if (cur->compression < 0) cur->compression = xmlGetCompressMode();
+#endif
+    /* 
+     * save the content to a temp buffer.
+     */
+    buf = xmlOutputBufferCreateFilename(filename, handler, cur->compression);
+    if (buf == NULL) return(-1);
+    memset(&ctxt, 0, sizeof(ctxt));
+    ctxt.doc = cur;
+    ctxt.buf = buf;
+    ctxt.level = 0;
+    ctxt.format = format;
+    ctxt.encoding = (const xmlChar *) encoding;
+    xmlSaveCtxtInit(&ctxt);
+
+    xmlDocContentDumpOutput(&ctxt, cur);
+
+    ret = xmlOutputBufferClose(buf);
+    return(ret);
+}
+
+
+/**
+ * xmlSaveFileEnc:
+ * @filename:  the filename (or URL)
+ * @cur:  the document
+ * @encoding:  the name of an encoding (or NULL)
+ *
+ * Dump an XML document, converting it to the given encoding
+ *
+ * returns: the number of bytes written or -1 in case of failure.
+ */
+int
+xmlSaveFileEnc(const char *filename, xmlDocPtr cur, const char *encoding) {
+    return ( xmlSaveFormatFileEnc( filename, cur, encoding, 0 ) );
+}
+
+/**
+ * xmlSaveFormatFile:
+ * @filename:  the filename (or URL)
+ * @cur:  the document
+ * @format:  should formatting spaces been added
+ *
+ * Dump an XML document to a file. Will use compression if
+ * compiled in and enabled. If @filename is "-" the stdout file is
+ * used. If @format is set then the document will be indented on output.
+ * Note that @format = 1 provide node indenting only if xmlIndentTreeOutput = 1
+ * or xmlKeepBlanksDefault(0) was called
+ *
+ * returns: the number of bytes written or -1 in case of failure.
+ */
+int
+xmlSaveFormatFile(const char *filename, xmlDocPtr cur, int format) {
+    return ( xmlSaveFormatFileEnc( filename, cur, NULL, format ) );
+}
+
+/**
+ * xmlSaveFile:
+ * @filename:  the filename (or URL)
+ * @cur:  the document
+ *
+ * Dump an XML document to a file. Will use compression if
+ * compiled in and enabled. If @filename is "-" the stdout file is
+ * used.
+ * returns: the number of bytes written or -1 in case of failure.
+ */
+int
+xmlSaveFile(const char *filename, xmlDocPtr cur) {
+    return(xmlSaveFormatFileEnc(filename, cur, NULL, 0));
+}
+
+#endif /* LIBXML_OUTPUT_ENABLED */
+
diff --git a/src/libxml/src/xmlschemas.c b/src/libxml/src/xmlschemas.c
new file mode 100644
index 0000000..25f9400
--- /dev/null
+++ b/src/libxml/src/xmlschemas.c
@@ -0,0 +1,6616 @@
+/*
+ * schemas.c : implementation of the XML Schema handling and
+ *             schema validity checking
+ *
+ * See Copyright for the status of this software.
+ *
+ * Daniel Veillard <veillard@redhat.com>
+ */
+
+/*
+ * TODO:
+ *   - when types are redefined in includes, check that all
+ *     types in the redef list are equal
+ *     -> need a type equality operation.
+ */
+#define IN_LIBXML
+#include "libxml.h"
+
+#ifdef LIBXML_SCHEMAS_ENABLED
+
+#include <string.h>
+#include <libxml/xmlmemory.h>
+#include <libxml/parser.h>
+#include <libxml/parserInternals.h>
+#include <libxml/hash.h>
+#include <libxml/uri.h>
+
+#include <libxml/xmlschemas.h>
+#include <libxml/schemasInternals.h>
+#include <libxml/xmlschemastypes.h>
+#include <libxml/xmlautomata.h>
+#include <libxml/xmlregexp.h>
+#include <libxml/dict.h>
+
+/* #define DEBUG 1 */
+
+/* #define DEBUG_CONTENT 1 */
+
+/* #define DEBUG_TYPE 1 */
+
+/* #define DEBUG_CONTENT_REGEXP 1 */
+
+/* #define DEBUG_AUTOMATA 1 */
+
+#define UNBOUNDED (1 << 30)
+#define TODO 								\
+    xmlGenericError(xmlGenericErrorContext,				\
+	    "Unimplemented block at %s:%d\n",				\
+            __FILE__, __LINE__);
+
+#define XML_SCHEMAS_DEFAULT_NAMESPACE (const xmlChar *)"the default namespace"
+
+/*
+ * The XML Schemas namespaces
+ */
+static const xmlChar *xmlSchemaNs = (const xmlChar *)
+    "http://www.w3.org/2001/XMLSchema";
+
+static const xmlChar *xmlSchemaInstanceNs = (const xmlChar *)
+    "http://www.w3.org/2001/XMLSchema-instance";
+
+#define IS_SCHEMA(node, type)						\
+   ((node != NULL) && (node->ns != NULL) &&				\
+    (xmlStrEqual(node->name, (const xmlChar *) type)) &&		\
+    (xmlStrEqual(node->ns->href, xmlSchemaNs)))
+
+#define XML_SCHEMAS_PARSE_ERROR		1
+
+#define SCHEMAS_PARSE_OPTIONS XML_PARSE_NOENT
+
+struct _xmlSchemaParserCtxt {
+    void *userData;             /* user specific data block */
+    xmlSchemaValidityErrorFunc error;   /* the callback in case of errors */
+    xmlSchemaValidityWarningFunc warning;       /* the callback in case of warning */
+    xmlSchemaValidError err;
+    int nberrors;
+    xmlStructuredErrorFunc serror;
+
+    xmlSchemaPtr topschema;	/* The main schema */
+    xmlHashTablePtr namespaces;	/* Hash table of namespaces to schemas */
+
+    xmlSchemaPtr schema;        /* The schema in use */
+    const xmlChar *container;   /* the current element, group, ... */
+    int counter;
+
+    const xmlChar *URL;
+    xmlDocPtr doc;
+    int preserve;		/* Whether the doc should be freed  */
+
+    const char *buffer;
+    int size;
+
+    /*
+     * Used to build complex element content models
+     */
+    xmlAutomataPtr am;
+    xmlAutomataStatePtr start;
+    xmlAutomataStatePtr end;
+    xmlAutomataStatePtr state;
+
+    xmlDictPtr dict;		/* dictionnary for interned string names */
+    int        includes;	/* the inclusion level, 0 for root or imports */
+};
+
+
+#define XML_SCHEMAS_ATTR_UNKNOWN 1
+#define XML_SCHEMAS_ATTR_CHECKED 2
+
+typedef struct _xmlSchemaAttrState xmlSchemaAttrState;
+typedef xmlSchemaAttrState *xmlSchemaAttrStatePtr;
+struct _xmlSchemaAttrState {
+    xmlAttrPtr attr;
+    int state;
+};
+
+/**
+ * xmlSchemaValidCtxt:
+ *
+ * A Schemas validation context
+ */
+
+struct _xmlSchemaValidCtxt {
+    void *userData;             /* user specific data block */
+    xmlSchemaValidityErrorFunc error;   /* the callback in case of errors */
+    xmlSchemaValidityWarningFunc warning;       /* the callback in case of warning */
+    xmlStructuredErrorFunc serror;
+
+    xmlSchemaPtr schema;        /* The schema in use */
+    xmlDocPtr doc;
+    xmlParserInputBufferPtr input;
+    xmlCharEncoding enc;
+    xmlSAXHandlerPtr sax;
+    void *user_data;
+
+    xmlDocPtr myDoc;
+    int err;
+    int nberrors;
+
+    xmlNodePtr node;
+    xmlNodePtr cur;
+    xmlSchemaTypePtr type;
+
+    xmlRegExecCtxtPtr regexp;
+    xmlSchemaValPtr value;
+
+    int attrNr;
+    int attrBase;
+    int attrMax;
+    xmlSchemaAttrStatePtr attr;
+};
+
+/*
+ * These are the entries in the schemas importSchemas hash table
+ */
+typedef struct _xmlSchemaImport xmlSchemaImport;
+typedef xmlSchemaImport *xmlSchemaImportPtr;
+struct _xmlSchemaImport {
+    const xmlChar *schemaLocation;
+    xmlSchemaPtr schema;
+};
+
+/*
+ * These are the entries associated to includes in a schemas
+ */
+typedef struct _xmlSchemaInclude xmlSchemaInclude;
+typedef xmlSchemaInclude *xmlSchemaIncludePtr;
+struct _xmlSchemaInclude {
+    xmlSchemaIncludePtr next;
+
+    const xmlChar *schemaLocation;
+    xmlDocPtr doc;
+};
+
+/************************************************************************
+ * 									*
+ * 			Some predeclarations				*
+ * 									*
+ ************************************************************************/
+static int xmlSchemaValidateSimpleValue(xmlSchemaValidCtxtPtr ctxt,
+                                        xmlSchemaTypePtr type,
+                                        const xmlChar * value);
+
+static int xmlSchemaParseInclude(xmlSchemaParserCtxtPtr ctxt,
+                                 xmlSchemaPtr schema,
+                                 xmlNodePtr node);
+static int
+xmlSchemaValidateSimpleValueInternal(xmlSchemaValidCtxtPtr ctxt,
+                             xmlSchemaTypePtr type,
+			     const xmlChar * value,
+			     int fireErrors);
+
+/************************************************************************
+ *									*
+ * 			Datatype error handlers				*
+ *									*
+ ************************************************************************/
+
+/**
+ * xmlSchemaPErrMemory:
+ * @node: a context node
+ * @extra:  extra informations
+ *
+ * Handle an out of memory condition
+ */
+static void
+xmlSchemaPErrMemory(xmlSchemaParserCtxtPtr ctxt,
+                    const char *extra, xmlNodePtr node)
+{
+    if (ctxt != NULL)
+        ctxt->nberrors++;
+    __xmlSimpleError(XML_FROM_SCHEMASP, XML_ERR_NO_MEMORY, node, NULL,
+                     extra);
+}
+
+/**
+ * xmlSchemaPErr:
+ * @ctxt: the parsing context
+ * @node: the context node
+ * @error: the error code
+ * @msg: the error message
+ * @str1: extra data
+ * @str2: extra data
+ * 
+ * Handle a parser error
+ */
+static void
+xmlSchemaPErr(xmlSchemaParserCtxtPtr ctxt, xmlNodePtr node, int error,
+              const char *msg, const xmlChar * str1, const xmlChar * str2)
+{
+    xmlGenericErrorFunc channel = NULL;
+    xmlStructuredErrorFunc schannel = NULL;
+    void *data = NULL;
+
+    if (ctxt != NULL) {
+        ctxt->nberrors++;
+        channel = ctxt->error;
+        data = ctxt->userData;
+	schannel = ctxt->serror;
+    }
+    __xmlRaiseError(schannel, channel, data, ctxt, node, XML_FROM_SCHEMASP,
+                    error, XML_ERR_ERROR, NULL, 0,
+                    (const char *) str1, (const char *) str2, NULL, 0, 0,
+                    msg, str1, str2);
+}
+
+/**
+ * xmlSchemaPErr2:
+ * @ctxt: the parsing context
+ * @node: the context node
+ * @node: the current child
+ * @error: the error code
+ * @msg: the error message
+ * @str1: extra data
+ * @str2: extra data
+ * 
+ * Handle a parser error
+ */
+static void
+xmlSchemaPErr2(xmlSchemaParserCtxtPtr ctxt, xmlNodePtr node,
+               xmlNodePtr child, int error,
+               const char *msg, const xmlChar * str1, const xmlChar * str2)
+{
+    if (child != NULL)
+        xmlSchemaPErr(ctxt, child, error, msg, str1, str2);
+    else
+        xmlSchemaPErr(ctxt, node, error, msg, str1, str2);
+}
+
+/**
+ * xmlSchemaVTypeErrMemory:
+ * @node: a context node
+ * @extra:  extra informations
+ *
+ * Handle an out of memory condition
+ */
+static void
+xmlSchemaVErrMemory(xmlSchemaValidCtxtPtr ctxt,
+                    const char *extra, xmlNodePtr node)
+{
+    if (ctxt != NULL) {
+        ctxt->nberrors++;
+        ctxt->err = XML_SCHEMAS_ERR_INTERNAL;
+    }
+    __xmlSimpleError(XML_FROM_SCHEMASV, XML_ERR_NO_MEMORY, node, NULL,
+                     extra);
+}
+
+/**
+ * xmlSchemaVErr3:
+ * @ctxt: the validation context
+ * @node: the context node
+ * @error: the error code
+ * @msg: the error message
+ * @str1: extra data
+ * @str2: extra data
+ * @str3: extra data
+ * 
+ * Handle a validation error
+ */
+static void
+xmlSchemaVErr3(xmlSchemaValidCtxtPtr ctxt, xmlNodePtr node, int error,
+               const char *msg, const xmlChar *str1, const xmlChar *str2,
+	       const xmlChar *str3)
+{
+    xmlStructuredErrorFunc schannel = NULL;
+    xmlGenericErrorFunc channel = NULL;
+    void *data = NULL;
+
+    if (ctxt != NULL) {
+        ctxt->nberrors++;
+	ctxt->err = error;
+        channel = ctxt->error;
+        schannel = ctxt->serror;
+        data = ctxt->userData;
+    }
+    /* reajust to global error numbers */
+    error += XML_SCHEMAV_NOROOT - XML_SCHEMAS_ERR_NOROOT;
+    __xmlRaiseError(schannel, channel, data, ctxt, node, XML_FROM_SCHEMASV,
+                    error, XML_ERR_ERROR, NULL, 0,
+                    (const char *) str1, (const char *) str2,
+		    (const char *) str3, 0, 0,
+                    msg, str1, str2, str3);
+}
+/**
+ * xmlSchemaVErr:
+ * @ctxt: the validation context
+ * @node: the context node
+ * @error: the error code
+ * @msg: the error message
+ * @str1: extra data
+ * @str2: extra data
+ * 
+ * Handle a validation error
+ */
+static void
+xmlSchemaVErr(xmlSchemaValidCtxtPtr ctxt, xmlNodePtr node, int error,
+              const char *msg, const xmlChar * str1, const xmlChar * str2)
+{
+    xmlStructuredErrorFunc schannel = NULL;
+    xmlGenericErrorFunc channel = NULL;
+    void *data = NULL;
+
+    if (ctxt != NULL) {
+        ctxt->nberrors++;
+	ctxt->err = error;
+        channel = ctxt->error;
+        data = ctxt->userData;
+        schannel = ctxt->serror;
+    }
+    /* reajust to global error numbers */
+    error += XML_SCHEMAV_NOROOT - XML_SCHEMAS_ERR_NOROOT;
+    __xmlRaiseError(schannel, channel, data, ctxt, node, XML_FROM_SCHEMASV,
+                    error, XML_ERR_ERROR, NULL, 0,
+                    (const char *) str1, (const char *) str2, NULL, 0, 0,
+                    msg, str1, str2);
+}
+
+/************************************************************************
+ * 									*
+ * 			Allocation functions				*
+ * 									*
+ ************************************************************************/
+
+/**
+ * xmlSchemaNewSchema:
+ * @ctxt:  a schema validation context
+ *
+ * Allocate a new Schema structure.
+ *
+ * Returns the newly allocated structure or NULL in case or error
+ */
+static xmlSchemaPtr
+xmlSchemaNewSchema(xmlSchemaParserCtxtPtr ctxt)
+{
+    xmlSchemaPtr ret;
+
+    ret = (xmlSchemaPtr) xmlMalloc(sizeof(xmlSchema));
+    if (ret == NULL) {
+        xmlSchemaPErrMemory(ctxt, "allocating schema", NULL);
+        return (NULL);
+    }
+    memset(ret, 0, sizeof(xmlSchema));
+    ret->dict = ctxt->dict;
+    xmlDictReference(ret->dict);
+
+    return (ret);
+}
+
+/**
+ * xmlSchemaNewFacet:
+ *
+ * Allocate a new Facet structure.
+ *
+ * Returns the newly allocated structure or NULL in case or error
+ */
+xmlSchemaFacetPtr
+xmlSchemaNewFacet(void)
+{
+    xmlSchemaFacetPtr ret;
+
+    ret = (xmlSchemaFacetPtr) xmlMalloc(sizeof(xmlSchemaFacet));
+    if (ret == NULL) {
+        return (NULL);
+    }
+    memset(ret, 0, sizeof(xmlSchemaFacet));
+
+    return (ret);
+}
+
+/**
+ * xmlSchemaNewAnnot:
+ * @ctxt:  a schema validation context
+ * @node:  a node
+ *
+ * Allocate a new annotation structure.
+ *
+ * Returns the newly allocated structure or NULL in case or error
+ */
+static xmlSchemaAnnotPtr
+xmlSchemaNewAnnot(xmlSchemaParserCtxtPtr ctxt, xmlNodePtr node)
+{
+    xmlSchemaAnnotPtr ret;
+
+    ret = (xmlSchemaAnnotPtr) xmlMalloc(sizeof(xmlSchemaAnnot));
+    if (ret == NULL) {
+        xmlSchemaPErrMemory(ctxt, "allocating annotation", node);
+        return (NULL);
+    }
+    memset(ret, 0, sizeof(xmlSchemaAnnot));
+    ret->content = node;
+    return (ret);
+}
+
+/**
+ * xmlSchemaFreeAnnot:
+ * @annot:  a schema type structure
+ *
+ * Deallocate a annotation structure
+ */
+static void
+xmlSchemaFreeAnnot(xmlSchemaAnnotPtr annot)
+{
+    if (annot == NULL)
+        return;
+    xmlFree(annot);
+}
+
+/**
+ * xmlSchemaFreeImport:
+ * @import:  a schema import structure
+ *
+ * Deallocate an import structure
+ */
+static void
+xmlSchemaFreeImport(xmlSchemaImportPtr import)
+{
+    if (import == NULL)
+        return;
+
+    xmlSchemaFree(import->schema);
+    xmlFree(import);
+}
+
+/**
+ * xmlSchemaFreeInclude:
+ * @include:  a schema include structure
+ *
+ * Deallocate an include structure
+ */
+static void
+xmlSchemaFreeInclude(xmlSchemaIncludePtr include)
+{
+    if (include == NULL)
+        return;
+
+    xmlFreeDoc(include->doc);
+    xmlFree(include);
+}
+
+/**
+ * xmlSchemaFreeIncludeList:
+ * @includes:  a schema include list
+ *
+ * Deallocate an include structure
+ */
+static void
+xmlSchemaFreeIncludeList(xmlSchemaIncludePtr includes)
+{
+    xmlSchemaIncludePtr next;
+
+    while (includes != NULL) {
+        next = includes->next;
+	xmlSchemaFreeInclude(includes);
+	includes = next;
+    }
+}
+
+/**
+ * xmlSchemaFreeNotation:
+ * @schema:  a schema notation structure
+ *
+ * Deallocate a Schema Notation structure.
+ */
+static void
+xmlSchemaFreeNotation(xmlSchemaNotationPtr nota)
+{
+    if (nota == NULL)
+        return;
+    xmlFree(nota);
+}
+
+/**
+ * xmlSchemaFreeAttribute:
+ * @schema:  a schema attribute structure
+ *
+ * Deallocate a Schema Attribute structure.
+ */
+static void
+xmlSchemaFreeAttribute(xmlSchemaAttributePtr attr)
+{
+    if (attr == NULL)
+        return;
+    xmlFree(attr);
+}
+
+/**
+ * xmlSchemaFreeAttributeGroup:
+ * @schema:  a schema attribute group structure
+ *
+ * Deallocate a Schema Attribute Group structure.
+ */
+static void
+xmlSchemaFreeAttributeGroup(xmlSchemaAttributeGroupPtr attr)
+{
+    if (attr == NULL)
+        return;
+    xmlFree(attr);
+}
+
+/**
+ * xmlSchemaFreeElement:
+ * @schema:  a schema element structure
+ *
+ * Deallocate a Schema Element structure.
+ */
+static void
+xmlSchemaFreeElement(xmlSchemaElementPtr elem)
+{
+    if (elem == NULL)
+        return;
+    if (elem->annot != NULL)
+        xmlSchemaFreeAnnot(elem->annot);
+    if (elem->contModel != NULL)
+        xmlRegFreeRegexp(elem->contModel);
+    xmlFree(elem);
+}
+
+/**
+ * xmlSchemaFreeFacet:
+ * @facet:  a schema facet structure
+ *
+ * Deallocate a Schema Facet structure.
+ */
+void
+xmlSchemaFreeFacet(xmlSchemaFacetPtr facet)
+{
+    if (facet == NULL)
+        return;
+    if (facet->val != NULL)
+        xmlSchemaFreeValue(facet->val);
+    if (facet->regexp != NULL)
+        xmlRegFreeRegexp(facet->regexp);
+    if (facet->annot != NULL)
+        xmlSchemaFreeAnnot(facet->annot);
+    xmlFree(facet);
+}
+
+/**
+ * xmlSchemaFreeType:
+ * @type:  a schema type structure
+ *
+ * Deallocate a Schema Type structure.
+ */
+void
+xmlSchemaFreeType(xmlSchemaTypePtr type)
+{
+    if (type == NULL)
+        return;
+    if (type->annot != NULL)
+        xmlSchemaFreeAnnot(type->annot);
+    if (type->facets != NULL) {
+        xmlSchemaFacetPtr facet, next;
+
+        facet = type->facets;
+        while (facet != NULL) {
+            next = facet->next;
+            xmlSchemaFreeFacet(facet);
+            facet = next;
+        }
+    }
+    xmlFree(type);
+}
+
+/**
+ * xmlSchemaFreeTypeList:
+ * @type:  a schema type structure
+ *
+ * Deallocate a Schema Type structure.
+ */
+static void
+xmlSchemaFreeTypeList(xmlSchemaTypePtr type)
+{
+    xmlSchemaTypePtr next;
+
+    while (type != NULL) {
+        next = type->redef;
+	xmlSchemaFreeType(type);
+	type = next;
+    }
+}
+
+/**
+ * xmlSchemaFree:
+ * @schema:  a schema structure
+ *
+ * Deallocate a Schema structure.
+ */
+void
+xmlSchemaFree(xmlSchemaPtr schema)
+{
+    if (schema == NULL)
+        return;
+
+    if (schema->notaDecl != NULL)
+        xmlHashFree(schema->notaDecl,
+                    (xmlHashDeallocator) xmlSchemaFreeNotation);
+    if (schema->attrDecl != NULL)
+        xmlHashFree(schema->attrDecl,
+                    (xmlHashDeallocator) xmlSchemaFreeAttribute);
+    if (schema->attrgrpDecl != NULL)
+        xmlHashFree(schema->attrgrpDecl,
+                    (xmlHashDeallocator) xmlSchemaFreeAttributeGroup);
+    if (schema->elemDecl != NULL)
+        xmlHashFree(schema->elemDecl,
+                    (xmlHashDeallocator) xmlSchemaFreeElement);
+    if (schema->typeDecl != NULL)
+        xmlHashFree(schema->typeDecl,
+                    (xmlHashDeallocator) xmlSchemaFreeTypeList);
+    if (schema->groupDecl != NULL)
+        xmlHashFree(schema->groupDecl,
+                    (xmlHashDeallocator) xmlSchemaFreeType);
+    if (schema->schemasImports != NULL)
+	xmlHashFree(schema->schemasImports,
+		    (xmlHashDeallocator) xmlSchemaFreeImport);
+    if (schema->includes != NULL) {
+        xmlSchemaFreeIncludeList((xmlSchemaIncludePtr) schema->includes);
+    }
+    if (schema->annot != NULL)
+        xmlSchemaFreeAnnot(schema->annot);
+    if (schema->doc != NULL && !schema->preserve)
+        xmlFreeDoc(schema->doc);
+    xmlDictFree(schema->dict);
+
+    xmlFree(schema);
+}
+
+/************************************************************************
+ * 									*
+ * 			Debug functions					*
+ * 									*
+ ************************************************************************/
+
+#ifdef LIBXML_OUTPUT_ENABLED
+
+/**
+ * xmlSchemaElementDump:
+ * @elem:  an element
+ * @output:  the file output
+ *
+ * Dump the element
+ */
+static void
+xmlSchemaElementDump(xmlSchemaElementPtr elem, FILE * output,
+                     const xmlChar * name ATTRIBUTE_UNUSED,
+                     const xmlChar * context ATTRIBUTE_UNUSED,
+                     const xmlChar * namespace ATTRIBUTE_UNUSED)
+{
+    if (elem == NULL)
+        return;
+
+    fprintf(output, "Element ");
+    if (elem->flags & XML_SCHEMAS_ELEM_TOPLEVEL)
+        fprintf(output, "toplevel ");
+    fprintf(output, ": %s ", elem->name);
+    if (namespace != NULL)
+        fprintf(output, "namespace '%s' ", namespace);
+
+    if (elem->flags & XML_SCHEMAS_ELEM_NILLABLE)
+        fprintf(output, "nillable ");
+    if (elem->flags & XML_SCHEMAS_ELEM_GLOBAL)
+        fprintf(output, "global ");
+    if (elem->flags & XML_SCHEMAS_ELEM_DEFAULT)
+        fprintf(output, "default ");
+    if (elem->flags & XML_SCHEMAS_ELEM_FIXED)
+        fprintf(output, "fixed ");
+    if (elem->flags & XML_SCHEMAS_ELEM_ABSTRACT)
+        fprintf(output, "abstract ");
+    if (elem->flags & XML_SCHEMAS_ELEM_REF)
+        fprintf(output, "ref '%s' ", elem->ref);
+    if (elem->id != NULL)
+        fprintf(output, "id '%s' ", elem->id);
+    fprintf(output, "\n");
+    if ((elem->minOccurs != 1) || (elem->maxOccurs != 1)) {
+        fprintf(output, "  ");
+        if (elem->minOccurs != 1)
+            fprintf(output, "min: %d ", elem->minOccurs);
+        if (elem->maxOccurs >= UNBOUNDED)
+            fprintf(output, "max: unbounded\n");
+        else if (elem->maxOccurs != 1)
+            fprintf(output, "max: %d\n", elem->maxOccurs);
+        else
+            fprintf(output, "\n");
+    }
+    if (elem->namedType != NULL) {
+        fprintf(output, "  type: %s", elem->namedType);
+        if (elem->namedTypeNs != NULL)
+            fprintf(output, " ns %s\n", elem->namedTypeNs);
+        else
+            fprintf(output, "\n");
+    }
+    if (elem->substGroup != NULL) {
+        fprintf(output, "  substitutionGroup: %s", elem->substGroup);
+        if (elem->substGroupNs != NULL)
+            fprintf(output, " ns %s\n", elem->substGroupNs);
+        else
+            fprintf(output, "\n");
+    }
+    if (elem->value != NULL)
+        fprintf(output, "  default: %s", elem->value);
+}
+
+/**
+ * xmlSchemaAnnotDump:
+ * @output:  the file output
+ * @annot:  a annotation
+ *
+ * Dump the annotation
+ */
+static void
+xmlSchemaAnnotDump(FILE * output, xmlSchemaAnnotPtr annot)
+{
+    xmlChar *content;
+
+    if (annot == NULL)
+        return;
+
+    content = xmlNodeGetContent(annot->content);
+    if (content != NULL) {
+        fprintf(output, "  Annot: %s\n", content);
+        xmlFree(content);
+    } else
+        fprintf(output, "  Annot: empty\n");
+}
+
+/**
+ * xmlSchemaTypeDump:
+ * @output:  the file output
+ * @type:  a type structure
+ *
+ * Dump a SchemaType structure
+ */
+static void
+xmlSchemaTypeDump(xmlSchemaTypePtr type, FILE * output)
+{
+    if (type == NULL) {
+        fprintf(output, "Type: NULL\n");
+        return;
+    }
+    fprintf(output, "Type: ");
+    if (type->name != NULL)
+        fprintf(output, "%s, ", type->name);
+    else
+        fprintf(output, "no name");
+    switch (type->type) {
+        case XML_SCHEMA_TYPE_BASIC:
+            fprintf(output, "basic ");
+            break;
+        case XML_SCHEMA_TYPE_SIMPLE:
+            fprintf(output, "simple ");
+            break;
+        case XML_SCHEMA_TYPE_COMPLEX:
+            fprintf(output, "complex ");
+            break;
+        case XML_SCHEMA_TYPE_SEQUENCE:
+            fprintf(output, "sequence ");
+            break;
+        case XML_SCHEMA_TYPE_CHOICE:
+            fprintf(output, "choice ");
+            break;
+        case XML_SCHEMA_TYPE_ALL:
+            fprintf(output, "all ");
+            break;
+        case XML_SCHEMA_TYPE_UR:
+            fprintf(output, "ur ");
+            break;
+        case XML_SCHEMA_TYPE_RESTRICTION:
+            fprintf(output, "restriction ");
+            break;
+        case XML_SCHEMA_TYPE_EXTENSION:
+            fprintf(output, "extension ");
+            break;
+        default:
+            fprintf(output, "unknowntype%d ", type->type);
+            break;
+    }
+    if (type->base != NULL) {
+        fprintf(output, "base %s, ", type->base);
+    }
+    switch (type->contentType) {
+        case XML_SCHEMA_CONTENT_UNKNOWN:
+            fprintf(output, "unknown ");
+            break;
+        case XML_SCHEMA_CONTENT_EMPTY:
+            fprintf(output, "empty ");
+            break;
+        case XML_SCHEMA_CONTENT_ELEMENTS:
+            fprintf(output, "element ");
+            break;
+        case XML_SCHEMA_CONTENT_MIXED:
+            fprintf(output, "mixed ");
+            break;
+        case XML_SCHEMA_CONTENT_MIXED_OR_ELEMENTS:
+            fprintf(output, "mixed_or_elems ");
+            break;
+        case XML_SCHEMA_CONTENT_BASIC:
+            fprintf(output, "basic ");
+            break;
+        case XML_SCHEMA_CONTENT_SIMPLE:
+            fprintf(output, "simple ");
+            break;
+        case XML_SCHEMA_CONTENT_ANY:
+            fprintf(output, "any ");
+            break;
+    }
+    fprintf(output, "\n");
+    if ((type->minOccurs != 1) || (type->maxOccurs != 1)) {
+        fprintf(output, "  ");
+        if (type->minOccurs != 1)
+            fprintf(output, "min: %d ", type->minOccurs);
+        if (type->maxOccurs >= UNBOUNDED)
+            fprintf(output, "max: unbounded\n");
+        else if (type->maxOccurs != 1)
+            fprintf(output, "max: %d\n", type->maxOccurs);
+        else
+            fprintf(output, "\n");
+    }
+    if (type->annot != NULL)
+        xmlSchemaAnnotDump(output, type->annot);
+    if (type->subtypes != NULL) {
+        xmlSchemaTypePtr sub = type->subtypes;
+
+        fprintf(output, "  subtypes: ");
+        while (sub != NULL) {
+            fprintf(output, "%s ", sub->name);
+            sub = sub->next;
+        }
+        fprintf(output, "\n");
+    }
+
+}
+
+/**
+ * xmlSchemaDump:
+ * @output:  the file output
+ * @schema:  a schema structure
+ *
+ * Dump a Schema structure.
+ */
+void
+xmlSchemaDump(FILE * output, xmlSchemaPtr schema)
+{
+    if (schema == NULL) {
+        fprintf(output, "Schemas: NULL\n");
+        return;
+    }
+    fprintf(output, "Schemas: ");
+    if (schema->name != NULL)
+        fprintf(output, "%s, ", schema->name);
+    else
+        fprintf(output, "no name, ");
+    if (schema->targetNamespace != NULL)
+        fprintf(output, "%s", (const char *) schema->targetNamespace);
+    else
+        fprintf(output, "no target namespace");
+    fprintf(output, "\n");
+    if (schema->annot != NULL)
+        xmlSchemaAnnotDump(output, schema->annot);
+
+    xmlHashScan(schema->typeDecl, (xmlHashScanner) xmlSchemaTypeDump,
+                output);
+    xmlHashScanFull(schema->elemDecl,
+                    (xmlHashScannerFull) xmlSchemaElementDump, output);
+}
+#endif /* LIBXML_OUTPUT_ENABLED */
+
+/************************************************************************
+ *									*
+ * 			Utilities					*
+ *									*
+ ************************************************************************/
+
+/**
+ * xmlSchemaGetProp:
+ * @ctxt: the parser context
+ * @node: the node
+ * @name: the property name
+ * 
+ * Read a attribute value and internalize the string
+ *
+ * Returns the string or NULL if not present.
+ */
+static const xmlChar *
+xmlSchemaGetProp(xmlSchemaParserCtxtPtr ctxt, xmlNodePtr node,
+                 const char *name)
+{
+    xmlChar *val;
+    const xmlChar *ret;
+
+    val = xmlGetProp(node, BAD_CAST name);
+    if (val == NULL)
+        return(NULL);
+    ret = xmlDictLookup(ctxt->dict, val, -1);
+    xmlFree(val);
+    return(ret);
+}
+
+/**
+ * xmlSchemaGetNamespace:
+ * @ctxt: the parser context
+ * @schema: the schemas containing the declaration
+ * @node: the node
+ * @qname: the QName to analyze
+ * 
+ * Find the namespace name for the given declaration.
+ *
+ * Returns the local name for that declaration, as well as the namespace name
+ */
+static const xmlChar *
+xmlSchemaGetNamespace(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
+	              xmlNodePtr node, const xmlChar *qname,
+	     const xmlChar **namespace) {
+    int len;
+    const xmlChar *name, *prefix, *def = NULL;
+    xmlNsPtr ns;
+
+    *namespace = NULL;
+    
+    if (xmlStrEqual(node->name, BAD_CAST "element") ||
+        xmlStrEqual(node->name, BAD_CAST "attribute") ||
+	xmlStrEqual(node->name, BAD_CAST "simpleType") ||
+	xmlStrEqual(node->name, BAD_CAST "complexType")) {
+	def = xmlSchemaGetProp(ctxt, node, "targetNamespace");
+    }
+
+    qname = xmlDictLookup(ctxt->dict, qname, -1); /* intern the string */
+    name = xmlSplitQName3(qname, &len);
+    if (name == NULL) {
+        if (def == NULL) {
+	    if (xmlStrEqual(node->name, BAD_CAST "element")) {
+		if (schema->flags & XML_SCHEMAS_QUALIF_ELEM)
+		    *namespace = schema->targetNamespace;
+	    } else if (xmlStrEqual(node->name, BAD_CAST "attribute")) {
+		if (schema->flags & XML_SCHEMAS_QUALIF_ATTR)
+		    *namespace = schema->targetNamespace;
+	    } else if ((xmlStrEqual(node->name, BAD_CAST "simpleType")) ||
+	               (xmlStrEqual(node->name, BAD_CAST "complexType"))) {
+		*namespace = schema->targetNamespace;
+	    }
+	} else {
+	    *namespace = def;
+	}
+	return(qname);
+    }
+    name = xmlDictLookup(ctxt->dict, name, -1);
+    prefix = xmlDictLookup(ctxt->dict, qname, len);
+    if (def != NULL) {
+        xmlSchemaPErr(ctxt, node, XML_SCHEMAP_DEF_AND_PREFIX,
+                      "%s: presence of both prefix %s and targetNamespace\n",
+                      node->name, prefix);
+    }
+    ns = xmlSearchNs(node->doc, node, prefix);
+    if (ns == NULL) {
+        xmlSchemaPErr(ctxt, node, XML_SCHEMAP_PREFIX_UNDEFINED,
+                      "%s: the QName prefix %s is undefined\n",
+                      node->name, prefix);
+	return(name);
+    }
+    *namespace = xmlDictLookup(ctxt->dict, ns->href, -1);
+    return(name);
+}
+
+/************************************************************************
+ * 									*
+ * 			Parsing functions				*
+ * 									*
+ ************************************************************************/
+
+/**
+ * xmlSchemaGetElem:
+ * @schema:  the schemas context
+ * @name:  the element name
+ * @ns:  the element namespace
+ * @level: how deep is the request
+ *
+ * Lookup a an element in the schemas or the accessible schemas
+ *
+ * Returns the element definition or NULL if not found.
+ */
+static xmlSchemaElementPtr
+xmlSchemaGetElem(xmlSchemaPtr schema, const xmlChar * name,
+                 const xmlChar * namespace, int level)
+{
+    xmlSchemaElementPtr ret;
+    xmlSchemaImportPtr import = NULL;
+
+    if ((name == NULL) || (schema == NULL))
+        return (NULL);
+    
+    if (namespace == NULL) {
+        ret = xmlHashLookup2(schema->elemDecl, name, namespace);
+        if ((ret != NULL) &&
+	    ((level == 0) || (ret->flags & XML_SCHEMAS_ELEM_TOPLEVEL))) {
+            return (ret);
+	}
+    } else if ((schema->flags & XML_SCHEMAS_QUALIF_ELEM) == 0) {
+        if (xmlStrEqual(namespace, schema->targetNamespace))
+	    ret = xmlHashLookup2(schema->elemDecl, name, NULL);
+	else
+	    ret = xmlHashLookup2(schema->elemDecl, name, namespace);
+        if ((ret != NULL) &&
+	    ((level == 0) || (ret->flags & XML_SCHEMAS_ELEM_TOPLEVEL))) {
+            return (ret);
+	}
+    } else {
+	ret = xmlHashLookup2(schema->elemDecl, name, namespace);
+        if ((ret != NULL) &&
+	    ((level == 0) || (ret->flags & XML_SCHEMAS_ELEM_TOPLEVEL))) {
+            return (ret);
+	}
+    }
+    if (level > 0)
+    import = xmlHashLookup(schema->schemasImports, namespace);
+    if (import != NULL)
+	ret = xmlSchemaGetElem(import->schema, name, namespace, level + 1);
+#ifdef DEBUG
+    if (ret == NULL) {
+        if (namespace == NULL)
+            fprintf(stderr, "Unable to lookup type %s", name);
+        else
+            fprintf(stderr, "Unable to lookup type %s:%s", name,
+                    namespace);
+    }
+#endif
+    return (ret);
+}
+
+/**
+ * xmlSchemaGetType:
+ * @schema:  the schemas context
+ * @name:  the type name
+ * @ns:  the type namespace
+ *
+ * Lookup a type in the schemas or the predefined types
+ *
+ * Returns the group definition or NULL if not found.
+ */
+static xmlSchemaTypePtr
+xmlSchemaGetType(xmlSchemaPtr schema, const xmlChar * name,
+                 const xmlChar * namespace)
+{
+    xmlSchemaTypePtr ret;
+    xmlSchemaImportPtr import;
+
+    if (name == NULL)
+        return (NULL);
+    if (schema != NULL) {
+        ret = xmlHashLookup2(schema->typeDecl, name, namespace);
+        if (ret != NULL)
+            return (ret);
+    }
+    ret = xmlSchemaGetPredefinedType(name, namespace);
+    if (ret != NULL)
+	return (ret);
+    import = xmlHashLookup(schema->schemasImports, namespace);
+    if (import != NULL)
+	ret = xmlSchemaGetType(import->schema, name, namespace);
+#ifdef DEBUG
+    if (ret == NULL) {
+        if (namespace == NULL)
+            fprintf(stderr, "Unable to lookup type %s", name);
+        else
+            fprintf(stderr, "Unable to lookup type %s:%s", name,
+                    namespace);
+    }
+#endif
+    return (ret);
+}
+
+/************************************************************************
+ * 									*
+ * 			Parsing functions				*
+ * 									*
+ ************************************************************************/
+
+#define IS_BLANK_NODE(n)						\
+    (((n)->type == XML_TEXT_NODE) && (xmlSchemaIsBlank((n)->content)))
+
+/**
+ * xmlSchemaIsBlank:
+ * @str:  a string
+ *
+ * Check if a string is ignorable
+ *
+ * Returns 1 if the string is NULL or made of blanks chars, 0 otherwise
+ */
+static int
+xmlSchemaIsBlank(xmlChar * str)
+{
+    if (str == NULL)
+        return (1);
+    while (*str != 0) {
+        if (!(IS_BLANK_CH(*str)))
+            return (0);
+        str++;
+    }
+    return (1);
+}
+
+/**
+ * xmlSchemaAddNotation:
+ * @ctxt:  a schema validation context
+ * @schema:  the schema being built
+ * @name:  the item name
+ *
+ * Add an XML schema Attrribute declaration
+ * *WARNING* this interface is highly subject to change
+ *
+ * Returns the new struture or NULL in case of error
+ */
+static xmlSchemaNotationPtr
+xmlSchemaAddNotation(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
+                     const xmlChar * name)
+{
+    xmlSchemaNotationPtr ret = NULL;
+    int val;
+
+    if ((ctxt == NULL) || (schema == NULL) || (name == NULL))
+        return (NULL);
+
+    if (schema->notaDecl == NULL)
+        schema->notaDecl = xmlHashCreate(10);
+    if (schema->notaDecl == NULL)
+        return (NULL);
+
+    ret = (xmlSchemaNotationPtr) xmlMalloc(sizeof(xmlSchemaNotation));
+    if (ret == NULL) {
+        xmlSchemaPErrMemory(ctxt, "add annotation", NULL);
+        return (NULL);
+    }
+    memset(ret, 0, sizeof(xmlSchemaNotation));
+    ret->name = xmlDictLookup(ctxt->dict, name, -1);
+    val = xmlHashAddEntry2(schema->notaDecl, name, schema->targetNamespace,
+                           ret);
+    if (val != 0) {
+	xmlSchemaPErr(ctxt, (xmlNodePtr) ctxt->doc,
+		      XML_SCHEMAP_REDEFINED_NOTATION,
+                      "Notation %s already defined\n",
+                      name, NULL);
+        xmlFree(ret);
+        return (NULL);
+    }
+    return (ret);
+}
+
+
+/**
+ * xmlSchemaAddAttribute:
+ * @ctxt:  a schema validation context
+ * @schema:  the schema being built
+ * @name:  the item name
+ * @namespace:  the namespace
+ *
+ * Add an XML schema Attrribute declaration
+ * *WARNING* this interface is highly subject to change
+ *
+ * Returns the new struture or NULL in case of error
+ */
+static xmlSchemaAttributePtr
+xmlSchemaAddAttribute(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
+                      const xmlChar * name, const xmlChar * namespace)
+{
+    xmlSchemaAttributePtr ret = NULL;
+    int val;
+
+    if ((ctxt == NULL) || (schema == NULL) || (name == NULL))
+        return (NULL);
+
+#ifdef DEBUG
+    fprintf(stderr, "Adding attribute %s\n", name);
+    if (namespace != NULL)
+	fprintf(stderr, "  target namespace %s\n", namespace);
+#endif
+
+    if (schema->attrDecl == NULL)
+        schema->attrDecl = xmlHashCreate(10);
+    if (schema->attrDecl == NULL)
+        return (NULL);
+
+    ret = (xmlSchemaAttributePtr) xmlMalloc(sizeof(xmlSchemaAttribute));
+    if (ret == NULL) {
+        xmlSchemaPErrMemory(ctxt, "allocating attribute", NULL);
+        return (NULL);
+    }
+    memset(ret, 0, sizeof(xmlSchemaAttribute));
+    ret->name = xmlDictLookup(ctxt->dict, name, -1);
+    ret->targetNamespace = xmlDictLookup(ctxt->dict, namespace, -1);
+    val = xmlHashAddEntry3(schema->attrDecl, name,
+                           schema->targetNamespace, ctxt->container, ret);
+    if (val != 0) {
+	xmlSchemaPErr(ctxt, (xmlNodePtr) ctxt->doc,
+		      XML_SCHEMAP_REDEFINED_ATTR,
+                      "Attribute %s already defined\n",
+                      name, NULL);
+        xmlFree(ret);
+        return (NULL);
+    }
+    return (ret);
+}
+
+/**
+ * xmlSchemaAddAttributeGroup:
+ * @ctxt:  a schema validation context
+ * @schema:  the schema being built
+ * @name:  the item name
+ *
+ * Add an XML schema Attrribute Group declaration
+ *
+ * Returns the new struture or NULL in case of error
+ */
+static xmlSchemaAttributeGroupPtr
+xmlSchemaAddAttributeGroup(xmlSchemaParserCtxtPtr ctxt,
+                           xmlSchemaPtr schema, const xmlChar * name)
+{
+    xmlSchemaAttributeGroupPtr ret = NULL;
+    int val;
+
+    if ((ctxt == NULL) || (schema == NULL) || (name == NULL))
+        return (NULL);
+
+    if (schema->attrgrpDecl == NULL)
+        schema->attrgrpDecl = xmlHashCreate(10);
+    if (schema->attrgrpDecl == NULL)
+        return (NULL);
+
+    ret =
+        (xmlSchemaAttributeGroupPtr)
+        xmlMalloc(sizeof(xmlSchemaAttributeGroup));
+    if (ret == NULL) {
+        xmlSchemaPErrMemory(ctxt, "allocating attribute group", NULL);
+        return (NULL);
+    }
+    memset(ret, 0, sizeof(xmlSchemaAttributeGroup));
+    ret->name = xmlDictLookup(ctxt->dict, name, -1);
+    val = xmlHashAddEntry3(schema->attrgrpDecl, name,
+                           schema->targetNamespace, ctxt->container, ret);
+    if (val != 0) {
+	xmlSchemaPErr(ctxt, (xmlNodePtr) ctxt->doc,
+		      XML_SCHEMAP_REDEFINED_ATTRGROUP,
+                      "Attribute group %s already defined\n",
+                      name, NULL);
+        xmlFree(ret);
+        return (NULL);
+    }
+    return (ret);
+}
+
+/**
+ * xmlSchemaAddElement:
+ * @ctxt:  a schema validation context
+ * @schema:  the schema being built
+ * @name:  the type name
+ * @namespace:  the type namespace
+ *
+ * Add an XML schema Element declaration
+ * *WARNING* this interface is highly subject to change
+ *
+ * Returns the new struture or NULL in case of error
+ */
+static xmlSchemaElementPtr
+xmlSchemaAddElement(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
+                    const xmlChar * name, const xmlChar * namespace)
+{
+    xmlSchemaElementPtr ret = NULL;
+    int val;
+
+    if ((ctxt == NULL) || (schema == NULL) || (name == NULL))
+        return (NULL);
+
+#ifdef DEBUG
+    fprintf(stderr, "Adding element %s\n", name);
+    if (namespace != NULL)
+	fprintf(stderr, "  target namespace %s\n", namespace);
+#endif
+
+    if (schema->elemDecl == NULL)
+        schema->elemDecl = xmlHashCreate(10);
+    if (schema->elemDecl == NULL)
+        return (NULL);
+
+    ret = (xmlSchemaElementPtr) xmlMalloc(sizeof(xmlSchemaElement));
+    if (ret == NULL) {
+        xmlSchemaPErrMemory(ctxt, "allocating element", NULL);
+        return (NULL);
+    }
+    memset(ret, 0, sizeof(xmlSchemaElement));
+    ret->name = xmlDictLookup(ctxt->dict, name, -1);
+    ret->targetNamespace = xmlDictLookup(ctxt->dict, namespace, -1);
+    val = xmlHashAddEntry3(schema->elemDecl, name,
+                           namespace, ctxt->container, ret);
+    if (val != 0) {
+        char buf[100];
+
+        snprintf(buf, 99, "privatieelem %d", ctxt->counter++ + 1);
+        val = xmlHashAddEntry3(schema->elemDecl, name, (xmlChar *) buf,
+                               namespace, ret);
+        if (val != 0) {
+	    xmlSchemaPErr(ctxt, (xmlNodePtr) ctxt->doc,
+			  XML_SCHEMAP_REDEFINED_ELEMENT,
+			  "Element %s already defined\n",
+			  name, NULL);
+            xmlFree(ret);
+            return (NULL);
+        }
+    }
+    return (ret);
+}
+
+/**
+ * xmlSchemaAddType:
+ * @ctxt:  a schema validation context
+ * @schema:  the schema being built
+ * @name:  the item name
+ * @namespace:  the namespace
+ *
+ * Add an XML schema Simple Type definition
+ * *WARNING* this interface is highly subject to change
+ *
+ * Returns the new struture or NULL in case of error
+ */
+static xmlSchemaTypePtr
+xmlSchemaAddType(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
+                 const xmlChar * name, const xmlChar * namespace)
+{
+    xmlSchemaTypePtr ret = NULL;
+    int val;
+
+    if ((ctxt == NULL) || (schema == NULL) || (name == NULL))
+        return (NULL);
+
+#ifdef DEBUG
+    fprintf(stderr, "Adding type %s\n", name);
+    if (namespace != NULL)
+	fprintf(stderr, "  target namespace %s\n", namespace);
+#endif
+
+    if (schema->typeDecl == NULL)
+        schema->typeDecl = xmlHashCreate(10);
+    if (schema->typeDecl == NULL)
+        return (NULL);
+
+    ret = (xmlSchemaTypePtr) xmlMalloc(sizeof(xmlSchemaType));
+    if (ret == NULL) {
+        xmlSchemaPErrMemory(ctxt, "allocating type", NULL);
+        return (NULL);
+    }
+    memset(ret, 0, sizeof(xmlSchemaType));
+    ret->name = xmlDictLookup(ctxt->dict, name, -1);
+    ret->redef = NULL;
+    val = xmlHashAddEntry2(schema->typeDecl, name, namespace, ret);
+    if (val != 0) {
+        if (ctxt->includes == 0) {
+	    xmlSchemaPErr(ctxt, (xmlNodePtr) ctxt->doc,
+			  XML_SCHEMAP_REDEFINED_TYPE,
+			  "Type %s already defined\n",
+			  name, NULL);
+	    xmlFree(ret);
+	    return (NULL);
+	} else {
+	    xmlSchemaTypePtr prev;
+
+	    prev = xmlHashLookup2(schema->typeDecl, name, namespace);
+	    if (prev == NULL) {
+		xmlSchemaPErr(ctxt, (xmlNodePtr) ctxt->doc,
+			      XML_ERR_INTERNAL_ERROR,
+			      "Internal error on type %s definition\n",
+			      name, NULL);
+		xmlFree(ret);
+		return (NULL);
+	    }
+	    ret->redef = prev->redef;
+	    prev->redef = ret;
+	}
+    }
+    ret->minOccurs = 1;
+    ret->maxOccurs = 1;
+
+    return (ret);
+}
+
+/**
+ * xmlSchemaAddGroup:
+ * @ctxt:  a schema validation context
+ * @schema:  the schema being built
+ * @name:  the group name
+ *
+ * Add an XML schema Group definition
+ *
+ * Returns the new struture or NULL in case of error
+ */
+static xmlSchemaTypePtr
+xmlSchemaAddGroup(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
+                  const xmlChar * name)
+{
+    xmlSchemaTypePtr ret = NULL;
+    int val;
+
+    if ((ctxt == NULL) || (schema == NULL) || (name == NULL))
+        return (NULL);
+
+    if (schema->groupDecl == NULL)
+        schema->groupDecl = xmlHashCreate(10);
+    if (schema->groupDecl == NULL)
+        return (NULL);
+
+    ret = (xmlSchemaTypePtr) xmlMalloc(sizeof(xmlSchemaType));
+    if (ret == NULL) {
+        xmlSchemaPErrMemory(ctxt, "adding group", NULL);
+        return (NULL);
+    }
+    memset(ret, 0, sizeof(xmlSchemaType));
+    ret->name = xmlDictLookup(ctxt->dict, name, -1);
+    val =
+        xmlHashAddEntry2(schema->groupDecl, name, schema->targetNamespace,
+                         ret);
+    if (val != 0) {
+	xmlSchemaPErr(ctxt, (xmlNodePtr) ctxt->doc,
+		      XML_SCHEMAP_REDEFINED_GROUP,
+                      "Group %s already defined\n",
+                      name, NULL);
+        xmlFree(ret);
+        return (NULL);
+    }
+    ret->minOccurs = 1;
+    ret->maxOccurs = 1;
+
+    return (ret);
+}
+
+/************************************************************************
+ * 									*
+ *		Utilities for parsing					*
+ * 									*
+ ************************************************************************/
+
+/**
+ * xmlGetQNameProp:
+ * @ctxt:  a schema validation context
+ * @node:  a subtree containing XML Schema informations
+ * @name:  the attribute name
+ * @namespace:  the result namespace if any
+ *
+ * Extract a QName Attribute value
+ *
+ * Returns the NCName or NULL if not found, and also update @namespace
+ *    with the namespace URI
+ */
+static const xmlChar *
+xmlGetQNameProp(xmlSchemaParserCtxtPtr ctxt, xmlNodePtr node,
+                const char *name, const xmlChar ** namespace)
+{
+    const xmlChar *val;
+    xmlNsPtr ns;
+    const xmlChar *ret, *prefix;
+    int len;
+
+    *namespace = NULL;
+    val = xmlSchemaGetProp(ctxt, node, name);
+    if (val == NULL)
+        return (NULL);
+
+    if (!strchr((char *) val, ':')) {
+	ns = xmlSearchNs(node->doc, node, 0);
+	if (ns) {
+	    *namespace = xmlDictLookup(ctxt->dict, ns->href, -1);
+	    return (val);
+	}
+    }
+    ret = xmlSplitQName3(val, &len);
+    if (ret == NULL) {
+        return (val);
+    }
+    ret = xmlDictLookup(ctxt->dict, ret, -1);
+    prefix = xmlDictLookup(ctxt->dict, val, len);
+
+    ns = xmlSearchNs(node->doc, node, prefix);
+    if (ns == NULL) {
+        xmlSchemaPErr(ctxt, node, XML_SCHEMAP_PREFIX_UNDEFINED,
+                      "Attribute %s: the QName prefix %s is undefined\n",
+                      (const xmlChar *) name, prefix);
+    } else {
+        *namespace = xmlDictLookup(ctxt->dict, ns->href, -1);
+    }
+    return (ret);
+}
+
+/**
+ * xmlGetMaxOccurs:
+ * @ctxt:  a schema validation context
+ * @node:  a subtree containing XML Schema informations
+ *
+ * Get the maxOccurs property
+ *
+ * Returns the default if not found, or the value
+ */
+static int
+xmlGetMaxOccurs(xmlSchemaParserCtxtPtr ctxt, xmlNodePtr node)
+{
+    const xmlChar *val, *cur;
+    int ret = 0;
+
+    val = xmlSchemaGetProp(ctxt, node, "maxOccurs");
+    if (val == NULL)
+        return (1);
+
+    if (xmlStrEqual(val, (const xmlChar *) "unbounded")) {
+        return (UNBOUNDED);  /* encoding it with -1 might be another option */
+    }
+
+    cur = val;
+    while (IS_BLANK_CH(*cur))
+        cur++;
+    while ((*cur >= '0') && (*cur <= '9')) {
+        ret = ret * 10 + (*cur - '0');
+        cur++;
+    }
+    while (IS_BLANK_CH(*cur))
+        cur++;
+    if (*cur != 0) {
+        xmlSchemaPErr(ctxt, node, XML_SCHEMAP_INVALID_MAXOCCURS,
+                      "invalid value for maxOccurs: %s\n", val, NULL);
+        return (1);
+    }
+    return (ret);
+}
+
+/**
+ * xmlGetMinOccurs:
+ * @ctxt:  a schema validation context
+ * @node:  a subtree containing XML Schema informations
+ *
+ * Get the minOccurs property
+ *
+ * Returns the default if not found, or the value
+ */
+static int
+xmlGetMinOccurs(xmlSchemaParserCtxtPtr ctxt, xmlNodePtr node)
+{
+    const xmlChar *val, *cur;
+    int ret = 0;
+
+    val = xmlSchemaGetProp(ctxt, node, "minOccurs");
+    if (val == NULL)
+        return (1);
+
+    cur = val;
+    while (IS_BLANK_CH(*cur))
+        cur++;
+    while ((*cur >= '0') && (*cur <= '9')) {
+        ret = ret * 10 + (*cur - '0');
+        cur++;
+    }
+    while (IS_BLANK_CH(*cur))
+        cur++;
+    if (*cur != 0) {
+        xmlSchemaPErr(ctxt, node, XML_SCHEMAP_INVALID_MINOCCURS,
+                      "invalid value for minOccurs: %s\n", val, NULL);
+        return (1);
+    }
+    return (ret);
+}
+
+/**
+ * xmlGetBooleanProp:
+ * @ctxt:  a schema validation context
+ * @node:  a subtree containing XML Schema informations
+ * @name:  the attribute name
+ * @def:  the default value
+ *
+ * Get is a bolean property is set
+ *
+ * Returns the default if not found, 0 if found to be false,
+ *         1 if found to be true
+ */
+static int
+xmlGetBooleanProp(xmlSchemaParserCtxtPtr ctxt, xmlNodePtr node,
+                  const char *name, int def)
+{
+    const xmlChar *val;
+
+    val = xmlSchemaGetProp(ctxt, node, name);
+    if (val == NULL)
+        return (def);
+
+    if (xmlStrEqual(val, BAD_CAST "true"))
+        def = 1;
+    else if (xmlStrEqual(val, BAD_CAST "false"))
+        def = 0;
+    else {
+        xmlSchemaPErr(ctxt, node, XML_SCHEMAP_INVALID_BOOLEAN,
+                      "Attribute %s: the value %s is not boolean\n",
+                      (const xmlChar *) name, val);
+    }
+    return (def);
+}
+
+/************************************************************************
+ * 									*
+ *		Shema extraction from an Infoset			*
+ * 									*
+ ************************************************************************/
+static xmlSchemaTypePtr xmlSchemaParseSimpleType(xmlSchemaParserCtxtPtr
+                                                 ctxt, xmlSchemaPtr schema,
+                                                 xmlNodePtr node);
+static xmlSchemaTypePtr xmlSchemaParseComplexType(xmlSchemaParserCtxtPtr
+                                                  ctxt,
+                                                  xmlSchemaPtr schema,
+                                                  xmlNodePtr node);
+static xmlSchemaTypePtr xmlSchemaParseRestriction(xmlSchemaParserCtxtPtr
+                                                  ctxt,
+                                                  xmlSchemaPtr schema,
+                                                  xmlNodePtr node,
+                                                  int simple);
+static xmlSchemaTypePtr xmlSchemaParseSequence(xmlSchemaParserCtxtPtr ctxt,
+                                               xmlSchemaPtr schema,
+                                               xmlNodePtr node);
+static xmlSchemaTypePtr xmlSchemaParseAll(xmlSchemaParserCtxtPtr ctxt,
+                                          xmlSchemaPtr schema,
+                                          xmlNodePtr node);
+static xmlSchemaAttributePtr xmlSchemaParseAttribute(xmlSchemaParserCtxtPtr
+                                                     ctxt,
+                                                     xmlSchemaPtr schema,
+                                                     xmlNodePtr node);
+static xmlSchemaAttributeGroupPtr
+xmlSchemaParseAttributeGroup(xmlSchemaParserCtxtPtr ctxt,
+                             xmlSchemaPtr schema, xmlNodePtr node);
+static xmlSchemaTypePtr xmlSchemaParseChoice(xmlSchemaParserCtxtPtr ctxt,
+                                             xmlSchemaPtr schema,
+                                             xmlNodePtr node);
+static xmlSchemaTypePtr xmlSchemaParseList(xmlSchemaParserCtxtPtr ctxt,
+                                           xmlSchemaPtr schema,
+                                           xmlNodePtr node);
+static xmlSchemaAttributePtr
+xmlSchemaParseAnyAttribute(xmlSchemaParserCtxtPtr ctxt,
+                           xmlSchemaPtr schema, xmlNodePtr node);
+
+/**
+ * xmlSchemaParseAttrDecls:
+ * @ctxt:  a schema validation context
+ * @schema:  the schema being built
+ * @node:  a subtree containing XML Schema informations
+ * @type:  the hosting type
+ *
+ * parse a XML schema attrDecls declaration corresponding to
+ * <!ENTITY % attrDecls  
+ *       '((%attribute;| %attributeGroup;)*,(%anyAttribute;)?)'>
+ */
+static xmlNodePtr
+xmlSchemaParseAttrDecls(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
+                        xmlNodePtr child, xmlSchemaTypePtr type)
+{
+    xmlSchemaAttributePtr lastattr, attr;
+
+    lastattr = NULL;
+    while ((IS_SCHEMA(child, "attribute")) ||
+           (IS_SCHEMA(child, "attributeGroup"))) {
+        attr = NULL;
+        if (IS_SCHEMA(child, "attribute")) {
+            attr = xmlSchemaParseAttribute(ctxt, schema, child);
+        } else if (IS_SCHEMA(child, "attributeGroup")) {
+            attr = (xmlSchemaAttributePtr)
+                xmlSchemaParseAttributeGroup(ctxt, schema, child);
+        }
+        if (attr != NULL) {
+            if (lastattr == NULL) {
+                type->attributes = attr;
+                lastattr = attr;
+            } else {
+                lastattr->next = attr;
+                lastattr = attr;
+            }
+        }
+        child = child->next;
+    }
+    if (IS_SCHEMA(child, "anyAttribute")) {
+        attr = xmlSchemaParseAnyAttribute(ctxt, schema, child);
+        if (attr != NULL) {
+            if (lastattr == NULL) {
+                type->attributes = attr;
+                lastattr = attr;
+            } else {
+                lastattr->next = attr;
+                lastattr = attr;
+            }
+        }
+        child = child->next;
+    }
+    return (child);
+}
+
+/**
+ * xmlSchemaParseAnnotation:
+ * @ctxt:  a schema validation context
+ * @schema:  the schema being built
+ * @node:  a subtree containing XML Schema informations
+ *
+ * parse a XML schema Attrribute declaration
+ * *WARNING* this interface is highly subject to change
+ *
+ * Returns -1 in case of error, 0 if the declaration is inproper and
+ *         1 in case of success.
+ */
+static xmlSchemaAnnotPtr
+xmlSchemaParseAnnotation(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
+                         xmlNodePtr node)
+{
+    xmlSchemaAnnotPtr ret;
+
+    if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
+        return (NULL);
+    ret = xmlSchemaNewAnnot(ctxt, node);
+
+    return (ret);
+}
+
+/**
+ * xmlSchemaParseFacet:
+ * @ctxt:  a schema validation context
+ * @schema:  the schema being built
+ * @node:  a subtree containing XML Schema informations
+ *
+ * parse a XML schema Facet declaration
+ * *WARNING* this interface is highly subject to change
+ *
+ * Returns the new type structure or NULL in case of error
+ */
+static xmlSchemaFacetPtr
+xmlSchemaParseFacet(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
+                    xmlNodePtr node)
+{
+    xmlSchemaFacetPtr facet;
+    xmlNodePtr child = NULL;
+    const xmlChar *value;
+
+    if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
+        return (NULL);
+
+    facet = xmlSchemaNewFacet();
+    if (facet == NULL) {
+        xmlSchemaPErrMemory(ctxt, "allocating facet", node);
+        return (NULL);
+    }
+    facet->node = node;
+    value = xmlSchemaGetProp(ctxt, node, "value");
+    if (value == NULL) {
+        xmlSchemaPErr2(ctxt, node, child, XML_SCHEMAP_FACET_NO_VALUE,
+                       "Facet %s has no value\n", node->name, NULL);
+        xmlSchemaFreeFacet(facet);
+        return (NULL);
+    }
+    if (IS_SCHEMA(node, "minInclusive")) {
+        facet->type = XML_SCHEMA_FACET_MININCLUSIVE;
+    } else if (IS_SCHEMA(node, "minExclusive")) {
+        facet->type = XML_SCHEMA_FACET_MINEXCLUSIVE;
+    } else if (IS_SCHEMA(node, "maxInclusive")) {
+        facet->type = XML_SCHEMA_FACET_MAXINCLUSIVE;
+    } else if (IS_SCHEMA(node, "maxExclusive")) {
+        facet->type = XML_SCHEMA_FACET_MAXEXCLUSIVE;
+    } else if (IS_SCHEMA(node, "totalDigits")) {
+        facet->type = XML_SCHEMA_FACET_TOTALDIGITS;
+    } else if (IS_SCHEMA(node, "fractionDigits")) {
+        facet->type = XML_SCHEMA_FACET_FRACTIONDIGITS;
+    } else if (IS_SCHEMA(node, "pattern")) {
+        facet->type = XML_SCHEMA_FACET_PATTERN;
+    } else if (IS_SCHEMA(node, "enumeration")) {
+        facet->type = XML_SCHEMA_FACET_ENUMERATION;
+    } else if (IS_SCHEMA(node, "whiteSpace")) {
+        facet->type = XML_SCHEMA_FACET_WHITESPACE;
+    } else if (IS_SCHEMA(node, "length")) {
+        facet->type = XML_SCHEMA_FACET_LENGTH;
+    } else if (IS_SCHEMA(node, "maxLength")) {
+        facet->type = XML_SCHEMA_FACET_MAXLENGTH;
+    } else if (IS_SCHEMA(node, "minLength")) {
+        facet->type = XML_SCHEMA_FACET_MINLENGTH;
+    } else {
+        xmlSchemaPErr2(ctxt, node, child, XML_SCHEMAP_UNKNOWN_FACET_TYPE,
+                       "Unknown facet type %s\n", node->name, NULL);
+        xmlSchemaFreeFacet(facet);
+        return (NULL);
+    }
+    facet->id = xmlSchemaGetProp(ctxt, node, "id");
+    facet->value = value;
+    child = node->children;
+
+    if (IS_SCHEMA(child, "annotation")) {
+        facet->annot = xmlSchemaParseAnnotation(ctxt, schema, child);
+        child = child->next;
+    }
+    if (child != NULL) {
+        xmlSchemaPErr2(ctxt, node, child, XML_SCHEMAP_UNKNOWN_FACET_CHILD,
+                       "Facet %s has unexpected child content\n",
+                       node->name, NULL);
+    }
+    return (facet);
+}
+
+/**
+ * xmlSchemaParseAny:
+ * @ctxt:  a schema validation context
+ * @schema:  the schema being built
+ * @node:  a subtree containing XML Schema informations
+ *
+ * parse a XML schema Any declaration
+ * *WARNING* this interface is highly subject to change
+ *
+ * Returns the new type structure or NULL in case of error
+ */
+static xmlSchemaTypePtr
+xmlSchemaParseAny(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
+                  xmlNodePtr node)
+{
+    xmlSchemaTypePtr type;
+    xmlNodePtr child = NULL;
+    xmlChar name[30];
+
+    if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
+        return (NULL);
+    snprintf((char *) name, 30, "any %d", ctxt->counter++ + 1);
+    type = xmlSchemaAddType(ctxt, schema, name, NULL);
+    if (type == NULL)
+        return (NULL);
+    type->node = node;
+    type->type = XML_SCHEMA_TYPE_ANY;
+    child = node->children;
+    type->minOccurs = xmlGetMinOccurs(ctxt, node);
+    type->maxOccurs = xmlGetMaxOccurs(ctxt, node);
+
+    if (IS_SCHEMA(child, "annotation")) {
+        type->annot = xmlSchemaParseAnnotation(ctxt, schema, child);
+        child = child->next;
+    }
+    if (child != NULL) {
+        xmlSchemaPErr2(ctxt, node, child,
+                       XML_SCHEMAP_UNKNOWN_SEQUENCE_CHILD,
+                       "Sequence %s has unexpected content\n", type->name,
+                       NULL);
+    }
+
+    return (type);
+}
+
+/**
+ * xmlSchemaParseNotation:
+ * @ctxt:  a schema validation context
+ * @schema:  the schema being built
+ * @node:  a subtree containing XML Schema informations
+ *
+ * parse a XML schema Notation declaration
+ *
+ * Returns the new structure or NULL in case of error
+ */
+static xmlSchemaNotationPtr
+xmlSchemaParseNotation(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
+                       xmlNodePtr node)
+{
+    const xmlChar *name;
+    xmlSchemaNotationPtr ret;
+    xmlNodePtr child = NULL;
+
+    if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
+        return (NULL);
+    name = xmlSchemaGetProp(ctxt, node, "name");
+    if (name == NULL) {
+        xmlSchemaPErr2(ctxt, node, child, XML_SCHEMAP_NOTATION_NO_NAME,
+                       "Notation has no name\n", NULL, NULL);
+        return (NULL);
+    }
+    ret = xmlSchemaAddNotation(ctxt, schema, name);
+    if (ret == NULL) {
+        return (NULL);
+    }
+    child = node->children;
+    if (IS_SCHEMA(child, "annotation")) {
+        ret->annot = xmlSchemaParseAnnotation(ctxt, schema, child);
+        child = child->next;
+    }
+    if (child != NULL) {
+        xmlSchemaPErr2(ctxt, node, child,
+                       XML_SCHEMAP_UNKNOWN_NOTATION_CHILD,
+                       "notation %s has unexpected content\n", name, NULL);
+    }
+
+    return (ret);
+}
+
+/**
+ * xmlSchemaParseAnyAttribute:
+ * @ctxt:  a schema validation context
+ * @schema:  the schema being built
+ * @node:  a subtree containing XML Schema informations
+ *
+ * parse a XML schema AnyAttrribute declaration
+ * *WARNING* this interface is highly subject to change
+ *
+ * Returns an attribute def structure or NULL
+ */
+static xmlSchemaAttributePtr
+xmlSchemaParseAnyAttribute(xmlSchemaParserCtxtPtr ctxt,
+                           xmlSchemaPtr schema, xmlNodePtr node)
+{
+    const xmlChar *processContents;
+    xmlSchemaAttributePtr ret;
+    xmlNodePtr child = NULL;
+    char name[100];
+    const xmlChar *local, *ns;
+
+
+    if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
+        return (NULL);
+
+    snprintf(name, 99, "anyattr %d", ctxt->counter++ + 1);
+    local = xmlSchemaGetNamespace(ctxt, schema, node, BAD_CAST "anyattr", &ns);
+    ret = xmlSchemaAddAttribute(ctxt, schema, BAD_CAST name, ns);
+    if (ret == NULL) {
+        return (NULL);
+    }
+    ret->id = xmlSchemaGetProp(ctxt, node, "id");
+    processContents = xmlSchemaGetProp(ctxt, node, "processContents");
+    if ((processContents == NULL)
+        || (xmlStrEqual(processContents, (const xmlChar *) "strict"))) {
+        ret->occurs = XML_SCHEMAS_ANYATTR_STRICT;
+    } else if (xmlStrEqual(processContents, (const xmlChar *) "skip")) {
+        ret->occurs = XML_SCHEMAS_ANYATTR_SKIP;
+    } else if (xmlStrEqual(processContents, (const xmlChar *) "lax")) {
+        ret->occurs = XML_SCHEMAS_ANYATTR_LAX;
+    } else {
+        xmlSchemaPErr2(ctxt, node, child,
+                       XML_SCHEMAP_UNKNOWN_PROCESSCONTENT_CHILD,
+                       "anyAttribute has unexpected content for processContents: %s\n",
+                       processContents, NULL);
+        ret->occurs = XML_SCHEMAS_ANYATTR_STRICT;
+    }
+
+    child = node->children;
+    if (IS_SCHEMA(child, "annotation")) {
+        ret->annot = xmlSchemaParseAnnotation(ctxt, schema, child);
+        child = child->next;
+    }
+    if (child != NULL) {
+        xmlSchemaPErr2(ctxt, node, child,
+                       XML_SCHEMAP_UNKNOWN_ANYATTRIBUTE_CHILD,
+                       "anyAttribute %s has unexpected content\n",
+                       (const xmlChar *) name, NULL);
+    }
+
+    return (ret);
+}
+
+
+/**
+ * xmlSchemaParseAttribute:
+ * @ctxt:  a schema validation context
+ * @schema:  the schema being built
+ * @node:  a subtree containing XML Schema informations
+ *
+ * parse a XML schema Attrribute declaration
+ * *WARNING* this interface is highly subject to change
+ *
+ * Returns -1 in case of error, 0 if the declaration is inproper and
+ *         1 in case of success.
+ */
+static xmlSchemaAttributePtr
+xmlSchemaParseAttribute(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
+                        xmlNodePtr node)
+{
+    const xmlChar *name, *refNs = NULL, *ref = NULL, *attrVal;
+    xmlSchemaAttributePtr ret;
+    xmlNodePtr child = NULL;
+    char buf[100];
+
+    if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
+        return (NULL);
+    name = xmlSchemaGetProp(ctxt, node, "name");
+    if (name == NULL) {
+
+        ref = xmlGetQNameProp(ctxt, node, "ref", &refNs);
+        if (ref == NULL) {
+            xmlSchemaPErr2(ctxt, node, child,
+                           XML_SCHEMAP_ATTR_NONAME_NOREF,
+                           "Attribute has no name nor ref\n", NULL, NULL);
+            return (NULL);
+        }
+        snprintf(buf, 99, "anonattr %d", ctxt->counter++ + 1);
+        name = (const xmlChar *) buf;
+	ret = xmlSchemaAddAttribute(ctxt, schema, name, NULL);
+    } else {
+        const xmlChar *local, *ns;
+
+        local = xmlSchemaGetNamespace(ctxt, schema, node, name, &ns);
+	ret = xmlSchemaAddAttribute(ctxt, schema, local, ns);
+    }
+    if (ret == NULL) {
+        return (NULL);
+    }
+
+    /* Read the "use" attribute. */
+	attrVal = xmlSchemaGetProp(ctxt, node, "use");
+	if (attrVal != NULL) {
+		if (xmlStrEqual(attrVal, BAD_CAST "optional"))
+			ret->occurs = XML_SCHEMAS_ATTR_USE_OPTIONAL;
+		else if (xmlStrEqual(attrVal, BAD_CAST "prohibited"))
+			ret->occurs = XML_SCHEMAS_ATTR_USE_PROHIBITED;
+		else if (xmlStrEqual(attrVal, BAD_CAST "required"))
+			ret->occurs = XML_SCHEMAS_ATTR_USE_REQUIRED;
+    else
+		  xmlSchemaPErr(ctxt, node,
+                    XML_SCHEMAP_INVALID_ATTR_USE,
+                    "attribute %s has an invalid value for \"use\"\n", name, NULL);
+	} else
+		ret->occurs = XML_SCHEMAS_ATTR_USE_OPTIONAL;
+
+    ret->ref = ref;
+    ret->refNs = refNs;
+    if ((ret->targetNamespace != NULL) &&
+        ((schema->flags & XML_SCHEMAS_QUALIF_ATTR) == 0) &&
+	(xmlStrEqual(ret->targetNamespace, schema->targetNamespace)))
+	ret->flags |= XML_SCHEMAS_ATTR_NSDEFAULT;
+    ret->typeName = xmlGetQNameProp(ctxt, node, "type", &(ret->typeNs));
+    ret->node = node;
+    child = node->children;
+    if (IS_SCHEMA(child, "annotation")) {
+        ret->annot = xmlSchemaParseAnnotation(ctxt, schema, child);
+        child = child->next;
+    }
+    if (IS_SCHEMA(child, "simpleType")) {
+        ret->subtypes = xmlSchemaParseSimpleType(ctxt, schema, child);
+        child = child->next;
+    }
+    if (child != NULL) {
+        xmlSchemaPErr2(ctxt, node, child, XML_SCHEMAP_UNKNOWN_ATTR_CHILD,
+                       "attribute %s has unexpected content\n", name,
+                       NULL);
+    }
+
+    return (ret);
+}
+
+/**
+ * xmlSchemaParseAttributeGroup:
+ * @ctxt:  a schema validation context
+ * @schema:  the schema being built
+ * @node:  a subtree containing XML Schema informations
+ *
+ * parse a XML schema Attribute Group declaration
+ * *WARNING* this interface is highly subject to change
+ *
+ * Returns the attribute group or NULL in case of error.
+ */
+static xmlSchemaAttributeGroupPtr
+xmlSchemaParseAttributeGroup(xmlSchemaParserCtxtPtr ctxt,
+                             xmlSchemaPtr schema, xmlNodePtr node)
+{
+    const xmlChar *name, *refNs = NULL, *ref = NULL;
+    xmlSchemaAttributeGroupPtr ret;
+    xmlSchemaAttributePtr last = NULL, attr;
+    xmlNodePtr child = NULL;
+    const xmlChar *oldcontainer;
+    char buf[100];
+
+    if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
+        return (NULL);
+    oldcontainer = ctxt->container;
+    name = xmlSchemaGetProp(ctxt, node, "name");
+    if (name == NULL) {
+
+        ref = xmlGetQNameProp(ctxt, node, "ref", &refNs);
+        if (ref == NULL) {
+            xmlSchemaPErr2(ctxt, node, child,
+                           XML_SCHEMAP_ATTRGRP_NONAME_NOREF,
+                           "AttributeGroup has no name nor ref\n", NULL,
+                           NULL);
+            return (NULL);
+        }
+        snprintf(buf, 99, "anonattrgroup %d", ctxt->counter++ + 1);
+        name = (const xmlChar *) buf;
+        if (name == NULL) {
+	    xmlSchemaPErrMemory(ctxt, "creating attribute group", node);
+            return (NULL);
+        }
+    }
+    ret = xmlSchemaAddAttributeGroup(ctxt, schema, name);
+    if (ret == NULL) {
+        return (NULL);
+    }
+    ret->ref = ref;
+    ret->refNs = refNs;
+    ret->type = XML_SCHEMA_TYPE_ATTRIBUTEGROUP;
+    ret->node = node;
+    child = node->children;
+    ctxt->container = name;
+    if (IS_SCHEMA(child, "annotation")) {
+        ret->annot = xmlSchemaParseAnnotation(ctxt, schema, child);
+        child = child->next;
+    }
+    while ((IS_SCHEMA(child, "attribute")) ||
+           (IS_SCHEMA(child, "attributeGroup"))) {
+        attr = NULL;
+        if (IS_SCHEMA(child, "attribute")) {
+            attr = xmlSchemaParseAttribute(ctxt, schema, child);
+        } else if (IS_SCHEMA(child, "attributeGroup")) {
+            attr = (xmlSchemaAttributePtr)
+                xmlSchemaParseAttributeGroup(ctxt, schema, child);
+        }
+        if (attr != NULL) {
+            if (last == NULL) {
+                ret->attributes = attr;
+                last = attr;
+            } else {
+                last->next = attr;
+                last = attr;
+            }
+        }
+        child = child->next;
+    }
+    if (IS_SCHEMA(child, "anyAttribute")) {
+        TODO
+	child = child->next;
+    }
+    if (child != NULL) {
+        xmlSchemaPErr2(ctxt, node, child,
+                       XML_SCHEMAP_UNKNOWN_ATTRGRP_CHILD,
+                       "attribute group %s has unexpected content\n", name,
+                       NULL);
+    }
+    ctxt->container = oldcontainer;
+    return (ret);
+}
+
+/**
+ * xmlSchemaParseElement:
+ * @ctxt:  a schema validation context
+ * @schema:  the schema being built
+ * @node:  a subtree containing XML Schema informations
+ *
+ * parse a XML schema Element declaration
+ * *WARNING* this interface is highly subject to change
+ *
+ * Returns -1 in case of error, 0 if the declaration is inproper and
+ *         1 in case of success.
+ */
+static xmlSchemaElementPtr
+xmlSchemaParseElement(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
+                      xmlNodePtr node, int toplevel)
+{
+    const xmlChar *name, *fixed;
+    const xmlChar *refNs = NULL, *ref = NULL;
+    xmlSchemaElementPtr ret;
+    xmlNodePtr child = NULL;
+    const xmlChar *oldcontainer;
+    char buf[100];
+
+    if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
+        return (NULL);
+    oldcontainer = ctxt->container;
+    name = xmlSchemaGetProp(ctxt, node, "name");
+    if (name == NULL) {
+
+        ref = xmlGetQNameProp(ctxt, node, "ref", &refNs);
+        if (ref == NULL) {
+            xmlSchemaPErr2(ctxt, node, child,
+                           XML_SCHEMAP_ELEM_NONAME_NOREF,
+                           "Element has no name nor ref\n", NULL, NULL);
+            return (NULL);
+        }
+        snprintf(buf, 99, "anonelem %d", ctxt->counter++ + 1);
+        name = (const xmlChar *) buf;
+	ret = xmlSchemaAddElement(ctxt, schema, name, NULL);
+    } else {
+        const xmlChar *local, *ns;
+
+        local = xmlSchemaGetNamespace(ctxt, schema, node, name, &ns);
+	ret = xmlSchemaAddElement(ctxt, schema, local, ns);
+    }
+    if (ret != NULL)
+	ret->node = node;
+    if (ret == NULL) {
+        return (NULL);
+    }
+    ret->type = XML_SCHEMA_TYPE_ELEMENT;
+    ret->ref = ref;
+    ret->refNs = refNs;
+    if (ref != NULL)
+        ret->flags |= XML_SCHEMAS_ELEM_REF;
+    if (toplevel)
+        ret->flags |= XML_SCHEMAS_ELEM_TOPLEVEL;
+    if (xmlGetBooleanProp(ctxt, node, "nillable", 0))
+        ret->flags |= XML_SCHEMAS_ELEM_NILLABLE;
+    if (xmlGetBooleanProp(ctxt, node, "abstract", 0))
+        ret->flags |= XML_SCHEMAS_ELEM_NILLABLE;
+    ctxt->container = name;
+
+    ret->id = xmlSchemaGetProp(ctxt, node, "id");
+    ret->namedType =
+        xmlGetQNameProp(ctxt, node, "type", &(ret->namedTypeNs));
+    ret->substGroup =
+        xmlGetQNameProp(ctxt, node, "substitutionGroup",
+                        &(ret->substGroupNs));
+    fixed = xmlSchemaGetProp(ctxt, node, "fixed");
+    ret->minOccurs = xmlGetMinOccurs(ctxt, node);
+    ret->maxOccurs = xmlGetMaxOccurs(ctxt, node);
+
+    ret->value = xmlSchemaGetProp(ctxt, node, "default");
+    if ((ret->value != NULL) && (fixed != NULL)) {
+        xmlSchemaPErr2(ctxt, node, child, XML_SCHEMAP_ELEM_DEFAULT_FIXED,
+                       "Element %s has both default and fixed\n",
+		       ret->name, NULL);
+    } else if (fixed != NULL) {
+        ret->flags |= XML_SCHEMAS_ELEM_FIXED;
+        ret->value = fixed;
+    }
+
+    child = node->children;
+    if (IS_SCHEMA(child, "annotation")) {
+        ret->annot = xmlSchemaParseAnnotation(ctxt, schema, child);
+        child = child->next;
+    }
+    if (IS_SCHEMA(child, "complexType")) {
+        ret->subtypes = xmlSchemaParseComplexType(ctxt, schema, child);
+        child = child->next;
+    } else if (IS_SCHEMA(child, "simpleType")) {
+        ret->subtypes = xmlSchemaParseSimpleType(ctxt, schema, child);
+        child = child->next;
+    }
+    while ((IS_SCHEMA(child, "unique")) ||
+           (IS_SCHEMA(child, "key")) || (IS_SCHEMA(child, "keyref"))) {
+        TODO child = child->next;
+    }
+    if (child != NULL) {
+        xmlSchemaPErr2(ctxt, node, child, XML_SCHEMAP_UNKNOWN_ELEM_CHILD,
+                       "element %s has unexpected content\n", name, NULL);
+    }
+
+    ctxt->container = oldcontainer;
+    return (ret);
+}
+
+/**
+ * xmlSchemaParseUnion:
+ * @ctxt:  a schema validation context
+ * @schema:  the schema being built
+ * @node:  a subtree containing XML Schema informations
+ *
+ * parse a XML schema Union definition
+ * *WARNING* this interface is highly subject to change
+ *
+ * Returns -1 in case of error, 0 if the declaration is inproper and
+ *         1 in case of success.
+ */
+static xmlSchemaTypePtr
+xmlSchemaParseUnion(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
+                    xmlNodePtr node)
+{
+    xmlSchemaTypePtr type, subtype, last = NULL;
+    xmlNodePtr child = NULL;
+    xmlChar name[30];
+
+    if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
+        return (NULL);
+
+
+    snprintf((char *) name, 30, "union %d", ctxt->counter++ + 1);
+    type = xmlSchemaAddType(ctxt, schema, name, NULL);
+    if (type == NULL)
+        return (NULL);
+    type->node = node;
+    type->type = XML_SCHEMA_TYPE_UNION;
+    type->id = xmlSchemaGetProp(ctxt, node, "id");
+    type->ref = xmlSchemaGetProp(ctxt, node, "memberTypes");
+
+    child = node->children;
+    if (IS_SCHEMA(child, "annotation")) {
+        type->annot = xmlSchemaParseAnnotation(ctxt, schema, child);
+        child = child->next;
+    }
+    while (IS_SCHEMA(child, "simpleType")) {
+        subtype = (xmlSchemaTypePtr)
+            xmlSchemaParseSimpleType(ctxt, schema, child);
+        if (subtype != NULL) {
+            if (last == NULL) {
+                type->subtypes = subtype;
+                last = subtype;
+            } else {
+                last->next = subtype;
+                last = subtype;
+            }
+            last->next = NULL;
+        }
+        child = child->next;
+    }
+    if (child != NULL) {
+        xmlSchemaPErr2(ctxt, node, child, XML_SCHEMAP_UNKNOWN_UNION_CHILD,
+                       "Union %s has unexpected content\n", type->name,
+                       NULL);
+    }
+    return (type);
+}
+
+/**
+ * xmlSchemaParseList:
+ * @ctxt:  a schema validation context
+ * @schema:  the schema being built
+ * @node:  a subtree containing XML Schema informations
+ *
+ * parse a XML schema List definition
+ * *WARNING* this interface is highly subject to change
+ *
+ * Returns -1 in case of error, 0 if the declaration is inproper and
+ *         1 in case of success.
+ */
+static xmlSchemaTypePtr
+xmlSchemaParseList(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
+                   xmlNodePtr node)
+{
+    xmlSchemaTypePtr type, subtype;
+    xmlNodePtr child = NULL;
+    xmlChar name[30];
+
+    if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
+        return (NULL);
+
+    snprintf((char *) name, 30, "list %d", ctxt->counter++ + 1);
+    type = xmlSchemaAddType(ctxt, schema, name, NULL);
+    if (type == NULL)
+        return (NULL);
+    type->node = node;
+    type->type = XML_SCHEMA_TYPE_LIST;
+    type->id = xmlSchemaGetProp(ctxt, node, "id");
+    type->ref = xmlGetQNameProp(ctxt, node, "ref", &(type->refNs));
+
+    child = node->children;
+    if (IS_SCHEMA(child, "annotation")) {
+        type->annot = xmlSchemaParseAnnotation(ctxt, schema, child);
+        child = child->next;
+    }
+    subtype = NULL;
+    if (IS_SCHEMA(child, "simpleType")) {
+        subtype = (xmlSchemaTypePtr)
+            xmlSchemaParseSimpleType(ctxt, schema, child);
+        child = child->next;
+        type->subtypes = subtype;
+    }
+    if (child != NULL) {
+        xmlSchemaPErr2(ctxt, node, child, XML_SCHEMAP_UNKNOWN_LIST_CHILD,
+                       "List %s has unexpected content\n", type->name,
+                       NULL);
+    }
+    return (type);
+}
+
+/**
+ * xmlSchemaParseSimpleType:
+ * @ctxt:  a schema validation context
+ * @schema:  the schema being built
+ * @node:  a subtree containing XML Schema informations
+ *
+ * parse a XML schema Simple Type definition
+ * *WARNING* this interface is highly subject to change
+ *
+ * Returns -1 in case of error, 0 if the declaration is inproper and
+ *         1 in case of success.
+ */
+static xmlSchemaTypePtr
+xmlSchemaParseSimpleType(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
+                         xmlNodePtr node)
+{
+    xmlSchemaTypePtr type, subtype;
+    xmlNodePtr child = NULL;
+    const xmlChar *name;
+
+    if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
+        return (NULL);
+
+
+    name = xmlSchemaGetProp(ctxt, node, "name");
+    if (name == NULL) {
+        char buf[100];
+
+        snprintf(buf, 99, "simpletype %d", ctxt->counter++ + 1);
+	type = xmlSchemaAddType(ctxt, schema, (const xmlChar *)buf, NULL);
+    } else {
+	const xmlChar *local, *ns;
+
+        local = xmlSchemaGetNamespace(ctxt, schema, node, name, &ns);
+	type = xmlSchemaAddType(ctxt, schema, local, ns);
+    }
+    if (type == NULL)
+        return (NULL);
+    type->node = node;
+    type->type = XML_SCHEMA_TYPE_SIMPLE;
+    type->id = xmlSchemaGetProp(ctxt, node, "id");
+
+    child = node->children;
+    if (IS_SCHEMA(child, "annotation")) {
+        type->annot = xmlSchemaParseAnnotation(ctxt, schema, child);
+        child = child->next;
+    }
+    subtype = NULL;
+    if (IS_SCHEMA(child, "restriction")) {
+        subtype = (xmlSchemaTypePtr)
+            xmlSchemaParseRestriction(ctxt, schema, child, 1);
+        child = child->next;
+    } else if (IS_SCHEMA(child, "list")) {
+        subtype = (xmlSchemaTypePtr)
+            xmlSchemaParseList(ctxt, schema, child);
+        child = child->next;
+    } else if (IS_SCHEMA(child, "union")) {
+        subtype = (xmlSchemaTypePtr)
+            xmlSchemaParseUnion(ctxt, schema, child);
+        child = child->next;
+    }
+    type->subtypes = subtype;
+    if (child != NULL) {
+        xmlSchemaPErr2(ctxt, node, child,
+                       XML_SCHEMAP_UNKNOWN_SIMPLETYPE_CHILD,
+                       "SimpleType %s has unexpected content\n",
+                       type->name, NULL);
+    }
+
+    return (type);
+}
+
+
+/**
+ * xmlSchemaParseGroup:
+ * @ctxt:  a schema validation context
+ * @schema:  the schema being built
+ * @node:  a subtree containing XML Schema informations
+ *
+ * parse a XML schema Group definition
+ * *WARNING* this interface is highly subject to change
+ *
+ * Returns -1 in case of error, 0 if the declaration is inproper and
+ *         1 in case of success.
+ */
+static xmlSchemaTypePtr
+xmlSchemaParseGroup(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
+                    xmlNodePtr node)
+{
+    xmlSchemaTypePtr type, subtype;
+    xmlNodePtr child = NULL;
+    const xmlChar *name;
+    const xmlChar *ref = NULL, *refNs = NULL;
+    char buf[100];
+
+    if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
+        return (NULL);
+
+
+    name = xmlSchemaGetProp(ctxt, node, "name");
+    if (name == NULL) {
+
+        ref = xmlGetQNameProp(ctxt, node, "ref", &refNs);
+        if (ref == NULL) {
+            xmlSchemaPErr2(ctxt, node, child,
+                           XML_SCHEMAP_GROUP_NONAME_NOREF,
+                           "Group has no name nor ref\n", NULL, NULL);
+            return (NULL);
+        }
+	if (refNs == NULL)
+	    refNs = schema->targetNamespace;
+        snprintf(buf, 99, "anongroup %d", ctxt->counter++ + 1);
+        name = (const xmlChar *) buf;
+    }
+    type = xmlSchemaAddGroup(ctxt, schema, name);
+    if (type == NULL)
+        return (NULL);
+
+    type->node = node;
+    type->type = XML_SCHEMA_TYPE_GROUP;
+    type->id = xmlSchemaGetProp(ctxt, node, "id");
+    type->ref = ref;
+    type->refNs = refNs;
+    type->minOccurs = xmlGetMinOccurs(ctxt, node);
+    type->maxOccurs = xmlGetMaxOccurs(ctxt, node);
+
+    child = node->children;
+    if (IS_SCHEMA(child, "annotation")) {
+        type->annot = xmlSchemaParseAnnotation(ctxt, schema, child);
+        child = child->next;
+    }
+    subtype = NULL;
+    if (IS_SCHEMA(child, "all")) {
+        subtype = (xmlSchemaTypePtr)
+            xmlSchemaParseAll(ctxt, schema, child);
+        child = child->next;
+    } else if (IS_SCHEMA(child, "choice")) {
+        subtype = xmlSchemaParseChoice(ctxt, schema, child);
+        child = child->next;
+    } else if (IS_SCHEMA(child, "sequence")) {
+        subtype = (xmlSchemaTypePtr)
+            xmlSchemaParseSequence(ctxt, schema, child);
+        child = child->next;
+    }
+    if (subtype != NULL)
+        type->subtypes = subtype;
+    if (child != NULL) {
+        xmlSchemaPErr2(ctxt, node, child, XML_SCHEMAP_UNKNOWN_GROUP_CHILD,
+                       "Group %s has unexpected content\n", type->name,
+                       NULL);
+    }
+
+    return (type);
+}
+
+/**
+ * xmlSchemaParseAll:
+ * @ctxt:  a schema validation context
+ * @schema:  the schema being built
+ * @node:  a subtree containing XML Schema informations
+ *
+ * parse a XML schema All definition
+ * *WARNING* this interface is highly subject to change
+ *
+ * Returns -1 in case of error, 0 if the declaration is inproper and
+ *         1 in case of success.
+ */
+static xmlSchemaTypePtr
+xmlSchemaParseAll(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
+                  xmlNodePtr node)
+{
+    xmlSchemaTypePtr type, subtype, last = NULL;
+    xmlNodePtr child = NULL;
+    xmlChar name[30];
+
+    if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
+        return (NULL);
+
+
+    snprintf((char *) name, 30, "all%d", ctxt->counter++ + 1);
+    type = xmlSchemaAddType(ctxt, schema, name, NULL);
+    if (type == NULL)
+        return (NULL);
+    type->node = node;
+    type->type = XML_SCHEMA_TYPE_ALL;
+    type->id = xmlSchemaGetProp(ctxt, node, "id");
+    type->minOccurs = xmlGetMinOccurs(ctxt, node);
+    if (type->minOccurs > 1)
+        xmlSchemaPErr(ctxt, node, XML_SCHEMAP_INVALID_MINOCCURS,
+	    "invalid value for minOccurs (must be 0 or 1)\n", NULL, NULL);
+    type->maxOccurs = xmlGetMaxOccurs(ctxt, node);
+    if (type->maxOccurs > 1)
+        xmlSchemaPErr(ctxt, node, XML_SCHEMAP_INVALID_MAXOCCURS,
+	    "invalid value for maxOccurs (must be 0 or 1)\n", NULL, NULL);
+
+    child = node->children;
+    if (IS_SCHEMA(child, "annotation")) {
+        type->annot = xmlSchemaParseAnnotation(ctxt, schema, child);
+        child = child->next;
+    }
+    while (IS_SCHEMA(child, "element")) {
+        subtype = (xmlSchemaTypePtr)
+            xmlSchemaParseElement(ctxt, schema, child, 0);
+        if (subtype != NULL) {
+	    if (subtype->minOccurs > 1)
+                xmlSchemaPErr(ctxt, child, XML_SCHEMAP_INVALID_MINOCCURS,
+	             "invalid value for minOccurs (must be 0 or 1)\n",
+		     NULL, NULL);
+	    if (subtype->maxOccurs > 1)
+	        xmlSchemaPErr(ctxt, child, XML_SCHEMAP_INVALID_MAXOCCURS,
+	             "invalid value for maxOccurs (must be 0 or 1)\n",
+		     NULL, NULL);
+            if (last == NULL) {
+                type->subtypes = subtype;
+                last = subtype;
+            } else {
+                last->next = subtype;
+                last = subtype;
+            }
+            last->next = NULL;
+        }
+        child = child->next;
+    }
+    if (child != NULL) {
+        xmlSchemaPErr2(ctxt, node, child, XML_SCHEMAP_UNKNOWN_ALL_CHILD,
+                       "All %s has unexpected content\n", type->name,
+                       NULL);
+    }
+
+    return (type);
+}
+
+/**
+ * xmlSchemaImportSchema
+ * 
+ * @ctxt:  a schema validation context
+ * @schemaLocation:  an URI defining where to find the imported schema
+ *
+ * import a XML schema
+ * *WARNING* this interface is highly subject to change
+ *
+ * Returns -1 in case of error and 1 in case of success.
+ */
+static xmlSchemaImportPtr
+xmlSchemaImportSchema(xmlSchemaParserCtxtPtr ctxt,
+                      const xmlChar *schemaLocation)
+{
+    xmlSchemaImportPtr import;
+    xmlSchemaParserCtxtPtr newctxt;
+
+    newctxt = (xmlSchemaParserCtxtPtr) xmlMalloc(sizeof(xmlSchemaParserCtxt));
+    if (newctxt == NULL) {
+        xmlSchemaPErrMemory(ctxt, "allocating schama parser context",
+                            NULL);
+        return (NULL);
+    }
+    memset(newctxt, 0, sizeof(xmlSchemaParserCtxt));
+    /* Keep the same dictionnary for parsing, really */
+    xmlDictReference(ctxt->dict);
+    newctxt->dict = ctxt->dict;
+    newctxt->includes = 0;
+    newctxt->URL = xmlDictLookup(newctxt->dict, schemaLocation, -1);
+
+    xmlSchemaSetParserErrors(newctxt, ctxt->error, ctxt->warning,
+	                     ctxt->userData);
+
+    import = (xmlSchemaImport*) xmlMalloc(sizeof(xmlSchemaImport));
+    if (import == NULL) {
+        xmlSchemaPErrMemory(NULL, "allocating imported schema",
+                            NULL);
+	xmlSchemaFreeParserCtxt(newctxt);
+        return (NULL);
+    }
+
+    memset(import, 0, sizeof(xmlSchemaImport));
+    import->schemaLocation = xmlDictLookup(ctxt->dict, schemaLocation, -1);
+    import->schema = xmlSchemaParse(newctxt);
+
+    if (import->schema == NULL) {
+        /* FIXME use another error enum here ? */
+        xmlSchemaPErr(ctxt, NULL, XML_SCHEMAS_ERR_INTERNAL,
+	              "failed to import schema at location %s\n",
+		      schemaLocation, NULL);
+
+	xmlSchemaFreeParserCtxt(newctxt);
+	if (import->schemaLocation != NULL)
+	    xmlFree((xmlChar *)import->schemaLocation);
+	xmlFree(import);
+	return NULL;
+    }
+
+    xmlSchemaFreeParserCtxt(newctxt);
+    return import;
+}
+
+
+/**
+ * xmlSchemaParseImport:
+ * @ctxt:  a schema validation context
+ * @schema:  the schema being built
+ * @node:  a subtree containing XML Schema informations
+ *
+ * parse a XML schema Import definition
+ * *WARNING* this interface is highly subject to change
+ *
+ * Returns -1 in case of error, 0 if the declaration is inproper and
+ *         1 in case of success.
+ */
+static int
+xmlSchemaParseImport(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
+                     xmlNodePtr node)
+{
+    xmlNodePtr child = NULL;
+    xmlSchemaImportPtr import = NULL;
+    const xmlChar *namespace;
+    const xmlChar *schemaLocation;
+    const xmlChar *previous;
+    xmlURIPtr check;
+
+
+    if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
+        return (-1);
+
+    namespace = xmlSchemaGetProp(ctxt, node, "namespace");
+    if (namespace != NULL) {
+        check = xmlParseURI((const char *) namespace);
+        if (check == NULL) {
+            xmlSchemaPErr2(ctxt, node, child,
+                           XML_SCHEMAP_IMPORT_NAMESPACE_NOT_URI,
+                           "Import namespace attribute is not an URI: %s\n",
+                           namespace, NULL);
+            return (-1);
+        } else {
+            xmlFreeURI(check);
+        }
+    }
+    schemaLocation = xmlSchemaGetProp(ctxt, node, "schemaLocation");
+    if (schemaLocation != NULL) {
+        xmlChar *base = NULL;
+        xmlChar *URI = NULL;
+        check = xmlParseURI((const char *) schemaLocation);
+        if (check == NULL) {
+            xmlSchemaPErr2(ctxt, node, child,
+                           XML_SCHEMAP_IMPORT_SCHEMA_NOT_URI,
+                           "Import schemaLocation attribute is not an URI: %s\n",
+                           schemaLocation, NULL);
+            return (-1);
+        } else {
+            xmlFreeURI(check);
+        }
+	base = xmlNodeGetBase(node->doc, node);
+	if (base == NULL) {
+	    URI = xmlBuildURI(schemaLocation, node->doc->URL);
+	} else {
+	    URI = xmlBuildURI(schemaLocation, base);
+	    xmlFree(base);
+	}
+	if (URI != NULL) {
+	    schemaLocation = xmlDictLookup(ctxt->dict, URI, -1);
+	    xmlFree(URI);
+	}
+    }
+    if (schema->schemasImports == NULL) {
+        schema->schemasImports = xmlHashCreate(10);
+        if (schema->schemasImports == NULL) {
+            xmlSchemaPErr2(ctxt, node, child,
+                           XML_SCHEMAP_FAILED_BUILD_IMPORT,
+                           "Internal: failed to build import table\n",
+                           NULL, NULL);
+            return (-1);
+        }
+    }
+    if (namespace == NULL) {
+        import = xmlHashLookup(schema->schemasImports,
+	                               XML_SCHEMAS_DEFAULT_NAMESPACE);
+	if (import != NULL)
+            previous = import->schemaLocation;
+	else
+	    previous = NULL;
+
+        if (schemaLocation != NULL) {
+            if (previous != NULL) {
+                if (!xmlStrEqual(schemaLocation, previous)) {
+                    xmlSchemaPErr2(ctxt, node, child,
+                                   XML_SCHEMAP_IMPORT_REDEFINE_NSNAME,
+                                   "Redefining import for default namespace with a different URI: %s\n",
+                                   schemaLocation, NULL);
+                }
+            } else {
+	        import = xmlSchemaImportSchema(ctxt, schemaLocation);
+		if (import == NULL) {
+		    return (-1);
+		}
+                xmlHashAddEntry(schema->schemasImports,
+                                XML_SCHEMAS_DEFAULT_NAMESPACE,
+                                import);
+            }
+        }
+    } else {
+        import = xmlHashLookup(schema->schemasImports, namespace);
+	if (import != NULL)
+	    previous = import->schemaLocation;
+	else
+	    previous = NULL;
+
+        if (schemaLocation != NULL) {
+            if (previous != NULL) {
+                if (!xmlStrEqual(schemaLocation, previous)) {
+                    xmlSchemaPErr2(ctxt, node, child,
+                                   XML_SCHEMAP_IMPORT_REDEFINE_NSNAME,
+                                   "Redefining import for namespace %s with a different URI: %s\n",
+                                   namespace, schemaLocation);
+                }
+            } else {
+	        import = xmlSchemaImportSchema(ctxt, schemaLocation);
+		if (import == NULL) {
+		    return (-1);
+		}
+                xmlHashAddEntry(schema->schemasImports,
+                                namespace, import);
+            }
+        }
+    }
+
+    child = node->children;
+    while (IS_SCHEMA(child, "annotation")) {
+        /*
+         * the annotations here are simply discarded ...
+         */
+        child = child->next;
+    }
+    if (child != NULL) {
+        xmlSchemaPErr2(ctxt, node, child, XML_SCHEMAP_UNKNOWN_IMPORT_CHILD,
+                       "Import has unexpected content\n", NULL, NULL);
+        return (-1);
+    }
+    return (1);
+}
+
+/**
+ * xmlSchemaCleanupDoc:
+ * @ctxt:  a schema validation context
+ * @node:  the root of the document.
+ *
+ * removes unwanted nodes in a schemas document tree
+ */
+static void
+xmlSchemaCleanupDoc(xmlSchemaParserCtxtPtr ctxt, xmlNodePtr root)
+{
+    xmlNodePtr delete, cur;
+
+    if ((ctxt == NULL) || (root == NULL)) return;
+
+    /*
+     * Remove all the blank text nodes
+     */
+    delete = NULL;
+    cur = root;
+    while (cur != NULL) {
+        if (delete != NULL) {
+            xmlUnlinkNode(delete);
+            xmlFreeNode(delete);
+            delete = NULL;
+        }
+        if (cur->type == XML_TEXT_NODE) {
+            if (IS_BLANK_NODE(cur)) {
+                if (xmlNodeGetSpacePreserve(cur) != 1) {
+                    delete = cur;
+                }
+            }
+        } else if ((cur->type != XML_ELEMENT_NODE) &&
+                   (cur->type != XML_CDATA_SECTION_NODE)) {
+            delete = cur;
+            goto skip_children;
+        }
+
+        /*
+         * Skip to next node
+         */
+        if (cur->children != NULL) {
+            if ((cur->children->type != XML_ENTITY_DECL) &&
+                (cur->children->type != XML_ENTITY_REF_NODE) &&
+                (cur->children->type != XML_ENTITY_NODE)) {
+                cur = cur->children;
+                continue;
+            }
+        }
+      skip_children:
+        if (cur->next != NULL) {
+            cur = cur->next;
+            continue;
+        }
+
+        do {
+            cur = cur->parent;
+            if (cur == NULL)
+                break;
+            if (cur == root) {
+                cur = NULL;
+                break;
+            }
+            if (cur->next != NULL) {
+                cur = cur->next;
+                break;
+            }
+        } while (cur != NULL);
+    }
+    if (delete != NULL) {
+        xmlUnlinkNode(delete);
+        xmlFreeNode(delete);
+        delete = NULL;
+    }
+}
+
+/**
+ * xmlSchemaParseSchemaTopLevel:
+ * @ctxt:  a schema validation context
+ * @schema:  the schemas
+ * @nodes:  the list of top level nodes
+ *
+ * Returns the internal XML Schema structure built from the resource or
+ *         NULL in case of error
+ */
+static void
+xmlSchemaParseSchemaTopLevel(xmlSchemaParserCtxtPtr ctxt,
+                             xmlSchemaPtr schema, xmlNodePtr nodes)
+{
+    xmlNodePtr child;
+    xmlSchemaAnnotPtr annot;
+
+    if ((ctxt == NULL) || (schema == NULL) || (nodes == NULL))
+        return;
+
+    child = nodes;
+    while ((IS_SCHEMA(child, "include")) ||
+	   (IS_SCHEMA(child, "import")) ||
+	   (IS_SCHEMA(child, "redefine")) ||
+	   (IS_SCHEMA(child, "annotation"))) {
+	if (IS_SCHEMA(child, "annotation")) {
+	    annot = xmlSchemaParseAnnotation(ctxt, schema, child);
+	    if (schema->annot == NULL)
+		schema->annot = annot;
+	    else
+		xmlSchemaFreeAnnot(annot);
+	} else if (IS_SCHEMA(child, "import")) {
+	    xmlSchemaParseImport(ctxt, schema, child);
+	} else if (IS_SCHEMA(child, "include")) {
+	    ctxt->includes++;
+	    xmlSchemaParseInclude(ctxt, schema, child);
+	    ctxt->includes--;
+	} else if (IS_SCHEMA(child, "redefine")) {
+	    TODO
+	}
+	child = child->next;
+    }
+    while (child != NULL) {
+	if (IS_SCHEMA(child, "complexType")) {
+	    xmlSchemaParseComplexType(ctxt, schema, child);
+	    child = child->next;
+	} else if (IS_SCHEMA(child, "simpleType")) {
+	    xmlSchemaParseSimpleType(ctxt, schema, child);
+	    child = child->next;
+	} else if (IS_SCHEMA(child, "element")) {
+	    xmlSchemaParseElement(ctxt, schema, child, 1);
+	    child = child->next;
+	} else if (IS_SCHEMA(child, "attribute")) {
+	    xmlSchemaParseAttribute(ctxt, schema, child);
+	    child = child->next;
+	} else if (IS_SCHEMA(child, "attributeGroup")) {
+	    xmlSchemaParseAttributeGroup(ctxt, schema, child);
+	    child = child->next;
+	} else if (IS_SCHEMA(child, "group")) {
+	    xmlSchemaParseGroup(ctxt, schema, child);
+	    child = child->next;
+	} else if (IS_SCHEMA(child, "notation")) {
+	    xmlSchemaParseNotation(ctxt, schema, child);
+	    child = child->next;
+	} else {
+	    xmlSchemaPErr2(ctxt, NULL, child,
+			   XML_SCHEMAP_UNKNOWN_SCHEMAS_CHILD,
+			   "Schemas: unexpected element %s here \n",
+			   child->name, NULL);
+	    child = child->next;
+	}
+	while (IS_SCHEMA(child, "annotation")) {
+	    annot = xmlSchemaParseAnnotation(ctxt, schema, child);
+	    if (schema->annot == NULL)
+		schema->annot = annot;
+	    else
+		xmlSchemaFreeAnnot(annot);
+	    child = child->next;
+	}
+    }
+}
+
+/**
+ * xmlSchemaParseInclude:
+ * @ctxt:  a schema validation context
+ * @schema:  the schema being built
+ * @node:  a subtree containing XML Schema informations
+ *
+ * parse a XML schema Include definition
+ *
+ * Returns -1 in case of error, 0 if the declaration is inproper and
+ *         1 in case of success.
+ */
+static int
+xmlSchemaParseInclude(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
+                      xmlNodePtr node)
+{
+    xmlNodePtr child = NULL;
+    const xmlChar *schemaLocation;
+    xmlURIPtr check;
+    xmlDocPtr doc;
+    xmlNodePtr root;
+    xmlSchemaIncludePtr include;
+
+
+    if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
+        return (-1);
+
+    /*
+     * Preliminary step, extract the URI-Reference for the include and
+     * make an URI from the base.
+     */
+    schemaLocation = xmlSchemaGetProp(ctxt, node, "schemaLocation");
+    if (schemaLocation != NULL) {
+        xmlChar *base = NULL;
+        xmlChar *URI = NULL;
+        check = xmlParseURI((const char *) schemaLocation);
+        if (check == NULL) {
+            xmlSchemaPErr2(ctxt, node, child,
+                           XML_SCHEMAP_INCLUDE_SCHEMA_NOT_URI,
+		       "Include schemaLocation attribute is not an URI: %s\n",
+                           schemaLocation, NULL);
+            return (-1);
+        } else {
+            xmlFreeURI(check);
+        }
+	base = xmlNodeGetBase(node->doc, node);
+	if (base == NULL) {
+	    URI = xmlBuildURI(schemaLocation, node->doc->URL);
+	} else {
+	    URI = xmlBuildURI(schemaLocation, base);
+	    xmlFree(base);
+	}
+	if (URI != NULL) {
+	    schemaLocation = xmlDictLookup(ctxt->dict, URI, -1);
+	    xmlFree(URI);
+	}
+    } else {
+	xmlSchemaPErr2(ctxt, node, child,
+		       XML_SCHEMAP_INCLUDE_SCHEMA_NO_URI,
+		   "Include schemaLocation attribute missing\n",
+		       NULL, NULL);
+	return (-1);
+    }
+
+    child = node->children;
+    while (IS_SCHEMA(child, "annotation")) {
+        /*
+         * the annotations here are simply discarded ...
+         */
+        child = child->next;
+    }
+    if (child != NULL) {
+        xmlSchemaPErr2(ctxt, node, child, XML_SCHEMAP_UNKNOWN_INCLUDE_CHILD,
+                       "Include has unexpected content\n", NULL, NULL);
+        return (-1);
+    }
+
+    /*
+     * First step is to parse the input document into an DOM/Infoset
+     */
+    doc = xmlReadFile((const char *) schemaLocation, NULL,
+                      SCHEMAS_PARSE_OPTIONS);
+    if (doc == NULL) {
+	xmlSchemaPErr(ctxt, NULL,
+		      XML_SCHEMAP_FAILED_LOAD,
+		      "xmlSchemaParse: could not load %s\n",
+		      ctxt->URL, NULL);
+	return(-1);
+    }
+
+    /*
+     * Then extract the root of the schema
+     */
+    root = xmlDocGetRootElement(doc);
+    if (root == NULL) {
+	xmlSchemaPErr(ctxt, (xmlNodePtr) doc,
+		      XML_SCHEMAP_NOROOT,
+		      "schemas %s has no root", schemaLocation, NULL);
+	xmlFreeDoc(doc);
+        return (-1);
+    }
+
+    /*
+     * Remove all the blank text nodes
+     */
+    xmlSchemaCleanupDoc(ctxt, root);
+
+    /*
+     * Check the schemas top level element
+     */
+    if (!IS_SCHEMA(root, "schema")) {
+	xmlSchemaPErr(ctxt, (xmlNodePtr) doc,
+		      XML_SCHEMAP_NOT_SCHEMA,
+		      "File %s is not a schemas", schemaLocation, NULL);
+	xmlFreeDoc(doc);
+        return (-1);
+    }
+
+    /*
+     * register the include
+     */
+    include = (xmlSchemaIncludePtr) xmlMalloc(sizeof(xmlSchemaInclude));
+    if (include == NULL) {
+        xmlSchemaPErrMemory(ctxt, "allocating included schema", NULL);
+	xmlFreeDoc(doc);
+        return (-1);
+    }
+
+    memset(include, 0, sizeof(xmlSchemaInclude));
+    include->schemaLocation = xmlDictLookup(ctxt->dict, schemaLocation, -1);
+    include->doc = doc;
+    include->next = schema->includes;
+    schema->includes = include;
+
+
+    /*
+     * parse the declarations in the included file like if they
+     * were in the original file.
+     */
+    xmlSchemaParseSchemaTopLevel(ctxt, schema, root->children);
+
+    return (1);
+}
+
+/**
+ * xmlSchemaParseChoice:
+ * @ctxt:  a schema validation context
+ * @schema:  the schema being built
+ * @node:  a subtree containing XML Schema informations
+ *
+ * parse a XML schema Choice definition
+ * *WARNING* this interface is highly subject to change
+ *
+ * Returns -1 in case of error, 0 if the declaration is inproper and
+ *         1 in case of success.
+ */
+static xmlSchemaTypePtr
+xmlSchemaParseChoice(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
+                     xmlNodePtr node)
+{
+    xmlSchemaTypePtr type, subtype, last = NULL;
+    xmlNodePtr child = NULL;
+    xmlChar name[30];
+
+    if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
+        return (NULL);
+
+
+    snprintf((char *) name, 30, "choice %d", ctxt->counter++ + 1);
+    type = xmlSchemaAddType(ctxt, schema, name, NULL);
+    if (type == NULL)
+        return (NULL);
+    type->node = node;
+    type->type = XML_SCHEMA_TYPE_CHOICE;
+    type->id = xmlSchemaGetProp(ctxt, node, "id");
+    type->minOccurs = xmlGetMinOccurs(ctxt, node);
+    type->maxOccurs = xmlGetMaxOccurs(ctxt, node);
+
+    child = node->children;
+    if (IS_SCHEMA(child, "annotation")) {
+        type->annot = xmlSchemaParseAnnotation(ctxt, schema, child);
+        child = child->next;
+    }
+    while ((IS_SCHEMA(child, "element")) ||
+           (IS_SCHEMA(child, "group")) ||
+           (IS_SCHEMA(child, "any")) ||
+           (IS_SCHEMA(child, "choice")) ||
+           (IS_SCHEMA(child, "sequence"))) {
+        subtype = NULL;
+        if (IS_SCHEMA(child, "element")) {
+            subtype = (xmlSchemaTypePtr)
+                xmlSchemaParseElement(ctxt, schema, child, 0);
+        } else if (IS_SCHEMA(child, "group")) {
+            subtype = xmlSchemaParseGroup(ctxt, schema, child);
+        } else if (IS_SCHEMA(child, "any")) {
+            subtype = xmlSchemaParseAny(ctxt, schema, child);
+        } else if (IS_SCHEMA(child, "sequence")) {
+            subtype = xmlSchemaParseSequence(ctxt, schema, child);
+        } else if (IS_SCHEMA(child, "choice")) {
+            subtype = xmlSchemaParseChoice(ctxt, schema, child);
+        }
+        if (subtype != NULL) {
+            if (last == NULL) {
+                type->subtypes = subtype;
+                last = subtype;
+            } else {
+                last->next = subtype;
+                last = subtype;
+            }
+            last->next = NULL;
+        }
+        child = child->next;
+    }
+    if (child != NULL) {
+        xmlSchemaPErr2(ctxt, node, child, XML_SCHEMAP_UNKNOWN_CHOICE_CHILD,
+                       "Choice %s has unexpected content\n", type->name,
+                       NULL);
+    }
+
+    return (type);
+}
+
+/**
+ * xmlSchemaParseSequence:
+ * @ctxt:  a schema validation context
+ * @schema:  the schema being built
+ * @node:  a subtree containing XML Schema informations
+ *
+ * parse a XML schema Sequence definition
+ * *WARNING* this interface is highly subject to change
+ *
+ * Returns -1 in case of error, 0 if the declaration is inproper and
+ *         1 in case of success.
+ */
+static xmlSchemaTypePtr
+xmlSchemaParseSequence(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
+                       xmlNodePtr node)
+{
+    xmlSchemaTypePtr type, subtype, last = NULL;
+    xmlNodePtr child = NULL;
+    xmlChar name[30];
+
+    if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
+        return (NULL);
+
+
+    snprintf((char *) name, 30, "sequence %d", ctxt->counter++ + 1);
+    type = xmlSchemaAddType(ctxt, schema, name, NULL);
+    if (type == NULL)
+        return (NULL);
+    type->node = node;
+    type->type = XML_SCHEMA_TYPE_SEQUENCE;
+    type->id = xmlSchemaGetProp(ctxt, node, "id");
+    type->minOccurs = xmlGetMinOccurs(ctxt, node);
+    type->maxOccurs = xmlGetMaxOccurs(ctxt, node);
+
+    child = node->children;
+    if (IS_SCHEMA(child, "annotation")) {
+        type->annot = xmlSchemaParseAnnotation(ctxt, schema, child);
+        child = child->next;
+    }
+    while ((IS_SCHEMA(child, "element")) ||
+           (IS_SCHEMA(child, "group")) ||
+           (IS_SCHEMA(child, "any")) ||
+           (IS_SCHEMA(child, "choice")) ||
+           (IS_SCHEMA(child, "sequence"))) {
+        subtype = NULL;
+        if (IS_SCHEMA(child, "element")) {
+            subtype = (xmlSchemaTypePtr)
+                xmlSchemaParseElement(ctxt, schema, child, 0);
+        } else if (IS_SCHEMA(child, "group")) {
+            subtype = xmlSchemaParseGroup(ctxt, schema, child);
+        } else if (IS_SCHEMA(child, "any")) {
+            subtype = xmlSchemaParseAny(ctxt, schema, child);
+        } else if (IS_SCHEMA(child, "choice")) {
+            subtype = xmlSchemaParseChoice(ctxt, schema, child);
+        } else if (IS_SCHEMA(child, "sequence")) {
+            subtype = xmlSchemaParseSequence(ctxt, schema, child);
+        }
+        if (subtype != NULL) {
+            if (last == NULL) {
+                type->subtypes = subtype;
+                last = subtype;
+            } else {
+                last->next = subtype;
+                last = subtype;
+            }
+            last->next = NULL;
+        }
+        child = child->next;
+    }
+    if (child != NULL) {
+        xmlSchemaPErr2(ctxt, node, child,
+                       XML_SCHEMAP_UNKNOWN_SEQUENCE_CHILD,
+                       "Sequence %s has unexpected content\n", type->name,
+                       NULL);
+    }
+
+    return (type);
+}
+
+/**
+ * xmlSchemaParseRestriction:
+ * @ctxt:  a schema validation context
+ * @schema:  the schema being built
+ * @node:  a subtree containing XML Schema informations
+ * @simple:  is that part of a simple type.
+ *
+ * parse a XML schema Restriction definition
+ * *WARNING* this interface is highly subject to change
+ *
+ * Returns the type definition or NULL in case of error
+ */
+static xmlSchemaTypePtr
+xmlSchemaParseRestriction(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
+                          xmlNodePtr node, int simple)
+{
+    xmlSchemaTypePtr type, subtype;
+    xmlSchemaFacetPtr facet, lastfacet = NULL;
+    xmlNodePtr child = NULL;
+    xmlChar name[30];
+    const xmlChar *oldcontainer;
+
+    if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
+        return (NULL);
+
+    oldcontainer = ctxt->container;
+
+    snprintf((char *) name, 30, "restriction %d", ctxt->counter++ + 1);
+    type = xmlSchemaAddType(ctxt, schema, name, NULL);
+    if (type == NULL)
+        return (NULL);
+    type->node = node;
+    type->type = XML_SCHEMA_TYPE_RESTRICTION;
+    type->id = xmlSchemaGetProp(ctxt, node, "id");
+    type->base = xmlGetQNameProp(ctxt, node, "base", &(type->baseNs));
+    if ((!simple) && (type->base == NULL)) {
+        xmlSchemaPErr2(ctxt, node, child,
+                       XML_SCHEMAP_RESTRICTION_NONAME_NOREF,
+                       "Restriction %s has no base\n", type->name, NULL);
+    }
+    ctxt->container = name;
+
+    child = node->children;
+    if (IS_SCHEMA(child, "annotation")) {
+        type->annot = xmlSchemaParseAnnotation(ctxt, schema, child);
+        child = child->next;
+    }
+    subtype = NULL;
+
+    if (IS_SCHEMA(child, "all")) {
+        subtype = (xmlSchemaTypePtr)
+            xmlSchemaParseAll(ctxt, schema, child);
+        child = child->next;
+        type->subtypes = subtype;
+    } else if (IS_SCHEMA(child, "choice")) {
+        subtype = xmlSchemaParseChoice(ctxt, schema, child);
+        child = child->next;
+        type->subtypes = subtype;
+    } else if (IS_SCHEMA(child, "sequence")) {
+        subtype = (xmlSchemaTypePtr)
+            xmlSchemaParseSequence(ctxt, schema, child);
+        child = child->next;
+        type->subtypes = subtype;
+    } else if (IS_SCHEMA(child, "group")) {
+        subtype = (xmlSchemaTypePtr)
+            xmlSchemaParseGroup(ctxt, schema, child);
+        child = child->next;
+        type->subtypes = subtype;
+    } else {
+        if (IS_SCHEMA(child, "simpleType")) {
+            subtype = (xmlSchemaTypePtr)
+                xmlSchemaParseSimpleType(ctxt, schema, child);
+            child = child->next;
+            type->baseType = subtype;
+        }
+        /*
+         * Facets
+         */
+        while ((IS_SCHEMA(child, "minInclusive")) ||
+               (IS_SCHEMA(child, "minExclusive")) ||
+               (IS_SCHEMA(child, "maxInclusive")) ||
+               (IS_SCHEMA(child, "maxExclusive")) ||
+               (IS_SCHEMA(child, "totalDigits")) ||
+               (IS_SCHEMA(child, "fractionDigits")) ||
+               (IS_SCHEMA(child, "pattern")) ||
+               (IS_SCHEMA(child, "enumeration")) ||
+               (IS_SCHEMA(child, "whiteSpace")) ||
+               (IS_SCHEMA(child, "length")) ||
+               (IS_SCHEMA(child, "maxLength")) ||
+               (IS_SCHEMA(child, "minLength"))) {
+            facet = xmlSchemaParseFacet(ctxt, schema, child);
+            if (facet != NULL) {
+                if (lastfacet == NULL) {
+                    type->facets = facet;
+                    lastfacet = facet;
+                } else {
+                    lastfacet->next = facet;
+                    lastfacet = facet;
+                }
+                lastfacet->next = NULL;
+            }
+            child = child->next;
+        }
+    }
+    child = xmlSchemaParseAttrDecls(ctxt, schema, child, type);
+    if (child != NULL) {
+        xmlSchemaPErr2(ctxt, node, child,
+                       XML_SCHEMAP_UNKNOWN_RESTRICTION_CHILD,
+                       "Restriction %s has unexpected content\n",
+                       type->name, NULL);
+    }
+    ctxt->container = oldcontainer;
+    return (type);
+}
+
+/**
+ * xmlSchemaParseExtension:
+ * @ctxt:  a schema validation context
+ * @schema:  the schema being built
+ * @node:  a subtree containing XML Schema informations
+ *
+ * parse a XML schema Extension definition
+ * *WARNING* this interface is highly subject to change
+ *
+ * Returns the type definition or NULL in case of error
+ */
+static xmlSchemaTypePtr
+xmlSchemaParseExtension(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
+                        xmlNodePtr node)
+{
+    xmlSchemaTypePtr type, subtype;
+    xmlNodePtr child = NULL;
+    xmlChar name[30];
+    const xmlChar *oldcontainer;
+
+    if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
+        return (NULL);
+
+    oldcontainer = ctxt->container;
+
+    snprintf((char *) name, 30, "extension %d", ctxt->counter++ + 1);
+    type = xmlSchemaAddType(ctxt, schema, name, NULL);
+    if (type == NULL)
+        return (NULL);
+    type->node = node;
+    type->type = XML_SCHEMA_TYPE_EXTENSION;
+    type->id = xmlSchemaGetProp(ctxt, node, "id");
+    ctxt->container = name;
+
+    type->base = xmlGetQNameProp(ctxt, node, "base", &(type->baseNs));
+    if (type->base == NULL) {
+        xmlSchemaPErr2(ctxt, node, child, XML_SCHEMAP_EXTENSION_NO_BASE,
+                       "Extension %s has no base\n", type->name, NULL);
+    }
+    child = node->children;
+    if (IS_SCHEMA(child, "annotation")) {
+        type->annot = xmlSchemaParseAnnotation(ctxt, schema, child);
+        child = child->next;
+    }
+    subtype = NULL;
+
+    if (IS_SCHEMA(child, "all")) {
+        subtype = xmlSchemaParseAll(ctxt, schema, child);
+        child = child->next;
+    } else if (IS_SCHEMA(child, "choice")) {
+        subtype = xmlSchemaParseChoice(ctxt, schema, child);
+        child = child->next;
+    } else if (IS_SCHEMA(child, "sequence")) {
+        subtype = xmlSchemaParseSequence(ctxt, schema, child);
+        child = child->next;
+    } else if (IS_SCHEMA(child, "group")) {
+        subtype = xmlSchemaParseGroup(ctxt, schema, child);
+        child = child->next;
+    }
+    if (subtype != NULL)
+        type->subtypes = subtype;
+    child = xmlSchemaParseAttrDecls(ctxt, schema, child, type);
+    if (child != NULL) {
+        xmlSchemaPErr2(ctxt, node, child,
+                       XML_SCHEMAP_UNKNOWN_EXTENSION_CHILD,
+                       "Extension %s has unexpected content\n", type->name,
+                       NULL);
+    }
+    ctxt->container = oldcontainer;
+    return (type);
+}
+
+/**
+ * xmlSchemaParseSimpleContent:
+ * @ctxt:  a schema validation context
+ * @schema:  the schema being built
+ * @node:  a subtree containing XML Schema informations
+ *
+ * parse a XML schema SimpleContent definition
+ * *WARNING* this interface is highly subject to change
+ *
+ * Returns the type definition or NULL in case of error
+ */
+static xmlSchemaTypePtr
+xmlSchemaParseSimpleContent(xmlSchemaParserCtxtPtr ctxt,
+                            xmlSchemaPtr schema, xmlNodePtr node)
+{
+    xmlSchemaTypePtr type, subtype;
+    xmlNodePtr child = NULL;
+    xmlChar name[30];
+
+    if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
+        return (NULL);
+
+
+    snprintf((char *) name, 30, "complexContent %d", ctxt->counter++ + 1);
+    type = xmlSchemaAddType(ctxt, schema, name, NULL);
+    if (type == NULL)
+        return (NULL);
+    type->node = node;
+    type->type = XML_SCHEMA_TYPE_SIMPLE_CONTENT;
+    type->id = xmlSchemaGetProp(ctxt, node, "id");
+
+    child = node->children;
+    if (IS_SCHEMA(child, "annotation")) {
+        type->annot = xmlSchemaParseAnnotation(ctxt, schema, child);
+        child = child->next;
+    }
+    subtype = NULL;
+    if (IS_SCHEMA(child, "restriction")) {
+        subtype = (xmlSchemaTypePtr)
+            xmlSchemaParseRestriction(ctxt, schema, child, 0);
+        child = child->next;
+    } else if (IS_SCHEMA(child, "extension")) {
+        subtype = (xmlSchemaTypePtr)
+            xmlSchemaParseExtension(ctxt, schema, child);
+        child = child->next;
+    }
+    type->subtypes = subtype;
+    if (child != NULL) {
+        xmlSchemaPErr2(ctxt, node, child,
+                       XML_SCHEMAP_UNKNOWN_SIMPLECONTENT_CHILD,
+                       "SimpleContent %s has unexpected content\n",
+                       type->name, NULL);
+    }
+    return (type);
+}
+
+/**
+ * xmlSchemaParseComplexContent:
+ * @ctxt:  a schema validation context
+ * @schema:  the schema being built
+ * @node:  a subtree containing XML Schema informations
+ *
+ * parse a XML schema ComplexContent definition
+ * *WARNING* this interface is highly subject to change
+ *
+ * Returns the type definition or NULL in case of error
+ */
+static xmlSchemaTypePtr
+xmlSchemaParseComplexContent(xmlSchemaParserCtxtPtr ctxt,
+                             xmlSchemaPtr schema, xmlNodePtr node)
+{
+    xmlSchemaTypePtr type, subtype;
+    xmlNodePtr child = NULL;
+    xmlChar name[30];
+
+    if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
+        return (NULL);
+
+
+    snprintf((char *) name, 30, "complexContent %d", ctxt->counter++ + 1);
+    type = xmlSchemaAddType(ctxt, schema, name, NULL);
+    if (type == NULL)
+        return (NULL);
+    type->node = node;
+    type->type = XML_SCHEMA_TYPE_COMPLEX_CONTENT;
+    type->id = xmlSchemaGetProp(ctxt, node, "id");
+
+    child = node->children;
+    if (IS_SCHEMA(child, "annotation")) {
+        type->annot = xmlSchemaParseAnnotation(ctxt, schema, child);
+        child = child->next;
+    }
+    subtype = NULL;
+    if (IS_SCHEMA(child, "restriction")) {
+        subtype = (xmlSchemaTypePtr)
+            xmlSchemaParseRestriction(ctxt, schema, child, 0);
+        child = child->next;
+    } else if (IS_SCHEMA(child, "extension")) {
+        subtype = (xmlSchemaTypePtr)
+            xmlSchemaParseExtension(ctxt, schema, child);
+        child = child->next;
+    }
+    type->subtypes = subtype;
+    if (child != NULL) {
+        xmlSchemaPErr2(ctxt, node, child,
+                       XML_SCHEMAP_UNKNOWN_COMPLEXCONTENT_CHILD,
+                       "ComplexContent %s has unexpected content\n",
+                       type->name, NULL);
+    }
+    return (type);
+}
+
+/**
+ * xmlSchemaParseComplexType:
+ * @ctxt:  a schema validation context
+ * @schema:  the schema being built
+ * @node:  a subtree containing XML Schema informations
+ *
+ * parse a XML schema Complex Type definition
+ * *WARNING* this interface is highly subject to change
+ *
+ * Returns the type definition or NULL in case of error
+ */
+static xmlSchemaTypePtr
+xmlSchemaParseComplexType(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
+                          xmlNodePtr node)
+{
+    xmlSchemaTypePtr type, subtype;
+    xmlNodePtr child = NULL;
+    const xmlChar *name;
+    const xmlChar *oldcontainer;
+    const xmlChar *mixed;
+    char buf[100];
+
+    if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
+        return (NULL);
+
+    oldcontainer = ctxt->container;
+    name = xmlSchemaGetProp(ctxt, node, "name");
+    if (name == NULL) {
+
+        snprintf(buf, 99, "anontype %d", ctxt->counter++ + 1);
+	name = (const xmlChar *)buf;
+	type = xmlSchemaAddType(ctxt, schema, name, NULL);
+    } else {
+	const xmlChar *local, *ns;
+
+        local = xmlSchemaGetNamespace(ctxt, schema, node, name, &ns);
+	type = xmlSchemaAddType(ctxt, schema, local, ns);
+    }
+    if (type == NULL) {
+        return (NULL);
+    }
+
+    mixed = xmlSchemaGetProp(ctxt, node, "mixed");
+    if (mixed != NULL)
+	type->flags |= XML_SCHEMAS_TYPE_MIXED;
+
+    type->node = node;
+    type->type = XML_SCHEMA_TYPE_COMPLEX;
+    type->id = xmlSchemaGetProp(ctxt, node, "id");
+    ctxt->container = name;
+
+    child = node->children;
+    if (IS_SCHEMA(child, "annotation")) {
+        type->annot = xmlSchemaParseAnnotation(ctxt, schema, child);
+        child = child->next;
+    }
+    if (IS_SCHEMA(child, "simpleContent")) {
+        type->subtypes = xmlSchemaParseSimpleContent(ctxt, schema, child);
+        child = child->next;
+    } else if (IS_SCHEMA(child, "complexContent")) {
+        type->subtypes = xmlSchemaParseComplexContent(ctxt, schema, child);
+        child = child->next;
+    } else {
+        subtype = NULL;
+
+        if (IS_SCHEMA(child, "all")) {
+            subtype = xmlSchemaParseAll(ctxt, schema, child);
+            child = child->next;
+        } else if (IS_SCHEMA(child, "choice")) {
+            subtype = xmlSchemaParseChoice(ctxt, schema, child);
+            child = child->next;
+        } else if (IS_SCHEMA(child, "sequence")) {
+            subtype = xmlSchemaParseSequence(ctxt, schema, child);
+            child = child->next;
+        } else if (IS_SCHEMA(child, "group")) {
+            subtype = xmlSchemaParseGroup(ctxt, schema, child);
+            child = child->next;
+        }
+        if (subtype != NULL)
+            type->subtypes = subtype;
+        child = xmlSchemaParseAttrDecls(ctxt, schema, child, type);
+    }
+    if (child != NULL) {
+        xmlSchemaPErr2(ctxt, node, child,
+                       XML_SCHEMAP_UNKNOWN_COMPLEXTYPE_CHILD,
+                       "ComplexType %s has unexpected content\n",
+                       type->name, NULL);
+    }
+    ctxt->container = oldcontainer;
+    return (type);
+}
+
+/**
+ * xmlSchemaParseSchema:
+ * @ctxt:  a schema validation context
+ * @node:  a subtree containing XML Schema informations
+ *
+ * parse a XML schema definition from a node set
+ * *WARNING* this interface is highly subject to change
+ *
+ * Returns the internal XML Schema structure built from the resource or
+ *         NULL in case of error
+ */
+static xmlSchemaPtr
+xmlSchemaParseSchema(xmlSchemaParserCtxtPtr ctxt, xmlNodePtr node)
+{
+    xmlSchemaPtr schema = NULL;
+    xmlNodePtr child = NULL;
+    const xmlChar *val;
+    int nberrors;
+
+    if ((ctxt == NULL) || (node == NULL))
+        return (NULL);
+
+    nberrors = ctxt->nberrors;
+    ctxt->nberrors = 0;
+    if (IS_SCHEMA(node, "schema")) {
+        schema = xmlSchemaNewSchema(ctxt);
+        if (schema == NULL)
+            return (NULL);
+	val = xmlSchemaGetProp(ctxt, node, "targetNamespace");
+	if (val != NULL) {
+	    schema->targetNamespace = xmlDictLookup(ctxt->dict, val, -1);
+	} else {
+	    schema->targetNamespace = NULL;
+	}
+        schema->id = xmlSchemaGetProp(ctxt, node, "id");
+        schema->version = xmlSchemaGetProp(ctxt, node, "version");
+        val = xmlSchemaGetProp(ctxt, node, "elementFormDefault");
+        if (val != NULL) {
+            if (xmlStrEqual(val, BAD_CAST "qualified"))
+                schema->flags |= XML_SCHEMAS_QUALIF_ELEM;
+            else if (!xmlStrEqual(val, BAD_CAST "unqualified")) {
+                xmlSchemaPErr2(ctxt, node, child,
+                               XML_SCHEMAP_ELEMFORMDEFAULT_VALUE,
+                               "Invalid value %s for elementFormDefault\n",
+                               val, NULL);
+            }
+        } else {
+	    schema->flags |= XML_SCHEMAS_QUALIF_ELEM;
+	}
+        val = xmlSchemaGetProp(ctxt, node, "attributeFormDefault");
+        if (val != NULL) {
+            if (xmlStrEqual(val, BAD_CAST "qualified"))
+                schema->flags |= XML_SCHEMAS_QUALIF_ATTR;
+            else if (!xmlStrEqual(val, BAD_CAST "unqualified")) {
+                xmlSchemaPErr2(ctxt, node, child,
+                               XML_SCHEMAP_ATTRFORMDEFAULT_VALUE,
+                               "Invalid value %s for attributeFormDefault\n",
+                               val, NULL);
+            }
+        } 
+
+        xmlSchemaParseSchemaTopLevel(ctxt, schema, node->children);
+    } else {
+        xmlDocPtr doc;
+
+	doc = node->doc;
+
+        if ((doc != NULL) && (doc->URL != NULL)) {
+	    xmlSchemaPErr(ctxt, (xmlNodePtr) doc,
+		      XML_SCHEMAP_NOT_SCHEMA,
+		      "File %s is not a schemas", doc->URL, NULL);
+	} else {
+	    xmlSchemaPErr(ctxt, (xmlNodePtr) doc,
+		      XML_SCHEMAP_NOT_SCHEMA,
+		      "File is not a schemas", NULL, NULL);
+	}
+	return(NULL);
+    }
+    if (ctxt->nberrors != 0) {
+        if (schema != NULL) {
+            xmlSchemaFree(schema);
+            schema = NULL;
+        }
+    }
+    ctxt->nberrors = nberrors;
+#ifdef DEBUG
+    if (schema == NULL)
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlSchemaParse() failed\n");
+#endif
+
+    return (schema);
+}
+
+/************************************************************************
+ * 									*
+ * 			Validating using Schemas			*
+ * 									*
+ ************************************************************************/
+
+/************************************************************************
+ * 									*
+ * 			Reading/Writing Schemas				*
+ * 									*
+ ************************************************************************/
+
+/**
+ * xmlSchemaNewParserCtxt:
+ * @URL:  the location of the schema
+ *
+ * Create an XML Schemas parse context for that file/resource expected
+ * to contain an XML Schemas file.
+ *
+ * Returns the parser context or NULL in case of error
+ */
+xmlSchemaParserCtxtPtr
+xmlSchemaNewParserCtxt(const char *URL)
+{
+    xmlSchemaParserCtxtPtr ret;
+
+    if (URL == NULL)
+        return (NULL);
+
+    ret = (xmlSchemaParserCtxtPtr) xmlMalloc(sizeof(xmlSchemaParserCtxt));
+    if (ret == NULL) {
+        xmlSchemaPErrMemory(NULL, "allocating schama parser context",
+                            NULL);
+        return (NULL);
+    }
+    memset(ret, 0, sizeof(xmlSchemaParserCtxt));
+    ret->dict = xmlDictCreate();
+    ret->URL = xmlDictLookup(ret->dict, (const xmlChar *) URL, -1);
+    ret->includes = 0;
+    return (ret);
+}
+
+/**
+ * xmlSchemaNewMemParserCtxt:
+ * @buffer:  a pointer to a char array containing the schemas
+ * @size:  the size of the array
+ *
+ * Create an XML Schemas parse context for that memory buffer expected
+ * to contain an XML Schemas file.
+ *
+ * Returns the parser context or NULL in case of error
+ */
+xmlSchemaParserCtxtPtr
+xmlSchemaNewMemParserCtxt(const char *buffer, int size)
+{
+    xmlSchemaParserCtxtPtr ret;
+
+    if ((buffer == NULL) || (size <= 0))
+        return (NULL);
+
+    ret = (xmlSchemaParserCtxtPtr) xmlMalloc(sizeof(xmlSchemaParserCtxt));
+    if (ret == NULL) {
+        xmlSchemaPErrMemory(NULL, "allocating schama parser context",
+                            NULL);
+        return (NULL);
+    }
+    memset(ret, 0, sizeof(xmlSchemaParserCtxt));
+    ret->buffer = buffer;
+    ret->size = size;
+    ret->dict = xmlDictCreate();
+    return (ret);
+}
+
+/**
+ * xmlSchemaNewDocParserCtxt:
+ * @doc:  a preparsed document tree
+ *
+ * Create an XML Schemas parse context for that document.
+ * NB. The document may be modified during the parsing process.
+ *
+ * Returns the parser context or NULL in case of error
+ */
+xmlSchemaParserCtxtPtr
+xmlSchemaNewDocParserCtxt(xmlDocPtr doc)
+{
+    xmlSchemaParserCtxtPtr ret;
+
+    if (doc == NULL)
+      return (NULL);
+
+    ret = (xmlSchemaParserCtxtPtr) xmlMalloc(sizeof(xmlSchemaParserCtxt));
+    if (ret == NULL) {
+      xmlSchemaPErrMemory(NULL, "allocating schema parser context",
+			  NULL);
+      return (NULL);
+    }
+    memset(ret, 0, sizeof(xmlSchemaParserCtxt));
+    ret->doc = doc;
+    ret->dict = xmlDictCreate();
+    /* The application has responsibility for the document */
+    ret->preserve = 1;
+
+    return (ret);
+}
+
+/**
+ * xmlSchemaFreeParserCtxt:
+ * @ctxt:  the schema parser context
+ *
+ * Free the resources associated to the schema parser context
+ */
+void
+xmlSchemaFreeParserCtxt(xmlSchemaParserCtxtPtr ctxt)
+{
+    if (ctxt == NULL)
+        return;
+    if (ctxt->doc != NULL && !ctxt->preserve)
+        xmlFreeDoc(ctxt->doc);
+    xmlDictFree(ctxt->dict);
+    xmlFree(ctxt);
+}
+
+/************************************************************************
+ *									*
+ *			Building the content models			*
+ *									*
+ ************************************************************************/
+
+/**
+ * xmlSchemaBuildAContentModel:
+ * @type:  the schema type definition
+ * @ctxt:  the schema parser context
+ * @name:  the element name whose content is being built
+ *
+ * Generate the automata sequence needed for that type
+ */
+static void
+xmlSchemaBuildAContentModel(xmlSchemaTypePtr type,
+                            xmlSchemaParserCtxtPtr ctxt,
+                            const xmlChar * name)
+{
+    if (type == NULL) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "Found unexpected type = NULL in %s content model\n",
+                        name);
+        return;
+    }
+    switch (type->type) {
+        case XML_SCHEMA_TYPE_ANY:
+            /* TODO : handle the namespace too */
+            /* TODO : make that a specific transition type */
+            TODO ctxt->state =
+                xmlAutomataNewTransition(ctxt->am, ctxt->state, NULL,
+                                         BAD_CAST "*", NULL);
+            break;
+        case XML_SCHEMA_TYPE_ELEMENT:{
+                xmlSchemaElementPtr elem = (xmlSchemaElementPtr) type;
+
+                /* TODO : handle the namespace too */
+                xmlAutomataStatePtr oldstate = ctxt->state;
+
+                if (elem->maxOccurs >= UNBOUNDED) {
+                    if (elem->minOccurs > 1) {
+                        xmlAutomataStatePtr tmp;
+                        int counter;
+
+                        ctxt->state = xmlAutomataNewEpsilon(ctxt->am,
+                                                            oldstate,
+                                                            NULL);
+                        oldstate = ctxt->state;
+
+                        counter = xmlAutomataNewCounter(ctxt->am,
+                                                        elem->minOccurs -
+                                                        1, UNBOUNDED);
+
+                        if (elem->refDecl != NULL) {
+                            xmlSchemaBuildAContentModel((xmlSchemaTypePtr)
+                                                        elem->refDecl,
+                                                        ctxt,
+                                                        elem->refDecl->
+                                                        name);
+                        } else {
+                            ctxt->state =
+                                xmlAutomataNewTransition(ctxt->am,
+                                                         ctxt->state, NULL,
+                                                         elem->name, type);
+                        }
+                        tmp = ctxt->state;
+                        xmlAutomataNewCountedTrans(ctxt->am, tmp, oldstate,
+                                                   counter);
+                        ctxt->state =
+                            xmlAutomataNewCounterTrans(ctxt->am, tmp, NULL,
+                                                       counter);
+
+                    } else {
+                        if (elem->refDecl != NULL) {
+                            xmlSchemaBuildAContentModel((xmlSchemaTypePtr)
+                                                        elem->refDecl,
+                                                        ctxt,
+                                                        elem->refDecl->
+                                                        name);
+                        } else {
+                            ctxt->state =
+                                xmlAutomataNewTransition(ctxt->am,
+                                                         ctxt->state, NULL,
+                                                         elem->name, type);
+                        }
+                        xmlAutomataNewEpsilon(ctxt->am, ctxt->state,
+                                              oldstate);
+                        if (elem->minOccurs == 0) {
+                            /* basically an elem* */
+                            xmlAutomataNewEpsilon(ctxt->am, oldstate,
+                                                  ctxt->state);
+                        }
+                    }
+                } else if ((elem->maxOccurs > 1) || (elem->minOccurs > 1)) {
+                    xmlAutomataStatePtr tmp;
+                    int counter;
+
+                    ctxt->state = xmlAutomataNewEpsilon(ctxt->am,
+                                                        oldstate, NULL);
+                    oldstate = ctxt->state;
+
+                    counter = xmlAutomataNewCounter(ctxt->am,
+                                                    elem->minOccurs - 1,
+                                                    elem->maxOccurs - 1);
+
+                    if (elem->refDecl != NULL) {
+                        xmlSchemaBuildAContentModel((xmlSchemaTypePtr)
+                                                    elem->refDecl, ctxt,
+                                                    elem->refDecl->name);
+                    } else {
+                        ctxt->state = xmlAutomataNewTransition(ctxt->am,
+                                                               ctxt->state,
+                                                               NULL,
+                                                               elem->name,
+                                                               type);
+                    }
+                    tmp = ctxt->state;
+                    xmlAutomataNewCountedTrans(ctxt->am, tmp, oldstate,
+                                               counter);
+                    ctxt->state = xmlAutomataNewCounterTrans(ctxt->am, tmp,
+                                                             NULL,
+                                                             counter);
+                    if (elem->minOccurs == 0) {
+                        /* basically an elem? */
+                        xmlAutomataNewEpsilon(ctxt->am, oldstate,
+                                              ctxt->state);
+                    }
+
+                } else {
+                    if (elem->refDecl != NULL) {
+                        xmlSchemaBuildAContentModel((xmlSchemaTypePtr)
+                                                    elem->refDecl, ctxt,
+                                                    elem->refDecl->name);
+                    } else {
+                        ctxt->state = xmlAutomataNewTransition(ctxt->am,
+                                                               ctxt->state,
+                                                               NULL,
+                                                               elem->name,
+                                                               type);
+                    }
+                    if (elem->minOccurs == 0) {
+                        /* basically an elem? */
+                        xmlAutomataNewEpsilon(ctxt->am, oldstate,
+                                              ctxt->state);
+                    }
+                }
+                break;
+            }
+        case XML_SCHEMA_TYPE_SEQUENCE:{
+                xmlSchemaTypePtr subtypes;
+
+                /*
+                 * If max and min occurances are default (1) then
+                 * simply iterate over the subtypes
+                 */
+                if ((type->minOccurs == 1) && (type->maxOccurs == 1)) {
+                    subtypes = type->subtypes;
+                    while (subtypes != NULL) {
+                        xmlSchemaBuildAContentModel(subtypes, ctxt, name);
+                        subtypes = subtypes->next;
+                    }
+                } else {
+                    xmlAutomataStatePtr oldstate = ctxt->state;
+
+                    if (type->maxOccurs >= UNBOUNDED) {
+                        if (type->minOccurs > 1) {
+                            xmlAutomataStatePtr tmp;
+                            int counter;
+
+                            ctxt->state = xmlAutomataNewEpsilon(ctxt->am,
+                                                                oldstate,
+                                                                NULL);
+                            oldstate = ctxt->state;
+
+                            counter = xmlAutomataNewCounter(ctxt->am,
+                                                            type->
+                                                            minOccurs - 1,
+                                                            UNBOUNDED);
+
+                            subtypes = type->subtypes;
+                            while (subtypes != NULL) {
+                                xmlSchemaBuildAContentModel(subtypes, ctxt,
+                                                            name);
+                                subtypes = subtypes->next;
+                            }
+                            tmp = ctxt->state;
+                            xmlAutomataNewCountedTrans(ctxt->am, tmp,
+                                                       oldstate, counter);
+                            ctxt->state =
+                                xmlAutomataNewCounterTrans(ctxt->am, tmp,
+                                                           NULL, counter);
+
+                        } else {
+                            subtypes = type->subtypes;
+                            while (subtypes != NULL) {
+                                xmlSchemaBuildAContentModel(subtypes, ctxt,
+                                                            name);
+                                subtypes = subtypes->next;
+                            }
+                            xmlAutomataNewEpsilon(ctxt->am, ctxt->state,
+                                                  oldstate);
+                            if (type->minOccurs == 0) {
+                                xmlAutomataNewEpsilon(ctxt->am, oldstate,
+                                                      ctxt->state);
+                            }
+                        }
+                    } else if ((type->maxOccurs > 1)
+                               || (type->minOccurs > 1)) {
+                        xmlAutomataStatePtr tmp;
+                        int counter;
+
+                        ctxt->state = xmlAutomataNewEpsilon(ctxt->am,
+                                                            oldstate,
+                                                            NULL);
+                        oldstate = ctxt->state;
+
+                        counter = xmlAutomataNewCounter(ctxt->am,
+                                                        type->minOccurs -
+                                                        1,
+                                                        type->maxOccurs -
+                                                        1);
+
+                        subtypes = type->subtypes;
+                        while (subtypes != NULL) {
+                            xmlSchemaBuildAContentModel(subtypes, ctxt,
+                                                        name);
+                            subtypes = subtypes->next;
+                        }
+                        tmp = ctxt->state;
+                        xmlAutomataNewCountedTrans(ctxt->am, tmp, oldstate,
+                                                   counter);
+                        ctxt->state =
+                            xmlAutomataNewCounterTrans(ctxt->am, tmp, NULL,
+                                                       counter);
+                        if (type->minOccurs == 0) {
+                            xmlAutomataNewEpsilon(ctxt->am, oldstate,
+                                                  ctxt->state);
+                        }
+
+                    } else {
+                        subtypes = type->subtypes;
+                        while (subtypes != NULL) {
+                            xmlSchemaBuildAContentModel(subtypes, ctxt,
+                                                        name);
+                            subtypes = subtypes->next;
+                        }
+                        if (type->minOccurs == 0) {
+                            xmlAutomataNewEpsilon(ctxt->am, oldstate,
+                                                  ctxt->state);
+                        }
+                    }
+                }
+                break;
+            }
+        case XML_SCHEMA_TYPE_CHOICE:{
+                xmlSchemaTypePtr subtypes;
+                xmlAutomataStatePtr start, end;
+
+                start = ctxt->state;
+                end = xmlAutomataNewState(ctxt->am);
+
+                /*
+                 * iterate over the subtypes and remerge the end with an
+                 * epsilon transition
+                 */
+                if (type->maxOccurs == 1) {
+                    subtypes = type->subtypes;
+                    while (subtypes != NULL) {
+                        ctxt->state = start;
+                        xmlSchemaBuildAContentModel(subtypes, ctxt, name);
+                        xmlAutomataNewEpsilon(ctxt->am, ctxt->state, end);
+                        subtypes = subtypes->next;
+                    }
+                } else {
+                    int counter;
+                    xmlAutomataStatePtr hop;
+                    int maxOccurs = type->maxOccurs == UNBOUNDED ?
+                        UNBOUNDED : type->maxOccurs - 1;
+                    int minOccurs =
+                        type->minOccurs < 1 ? 0 : type->minOccurs - 1;
+
+                    /*
+                     * use a counter to keep track of the number of transtions
+                     * which went through the choice.
+                     */
+                    counter =
+                        xmlAutomataNewCounter(ctxt->am, minOccurs,
+                                              maxOccurs);
+                    hop = xmlAutomataNewState(ctxt->am);
+
+                    subtypes = type->subtypes;
+                    while (subtypes != NULL) {
+                        ctxt->state = start;
+                        xmlSchemaBuildAContentModel(subtypes, ctxt, name);
+                        xmlAutomataNewEpsilon(ctxt->am, ctxt->state, hop);
+                        subtypes = subtypes->next;
+                    }
+                    xmlAutomataNewCountedTrans(ctxt->am, hop, start,
+                                               counter);
+                    xmlAutomataNewCounterTrans(ctxt->am, hop, end,
+                                               counter);
+                }
+                if (type->minOccurs == 0) {
+                    xmlAutomataNewEpsilon(ctxt->am, start, end);
+                }
+                ctxt->state = end;
+                break;
+            }
+        case XML_SCHEMA_TYPE_ALL:{
+                xmlAutomataStatePtr start;
+                xmlSchemaTypePtr subtypes;
+                xmlSchemaElementPtr elem = (xmlSchemaElementPtr) type;
+                int lax;
+
+                subtypes = type->subtypes;
+                if (subtypes == NULL)
+                    break;
+                start = ctxt->state;
+                while (subtypes != NULL) {
+                    ctxt->state = start;
+                    elem = (xmlSchemaElementPtr) subtypes;
+
+                    /* TODO : handle the namespace too */
+                    if ((elem->minOccurs == 1) && (elem->maxOccurs == 1)) {
+                        xmlAutomataNewOnceTrans(ctxt->am, ctxt->state,
+                                                ctxt->state, elem->name, 1,
+                                                1, subtypes);
+                    } else {
+                        xmlAutomataNewCountTrans(ctxt->am, ctxt->state,
+                                                 ctxt->state, elem->name,
+                                                 elem->minOccurs,
+                                                 elem->maxOccurs,
+                                                 subtypes);
+                    }
+                    subtypes = subtypes->next;
+                }
+                lax = type->minOccurs == 0;
+                ctxt->state =
+                    xmlAutomataNewAllTrans(ctxt->am, ctxt->state, NULL,
+                                           lax);
+                break;
+            }
+        case XML_SCHEMA_TYPE_RESTRICTION:
+            if (type->subtypes != NULL)
+                xmlSchemaBuildAContentModel(type->subtypes, ctxt, name);
+            break;
+        case XML_SCHEMA_TYPE_EXTENSION:
+            if (type->baseType != NULL) {
+                xmlSchemaTypePtr subtypes;
+
+                xmlSchemaBuildAContentModel(type->baseType, ctxt, name);
+                subtypes = type->subtypes;
+                while (subtypes != NULL) {
+                    xmlSchemaBuildAContentModel(subtypes, ctxt, name);
+                    subtypes = subtypes->next;
+                }
+            } else if (type->subtypes != NULL)
+                xmlSchemaBuildAContentModel(type->subtypes, ctxt, name);
+            break;
+        case XML_SCHEMA_TYPE_GROUP:
+            if (type->subtypes == NULL) {
+            }
+        case XML_SCHEMA_TYPE_COMPLEX:
+        case XML_SCHEMA_TYPE_COMPLEX_CONTENT:
+            if (type->subtypes != NULL)
+                xmlSchemaBuildAContentModel(type->subtypes, ctxt, name);
+            break;
+        default:
+            xmlGenericError(xmlGenericErrorContext,
+                            "Found unexpected type %d in %s content model\n",
+                            type->type, name);
+            return;
+    }
+}
+
+/**
+ * xmlSchemaBuildContentModel:
+ * @elem:  the element
+ * @ctxt:  the schema parser context
+ * @name:  the element name
+ *
+ * Builds the content model of the element.
+ */
+static void
+xmlSchemaBuildContentModel(xmlSchemaElementPtr elem,
+                           xmlSchemaParserCtxtPtr ctxt,
+                           const xmlChar * name)
+{
+    xmlAutomataStatePtr start;
+
+    if (elem->contModel != NULL)
+        return;
+    if (elem->subtypes == NULL) {
+        elem->contentType = XML_SCHEMA_CONTENT_ANY;
+        return;
+    }
+    if (elem->subtypes->type != XML_SCHEMA_TYPE_COMPLEX)
+        return;
+    if ((elem->subtypes->contentType == XML_SCHEMA_CONTENT_BASIC) ||
+        (elem->subtypes->contentType == XML_SCHEMA_CONTENT_SIMPLE))
+        return;
+
+#ifdef DEBUG_CONTENT
+    xmlGenericError(xmlGenericErrorContext,
+                    "Building content model for %s\n", name);
+#endif
+
+    ctxt->am = xmlNewAutomata();
+    if (ctxt->am == NULL) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "Cannot create automata for elem %s\n", name);
+        return;
+    }
+    start = ctxt->state = xmlAutomataGetInitState(ctxt->am);
+    xmlSchemaBuildAContentModel(elem->subtypes, ctxt, name);
+    xmlAutomataSetFinalState(ctxt->am, ctxt->state);
+    elem->contModel = xmlAutomataCompile(ctxt->am);
+    if (elem->contModel == NULL) {
+        xmlSchemaPErr(ctxt, elem->node, XML_SCHEMAS_ERR_INTERNAL,
+                      "failed to compile %s content model\n", name, NULL);
+    } else if (xmlRegexpIsDeterminist(elem->contModel) != 1) {
+        xmlSchemaPErr(ctxt, elem->node, XML_SCHEMAS_ERR_NOTDETERMINIST,
+                      "Content model of %s is not determinist:\n", name,
+                      NULL);
+    } else {
+#ifdef DEBUG_CONTENT_REGEXP
+        xmlGenericError(xmlGenericErrorContext,
+                        "Content model of %s:\n", name);
+        xmlRegexpPrint(stderr, elem->contModel);
+#endif
+    }
+    ctxt->state = NULL;
+    xmlFreeAutomata(ctxt->am);
+    ctxt->am = NULL;
+}
+
+/**
+ * xmlSchemaRefFixupCallback:
+ * @elem:  the schema element context
+ * @ctxt:  the schema parser context
+ *
+ * Free the resources associated to the schema parser context
+ */
+static void
+xmlSchemaRefFixupCallback(xmlSchemaElementPtr elem,
+                          xmlSchemaParserCtxtPtr ctxt,
+                          const xmlChar * name,
+                          const xmlChar * context ATTRIBUTE_UNUSED,
+                          const xmlChar * namespace ATTRIBUTE_UNUSED)
+{
+    if ((ctxt == NULL) || (elem == NULL))
+        return;
+    if (elem->ref != NULL) {
+        xmlSchemaElementPtr elemDecl;
+
+        if (elem->subtypes != NULL) {
+            xmlSchemaPErr(ctxt, elem->node,
+                          XML_SCHEMAP_INVALID_REF_AND_SUBTYPE,
+                          "Schemas: element %s have both ref and subtype\n",
+                          name, NULL);
+            return;
+        }
+        elemDecl = xmlSchemaGetElem(ctxt->schema, elem->ref, elem->refNs, 0);
+
+        if (elemDecl == NULL) {
+            xmlSchemaPErr(ctxt, elem->node, XML_SCHEMAP_UNKNOWN_REF,
+                          "Schemas: element %s ref to %s not found\n",
+                          name, elem->ref);
+            return;
+        }
+        elem->refDecl = elemDecl;
+    } else if (elem->namedType != NULL) {
+        xmlSchemaTypePtr typeDecl;
+
+        if (elem->subtypes != NULL) {
+            xmlSchemaPErr(ctxt, elem->node, XML_SCHEMAP_TYPE_AND_SUBTYPE,
+                          "Schemas: element %s have both type and subtype\n",
+                          name, NULL);
+            return;
+        }
+        typeDecl = xmlSchemaGetType(ctxt->schema, elem->namedType,
+                                    elem->namedTypeNs);
+
+        if (typeDecl == NULL) {
+            xmlSchemaPErr(ctxt, elem->node, XML_SCHEMAP_UNKNOWN_TYPE,
+                          "Schemas: element %s type %s not found\n", name,
+                          elem->namedType);
+            return;
+        }
+        elem->subtypes = typeDecl;
+    }
+}
+
+static void
+xmlSchemaParseUnionRefCheck(xmlSchemaTypePtr typeDecl,
+                   xmlSchemaParserCtxtPtr ctxt)
+{
+    const xmlChar *cur, *end, *prefix, *ncName, *namespace;
+    xmlChar *tmp;
+    xmlSchemaTypePtr subtype;
+    xmlNsPtr ns;
+    int len;
+
+     if ((typeDecl->type != XML_SCHEMA_TYPE_UNION) || (typeDecl->ref == NULL))
+        return;
+
+    cur = typeDecl->ref;
+    do {
+        while (IS_BLANK_CH(*cur))
+            cur++;
+        end = cur;
+        while ((*end != 0) && (!(IS_BLANK_CH(*end))))
+            end++;
+        if (end == cur)
+            break;
+        tmp = xmlStrndup(cur, end - cur);
+        ncName = xmlSplitQName3(tmp, &len);
+        if (ncName != NULL) {
+            prefix = xmlDictLookup(ctxt->dict, tmp, len);
+        } else {
+            prefix = NULL;
+            ncName = tmp;
+        }
+        ns = xmlSearchNs(typeDecl->node->doc, typeDecl->node, prefix);
+        if (ns == NULL) {
+            xmlSchemaPErr(ctxt, typeDecl->node, XML_SCHEMAP_PREFIX_UNDEFINED,
+                  "Union %s: the namespace of member type %s is undefined\n",
+                  typeDecl->name, (const xmlChar *) tmp);
+	    namespace = NULL;
+        } else {
+            namespace = xmlDictLookup(ctxt->dict, ns->href, -1);
+        }
+        /* Lookup the referenced type */
+        subtype = xmlSchemaGetType(ctxt->schema, ncName, namespace);
+        if (subtype == NULL) {
+            xmlSchemaPErr(ctxt, typeDecl->node, XML_SCHEMAP_UNKNOWN_MEMBER_TYPE,
+                       "Union %s references an unknown member type >%s<\n",
+                       typeDecl->name,  (const xmlChar *) tmp);
+        } 
+	 xmlFree(tmp);
+        cur = end;
+    } while (*cur != 0);
+    
+}
+
+/**
+ * xmlSchemaTypeFixup:
+ * @typeDecl:  the schema type definition
+ * @ctxt:  the schema parser context
+ *
+ * Fixes the content model of the type.
+ */
+static void
+xmlSchemaTypeFixup(xmlSchemaTypePtr typeDecl,
+                   xmlSchemaParserCtxtPtr ctxt, const xmlChar * name)
+{
+    if (typeDecl == NULL)
+        return;
+    if (name == NULL)
+        name = typeDecl->name;
+    if (typeDecl->contentType == XML_SCHEMA_CONTENT_UNKNOWN) {
+        switch (typeDecl->type) {
+            case XML_SCHEMA_TYPE_SIMPLE_CONTENT:{
+                    xmlSchemaTypeFixup(typeDecl->subtypes, ctxt, NULL);
+                    if (typeDecl->subtypes != NULL)
+                        typeDecl->contentType =
+                            typeDecl->subtypes->contentType;
+                    break;
+                }
+            case XML_SCHEMA_TYPE_RESTRICTION:{
+                    if (typeDecl->subtypes != NULL)
+                        xmlSchemaTypeFixup(typeDecl->subtypes, ctxt, NULL);
+
+                    if (typeDecl->base != NULL) {
+                        xmlSchemaTypePtr baseType;
+
+                        baseType =
+                            xmlSchemaGetType(ctxt->schema, typeDecl->base,
+                                             typeDecl->baseNs);
+                        if (baseType == NULL) {
+			    xmlSchemaPErr(ctxt, typeDecl->node,
+			                  XML_SCHEMAP_UNKNOWN_BASE_TYPE,
+				"Schemas: type %s base type %s not found\n",
+                                          name, typeDecl->base);
+                        }
+                        typeDecl->baseType = baseType;
+                    }
+		    if (typeDecl->subtypes == NULL)
+			if (typeDecl->baseType != NULL)
+			    typeDecl->contentType =
+			             typeDecl->baseType->contentType;
+			else 
+                            /* 1.1.1 */
+                            typeDecl->contentType = XML_SCHEMA_CONTENT_EMPTY;
+                    else if ((typeDecl->subtypes->subtypes == NULL) &&
+                             ((typeDecl->subtypes->type ==
+                               XML_SCHEMA_TYPE_ALL)
+                              || (typeDecl->subtypes->type ==
+                                  XML_SCHEMA_TYPE_SEQUENCE)))
+                        /* 1.1.2 */
+                        typeDecl->contentType = XML_SCHEMA_CONTENT_EMPTY;
+                    else if ((typeDecl->subtypes->type ==
+                              XML_SCHEMA_TYPE_CHOICE)
+                             && (typeDecl->subtypes->subtypes == NULL))
+                        /* 1.1.3 */
+                        typeDecl->contentType = XML_SCHEMA_CONTENT_EMPTY;
+                    else {
+                        /* 1.2 and 2.X are applied at the other layer */
+                        typeDecl->contentType =
+                            XML_SCHEMA_CONTENT_ELEMENTS;
+                    }
+                    break;
+                }
+            case XML_SCHEMA_TYPE_EXTENSION:{
+                    xmlSchemaContentType explicitContentType;
+                    xmlSchemaTypePtr base;
+
+                    if (typeDecl->base != NULL) {
+                        xmlSchemaTypePtr baseType;
+
+                        baseType =
+                            xmlSchemaGetType(ctxt->schema, typeDecl->base,
+                                             typeDecl->baseNs);
+                        if (baseType == NULL) {
+			    xmlSchemaPErr(ctxt, typeDecl->node,
+			                  XML_SCHEMAP_UNKNOWN_BASE_TYPE,
+				"Schemas: type %s base type %s not found\n",
+                                          name, typeDecl->base);
+                        }
+                        typeDecl->baseType = baseType;
+                    }
+                    if (typeDecl->subtypes != NULL)
+                        xmlSchemaTypeFixup(typeDecl->subtypes, ctxt, NULL);
+
+                    explicitContentType = XML_SCHEMA_CONTENT_ELEMENTS;
+                    if (typeDecl->subtypes == NULL)
+                        /* 1.1.1 */
+                        explicitContentType = XML_SCHEMA_CONTENT_EMPTY;
+                    else if ((typeDecl->subtypes->subtypes == NULL) &&
+                             ((typeDecl->subtypes->type ==
+                               XML_SCHEMA_TYPE_ALL)
+                              || (typeDecl->subtypes->type ==
+                                  XML_SCHEMA_TYPE_SEQUENCE)))
+                        /* 1.1.2 */
+                        explicitContentType = XML_SCHEMA_CONTENT_EMPTY;
+                    else if ((typeDecl->subtypes->type ==
+                              XML_SCHEMA_TYPE_CHOICE)
+                             && (typeDecl->subtypes->subtypes == NULL))
+                        /* 1.1.3 */
+                        explicitContentType = XML_SCHEMA_CONTENT_EMPTY;
+
+                    base = xmlSchemaGetType(ctxt->schema, typeDecl->base,
+                                            typeDecl->baseNs);
+                    if (base == NULL) {
+                        xmlSchemaPErr(ctxt, typeDecl->node,
+                                      XML_SCHEMAP_UNKNOWN_BASE_TYPE,
+                                      "Schemas: base type %s of type %s not found\n",
+                                      typeDecl->base, name);
+                        return;
+                    }
+                    if (typeDecl->recurse) {
+                        xmlSchemaPErr(ctxt, typeDecl->node,
+                                      XML_SCHEMAP_UNKNOWN_BASE_TYPE,
+				  "Schemas: extension type %s is recursive\n",
+                                      name, NULL);
+                        return;
+		    }
+		    typeDecl->recurse = 1;
+                    xmlSchemaTypeFixup(base, ctxt, NULL);
+		    typeDecl->recurse = 0;
+                    if (explicitContentType == XML_SCHEMA_CONTENT_EMPTY) {
+                        /* 2.1 */
+                        typeDecl->contentType = base->contentType;
+                    } else if (base->contentType ==
+                               XML_SCHEMA_CONTENT_EMPTY) {
+                        /* 2.2 imbitable ! */
+                        typeDecl->contentType =
+                            XML_SCHEMA_CONTENT_ELEMENTS;
+                    } else {
+                        /* 2.3 imbitable pareil ! */
+                        typeDecl->contentType =
+                            XML_SCHEMA_CONTENT_ELEMENTS;
+                    }
+                    break;
+                }
+            case XML_SCHEMA_TYPE_COMPLEX:{
+                    if (typeDecl->subtypes == NULL) {
+                        typeDecl->contentType = XML_SCHEMA_CONTENT_EMPTY;
+
+                        if (typeDecl->flags & XML_SCHEMAS_TYPE_MIXED)
+                            typeDecl->contentType =
+                                XML_SCHEMA_CONTENT_MIXED;
+                    } else {
+                        if (typeDecl->flags & XML_SCHEMAS_TYPE_MIXED)
+                            typeDecl->contentType =
+                                XML_SCHEMA_CONTENT_MIXED;
+                        else {
+                            xmlSchemaTypeFixup(typeDecl->subtypes, ctxt,
+                                               NULL);
+                            if (typeDecl->subtypes != NULL)
+                                typeDecl->contentType =
+                                    typeDecl->subtypes->contentType;
+                        }
+			if (typeDecl->attributes == NULL)
+			    typeDecl->attributes =
+			        typeDecl->subtypes->attributes;
+                    }
+                    break;
+                }
+            case XML_SCHEMA_TYPE_COMPLEX_CONTENT:{
+                    if (typeDecl->subtypes == NULL) {
+                        typeDecl->contentType = XML_SCHEMA_CONTENT_EMPTY;
+                        if (typeDecl->flags & XML_SCHEMAS_TYPE_MIXED)
+                            typeDecl->contentType =
+                                XML_SCHEMA_CONTENT_MIXED;
+                    } else {
+                        if (typeDecl->flags & XML_SCHEMAS_TYPE_MIXED)
+                            typeDecl->contentType =
+                                XML_SCHEMA_CONTENT_MIXED;
+                        else {
+                            xmlSchemaTypeFixup(typeDecl->subtypes, ctxt,
+                                               NULL);
+                            if (typeDecl->subtypes != NULL)
+                                typeDecl->contentType =
+                                    typeDecl->subtypes->contentType;
+                        }
+			if (typeDecl->attributes == NULL)
+			    typeDecl->attributes =
+			        typeDecl->subtypes->attributes;
+                    }
+                    break;
+                }
+            case XML_SCHEMA_TYPE_SEQUENCE:
+            case XML_SCHEMA_TYPE_GROUP:
+            case XML_SCHEMA_TYPE_ALL:
+            case XML_SCHEMA_TYPE_CHOICE:
+                typeDecl->contentType = XML_SCHEMA_CONTENT_ELEMENTS;
+                break;
+            case XML_SCHEMA_TYPE_BASIC:
+            case XML_SCHEMA_TYPE_ANY:
+            case XML_SCHEMA_TYPE_FACET:
+            case XML_SCHEMA_TYPE_SIMPLE:
+            case XML_SCHEMA_TYPE_UR:
+            case XML_SCHEMA_TYPE_ELEMENT:
+            case XML_SCHEMA_TYPE_ATTRIBUTE:
+            case XML_SCHEMA_TYPE_ATTRIBUTEGROUP:
+            case XML_SCHEMA_TYPE_NOTATION:
+            case XML_SCHEMA_TYPE_LIST:
+            case XML_SCHEMA_TYPE_UNION:
+                xmlSchemaParseUnionRefCheck(typeDecl, ctxt);
+            case XML_SCHEMA_FACET_MININCLUSIVE:
+            case XML_SCHEMA_FACET_MINEXCLUSIVE:
+            case XML_SCHEMA_FACET_MAXINCLUSIVE:
+            case XML_SCHEMA_FACET_MAXEXCLUSIVE:
+            case XML_SCHEMA_FACET_TOTALDIGITS:
+            case XML_SCHEMA_FACET_FRACTIONDIGITS:
+            case XML_SCHEMA_FACET_PATTERN:
+            case XML_SCHEMA_FACET_ENUMERATION:
+            case XML_SCHEMA_FACET_WHITESPACE:
+            case XML_SCHEMA_FACET_LENGTH:
+            case XML_SCHEMA_FACET_MAXLENGTH:
+            case XML_SCHEMA_FACET_MINLENGTH:
+                typeDecl->contentType = XML_SCHEMA_CONTENT_SIMPLE;
+		if (typeDecl->subtypes != NULL)
+		    xmlSchemaTypeFixup(typeDecl->subtypes, ctxt, NULL);
+                break;
+        }
+    }
+#ifdef DEBUG_TYPE
+    if (typeDecl->node != NULL) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "Type of %s : %s:%d :", name,
+                        typeDecl->node->doc->URL,
+                        xmlGetLineNo(typeDecl->node));
+    } else {
+        xmlGenericError(xmlGenericErrorContext, "Type of %s :", name);
+    }
+    switch (typeDecl->contentType) {
+        case XML_SCHEMA_CONTENT_SIMPLE:
+            xmlGenericError(xmlGenericErrorContext, "simple\n");
+            break;
+        case XML_SCHEMA_CONTENT_ELEMENTS:
+            xmlGenericError(xmlGenericErrorContext, "elements\n");
+            break;
+        case XML_SCHEMA_CONTENT_UNKNOWN:
+            xmlGenericError(xmlGenericErrorContext, "unknown !!!\n");
+            break;
+        case XML_SCHEMA_CONTENT_EMPTY:
+            xmlGenericError(xmlGenericErrorContext, "empty\n");
+            break;
+        case XML_SCHEMA_CONTENT_MIXED:
+            xmlGenericError(xmlGenericErrorContext, "mixed\n");
+            break;
+        case XML_SCHEMA_CONTENT_MIXED_OR_ELEMENTS:
+            xmlGenericError(xmlGenericErrorContext, "mixed or elems\n");
+            break;
+        case XML_SCHEMA_CONTENT_BASIC:
+            xmlGenericError(xmlGenericErrorContext, "basic\n");
+            break;
+        default:
+            xmlGenericError(xmlGenericErrorContext,
+                            "not registered !!!\n");
+            break;
+    }
+#endif
+}
+
+/**
+ * xmlSchemaCheckFacet:
+ * @facet:  the facet
+ * @typeDecl:  the schema type definition
+ * @ctxt:  the schema parser context or NULL
+ * @name: name of the type
+ *
+ * Checks the default values types, especially for facets 
+ *
+ * Returns 0 if okay or -1 in cae of error
+ */
+int
+xmlSchemaCheckFacet(xmlSchemaFacetPtr facet,
+                    xmlSchemaTypePtr typeDecl,
+                    xmlSchemaParserCtxtPtr ctxt, const xmlChar * name)
+{
+    static xmlSchemaTypePtr nonNegativeIntegerType = NULL;
+    int ret = 0;
+
+    if (nonNegativeIntegerType == NULL) {
+        nonNegativeIntegerType =
+            xmlSchemaGetPredefinedType(BAD_CAST "nonNegativeInteger",
+                                       xmlSchemaNs);
+    }
+    switch (facet->type) {
+        case XML_SCHEMA_FACET_MININCLUSIVE:
+        case XML_SCHEMA_FACET_MINEXCLUSIVE:
+        case XML_SCHEMA_FACET_MAXINCLUSIVE:
+        case XML_SCHEMA_FACET_MAXEXCLUSIVE:{
+                /*
+                 * Okay we need to validate the value
+                 * at that point.
+                 */
+                xmlSchemaValidCtxtPtr vctxt;
+
+                vctxt = xmlSchemaNewValidCtxt(NULL);
+                if (vctxt == NULL)
+                    break;
+                xmlSchemaValidateSimpleValue(vctxt, typeDecl,
+                                             facet->value);
+                facet->val = vctxt->value;
+                vctxt->value = NULL;
+                if (facet->val == NULL) {
+                    /* error code */
+                    if (ctxt != NULL) {
+                        xmlSchemaPErr(ctxt, facet->node,
+                                      XML_SCHEMAP_INVALID_FACET,
+                                      "Schemas: type %s facet value %s invalid\n",
+                                      name, facet->value);
+                    }
+                    ret = -1;
+                }
+                xmlSchemaFreeValidCtxt(vctxt);
+                break;
+            }
+        case XML_SCHEMA_FACET_ENUMERATION:{
+                /*
+                 * Okay we need to validate the value
+                 * at that point.
+                 */
+                xmlSchemaValidCtxtPtr vctxt;
+                int tmp;
+
+                vctxt = xmlSchemaNewValidCtxt(NULL);
+                if (vctxt == NULL)
+                    break;
+                tmp = xmlSchemaValidateSimpleValue(vctxt, typeDecl,
+                                                   facet->value);
+                if (tmp != 0) {
+                    if (ctxt != NULL) {
+                        xmlSchemaPErr(ctxt, facet->node,
+                                      XML_SCHEMAP_INVALID_ENUM,
+                                      "Schemas: type %s enumeration value %s invalid\n",
+                                      name, facet->value);
+                    }
+                    ret = -1;
+                }
+                xmlSchemaFreeValidCtxt(vctxt);
+                break;
+            }
+        case XML_SCHEMA_FACET_PATTERN:
+            facet->regexp = xmlRegexpCompile(facet->value);
+            if (facet->regexp == NULL) {
+		xmlSchemaPErr(ctxt, typeDecl->node,
+			      XML_SCHEMAP_REGEXP_INVALID,
+                              "Schemas: type %s facet regexp %s invalid\n",
+                              name, facet->value);
+                ret = -1;
+            }
+            break;
+        case XML_SCHEMA_FACET_TOTALDIGITS:
+        case XML_SCHEMA_FACET_FRACTIONDIGITS:
+        case XML_SCHEMA_FACET_LENGTH:
+        case XML_SCHEMA_FACET_MAXLENGTH:
+        case XML_SCHEMA_FACET_MINLENGTH:{
+                int tmp;
+
+                tmp =
+                    xmlSchemaValidatePredefinedType(nonNegativeIntegerType,
+                                                    facet->value,
+                                                    &facet->val);
+                if (tmp != 0) {
+                    /* error code */
+                    if (ctxt != NULL) {
+                        xmlSchemaPErr(ctxt, facet->node,
+                                      XML_SCHEMAP_INVALID_FACET_VALUE,
+                                      "Schemas: type %s facet value %s invalid\n",
+                                      name, facet->value);
+                    }
+                    ret = -1;
+                }
+                break;
+            }
+        case XML_SCHEMA_FACET_WHITESPACE:{
+                if (xmlStrEqual(facet->value, BAD_CAST "preserve")) {
+                    facet->whitespace = XML_SCHEMAS_FACET_PRESERVE;
+                } else if (xmlStrEqual(facet->value, BAD_CAST "replace")) {
+                    facet->whitespace = XML_SCHEMAS_FACET_REPLACE;
+                } else if (xmlStrEqual(facet->value, BAD_CAST "collapse")) {
+                    facet->whitespace = XML_SCHEMAS_FACET_COLLAPSE;
+                } else {
+                    if (ctxt != NULL) {
+                        xmlSchemaPErr(ctxt, facet->node,
+                                      XML_SCHEMAP_INVALID_WHITE_SPACE,
+                                      "Schemas: type %s whiteSpace value %s invalid\n",
+                                      name, facet->value);
+                    }
+                    ret = -1;
+                }
+            }
+        default:
+            break;
+    }
+    return (ret);
+}
+
+/**
+ * xmlSchemaCheckDefaults:
+ * @typeDecl:  the schema type definition
+ * @ctxt:  the schema parser context
+ *
+ * Checks the default values types, especially for facets 
+ */
+static void
+xmlSchemaCheckDefaults(xmlSchemaTypePtr typeDecl,
+                       xmlSchemaParserCtxtPtr ctxt, const xmlChar * name)
+{
+    if (name == NULL)
+        name = typeDecl->name;
+    if (typeDecl->type == XML_SCHEMA_TYPE_RESTRICTION) {
+        if (typeDecl->facets != NULL) {
+            xmlSchemaFacetPtr facet = typeDecl->facets;
+
+            while (facet != NULL) {
+                xmlSchemaCheckFacet(facet, typeDecl, ctxt, name);
+                facet = facet->next;
+            }
+        }
+    }
+}
+
+/**
+ * xmlSchemaAttrGrpFixup:
+ * @attrgrpDecl:  the schema attribute definition
+ * @ctxt:  the schema parser context
+ * @name:  the attribute name
+ *
+ * Fixes finish doing the computations on the attributes definitions
+ */
+static void
+xmlSchemaAttrGrpFixup(xmlSchemaAttributeGroupPtr attrgrpDecl,
+                      xmlSchemaParserCtxtPtr ctxt, const xmlChar * name)
+{
+    if (name == NULL)
+        name = attrgrpDecl->name;
+    if (attrgrpDecl->attributes != NULL)
+        return;
+    if (attrgrpDecl->ref != NULL) {
+        xmlSchemaAttributeGroupPtr ref;
+
+        ref = xmlHashLookup2(ctxt->schema->attrgrpDecl, attrgrpDecl->ref,
+                             attrgrpDecl->refNs);
+        if (ref == NULL) {
+            xmlSchemaPErr(ctxt, attrgrpDecl->node,
+                          XML_SCHEMAP_UNKNOWN_ATTRIBUTE_GROUP,
+                          "Schemas: attribute group %s reference %s not found\n",
+                          name, attrgrpDecl->ref);
+            return;
+        }
+        xmlSchemaAttrGrpFixup(ref, ctxt, NULL);
+        attrgrpDecl->attributes = ref->attributes;
+    } else {
+        xmlSchemaPErr(ctxt, attrgrpDecl->node, XML_SCHEMAP_NOATTR_NOREF,
+                      "Schemas: attribute %s has no attributes nor reference\n",
+                      name, NULL);
+    }
+}
+
+/**
+ * xmlSchemaAttrFixup:
+ * @attrDecl:  the schema attribute definition
+ * @ctxt:  the schema parser context
+ * @name:  the attribute name
+ *
+ * Fixes finish doing the computations on the attributes definitions
+ */
+static void
+xmlSchemaAttrFixup(xmlSchemaAttributePtr attrDecl,
+                   xmlSchemaParserCtxtPtr ctxt, const xmlChar * name)
+{
+    if (name == NULL)
+        name = attrDecl->name;
+    if (attrDecl->subtypes != NULL)
+        return;
+    if (attrDecl->typeName != NULL) {
+        xmlSchemaTypePtr type;
+
+        type = xmlSchemaGetType(ctxt->schema, attrDecl->typeName,
+                                attrDecl->typeNs);
+        if (type == NULL) {
+            xmlSchemaPErr(ctxt, attrDecl->node, XML_SCHEMAP_UNKNOWN_TYPE,
+                          "Schemas: attribute %s type %s not found\n",
+                          name, attrDecl->typeName);
+        }
+        attrDecl->subtypes = type;
+    } else if (attrDecl->ref != NULL) {
+        xmlSchemaAttributePtr ref;
+
+        ref = xmlHashLookup2(ctxt->schema->attrDecl, attrDecl->ref,
+                             attrDecl->refNs);
+        if (ref == NULL) {
+            xmlSchemaPErr(ctxt, attrDecl->node, XML_SCHEMAP_UNKNOWN_REF,
+                          "Schemas: attribute %s reference %s not found\n",
+                          name, attrDecl->ref);
+            return;
+        }
+        xmlSchemaAttrFixup(ref, ctxt, NULL);
+        attrDecl->subtypes = ref->subtypes;
+    } else {
+        xmlSchemaPErr(ctxt, attrDecl->node, XML_SCHEMAP_NOTYPE_NOREF,
+                      "Schemas: attribute %s has no type nor reference\n",
+                      name, NULL);
+    }
+}
+
+/**
+ * xmlSchemaParse:
+ * @ctxt:  a schema validation context
+ *
+ * parse a schema definition resource and build an internal
+ * XML Shema struture which can be used to validate instances.
+ * *WARNING* this interface is highly subject to change
+ *
+ * Returns the internal XML Schema structure built from the resource or
+ *         NULL in case of error
+ */
+xmlSchemaPtr
+xmlSchemaParse(xmlSchemaParserCtxtPtr ctxt)
+{
+    xmlSchemaPtr ret = NULL;
+    xmlDocPtr doc;
+    xmlNodePtr root;
+    int nberrors;
+    int preserve = 0;
+
+    xmlSchemaInitTypes();
+
+    if (ctxt == NULL)
+        return (NULL);
+
+    nberrors = ctxt->nberrors;
+    ctxt->nberrors = 0;
+    ctxt->counter = 0;
+    ctxt->container = NULL;
+
+    /*
+     * First step is to parse the input document into an DOM/Infoset
+     */
+    if (ctxt->URL != NULL) {
+        doc = xmlReadFile((const char *) ctxt->URL, NULL, 
+	                  SCHEMAS_PARSE_OPTIONS);
+        if (doc == NULL) {
+	    xmlSchemaPErr(ctxt, NULL,
+			  XML_SCHEMAP_FAILED_LOAD,
+                          "xmlSchemaParse: could not load %s\n",
+                          ctxt->URL, NULL);
+            return (NULL);
+        }
+    } else if (ctxt->buffer != NULL) {
+        doc = xmlReadMemory(ctxt->buffer, ctxt->size, NULL, NULL,
+	                    SCHEMAS_PARSE_OPTIONS);
+        if (doc == NULL) {
+	    xmlSchemaPErr(ctxt, NULL,
+			  XML_SCHEMAP_FAILED_PARSE,
+                          "xmlSchemaParse: could not parse\n",
+                          NULL, NULL);
+            return (NULL);
+        }
+        doc->URL = xmlStrdup(BAD_CAST "in_memory_buffer");
+        ctxt->URL = xmlDictLookup(ctxt->dict, BAD_CAST "in_memory_buffer", -1);
+    } else if (ctxt->doc != NULL) {
+        doc = ctxt->doc;
+	preserve = 1;
+    } else {
+	xmlSchemaPErr(ctxt, NULL,
+		      XML_SCHEMAP_NOTHING_TO_PARSE,
+		      "xmlSchemaParse: could not parse\n",
+		      NULL, NULL);
+        return (NULL);
+    }
+
+    /*
+     * Then extract the root and Schema parse it
+     */
+    root = xmlDocGetRootElement(doc);
+    if (root == NULL) {
+	xmlSchemaPErr(ctxt, (xmlNodePtr) doc,
+		      XML_SCHEMAP_NOROOT,
+		      "schemas has no root", NULL, NULL);
+	if (!preserve) {
+	    xmlFreeDoc(doc);
+	}
+        return (NULL);
+    }
+
+    /*
+     * Remove all the blank text nodes
+     */
+    xmlSchemaCleanupDoc(ctxt, root);
+
+    /*
+     * Then do the parsing for good
+     */
+    ret = xmlSchemaParseSchema(ctxt, root);
+    if (ret == NULL) {
+        if (!preserve) {
+	    xmlFreeDoc(doc);
+	}
+        return (NULL);
+    }
+    ret->doc = doc;
+    ret->preserve = preserve;
+
+    /*
+     * Then fix all the references.
+     */
+    ctxt->schema = ret;
+    xmlHashScanFull(ret->elemDecl,
+                    (xmlHashScannerFull) xmlSchemaRefFixupCallback, ctxt);
+
+    /*
+     * Then fixup all attributes declarations
+     */
+    xmlHashScan(ret->attrDecl, (xmlHashScanner) xmlSchemaAttrFixup, ctxt);
+
+    /*
+     * Then fixup all attributes group declarations
+     */
+    xmlHashScan(ret->attrgrpDecl, (xmlHashScanner) xmlSchemaAttrGrpFixup,
+                ctxt);
+
+    /*
+     * Then fixup all types properties
+     */
+    xmlHashScan(ret->typeDecl, (xmlHashScanner) xmlSchemaTypeFixup, ctxt);
+
+    /*
+     * Then build the content model for all elements
+     */
+    xmlHashScan(ret->elemDecl,
+                (xmlHashScanner) xmlSchemaBuildContentModel, ctxt);
+
+    /*
+     * Then check the defaults part of the type like facets values
+     */
+    xmlHashScan(ret->typeDecl, (xmlHashScanner) xmlSchemaCheckDefaults,
+                ctxt);
+
+    if (ctxt->nberrors != 0) {
+        xmlSchemaFree(ret);
+        ret = NULL;
+    }
+    return (ret);
+}
+
+/**
+ * xmlSchemaSetParserErrors:
+ * @ctxt:  a schema validation context
+ * @err:  the error callback
+ * @warn:  the warning callback
+ * @ctx:  contextual data for the callbacks
+ *
+ * Set the callback functions used to handle errors for a validation context
+ */
+void
+xmlSchemaSetParserErrors(xmlSchemaParserCtxtPtr ctxt,
+                         xmlSchemaValidityErrorFunc err,
+                         xmlSchemaValidityWarningFunc warn, void *ctx)
+{
+    if (ctxt == NULL)
+        return;
+    ctxt->error = err;
+    ctxt->warning = warn;
+    ctxt->userData = ctx;
+}
+
+/**
+ * xmlSchemaFacetTypeToString:
+ * @type:  the facet type
+ *
+ * Convert the xmlSchemaTypeType to a char string.
+ *
+ * Returns the char string representation of the facet type if the
+ *     type is a facet and an "Internal Error" string otherwise.
+ */
+static const char *
+xmlSchemaFacetTypeToString(xmlSchemaTypeType type)
+{
+    switch (type) {
+        case XML_SCHEMA_FACET_PATTERN:
+            return ("pattern");
+        case XML_SCHEMA_FACET_MAXEXCLUSIVE:
+            return ("maxExclusive");
+        case XML_SCHEMA_FACET_MAXINCLUSIVE:
+            return ("maxInclusive");
+        case XML_SCHEMA_FACET_MINEXCLUSIVE:
+            return ("minExclusive");
+        case XML_SCHEMA_FACET_MININCLUSIVE:
+            return ("minInclusive");
+        case XML_SCHEMA_FACET_WHITESPACE:
+            return ("whiteSpace");
+        case XML_SCHEMA_FACET_ENUMERATION:
+            return ("enumeration");
+        case XML_SCHEMA_FACET_LENGTH:
+            return ("length");
+        case XML_SCHEMA_FACET_MAXLENGTH:
+            return ("maxLength");
+        case XML_SCHEMA_FACET_MINLENGTH:
+            return ("minLength");
+        case XML_SCHEMA_FACET_TOTALDIGITS:
+            return ("totalDigits");
+        case XML_SCHEMA_FACET_FRACTIONDIGITS:
+            return ("fractionDigits");
+        default:
+            break;
+    }
+    return ("Internal Error");
+}
+
+/**
+ * xmlSchemaValidateFacetsInternal:
+ * @ctxt:  a schema validation context
+ * @base:  the base type
+ * @facets:  the list of facets to check
+ * @value:  the lexical repr of the value to validate
+ * @val:  the precomputed value
+ * @fireErrors:  if 0, only internal errors will be fired; otherwise all errors will be fired.
+ *
+ * Check a value against all facet conditions
+ *
+ * Returns 0 if the element is schemas valid, a positive error code
+ *     number otherwise and -1 in case of internal or API error.
+ */
+static int
+xmlSchemaValidateFacetsInternal(xmlSchemaValidCtxtPtr ctxt,
+                        xmlSchemaTypePtr base,
+                        xmlSchemaFacetPtr facets, const xmlChar * value, int fireErrors)
+{
+    int ret = 0;
+    int tmp = 0;
+    xmlSchemaTypeType type;
+    xmlSchemaFacetPtr facet = facets;
+
+    while (facet != NULL) {
+        type = facet->type;
+        if (type == XML_SCHEMA_FACET_ENUMERATION) {
+            tmp = 1;
+
+            while (facet != NULL) {
+                tmp =
+                    xmlSchemaValidateFacet(base, facet, value,
+                                           ctxt->value);
+                if (tmp == 0) {
+                    return 0;
+                }
+                facet = facet->next;
+            }
+        } else
+            tmp = xmlSchemaValidateFacet(base, facet, value, ctxt->value);
+
+        if (tmp != 0) {
+            ret = tmp;
+            if (fireErrors)
+                xmlSchemaVErr(ctxt, ctxt->cur, XML_SCHEMAS_ERR_FACET, "Failed to validate type with facet %s\n", (const xmlChar *) xmlSchemaFacetTypeToString(type), NULL);
+        }
+        if (facet != NULL)
+            facet = facet->next;
+    }
+    return (ret);
+}
+
+/**
+ * xmlSchemaValidateFacets:
+ * @ctxt:  a schema validation context
+ * @base:  the base type
+ * @facets:  the list of facets to check
+ * @value:  the lexical repr of the value to validate
+ * @val:  the precomputed value
+ *
+ * Check a value against all facet conditions
+ *
+ * Returns 0 if the element is schemas valid, a positive error code
+ *     number otherwise and -1 in case of internal or API error.
+ */
+static int
+xmlSchemaValidateFacets(xmlSchemaValidCtxtPtr ctxt,
+                        xmlSchemaTypePtr base,
+                        xmlSchemaFacetPtr facets, const xmlChar * value)
+{
+    return(xmlSchemaValidateFacetsInternal(ctxt, base, facets, value, 1));
+}
+
+/************************************************************************
+ * 									*
+ * 			Simple type validation				*
+ * 									*
+ ************************************************************************/
+
+/**
+ * xmlSchemaValidateSimpleValueUnion:
+ * @ctxt:  a schema validation context
+ * @type:  the type declaration
+ * @value:  the value to validate
+ *
+ * Validates a value against a union.
+ *
+ * Returns 0 if the value is valid, a positive error code
+ *     number otherwise and -1 in case of internal or API error.
+ */
+static int
+xmlSchemaValidateSimpleValueUnion(xmlSchemaValidCtxtPtr ctxt,
+                             xmlSchemaTypePtr type, const xmlChar * value)
+{
+    int ret = 0;
+    const xmlChar *cur, *end, *prefix, *ncName;
+    xmlChar *tmp;
+    xmlSchemaTypePtr subtype;
+    xmlNsPtr ns;
+    int len;
+   
+
+    /* Process referenced memberTypes. */
+    cur = type->ref;
+    do {
+        while (IS_BLANK_CH(*cur))
+            cur++;
+        end = cur;
+        while ((*end != 0) && (!(IS_BLANK_CH(*end))))
+            end++;
+        if (end == cur)
+            break;
+        tmp = xmlStrndup(cur, end - cur);
+         ncName = xmlSplitQName3(tmp, &len);
+        if (ncName != NULL) {
+            prefix = xmlStrndup(tmp, len);
+            /* prefix = xmlDictLookup(ctxt->doc->dict, tmp, len); */
+        } else {
+            prefix = NULL;
+            ncName = tmp;
+        }
+        /* We won't do additional checks here, since they have been performed during parsing. */
+        ns = xmlSearchNs(type->node->doc, type->node, prefix);
+        /* namespace = xmlDictLookup(ctxt->doc->dict, ns->href, -1); */
+        subtype = xmlSchemaGetType(ctxt->schema, ncName, ns->href);
+	if (tmp != NULL)
+	    xmlFree(tmp);
+	if (prefix != NULL)
+	    xmlFree((void *)prefix);
+        ret = xmlSchemaValidateSimpleValueInternal(ctxt, subtype, value, 0);
+        if ((ret == 0) || (ret == -1)) {
+            return (ret);
+        }
+        cur = end;
+    } while (*cur != 0);
+
+    if (type->subtypes != NULL) {
+        subtype = type->subtypes;
+        do {
+            ret = xmlSchemaValidateSimpleValueInternal(ctxt, subtype, value, 0);
+            if ((ret == 0) || (ret == -1)) {
+                return (ret);
+            }
+            subtype = subtype->next;
+        } while (subtype != NULL);
+    }
+    return (ret);
+}
+
+/**
+ * xmlSchemaValidateSimpleValue:
+ * @ctxt:  a schema validation context
+ * @type:  the type declaration
+ * @value:  the value to validate
+ *
+ * Validate a value against a simple type
+ *
+ * Returns 0 if the value is valid, a positive error code
+ *     number otherwise and -1 in case of internal or API error.
+ */
+static int
+xmlSchemaValidateSimpleValue(xmlSchemaValidCtxtPtr ctxt,
+                             xmlSchemaTypePtr type, const xmlChar * value)
+{
+  return (xmlSchemaValidateSimpleValueInternal(ctxt, type, value, 1));
+}
+
+/**
+ * xmlSchemaValidateSimpleValue:
+ * @ctxt:  a schema validation context
+ * @type:  the type declaration
+ * @value:  the value to validate
+ * @fireErrors:  if 0, only internal errors will be fired; otherwise all errors will be fired.
+ *
+ * Validate a value against a simple type
+ *
+ * Returns 0 if the value is valid, a positive error code
+ *     number otherwise and -1 in case of internal or API error.
+ */
+static int
+xmlSchemaValidateSimpleValueInternal(xmlSchemaValidCtxtPtr ctxt,
+                             xmlSchemaTypePtr type, const xmlChar * value, int fireErrors)
+{
+    int ret = 0;
+
+    /*
+     * First normalize the value accordingly to Schema Datatype
+     * 4.3.6 whiteSpace definition of the whiteSpace facet of type
+     */
+    /*
+     * Then check the normalized value against the lexical space of the
+     * type.
+     */
+    if (type->type == XML_SCHEMA_TYPE_BASIC) {
+        if (ctxt->value != NULL) {
+            xmlSchemaFreeValue(ctxt->value);
+            ctxt->value = NULL;
+        }
+        ret = xmlSchemaValPredefTypeNode(type, value, &(ctxt->value),
+                                         ctxt->cur);
+        if ((fireErrors) && (ret != 0)) {
+            xmlSchemaVErr(ctxt, ctxt->cur, XML_SCHEMAS_ERR_VALUE, "Failed to validate basic type %s\n", type->name, NULL);
+        }
+    } else if (type->type == XML_SCHEMA_TYPE_RESTRICTION) {
+        xmlSchemaTypePtr base;
+        xmlSchemaFacetPtr facet;
+
+        base = type->baseType;
+        if (base != NULL) {
+            ret = xmlSchemaValidateSimpleValueInternal(ctxt, base, value, fireErrors);
+        } else if (type->subtypes != NULL) {
+	    TODO
+        }
+
+        /*
+         * Do not validate facets or attributes when working on
+	 * building the Schemas
+         */
+        if (ctxt->schema != NULL) {
+            if (ret == 0) {
+                facet = type->facets;
+                ret = xmlSchemaValidateFacetsInternal(ctxt, base, facet, value, fireErrors);
+            }
+        }
+    } else if (type->type == XML_SCHEMA_TYPE_SIMPLE) {
+        xmlSchemaTypePtr base;
+
+        base = type->subtypes;
+        if (base != NULL) {
+            ret = xmlSchemaValidateSimpleValueInternal(ctxt, base, value, fireErrors);
+        } else {
+        TODO}
+    } else if (type->type == XML_SCHEMA_TYPE_LIST) {
+        xmlSchemaTypePtr base;
+        const xmlChar *cur, *end;
+	xmlChar *tmp;
+        int ret2;
+
+        base = type->subtypes;
+        if (base == NULL) {
+	    xmlSchemaVErr(ctxt, type->node, XML_SCHEMAS_ERR_INTERNAL,
+			"Internal: List type %s has no base type\n",
+			type->name, NULL);
+            return (-1);
+        }
+        cur = value;
+        do {
+            while (IS_BLANK_CH(*cur))
+                cur++;
+            end = cur;
+            while ((*end != 0) && (!(IS_BLANK_CH(*end))))
+                end++;
+            if (end == cur)
+                break;
+            tmp = xmlStrndup(cur, end - cur);
+            ret2 = xmlSchemaValidateSimpleValueInternal(ctxt, base, tmp, fireErrors);
+	    xmlFree(tmp);
+            if (ret2 != 0)
+                ret = 1;
+            cur = end;
+        } while (*cur != 0);
+    }  else if (type->type == XML_SCHEMA_TYPE_UNION) {
+        ret = xmlSchemaValidateSimpleValueUnion(ctxt, type, value);
+        if ((fireErrors) && (ret != 0)) {
+            xmlSchemaVErr(ctxt, ctxt->cur, XML_SCHEMAS_ERR_VALUE, "Failed to validate type %s\n", type->name, NULL);
+        }
+    } else {
+        TODO
+    }
+    return (ret);
+}
+
+/************************************************************************
+ * 									*
+ * 			DOM Validation code				*
+ * 									*
+ ************************************************************************/
+
+static int xmlSchemaValidateContent(xmlSchemaValidCtxtPtr ctxt,
+                                    xmlNodePtr node);
+static int xmlSchemaValidateAttributes(xmlSchemaValidCtxtPtr ctxt,
+                                       xmlNodePtr elem,
+                                       xmlSchemaAttributePtr attributes);
+static int xmlSchemaValidateType(xmlSchemaValidCtxtPtr ctxt,
+                                 xmlNodePtr elem,
+                                 xmlSchemaElementPtr elemDecl,
+                                 xmlSchemaTypePtr type);
+
+/**
+ * xmlSchemaRegisterAttributes:
+ * @ctxt:  a schema validation context
+ * @attrs:  a list of attributes
+ *
+ * Register the list of attributes as the set to be validated on that element
+ *
+ * Returns -1 in case of error, 0 otherwise
+ */
+static int
+xmlSchemaRegisterAttributes(xmlSchemaValidCtxtPtr ctxt, xmlAttrPtr attrs)
+{
+    while (attrs != NULL) {
+        if ((attrs->ns != NULL) &&
+            (xmlStrEqual(attrs->ns->href, xmlSchemaInstanceNs))) {
+            attrs = attrs->next;
+            continue;
+        }
+        if (ctxt->attrNr >= ctxt->attrMax) {
+            xmlSchemaAttrStatePtr tmp;
+
+            ctxt->attrMax *= 2;
+            tmp = (xmlSchemaAttrStatePtr)
+                xmlRealloc(ctxt->attr, ctxt->attrMax *
+                           sizeof(xmlSchemaAttrState));
+            if (tmp == NULL) {
+                xmlSchemaVErrMemory(ctxt, "registering attributes", NULL);
+                ctxt->attrMax /= 2;
+                return (-1);
+            }
+            ctxt->attr = tmp;
+        }
+        ctxt->attr[ctxt->attrNr].attr = attrs;
+        ctxt->attr[ctxt->attrNr].state = XML_SCHEMAS_ATTR_UNKNOWN;
+        ctxt->attrNr++;
+        attrs = attrs->next;
+    }
+    return (0);
+}
+
+/**
+ * xmlSchemaCheckAttributes:
+ * @ctxt:  a schema validation context
+ * @node:  the node carrying it.
+ *
+ * Check that the registered set of attributes on the current node
+ * has been properly validated.
+ *
+ * Returns 0 if validity constraints are met, 1 otherwise.
+ */
+static int
+xmlSchemaCheckAttributes(xmlSchemaValidCtxtPtr ctxt, xmlNodePtr node)
+{
+    int ret = 0;
+    int i;
+
+    for (i = ctxt->attrBase; i < ctxt->attrNr; i++) {
+        if (ctxt->attr[i].attr == NULL)
+            break;
+        if (ctxt->attr[i].state == XML_SCHEMAS_ATTR_UNKNOWN) {
+            ret = 1;
+            xmlSchemaVErr(ctxt, node, XML_SCHEMAS_ERR_ATTRUNKNOWN, "Attribute %s on %s is unknown\n", ctxt->attr[i].attr->name, node->name);
+        }
+    }
+    return (ret);
+}
+
+/**
+ * xmlSchemaValidateSimpleContent:
+ * @ctxt:  a schema validation context
+ * @elem:  an element
+ * @type:  the type declaration
+ *
+ * Validate the content of an element expected to be a simple type
+ *
+ * Returns 0 if the element is schemas valid, a positive error code
+ *     number otherwise and -1 in case of internal or API error.
+ */
+static int
+xmlSchemaValidateSimpleContent(xmlSchemaValidCtxtPtr ctxt,
+                               xmlNodePtr node ATTRIBUTE_UNUSED)
+{
+    xmlNodePtr child;
+    xmlSchemaTypePtr type, base;
+    xmlChar *value;
+    int ret = 0;
+
+    child = ctxt->node;
+    type = ctxt->type;
+
+    /*
+     * Validation Rule: Element Locally Valid (Type): 3.1.3
+     */
+    value = xmlNodeGetContent(child);
+    /* xmlSchemaValidateSimpleValue(ctxt, type, value); */
+    switch (type->type) {
+        case XML_SCHEMA_TYPE_RESTRICTION:{
+                xmlSchemaFacetPtr facet;
+
+                base = type->baseType;
+                if (base != NULL) {
+                    ret = xmlSchemaValidateSimpleValue(ctxt, base, value);
+                } else {
+                TODO}
+                if (ret == 0) {
+                    facet = type->facets;
+                    ret =
+                        xmlSchemaValidateFacets(ctxt, base, facet, value);
+                }
+		if ((ret == 0) && (type->attributes != NULL)) {
+		    ret = xmlSchemaValidateAttributes(ctxt, node,
+		                                      type->attributes);
+		}
+                break;
+            }
+        case XML_SCHEMA_TYPE_EXTENSION:{
+	        TODO
+                break;
+            }
+        default:
+	    TODO
+    }
+    if (value != NULL)
+        xmlFree(value);
+
+    return (ret);
+}
+
+/**
+ * xmlSchemaValidateCheckNodeList
+ * @nodelist: the list of nodes
+ *
+ * Check the node list is only made of text nodes and entities pointing
+ * to text nodes
+ *
+ * Returns 1 if true, 0 if false and -1 in case of error
+ */
+static int
+xmlSchemaValidateCheckNodeList(xmlNodePtr nodelist)
+{
+    while (nodelist != NULL) {
+        if (nodelist->type == XML_ENTITY_REF_NODE) {
+            TODO                /* implement recursion in the entity content */
+        }
+        if ((nodelist->type != XML_TEXT_NODE) &&
+            (nodelist->type != XML_COMMENT_NODE) &&
+            (nodelist->type != XML_PI_NODE) &&
+            (nodelist->type != XML_PI_NODE)) {
+            return (0);
+        }
+        nodelist = nodelist->next;
+    }
+    return (1);
+}
+
+/**
+ * xmlSchemaSkipIgnored:
+ * @ctxt:  a schema validation context
+ * @type:  the current type context
+ * @node:  the top node.
+ *
+ * Skip ignorable nodes in that context
+ *
+ * Returns the new sibling
+ *     number otherwise and -1 in case of internal or API error.
+ */
+static xmlNodePtr
+xmlSchemaSkipIgnored(xmlSchemaValidCtxtPtr ctxt ATTRIBUTE_UNUSED,
+                     xmlSchemaTypePtr type, xmlNodePtr node)
+{
+    int mixed = 0;
+
+    /*
+     * TODO complete and handle entities
+     */
+    mixed = ((type->contentType == XML_SCHEMA_CONTENT_MIXED) ||
+             (type->contentType == XML_SCHEMA_CONTENT_MIXED_OR_ELEMENTS));
+    while ((node != NULL) &&
+           ((node->type == XML_COMMENT_NODE) ||
+            ((mixed == 1) && (node->type == XML_TEXT_NODE)) ||
+            (((type->contentType == XML_SCHEMA_CONTENT_ELEMENTS) &&
+              (node->type == XML_TEXT_NODE) && (IS_BLANK_NODE(node)))))) {
+        node = node->next;
+    }
+    return (node);
+}
+
+/**
+ * xmlSchemaValidateCallback:
+ * @ctxt:  a schema validation context
+ * @name:  the name of the element detected (might be NULL)
+ * @type:  the type
+ *
+ * A transition has been made in the automata associated to an element
+ * content model
+ */
+static void
+xmlSchemaValidateCallback(xmlSchemaValidCtxtPtr ctxt,
+                          const xmlChar * name ATTRIBUTE_UNUSED,
+                          xmlSchemaTypePtr type, xmlNodePtr node)
+{
+    xmlSchemaTypePtr oldtype = ctxt->type;
+    xmlNodePtr oldnode = ctxt->node;
+
+#ifdef DEBUG_CONTENT
+    xmlGenericError(xmlGenericErrorContext,
+                    "xmlSchemaValidateCallback: %s, %s, %s\n",
+                    name, type->name, node->name);
+#endif
+    ctxt->type = type;
+    ctxt->node = node;
+    xmlSchemaValidateContent(ctxt, node);
+    ctxt->type = oldtype;
+    ctxt->node = oldnode;
+}
+
+
+#if 0
+
+/**
+ * xmlSchemaValidateSimpleRestrictionType:
+ * @ctxt:  a schema validation context
+ * @node:  the top node.
+ *
+ * Validate the content of a restriction type.
+ *
+ * Returns 0 if the element is schemas valid, a positive error code
+ *     number otherwise and -1 in case of internal or API error.
+ */
+static int
+xmlSchemaValidateSimpleRestrictionType(xmlSchemaValidCtxtPtr ctxt,
+                                       xmlNodePtr node)
+{
+    xmlNodePtr child;
+    xmlSchemaTypePtr type;
+    int ret;
+
+    child = ctxt->node;
+    type = ctxt->type;
+
+    if ((ctxt == NULL) || (type == NULL)) {
+        xmlSchemaVErr(ctxt, node, XML_SCHEMAS_ERR_INTERNAL, "Internal error: xmlSchemaValidateSimpleRestrictionType %s\n", node->name, NULL);
+        return (-1);
+    }
+    /*
+     * Only text and text based entities references shall be found there
+     */
+    ret = xmlSchemaValidateCheckNodeList(child);
+    if (ret < 0) {
+        xmlSchemaVErr(ctxt, node, XML_SCHEMAS_ERR_INTERNAL, "Internal error: xmlSchemaValidateSimpleType %s content\n", node->name, NULL);
+        return (-1);
+    } else if (ret == 0) {
+        xmlSchemaVErr(ctxt, node, XML_SCHEMAS_ERR_NOTSIMPLE, "Element %s content is not a simple type\n", node->name, NULL);
+        return (-1);
+    }
+    ctxt->type = type->subtypes;
+    xmlSchemaValidateContent(ctxt, node);
+    ctxt->type = type;
+    return (ret);
+}
+#endif
+
+/**
+ * xmlSchemaValidateSimpleType:
+ * @ctxt:  a schema validation context
+ * @node:  the top node.
+ *
+ * Validate the content of an simple type.
+ *
+ * Returns 0 if the element is schemas valid, a positive error code
+ *     number otherwise and -1 in case of internal or API error.
+ */
+static int
+xmlSchemaValidateSimpleType(xmlSchemaValidCtxtPtr ctxt, xmlNodePtr node)
+{
+    xmlNodePtr child;
+    xmlSchemaTypePtr type;
+    xmlAttrPtr attr;
+    int ret;
+
+    child = ctxt->node;
+    type = ctxt->type;
+
+    if ((ctxt == NULL) || (type == NULL)) {
+        xmlSchemaVErr(ctxt, node, XML_SCHEMAS_ERR_INTERNAL, "Internal error: xmlSchemaValidateSimpleType %s\n", node->name, NULL);
+        return (-1);
+    }
+    /*
+     * Only text and text based entities references shall be found there
+     */
+    ret = xmlSchemaValidateCheckNodeList(child);
+    if (ret < 0) {
+        xmlSchemaVErr(ctxt, node, XML_SCHEMAS_ERR_INTERNAL, "Internal error: xmlSchemaValidateSimpleType %s content\n", node->name, NULL);
+        return (-1);
+    } else if (ret == 0) {
+        xmlSchemaVErr(ctxt, node, XML_SCHEMAS_ERR_NOTSIMPLE, "Element %s content is not a simple type\n", node->name, NULL);
+        return (-1);
+    }
+    /*
+     * Validation Rule: Element Locally Valid (Type): 3.1.1
+     */
+    attr = node->properties;
+    while (attr != NULL) {
+        if ((attr->ns == NULL) ||
+            (!xmlStrEqual(attr->ns->href, xmlSchemaInstanceNs)) ||
+            ((!xmlStrEqual(attr->name, BAD_CAST "type")) &&
+             (!xmlStrEqual(attr->name, BAD_CAST "nil")) &&
+             (!xmlStrEqual(attr->name, BAD_CAST "schemasLocation")) &&
+             (!xmlStrEqual
+              (attr->name, BAD_CAST "noNamespaceSchemaLocation")))) {
+            xmlSchemaVErr(ctxt, node, XML_SCHEMAS_ERR_INVALIDATTR, "Element %s: attribute %s should not be present\n", node->name, attr->name);
+            return (ctxt->err);
+        }
+    }
+
+    ctxt->type = type->subtypes;
+    ret = xmlSchemaValidateSimpleContent(ctxt, node);
+    ctxt->type = type;
+    return (ret);
+}
+
+/**
+ * xmlSchemaValidateElementType:
+ * @ctxt:  a schema validation context
+ * @node:  the top node.
+ *
+ * Validate the content of an element type.
+ * Validation Rule: Element Locally Valid (Complex Type)
+ *
+ * Returns 0 if the element is schemas valid, a positive error code
+ *     number otherwise and -1 in case of internal or API error.
+ */
+static int
+xmlSchemaValidateElementType(xmlSchemaValidCtxtPtr ctxt, xmlNodePtr node)
+{
+    xmlNodePtr child;
+    xmlSchemaTypePtr type;
+    xmlRegExecCtxtPtr oldregexp;        /* cont model of the parent */
+    xmlSchemaElementPtr decl;
+    int ret, attrBase;
+
+    oldregexp = ctxt->regexp;
+
+    child = ctxt->node;
+    type = ctxt->type;
+
+    if ((ctxt == NULL) || (type == NULL)) {
+        xmlSchemaVErr(ctxt, node, XML_SCHEMAS_ERR_INTERNAL, "Internal error: xmlSchemaValidateElementType\n", node->name, NULL);
+        return (-1);
+    }
+    if (child == NULL) {
+        if (type->minOccurs > 0) {
+            xmlSchemaVErr(ctxt, node, XML_SCHEMAS_ERR_MISSING, "Element %s: missing child %s\n", node->name, type->name);
+        }
+        return (ctxt->err);
+    }
+
+    /*
+     * Verify the element matches
+     */
+    if (!xmlStrEqual(child->name, type->name)) {
+        xmlSchemaVErr3(ctxt, node, XML_SCHEMAS_ERR_WRONGELEM, "Element %s: missing child %s found %s\n", node->name, type->name, child->name);
+        return (ctxt->err);
+    }
+    /*
+     * Verify the attributes
+     */
+    attrBase = ctxt->attrBase;
+    ctxt->attrBase = ctxt->attrNr;
+    xmlSchemaRegisterAttributes(ctxt, child->properties);
+    xmlSchemaValidateAttributes(ctxt, child, type->attributes);
+    /*
+     * Verify the element content recursively
+     */
+    decl = (xmlSchemaElementPtr) type;
+    oldregexp = ctxt->regexp;
+    if (decl->contModel != NULL) {
+        ctxt->regexp = xmlRegNewExecCtxt(decl->contModel,
+                                         (xmlRegExecCallbacks)
+                                         xmlSchemaValidateCallback, ctxt);
+#ifdef DEBUG_AUTOMATA
+        xmlGenericError(xmlGenericErrorContext, "====> %s\n", node->name);
+#endif
+    }
+    xmlSchemaValidateType(ctxt, child, (xmlSchemaElementPtr) type,
+                          type->subtypes);
+
+    if (decl->contModel != NULL) {
+        ret = xmlRegExecPushString(ctxt->regexp, NULL, NULL);
+#ifdef DEBUG_AUTOMATA
+        xmlGenericError(xmlGenericErrorContext,
+                        "====> %s : %d\n", node->name, ret);
+#endif
+        if (ret == 0) {
+            xmlSchemaVErr(ctxt, node, XML_SCHEMAS_ERR_ELEMCONT, "Element %s content check failed\n", node->name, NULL);
+        } else if (ret < 0) {
+            xmlSchemaVErr(ctxt, node, XML_SCHEMAS_ERR_ELEMCONT, "Element %s content check failure\n", node->name, NULL);
+#ifdef DEBUG_CONTENT
+        } else {
+            xmlGenericError(xmlGenericErrorContext,
+                            "Element %s content check succeeded\n",
+                            node->name);
+
+#endif
+        }
+        xmlRegFreeExecCtxt(ctxt->regexp);
+    }
+    /*
+     * Verify that all attributes were Schemas-validated
+     */
+    xmlSchemaCheckAttributes(ctxt, node);
+    ctxt->attrNr = ctxt->attrBase;
+    ctxt->attrBase = attrBase;
+
+    ctxt->regexp = oldregexp;
+
+    ctxt->node = child;
+    ctxt->type = type;
+    return (ctxt->err);
+}
+
+/**
+ * xmlSchemaValidateBasicType:
+ * @ctxt:  a schema validation context
+ * @node:  the top node.
+ *
+ * Validate the content of an element expected to be a basic type type
+ *
+ * Returns 0 if the element is schemas valid, a positive error code
+ *     number otherwise and -1 in case of internal or API error.
+ */
+static int
+xmlSchemaValidateBasicType(xmlSchemaValidCtxtPtr ctxt, xmlNodePtr node)
+{
+    int ret;
+    xmlNodePtr child, cur;
+    xmlSchemaTypePtr type;
+    xmlChar *value;             /* lexical representation */
+
+    child = ctxt->node;
+    type = ctxt->type;
+
+    if ((ctxt == NULL) || (type == NULL)) {
+        xmlSchemaVErr(ctxt, node, XML_SCHEMAS_ERR_INTERNAL, "Internal error: xmlSchemaValidateBasicType\n", node->name, NULL);
+        return (-1);
+    }
+    /*
+     * First check the content model of the node.
+     */
+    cur = child;
+    while (cur != NULL) {
+        switch (cur->type) {
+            case XML_TEXT_NODE:
+            case XML_CDATA_SECTION_NODE:
+            case XML_PI_NODE:
+            case XML_COMMENT_NODE:
+            case XML_XINCLUDE_START:
+            case XML_XINCLUDE_END:
+                break;
+            case XML_ENTITY_REF_NODE:
+            case XML_ENTITY_NODE:
+                TODO break;
+            case XML_ELEMENT_NODE:
+                xmlSchemaVErr(ctxt, node, XML_SCHEMAS_ERR_INVALIDELEM, "Element %s: child %s should not be present\n", node->name, cur->name);
+                return (ctxt->err);
+            case XML_ATTRIBUTE_NODE:
+            case XML_DOCUMENT_NODE:
+            case XML_DOCUMENT_TYPE_NODE:
+            case XML_DOCUMENT_FRAG_NODE:
+            case XML_NOTATION_NODE:
+            case XML_HTML_DOCUMENT_NODE:
+            case XML_DTD_NODE:
+            case XML_ELEMENT_DECL:
+            case XML_ATTRIBUTE_DECL:
+            case XML_ENTITY_DECL:
+            case XML_NAMESPACE_DECL:
+#ifdef LIBXML_DOCB_ENABLED
+            case XML_DOCB_DOCUMENT_NODE:
+#endif
+                xmlSchemaVErr(ctxt, node, XML_SCHEMAS_ERR_INVALIDELEM, "Element %s: node type of node unexpected here\n", node->name, NULL);
+                return (ctxt->err);
+        }
+        cur = cur->next;
+    }
+    if (child == NULL)
+        value = NULL;
+    else
+        value = xmlNodeGetContent(child->parent);
+
+    if (ctxt->value != NULL) {
+        xmlSchemaFreeValue(ctxt->value);
+        ctxt->value = NULL;
+    }
+    ret = xmlSchemaValidatePredefinedType(type, value, &(ctxt->value));
+    if (value != NULL)
+        xmlFree(value);
+    if (ret != 0) {
+        xmlSchemaVErr(ctxt, node, XML_SCHEMAS_ERR_VALUE, "Element %s: failed to validate basic type %s\n", node->name, type->name);
+    }
+    return (ret);
+}
+
+/**
+ * xmlSchemaValidateComplexType:
+ * @ctxt:  a schema validation context
+ * @node:  the top node.
+ *
+ * Validate the content of an element expected to be a complex type type
+ * xmlschema-1.html#cvc-complex-type
+ * Validation Rule: Element Locally Valid (Complex Type)
+ *
+ * Returns 0 if the element is schemas valid, a positive error code
+ *     number otherwise and -1 in case of internal or API error.
+ */
+static int
+xmlSchemaValidateComplexType(xmlSchemaValidCtxtPtr ctxt, xmlNodePtr node)
+{
+    xmlNodePtr child;
+    xmlSchemaTypePtr type, subtype;
+    int ret;
+
+    child = ctxt->node;
+    type = ctxt->type;
+    ctxt->cur = node;
+
+    switch (type->contentType) {
+        case XML_SCHEMA_CONTENT_EMPTY:
+	    if (type->baseType != NULL) {
+	    } else if (child != NULL) {
+		xmlSchemaVErr(ctxt, node, XML_SCHEMAS_ERR_NOTEMPTY, "Element %s is supposed to be empty\n", node->name, NULL);
+            }
+            if (type->attributes != NULL) {
+                xmlSchemaValidateAttributes(ctxt, node, type->attributes);
+            }
+            subtype = type->subtypes;
+            while (subtype != NULL) {
+                ctxt->type = subtype;
+                xmlSchemaValidateComplexType(ctxt, node);
+                subtype = subtype->next;
+            }
+            break;
+        case XML_SCHEMA_CONTENT_ELEMENTS:
+        case XML_SCHEMA_CONTENT_MIXED:
+        case XML_SCHEMA_CONTENT_MIXED_OR_ELEMENTS:
+            /*
+             * Skip ignorable nodes in that context
+             */
+            child = xmlSchemaSkipIgnored(ctxt, type, child);
+            while (child != NULL) {
+                if (child->type == XML_ELEMENT_NODE) {
+                    ret = xmlRegExecPushString(ctxt->regexp,
+                                               child->name, child);
+#ifdef DEBUG_AUTOMATA
+                    if (ret < 0)
+                        xmlGenericError(xmlGenericErrorContext,
+                                        "  --> %s Error\n", child->name);
+                    else
+                        xmlGenericError(xmlGenericErrorContext,
+                                        "  --> %s\n", child->name);
+#endif
+                }
+                child = child->next;
+                /*
+                 * Skip ignorable nodes in that context
+                 */
+                child = xmlSchemaSkipIgnored(ctxt, type, child);
+            }
+            if (type->attributes != NULL) {
+                xmlSchemaValidateAttributes(ctxt, node, type->attributes);
+            }
+            break;
+        case XML_SCHEMA_CONTENT_BASIC:{
+                if (type->subtypes != NULL) {
+                    ctxt->type = type->subtypes;
+                    xmlSchemaValidateComplexType(ctxt, node);
+                }
+                if (type->baseType != NULL) {
+                    ctxt->type = type->baseType;
+                    xmlSchemaValidateBasicType(ctxt, node);
+                }
+                if (type->attributes != NULL) {
+                    xmlSchemaValidateAttributes(ctxt, node,
+                                                type->attributes);
+                }
+                ctxt->type = type;
+                break;
+            }
+        case XML_SCHEMA_CONTENT_SIMPLE:{
+                if (type->subtypes != NULL) {
+                    ctxt->type = type->subtypes;
+                    xmlSchemaValidateComplexType(ctxt, node);
+                }
+                if (type->baseType != NULL) {
+                    ctxt->type = type->baseType;
+                    xmlSchemaValidateComplexType(ctxt, node);
+                }
+                if (type->attributes != NULL) {
+                    xmlSchemaValidateAttributes(ctxt, node,
+                                                type->attributes);
+                }
+                ctxt->type = type;
+                break;
+	}
+        default:
+            TODO xmlGenericError(xmlGenericErrorContext,
+                                 "unimplemented content type %d\n",
+                                 type->contentType);
+    }
+    return (ctxt->err);
+}
+
+/**
+ * xmlSchemaValidateContent:
+ * @ctxt:  a schema validation context
+ * @elem:  an element
+ * @type:  the type declaration
+ *
+ * Validate the content of an element against the type.
+ *
+ * Returns 0 if the element is schemas valid, a positive error code
+ *     number otherwise and -1 in case of internal or API error.
+ */
+static int
+xmlSchemaValidateContent(xmlSchemaValidCtxtPtr ctxt, xmlNodePtr node)
+{
+    xmlNodePtr child;
+    xmlSchemaTypePtr type;
+
+    child = ctxt->node;
+    type = ctxt->type;
+    ctxt->cur = node;
+
+    xmlSchemaValidateAttributes(ctxt, node, type->attributes);
+    ctxt->cur = node;
+
+    switch (type->type) {
+        case XML_SCHEMA_TYPE_ANY:
+            /* Any type will do it, fine */
+            TODO                /* handle recursivity */
+                break;
+        case XML_SCHEMA_TYPE_COMPLEX:
+            xmlSchemaValidateComplexType(ctxt, node);
+            break;
+        case XML_SCHEMA_TYPE_ELEMENT:{
+                xmlSchemaElementPtr decl = (xmlSchemaElementPtr) type;
+
+                /*
+                 * Handle element reference here
+                 */
+                if (decl->ref != NULL) {
+                    if (decl->refDecl == NULL) {
+                        xmlSchemaVErr(ctxt, node, XML_SCHEMAS_ERR_INTERNAL, "Internal error: element reference %s not resolved\n", decl->ref, NULL);
+                        return (-1);
+                    }
+                    ctxt->type = (xmlSchemaTypePtr) decl->refDecl;
+                    decl = decl->refDecl;
+                }
+                xmlSchemaValidateElementType(ctxt, node);
+                ctxt->type = type;
+                break;
+            }
+        case XML_SCHEMA_TYPE_BASIC:
+            xmlSchemaValidateBasicType(ctxt, node);
+            break;
+        case XML_SCHEMA_TYPE_FACET:
+            TODO break;
+        case XML_SCHEMA_TYPE_SIMPLE:
+            xmlSchemaValidateSimpleType(ctxt, node);
+            break;
+        case XML_SCHEMA_TYPE_SEQUENCE:
+            TODO break;
+        case XML_SCHEMA_TYPE_CHOICE:
+            TODO break;
+        case XML_SCHEMA_TYPE_ALL:
+            TODO break;
+        case XML_SCHEMA_TYPE_SIMPLE_CONTENT:
+            TODO break;
+        case XML_SCHEMA_TYPE_COMPLEX_CONTENT:
+            TODO break;
+        case XML_SCHEMA_TYPE_UR:
+            TODO break;
+        case XML_SCHEMA_TYPE_RESTRICTION:
+            /*xmlSchemaValidateRestrictionType(ctxt, node); */
+            TODO break;
+        case XML_SCHEMA_TYPE_EXTENSION:
+            TODO break;
+        case XML_SCHEMA_TYPE_ATTRIBUTE:
+            TODO break;
+        case XML_SCHEMA_TYPE_GROUP:
+            TODO break;
+        case XML_SCHEMA_TYPE_NOTATION:
+            TODO break;
+        case XML_SCHEMA_TYPE_LIST:
+            TODO break;
+        case XML_SCHEMA_TYPE_UNION:
+            TODO break;
+        case XML_SCHEMA_FACET_MININCLUSIVE:
+            TODO break;
+        case XML_SCHEMA_FACET_MINEXCLUSIVE:
+            TODO break;
+        case XML_SCHEMA_FACET_MAXINCLUSIVE:
+            TODO break;
+        case XML_SCHEMA_FACET_MAXEXCLUSIVE:
+            TODO break;
+        case XML_SCHEMA_FACET_TOTALDIGITS:
+            TODO break;
+        case XML_SCHEMA_FACET_FRACTIONDIGITS:
+            TODO break;
+        case XML_SCHEMA_FACET_PATTERN:
+            TODO break;
+        case XML_SCHEMA_FACET_ENUMERATION:
+            TODO break;
+        case XML_SCHEMA_FACET_WHITESPACE:
+            TODO break;
+        case XML_SCHEMA_FACET_LENGTH:
+            TODO break;
+        case XML_SCHEMA_FACET_MAXLENGTH:
+            TODO break;
+        case XML_SCHEMA_FACET_MINLENGTH:
+            TODO break;
+        case XML_SCHEMA_TYPE_ATTRIBUTEGROUP:
+            TODO break;
+    }
+    xmlSchemaValidateAttributes(ctxt, node, type->attributes);
+
+    if (ctxt->node == NULL)
+        return (ctxt->err);
+    ctxt->node = ctxt->node->next;
+    ctxt->type = type->next;
+    return (ctxt->err);
+}
+
+/**
+ * xmlSchemaValidateType:
+ * @ctxt:  a schema validation context
+ * @elem:  an element
+ * @type:  the list of type declarations
+ *
+ * Validate the content of an element against the types.
+ *
+ * Returns 0 if the element is schemas valid, a positive error code
+ *     number otherwise and -1 in case of internal or API error.
+ */
+static int
+xmlSchemaValidateType(xmlSchemaValidCtxtPtr ctxt, xmlNodePtr elem,
+                      xmlSchemaElementPtr elemDecl, xmlSchemaTypePtr type)
+{
+    xmlChar *nil;
+
+    if ((elem == NULL) || (type == NULL) || (elemDecl == NULL))
+        return (0);
+
+    /*
+     * 3.3.4 : 2
+     */
+    if (elemDecl->flags & XML_SCHEMAS_ELEM_ABSTRACT) {
+        xmlSchemaVErr(ctxt, elem, XML_SCHEMAS_ERR_ISABSTRACT, "Element %s is abstract\n", elem->name, NULL);
+        return (ctxt->err);
+    }
+    /*
+     * 3.3.4: 3
+     */
+    nil = xmlGetNsProp(elem, BAD_CAST "nil", xmlSchemaInstanceNs);
+    if (elemDecl->flags & XML_SCHEMAS_ELEM_NILLABLE) {
+        /* 3.3.4: 3.2 */
+        if (xmlStrEqual(nil, BAD_CAST "true")) {
+            if (elem->children != NULL) {
+                xmlSchemaVErr(ctxt, elem, XML_SCHEMAS_ERR_NOTEMPTY, "Element %s is not empty\n", elem->name, NULL);
+                return (ctxt->err);
+            }
+            if ((elemDecl->flags & XML_SCHEMAS_ELEM_FIXED) &&
+                (elemDecl->value != NULL)) {
+                xmlSchemaVErr(ctxt, elem, XML_SCHEMAS_ERR_HAVEDEFAULT, "Empty element %s cannot get a fixed value\n", elem->name, NULL);
+                return (ctxt->err);
+            }
+        }
+    } else {
+        /* 3.3.4: 3.1 */
+        if (nil != NULL) {
+            xmlSchemaVErr(ctxt, elem, XML_SCHEMAS_ERR_NOTNILLABLE, "Element %s with xs:nil but not nillable\n", elem->name, NULL);
+            xmlFree(nil);
+            return (ctxt->err);
+        }
+    }
+
+    /* TODO 3.3.4: 4 if the element carries xs:type */
+
+    ctxt->type = elemDecl->subtypes;
+    ctxt->node = elem->children;
+    xmlSchemaValidateContent(ctxt, elem);
+    xmlSchemaValidateAttributes(ctxt, elem, elemDecl->attributes);
+
+    return (ctxt->err);
+}
+
+
+/**
+ * xmlSchemaValidateAttributes:
+ * @ctxt:  a schema validation context
+ * @elem:  an element
+ * @attributes:  the list of attribute declarations
+ *
+ * Validate the attributes of an element.
+ *
+ * Returns 0 if the element is schemas valid, a positive error code
+ *     number otherwise and -1 in case of internal or API error.
+ */
+static int
+xmlSchemaValidateAttributes(xmlSchemaValidCtxtPtr ctxt, xmlNodePtr elem,
+                            xmlSchemaAttributePtr attributes)
+{
+    int i, ret;
+    xmlAttrPtr attr;
+    xmlChar *value;
+    xmlSchemaAttributeGroupPtr group = NULL;
+    int found;
+
+    if (attributes == NULL)
+        return (0);
+    while (attributes != NULL) {
+        found = 0;    
+        /*
+         * Handle attribute groups
+         */
+        if (attributes->type == XML_SCHEMA_TYPE_ATTRIBUTEGROUP) {
+            group = (xmlSchemaAttributeGroupPtr) attributes;
+            xmlSchemaValidateAttributes(ctxt, elem, group->attributes);
+            attributes = group->next;
+            continue;
+        }
+        for (i = ctxt->attrBase; i < ctxt->attrNr; i++) {
+            attr = ctxt->attr[i].attr;
+            if (attr == NULL)
+                continue;
+            if (attributes->ref != NULL) {
+                if (!xmlStrEqual(attr->name, attributes->ref))
+                    continue;
+                if (attr->ns != NULL) {
+                    if ((attributes->refNs == NULL) ||
+                        (!xmlStrEqual(attr->ns->href, attributes->refNs)))
+                        continue;
+                } else if (attributes->refNs != NULL) {
+                    continue;
+                }
+            } else {
+                if (!xmlStrEqual(attr->name, attributes->name))
+                    continue;
+                /*
+                 * handle the namespaces checks here
+                 */
+                if (attr->ns == NULL) {
+		    /*
+		     * accept an unqualified attribute only if the declaration
+		     * is unqualified or if the schemas allowed it.
+		     */
+		    if ((attributes->targetNamespace != NULL) &&
+		        ((attributes->flags & XML_SCHEMAS_ATTR_NSDEFAULT) == 0))
+		        continue;
+		} else {
+		    if (attributes->targetNamespace == NULL)
+		        continue;
+		    if (!xmlStrEqual(attributes->targetNamespace,
+		                     attr->ns->href))
+			continue;
+		}
+            }
+            found = 1;
+            ctxt->cur = (xmlNodePtr) attributes;
+
+            if (attributes->subtypes == NULL) {
+                xmlSchemaVErr(ctxt, (xmlNodePtr) attr, XML_SCHEMAS_ERR_INTERNAL, "Internal error: attribute %s type not resolved\n", attr->name, NULL);
+                continue;
+            }
+
+            if (attributes->occurs == XML_SCHEMAS_ATTR_USE_PROHIBITED) {
+                xmlSchemaVErr(ctxt, elem, XML_SCHEMAS_ERR_INVALIDATTR, "attribute %s on %s is prohibited\n", attributes->name, elem->name);
+                /* Setting the state to XML_SCHEMAS_ATTR_CHECKED seems not very logical but it
+                   surpresses the "attribute is unknown" error report. Please change this if you know better */
+                ctxt->attr[i].state = XML_SCHEMAS_ATTR_CHECKED;
+                break;
+            }            
+         
+            value = xmlNodeListGetString(elem->doc, attr->children, 1);
+            ret = xmlSchemaValidateSimpleValue(ctxt, attributes->subtypes,
+                                               value);
+            if (ret != 0) {
+                xmlSchemaVErr(ctxt, (xmlNodePtr) attr, XML_SCHEMAS_ERR_ATTRINVALID, "attribute %s on %s does not match type\n", attr->name, elem->name);
+            } else {
+                ctxt->attr[i].state = XML_SCHEMAS_ATTR_CHECKED;
+            }
+            if (value != NULL) {
+                xmlFree(value);
+            }
+        }
+        if ((!found) && (attributes->occurs == XML_SCHEMAS_ATTR_USE_REQUIRED)) {
+        	xmlSchemaVErr(ctxt, elem, XML_SCHEMAS_ERR_MISSING, "required attribute %s on %s is missing\n", attributes->name, elem->name);            
+        }
+        attributes = attributes->next;
+    }
+    return (ctxt->err);
+}
+
+/**
+ * xmlSchemaValidateElement:
+ * @ctxt:  a schema validation context
+ * @elem:  an element
+ *
+ * Validate an element in a tree
+ *
+ * Returns 0 if the element is schemas valid, a positive error code
+ *     number otherwise and -1 in case of internal or API error.
+ */
+static int
+xmlSchemaValidateElement(xmlSchemaValidCtxtPtr ctxt, xmlNodePtr elem)
+{
+    xmlSchemaElementPtr elemDecl;
+    int ret, attrBase;
+
+    if (elem->ns != NULL) {
+        elemDecl = xmlHashLookup3(ctxt->schema->elemDecl,
+                                  elem->name, elem->ns->href, NULL);
+    } else {
+        elemDecl = xmlHashLookup3(ctxt->schema->elemDecl,
+                                  elem->name, NULL, NULL);
+    }
+    /*
+     * special case whe elementFormDefault is unqualified for top-level elem.
+     */
+    if ((elemDecl == NULL) && (elem->ns != NULL) &&
+        (elem->parent != NULL) && (elem->parent->type != XML_ELEMENT_NODE) &&
+        (xmlStrEqual(ctxt->schema->targetNamespace, elem->ns->href)) &&
+	((ctxt->schema->flags & XML_SCHEMAS_QUALIF_ELEM) == 0)) {
+        elemDecl = xmlHashLookup3(ctxt->schema->elemDecl,
+                                  elem->name, NULL, NULL);
+    }
+
+    /*
+     * 3.3.4 : 1
+     */
+    if (elemDecl == NULL) {
+        xmlSchemaVErr(ctxt, elem, XML_SCHEMAS_ERR_UNDECLAREDELEM, "Element %s not declared\n", elem->name, NULL);
+        return (ctxt->err);
+    }
+    if (elemDecl->subtypes == NULL) {
+        xmlSchemaVErr(ctxt, elem, XML_SCHEMAS_ERR_NOTYPE, "Element %s has no type\n", elem->name, NULL);
+        return (ctxt->err);
+    }
+    /*
+     * Verify the attributes
+     */
+    attrBase = ctxt->attrBase;
+    ctxt->attrBase = ctxt->attrNr;
+    xmlSchemaRegisterAttributes(ctxt, elem->properties);
+    xmlSchemaValidateAttributes(ctxt, elem, elemDecl->attributes);
+    /*
+     * Verify the element content recursively
+     */
+    if (elemDecl->contModel != NULL) {
+        ctxt->regexp = xmlRegNewExecCtxt(elemDecl->contModel,
+                                         (xmlRegExecCallbacks)
+                                         xmlSchemaValidateCallback, ctxt);
+#ifdef DEBUG_AUTOMATA
+        xmlGenericError(xmlGenericErrorContext, "====> %s\n", elem->name);
+#endif
+    }
+    xmlSchemaValidateType(ctxt, elem, elemDecl, elemDecl->subtypes);
+    if (elemDecl->contModel != NULL) {
+        ret = xmlRegExecPushString(ctxt->regexp, NULL, NULL);
+#ifdef DEBUG_AUTOMATA
+        xmlGenericError(xmlGenericErrorContext,
+                        "====> %s : %d\n", elem->name, ret);
+#endif
+        if (ret == 0) {
+            xmlSchemaVErr(ctxt, elem, XML_SCHEMAS_ERR_ELEMCONT, "Element %s content check failed\n", elem->name, NULL);
+        } else if (ret < 0) {
+            xmlSchemaVErr(ctxt, elem, XML_SCHEMAS_ERR_ELEMCONT, "Element %s content check failed\n", elem->name, NULL);
+#ifdef DEBUG_CONTENT
+        } else {
+            xmlGenericError(xmlGenericErrorContext,
+                            "Element %s content check succeeded\n",
+                            elem->name);
+
+#endif
+        }
+        xmlRegFreeExecCtxt(ctxt->regexp);
+    }
+    /*
+     * Verify that all attributes were Schemas-validated
+     */
+    xmlSchemaCheckAttributes(ctxt, elem);
+    ctxt->attrNr = ctxt->attrBase;
+    ctxt->attrBase = attrBase;
+
+    return (ctxt->err);
+}
+
+/**
+ * xmlSchemaValidateDocument:
+ * @ctxt:  a schema validation context
+ * @doc:  a parsed document tree
+ *
+ * Validate a document tree in memory.
+ *
+ * Returns 0 if the document is schemas valid, a positive error code
+ *     number otherwise and -1 in case of internal or API error.
+ */
+static int
+xmlSchemaValidateDocument(xmlSchemaValidCtxtPtr ctxt, xmlDocPtr doc)
+{
+    xmlNodePtr root;
+    xmlSchemaElementPtr elemDecl;
+
+    root = xmlDocGetRootElement(doc);
+    if (root == NULL) {
+        xmlSchemaVErr(ctxt, (xmlNodePtr) doc, XML_SCHEMAS_ERR_NOROOT, "document has no root\n", NULL, NULL);
+        return (ctxt->err);
+    }
+    if (root->ns != NULL)
+        elemDecl = xmlHashLookup3(ctxt->schema->elemDecl,
+                                  root->name, root->ns->href, NULL);
+    else
+        elemDecl = xmlHashLookup3(ctxt->schema->elemDecl,
+                                  root->name, NULL, NULL);
+    /*
+     * special case whe elementFormDefault is unqualified for top-level elem.
+     */
+    if ((elemDecl == NULL) && (root->ns != NULL) &&
+        (xmlStrEqual(ctxt->schema->targetNamespace, root->ns->href)) &&
+	((ctxt->schema->flags & XML_SCHEMAS_QUALIF_ELEM) == 0)) {
+        elemDecl = xmlHashLookup3(ctxt->schema->elemDecl,
+                                  root->name, NULL, NULL);
+    }
+
+    if (elemDecl == NULL) {
+        xmlSchemaVErr(ctxt, root, XML_SCHEMAS_ERR_UNDECLAREDELEM, "Element %s not declared\n", root->name, NULL);
+    } else if ((elemDecl->flags & XML_SCHEMAS_ELEM_TOPLEVEL) == 0) {
+        xmlSchemaVErr(ctxt, root, XML_SCHEMAS_ERR_NOTTOPLEVEL, "Root element %s not toplevel\n", root->name, NULL);
+    }
+    /*
+     * Okay, start the recursive validation
+     */
+    xmlSchemaValidateElement(ctxt, root);
+
+    return (ctxt->err);
+}
+
+/************************************************************************
+ * 									*
+ * 			SAX Validation code				*
+ * 									*
+ ************************************************************************/
+
+/************************************************************************
+ * 									*
+ * 			Validation interfaces				*
+ * 									*
+ ************************************************************************/
+
+/**
+ * xmlSchemaNewValidCtxt:
+ * @schema:  a precompiled XML Schemas
+ *
+ * Create an XML Schemas validation context based on the given schema
+ *
+ * Returns the validation context or NULL in case of error
+ */
+xmlSchemaValidCtxtPtr
+xmlSchemaNewValidCtxt(xmlSchemaPtr schema)
+{
+    xmlSchemaValidCtxtPtr ret;
+
+    ret = (xmlSchemaValidCtxtPtr) xmlMalloc(sizeof(xmlSchemaValidCtxt));
+    if (ret == NULL) {
+        xmlSchemaVErrMemory(NULL, "allocating validation context", NULL);
+        return (NULL);
+    }
+    memset(ret, 0, sizeof(xmlSchemaValidCtxt));
+    ret->schema = schema;
+    ret->attrNr = 0;
+    ret->attrMax = 10;
+    ret->attr = (xmlSchemaAttrStatePtr) xmlMalloc(ret->attrMax *
+                                                  sizeof
+                                                  (xmlSchemaAttrState));
+    if (ret->attr == NULL) {
+        xmlSchemaVErrMemory(NULL, "allocating validation context", NULL);
+        free(ret);
+        return (NULL);
+    }
+    memset(ret->attr, 0, ret->attrMax * sizeof(xmlSchemaAttrState));
+    return (ret);
+}
+
+/**
+ * xmlSchemaFreeValidCtxt:
+ * @ctxt:  the schema validation context
+ *
+ * Free the resources associated to the schema validation context
+ */
+void
+xmlSchemaFreeValidCtxt(xmlSchemaValidCtxtPtr ctxt)
+{
+    if (ctxt == NULL)
+        return;
+    if (ctxt->attr != NULL)
+        xmlFree(ctxt->attr);
+    if (ctxt->value != NULL)
+        xmlSchemaFreeValue(ctxt->value);
+    xmlFree(ctxt);
+}
+
+/**
+ * xmlSchemaSetValidErrors:
+ * @ctxt:  a schema validation context
+ * @err:  the error function
+ * @warn: the warning function
+ * @ctx: the functions context
+ *
+ * Set the error and warning callback informations
+ */
+void
+xmlSchemaSetValidErrors(xmlSchemaValidCtxtPtr ctxt,
+                        xmlSchemaValidityErrorFunc err,
+                        xmlSchemaValidityWarningFunc warn, void *ctx)
+{
+    if (ctxt == NULL)
+        return;
+    ctxt->error = err;
+    ctxt->warning = warn;
+    ctxt->userData = ctx;
+}
+
+/**
+ * xmlSchemaValidateDoc:
+ * @ctxt:  a schema validation context
+ * @doc:  a parsed document tree
+ *
+ * Validate a document tree in memory.
+ *
+ * Returns 0 if the document is schemas valid, a positive error code
+ *     number otherwise and -1 in case of internal or API error.
+ */
+int
+xmlSchemaValidateDoc(xmlSchemaValidCtxtPtr ctxt, xmlDocPtr doc)
+{
+    int ret;
+
+    if ((ctxt == NULL) || (doc == NULL))
+        return (-1);
+
+    ctxt->doc = doc;
+    ret = xmlSchemaValidateDocument(ctxt, doc);
+    return (ret);
+}
+
+/**
+ * xmlSchemaValidateStream:
+ * @ctxt:  a schema validation context
+ * @input:  the input to use for reading the data
+ * @enc:  an optional encoding information
+ * @sax:  a SAX handler for the resulting events
+ * @user_data:  the context to provide to the SAX handler.
+ *
+ * Validate a document tree in memory.
+ *
+ * Returns 0 if the document is schemas valid, a positive error code
+ *     number otherwise and -1 in case of internal or API error.
+ */
+int
+xmlSchemaValidateStream(xmlSchemaValidCtxtPtr ctxt,
+                        xmlParserInputBufferPtr input, xmlCharEncoding enc,
+                        xmlSAXHandlerPtr sax, void *user_data)
+{
+    if ((ctxt == NULL) || (input == NULL))
+        return (-1);
+    ctxt->input = input;
+    ctxt->enc = enc;
+    ctxt->sax = sax;
+    ctxt->user_data = user_data;
+    TODO return (0);
+}
+
+#endif /* LIBXML_SCHEMAS_ENABLED */
diff --git a/src/libxml/src/xmlschemastypes.c b/src/libxml/src/xmlschemastypes.c
new file mode 100644
index 0000000..9ed7fb0
--- /dev/null
+++ b/src/libxml/src/xmlschemastypes.c
@@ -0,0 +1,3597 @@
+/*
+ * schemastypes.c : implementation of the XML Schema Datatypes
+ *             definition and validity checking
+ *
+ * See Copyright for the status of this software.
+ *
+ * Daniel Veillard <veillard@redhat.com>
+ */
+
+#define IN_LIBXML
+#include "libxml.h"
+
+#ifdef LIBXML_SCHEMAS_ENABLED
+
+#include <string.h>
+#include <libxml/xmlmemory.h>
+#include <libxml/parser.h>
+#include <libxml/parserInternals.h>
+#include <libxml/hash.h>
+#include <libxml/valid.h>
+#include <libxml/xpath.h>
+#include <libxml/uri.h>
+
+#include <libxml/xmlschemas.h>
+#include <libxml/schemasInternals.h>
+#include <libxml/xmlschemastypes.h>
+
+#ifdef HAVE_MATH_H
+#include <math.h>
+#endif
+
+#define DEBUG
+
+#define TODO 								\
+    xmlGenericError(xmlGenericErrorContext,				\
+	    "Unimplemented block at %s:%d\n",				\
+            __FILE__, __LINE__);
+
+#define XML_SCHEMAS_NAMESPACE_NAME \
+    (const xmlChar *)"http://www.w3.org/2001/XMLSchema"
+
+typedef enum {
+    XML_SCHEMAS_UNKNOWN = 0,
+    XML_SCHEMAS_STRING,
+    XML_SCHEMAS_NORMSTRING,
+    XML_SCHEMAS_DECIMAL,
+    XML_SCHEMAS_TIME,
+    XML_SCHEMAS_GDAY,
+    XML_SCHEMAS_GMONTH,
+    XML_SCHEMAS_GMONTHDAY,
+    XML_SCHEMAS_GYEAR,
+    XML_SCHEMAS_GYEARMONTH,
+    XML_SCHEMAS_DATE,
+    XML_SCHEMAS_DATETIME,
+    XML_SCHEMAS_DURATION,
+    XML_SCHEMAS_FLOAT,
+    XML_SCHEMAS_DOUBLE,
+    XML_SCHEMAS_BOOLEAN,
+    XML_SCHEMAS_TOKEN,
+    XML_SCHEMAS_LANGUAGE,
+    XML_SCHEMAS_NMTOKEN,
+    XML_SCHEMAS_NMTOKENS,
+    XML_SCHEMAS_NAME,
+    XML_SCHEMAS_QNAME,
+    XML_SCHEMAS_NCNAME,
+    XML_SCHEMAS_ID,
+    XML_SCHEMAS_IDREF,
+    XML_SCHEMAS_IDREFS,
+    XML_SCHEMAS_ENTITY,
+    XML_SCHEMAS_ENTITIES,
+    XML_SCHEMAS_NOTATION,
+    XML_SCHEMAS_ANYURI,
+    XML_SCHEMAS_INTEGER,
+    XML_SCHEMAS_NPINTEGER,
+    XML_SCHEMAS_NINTEGER,
+    XML_SCHEMAS_NNINTEGER,
+    XML_SCHEMAS_PINTEGER,
+    XML_SCHEMAS_INT,
+    XML_SCHEMAS_UINT,
+    XML_SCHEMAS_LONG,
+    XML_SCHEMAS_ULONG,
+    XML_SCHEMAS_SHORT,
+    XML_SCHEMAS_USHORT,
+    XML_SCHEMAS_BYTE,
+    XML_SCHEMAS_UBYTE,
+    XML_SCHEMAS_HEXBINARY,
+    XML_SCHEMAS_BASE64BINARY
+} xmlSchemaValType;
+
+static unsigned long powten[10] = {
+    1, 10, 100, 1000, 10000, 100000, 1000000, 10000000L,
+    100000000L, 1000000000L
+};
+
+/* Date value */
+typedef struct _xmlSchemaValDate xmlSchemaValDate;
+typedef xmlSchemaValDate *xmlSchemaValDatePtr;
+struct _xmlSchemaValDate {
+    long		year;
+    unsigned int	mon	:4;	/* 1 <=  mon    <= 12   */
+    unsigned int	day	:5;	/* 1 <=  day    <= 31   */
+    unsigned int	hour	:5;	/* 0 <=  hour   <= 23   */
+    unsigned int	min	:6;	/* 0 <=  min    <= 59	*/
+    double		sec;
+    unsigned int	tz_flag	:1;	/* is tzo explicitely set? */
+    int			tzo	:11;	/* -1440 <= tzo <= 1440 */
+};
+
+/* Duration value */
+typedef struct _xmlSchemaValDuration xmlSchemaValDuration;
+typedef xmlSchemaValDuration *xmlSchemaValDurationPtr;
+struct _xmlSchemaValDuration {
+    long	        mon;		/* mon stores years also */
+    long        	day;
+    double		sec;            /* sec stores min and hour also */
+};
+
+typedef struct _xmlSchemaValDecimal xmlSchemaValDecimal;
+typedef xmlSchemaValDecimal *xmlSchemaValDecimalPtr;
+struct _xmlSchemaValDecimal {
+    /* would use long long but not portable */
+    unsigned long lo;
+    unsigned long mi;
+    unsigned long hi;
+    unsigned int extra;
+    unsigned int sign:1;
+    unsigned int frac:7;
+    unsigned int total:8;
+};
+
+typedef struct _xmlSchemaValQName xmlSchemaValQName;
+typedef xmlSchemaValQName *xmlSchemaValQNamePtr;
+struct _xmlSchemaValQName {
+    xmlChar *name;
+    xmlChar *uri;
+};
+
+typedef struct _xmlSchemaValHex xmlSchemaValHex;
+typedef xmlSchemaValHex *xmlSchemaValHexPtr;
+struct _xmlSchemaValHex {
+    xmlChar     *str;
+    unsigned int total;
+};
+
+typedef struct _xmlSchemaValBase64 xmlSchemaValBase64;
+typedef xmlSchemaValBase64 *xmlSchemaValBase64Ptr;
+struct _xmlSchemaValBase64 {
+    xmlChar     *str;
+    unsigned int total;
+};
+
+struct _xmlSchemaVal {
+    xmlSchemaValType type;
+    union {
+	xmlSchemaValDecimal     decimal;
+        xmlSchemaValDate        date;
+        xmlSchemaValDuration    dur;
+	xmlSchemaValQName	qname;
+	xmlSchemaValHex		hex;
+	xmlSchemaValBase64	base64;
+	float			f;
+	double			d;
+	int			b;
+	xmlChar                *str;
+    } value;
+};
+
+static int xmlSchemaTypesInitialized = 0;
+static xmlHashTablePtr xmlSchemaTypesBank = NULL;
+
+/*
+ * Basic types
+ */
+static xmlSchemaTypePtr xmlSchemaTypeStringDef = NULL;
+static xmlSchemaTypePtr xmlSchemaTypeAnyTypeDef = NULL;
+static xmlSchemaTypePtr xmlSchemaTypeAnySimpleTypeDef = NULL;
+static xmlSchemaTypePtr xmlSchemaTypeDecimalDef = NULL;
+static xmlSchemaTypePtr xmlSchemaTypeDatetimeDef = NULL;
+static xmlSchemaTypePtr xmlSchemaTypeDateDef = NULL;
+static xmlSchemaTypePtr xmlSchemaTypeTimeDef = NULL;
+static xmlSchemaTypePtr xmlSchemaTypeGYearDef = NULL;
+static xmlSchemaTypePtr xmlSchemaTypeGYearMonthDef = NULL;
+static xmlSchemaTypePtr xmlSchemaTypeGDayDef = NULL;
+static xmlSchemaTypePtr xmlSchemaTypeGMonthDayDef = NULL;
+static xmlSchemaTypePtr xmlSchemaTypeGMonthDef = NULL;
+static xmlSchemaTypePtr xmlSchemaTypeDurationDef = NULL;
+static xmlSchemaTypePtr xmlSchemaTypeFloatDef = NULL;
+static xmlSchemaTypePtr xmlSchemaTypeBooleanDef = NULL;
+static xmlSchemaTypePtr xmlSchemaTypeDoubleDef = NULL;
+static xmlSchemaTypePtr xmlSchemaTypeHexBinaryDef = NULL;
+static xmlSchemaTypePtr xmlSchemaTypeBase64BinaryDef = NULL;
+static xmlSchemaTypePtr xmlSchemaTypeAnyURIDef = NULL;
+
+/*
+ * Derived types
+ */
+static xmlSchemaTypePtr xmlSchemaTypePositiveIntegerDef = NULL;
+static xmlSchemaTypePtr xmlSchemaTypeNonPositiveIntegerDef = NULL;
+static xmlSchemaTypePtr xmlSchemaTypeNegativeIntegerDef = NULL;
+static xmlSchemaTypePtr xmlSchemaTypeNonNegativeIntegerDef = NULL;
+static xmlSchemaTypePtr xmlSchemaTypeIntegerDef = NULL;
+static xmlSchemaTypePtr xmlSchemaTypeLongDef = NULL;
+static xmlSchemaTypePtr xmlSchemaTypeIntDef = NULL;
+static xmlSchemaTypePtr xmlSchemaTypeShortDef = NULL;
+static xmlSchemaTypePtr xmlSchemaTypeByteDef = NULL;
+static xmlSchemaTypePtr xmlSchemaTypeUnsignedLongDef = NULL;
+static xmlSchemaTypePtr xmlSchemaTypeUnsignedIntDef = NULL;
+static xmlSchemaTypePtr xmlSchemaTypeUnsignedShortDef = NULL;
+static xmlSchemaTypePtr xmlSchemaTypeUnsignedByteDef = NULL;
+static xmlSchemaTypePtr xmlSchemaTypeNormStringDef = NULL;
+static xmlSchemaTypePtr xmlSchemaTypeTokenDef = NULL;
+static xmlSchemaTypePtr xmlSchemaTypeLanguageDef = NULL;
+static xmlSchemaTypePtr xmlSchemaTypeNameDef = NULL;
+static xmlSchemaTypePtr xmlSchemaTypeQNameDef = NULL;
+static xmlSchemaTypePtr xmlSchemaTypeNCNameDef = NULL;
+static xmlSchemaTypePtr xmlSchemaTypeIdDef = NULL;
+static xmlSchemaTypePtr xmlSchemaTypeIdrefDef = NULL;
+static xmlSchemaTypePtr xmlSchemaTypeIdrefsDef = NULL;
+static xmlSchemaTypePtr xmlSchemaTypeEntityDef = NULL;
+static xmlSchemaTypePtr xmlSchemaTypeEntitiesDef = NULL;
+static xmlSchemaTypePtr xmlSchemaTypeNotationDef = NULL;
+static xmlSchemaTypePtr xmlSchemaTypeNmtokenDef = NULL;
+static xmlSchemaTypePtr xmlSchemaTypeNmtokensDef = NULL;
+
+/************************************************************************
+ *									*
+ * 			Datatype error handlers				*
+ *									*
+ ************************************************************************/
+/**
+ * xmlSchemaTypeErrMemory:
+ * @extra:  extra informations
+ *
+ * Handle an out of memory condition
+ */
+static void
+xmlSchemaTypeErrMemory(xmlNodePtr node, const char *extra)
+{
+    __xmlSimpleError(XML_FROM_DATATYPE, XML_ERR_NO_MEMORY, node, NULL, extra);
+}
+
+/************************************************************************
+ *									*
+ * 			Base types support				*
+ *									*
+ ************************************************************************/
+/*
+ * xmlSchemaInitBasicType:
+ * @name:  the type name
+ * @type:  the value type associated
+ *
+ * Initialize one default type
+ */
+static xmlSchemaTypePtr
+xmlSchemaInitBasicType(const char *name, xmlSchemaValType type) {
+    xmlSchemaTypePtr ret;
+
+    ret = (xmlSchemaTypePtr) xmlMalloc(sizeof(xmlSchemaType));
+    if (ret == NULL) {
+        xmlSchemaTypeErrMemory(NULL, "could not initialize basic types");
+	return(NULL);
+    }
+    memset(ret, 0, sizeof(xmlSchemaType));
+    ret->name = (const xmlChar *)name;
+    ret->type = XML_SCHEMA_TYPE_BASIC;
+    ret->flags = type;
+    ret->contentType = XML_SCHEMA_CONTENT_BASIC;
+    xmlHashAddEntry2(xmlSchemaTypesBank, ret->name,
+	             XML_SCHEMAS_NAMESPACE_NAME, ret);
+    return(ret);
+}
+
+/*
+ * xmlSchemaInitTypes:
+ *
+ * Initialize the default XML Schemas type library
+ */
+void
+xmlSchemaInitTypes(void)
+{
+    if (xmlSchemaTypesInitialized != 0)
+        return;
+    xmlSchemaTypesBank = xmlHashCreate(40);
+
+    /*
+     * primitive datatypes
+     */
+    xmlSchemaTypeStringDef = xmlSchemaInitBasicType("string",
+                                                    XML_SCHEMAS_STRING);
+    xmlSchemaTypeAnyTypeDef = xmlSchemaInitBasicType("anyType",
+                                                     XML_SCHEMAS_UNKNOWN);
+    xmlSchemaTypeAnySimpleTypeDef = xmlSchemaInitBasicType("anySimpleType",
+                                                           XML_SCHEMAS_UNKNOWN);
+    xmlSchemaTypeDecimalDef = xmlSchemaInitBasicType("decimal",
+                                                     XML_SCHEMAS_DECIMAL);
+    xmlSchemaTypeDateDef = xmlSchemaInitBasicType("date",
+                                                  XML_SCHEMAS_DATE);
+    xmlSchemaTypeDatetimeDef = xmlSchemaInitBasicType("dateTime",
+                                                      XML_SCHEMAS_DATETIME);
+    xmlSchemaTypeTimeDef = xmlSchemaInitBasicType("time",
+                                                  XML_SCHEMAS_TIME);
+    xmlSchemaTypeGYearDef = xmlSchemaInitBasicType("gYear",
+                                                   XML_SCHEMAS_GYEAR);
+    xmlSchemaTypeGYearMonthDef = xmlSchemaInitBasicType("gYearMonth",
+                                                        XML_SCHEMAS_GYEARMONTH);
+    xmlSchemaTypeGMonthDef = xmlSchemaInitBasicType("gMonth",
+                                                    XML_SCHEMAS_GMONTH);
+    xmlSchemaTypeGMonthDayDef = xmlSchemaInitBasicType("gMonthDay",
+                                                       XML_SCHEMAS_GMONTHDAY);
+    xmlSchemaTypeGDayDef = xmlSchemaInitBasicType("gDay",
+                                                  XML_SCHEMAS_GDAY);
+    xmlSchemaTypeDurationDef = xmlSchemaInitBasicType("duration",
+                                                      XML_SCHEMAS_DURATION);
+    xmlSchemaTypeFloatDef = xmlSchemaInitBasicType("float",
+                                                   XML_SCHEMAS_FLOAT);
+    xmlSchemaTypeDoubleDef = xmlSchemaInitBasicType("double",
+                                                    XML_SCHEMAS_DOUBLE);
+    xmlSchemaTypeBooleanDef = xmlSchemaInitBasicType("boolean",
+                                                     XML_SCHEMAS_BOOLEAN);
+    xmlSchemaTypeAnyURIDef = xmlSchemaInitBasicType("anyURI",
+                                                    XML_SCHEMAS_ANYURI);
+    xmlSchemaTypeHexBinaryDef = xmlSchemaInitBasicType("hexBinary",
+                                                     XML_SCHEMAS_HEXBINARY);
+    xmlSchemaTypeBase64BinaryDef
+        = xmlSchemaInitBasicType("base64Binary", XML_SCHEMAS_BASE64BINARY);
+
+    /*
+     * derived datatypes
+     */
+    xmlSchemaTypeIntegerDef = xmlSchemaInitBasicType("integer",
+                                                     XML_SCHEMAS_INTEGER);;
+    xmlSchemaTypeNonPositiveIntegerDef =
+        xmlSchemaInitBasicType("nonPositiveInteger",
+                               XML_SCHEMAS_NPINTEGER);;
+    xmlSchemaTypeNegativeIntegerDef =
+        xmlSchemaInitBasicType("negativeInteger", XML_SCHEMAS_NINTEGER);;
+    xmlSchemaTypeLongDef =
+        xmlSchemaInitBasicType("long", XML_SCHEMAS_LONG);;
+    xmlSchemaTypeIntDef = xmlSchemaInitBasicType("int", XML_SCHEMAS_INT);;
+    xmlSchemaTypeShortDef = xmlSchemaInitBasicType("short",
+                                                   XML_SCHEMAS_SHORT);;
+    xmlSchemaTypeByteDef = xmlSchemaInitBasicType("byte",
+                                                  XML_SCHEMAS_BYTE);;
+    xmlSchemaTypeNonNegativeIntegerDef =
+        xmlSchemaInitBasicType("nonNegativeInteger",
+                               XML_SCHEMAS_NNINTEGER);
+    xmlSchemaTypeUnsignedLongDef =
+        xmlSchemaInitBasicType("unsignedLong", XML_SCHEMAS_ULONG);;
+    xmlSchemaTypeUnsignedIntDef =
+        xmlSchemaInitBasicType("unsignedInt", XML_SCHEMAS_UINT);;
+    xmlSchemaTypeUnsignedShortDef =
+        xmlSchemaInitBasicType("unsignedShort", XML_SCHEMAS_USHORT);;
+    xmlSchemaTypeUnsignedByteDef =
+        xmlSchemaInitBasicType("unsignedByte", XML_SCHEMAS_UBYTE);;
+    xmlSchemaTypePositiveIntegerDef =
+        xmlSchemaInitBasicType("positiveInteger", XML_SCHEMAS_PINTEGER);
+
+    xmlSchemaTypeNormStringDef = xmlSchemaInitBasicType("normalizedString",
+                                                        XML_SCHEMAS_NORMSTRING);
+    xmlSchemaTypeTokenDef = xmlSchemaInitBasicType("token",
+                                                   XML_SCHEMAS_TOKEN);
+    xmlSchemaTypeLanguageDef = xmlSchemaInitBasicType("language",
+                                                      XML_SCHEMAS_LANGUAGE);
+    xmlSchemaTypeIdDef = xmlSchemaInitBasicType("ID", XML_SCHEMAS_ID);
+    xmlSchemaTypeIdrefDef = xmlSchemaInitBasicType("IDREF",
+                                                   XML_SCHEMAS_IDREF);
+    xmlSchemaTypeIdrefsDef = xmlSchemaInitBasicType("IDREFS",
+                                                    XML_SCHEMAS_IDREFS);
+    xmlSchemaTypeEntityDef = xmlSchemaInitBasicType("ENTITY",
+                                                    XML_SCHEMAS_ENTITY);
+    xmlSchemaTypeEntitiesDef = xmlSchemaInitBasicType("ENTITIES",
+                                                      XML_SCHEMAS_ENTITIES);
+    xmlSchemaTypeNotationDef = xmlSchemaInitBasicType("NOTATION",
+                                                    XML_SCHEMAS_NOTATION);
+    xmlSchemaTypeNameDef = xmlSchemaInitBasicType("Name",
+                                                  XML_SCHEMAS_NAME);
+    xmlSchemaTypeQNameDef = xmlSchemaInitBasicType("QName",
+                                                   XML_SCHEMAS_QNAME);
+    xmlSchemaTypeNCNameDef = xmlSchemaInitBasicType("NCName",
+                                                    XML_SCHEMAS_NCNAME);
+    xmlSchemaTypeNmtokenDef = xmlSchemaInitBasicType("NMTOKEN",
+                                                     XML_SCHEMAS_NMTOKEN);
+    xmlSchemaTypeNmtokensDef = xmlSchemaInitBasicType("NMTOKENS",
+                                                      XML_SCHEMAS_NMTOKENS);
+    xmlSchemaTypesInitialized = 1;
+}
+
+/**
+ * xmlSchemaCleanupTypes:
+ *
+ * Cleanup the default XML Schemas type library
+ */
+void	
+xmlSchemaCleanupTypes(void) {
+    if (xmlSchemaTypesInitialized == 0)
+	return;
+    xmlHashFree(xmlSchemaTypesBank, (xmlHashDeallocator) xmlSchemaFreeType);
+    xmlSchemaTypesInitialized = 0;
+}
+
+/**
+ * xmlSchemaNewValue:
+ * @type:  the value type
+ *
+ * Allocate a new simple type value
+ *
+ * Returns a pointer to the new value or NULL in case of error
+ */
+static xmlSchemaValPtr
+xmlSchemaNewValue(xmlSchemaValType type) {
+    xmlSchemaValPtr value;
+
+    value = (xmlSchemaValPtr) xmlMalloc(sizeof(xmlSchemaVal));
+    if (value == NULL) {
+	return(NULL);
+    }
+    memset(value, 0, sizeof(xmlSchemaVal));
+    value->type = type;
+    return(value);
+}
+
+/**
+ * xmlSchemaFreeValue:
+ * @value:  the value to free
+ *
+ * Cleanup the default XML Schemas type library
+ */
+void	
+xmlSchemaFreeValue(xmlSchemaValPtr value) {
+    if (value == NULL)
+	return;
+    switch (value->type) {
+        case XML_SCHEMAS_STRING:
+        case XML_SCHEMAS_NORMSTRING:
+        case XML_SCHEMAS_TOKEN:
+        case XML_SCHEMAS_LANGUAGE:
+        case XML_SCHEMAS_NMTOKEN:
+        case XML_SCHEMAS_NMTOKENS:
+        case XML_SCHEMAS_NAME:
+        case XML_SCHEMAS_NCNAME:
+        case XML_SCHEMAS_ID:
+        case XML_SCHEMAS_IDREF:
+        case XML_SCHEMAS_IDREFS:
+        case XML_SCHEMAS_ENTITY:
+        case XML_SCHEMAS_ENTITIES:
+        case XML_SCHEMAS_NOTATION:
+        case XML_SCHEMAS_ANYURI:
+	    if (value->value.str != NULL)
+		xmlFree(value->value.str);
+	    break;
+        case XML_SCHEMAS_QNAME:
+	    if (value->value.qname.uri != NULL)
+		xmlFree(value->value.qname.uri);
+	    if (value->value.qname.name != NULL)
+		xmlFree(value->value.qname.name);
+	    break;
+        case XML_SCHEMAS_HEXBINARY:
+	    if (value->value.hex.str != NULL)
+		xmlFree(value->value.hex.str);
+	    break;
+        case XML_SCHEMAS_BASE64BINARY:
+	    if (value->value.base64.str != NULL)
+		xmlFree(value->value.base64.str);
+	    break;
+	default:
+	    break;
+    }
+    xmlFree(value);
+}
+
+/**
+ * xmlSchemaGetPredefinedType:
+ * @name: the type name
+ * @ns:  the URI of the namespace usually "http://www.w3.org/2001/XMLSchema"
+ *
+ * Lookup a type in the default XML Schemas type library
+ *
+ * Returns the type if found, NULL otherwise
+ */
+xmlSchemaTypePtr
+xmlSchemaGetPredefinedType(const xmlChar *name, const xmlChar *ns) {
+    if (xmlSchemaTypesInitialized == 0)
+	xmlSchemaInitTypes();
+    if (name == NULL)
+	return(NULL);
+    return((xmlSchemaTypePtr) xmlHashLookup2(xmlSchemaTypesBank, name, ns));
+}
+
+/****************************************************************
+ *								*
+ *		Convenience macros and functions		*
+ *								*
+ ****************************************************************/
+
+#define IS_TZO_CHAR(c)						\
+	((c == 0) || (c == 'Z') || (c == '+') || (c == '-'))
+
+#define VALID_YEAR(yr)          (yr != 0)
+#define VALID_MONTH(mon)        ((mon >= 1) && (mon <= 12))
+/* VALID_DAY should only be used when month is unknown */
+#define VALID_DAY(day)          ((day >= 1) && (day <= 31))
+#define VALID_HOUR(hr)          ((hr >= 0) && (hr <= 23))
+#define VALID_MIN(min)          ((min >= 0) && (min <= 59))
+#define VALID_SEC(sec)          ((sec >= 0) && (sec < 60))
+#define VALID_TZO(tzo)          ((tzo > -1440) && (tzo < 1440))
+#define IS_LEAP(y)						\
+	(((y % 4 == 0) && (y % 100 != 0)) || (y % 400 == 0))
+
+static const unsigned int daysInMonth[12] =
+	{ 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
+static const unsigned int daysInMonthLeap[12] =
+	{ 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
+
+#define MAX_DAYINMONTH(yr,mon)                                  \
+        (IS_LEAP(yr) ? daysInMonthLeap[mon - 1] : daysInMonth[mon - 1])
+
+#define VALID_MDAY(dt)						\
+	(IS_LEAP(dt->year) ?				        \
+	    (dt->day <= daysInMonthLeap[dt->mon - 1]) :	        \
+	    (dt->day <= daysInMonth[dt->mon - 1]))
+
+#define VALID_DATE(dt)						\
+	(VALID_YEAR(dt->year) && VALID_MONTH(dt->mon) && VALID_MDAY(dt))
+
+#define VALID_TIME(dt)						\
+	(VALID_HOUR(dt->hour) && VALID_MIN(dt->min) &&		\
+	 VALID_SEC(dt->sec) && VALID_TZO(dt->tzo))
+
+#define VALID_DATETIME(dt)					\
+	(VALID_DATE(dt) && VALID_TIME(dt))
+
+#define SECS_PER_MIN            (60)
+#define SECS_PER_HOUR           (60 * SECS_PER_MIN)
+#define SECS_PER_DAY            (24 * SECS_PER_HOUR)
+
+static const long dayInYearByMonth[12] =
+	{ 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 };
+static const long dayInLeapYearByMonth[12] =
+	{ 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335 };
+
+#define DAY_IN_YEAR(day, month, year)				\
+        ((IS_LEAP(year) ?					\
+                dayInLeapYearByMonth[month - 1] :		\
+                dayInYearByMonth[month - 1]) + day)
+
+#ifdef DEBUG
+#define DEBUG_DATE(dt)                                                  \
+    xmlGenericError(xmlGenericErrorContext,                             \
+        "type=%o %04ld-%02u-%02uT%02u:%02u:%03f",                       \
+        dt->type,dt->value.date.year,dt->value.date.mon,                \
+        dt->value.date.day,dt->value.date.hour,dt->value.date.min,      \
+        dt->value.date.sec);                                            \
+    if (dt->value.date.tz_flag)                                         \
+        if (dt->value.date.tzo != 0)                                    \
+            xmlGenericError(xmlGenericErrorContext,                     \
+                "%+05d\n",dt->value.date.tzo);                          \
+        else                                                            \
+            xmlGenericError(xmlGenericErrorContext, "Z\n");             \
+    else                                                                \
+        xmlGenericError(xmlGenericErrorContext,"\n")
+#else
+#define DEBUG_DATE(dt)
+#endif
+
+/**
+ * _xmlSchemaParseGYear:
+ * @dt:  pointer to a date structure
+ * @str: pointer to the string to analyze
+ *
+ * Parses a xs:gYear without time zone and fills in the appropriate
+ * field of the @dt structure. @str is updated to point just after the
+ * xs:gYear. It is supposed that @dt->year is big enough to contain
+ * the year.
+ *
+ * Returns 0 or the error code
+ */
+static int
+_xmlSchemaParseGYear (xmlSchemaValDatePtr dt, const xmlChar **str) {
+    const xmlChar *cur = *str, *firstChar;
+    int isneg = 0, digcnt = 0;
+
+    if (((*cur < '0') || (*cur > '9')) &&
+	(*cur != '-') && (*cur != '+'))
+	return -1;
+
+    if (*cur == '-') {
+	isneg = 1;
+	cur++;
+    }
+
+    firstChar = cur;
+
+    while ((*cur >= '0') && (*cur <= '9')) {
+	dt->year = dt->year * 10 + (*cur - '0');
+	cur++;
+	digcnt++;
+    }
+
+    /* year must be at least 4 digits (CCYY); over 4
+     * digits cannot have a leading zero. */
+    if ((digcnt < 4) || ((digcnt > 4) && (*firstChar == '0')))
+	return 1;
+
+    if (isneg)
+	dt->year = - dt->year;
+
+    if (!VALID_YEAR(dt->year))
+	return 2;
+
+    *str = cur;
+    return 0;
+}
+
+/**
+ * PARSE_2_DIGITS:
+ * @num:  the integer to fill in
+ * @cur:  an #xmlChar *
+ * @invalid: an integer
+ *
+ * Parses a 2-digits integer and updates @num with the value. @cur is
+ * updated to point just after the integer.
+ * In case of error, @invalid is set to %TRUE, values of @num and
+ * @cur are undefined.
+ */
+#define PARSE_2_DIGITS(num, cur, invalid)			\
+	if ((cur[0] < '0') || (cur[0] > '9') ||			\
+	    (cur[1] < '0') || (cur[1] > '9'))			\
+	    invalid = 1;					\
+	else							\
+	    num = (cur[0] - '0') * 10 + (cur[1] - '0');		\
+	cur += 2;
+
+/**
+ * PARSE_FLOAT:
+ * @num:  the double to fill in
+ * @cur:  an #xmlChar *
+ * @invalid: an integer
+ *
+ * Parses a float and updates @num with the value. @cur is
+ * updated to point just after the float. The float must have a
+ * 2-digits integer part and may or may not have a decimal part.
+ * In case of error, @invalid is set to %TRUE, values of @num and
+ * @cur are undefined.
+ */
+#define PARSE_FLOAT(num, cur, invalid)				\
+	PARSE_2_DIGITS(num, cur, invalid);			\
+	if (!invalid && (*cur == '.')) {			\
+	    double mult = 1;				        \
+	    cur++;						\
+	    if ((*cur < '0') || (*cur > '9'))			\
+		invalid = 1;					\
+	    while ((*cur >= '0') && (*cur <= '9')) {		\
+		mult /= 10;					\
+		num += (*cur - '0') * mult;			\
+		cur++;						\
+	    }							\
+	}
+
+/**
+ * _xmlSchemaParseGMonth:
+ * @dt:  pointer to a date structure
+ * @str: pointer to the string to analyze
+ *
+ * Parses a xs:gMonth without time zone and fills in the appropriate
+ * field of the @dt structure. @str is updated to point just after the
+ * xs:gMonth.
+ *
+ * Returns 0 or the error code
+ */
+static int
+_xmlSchemaParseGMonth (xmlSchemaValDatePtr dt, const xmlChar **str) {
+    const xmlChar *cur = *str;
+    int ret = 0;
+
+    PARSE_2_DIGITS(dt->mon, cur, ret);
+    if (ret != 0)
+	return ret;
+
+    if (!VALID_MONTH(dt->mon))
+	return 2;
+
+    *str = cur;
+    return 0;
+}
+
+/**
+ * _xmlSchemaParseGDay:
+ * @dt:  pointer to a date structure
+ * @str: pointer to the string to analyze
+ *
+ * Parses a xs:gDay without time zone and fills in the appropriate
+ * field of the @dt structure. @str is updated to point just after the
+ * xs:gDay.
+ *
+ * Returns 0 or the error code
+ */
+static int
+_xmlSchemaParseGDay (xmlSchemaValDatePtr dt, const xmlChar **str) {
+    const xmlChar *cur = *str;
+    int ret = 0;
+
+    PARSE_2_DIGITS(dt->day, cur, ret);
+    if (ret != 0)
+	return ret;
+
+    if (!VALID_DAY(dt->day))
+	return 2;
+
+    *str = cur;
+    return 0;
+}
+
+/**
+ * _xmlSchemaParseTime:
+ * @dt:  pointer to a date structure
+ * @str: pointer to the string to analyze
+ *
+ * Parses a xs:time without time zone and fills in the appropriate
+ * fields of the @dt structure. @str is updated to point just after the
+ * xs:time.
+ * In case of error, values of @dt fields are undefined.
+ *
+ * Returns 0 or the error code
+ */
+static int
+_xmlSchemaParseTime (xmlSchemaValDatePtr dt, const xmlChar **str) {
+    const xmlChar *cur = *str;
+    unsigned int hour = 0; /* use temp var in case str is not xs:time */
+    int ret = 0;
+
+    PARSE_2_DIGITS(hour, cur, ret);
+    if (ret != 0)
+	return ret;
+
+    if (*cur != ':')
+	return 1;
+    cur++;
+
+    /* the ':' insures this string is xs:time */
+    dt->hour = hour;
+
+    PARSE_2_DIGITS(dt->min, cur, ret);
+    if (ret != 0)
+	return ret;
+
+    if (*cur != ':')
+	return 1;
+    cur++;
+
+    PARSE_FLOAT(dt->sec, cur, ret);
+    if (ret != 0)
+	return ret;
+
+    if (!VALID_TIME(dt))
+	return 2;
+
+    *str = cur;
+    return 0;
+}
+
+/**
+ * _xmlSchemaParseTimeZone:
+ * @dt:  pointer to a date structure
+ * @str: pointer to the string to analyze
+ *
+ * Parses a time zone without time zone and fills in the appropriate
+ * field of the @dt structure. @str is updated to point just after the
+ * time zone.
+ *
+ * Returns 0 or the error code
+ */
+static int
+_xmlSchemaParseTimeZone (xmlSchemaValDatePtr dt, const xmlChar **str) {
+    const xmlChar *cur = *str;
+    int ret = 0;
+
+    if (str == NULL)
+	return -1;
+
+    switch (*cur) {
+    case 0:
+	dt->tz_flag = 0;
+	dt->tzo = 0;
+	break;
+
+    case 'Z':
+	dt->tz_flag = 1;
+	dt->tzo = 0;
+	cur++;
+	break;
+
+    case '+':
+    case '-': {
+	int isneg = 0, tmp = 0;
+	isneg = (*cur == '-');
+
+	cur++;
+
+	PARSE_2_DIGITS(tmp, cur, ret);
+	if (ret != 0)
+	    return ret;
+	if (!VALID_HOUR(tmp))
+	    return 2;
+
+	if (*cur != ':')
+	    return 1;
+	cur++;
+
+	dt->tzo = tmp * 60;
+
+	PARSE_2_DIGITS(tmp, cur, ret);
+	if (ret != 0)
+	    return ret;
+	if (!VALID_MIN(tmp))
+	    return 2;
+
+	dt->tzo += tmp;
+	if (isneg)
+	    dt->tzo = - dt->tzo;
+
+	if (!VALID_TZO(dt->tzo))
+	    return 2;
+
+	dt->tz_flag = 1;
+	break;
+      }
+    default:
+	return 1;
+    }
+
+    *str = cur;
+    return 0;
+}
+
+/**
+ * _xmlSchemaBase64Decode:
+ * @ch: a character
+ *
+ * Converts a base64 encoded character to its base 64 value.
+ *
+ * Returns 0-63 (value), 64 (pad), or -1 (not recognized)
+ */
+static int
+_xmlSchemaBase64Decode (const xmlChar ch) {
+    if (('A' <= ch) && (ch <= 'Z')) return ch - 'A';
+    if (('a' <= ch) && (ch <= 'z')) return ch - 'a' + 26;
+    if (('0' <= ch) && (ch <= '9')) return ch - '0' + 52;
+    if ('+' == ch) return 62;
+    if ('/' == ch) return 63;
+    if ('=' == ch) return 64;
+    return -1;
+}
+
+/****************************************************************
+ *								*
+ *	XML Schema Dates/Times Datatypes Handling		*
+ *								*
+ ****************************************************************/
+
+/**
+ * PARSE_DIGITS:
+ * @num:  the integer to fill in
+ * @cur:  an #xmlChar *
+ * @num_type: an integer flag
+ *
+ * Parses a digits integer and updates @num with the value. @cur is
+ * updated to point just after the integer.
+ * In case of error, @num_type is set to -1, values of @num and
+ * @cur are undefined.
+ */
+#define PARSE_DIGITS(num, cur, num_type)	                \
+	if ((*cur < '0') || (*cur > '9'))			\
+	    num_type = -1;					\
+        else                                                    \
+	    while ((*cur >= '0') && (*cur <= '9')) {		\
+	        num = num * 10 + (*cur - '0');		        \
+	        cur++;                                          \
+            }
+
+/**
+ * PARSE_NUM:
+ * @num:  the double to fill in
+ * @cur:  an #xmlChar *
+ * @num_type: an integer flag
+ *
+ * Parses a float or integer and updates @num with the value. @cur is
+ * updated to point just after the number. If the number is a float,
+ * then it must have an integer part and a decimal part; @num_type will
+ * be set to 1. If there is no decimal part, @num_type is set to zero.
+ * In case of error, @num_type is set to -1, values of @num and
+ * @cur are undefined.
+ */
+#define PARSE_NUM(num, cur, num_type)				\
+        num = 0;                                                \
+	PARSE_DIGITS(num, cur, num_type);	                \
+	if (!num_type && (*cur == '.')) {			\
+	    double mult = 1;				        \
+	    cur++;						\
+	    if ((*cur < '0') || (*cur > '9'))			\
+		num_type = -1;					\
+            else                                                \
+                num_type = 1;                                   \
+	    while ((*cur >= '0') && (*cur <= '9')) {		\
+		mult /= 10;					\
+		num += (*cur - '0') * mult;			\
+		cur++;						\
+	    }							\
+	}
+
+/**
+ * xmlSchemaValidateDates:
+ * @type: the expected type or XML_SCHEMAS_UNKNOWN
+ * @dateTime:  string to analyze
+ * @val:  the return computed value
+ *
+ * Check that @dateTime conforms to the lexical space of one of the date types.
+ * if true a value is computed and returned in @val.
+ *
+ * Returns 0 if this validates, a positive error code number otherwise
+ *         and -1 in case of internal or API error.
+ */
+static int
+xmlSchemaValidateDates (xmlSchemaValType type,
+	                const xmlChar *dateTime, xmlSchemaValPtr *val) {
+    xmlSchemaValPtr dt;
+    int ret;
+    const xmlChar *cur = dateTime;
+
+#define RETURN_TYPE_IF_VALID(t)					\
+    if (IS_TZO_CHAR(*cur)) {					\
+	ret = _xmlSchemaParseTimeZone(&(dt->value.date), &cur);	\
+	if (ret == 0) {						\
+	    if (*cur != 0)					\
+		goto error;					\
+	    dt->type = t;					\
+	    goto done;						\
+	}							\
+    }
+
+    if (dateTime == NULL)
+	return -1;
+
+    if ((*cur != '-') && (*cur < '0') && (*cur > '9'))
+	return 1;
+
+    dt = xmlSchemaNewValue(XML_SCHEMAS_UNKNOWN);
+    if (dt == NULL)
+	return -1;
+
+    if ((cur[0] == '-') && (cur[1] == '-')) {
+	/*
+	 * It's an incomplete date (xs:gMonthDay, xs:gMonth or
+	 * xs:gDay)
+	 */
+	cur += 2;
+
+	/* is it an xs:gDay? */
+	if (*cur == '-') {
+	    if (type == XML_SCHEMAS_GMONTH)
+		goto error;
+	  ++cur;
+	    ret = _xmlSchemaParseGDay(&(dt->value.date), &cur);
+	    if (ret != 0)
+		goto error;
+
+	    RETURN_TYPE_IF_VALID(XML_SCHEMAS_GDAY);
+
+	    goto error;
+	}
+
+	/*
+	 * it should be an xs:gMonthDay or xs:gMonth
+	 */
+	ret = _xmlSchemaParseGMonth(&(dt->value.date), &cur);
+	if (ret != 0)
+	    goto error;
+
+        /*
+         * a '-' char could indicate this type is xs:gMonthDay or
+         * a negative time zone offset. Check for xs:gMonthDay first.
+         * Also the first three char's of a negative tzo (-MM:SS) can
+         * appear to be a valid day; so even if the day portion
+         * of the xs:gMonthDay verifies, we must insure it was not
+         * a tzo.
+         */
+        if (*cur == '-') {
+            const xmlChar *rewnd = cur;
+            cur++;
+
+  	    ret = _xmlSchemaParseGDay(&(dt->value.date), &cur);
+            if ((ret == 0) && ((*cur == 0) || (*cur != ':'))) {
+
+                /*
+                 * we can use the VALID_MDAY macro to validate the month
+                 * and day because the leap year test will flag year zero
+                 * as a leap year (even though zero is an invalid year).
+                 */
+                if (VALID_MDAY((&(dt->value.date)))) {
+
+	            RETURN_TYPE_IF_VALID(XML_SCHEMAS_GMONTHDAY);
+
+                    goto error;
+                }
+            }
+
+            /*
+             * not xs:gMonthDay so rewind and check if just xs:gMonth
+             * with an optional time zone.
+             */
+            cur = rewnd;
+        }
+
+	RETURN_TYPE_IF_VALID(XML_SCHEMAS_GMONTH);
+
+	goto error;
+    }
+
+    /*
+     * It's a right-truncated date or an xs:time.
+     * Try to parse an xs:time then fallback on right-truncated dates.
+     */
+    if ((*cur >= '0') && (*cur <= '9')) {
+	ret = _xmlSchemaParseTime(&(dt->value.date), &cur);
+	if (ret == 0) {
+	    /* it's an xs:time */
+	    RETURN_TYPE_IF_VALID(XML_SCHEMAS_TIME);
+	}
+    }
+
+    /* fallback on date parsing */
+    cur = dateTime;
+
+    ret = _xmlSchemaParseGYear(&(dt->value.date), &cur);
+    if (ret != 0)
+	goto error;
+
+    /* is it an xs:gYear? */
+    RETURN_TYPE_IF_VALID(XML_SCHEMAS_GYEAR);
+
+    if (*cur != '-')
+	goto error;
+    cur++;
+
+    ret = _xmlSchemaParseGMonth(&(dt->value.date), &cur);
+    if (ret != 0)
+	goto error;
+
+    /* is it an xs:gYearMonth? */
+    RETURN_TYPE_IF_VALID(XML_SCHEMAS_GYEARMONTH);
+
+    if (*cur != '-')
+	goto error;
+    cur++;
+
+    ret = _xmlSchemaParseGDay(&(dt->value.date), &cur);
+    if ((ret != 0) || !VALID_DATE((&(dt->value.date))))
+	goto error;
+
+    /* is it an xs:date? */
+    RETURN_TYPE_IF_VALID(XML_SCHEMAS_DATE);
+
+    if (*cur != 'T')
+	goto error;
+    cur++;
+
+    /* it should be an xs:dateTime */
+    ret = _xmlSchemaParseTime(&(dt->value.date), &cur);
+    if (ret != 0)
+	goto error;
+
+    ret = _xmlSchemaParseTimeZone(&(dt->value.date), &cur);
+    if ((ret != 0) || (*cur != 0) || !VALID_DATETIME((&(dt->value.date))))
+	goto error;
+
+
+    dt->type = XML_SCHEMAS_DATETIME;
+
+done:
+#if 1
+    if ((type != XML_SCHEMAS_UNKNOWN) && (type != dt->type))
+        goto error;
+#else
+    /*
+     * insure the parsed type is equal to or less significant (right
+     * truncated) than the desired type.
+     */
+    if ((type != XML_SCHEMAS_UNKNOWN) && (type != dt->type)) {
+
+        /* time only matches time */
+        if ((type == XML_SCHEMAS_TIME) && (dt->type == XML_SCHEMAS_TIME))
+            goto error;
+
+        if ((type == XML_SCHEMAS_DATETIME) &&
+            ((dt->type != XML_SCHEMAS_DATE) ||
+             (dt->type != XML_SCHEMAS_GYEARMONTH) ||
+             (dt->type != XML_SCHEMAS_GYEAR)))
+            goto error;
+
+        if ((type == XML_SCHEMAS_DATE) &&
+            ((dt->type != XML_SCHEMAS_GYEAR) ||
+             (dt->type != XML_SCHEMAS_GYEARMONTH)))
+            goto error;
+
+        if ((type == XML_SCHEMAS_GYEARMONTH) && (dt->type != XML_SCHEMAS_GYEAR))
+            goto error;
+
+        if ((type == XML_SCHEMAS_GMONTHDAY) && (dt->type != XML_SCHEMAS_GMONTH))
+            goto error;
+    }
+#endif
+
+    if (val != NULL)
+        *val = dt;
+    else
+	xmlSchemaFreeValue(dt);
+
+    return 0;
+
+error:
+    if (dt != NULL)
+	xmlSchemaFreeValue(dt);
+    return 1;
+}
+
+/**
+ * xmlSchemaValidateDuration:
+ * @type: the predefined type
+ * @duration:  string to analyze
+ * @val:  the return computed value
+ *
+ * Check that @duration conforms to the lexical space of the duration type.
+ * if true a value is computed and returned in @val.
+ *
+ * Returns 0 if this validates, a positive error code number otherwise
+ *         and -1 in case of internal or API error.
+ */
+static int
+xmlSchemaValidateDuration (xmlSchemaTypePtr type ATTRIBUTE_UNUSED,
+	                   const xmlChar *duration, xmlSchemaValPtr *val) {
+    const xmlChar  *cur = duration;
+    xmlSchemaValPtr dur;
+    int isneg = 0;
+    unsigned int seq = 0;
+    double         num;
+    int            num_type = 0;  /* -1 = invalid, 0 = int, 1 = floating */
+    const xmlChar  desig[]  = {'Y', 'M', 'D', 'H', 'M', 'S'};
+    const double   multi[]  = { 0.0, 0.0, 86400.0, 3600.0, 60.0, 1.0, 0.0};
+
+    if (duration == NULL)
+	return -1;
+
+    if (*cur == '-') {
+        isneg = 1;
+        cur++;
+    }
+
+    /* duration must start with 'P' (after sign) */
+    if (*cur++ != 'P')
+	return 1;
+
+    if (*cur == 0)
+	return 1;
+
+    dur = xmlSchemaNewValue(XML_SCHEMAS_DURATION);
+    if (dur == NULL)
+	return -1;
+
+    while (*cur != 0) {
+
+        /* input string should be empty or invalid date/time item */
+        if (seq >= sizeof(desig))
+            goto error;
+
+        /* T designator must be present for time items */
+        if (*cur == 'T') {
+            if (seq <= 3) {
+                seq = 3;
+                cur++;
+            } else
+                return 1;
+        } else if (seq == 3)
+            goto error;
+
+        /* parse the number portion of the item */
+        PARSE_NUM(num, cur, num_type);
+
+        if ((num_type == -1) || (*cur == 0))
+            goto error;
+
+        /* update duration based on item type */
+        while (seq < sizeof(desig)) {
+            if (*cur == desig[seq]) {
+
+                /* verify numeric type; only seconds can be float */
+                if ((num_type != 0) && (seq < (sizeof(desig)-1)))
+                    goto error;
+
+                switch (seq) {
+                    case 0:
+                        dur->value.dur.mon = (long)num * 12;
+                        break;
+                    case 1:
+                        dur->value.dur.mon += (long)num;
+                        break;
+                    default:
+                        /* convert to seconds using multiplier */
+                        dur->value.dur.sec += num * multi[seq];
+                        seq++;
+                        break;
+                }
+
+                break;          /* exit loop */
+            }
+            /* no date designators found? */
+            if (++seq == 3)
+                goto error;
+        }
+        cur++;
+    }
+
+    if (isneg) {
+        dur->value.dur.mon = -dur->value.dur.mon;
+        dur->value.dur.day = -dur->value.dur.day;
+        dur->value.dur.sec = -dur->value.dur.sec;
+    }
+
+    if (val != NULL)
+        *val = dur;
+    else
+	xmlSchemaFreeValue(dur);
+
+    return 0;
+
+error:
+    if (dur != NULL)
+	xmlSchemaFreeValue(dur);
+    return 1;
+}
+
+/**
+ * xmlSchemaStrip:
+ * @value: a value
+ *
+ * Removes the leading and ending spaces of a string
+ *
+ * Returns the new string or NULL if no change was required.
+ */
+static xmlChar *
+xmlSchemaStrip(const xmlChar *value) {
+    const xmlChar *start = value, *end, *f;
+
+    if (value == NULL) return(NULL);
+    while ((*start != 0) && (IS_BLANK_CH(*start))) start++;
+    end = start;
+    while (*end != 0) end++;
+    f = end;
+    end--;
+    while ((end > start) && (IS_BLANK_CH(*end))) end--;
+    end++;
+    if ((start == value) && (f == end)) return(NULL);
+    return(xmlStrndup(start, end - start));
+}
+
+/**
+ * xmlSchemaCollapseString:
+ * @value: a value
+ *
+ * Removes and normalize white spaces in the string
+ *
+ * Returns the new string or NULL if no change was required.
+ */
+static xmlChar *
+xmlSchemaCollapseString(const xmlChar *value) {
+    const xmlChar *start = value, *end, *f;
+    xmlChar *g;
+    int col = 0;
+
+    if (value == NULL) return(NULL);
+    while ((*start != 0) && (IS_BLANK_CH(*start))) start++;
+    end = start;
+    while (*end != 0) {
+	if ((*end == ' ') && (IS_BLANK_CH(end[1]))) {
+	    col = end - start;
+	    break;
+	} else if ((*end == 0xa) || (*end == 0x9) || (*end == 0xd)) {
+	    col = end - start;
+	    break;
+	}
+	end++;
+    }
+    if (col == 0) {
+	f = end;
+	end--;
+	while ((end > start) && (IS_BLANK_CH(*end))) end--;
+	end++;
+	if ((start == value) && (f == end)) return(NULL);
+	return(xmlStrndup(start, end - start));
+    }
+    start = xmlStrdup(start);
+    if (start == NULL) return(NULL);
+    g = (xmlChar *) (start + col);
+    end = g;
+    while (*end != 0) {
+	if (IS_BLANK_CH(*end)) {
+	    end++;
+	    while (IS_BLANK_CH(*end)) end++;
+	    if (*end != 0)
+		*g++ = ' ';
+	} else
+	    *g++ = *end++;
+    }
+    *g = 0;
+    return((xmlChar *) start);
+}
+
+/**
+ * xmlSchemaValAtomicListNode:
+ * @type: the predefined atomic type for a token in the list
+ * @value: the list value to check
+ * @ret:  the return computed value
+ * @node:  the node containing the value
+ *
+ * Check that a value conforms to the lexical space of the predefined
+ * list type. if true a value is computed and returned in @ret.
+ *
+ * Returns the number of items if this validates, a negative error code
+ *         number otherwise
+ */
+static int
+xmlSchemaValAtomicListNode(xmlSchemaTypePtr type, const xmlChar *value,
+	                   xmlSchemaValPtr *ret, xmlNodePtr node) {
+    xmlChar *val, *cur, *endval;
+    int nb_values = 0;
+    int tmp = 0;
+
+    if (value == NULL) {
+	return(-1);
+    }
+    val = xmlStrdup(value);
+    if (val == NULL) {
+	return(-1);
+    }
+    cur = val;
+    /*
+     * Split the list
+     */
+    while (IS_BLANK_CH(*cur)) *cur++ = 0;
+    while (*cur != 0) {
+	if (IS_BLANK_CH(*cur)) {
+	    *cur = 0;
+	    cur++;
+	    while (IS_BLANK_CH(*cur)) *cur++ = 0;
+	} else {
+	    nb_values++;
+	    cur++;
+	    while ((*cur != 0) && (!IS_BLANK_CH(*cur))) cur++;
+	}
+    }
+    if (nb_values == 0) {
+	if (ret != NULL) {
+	    TODO
+	}
+	xmlFree(val);
+	return(nb_values);
+    }
+    endval = cur;
+    cur = val;
+    while ((*cur == 0) && (cur != endval)) cur++;
+    while (cur != endval) {
+	tmp = xmlSchemaValPredefTypeNode(type, cur, NULL, node);
+	if (tmp != 0)
+	    break;
+	while (*cur != 0) cur++;
+	while ((*cur == 0) && (cur != endval)) cur++;
+    }
+    xmlFree(val);
+    if (ret != NULL) {
+	TODO
+    }
+    if (tmp == 0)
+	return(nb_values);
+    return(-1);
+}
+
+/**
+ * xmlSchemaParseUInt:
+ * @str: pointer to the string R/W
+ * @llo: pointer to the low result
+ * @lmi: pointer to the mid result
+ * @lhi: pointer to the high result
+ *
+ * Parse an unsigned long into 3 fields.
+ *
+ * Returns the number of chars parsed or -1 if overflow of the capacity
+ */
+static int
+xmlSchemaParseUInt(const xmlChar **str, unsigned long *llo,
+	           unsigned long *lmi, unsigned long *lhi) {
+    unsigned long lo = 0, mi = 0, hi = 0;
+    const xmlChar *tmp, *cur = *str;
+    int ret = 0, i = 0;
+
+    while (*cur == '0') {
+	ret++;
+	cur++;
+    }
+    tmp = cur;
+    while ((*tmp != 0) && (*tmp >= '0') && (*tmp <= '9')) {
+	i++;tmp++;ret++;
+    }
+    if (i > 24) {
+	*str = tmp;
+	return(-1);
+    }
+    while (i > 16) {
+	hi = hi * 10 + (*cur++ - '0');
+	i--;
+    }
+    while (i > 8) {
+	mi = mi * 10 + (*cur++ - '0');
+	i--;
+    }
+    while (i > 0) {
+	lo = lo * 10 + (*cur++ - '0');
+	i--;
+    }
+
+    *str = cur;
+    *llo = lo;
+    *lmi = mi;
+    *lhi = hi;
+    return(ret);
+}
+
+/**
+ * xmlSchemaValAtomicType:
+ * @type: the predefined type
+ * @value: the value to check
+ * @val:  the return computed value
+ * @node:  the node containing the value
+ * flags:  flags to control the vlidation
+ *
+ * Check that a value conforms to the lexical space of the atomic type.
+ * if true a value is computed and returned in @val.
+ *
+ * Returns 0 if this validates, a positive error code number otherwise
+ *         and -1 in case of internal or API error.
+ */
+static int
+xmlSchemaValAtomicType(xmlSchemaTypePtr type, const xmlChar * value,
+                       xmlSchemaValPtr * val, xmlNodePtr node, int flags)
+{
+    xmlSchemaValPtr v;
+    xmlChar *norm = NULL;
+    int ret = 0;
+
+    if (xmlSchemaTypesInitialized == 0)
+        return (-1);
+    if (type == NULL)
+        return (-1);
+
+    if (val != NULL)
+        *val = NULL;
+    if ((flags == 0) && (value != NULL)) {
+        if ((type->flags != XML_SCHEMAS_STRING) &&
+            (type->flags != XML_SCHEMAS_NORMSTRING)) {
+            norm = xmlSchemaCollapseString(value);
+            if (norm != NULL)
+                value = norm;
+        }
+    }
+
+    switch (type->flags) {
+        case XML_SCHEMAS_UNKNOWN:
+            if (type == xmlSchemaTypeAnyTypeDef)
+                goto return0;
+            goto error;
+        case XML_SCHEMAS_STRING:
+            goto return0;
+        case XML_SCHEMAS_NORMSTRING:{
+                const xmlChar *cur = value;
+
+                while (*cur != 0) {
+                    if ((*cur == 0xd) || (*cur == 0xa) || (*cur == 0x9)) {
+                        goto return1;
+                    } else {
+                        cur++;
+                    }
+                }
+                if (val != NULL) {
+                    v = xmlSchemaNewValue(XML_SCHEMAS_NORMSTRING);
+                    if (v != NULL) {
+                        v->value.str = xmlStrdup(value);
+                        *val = v;
+                    } else {
+                        goto error;
+                    }
+                }
+                goto return0;
+            }
+        case XML_SCHEMAS_DECIMAL:{
+                const xmlChar *cur = value, *tmp;
+                unsigned int frac = 0, len, neg = 0;
+                unsigned long base = 0;
+
+                if (cur == NULL)
+                    goto return1;
+                if (*cur == '+')
+                    cur++;
+                else if (*cur == '-') {
+                    neg = 1;
+                    cur++;
+                }
+                tmp = cur;
+                while ((*cur >= '0') && (*cur <= '9')) {
+                    base = base * 10 + (*cur - '0');
+                    cur++;
+                }
+                len = cur - tmp;
+                if (*cur == '.') {
+                    cur++;
+                    tmp = cur;
+                    while ((*cur >= '0') && (*cur <= '9')) {
+                        base = base * 10 + (*cur - '0');
+                        cur++;
+                    }
+                    frac = cur - tmp;
+                }
+                if (*cur != 0)
+                    goto return1;
+                if (val != NULL) {
+                    v = xmlSchemaNewValue(XML_SCHEMAS_DECIMAL);
+                    if (v != NULL) {
+                        v->value.decimal.lo = base;
+                        v->value.decimal.sign = neg;
+                        v->value.decimal.frac = frac;
+                        v->value.decimal.total = frac + len;
+                        *val = v;
+                    }
+                }
+                goto return0;
+            }
+        case XML_SCHEMAS_TIME:
+        case XML_SCHEMAS_GDAY:
+        case XML_SCHEMAS_GMONTH:
+        case XML_SCHEMAS_GMONTHDAY:
+        case XML_SCHEMAS_GYEAR:
+        case XML_SCHEMAS_GYEARMONTH:
+        case XML_SCHEMAS_DATE:
+        case XML_SCHEMAS_DATETIME:
+            ret = xmlSchemaValidateDates(type->flags, value, val);
+            break;
+        case XML_SCHEMAS_DURATION:
+            ret = xmlSchemaValidateDuration(type, value, val);
+            break;
+        case XML_SCHEMAS_FLOAT:
+        case XML_SCHEMAS_DOUBLE:{
+                const xmlChar *cur = value;
+                int neg = 0;
+
+                if (cur == NULL)
+                    goto return1;
+                if ((cur[0] == 'N') && (cur[1] == 'a') && (cur[2] == 'N')) {
+                    cur += 3;
+                    if (*cur != 0)
+                        goto return1;
+                    if (val != NULL) {
+                        if (type == xmlSchemaTypeFloatDef) {
+                            v = xmlSchemaNewValue(XML_SCHEMAS_FLOAT);
+                            if (v != NULL) {
+                                v->value.f = (float) xmlXPathNAN;
+                            } else {
+                                xmlSchemaFreeValue(v);
+                                goto error;
+                            }
+                        } else {
+                            v = xmlSchemaNewValue(XML_SCHEMAS_DOUBLE);
+                            if (v != NULL) {
+                                v->value.d = xmlXPathNAN;
+                            } else {
+                                xmlSchemaFreeValue(v);
+                                goto error;
+                            }
+                        }
+                        *val = v;
+                    }
+                    goto return0;
+                }
+                if (*cur == '-') {
+                    neg = 1;
+                    cur++;
+                }
+                if ((cur[0] == 'I') && (cur[1] == 'N') && (cur[2] == 'F')) {
+                    cur += 3;
+                    if (*cur != 0)
+                        goto return1;
+                    if (val != NULL) {
+                        if (type == xmlSchemaTypeFloatDef) {
+                            v = xmlSchemaNewValue(XML_SCHEMAS_FLOAT);
+                            if (v != NULL) {
+                                if (neg)
+                                    v->value.f = (float) xmlXPathNINF;
+                                else
+                                    v->value.f = (float) xmlXPathPINF;
+                            } else {
+                                xmlSchemaFreeValue(v);
+                                goto error;
+                            }
+                        } else {
+                            v = xmlSchemaNewValue(XML_SCHEMAS_DOUBLE);
+                            if (v != NULL) {
+                                if (neg)
+                                    v->value.d = xmlXPathNINF;
+                                else
+                                    v->value.d = xmlXPathPINF;
+                            } else {
+                                xmlSchemaFreeValue(v);
+                                goto error;
+                            }
+                        }
+                        *val = v;
+                    }
+                    goto return0;
+                }
+                if ((neg == 0) && (*cur == '+'))
+                    cur++;
+                if ((cur[0] == 0) || (cur[0] == '+') || (cur[0] == '-'))
+                    goto return1;
+                while ((*cur >= '0') && (*cur <= '9')) {
+                    cur++;
+                }
+                if (*cur == '.') {
+                    cur++;
+                    while ((*cur >= '0') && (*cur <= '9'))
+                        cur++;
+                }
+                if ((*cur == 'e') || (*cur == 'E')) {
+                    cur++;
+                    if ((*cur == '-') || (*cur == '+'))
+                        cur++;
+                    while ((*cur >= '0') && (*cur <= '9'))
+                        cur++;
+                }
+                if (*cur != 0)
+                    goto return1;
+                if (val != NULL) {
+                    if (type == xmlSchemaTypeFloatDef) {
+                        v = xmlSchemaNewValue(XML_SCHEMAS_FLOAT);
+                        if (v != NULL) {
+                            if (sscanf((const char *) value, "%f",
+                                 &(v->value.f)) == 1) {
+                                *val = v;
+                            } else {
+                                xmlSchemaFreeValue(v);
+                                goto return1;
+                            }
+                        } else {
+                            goto error;
+                        }
+                    } else {
+                        v = xmlSchemaNewValue(XML_SCHEMAS_DOUBLE);
+                        if (v != NULL) {
+                            if (sscanf((const char *) value, "%lf",
+                                 &(v->value.d)) == 1) {
+                                *val = v;
+                            } else {
+                                xmlSchemaFreeValue(v);
+                                goto return1;
+                            }
+                        } else {
+                            goto error;
+                        }
+                    }
+                }
+                goto return0;
+            }
+        case XML_SCHEMAS_BOOLEAN:{
+                const xmlChar *cur = value;
+
+                if ((cur[0] == '0') && (cur[1] == 0))
+                    ret = 0;
+                else if ((cur[0] == '1') && (cur[1] == 0))
+                    ret = 1;
+                else if ((cur[0] == 't') && (cur[1] == 'r')
+                         && (cur[2] == 'u') && (cur[3] == 'e')
+                         && (cur[4] == 0))
+                    ret = 1;
+                else if ((cur[0] == 'f') && (cur[1] == 'a')
+                         && (cur[2] == 'l') && (cur[3] == 's')
+                         && (cur[4] == 'e') && (cur[5] == 0))
+                    ret = 0;
+                else
+                    goto return1;
+                if (val != NULL) {
+                    v = xmlSchemaNewValue(XML_SCHEMAS_BOOLEAN);
+                    if (v != NULL) {
+                        v->value.b = ret;
+                        *val = v;
+                    } else {
+                        goto error;
+                    }
+                }
+                goto return0;
+            }
+        case XML_SCHEMAS_TOKEN:{
+                const xmlChar *cur = value;
+
+                if (IS_BLANK_CH(*cur))
+                    goto return1;
+
+                while (*cur != 0) {
+                    if ((*cur == 0xd) || (*cur == 0xa) || (*cur == 0x9)) {
+                        goto return1;
+                    } else if (*cur == ' ') {
+                        cur++;
+                        if (*cur == 0)
+                            goto return1;
+                        if (*cur == ' ')
+                            goto return1;
+                    } else {
+                        cur++;
+                    }
+                }
+                if (val != NULL) {
+                    v = xmlSchemaNewValue(XML_SCHEMAS_TOKEN);
+                    if (v != NULL) {
+                        v->value.str = xmlStrdup(value);
+                        *val = v;
+                    } else {
+                        goto error;
+                    }
+                }
+                goto return0;
+            }
+        case XML_SCHEMAS_LANGUAGE:
+            if (xmlCheckLanguageID(value) == 1) {
+                if (val != NULL) {
+                    v = xmlSchemaNewValue(XML_SCHEMAS_LANGUAGE);
+                    if (v != NULL) {
+                        v->value.str = xmlStrdup(value);
+                        *val = v;
+                    } else {
+                        goto error;
+                    }
+                }
+                goto return0;
+            }
+            goto return1;
+        case XML_SCHEMAS_NMTOKEN:
+            if (xmlValidateNMToken(value, 1) == 0) {
+                if (val != NULL) {
+                    v = xmlSchemaNewValue(XML_SCHEMAS_NMTOKEN);
+                    if (v != NULL) {
+                        v->value.str = xmlStrdup(value);
+                        *val = v;
+                    } else {
+                        goto error;
+                    }
+                }
+                goto return0;
+            }
+            goto return1;
+        case XML_SCHEMAS_NMTOKENS:
+            ret = xmlSchemaValAtomicListNode(xmlSchemaTypeNmtokenDef,
+                                             value, val, node);
+            if (ret > 0)
+                ret = 0;
+            else
+                ret = 1;
+            goto done;
+        case XML_SCHEMAS_NAME:
+            ret = xmlValidateName(value, 1);
+            if ((ret == 0) && (val != NULL)) {
+                TODO;
+            }
+            goto done;
+        case XML_SCHEMAS_QNAME:{
+                xmlChar *uri = NULL;
+                xmlChar *local = NULL;
+
+                ret = xmlValidateQName(value, 1);
+                if ((ret == 0) && (node != NULL)) {
+                    xmlChar *prefix;
+
+                    local = xmlSplitQName2(value, &prefix);
+                    if (prefix != NULL) {
+                        xmlNsPtr ns;
+
+                        ns = xmlSearchNs(node->doc, node, prefix);
+                        if (ns == NULL)
+                            ret = 1;
+                        else if (val != NULL)
+                            uri = xmlStrdup(ns->href);
+                    }
+                    if ((local != NULL) && ((val == NULL) || (ret != 0)))
+                        xmlFree(local);
+                    if (prefix != NULL)
+                        xmlFree(prefix);
+                }
+                if ((ret == 0) && (val != NULL)) {
+                    v = xmlSchemaNewValue(XML_SCHEMAS_QNAME);
+                    if (v != NULL) {
+                        if (local != NULL)
+                            v->value.qname.name = local;
+                        else
+                            v->value.qname.name = xmlStrdup(value);
+                        if (uri != NULL)
+                            v->value.qname.uri = uri;
+
+                        *val = v;
+                    } else {
+                        if (local != NULL)
+                            xmlFree(local);
+                        if (uri != NULL)
+                            xmlFree(uri);
+                        goto error;
+                    }
+                }
+                goto done;
+            }
+        case XML_SCHEMAS_NCNAME:
+            ret = xmlValidateNCName(value, 1);
+            if ((ret == 0) && (val != NULL)) {
+                v = xmlSchemaNewValue(XML_SCHEMAS_NCNAME);
+                if (v != NULL) {
+                    v->value.str = xmlStrdup(value);
+                    *val = v;
+                } else {
+                    goto error;
+                }
+            }
+            goto done;
+        case XML_SCHEMAS_ID:
+            ret = xmlValidateNCName(value, 1);
+            if ((ret == 0) && (val != NULL)) {
+                v = xmlSchemaNewValue(XML_SCHEMAS_ID);
+                if (v != NULL) {
+                    v->value.str = xmlStrdup(value);
+                    *val = v;
+                } else {
+                    goto error;
+                }
+            }
+            if ((ret == 0) && (node != NULL) &&
+                (node->type == XML_ATTRIBUTE_NODE)) {
+                xmlAttrPtr attr = (xmlAttrPtr) node;
+
+                /*
+                 * NOTE: the IDness might have already be declared in the DTD
+                 */
+                if (attr->atype != XML_ATTRIBUTE_ID) {
+                    xmlIDPtr res;
+                    xmlChar *strip;
+
+                    strip = xmlSchemaStrip(value);
+                    if (strip != NULL) {
+                        res = xmlAddID(NULL, node->doc, strip, attr);
+                        xmlFree(strip);
+                    } else
+                        res = xmlAddID(NULL, node->doc, value, attr);
+                    if (res == NULL) {
+                        ret = 2;
+                    } else {
+                        attr->atype = XML_ATTRIBUTE_ID;
+                    }
+                }
+            }
+            goto done;
+        case XML_SCHEMAS_IDREF:
+            ret = xmlValidateNCName(value, 1);
+            if ((ret == 0) && (val != NULL)) {
+                TODO;
+            }
+            if ((ret == 0) && (node != NULL) &&
+                (node->type == XML_ATTRIBUTE_NODE)) {
+                xmlAttrPtr attr = (xmlAttrPtr) node;
+                xmlChar *strip;
+
+                strip = xmlSchemaStrip(value);
+                if (strip != NULL) {
+                    xmlAddRef(NULL, node->doc, strip, attr);
+                    xmlFree(strip);
+                } else
+                    xmlAddRef(NULL, node->doc, value, attr);
+                attr->atype = XML_ATTRIBUTE_IDREF;
+            }
+            goto done;
+        case XML_SCHEMAS_IDREFS:
+            ret = xmlSchemaValAtomicListNode(xmlSchemaTypeIdrefDef,
+                                             value, val, node);
+            if (ret < 0)
+                ret = 2;
+            else
+                ret = 0;
+            if ((ret == 0) && (node != NULL) &&
+                (node->type == XML_ATTRIBUTE_NODE)) {
+                xmlAttrPtr attr = (xmlAttrPtr) node;
+
+                attr->atype = XML_ATTRIBUTE_IDREFS;
+            }
+            goto done;
+        case XML_SCHEMAS_ENTITY:{
+                xmlChar *strip;
+
+                ret = xmlValidateNCName(value, 1);
+                if ((node == NULL) || (node->doc == NULL))
+                    ret = 3;
+                if (ret == 0) {
+                    xmlEntityPtr ent;
+
+                    strip = xmlSchemaStrip(value);
+                    if (strip != NULL) {
+                        ent = xmlGetDocEntity(node->doc, strip);
+                        xmlFree(strip);
+                    } else {
+                        ent = xmlGetDocEntity(node->doc, value);
+                    }
+                    if ((ent == NULL) ||
+                        (ent->etype !=
+                         XML_EXTERNAL_GENERAL_UNPARSED_ENTITY))
+                        ret = 4;
+                }
+                if ((ret == 0) && (val != NULL)) {
+                    TODO;
+                }
+                if ((ret == 0) && (node != NULL) &&
+                    (node->type == XML_ATTRIBUTE_NODE)) {
+                    xmlAttrPtr attr = (xmlAttrPtr) node;
+
+                    attr->atype = XML_ATTRIBUTE_ENTITY;
+                }
+                goto done;
+            }
+        case XML_SCHEMAS_ENTITIES:
+            if ((node == NULL) || (node->doc == NULL))
+                goto return3;
+            ret = xmlSchemaValAtomicListNode(xmlSchemaTypeEntityDef,
+                                             value, val, node);
+            if (ret <= 0)
+                ret = 1;
+            else
+                ret = 0;
+            if ((ret == 0) && (node != NULL) &&
+                (node->type == XML_ATTRIBUTE_NODE)) {
+                xmlAttrPtr attr = (xmlAttrPtr) node;
+
+                attr->atype = XML_ATTRIBUTE_ENTITIES;
+            }
+            goto done;
+        case XML_SCHEMAS_NOTATION:{
+                xmlChar *uri = NULL;
+                xmlChar *local = NULL;
+
+                ret = xmlValidateQName(value, 1);
+                if ((ret == 0) && (node != NULL)) {
+                    xmlChar *prefix;
+
+                    local = xmlSplitQName2(value, &prefix);
+                    if (prefix != NULL) {
+                        xmlNsPtr ns;
+
+                        ns = xmlSearchNs(node->doc, node, prefix);
+                        if (ns == NULL)
+                            ret = 1;
+                        else if (val != NULL)
+                            uri = xmlStrdup(ns->href);
+                    }
+                    if ((local != NULL) && ((val == NULL) || (ret != 0)))
+                        xmlFree(local);
+                    if (prefix != NULL)
+                        xmlFree(prefix);
+                }
+                if ((node == NULL) || (node->doc == NULL))
+                    ret = 3;
+                if (ret == 0) {
+                    ret = xmlValidateNotationUse(NULL, node->doc, value);
+                    if (ret == 1)
+                        ret = 0;
+                    else
+                        ret = 1;
+                }
+                if ((ret == 0) && (val != NULL)) {
+                    v = xmlSchemaNewValue(XML_SCHEMAS_NOTATION);
+                    if (v != NULL) {
+                        if (local != NULL)
+                            v->value.qname.name = local;
+                        else
+                            v->value.qname.name = xmlStrdup(value);
+                        if (uri != NULL)
+                            v->value.qname.uri = uri;
+
+                        *val = v;
+                    } else {
+                        if (local != NULL)
+                            xmlFree(local);
+                        if (uri != NULL)
+                            xmlFree(uri);
+                        goto error;
+                    }
+                }
+                goto done;
+            }
+        case XML_SCHEMAS_ANYURI:{
+                if (*value != 0) {
+                    xmlURIPtr uri = xmlParseURI((const char *) value);
+                    if (uri == NULL)
+                        goto return1;
+                    xmlFreeURI(uri);
+                }
+
+                if (val != NULL) {
+                    v = xmlSchemaNewValue(XML_SCHEMAS_ANYURI);
+                    if (v == NULL)
+                        goto error;
+                    v->value.str = xmlStrdup(value);
+                    *val = v;
+                }
+                goto return0;
+            }
+        case XML_SCHEMAS_HEXBINARY:{
+                const xmlChar *cur = value;
+                xmlChar *base;
+                int total, i = 0;
+
+                if (cur == NULL)
+                    goto return1;
+
+                while (((*cur >= '0') && (*cur <= '9')) ||
+                       ((*cur >= 'A') && (*cur <= 'F')) ||
+                       ((*cur >= 'a') && (*cur <= 'f'))) {
+                    i++;
+                    cur++;
+                }
+
+                if (*cur != 0)
+                    goto return1;
+                if ((i % 2) != 0)
+                    goto return1;
+
+                if (val != NULL) {
+
+                    v = xmlSchemaNewValue(XML_SCHEMAS_HEXBINARY);
+                    if (v == NULL)
+                        goto error;
+
+                    cur = xmlStrdup(value);
+                    if (cur == NULL) {
+		        xmlSchemaTypeErrMemory(node, "allocating hexbin data");
+                        xmlFree(v);
+                        goto return1;
+                    }
+
+                    total = i / 2;      /* number of octets */
+
+                    base = (xmlChar *) cur;
+                    while (i-- > 0) {
+                        if (*base >= 'a')
+                            *base = *base - ('a' - 'A');
+                        base++;
+                    }
+
+                    v->value.hex.str = (xmlChar *) cur;
+                    v->value.hex.total = total;
+                    *val = v;
+                }
+                goto return0;
+            }
+        case XML_SCHEMAS_BASE64BINARY:{
+                /* ISSUE:
+                 * 
+                 * Ignore all stray characters? (yes, currently)
+                 * Worry about long lines? (no, currently)
+                 * 
+                 * rfc2045.txt:
+                 * 
+                 * "The encoded output stream must be represented in lines of
+                 * no more than 76 characters each.  All line breaks or other
+                 * characters not found in Table 1 must be ignored by decoding
+                 * software.  In base64 data, characters other than those in
+                 * Table 1, line breaks, and other white space probably
+                 * indicate a transmission error, about which a warning
+                 * message or even a message rejection might be appropriate
+                 * under some circumstances." */
+                const xmlChar *cur = value;
+                xmlChar *base;
+                int total, i = 0, pad = 0;
+
+                if (cur == NULL)
+                    goto return1;
+
+                for (; *cur; ++cur) {
+                    int decc;
+
+                    decc = _xmlSchemaBase64Decode(*cur);
+                    if (decc < 0) ;
+                    else if (decc < 64)
+                        i++;
+                    else
+                        break;
+                }
+                for (; *cur; ++cur) {
+                    int decc;
+
+                    decc = _xmlSchemaBase64Decode(*cur);
+                    if (decc < 0) ;
+                    else if (decc < 64)
+                        goto return1;
+                    if (decc == 64)
+                        pad++;
+                }
+
+                /* rfc2045.txt: "Special processing is performed if fewer than
+                 * 24 bits are available at the end of the data being encoded.
+                 * A full encoding quantum is always completed at the end of a
+                 * body.  When fewer than 24 input bits are available in an
+                 * input group, zero bits are added (on the right) to form an
+                 * integral number of 6-bit groups.  Padding at the end of the
+                 * data is performed using the "=" character.  Since all
+                 * base64 input is an integral number of octets, only the
+                 * following cases can arise: (1) the final quantum of
+                 * encoding input is an integral multiple of 24 bits; here,
+                 * the final unit of encoded output will be an integral
+                 * multiple ofindent: Standard input:701: Warning:old style
+		 * assignment ambiguity in "=*".  Assuming "= *" 4 characters
+		 * with no "=" padding, (2) the final
+                 * quantum of encoding input is exactly 8 bits; here, the
+                 * final unit of encoded output will be two characters
+                 * followed by two "=" padding characters, or (3) the final
+                 * quantum of encoding input is exactly 16 bits; here, the
+                 * final unit of encoded output will be three characters
+                 * followed by one "=" padding character." */
+
+                total = 3 * (i / 4);
+                if (pad == 0) {
+                    if (i % 4 != 0)
+                        goto return1;
+                } else if (pad == 1) {
+                    int decc;
+
+                    if (i % 4 != 3)
+                        goto return1;
+                    for (decc = _xmlSchemaBase64Decode(*cur);
+                         (decc < 0) || (decc > 63);
+                         decc = _xmlSchemaBase64Decode(*cur))
+                        --cur;
+                    /* 16bits in 24bits means 2 pad bits: nnnnnn nnmmmm mmmm00*/
+                    /* 00111100 -> 0x3c */
+                    if (decc & ~0x3c)
+                        goto return1;
+                    total += 2;
+                } else if (pad == 2) {
+                    int decc;
+
+                    if (i % 4 != 2)
+                        goto return1;
+                    for (decc = _xmlSchemaBase64Decode(*cur);
+                         (decc < 0) || (decc > 63);
+                         decc = _xmlSchemaBase64Decode(*cur))
+                        --cur;
+                    /* 8bits in 12bits means 4 pad bits: nnnnnn nn0000 */
+                    /* 00110000 -> 0x30 */
+                    if (decc & ~0x30)
+                        goto return1;
+                    total += 1;
+                } else
+                    goto return1;
+
+                if (val != NULL) {
+                    v = xmlSchemaNewValue(XML_SCHEMAS_BASE64BINARY);
+                    if (v == NULL)
+                        goto error;
+                    base =
+                        (xmlChar *) xmlMallocAtomic((i + pad + 1) *
+                                                    sizeof(xmlChar));
+                    if (base == NULL) {
+		        xmlSchemaTypeErrMemory(node, "allocating base64 data");
+                        xmlFree(v);
+                        goto return1;
+                    }
+                    v->value.base64.str = base;
+                    for (cur = value; *cur; ++cur)
+                        if (_xmlSchemaBase64Decode(*cur) >= 0) {
+                            *base = *cur;
+                            ++base;
+                        }
+                    *base = 0;
+                    v->value.base64.total = total;
+                    *val = v;
+                }
+                goto return0;
+            }
+        case XML_SCHEMAS_INTEGER:
+        case XML_SCHEMAS_PINTEGER:
+        case XML_SCHEMAS_NPINTEGER:
+        case XML_SCHEMAS_NINTEGER:
+        case XML_SCHEMAS_NNINTEGER:{
+                const xmlChar *cur = value;
+                unsigned long lo, mi, hi;
+                int sign = 0;
+
+                if (cur == NULL)
+                    goto return1;
+                if (*cur == '-') {
+                    sign = 1;
+                    cur++;
+                } else if (*cur == '+')
+                    cur++;
+                ret = xmlSchemaParseUInt(&cur, &lo, &mi, &hi);
+                if (ret == 0)
+                    goto return1;
+                if (*cur != 0)
+                    goto return1;
+                if (type->flags == XML_SCHEMAS_NPINTEGER) {
+                    if ((sign == 0) &&
+                        ((hi != 0) || (mi != 0) || (lo != 0)))
+                        goto return1;
+                } else if (type->flags == XML_SCHEMAS_PINTEGER) {
+                    if (sign == 1)
+                        goto return1;
+                    if ((hi == 0) && (mi == 0) && (lo == 0))
+                        goto return1;
+                } else if (type->flags == XML_SCHEMAS_NINTEGER) {
+                    if (sign == 0)
+                        goto return1;
+                    if ((hi == 0) && (mi == 0) && (lo == 0))
+                        goto return1;
+                } else if (type->flags == XML_SCHEMAS_NNINTEGER) {
+                    if ((sign == 1) &&
+                        ((hi != 0) || (mi != 0) || (lo != 0)))
+                        goto return1;
+                }
+                /*
+                 * We can store a value only if no overflow occured
+                 */
+                if ((ret > 0) && (val != NULL)) {
+                    v = xmlSchemaNewValue(type->flags);
+                    if (v != NULL) {
+                        v->value.decimal.lo = lo;
+                        v->value.decimal.mi = lo;
+                        v->value.decimal.hi = lo;
+                        v->value.decimal.sign = sign;
+                        v->value.decimal.frac = 0;
+                        v->value.decimal.total = cur - value;
+                        *val = v;
+                    }
+                }
+                goto return0;
+            }
+        case XML_SCHEMAS_LONG:
+        case XML_SCHEMAS_BYTE:
+        case XML_SCHEMAS_SHORT:
+        case XML_SCHEMAS_INT:{
+                const xmlChar *cur = value;
+                unsigned long lo, mi, hi;
+                int total = 0;
+                int sign = 0;
+
+                if (cur == NULL)
+                    goto return1;
+                if (*cur == '-') {
+                    sign = 1;
+                    cur++;
+                } else if (*cur == '+')
+                    cur++;
+                ret = xmlSchemaParseUInt(&cur, &lo, &mi, &hi);
+                if (ret <= 0)
+                    goto return1;
+                if (*cur != 0)
+                    goto return1;
+                if (type->flags == XML_SCHEMAS_LONG) {
+                    if (hi >= 922) {
+                        if (hi > 922)
+                            goto return1;
+                        if (mi >= 33720368) {
+                            if (mi > 33720368)
+                                goto return1;
+                            if ((sign == 0) && (lo > 54775807))
+                                goto return1;
+                            if ((sign == 1) && (lo > 54775808))
+                                goto return1;
+                        }
+                    }
+                } else if (type->flags == XML_SCHEMAS_INT) {
+                    if (hi != 0)
+                        goto return1;
+                    if (mi >= 21) {
+                        if (mi > 21)
+                            goto return1;
+                        if ((sign == 0) && (lo > 47483647))
+                            goto return1;
+                        if ((sign == 1) && (lo > 47483648))
+                            goto return1;
+                    }
+                } else if (type->flags == XML_SCHEMAS_SHORT) {
+                    if ((mi != 0) || (hi != 0))
+                        goto return1;
+                    if ((sign == 1) && (lo > 32768))
+                        goto return1;
+                    if ((sign == 0) && (lo > 32767))
+                        goto return1;
+                } else if (type->flags == XML_SCHEMAS_BYTE) {
+                    if ((mi != 0) || (hi != 0))
+                        goto return1;
+                    if ((sign == 1) && (lo > 128))
+                        goto return1;
+                    if ((sign == 0) && (lo > 127))
+                        goto return1;
+                }
+                if (val != NULL) {
+                    v = xmlSchemaNewValue(type->flags);
+                    if (v != NULL) {
+                        v->value.decimal.lo = lo;
+                        v->value.decimal.mi = lo;
+                        v->value.decimal.hi = lo;
+                        v->value.decimal.sign = sign;
+                        v->value.decimal.frac = 0;
+                        v->value.decimal.total = total;
+                        *val = v;
+                    }
+                }
+                goto return0;
+            }
+        case XML_SCHEMAS_UINT:
+        case XML_SCHEMAS_ULONG:
+        case XML_SCHEMAS_USHORT:
+        case XML_SCHEMAS_UBYTE:{
+                const xmlChar *cur = value;
+                unsigned long lo, mi, hi;
+                int total = 0;
+
+                if (cur == NULL)
+                    goto return1;
+                ret = xmlSchemaParseUInt(&cur, &lo, &mi, &hi);
+                if (ret <= 0)
+                    goto return1;
+                if (*cur != 0)
+                    goto return1;
+                if (type->flags == XML_SCHEMAS_ULONG) {
+                    if (hi >= 1844) {
+                        if (hi > 1844)
+                            goto return1;
+                        if (mi >= 67440737) {
+                            if (mi > 67440737)
+                                goto return1;
+                            if (lo > 9551615)
+                                goto return1;
+                        }
+                    }
+                } else if (type->flags == XML_SCHEMAS_UINT) {
+                    if (hi != 0)
+                        goto return1;
+                    if (mi >= 42) {
+                        if (mi > 42)
+                            goto return1;
+                        if (lo > 94967295)
+                            goto return1;
+                    }
+                } else if (type->flags == XML_SCHEMAS_USHORT) {
+                    if ((mi != 0) || (hi != 0))
+                        goto return1;
+                    if (lo > 65535)
+                        goto return1;
+                } else if (type->flags == XML_SCHEMAS_UBYTE) {
+                    if ((mi != 0) || (hi != 0))
+                        goto return1;
+                    if (lo > 255)
+                        goto return1;
+                }
+                if (val != NULL) {
+                    v = xmlSchemaNewValue(type->flags);
+                    if (v != NULL) {
+                        v->value.decimal.lo = lo;
+                        v->value.decimal.mi = mi;
+                        v->value.decimal.hi = hi;
+                        v->value.decimal.sign = 0;
+                        v->value.decimal.frac = 0;
+                        v->value.decimal.total = total;
+                        *val = v;
+                    }
+                }
+                goto return0;
+            }
+    }
+
+  done:
+    if (norm != NULL)
+        xmlFree(norm);
+    return (ret);
+  return3:
+    if (norm != NULL)
+        xmlFree(norm);
+    return (3);
+  return1:
+    if (norm != NULL)
+        xmlFree(norm);
+    return (1);
+  return0:
+    if (norm != NULL)
+        xmlFree(norm);
+    return (0);
+  error:
+    if (norm != NULL)
+        xmlFree(norm);
+    return (-1);
+}
+
+/**
+ * xmlSchemaValPredefTypeNode:
+ * @type: the predefined type
+ * @value: the value to check
+ * @val:  the return computed value
+ * @node:  the node containing the value
+ *
+ * Check that a value conforms to the lexical space of the predefined type.
+ * if true a value is computed and returned in @val.
+ *
+ * Returns 0 if this validates, a positive error code number otherwise
+ *         and -1 in case of internal or API error.
+ */
+int
+xmlSchemaValPredefTypeNode(xmlSchemaTypePtr type, const xmlChar *value,
+	                   xmlSchemaValPtr *val, xmlNodePtr node) {
+    return(xmlSchemaValAtomicType(type, value, val, node, 0));
+}
+
+/**
+ * xmlSchemaValidatePredefinedType:
+ * @type: the predefined type
+ * @value: the value to check
+ * @val:  the return computed value
+ *
+ * Check that a value conforms to the lexical space of the predefined type.
+ * if true a value is computed and returned in @val.
+ *
+ * Returns 0 if this validates, a positive error code number otherwise
+ *         and -1 in case of internal or API error.
+ */
+int
+xmlSchemaValidatePredefinedType(xmlSchemaTypePtr type, const xmlChar *value,
+	                        xmlSchemaValPtr *val) {
+    return(xmlSchemaValPredefTypeNode(type, value, val, NULL));
+}
+
+/**
+ * xmlSchemaCompareDecimals:
+ * @x:  a first decimal value
+ * @y:  a second decimal value
+ *
+ * Compare 2 decimals
+ *
+ * Returns -1 if x < y, 0 if x == y, 1 if x > y and -2 in case of error
+ */
+static int
+xmlSchemaCompareDecimals(xmlSchemaValPtr x, xmlSchemaValPtr y)
+{
+    xmlSchemaValPtr swp;
+    int order = 1, p;
+    unsigned long tmp;
+
+    if ((x->value.decimal.sign) && 
+	((x->value.decimal.lo != 0) ||
+	 (x->value.decimal.mi != 0) ||
+	 (x->value.decimal.hi != 0))) {
+	if ((y->value.decimal.sign) &&
+	    ((y->value.decimal.lo != 0) ||
+	     (y->value.decimal.mi != 0) ||
+	     (y->value.decimal.hi != 0)))
+	    order = -1;
+	else
+	    return (-1);
+    } else if ((y->value.decimal.sign) &&
+	       ((y->value.decimal.lo != 0) ||
+		(y->value.decimal.mi != 0) ||
+		(y->value.decimal.hi != 0))) {
+        return (1);
+    }
+    if (x->value.decimal.frac == y->value.decimal.frac) {
+	if (x->value.decimal.hi < y->value.decimal.hi)
+	    return (-order);
+	if (x->value.decimal.hi < y->value.decimal.hi)
+	    return (order);
+	if (x->value.decimal.mi < y->value.decimal.mi)
+	    return (-order);
+	if (x->value.decimal.mi < y->value.decimal.mi)
+	    return (order);
+        if (x->value.decimal.lo < y->value.decimal.lo)
+            return (-order);
+        if (x->value.decimal.lo > y->value.decimal.lo)
+	    return(order);
+	return(0);
+    }
+    if (y->value.decimal.frac > x->value.decimal.frac) {
+        swp = y;
+        y = x;
+        x = swp;
+        order = -order;
+    }
+    p = powten[x->value.decimal.frac - y->value.decimal.frac];
+    tmp = x->value.decimal.lo / p;
+    if (tmp > y->value.decimal.lo)
+        return (order);
+    if (tmp < y->value.decimal.lo)
+        return (-order);
+    tmp = y->value.decimal.lo * p;
+    if (x->value.decimal.lo < tmp)
+        return (-order);
+    if (x->value.decimal.lo == tmp)
+        return (0);
+    return (order);
+}
+
+/**
+ * xmlSchemaCompareDurations:
+ * @x:  a first duration value
+ * @y:  a second duration value
+ *
+ * Compare 2 durations
+ *
+ * Returns -1 if x < y, 0 if x == y, 1 if x > y, 2 if x <> y, and -2 in
+ * case of error
+ */
+static int
+xmlSchemaCompareDurations(xmlSchemaValPtr x, xmlSchemaValPtr y)
+{
+    long carry, mon, day;
+    double sec;
+    int invert = 1;
+    long xmon, xday, myear, minday, maxday;
+    static const long dayRange [2][12] = {
+        { 0, 28, 59, 89, 120, 150, 181, 212, 242, 273, 303, 334, },
+        { 0, 31, 62, 92, 123, 153, 184, 215, 245, 276, 306, 337} };
+
+    if ((x == NULL) || (y == NULL))
+        return -2;
+
+    /* months */
+    mon = x->value.dur.mon - y->value.dur.mon;
+
+    /* seconds */
+    sec = x->value.dur.sec - y->value.dur.sec;
+    carry = (long)sec / SECS_PER_DAY;
+    sec -= (double)(carry * SECS_PER_DAY);
+
+    /* days */
+    day = x->value.dur.day - y->value.dur.day + carry;
+
+    /* easy test */
+    if (mon == 0) {
+        if (day == 0)
+            if (sec == 0.0)
+                return 0;
+            else if (sec < 0.0)
+                return -1;
+            else
+                return 1;
+        else if (day < 0)
+            return -1;
+        else
+            return 1;
+    }
+
+    if (mon > 0) {
+        if ((day >= 0) && (sec >= 0.0))
+            return 1;
+        else {
+            xmon = mon;
+            xday = -day;
+        }
+    } else if ((day <= 0) && (sec <= 0.0)) {
+        return -1;
+    } else {
+	invert = -1;
+        xmon = -mon;
+        xday = day;
+    }
+
+    myear = xmon / 12;
+    if (myear == 0) {
+	minday = 0;
+	maxday = 0;
+    } else {
+	maxday = 366 * ((myear + 3) / 4) +
+	         365 * ((myear - 1) % 4);
+	minday = maxday - 1;
+    }
+
+    xmon = xmon % 12;
+    minday += dayRange[0][xmon];
+    maxday += dayRange[1][xmon];
+
+    if ((maxday == minday) && (maxday == xday))
+	return(0); /* can this really happen ? */
+    if (maxday < xday)
+        return(-invert);
+    if (minday > xday)
+        return(invert);
+
+    /* indeterminate */
+    return 2;
+}
+
+/*
+ * macros for adding date/times and durations
+ */
+#define FQUOTIENT(a,b)                  (floor(((double)a/(double)b)))
+#define MODULO(a,b)                     (a - FQUOTIENT(a,b) * b)
+#define FQUOTIENT_RANGE(a,low,high)     (FQUOTIENT((a-low),(high-low)))
+#define MODULO_RANGE(a,low,high)        ((MODULO((a-low),(high-low)))+low)
+
+/**
+ * _xmlSchemaDateAdd:
+ * @dt: an #xmlSchemaValPtr
+ * @dur: an #xmlSchemaValPtr of type #XS_DURATION
+ *
+ * Compute a new date/time from @dt and @dur. This function assumes @dt
+ * is either #XML_SCHEMAS_DATETIME, #XML_SCHEMAS_DATE, #XML_SCHEMAS_GYEARMONTH,
+ * or #XML_SCHEMAS_GYEAR.
+ *
+ * Returns date/time pointer or NULL.
+ */
+static xmlSchemaValPtr
+_xmlSchemaDateAdd (xmlSchemaValPtr dt, xmlSchemaValPtr dur)
+{
+    xmlSchemaValPtr ret;
+    long carry, tempdays, temp;
+    xmlSchemaValDatePtr r, d;
+    xmlSchemaValDurationPtr u;
+
+    if ((dt == NULL) || (dur == NULL))
+        return NULL;
+
+    ret = xmlSchemaNewValue(dt->type);
+    if (ret == NULL)
+        return NULL;
+
+    r = &(ret->value.date);
+    d = &(dt->value.date);
+    u = &(dur->value.dur);
+
+    /* normalization */
+    if (d->mon == 0)
+        d->mon = 1;
+
+    /* normalize for time zone offset */
+    u->sec -= (d->tzo * 60);
+    d->tzo = 0;
+
+    /* normalization */
+    if (d->day == 0)
+        d->day = 1;
+
+    /* month */
+    carry  = d->mon + u->mon;
+    r->mon = (unsigned int) MODULO_RANGE(carry, 1, 13);
+    carry  = (long) FQUOTIENT_RANGE(carry, 1, 13);
+
+    /* year (may be modified later) */
+    r->year = d->year + carry;
+    if (r->year == 0) {
+        if (d->year > 0)
+            r->year--;
+        else
+            r->year++;
+    }
+
+    /* time zone */
+    r->tzo     = d->tzo;
+    r->tz_flag = d->tz_flag;
+
+    /* seconds */
+    r->sec = d->sec + u->sec;
+    carry  = (long) FQUOTIENT((long)r->sec, 60);
+    if (r->sec != 0.0) {
+        r->sec = MODULO(r->sec, 60.0);
+    }
+
+    /* minute */
+    carry += d->min;
+    r->min = (unsigned int) MODULO(carry, 60);
+    carry  = (long) FQUOTIENT(carry, 60);
+
+    /* hours */
+    carry  += d->hour;
+    r->hour = (unsigned int) MODULO(carry, 24);
+    carry   = (long)FQUOTIENT(carry, 24);
+
+    /*
+     * days
+     * Note we use tempdays because the temporary values may need more
+     * than 5 bits
+     */
+    if ((VALID_YEAR(r->year)) && (VALID_MONTH(r->mon)) &&
+                  (d->day > MAX_DAYINMONTH(r->year, r->mon)))
+        tempdays = MAX_DAYINMONTH(r->year, r->mon);
+    else if (d->day < 1)
+        tempdays = 1;
+    else
+        tempdays = d->day;
+
+    tempdays += u->day + carry;
+
+    while (1) {
+        if (tempdays < 1) {
+            long tmon = (long) MODULO_RANGE(r->mon-1, 1, 13);
+            long tyr  = r->year + (long)FQUOTIENT_RANGE(r->mon-1, 1, 13);
+            if (tyr == 0)
+                tyr--;
+            tempdays += MAX_DAYINMONTH(tyr, tmon);
+            carry = -1;
+        } else if (tempdays > (long) MAX_DAYINMONTH(r->year, r->mon)) {
+            tempdays = tempdays - MAX_DAYINMONTH(r->year, r->mon);
+            carry = 1;
+        } else
+            break;
+
+        temp = r->mon + carry;
+        r->mon = (unsigned int) MODULO_RANGE(temp, 1, 13);
+        r->year = r->year + (unsigned int) FQUOTIENT_RANGE(temp, 1, 13);
+        if (r->year == 0) {
+            if (temp < 1)
+                r->year--;
+            else
+                r->year++;
+	}
+    }
+    
+    r->day = tempdays;
+
+    /*
+     * adjust the date/time type to the date values
+     */
+    if (ret->type != XML_SCHEMAS_DATETIME) {
+        if ((r->hour) || (r->min) || (r->sec))
+            ret->type = XML_SCHEMAS_DATETIME;
+        else if (ret->type != XML_SCHEMAS_DATE) {
+            if ((r->mon != 1) && (r->day != 1))
+                ret->type = XML_SCHEMAS_DATE;
+            else if ((ret->type != XML_SCHEMAS_GYEARMONTH) && (r->mon != 1))
+                ret->type = XML_SCHEMAS_GYEARMONTH;
+        }
+    }
+
+    return ret;
+}
+
+/**
+ * xmlSchemaDupVal:
+ * @v: value to duplicate
+ *
+ * returns a duplicated value.
+ */
+static xmlSchemaValPtr
+xmlSchemaDupVal (xmlSchemaValPtr v)
+{
+    xmlSchemaValPtr ret = xmlSchemaNewValue(v->type);
+    if (ret == NULL)
+        return ret;
+    
+    memcpy(ret, v, sizeof(xmlSchemaVal));
+    return ret;
+}
+
+/**
+ * xmlSchemaDateNormalize:
+ * @dt: an #xmlSchemaValPtr
+ *
+ * Normalize @dt to GMT time.
+ *
+ */
+static xmlSchemaValPtr
+xmlSchemaDateNormalize (xmlSchemaValPtr dt, double offset)
+{
+    xmlSchemaValPtr dur, ret;
+
+    if (dt == NULL)
+        return NULL;
+
+    if (((dt->type != XML_SCHEMAS_TIME) &&
+         (dt->type != XML_SCHEMAS_DATETIME)) || (dt->value.date.tzo == 0))
+        return xmlSchemaDupVal(dt);
+
+    dur = xmlSchemaNewValue(XML_SCHEMAS_DURATION);
+    if (dur == NULL)
+        return NULL;
+
+    dur->value.date.sec -= offset;
+
+    ret = _xmlSchemaDateAdd(dt, dur);
+    if (ret == NULL)
+        return NULL;
+
+    xmlSchemaFreeValue(dur);
+
+    /* ret->value.date.tzo = 0; */
+    return ret;
+}
+
+/**
+ * _xmlSchemaDateCastYMToDays:
+ * @dt: an #xmlSchemaValPtr
+ *
+ * Convert mon and year of @dt to total number of days. Take the 
+ * number of years since (or before) 1 AD and add the number of leap
+ * years. This is a function  because negative
+ * years must be handled a little differently and there is no zero year.
+ *
+ * Returns number of days.
+ */
+static long
+_xmlSchemaDateCastYMToDays (const xmlSchemaValPtr dt)
+{
+    long ret;
+
+    if (dt->value.date.year < 0)
+        ret = (dt->value.date.year * 365) +
+              (((dt->value.date.year+1)/4)-((dt->value.date.year+1)/100)+
+               ((dt->value.date.year+1)/400)) +
+              DAY_IN_YEAR(0, dt->value.date.mon, dt->value.date.year);
+    else
+        ret = ((dt->value.date.year-1) * 365) +
+              (((dt->value.date.year-1)/4)-((dt->value.date.year-1)/100)+
+               ((dt->value.date.year-1)/400)) +
+              DAY_IN_YEAR(0, dt->value.date.mon, dt->value.date.year);
+
+    return ret;
+}
+
+/**
+ * TIME_TO_NUMBER:
+ * @dt:  an #xmlSchemaValPtr
+ *
+ * Calculates the number of seconds in the time portion of @dt.
+ *
+ * Returns seconds.
+ */
+#define TIME_TO_NUMBER(dt)                              \
+    ((double)((dt->value.date.hour * SECS_PER_HOUR) +   \
+              (dt->value.date.min * SECS_PER_MIN) +	\
+              (dt->value.date.tzo * SECS_PER_MIN)) +	\
+               dt->value.date.sec)
+
+/**
+ * xmlSchemaCompareDates:
+ * @x:  a first date/time value
+ * @y:  a second date/time value
+ *
+ * Compare 2 date/times
+ *
+ * Returns -1 if x < y, 0 if x == y, 1 if x > y, 2 if x <> y, and -2 in
+ * case of error
+ */
+static int
+xmlSchemaCompareDates (xmlSchemaValPtr x, xmlSchemaValPtr y)
+{
+    unsigned char xmask, ymask, xor_mask, and_mask;
+    xmlSchemaValPtr p1, p2, q1, q2;
+    long p1d, p2d, q1d, q2d;
+
+    if ((x == NULL) || (y == NULL))
+        return -2;
+
+    if (x->value.date.tz_flag) {
+
+        if (!y->value.date.tz_flag) {
+            p1 = xmlSchemaDateNormalize(x, 0);
+            p1d = _xmlSchemaDateCastYMToDays(p1) + p1->value.date.day;
+            /* normalize y + 14:00 */
+            q1 = xmlSchemaDateNormalize(y, (14 * SECS_PER_HOUR));
+
+            q1d = _xmlSchemaDateCastYMToDays(q1) + q1->value.date.day;
+            if (p1d < q1d) {
+		xmlSchemaFreeValue(p1);
+		xmlSchemaFreeValue(q1);
+                return -1;
+	    } else if (p1d == q1d) {
+                double sec;
+
+                sec = TIME_TO_NUMBER(p1) - TIME_TO_NUMBER(q1);
+                if (sec < 0.0) {
+		    xmlSchemaFreeValue(p1);
+		    xmlSchemaFreeValue(q1);
+                    return -1;
+		} else {
+		    int ret = 0;
+                    /* normalize y - 14:00 */
+                    q2 = xmlSchemaDateNormalize(y, -(14 * SECS_PER_HOUR));
+                    q2d = _xmlSchemaDateCastYMToDays(q2) + q2->value.date.day;
+                    if (p1d > q2d)
+                        ret = 1;
+                    else if (p1d == q2d) {
+                        sec = TIME_TO_NUMBER(p1) - TIME_TO_NUMBER(q2);
+                        if (sec > 0.0)
+                            ret = 1;
+                        else
+                            ret = 2; /* indeterminate */
+                    }
+		    xmlSchemaFreeValue(p1);
+		    xmlSchemaFreeValue(q1);
+		    xmlSchemaFreeValue(q2);
+		    if (ret != 0)
+		        return(ret);
+                }
+            } else {
+		xmlSchemaFreeValue(p1);
+		xmlSchemaFreeValue(q1);
+	    }
+        }
+    } else if (y->value.date.tz_flag) {
+        q1 = xmlSchemaDateNormalize(y, 0);
+        q1d = _xmlSchemaDateCastYMToDays(q1) + q1->value.date.day;
+
+        /* normalize x - 14:00 */
+        p1 = xmlSchemaDateNormalize(x, -(14 * SECS_PER_HOUR));
+        p1d = _xmlSchemaDateCastYMToDays(p1) + p1->value.date.day;
+
+        if (p1d < q1d) {
+	    xmlSchemaFreeValue(p1);
+	    xmlSchemaFreeValue(q1);
+            return -1;
+	} else if (p1d == q1d) {
+            double sec;
+
+            sec = TIME_TO_NUMBER(p1) - TIME_TO_NUMBER(q1);
+            if (sec < 0.0) {
+		xmlSchemaFreeValue(p1);
+		xmlSchemaFreeValue(q1);
+                return -1;
+	    } else {
+	        int ret = 0;
+                /* normalize x + 14:00 */
+                p2 = xmlSchemaDateNormalize(x, (14 * SECS_PER_HOUR));
+                p2d = _xmlSchemaDateCastYMToDays(p2) + p2->value.date.day;
+
+                if (p2d > q1d) {
+                    ret = 1;
+		} else if (p2d == q1d) {
+                    sec = TIME_TO_NUMBER(p2) - TIME_TO_NUMBER(q1);
+                    if (sec > 0.0)
+                        ret = 1;
+                    else
+                        ret = 2; /* indeterminate */
+                }
+		xmlSchemaFreeValue(p1);
+		xmlSchemaFreeValue(q1);
+		xmlSchemaFreeValue(p2);
+		if (ret != 0)
+		    return(ret);
+            }
+	} else {
+	    xmlSchemaFreeValue(p1);
+	    xmlSchemaFreeValue(q1);
+        }
+    }
+
+    /*
+     * if the same type then calculate the difference
+     */
+    if (x->type == y->type) {
+        int ret = 0;
+        q1 = xmlSchemaDateNormalize(y, 0);
+        q1d = _xmlSchemaDateCastYMToDays(q1) + q1->value.date.day;
+
+        p1 = xmlSchemaDateNormalize(x, 0);
+        p1d = _xmlSchemaDateCastYMToDays(p1) + p1->value.date.day;
+
+        if (p1d < q1d) {
+            ret = -1;
+	} else if (p1d > q1d) {
+            ret = 1;
+	} else {
+            double sec;
+
+            sec = TIME_TO_NUMBER(p1) - TIME_TO_NUMBER(q1);
+            if (sec < 0.0)
+                ret = -1;
+            else if (sec > 0.0)
+                ret = 1;
+            
+        }
+	xmlSchemaFreeValue(p1);
+	xmlSchemaFreeValue(q1);
+        return(ret);
+    }
+
+    switch (x->type) {
+        case XML_SCHEMAS_DATETIME:
+            xmask = 0xf;
+            break;
+        case XML_SCHEMAS_DATE:
+            xmask = 0x7;
+            break;
+        case XML_SCHEMAS_GYEAR:
+            xmask = 0x1;
+            break;
+        case XML_SCHEMAS_GMONTH:
+            xmask = 0x2;
+            break;
+        case XML_SCHEMAS_GDAY:
+            xmask = 0x3;
+            break;
+        case XML_SCHEMAS_GYEARMONTH:
+            xmask = 0x3;
+            break;
+        case XML_SCHEMAS_GMONTHDAY:
+            xmask = 0x6;
+            break;
+        case XML_SCHEMAS_TIME:
+            xmask = 0x8;
+            break;
+        default:
+            xmask = 0;
+            break;
+    }
+
+    switch (y->type) {
+        case XML_SCHEMAS_DATETIME:
+            ymask = 0xf;
+            break;
+        case XML_SCHEMAS_DATE:
+            ymask = 0x7;
+            break;
+        case XML_SCHEMAS_GYEAR:
+            ymask = 0x1;
+            break;
+        case XML_SCHEMAS_GMONTH:
+            ymask = 0x2;
+            break;
+        case XML_SCHEMAS_GDAY:
+            ymask = 0x3;
+            break;
+        case XML_SCHEMAS_GYEARMONTH:
+            ymask = 0x3;
+            break;
+        case XML_SCHEMAS_GMONTHDAY:
+            ymask = 0x6;
+            break;
+        case XML_SCHEMAS_TIME:
+            ymask = 0x8;
+            break;
+        default:
+            ymask = 0;
+            break;
+    }
+
+    xor_mask = xmask ^ ymask;           /* mark type differences */
+    and_mask = xmask & ymask;           /* mark field specification */
+
+    /* year */
+    if (xor_mask & 1)
+        return 2; /* indeterminate */
+    else if (and_mask & 1) {
+        if (x->value.date.year < y->value.date.year)
+            return -1;
+        else if (x->value.date.year > y->value.date.year)
+            return 1;
+    }
+
+    /* month */
+    if (xor_mask & 2)
+        return 2; /* indeterminate */
+    else if (and_mask & 2) {
+        if (x->value.date.mon < y->value.date.mon)
+            return -1;
+        else if (x->value.date.mon > y->value.date.mon)
+            return 1;
+    }
+
+    /* day */
+    if (xor_mask & 4)
+        return 2; /* indeterminate */
+    else if (and_mask & 4) {
+        if (x->value.date.day < y->value.date.day)
+            return -1;
+        else if (x->value.date.day > y->value.date.day)
+            return 1;
+    }
+
+    /* time */
+    if (xor_mask & 8)
+        return 2; /* indeterminate */
+    else if (and_mask & 8) {
+        if (x->value.date.hour < y->value.date.hour)
+            return -1;
+        else if (x->value.date.hour > y->value.date.hour)
+            return 1;
+        else if (x->value.date.min < y->value.date.min)
+            return -1;
+        else if (x->value.date.min > y->value.date.min)
+            return 1;
+        else if (x->value.date.sec < y->value.date.sec)
+            return -1;
+        else if (x->value.date.sec > y->value.date.sec)
+            return 1;
+    }
+
+    return 0;
+}
+
+/**
+ * xmlSchemaCompareNormStrings:
+ * @x:  a first string value
+ * @y:  a second string value
+ *
+ * Compare 2 string for their normalized values.
+ *
+ * Returns -1 if x < y, 0 if x == y, 1 if x > y, and -2 in
+ * case of error
+ */
+static int
+xmlSchemaCompareNormStrings(xmlSchemaValPtr x, xmlSchemaValPtr y) {
+    const xmlChar *utf1;
+    const xmlChar *utf2;
+    int tmp;
+
+    if ((x == NULL) || (y == NULL))
+	return(-2);
+    utf1 = x->value.str;
+    utf2 = y->value.str;
+    
+    while (IS_BLANK_CH(*utf1)) utf1++;
+    while (IS_BLANK_CH(*utf2)) utf2++;
+    while ((*utf1 != 0) && (*utf2 != 0)) {
+	if (IS_BLANK_CH(*utf1)) {
+	    if (!IS_BLANK_CH(*utf2)) {
+		tmp = *utf1 - *utf2;
+		return(tmp);
+	    }
+	    while (IS_BLANK_CH(*utf1)) utf1++;
+	    while (IS_BLANK_CH(*utf2)) utf2++;
+	} else {
+	    tmp = *utf1++ - *utf2++;
+	    if (tmp < 0)
+		return(-1);
+	    if (tmp > 0)
+		return(1);
+	}
+    }
+    if (*utf1 != 0) {
+	while (IS_BLANK_CH(*utf1)) utf1++;
+	if (*utf1 != 0)
+	    return(1);
+    }
+    if (*utf2 != 0) {
+	while (IS_BLANK_CH(*utf2)) utf2++;
+	if (*utf2 != 0)
+	    return(-1);
+    }
+    return(0);
+}
+
+/**
+ * xmlSchemaCompareFloats:
+ * @x:  a first float or double value
+ * @y:  a second float or double value
+ *
+ * Compare 2 values
+ *
+ * Returns -1 if x < y, 0 if x == y, 1 if x > y, 2 if x <> y, and -2 in
+ * case of error
+ */
+static int
+xmlSchemaCompareFloats(xmlSchemaValPtr x, xmlSchemaValPtr y) {
+    double d1, d2;
+
+    if ((x == NULL) || (y == NULL))
+	return(-2);
+
+    /*
+     * Cast everything to doubles.
+     */
+    if (x->type == XML_SCHEMAS_DOUBLE)
+	d1 = x->value.d;
+    else if (x->type == XML_SCHEMAS_FLOAT)
+	d1 = x->value.f;
+    else
+	return(-2);
+
+    if (y->type == XML_SCHEMAS_DOUBLE)
+	d2 = y->value.d;
+    else if (y->type == XML_SCHEMAS_FLOAT)
+	d2 = y->value.f;
+    else
+	return(-2);
+
+    /*
+     * Check for special cases.
+     */
+    if (xmlXPathIsNaN(d1)) {
+	if (xmlXPathIsNaN(d2))
+	    return(0);
+	return(1);
+    }
+    if (xmlXPathIsNaN(d2))
+	return(-1);
+    if (d1 == xmlXPathPINF) {
+	if (d2 == xmlXPathPINF)
+	    return(0);
+        return(1);
+    }
+    if (d2 == xmlXPathPINF)
+        return(-1);
+    if (d1 == xmlXPathNINF) {
+	if (d2 == xmlXPathNINF)
+	    return(0);
+        return(-1);
+    }
+    if (d2 == xmlXPathNINF)
+        return(1);
+
+    /*
+     * basic tests, the last one we should have equality, but
+     * portability is more important than speed and handling
+     * NaN or Inf in a portable way is always a challenge, so ...
+     */
+    if (d1 < d2)
+	return(-1);
+    if (d1 > d2)
+	return(1);
+    if (d1 == d2)
+	return(0);
+    return(2);
+}
+
+/**
+ * xmlSchemaCompareValues:
+ * @x:  a first value
+ * @y:  a second value
+ *
+ * Compare 2 values
+ *
+ * Returns -1 if x < y, 0 if x == y, 1 if x > y, 2 if x <> y, and -2 in
+ * case of error
+ */
+int
+xmlSchemaCompareValues(xmlSchemaValPtr x, xmlSchemaValPtr y) {
+    if ((x == NULL) || (y == NULL))
+	return(-2);
+
+    switch (x->type) {
+	case XML_SCHEMAS_UNKNOWN:
+	    return(-2);
+        case XML_SCHEMAS_INTEGER:
+        case XML_SCHEMAS_NPINTEGER:
+        case XML_SCHEMAS_NINTEGER:
+        case XML_SCHEMAS_NNINTEGER:
+        case XML_SCHEMAS_PINTEGER:
+        case XML_SCHEMAS_INT:
+        case XML_SCHEMAS_UINT:
+        case XML_SCHEMAS_LONG:
+        case XML_SCHEMAS_ULONG:
+        case XML_SCHEMAS_SHORT:
+        case XML_SCHEMAS_USHORT:
+        case XML_SCHEMAS_BYTE:
+        case XML_SCHEMAS_UBYTE:
+	case XML_SCHEMAS_DECIMAL:
+	    if (y->type == x->type)
+		return(xmlSchemaCompareDecimals(x, y));
+	    if ((y->type == XML_SCHEMAS_DECIMAL) ||
+		(y->type == XML_SCHEMAS_INTEGER) ||
+		(y->type == XML_SCHEMAS_NPINTEGER) ||
+		(y->type == XML_SCHEMAS_NINTEGER) ||
+		(y->type == XML_SCHEMAS_NNINTEGER) ||
+		(y->type == XML_SCHEMAS_PINTEGER) ||
+		(y->type == XML_SCHEMAS_INT) ||
+		(y->type == XML_SCHEMAS_UINT) ||
+		(y->type == XML_SCHEMAS_LONG) ||
+		(y->type == XML_SCHEMAS_ULONG) ||
+		(y->type == XML_SCHEMAS_SHORT) ||
+		(y->type == XML_SCHEMAS_USHORT) ||
+		(y->type == XML_SCHEMAS_BYTE) ||
+		(y->type == XML_SCHEMAS_UBYTE))
+		return(xmlSchemaCompareDecimals(x, y));
+	    return(-2);
+        case XML_SCHEMAS_DURATION:
+	    if (y->type == XML_SCHEMAS_DURATION)
+                return(xmlSchemaCompareDurations(x, y));
+            return(-2);
+        case XML_SCHEMAS_TIME:
+        case XML_SCHEMAS_GDAY:
+        case XML_SCHEMAS_GMONTH:
+        case XML_SCHEMAS_GMONTHDAY:
+        case XML_SCHEMAS_GYEAR:
+        case XML_SCHEMAS_GYEARMONTH:
+        case XML_SCHEMAS_DATE:
+        case XML_SCHEMAS_DATETIME:
+            if ((y->type == XML_SCHEMAS_DATETIME)  ||
+                (y->type == XML_SCHEMAS_TIME)      ||
+                (y->type == XML_SCHEMAS_GDAY)      ||
+                (y->type == XML_SCHEMAS_GMONTH)    ||
+                (y->type == XML_SCHEMAS_GMONTHDAY) ||
+                (y->type == XML_SCHEMAS_GYEAR)     ||
+                (y->type == XML_SCHEMAS_DATE)      ||
+                (y->type == XML_SCHEMAS_GYEARMONTH))
+                return (xmlSchemaCompareDates(x, y));
+            return (-2);
+        case XML_SCHEMAS_NORMSTRING:
+        case XML_SCHEMAS_TOKEN:
+        case XML_SCHEMAS_LANGUAGE:
+        case XML_SCHEMAS_NMTOKEN:
+        case XML_SCHEMAS_NAME:
+        case XML_SCHEMAS_NCNAME:
+        case XML_SCHEMAS_ID:
+        case XML_SCHEMAS_IDREF:
+        case XML_SCHEMAS_ENTITY:
+        case XML_SCHEMAS_NOTATION:
+        case XML_SCHEMAS_ANYURI:
+            if ((y->type == XML_SCHEMAS_NORMSTRING) ||
+                (y->type == XML_SCHEMAS_TOKEN) ||
+                (y->type == XML_SCHEMAS_LANGUAGE) ||
+                (y->type == XML_SCHEMAS_NMTOKEN) ||
+                (y->type == XML_SCHEMAS_NAME) ||
+                (y->type == XML_SCHEMAS_QNAME) ||
+                (y->type == XML_SCHEMAS_NCNAME) ||
+                (y->type == XML_SCHEMAS_ID) ||
+                (y->type == XML_SCHEMAS_IDREF) ||
+                (y->type == XML_SCHEMAS_ENTITY) ||
+                (y->type == XML_SCHEMAS_NOTATION) ||
+                (y->type == XML_SCHEMAS_ANYURI))
+                return (xmlSchemaCompareNormStrings(x, y));
+            return (-2);
+        case XML_SCHEMAS_QNAME:
+            if (y->type == XML_SCHEMAS_QNAME) {
+		if ((xmlStrEqual(x->value.qname.name, y->value.qname.name)) &&
+		    (xmlStrEqual(x->value.qname.uri, y->value.qname.uri)))
+		    return(0);
+		return(2);
+	    }
+	    return (-2);
+        case XML_SCHEMAS_FLOAT:
+        case XML_SCHEMAS_DOUBLE:
+            if ((y->type == XML_SCHEMAS_FLOAT) ||
+                (y->type == XML_SCHEMAS_DOUBLE))
+                return (xmlSchemaCompareFloats(x, y));
+            return (-2);
+        case XML_SCHEMAS_BOOLEAN:
+            if (y->type == XML_SCHEMAS_BOOLEAN) {
+		if (x->value.b == y->value.b)
+		    return(0);
+		if (x->value.b == 0)
+		    return(-1);
+		return(1);
+	    }
+	    return (-2);
+        case XML_SCHEMAS_HEXBINARY:
+            if (y->type == XML_SCHEMAS_HEXBINARY) {
+	        if (x->value.hex.total == y->value.hex.total) {
+		    int ret = xmlStrcmp(x->value.hex.str, y->value.hex.str);
+		    if (ret > 0)
+			return(1);
+		    else if (ret == 0)
+			return(0);
+		}
+		else if (x->value.hex.total > y->value.hex.total)
+		    return(1);
+
+		return(-1);
+            }
+            return (-2);
+        case XML_SCHEMAS_BASE64BINARY:
+            if (y->type == XML_SCHEMAS_BASE64BINARY) {
+                if (x->value.base64.total == y->value.base64.total) {
+                    int ret = xmlStrcmp(x->value.base64.str,
+		                        y->value.base64.str);
+                    if (ret > 0)
+                        return(1);
+                    else if (ret == 0)
+                        return(0);
+                }
+                else if (x->value.base64.total > y->value.base64.total)
+                    return(1);
+                else
+                    return(-1);
+            }
+            return (-2);
+        case XML_SCHEMAS_STRING:
+        case XML_SCHEMAS_IDREFS:
+        case XML_SCHEMAS_ENTITIES:
+        case XML_SCHEMAS_NMTOKENS:
+	    TODO
+	    break;
+    }
+    return -2;
+}
+
+/**
+ * xmlSchemaNormLen:
+ * @value:  a string
+ *
+ * Computes the UTF8 length of the normalized value of the string
+ *
+ * Returns the length or -1 in case of error.
+ */
+static int
+xmlSchemaNormLen(const xmlChar *value) {
+    const xmlChar *utf;
+    int ret = 0;
+
+    if (value == NULL)
+	return(-1);
+    utf = value;
+    while (IS_BLANK_CH(*utf)) utf++;
+    while (*utf != 0) {
+	if (utf[0] & 0x80) {
+	    if ((utf[1] & 0xc0) != 0x80)
+		return(-1);
+	    if ((utf[0] & 0xe0) == 0xe0) {
+		if ((utf[2] & 0xc0) != 0x80)
+		    return(-1);
+		if ((utf[0] & 0xf0) == 0xf0) {
+		    if ((utf[0] & 0xf8) != 0xf0 || (utf[3] & 0xc0) != 0x80)
+			return(-1);
+		    utf += 4;
+		} else {
+		    utf += 3;
+		}
+	    } else {
+		utf += 2;
+	    }
+	} else if (IS_BLANK_CH(*utf)) {
+	    while (IS_BLANK_CH(*utf)) utf++;
+	    if (*utf == 0)
+		break;
+	} else {
+	    utf++;
+	}
+	ret++;
+    }
+    return(ret);
+}
+
+/**
+ * xmlSchemaValidateFacet:
+ * @base:  the base type
+ * @facet:  the facet to check
+ * @value:  the lexical repr of the value to validate
+ * @val:  the precomputed value
+ *
+ * Check a value against a facet condition
+ *
+ * Returns 0 if the element is schemas valid, a positive error code
+ *     number otherwise and -1 in case of internal or API error.
+ */
+int
+xmlSchemaValidateFacet(xmlSchemaTypePtr base ATTRIBUTE_UNUSED,
+	               xmlSchemaFacetPtr facet,
+	               const xmlChar *value, xmlSchemaValPtr val)
+{
+    int ret;
+
+    switch (facet->type) {
+	case XML_SCHEMA_FACET_PATTERN:
+	    ret = xmlRegexpExec(facet->regexp, value);
+	    if (ret == 1)
+		return(0);
+	    if (ret == 0) {
+		/* TODO error code */
+		return(1);
+	    }
+	    return(ret);
+	case XML_SCHEMA_FACET_MAXEXCLUSIVE:
+	    ret = xmlSchemaCompareValues(val, facet->val);
+	    if (ret == -2) {
+		/* TODO error code */
+		return(-1);
+	    }
+	    if (ret == -1)
+		return(0);
+	    /* error code */
+	    return(1);
+	case XML_SCHEMA_FACET_MAXINCLUSIVE:
+	    ret = xmlSchemaCompareValues(val, facet->val);
+	    if (ret == -2) {
+		/* TODO error code */
+		return(-1);
+	    }
+	    if ((ret == -1) || (ret == 0))
+		return(0);
+	    /* error code */
+	    return(1);
+	case XML_SCHEMA_FACET_MINEXCLUSIVE:
+	    ret = xmlSchemaCompareValues(val, facet->val);
+	    if (ret == -2) {
+		/* TODO error code */
+		return(-1);
+	    }
+	    if (ret == 1)
+		return(0);
+	    /* error code */
+	    return(1);
+	case XML_SCHEMA_FACET_MININCLUSIVE:
+	    ret = xmlSchemaCompareValues(val, facet->val);
+	    if (ret == -2) {
+		/* TODO error code */
+		return(-1);
+	    }
+	    if ((ret == 1) || (ret == 0))
+		return(0);
+	    /* error code */
+	    return(1);
+	case XML_SCHEMA_FACET_WHITESPACE:
+	    /* TODO whitespaces */
+	    return(0);
+	case  XML_SCHEMA_FACET_ENUMERATION:
+	    if ((facet->value != NULL) &&
+		(xmlStrEqual(facet->value, value)))
+		return(0);
+	    return(1);
+	case XML_SCHEMA_FACET_LENGTH:
+	case XML_SCHEMA_FACET_MAXLENGTH:
+	case XML_SCHEMA_FACET_MINLENGTH: {
+	    unsigned int len = 0;
+
+	    if ((facet->val == NULL) ||
+		((facet->val->type != XML_SCHEMAS_DECIMAL) &&
+		 (facet->val->type != XML_SCHEMAS_NNINTEGER)) ||
+		(facet->val->value.decimal.frac != 0)) {
+		return(-1);
+	    }
+	    if ((val != NULL) && (val->type == XML_SCHEMAS_HEXBINARY))
+		len = val->value.hex.total;
+	    else if ((val != NULL) && (val->type == XML_SCHEMAS_BASE64BINARY))
+		len = val->value.base64.total;
+	    else {
+	    	switch (base->flags) {
+	    	    case XML_SCHEMAS_IDREF:
+		    case XML_SCHEMAS_NORMSTRING:
+		    case XML_SCHEMAS_TOKEN:
+		    case XML_SCHEMAS_LANGUAGE:
+		    case XML_SCHEMAS_NMTOKEN:
+		    case XML_SCHEMAS_NAME:
+		    case XML_SCHEMAS_NCNAME:
+		    case XML_SCHEMAS_ID:
+		    	len = xmlSchemaNormLen(value);
+		    	break;
+		    case XML_SCHEMAS_STRING:
+		        if (value != NULL)
+			    len = xmlUTF8Strlen(value);
+		    	break;
+		    default:
+		        TODO
+	    	}
+	    }
+	    if (facet->type == XML_SCHEMA_FACET_LENGTH) {
+		if (len != facet->val->value.decimal.lo)
+		    return(1);
+	    } else if (facet->type == XML_SCHEMA_FACET_MINLENGTH) {
+		if (len < facet->val->value.decimal.lo)
+		    return(1);
+	    } else {
+		if (len > facet->val->value.decimal.lo)
+		    return(1);
+	    }
+	    break;
+	}
+	case XML_SCHEMA_FACET_TOTALDIGITS:
+	case XML_SCHEMA_FACET_FRACTIONDIGITS:
+
+	    if ((facet->val == NULL) ||
+		((facet->val->type != XML_SCHEMAS_DECIMAL) &&
+		 (facet->val->type != XML_SCHEMAS_NNINTEGER)) ||
+		(facet->val->value.decimal.frac != 0)) {
+		return(-1);
+	    }
+	    if ((val == NULL) ||
+		((val->type != XML_SCHEMAS_DECIMAL) &&
+		 (val->type != XML_SCHEMAS_INTEGER) &&
+		 (val->type != XML_SCHEMAS_NPINTEGER) &&
+		 (val->type != XML_SCHEMAS_NINTEGER) &&
+		 (val->type != XML_SCHEMAS_NNINTEGER) &&
+		 (val->type != XML_SCHEMAS_PINTEGER) &&
+		 (val->type != XML_SCHEMAS_INT) &&
+		 (val->type != XML_SCHEMAS_UINT) &&
+		 (val->type != XML_SCHEMAS_LONG) &&
+		 (val->type != XML_SCHEMAS_ULONG) &&
+		 (val->type != XML_SCHEMAS_SHORT) &&
+		 (val->type != XML_SCHEMAS_USHORT) &&
+		 (val->type != XML_SCHEMAS_BYTE) &&
+		 (val->type != XML_SCHEMAS_UBYTE))) {
+		return(-1);
+	    }
+	    if (facet->type == XML_SCHEMA_FACET_TOTALDIGITS) {
+	        if (val->value.decimal.total > facet->val->value.decimal.lo)
+	            return(1);
+
+	    } else if (facet->type == XML_SCHEMA_FACET_FRACTIONDIGITS) {
+	        if (val->value.decimal.frac > facet->val->value.decimal.lo)
+		    return(1);
+	    }
+	    break;
+	default:
+	    TODO
+    }
+    return(0);
+
+}
+
+#endif /* LIBXML_SCHEMAS_ENABLED */
diff --git a/src/libxml/src/xmlstring.c b/src/libxml/src/xmlstring.c
new file mode 100644
index 0000000..5c64053
--- /dev/null
+++ b/src/libxml/src/xmlstring.c
@@ -0,0 +1,956 @@
+/*
+ * string.c : an XML string utilities module
+ *
+ * This module provides various utility functions for manipulating
+ * the xmlChar* type. All functions named xmlStr* have been moved here
+ * from the parser.c file (their original home). 
+ *
+ * See Copyright for the status of this software.
+ *
+ * UTF8 string routines from:
+ * William Brack <wbrack@mmm.com.hk>
+ *
+ * daniel@veillard.com
+ */
+
+#define IN_LIBXML
+#include "libxml.h"
+
+#include <stdlib.h>
+#include <string.h>
+#include <libxml/xmlmemory.h>
+#include <libxml/parserInternals.h>
+#include <libxml/xmlstring.h>
+
+/************************************************************************
+ *                                                                      *
+ *                Commodity functions to handle xmlChars                *
+ *                                                                      *
+ ************************************************************************/
+
+/**
+ * xmlStrndup:
+ * @cur:  the input xmlChar *
+ * @len:  the len of @cur
+ *
+ * a strndup for array of xmlChar's
+ *
+ * Returns a new xmlChar * or NULL
+ */
+xmlChar *
+xmlStrndup(const xmlChar *cur, int len) {
+    xmlChar *ret;
+    
+    if ((cur == NULL) || (len < 0)) return(NULL);
+    ret = (xmlChar *) xmlMallocAtomic((len + 1) * sizeof(xmlChar));
+    if (ret == NULL) {
+        xmlErrMemory(NULL, NULL);
+        return(NULL);
+    }
+    memcpy(ret, cur, len * sizeof(xmlChar));
+    ret[len] = 0;
+    return(ret);
+}
+
+/**
+ * xmlStrdup:
+ * @cur:  the input xmlChar *
+ *
+ * a strdup for array of xmlChar's. Since they are supposed to be
+ * encoded in UTF-8 or an encoding with 8bit based chars, we assume
+ * a termination mark of '0'.
+ *
+ * Returns a new xmlChar * or NULL
+ */
+xmlChar *
+xmlStrdup(const xmlChar *cur) {
+    const xmlChar *p = cur;
+
+    if (cur == NULL) return(NULL);
+    while (*p != 0) p++; /* non input consuming */
+    return(xmlStrndup(cur, p - cur));
+}
+
+/**
+ * xmlCharStrndup:
+ * @cur:  the input char *
+ * @len:  the len of @cur
+ *
+ * a strndup for char's to xmlChar's
+ *
+ * Returns a new xmlChar * or NULL
+ */
+
+xmlChar *
+xmlCharStrndup(const char *cur, int len) {
+    int i;
+    xmlChar *ret;
+    
+    if ((cur == NULL) || (len < 0)) return(NULL);
+    ret = (xmlChar *) xmlMallocAtomic((len + 1) * sizeof(xmlChar));
+    if (ret == NULL) {
+        xmlErrMemory(NULL, NULL);
+        return(NULL);
+    }
+    for (i = 0;i < len;i++)
+        ret[i] = (xmlChar) cur[i];
+    ret[len] = 0;
+    return(ret);
+}
+
+/**
+ * xmlCharStrdup:
+ * @cur:  the input char *
+ *
+ * a strdup for char's to xmlChar's
+ *
+ * Returns a new xmlChar * or NULL
+ */
+
+xmlChar *
+xmlCharStrdup(const char *cur) {
+    const char *p = cur;
+
+    if (cur == NULL) return(NULL);
+    while (*p != '\0') p++; /* non input consuming */
+    return(xmlCharStrndup(cur, p - cur));
+}
+
+/**
+ * xmlStrcmp:
+ * @str1:  the first xmlChar *
+ * @str2:  the second xmlChar *
+ *
+ * a strcmp for xmlChar's
+ *
+ * Returns the integer result of the comparison
+ */
+
+int
+xmlStrcmp(const xmlChar *str1, const xmlChar *str2) {
+    register int tmp;
+
+    if (str1 == str2) return(0);
+    if (str1 == NULL) return(-1);
+    if (str2 == NULL) return(1);
+    do {
+        tmp = *str1++ - *str2;
+        if (tmp != 0) return(tmp);
+    } while (*str2++ != 0);
+    return 0;
+}
+
+/**
+ * xmlStrEqual:
+ * @str1:  the first xmlChar *
+ * @str2:  the second xmlChar *
+ *
+ * Check if both string are equal of have same content
+ * Should be a bit more readable and faster than xmlStrEqual()
+ *
+ * Returns 1 if they are equal, 0 if they are different
+ */
+
+int
+xmlStrEqual(const xmlChar *str1, const xmlChar *str2) {
+    if (str1 == str2) return(1);
+    if (str1 == NULL) return(0);
+    if (str2 == NULL) return(0);
+    do {
+        if (*str1++ != *str2) return(0);
+    } while (*str2++);
+    return(1);
+}
+
+/**
+ * xmlStrQEqual:
+ * @pref:  the prefix of the QName
+ * @name:  the localname of the QName
+ * @str:  the second xmlChar *
+ *
+ * Check if a QName is Equal to a given string 
+ *
+ * Returns 1 if they are equal, 0 if they are different
+ */
+
+int
+xmlStrQEqual(const xmlChar *pref, const xmlChar *name, const xmlChar *str) {
+    if (pref == NULL) return(xmlStrEqual(name, str));
+    if (name == NULL) return(0);
+    if (str == NULL) return(0);
+
+    do {
+        if (*pref++ != *str) return(0);
+    } while ((*str++) && (*pref));
+    if (*str++ != ':') return(0);
+    do {
+        if (*name++ != *str) return(0);
+    } while (*str++);
+    return(1);
+}
+
+/**
+ * xmlStrncmp:
+ * @str1:  the first xmlChar *
+ * @str2:  the second xmlChar *
+ * @len:  the max comparison length
+ *
+ * a strncmp for xmlChar's
+ *
+ * Returns the integer result of the comparison
+ */
+
+int
+xmlStrncmp(const xmlChar *str1, const xmlChar *str2, int len) {
+    register int tmp;
+
+    if (len <= 0) return(0);
+    if (str1 == str2) return(0);
+    if (str1 == NULL) return(-1);
+    if (str2 == NULL) return(1);
+#ifdef __GNUC__
+    tmp = strncmp(str1, str2, len);
+    return tmp;
+#else
+    do {
+        tmp = *str1++ - *str2;
+        if (tmp != 0 || --len == 0) return(tmp);
+    } while (*str2++ != 0);
+    return 0;
+#endif
+}
+
+static const xmlChar casemap[256] = {
+    0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,
+    0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F,
+    0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,
+    0x18,0x19,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F,
+    0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,
+    0x28,0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F,
+    0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,
+    0x38,0x39,0x3A,0x3B,0x3C,0x3D,0x3E,0x3F,
+    0x40,0x61,0x62,0x63,0x64,0x65,0x66,0x67,
+    0x68,0x69,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,
+    0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,
+    0x78,0x79,0x7A,0x7B,0x5C,0x5D,0x5E,0x5F,
+    0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67,
+    0x68,0x69,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,
+    0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,
+    0x78,0x79,0x7A,0x7B,0x7C,0x7D,0x7E,0x7F,
+    0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,
+    0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,
+    0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,
+    0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F,
+    0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,
+    0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,
+    0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,
+    0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF,
+    0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,
+    0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,
+    0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,
+    0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF,
+    0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,
+    0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,
+    0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,
+    0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF
+};
+
+/**
+ * xmlStrcasecmp:
+ * @str1:  the first xmlChar *
+ * @str2:  the second xmlChar *
+ *
+ * a strcasecmp for xmlChar's
+ *
+ * Returns the integer result of the comparison
+ */
+
+int
+xmlStrcasecmp(const xmlChar *str1, const xmlChar *str2) {
+    register int tmp;
+
+    if (str1 == str2) return(0);
+    if (str1 == NULL) return(-1);
+    if (str2 == NULL) return(1);
+    do {
+        tmp = casemap[*str1++] - casemap[*str2];
+        if (tmp != 0) return(tmp);
+    } while (*str2++ != 0);
+    return 0;
+}
+
+/**
+ * xmlStrncasecmp:
+ * @str1:  the first xmlChar *
+ * @str2:  the second xmlChar *
+ * @len:  the max comparison length
+ *
+ * a strncasecmp for xmlChar's
+ *
+ * Returns the integer result of the comparison
+ */
+
+int
+xmlStrncasecmp(const xmlChar *str1, const xmlChar *str2, int len) {
+    register int tmp;
+
+    if (len <= 0) return(0);
+    if (str1 == str2) return(0);
+    if (str1 == NULL) return(-1);
+    if (str2 == NULL) return(1);
+    do {
+        tmp = casemap[*str1++] - casemap[*str2];
+        if (tmp != 0 || --len == 0) return(tmp);
+    } while (*str2++ != 0);
+    return 0;
+}
+
+/**
+ * xmlStrchr:
+ * @str:  the xmlChar * array
+ * @val:  the xmlChar to search
+ *
+ * a strchr for xmlChar's
+ *
+ * Returns the xmlChar * for the first occurrence or NULL.
+ */
+
+const xmlChar *
+xmlStrchr(const xmlChar *str, xmlChar val) {
+    if (str == NULL) return(NULL);
+    while (*str != 0) { /* non input consuming */
+        if (*str == val) return((xmlChar *) str);
+        str++;
+    }
+    return(NULL);
+}
+
+/**
+ * xmlStrstr:
+ * @str:  the xmlChar * array (haystack)
+ * @val:  the xmlChar to search (needle)
+ *
+ * a strstr for xmlChar's
+ *
+ * Returns the xmlChar * for the first occurrence or NULL.
+ */
+
+const xmlChar *
+xmlStrstr(const xmlChar *str, const xmlChar *val) {
+    int n;
+    
+    if (str == NULL) return(NULL);
+    if (val == NULL) return(NULL);
+    n = xmlStrlen(val);
+
+    if (n == 0) return(str);
+    while (*str != 0) { /* non input consuming */
+        if (*str == *val) {
+            if (!xmlStrncmp(str, val, n)) return((const xmlChar *) str);
+        }
+        str++;
+    }
+    return(NULL);
+}
+
+/**
+ * xmlStrcasestr:
+ * @str:  the xmlChar * array (haystack)
+ * @val:  the xmlChar to search (needle)
+ *
+ * a case-ignoring strstr for xmlChar's
+ *
+ * Returns the xmlChar * for the first occurrence or NULL.
+ */
+
+const xmlChar *
+xmlStrcasestr(const xmlChar *str, xmlChar *val) {
+    int n;
+    
+    if (str == NULL) return(NULL);
+    if (val == NULL) return(NULL);
+    n = xmlStrlen(val);
+
+    if (n == 0) return(str);
+    while (*str != 0) { /* non input consuming */
+        if (casemap[*str] == casemap[*val])
+            if (!xmlStrncasecmp(str, val, n)) return(str);
+        str++;
+    }
+    return(NULL);
+}
+
+/**
+ * xmlStrsub:
+ * @str:  the xmlChar * array (haystack)
+ * @start:  the index of the first char (zero based)
+ * @len:  the length of the substring
+ *
+ * Extract a substring of a given string
+ *
+ * Returns the xmlChar * for the first occurrence or NULL.
+ */
+
+xmlChar *
+xmlStrsub(const xmlChar *str, int start, int len) {
+    int i;
+    
+    if (str == NULL) return(NULL);
+    if (start < 0) return(NULL);
+    if (len < 0) return(NULL);
+
+    for (i = 0;i < start;i++) {
+        if (*str == 0) return(NULL);
+        str++;
+    }
+    if (*str == 0) return(NULL);
+    return(xmlStrndup(str, len));
+}
+
+/**
+ * xmlStrlen:
+ * @str:  the xmlChar * array
+ *
+ * length of a xmlChar's string
+ *
+ * Returns the number of xmlChar contained in the ARRAY.
+ */
+
+int
+xmlStrlen(const xmlChar *str) {
+    int len = 0;
+
+    if (str == NULL) return(0);
+    while (*str != 0) { /* non input consuming */
+        str++;
+        len++;
+    }
+    return(len);
+}
+
+/**
+ * xmlStrncat:
+ * @cur:  the original xmlChar * array
+ * @add:  the xmlChar * array added
+ * @len:  the length of @add
+ *
+ * a strncat for array of xmlChar's, it will extend @cur with the len
+ * first bytes of @add.
+ *
+ * Returns a new xmlChar *, the original @cur is reallocated if needed
+ * and should not be freed
+ */
+
+xmlChar *
+xmlStrncat(xmlChar *cur, const xmlChar *add, int len) {
+    int size;
+    xmlChar *ret;
+
+    if ((add == NULL) || (len == 0))
+        return(cur);
+    if (cur == NULL)
+        return(xmlStrndup(add, len));
+
+    size = xmlStrlen(cur);
+    ret = (xmlChar *) xmlRealloc(cur, (size + len + 1) * sizeof(xmlChar));
+    if (ret == NULL) {
+        xmlErrMemory(NULL, NULL);
+        return(cur);
+    }
+    memcpy(&ret[size], add, len * sizeof(xmlChar));
+    ret[size + len] = 0;
+    return(ret);
+}
+
+/**
+ * xmlStrncatNew:
+ * @str1:  first xmlChar string
+ * @str2:  second xmlChar string
+ * @len:  the len of @str2
+ *
+ * same as xmlStrncat, but creates a new string.  The original
+ * two strings are not freed.
+ *
+ * Returns a new xmlChar * or NULL
+ */
+xmlChar *
+xmlStrncatNew(const xmlChar *str1, const xmlChar *str2, int len) {
+    int size;
+    xmlChar *ret;
+
+    if ((str2 == NULL) || (len == 0))
+        return(xmlStrdup(str1));
+    if (str1 == NULL)
+        return(xmlStrndup(str2, len));
+
+    size = xmlStrlen(str1);
+    ret = (xmlChar *) xmlMalloc((size + len + 1) * sizeof(xmlChar));
+    if (ret == NULL) {
+        xmlErrMemory(NULL, NULL);
+        return(xmlStrndup(str1, size));
+    }
+    memcpy(ret, str1, size * sizeof(xmlChar));
+    memcpy(&ret[size], str2, len * sizeof(xmlChar));
+    ret[size + len] = 0;
+    return(ret);
+}
+
+/**
+ * xmlStrcat:
+ * @cur:  the original xmlChar * array
+ * @add:  the xmlChar * array added
+ *
+ * a strcat for array of xmlChar's. Since they are supposed to be
+ * encoded in UTF-8 or an encoding with 8bit based chars, we assume
+ * a termination mark of '0'.
+ *
+ * Returns a new xmlChar * containing the concatenated string.
+ */
+xmlChar *
+xmlStrcat(xmlChar *cur, const xmlChar *add) {
+    const xmlChar *p = add;
+
+    if (add == NULL) return(cur);
+    if (cur == NULL) 
+        return(xmlStrdup(add));
+
+    while (*p != 0) p++; /* non input consuming */
+    return(xmlStrncat(cur, add, p - add));
+}
+
+/**
+ * xmlStrPrintf:
+ * @buf:   the result buffer.
+ * @len:   the result buffer length.
+ * @msg:   the message with printf formatting.
+ * @...:   extra parameters for the message.
+ *
+ * Formats @msg and places result into @buf.
+ *
+ * Returns the number of characters written to @buf or -1 if an error occurs.
+ */
+int 
+xmlStrPrintf(xmlChar *buf, int len, const xmlChar *msg, ...) {
+    va_list args;
+    int ret;
+    
+    if((buf == NULL) || (msg == NULL)) {
+        return(-1);
+    }
+    
+    va_start(args, msg);
+    ret = vsnprintf((char *) buf, len, (const char *) msg, args);
+    va_end(args);
+    buf[len - 1] = 0; /* be safe ! */
+    
+    return(ret);
+}
+
+/**
+ * xmlStrVPrintf:
+ * @buf:   the result buffer.
+ * @len:   the result buffer length.
+ * @msg:   the message with printf formatting.
+ * @ap:    extra parameters for the message.
+ *
+ * Formats @msg and places result into @buf.
+ *
+ * Returns the number of characters written to @buf or -1 if an error occurs.
+ */
+int 
+xmlStrVPrintf(xmlChar *buf, int len, const xmlChar *msg, va_list ap) {
+    int ret;
+    
+    if((buf == NULL) || (msg == NULL)) {
+        return(-1);
+    }
+    
+    ret = vsnprintf((char *) buf, len, (const char *) msg, ap);
+    buf[len - 1] = 0; /* be safe ! */
+    
+    return(ret);
+}
+
+/************************************************************************
+ *                                                                      *
+ *              Generic UTF8 handling routines                          *
+ *                                                                      *
+ * From rfc2044: encoding of the Unicode values on UTF-8:               *
+ *                                                                      *
+ * UCS-4 range (hex.)           UTF-8 octet sequence (binary)           *
+ * 0000 0000-0000 007F   0xxxxxxx                                       *
+ * 0000 0080-0000 07FF   110xxxxx 10xxxxxx                              *
+ * 0000 0800-0000 FFFF   1110xxxx 10xxxxxx 10xxxxxx                     *
+ *                                                                      *
+ * I hope we won't use values > 0xFFFF anytime soon !                   *
+ *                                                                      *
+ ************************************************************************/
+
+
+/**
+ * xmlUTF8Size:
+ * @utf: pointer to the UTF8 character
+ *
+ * calculates the internal size of a UTF8 character
+ *
+ * returns the numbers of bytes in the character, -1 on format error
+ */
+int
+xmlUTF8Size(const xmlChar *utf) {
+    xmlChar mask;
+    int len;
+
+    if (utf == NULL)
+        return -1;
+    if (*utf < 0x80)
+        return 1;
+    /* check valid UTF8 character */
+    if (!(*utf & 0x40))
+        return -1;
+    /* determine number of bytes in char */
+    len = 2;
+    for (mask=0x20; mask != 0; mask>>=1) {
+        if (!(*utf & mask))
+            return len;
+        len++;
+    }
+    return -1;
+}
+
+/**
+ * xmlUTF8Charcmp:
+ * @utf1: pointer to first UTF8 char
+ * @utf2: pointer to second UTF8 char
+ *
+ * compares the two UCS4 values
+ *
+ * returns result of the compare as with xmlStrncmp
+ */
+int
+xmlUTF8Charcmp(const xmlChar *utf1, const xmlChar *utf2) {
+
+    if (utf1 == NULL ) {
+        if (utf2 == NULL)
+            return 0;
+        return -1;
+    }
+    return xmlStrncmp(utf1, utf2, xmlUTF8Size(utf1));
+}
+
+/**
+ * xmlUTF8Strlen:
+ * @utf:  a sequence of UTF-8 encoded bytes
+ *
+ * compute the length of an UTF8 string, it doesn't do a full UTF8
+ * checking of the content of the string.
+ *
+ * Returns the number of characters in the string or -1 in case of error
+ */
+int
+xmlUTF8Strlen(const xmlChar *utf) {
+    int ret = 0;
+
+    if (utf == NULL)
+        return(-1);
+
+    while (*utf != 0) {
+        if (utf[0] & 0x80) {
+            if ((utf[1] & 0xc0) != 0x80)
+                return(-1);
+            if ((utf[0] & 0xe0) == 0xe0) {
+                if ((utf[2] & 0xc0) != 0x80)
+                    return(-1);
+                if ((utf[0] & 0xf0) == 0xf0) {
+                    if ((utf[0] & 0xf8) != 0xf0 || (utf[3] & 0xc0) != 0x80)
+                        return(-1);
+                    utf += 4;
+                } else {
+                    utf += 3;
+                }
+            } else {
+                utf += 2;
+            }
+        } else {
+            utf++;
+        }
+        ret++;
+    }
+    return(ret);
+}
+
+/**
+ * xmlGetUTF8Char:
+ * @utf:  a sequence of UTF-8 encoded bytes
+ * @len:  a pointer to @bytes len
+ *
+ * Read one UTF8 Char from @utf
+ *
+ * Returns the char value or -1 in case of error, and updates *len with the
+ *        number of bytes consumed
+ */
+int
+xmlGetUTF8Char(const unsigned char *utf, int *len) {
+    unsigned int c;
+
+    if (utf == NULL)
+        goto error;
+    if (len == NULL)
+        goto error;
+    if (*len < 1)
+        goto error;
+
+    c = utf[0];
+    if (c & 0x80) {
+        if (*len < 2)
+            goto error;
+        if ((utf[1] & 0xc0) != 0x80)
+            goto error;
+        if ((c & 0xe0) == 0xe0) {
+            if (*len < 3)
+                goto error;
+            if ((utf[2] & 0xc0) != 0x80)
+                goto error;
+            if ((c & 0xf0) == 0xf0) {
+                if (*len < 4)
+                    goto error;
+                if ((c & 0xf8) != 0xf0 || (utf[3] & 0xc0) != 0x80)
+                    goto error;
+                *len = 4;
+                /* 4-byte code */
+                c = (utf[0] & 0x7) << 18;
+                c |= (utf[1] & 0x3f) << 12;
+                c |= (utf[2] & 0x3f) << 6;
+                c |= utf[3] & 0x3f;
+            } else {
+              /* 3-byte code */
+                *len = 3;
+                c = (utf[0] & 0xf) << 12;
+                c |= (utf[1] & 0x3f) << 6;
+                c |= utf[2] & 0x3f;
+            }
+        } else {
+          /* 2-byte code */
+            *len = 2;
+            c = (utf[0] & 0x1f) << 6;
+            c |= utf[1] & 0x3f;
+        }
+    } else {
+        /* 1-byte code */
+        *len = 1;
+    }
+    return(c);
+
+error:
+    *len = 0;
+    return(-1);
+}
+
+/**
+ * xmlCheckUTF8:
+ * @utf: Pointer to putative UTF-8 encoded string.
+ *
+ * Checks @utf for being valid UTF-8. @utf is assumed to be
+ * null-terminated. This function is not super-strict, as it will
+ * allow longer UTF-8 sequences than necessary. Note that Java is
+ * capable of producing these sequences if provoked. Also note, this
+ * routine checks for the 4-byte maximum size, but does not check for
+ * 0x10ffff maximum value.
+ *
+ * Return value: true if @utf is valid.
+ **/
+int
+xmlCheckUTF8(const unsigned char *utf)
+{
+    int ix;
+    unsigned char c;
+
+    for (ix = 0; (c = utf[ix]);) {
+        if (c & 0x80) {
+            if ((utf[ix + 1] & 0xc0) != 0x80)
+                return(0);
+            if ((c & 0xe0) == 0xe0) {
+                if ((utf[ix + 2] & 0xc0) != 0x80)
+                    return(0);
+                if ((c & 0xf0) == 0xf0) {
+                    if ((c & 0xf8) != 0xf0 || (utf[ix + 3] & 0xc0) != 0x80)
+                        return(0);
+                    ix += 4;
+                    /* 4-byte code */
+                } else
+                    /* 3-byte code */
+                    ix += 3;
+            } else
+                /* 2-byte code */
+                ix += 2;
+        } else
+            /* 1-byte code */
+            ix++;
+      }
+      return(1);
+}
+
+/**
+ * xmlUTF8Strsize:
+ * @utf:  a sequence of UTF-8 encoded bytes
+ * @len:  the number of characters in the array
+ *
+ * storage size of an UTF8 string
+ *
+ * Returns the storage size of
+ * the first 'len' characters of ARRAY
+ *
+ */
+
+int
+xmlUTF8Strsize(const xmlChar *utf, int len) {
+    const xmlChar   *ptr=utf;
+    xmlChar         ch;
+
+    if (len <= 0)
+        return(0);
+
+    while ( len-- > 0) {
+        if ( !*ptr )
+            break;
+        if ( (ch = *ptr++) & 0x80)
+            while ( (ch<<=1) & 0x80 )
+                ptr++;
+    }
+    return (ptr - utf);
+}
+
+
+/**
+ * xmlUTF8Strndup:
+ * @utf:  the input UTF8 *
+ * @len:  the len of @utf (in chars)
+ *
+ * a strndup for array of UTF8's
+ *
+ * Returns a new UTF8 * or NULL
+ */
+xmlChar *
+xmlUTF8Strndup(const xmlChar *utf, int len) {
+    xmlChar *ret;
+    int i;
+    
+    if ((utf == NULL) || (len < 0)) return(NULL);
+    i = xmlUTF8Strsize(utf, len);
+    ret = (xmlChar *) xmlMallocAtomic((i + 1) * sizeof(xmlChar));
+    if (ret == NULL) {
+        xmlGenericError(xmlGenericErrorContext,
+                "malloc of %ld byte failed\n",
+                (len + 1) * (long)sizeof(xmlChar));
+        return(NULL);
+    }
+    memcpy(ret, utf, i * sizeof(xmlChar));
+    ret[i] = 0;
+    return(ret);
+}
+
+/**
+ * xmlUTF8Strpos:
+ * @utf:  the input UTF8 *
+ * @pos:  the position of the desired UTF8 char (in chars)
+ *
+ * a function to provide the equivalent of fetching a
+ * character from a string array
+ *
+ * Returns a pointer to the UTF8 character or NULL
+ */
+xmlChar *
+xmlUTF8Strpos(const xmlChar *utf, int pos) {
+    xmlChar ch;
+
+    if (utf == NULL) return(NULL);
+    if ( (pos < 0) || (pos >= xmlUTF8Strlen(utf)) )
+        return(NULL);
+    while (pos--) {
+        if ((ch=*utf++) == 0) return(NULL);
+        if ( ch & 0x80 ) {
+            /* if not simple ascii, verify proper format */
+            if ( (ch & 0xc0) != 0xc0 )
+                return(NULL);
+            /* then skip over remaining bytes for this char */
+            while ( (ch <<= 1) & 0x80 )
+                if ( (*utf++ & 0xc0) != 0x80 )
+                    return(NULL);
+        }
+    }
+    return((xmlChar *)utf);
+}
+
+/**
+ * xmlUTF8Strloc:
+ * @utf:  the input UTF8 *
+ * @utfchar:  the UTF8 character to be found
+ *
+ * a function to provide the relative location of a UTF8 char
+ *
+ * Returns the relative character position of the desired char
+ * or -1 if not found
+ */
+int
+xmlUTF8Strloc(const xmlChar *utf, const xmlChar *utfchar) {
+    int i, size;
+    xmlChar ch;
+
+    if (utf==NULL || utfchar==NULL) return -1;
+    size = xmlUTF8Strsize(utfchar, 1);
+        for(i=0; (ch=*utf) != 0; i++) {
+            if (xmlStrncmp(utf, utfchar, size)==0)
+                return(i);
+            utf++;
+            if ( ch & 0x80 ) {
+                /* if not simple ascii, verify proper format */
+                if ( (ch & 0xc0) != 0xc0 )
+                    return(-1);
+                /* then skip over remaining bytes for this char */
+                while ( (ch <<= 1) & 0x80 )
+                    if ( (*utf++ & 0xc0) != 0x80 )
+                        return(-1);
+            }
+        }
+
+    return(-1);
+}
+/**
+ * xmlUTF8Strsub:
+ * @utf:  a sequence of UTF-8 encoded bytes
+ * @start: relative pos of first char
+ * @len:   total number to copy
+ *
+ * Create a substring from a given UTF-8 string
+ * Note:  positions are given in units of UTF-8 chars
+ *
+ * Returns a pointer to a newly created string
+ * or NULL if any problem
+ */
+
+xmlChar *
+xmlUTF8Strsub(const xmlChar *utf, int start, int len) {
+    int            i;
+    xmlChar ch;
+
+    if (utf == NULL) return(NULL);
+    if (start < 0) return(NULL);
+    if (len < 0) return(NULL);
+
+    /*
+     * Skip over any leading chars
+     */
+    for (i = 0;i < start;i++) {
+        if ((ch=*utf++) == 0) return(NULL);
+        if ( ch & 0x80 ) {
+            /* if not simple ascii, verify proper format */
+            if ( (ch & 0xc0) != 0xc0 )
+                return(NULL);
+            /* then skip over remaining bytes for this char */
+            while ( (ch <<= 1) & 0x80 )
+                if ( (*utf++ & 0xc0) != 0x80 )
+                    return(NULL);
+        }
+    }
+
+    return(xmlUTF8Strndup(utf, len));
+}
diff --git a/src/libxml/src/xmlunicode.c b/src/libxml/src/xmlunicode.c
new file mode 100644
index 0000000..4667636
--- /dev/null
+++ b/src/libxml/src/xmlunicode.c
@@ -0,0 +1,3172 @@
+/*
+ * xmlunicode.c: this module implements the Unicode character APIs
+ *
+ * This file is automatically generated from the
+ * UCS description files of the Unicode Character Database
+ * http://www.unicode.org/Public/4.0-Update1/UCD-4.0.1d5b.html
+ * using the genUnicode.py Python script.
+ *
+ * Generation date: Mon Nov 10 22:35:10 2003
+ * Sources: Blocks-4.0.1d1b.txt UnicodeData-4.0.1d1b.txt
+ * Daniel Veillard <veillard@redhat.com>
+ */
+
+#define IN_LIBXML
+#include "libxml.h"
+
+#ifdef LIBXML_UNICODE_ENABLED
+
+#include <string.h>
+#include <libxml/xmlversion.h>
+#include <libxml/xmlunicode.h>
+#include <libxml/chvalid.h>
+
+typedef int (xmlIntFunc)(int);	/* just to keep one's mind untwisted */
+
+typedef struct {
+    const char *rangename;
+    xmlIntFunc *func;
+} xmlUnicodeRange;
+
+typedef struct {
+    xmlUnicodeRange *table;
+    int		    numentries;
+} xmlUnicodeNameTable;
+
+
+static xmlIntFunc *xmlUnicodeLookup(xmlUnicodeNameTable *tptr, const char *tname);
+
+static xmlUnicodeRange xmlUnicodeBlocks[] = {
+  {"AegeanNumbers", xmlUCSIsAegeanNumbers},
+  {"AlphabeticPresentationForms", xmlUCSIsAlphabeticPresentationForms},
+  {"Arabic", xmlUCSIsArabic},
+  {"ArabicPresentationForms-A", xmlUCSIsArabicPresentationFormsA},
+  {"ArabicPresentationForms-B", xmlUCSIsArabicPresentationFormsB},
+  {"Armenian", xmlUCSIsArmenian},
+  {"Arrows", xmlUCSIsArrows},
+  {"BasicLatin", xmlUCSIsBasicLatin},
+  {"Bengali", xmlUCSIsBengali},
+  {"BlockElements", xmlUCSIsBlockElements},
+  {"Bopomofo", xmlUCSIsBopomofo},
+  {"BopomofoExtended", xmlUCSIsBopomofoExtended},
+  {"BoxDrawing", xmlUCSIsBoxDrawing},
+  {"BraillePatterns", xmlUCSIsBraillePatterns},
+  {"Buhid", xmlUCSIsBuhid},
+  {"ByzantineMusicalSymbols", xmlUCSIsByzantineMusicalSymbols},
+  {"CJKCompatibility", xmlUCSIsCJKCompatibility},
+  {"CJKCompatibilityForms", xmlUCSIsCJKCompatibilityForms},
+  {"CJKCompatibilityIdeographs", xmlUCSIsCJKCompatibilityIdeographs},
+  {"CJKCompatibilityIdeographsSupplement", xmlUCSIsCJKCompatibilityIdeographsSupplement},
+  {"CJKRadicalsSupplement", xmlUCSIsCJKRadicalsSupplement},
+  {"CJKSymbolsandPunctuation", xmlUCSIsCJKSymbolsandPunctuation},
+  {"CJKUnifiedIdeographs", xmlUCSIsCJKUnifiedIdeographs},
+  {"CJKUnifiedIdeographsExtensionA", xmlUCSIsCJKUnifiedIdeographsExtensionA},
+  {"CJKUnifiedIdeographsExtensionB", xmlUCSIsCJKUnifiedIdeographsExtensionB},
+  {"Cherokee", xmlUCSIsCherokee},
+  {"CombiningDiacriticalMarks", xmlUCSIsCombiningDiacriticalMarks},
+  {"CombiningDiacriticalMarksforSymbols", xmlUCSIsCombiningDiacriticalMarksforSymbols},
+  {"CombiningHalfMarks", xmlUCSIsCombiningHalfMarks},
+  {"CombiningMarksforSymbols", xmlUCSIsCombiningMarksforSymbols},
+  {"ControlPictures", xmlUCSIsControlPictures},
+  {"CurrencySymbols", xmlUCSIsCurrencySymbols},
+  {"CypriotSyllabary", xmlUCSIsCypriotSyllabary},
+  {"Cyrillic", xmlUCSIsCyrillic},
+  {"CyrillicSupplement", xmlUCSIsCyrillicSupplement},
+  {"Deseret", xmlUCSIsDeseret},
+  {"Devanagari", xmlUCSIsDevanagari},
+  {"Dingbats", xmlUCSIsDingbats},
+  {"EnclosedAlphanumerics", xmlUCSIsEnclosedAlphanumerics},
+  {"EnclosedCJKLettersandMonths", xmlUCSIsEnclosedCJKLettersandMonths},
+  {"Ethiopic", xmlUCSIsEthiopic},
+  {"GeneralPunctuation", xmlUCSIsGeneralPunctuation},
+  {"GeometricShapes", xmlUCSIsGeometricShapes},
+  {"Georgian", xmlUCSIsGeorgian},
+  {"Gothic", xmlUCSIsGothic},
+  {"Greek", xmlUCSIsGreek},
+  {"GreekExtended", xmlUCSIsGreekExtended},
+  {"GreekandCoptic", xmlUCSIsGreekandCoptic},
+  {"Gujarati", xmlUCSIsGujarati},
+  {"Gurmukhi", xmlUCSIsGurmukhi},
+  {"HalfwidthandFullwidthForms", xmlUCSIsHalfwidthandFullwidthForms},
+  {"HangulCompatibilityJamo", xmlUCSIsHangulCompatibilityJamo},
+  {"HangulJamo", xmlUCSIsHangulJamo},
+  {"HangulSyllables", xmlUCSIsHangulSyllables},
+  {"Hanunoo", xmlUCSIsHanunoo},
+  {"Hebrew", xmlUCSIsHebrew},
+  {"HighPrivateUseSurrogates", xmlUCSIsHighPrivateUseSurrogates},
+  {"HighSurrogates", xmlUCSIsHighSurrogates},
+  {"Hiragana", xmlUCSIsHiragana},
+  {"IPAExtensions", xmlUCSIsIPAExtensions},
+  {"IdeographicDescriptionCharacters", xmlUCSIsIdeographicDescriptionCharacters},
+  {"Kanbun", xmlUCSIsKanbun},
+  {"KangxiRadicals", xmlUCSIsKangxiRadicals},
+  {"Kannada", xmlUCSIsKannada},
+  {"Katakana", xmlUCSIsKatakana},
+  {"KatakanaPhoneticExtensions", xmlUCSIsKatakanaPhoneticExtensions},
+  {"Khmer", xmlUCSIsKhmer},
+  {"KhmerSymbols", xmlUCSIsKhmerSymbols},
+  {"Lao", xmlUCSIsLao},
+  {"Latin-1Supplement", xmlUCSIsLatin1Supplement},
+  {"LatinExtended-A", xmlUCSIsLatinExtendedA},
+  {"LatinExtended-B", xmlUCSIsLatinExtendedB},
+  {"LatinExtendedAdditional", xmlUCSIsLatinExtendedAdditional},
+  {"LetterlikeSymbols", xmlUCSIsLetterlikeSymbols},
+  {"Limbu", xmlUCSIsLimbu},
+  {"LinearBIdeograms", xmlUCSIsLinearBIdeograms},
+  {"LinearBSyllabary", xmlUCSIsLinearBSyllabary},
+  {"LowSurrogates", xmlUCSIsLowSurrogates},
+  {"Malayalam", xmlUCSIsMalayalam},
+  {"MathematicalAlphanumericSymbols", xmlUCSIsMathematicalAlphanumericSymbols},
+  {"MathematicalOperators", xmlUCSIsMathematicalOperators},
+  {"MiscellaneousMathematicalSymbols-A", xmlUCSIsMiscellaneousMathematicalSymbolsA},
+  {"MiscellaneousMathematicalSymbols-B", xmlUCSIsMiscellaneousMathematicalSymbolsB},
+  {"MiscellaneousSymbols", xmlUCSIsMiscellaneousSymbols},
+  {"MiscellaneousSymbolsandArrows", xmlUCSIsMiscellaneousSymbolsandArrows},
+  {"MiscellaneousTechnical", xmlUCSIsMiscellaneousTechnical},
+  {"Mongolian", xmlUCSIsMongolian},
+  {"MusicalSymbols", xmlUCSIsMusicalSymbols},
+  {"Myanmar", xmlUCSIsMyanmar},
+  {"NumberForms", xmlUCSIsNumberForms},
+  {"Ogham", xmlUCSIsOgham},
+  {"OldItalic", xmlUCSIsOldItalic},
+  {"OpticalCharacterRecognition", xmlUCSIsOpticalCharacterRecognition},
+  {"Oriya", xmlUCSIsOriya},
+  {"Osmanya", xmlUCSIsOsmanya},
+  {"PhoneticExtensions", xmlUCSIsPhoneticExtensions},
+  {"PrivateUse", xmlUCSIsPrivateUse},
+  {"PrivateUseArea", xmlUCSIsPrivateUseArea},
+  {"Runic", xmlUCSIsRunic},
+  {"Shavian", xmlUCSIsShavian},
+  {"Sinhala", xmlUCSIsSinhala},
+  {"SmallFormVariants", xmlUCSIsSmallFormVariants},
+  {"SpacingModifierLetters", xmlUCSIsSpacingModifierLetters},
+  {"Specials", xmlUCSIsSpecials},
+  {"SuperscriptsandSubscripts", xmlUCSIsSuperscriptsandSubscripts},
+  {"SupplementalArrows-A", xmlUCSIsSupplementalArrowsA},
+  {"SupplementalArrows-B", xmlUCSIsSupplementalArrowsB},
+  {"SupplementalMathematicalOperators", xmlUCSIsSupplementalMathematicalOperators},
+  {"SupplementaryPrivateUseArea-A", xmlUCSIsSupplementaryPrivateUseAreaA},
+  {"SupplementaryPrivateUseArea-B", xmlUCSIsSupplementaryPrivateUseAreaB},
+  {"Syriac", xmlUCSIsSyriac},
+  {"Tagalog", xmlUCSIsTagalog},
+  {"Tagbanwa", xmlUCSIsTagbanwa},
+  {"Tags", xmlUCSIsTags},
+  {"TaiLe", xmlUCSIsTaiLe},
+  {"TaiXuanJingSymbols", xmlUCSIsTaiXuanJingSymbols},
+  {"Tamil", xmlUCSIsTamil},
+  {"Telugu", xmlUCSIsTelugu},
+  {"Thaana", xmlUCSIsThaana},
+  {"Thai", xmlUCSIsThai},
+  {"Tibetan", xmlUCSIsTibetan},
+  {"Ugaritic", xmlUCSIsUgaritic},
+  {"UnifiedCanadianAboriginalSyllabics", xmlUCSIsUnifiedCanadianAboriginalSyllabics},
+  {"VariationSelectors", xmlUCSIsVariationSelectors},
+  {"VariationSelectorsSupplement", xmlUCSIsVariationSelectorsSupplement},
+  {"YiRadicals", xmlUCSIsYiRadicals},
+  {"YiSyllables", xmlUCSIsYiSyllables},
+  {"YijingHexagramSymbols", xmlUCSIsYijingHexagramSymbols}};
+
+static xmlUnicodeRange xmlUnicodeCats[] = {
+  {"C", xmlUCSIsCatC},
+  {"Cc", xmlUCSIsCatCc},
+  {"Cf", xmlUCSIsCatCf},
+  {"Co", xmlUCSIsCatCo},
+  {"Cs", xmlUCSIsCatCs},
+  {"L", xmlUCSIsCatL},
+  {"Ll", xmlUCSIsCatLl},
+  {"Lm", xmlUCSIsCatLm},
+  {"Lo", xmlUCSIsCatLo},
+  {"Lt", xmlUCSIsCatLt},
+  {"Lu", xmlUCSIsCatLu},
+  {"M", xmlUCSIsCatM},
+  {"Mc", xmlUCSIsCatMc},
+  {"Me", xmlUCSIsCatMe},
+  {"Mn", xmlUCSIsCatMn},
+  {"N", xmlUCSIsCatN},
+  {"Nd", xmlUCSIsCatNd},
+  {"Nl", xmlUCSIsCatNl},
+  {"No", xmlUCSIsCatNo},
+  {"P", xmlUCSIsCatP},
+  {"Pc", xmlUCSIsCatPc},
+  {"Pd", xmlUCSIsCatPd},
+  {"Pe", xmlUCSIsCatPe},
+  {"Pf", xmlUCSIsCatPf},
+  {"Pi", xmlUCSIsCatPi},
+  {"Po", xmlUCSIsCatPo},
+  {"Ps", xmlUCSIsCatPs},
+  {"S", xmlUCSIsCatS},
+  {"Sc", xmlUCSIsCatSc},
+  {"Sk", xmlUCSIsCatSk},
+  {"Sm", xmlUCSIsCatSm},
+  {"So", xmlUCSIsCatSo},
+  {"Z", xmlUCSIsCatZ},
+  {"Zl", xmlUCSIsCatZl},
+  {"Zp", xmlUCSIsCatZp},
+  {"Zs", xmlUCSIsCatZs}};
+
+static xmlChSRange xmlCS[] = {{0x0, 0x1f}, {0x7f, 0x9f}, {0xad, 0xad}, 
+    {0x600, 0x603}, {0x6dd, 0x6dd}, {0x70f, 0x70f}, {0x17b4, 0x17b5}, 
+    {0x200c, 0x200f}, {0x202a, 0x202e}, {0x2060, 0x2063}, {0x206a, 0x206f}, 
+    {0xd800, 0xd800}, {0xdb7f, 0xdb80}, {0xdbff, 0xdc00}, {0xdfff, 0xe000}, 
+    {0xf8ff, 0xf8ff}, {0xfeff, 0xfeff}, {0xfff9, 0xfffb} };
+static xmlChLRange xmlCL[] = {{0x1d173, 0x1d17a}, {0xe0001, 0xe0001}, 
+    {0xe0020, 0xe007f}, {0xf0000, 0xf0000}, {0xffffd, 0xffffd}, 
+    {0x100000, 0x100000}, {0x10fffd, 0x10fffd} };
+static xmlChRangeGroup xmlCG = {18,7,xmlCS,xmlCL};
+
+static xmlChSRange xmlCfS[] = {{0xad, 0xad}, {0x600, 0x603}, 
+    {0x6dd, 0x6dd}, {0x70f, 0x70f}, {0x17b4, 0x17b5}, {0x200c, 0x200f}, 
+    {0x202a, 0x202e}, {0x2060, 0x2063}, {0x206a, 0x206f}, {0xfeff, 0xfeff}, 
+    {0xfff9, 0xfffb} };
+static xmlChLRange xmlCfL[] = {{0x1d173, 0x1d17a}, {0xe0001, 0xe0001}, 
+    {0xe0020, 0xe007f} };
+static xmlChRangeGroup xmlCfG = {11,3,xmlCfS,xmlCfL};
+
+static xmlChSRange xmlLS[] = {{0x41, 0x5a}, {0x61, 0x7a}, {0xaa, 0xaa}, 
+    {0xb5, 0xb5}, {0xba, 0xba}, {0xc0, 0xd6}, {0xd8, 0xf6}, {0xf8, 0x236}, 
+    {0x250, 0x2c1}, {0x2c6, 0x2d1}, {0x2e0, 0x2e4}, {0x2ee, 0x2ee}, 
+    {0x37a, 0x37a}, {0x386, 0x386}, {0x388, 0x38a}, {0x38c, 0x38c}, 
+    {0x38e, 0x3a1}, {0x3a3, 0x3ce}, {0x3d0, 0x3f5}, {0x3f7, 0x3fb}, 
+    {0x400, 0x481}, {0x48a, 0x4ce}, {0x4d0, 0x4f5}, {0x4f8, 0x4f9}, 
+    {0x500, 0x50f}, {0x531, 0x556}, {0x559, 0x559}, {0x561, 0x587}, 
+    {0x5d0, 0x5ea}, {0x5f0, 0x5f2}, {0x621, 0x63a}, {0x640, 0x64a}, 
+    {0x66e, 0x66f}, {0x671, 0x6d3}, {0x6d5, 0x6d5}, {0x6e5, 0x6e6}, 
+    {0x6ee, 0x6ef}, {0x6fa, 0x6fc}, {0x6ff, 0x6ff}, {0x710, 0x710}, 
+    {0x712, 0x72f}, {0x74d, 0x74f}, {0x780, 0x7a5}, {0x7b1, 0x7b1}, 
+    {0x904, 0x939}, {0x93d, 0x93d}, {0x950, 0x950}, {0x958, 0x961}, 
+    {0x985, 0x98c}, {0x98f, 0x990}, {0x993, 0x9a8}, {0x9aa, 0x9b0}, 
+    {0x9b2, 0x9b2}, {0x9b6, 0x9b9}, {0x9bd, 0x9bd}, {0x9dc, 0x9dd}, 
+    {0x9df, 0x9e1}, {0x9f0, 0x9f1}, {0xa05, 0xa0a}, {0xa0f, 0xa10}, 
+    {0xa13, 0xa28}, {0xa2a, 0xa30}, {0xa32, 0xa33}, {0xa35, 0xa36}, 
+    {0xa38, 0xa39}, {0xa59, 0xa5c}, {0xa5e, 0xa5e}, {0xa72, 0xa74}, 
+    {0xa85, 0xa8d}, {0xa8f, 0xa91}, {0xa93, 0xaa8}, {0xaaa, 0xab0}, 
+    {0xab2, 0xab3}, {0xab5, 0xab9}, {0xabd, 0xabd}, {0xad0, 0xad0}, 
+    {0xae0, 0xae1}, {0xb05, 0xb0c}, {0xb0f, 0xb10}, {0xb13, 0xb28}, 
+    {0xb2a, 0xb30}, {0xb32, 0xb33}, {0xb35, 0xb39}, {0xb3d, 0xb3d}, 
+    {0xb5c, 0xb5d}, {0xb5f, 0xb61}, {0xb71, 0xb71}, {0xb83, 0xb83}, 
+    {0xb85, 0xb8a}, {0xb8e, 0xb90}, {0xb92, 0xb95}, {0xb99, 0xb9a}, 
+    {0xb9c, 0xb9c}, {0xb9e, 0xb9f}, {0xba3, 0xba4}, {0xba8, 0xbaa}, 
+    {0xbae, 0xbb5}, {0xbb7, 0xbb9}, {0xc05, 0xc0c}, {0xc0e, 0xc10}, 
+    {0xc12, 0xc28}, {0xc2a, 0xc33}, {0xc35, 0xc39}, {0xc60, 0xc61}, 
+    {0xc85, 0xc8c}, {0xc8e, 0xc90}, {0xc92, 0xca8}, {0xcaa, 0xcb3}, 
+    {0xcb5, 0xcb9}, {0xcbd, 0xcbd}, {0xcde, 0xcde}, {0xce0, 0xce1}, 
+    {0xd05, 0xd0c}, {0xd0e, 0xd10}, {0xd12, 0xd28}, {0xd2a, 0xd39}, 
+    {0xd60, 0xd61}, {0xd85, 0xd96}, {0xd9a, 0xdb1}, {0xdb3, 0xdbb}, 
+    {0xdbd, 0xdbd}, {0xdc0, 0xdc6}, {0xe01, 0xe30}, {0xe32, 0xe33}, 
+    {0xe40, 0xe46}, {0xe81, 0xe82}, {0xe84, 0xe84}, {0xe87, 0xe88}, 
+    {0xe8a, 0xe8a}, {0xe8d, 0xe8d}, {0xe94, 0xe97}, {0xe99, 0xe9f}, 
+    {0xea1, 0xea3}, {0xea5, 0xea5}, {0xea7, 0xea7}, {0xeaa, 0xeab}, 
+    {0xead, 0xeb0}, {0xeb2, 0xeb3}, {0xebd, 0xebd}, {0xec0, 0xec4}, 
+    {0xec6, 0xec6}, {0xedc, 0xedd}, {0xf00, 0xf00}, {0xf40, 0xf47}, 
+    {0xf49, 0xf6a}, {0xf88, 0xf8b}, {0x1000, 0x1021}, {0x1023, 0x1027}, 
+    {0x1029, 0x102a}, {0x1050, 0x1055}, {0x10a0, 0x10c5}, {0x10d0, 0x10f8}, 
+    {0x1100, 0x1159}, {0x115f, 0x11a2}, {0x11a8, 0x11f9}, {0x1200, 0x1206}, 
+    {0x1208, 0x1246}, {0x1248, 0x1248}, {0x124a, 0x124d}, {0x1250, 0x1256}, 
+    {0x1258, 0x1258}, {0x125a, 0x125d}, {0x1260, 0x1286}, {0x1288, 0x1288}, 
+    {0x128a, 0x128d}, {0x1290, 0x12ae}, {0x12b0, 0x12b0}, {0x12b2, 0x12b5}, 
+    {0x12b8, 0x12be}, {0x12c0, 0x12c0}, {0x12c2, 0x12c5}, {0x12c8, 0x12ce}, 
+    {0x12d0, 0x12d6}, {0x12d8, 0x12ee}, {0x12f0, 0x130e}, {0x1310, 0x1310}, 
+    {0x1312, 0x1315}, {0x1318, 0x131e}, {0x1320, 0x1346}, {0x1348, 0x135a}, 
+    {0x13a0, 0x13f4}, {0x1401, 0x166c}, {0x166f, 0x1676}, {0x1681, 0x169a}, 
+    {0x16a0, 0x16ea}, {0x1700, 0x170c}, {0x170e, 0x1711}, {0x1720, 0x1731}, 
+    {0x1740, 0x1751}, {0x1760, 0x176c}, {0x176e, 0x1770}, {0x1780, 0x17b3}, 
+    {0x17d7, 0x17d7}, {0x17dc, 0x17dc}, {0x1820, 0x1877}, {0x1880, 0x18a8}, 
+    {0x1900, 0x191c}, {0x1950, 0x196d}, {0x1970, 0x1974}, {0x1d00, 0x1d6b}, 
+    {0x1e00, 0x1e9b}, {0x1ea0, 0x1ef9}, {0x1f00, 0x1f15}, {0x1f18, 0x1f1d}, 
+    {0x1f20, 0x1f45}, {0x1f48, 0x1f4d}, {0x1f50, 0x1f57}, {0x1f59, 0x1f59}, 
+    {0x1f5b, 0x1f5b}, {0x1f5d, 0x1f5d}, {0x1f5f, 0x1f7d}, {0x1f80, 0x1fb4}, 
+    {0x1fb6, 0x1fbc}, {0x1fbe, 0x1fbe}, {0x1fc2, 0x1fc4}, {0x1fc6, 0x1fcc}, 
+    {0x1fd0, 0x1fd3}, {0x1fd6, 0x1fdb}, {0x1fe0, 0x1fec}, {0x1ff2, 0x1ff4}, 
+    {0x1ff6, 0x1ffc}, {0x2071, 0x2071}, {0x207f, 0x207f}, {0x2102, 0x2102}, 
+    {0x2107, 0x2107}, {0x210a, 0x2113}, {0x2115, 0x2115}, {0x2119, 0x211d}, 
+    {0x2124, 0x2124}, {0x2126, 0x2126}, {0x2128, 0x2128}, {0x212a, 0x212d}, 
+    {0x212f, 0x2131}, {0x2133, 0x2139}, {0x213d, 0x213f}, {0x2145, 0x2149}, 
+    {0x3005, 0x3006}, {0x3031, 0x3035}, {0x303b, 0x303c}, {0x3041, 0x3096}, 
+    {0x309d, 0x309f}, {0x30a1, 0x30fa}, {0x30fc, 0x30ff}, {0x3105, 0x312c}, 
+    {0x3131, 0x318e}, {0x31a0, 0x31b7}, {0x31f0, 0x31ff}, {0x3400, 0x3400}, 
+    {0x4db5, 0x4db5}, {0x4e00, 0x4e00}, {0x9fa5, 0x9fa5}, {0xa000, 0xa48c}, 
+    {0xac00, 0xac00}, {0xd7a3, 0xd7a3}, {0xf900, 0xfa2d}, {0xfa30, 0xfa6a}, 
+    {0xfb00, 0xfb06}, {0xfb13, 0xfb17}, {0xfb1d, 0xfb1d}, {0xfb1f, 0xfb28}, 
+    {0xfb2a, 0xfb36}, {0xfb38, 0xfb3c}, {0xfb3e, 0xfb3e}, {0xfb40, 0xfb41}, 
+    {0xfb43, 0xfb44}, {0xfb46, 0xfbb1}, {0xfbd3, 0xfd3d}, {0xfd50, 0xfd8f}, 
+    {0xfd92, 0xfdc7}, {0xfdf0, 0xfdfb}, {0xfe70, 0xfe74}, {0xfe76, 0xfefc}, 
+    {0xff21, 0xff3a}, {0xff41, 0xff5a}, {0xff66, 0xffbe}, {0xffc2, 0xffc7}, 
+    {0xffca, 0xffcf}, {0xffd2, 0xffd7}, {0xffda, 0xffdc} };
+static xmlChLRange xmlLL[] = {{0x10000, 0x1000b}, {0x1000d, 0x10026}, 
+    {0x10028, 0x1003a}, {0x1003c, 0x1003d}, {0x1003f, 0x1004d}, 
+    {0x10050, 0x1005d}, {0x10080, 0x100fa}, {0x10300, 0x1031e}, 
+    {0x10330, 0x10349}, {0x10380, 0x1039d}, {0x10400, 0x1049d}, 
+    {0x10800, 0x10805}, {0x10808, 0x10808}, {0x1080a, 0x10835}, 
+    {0x10837, 0x10838}, {0x1083c, 0x1083c}, {0x1083f, 0x1083f}, 
+    {0x1d400, 0x1d454}, {0x1d456, 0x1d49c}, {0x1d49e, 0x1d49f}, 
+    {0x1d4a2, 0x1d4a2}, {0x1d4a5, 0x1d4a6}, {0x1d4a9, 0x1d4ac}, 
+    {0x1d4ae, 0x1d4b9}, {0x1d4bb, 0x1d4bb}, {0x1d4bd, 0x1d4c3}, 
+    {0x1d4c5, 0x1d505}, {0x1d507, 0x1d50a}, {0x1d50d, 0x1d514}, 
+    {0x1d516, 0x1d51c}, {0x1d51e, 0x1d539}, {0x1d53b, 0x1d53e}, 
+    {0x1d540, 0x1d544}, {0x1d546, 0x1d546}, {0x1d54a, 0x1d550}, 
+    {0x1d552, 0x1d6a3}, {0x1d6a8, 0x1d6c0}, {0x1d6c2, 0x1d6da}, 
+    {0x1d6dc, 0x1d6fa}, {0x1d6fc, 0x1d714}, {0x1d716, 0x1d734}, 
+    {0x1d736, 0x1d74e}, {0x1d750, 0x1d76e}, {0x1d770, 0x1d788}, 
+    {0x1d78a, 0x1d7a8}, {0x1d7aa, 0x1d7c2}, {0x1d7c4, 0x1d7c9}, 
+    {0x20000, 0x20000}, {0x2a6d6, 0x2a6d6}, {0x2f800, 0x2fa1d} };
+static xmlChRangeGroup xmlLG = {279,50,xmlLS,xmlLL};
+
+static xmlChSRange xmlLlS[] = {{0x61, 0x7a}, {0xaa, 0xaa}, {0xb5, 0xb5}, 
+    {0xba, 0xba}, {0xdf, 0xf6}, {0xf8, 0xff}, {0x101, 0x101}, 
+    {0x103, 0x103}, {0x105, 0x105}, {0x107, 0x107}, {0x109, 0x109}, 
+    {0x10b, 0x10b}, {0x10d, 0x10d}, {0x10f, 0x10f}, {0x111, 0x111}, 
+    {0x113, 0x113}, {0x115, 0x115}, {0x117, 0x117}, {0x119, 0x119}, 
+    {0x11b, 0x11b}, {0x11d, 0x11d}, {0x11f, 0x11f}, {0x121, 0x121}, 
+    {0x123, 0x123}, {0x125, 0x125}, {0x127, 0x127}, {0x129, 0x129}, 
+    {0x12b, 0x12b}, {0x12d, 0x12d}, {0x12f, 0x12f}, {0x131, 0x131}, 
+    {0x133, 0x133}, {0x135, 0x135}, {0x137, 0x138}, {0x13a, 0x13a}, 
+    {0x13c, 0x13c}, {0x13e, 0x13e}, {0x140, 0x140}, {0x142, 0x142}, 
+    {0x144, 0x144}, {0x146, 0x146}, {0x148, 0x149}, {0x14b, 0x14b}, 
+    {0x14d, 0x14d}, {0x14f, 0x14f}, {0x151, 0x151}, {0x153, 0x153}, 
+    {0x155, 0x155}, {0x157, 0x157}, {0x159, 0x159}, {0x15b, 0x15b}, 
+    {0x15d, 0x15d}, {0x15f, 0x15f}, {0x161, 0x161}, {0x163, 0x163}, 
+    {0x165, 0x165}, {0x167, 0x167}, {0x169, 0x169}, {0x16b, 0x16b}, 
+    {0x16d, 0x16d}, {0x16f, 0x16f}, {0x171, 0x171}, {0x173, 0x173}, 
+    {0x175, 0x175}, {0x177, 0x177}, {0x17a, 0x17a}, {0x17c, 0x17c}, 
+    {0x17e, 0x180}, {0x183, 0x183}, {0x185, 0x185}, {0x188, 0x188}, 
+    {0x18c, 0x18d}, {0x192, 0x192}, {0x195, 0x195}, {0x199, 0x19b}, 
+    {0x19e, 0x19e}, {0x1a1, 0x1a1}, {0x1a3, 0x1a3}, {0x1a5, 0x1a5}, 
+    {0x1a8, 0x1a8}, {0x1aa, 0x1ab}, {0x1ad, 0x1ad}, {0x1b0, 0x1b0}, 
+    {0x1b4, 0x1b4}, {0x1b6, 0x1b6}, {0x1b9, 0x1ba}, {0x1bd, 0x1bf}, 
+    {0x1c6, 0x1c6}, {0x1c9, 0x1c9}, {0x1cc, 0x1cc}, {0x1ce, 0x1ce}, 
+    {0x1d0, 0x1d0}, {0x1d2, 0x1d2}, {0x1d4, 0x1d4}, {0x1d6, 0x1d6}, 
+    {0x1d8, 0x1d8}, {0x1da, 0x1da}, {0x1dc, 0x1dd}, {0x1df, 0x1df}, 
+    {0x1e1, 0x1e1}, {0x1e3, 0x1e3}, {0x1e5, 0x1e5}, {0x1e7, 0x1e7}, 
+    {0x1e9, 0x1e9}, {0x1eb, 0x1eb}, {0x1ed, 0x1ed}, {0x1ef, 0x1f0}, 
+    {0x1f3, 0x1f3}, {0x1f5, 0x1f5}, {0x1f9, 0x1f9}, {0x1fb, 0x1fb}, 
+    {0x1fd, 0x1fd}, {0x1ff, 0x1ff}, {0x201, 0x201}, {0x203, 0x203}, 
+    {0x205, 0x205}, {0x207, 0x207}, {0x209, 0x209}, {0x20b, 0x20b}, 
+    {0x20d, 0x20d}, {0x20f, 0x20f}, {0x211, 0x211}, {0x213, 0x213}, 
+    {0x215, 0x215}, {0x217, 0x217}, {0x219, 0x219}, {0x21b, 0x21b}, 
+    {0x21d, 0x21d}, {0x21f, 0x21f}, {0x221, 0x221}, {0x223, 0x223}, 
+    {0x225, 0x225}, {0x227, 0x227}, {0x229, 0x229}, {0x22b, 0x22b}, 
+    {0x22d, 0x22d}, {0x22f, 0x22f}, {0x231, 0x231}, {0x233, 0x236}, 
+    {0x250, 0x2af}, {0x390, 0x390}, {0x3ac, 0x3ce}, {0x3d0, 0x3d1}, 
+    {0x3d5, 0x3d7}, {0x3d9, 0x3d9}, {0x3db, 0x3db}, {0x3dd, 0x3dd}, 
+    {0x3df, 0x3df}, {0x3e1, 0x3e1}, {0x3e3, 0x3e3}, {0x3e5, 0x3e5}, 
+    {0x3e7, 0x3e7}, {0x3e9, 0x3e9}, {0x3eb, 0x3eb}, {0x3ed, 0x3ed}, 
+    {0x3ef, 0x3f3}, {0x3f5, 0x3f5}, {0x3f8, 0x3f8}, {0x3fb, 0x3fb}, 
+    {0x430, 0x45f}, {0x461, 0x461}, {0x463, 0x463}, {0x465, 0x465}, 
+    {0x467, 0x467}, {0x469, 0x469}, {0x46b, 0x46b}, {0x46d, 0x46d}, 
+    {0x46f, 0x46f}, {0x471, 0x471}, {0x473, 0x473}, {0x475, 0x475}, 
+    {0x477, 0x477}, {0x479, 0x479}, {0x47b, 0x47b}, {0x47d, 0x47d}, 
+    {0x47f, 0x47f}, {0x481, 0x481}, {0x48b, 0x48b}, {0x48d, 0x48d}, 
+    {0x48f, 0x48f}, {0x491, 0x491}, {0x493, 0x493}, {0x495, 0x495}, 
+    {0x497, 0x497}, {0x499, 0x499}, {0x49b, 0x49b}, {0x49d, 0x49d}, 
+    {0x49f, 0x49f}, {0x4a1, 0x4a1}, {0x4a3, 0x4a3}, {0x4a5, 0x4a5}, 
+    {0x4a7, 0x4a7}, {0x4a9, 0x4a9}, {0x4ab, 0x4ab}, {0x4ad, 0x4ad}, 
+    {0x4af, 0x4af}, {0x4b1, 0x4b1}, {0x4b3, 0x4b3}, {0x4b5, 0x4b5}, 
+    {0x4b7, 0x4b7}, {0x4b9, 0x4b9}, {0x4bb, 0x4bb}, {0x4bd, 0x4bd}, 
+    {0x4bf, 0x4bf}, {0x4c2, 0x4c2}, {0x4c4, 0x4c4}, {0x4c6, 0x4c6}, 
+    {0x4c8, 0x4c8}, {0x4ca, 0x4ca}, {0x4cc, 0x4cc}, {0x4ce, 0x4ce}, 
+    {0x4d1, 0x4d1}, {0x4d3, 0x4d3}, {0x4d5, 0x4d5}, {0x4d7, 0x4d7}, 
+    {0x4d9, 0x4d9}, {0x4db, 0x4db}, {0x4dd, 0x4dd}, {0x4df, 0x4df}, 
+    {0x4e1, 0x4e1}, {0x4e3, 0x4e3}, {0x4e5, 0x4e5}, {0x4e7, 0x4e7}, 
+    {0x4e9, 0x4e9}, {0x4eb, 0x4eb}, {0x4ed, 0x4ed}, {0x4ef, 0x4ef}, 
+    {0x4f1, 0x4f1}, {0x4f3, 0x4f3}, {0x4f5, 0x4f5}, {0x4f9, 0x4f9}, 
+    {0x501, 0x501}, {0x503, 0x503}, {0x505, 0x505}, {0x507, 0x507}, 
+    {0x509, 0x509}, {0x50b, 0x50b}, {0x50d, 0x50d}, {0x50f, 0x50f}, 
+    {0x561, 0x587}, {0x1d00, 0x1d2b}, {0x1d62, 0x1d6b}, {0x1e01, 0x1e01}, 
+    {0x1e03, 0x1e03}, {0x1e05, 0x1e05}, {0x1e07, 0x1e07}, {0x1e09, 0x1e09}, 
+    {0x1e0b, 0x1e0b}, {0x1e0d, 0x1e0d}, {0x1e0f, 0x1e0f}, {0x1e11, 0x1e11}, 
+    {0x1e13, 0x1e13}, {0x1e15, 0x1e15}, {0x1e17, 0x1e17}, {0x1e19, 0x1e19}, 
+    {0x1e1b, 0x1e1b}, {0x1e1d, 0x1e1d}, {0x1e1f, 0x1e1f}, {0x1e21, 0x1e21}, 
+    {0x1e23, 0x1e23}, {0x1e25, 0x1e25}, {0x1e27, 0x1e27}, {0x1e29, 0x1e29}, 
+    {0x1e2b, 0x1e2b}, {0x1e2d, 0x1e2d}, {0x1e2f, 0x1e2f}, {0x1e31, 0x1e31}, 
+    {0x1e33, 0x1e33}, {0x1e35, 0x1e35}, {0x1e37, 0x1e37}, {0x1e39, 0x1e39}, 
+    {0x1e3b, 0x1e3b}, {0x1e3d, 0x1e3d}, {0x1e3f, 0x1e3f}, {0x1e41, 0x1e41}, 
+    {0x1e43, 0x1e43}, {0x1e45, 0x1e45}, {0x1e47, 0x1e47}, {0x1e49, 0x1e49}, 
+    {0x1e4b, 0x1e4b}, {0x1e4d, 0x1e4d}, {0x1e4f, 0x1e4f}, {0x1e51, 0x1e51}, 
+    {0x1e53, 0x1e53}, {0x1e55, 0x1e55}, {0x1e57, 0x1e57}, {0x1e59, 0x1e59}, 
+    {0x1e5b, 0x1e5b}, {0x1e5d, 0x1e5d}, {0x1e5f, 0x1e5f}, {0x1e61, 0x1e61}, 
+    {0x1e63, 0x1e63}, {0x1e65, 0x1e65}, {0x1e67, 0x1e67}, {0x1e69, 0x1e69}, 
+    {0x1e6b, 0x1e6b}, {0x1e6d, 0x1e6d}, {0x1e6f, 0x1e6f}, {0x1e71, 0x1e71}, 
+    {0x1e73, 0x1e73}, {0x1e75, 0x1e75}, {0x1e77, 0x1e77}, {0x1e79, 0x1e79}, 
+    {0x1e7b, 0x1e7b}, {0x1e7d, 0x1e7d}, {0x1e7f, 0x1e7f}, {0x1e81, 0x1e81}, 
+    {0x1e83, 0x1e83}, {0x1e85, 0x1e85}, {0x1e87, 0x1e87}, {0x1e89, 0x1e89}, 
+    {0x1e8b, 0x1e8b}, {0x1e8d, 0x1e8d}, {0x1e8f, 0x1e8f}, {0x1e91, 0x1e91}, 
+    {0x1e93, 0x1e93}, {0x1e95, 0x1e9b}, {0x1ea1, 0x1ea1}, {0x1ea3, 0x1ea3}, 
+    {0x1ea5, 0x1ea5}, {0x1ea7, 0x1ea7}, {0x1ea9, 0x1ea9}, {0x1eab, 0x1eab}, 
+    {0x1ead, 0x1ead}, {0x1eaf, 0x1eaf}, {0x1eb1, 0x1eb1}, {0x1eb3, 0x1eb3}, 
+    {0x1eb5, 0x1eb5}, {0x1eb7, 0x1eb7}, {0x1eb9, 0x1eb9}, {0x1ebb, 0x1ebb}, 
+    {0x1ebd, 0x1ebd}, {0x1ebf, 0x1ebf}, {0x1ec1, 0x1ec1}, {0x1ec3, 0x1ec3}, 
+    {0x1ec5, 0x1ec5}, {0x1ec7, 0x1ec7}, {0x1ec9, 0x1ec9}, {0x1ecb, 0x1ecb}, 
+    {0x1ecd, 0x1ecd}, {0x1ecf, 0x1ecf}, {0x1ed1, 0x1ed1}, {0x1ed3, 0x1ed3}, 
+    {0x1ed5, 0x1ed5}, {0x1ed7, 0x1ed7}, {0x1ed9, 0x1ed9}, {0x1edb, 0x1edb}, 
+    {0x1edd, 0x1edd}, {0x1edf, 0x1edf}, {0x1ee1, 0x1ee1}, {0x1ee3, 0x1ee3}, 
+    {0x1ee5, 0x1ee5}, {0x1ee7, 0x1ee7}, {0x1ee9, 0x1ee9}, {0x1eeb, 0x1eeb}, 
+    {0x1eed, 0x1eed}, {0x1eef, 0x1eef}, {0x1ef1, 0x1ef1}, {0x1ef3, 0x1ef3}, 
+    {0x1ef5, 0x1ef5}, {0x1ef7, 0x1ef7}, {0x1ef9, 0x1ef9}, {0x1f00, 0x1f07}, 
+    {0x1f10, 0x1f15}, {0x1f20, 0x1f27}, {0x1f30, 0x1f37}, {0x1f40, 0x1f45}, 
+    {0x1f50, 0x1f57}, {0x1f60, 0x1f67}, {0x1f70, 0x1f7d}, {0x1f80, 0x1f87}, 
+    {0x1f90, 0x1f97}, {0x1fa0, 0x1fa7}, {0x1fb0, 0x1fb4}, {0x1fb6, 0x1fb7}, 
+    {0x1fbe, 0x1fbe}, {0x1fc2, 0x1fc4}, {0x1fc6, 0x1fc7}, {0x1fd0, 0x1fd3}, 
+    {0x1fd6, 0x1fd7}, {0x1fe0, 0x1fe7}, {0x1ff2, 0x1ff4}, {0x1ff6, 0x1ff7}, 
+    {0x2071, 0x2071}, {0x207f, 0x207f}, {0x210a, 0x210a}, {0x210e, 0x210f}, 
+    {0x2113, 0x2113}, {0x212f, 0x212f}, {0x2134, 0x2134}, {0x2139, 0x2139}, 
+    {0x213d, 0x213d}, {0x2146, 0x2149}, {0xfb00, 0xfb06}, {0xfb13, 0xfb17}, 
+    {0xff41, 0xff5a} };
+static xmlChLRange xmlLlL[] = {{0x10428, 0x1044f}, {0x1d41a, 0x1d433}, 
+    {0x1d44e, 0x1d454}, {0x1d456, 0x1d467}, {0x1d482, 0x1d49b}, 
+    {0x1d4b6, 0x1d4b9}, {0x1d4bb, 0x1d4bb}, {0x1d4bd, 0x1d4c3}, 
+    {0x1d4c5, 0x1d4cf}, {0x1d4ea, 0x1d503}, {0x1d51e, 0x1d537}, 
+    {0x1d552, 0x1d56b}, {0x1d586, 0x1d59f}, {0x1d5ba, 0x1d5d3}, 
+    {0x1d5ee, 0x1d607}, {0x1d622, 0x1d63b}, {0x1d656, 0x1d66f}, 
+    {0x1d68a, 0x1d6a3}, {0x1d6c2, 0x1d6da}, {0x1d6dc, 0x1d6e1}, 
+    {0x1d6fc, 0x1d714}, {0x1d716, 0x1d71b}, {0x1d736, 0x1d74e}, 
+    {0x1d750, 0x1d755}, {0x1d770, 0x1d788}, {0x1d78a, 0x1d78f}, 
+    {0x1d7aa, 0x1d7c2}, {0x1d7c4, 0x1d7c9} };
+static xmlChRangeGroup xmlLlG = {396,28,xmlLlS,xmlLlL};
+
+static xmlChSRange xmlLmS[] = {{0x2b0, 0x2c1}, {0x2c6, 0x2d1}, 
+    {0x2e0, 0x2e4}, {0x2ee, 0x2ee}, {0x37a, 0x37a}, {0x559, 0x559}, 
+    {0x640, 0x640}, {0x6e5, 0x6e6}, {0xe46, 0xe46}, {0xec6, 0xec6}, 
+    {0x17d7, 0x17d7}, {0x1843, 0x1843}, {0x1d2c, 0x1d61}, {0x3005, 0x3005}, 
+    {0x3031, 0x3035}, {0x303b, 0x303b}, {0x309d, 0x309e}, {0x30fc, 0x30fe}, 
+    {0xff70, 0xff70}, {0xff9e, 0xff9f} };
+static xmlChRangeGroup xmlLmG = {20,0,xmlLmS,NULL};
+
+static xmlChSRange xmlLoS[] = {{0x1bb, 0x1bb}, {0x1c0, 0x1c3}, 
+    {0x5d0, 0x5ea}, {0x5f0, 0x5f2}, {0x621, 0x63a}, {0x641, 0x64a}, 
+    {0x66e, 0x66f}, {0x671, 0x6d3}, {0x6d5, 0x6d5}, {0x6ee, 0x6ef}, 
+    {0x6fa, 0x6fc}, {0x6ff, 0x6ff}, {0x710, 0x710}, {0x712, 0x72f}, 
+    {0x74d, 0x74f}, {0x780, 0x7a5}, {0x7b1, 0x7b1}, {0x904, 0x939}, 
+    {0x93d, 0x93d}, {0x950, 0x950}, {0x958, 0x961}, {0x985, 0x98c}, 
+    {0x98f, 0x990}, {0x993, 0x9a8}, {0x9aa, 0x9b0}, {0x9b2, 0x9b2}, 
+    {0x9b6, 0x9b9}, {0x9bd, 0x9bd}, {0x9dc, 0x9dd}, {0x9df, 0x9e1}, 
+    {0x9f0, 0x9f1}, {0xa05, 0xa0a}, {0xa0f, 0xa10}, {0xa13, 0xa28}, 
+    {0xa2a, 0xa30}, {0xa32, 0xa33}, {0xa35, 0xa36}, {0xa38, 0xa39}, 
+    {0xa59, 0xa5c}, {0xa5e, 0xa5e}, {0xa72, 0xa74}, {0xa85, 0xa8d}, 
+    {0xa8f, 0xa91}, {0xa93, 0xaa8}, {0xaaa, 0xab0}, {0xab2, 0xab3}, 
+    {0xab5, 0xab9}, {0xabd, 0xabd}, {0xad0, 0xad0}, {0xae0, 0xae1}, 
+    {0xb05, 0xb0c}, {0xb0f, 0xb10}, {0xb13, 0xb28}, {0xb2a, 0xb30}, 
+    {0xb32, 0xb33}, {0xb35, 0xb39}, {0xb3d, 0xb3d}, {0xb5c, 0xb5d}, 
+    {0xb5f, 0xb61}, {0xb71, 0xb71}, {0xb83, 0xb83}, {0xb85, 0xb8a}, 
+    {0xb8e, 0xb90}, {0xb92, 0xb95}, {0xb99, 0xb9a}, {0xb9c, 0xb9c}, 
+    {0xb9e, 0xb9f}, {0xba3, 0xba4}, {0xba8, 0xbaa}, {0xbae, 0xbb5}, 
+    {0xbb7, 0xbb9}, {0xc05, 0xc0c}, {0xc0e, 0xc10}, {0xc12, 0xc28}, 
+    {0xc2a, 0xc33}, {0xc35, 0xc39}, {0xc60, 0xc61}, {0xc85, 0xc8c}, 
+    {0xc8e, 0xc90}, {0xc92, 0xca8}, {0xcaa, 0xcb3}, {0xcb5, 0xcb9}, 
+    {0xcbd, 0xcbd}, {0xcde, 0xcde}, {0xce0, 0xce1}, {0xd05, 0xd0c}, 
+    {0xd0e, 0xd10}, {0xd12, 0xd28}, {0xd2a, 0xd39}, {0xd60, 0xd61}, 
+    {0xd85, 0xd96}, {0xd9a, 0xdb1}, {0xdb3, 0xdbb}, {0xdbd, 0xdbd}, 
+    {0xdc0, 0xdc6}, {0xe01, 0xe30}, {0xe32, 0xe33}, {0xe40, 0xe45}, 
+    {0xe81, 0xe82}, {0xe84, 0xe84}, {0xe87, 0xe88}, {0xe8a, 0xe8a}, 
+    {0xe8d, 0xe8d}, {0xe94, 0xe97}, {0xe99, 0xe9f}, {0xea1, 0xea3}, 
+    {0xea5, 0xea5}, {0xea7, 0xea7}, {0xeaa, 0xeab}, {0xead, 0xeb0}, 
+    {0xeb2, 0xeb3}, {0xebd, 0xebd}, {0xec0, 0xec4}, {0xedc, 0xedd}, 
+    {0xf00, 0xf00}, {0xf40, 0xf47}, {0xf49, 0xf6a}, {0xf88, 0xf8b}, 
+    {0x1000, 0x1021}, {0x1023, 0x1027}, {0x1029, 0x102a}, {0x1050, 0x1055}, 
+    {0x10d0, 0x10f8}, {0x1100, 0x1159}, {0x115f, 0x11a2}, {0x11a8, 0x11f9}, 
+    {0x1200, 0x1206}, {0x1208, 0x1246}, {0x1248, 0x1248}, {0x124a, 0x124d}, 
+    {0x1250, 0x1256}, {0x1258, 0x1258}, {0x125a, 0x125d}, {0x1260, 0x1286}, 
+    {0x1288, 0x1288}, {0x128a, 0x128d}, {0x1290, 0x12ae}, {0x12b0, 0x12b0}, 
+    {0x12b2, 0x12b5}, {0x12b8, 0x12be}, {0x12c0, 0x12c0}, {0x12c2, 0x12c5}, 
+    {0x12c8, 0x12ce}, {0x12d0, 0x12d6}, {0x12d8, 0x12ee}, {0x12f0, 0x130e}, 
+    {0x1310, 0x1310}, {0x1312, 0x1315}, {0x1318, 0x131e}, {0x1320, 0x1346}, 
+    {0x1348, 0x135a}, {0x13a0, 0x13f4}, {0x1401, 0x166c}, {0x166f, 0x1676}, 
+    {0x1681, 0x169a}, {0x16a0, 0x16ea}, {0x1700, 0x170c}, {0x170e, 0x1711}, 
+    {0x1720, 0x1731}, {0x1740, 0x1751}, {0x1760, 0x176c}, {0x176e, 0x1770}, 
+    {0x1780, 0x17b3}, {0x17dc, 0x17dc}, {0x1820, 0x1842}, {0x1844, 0x1877}, 
+    {0x1880, 0x18a8}, {0x1900, 0x191c}, {0x1950, 0x196d}, {0x1970, 0x1974}, 
+    {0x2135, 0x2138}, {0x3006, 0x3006}, {0x303c, 0x303c}, {0x3041, 0x3096}, 
+    {0x309f, 0x309f}, {0x30a1, 0x30fa}, {0x30ff, 0x30ff}, {0x3105, 0x312c}, 
+    {0x3131, 0x318e}, {0x31a0, 0x31b7}, {0x31f0, 0x31ff}, {0x3400, 0x3400}, 
+    {0x4db5, 0x4db5}, {0x4e00, 0x4e00}, {0x9fa5, 0x9fa5}, {0xa000, 0xa48c}, 
+    {0xac00, 0xac00}, {0xd7a3, 0xd7a3}, {0xf900, 0xfa2d}, {0xfa30, 0xfa6a}, 
+    {0xfb1d, 0xfb1d}, {0xfb1f, 0xfb28}, {0xfb2a, 0xfb36}, {0xfb38, 0xfb3c}, 
+    {0xfb3e, 0xfb3e}, {0xfb40, 0xfb41}, {0xfb43, 0xfb44}, {0xfb46, 0xfbb1}, 
+    {0xfbd3, 0xfd3d}, {0xfd50, 0xfd8f}, {0xfd92, 0xfdc7}, {0xfdf0, 0xfdfb}, 
+    {0xfe70, 0xfe74}, {0xfe76, 0xfefc}, {0xff66, 0xff6f}, {0xff71, 0xff9d}, 
+    {0xffa0, 0xffbe}, {0xffc2, 0xffc7}, {0xffca, 0xffcf}, {0xffd2, 0xffd7}, 
+    {0xffda, 0xffdc} };
+static xmlChLRange xmlLoL[] = {{0x10000, 0x1000b}, {0x1000d, 0x10026}, 
+    {0x10028, 0x1003a}, {0x1003c, 0x1003d}, {0x1003f, 0x1004d}, 
+    {0x10050, 0x1005d}, {0x10080, 0x100fa}, {0x10300, 0x1031e}, 
+    {0x10330, 0x10349}, {0x10380, 0x1039d}, {0x10450, 0x1049d}, 
+    {0x10800, 0x10805}, {0x10808, 0x10808}, {0x1080a, 0x10835}, 
+    {0x10837, 0x10838}, {0x1083c, 0x1083c}, {0x1083f, 0x1083f}, 
+    {0x20000, 0x20000}, {0x2a6d6, 0x2a6d6}, {0x2f800, 0x2fa1d} };
+static xmlChRangeGroup xmlLoG = {211,20,xmlLoS,xmlLoL};
+
+static xmlChSRange xmlLtS[] = {{0x1c5, 0x1c5}, {0x1c8, 0x1c8}, 
+    {0x1cb, 0x1cb}, {0x1f2, 0x1f2}, {0x1f88, 0x1f8f}, {0x1f98, 0x1f9f}, 
+    {0x1fa8, 0x1faf}, {0x1fbc, 0x1fbc}, {0x1fcc, 0x1fcc}, {0x1ffc, 0x1ffc} };
+static xmlChRangeGroup xmlLtG = {10,0,xmlLtS,NULL};
+
+static xmlChSRange xmlLuS[] = {{0x41, 0x5a}, {0xc0, 0xd6}, {0xd8, 0xde}, 
+    {0x100, 0x100}, {0x102, 0x102}, {0x104, 0x104}, {0x106, 0x106}, 
+    {0x108, 0x108}, {0x10a, 0x10a}, {0x10c, 0x10c}, {0x10e, 0x10e}, 
+    {0x110, 0x110}, {0x112, 0x112}, {0x114, 0x114}, {0x116, 0x116}, 
+    {0x118, 0x118}, {0x11a, 0x11a}, {0x11c, 0x11c}, {0x11e, 0x11e}, 
+    {0x120, 0x120}, {0x122, 0x122}, {0x124, 0x124}, {0x126, 0x126}, 
+    {0x128, 0x128}, {0x12a, 0x12a}, {0x12c, 0x12c}, {0x12e, 0x12e}, 
+    {0x130, 0x130}, {0x132, 0x132}, {0x134, 0x134}, {0x136, 0x136}, 
+    {0x139, 0x139}, {0x13b, 0x13b}, {0x13d, 0x13d}, {0x13f, 0x13f}, 
+    {0x141, 0x141}, {0x143, 0x143}, {0x145, 0x145}, {0x147, 0x147}, 
+    {0x14a, 0x14a}, {0x14c, 0x14c}, {0x14e, 0x14e}, {0x150, 0x150}, 
+    {0x152, 0x152}, {0x154, 0x154}, {0x156, 0x156}, {0x158, 0x158}, 
+    {0x15a, 0x15a}, {0x15c, 0x15c}, {0x15e, 0x15e}, {0x160, 0x160}, 
+    {0x162, 0x162}, {0x164, 0x164}, {0x166, 0x166}, {0x168, 0x168}, 
+    {0x16a, 0x16a}, {0x16c, 0x16c}, {0x16e, 0x16e}, {0x170, 0x170}, 
+    {0x172, 0x172}, {0x174, 0x174}, {0x176, 0x176}, {0x178, 0x179}, 
+    {0x17b, 0x17b}, {0x17d, 0x17d}, {0x181, 0x182}, {0x184, 0x184}, 
+    {0x186, 0x187}, {0x189, 0x18b}, {0x18e, 0x191}, {0x193, 0x194}, 
+    {0x196, 0x198}, {0x19c, 0x19d}, {0x19f, 0x1a0}, {0x1a2, 0x1a2}, 
+    {0x1a4, 0x1a4}, {0x1a6, 0x1a7}, {0x1a9, 0x1a9}, {0x1ac, 0x1ac}, 
+    {0x1ae, 0x1af}, {0x1b1, 0x1b3}, {0x1b5, 0x1b5}, {0x1b7, 0x1b8}, 
+    {0x1bc, 0x1bc}, {0x1c4, 0x1c4}, {0x1c7, 0x1c7}, {0x1ca, 0x1ca}, 
+    {0x1cd, 0x1cd}, {0x1cf, 0x1cf}, {0x1d1, 0x1d1}, {0x1d3, 0x1d3}, 
+    {0x1d5, 0x1d5}, {0x1d7, 0x1d7}, {0x1d9, 0x1d9}, {0x1db, 0x1db}, 
+    {0x1de, 0x1de}, {0x1e0, 0x1e0}, {0x1e2, 0x1e2}, {0x1e4, 0x1e4}, 
+    {0x1e6, 0x1e6}, {0x1e8, 0x1e8}, {0x1ea, 0x1ea}, {0x1ec, 0x1ec}, 
+    {0x1ee, 0x1ee}, {0x1f1, 0x1f1}, {0x1f4, 0x1f4}, {0x1f6, 0x1f8}, 
+    {0x1fa, 0x1fa}, {0x1fc, 0x1fc}, {0x1fe, 0x1fe}, {0x200, 0x200}, 
+    {0x202, 0x202}, {0x204, 0x204}, {0x206, 0x206}, {0x208, 0x208}, 
+    {0x20a, 0x20a}, {0x20c, 0x20c}, {0x20e, 0x20e}, {0x210, 0x210}, 
+    {0x212, 0x212}, {0x214, 0x214}, {0x216, 0x216}, {0x218, 0x218}, 
+    {0x21a, 0x21a}, {0x21c, 0x21c}, {0x21e, 0x21e}, {0x220, 0x220}, 
+    {0x222, 0x222}, {0x224, 0x224}, {0x226, 0x226}, {0x228, 0x228}, 
+    {0x22a, 0x22a}, {0x22c, 0x22c}, {0x22e, 0x22e}, {0x230, 0x230}, 
+    {0x232, 0x232}, {0x386, 0x386}, {0x388, 0x38a}, {0x38c, 0x38c}, 
+    {0x38e, 0x38f}, {0x391, 0x3a1}, {0x3a3, 0x3ab}, {0x3d2, 0x3d4}, 
+    {0x3d8, 0x3d8}, {0x3da, 0x3da}, {0x3dc, 0x3dc}, {0x3de, 0x3de}, 
+    {0x3e0, 0x3e0}, {0x3e2, 0x3e2}, {0x3e4, 0x3e4}, {0x3e6, 0x3e6}, 
+    {0x3e8, 0x3e8}, {0x3ea, 0x3ea}, {0x3ec, 0x3ec}, {0x3ee, 0x3ee}, 
+    {0x3f4, 0x3f4}, {0x3f7, 0x3f7}, {0x3f9, 0x3fa}, {0x400, 0x42f}, 
+    {0x460, 0x460}, {0x462, 0x462}, {0x464, 0x464}, {0x466, 0x466}, 
+    {0x468, 0x468}, {0x46a, 0x46a}, {0x46c, 0x46c}, {0x46e, 0x46e}, 
+    {0x470, 0x470}, {0x472, 0x472}, {0x474, 0x474}, {0x476, 0x476}, 
+    {0x478, 0x478}, {0x47a, 0x47a}, {0x47c, 0x47c}, {0x47e, 0x47e}, 
+    {0x480, 0x480}, {0x48a, 0x48a}, {0x48c, 0x48c}, {0x48e, 0x48e}, 
+    {0x490, 0x490}, {0x492, 0x492}, {0x494, 0x494}, {0x496, 0x496}, 
+    {0x498, 0x498}, {0x49a, 0x49a}, {0x49c, 0x49c}, {0x49e, 0x49e}, 
+    {0x4a0, 0x4a0}, {0x4a2, 0x4a2}, {0x4a4, 0x4a4}, {0x4a6, 0x4a6}, 
+    {0x4a8, 0x4a8}, {0x4aa, 0x4aa}, {0x4ac, 0x4ac}, {0x4ae, 0x4ae}, 
+    {0x4b0, 0x4b0}, {0x4b2, 0x4b2}, {0x4b4, 0x4b4}, {0x4b6, 0x4b6}, 
+    {0x4b8, 0x4b8}, {0x4ba, 0x4ba}, {0x4bc, 0x4bc}, {0x4be, 0x4be}, 
+    {0x4c0, 0x4c1}, {0x4c3, 0x4c3}, {0x4c5, 0x4c5}, {0x4c7, 0x4c7}, 
+    {0x4c9, 0x4c9}, {0x4cb, 0x4cb}, {0x4cd, 0x4cd}, {0x4d0, 0x4d0}, 
+    {0x4d2, 0x4d2}, {0x4d4, 0x4d4}, {0x4d6, 0x4d6}, {0x4d8, 0x4d8}, 
+    {0x4da, 0x4da}, {0x4dc, 0x4dc}, {0x4de, 0x4de}, {0x4e0, 0x4e0}, 
+    {0x4e2, 0x4e2}, {0x4e4, 0x4e4}, {0x4e6, 0x4e6}, {0x4e8, 0x4e8}, 
+    {0x4ea, 0x4ea}, {0x4ec, 0x4ec}, {0x4ee, 0x4ee}, {0x4f0, 0x4f0}, 
+    {0x4f2, 0x4f2}, {0x4f4, 0x4f4}, {0x4f8, 0x4f8}, {0x500, 0x500}, 
+    {0x502, 0x502}, {0x504, 0x504}, {0x506, 0x506}, {0x508, 0x508}, 
+    {0x50a, 0x50a}, {0x50c, 0x50c}, {0x50e, 0x50e}, {0x531, 0x556}, 
+    {0x10a0, 0x10c5}, {0x1e00, 0x1e00}, {0x1e02, 0x1e02}, {0x1e04, 0x1e04}, 
+    {0x1e06, 0x1e06}, {0x1e08, 0x1e08}, {0x1e0a, 0x1e0a}, {0x1e0c, 0x1e0c}, 
+    {0x1e0e, 0x1e0e}, {0x1e10, 0x1e10}, {0x1e12, 0x1e12}, {0x1e14, 0x1e14}, 
+    {0x1e16, 0x1e16}, {0x1e18, 0x1e18}, {0x1e1a, 0x1e1a}, {0x1e1c, 0x1e1c}, 
+    {0x1e1e, 0x1e1e}, {0x1e20, 0x1e20}, {0x1e22, 0x1e22}, {0x1e24, 0x1e24}, 
+    {0x1e26, 0x1e26}, {0x1e28, 0x1e28}, {0x1e2a, 0x1e2a}, {0x1e2c, 0x1e2c}, 
+    {0x1e2e, 0x1e2e}, {0x1e30, 0x1e30}, {0x1e32, 0x1e32}, {0x1e34, 0x1e34}, 
+    {0x1e36, 0x1e36}, {0x1e38, 0x1e38}, {0x1e3a, 0x1e3a}, {0x1e3c, 0x1e3c}, 
+    {0x1e3e, 0x1e3e}, {0x1e40, 0x1e40}, {0x1e42, 0x1e42}, {0x1e44, 0x1e44}, 
+    {0x1e46, 0x1e46}, {0x1e48, 0x1e48}, {0x1e4a, 0x1e4a}, {0x1e4c, 0x1e4c}, 
+    {0x1e4e, 0x1e4e}, {0x1e50, 0x1e50}, {0x1e52, 0x1e52}, {0x1e54, 0x1e54}, 
+    {0x1e56, 0x1e56}, {0x1e58, 0x1e58}, {0x1e5a, 0x1e5a}, {0x1e5c, 0x1e5c}, 
+    {0x1e5e, 0x1e5e}, {0x1e60, 0x1e60}, {0x1e62, 0x1e62}, {0x1e64, 0x1e64}, 
+    {0x1e66, 0x1e66}, {0x1e68, 0x1e68}, {0x1e6a, 0x1e6a}, {0x1e6c, 0x1e6c}, 
+    {0x1e6e, 0x1e6e}, {0x1e70, 0x1e70}, {0x1e72, 0x1e72}, {0x1e74, 0x1e74}, 
+    {0x1e76, 0x1e76}, {0x1e78, 0x1e78}, {0x1e7a, 0x1e7a}, {0x1e7c, 0x1e7c}, 
+    {0x1e7e, 0x1e7e}, {0x1e80, 0x1e80}, {0x1e82, 0x1e82}, {0x1e84, 0x1e84}, 
+    {0x1e86, 0x1e86}, {0x1e88, 0x1e88}, {0x1e8a, 0x1e8a}, {0x1e8c, 0x1e8c}, 
+    {0x1e8e, 0x1e8e}, {0x1e90, 0x1e90}, {0x1e92, 0x1e92}, {0x1e94, 0x1e94}, 
+    {0x1ea0, 0x1ea0}, {0x1ea2, 0x1ea2}, {0x1ea4, 0x1ea4}, {0x1ea6, 0x1ea6}, 
+    {0x1ea8, 0x1ea8}, {0x1eaa, 0x1eaa}, {0x1eac, 0x1eac}, {0x1eae, 0x1eae}, 
+    {0x1eb0, 0x1eb0}, {0x1eb2, 0x1eb2}, {0x1eb4, 0x1eb4}, {0x1eb6, 0x1eb6}, 
+    {0x1eb8, 0x1eb8}, {0x1eba, 0x1eba}, {0x1ebc, 0x1ebc}, {0x1ebe, 0x1ebe}, 
+    {0x1ec0, 0x1ec0}, {0x1ec2, 0x1ec2}, {0x1ec4, 0x1ec4}, {0x1ec6, 0x1ec6}, 
+    {0x1ec8, 0x1ec8}, {0x1eca, 0x1eca}, {0x1ecc, 0x1ecc}, {0x1ece, 0x1ece}, 
+    {0x1ed0, 0x1ed0}, {0x1ed2, 0x1ed2}, {0x1ed4, 0x1ed4}, {0x1ed6, 0x1ed6}, 
+    {0x1ed8, 0x1ed8}, {0x1eda, 0x1eda}, {0x1edc, 0x1edc}, {0x1ede, 0x1ede}, 
+    {0x1ee0, 0x1ee0}, {0x1ee2, 0x1ee2}, {0x1ee4, 0x1ee4}, {0x1ee6, 0x1ee6}, 
+    {0x1ee8, 0x1ee8}, {0x1eea, 0x1eea}, {0x1eec, 0x1eec}, {0x1eee, 0x1eee}, 
+    {0x1ef0, 0x1ef0}, {0x1ef2, 0x1ef2}, {0x1ef4, 0x1ef4}, {0x1ef6, 0x1ef6}, 
+    {0x1ef8, 0x1ef8}, {0x1f08, 0x1f0f}, {0x1f18, 0x1f1d}, {0x1f28, 0x1f2f}, 
+    {0x1f38, 0x1f3f}, {0x1f48, 0x1f4d}, {0x1f59, 0x1f59}, {0x1f5b, 0x1f5b}, 
+    {0x1f5d, 0x1f5d}, {0x1f5f, 0x1f5f}, {0x1f68, 0x1f6f}, {0x1fb8, 0x1fbb}, 
+    {0x1fc8, 0x1fcb}, {0x1fd8, 0x1fdb}, {0x1fe8, 0x1fec}, {0x1ff8, 0x1ffb}, 
+    {0x2102, 0x2102}, {0x2107, 0x2107}, {0x210b, 0x210d}, {0x2110, 0x2112}, 
+    {0x2115, 0x2115}, {0x2119, 0x211d}, {0x2124, 0x2124}, {0x2126, 0x2126}, 
+    {0x2128, 0x2128}, {0x212a, 0x212d}, {0x2130, 0x2131}, {0x2133, 0x2133}, 
+    {0x213e, 0x213f}, {0x2145, 0x2145}, {0xff21, 0xff3a} };
+static xmlChLRange xmlLuL[] = {{0x10400, 0x10427}, {0x1d400, 0x1d419}, 
+    {0x1d434, 0x1d44d}, {0x1d468, 0x1d481}, {0x1d49c, 0x1d49c}, 
+    {0x1d49e, 0x1d49f}, {0x1d4a2, 0x1d4a2}, {0x1d4a5, 0x1d4a6}, 
+    {0x1d4a9, 0x1d4ac}, {0x1d4ae, 0x1d4b5}, {0x1d4d0, 0x1d4e9}, 
+    {0x1d504, 0x1d505}, {0x1d507, 0x1d50a}, {0x1d50d, 0x1d514}, 
+    {0x1d516, 0x1d51c}, {0x1d538, 0x1d539}, {0x1d53b, 0x1d53e}, 
+    {0x1d540, 0x1d544}, {0x1d546, 0x1d546}, {0x1d54a, 0x1d550}, 
+    {0x1d56c, 0x1d585}, {0x1d5a0, 0x1d5b9}, {0x1d5d4, 0x1d5ed}, 
+    {0x1d608, 0x1d621}, {0x1d63c, 0x1d655}, {0x1d670, 0x1d689}, 
+    {0x1d6a8, 0x1d6c0}, {0x1d6e2, 0x1d6fa}, {0x1d71c, 0x1d734}, 
+    {0x1d756, 0x1d76e}, {0x1d790, 0x1d7a8} };
+static xmlChRangeGroup xmlLuG = {390,31,xmlLuS,xmlLuL};
+
+static xmlChSRange xmlMS[] = {{0x300, 0x357}, {0x35d, 0x36f}, 
+    {0x483, 0x486}, {0x488, 0x489}, {0x591, 0x5a1}, {0x5a3, 0x5b9}, 
+    {0x5bb, 0x5bd}, {0x5bf, 0x5bf}, {0x5c1, 0x5c2}, {0x5c4, 0x5c4}, 
+    {0x610, 0x615}, {0x64b, 0x658}, {0x670, 0x670}, {0x6d6, 0x6dc}, 
+    {0x6de, 0x6e4}, {0x6e7, 0x6e8}, {0x6ea, 0x6ed}, {0x711, 0x711}, 
+    {0x730, 0x74a}, {0x7a6, 0x7b0}, {0x901, 0x903}, {0x93c, 0x93c}, 
+    {0x93e, 0x94d}, {0x951, 0x954}, {0x962, 0x963}, {0x981, 0x983}, 
+    {0x9bc, 0x9bc}, {0x9be, 0x9c4}, {0x9c7, 0x9c8}, {0x9cb, 0x9cd}, 
+    {0x9d7, 0x9d7}, {0x9e2, 0x9e3}, {0xa01, 0xa03}, {0xa3c, 0xa3c}, 
+    {0xa3e, 0xa42}, {0xa47, 0xa48}, {0xa4b, 0xa4d}, {0xa70, 0xa71}, 
+    {0xa81, 0xa83}, {0xabc, 0xabc}, {0xabe, 0xac5}, {0xac7, 0xac9}, 
+    {0xacb, 0xacd}, {0xae2, 0xae3}, {0xb01, 0xb03}, {0xb3c, 0xb3c}, 
+    {0xb3e, 0xb43}, {0xb47, 0xb48}, {0xb4b, 0xb4d}, {0xb56, 0xb57}, 
+    {0xb82, 0xb82}, {0xbbe, 0xbc2}, {0xbc6, 0xbc8}, {0xbca, 0xbcd}, 
+    {0xbd7, 0xbd7}, {0xc01, 0xc03}, {0xc3e, 0xc44}, {0xc46, 0xc48}, 
+    {0xc4a, 0xc4d}, {0xc55, 0xc56}, {0xc82, 0xc83}, {0xcbc, 0xcbc}, 
+    {0xcbe, 0xcc4}, {0xcc6, 0xcc8}, {0xcca, 0xccd}, {0xcd5, 0xcd6}, 
+    {0xd02, 0xd03}, {0xd3e, 0xd43}, {0xd46, 0xd48}, {0xd4a, 0xd4d}, 
+    {0xd57, 0xd57}, {0xd82, 0xd83}, {0xdca, 0xdca}, {0xdcf, 0xdd4}, 
+    {0xdd6, 0xdd6}, {0xdd8, 0xddf}, {0xdf2, 0xdf3}, {0xe31, 0xe31}, 
+    {0xe34, 0xe3a}, {0xe47, 0xe4e}, {0xeb1, 0xeb1}, {0xeb4, 0xeb9}, 
+    {0xebb, 0xebc}, {0xec8, 0xecd}, {0xf18, 0xf19}, {0xf35, 0xf35}, 
+    {0xf37, 0xf37}, {0xf39, 0xf39}, {0xf3e, 0xf3f}, {0xf71, 0xf84}, 
+    {0xf86, 0xf87}, {0xf90, 0xf97}, {0xf99, 0xfbc}, {0xfc6, 0xfc6}, 
+    {0x102c, 0x1032}, {0x1036, 0x1039}, {0x1056, 0x1059}, {0x1712, 0x1714}, 
+    {0x1732, 0x1734}, {0x1752, 0x1753}, {0x1772, 0x1773}, {0x17b6, 0x17d3}, 
+    {0x17dd, 0x17dd}, {0x180b, 0x180d}, {0x18a9, 0x18a9}, {0x1920, 0x192b}, 
+    {0x1930, 0x193b}, {0x20d0, 0x20ea}, {0x302a, 0x302f}, {0x3099, 0x309a}, 
+    {0xfb1e, 0xfb1e}, {0xfe00, 0xfe0f}, {0xfe20, 0xfe23} };
+static xmlChLRange xmlML[] = {{0x1d165, 0x1d169}, {0x1d16d, 0x1d172}, 
+    {0x1d17b, 0x1d182}, {0x1d185, 0x1d18b}, {0x1d1aa, 0x1d1ad}, 
+    {0xe0100, 0xe01ef} };
+static xmlChRangeGroup xmlMG = {113,6,xmlMS,xmlML};
+
+static xmlChSRange xmlMcS[] = {{0x903, 0x903}, {0x93e, 0x940}, 
+    {0x949, 0x94c}, {0x982, 0x983}, {0x9be, 0x9c0}, {0x9c7, 0x9c8}, 
+    {0x9cb, 0x9cc}, {0x9d7, 0x9d7}, {0xa03, 0xa03}, {0xa3e, 0xa40}, 
+    {0xa83, 0xa83}, {0xabe, 0xac0}, {0xac9, 0xac9}, {0xacb, 0xacc}, 
+    {0xb02, 0xb03}, {0xb3e, 0xb3e}, {0xb40, 0xb40}, {0xb47, 0xb48}, 
+    {0xb4b, 0xb4c}, {0xb57, 0xb57}, {0xbbe, 0xbbf}, {0xbc1, 0xbc2}, 
+    {0xbc6, 0xbc8}, {0xbca, 0xbcc}, {0xbd7, 0xbd7}, {0xc01, 0xc03}, 
+    {0xc41, 0xc44}, {0xc82, 0xc83}, {0xcbe, 0xcbe}, {0xcc0, 0xcc4}, 
+    {0xcc7, 0xcc8}, {0xcca, 0xccb}, {0xcd5, 0xcd6}, {0xd02, 0xd03}, 
+    {0xd3e, 0xd40}, {0xd46, 0xd48}, {0xd4a, 0xd4c}, {0xd57, 0xd57}, 
+    {0xd82, 0xd83}, {0xdcf, 0xdd1}, {0xdd8, 0xddf}, {0xdf2, 0xdf3}, 
+    {0xf3e, 0xf3f}, {0xf7f, 0xf7f}, {0x102c, 0x102c}, {0x1031, 0x1031}, 
+    {0x1038, 0x1038}, {0x1056, 0x1057}, {0x17b6, 0x17b6}, {0x17be, 0x17c5}, 
+    {0x17c7, 0x17c8}, {0x1923, 0x1926}, {0x1929, 0x192b}, {0x1930, 0x1931}, 
+    {0x1933, 0x1938} };
+static xmlChLRange xmlMcL[] = {{0x1d165, 0x1d166}, {0x1d16d, 0x1d172} };
+static xmlChRangeGroup xmlMcG = {55,2,xmlMcS,xmlMcL};
+
+static xmlChSRange xmlMnS[] = {{0x300, 0x357}, {0x35d, 0x36f}, 
+    {0x483, 0x486}, {0x591, 0x5a1}, {0x5a3, 0x5b9}, {0x5bb, 0x5bd}, 
+    {0x5bf, 0x5bf}, {0x5c1, 0x5c2}, {0x5c4, 0x5c4}, {0x610, 0x615}, 
+    {0x64b, 0x658}, {0x670, 0x670}, {0x6d6, 0x6dc}, {0x6df, 0x6e4}, 
+    {0x6e7, 0x6e8}, {0x6ea, 0x6ed}, {0x711, 0x711}, {0x730, 0x74a}, 
+    {0x7a6, 0x7b0}, {0x901, 0x902}, {0x93c, 0x93c}, {0x941, 0x948}, 
+    {0x94d, 0x94d}, {0x951, 0x954}, {0x962, 0x963}, {0x981, 0x981}, 
+    {0x9bc, 0x9bc}, {0x9c1, 0x9c4}, {0x9cd, 0x9cd}, {0x9e2, 0x9e3}, 
+    {0xa01, 0xa02}, {0xa3c, 0xa3c}, {0xa41, 0xa42}, {0xa47, 0xa48}, 
+    {0xa4b, 0xa4d}, {0xa70, 0xa71}, {0xa81, 0xa82}, {0xabc, 0xabc}, 
+    {0xac1, 0xac5}, {0xac7, 0xac8}, {0xacd, 0xacd}, {0xae2, 0xae3}, 
+    {0xb01, 0xb01}, {0xb3c, 0xb3c}, {0xb3f, 0xb3f}, {0xb41, 0xb43}, 
+    {0xb4d, 0xb4d}, {0xb56, 0xb56}, {0xb82, 0xb82}, {0xbc0, 0xbc0}, 
+    {0xbcd, 0xbcd}, {0xc3e, 0xc40}, {0xc46, 0xc48}, {0xc4a, 0xc4d}, 
+    {0xc55, 0xc56}, {0xcbc, 0xcbc}, {0xcbf, 0xcbf}, {0xcc6, 0xcc6}, 
+    {0xccc, 0xccd}, {0xd41, 0xd43}, {0xd4d, 0xd4d}, {0xdca, 0xdca}, 
+    {0xdd2, 0xdd4}, {0xdd6, 0xdd6}, {0xe31, 0xe31}, {0xe34, 0xe3a}, 
+    {0xe47, 0xe4e}, {0xeb1, 0xeb1}, {0xeb4, 0xeb9}, {0xebb, 0xebc}, 
+    {0xec8, 0xecd}, {0xf18, 0xf19}, {0xf35, 0xf35}, {0xf37, 0xf37}, 
+    {0xf39, 0xf39}, {0xf71, 0xf7e}, {0xf80, 0xf84}, {0xf86, 0xf87}, 
+    {0xf90, 0xf97}, {0xf99, 0xfbc}, {0xfc6, 0xfc6}, {0x102d, 0x1030}, 
+    {0x1032, 0x1032}, {0x1036, 0x1037}, {0x1039, 0x1039}, {0x1058, 0x1059}, 
+    {0x1712, 0x1714}, {0x1732, 0x1734}, {0x1752, 0x1753}, {0x1772, 0x1773}, 
+    {0x17b7, 0x17bd}, {0x17c6, 0x17c6}, {0x17c9, 0x17d3}, {0x17dd, 0x17dd}, 
+    {0x180b, 0x180d}, {0x18a9, 0x18a9}, {0x1920, 0x1922}, {0x1927, 0x1928}, 
+    {0x1932, 0x1932}, {0x1939, 0x193b}, {0x20d0, 0x20dc}, {0x20e1, 0x20e1}, 
+    {0x20e5, 0x20ea}, {0x302a, 0x302f}, {0x3099, 0x309a}, {0xfb1e, 0xfb1e}, 
+    {0xfe00, 0xfe0f}, {0xfe20, 0xfe23} };
+static xmlChLRange xmlMnL[] = {{0x1d167, 0x1d169}, {0x1d17b, 0x1d182}, 
+    {0x1d185, 0x1d18b}, {0x1d1aa, 0x1d1ad}, {0xe0100, 0xe01ef} };
+static xmlChRangeGroup xmlMnG = {108,5,xmlMnS,xmlMnL};
+
+static xmlChSRange xmlNS[] = {{0x30, 0x39}, {0xb2, 0xb3}, {0xb9, 0xb9}, 
+    {0xbc, 0xbe}, {0x660, 0x669}, {0x6f0, 0x6f9}, {0x966, 0x96f}, 
+    {0x9e6, 0x9ef}, {0x9f4, 0x9f9}, {0xa66, 0xa6f}, {0xae6, 0xaef}, 
+    {0xb66, 0xb6f}, {0xbe7, 0xbf2}, {0xc66, 0xc6f}, {0xce6, 0xcef}, 
+    {0xd66, 0xd6f}, {0xe50, 0xe59}, {0xed0, 0xed9}, {0xf20, 0xf33}, 
+    {0x1040, 0x1049}, {0x1369, 0x137c}, {0x16ee, 0x16f0}, {0x17e0, 0x17e9}, 
+    {0x17f0, 0x17f9}, {0x1810, 0x1819}, {0x1946, 0x194f}, {0x2070, 0x2070}, 
+    {0x2074, 0x2079}, {0x2080, 0x2089}, {0x2153, 0x2183}, {0x2460, 0x249b}, 
+    {0x24ea, 0x24ff}, {0x2776, 0x2793}, {0x3007, 0x3007}, {0x3021, 0x3029}, 
+    {0x3038, 0x303a}, {0x3192, 0x3195}, {0x3220, 0x3229}, {0x3251, 0x325f}, 
+    {0x3280, 0x3289}, {0x32b1, 0x32bf}, {0xff10, 0xff19} };
+static xmlChLRange xmlNL[] = {{0x10107, 0x10133}, {0x10320, 0x10323}, 
+    {0x1034a, 0x1034a}, {0x104a0, 0x104a9}, {0x1d7ce, 0x1d7ff} };
+static xmlChRangeGroup xmlNG = {42,5,xmlNS,xmlNL};
+
+static xmlChSRange xmlNdS[] = {{0x30, 0x39}, {0x660, 0x669}, 
+    {0x6f0, 0x6f9}, {0x966, 0x96f}, {0x9e6, 0x9ef}, {0xa66, 0xa6f}, 
+    {0xae6, 0xaef}, {0xb66, 0xb6f}, {0xbe7, 0xbef}, {0xc66, 0xc6f}, 
+    {0xce6, 0xcef}, {0xd66, 0xd6f}, {0xe50, 0xe59}, {0xed0, 0xed9}, 
+    {0xf20, 0xf29}, {0x1040, 0x1049}, {0x1369, 0x1371}, {0x17e0, 0x17e9}, 
+    {0x1810, 0x1819}, {0x1946, 0x194f}, {0xff10, 0xff19} };
+static xmlChLRange xmlNdL[] = {{0x104a0, 0x104a9}, {0x1d7ce, 0x1d7ff} };
+static xmlChRangeGroup xmlNdG = {21,2,xmlNdS,xmlNdL};
+
+static xmlChSRange xmlNoS[] = {{0xb2, 0xb3}, {0xb9, 0xb9}, {0xbc, 0xbe}, 
+    {0x9f4, 0x9f9}, {0xbf0, 0xbf2}, {0xf2a, 0xf33}, {0x1372, 0x137c}, 
+    {0x17f0, 0x17f9}, {0x2070, 0x2070}, {0x2074, 0x2079}, {0x2080, 0x2089}, 
+    {0x2153, 0x215f}, {0x2460, 0x249b}, {0x24ea, 0x24ff}, {0x2776, 0x2793}, 
+    {0x3192, 0x3195}, {0x3220, 0x3229}, {0x3251, 0x325f}, {0x3280, 0x3289}, 
+    {0x32b1, 0x32bf} };
+static xmlChLRange xmlNoL[] = {{0x10107, 0x10133}, {0x10320, 0x10323} };
+static xmlChRangeGroup xmlNoG = {20,2,xmlNoS,xmlNoL};
+
+static xmlChSRange xmlPS[] = {{0x21, 0x23}, {0x25, 0x2a}, {0x2c, 0x2f}, 
+    {0x3a, 0x3b}, {0x3f, 0x40}, {0x5b, 0x5d}, {0x5f, 0x5f}, {0x7b, 0x7b}, 
+    {0x7d, 0x7d}, {0xa1, 0xa1}, {0xab, 0xab}, {0xb7, 0xb7}, {0xbb, 0xbb}, 
+    {0xbf, 0xbf}, {0x37e, 0x37e}, {0x387, 0x387}, {0x55a, 0x55f}, 
+    {0x589, 0x58a}, {0x5be, 0x5be}, {0x5c0, 0x5c0}, {0x5c3, 0x5c3}, 
+    {0x5f3, 0x5f4}, {0x60c, 0x60d}, {0x61b, 0x61b}, {0x61f, 0x61f}, 
+    {0x66a, 0x66d}, {0x6d4, 0x6d4}, {0x700, 0x70d}, {0x964, 0x965}, 
+    {0x970, 0x970}, {0xdf4, 0xdf4}, {0xe4f, 0xe4f}, {0xe5a, 0xe5b}, 
+    {0xf04, 0xf12}, {0xf3a, 0xf3d}, {0xf85, 0xf85}, {0x104a, 0x104f}, 
+    {0x10fb, 0x10fb}, {0x1361, 0x1368}, {0x166d, 0x166e}, {0x169b, 0x169c}, 
+    {0x16eb, 0x16ed}, {0x1735, 0x1736}, {0x17d4, 0x17d6}, {0x17d8, 0x17da}, 
+    {0x1800, 0x180a}, {0x1944, 0x1945}, {0x2010, 0x2027}, {0x2030, 0x2043}, 
+    {0x2045, 0x2051}, {0x2053, 0x2054}, {0x2057, 0x2057}, {0x207d, 0x207e}, 
+    {0x208d, 0x208e}, {0x2329, 0x232a}, {0x23b4, 0x23b6}, {0x2768, 0x2775}, 
+    {0x27e6, 0x27eb}, {0x2983, 0x2998}, {0x29d8, 0x29db}, {0x29fc, 0x29fd}, 
+    {0x3001, 0x3003}, {0x3008, 0x3011}, {0x3014, 0x301f}, {0x3030, 0x3030}, 
+    {0x303d, 0x303d}, {0x30a0, 0x30a0}, {0x30fb, 0x30fb}, {0xfd3e, 0xfd3f}, 
+    {0xfe30, 0xfe52}, {0xfe54, 0xfe61}, {0xfe63, 0xfe63}, {0xfe68, 0xfe68}, 
+    {0xfe6a, 0xfe6b}, {0xff01, 0xff03}, {0xff05, 0xff0a}, {0xff0c, 0xff0f}, 
+    {0xff1a, 0xff1b}, {0xff1f, 0xff20}, {0xff3b, 0xff3d}, {0xff3f, 0xff3f}, 
+    {0xff5b, 0xff5b}, {0xff5d, 0xff5d}, {0xff5f, 0xff65} };
+static xmlChLRange xmlPL[] = {{0x10100, 0x10101}, {0x1039f, 0x1039f} };
+static xmlChRangeGroup xmlPG = {84,2,xmlPS,xmlPL};
+
+static xmlChSRange xmlPdS[] = {{0x2d, 0x2d}, {0x58a, 0x58a}, 
+    {0x1806, 0x1806}, {0x2010, 0x2015}, {0x301c, 0x301c}, {0x3030, 0x3030}, 
+    {0x30a0, 0x30a0}, {0xfe31, 0xfe32}, {0xfe58, 0xfe58}, {0xfe63, 0xfe63}, 
+    {0xff0d, 0xff0d} };
+static xmlChRangeGroup xmlPdG = {11,0,xmlPdS,NULL};
+
+static xmlChSRange xmlPeS[] = {{0x29, 0x29}, {0x5d, 0x5d}, {0x7d, 0x7d}, 
+    {0xf3b, 0xf3b}, {0xf3d, 0xf3d}, {0x169c, 0x169c}, {0x2046, 0x2046}, 
+    {0x207e, 0x207e}, {0x208e, 0x208e}, {0x232a, 0x232a}, {0x23b5, 0x23b5}, 
+    {0x2769, 0x2769}, {0x276b, 0x276b}, {0x276d, 0x276d}, {0x276f, 0x276f}, 
+    {0x2771, 0x2771}, {0x2773, 0x2773}, {0x2775, 0x2775}, {0x27e7, 0x27e7}, 
+    {0x27e9, 0x27e9}, {0x27eb, 0x27eb}, {0x2984, 0x2984}, {0x2986, 0x2986}, 
+    {0x2988, 0x2988}, {0x298a, 0x298a}, {0x298c, 0x298c}, {0x298e, 0x298e}, 
+    {0x2990, 0x2990}, {0x2992, 0x2992}, {0x2994, 0x2994}, {0x2996, 0x2996}, 
+    {0x2998, 0x2998}, {0x29d9, 0x29d9}, {0x29db, 0x29db}, {0x29fd, 0x29fd}, 
+    {0x3009, 0x3009}, {0x300b, 0x300b}, {0x300d, 0x300d}, {0x300f, 0x300f}, 
+    {0x3011, 0x3011}, {0x3015, 0x3015}, {0x3017, 0x3017}, {0x3019, 0x3019}, 
+    {0x301b, 0x301b}, {0x301e, 0x301f}, {0xfd3f, 0xfd3f}, {0xfe36, 0xfe36}, 
+    {0xfe38, 0xfe38}, {0xfe3a, 0xfe3a}, {0xfe3c, 0xfe3c}, {0xfe3e, 0xfe3e}, 
+    {0xfe40, 0xfe40}, {0xfe42, 0xfe42}, {0xfe44, 0xfe44}, {0xfe48, 0xfe48}, 
+    {0xfe5a, 0xfe5a}, {0xfe5c, 0xfe5c}, {0xfe5e, 0xfe5e}, {0xff09, 0xff09}, 
+    {0xff3d, 0xff3d}, {0xff5d, 0xff5d}, {0xff60, 0xff60}, {0xff63, 0xff63} };
+static xmlChRangeGroup xmlPeG = {63,0,xmlPeS,NULL};
+
+static xmlChSRange xmlPoS[] = {{0x21, 0x23}, {0x25, 0x27}, {0x2a, 0x2a}, 
+    {0x2c, 0x2c}, {0x2e, 0x2f}, {0x3a, 0x3b}, {0x3f, 0x40}, {0x5c, 0x5c}, 
+    {0xa1, 0xa1}, {0xb7, 0xb7}, {0xbf, 0xbf}, {0x37e, 0x37e}, 
+    {0x387, 0x387}, {0x55a, 0x55f}, {0x589, 0x589}, {0x5be, 0x5be}, 
+    {0x5c0, 0x5c0}, {0x5c3, 0x5c3}, {0x5f3, 0x5f4}, {0x60c, 0x60d}, 
+    {0x61b, 0x61b}, {0x61f, 0x61f}, {0x66a, 0x66d}, {0x6d4, 0x6d4}, 
+    {0x700, 0x70d}, {0x964, 0x965}, {0x970, 0x970}, {0xdf4, 0xdf4}, 
+    {0xe4f, 0xe4f}, {0xe5a, 0xe5b}, {0xf04, 0xf12}, {0xf85, 0xf85}, 
+    {0x104a, 0x104f}, {0x10fb, 0x10fb}, {0x1361, 0x1368}, {0x166d, 0x166e}, 
+    {0x16eb, 0x16ed}, {0x1735, 0x1736}, {0x17d4, 0x17d6}, {0x17d8, 0x17da}, 
+    {0x1800, 0x1805}, {0x1807, 0x180a}, {0x1944, 0x1945}, {0x2016, 0x2017}, 
+    {0x2020, 0x2027}, {0x2030, 0x2038}, {0x203b, 0x203e}, {0x2041, 0x2043}, 
+    {0x2047, 0x2051}, {0x2053, 0x2053}, {0x2057, 0x2057}, {0x23b6, 0x23b6}, 
+    {0x3001, 0x3003}, {0x303d, 0x303d}, {0xfe30, 0xfe30}, {0xfe45, 0xfe46}, 
+    {0xfe49, 0xfe4c}, {0xfe50, 0xfe52}, {0xfe54, 0xfe57}, {0xfe5f, 0xfe61}, 
+    {0xfe68, 0xfe68}, {0xfe6a, 0xfe6b}, {0xff01, 0xff03}, {0xff05, 0xff07}, 
+    {0xff0a, 0xff0a}, {0xff0c, 0xff0c}, {0xff0e, 0xff0f}, {0xff1a, 0xff1b}, 
+    {0xff1f, 0xff20}, {0xff3c, 0xff3c}, {0xff61, 0xff61}, {0xff64, 0xff64} };
+static xmlChLRange xmlPoL[] = {{0x10100, 0x10101}, {0x1039f, 0x1039f} };
+static xmlChRangeGroup xmlPoG = {72,2,xmlPoS,xmlPoL};
+
+static xmlChSRange xmlPsS[] = {{0x28, 0x28}, {0x5b, 0x5b}, {0x7b, 0x7b}, 
+    {0xf3a, 0xf3a}, {0xf3c, 0xf3c}, {0x169b, 0x169b}, {0x201a, 0x201a}, 
+    {0x201e, 0x201e}, {0x2045, 0x2045}, {0x207d, 0x207d}, {0x208d, 0x208d}, 
+    {0x2329, 0x2329}, {0x23b4, 0x23b4}, {0x2768, 0x2768}, {0x276a, 0x276a}, 
+    {0x276c, 0x276c}, {0x276e, 0x276e}, {0x2770, 0x2770}, {0x2772, 0x2772}, 
+    {0x2774, 0x2774}, {0x27e6, 0x27e6}, {0x27e8, 0x27e8}, {0x27ea, 0x27ea}, 
+    {0x2983, 0x2983}, {0x2985, 0x2985}, {0x2987, 0x2987}, {0x2989, 0x2989}, 
+    {0x298b, 0x298b}, {0x298d, 0x298d}, {0x298f, 0x298f}, {0x2991, 0x2991}, 
+    {0x2993, 0x2993}, {0x2995, 0x2995}, {0x2997, 0x2997}, {0x29d8, 0x29d8}, 
+    {0x29da, 0x29da}, {0x29fc, 0x29fc}, {0x3008, 0x3008}, {0x300a, 0x300a}, 
+    {0x300c, 0x300c}, {0x300e, 0x300e}, {0x3010, 0x3010}, {0x3014, 0x3014}, 
+    {0x3016, 0x3016}, {0x3018, 0x3018}, {0x301a, 0x301a}, {0x301d, 0x301d}, 
+    {0xfd3e, 0xfd3e}, {0xfe35, 0xfe35}, {0xfe37, 0xfe37}, {0xfe39, 0xfe39}, 
+    {0xfe3b, 0xfe3b}, {0xfe3d, 0xfe3d}, {0xfe3f, 0xfe3f}, {0xfe41, 0xfe41}, 
+    {0xfe43, 0xfe43}, {0xfe47, 0xfe47}, {0xfe59, 0xfe59}, {0xfe5b, 0xfe5b}, 
+    {0xfe5d, 0xfe5d}, {0xff08, 0xff08}, {0xff3b, 0xff3b}, {0xff5b, 0xff5b}, 
+    {0xff5f, 0xff5f}, {0xff62, 0xff62} };
+static xmlChRangeGroup xmlPsG = {65,0,xmlPsS,NULL};
+
+static xmlChSRange xmlSS[] = {{0x24, 0x24}, {0x2b, 0x2b}, {0x3c, 0x3e}, 
+    {0x5e, 0x5e}, {0x60, 0x60}, {0x7c, 0x7c}, {0x7e, 0x7e}, {0xa2, 0xa9}, 
+    {0xac, 0xac}, {0xae, 0xb1}, {0xb4, 0xb4}, {0xb6, 0xb6}, {0xb8, 0xb8}, 
+    {0xd7, 0xd7}, {0xf7, 0xf7}, {0x2c2, 0x2c5}, {0x2d2, 0x2df}, 
+    {0x2e5, 0x2ed}, {0x2ef, 0x2ff}, {0x374, 0x375}, {0x384, 0x385}, 
+    {0x3f6, 0x3f6}, {0x482, 0x482}, {0x60e, 0x60f}, {0x6e9, 0x6e9}, 
+    {0x6fd, 0x6fe}, {0x9f2, 0x9f3}, {0x9fa, 0x9fa}, {0xaf1, 0xaf1}, 
+    {0xb70, 0xb70}, {0xbf3, 0xbfa}, {0xe3f, 0xe3f}, {0xf01, 0xf03}, 
+    {0xf13, 0xf17}, {0xf1a, 0xf1f}, {0xf34, 0xf34}, {0xf36, 0xf36}, 
+    {0xf38, 0xf38}, {0xfbe, 0xfc5}, {0xfc7, 0xfcc}, {0xfcf, 0xfcf}, 
+    {0x17db, 0x17db}, {0x1940, 0x1940}, {0x19e0, 0x19ff}, {0x1fbd, 0x1fbd}, 
+    {0x1fbf, 0x1fc1}, {0x1fcd, 0x1fcf}, {0x1fdd, 0x1fdf}, {0x1fed, 0x1fef}, 
+    {0x1ffd, 0x1ffe}, {0x2044, 0x2044}, {0x2052, 0x2052}, {0x207a, 0x207c}, 
+    {0x208a, 0x208c}, {0x20a0, 0x20b1}, {0x2100, 0x2101}, {0x2103, 0x2106}, 
+    {0x2108, 0x2109}, {0x2114, 0x2114}, {0x2116, 0x2118}, {0x211e, 0x2123}, 
+    {0x2125, 0x2125}, {0x2127, 0x2127}, {0x2129, 0x2129}, {0x212e, 0x212e}, 
+    {0x2132, 0x2132}, {0x213a, 0x213b}, {0x2140, 0x2144}, {0x214a, 0x214b}, 
+    {0x2190, 0x2328}, {0x232b, 0x23b3}, {0x23b7, 0x23d0}, {0x2400, 0x2426}, 
+    {0x2440, 0x244a}, {0x249c, 0x24e9}, {0x2500, 0x2617}, {0x2619, 0x267d}, 
+    {0x2680, 0x2691}, {0x26a0, 0x26a1}, {0x2701, 0x2704}, {0x2706, 0x2709}, 
+    {0x270c, 0x2727}, {0x2729, 0x274b}, {0x274d, 0x274d}, {0x274f, 0x2752}, 
+    {0x2756, 0x2756}, {0x2758, 0x275e}, {0x2761, 0x2767}, {0x2794, 0x2794}, 
+    {0x2798, 0x27af}, {0x27b1, 0x27be}, {0x27d0, 0x27e5}, {0x27f0, 0x2982}, 
+    {0x2999, 0x29d7}, {0x29dc, 0x29fb}, {0x29fe, 0x2b0d}, {0x2e80, 0x2e99}, 
+    {0x2e9b, 0x2ef3}, {0x2f00, 0x2fd5}, {0x2ff0, 0x2ffb}, {0x3004, 0x3004}, 
+    {0x3012, 0x3013}, {0x3020, 0x3020}, {0x3036, 0x3037}, {0x303e, 0x303f}, 
+    {0x309b, 0x309c}, {0x3190, 0x3191}, {0x3196, 0x319f}, {0x3200, 0x321e}, 
+    {0x322a, 0x3243}, {0x3250, 0x3250}, {0x3260, 0x327d}, {0x327f, 0x327f}, 
+    {0x328a, 0x32b0}, {0x32c0, 0x32fe}, {0x3300, 0x33ff}, {0x4dc0, 0x4dff}, 
+    {0xa490, 0xa4c6}, {0xfb29, 0xfb29}, {0xfdfc, 0xfdfd}, {0xfe62, 0xfe62}, 
+    {0xfe64, 0xfe66}, {0xfe69, 0xfe69}, {0xff04, 0xff04}, {0xff0b, 0xff0b}, 
+    {0xff1c, 0xff1e}, {0xff3e, 0xff3e}, {0xff40, 0xff40}, {0xff5c, 0xff5c}, 
+    {0xff5e, 0xff5e}, {0xffe0, 0xffe6}, {0xffe8, 0xffee}, {0xfffc, 0xfffd} };
+static xmlChLRange xmlSL[] = {{0x10102, 0x10102}, {0x10137, 0x1013f}, 
+    {0x1d000, 0x1d0f5}, {0x1d100, 0x1d126}, {0x1d12a, 0x1d164}, 
+    {0x1d16a, 0x1d16c}, {0x1d183, 0x1d184}, {0x1d18c, 0x1d1a9}, 
+    {0x1d1ae, 0x1d1dd}, {0x1d300, 0x1d356}, {0x1d6c1, 0x1d6c1}, 
+    {0x1d6db, 0x1d6db}, {0x1d6fb, 0x1d6fb}, {0x1d715, 0x1d715}, 
+    {0x1d735, 0x1d735}, {0x1d74f, 0x1d74f}, {0x1d76f, 0x1d76f}, 
+    {0x1d789, 0x1d789}, {0x1d7a9, 0x1d7a9}, {0x1d7c3, 0x1d7c3} };
+static xmlChRangeGroup xmlSG = {133,20,xmlSS,xmlSL};
+
+static xmlChSRange xmlScS[] = {{0x24, 0x24}, {0xa2, 0xa5}, {0x9f2, 0x9f3}, 
+    {0xaf1, 0xaf1}, {0xbf9, 0xbf9}, {0xe3f, 0xe3f}, {0x17db, 0x17db}, 
+    {0x20a0, 0x20b1}, {0xfdfc, 0xfdfc}, {0xfe69, 0xfe69}, {0xff04, 0xff04}, 
+    {0xffe0, 0xffe1}, {0xffe5, 0xffe6} };
+static xmlChRangeGroup xmlScG = {13,0,xmlScS,NULL};
+
+static xmlChSRange xmlSkS[] = {{0x5e, 0x5e}, {0x60, 0x60}, {0xa8, 0xa8}, 
+    {0xaf, 0xaf}, {0xb4, 0xb4}, {0xb8, 0xb8}, {0x2c2, 0x2c5}, 
+    {0x2d2, 0x2df}, {0x2e5, 0x2ed}, {0x2ef, 0x2ff}, {0x374, 0x375}, 
+    {0x384, 0x385}, {0x1fbd, 0x1fbd}, {0x1fbf, 0x1fc1}, {0x1fcd, 0x1fcf}, 
+    {0x1fdd, 0x1fdf}, {0x1fed, 0x1fef}, {0x1ffd, 0x1ffe}, {0x309b, 0x309c}, 
+    {0xff3e, 0xff3e}, {0xff40, 0xff40}, {0xffe3, 0xffe3} };
+static xmlChRangeGroup xmlSkG = {22,0,xmlSkS,NULL};
+
+static xmlChSRange xmlSmS[] = {{0x2b, 0x2b}, {0x3c, 0x3e}, {0x7c, 0x7c}, 
+    {0x7e, 0x7e}, {0xac, 0xac}, {0xb1, 0xb1}, {0xd7, 0xd7}, {0xf7, 0xf7}, 
+    {0x3f6, 0x3f6}, {0x2044, 0x2044}, {0x2052, 0x2052}, {0x207a, 0x207c}, 
+    {0x208a, 0x208c}, {0x2140, 0x2144}, {0x214b, 0x214b}, {0x2190, 0x2194}, 
+    {0x219a, 0x219b}, {0x21a0, 0x21a0}, {0x21a3, 0x21a3}, {0x21a6, 0x21a6}, 
+    {0x21ae, 0x21ae}, {0x21ce, 0x21cf}, {0x21d2, 0x21d2}, {0x21d4, 0x21d4}, 
+    {0x21f4, 0x22ff}, {0x2308, 0x230b}, {0x2320, 0x2321}, {0x237c, 0x237c}, 
+    {0x239b, 0x23b3}, {0x25b7, 0x25b7}, {0x25c1, 0x25c1}, {0x25f8, 0x25ff}, 
+    {0x266f, 0x266f}, {0x27d0, 0x27e5}, {0x27f0, 0x27ff}, {0x2900, 0x2982}, 
+    {0x2999, 0x29d7}, {0x29dc, 0x29fb}, {0x29fe, 0x2aff}, {0xfb29, 0xfb29}, 
+    {0xfe62, 0xfe62}, {0xfe64, 0xfe66}, {0xff0b, 0xff0b}, {0xff1c, 0xff1e}, 
+    {0xff5c, 0xff5c}, {0xff5e, 0xff5e}, {0xffe2, 0xffe2}, {0xffe9, 0xffec} };
+static xmlChLRange xmlSmL[] = {{0x1d6c1, 0x1d6c1}, {0x1d6db, 0x1d6db}, 
+    {0x1d6fb, 0x1d6fb}, {0x1d715, 0x1d715}, {0x1d735, 0x1d735}, 
+    {0x1d74f, 0x1d74f}, {0x1d76f, 0x1d76f}, {0x1d789, 0x1d789}, 
+    {0x1d7a9, 0x1d7a9}, {0x1d7c3, 0x1d7c3} };
+static xmlChRangeGroup xmlSmG = {48,10,xmlSmS,xmlSmL};
+
+static xmlChSRange xmlSoS[] = {{0xa6, 0xa7}, {0xa9, 0xa9}, {0xae, 0xae}, 
+    {0xb0, 0xb0}, {0xb6, 0xb6}, {0x482, 0x482}, {0x60e, 0x60f}, 
+    {0x6e9, 0x6e9}, {0x6fd, 0x6fe}, {0x9fa, 0x9fa}, {0xb70, 0xb70}, 
+    {0xbf3, 0xbf8}, {0xbfa, 0xbfa}, {0xf01, 0xf03}, {0xf13, 0xf17}, 
+    {0xf1a, 0xf1f}, {0xf34, 0xf34}, {0xf36, 0xf36}, {0xf38, 0xf38}, 
+    {0xfbe, 0xfc5}, {0xfc7, 0xfcc}, {0xfcf, 0xfcf}, {0x1940, 0x1940}, 
+    {0x19e0, 0x19ff}, {0x2100, 0x2101}, {0x2103, 0x2106}, {0x2108, 0x2109}, 
+    {0x2114, 0x2114}, {0x2116, 0x2118}, {0x211e, 0x2123}, {0x2125, 0x2125}, 
+    {0x2127, 0x2127}, {0x2129, 0x2129}, {0x212e, 0x212e}, {0x2132, 0x2132}, 
+    {0x213a, 0x213b}, {0x214a, 0x214a}, {0x2195, 0x2199}, {0x219c, 0x219f}, 
+    {0x21a1, 0x21a2}, {0x21a4, 0x21a5}, {0x21a7, 0x21ad}, {0x21af, 0x21cd}, 
+    {0x21d0, 0x21d1}, {0x21d3, 0x21d3}, {0x21d5, 0x21f3}, {0x2300, 0x2307}, 
+    {0x230c, 0x231f}, {0x2322, 0x2328}, {0x232b, 0x237b}, {0x237d, 0x239a}, 
+    {0x23b7, 0x23d0}, {0x2400, 0x2426}, {0x2440, 0x244a}, {0x249c, 0x24e9}, 
+    {0x2500, 0x25b6}, {0x25b8, 0x25c0}, {0x25c2, 0x25f7}, {0x2600, 0x2617}, 
+    {0x2619, 0x266e}, {0x2670, 0x267d}, {0x2680, 0x2691}, {0x26a0, 0x26a1}, 
+    {0x2701, 0x2704}, {0x2706, 0x2709}, {0x270c, 0x2727}, {0x2729, 0x274b}, 
+    {0x274d, 0x274d}, {0x274f, 0x2752}, {0x2756, 0x2756}, {0x2758, 0x275e}, 
+    {0x2761, 0x2767}, {0x2794, 0x2794}, {0x2798, 0x27af}, {0x27b1, 0x27be}, 
+    {0x2800, 0x28ff}, {0x2b00, 0x2b0d}, {0x2e80, 0x2e99}, {0x2e9b, 0x2ef3}, 
+    {0x2f00, 0x2fd5}, {0x2ff0, 0x2ffb}, {0x3004, 0x3004}, {0x3012, 0x3013}, 
+    {0x3020, 0x3020}, {0x3036, 0x3037}, {0x303e, 0x303f}, {0x3190, 0x3191}, 
+    {0x3196, 0x319f}, {0x3200, 0x321e}, {0x322a, 0x3243}, {0x3250, 0x3250}, 
+    {0x3260, 0x327d}, {0x327f, 0x327f}, {0x328a, 0x32b0}, {0x32c0, 0x32fe}, 
+    {0x3300, 0x33ff}, {0x4dc0, 0x4dff}, {0xa490, 0xa4c6}, {0xfdfd, 0xfdfd}, 
+    {0xffe4, 0xffe4}, {0xffe8, 0xffe8}, {0xffed, 0xffee}, {0xfffc, 0xfffd} };
+static xmlChLRange xmlSoL[] = {{0x10102, 0x10102}, {0x10137, 0x1013f}, 
+    {0x1d000, 0x1d0f5}, {0x1d100, 0x1d126}, {0x1d12a, 0x1d164}, 
+    {0x1d16a, 0x1d16c}, {0x1d183, 0x1d184}, {0x1d18c, 0x1d1a9}, 
+    {0x1d1ae, 0x1d1dd}, {0x1d300, 0x1d356} };
+static xmlChRangeGroup xmlSoG = {103,10,xmlSoS,xmlSoL};
+
+static xmlChSRange xmlZS[] = {{0x20, 0x20}, {0xa0, 0xa0}, {0x1680, 0x1680}, 
+    {0x180e, 0x180e}, {0x2000, 0x200b}, {0x2028, 0x2029}, {0x202f, 0x202f}, 
+    {0x205f, 0x205f}, {0x3000, 0x3000} };
+static xmlChRangeGroup xmlZG = {9,0,xmlZS,NULL};
+
+xmlUnicodeNameTable xmlUnicodeBlockTbl = {xmlUnicodeBlocks, 128};
+xmlUnicodeNameTable xmlUnicodeCatTbl = {xmlUnicodeCats, 36};
+
+/**
+ * xmlUnicodeLookup:
+ * @tptr: pointer to the name table
+ * @name: name to be found
+ *
+ * binary table lookup for user-supplied name
+ *
+ * Returns pointer to range function if found, otherwise NULL
+ */
+static xmlIntFunc
+*xmlUnicodeLookup(xmlUnicodeNameTable *tptr, const char *tname) {
+    int low, high, mid, cmp;
+    xmlUnicodeRange *sptr;
+
+    low = 0;
+    high = tptr->numentries - 1;
+    sptr = tptr->table;
+    while (low <= high) {
+	mid = (low + high) / 2;
+	if ((cmp=strcmp(tname, sptr[mid].rangename)) == 0)
+	    return (sptr[mid].func);
+	if (cmp < 0)
+	    high = mid - 1;
+	else
+	    low = mid + 1;
+    }
+    return (NULL);    
+}
+
+/**
+ * xmlUCSIsAegeanNumbers:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of AegeanNumbers UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsAegeanNumbers(int code) {
+    return(((code >= 0x10100) && (code <= 0x1013F)));
+}
+
+/**
+ * xmlUCSIsAlphabeticPresentationForms:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of AlphabeticPresentationForms UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsAlphabeticPresentationForms(int code) {
+    return(((code >= 0xFB00) && (code <= 0xFB4F)));
+}
+
+/**
+ * xmlUCSIsArabic:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Arabic UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsArabic(int code) {
+    return(((code >= 0x0600) && (code <= 0x06FF)));
+}
+
+/**
+ * xmlUCSIsArabicPresentationFormsA:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of ArabicPresentationForms-A UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsArabicPresentationFormsA(int code) {
+    return(((code >= 0xFB50) && (code <= 0xFDFF)));
+}
+
+/**
+ * xmlUCSIsArabicPresentationFormsB:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of ArabicPresentationForms-B UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsArabicPresentationFormsB(int code) {
+    return(((code >= 0xFE70) && (code <= 0xFEFF)));
+}
+
+/**
+ * xmlUCSIsArmenian:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Armenian UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsArmenian(int code) {
+    return(((code >= 0x0530) && (code <= 0x058F)));
+}
+
+/**
+ * xmlUCSIsArrows:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Arrows UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsArrows(int code) {
+    return(((code >= 0x2190) && (code <= 0x21FF)));
+}
+
+/**
+ * xmlUCSIsBasicLatin:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of BasicLatin UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsBasicLatin(int code) {
+    return(((code >= 0x0000) && (code <= 0x007F)));
+}
+
+/**
+ * xmlUCSIsBengali:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Bengali UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsBengali(int code) {
+    return(((code >= 0x0980) && (code <= 0x09FF)));
+}
+
+/**
+ * xmlUCSIsBlockElements:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of BlockElements UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsBlockElements(int code) {
+    return(((code >= 0x2580) && (code <= 0x259F)));
+}
+
+/**
+ * xmlUCSIsBopomofo:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Bopomofo UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsBopomofo(int code) {
+    return(((code >= 0x3100) && (code <= 0x312F)));
+}
+
+/**
+ * xmlUCSIsBopomofoExtended:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of BopomofoExtended UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsBopomofoExtended(int code) {
+    return(((code >= 0x31A0) && (code <= 0x31BF)));
+}
+
+/**
+ * xmlUCSIsBoxDrawing:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of BoxDrawing UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsBoxDrawing(int code) {
+    return(((code >= 0x2500) && (code <= 0x257F)));
+}
+
+/**
+ * xmlUCSIsBraillePatterns:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of BraillePatterns UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsBraillePatterns(int code) {
+    return(((code >= 0x2800) && (code <= 0x28FF)));
+}
+
+/**
+ * xmlUCSIsBuhid:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Buhid UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsBuhid(int code) {
+    return(((code >= 0x1740) && (code <= 0x175F)));
+}
+
+/**
+ * xmlUCSIsByzantineMusicalSymbols:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of ByzantineMusicalSymbols UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsByzantineMusicalSymbols(int code) {
+    return(((code >= 0x1D000) && (code <= 0x1D0FF)));
+}
+
+/**
+ * xmlUCSIsCJKCompatibility:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of CJKCompatibility UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsCJKCompatibility(int code) {
+    return(((code >= 0x3300) && (code <= 0x33FF)));
+}
+
+/**
+ * xmlUCSIsCJKCompatibilityForms:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of CJKCompatibilityForms UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsCJKCompatibilityForms(int code) {
+    return(((code >= 0xFE30) && (code <= 0xFE4F)));
+}
+
+/**
+ * xmlUCSIsCJKCompatibilityIdeographs:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of CJKCompatibilityIdeographs UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsCJKCompatibilityIdeographs(int code) {
+    return(((code >= 0xF900) && (code <= 0xFAFF)));
+}
+
+/**
+ * xmlUCSIsCJKCompatibilityIdeographsSupplement:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of CJKCompatibilityIdeographsSupplement UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsCJKCompatibilityIdeographsSupplement(int code) {
+    return(((code >= 0x2F800) && (code <= 0x2FA1F)));
+}
+
+/**
+ * xmlUCSIsCJKRadicalsSupplement:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of CJKRadicalsSupplement UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsCJKRadicalsSupplement(int code) {
+    return(((code >= 0x2E80) && (code <= 0x2EFF)));
+}
+
+/**
+ * xmlUCSIsCJKSymbolsandPunctuation:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of CJKSymbolsandPunctuation UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsCJKSymbolsandPunctuation(int code) {
+    return(((code >= 0x3000) && (code <= 0x303F)));
+}
+
+/**
+ * xmlUCSIsCJKUnifiedIdeographs:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of CJKUnifiedIdeographs UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsCJKUnifiedIdeographs(int code) {
+    return(((code >= 0x4E00) && (code <= 0x9FFF)));
+}
+
+/**
+ * xmlUCSIsCJKUnifiedIdeographsExtensionA:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of CJKUnifiedIdeographsExtensionA UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsCJKUnifiedIdeographsExtensionA(int code) {
+    return(((code >= 0x3400) && (code <= 0x4DBF)));
+}
+
+/**
+ * xmlUCSIsCJKUnifiedIdeographsExtensionB:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of CJKUnifiedIdeographsExtensionB UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsCJKUnifiedIdeographsExtensionB(int code) {
+    return(((code >= 0x20000) && (code <= 0x2A6DF)));
+}
+
+/**
+ * xmlUCSIsCherokee:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Cherokee UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsCherokee(int code) {
+    return(((code >= 0x13A0) && (code <= 0x13FF)));
+}
+
+/**
+ * xmlUCSIsCombiningDiacriticalMarks:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of CombiningDiacriticalMarks UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsCombiningDiacriticalMarks(int code) {
+    return(((code >= 0x0300) && (code <= 0x036F)));
+}
+
+/**
+ * xmlUCSIsCombiningDiacriticalMarksforSymbols:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of CombiningDiacriticalMarksforSymbols UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsCombiningDiacriticalMarksforSymbols(int code) {
+    return(((code >= 0x20D0) && (code <= 0x20FF)));
+}
+
+/**
+ * xmlUCSIsCombiningHalfMarks:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of CombiningHalfMarks UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsCombiningHalfMarks(int code) {
+    return(((code >= 0xFE20) && (code <= 0xFE2F)));
+}
+
+/**
+ * xmlUCSIsCombiningMarksforSymbols:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of CombiningMarksforSymbols UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsCombiningMarksforSymbols(int code) {
+    return(((code >= 0x20D0) && (code <= 0x20FF)));
+}
+
+/**
+ * xmlUCSIsControlPictures:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of ControlPictures UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsControlPictures(int code) {
+    return(((code >= 0x2400) && (code <= 0x243F)));
+}
+
+/**
+ * xmlUCSIsCurrencySymbols:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of CurrencySymbols UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsCurrencySymbols(int code) {
+    return(((code >= 0x20A0) && (code <= 0x20CF)));
+}
+
+/**
+ * xmlUCSIsCypriotSyllabary:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of CypriotSyllabary UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsCypriotSyllabary(int code) {
+    return(((code >= 0x10800) && (code <= 0x1083F)));
+}
+
+/**
+ * xmlUCSIsCyrillic:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Cyrillic UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsCyrillic(int code) {
+    return(((code >= 0x0400) && (code <= 0x04FF)));
+}
+
+/**
+ * xmlUCSIsCyrillicSupplement:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of CyrillicSupplement UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsCyrillicSupplement(int code) {
+    return(((code >= 0x0500) && (code <= 0x052F)));
+}
+
+/**
+ * xmlUCSIsDeseret:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Deseret UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsDeseret(int code) {
+    return(((code >= 0x10400) && (code <= 0x1044F)));
+}
+
+/**
+ * xmlUCSIsDevanagari:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Devanagari UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsDevanagari(int code) {
+    return(((code >= 0x0900) && (code <= 0x097F)));
+}
+
+/**
+ * xmlUCSIsDingbats:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Dingbats UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsDingbats(int code) {
+    return(((code >= 0x2700) && (code <= 0x27BF)));
+}
+
+/**
+ * xmlUCSIsEnclosedAlphanumerics:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of EnclosedAlphanumerics UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsEnclosedAlphanumerics(int code) {
+    return(((code >= 0x2460) && (code <= 0x24FF)));
+}
+
+/**
+ * xmlUCSIsEnclosedCJKLettersandMonths:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of EnclosedCJKLettersandMonths UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsEnclosedCJKLettersandMonths(int code) {
+    return(((code >= 0x3200) && (code <= 0x32FF)));
+}
+
+/**
+ * xmlUCSIsEthiopic:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Ethiopic UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsEthiopic(int code) {
+    return(((code >= 0x1200) && (code <= 0x137F)));
+}
+
+/**
+ * xmlUCSIsGeneralPunctuation:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of GeneralPunctuation UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsGeneralPunctuation(int code) {
+    return(((code >= 0x2000) && (code <= 0x206F)));
+}
+
+/**
+ * xmlUCSIsGeometricShapes:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of GeometricShapes UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsGeometricShapes(int code) {
+    return(((code >= 0x25A0) && (code <= 0x25FF)));
+}
+
+/**
+ * xmlUCSIsGeorgian:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Georgian UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsGeorgian(int code) {
+    return(((code >= 0x10A0) && (code <= 0x10FF)));
+}
+
+/**
+ * xmlUCSIsGothic:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Gothic UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsGothic(int code) {
+    return(((code >= 0x10330) && (code <= 0x1034F)));
+}
+
+/**
+ * xmlUCSIsGreek:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Greek UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsGreek(int code) {
+    return(((code >= 0x0370) && (code <= 0x03FF)));
+}
+
+/**
+ * xmlUCSIsGreekExtended:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of GreekExtended UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsGreekExtended(int code) {
+    return(((code >= 0x1F00) && (code <= 0x1FFF)));
+}
+
+/**
+ * xmlUCSIsGreekandCoptic:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of GreekandCoptic UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsGreekandCoptic(int code) {
+    return(((code >= 0x0370) && (code <= 0x03FF)));
+}
+
+/**
+ * xmlUCSIsGujarati:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Gujarati UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsGujarati(int code) {
+    return(((code >= 0x0A80) && (code <= 0x0AFF)));
+}
+
+/**
+ * xmlUCSIsGurmukhi:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Gurmukhi UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsGurmukhi(int code) {
+    return(((code >= 0x0A00) && (code <= 0x0A7F)));
+}
+
+/**
+ * xmlUCSIsHalfwidthandFullwidthForms:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of HalfwidthandFullwidthForms UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsHalfwidthandFullwidthForms(int code) {
+    return(((code >= 0xFF00) && (code <= 0xFFEF)));
+}
+
+/**
+ * xmlUCSIsHangulCompatibilityJamo:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of HangulCompatibilityJamo UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsHangulCompatibilityJamo(int code) {
+    return(((code >= 0x3130) && (code <= 0x318F)));
+}
+
+/**
+ * xmlUCSIsHangulJamo:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of HangulJamo UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsHangulJamo(int code) {
+    return(((code >= 0x1100) && (code <= 0x11FF)));
+}
+
+/**
+ * xmlUCSIsHangulSyllables:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of HangulSyllables UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsHangulSyllables(int code) {
+    return(((code >= 0xAC00) && (code <= 0xD7AF)));
+}
+
+/**
+ * xmlUCSIsHanunoo:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Hanunoo UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsHanunoo(int code) {
+    return(((code >= 0x1720) && (code <= 0x173F)));
+}
+
+/**
+ * xmlUCSIsHebrew:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Hebrew UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsHebrew(int code) {
+    return(((code >= 0x0590) && (code <= 0x05FF)));
+}
+
+/**
+ * xmlUCSIsHighPrivateUseSurrogates:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of HighPrivateUseSurrogates UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsHighPrivateUseSurrogates(int code) {
+    return(((code >= 0xDB80) && (code <= 0xDBFF)));
+}
+
+/**
+ * xmlUCSIsHighSurrogates:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of HighSurrogates UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsHighSurrogates(int code) {
+    return(((code >= 0xD800) && (code <= 0xDB7F)));
+}
+
+/**
+ * xmlUCSIsHiragana:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Hiragana UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsHiragana(int code) {
+    return(((code >= 0x3040) && (code <= 0x309F)));
+}
+
+/**
+ * xmlUCSIsIPAExtensions:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of IPAExtensions UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsIPAExtensions(int code) {
+    return(((code >= 0x0250) && (code <= 0x02AF)));
+}
+
+/**
+ * xmlUCSIsIdeographicDescriptionCharacters:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of IdeographicDescriptionCharacters UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsIdeographicDescriptionCharacters(int code) {
+    return(((code >= 0x2FF0) && (code <= 0x2FFF)));
+}
+
+/**
+ * xmlUCSIsKanbun:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Kanbun UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsKanbun(int code) {
+    return(((code >= 0x3190) && (code <= 0x319F)));
+}
+
+/**
+ * xmlUCSIsKangxiRadicals:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of KangxiRadicals UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsKangxiRadicals(int code) {
+    return(((code >= 0x2F00) && (code <= 0x2FDF)));
+}
+
+/**
+ * xmlUCSIsKannada:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Kannada UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsKannada(int code) {
+    return(((code >= 0x0C80) && (code <= 0x0CFF)));
+}
+
+/**
+ * xmlUCSIsKatakana:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Katakana UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsKatakana(int code) {
+    return(((code >= 0x30A0) && (code <= 0x30FF)));
+}
+
+/**
+ * xmlUCSIsKatakanaPhoneticExtensions:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of KatakanaPhoneticExtensions UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsKatakanaPhoneticExtensions(int code) {
+    return(((code >= 0x31F0) && (code <= 0x31FF)));
+}
+
+/**
+ * xmlUCSIsKhmer:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Khmer UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsKhmer(int code) {
+    return(((code >= 0x1780) && (code <= 0x17FF)));
+}
+
+/**
+ * xmlUCSIsKhmerSymbols:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of KhmerSymbols UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsKhmerSymbols(int code) {
+    return(((code >= 0x19E0) && (code <= 0x19FF)));
+}
+
+/**
+ * xmlUCSIsLao:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Lao UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsLao(int code) {
+    return(((code >= 0x0E80) && (code <= 0x0EFF)));
+}
+
+/**
+ * xmlUCSIsLatin1Supplement:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Latin-1Supplement UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsLatin1Supplement(int code) {
+    return(((code >= 0x0080) && (code <= 0x00FF)));
+}
+
+/**
+ * xmlUCSIsLatinExtendedA:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of LatinExtended-A UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsLatinExtendedA(int code) {
+    return(((code >= 0x0100) && (code <= 0x017F)));
+}
+
+/**
+ * xmlUCSIsLatinExtendedB:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of LatinExtended-B UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsLatinExtendedB(int code) {
+    return(((code >= 0x0180) && (code <= 0x024F)));
+}
+
+/**
+ * xmlUCSIsLatinExtendedAdditional:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of LatinExtendedAdditional UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsLatinExtendedAdditional(int code) {
+    return(((code >= 0x1E00) && (code <= 0x1EFF)));
+}
+
+/**
+ * xmlUCSIsLetterlikeSymbols:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of LetterlikeSymbols UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsLetterlikeSymbols(int code) {
+    return(((code >= 0x2100) && (code <= 0x214F)));
+}
+
+/**
+ * xmlUCSIsLimbu:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Limbu UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsLimbu(int code) {
+    return(((code >= 0x1900) && (code <= 0x194F)));
+}
+
+/**
+ * xmlUCSIsLinearBIdeograms:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of LinearBIdeograms UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsLinearBIdeograms(int code) {
+    return(((code >= 0x10080) && (code <= 0x100FF)));
+}
+
+/**
+ * xmlUCSIsLinearBSyllabary:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of LinearBSyllabary UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsLinearBSyllabary(int code) {
+    return(((code >= 0x10000) && (code <= 0x1007F)));
+}
+
+/**
+ * xmlUCSIsLowSurrogates:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of LowSurrogates UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsLowSurrogates(int code) {
+    return(((code >= 0xDC00) && (code <= 0xDFFF)));
+}
+
+/**
+ * xmlUCSIsMalayalam:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Malayalam UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsMalayalam(int code) {
+    return(((code >= 0x0D00) && (code <= 0x0D7F)));
+}
+
+/**
+ * xmlUCSIsMathematicalAlphanumericSymbols:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of MathematicalAlphanumericSymbols UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsMathematicalAlphanumericSymbols(int code) {
+    return(((code >= 0x1D400) && (code <= 0x1D7FF)));
+}
+
+/**
+ * xmlUCSIsMathematicalOperators:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of MathematicalOperators UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsMathematicalOperators(int code) {
+    return(((code >= 0x2200) && (code <= 0x22FF)));
+}
+
+/**
+ * xmlUCSIsMiscellaneousMathematicalSymbolsA:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of MiscellaneousMathematicalSymbols-A UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsMiscellaneousMathematicalSymbolsA(int code) {
+    return(((code >= 0x27C0) && (code <= 0x27EF)));
+}
+
+/**
+ * xmlUCSIsMiscellaneousMathematicalSymbolsB:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of MiscellaneousMathematicalSymbols-B UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsMiscellaneousMathematicalSymbolsB(int code) {
+    return(((code >= 0x2980) && (code <= 0x29FF)));
+}
+
+/**
+ * xmlUCSIsMiscellaneousSymbols:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of MiscellaneousSymbols UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsMiscellaneousSymbols(int code) {
+    return(((code >= 0x2600) && (code <= 0x26FF)));
+}
+
+/**
+ * xmlUCSIsMiscellaneousSymbolsandArrows:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of MiscellaneousSymbolsandArrows UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsMiscellaneousSymbolsandArrows(int code) {
+    return(((code >= 0x2B00) && (code <= 0x2BFF)));
+}
+
+/**
+ * xmlUCSIsMiscellaneousTechnical:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of MiscellaneousTechnical UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsMiscellaneousTechnical(int code) {
+    return(((code >= 0x2300) && (code <= 0x23FF)));
+}
+
+/**
+ * xmlUCSIsMongolian:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Mongolian UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsMongolian(int code) {
+    return(((code >= 0x1800) && (code <= 0x18AF)));
+}
+
+/**
+ * xmlUCSIsMusicalSymbols:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of MusicalSymbols UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsMusicalSymbols(int code) {
+    return(((code >= 0x1D100) && (code <= 0x1D1FF)));
+}
+
+/**
+ * xmlUCSIsMyanmar:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Myanmar UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsMyanmar(int code) {
+    return(((code >= 0x1000) && (code <= 0x109F)));
+}
+
+/**
+ * xmlUCSIsNumberForms:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of NumberForms UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsNumberForms(int code) {
+    return(((code >= 0x2150) && (code <= 0x218F)));
+}
+
+/**
+ * xmlUCSIsOgham:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Ogham UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsOgham(int code) {
+    return(((code >= 0x1680) && (code <= 0x169F)));
+}
+
+/**
+ * xmlUCSIsOldItalic:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of OldItalic UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsOldItalic(int code) {
+    return(((code >= 0x10300) && (code <= 0x1032F)));
+}
+
+/**
+ * xmlUCSIsOpticalCharacterRecognition:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of OpticalCharacterRecognition UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsOpticalCharacterRecognition(int code) {
+    return(((code >= 0x2440) && (code <= 0x245F)));
+}
+
+/**
+ * xmlUCSIsOriya:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Oriya UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsOriya(int code) {
+    return(((code >= 0x0B00) && (code <= 0x0B7F)));
+}
+
+/**
+ * xmlUCSIsOsmanya:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Osmanya UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsOsmanya(int code) {
+    return(((code >= 0x10480) && (code <= 0x104AF)));
+}
+
+/**
+ * xmlUCSIsPhoneticExtensions:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of PhoneticExtensions UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsPhoneticExtensions(int code) {
+    return(((code >= 0x1D00) && (code <= 0x1D7F)));
+}
+
+/**
+ * xmlUCSIsPrivateUse:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of PrivateUse UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsPrivateUse(int code) {
+    return(((code >= 0xE000) && (code <= 0xF8FF)) ||
+           ((code >= 0xF0000) && (code <= 0xFFFFF)) ||
+           ((code >= 0x100000) && (code <= 0x10FFFF)));
+}
+
+/**
+ * xmlUCSIsPrivateUseArea:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of PrivateUseArea UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsPrivateUseArea(int code) {
+    return(((code >= 0xE000) && (code <= 0xF8FF)));
+}
+
+/**
+ * xmlUCSIsRunic:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Runic UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsRunic(int code) {
+    return(((code >= 0x16A0) && (code <= 0x16FF)));
+}
+
+/**
+ * xmlUCSIsShavian:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Shavian UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsShavian(int code) {
+    return(((code >= 0x10450) && (code <= 0x1047F)));
+}
+
+/**
+ * xmlUCSIsSinhala:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Sinhala UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsSinhala(int code) {
+    return(((code >= 0x0D80) && (code <= 0x0DFF)));
+}
+
+/**
+ * xmlUCSIsSmallFormVariants:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of SmallFormVariants UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsSmallFormVariants(int code) {
+    return(((code >= 0xFE50) && (code <= 0xFE6F)));
+}
+
+/**
+ * xmlUCSIsSpacingModifierLetters:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of SpacingModifierLetters UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsSpacingModifierLetters(int code) {
+    return(((code >= 0x02B0) && (code <= 0x02FF)));
+}
+
+/**
+ * xmlUCSIsSpecials:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Specials UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsSpecials(int code) {
+    return(((code >= 0xFFF0) && (code <= 0xFFFF)));
+}
+
+/**
+ * xmlUCSIsSuperscriptsandSubscripts:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of SuperscriptsandSubscripts UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsSuperscriptsandSubscripts(int code) {
+    return(((code >= 0x2070) && (code <= 0x209F)));
+}
+
+/**
+ * xmlUCSIsSupplementalArrowsA:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of SupplementalArrows-A UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsSupplementalArrowsA(int code) {
+    return(((code >= 0x27F0) && (code <= 0x27FF)));
+}
+
+/**
+ * xmlUCSIsSupplementalArrowsB:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of SupplementalArrows-B UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsSupplementalArrowsB(int code) {
+    return(((code >= 0x2900) && (code <= 0x297F)));
+}
+
+/**
+ * xmlUCSIsSupplementalMathematicalOperators:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of SupplementalMathematicalOperators UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsSupplementalMathematicalOperators(int code) {
+    return(((code >= 0x2A00) && (code <= 0x2AFF)));
+}
+
+/**
+ * xmlUCSIsSupplementaryPrivateUseAreaA:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of SupplementaryPrivateUseArea-A UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsSupplementaryPrivateUseAreaA(int code) {
+    return(((code >= 0xF0000) && (code <= 0xFFFFF)));
+}
+
+/**
+ * xmlUCSIsSupplementaryPrivateUseAreaB:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of SupplementaryPrivateUseArea-B UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsSupplementaryPrivateUseAreaB(int code) {
+    return(((code >= 0x100000) && (code <= 0x10FFFF)));
+}
+
+/**
+ * xmlUCSIsSyriac:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Syriac UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsSyriac(int code) {
+    return(((code >= 0x0700) && (code <= 0x074F)));
+}
+
+/**
+ * xmlUCSIsTagalog:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Tagalog UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsTagalog(int code) {
+    return(((code >= 0x1700) && (code <= 0x171F)));
+}
+
+/**
+ * xmlUCSIsTagbanwa:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Tagbanwa UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsTagbanwa(int code) {
+    return(((code >= 0x1760) && (code <= 0x177F)));
+}
+
+/**
+ * xmlUCSIsTags:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Tags UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsTags(int code) {
+    return(((code >= 0xE0000) && (code <= 0xE007F)));
+}
+
+/**
+ * xmlUCSIsTaiLe:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of TaiLe UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsTaiLe(int code) {
+    return(((code >= 0x1950) && (code <= 0x197F)));
+}
+
+/**
+ * xmlUCSIsTaiXuanJingSymbols:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of TaiXuanJingSymbols UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsTaiXuanJingSymbols(int code) {
+    return(((code >= 0x1D300) && (code <= 0x1D35F)));
+}
+
+/**
+ * xmlUCSIsTamil:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Tamil UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsTamil(int code) {
+    return(((code >= 0x0B80) && (code <= 0x0BFF)));
+}
+
+/**
+ * xmlUCSIsTelugu:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Telugu UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsTelugu(int code) {
+    return(((code >= 0x0C00) && (code <= 0x0C7F)));
+}
+
+/**
+ * xmlUCSIsThaana:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Thaana UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsThaana(int code) {
+    return(((code >= 0x0780) && (code <= 0x07BF)));
+}
+
+/**
+ * xmlUCSIsThai:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Thai UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsThai(int code) {
+    return(((code >= 0x0E00) && (code <= 0x0E7F)));
+}
+
+/**
+ * xmlUCSIsTibetan:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Tibetan UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsTibetan(int code) {
+    return(((code >= 0x0F00) && (code <= 0x0FFF)));
+}
+
+/**
+ * xmlUCSIsUgaritic:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Ugaritic UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsUgaritic(int code) {
+    return(((code >= 0x10380) && (code <= 0x1039F)));
+}
+
+/**
+ * xmlUCSIsUnifiedCanadianAboriginalSyllabics:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of UnifiedCanadianAboriginalSyllabics UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsUnifiedCanadianAboriginalSyllabics(int code) {
+    return(((code >= 0x1400) && (code <= 0x167F)));
+}
+
+/**
+ * xmlUCSIsVariationSelectors:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of VariationSelectors UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsVariationSelectors(int code) {
+    return(((code >= 0xFE00) && (code <= 0xFE0F)));
+}
+
+/**
+ * xmlUCSIsVariationSelectorsSupplement:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of VariationSelectorsSupplement UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsVariationSelectorsSupplement(int code) {
+    return(((code >= 0xE0100) && (code <= 0xE01EF)));
+}
+
+/**
+ * xmlUCSIsYiRadicals:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of YiRadicals UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsYiRadicals(int code) {
+    return(((code >= 0xA490) && (code <= 0xA4CF)));
+}
+
+/**
+ * xmlUCSIsYiSyllables:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of YiSyllables UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsYiSyllables(int code) {
+    return(((code >= 0xA000) && (code <= 0xA48F)));
+}
+
+/**
+ * xmlUCSIsYijingHexagramSymbols:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of YijingHexagramSymbols UCS Block
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsYijingHexagramSymbols(int code) {
+    return(((code >= 0x4DC0) && (code <= 0x4DFF)));
+}
+
+/**
+ * xmlUCSIsBlock:
+ * @code: UCS code point
+ * @block: UCS block name
+ *
+ * Check whether the character is part of the UCS Block
+ *
+ * Returns 1 if true, 0 if false and -1 on unknown block
+ */
+int
+xmlUCSIsBlock(int code, const char *block) {
+    xmlIntFunc *func;
+
+    func = xmlUnicodeLookup(&xmlUnicodeBlockTbl, block);
+    if (func == NULL)
+	return (-1);
+    return (func(code));
+}
+
+/**
+ * xmlUCSIsCatC:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of C UCS Category
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsCatC(int code) {
+    return(xmlCharInRange((unsigned int)code, &xmlCG));
+}
+
+/**
+ * xmlUCSIsCatCc:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Cc UCS Category
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsCatCc(int code) {
+    return(((code >= 0x0) && (code <= 0x1f)) ||
+           ((code >= 0x7f) && (code <= 0x9f)));
+}
+
+/**
+ * xmlUCSIsCatCf:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Cf UCS Category
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsCatCf(int code) {
+    return(xmlCharInRange((unsigned int)code, &xmlCfG));
+}
+
+/**
+ * xmlUCSIsCatCo:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Co UCS Category
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsCatCo(int code) {
+    return((code == 0xe000) ||
+           (code == 0xf8ff) ||
+           (code == 0xf0000) ||
+           (code == 0xffffd) ||
+           (code == 0x100000) ||
+           (code == 0x10fffd));
+}
+
+/**
+ * xmlUCSIsCatCs:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Cs UCS Category
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsCatCs(int code) {
+    return((code == 0xd800) ||
+           ((code >= 0xdb7f) && (code <= 0xdb80)) ||
+           ((code >= 0xdbff) && (code <= 0xdc00)) ||
+           (code == 0xdfff));
+}
+
+/**
+ * xmlUCSIsCatL:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of L UCS Category
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsCatL(int code) {
+    return(xmlCharInRange((unsigned int)code, &xmlLG));
+}
+
+/**
+ * xmlUCSIsCatLl:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Ll UCS Category
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsCatLl(int code) {
+    return(xmlCharInRange((unsigned int)code, &xmlLlG));
+}
+
+/**
+ * xmlUCSIsCatLm:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Lm UCS Category
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsCatLm(int code) {
+    return(xmlCharInRange((unsigned int)code, &xmlLmG));
+}
+
+/**
+ * xmlUCSIsCatLo:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Lo UCS Category
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsCatLo(int code) {
+    return(xmlCharInRange((unsigned int)code, &xmlLoG));
+}
+
+/**
+ * xmlUCSIsCatLt:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Lt UCS Category
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsCatLt(int code) {
+    return(xmlCharInRange((unsigned int)code, &xmlLtG));
+}
+
+/**
+ * xmlUCSIsCatLu:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Lu UCS Category
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsCatLu(int code) {
+    return(xmlCharInRange((unsigned int)code, &xmlLuG));
+}
+
+/**
+ * xmlUCSIsCatM:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of M UCS Category
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsCatM(int code) {
+    return(xmlCharInRange((unsigned int)code, &xmlMG));
+}
+
+/**
+ * xmlUCSIsCatMc:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Mc UCS Category
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsCatMc(int code) {
+    return(xmlCharInRange((unsigned int)code, &xmlMcG));
+}
+
+/**
+ * xmlUCSIsCatMe:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Me UCS Category
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsCatMe(int code) {
+    return(((code >= 0x488) && (code <= 0x489)) ||
+           (code == 0x6de) ||
+           ((code >= 0x20dd) && (code <= 0x20e0)) ||
+           ((code >= 0x20e2) && (code <= 0x20e4)));
+}
+
+/**
+ * xmlUCSIsCatMn:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Mn UCS Category
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsCatMn(int code) {
+    return(xmlCharInRange((unsigned int)code, &xmlMnG));
+}
+
+/**
+ * xmlUCSIsCatN:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of N UCS Category
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsCatN(int code) {
+    return(xmlCharInRange((unsigned int)code, &xmlNG));
+}
+
+/**
+ * xmlUCSIsCatNd:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Nd UCS Category
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsCatNd(int code) {
+    return(xmlCharInRange((unsigned int)code, &xmlNdG));
+}
+
+/**
+ * xmlUCSIsCatNl:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Nl UCS Category
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsCatNl(int code) {
+    return(((code >= 0x16ee) && (code <= 0x16f0)) ||
+           ((code >= 0x2160) && (code <= 0x2183)) ||
+           (code == 0x3007) ||
+           ((code >= 0x3021) && (code <= 0x3029)) ||
+           ((code >= 0x3038) && (code <= 0x303a)) ||
+           (code == 0x1034a));
+}
+
+/**
+ * xmlUCSIsCatNo:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of No UCS Category
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsCatNo(int code) {
+    return(xmlCharInRange((unsigned int)code, &xmlNoG));
+}
+
+/**
+ * xmlUCSIsCatP:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of P UCS Category
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsCatP(int code) {
+    return(xmlCharInRange((unsigned int)code, &xmlPG));
+}
+
+/**
+ * xmlUCSIsCatPc:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Pc UCS Category
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsCatPc(int code) {
+    return((code == 0x5f) ||
+           ((code >= 0x203f) && (code <= 0x2040)) ||
+           (code == 0x2054) ||
+           (code == 0x30fb) ||
+           ((code >= 0xfe33) && (code <= 0xfe34)) ||
+           ((code >= 0xfe4d) && (code <= 0xfe4f)) ||
+           (code == 0xff3f) ||
+           (code == 0xff65));
+}
+
+/**
+ * xmlUCSIsCatPd:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Pd UCS Category
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsCatPd(int code) {
+    return(xmlCharInRange((unsigned int)code, &xmlPdG));
+}
+
+/**
+ * xmlUCSIsCatPe:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Pe UCS Category
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsCatPe(int code) {
+    return(xmlCharInRange((unsigned int)code, &xmlPeG));
+}
+
+/**
+ * xmlUCSIsCatPf:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Pf UCS Category
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsCatPf(int code) {
+    return((code == 0xbb) ||
+           (code == 0x2019) ||
+           (code == 0x201d) ||
+           (code == 0x203a));
+}
+
+/**
+ * xmlUCSIsCatPi:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Pi UCS Category
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsCatPi(int code) {
+    return((code == 0xab) ||
+           (code == 0x2018) ||
+           ((code >= 0x201b) && (code <= 0x201c)) ||
+           (code == 0x201f) ||
+           (code == 0x2039));
+}
+
+/**
+ * xmlUCSIsCatPo:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Po UCS Category
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsCatPo(int code) {
+    return(xmlCharInRange((unsigned int)code, &xmlPoG));
+}
+
+/**
+ * xmlUCSIsCatPs:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Ps UCS Category
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsCatPs(int code) {
+    return(xmlCharInRange((unsigned int)code, &xmlPsG));
+}
+
+/**
+ * xmlUCSIsCatS:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of S UCS Category
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsCatS(int code) {
+    return(xmlCharInRange((unsigned int)code, &xmlSG));
+}
+
+/**
+ * xmlUCSIsCatSc:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Sc UCS Category
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsCatSc(int code) {
+    return(xmlCharInRange((unsigned int)code, &xmlScG));
+}
+
+/**
+ * xmlUCSIsCatSk:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Sk UCS Category
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsCatSk(int code) {
+    return(xmlCharInRange((unsigned int)code, &xmlSkG));
+}
+
+/**
+ * xmlUCSIsCatSm:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Sm UCS Category
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsCatSm(int code) {
+    return(xmlCharInRange((unsigned int)code, &xmlSmG));
+}
+
+/**
+ * xmlUCSIsCatSo:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of So UCS Category
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsCatSo(int code) {
+    return(xmlCharInRange((unsigned int)code, &xmlSoG));
+}
+
+/**
+ * xmlUCSIsCatZ:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Z UCS Category
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsCatZ(int code) {
+    return(xmlCharInRange((unsigned int)code, &xmlZG));
+}
+
+/**
+ * xmlUCSIsCatZl:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Zl UCS Category
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsCatZl(int code) {
+    return((code == 0x2028));
+}
+
+/**
+ * xmlUCSIsCatZp:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Zp UCS Category
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsCatZp(int code) {
+    return((code == 0x2029));
+}
+
+/**
+ * xmlUCSIsCatZs:
+ * @code: UCS code point
+ *
+ * Check whether the character is part of Zs UCS Category
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlUCSIsCatZs(int code) {
+    return((code == 0x20) ||
+           (code == 0xa0) ||
+           (code == 0x1680) ||
+           (code == 0x180e) ||
+           ((code >= 0x2000) && (code <= 0x200b)) ||
+           (code == 0x202f) ||
+           (code == 0x205f) ||
+           (code == 0x3000));
+}
+
+/**
+ * xmlUCSIsCat:
+ * @code: UCS code point
+ * @cat: UCS Category name
+ *
+ * Check whether the character is part of the UCS Category
+ *
+ * Returns 1 if true, 0 if false and -1 on unknown category
+ */
+int
+xmlUCSIsCat(int code, const char *cat) {
+    xmlIntFunc *func;
+
+    func = xmlUnicodeLookup(&xmlUnicodeCatTbl, cat);
+    if (func == NULL)
+	return (-1);
+    return (func(code));
+}
+
+
+#endif /* LIBXML_UNICODE_ENABLED */
diff --git a/src/libxml/src/xmlwriter.c b/src/libxml/src/xmlwriter.c
new file mode 100644
index 0000000..fc2b066
--- /dev/null
+++ b/src/libxml/src/xmlwriter.c
@@ -0,0 +1,4504 @@
+
+/*
+ * xmlwriter.c: XML text writer implementation
+ *
+ * For license and disclaimer see the license and disclaimer of
+ * libxml2.
+ *
+ * alfred@mickautsch.de
+ */
+
+#define IN_LIBXML
+#include <string.h>
+
+#include "libxml.h"
+#include <libxml/xmlmemory.h>
+#include <libxml/parser.h>
+#include <libxml/uri.h>
+#include <libxml/HTMLtree.h>
+
+#ifdef LIBXML_WRITER_ENABLED
+
+#include <libxml/xmlwriter.h>
+
+#define B64LINELEN 72
+#define B64CRLF "\r\n"
+
+/*
+ * Types are kept private
+ */
+typedef enum {
+    XML_TEXTWRITER_NONE = 0,
+    XML_TEXTWRITER_NAME,
+    XML_TEXTWRITER_ATTRIBUTE,
+    XML_TEXTWRITER_TEXT,
+    XML_TEXTWRITER_PI,
+    XML_TEXTWRITER_PI_TEXT,
+    XML_TEXTWRITER_CDATA,
+    XML_TEXTWRITER_DTD,
+    XML_TEXTWRITER_DTD_TEXT,
+    XML_TEXTWRITER_DTD_ELEM,
+    XML_TEXTWRITER_DTD_ELEM_TEXT,
+    XML_TEXTWRITER_DTD_ATTL,
+    XML_TEXTWRITER_DTD_ATTL_TEXT,
+    XML_TEXTWRITER_DTD_ENTY,    /* entity */
+    XML_TEXTWRITER_DTD_ENTY_TEXT,
+    XML_TEXTWRITER_DTD_PENT,    /* parameter entity */
+    XML_TEXTWRITER_COMMENT
+} xmlTextWriterState;
+
+typedef struct _xmlTextWriterStackEntry xmlTextWriterStackEntry;
+
+struct _xmlTextWriterStackEntry {
+    xmlChar *name;
+    xmlTextWriterState state;
+};
+
+typedef struct _xmlTextWriterNsStackEntry xmlTextWriterNsStackEntry;
+struct _xmlTextWriterNsStackEntry {
+    xmlChar *prefix;
+    xmlChar *uri;
+    xmlLinkPtr elem;
+};
+
+struct _xmlTextWriter {
+    xmlOutputBufferPtr out;     /* output buffer */
+    xmlListPtr nodes;           /* element name stack */
+    xmlListPtr nsstack;         /* name spaces stack */
+    int level;
+    int indent;                 /* enable indent */
+    int doindent;               /* internal indent flag */
+    xmlChar *ichar;             /* indent character */
+    char qchar;                 /* character used for quoting attribute values */
+    xmlParserCtxtPtr ctxt;
+};
+
+static void xmlFreeTextWriterStackEntry(xmlLinkPtr lk);
+static int xmlCmpTextWriterStackEntry(const void *data0,
+                                      const void *data1);
+static void xmlFreeTextWriterNsStackEntry(xmlLinkPtr lk);
+static int xmlCmpTextWriterNsStackEntry(const void *data0,
+                                        const void *data1);
+static int xmlTextWriterWriteMemCallback(void *context,
+                                         const xmlChar * str, int len);
+static int xmlTextWriterCloseMemCallback(void *context);
+static int xmlTextWriterWriteDocCallback(void *context,
+                                         const xmlChar * str, int len);
+static int xmlTextWriterCloseDocCallback(void *context);
+
+static xmlChar *xmlTextWriterVSprintf(const char *format, va_list argptr);
+static int xmlOutputBufferWriteBase64(xmlOutputBufferPtr out, int len,
+                                      const unsigned char *data);
+static void xmlTextWriterStartDocumentCallback(void *ctx);
+static int xmlTextWriterWriteIndent(xmlTextWriterPtr writer);
+static int
+  xmlTextWriterHandleStateDependencies(xmlTextWriterPtr writer,
+                                       xmlTextWriterStackEntry * p);
+
+/**
+ * xmlNewTextWriter:
+ * @out:  an xmlOutputBufferPtr
+ *
+ * Create a new xmlNewTextWriter structure using an xmlOutputBufferPtr
+ *
+ * Returns the new xmlTextWriterPtr or NULL in case of error
+ */
+xmlTextWriterPtr
+xmlNewTextWriter(xmlOutputBufferPtr out)
+{
+    xmlTextWriterPtr ret;
+
+    ret = (xmlTextWriterPtr) xmlMalloc(sizeof(xmlTextWriter));
+    if (ret == NULL) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlNewTextWriter : out of memory!\n");
+        return NULL;
+    }
+    memset(ret, 0, (size_t) sizeof(xmlTextWriter));
+
+    ret->nodes = xmlListCreate((xmlListDeallocator)
+                               xmlFreeTextWriterStackEntry,
+                               (xmlListDataCompare)
+                               xmlCmpTextWriterStackEntry);
+    if (ret->nodes == NULL) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlNewTextWriter : out of memory!\n");
+        xmlFree(ret);
+        return NULL;
+    }
+
+    ret->nsstack = xmlListCreate((xmlListDeallocator)
+                                 xmlFreeTextWriterNsStackEntry,
+                                 (xmlListDataCompare)
+                                 xmlCmpTextWriterNsStackEntry);
+    if (ret->nsstack == NULL) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlNewTextWriter : out of memory!\n");
+        xmlListDelete(ret->nodes);
+        xmlFree(ret);
+        return NULL;
+    }
+
+    ret->out = out;
+    ret->ichar = xmlStrdup(BAD_CAST " ");
+    ret->qchar = '"';
+
+    if (!ret->ichar) {
+        xmlListDelete(ret->nodes);
+        xmlListDelete(ret->nsstack);
+        xmlFree(ret);
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlNewTextWriter : out of memory!\n");
+        return NULL;
+    }
+
+    return ret;
+}
+
+/**
+ * xmlNewTextWriterFilename:
+ * @uri:  the URI of the resource for the output
+ * @compression:  compress the output?
+ *
+ * Create a new xmlNewTextWriter structure with @uri as output
+ *
+ * Returns the new xmlTextWriterPtr or NULL in case of error
+ */
+xmlTextWriterPtr
+xmlNewTextWriterFilename(const char *uri, int compression)
+{
+    xmlTextWriterPtr ret;
+    xmlOutputBufferPtr out;
+
+    out = xmlOutputBufferCreateFilename(uri, NULL, compression);
+    if (out == NULL) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlNewTextWriterFilename : out of memory!\n");
+        return NULL;
+    }
+
+    ret = xmlNewTextWriter(out);
+    if (ret == NULL) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlNewTextWriterFilename : out of memory!\n");
+        xmlOutputBufferClose(out);
+        return NULL;
+    }
+
+    ret->indent = 0;
+    ret->doindent = 0;
+    return ret;
+}
+
+/**
+ * xmlNewTextWriterMemory:
+ * @buf:  xmlBufferPtr
+ * @compression:  compress the output?
+ *
+ * Create a new xmlNewTextWriter structure with @buf as output
+ * TODO: handle compression
+ *
+ * Returns the new xmlTextWriterPtr or NULL in case of error
+ */
+xmlTextWriterPtr
+xmlNewTextWriterMemory(xmlBufferPtr buf, int compression ATTRIBUTE_UNUSED)
+{
+    xmlTextWriterPtr ret;
+    xmlOutputBufferPtr out;
+
+/*::todo handle compression */
+    out = xmlOutputBufferCreateIO((xmlOutputWriteCallback)
+                                  xmlTextWriterWriteMemCallback,
+                                  (xmlOutputCloseCallback)
+                                  xmlTextWriterCloseMemCallback,
+                                  (void *) buf, NULL);
+    if (out == NULL) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlNewTextWriterMemory : out of memory!\n");
+        return NULL;
+    }
+
+    ret = xmlNewTextWriter(out);
+    if (ret == NULL) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlNewTextWriterMemory : out of memory!\n");
+        xmlOutputBufferClose(out);
+        return NULL;
+    }
+
+    return ret;
+}
+
+/**
+ * xmlNewTextWriterPushParser:
+ * @ctxt: xmlParserCtxtPtr to hold the new XML document tree
+ * @compression:  compress the output?
+ *
+ * Create a new xmlNewTextWriter structure with @ctxt as output
+ * TODO: handle compression
+ *
+ * Returns the new xmlTextWriterPtr or NULL in case of error
+ */
+xmlTextWriterPtr
+xmlNewTextWriterPushParser(xmlParserCtxtPtr ctxt,
+                           int compression ATTRIBUTE_UNUSED)
+{
+    xmlTextWriterPtr ret;
+    xmlOutputBufferPtr out;
+
+    if (ctxt == NULL) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlNewTextWriterPushParser : invalid context!\n");
+        return NULL;
+    }
+
+    out = xmlOutputBufferCreateIO((xmlOutputWriteCallback)
+                                  xmlTextWriterWriteDocCallback,
+                                  (xmlOutputCloseCallback)
+                                  xmlTextWriterCloseDocCallback,
+                                  (void *) ctxt, NULL);
+    if (out == NULL) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlNewTextWriterPushParser : error at xmlOutputBufferCreateIO!\n");
+        return NULL;
+    }
+
+    ret = xmlNewTextWriter(out);
+    if (ret == NULL) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlNewTextWriterPushParser : error at xmlNewTextWriter!\n");
+        xmlOutputBufferClose(out);
+        return NULL;
+    }
+
+    ret->ctxt = ctxt;
+
+    return ret;
+}
+
+/**
+ * xmlNewTextWriterDoc:
+ * @doc: address of a xmlDocPtr to hold the new XML document tree
+ * @compression:  compress the output?
+ *
+ * Create a new xmlNewTextWriter structure with @*doc as output
+ *
+ * Returns the new xmlTextWriterPtr or NULL in case of error
+ */
+xmlTextWriterPtr
+xmlNewTextWriterDoc(xmlDocPtr * doc, int compression)
+{
+    xmlTextWriterPtr ret;
+    xmlSAXHandler saxHandler;
+    xmlParserCtxtPtr ctxt;
+
+    memset(&saxHandler, '\0', sizeof(saxHandler));
+    xmlSAX2InitDefaultSAXHandler(&saxHandler, 1);
+    saxHandler.startDocument = xmlTextWriterStartDocumentCallback;
+    saxHandler.startElement = xmlSAX2StartElement;
+    saxHandler.endElement = xmlSAX2EndElement;
+
+    ctxt = xmlCreatePushParserCtxt(&saxHandler, NULL, NULL, 0, NULL);
+    if (ctxt == NULL) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlNewTextWriterDoc : error at xmlCreatePushParserCtxt!\n");
+        return NULL;
+    }
+
+    ctxt->myDoc = xmlNewDoc(BAD_CAST XML_DEFAULT_VERSION);
+    if (ctxt->myDoc == NULL) {
+        xmlFreeParserCtxt(ctxt);
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlNewTextWriterDoc : error at xmlNewDoc!\n");
+        return NULL;
+    }
+
+    ret = xmlNewTextWriterPushParser(ctxt, compression);
+    if (ret == NULL) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlNewTextWriterDoc : error at xmlNewTextWriterPushParser!\n");
+        return NULL;
+    }
+
+    xmlSetDocCompressMode(ctxt->myDoc, compression);
+
+    if (doc != NULL)
+        *doc = ctxt->myDoc;
+
+    return ret;
+}
+
+/**
+ * xmlNewTextWriterTree:
+ * @doc: xmlDocPtr
+ * @node: xmlNodePtr or NULL for doc->children
+ * @compression:  compress the output?
+ *
+ * Create a new xmlNewTextWriter structure with @doc as output
+ * starting at @node
+ *
+ * Returns the new xmlTextWriterPtr or NULL in case of error
+ */
+xmlTextWriterPtr
+xmlNewTextWriterTree(xmlDocPtr doc, xmlNodePtr node, int compression)
+{
+    xmlTextWriterPtr ret;
+    xmlSAXHandler saxHandler;
+    xmlParserCtxtPtr ctxt;
+
+    if (doc == NULL) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlNewTextWriterTree : invalid document tree!\n");
+        return NULL;
+    }
+
+    memset(&saxHandler, '\0', sizeof(saxHandler));
+    xmlSAX2InitDefaultSAXHandler(&saxHandler, 1);
+    saxHandler.startDocument = xmlTextWriterStartDocumentCallback;
+    saxHandler.startElement = xmlSAX2StartElement;
+    saxHandler.endElement = xmlSAX2EndElement;
+
+    ctxt = xmlCreatePushParserCtxt(&saxHandler, NULL, NULL, 0, NULL);
+    if (ctxt == NULL) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlNewTextWriterDoc : error at xmlCreatePushParserCtxt!\n");
+        return NULL;
+    }
+
+    ret = xmlNewTextWriterPushParser(ctxt, compression);
+    if (ret == NULL) {
+        xmlFreeParserCtxt(ctxt);
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlNewTextWriterDoc : error at xmlNewTextWriterPushParser!\n");
+        return NULL;
+    }
+
+    ctxt->myDoc = doc;
+    ctxt->node = node;
+
+    xmlSetDocCompressMode(doc, compression);
+
+    return ret;
+}
+
+/**
+ * xmlFreeTextWriter:
+ * @writer:  the xmlTextWriterPtr
+ *
+ * Deallocate all the resources associated to the writer
+ */
+void
+xmlFreeTextWriter(xmlTextWriterPtr writer)
+{
+    if (writer == NULL)
+        return;
+
+    if (writer->out != NULL)
+        xmlOutputBufferClose(writer->out);
+
+    if (writer->nodes != NULL)
+        xmlListDelete(writer->nodes);
+
+    if (writer->nsstack != NULL)
+        xmlListDelete(writer->nsstack);
+
+    if (writer->ctxt != NULL)
+        xmlFreeParserCtxt(writer->ctxt);
+
+    if (writer->ichar != NULL)
+        xmlFree(writer->ichar);
+    xmlFree(writer);
+}
+
+/**
+ * xmlTextWriterStartDocument:
+ * @writer:  the xmlTextWriterPtr
+ * @version:  the xml version ("1.0") or NULL for default ("1.0")
+ * @encoding:  the encoding or NULL for default
+ * @standalone: "yes" or "no" or NULL for default
+ *
+ * Start a new xml document
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterStartDocument(xmlTextWriterPtr writer, const char *version,
+                           const char *encoding, const char *standalone)
+{
+    int count;
+    int sum;
+    xmlLinkPtr lk;
+    xmlCharEncodingHandlerPtr encoder;
+
+    if ((writer == NULL) || (writer->out == NULL)) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlTextWriterStartDocument : invalid writer!\n");
+        return -1;
+    }
+
+    lk = xmlListFront(writer->nodes);
+    if ((lk != NULL) && (xmlLinkGetData(lk) != NULL)) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlTextWriterStartDocument : not allowed in this context!\n");
+        return -1;
+    }
+
+    encoder = NULL;
+    if (encoding != NULL) {
+        encoder = xmlFindCharEncodingHandler(encoding);
+        if (encoder == NULL) {
+            xmlGenericError(xmlGenericErrorContext,
+                            "xmlTextWriterStartDocument : out of memory!\n");
+            return -1;
+        }
+    }
+
+    writer->out->encoder = encoder;
+    if (encoder != NULL) {
+        writer->out->conv = xmlBufferCreateSize(4000);
+        xmlCharEncOutFunc(encoder, writer->out->conv, NULL);
+    } else
+        writer->out->conv = NULL;
+
+    sum = 0;
+    count = xmlOutputBufferWriteString(writer->out, "<?xml version=");
+    if (count < 0)
+        return -1;
+    sum += count;
+    count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
+    if (count < 0)
+        return -1;
+    sum += count;
+    if (version != 0)
+        count = xmlOutputBufferWriteString(writer->out, version);
+    else
+        count = xmlOutputBufferWriteString(writer->out, "1.0");
+    if (count < 0)
+        return -1;
+    sum += count;
+    count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
+    if (count < 0)
+        return -1;
+    sum += count;
+    if (writer->out->encoder != 0) {
+        count = xmlOutputBufferWriteString(writer->out, " encoding=");
+        if (count < 0)
+            return -1;
+        sum += count;
+        count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
+        if (count < 0)
+            return -1;
+        sum += count;
+        count =
+            xmlOutputBufferWriteString(writer->out,
+                                       writer->out->encoder->name);
+        if (count < 0)
+            return -1;
+        sum += count;
+        count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
+        if (count < 0)
+            return -1;
+        sum += count;
+    }
+
+    if (standalone != 0) {
+        count = xmlOutputBufferWriteString(writer->out, " standalone=");
+        if (count < 0)
+            return -1;
+        sum += count;
+        count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
+        if (count < 0)
+            return -1;
+        sum += count;
+        count = xmlOutputBufferWriteString(writer->out, standalone);
+        if (count < 0)
+            return -1;
+        sum += count;
+        count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
+        if (count < 0)
+            return -1;
+        sum += count;
+    }
+
+    count = xmlOutputBufferWriteString(writer->out, "?>\n");
+    if (count < 0)
+        return -1;
+    sum += count;
+
+    return sum;
+}
+
+/**
+ * xmlTextWriterEndDocument:
+ * @writer:  the xmlTextWriterPtr
+ *
+ * End an xml document. All open elements are closed
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterEndDocument(xmlTextWriterPtr writer)
+{
+    int count;
+    int sum;
+    xmlLinkPtr lk;
+    xmlTextWriterStackEntry *p;
+
+    if (writer == NULL) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlTextWriterEndDocument : invalid writer!\n");
+        return -1;
+    }
+
+    sum = 0;
+    while ((lk = xmlListFront(writer->nodes)) != NULL) {
+        p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
+        if (p == 0)
+            break;
+        switch (p->state) {
+            case XML_TEXTWRITER_NAME:
+            case XML_TEXTWRITER_ATTRIBUTE:
+            case XML_TEXTWRITER_TEXT:
+                count = xmlTextWriterEndElement(writer);
+                if (count < 0)
+                    return -1;
+                sum += count;
+                break;
+            case XML_TEXTWRITER_PI:
+            case XML_TEXTWRITER_PI_TEXT:
+                count = xmlTextWriterEndPI(writer);
+                if (count < 0)
+                    return -1;
+                sum += count;
+                break;
+            case XML_TEXTWRITER_CDATA:
+                count = xmlTextWriterEndCDATA(writer);
+                if (count < 0)
+                    return -1;
+                sum += count;
+                break;
+            case XML_TEXTWRITER_DTD:
+            case XML_TEXTWRITER_DTD_TEXT:
+            case XML_TEXTWRITER_DTD_ELEM:
+            case XML_TEXTWRITER_DTD_ELEM_TEXT:
+            case XML_TEXTWRITER_DTD_ATTL:
+            case XML_TEXTWRITER_DTD_ATTL_TEXT:
+            case XML_TEXTWRITER_DTD_ENTY:
+            case XML_TEXTWRITER_DTD_ENTY_TEXT:
+            case XML_TEXTWRITER_DTD_PENT:
+                count = xmlTextWriterEndDTD(writer);
+                if (count < 0)
+                    return -1;
+                sum += count;
+                break;
+            case XML_TEXTWRITER_COMMENT:
+                count = xmlTextWriterEndComment(writer);
+                if (count < 0)
+                    return -1;
+                sum += count;
+                break;
+            default:
+                break;
+        }
+    }
+
+    if (!writer->indent) {
+        count = xmlOutputBufferWriteString(writer->out, "\n");
+        if (count < 0)
+            return -1;
+        sum += count;
+    }
+    return sum;
+}
+
+/**
+ * xmlTextWriterStartComment:
+ * @writer:  the xmlTextWriterPtr
+ *
+ * Start an xml comment.
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterStartComment(xmlTextWriterPtr writer)
+{
+    int count;
+    int sum;
+    xmlLinkPtr lk;
+    xmlTextWriterStackEntry *p;
+
+    if (writer == NULL) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlTextWriterStartComment : invalid writer!\n");
+        return -1;
+    }
+
+    sum = 0;
+    lk = xmlListFront(writer->nodes);
+    if (lk != 0) {
+        p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
+        if (p != 0) {
+            switch (p->state) {
+                case XML_TEXTWRITER_TEXT:
+                case XML_TEXTWRITER_NONE:
+                    break;
+                case XML_TEXTWRITER_NAME:
+                    count = xmlOutputBufferWriteString(writer->out, ">");
+                    if (count < 0)
+                        return -1;
+                    sum += count;
+                    if (writer->indent) {
+                        count =
+                            xmlOutputBufferWriteString(writer->out, "\n");
+                        if (count < 0)
+                            return -1;
+                        sum += count;
+                    }
+                    p->state = XML_TEXTWRITER_TEXT;
+                    break;
+                default:
+                    return -1;
+            }
+        }
+    }
+
+    p = (xmlTextWriterStackEntry *)
+        xmlMalloc(sizeof(xmlTextWriterStackEntry));
+    if (p == 0) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlTextWriterStartElement : out of memory!\n");
+        return -1;
+    }
+
+    p->name = 0;
+    p->state = XML_TEXTWRITER_COMMENT;
+
+    xmlListPushFront(writer->nodes, p);
+
+    if (writer->indent) {
+        count = xmlTextWriterWriteIndent(writer);
+        if (count < 0)
+            return -1;
+        sum += count;
+    }
+
+    count = xmlOutputBufferWriteString(writer->out, "<!--");
+    if (count < 0)
+        return -1;
+    sum += count;
+
+    return sum;
+}
+
+/**
+ * xmlTextWriterEndComment:
+ * @writer:  the xmlTextWriterPtr
+ *
+ * End the current xml coment.
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterEndComment(xmlTextWriterPtr writer)
+{
+    int count;
+    int sum;
+    xmlLinkPtr lk;
+    xmlTextWriterStackEntry *p;
+
+    if (writer == NULL) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlTextWriterEndComment : invalid writer!\n");
+        return -1;
+    }
+
+    lk = xmlListFront(writer->nodes);
+    if (lk == 0) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlTextWriterEndComment : not allowed in this context!\n");
+        return -1;
+    }
+
+    p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
+    if (p == 0)
+        return -1;
+
+    sum = 0;
+    switch (p->state) {
+        case XML_TEXTWRITER_COMMENT:
+            count = xmlOutputBufferWriteString(writer->out, "-->");
+            if (count < 0)
+                return -1;
+            sum += count;
+            break;
+        default:
+            return -1;
+    }
+
+    if (writer->indent) {
+        count = xmlOutputBufferWriteString(writer->out, "\n");
+        if (count < 0)
+            return -1;
+        sum += count;
+    }
+
+    xmlListPopFront(writer->nodes);
+    return sum;
+}
+
+/**
+ * xmlTextWriterWriteFormatComment:
+ * @writer:  the xmlTextWriterPtr
+ * @format:  format string (see printf)
+ * @...:  extra parameters for the format
+ *
+ * Write an xml comment.
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterWriteFormatComment(xmlTextWriterPtr writer,
+                                const char *format, ...)
+{
+    int rc;
+    va_list ap;
+
+    va_start(ap, format);
+
+    rc = xmlTextWriterWriteVFormatComment(writer, format, ap);
+
+    va_end(ap);
+    return rc;
+}
+
+/**
+ * xmlTextWriterWriteVFormatComment:
+ * @writer:  the xmlTextWriterPtr
+ * @format:  format string (see printf)
+ * @argptr:  pointer to the first member of the variable argument list.
+ *
+ * Write an xml comment.
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterWriteVFormatComment(xmlTextWriterPtr writer,
+                                 const char *format, va_list argptr)
+{
+    int rc;
+    xmlChar *buf;
+
+    if (writer == NULL) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlTextWriterWriteVFormatComment : invalid writer!\n");
+        return -1;
+    }
+
+    buf = xmlTextWriterVSprintf(format, argptr);
+    if (buf == 0)
+        return 0;
+
+    rc = xmlTextWriterWriteComment(writer, buf);
+
+    xmlFree(buf);
+    return rc;
+}
+
+/**
+ * xmlTextWriterWriteComment:
+ * @writer:  the xmlTextWriterPtr
+ * @content:  comment string
+ *
+ * Write an xml comment.
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterWriteComment(xmlTextWriterPtr writer, const xmlChar * content)
+{
+    int count;
+    int sum;
+
+    sum = 0;
+    count = xmlTextWriterStartComment(writer);
+    if (count < 0)
+        return -1;
+    sum += count;
+    count = xmlTextWriterWriteString(writer, content);
+    if (count < 0)
+        return -1;
+    sum += count;
+    count = xmlTextWriterEndComment(writer);
+    if (count < 0)
+        return -1;
+    sum += count;
+
+    return sum;
+}
+
+/**
+ * xmlTextWriterStartElement:
+ * @writer:  the xmlTextWriterPtr
+ * @name:  element name
+ *
+ * Start an xml element.
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterStartElement(xmlTextWriterPtr writer, const xmlChar * name)
+{
+    int count;
+    int sum;
+    xmlLinkPtr lk;
+    xmlTextWriterStackEntry *p;
+
+    if ((writer == NULL) || (name == NULL) || (*name == '\0'))
+        return -1;
+
+    sum = 0;
+    lk = xmlListFront(writer->nodes);
+    if (lk != 0) {
+        p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
+        if (p != 0) {
+            switch (p->state) {
+                case XML_TEXTWRITER_PI:
+                case XML_TEXTWRITER_PI_TEXT:
+                    return -1;
+                case XML_TEXTWRITER_NONE:
+                    break;
+                case XML_TEXTWRITER_NAME:
+                    count = xmlOutputBufferWriteString(writer->out, ">");
+                    if (count < 0)
+                        return -1;
+                    sum += count;
+                    if (writer->indent)
+                        count =
+                            xmlOutputBufferWriteString(writer->out, "\n");
+                    p->state = XML_TEXTWRITER_TEXT;
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+
+    p = (xmlTextWriterStackEntry *)
+        xmlMalloc(sizeof(xmlTextWriterStackEntry));
+    if (p == 0) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlTextWriterStartElement : out of memory!\n");
+        return -1;
+    }
+
+    p->name = xmlStrdup(name);
+    if (p->name == 0) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlTextWriterStartElement : out of memory!\n");
+        xmlFree(p);
+        return -1;
+    }
+    p->state = XML_TEXTWRITER_NAME;
+
+    xmlListPushFront(writer->nodes, p);
+
+    if (writer->indent) {
+        count = xmlTextWriterWriteIndent(writer);
+        sum += count;
+    }
+
+    count = xmlOutputBufferWriteString(writer->out, "<");
+    if (count < 0)
+        return -1;
+    sum += count;
+    count =
+        xmlOutputBufferWriteString(writer->out, (const char *) p->name);
+    if (count < 0)
+        return -1;
+    sum += count;
+
+    return sum;
+}
+
+/**
+ * xmlTextWriterStartElementNS:
+ * @writer:  the xmlTextWriterPtr
+ * @prefix:  namespace prefix or NULL
+ * @name:  element local name
+ * @namespaceURI:  namespace URI or NULL
+ *
+ * Start an xml element with namespace support.
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterStartElementNS(xmlTextWriterPtr writer,
+                            const xmlChar * prefix, const xmlChar * name,
+                            const xmlChar * namespaceURI)
+{
+    int count;
+    int sum;
+    xmlChar *buf;
+
+    if ((writer == NULL) || (name == NULL) || (*name == '\0'))
+        return -1;
+
+    buf = 0;
+    if (prefix != 0) {
+        buf = xmlStrdup(prefix);
+        buf = xmlStrcat(buf, BAD_CAST ":");
+    }
+    buf = xmlStrcat(buf, name);
+
+    sum = 0;
+    count = xmlTextWriterStartElement(writer, buf);
+    xmlFree(buf);
+    if (count < 0)
+        return -1;
+    sum += count;
+
+    if (namespaceURI != 0) {
+        buf = xmlStrdup(BAD_CAST "xmlns");
+        if (prefix != 0) {
+            buf = xmlStrcat(buf, BAD_CAST ":");
+            buf = xmlStrcat(buf, prefix);
+        }
+
+        count = xmlTextWriterWriteAttribute(writer, buf, namespaceURI);
+        xmlFree(buf);
+        if (count < 0)
+            return -1;
+        sum += count;
+    }
+
+    return sum;
+}
+
+/**
+ * xmlTextWriterEndElement:
+ * @writer:  the xmlTextWriterPtr
+ *
+ * End the current xml element.
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterEndElement(xmlTextWriterPtr writer)
+{
+    int count;
+    int sum;
+    xmlLinkPtr lk;
+    xmlTextWriterStackEntry *p;
+
+    if (writer == NULL)
+        return -1;
+
+    lk = xmlListFront(writer->nodes);
+    if (lk == 0)
+        return -1;
+
+    p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
+    if (p == 0)
+        return -1;
+
+    sum = 0;
+    switch (p->state) {
+        case XML_TEXTWRITER_ATTRIBUTE:
+            count = xmlTextWriterEndAttribute(writer);
+            if (count < 0)
+                return -1;
+            sum += count;
+            /* fallthrough */
+        case XML_TEXTWRITER_NAME:
+            if (writer->indent) /* next element needs indent */
+                writer->doindent = 1;
+            count = xmlOutputBufferWriteString(writer->out, "/>");
+            if (count < 0)
+                return -1;
+            sum += count;
+            break;
+        case XML_TEXTWRITER_TEXT:
+            if ((writer->indent) && (writer->doindent)) {
+                count = xmlTextWriterWriteIndent(writer);
+                sum += count;
+                writer->doindent = 1;
+            } else
+                writer->doindent = 1;
+            count = xmlOutputBufferWriteString(writer->out, "</");
+            if (count < 0)
+                return -1;
+            sum += count;
+            count = xmlOutputBufferWriteString(writer->out,
+                                               (const char *) p->name);
+            if (count < 0)
+                return -1;
+            sum += count;
+            count = xmlOutputBufferWriteString(writer->out, ">");
+            if (count < 0)
+                return -1;
+            sum += count;
+            break;
+        default:
+            return -1;
+    }
+
+    if (writer->indent) {
+        count = xmlOutputBufferWriteString(writer->out, "\n");
+        sum += count;
+    }
+
+    xmlListPopFront(writer->nodes);
+    return sum;
+}
+
+/**
+ * xmlTextWriterFullEndElement:
+ * @writer:  the xmlTextWriterPtr
+ *
+ * End the current xml element. Writes an end tag even if the element is empty
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterFullEndElement(xmlTextWriterPtr writer)
+{
+    int count;
+    int sum;
+    xmlLinkPtr lk;
+    xmlTextWriterStackEntry *p;
+
+    if (writer == NULL)
+        return -1;
+
+    lk = xmlListFront(writer->nodes);
+    if (lk == 0)
+        return -1;
+
+    p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
+    if (p == 0)
+        return -1;
+
+    sum = 0;
+    switch (p->state) {
+        case XML_TEXTWRITER_ATTRIBUTE:
+            count = xmlTextWriterEndAttribute(writer);
+            if (count < 0)
+                return -1;
+            sum += count;
+            /* fallthrough */
+        case XML_TEXTWRITER_NAME:
+            count = xmlOutputBufferWriteString(writer->out, ">");
+            if (count < 0)
+                return -1;
+            sum += count;
+            /* fallthrough */
+        case XML_TEXTWRITER_TEXT:
+            count = xmlOutputBufferWriteString(writer->out, "</");
+            if (count < 0)
+                return -1;
+            sum += count;
+            count = xmlOutputBufferWriteString(writer->out,
+                                               (const char *) p->name);
+            if (count < 0)
+                return -1;
+            sum += count;
+            count = xmlOutputBufferWriteString(writer->out, ">");
+            if (count < 0)
+                return -1;
+            sum += count;
+            break;
+        default:
+            return -1;
+    }
+
+    xmlListPopFront(writer->nodes);
+    return sum;
+}
+
+/**
+ * xmlTextWriterWriteFormatRaw:
+ * @writer:  the xmlTextWriterPtr
+ * @format:  format string (see printf)
+ * @...:  extra parameters for the format
+ *
+ * Write a formatted raw xml text.
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterWriteFormatRaw(xmlTextWriterPtr writer, const char *format,
+                            ...)
+{
+    int rc;
+    va_list ap;
+
+    va_start(ap, format);
+
+    rc = xmlTextWriterWriteVFormatRaw(writer, format, ap);
+
+    va_end(ap);
+    return rc;
+}
+
+/**
+ * xmlTextWriterWriteVFormatRaw:
+ * @writer:  the xmlTextWriterPtr
+ * @format:  format string (see printf)
+ * @argptr:  pointer to the first member of the variable argument list.
+ *
+ * Write a formatted raw xml text.
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterWriteVFormatRaw(xmlTextWriterPtr writer, const char *format,
+                             va_list argptr)
+{
+    int rc;
+    xmlChar *buf;
+
+    if (writer == NULL)
+        return -1;
+
+    buf = xmlTextWriterVSprintf(format, argptr);
+    if (buf == 0)
+        return 0;
+
+    rc = xmlTextWriterWriteRaw(writer, buf);
+
+    xmlFree(buf);
+    return rc;
+}
+
+/**
+ * xmlTextWriterWriteRawLen:
+ * @writer:  the xmlTextWriterPtr
+ * @content:  text string
+ * @len:  length of the text string
+ *
+ * Write an xml text.
+ * TODO: what about entities and special chars??
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterWriteRawLen(xmlTextWriterPtr writer, const xmlChar * content,
+                         int len)
+{
+    int count;
+    int sum;
+    xmlLinkPtr lk;
+    xmlTextWriterStackEntry *p;
+
+    if (writer == NULL) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlTextWriterWriteRawLen : invalid writer!\n");
+        return -1;
+    }
+
+    if ((content == NULL) && (len > 0)) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlTextWriterWriteRawLen : invalid content!\n");
+        return -1;
+    }
+
+    sum = 0;
+    lk = xmlListFront(writer->nodes);
+    if (lk != 0) {
+        p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
+        count = xmlTextWriterHandleStateDependencies(writer, p);
+        if (count < 0)
+            return -1;
+        sum += count;
+    }
+
+    if (writer->indent)
+        writer->doindent = 0;
+
+    if (content != NULL) {
+        count =
+            xmlOutputBufferWrite(writer->out, len, (const char *) content);
+        if (count < 0)
+            return -1;
+        sum += count;
+    }
+
+    return sum;
+}
+
+/**
+ * xmlTextWriterWriteRaw:
+ * @writer:  the xmlTextWriterPtr
+ * @content:  text string
+ *
+ * Write a raw xml text.
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterWriteRaw(xmlTextWriterPtr writer, const xmlChar * content)
+{
+    return xmlTextWriterWriteRawLen(writer, content, xmlStrlen(content));
+}
+
+/**
+ * xmlTextWriterWriteFormatString:
+ * @writer:  the xmlTextWriterPtr
+ * @format:  format string (see printf)
+ * @...:  extra parameters for the format
+ *
+ * Write a formatted xml text.
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterWriteFormatString(xmlTextWriterPtr writer, const char *format,
+                               ...)
+{
+    int rc;
+    va_list ap;
+
+    va_start(ap, format);
+
+    rc = xmlTextWriterWriteVFormatString(writer, format, ap);
+
+    va_end(ap);
+    return rc;
+}
+
+/**
+ * xmlTextWriterWriteVFormatString:
+ * @writer:  the xmlTextWriterPtr
+ * @format:  format string (see printf)
+ * @argptr:  pointer to the first member of the variable argument list.
+ *
+ * Write a formatted xml text.
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterWriteVFormatString(xmlTextWriterPtr writer,
+                                const char *format, va_list argptr)
+{
+    int rc;
+    xmlChar *buf;
+
+    if (writer == NULL)
+        return -1;
+
+    buf = xmlTextWriterVSprintf(format, argptr);
+    if (buf == 0)
+        return 0;
+
+    rc = xmlTextWriterWriteString(writer, buf);
+
+    xmlFree(buf);
+    return rc;
+}
+
+/**
+ * xmlTextWriterWriteString:
+ * @writer:  the xmlTextWriterPtr
+ * @content:  text string
+ *
+ * Write an xml text.
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterWriteString(xmlTextWriterPtr writer, const xmlChar * content)
+{
+    int count;
+    int sum;
+    xmlLinkPtr lk;
+    xmlTextWriterStackEntry *p;
+    xmlChar *buf;
+
+    if (writer == NULL)
+        return -1;
+
+    sum = 0;
+    buf = (xmlChar *) content;
+    lk = xmlListFront(writer->nodes);
+    if (lk != 0) {
+        p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
+        if (p != 0) {
+            switch (p->state) {
+                case XML_TEXTWRITER_NAME:
+                case XML_TEXTWRITER_TEXT:
+                    buf = xmlEncodeSpecialChars(NULL, content);
+                    break;
+                case XML_TEXTWRITER_ATTRIBUTE:
+                    buf = NULL;
+                    xmlAttrSerializeTxtContent(writer->out->buffer, NULL,
+                                               NULL, content);
+                    break;
+		default:
+		    break;
+            }
+        }
+    }
+
+    if (buf != NULL) {
+        count = xmlTextWriterWriteRaw(writer, buf);
+        if (count < 0)
+            return -1;
+        sum += count;
+
+        if (buf != content)     /* buf was allocated by us, so free it */
+            xmlFree(buf);
+    }
+
+    return sum;
+}
+
+/**
+ * xmlOutputBufferWriteBase64:
+ * @out: the xmlOutputBufferPtr
+ * @data:   binary data
+ * @len:  the number of bytes to encode
+ *
+ * Write base64 encoded data to an xmlOutputBuffer.
+ * Adapted from John Walker's base64.c (http://www.fourmilab.ch/).
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+static int
+xmlOutputBufferWriteBase64(xmlOutputBufferPtr out, int len,
+                           const unsigned char *data)
+{
+    static unsigned char dtable[64] =
+        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    int i;
+    int linelen;
+    int count;
+    int sum;
+
+    linelen = 0;
+    sum = 0;
+
+    i = 0;
+    while (1) {
+        unsigned char igroup[3];
+        unsigned char ogroup[4];
+        int c;
+        int n;
+
+        igroup[0] = igroup[1] = igroup[2] = 0;
+        for (n = 0; n < 3 && i < len; n++, i++) {
+            c = data[i];
+            igroup[n] = (unsigned char) c;
+        }
+
+        if (n > 0) {
+            ogroup[0] = dtable[igroup[0] >> 2];
+            ogroup[1] = dtable[((igroup[0] & 3) << 4) | (igroup[1] >> 4)];
+            ogroup[2] =
+                dtable[((igroup[1] & 0xF) << 2) | (igroup[2] >> 6)];
+            ogroup[3] = dtable[igroup[2] & 0x3F];
+
+            if (n < 3) {
+                ogroup[3] = '=';
+                if (n < 2) {
+                    ogroup[2] = '=';
+                }
+            }
+
+            if (linelen >= B64LINELEN) {
+                count = xmlOutputBufferWrite(out, 2, B64CRLF);
+                if (count == -1)
+                    return -1;
+                sum += count;
+                linelen = 0;
+            }
+            count = xmlOutputBufferWrite(out, 4, (const char *) ogroup);
+            if (count == -1)
+                return -1;
+            sum += count;
+
+            linelen += 4;
+        }
+
+        if (i >= len)
+            break;
+    }
+
+    return sum;
+}
+
+/**
+ * xmlTextWriterWriteBase64:
+ * @writer: the xmlTextWriterPtr
+ * @data:   binary data
+ * @start:  the position within the data of the first byte to encode
+ * @len:  the number of bytes to encode
+ *
+ * Write an base64 encoded xml text.
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterWriteBase64(xmlTextWriterPtr writer, const char *data,
+                         int start, int len)
+{
+    int count;
+    int sum;
+    xmlLinkPtr lk;
+    xmlTextWriterStackEntry *p;
+
+    if (writer == NULL)
+        return -1;
+
+    sum = 0;
+    lk = xmlListFront(writer->nodes);
+    if (lk != 0) {
+        p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
+        if (p != 0) {
+            count = xmlTextWriterHandleStateDependencies(writer, p);
+            if (count < 0)
+                return -1;
+            sum += count;
+        }
+    }
+
+    if (writer->indent)
+        writer->doindent = 0;
+
+    count =
+        xmlOutputBufferWriteBase64(writer->out, len,
+                                   (unsigned char *) data + start);
+    if (count < 0)
+        return -1;
+    sum += count;
+
+    return sum;
+}
+
+/**
+ * xmlOutputBufferWriteBinHex:
+ * @out: the xmlOutputBufferPtr
+ * @data:   binary data
+ * @len:  the number of bytes to encode
+ *
+ * Write hqx encoded data to an xmlOutputBuffer.
+ * ::todo
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+static int
+xmlOutputBufferWriteBinHex(xmlOutputBufferPtr out,
+                           int len, const unsigned char *data)
+{
+    int count;
+    int sum;
+    static char hex[] = "0123456789ABCDEF";
+    int i;
+
+    if ((out == NULL) || ((data == 0) && (len != 0))) {
+        return -1;
+    }
+
+    sum = 0;
+    for (i = 0; i < len; i++) {
+        count =
+            xmlOutputBufferWrite(out, 1,
+                                 (const char *) &hex[data[i] >> 4]);
+        if (count == -1)
+            return -1;
+        sum += count;
+        count =
+            xmlOutputBufferWrite(out, 1,
+                                 (const char *) &hex[data[i] & 0xF]);
+        if (count == -1)
+            return -1;
+        sum += count;
+    }
+
+    return sum;
+}
+
+/**
+ * xmlTextWriterWriteBinHex:
+ * @writer: the xmlTextWriterPtr
+ * @data:   binary data
+ * @start:  the position within the data of the first byte to encode
+ * @len:  the number of bytes to encode
+ *
+ * Write a BinHex encoded xml text.
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterWriteBinHex(xmlTextWriterPtr writer, const char *data,
+                         int start, int len)
+{
+    int count;
+    int sum;
+    xmlLinkPtr lk;
+    xmlTextWriterStackEntry *p;
+
+    if (writer == NULL)
+        return -1;
+
+    sum = 0;
+    lk = xmlListFront(writer->nodes);
+    if (lk != 0) {
+        p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
+        if (p != 0) {
+            count = xmlTextWriterHandleStateDependencies(writer, p);
+            if (count < 0)
+                return -1;
+            sum += count;
+        }
+    }
+
+    if (writer->indent)
+        writer->doindent = 0;
+
+    count =
+        xmlOutputBufferWriteBinHex(writer->out, len,
+                                   (unsigned char *) data + start);
+    if (count < 0)
+        return -1;
+    sum += count;
+
+    return sum;
+}
+
+/**
+ * xmlTextWriterStartAttribute:
+ * @writer:  the xmlTextWriterPtr
+ * @name:  element name
+ *
+ * Start an xml attribute.
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterStartAttribute(xmlTextWriterPtr writer, const xmlChar * name)
+{
+    int count;
+    int sum;
+    xmlLinkPtr lk;
+    xmlTextWriterStackEntry *p;
+
+    if ((writer == NULL) || (name == NULL) || (*name == '\0'))
+        return -1;
+
+    sum = 0;
+    lk = xmlListFront(writer->nodes);
+    if (lk == 0)
+        return -1;
+
+    p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
+    if (p == 0)
+        return -1;
+
+    switch (p->state) {
+        case XML_TEXTWRITER_ATTRIBUTE:
+            count = xmlTextWriterEndAttribute(writer);
+            if (count < 0)
+                return -1;
+            sum += count;
+            /* fallthrough */
+        case XML_TEXTWRITER_NAME:
+            count = xmlOutputBufferWriteString(writer->out, " ");
+            if (count < 0)
+                return -1;
+            sum += count;
+            count =
+                xmlOutputBufferWriteString(writer->out,
+                                           (const char *) name);
+            if (count < 0)
+                return -1;
+            sum += count;
+            count = xmlOutputBufferWriteString(writer->out, "=");
+            if (count < 0)
+                return -1;
+            sum += count;
+            count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
+            if (count < 0)
+                return -1;
+            sum += count;
+            p->state = XML_TEXTWRITER_ATTRIBUTE;
+            break;
+        default:
+            return -1;
+    }
+
+    return sum;
+}
+
+/**
+ * xmlTextWriterStartAttributeNS:
+ * @writer:  the xmlTextWriterPtr
+ * @prefix:  namespace prefix or NULL
+ * @name:  element local name
+ * @namespaceURI:  namespace URI or NULL
+ *
+ * Start an xml attribute with namespace support.
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterStartAttributeNS(xmlTextWriterPtr writer,
+                              const xmlChar * prefix, const xmlChar * name,
+                              const xmlChar * namespaceURI)
+{
+    int count;
+    int sum;
+    xmlChar *buf;
+    xmlTextWriterNsStackEntry *p;
+
+    if ((writer == NULL) || (name == NULL) || (*name == '\0'))
+        return -1;
+
+    buf = 0;
+    if (prefix != 0) {
+        buf = xmlStrdup(prefix);
+        buf = xmlStrcat(buf, BAD_CAST ":");
+    }
+    buf = xmlStrcat(buf, name);
+
+    sum = 0;
+    count = xmlTextWriterStartAttribute(writer, buf);
+    xmlFree(buf);
+    if (count < 0)
+        return -1;
+    sum += count;
+
+    if (namespaceURI != 0) {
+        buf = xmlStrdup(BAD_CAST "xmlns");
+        if (prefix != 0) {
+            buf = xmlStrcat(buf, BAD_CAST ":");
+            buf = xmlStrcat(buf, prefix);
+        }
+
+        p = (xmlTextWriterNsStackEntry *)
+            xmlMalloc(sizeof(xmlTextWriterNsStackEntry));
+        if (p == 0) {
+            xmlGenericError(xmlGenericErrorContext,
+                            "xmlTextWriterStartAttributeNS : out of memory!\n");
+            return -1;
+        }
+
+        p->prefix = buf;
+        p->uri = xmlStrdup(namespaceURI);
+        if (p->uri == 0) {
+            xmlGenericError(xmlGenericErrorContext,
+                            "xmlTextWriterStartAttributeNS : out of memory!\n");
+            xmlFree(p);
+            return -1;
+        }
+        p->elem = xmlListFront(writer->nodes);
+
+        xmlListPushFront(writer->nsstack, p);
+    }
+
+    return sum;
+}
+
+/**
+ * xmlTextWriterEndAttribute:
+ * @writer:  the xmlTextWriterPtr
+ *
+ * End the current xml element.
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterEndAttribute(xmlTextWriterPtr writer)
+{
+    int count;
+    int sum;
+    xmlLinkPtr lk;
+    xmlTextWriterStackEntry *p;
+    xmlTextWriterNsStackEntry *np;
+
+    if (writer == NULL)
+        return -1;
+
+    lk = xmlListFront(writer->nodes);
+    if (lk == 0) {
+        xmlListDelete(writer->nsstack);
+        return -1;
+    }
+
+    p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
+    if (p == 0) {
+        xmlListDelete(writer->nsstack);
+        return -1;
+    }
+
+    sum = 0;
+    switch (p->state) {
+        case XML_TEXTWRITER_ATTRIBUTE:
+            p->state = XML_TEXTWRITER_NAME;
+
+            count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
+            if (count < 0) {
+                xmlListDelete(writer->nsstack);
+                return -1;
+            }
+            sum += count;
+
+            while (!xmlListEmpty(writer->nsstack)) {
+                lk = xmlListFront(writer->nsstack);
+                np = (xmlTextWriterNsStackEntry *) xmlLinkGetData(lk);
+                if (np != 0) {
+                    count =
+                        xmlTextWriterWriteAttribute(writer, np->prefix,
+                                                    np->uri);
+                    if (count < 0) {
+                        xmlListDelete(writer->nsstack);
+                        return -1;
+                    }
+                    sum += count;
+                }
+
+                xmlListPopFront(writer->nsstack);
+            }
+            break;
+
+        default:
+            xmlListClear(writer->nsstack);
+            return -1;
+    }
+
+    return sum;
+}
+
+/**
+ * xmlTextWriterWriteFormatAttribute:
+ * @writer:  the xmlTextWriterPtr
+ * @name:  attribute name
+ * @format:  format string (see printf)
+ * @...:  extra parameters for the format
+ *
+ * Write a formatted xml attribute.
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterWriteFormatAttribute(xmlTextWriterPtr writer,
+                                  const xmlChar * name, const char *format,
+                                  ...)
+{
+    int rc;
+    va_list ap;
+
+    va_start(ap, format);
+
+    rc = xmlTextWriterWriteVFormatAttribute(writer, name, format, ap);
+
+    va_end(ap);
+    return rc;
+}
+
+/**
+ * xmlTextWriterWriteVFormatAttribute:
+ * @writer:  the xmlTextWriterPtr
+ * @name:  attribute name
+ * @format:  format string (see printf)
+ * @argptr:  pointer to the first member of the variable argument list.
+ *
+ * Write a formatted xml attribute.
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterWriteVFormatAttribute(xmlTextWriterPtr writer,
+                                   const xmlChar * name,
+                                   const char *format, va_list argptr)
+{
+    int rc;
+    xmlChar *buf;
+
+    if (writer == NULL)
+        return -1;
+
+    buf = xmlTextWriterVSprintf(format, argptr);
+    if (buf == 0)
+        return 0;
+
+    rc = xmlTextWriterWriteAttribute(writer, name, buf);
+
+    xmlFree(buf);
+    return rc;
+}
+
+/**
+ * xmlTextWriterWriteAttribute:
+ * @writer:  the xmlTextWriterPtr
+ * @name:  attribute name
+ * @content:  attribute content
+ *
+ * Write an xml attribute.
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterWriteAttribute(xmlTextWriterPtr writer, const xmlChar * name,
+                            const xmlChar * content)
+{
+    int count;
+    int sum;
+
+    sum = 0;
+    count = xmlTextWriterStartAttribute(writer, name);
+    if (count < 0)
+        return -1;
+    sum += count;
+    count = xmlTextWriterWriteString(writer, content);
+    if (count < 0)
+        return -1;
+    sum += count;
+    count = xmlTextWriterEndAttribute(writer);
+    if (count < 0)
+        return -1;
+    sum += count;
+
+    return sum;
+}
+
+/**
+ * xmlTextWriterWriteFormatAttributeNS:
+ * @writer:  the xmlTextWriterPtr
+ * @prefix:  namespace prefix
+ * @name:  attribute local name
+ * @namespaceURI:  namespace URI
+ * @format:  format string (see printf)
+ * @...:  extra parameters for the format
+ *
+ * Write a formatted xml attribute.with namespace support
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterWriteFormatAttributeNS(xmlTextWriterPtr writer,
+                                    const xmlChar * prefix,
+                                    const xmlChar * name,
+                                    const xmlChar * namespaceURI,
+                                    const char *format, ...)
+{
+    int rc;
+    va_list ap;
+
+    va_start(ap, format);
+
+    rc = xmlTextWriterWriteVFormatAttributeNS(writer, prefix, name,
+                                              namespaceURI, format, ap);
+
+    va_end(ap);
+    return rc;
+}
+
+/**
+ * xmlTextWriterWriteVFormatAttributeNS:
+ * @writer:  the xmlTextWriterPtr
+ * @prefix:  namespace prefix
+ * @name:  attribute local name
+ * @namespaceURI:  namespace URI
+ * @format:  format string (see printf)
+ * @argptr:  pointer to the first member of the variable argument list.
+ *
+ * Write a formatted xml attribute.with namespace support
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterWriteVFormatAttributeNS(xmlTextWriterPtr writer,
+                                     const xmlChar * prefix,
+                                     const xmlChar * name,
+                                     const xmlChar * namespaceURI,
+                                     const char *format, va_list argptr)
+{
+    int rc;
+    xmlChar *buf;
+
+    if (writer == NULL)
+        return -1;
+
+    buf = xmlTextWriterVSprintf(format, argptr);
+    if (buf == 0)
+        return 0;
+
+    rc = xmlTextWriterWriteAttributeNS(writer, prefix, name, namespaceURI,
+                                       buf);
+
+    xmlFree(buf);
+    return rc;
+}
+
+/**
+ * xmlTextWriterWriteAttributeNS:
+ * @writer:  the xmlTextWriterPtr
+ * @prefix:  namespace prefix
+ * @name:  attribute local name
+ * @namespaceURI:  namespace URI
+ * @content:  attribute content
+ *
+ * Write an xml attribute.
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterWriteAttributeNS(xmlTextWriterPtr writer,
+                              const xmlChar * prefix, const xmlChar * name,
+                              const xmlChar * namespaceURI,
+                              const xmlChar * content)
+{
+    int count;
+    int sum;
+    xmlChar *buf;
+
+    if ((writer == NULL) || (name == NULL) || (*name == '\0'))
+        return -1;
+
+    buf = 0;
+    if (prefix != NULL) {
+        buf = xmlStrdup(prefix);
+        buf = xmlStrcat(buf, BAD_CAST ":");
+    }
+    buf = xmlStrcat(buf, name);
+
+    sum = 0;
+    count = xmlTextWriterWriteAttribute(writer, buf, content);
+    xmlFree(buf);
+    if (count < 0)
+        return -1;
+    sum += count;
+
+    if (namespaceURI != NULL) {
+        buf = 0;
+        buf = xmlStrdup(BAD_CAST "xmlns");
+        if (prefix != NULL) {
+            buf = xmlStrcat(buf, BAD_CAST ":");
+            buf = xmlStrcat(buf, prefix);
+        }
+        count = xmlTextWriterWriteAttribute(writer, buf, namespaceURI);
+        xmlFree(buf);
+        if (count < 0)
+            return -1;
+        sum += count;
+    }
+    return sum;
+}
+
+/**
+ * xmlTextWriterWriteFormatElement:
+ * @writer:  the xmlTextWriterPtr
+ * @name:  element name
+ * @format:  format string (see printf)
+ * @...:  extra parameters for the format
+ *
+ * Write a formatted xml element.
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterWriteFormatElement(xmlTextWriterPtr writer,
+                                const xmlChar * name, const char *format,
+                                ...)
+{
+    int rc;
+    va_list ap;
+
+    va_start(ap, format);
+
+    rc = xmlTextWriterWriteVFormatElement(writer, name, format, ap);
+
+    va_end(ap);
+    return rc;
+}
+
+/**
+ * xmlTextWriterWriteVFormatElement:
+ * @writer:  the xmlTextWriterPtr
+ * @name:  element name
+ * @format:  format string (see printf)
+ * @argptr:  pointer to the first member of the variable argument list.
+ *
+ * Write a formatted xml element.
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterWriteVFormatElement(xmlTextWriterPtr writer,
+                                 const xmlChar * name, const char *format,
+                                 va_list argptr)
+{
+    int rc;
+    xmlChar *buf;
+
+    if (writer == NULL)
+        return -1;
+
+    buf = xmlTextWriterVSprintf(format, argptr);
+    if (buf == 0)
+        return 0;
+
+    rc = xmlTextWriterWriteElement(writer, name, buf);
+
+    xmlFree(buf);
+    return rc;
+}
+
+/**
+ * xmlTextWriterWriteElement:
+ * @writer:  the xmlTextWriterPtr
+ * @name:  element name
+ * @content:  element content
+ *
+ * Write an xml element.
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterWriteElement(xmlTextWriterPtr writer, const xmlChar * name,
+                          const xmlChar * content)
+{
+    int count;
+    int sum;
+
+    sum = 0;
+    count = xmlTextWriterStartElement(writer, name);
+    if (count == -1)
+        return -1;
+    sum += count;
+    count = xmlTextWriterWriteString(writer, content);
+    if (count == -1)
+        return -1;
+    sum += count;
+    count = xmlTextWriterEndElement(writer);
+    if (count == -1)
+        return -1;
+    sum += count;
+
+    return sum;
+}
+
+/**
+ * xmlTextWriterWriteFormatElementNS:
+ * @writer:  the xmlTextWriterPtr
+ * @prefix:  namespace prefix
+ * @name:  element local name
+ * @namespaceURI:  namespace URI
+ * @format:  format string (see printf)
+ * @...:  extra parameters for the format
+ *
+ * Write a formatted xml element with namespace support.
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterWriteFormatElementNS(xmlTextWriterPtr writer,
+                                  const xmlChar * prefix,
+                                  const xmlChar * name,
+                                  const xmlChar * namespaceURI,
+                                  const char *format, ...)
+{
+    int rc;
+    va_list ap;
+
+    va_start(ap, format);
+
+    rc = xmlTextWriterWriteVFormatElementNS(writer, prefix, name,
+                                            namespaceURI, format, ap);
+
+    va_end(ap);
+    return rc;
+}
+
+/**
+ * xmlTextWriterWriteVFormatElementNS:
+ * @writer:  the xmlTextWriterPtr
+ * @prefix:  namespace prefix
+ * @name:  element local name
+ * @namespaceURI:  namespace URI
+ * @format:  format string (see printf)
+ * @argptr:  pointer to the first member of the variable argument list.
+ *
+ * Write a formatted xml element with namespace support.
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterWriteVFormatElementNS(xmlTextWriterPtr writer,
+                                   const xmlChar * prefix,
+                                   const xmlChar * name,
+                                   const xmlChar * namespaceURI,
+                                   const char *format, va_list argptr)
+{
+    int rc;
+    xmlChar *buf;
+
+    if (writer == NULL)
+        return -1;
+
+    buf = xmlTextWriterVSprintf(format, argptr);
+    if (buf == 0)
+        return 0;
+
+    rc = xmlTextWriterWriteElementNS(writer, prefix, name, namespaceURI,
+                                     buf);
+
+    xmlFree(buf);
+    return rc;
+}
+
+/**
+ * xmlTextWriterWriteElementNS:
+ * @writer:  the xmlTextWriterPtr
+ * @prefix:  namespace prefix
+ * @name:  element local name
+ * @namespaceURI:  namespace URI
+ * @content:  element content
+ *
+ * Write an xml element with namespace support.
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterWriteElementNS(xmlTextWriterPtr writer,
+                            const xmlChar * prefix, const xmlChar * name,
+                            const xmlChar * namespaceURI,
+                            const xmlChar * content)
+{
+    int count;
+    int sum;
+
+    if ((writer == NULL) || (name == NULL) || (*name == '\0'))
+        return -1;
+
+    sum = 0;
+    count =
+        xmlTextWriterStartElementNS(writer, prefix, name, namespaceURI);
+    if (count < 0)
+        return -1;
+    sum += count;
+    count = xmlTextWriterWriteString(writer, content);
+    if (count == -1)
+        return -1;
+    sum += count;
+    count = xmlTextWriterEndElement(writer);
+    if (count == -1)
+        return -1;
+    sum += count;
+
+    return sum;
+}
+
+/**
+ * xmlTextWriterStartPI:
+ * @writer:  the xmlTextWriterPtr
+ * @target:  PI target
+ *
+ * Start an xml PI.
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterStartPI(xmlTextWriterPtr writer, const xmlChar * target)
+{
+    int count;
+    int sum;
+    xmlLinkPtr lk;
+    xmlTextWriterStackEntry *p;
+
+    if ((writer == NULL) || (target == NULL) || (*target == '\0'))
+        return -1;
+
+    if (xmlStrcasecmp(target, (const xmlChar *) "xml") == 0) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlTextWriterStartPI : target name [Xx][Mm][Ll] is reserved for xml standardization!\n");
+        return -1;
+    }
+
+    sum = 0;
+    lk = xmlListFront(writer->nodes);
+    if (lk != 0) {
+        p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
+        if (p != 0) {
+            switch (p->state) {
+                case XML_TEXTWRITER_ATTRIBUTE:
+                    count = xmlTextWriterEndAttribute(writer);
+                    if (count < 0)
+                        return -1;
+                    sum += count;
+                    /* fallthrough */
+                case XML_TEXTWRITER_NAME:
+                    count = xmlOutputBufferWriteString(writer->out, ">");
+                    if (count < 0)
+                        return -1;
+                    sum += count;
+                    p->state = XML_TEXTWRITER_TEXT;
+                    break;
+                case XML_TEXTWRITER_NONE:
+                case XML_TEXTWRITER_TEXT:
+                case XML_TEXTWRITER_DTD:
+                    break;
+                case XML_TEXTWRITER_PI:
+                case XML_TEXTWRITER_PI_TEXT:
+                    xmlGenericError(xmlGenericErrorContext,
+                                    "xmlTextWriterStartPI : nested PI!\n");
+                    return -1;
+                default:
+                    return -1;
+            }
+        }
+    }
+
+    p = (xmlTextWriterStackEntry *)
+        xmlMalloc(sizeof(xmlTextWriterStackEntry));
+    if (p == 0) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlTextWriterStartPI : out of memory!\n");
+        return -1;
+    }
+
+    p->name = xmlStrdup(target);
+    if (p->name == 0) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlTextWriterStartPI : out of memory!\n");
+        xmlFree(p);
+        return -1;
+    }
+    p->state = XML_TEXTWRITER_PI;
+
+    xmlListPushFront(writer->nodes, p);
+
+    count = xmlOutputBufferWriteString(writer->out, "<?");
+    if (count < 0)
+        return -1;
+    sum += count;
+    count =
+        xmlOutputBufferWriteString(writer->out, (const char *) p->name);
+    if (count < 0)
+        return -1;
+    sum += count;
+
+    return sum;
+}
+
+/**
+ * xmlTextWriterEndPI:
+ * @writer:  the xmlTextWriterPtr
+ *
+ * End the current xml PI.
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterEndPI(xmlTextWriterPtr writer)
+{
+    int count;
+    int sum;
+    xmlLinkPtr lk;
+    xmlTextWriterStackEntry *p;
+
+    if (writer == NULL)
+        return -1;
+
+    lk = xmlListFront(writer->nodes);
+    if (lk == 0)
+        return 0;
+
+    p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
+    if (p == 0)
+        return 0;
+
+    sum = 0;
+    switch (p->state) {
+        case XML_TEXTWRITER_PI:
+        case XML_TEXTWRITER_PI_TEXT:
+            count = xmlOutputBufferWriteString(writer->out, "?>");
+            if (count < 0)
+                return -1;
+            sum += count;
+            break;
+        default:
+            return -1;
+    }
+
+    xmlListPopFront(writer->nodes);
+    return sum;
+}
+
+/**
+ * xmlTextWriterWriteFormatPI:
+ * @writer:  the xmlTextWriterPtr
+ * @target:  PI target
+ * @format:  format string (see printf)
+ * @...:  extra parameters for the format
+ *
+ * Write a formatted PI.
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterWriteFormatPI(xmlTextWriterPtr writer, const xmlChar * target,
+                           const char *format, ...)
+{
+    int rc;
+    va_list ap;
+
+    va_start(ap, format);
+
+    rc = xmlTextWriterWriteVFormatPI(writer, target, format, ap);
+
+    va_end(ap);
+    return rc;
+}
+
+/**
+ * xmlTextWriterWriteVFormatPI:
+ * @writer:  the xmlTextWriterPtr
+ * @target:  PI target
+ * @format:  format string (see printf)
+ * @argptr:  pointer to the first member of the variable argument list.
+ *
+ * Write a formatted xml PI.
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterWriteVFormatPI(xmlTextWriterPtr writer,
+                            const xmlChar * target, const char *format,
+                            va_list argptr)
+{
+    int rc;
+    xmlChar *buf;
+
+    if (writer == NULL)
+        return -1;
+
+    buf = xmlTextWriterVSprintf(format, argptr);
+    if (buf == 0)
+        return 0;
+
+    rc = xmlTextWriterWritePI(writer, target, buf);
+
+    xmlFree(buf);
+    return rc;
+}
+
+/**
+ * xmlTextWriterWritePI:
+ * @writer:  the xmlTextWriterPtr
+ * @target:  PI target
+ * @content:  PI content
+ *
+ * Write an xml PI.
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterWritePI(xmlTextWriterPtr writer, const xmlChar * target,
+                     const xmlChar * content)
+{
+    int count;
+    int sum;
+
+    sum = 0;
+    count = xmlTextWriterStartPI(writer, target);
+    if (count == -1)
+        return -1;
+    sum += count;
+    if (content != 0) {
+        count = xmlTextWriterWriteString(writer, content);
+        if (count == -1)
+            return -1;
+        sum += count;
+    }
+    count = xmlTextWriterEndPI(writer);
+    if (count == -1)
+        return -1;
+    sum += count;
+
+    return sum;
+}
+
+/**
+ * xmlTextWriterStartCDATA:
+ * @writer:  the xmlTextWriterPtr
+ *
+ * Start an xml CDATA section.
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterStartCDATA(xmlTextWriterPtr writer)
+{
+    int count;
+    int sum;
+    xmlLinkPtr lk;
+    xmlTextWriterStackEntry *p;
+
+    if (writer == NULL)
+        return -1;
+
+    sum = 0;
+    lk = xmlListFront(writer->nodes);
+    if (lk != 0) {
+        p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
+        if (p != 0) {
+            switch (p->state) {
+                case XML_TEXTWRITER_NONE:
+                case XML_TEXTWRITER_PI:
+                case XML_TEXTWRITER_PI_TEXT:
+                    break;
+                case XML_TEXTWRITER_ATTRIBUTE:
+                    count = xmlTextWriterEndAttribute(writer);
+                    if (count < 0)
+                        return -1;
+                    sum += count;
+                    /* fallthrough */
+                case XML_TEXTWRITER_NAME:
+                    count = xmlOutputBufferWriteString(writer->out, ">");
+                    if (count < 0)
+                        return -1;
+                    sum += count;
+                    p->state = XML_TEXTWRITER_TEXT;
+                    break;
+                case XML_TEXTWRITER_CDATA:
+                    xmlGenericError(xmlGenericErrorContext,
+                                    "xmlTextWriterStartCDATA : CDATA not allowed in this context!\n");
+                    return -1;
+                default:
+                    return -1;
+            }
+        }
+    }
+
+    p = (xmlTextWriterStackEntry *)
+        xmlMalloc(sizeof(xmlTextWriterStackEntry));
+    if (p == 0) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlTextWriterStartCDATA : out of memory!\n");
+        return -1;
+    }
+
+    p->name = 0;
+    p->state = XML_TEXTWRITER_CDATA;
+
+    xmlListPushFront(writer->nodes, p);
+
+    count = xmlOutputBufferWriteString(writer->out, "<![CDATA[");
+    if (count < 0)
+        return -1;
+    sum += count;
+
+    return sum;
+}
+
+/**
+ * xmlTextWriterEndCDATA:
+ * @writer:  the xmlTextWriterPtr
+ *
+ * End an xml CDATA section.
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterEndCDATA(xmlTextWriterPtr writer)
+{
+    int count;
+    int sum;
+    xmlLinkPtr lk;
+    xmlTextWriterStackEntry *p;
+
+    if (writer == NULL)
+        return -1;
+
+    lk = xmlListFront(writer->nodes);
+    if (lk == 0)
+        return -1;
+
+    p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
+    if (p == 0)
+        return -1;
+
+    sum = 0;
+    switch (p->state) {
+        case XML_TEXTWRITER_CDATA:
+            count = xmlOutputBufferWriteString(writer->out, "]]>");
+            if (count < 0)
+                return -1;
+            sum += count;
+            break;
+        default:
+            return -1;
+    }
+
+    xmlListPopFront(writer->nodes);
+    return sum;
+}
+
+/**
+ * xmlTextWriterWriteFormatCDATA:
+ * @writer:  the xmlTextWriterPtr
+ * @format:  format string (see printf)
+ * @...:  extra parameters for the format
+ *
+ * Write a formatted xml CDATA.
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterWriteFormatCDATA(xmlTextWriterPtr writer, const char *format,
+                              ...)
+{
+    int rc;
+    va_list ap;
+
+    va_start(ap, format);
+
+    rc = xmlTextWriterWriteVFormatCDATA(writer, format, ap);
+
+    va_end(ap);
+    return rc;
+}
+
+/**
+ * xmlTextWriterWriteVFormatCDATA:
+ * @writer:  the xmlTextWriterPtr
+ * @format:  format string (see printf)
+ * @argptr:  pointer to the first member of the variable argument list.
+ *
+ * Write a formatted xml CDATA.
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterWriteVFormatCDATA(xmlTextWriterPtr writer, const char *format,
+                               va_list argptr)
+{
+    int rc;
+    xmlChar *buf;
+
+    if (writer == NULL)
+        return -1;
+
+    buf = xmlTextWriterVSprintf(format, argptr);
+    if (buf == 0)
+        return 0;
+
+    rc = xmlTextWriterWriteCDATA(writer, buf);
+
+    xmlFree(buf);
+    return rc;
+}
+
+/**
+ * xmlTextWriterWriteCDATA:
+ * @writer:  the xmlTextWriterPtr
+ * @content:  CDATA content
+ *
+ * Write an xml CDATA.
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterWriteCDATA(xmlTextWriterPtr writer, const xmlChar * content)
+{
+    int count;
+    int sum;
+
+    sum = 0;
+    count = xmlTextWriterStartCDATA(writer);
+    if (count == -1)
+        return -1;
+    sum += count;
+    if (content != 0) {
+        count = xmlTextWriterWriteString(writer, content);
+        if (count == -1)
+            return -1;
+        sum += count;
+    }
+    count = xmlTextWriterEndCDATA(writer);
+    if (count == -1)
+        return -1;
+    sum += count;
+
+    return sum;
+}
+
+/**
+ * xmlTextWriterStartDTD:
+ * @writer:  the xmlTextWriterPtr
+ * @name:  the name of the DTD
+ * @pubid:  the public identifier, which is an alternative to the system identifier
+ * @sysid:  the system identifier, which is the URI of the DTD
+ *
+ * Start an xml DTD.
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterStartDTD(xmlTextWriterPtr writer,
+                      const xmlChar * name,
+                      const xmlChar * pubid, const xmlChar * sysid)
+{
+    int count;
+    int sum;
+    xmlLinkPtr lk;
+    xmlTextWriterStackEntry *p;
+
+    if (writer == NULL || name == NULL || *name == '\0')
+        return -1;
+
+    sum = 0;
+    lk = xmlListFront(writer->nodes);
+    if ((lk != NULL) && (xmlLinkGetData(lk) != NULL)) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlTextWriterStartDTD : DTD allowed only in prolog!\n");
+        return -1;
+    }
+
+    p = (xmlTextWriterStackEntry *)
+        xmlMalloc(sizeof(xmlTextWriterStackEntry));
+    if (p == 0) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlTextWriterStartDTD : out of memory!\n");
+        return -1;
+    }
+
+    p->name = xmlStrdup(name);
+    if (p->name == 0) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlTextWriterStartDTD : out of memory!\n");
+        xmlFree(p);
+        return -1;
+    }
+    p->state = XML_TEXTWRITER_DTD;
+
+    xmlListPushFront(writer->nodes, p);
+
+    count = xmlOutputBufferWriteString(writer->out, "<!DOCTYPE ");
+    if (count < 0)
+        return -1;
+    sum += count;
+    count = xmlOutputBufferWriteString(writer->out, (const char *) name);
+    if (count < 0)
+        return -1;
+    sum += count;
+
+    if (pubid != 0) {
+        if (sysid == 0) {
+            xmlGenericError(xmlGenericErrorContext,
+                            "xmlTextWriterStartDTD : system identifier needed!\n");
+            return -1;
+        }
+
+        if (writer->indent)
+            count = xmlOutputBufferWrite(writer->out, 1, "\n");
+        else
+            count = xmlOutputBufferWrite(writer->out, 1, " ");
+        if (count < 0)
+            return -1;
+        sum += count;
+
+        count = xmlOutputBufferWriteString(writer->out, "PUBLIC ");
+        if (count < 0)
+            return -1;
+        sum += count;
+
+        count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
+        if (count < 0)
+            return -1;
+        sum += count;
+
+        count =
+            xmlOutputBufferWriteString(writer->out, (const char *) pubid);
+        if (count < 0)
+            return -1;
+        sum += count;
+
+        count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
+        if (count < 0)
+            return -1;
+        sum += count;
+    }
+
+    if (sysid != 0) {
+        if (pubid == 0) {
+            if (writer->indent)
+                count = xmlOutputBufferWrite(writer->out, 1, "\n");
+            else
+                count = xmlOutputBufferWrite(writer->out, 1, " ");
+            if (count < 0)
+                return -1;
+            sum += count;
+            count = xmlOutputBufferWriteString(writer->out, "SYSTEM ");
+            if (count < 0)
+                return -1;
+            sum += count;
+        } else if (writer->indent) {
+            count = xmlOutputBufferWriteString(writer->out, "\n       ");
+            if (count < 0)
+                return -1;
+            sum += count;
+        }
+
+        count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
+        if (count < 0)
+            return -1;
+        sum += count;
+
+        count =
+            xmlOutputBufferWriteString(writer->out, (const char *) sysid);
+        if (count < 0)
+            return -1;
+        sum += count;
+
+        count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
+        if (count < 0)
+            return -1;
+        sum += count;
+    }
+
+    return sum;
+}
+
+/**
+ * xmlTextWriterEndDTD:
+ * @writer:  the xmlTextWriterPtr
+ *
+ * End an xml DTD.
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterEndDTD(xmlTextWriterPtr writer)
+{
+    int loop;
+    int count;
+    int sum;
+    xmlLinkPtr lk;
+    xmlTextWriterStackEntry *p;
+
+    if (writer == NULL)
+        return -1;
+
+    sum = 0;
+    loop = 1;
+    while (loop) {
+        lk = xmlListFront(writer->nodes);
+        if (lk == NULL)
+            break;
+        p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
+        if (p == 0)
+            break;
+        switch (p->state) {
+            case XML_TEXTWRITER_DTD_TEXT:
+                count = xmlOutputBufferWriteString(writer->out, "]");
+                if (count < 0)
+                    return -1;
+                sum += count;
+                /* fallthrough */
+            case XML_TEXTWRITER_DTD:
+                count = xmlOutputBufferWriteString(writer->out, ">");
+
+                if (writer->indent) {
+                    if (count < 0)
+                        return -1;
+                    sum += count;
+                    count = xmlOutputBufferWriteString(writer->out, "\n");
+                }
+
+                xmlListPopFront(writer->nodes);
+                break;
+            case XML_TEXTWRITER_DTD_ELEM:
+            case XML_TEXTWRITER_DTD_ELEM_TEXT:
+                count = xmlTextWriterEndDTDElement(writer);
+                break;
+            case XML_TEXTWRITER_DTD_ATTL:
+            case XML_TEXTWRITER_DTD_ATTL_TEXT:
+                count = xmlTextWriterEndDTDAttlist(writer);
+                break;
+            case XML_TEXTWRITER_DTD_ENTY:
+            case XML_TEXTWRITER_DTD_PENT:
+            case XML_TEXTWRITER_DTD_ENTY_TEXT:
+                count = xmlTextWriterEndDTDEntity(writer);
+                break;
+            case XML_TEXTWRITER_COMMENT:
+                count = xmlTextWriterEndComment(writer);
+                break;
+            default:
+                loop = 0;
+                continue;
+        }
+
+        if (count < 0)
+            return -1;
+        sum += count;
+    }
+
+    return sum;
+}
+
+/**
+ * xmlTextWriterWriteFormatDTD:
+ * @writer:  the xmlTextWriterPtr
+ * @name:  the name of the DTD
+ * @pubid:  the public identifier, which is an alternative to the system identifier
+ * @sysid:  the system identifier, which is the URI of the DTD
+ * @format:  format string (see printf)
+ * @...:  extra parameters for the format
+ *
+ * Write a DTD with a formatted markup declarations part.
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterWriteFormatDTD(xmlTextWriterPtr writer,
+                            const xmlChar * name,
+                            const xmlChar * pubid,
+                            const xmlChar * sysid, const char *format, ...)
+{
+    int rc;
+    va_list ap;
+
+    va_start(ap, format);
+
+    rc = xmlTextWriterWriteVFormatDTD(writer, name, pubid, sysid, format,
+                                      ap);
+
+    va_end(ap);
+    return rc;
+}
+
+/**
+ * xmlTextWriterWriteVFormatDTD:
+ * @writer:  the xmlTextWriterPtr
+ * @name:  the name of the DTD
+ * @pubid:  the public identifier, which is an alternative to the system identifier
+ * @sysid:  the system identifier, which is the URI of the DTD
+ * @format:  format string (see printf)
+ * @argptr:  pointer to the first member of the variable argument list.
+ *
+ * Write a DTD with a formatted markup declarations part.
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterWriteVFormatDTD(xmlTextWriterPtr writer,
+                             const xmlChar * name,
+                             const xmlChar * pubid,
+                             const xmlChar * sysid,
+                             const char *format, va_list argptr)
+{
+    int rc;
+    xmlChar *buf;
+
+    if (writer == NULL)
+        return -1;
+
+    buf = xmlTextWriterVSprintf(format, argptr);
+    if (buf == 0)
+        return 0;
+
+    rc = xmlTextWriterWriteDTD(writer, name, pubid, sysid, buf);
+
+    xmlFree(buf);
+    return rc;
+}
+
+/**
+ * xmlTextWriterWriteDTD:
+ * @writer:  the xmlTextWriterPtr
+ * @name:  the name of the DTD
+ * @pubid:  the public identifier, which is an alternative to the system identifier
+ * @sysid:  the system identifier, which is the URI of the DTD
+ * @subset:  string content of the DTD
+ *
+ * Write a DTD.
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterWriteDTD(xmlTextWriterPtr writer,
+                      const xmlChar * name,
+                      const xmlChar * pubid,
+                      const xmlChar * sysid, const xmlChar * subset)
+{
+    int count;
+    int sum;
+
+    sum = 0;
+    count = xmlTextWriterStartDTD(writer, name, pubid, sysid);
+    if (count == -1)
+        return -1;
+    sum += count;
+    if (subset != 0) {
+        count = xmlTextWriterWriteString(writer, subset);
+        if (count == -1)
+            return -1;
+        sum += count;
+    }
+    count = xmlTextWriterEndDTD(writer);
+    if (count == -1)
+        return -1;
+    sum += count;
+
+    return sum;
+}
+
+/**
+ * xmlTextWriterStartDTDElement:
+ * @writer:  the xmlTextWriterPtr
+ * @name:  the name of the DTD element
+ *
+ * Start an xml DTD element.
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterStartDTDElement(xmlTextWriterPtr writer, const xmlChar * name)
+{
+    int count;
+    int sum;
+    xmlLinkPtr lk;
+    xmlTextWriterStackEntry *p;
+
+    if (writer == NULL || name == NULL || *name == '\0')
+        return -1;
+
+    sum = 0;
+    lk = xmlListFront(writer->nodes);
+    if (lk == 0) {
+        return -1;
+    }
+
+    p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
+    if (p != 0) {
+        switch (p->state) {
+            case XML_TEXTWRITER_DTD:
+                count = xmlOutputBufferWriteString(writer->out, " [");
+                if (count < 0)
+                    return -1;
+                sum += count;
+                if (writer->indent) {
+                    count = xmlOutputBufferWriteString(writer->out, "\n");
+                    if (count < 0)
+                        return -1;
+                    sum += count;
+                }
+                p->state = XML_TEXTWRITER_DTD_TEXT;
+                /* fallthrough */
+            case XML_TEXTWRITER_DTD_TEXT:
+            case XML_TEXTWRITER_NONE:
+                break;
+            default:
+                return -1;
+        }
+    }
+
+    p = (xmlTextWriterStackEntry *)
+        xmlMalloc(sizeof(xmlTextWriterStackEntry));
+    if (p == 0) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlTextWriterStartDTDElement : out of memory!\n");
+        return -1;
+    }
+
+    p->name = xmlStrdup(name);
+    if (p->name == 0) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlTextWriterStartDTDElement : out of memory!\n");
+        xmlFree(p);
+        return -1;
+    }
+    p->state = XML_TEXTWRITER_DTD_ELEM;
+
+    xmlListPushFront(writer->nodes, p);
+
+    if (writer->indent) {
+        count = xmlTextWriterWriteIndent(writer);
+        if (count < 0)
+            return -1;
+        sum += count;
+    }
+
+    count = xmlOutputBufferWriteString(writer->out, "<!ELEMENT ");
+    if (count < 0)
+        return -1;
+    sum += count;
+    count = xmlOutputBufferWriteString(writer->out, (const char *) name);
+    if (count < 0)
+        return -1;
+    sum += count;
+
+    return sum;
+}
+
+/**
+ * xmlTextWriterEndDTDElement:
+ * @writer:  the xmlTextWriterPtr
+ *
+ * End an xml DTD element.
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterEndDTDElement(xmlTextWriterPtr writer)
+{
+    int count;
+    int sum;
+    xmlLinkPtr lk;
+    xmlTextWriterStackEntry *p;
+
+    if (writer == NULL)
+        return -1;
+
+    sum = 0;
+    lk = xmlListFront(writer->nodes);
+    if (lk == 0)
+        return -1;
+
+    p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
+    if (p == 0)
+        return -1;
+
+    switch (p->state) {
+        case XML_TEXTWRITER_DTD_ELEM:
+        case XML_TEXTWRITER_DTD_ELEM_TEXT:
+            count = xmlOutputBufferWriteString(writer->out, ">");
+            if (count < 0)
+                return -1;
+            sum += count;
+            break;
+        default:
+            return -1;
+    }
+
+    if (writer->indent) {
+        count = xmlOutputBufferWriteString(writer->out, "\n");
+        if (count < 0)
+            return -1;
+        sum += count;
+    }
+
+    xmlListPopFront(writer->nodes);
+    return sum;
+}
+
+/**
+ * xmlTextWriterWriteFormatDTDElement:
+ * @writer:  the xmlTextWriterPtr
+ * @name:  the name of the DTD element
+ * @format:  format string (see printf)
+ * @...:  extra parameters for the format
+ *
+ * Write a formatted DTD element.
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterWriteFormatDTDElement(xmlTextWriterPtr writer,
+                                   const xmlChar * name,
+                                   const char *format, ...)
+{
+    int rc;
+    va_list ap;
+
+    va_start(ap, format);
+
+    rc = xmlTextWriterWriteVFormatDTDElement(writer, name, format, ap);
+
+    va_end(ap);
+    return rc;
+}
+
+/**
+ * xmlTextWriterWriteVFormatDTDElement:
+ * @writer:  the xmlTextWriterPtr
+ * @name:  the name of the DTD element
+ * @format:  format string (see printf)
+ * @argptr:  pointer to the first member of the variable argument list.
+ *
+ * Write a formatted DTD element.
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterWriteVFormatDTDElement(xmlTextWriterPtr writer,
+                                    const xmlChar * name,
+                                    const char *format, va_list argptr)
+{
+    int rc;
+    xmlChar *buf;
+
+    if (writer == NULL)
+        return -1;
+
+    buf = xmlTextWriterVSprintf(format, argptr);
+    if (buf == 0)
+        return 0;
+
+    rc = xmlTextWriterWriteDTDElement(writer, name, buf);
+
+    xmlFree(buf);
+    return rc;
+}
+
+/**
+ * xmlTextWriterWriteDTDElement:
+ * @writer:  the xmlTextWriterPtr
+ * @name:  the name of the DTD element
+ * @content:  content of the element
+ *
+ * Write a DTD element.
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterWriteDTDElement(xmlTextWriterPtr writer,
+                             const xmlChar * name, const xmlChar * content)
+{
+    int count;
+    int sum;
+
+    if (content == NULL)
+        return -1;
+
+    sum = 0;
+    count = xmlTextWriterStartDTDElement(writer, name);
+    if (count == -1)
+        return -1;
+    sum += count;
+
+    count = xmlTextWriterWriteString(writer, content);
+    if (count == -1)
+        return -1;
+    sum += count;
+
+    count = xmlTextWriterEndDTDElement(writer);
+    if (count == -1)
+        return -1;
+    sum += count;
+
+    return sum;
+}
+
+/**
+ * xmlTextWriterStartDTDAttlist:
+ * @writer:  the xmlTextWriterPtr
+ * @name:  the name of the DTD ATTLIST
+ *
+ * Start an xml DTD ATTLIST.
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterStartDTDAttlist(xmlTextWriterPtr writer, const xmlChar * name)
+{
+    int count;
+    int sum;
+    xmlLinkPtr lk;
+    xmlTextWriterStackEntry *p;
+
+    if (writer == NULL || name == NULL || *name == '\0')
+        return -1;
+
+    sum = 0;
+    lk = xmlListFront(writer->nodes);
+    if (lk == 0) {
+        return -1;
+    }
+
+    p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
+    if (p != 0) {
+        switch (p->state) {
+            case XML_TEXTWRITER_DTD:
+                count = xmlOutputBufferWriteString(writer->out, " [");
+                if (count < 0)
+                    return -1;
+                sum += count;
+                if (writer->indent) {
+                    count = xmlOutputBufferWriteString(writer->out, "\n");
+                    if (count < 0)
+                        return -1;
+                    sum += count;
+                }
+                p->state = XML_TEXTWRITER_DTD_TEXT;
+                /* fallthrough */
+            case XML_TEXTWRITER_DTD_TEXT:
+            case XML_TEXTWRITER_NONE:
+                break;
+            default:
+                return -1;
+        }
+    }
+
+    p = (xmlTextWriterStackEntry *)
+        xmlMalloc(sizeof(xmlTextWriterStackEntry));
+    if (p == 0) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlTextWriterStartDTDAttlist : out of memory!\n");
+        return -1;
+    }
+
+    p->name = xmlStrdup(name);
+    if (p->name == 0) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlTextWriterStartDTDAttlist : out of memory!\n");
+        xmlFree(p);
+        return -1;
+    }
+    p->state = XML_TEXTWRITER_DTD_ATTL;
+
+    xmlListPushFront(writer->nodes, p);
+
+    if (writer->indent) {
+        count = xmlTextWriterWriteIndent(writer);
+        if (count < 0)
+            return -1;
+        sum += count;
+    }
+
+    count = xmlOutputBufferWriteString(writer->out, "<!ATTLIST ");
+    if (count < 0)
+        return -1;
+    sum += count;
+    count = xmlOutputBufferWriteString(writer->out, (const char *) name);
+    if (count < 0)
+        return -1;
+    sum += count;
+
+    return sum;
+}
+
+/**
+ * xmlTextWriterEndDTDAttlist:
+ * @writer:  the xmlTextWriterPtr
+ *
+ * End an xml DTD attribute list.
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterEndDTDAttlist(xmlTextWriterPtr writer)
+{
+    int count;
+    int sum;
+    xmlLinkPtr lk;
+    xmlTextWriterStackEntry *p;
+
+    if (writer == NULL)
+        return -1;
+
+    sum = 0;
+    lk = xmlListFront(writer->nodes);
+    if (lk == 0)
+        return -1;
+
+    p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
+    if (p == 0)
+        return -1;
+
+    switch (p->state) {
+        case XML_TEXTWRITER_DTD_ATTL:
+        case XML_TEXTWRITER_DTD_ATTL_TEXT:
+            count = xmlOutputBufferWriteString(writer->out, ">");
+            if (count < 0)
+                return -1;
+            sum += count;
+            break;
+        default:
+            return -1;
+    }
+
+    if (writer->indent) {
+        count = xmlOutputBufferWriteString(writer->out, "\n");
+        if (count < 0)
+            return -1;
+        sum += count;
+    }
+
+    xmlListPopFront(writer->nodes);
+    return sum;
+}
+
+/**
+ * xmlTextWriterWriteFormatDTDAttlist:
+ * @writer:  the xmlTextWriterPtr
+ * @name:  the name of the DTD ATTLIST
+ * @format:  format string (see printf)
+ * @...:  extra parameters for the format
+ *
+ * Write a formatted DTD ATTLIST.
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterWriteFormatDTDAttlist(xmlTextWriterPtr writer,
+                                   const xmlChar * name,
+                                   const char *format, ...)
+{
+    int rc;
+    va_list ap;
+
+    va_start(ap, format);
+
+    rc = xmlTextWriterWriteVFormatDTDAttlist(writer, name, format, ap);
+
+    va_end(ap);
+    return rc;
+}
+
+/**
+ * xmlTextWriterWriteVFormatDTDAttlist:
+ * @writer:  the xmlTextWriterPtr
+ * @name:  the name of the DTD ATTLIST
+ * @format:  format string (see printf)
+ * @argptr:  pointer to the first member of the variable argument list.
+ *
+ * Write a formatted DTD ATTLIST.
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterWriteVFormatDTDAttlist(xmlTextWriterPtr writer,
+                                    const xmlChar * name,
+                                    const char *format, va_list argptr)
+{
+    int rc;
+    xmlChar *buf;
+
+    if (writer == NULL)
+        return -1;
+
+    buf = xmlTextWriterVSprintf(format, argptr);
+    if (buf == 0)
+        return 0;
+
+    rc = xmlTextWriterWriteDTDAttlist(writer, name, buf);
+
+    xmlFree(buf);
+    return rc;
+}
+
+/**
+ * xmlTextWriterWriteDTDAttlist:
+ * @writer:  the xmlTextWriterPtr
+ * @name:  the name of the DTD ATTLIST
+ * @content:  content of the ATTLIST
+ *
+ * Write a DTD ATTLIST.
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterWriteDTDAttlist(xmlTextWriterPtr writer,
+                             const xmlChar * name, const xmlChar * content)
+{
+    int count;
+    int sum;
+
+    if (content == NULL)
+        return -1;
+
+    sum = 0;
+    count = xmlTextWriterStartDTDAttlist(writer, name);
+    if (count == -1)
+        return -1;
+    sum += count;
+
+    count = xmlTextWriterWriteString(writer, content);
+    if (count == -1)
+        return -1;
+    sum += count;
+
+    count = xmlTextWriterEndDTDAttlist(writer);
+    if (count == -1)
+        return -1;
+    sum += count;
+
+    return sum;
+}
+
+/**
+ * xmlTextWriterStartDTDEntity:
+ * @writer:  the xmlTextWriterPtr
+ * @pe:  TRUE if this is a parameter entity, FALSE if not
+ * @name:  the name of the DTD ATTLIST
+ *
+ * Start an xml DTD ATTLIST.
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterStartDTDEntity(xmlTextWriterPtr writer,
+                            int pe, const xmlChar * name)
+{
+    int count;
+    int sum;
+    xmlLinkPtr lk;
+    xmlTextWriterStackEntry *p;
+
+    if (writer == NULL || name == NULL || *name == '\0')
+        return -1;
+
+    sum = 0;
+    lk = xmlListFront(writer->nodes);
+    if (lk != 0) {
+
+        p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
+        if (p != 0) {
+            switch (p->state) {
+                case XML_TEXTWRITER_DTD:
+                    count = xmlOutputBufferWriteString(writer->out, " [");
+                    if (count < 0)
+                        return -1;
+                    sum += count;
+                    if (writer->indent) {
+                        count =
+                            xmlOutputBufferWriteString(writer->out, "\n");
+                        if (count < 0)
+                            return -1;
+                        sum += count;
+                    }
+                    p->state = XML_TEXTWRITER_DTD_TEXT;
+                    /* fallthrough */
+                case XML_TEXTWRITER_DTD_TEXT:
+                case XML_TEXTWRITER_NONE:
+                    break;
+                default:
+                    return -1;
+            }
+        }
+    }
+
+    p = (xmlTextWriterStackEntry *)
+        xmlMalloc(sizeof(xmlTextWriterStackEntry));
+    if (p == 0) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlTextWriterStartDTDElement : out of memory!\n");
+        return -1;
+    }
+
+    p->name = xmlStrdup(name);
+    if (p->name == 0) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlTextWriterStartDTDElement : out of memory!\n");
+        xmlFree(p);
+        return -1;
+    }
+
+    if (pe != 0)
+        p->state = XML_TEXTWRITER_DTD_PENT;
+    else
+        p->state = XML_TEXTWRITER_DTD_ENTY;
+
+    xmlListPushFront(writer->nodes, p);
+
+    if (writer->indent) {
+        count = xmlTextWriterWriteIndent(writer);
+        if (count < 0)
+            return -1;
+        sum += count;
+    }
+
+    count = xmlOutputBufferWriteString(writer->out, "<!ENTITY ");
+    if (count < 0)
+        return -1;
+    sum += count;
+
+    if (pe != 0) {
+        count = xmlOutputBufferWriteString(writer->out, "% ");
+        if (count < 0)
+            return -1;
+        sum += count;
+    }
+
+    count = xmlOutputBufferWriteString(writer->out, (const char *) name);
+    if (count < 0)
+        return -1;
+    sum += count;
+
+    return sum;
+}
+
+/**
+ * xmlTextWriterEndDTDEntity:
+ * @writer:  the xmlTextWriterPtr
+ *
+ * End an xml DTD entity.
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterEndDTDEntity(xmlTextWriterPtr writer)
+{
+    int count;
+    int sum;
+    xmlLinkPtr lk;
+    xmlTextWriterStackEntry *p;
+
+    if (writer == NULL)
+        return -1;
+
+    sum = 0;
+    lk = xmlListFront(writer->nodes);
+    if (lk == 0)
+        return -1;
+
+    p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
+    if (p == 0)
+        return -1;
+
+    switch (p->state) {
+        case XML_TEXTWRITER_DTD_ENTY_TEXT:
+            count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
+            if (count < 0)
+                return -1;
+            sum += count;
+        case XML_TEXTWRITER_DTD_ENTY:
+        case XML_TEXTWRITER_DTD_PENT:
+            count = xmlOutputBufferWriteString(writer->out, ">");
+            if (count < 0)
+                return -1;
+            sum += count;
+            break;
+        default:
+            return -1;
+    }
+
+    if (writer->indent) {
+        count = xmlOutputBufferWriteString(writer->out, "\n");
+        if (count < 0)
+            return -1;
+        sum += count;
+    }
+
+    xmlListPopFront(writer->nodes);
+    return sum;
+}
+
+/**
+ * xmlTextWriterWriteFormatDTDInternalEntity:
+ * @writer:  the xmlTextWriterPtr
+ * @pe:  TRUE if this is a parameter entity, FALSE if not
+ * @name:  the name of the DTD entity
+ * @format:  format string (see printf)
+ * @...:  extra parameters for the format
+ *
+ * Write a formatted DTD internal entity.
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterWriteFormatDTDInternalEntity(xmlTextWriterPtr writer,
+                                          int pe,
+                                          const xmlChar * name,
+                                          const char *format, ...)
+{
+    int rc;
+    va_list ap;
+
+    va_start(ap, format);
+
+    rc = xmlTextWriterWriteVFormatDTDInternalEntity(writer, pe, name,
+                                                    format, ap);
+
+    va_end(ap);
+    return rc;
+}
+
+/**
+ * xmlTextWriterWriteVFormatDTDInternalEntity:
+ * @writer:  the xmlTextWriterPtr
+ * @pe:  TRUE if this is a parameter entity, FALSE if not
+ * @name:  the name of the DTD entity
+ * @format:  format string (see printf)
+ * @argptr:  pointer to the first member of the variable argument list.
+ *
+ * Write a formatted DTD internal entity.
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterWriteVFormatDTDInternalEntity(xmlTextWriterPtr writer,
+                                           int pe,
+                                           const xmlChar * name,
+                                           const char *format,
+                                           va_list argptr)
+{
+    int rc;
+    xmlChar *buf;
+
+    if (writer == NULL)
+        return -1;
+
+    buf = xmlTextWriterVSprintf(format, argptr);
+    if (buf == 0)
+        return 0;
+
+    rc = xmlTextWriterWriteDTDInternalEntity(writer, pe, name, buf);
+
+    xmlFree(buf);
+    return rc;
+}
+
+/**
+ * xmlTextWriterWriteDTDEntity:
+ * @writer:  the xmlTextWriterPtr
+ * @pe:  TRUE if this is a parameter entity, FALSE if not
+ * @name:  the name of the DTD entity
+ * @pubid:  the public identifier, which is an alternative to the system identifier
+ * @sysid:  the system identifier, which is the URI of the DTD
+ * @ndataid:  the xml notation name.
+ * @content:  content of the entity
+ *
+ * Write a DTD entity.
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterWriteDTDEntity(xmlTextWriterPtr writer,
+                            int pe,
+                            const xmlChar * name,
+                            const xmlChar * pubid,
+                            const xmlChar * sysid,
+                            const xmlChar * ndataid,
+                            const xmlChar * content)
+{
+    if ((content == NULL) && (pubid == NULL) && (sysid == NULL))
+        return -1;
+    if ((pe != 0) && (ndataid != NULL))
+        return -1;
+
+    if ((pubid == NULL) && (sysid == NULL))
+        return xmlTextWriterWriteDTDInternalEntity(writer, pe, name,
+                                                   content);
+
+    return xmlTextWriterWriteDTDExternalEntity(writer, pe, name, pubid,
+                                               sysid, ndataid);
+}
+
+/**
+ * xmlTextWriterWriteDTDInternalEntity:
+ * @writer:  the xmlTextWriterPtr
+ * @pe:  TRUE if this is a parameter entity, FALSE if not
+ * @name:  the name of the DTD entity
+ * @content:  content of the entity
+ *
+ * Write a DTD internal entity.
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterWriteDTDInternalEntity(xmlTextWriterPtr writer,
+                                    int pe,
+                                    const xmlChar * name,
+                                    const xmlChar * content)
+{
+    int count;
+    int sum;
+
+    if ((name == NULL) || (*name == '\0') || (content == NULL))
+        return -1;
+
+    sum = 0;
+    count = xmlTextWriterStartDTDEntity(writer, pe, name);
+    if (count == -1)
+        return -1;
+    sum += count;
+
+    count = xmlTextWriterWriteString(writer, content);
+    if (count == -1)
+        return -1;
+    sum += count;
+
+    count = xmlTextWriterEndDTDEntity(writer);
+    if (count == -1)
+        return -1;
+    sum += count;
+
+    return sum;
+}
+
+/**
+ * xmlTextWriterWriteDTDExternalEntity:
+ * @writer:  the xmlTextWriterPtr
+ * @pe:  TRUE if this is a parameter entity, FALSE if not
+ * @name:  the name of the DTD entity
+ * @pubid:  the public identifier, which is an alternative to the system identifier
+ * @sysid:  the system identifier, which is the URI of the DTD
+ * @ndataid:  the xml notation name.
+ *
+ * Write a DTD external entity. The entity must have been started with xmlTextWriterStartDTDEntity
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterWriteDTDExternalEntity(xmlTextWriterPtr writer,
+                                    int pe,
+                                    const xmlChar * name,
+                                    const xmlChar * pubid,
+                                    const xmlChar * sysid,
+                                    const xmlChar * ndataid)
+{
+    int count;
+    int sum;
+
+    if (((pubid == NULL) && (sysid == NULL)))
+        return -1;
+    if ((pe != 0) && (ndataid != NULL))
+        return -1;
+
+    sum = 0;
+    count = xmlTextWriterStartDTDEntity(writer, pe, name);
+    if (count == -1)
+        return -1;
+    sum += count;
+
+    count =
+        xmlTextWriterWriteDTDExternalEntityContents(writer, pubid, sysid,
+                                                    ndataid);
+    if (count < 0)
+        return -1;
+    sum += count;
+
+    count = xmlTextWriterEndDTDEntity(writer);
+    if (count == -1)
+        return -1;
+    sum += count;
+
+    return sum;
+}
+
+/**
+ * xmlTextWriterWriteDTDExternalEntityContents:
+ * @writer:  the xmlTextWriterPtr
+ * @pubid:  the public identifier, which is an alternative to the system identifier
+ * @sysid:  the system identifier, which is the URI of the DTD
+ * @ndataid:  the xml notation name.
+ *
+ * Write the contents of a DTD external entity.
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterWriteDTDExternalEntityContents(xmlTextWriterPtr writer,
+                                            const xmlChar * pubid,
+                                            const xmlChar * sysid,
+                                            const xmlChar * ndataid)
+{
+    int count;
+    int sum;
+    xmlLinkPtr lk;
+    xmlTextWriterStackEntry *p;
+
+    if (writer == NULL) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlTextWriterWriteDTDExternalEntityContents: xmlTextWriterPtr invalid!\n");
+        return -1;
+    }
+
+    sum = 0;
+    lk = xmlListFront(writer->nodes);
+    if (lk == 0) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlTextWriterWriteDTDExternalEntityContents: you must call xmlTextWriterStartDTDEntity before the call to this function!\n");
+        return -1;
+    }
+
+    p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
+    if (p == 0)
+        return -1;
+
+    switch (p->state) {
+        case XML_TEXTWRITER_DTD_ENTY:
+            break;
+        case XML_TEXTWRITER_DTD_PENT:
+            if (ndataid != NULL) {
+                xmlGenericError(xmlGenericErrorContext,
+                                "xmlTextWriterWriteDTDExternalEntityContents: notation not allowed with parameter entities!\n");
+                return -1;
+            }
+            break;
+        default:
+            xmlGenericError(xmlGenericErrorContext,
+                            "xmlTextWriterWriteDTDExternalEntityContents: you must call xmlTextWriterStartDTDEntity before the call to this function!\n");
+            return -1;
+    }
+
+    if (pubid != 0) {
+        if (sysid == 0) {
+            xmlGenericError(xmlGenericErrorContext,
+                            "xmlTextWriterWriteDTDExternalEntityContents: system identifier needed!\n");
+            return -1;
+        }
+
+        count = xmlOutputBufferWriteString(writer->out, " PUBLIC ");
+        if (count < 0)
+            return -1;
+        sum += count;
+
+        count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
+        if (count < 0)
+            return -1;
+        sum += count;
+
+        count =
+            xmlOutputBufferWriteString(writer->out, (const char *) pubid);
+        if (count < 0)
+            return -1;
+        sum += count;
+
+        count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
+        if (count < 0)
+            return -1;
+        sum += count;
+    }
+
+    if (sysid != 0) {
+        if (pubid == 0) {
+            count = xmlOutputBufferWriteString(writer->out, " SYSTEM");
+            if (count < 0)
+                return -1;
+            sum += count;
+        }
+
+        count = xmlOutputBufferWriteString(writer->out, " ");
+        if (count < 0)
+            return -1;
+        sum += count;
+
+        count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
+        if (count < 0)
+            return -1;
+        sum += count;
+
+        count =
+            xmlOutputBufferWriteString(writer->out, (const char *) sysid);
+        if (count < 0)
+            return -1;
+        sum += count;
+
+        count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
+        if (count < 0)
+            return -1;
+        sum += count;
+    }
+
+    if (ndataid != NULL) {
+        count = xmlOutputBufferWriteString(writer->out, " NDATA ");
+        if (count < 0)
+            return -1;
+        sum += count;
+
+        count =
+            xmlOutputBufferWriteString(writer->out,
+                                       (const char *) ndataid);
+        if (count < 0)
+            return -1;
+        sum += count;
+    }
+
+    return sum;
+}
+
+/**
+ * xmlTextWriterWriteDTDNotation:
+ * @writer:  the xmlTextWriterPtr
+ * @name:  the name of the xml notation
+ * @pubid:  the public identifier, which is an alternative to the system identifier
+ * @sysid:  the system identifier, which is the URI of the DTD
+ *
+ * Write a DTD entity.
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterWriteDTDNotation(xmlTextWriterPtr writer,
+                              const xmlChar * name,
+                              const xmlChar * pubid, const xmlChar * sysid)
+{
+    int count;
+    int sum;
+    xmlLinkPtr lk;
+    xmlTextWriterStackEntry *p;
+
+    if (writer == NULL || name == NULL || *name == '\0')
+        return -1;
+
+    sum = 0;
+    lk = xmlListFront(writer->nodes);
+    if (lk == 0) {
+        return -1;
+    }
+
+    p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
+    if (p != 0) {
+        switch (p->state) {
+            case XML_TEXTWRITER_DTD:
+                count = xmlOutputBufferWriteString(writer->out, " [");
+                if (count < 0)
+                    return -1;
+                sum += count;
+                if (writer->indent) {
+                    count = xmlOutputBufferWriteString(writer->out, "\n");
+                    if (count < 0)
+                        return -1;
+                    sum += count;
+                }
+                p->state = XML_TEXTWRITER_DTD_TEXT;
+                /* fallthrough */
+            case XML_TEXTWRITER_DTD_TEXT:
+                break;
+            default:
+                return -1;
+        }
+    }
+
+    if (writer->indent) {
+        count = xmlTextWriterWriteIndent(writer);
+        if (count < 0)
+            return -1;
+        sum += count;
+    }
+
+    count = xmlOutputBufferWriteString(writer->out, "<!NOTATION ");
+    if (count < 0)
+        return -1;
+    sum += count;
+    count = xmlOutputBufferWriteString(writer->out, (const char *) name);
+    if (count < 0)
+        return -1;
+    sum += count;
+
+    if (pubid != 0) {
+        count = xmlOutputBufferWriteString(writer->out, " PUBLIC ");
+        if (count < 0)
+            return -1;
+        sum += count;
+        count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
+        if (count < 0)
+            return -1;
+        sum += count;
+        count =
+            xmlOutputBufferWriteString(writer->out, (const char *) pubid);
+        if (count < 0)
+            return -1;
+        sum += count;
+        count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
+        if (count < 0)
+            return -1;
+        sum += count;
+    }
+
+    if (sysid != 0) {
+        if (pubid == 0) {
+            count = xmlOutputBufferWriteString(writer->out, " SYSTEM");
+            if (count < 0)
+                return -1;
+            sum += count;
+        }
+        count = xmlOutputBufferWriteString(writer->out, " ");
+        if (count < 0)
+            return -1;
+        sum += count;
+        count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
+        if (count < 0)
+            return -1;
+        sum += count;
+        count =
+            xmlOutputBufferWriteString(writer->out, (const char *) sysid);
+        if (count < 0)
+            return -1;
+        sum += count;
+        count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
+        if (count < 0)
+            return -1;
+        sum += count;
+    }
+
+    count = xmlOutputBufferWriteString(writer->out, ">");
+    if (count < 0)
+        return -1;
+    sum += count;
+
+    return sum;
+}
+
+/**
+ * xmlTextWriterFlush:
+ * @writer:  the xmlTextWriterPtr
+ *
+ * Flush the output buffer.
+ *
+ * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
+ */
+int
+xmlTextWriterFlush(xmlTextWriterPtr writer)
+{
+    int count;
+
+    if (writer == NULL)
+        return -1;
+
+    if (writer->out == NULL)
+        count = 0;
+    else
+        count = xmlOutputBufferFlush(writer->out);
+
+    return count;
+}
+
+/**
+ * misc
+ */
+
+/**
+ * xmlFreeTextWriterStackEntry:
+ * @lk:  the xmlLinkPtr
+ *
+ * Free callback for the xmlList.
+ */
+static void
+xmlFreeTextWriterStackEntry(xmlLinkPtr lk)
+{
+    xmlTextWriterStackEntry *p;
+
+    p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
+    if (p == 0)
+        return;
+
+    if (p->name != 0)
+        xmlFree(p->name);
+    xmlFree(p);
+}
+
+/**
+ * xmlCmpTextWriterStackEntry:
+ * @data0:  the first data
+ * @data1:  the second data
+ *
+ * Compare callback for the xmlList.
+ *
+ * Returns -1, 0, 1
+ */
+static int
+xmlCmpTextWriterStackEntry(const void *data0, const void *data1)
+{
+    xmlTextWriterStackEntry *p0;
+    xmlTextWriterStackEntry *p1;
+
+    if (data0 == data1)
+        return 0;
+
+    if (data0 == 0)
+        return -1;
+
+    if (data1 == 0)
+        return 1;
+
+    p0 = (xmlTextWriterStackEntry *) data0;
+    p1 = (xmlTextWriterStackEntry *) data1;
+
+    return xmlStrcmp(p0->name, p1->name);
+}
+
+/**
+ * misc
+ */
+
+/**
+ * xmlFreeTextWriterNsStackEntry:
+ * @lk:  the xmlLinkPtr
+ *
+ * Free callback for the xmlList.
+ */
+static void
+xmlFreeTextWriterNsStackEntry(xmlLinkPtr lk)
+{
+    xmlTextWriterNsStackEntry *p;
+
+    p = (xmlTextWriterNsStackEntry *) xmlLinkGetData(lk);
+    if (p == 0)
+        return;
+
+    if (p->prefix != 0)
+        xmlFree(p->prefix);
+    if (p->uri != 0)
+        xmlFree(p->uri);
+
+    xmlFree(p);
+}
+
+/**
+ * xmlCmpTextWriterNsStackEntry:
+ * @data0:  the first data
+ * @data1:  the second data
+ *
+ * Compare callback for the xmlList.
+ *
+ * Returns -1, 0, 1
+ */
+static int
+xmlCmpTextWriterNsStackEntry(const void *data0, const void *data1)
+{
+    xmlTextWriterNsStackEntry *p0;
+    xmlTextWriterNsStackEntry *p1;
+    int rc;
+
+    if (data0 == data1)
+        return 0;
+
+    if (data0 == 0)
+        return -1;
+
+    if (data1 == 0)
+        return 1;
+
+    p0 = (xmlTextWriterNsStackEntry *) data0;
+    p1 = (xmlTextWriterNsStackEntry *) data1;
+
+    rc = xmlStrcmp(p0->prefix, p1->prefix);
+
+    if (rc == 0)
+        rc = p0->elem == p1->elem;
+
+    return rc;
+}
+
+/**
+ * xmlTextWriterWriteMemCallback:
+ * @context:  the xmlBufferPtr
+ * @str:  the data to write
+ * @len:  the length of the data
+ *
+ * Write callback for the xmlOutputBuffer with target xmlBuffer
+ *
+ * Returns -1, 0, 1
+ */
+static int
+xmlTextWriterWriteMemCallback(void *context, const xmlChar * str, int len)
+{
+    xmlBufferPtr buf = (xmlBufferPtr) context;
+
+    xmlBufferAdd(buf, str, len);
+
+    return len;
+}
+
+/**
+ * xmlTextWriterCloseMemCallback:
+ * @context:  the xmlBufferPtr
+ *
+ * Close callback for the xmlOutputBuffer with target xmlBuffer
+ *
+ * Returns -1, 0, 1
+ */
+static int
+xmlTextWriterCloseMemCallback(void *context ATTRIBUTE_UNUSED)
+{
+    return 0;
+}
+
+/**
+ * xmlTextWriterWriteDocCallback:
+ * @context:  the xmlBufferPtr
+ * @str:  the data to write
+ * @len:  the length of the data
+ *
+ * Write callback for the xmlOutputBuffer with target xmlBuffer
+ *
+ * Returns -1, 0, 1
+ */
+static int
+xmlTextWriterWriteDocCallback(void *context, const xmlChar * str, int len)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) context;
+    int rc;
+
+    if ((rc = xmlParseChunk(ctxt, (const char *) str, len, 0)) != 0) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlTextWriterWriteDocCallback : XML error %d !\n",
+                        rc);
+        return -1;
+    }
+
+    return len;
+}
+
+/**
+ * xmlTextWriterCloseDocCallback:
+ * @context:  the xmlBufferPtr
+ *
+ * Close callback for the xmlOutputBuffer with target xmlBuffer
+ *
+ * Returns -1, 0, 1
+ */
+static int
+xmlTextWriterCloseDocCallback(void *context)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) context;
+    int rc;
+
+    if ((rc = xmlParseChunk(ctxt, NULL, 0, 1)) != 0) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlTextWriterWriteDocCallback : XML error %d !\n",
+                        rc);
+        return -1;
+    }
+
+    return 0;
+}
+
+/**
+ * xmlTextWriterVSprintf:
+ * @format:  see printf
+ * @argptr:  pointer to the first member of the variable argument list.
+ *
+ * Utility function for formatted output
+ *
+ * Returns a new xmlChar buffer with the data or NULL on error. This buffer must be freed.
+ */
+static xmlChar *
+xmlTextWriterVSprintf(const char *format, va_list argptr)
+{
+    int size;
+    int count;
+    xmlChar *buf;
+
+    size = BUFSIZ;
+    buf = (xmlChar *) xmlMalloc(size);
+    if (buf == NULL) {
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlTextWriterVSprintf : out of memory!\n");
+        return NULL;
+    }
+
+    while (((count = vsnprintf((char *) buf, size, format, argptr)) < 0)
+           || (count == size - 1) || (count == size) || (count > size)) {
+        xmlFree(buf);
+        size += BUFSIZ;
+        buf = (xmlChar *) xmlMalloc(size);
+        if (buf == NULL) {
+            xmlGenericError(xmlGenericErrorContext,
+                            "xmlTextWriterVSprintf : out of memory!\n");
+            return NULL;
+        }
+    }
+
+    return buf;
+}
+
+/**
+ * xmlTextWriterStartDocumentCallback:
+ * @ctx: the user data (XML parser context)
+ *
+ * called at the start of document processing.
+ */
+static void
+xmlTextWriterStartDocumentCallback(void *ctx)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+    xmlDocPtr doc;
+
+#ifdef DEBUG_SAX
+    xmlGenericError(xmlGenericErrorContext, "SAX.startDocument()\n");
+#endif
+    if (ctxt->html) {
+#ifdef LIBXML_HTML_ENABLED
+        if (ctxt->myDoc == NULL)
+            ctxt->myDoc = htmlNewDocNoDtD(NULL, NULL);
+        if (ctxt->myDoc == NULL) {
+            if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
+                ctxt->sax->error(ctxt->userData,
+                                 "SAX.startDocument(): out of memory\n");
+            ctxt->errNo = XML_ERR_NO_MEMORY;
+            ctxt->instate = XML_PARSER_EOF;
+            ctxt->disableSAX = 1;
+            return;
+        }
+#else
+        xmlGenericError(xmlGenericErrorContext,
+                        "libxml2 built without HTML support\n");
+        ctxt->errNo = XML_ERR_INTERNAL_ERROR;
+        ctxt->instate = XML_PARSER_EOF;
+        ctxt->disableSAX = 1;
+        return;
+#endif
+    } else {
+        doc = ctxt->myDoc;
+        if (doc == NULL)
+            doc = ctxt->myDoc = xmlNewDoc(ctxt->version);
+        if (doc != NULL) {
+            if (doc->children == NULL) {
+                if (ctxt->encoding != NULL)
+                    doc->encoding = xmlStrdup(ctxt->encoding);
+                else
+                    doc->encoding = NULL;
+                doc->standalone = ctxt->standalone;
+            }
+        } else {
+            if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
+                ctxt->sax->error(ctxt->userData,
+                                 "SAX.startDocument(): out of memory\n");
+            ctxt->errNo = XML_ERR_NO_MEMORY;
+            ctxt->instate = XML_PARSER_EOF;
+            ctxt->disableSAX = 1;
+            return;
+        }
+    }
+    if ((ctxt->myDoc != NULL) && (ctxt->myDoc->URL == NULL) &&
+        (ctxt->input != NULL) && (ctxt->input->filename != NULL)) {
+        ctxt->myDoc->URL =
+            xmlCanonicPath((const xmlChar *) ctxt->input->filename);
+        if (ctxt->myDoc->URL == NULL)
+            ctxt->myDoc->URL =
+                xmlStrdup((const xmlChar *) ctxt->input->filename);
+    }
+}
+
+/**
+ * xmlTextWriterSetIndent:
+ * @writer:  the xmlTextWriterPtr
+ * @indent:  do indentation?
+ *
+ * Set indentation output. indent = 0 do not indentation. indent > 0 do indentation.
+ *
+ * Returns -1 on error or 0 otherwise.
+ */
+int
+xmlTextWriterSetIndent(xmlTextWriterPtr writer, int indent)
+{
+    if (indent < 0)
+        return -1;
+
+    writer->indent = indent;
+    writer->doindent = 1;
+
+    return 0;
+}
+
+/**
+ * xmlTextWriterSetIndentString:
+ * @writer:  the xmlTextWriterPtr
+ * @str:  the xmlChar string
+ *
+ * Set string indentation.
+ *
+ * Returns -1 on error or 0 otherwise.
+ */
+int
+xmlTextWriterSetIndentString(xmlTextWriterPtr writer, const xmlChar * str)
+{
+    if (!str)
+        return -1;
+
+    if (writer->ichar != NULL)
+        xmlFree(writer->ichar);
+    writer->ichar = xmlStrdup(str);
+
+    if (!writer->ichar)
+        return -1;
+    else
+        return 0;
+}
+
+/**
+ * xmlTextWriterWriteIndent:
+ * @writer:  the xmlTextWriterPtr
+ *
+ * Write indent string.
+ *
+ * Returns -1 on error or the number of strings written.
+ */
+static int
+xmlTextWriterWriteIndent(xmlTextWriterPtr writer)
+{
+    int lksize;
+    int i;
+    int ret;
+
+    lksize = xmlListSize(writer->nodes);
+    if (lksize < 1)
+        return (-1);            /* list is empty */
+    for (i = 0; i < (lksize - 1); i++) {
+        ret = xmlOutputBufferWriteString(writer->out,
+                                         (const char *) writer->ichar);
+        if (ret == -1)
+            return (-1);
+    }
+
+    return (lksize - 1);
+}
+
+/**
+ * xmlTextWriterHandleStateDependencies:
+ * @writer:  the xmlTextWriterPtr
+ * @p:  the xmlTextWriterStackEntry
+ *
+ * Write state dependent strings.
+ *
+ * Returns -1 on error or the number of characters written.
+ */
+static int
+xmlTextWriterHandleStateDependencies(xmlTextWriterPtr writer,
+                                     xmlTextWriterStackEntry * p)
+{
+    int count;
+    int sum;
+    char extra[3];
+
+    if (writer == NULL)
+        return -1;
+
+    if (p == NULL)
+        return 0;
+
+    sum = 0;
+    extra[0] = extra[1] = extra[2] = '\0';
+    if (p != 0) {
+        sum = 0;
+        switch (p->state) {
+            case XML_TEXTWRITER_NAME:
+                extra[0] = '>';
+                p->state = XML_TEXTWRITER_TEXT;
+                break;
+            case XML_TEXTWRITER_PI:
+                extra[0] = ' ';
+                p->state = XML_TEXTWRITER_PI_TEXT;
+                break;
+            case XML_TEXTWRITER_DTD:
+                extra[0] = ' ';
+                extra[1] = '[';
+                p->state = XML_TEXTWRITER_DTD_TEXT;
+                break;
+            case XML_TEXTWRITER_DTD_ELEM:
+                extra[0] = ' ';
+                p->state = XML_TEXTWRITER_DTD_ELEM_TEXT;
+                break;
+            case XML_TEXTWRITER_DTD_ATTL:
+                extra[0] = ' ';
+                p->state = XML_TEXTWRITER_DTD_ATTL_TEXT;
+                break;
+            case XML_TEXTWRITER_DTD_ENTY:
+            case XML_TEXTWRITER_DTD_PENT:
+                extra[0] = ' ';
+                extra[1] = writer->qchar;
+                p->state = XML_TEXTWRITER_DTD_ENTY_TEXT;
+                break;
+            default:
+                break;
+        }
+    }
+
+    if (*extra != '\0') {
+        count = xmlOutputBufferWriteString(writer->out, extra);
+        if (count < 0)
+            return -1;
+        sum += count;
+    }
+
+    return sum;
+}
+
+#endif
diff --git a/src/libxml/src/xpath.c b/src/libxml/src/xpath.c
new file mode 100644
index 0000000..554350d
--- /dev/null
+++ b/src/libxml/src/xpath.c
@@ -0,0 +1,11391 @@
+/*
+ * xpath.c: XML Path Language implementation
+ *          XPath is a language for addressing parts of an XML document,
+ *          designed to be used by both XSLT and XPointer
+ *
+ * Reference: W3C Recommendation 16 November 1999
+ *     http://www.w3.org/TR/1999/REC-xpath-19991116
+ * Public reference:
+ *     http://www.w3.org/TR/xpath
+ *
+ * See Copyright for the status of this software
+ *
+ * Author: daniel@veillard.com
+ *
+ */
+
+#define IN_LIBXML
+#include "libxml.h"
+
+#include <string.h>
+
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_MATH_H
+#include <math.h>
+#endif
+#ifdef HAVE_FLOAT_H
+#include <float.h>
+#endif
+#ifdef HAVE_CTYPE_H
+#include <ctype.h>
+#endif
+#ifdef HAVE_SIGNAL_H
+#include <signal.h>
+#endif
+
+#include <libxml/xmlmemory.h>
+#include <libxml/tree.h>
+#include <libxml/valid.h>
+#include <libxml/xpath.h>
+#include <libxml/xpathInternals.h>
+#include <libxml/parserInternals.h>
+#include <libxml/hash.h>
+#ifdef LIBXML_XPTR_ENABLED
+#include <libxml/xpointer.h>
+#endif
+#ifdef LIBXML_DEBUG_ENABLED
+#include <libxml/debugXML.h>
+#endif
+#include <libxml/xmlerror.h>
+#include <libxml/threads.h>
+#include <libxml/globals.h>
+
+#define TODO 								\
+    xmlGenericError(xmlGenericErrorContext,				\
+	    "Unimplemented block at %s:%d\n",				\
+            __FILE__, __LINE__);
+
+#if defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_XPATH_ENABLED)
+/************************************************************************
+ * 									*
+ * 			Floating point stuff				*
+ * 									*
+ ************************************************************************/
+
+#ifndef TRIO_REPLACE_STDIO
+#define TRIO_PUBLIC static
+#endif
+#include "trionan.c"
+
+/*
+ * The lack of portability of this section of the libc is annoying !
+ */
+double xmlXPathNAN = 0;
+double xmlXPathPINF = 1;
+double xmlXPathNINF = -1;
+double xmlXPathNZERO = 0;
+static int xmlXPathInitialized = 0;
+
+/**
+ * xmlXPathInit:
+ *
+ * Initialize the XPath environment
+ */
+void
+xmlXPathInit(void) {
+    if (xmlXPathInitialized) return;
+
+    xmlXPathPINF = trio_pinf();
+    xmlXPathNINF = trio_ninf();
+    xmlXPathNAN = trio_nan();
+    xmlXPathNZERO = trio_nzero();
+
+    xmlXPathInitialized = 1;
+}
+
+/**
+ * xmlXPathIsNaN:
+ * @val:  a double value
+ *
+ * Provides a portable isnan() function to detect whether a double
+ * is a NotaNumber. Based on trio code
+ * http://sourceforge.net/projects/ctrio/
+ * 
+ * Returns 1 if the value is a NaN, 0 otherwise
+ */
+int
+xmlXPathIsNaN(double val) {
+    return(trio_isnan(val));
+}
+
+/**
+ * xmlXPathIsInf:
+ * @val:  a double value
+ *
+ * Provides a portable isinf() function to detect whether a double
+ * is a +Infinite or -Infinite. Based on trio code
+ * http://sourceforge.net/projects/ctrio/
+ * 
+ * Returns 1 vi the value is +Infinite, -1 if -Infinite, 0 otherwise
+ */
+int
+xmlXPathIsInf(double val) {
+    return(trio_isinf(val));
+}
+
+#endif /* SCHEMAS or XPATH */
+#ifdef LIBXML_XPATH_ENABLED
+/**
+ * xmlXPathGetSign:
+ * @val:  a double value
+ *
+ * Provides a portable function to detect the sign of a double
+ * Modified from trio code
+ * http://sourceforge.net/projects/ctrio/
+ * 
+ * Returns 1 if the value is Negative, 0 if positive
+ */
+static int
+xmlXPathGetSign(double val) {
+    return(trio_signbit(val));
+}
+
+
+/*
+ * TODO: when compatibility allows remove all "fake node libxslt" strings
+ *       the test should just be name[0] = ' '
+ */
+/* #define DEBUG */
+/* #define DEBUG_STEP */
+/* #define DEBUG_STEP_NTH */
+/* #define DEBUG_EXPR */
+/* #define DEBUG_EVAL_COUNTS */
+
+static xmlNs xmlXPathXMLNamespaceStruct = {
+    NULL,
+    XML_NAMESPACE_DECL,
+    XML_XML_NAMESPACE,
+    BAD_CAST "xml",
+    NULL
+};
+static xmlNsPtr xmlXPathXMLNamespace = &xmlXPathXMLNamespaceStruct;
+#ifndef LIBXML_THREAD_ENABLED
+/* 
+ * Optimizer is disabled only when threaded apps are detected while
+ * the library ain't compiled for thread safety.
+ */
+static int xmlXPathDisableOptimizer = 0;
+#endif
+
+/************************************************************************
+ *									*
+ *			Error handling routines				*
+ *									*
+ ************************************************************************/
+
+/*
+ * The array xmlXPathErrorMessages corresponds to the enum xmlXPathError
+ */
+static const char *xmlXPathErrorMessages[] = {
+    "Ok\n",
+    "Number encoding\n",
+    "Unfinished literal\n",
+    "Start of literal\n",
+    "Expected $ for variable reference\n",
+    "Undefined variable\n",
+    "Invalid predicate\n",
+    "Invalid expression\n",
+    "Missing closing curly brace\n",
+    "Unregistered function\n",
+    "Invalid operand\n",
+    "Invalid type\n",
+    "Invalid number of arguments\n",
+    "Invalid context size\n",
+    "Invalid context position\n",
+    "Memory allocation error\n",
+    "Syntax error\n",
+    "Resource error\n",
+    "Sub resource error\n",
+    "Undefined namespace prefix\n",
+    "Encoding error\n",
+    "Char out of XML range\n"
+};
+
+
+/**
+ * xmlXPathErrMemory:
+ * @ctxt:  an XPath context
+ * @extra:  extra informations
+ *
+ * Handle a redefinition of attribute error
+ */
+static void
+xmlXPathErrMemory(xmlXPathContextPtr ctxt, const char *extra)
+{
+    if (ctxt != NULL) {
+        if (extra) {
+            xmlChar buf[200];
+
+            xmlStrPrintf(buf, 200,
+                         BAD_CAST "Memory allocation failed : %s\n",
+                         extra);
+            ctxt->lastError.message = (char *) xmlStrdup(buf);
+        } else {
+            ctxt->lastError.message = (char *)
+	       xmlStrdup(BAD_CAST "Memory allocation failed\n");
+        }
+        ctxt->lastError.domain = XML_FROM_XPATH;
+        ctxt->lastError.code = XML_ERR_NO_MEMORY;
+	if (ctxt->error != NULL)
+	    ctxt->error(ctxt->userData, &ctxt->lastError);
+    } else {
+        if (extra)
+            __xmlRaiseError(NULL, NULL, NULL,
+                            NULL, NULL, XML_FROM_XPATH,
+                            XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0,
+                            extra, NULL, NULL, 0, 0,
+                            "Memory allocation failed : %s\n", extra);
+        else
+            __xmlRaiseError(NULL, NULL, NULL,
+                            NULL, NULL, XML_FROM_XPATH,
+                            XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0,
+                            NULL, NULL, NULL, 0, 0,
+                            "Memory allocation failed\n");
+    }
+}
+
+/**
+ * xmlXPathErrMemory:
+ * @ctxt:  an XPath parser context
+ * @extra:  extra informations
+ *
+ * Handle a redefinition of attribute error
+ */
+static void
+xmlXPathPErrMemory(xmlXPathParserContextPtr ctxt, const char *extra)
+{
+    ctxt->error = XPATH_MEMORY_ERROR;
+    if (ctxt == NULL)
+	xmlXPathErrMemory(NULL, extra);
+    else
+	xmlXPathErrMemory(ctxt->context, extra);
+}
+
+/**
+ * xmlXPathErr:
+ * @ctxt:  a XPath parser context
+ * @error:  the error code
+ *
+ * Handle a Relax NG Parsing error
+ */
+void
+xmlXPathErr(xmlXPathParserContextPtr ctxt, int error)
+{
+    if (ctxt == NULL) {
+	__xmlRaiseError(NULL, NULL, NULL,
+			NULL, NULL, XML_FROM_XPATH,
+			error + XML_XPATH_EXPRESSION_OK - XPATH_EXPRESSION_OK,
+			XML_ERR_ERROR, NULL, 0,
+			NULL, NULL, NULL, 0, 0,
+			xmlXPathErrorMessages[error]);
+	return;
+    }
+    ctxt->error = error;
+    if (ctxt->context == NULL) {
+	__xmlRaiseError(NULL, NULL, NULL,
+			NULL, NULL, XML_FROM_XPATH,
+			error + XML_XPATH_EXPRESSION_OK - XPATH_EXPRESSION_OK,
+			XML_ERR_ERROR, NULL, 0,
+			(const char *) ctxt->base, NULL, NULL,
+			ctxt->cur - ctxt->base, 0,
+			xmlXPathErrorMessages[error]);
+	return;
+    }
+    ctxt->context->lastError.domain = XML_FROM_XPATH;
+    ctxt->context->lastError.code = error + XML_XPATH_EXPRESSION_OK -
+                           XPATH_EXPRESSION_OK;
+    ctxt->context->lastError.level = XML_ERR_ERROR;
+    ctxt->context->lastError.str1 = (char *) xmlStrdup(ctxt->base);
+    ctxt->context->lastError.int1 = ctxt->cur - ctxt->base;
+    ctxt->context->lastError.node = ctxt->context->debugNode;
+    if (ctxt->context->error != NULL) {
+	ctxt->context->error(ctxt->context->userData,
+	                     &ctxt->context->lastError);
+    } else {
+	__xmlRaiseError(NULL, NULL, NULL,
+			NULL, ctxt->context->debugNode, XML_FROM_XPATH,
+			error + XML_XPATH_EXPRESSION_OK - XPATH_EXPRESSION_OK,
+			XML_ERR_ERROR, NULL, 0,
+			(const char *) ctxt->base, NULL, NULL,
+			ctxt->cur - ctxt->base, 0,
+			xmlXPathErrorMessages[error]);
+    }
+
+}
+
+/**
+ * xmlXPatherror:
+ * @ctxt:  the XPath Parser context
+ * @file:  the file name
+ * @line:  the line number
+ * @no:  the error number
+ *
+ * Formats an error message.
+ */
+void
+xmlXPatherror(xmlXPathParserContextPtr ctxt, const char *file ATTRIBUTE_UNUSED,
+              int line ATTRIBUTE_UNUSED, int no) {
+    xmlXPathErr(ctxt, no);
+}
+
+
+/************************************************************************
+ * 									*
+ * 			Parser Types					*
+ * 									*
+ ************************************************************************/
+
+/*
+ * Types are private:
+ */
+
+typedef enum {
+    XPATH_OP_END=0,
+    XPATH_OP_AND,
+    XPATH_OP_OR,
+    XPATH_OP_EQUAL,
+    XPATH_OP_CMP,
+    XPATH_OP_PLUS,
+    XPATH_OP_MULT,
+    XPATH_OP_UNION,
+    XPATH_OP_ROOT,
+    XPATH_OP_NODE,
+    XPATH_OP_RESET,
+    XPATH_OP_COLLECT,
+    XPATH_OP_VALUE,
+    XPATH_OP_VARIABLE,
+    XPATH_OP_FUNCTION,
+    XPATH_OP_ARG,
+    XPATH_OP_PREDICATE,
+    XPATH_OP_FILTER,
+    XPATH_OP_SORT
+#ifdef LIBXML_XPTR_ENABLED
+    ,XPATH_OP_RANGETO
+#endif
+} xmlXPathOp;
+
+typedef enum {
+    AXIS_ANCESTOR = 1,
+    AXIS_ANCESTOR_OR_SELF,
+    AXIS_ATTRIBUTE,
+    AXIS_CHILD,
+    AXIS_DESCENDANT,
+    AXIS_DESCENDANT_OR_SELF,
+    AXIS_FOLLOWING,
+    AXIS_FOLLOWING_SIBLING,
+    AXIS_NAMESPACE,
+    AXIS_PARENT,
+    AXIS_PRECEDING,
+    AXIS_PRECEDING_SIBLING,
+    AXIS_SELF
+} xmlXPathAxisVal;
+
+typedef enum {
+    NODE_TEST_NONE = 0,
+    NODE_TEST_TYPE = 1,
+    NODE_TEST_PI = 2,
+    NODE_TEST_ALL = 3,
+    NODE_TEST_NS = 4,
+    NODE_TEST_NAME = 5
+} xmlXPathTestVal;
+
+typedef enum {
+    NODE_TYPE_NODE = 0,
+    NODE_TYPE_COMMENT = XML_COMMENT_NODE,
+    NODE_TYPE_TEXT = XML_TEXT_NODE,
+    NODE_TYPE_PI = XML_PI_NODE
+} xmlXPathTypeVal;
+
+
+typedef struct _xmlXPathStepOp xmlXPathStepOp;
+typedef xmlXPathStepOp *xmlXPathStepOpPtr;
+struct _xmlXPathStepOp {
+    xmlXPathOp op;		/* The identifier of the operation */
+    int ch1;			/* First child */
+    int ch2;			/* Second child */
+    int value;
+    int value2;
+    int value3;
+    void *value4;
+    void *value5;
+    void *cache;
+    void *cacheURI;
+};
+
+struct _xmlXPathCompExpr {
+    int nbStep;			/* Number of steps in this expression */
+    int maxStep;		/* Maximum number of steps allocated */
+    xmlXPathStepOp *steps;	/* ops for computation of this expression */
+    int last;			/* index of last step in expression */
+    xmlChar *expr;		/* the expression being computed */
+    xmlDictPtr dict;		/* the dictionnary to use if any */
+#ifdef DEBUG_EVAL_COUNTS
+    int nb;
+    xmlChar *string;
+#endif
+};
+
+/************************************************************************
+ * 									*
+ * 			Parser Type functions 				*
+ * 									*
+ ************************************************************************/
+
+/**
+ * xmlXPathNewCompExpr:
+ *
+ * Create a new Xpath component
+ *
+ * Returns the newly allocated xmlXPathCompExprPtr or NULL in case of error
+ */
+static xmlXPathCompExprPtr
+xmlXPathNewCompExpr(void) {
+    xmlXPathCompExprPtr cur;
+
+    cur = (xmlXPathCompExprPtr) xmlMalloc(sizeof(xmlXPathCompExpr));
+    if (cur == NULL) {
+        xmlXPathErrMemory(NULL, "allocating component\n");
+	return(NULL);
+    }
+    memset(cur, 0, sizeof(xmlXPathCompExpr));
+    cur->maxStep = 10;
+    cur->nbStep = 0;
+    cur->steps = (xmlXPathStepOp *) xmlMalloc(cur->maxStep *
+	                                   sizeof(xmlXPathStepOp));
+    if (cur->steps == NULL) {
+        xmlXPathErrMemory(NULL, "allocating steps\n");
+	xmlFree(cur);
+	return(NULL);
+    }
+    memset(cur->steps, 0, cur->maxStep * sizeof(xmlXPathStepOp));
+    cur->last = -1;
+#ifdef DEBUG_EVAL_COUNTS
+    cur->nb = 0;
+#endif
+    return(cur);
+}
+
+/**
+ * xmlXPathFreeCompExpr:
+ * @comp:  an XPATH comp
+ *
+ * Free up the memory allocated by @comp
+ */
+void
+xmlXPathFreeCompExpr(xmlXPathCompExprPtr comp)
+{
+    xmlXPathStepOpPtr op;
+    int i;
+
+    if (comp == NULL)
+        return;
+    if (comp->dict == NULL) {
+	for (i = 0; i < comp->nbStep; i++) {
+	    op = &comp->steps[i];
+	    if (op->value4 != NULL) {
+		if (op->op == XPATH_OP_VALUE)
+		    xmlXPathFreeObject(op->value4);
+		else
+		    xmlFree(op->value4);
+	    }
+	    if (op->value5 != NULL)
+		xmlFree(op->value5);
+	}
+    } else {
+	for (i = 0; i < comp->nbStep; i++) {
+	    op = &comp->steps[i];
+	    if (op->value4 != NULL) {
+		if (op->op == XPATH_OP_VALUE)
+		    xmlXPathFreeObject(op->value4);
+	    }
+	}
+        xmlDictFree(comp->dict);
+    }
+    if (comp->steps != NULL) {
+        xmlFree(comp->steps);
+    }
+#ifdef DEBUG_EVAL_COUNTS
+    if (comp->string != NULL) {
+        xmlFree(comp->string);
+    }
+#endif
+    if (comp->expr != NULL) {
+        xmlFree(comp->expr);
+    }
+
+    xmlFree(comp);
+}
+
+/**
+ * xmlXPathCompExprAdd:
+ * @comp:  the compiled expression
+ * @ch1: first child index
+ * @ch2: second child index
+ * @op:  an op
+ * @value:  the first int value
+ * @value2:  the second int value
+ * @value3:  the third int value
+ * @value4:  the first string value
+ * @value5:  the second string value
+ *
+ * Add a step to an XPath Compiled Expression
+ *
+ * Returns -1 in case of failure, the index otherwise
+ */
+static int
+xmlXPathCompExprAdd(xmlXPathCompExprPtr comp, int ch1, int ch2,
+   xmlXPathOp op, int value,
+   int value2, int value3, void *value4, void *value5) {
+    if (comp->nbStep >= comp->maxStep) {
+	xmlXPathStepOp *real;
+
+	comp->maxStep *= 2;
+	real = (xmlXPathStepOp *) xmlRealloc(comp->steps,
+		                      comp->maxStep * sizeof(xmlXPathStepOp));
+	if (real == NULL) {
+	    comp->maxStep /= 2;
+	    xmlXPathErrMemory(NULL, "adding step\n");
+	    return(-1);
+	}
+	comp->steps = real;
+    }
+    comp->last = comp->nbStep;
+    comp->steps[comp->nbStep].ch1 = ch1;
+    comp->steps[comp->nbStep].ch2 = ch2;
+    comp->steps[comp->nbStep].op = op;
+    comp->steps[comp->nbStep].value = value;
+    comp->steps[comp->nbStep].value2 = value2;
+    comp->steps[comp->nbStep].value3 = value3;
+    if ((comp->dict != NULL) &&
+        ((op == XPATH_OP_FUNCTION) || (op == XPATH_OP_VARIABLE) ||
+	 (op == XPATH_OP_COLLECT))) {
+        if (value4 != NULL) {
+	    comp->steps[comp->nbStep].value4 = (xmlChar *)
+	        (void *)xmlDictLookup(comp->dict, value4, -1);
+	    xmlFree(value4);
+	} else
+	    comp->steps[comp->nbStep].value4 = NULL;
+        if (value5 != NULL) {
+	    comp->steps[comp->nbStep].value5 = (xmlChar *)
+	        (void *)xmlDictLookup(comp->dict, value5, -1);
+	    xmlFree(value5);
+	} else
+	    comp->steps[comp->nbStep].value5 = NULL;
+    } else {
+	comp->steps[comp->nbStep].value4 = value4;
+	comp->steps[comp->nbStep].value5 = value5;
+    }
+    comp->steps[comp->nbStep].cache = NULL;
+    return(comp->nbStep++);
+}
+
+/**
+ * xmlXPathCompSwap:
+ * @comp:  the compiled expression
+ * @op: operation index
+ *
+ * Swaps 2 operations in the compiled expression
+ */
+static void
+xmlXPathCompSwap(xmlXPathStepOpPtr op) {
+    int tmp;
+
+#ifndef LIBXML_THREAD_ENABLED
+    /*
+     * Since this manipulates possibly shared variables, this is
+     * disabled if one detects that the library is used in a multithreaded
+     * application
+     */
+    if (xmlXPathDisableOptimizer)
+	return;
+#endif
+
+    tmp = op->ch1;
+    op->ch1 = op->ch2;
+    op->ch2 = tmp;
+}
+
+#define PUSH_FULL_EXPR(op, op1, op2, val, val2, val3, val4, val5)	\
+    xmlXPathCompExprAdd(ctxt->comp, (op1), (op2),			\
+	                (op), (val), (val2), (val3), (val4), (val5))
+#define PUSH_LONG_EXPR(op, val, val2, val3, val4, val5)			\
+    xmlXPathCompExprAdd(ctxt->comp, ctxt->comp->last, -1,		\
+	                (op), (val), (val2), (val3), (val4), (val5))
+
+#define PUSH_LEAVE_EXPR(op, val, val2) 					\
+xmlXPathCompExprAdd(ctxt->comp, -1, -1, (op), (val), (val2), 0 ,NULL ,NULL)
+
+#define PUSH_UNARY_EXPR(op, ch, val, val2) 				\
+xmlXPathCompExprAdd(ctxt->comp, (ch), -1, (op), (val), (val2), 0 ,NULL ,NULL)
+
+#define PUSH_BINARY_EXPR(op, ch1, ch2, val, val2) 			\
+xmlXPathCompExprAdd(ctxt->comp, (ch1), (ch2), (op),			\
+			(val), (val2), 0 ,NULL ,NULL)
+
+/************************************************************************
+ *									*
+ * 		Debugging related functions				*
+ *									*
+ ************************************************************************/
+
+#define STRANGE 							\
+    xmlGenericError(xmlGenericErrorContext,				\
+	    "Internal error at %s:%d\n",				\
+            __FILE__, __LINE__);
+
+#ifdef LIBXML_DEBUG_ENABLED
+static void
+xmlXPathDebugDumpNode(FILE *output, xmlNodePtr cur, int depth) {
+    int i;
+    char shift[100];
+
+    for (i = 0;((i < depth) && (i < 25));i++)
+        shift[2 * i] = shift[2 * i + 1] = ' ';
+    shift[2 * i] = shift[2 * i + 1] = 0;
+    if (cur == NULL) {
+	fprintf(output, shift);
+	fprintf(output, "Node is NULL !\n");
+	return;
+        
+    }
+
+    if ((cur->type == XML_DOCUMENT_NODE) ||
+	     (cur->type == XML_HTML_DOCUMENT_NODE)) {
+	fprintf(output, shift);
+	fprintf(output, " /\n");
+    } else if (cur->type == XML_ATTRIBUTE_NODE)
+	xmlDebugDumpAttr(output, (xmlAttrPtr)cur, depth);
+    else
+	xmlDebugDumpOneNode(output, cur, depth);
+}
+static void
+xmlXPathDebugDumpNodeList(FILE *output, xmlNodePtr cur, int depth) {
+    xmlNodePtr tmp;
+    int i;
+    char shift[100];
+
+    for (i = 0;((i < depth) && (i < 25));i++)
+        shift[2 * i] = shift[2 * i + 1] = ' ';
+    shift[2 * i] = shift[2 * i + 1] = 0;
+    if (cur == NULL) {
+	fprintf(output, shift);
+	fprintf(output, "Node is NULL !\n");
+	return;
+        
+    }
+
+    while (cur != NULL) {
+	tmp = cur;
+	cur = cur->next;
+	xmlDebugDumpOneNode(output, tmp, depth);
+    }
+}
+
+static void
+xmlXPathDebugDumpNodeSet(FILE *output, xmlNodeSetPtr cur, int depth) {
+    int i;
+    char shift[100];
+
+    for (i = 0;((i < depth) && (i < 25));i++)
+        shift[2 * i] = shift[2 * i + 1] = ' ';
+    shift[2 * i] = shift[2 * i + 1] = 0;
+
+    if (cur == NULL) {
+	fprintf(output, shift);
+	fprintf(output, "NodeSet is NULL !\n");
+	return;
+        
+    }
+
+    if (cur != NULL) {
+	fprintf(output, "Set contains %d nodes:\n", cur->nodeNr);
+	for (i = 0;i < cur->nodeNr;i++) {
+	    fprintf(output, shift);
+	    fprintf(output, "%d", i + 1);
+	    xmlXPathDebugDumpNode(output, cur->nodeTab[i], depth + 1);
+	}
+    }
+}
+
+static void
+xmlXPathDebugDumpValueTree(FILE *output, xmlNodeSetPtr cur, int depth) {
+    int i;
+    char shift[100];
+
+    for (i = 0;((i < depth) && (i < 25));i++)
+        shift[2 * i] = shift[2 * i + 1] = ' ';
+    shift[2 * i] = shift[2 * i + 1] = 0;
+
+    if ((cur == NULL) || (cur->nodeNr == 0) || (cur->nodeTab[0] == NULL)) {
+	fprintf(output, shift);
+	fprintf(output, "Value Tree is NULL !\n");
+	return;
+        
+    }
+
+    fprintf(output, shift);
+    fprintf(output, "%d", i + 1);
+    xmlXPathDebugDumpNodeList(output, cur->nodeTab[0]->children, depth + 1);
+}
+#if defined(LIBXML_XPTR_ENABLED)
+static void
+xmlXPathDebugDumpLocationSet(FILE *output, xmlLocationSetPtr cur, int depth) {
+    int i;
+    char shift[100];
+
+    for (i = 0;((i < depth) && (i < 25));i++)
+        shift[2 * i] = shift[2 * i + 1] = ' ';
+    shift[2 * i] = shift[2 * i + 1] = 0;
+
+    if (cur == NULL) {
+	fprintf(output, shift);
+	fprintf(output, "LocationSet is NULL !\n");
+	return;
+        
+    }
+
+    for (i = 0;i < cur->locNr;i++) {
+	fprintf(output, shift);
+        fprintf(output, "%d : ", i + 1);
+	xmlXPathDebugDumpObject(output, cur->locTab[i], depth + 1);
+    }
+}
+#endif /* LIBXML_XPTR_ENABLED */
+
+/**
+ * xmlXPathDebugDumpObject:
+ * @output:  the FILE * to dump the output
+ * @cur:  the object to inspect
+ * @depth:  indentation level
+ *
+ * Dump the content of the object for debugging purposes
+ */
+void
+xmlXPathDebugDumpObject(FILE *output, xmlXPathObjectPtr cur, int depth) {
+    int i;
+    char shift[100];
+
+    for (i = 0;((i < depth) && (i < 25));i++)
+        shift[2 * i] = shift[2 * i + 1] = ' ';
+    shift[2 * i] = shift[2 * i + 1] = 0;
+
+    fprintf(output, shift);
+
+    if (cur == NULL) {
+        fprintf(output, "Object is empty (NULL)\n");
+	return;
+    }
+    switch(cur->type) {
+        case XPATH_UNDEFINED:
+	    fprintf(output, "Object is uninitialized\n");
+	    break;
+        case XPATH_NODESET:
+	    fprintf(output, "Object is a Node Set :\n");
+	    xmlXPathDebugDumpNodeSet(output, cur->nodesetval, depth);
+	    break;
+	case XPATH_XSLT_TREE:
+	    fprintf(output, "Object is an XSLT value tree :\n");
+	    xmlXPathDebugDumpValueTree(output, cur->nodesetval, depth);
+	    break;
+        case XPATH_BOOLEAN:
+	    fprintf(output, "Object is a Boolean : ");
+	    if (cur->boolval) fprintf(output, "true\n");
+	    else fprintf(output, "false\n");
+	    break;
+        case XPATH_NUMBER:
+	    switch (xmlXPathIsInf(cur->floatval)) {
+	    case 1:
+		fprintf(output, "Object is a number : Infinity\n");
+		break;
+	    case -1:
+		fprintf(output, "Object is a number : -Infinity\n");
+		break;
+	    default:
+		if (xmlXPathIsNaN(cur->floatval)) {
+		    fprintf(output, "Object is a number : NaN\n");
+		} else if (cur->floatval == 0 && xmlXPathGetSign(cur->floatval) != 0) {
+		    fprintf(output, "Object is a number : 0\n");
+		} else {
+		    fprintf(output, "Object is a number : %0g\n", cur->floatval);
+		}
+	    }
+	    break;
+        case XPATH_STRING:
+	    fprintf(output, "Object is a string : ");
+	    xmlDebugDumpString(output, cur->stringval);
+	    fprintf(output, "\n");
+	    break;
+	case XPATH_POINT:
+	    fprintf(output, "Object is a point : index %d in node", cur->index);
+	    xmlXPathDebugDumpNode(output, (xmlNodePtr) cur->user, depth + 1);
+	    fprintf(output, "\n");
+	    break;
+	case XPATH_RANGE:
+	    if ((cur->user2 == NULL) ||
+		((cur->user2 == cur->user) && (cur->index == cur->index2))) {
+		fprintf(output, "Object is a collapsed range :\n");
+		fprintf(output, shift);
+		if (cur->index >= 0)
+		    fprintf(output, "index %d in ", cur->index);
+		fprintf(output, "node\n");
+		xmlXPathDebugDumpNode(output, (xmlNodePtr) cur->user,
+			              depth + 1);
+	    } else  {
+		fprintf(output, "Object is a range :\n");
+		fprintf(output, shift);
+		fprintf(output, "From ");
+		if (cur->index >= 0)
+		    fprintf(output, "index %d in ", cur->index);
+		fprintf(output, "node\n");
+		xmlXPathDebugDumpNode(output, (xmlNodePtr) cur->user,
+			              depth + 1);
+		fprintf(output, shift);
+		fprintf(output, "To ");
+		if (cur->index2 >= 0)
+		    fprintf(output, "index %d in ", cur->index2);
+		fprintf(output, "node\n");
+		xmlXPathDebugDumpNode(output, (xmlNodePtr) cur->user2,
+			              depth + 1);
+		fprintf(output, "\n");
+	    }
+	    break;
+	case XPATH_LOCATIONSET:
+#if defined(LIBXML_XPTR_ENABLED)
+	    fprintf(output, "Object is a Location Set:\n");
+	    xmlXPathDebugDumpLocationSet(output,
+		    (xmlLocationSetPtr) cur->user, depth);
+#endif
+	    break;
+	case XPATH_USERS:
+	    fprintf(output, "Object is user defined\n");
+	    break;
+    }
+}
+
+static void
+xmlXPathDebugDumpStepOp(FILE *output, xmlXPathCompExprPtr comp,
+	                     xmlXPathStepOpPtr op, int depth) {
+    int i;
+    char shift[100];
+
+    for (i = 0;((i < depth) && (i < 25));i++)
+        shift[2 * i] = shift[2 * i + 1] = ' ';
+    shift[2 * i] = shift[2 * i + 1] = 0;
+
+    fprintf(output, shift);
+    if (op == NULL) {
+	fprintf(output, "Step is NULL\n");
+	return;
+    }
+    switch (op->op) {
+        case XPATH_OP_END:
+	    fprintf(output, "END"); break;
+        case XPATH_OP_AND:
+	    fprintf(output, "AND"); break;
+        case XPATH_OP_OR:
+	    fprintf(output, "OR"); break;
+        case XPATH_OP_EQUAL:
+	     if (op->value)
+		 fprintf(output, "EQUAL =");
+	     else
+		 fprintf(output, "EQUAL !=");
+	     break;
+        case XPATH_OP_CMP:
+	     if (op->value)
+		 fprintf(output, "CMP <");
+	     else
+		 fprintf(output, "CMP >");
+	     if (!op->value2)
+		 fprintf(output, "=");
+	     break;
+        case XPATH_OP_PLUS:
+	     if (op->value == 0)
+		 fprintf(output, "PLUS -");
+	     else if (op->value == 1)
+		 fprintf(output, "PLUS +");
+	     else if (op->value == 2)
+		 fprintf(output, "PLUS unary -");
+	     else if (op->value == 3)
+		 fprintf(output, "PLUS unary - -");
+	     break;
+        case XPATH_OP_MULT:
+	     if (op->value == 0)
+		 fprintf(output, "MULT *");
+	     else if (op->value == 1)
+		 fprintf(output, "MULT div");
+	     else
+		 fprintf(output, "MULT mod");
+	     break;
+        case XPATH_OP_UNION:
+	     fprintf(output, "UNION"); break;
+        case XPATH_OP_ROOT:
+	     fprintf(output, "ROOT"); break;
+        case XPATH_OP_NODE:
+	     fprintf(output, "NODE"); break;
+        case XPATH_OP_RESET:
+	     fprintf(output, "RESET"); break;
+        case XPATH_OP_SORT:
+	     fprintf(output, "SORT"); break;
+        case XPATH_OP_COLLECT: {
+	    xmlXPathAxisVal axis = (xmlXPathAxisVal)op->value;
+	    xmlXPathTestVal test = (xmlXPathTestVal)op->value2;
+	    xmlXPathTypeVal type = (xmlXPathTypeVal)op->value3;
+	    const xmlChar *prefix = op->value4;
+	    const xmlChar *name = op->value5;
+
+	    fprintf(output, "COLLECT ");
+	    switch (axis) {
+		case AXIS_ANCESTOR:
+		    fprintf(output, " 'ancestors' "); break;
+		case AXIS_ANCESTOR_OR_SELF:
+		    fprintf(output, " 'ancestors-or-self' "); break;
+		case AXIS_ATTRIBUTE:
+		    fprintf(output, " 'attributes' "); break;
+		case AXIS_CHILD:
+		    fprintf(output, " 'child' "); break;
+		case AXIS_DESCENDANT:
+		    fprintf(output, " 'descendant' "); break;
+		case AXIS_DESCENDANT_OR_SELF:
+		    fprintf(output, " 'descendant-or-self' "); break;
+		case AXIS_FOLLOWING:
+		    fprintf(output, " 'following' "); break;
+		case AXIS_FOLLOWING_SIBLING:
+		    fprintf(output, " 'following-siblings' "); break;
+		case AXIS_NAMESPACE:
+		    fprintf(output, " 'namespace' "); break;
+		case AXIS_PARENT:
+		    fprintf(output, " 'parent' "); break;
+		case AXIS_PRECEDING:
+		    fprintf(output, " 'preceding' "); break;
+		case AXIS_PRECEDING_SIBLING:
+		    fprintf(output, " 'preceding-sibling' "); break;
+		case AXIS_SELF:
+		    fprintf(output, " 'self' "); break;
+	    }
+	    switch (test) {
+                case NODE_TEST_NONE:
+		    fprintf(output, "'none' "); break;
+                case NODE_TEST_TYPE:
+		    fprintf(output, "'type' "); break;
+                case NODE_TEST_PI:
+		    fprintf(output, "'PI' "); break;
+                case NODE_TEST_ALL:
+		    fprintf(output, "'all' "); break;
+                case NODE_TEST_NS:
+		    fprintf(output, "'namespace' "); break;
+                case NODE_TEST_NAME:
+		    fprintf(output, "'name' "); break;
+	    }
+	    switch (type) {
+                case NODE_TYPE_NODE:
+		    fprintf(output, "'node' "); break;
+                case NODE_TYPE_COMMENT:
+		    fprintf(output, "'comment' "); break;
+                case NODE_TYPE_TEXT:
+		    fprintf(output, "'text' "); break;
+                case NODE_TYPE_PI:
+		    fprintf(output, "'PI' "); break;
+	    }
+	    if (prefix != NULL)
+		fprintf(output, "%s:", prefix);
+	    if (name != NULL)
+		fprintf(output, "%s", (const char *) name);
+	    break;
+
+        }
+	case XPATH_OP_VALUE: {
+	    xmlXPathObjectPtr object = (xmlXPathObjectPtr) op->value4;
+
+	    fprintf(output, "ELEM ");
+	    xmlXPathDebugDumpObject(output, object, 0);
+	    goto finish;
+	}
+	case XPATH_OP_VARIABLE: {
+	    const xmlChar *prefix = op->value5;
+	    const xmlChar *name = op->value4;
+
+	    if (prefix != NULL)
+		fprintf(output, "VARIABLE %s:%s", prefix, name);
+	    else
+		fprintf(output, "VARIABLE %s", name);
+	    break;
+	}
+	case XPATH_OP_FUNCTION: {
+	    int nbargs = op->value;
+	    const xmlChar *prefix = op->value5;
+	    const xmlChar *name = op->value4;
+
+	    if (prefix != NULL)
+		fprintf(output, "FUNCTION %s:%s(%d args)",
+			prefix, name, nbargs);
+	    else
+		fprintf(output, "FUNCTION %s(%d args)", name, nbargs);
+	    break;
+	}
+        case XPATH_OP_ARG: fprintf(output, "ARG"); break;
+        case XPATH_OP_PREDICATE: fprintf(output, "PREDICATE"); break;
+        case XPATH_OP_FILTER: fprintf(output, "FILTER"); break;
+#ifdef LIBXML_XPTR_ENABLED
+        case XPATH_OP_RANGETO: fprintf(output, "RANGETO"); break;
+#endif
+	default:
+        fprintf(output, "UNKNOWN %d\n", op->op); return;
+    }
+    fprintf(output, "\n");
+finish:
+    if (op->ch1 >= 0)
+	xmlXPathDebugDumpStepOp(output, comp, &comp->steps[op->ch1], depth + 1);
+    if (op->ch2 >= 0)
+	xmlXPathDebugDumpStepOp(output, comp, &comp->steps[op->ch2], depth + 1);
+}
+
+/**
+ * xmlXPathDebugDumpCompExpr:
+ * @output:  the FILE * for the output
+ * @comp:  the precompiled XPath expression
+ * @depth:  the indentation level.
+ *
+ * Dumps the tree of the compiled XPath expression.
+ */
+void
+xmlXPathDebugDumpCompExpr(FILE *output, xmlXPathCompExprPtr comp,
+	                  int depth) {
+    int i;
+    char shift[100];
+
+    for (i = 0;((i < depth) && (i < 25));i++)
+        shift[2 * i] = shift[2 * i + 1] = ' ';
+    shift[2 * i] = shift[2 * i + 1] = 0;
+
+    fprintf(output, shift);
+
+    if (comp == NULL) {
+	fprintf(output, "Compiled Expression is NULL\n");
+	return;
+    }
+    fprintf(output, "Compiled Expression : %d elements\n",
+	    comp->nbStep);
+    i = comp->last;
+    xmlXPathDebugDumpStepOp(output, comp, &comp->steps[i], depth + 1);
+}
+#endif /* LIBXML_DEBUG_ENABLED */
+
+/************************************************************************
+ *									*
+ * 		Parser stacks related functions and macros		*
+ *									*
+ ************************************************************************/
+
+/**
+ * valuePop:
+ * @ctxt: an XPath evaluation context
+ *
+ * Pops the top XPath object from the value stack
+ *
+ * Returns the XPath object just removed
+ */
+extern xmlXPathObjectPtr
+valuePop(xmlXPathParserContextPtr ctxt)
+{
+    xmlXPathObjectPtr ret;
+
+    if (ctxt->valueNr <= 0)
+        return (0);
+    ctxt->valueNr--;
+    if (ctxt->valueNr > 0)
+        ctxt->value = ctxt->valueTab[ctxt->valueNr - 1];
+    else
+        ctxt->value = NULL;
+    ret = ctxt->valueTab[ctxt->valueNr];
+    ctxt->valueTab[ctxt->valueNr] = 0;
+    return (ret);
+}
+/**
+ * valuePush:
+ * @ctxt:  an XPath evaluation context
+ * @value:  the XPath object
+ *
+ * Pushes a new XPath object on top of the value stack
+ *
+ * returns the number of items on the value stack
+ */
+extern int
+valuePush(xmlXPathParserContextPtr ctxt, xmlXPathObjectPtr value)
+{
+    if (ctxt->valueNr >= ctxt->valueMax) {
+        ctxt->valueMax *= 2;
+        ctxt->valueTab =
+            (xmlXPathObjectPtr *) xmlRealloc(ctxt->valueTab,
+                                             ctxt->valueMax *
+                                             sizeof(ctxt->valueTab[0]));
+        if (ctxt->valueTab == NULL) {
+            xmlGenericError(xmlGenericErrorContext, "realloc failed !\n");
+            return (0);
+        }
+    }
+    ctxt->valueTab[ctxt->valueNr] = value;
+    ctxt->value = value;
+    return (ctxt->valueNr++);
+}
+
+/**
+ * xmlXPathPopBoolean:
+ * @ctxt:  an XPath parser context
+ *
+ * Pops a boolean from the stack, handling conversion if needed.
+ * Check error with #xmlXPathCheckError.
+ *
+ * Returns the boolean
+ */
+int
+xmlXPathPopBoolean (xmlXPathParserContextPtr ctxt) {
+    xmlXPathObjectPtr obj;
+    int ret;
+
+    obj = valuePop(ctxt);
+    if (obj == NULL) {
+	xmlXPathSetError(ctxt, XPATH_INVALID_OPERAND);
+	return(0);
+    }
+    if (obj->type != XPATH_BOOLEAN)
+	ret = xmlXPathCastToBoolean(obj);
+    else
+        ret = obj->boolval;
+    xmlXPathFreeObject(obj);
+    return(ret);
+}
+
+/**
+ * xmlXPathPopNumber:
+ * @ctxt:  an XPath parser context
+ *
+ * Pops a number from the stack, handling conversion if needed.
+ * Check error with #xmlXPathCheckError.
+ *
+ * Returns the number
+ */
+double
+xmlXPathPopNumber (xmlXPathParserContextPtr ctxt) {
+    xmlXPathObjectPtr obj;
+    double ret;
+
+    obj = valuePop(ctxt);
+    if (obj == NULL) {
+	xmlXPathSetError(ctxt, XPATH_INVALID_OPERAND);
+	return(0);
+    }
+    if (obj->type != XPATH_NUMBER)
+	ret = xmlXPathCastToNumber(obj);
+    else
+        ret = obj->floatval;
+    xmlXPathFreeObject(obj);
+    return(ret);
+}
+
+/**
+ * xmlXPathPopString:
+ * @ctxt:  an XPath parser context
+ *
+ * Pops a string from the stack, handling conversion if needed.
+ * Check error with #xmlXPathCheckError.
+ *
+ * Returns the string
+ */
+xmlChar *
+xmlXPathPopString (xmlXPathParserContextPtr ctxt) {
+    xmlXPathObjectPtr obj;
+    xmlChar * ret;
+
+    obj = valuePop(ctxt);
+    if (obj == NULL) {
+	xmlXPathSetError(ctxt, XPATH_INVALID_OPERAND);
+	return(NULL);
+    }
+    ret = xmlXPathCastToString(obj);	/* this does required strdup */
+    /* TODO: needs refactoring somewhere else */
+    if (obj->stringval == ret)
+	obj->stringval = NULL;
+    xmlXPathFreeObject(obj);
+    return(ret);
+}
+
+/**
+ * xmlXPathPopNodeSet:
+ * @ctxt:  an XPath parser context
+ *
+ * Pops a node-set from the stack, handling conversion if needed.
+ * Check error with #xmlXPathCheckError.
+ *
+ * Returns the node-set
+ */
+xmlNodeSetPtr
+xmlXPathPopNodeSet (xmlXPathParserContextPtr ctxt) {
+    xmlXPathObjectPtr obj;
+    xmlNodeSetPtr ret;
+
+    if (ctxt->value == NULL) {
+	xmlXPathSetError(ctxt, XPATH_INVALID_OPERAND);
+	return(NULL);
+    }
+    if (!xmlXPathStackIsNodeSet(ctxt)) {
+	xmlXPathSetTypeError(ctxt);
+	return(NULL);
+    }
+    obj = valuePop(ctxt);
+    ret = obj->nodesetval;
+    /* to fix memory leak of not clearing obj->user */
+    if (obj->boolval && obj->user != NULL)
+        xmlFreeNodeList((xmlNodePtr) obj->user);
+    xmlXPathFreeNodeSetList(obj);
+    return(ret);
+}
+
+/**
+ * xmlXPathPopExternal:
+ * @ctxt:  an XPath parser context
+ *
+ * Pops an external object from the stack, handling conversion if needed.
+ * Check error with #xmlXPathCheckError.
+ *
+ * Returns the object
+ */
+void *
+xmlXPathPopExternal (xmlXPathParserContextPtr ctxt) {
+    xmlXPathObjectPtr obj;
+    void * ret;
+
+    if (ctxt->value == NULL) {
+	xmlXPathSetError(ctxt, XPATH_INVALID_OPERAND);
+	return(NULL);
+    }
+    if (ctxt->value->type != XPATH_USERS) {
+	xmlXPathSetTypeError(ctxt);
+	return(NULL);
+    }
+    obj = valuePop(ctxt);
+    ret = obj->user;
+    xmlXPathFreeObject(obj);
+    return(ret);
+}
+
+/*
+ * Macros for accessing the content. Those should be used only by the parser,
+ * and not exported.
+ *
+ * Dirty macros, i.e. one need to make assumption on the context to use them
+ *
+ *   CUR_PTR return the current pointer to the xmlChar to be parsed.
+ *   CUR     returns the current xmlChar value, i.e. a 8 bit value
+ *           in ISO-Latin or UTF-8.
+ *           This should be used internally by the parser
+ *           only to compare to ASCII values otherwise it would break when
+ *           running with UTF-8 encoding.
+ *   NXT(n)  returns the n'th next xmlChar. Same as CUR is should be used only
+ *           to compare on ASCII based substring.
+ *   SKIP(n) Skip n xmlChar, and must also be used only to skip ASCII defined
+ *           strings within the parser.
+ *   CURRENT Returns the current char value, with the full decoding of
+ *           UTF-8 if we are using this mode. It returns an int.
+ *   NEXT    Skip to the next character, this does the proper decoding
+ *           in UTF-8 mode. It also pop-up unfinished entities on the fly.
+ *           It returns the pointer to the current xmlChar.
+ */
+
+#define CUR (*ctxt->cur)
+#define SKIP(val) ctxt->cur += (val)
+#define NXT(val) ctxt->cur[(val)]
+#define CUR_PTR ctxt->cur
+#define CUR_CHAR(l) xmlXPathCurrentChar(ctxt, &l)
+
+#define COPY_BUF(l,b,i,v)                                              \
+    if (l == 1) b[i++] = (xmlChar) v;                                  \
+    else i += xmlCopyChar(l,&b[i],v)
+
+#define NEXTL(l)  ctxt->cur += l
+
+#define SKIP_BLANKS 							\
+    while (IS_BLANK_CH(*(ctxt->cur))) NEXT
+
+#define CURRENT (*ctxt->cur)
+#define NEXT ((*ctxt->cur) ?  ctxt->cur++: ctxt->cur)
+
+
+#ifndef DBL_DIG
+#define DBL_DIG 16
+#endif
+#ifndef DBL_EPSILON
+#define DBL_EPSILON 1E-9
+#endif
+
+#define UPPER_DOUBLE 1E9
+#define LOWER_DOUBLE 1E-5
+
+#define INTEGER_DIGITS DBL_DIG
+#define FRACTION_DIGITS (DBL_DIG + 1)
+#define EXPONENT_DIGITS (3 + 2)
+
+/**
+ * xmlXPathFormatNumber:
+ * @number:     number to format
+ * @buffer:     output buffer
+ * @buffersize: size of output buffer
+ *
+ * Convert the number into a string representation.
+ */
+static void
+xmlXPathFormatNumber(double number, char buffer[], int buffersize)
+{
+    switch (xmlXPathIsInf(number)) {
+    case 1:
+	if (buffersize > (int)sizeof("Infinity"))
+	    snprintf(buffer, buffersize, "Infinity");
+	break;
+    case -1:
+	if (buffersize > (int)sizeof("-Infinity"))
+	    snprintf(buffer, buffersize, "-Infinity");
+	break;
+    default:
+	if (xmlXPathIsNaN(number)) {
+	    if (buffersize > (int)sizeof("NaN"))
+		snprintf(buffer, buffersize, "NaN");
+	} else if (number == 0 && xmlXPathGetSign(number) != 0) {
+	    snprintf(buffer, buffersize, "0");
+	} else if (number == ((int) number)) {
+	    char work[30];
+	    char *ptr, *cur;
+	    int res, value = (int) number;
+
+            ptr = &buffer[0];
+	    if (value < 0) {
+		*ptr++ = '-';
+		value = -value;
+	    }
+	    if (value == 0) {
+		*ptr++ = '0';
+	    } else {
+		cur = &work[0];
+		while (value != 0) {
+		    res = value % 10;
+		    value = value / 10;
+		    *cur++ = '0' + res;
+		}
+		cur--;
+		while ((cur >= &work[0]) && (ptr - buffer < buffersize)) {
+		    *ptr++ = *cur--;
+		}
+	    }
+	    if (ptr - buffer < buffersize) {
+		*ptr = 0;
+	    } else if (buffersize > 0) {
+		ptr--;
+		*ptr = 0;
+	    }
+	} else {
+	    /* 3 is sign, decimal point, and terminating zero */
+	    char work[DBL_DIG + EXPONENT_DIGITS + 3];
+	    int integer_place, fraction_place;
+	    char *ptr;
+	    char *after_fraction;
+	    double absolute_value;
+	    int size;
+
+	    absolute_value = fabs(number);
+
+	    /*
+	     * First choose format - scientific or regular floating point.
+	     * In either case, result is in work, and after_fraction points
+	     * just past the fractional part.
+	    */
+	    if ( ((absolute_value > UPPER_DOUBLE) ||
+		  (absolute_value < LOWER_DOUBLE)) &&
+		 (absolute_value != 0.0) ) {
+		/* Use scientific notation */
+		integer_place = DBL_DIG + EXPONENT_DIGITS + 1;
+		fraction_place = DBL_DIG - 1;
+		snprintf(work, sizeof(work),"%*.*e",
+			 integer_place, fraction_place, number);
+		after_fraction = strchr(work + DBL_DIG, 'e');
+	    }
+	    else {
+		/* Use regular notation */
+		if (absolute_value > 0.0)
+		    integer_place = 1 + (int)log10(absolute_value);
+		else
+		    integer_place = 0;
+		fraction_place = (integer_place > 0)
+		    ? DBL_DIG - integer_place
+		    : DBL_DIG;
+		size = snprintf(work, sizeof(work), "%0.*f",
+				fraction_place, number);
+		after_fraction = work + size;
+	    }
+
+	    /* Remove fractional trailing zeroes */
+	    ptr = after_fraction;
+	    while (*(--ptr) == '0')
+		;
+	    if (*ptr != '.')
+	        ptr++;
+	    while ((*ptr++ = *after_fraction++) != 0);
+
+	    /* Finally copy result back to caller */
+	    size = strlen(work) + 1;
+	    if (size > buffersize) {
+		work[buffersize - 1] = 0;
+		size = buffersize;
+	    }
+	    memmove(buffer, work, size);
+	}
+	break;
+    }
+}
+
+
+/************************************************************************
+ *									*
+ *			Routines to handle NodeSets			*
+ *									*
+ ************************************************************************/
+
+/**
+ * xmlXPathOrderDocElems:
+ * @doc:  an input document
+ *
+ * Call this routine to speed up XPath computation on static documents.
+ * This stamps all the element nodes with the document order
+ * Like for line information, the order is kept in the element->content
+ * field, the value stored is actually - the node number (starting at -1)
+ * to be able to differentiate from line numbers.
+ *
+ * Returns the number of elements found in the document or -1 in case
+ *    of error.
+ */
+long
+xmlXPathOrderDocElems(xmlDocPtr doc) {
+    long count = 0;
+    xmlNodePtr cur;
+
+    if (doc == NULL)
+	return(-1);
+    cur = doc->children;
+    while (cur != NULL) {
+	if (cur->type == XML_ELEMENT_NODE) {
+	    cur->content = (void *) (-(++count));
+	    if (cur->children != NULL) {
+		cur = cur->children;
+		continue;
+	    }
+	}
+	if (cur->next != NULL) {
+	    cur = cur->next;
+	    continue;
+	}
+	do {
+	    cur = cur->parent;
+	    if (cur == NULL)
+		break;
+	    if (cur == (xmlNodePtr) doc) {
+		cur = NULL;
+		break;
+	    }
+	    if (cur->next != NULL) {
+		cur = cur->next;
+		break;
+	    }
+	} while (cur != NULL);
+    }
+    return(count);
+}
+
+/**
+ * xmlXPathCmpNodes:
+ * @node1:  the first node
+ * @node2:  the second node
+ *
+ * Compare two nodes w.r.t document order
+ *
+ * Returns -2 in case of error 1 if first point < second point, 0 if
+ *         it's the same node, -1 otherwise
+ */
+int
+xmlXPathCmpNodes(xmlNodePtr node1, xmlNodePtr node2) {
+    int depth1, depth2;
+    int attr1 = 0, attr2 = 0;
+    xmlNodePtr attrNode1 = NULL, attrNode2 = NULL;
+    xmlNodePtr cur, root;
+
+    if ((node1 == NULL) || (node2 == NULL))
+	return(-2);
+    /*
+     * a couple of optimizations which will avoid computations in most cases
+     */
+    if (node1->type == XML_ATTRIBUTE_NODE) {
+	attr1 = 1;
+	attrNode1 = node1;
+	node1 = node1->parent;
+    }
+    if (node2->type == XML_ATTRIBUTE_NODE) {
+	attr2 = 1;
+	attrNode2 = node2;
+	node2 = node2->parent;
+    }
+    if (node1 == node2) {
+	if (attr1 == attr2) {
+	    /* not required, but we keep attributes in order */
+	    if (attr1 != 0) {
+	        cur = attrNode2->prev;
+		while (cur != NULL) {
+		    if (cur == attrNode1)
+		        return (1);
+		    cur = cur->prev;
+		}
+		return (-1);
+	    }
+	    return(0);
+	}
+	if (attr2 == 1)
+	    return(1);
+	return(-1);
+    }
+    if ((node1->type == XML_NAMESPACE_DECL) ||
+        (node2->type == XML_NAMESPACE_DECL))
+	return(1);
+    if (node1 == node2->prev)
+	return(1);
+    if (node1 == node2->next)
+	return(-1);
+
+    /*
+     * Speedup using document order if availble.
+     */
+    if ((node1->type == XML_ELEMENT_NODE) &&
+	(node2->type == XML_ELEMENT_NODE) &&
+	(0 > (long) node1->content) &&
+	(0 > (long) node2->content) &&
+	(node1->doc == node2->doc)) {
+	long l1, l2;
+
+	l1 = -((long) node1->content);
+	l2 = -((long) node2->content);
+	if (l1 < l2)
+	    return(1);
+	if (l1 > l2)
+	    return(-1);
+    }
+
+    /*
+     * compute depth to root
+     */
+    for (depth2 = 0, cur = node2;cur->parent != NULL;cur = cur->parent) {
+	if (cur == node1)
+	    return(1);
+	depth2++;
+    }
+    root = cur;
+    for (depth1 = 0, cur = node1;cur->parent != NULL;cur = cur->parent) {
+	if (cur == node2)
+	    return(-1);
+	depth1++;
+    }
+    /*
+     * Distinct document (or distinct entities :-( ) case.
+     */
+    if (root != cur) {
+	return(-2);
+    }
+    /*
+     * get the nearest common ancestor.
+     */
+    while (depth1 > depth2) {
+	depth1--;
+	node1 = node1->parent;
+    }
+    while (depth2 > depth1) {
+	depth2--;
+	node2 = node2->parent;
+    }
+    while (node1->parent != node2->parent) {
+	node1 = node1->parent;
+	node2 = node2->parent;
+	/* should not happen but just in case ... */
+	if ((node1 == NULL) || (node2 == NULL))
+	    return(-2);
+    }
+    /*
+     * Find who's first.
+     */
+    if (node1 == node2->prev)
+	return(1);
+    if (node1 == node2->next)
+	return(-1);
+    /*
+     * Speedup using document order if availble.
+     */
+    if ((node1->type == XML_ELEMENT_NODE) &&
+	(node2->type == XML_ELEMENT_NODE) &&
+	(0 > (long) node1->content) &&
+	(0 > (long) node2->content) &&
+	(node1->doc == node2->doc)) {
+	long l1, l2;
+
+	l1 = -((long) node1->content);
+	l2 = -((long) node2->content);
+	if (l1 < l2)
+	    return(1);
+	if (l1 > l2)
+	    return(-1);
+    }
+
+    for (cur = node1->next;cur != NULL;cur = cur->next)
+	if (cur == node2)
+	    return(1);
+    return(-1); /* assume there is no sibling list corruption */
+}
+
+/**
+ * xmlXPathNodeSetSort:
+ * @set:  the node set
+ *
+ * Sort the node set in document order
+ */
+void
+xmlXPathNodeSetSort(xmlNodeSetPtr set) {
+    int i, j, incr, len;
+    xmlNodePtr tmp;
+
+    if (set == NULL)
+	return;
+
+    /* Use Shell's sort to sort the node-set */
+    len = set->nodeNr;
+    for (incr = len / 2; incr > 0; incr /= 2) {
+	for (i = incr; i < len; i++) {
+	    j = i - incr;
+	    while (j >= 0) {
+		if (xmlXPathCmpNodes(set->nodeTab[j],
+				     set->nodeTab[j + incr]) == -1) {
+		    tmp = set->nodeTab[j];
+		    set->nodeTab[j] = set->nodeTab[j + incr];
+		    set->nodeTab[j + incr] = tmp;
+		    j -= incr;
+		} else
+		    break;
+	    }
+	}
+    }
+}
+
+#define XML_NODESET_DEFAULT	10
+/**
+ * xmlXPathNodeSetDupNs:
+ * @node:  the parent node of the namespace XPath node
+ * @ns:  the libxml namespace declaration node.
+ *
+ * Namespace node in libxml don't match the XPath semantic. In a node set
+ * the namespace nodes are duplicated and the next pointer is set to the
+ * parent node in the XPath semantic.
+ *
+ * Returns the newly created object.
+ */
+static xmlNodePtr
+xmlXPathNodeSetDupNs(xmlNodePtr node, xmlNsPtr ns) {
+    xmlNsPtr cur;
+
+    if ((ns == NULL) || (ns->type != XML_NAMESPACE_DECL))
+	return(NULL);
+    if ((node == NULL) || (node->type == XML_NAMESPACE_DECL))
+	return((xmlNodePtr) ns);
+
+    /*
+     * Allocate a new Namespace and fill the fields.
+     */
+    cur = (xmlNsPtr) xmlMalloc(sizeof(xmlNs));
+    if (cur == NULL) {
+        xmlXPathErrMemory(NULL, "duplicating namespace\n");
+	return(NULL);
+    }
+    memset(cur, 0, sizeof(xmlNs));
+    cur->type = XML_NAMESPACE_DECL;
+    if (ns->href != NULL)
+	cur->href = xmlStrdup(ns->href); 
+    if (ns->prefix != NULL)
+	cur->prefix = xmlStrdup(ns->prefix); 
+    cur->next = (xmlNsPtr) node;
+    return((xmlNodePtr) cur);
+}
+
+/**
+ * xmlXPathNodeSetFreeNs:
+ * @ns:  the XPath namespace node found in a nodeset.
+ *
+ * Namespace nodes in libxml don't match the XPath semantic. In a node set
+ * the namespace nodes are duplicated and the next pointer is set to the
+ * parent node in the XPath semantic. Check if such a node needs to be freed
+ */
+void
+xmlXPathNodeSetFreeNs(xmlNsPtr ns) {
+    if ((ns == NULL) || (ns->type != XML_NAMESPACE_DECL))
+	return;
+
+    if ((ns->next != NULL) && (ns->next->type != XML_NAMESPACE_DECL)) {
+	if (ns->href != NULL)
+	    xmlFree((xmlChar *)ns->href);
+	if (ns->prefix != NULL)
+	    xmlFree((xmlChar *)ns->prefix);
+	xmlFree(ns);
+    }
+}
+
+/**
+ * xmlXPathNodeSetCreate:
+ * @val:  an initial xmlNodePtr, or NULL
+ *
+ * Create a new xmlNodeSetPtr of type double and of value @val
+ *
+ * Returns the newly created object.
+ */
+xmlNodeSetPtr
+xmlXPathNodeSetCreate(xmlNodePtr val) {
+    xmlNodeSetPtr ret;
+
+    ret = (xmlNodeSetPtr) xmlMalloc(sizeof(xmlNodeSet));
+    if (ret == NULL) {
+        xmlXPathErrMemory(NULL, "creating nodeset\n");
+	return(NULL);
+    }
+    memset(ret, 0 , (size_t) sizeof(xmlNodeSet));
+    if (val != NULL) {
+        ret->nodeTab = (xmlNodePtr *) xmlMalloc(XML_NODESET_DEFAULT *
+					     sizeof(xmlNodePtr));
+	if (ret->nodeTab == NULL) {
+	    xmlXPathErrMemory(NULL, "creating nodeset\n");
+	    xmlFree(ret);
+	    return(NULL);
+	}
+	memset(ret->nodeTab, 0 ,
+	       XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
+        ret->nodeMax = XML_NODESET_DEFAULT;
+	if (val->type == XML_NAMESPACE_DECL) {
+	    xmlNsPtr ns = (xmlNsPtr) val;
+
+	    ret->nodeTab[ret->nodeNr++] =
+		xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns);
+	} else
+	    ret->nodeTab[ret->nodeNr++] = val;
+    }
+    return(ret);
+}
+
+/**
+ * xmlXPathNodeSetContains:
+ * @cur:  the node-set
+ * @val:  the node
+ *
+ * checks whether @cur contains @val
+ *
+ * Returns true (1) if @cur contains @val, false (0) otherwise
+ */
+int
+xmlXPathNodeSetContains (xmlNodeSetPtr cur, xmlNodePtr val) {
+    int i;
+
+    if (val->type == XML_NAMESPACE_DECL) {
+	for (i = 0; i < cur->nodeNr; i++) {
+	    if (cur->nodeTab[i]->type == XML_NAMESPACE_DECL) {
+		xmlNsPtr ns1, ns2;
+
+		ns1 = (xmlNsPtr) val;
+		ns2 = (xmlNsPtr) cur->nodeTab[i];
+		if (ns1 == ns2)
+		    return(1);
+		if ((ns1->next != NULL) && (ns2->next == ns1->next) &&
+	            (xmlStrEqual(ns1->prefix, ns2->prefix)))
+		    return(1);
+	    }
+	}
+    } else {
+	for (i = 0; i < cur->nodeNr; i++) {
+	    if (cur->nodeTab[i] == val)
+		return(1);
+	}
+    }
+    return(0);
+}
+
+/**
+ * xmlXPathNodeSetAddNs:
+ * @cur:  the initial node set
+ * @node:  the hosting node
+ * @ns:  a the namespace node
+ *
+ * add a new namespace node to an existing NodeSet
+ */
+void
+xmlXPathNodeSetAddNs(xmlNodeSetPtr cur, xmlNodePtr node, xmlNsPtr ns) {
+    int i;
+
+    if ((ns == NULL) || (node == NULL) || (ns->type != XML_NAMESPACE_DECL) ||
+	(node->type != XML_ELEMENT_NODE))
+	return;
+
+    /* @@ with_ns to check whether namespace nodes should be looked at @@ */
+    /*
+     * prevent duplicates
+     */
+    for (i = 0;i < cur->nodeNr;i++) {
+        if ((cur->nodeTab[i] != NULL) &&
+	    (cur->nodeTab[i]->type == XML_NAMESPACE_DECL) &&
+	    (((xmlNsPtr)cur->nodeTab[i])->next == (xmlNsPtr) node) &&
+	    (xmlStrEqual(ns->prefix, ((xmlNsPtr)cur->nodeTab[i])->prefix)))
+	    return;
+    }
+
+    /*
+     * grow the nodeTab if needed
+     */
+    if (cur->nodeMax == 0) {
+        cur->nodeTab = (xmlNodePtr *) xmlMalloc(XML_NODESET_DEFAULT *
+					     sizeof(xmlNodePtr));
+	if (cur->nodeTab == NULL) {
+	    xmlXPathErrMemory(NULL, "growing nodeset\n");
+	    return;
+	}
+	memset(cur->nodeTab, 0 ,
+	       XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
+        cur->nodeMax = XML_NODESET_DEFAULT;
+    } else if (cur->nodeNr == cur->nodeMax) {
+        xmlNodePtr *temp;
+
+        cur->nodeMax *= 2;
+	temp = (xmlNodePtr *) xmlRealloc(cur->nodeTab, cur->nodeMax *
+				      sizeof(xmlNodePtr));
+	if (temp == NULL) {
+	    xmlXPathErrMemory(NULL, "growing nodeset\n");
+	    return;
+	}
+	cur->nodeTab = temp;
+    }
+    cur->nodeTab[cur->nodeNr++] = xmlXPathNodeSetDupNs(node, ns);
+}
+
+/**
+ * xmlXPathNodeSetAdd:
+ * @cur:  the initial node set
+ * @val:  a new xmlNodePtr
+ *
+ * add a new xmlNodePtr to an existing NodeSet
+ */
+void
+xmlXPathNodeSetAdd(xmlNodeSetPtr cur, xmlNodePtr val) {
+    int i;
+
+    if (val == NULL) return;
+
+#if 0
+    if ((val->type == XML_ELEMENT_NODE) && (val->name[0] == ' '))
+	return;	/* an XSLT fake node */
+#endif
+
+    /* @@ with_ns to check whether namespace nodes should be looked at @@ */
+    /*
+     * prevent duplcates
+     */
+    for (i = 0;i < cur->nodeNr;i++)
+        if (cur->nodeTab[i] == val) return;
+
+    /*
+     * grow the nodeTab if needed
+     */
+    if (cur->nodeMax == 0) {
+        cur->nodeTab = (xmlNodePtr *) xmlMalloc(XML_NODESET_DEFAULT *
+					     sizeof(xmlNodePtr));
+	if (cur->nodeTab == NULL) {
+	    xmlXPathErrMemory(NULL, "growing nodeset\n");
+	    return;
+	}
+	memset(cur->nodeTab, 0 ,
+	       XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
+        cur->nodeMax = XML_NODESET_DEFAULT;
+    } else if (cur->nodeNr == cur->nodeMax) {
+        xmlNodePtr *temp;
+
+        cur->nodeMax *= 2;
+	temp = (xmlNodePtr *) xmlRealloc(cur->nodeTab, cur->nodeMax *
+				      sizeof(xmlNodePtr));
+	if (temp == NULL) {
+	    xmlXPathErrMemory(NULL, "growing nodeset\n");
+	    return;
+	}
+	cur->nodeTab = temp;
+    }
+    if (val->type == XML_NAMESPACE_DECL) {
+	xmlNsPtr ns = (xmlNsPtr) val;
+
+	cur->nodeTab[cur->nodeNr++] = 
+	    xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns);
+    } else
+	cur->nodeTab[cur->nodeNr++] = val;
+}
+
+/**
+ * xmlXPathNodeSetAddUnique:
+ * @cur:  the initial node set
+ * @val:  a new xmlNodePtr
+ *
+ * add a new xmlNodePtr to an existing NodeSet, optimized version
+ * when we are sure the node is not already in the set.
+ */
+void
+xmlXPathNodeSetAddUnique(xmlNodeSetPtr cur, xmlNodePtr val) {
+    if (val == NULL) return;
+
+#if 0
+    if ((val->type == XML_ELEMENT_NODE) && (val->name[0] == ' '))
+	return;	/* an XSLT fake node */
+#endif
+
+    /* @@ with_ns to check whether namespace nodes should be looked at @@ */
+    /*
+     * grow the nodeTab if needed
+     */
+    if (cur->nodeMax == 0) {
+        cur->nodeTab = (xmlNodePtr *) xmlMalloc(XML_NODESET_DEFAULT *
+					     sizeof(xmlNodePtr));
+	if (cur->nodeTab == NULL) {
+	    xmlXPathErrMemory(NULL, "growing nodeset\n");
+	    return;
+	}
+	memset(cur->nodeTab, 0 ,
+	       XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
+        cur->nodeMax = XML_NODESET_DEFAULT;
+    } else if (cur->nodeNr == cur->nodeMax) {
+        xmlNodePtr *temp;
+
+        cur->nodeMax *= 2;
+	temp = (xmlNodePtr *) xmlRealloc(cur->nodeTab, cur->nodeMax *
+				      sizeof(xmlNodePtr));
+	if (temp == NULL) {
+	    xmlXPathErrMemory(NULL, "growing nodeset\n");
+	    return;
+	}
+	cur->nodeTab = temp;
+    }
+    if (val->type == XML_NAMESPACE_DECL) {
+	xmlNsPtr ns = (xmlNsPtr) val;
+
+	cur->nodeTab[cur->nodeNr++] = 
+	    xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns);
+    } else
+	cur->nodeTab[cur->nodeNr++] = val;
+}
+
+/**
+ * xmlXPathNodeSetMerge:
+ * @val1:  the first NodeSet or NULL
+ * @val2:  the second NodeSet
+ *
+ * Merges two nodesets, all nodes from @val2 are added to @val1
+ * if @val1 is NULL, a new set is created and copied from @val2
+ *
+ * Returns @val1 once extended or NULL in case of error.
+ */
+xmlNodeSetPtr
+xmlXPathNodeSetMerge(xmlNodeSetPtr val1, xmlNodeSetPtr val2) {
+    int i, j, initNr, skip;
+
+    if (val2 == NULL) return(val1);
+    if (val1 == NULL) {
+	val1 = xmlXPathNodeSetCreate(NULL);
+    }
+
+    /* @@ with_ns to check whether namespace nodes should be looked at @@ */
+    initNr = val1->nodeNr;
+
+    for (i = 0;i < val2->nodeNr;i++) {
+	/*
+	 * check against duplicates
+	 */
+	skip = 0;
+	for (j = 0; j < initNr; j++) {
+	    if (val1->nodeTab[j] == val2->nodeTab[i]) {
+		skip = 1;
+		break;
+	    } else if ((val1->nodeTab[j]->type == XML_NAMESPACE_DECL) &&
+		       (val2->nodeTab[i]->type == XML_NAMESPACE_DECL)) {
+		xmlNsPtr ns1, ns2;
+		ns1 = (xmlNsPtr) val1->nodeTab[j];
+		ns2 = (xmlNsPtr) val2->nodeTab[i];
+		if ((ns1->next == ns2->next) &&
+		    (xmlStrEqual(ns1->prefix, ns2->prefix))) {
+		    skip = 1;
+		    break;
+		}
+	    }
+	}
+	if (skip)
+	    continue;
+
+	/*
+	 * grow the nodeTab if needed
+	 */
+	if (val1->nodeMax == 0) {
+	    val1->nodeTab = (xmlNodePtr *) xmlMalloc(XML_NODESET_DEFAULT *
+						    sizeof(xmlNodePtr));
+	    if (val1->nodeTab == NULL) {
+	        xmlXPathErrMemory(NULL, "merging nodeset\n");
+		return(NULL);
+	    }
+	    memset(val1->nodeTab, 0 ,
+		   XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
+	    val1->nodeMax = XML_NODESET_DEFAULT;
+	} else if (val1->nodeNr == val1->nodeMax) {
+	    xmlNodePtr *temp;
+
+	    val1->nodeMax *= 2;
+	    temp = (xmlNodePtr *) xmlRealloc(val1->nodeTab, val1->nodeMax *
+					     sizeof(xmlNodePtr));
+	    if (temp == NULL) {
+	        xmlXPathErrMemory(NULL, "merging nodeset\n");
+		return(NULL);
+	    }
+	    val1->nodeTab = temp;
+	}
+	if (val2->nodeTab[i]->type == XML_NAMESPACE_DECL) {
+	    xmlNsPtr ns = (xmlNsPtr) val2->nodeTab[i];
+
+	    val1->nodeTab[val1->nodeNr++] =
+		xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns);
+	} else
+	    val1->nodeTab[val1->nodeNr++] = val2->nodeTab[i];
+    }
+
+    return(val1);
+}
+
+/**
+ * xmlXPathNodeSetMergeUnique:
+ * @val1:  the first NodeSet or NULL
+ * @val2:  the second NodeSet
+ *
+ * Merges two nodesets, all nodes from @val2 are added to @val1
+ * if @val1 is NULL, a new set is created and copied from @val2
+ *
+ * Returns @val1 once extended or NULL in case of error.
+ */
+static xmlNodeSetPtr
+xmlXPathNodeSetMergeUnique(xmlNodeSetPtr val1, xmlNodeSetPtr val2) {
+    int i;
+
+    if (val2 == NULL) return(val1);
+    if (val1 == NULL) {
+	val1 = xmlXPathNodeSetCreate(NULL);
+    }
+
+    /* @@ with_ns to check whether namespace nodes should be looked at @@ */
+
+    for (i = 0;i < val2->nodeNr;i++) {
+	/*
+	 * grow the nodeTab if needed
+	 */
+	if (val1->nodeMax == 0) {
+	    val1->nodeTab = (xmlNodePtr *) xmlMalloc(XML_NODESET_DEFAULT *
+						    sizeof(xmlNodePtr));
+	    if (val1->nodeTab == NULL) {
+	        xmlXPathErrMemory(NULL, "merging nodeset\n");
+		return(NULL);
+	    }
+	    memset(val1->nodeTab, 0 ,
+		   XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
+	    val1->nodeMax = XML_NODESET_DEFAULT;
+	} else if (val1->nodeNr == val1->nodeMax) {
+	    xmlNodePtr *temp;
+
+	    val1->nodeMax *= 2;
+	    temp = (xmlNodePtr *) xmlRealloc(val1->nodeTab, val1->nodeMax *
+					     sizeof(xmlNodePtr));
+	    if (temp == NULL) {
+	        xmlXPathErrMemory(NULL, "merging nodeset\n");
+		return(NULL);
+	    }
+	    val1->nodeTab = temp;
+	}
+	if (val2->nodeTab[i]->type == XML_NAMESPACE_DECL) {
+	    xmlNsPtr ns = (xmlNsPtr) val2->nodeTab[i];
+
+	    val1->nodeTab[val1->nodeNr++] =
+		xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns);
+	} else
+	    val1->nodeTab[val1->nodeNr++] = val2->nodeTab[i];
+    }
+
+    return(val1);
+}
+
+/**
+ * xmlXPathNodeSetDel:
+ * @cur:  the initial node set
+ * @val:  an xmlNodePtr
+ *
+ * Removes an xmlNodePtr from an existing NodeSet
+ */
+void
+xmlXPathNodeSetDel(xmlNodeSetPtr cur, xmlNodePtr val) {
+    int i;
+
+    if (cur == NULL) return;
+    if (val == NULL) return;
+
+    /*
+     * find node in nodeTab
+     */
+    for (i = 0;i < cur->nodeNr;i++)
+        if (cur->nodeTab[i] == val) break;
+
+    if (i >= cur->nodeNr) {	/* not found */
+#ifdef DEBUG
+        xmlGenericError(xmlGenericErrorContext, 
+	        "xmlXPathNodeSetDel: Node %s wasn't found in NodeList\n",
+		val->name);
+#endif
+        return;
+    }
+    if ((cur->nodeTab[i] != NULL) &&
+	(cur->nodeTab[i]->type == XML_NAMESPACE_DECL))
+	xmlXPathNodeSetFreeNs((xmlNsPtr) cur->nodeTab[i]);
+    cur->nodeNr--;
+    for (;i < cur->nodeNr;i++)
+        cur->nodeTab[i] = cur->nodeTab[i + 1];
+    cur->nodeTab[cur->nodeNr] = NULL;
+}
+
+/**
+ * xmlXPathNodeSetRemove:
+ * @cur:  the initial node set
+ * @val:  the index to remove
+ *
+ * Removes an entry from an existing NodeSet list.
+ */
+void
+xmlXPathNodeSetRemove(xmlNodeSetPtr cur, int val) {
+    if (cur == NULL) return;
+    if (val >= cur->nodeNr) return;
+    if ((cur->nodeTab[val] != NULL) &&
+	(cur->nodeTab[val]->type == XML_NAMESPACE_DECL))
+	xmlXPathNodeSetFreeNs((xmlNsPtr) cur->nodeTab[val]);
+    cur->nodeNr--;
+    for (;val < cur->nodeNr;val++)
+        cur->nodeTab[val] = cur->nodeTab[val + 1];
+    cur->nodeTab[cur->nodeNr] = NULL;
+}
+
+/**
+ * xmlXPathFreeNodeSet:
+ * @obj:  the xmlNodeSetPtr to free
+ *
+ * Free the NodeSet compound (not the actual nodes !).
+ */
+void
+xmlXPathFreeNodeSet(xmlNodeSetPtr obj) {
+    if (obj == NULL) return;
+    if (obj->nodeTab != NULL) {
+	int i;
+
+	/* @@ with_ns to check whether namespace nodes should be looked at @@ */
+	for (i = 0;i < obj->nodeNr;i++)
+	    if ((obj->nodeTab[i] != NULL) &&
+		(obj->nodeTab[i]->type == XML_NAMESPACE_DECL))
+		xmlXPathNodeSetFreeNs((xmlNsPtr) obj->nodeTab[i]);
+	xmlFree(obj->nodeTab);
+    }
+    xmlFree(obj);
+}
+
+/**
+ * xmlXPathFreeValueTree:
+ * @obj:  the xmlNodeSetPtr to free
+ *
+ * Free the NodeSet compound and the actual tree, this is different
+ * from xmlXPathFreeNodeSet()
+ */
+static void
+xmlXPathFreeValueTree(xmlNodeSetPtr obj) {
+    int i;
+
+    if (obj == NULL) return;
+
+    if (obj->nodeTab != NULL) {
+	for (i = 0;i < obj->nodeNr;i++) {
+	    if (obj->nodeTab[i] != NULL) {
+		if (obj->nodeTab[i]->type == XML_NAMESPACE_DECL) {
+		    xmlXPathNodeSetFreeNs((xmlNsPtr) obj->nodeTab[i]);
+		} else {
+		    xmlFreeNodeList(obj->nodeTab[i]);
+		}
+	    }
+	}
+	xmlFree(obj->nodeTab);
+    }
+    xmlFree(obj);
+}
+
+#if defined(DEBUG) || defined(DEBUG_STEP)
+/**
+ * xmlGenericErrorContextNodeSet:
+ * @output:  a FILE * for the output
+ * @obj:  the xmlNodeSetPtr to display
+ *
+ * Quick display of a NodeSet
+ */
+void
+xmlGenericErrorContextNodeSet(FILE *output, xmlNodeSetPtr obj) {
+    int i;
+
+    if (output == NULL) output = xmlGenericErrorContext;
+    if (obj == NULL)  {
+        fprintf(output, "NodeSet == NULL !\n");
+	return;
+    }
+    if (obj->nodeNr == 0) {
+        fprintf(output, "NodeSet is empty\n");
+	return;
+    }
+    if (obj->nodeTab == NULL) {
+	fprintf(output, " nodeTab == NULL !\n");
+	return;
+    }
+    for (i = 0; i < obj->nodeNr; i++) {
+        if (obj->nodeTab[i] == NULL) {
+	    fprintf(output, " NULL !\n");
+	    return;
+        }
+	if ((obj->nodeTab[i]->type == XML_DOCUMENT_NODE) ||
+	    (obj->nodeTab[i]->type == XML_HTML_DOCUMENT_NODE))
+	    fprintf(output, " /");
+	else if (obj->nodeTab[i]->name == NULL)
+	    fprintf(output, " noname!");
+	else fprintf(output, " %s", obj->nodeTab[i]->name);
+    }
+    fprintf(output, "\n");
+}
+#endif
+
+/**
+ * xmlXPathNewNodeSet:
+ * @val:  the NodePtr value
+ *
+ * Create a new xmlXPathObjectPtr of type NodeSet and initialize
+ * it with the single Node @val
+ *
+ * Returns the newly created object.
+ */
+xmlXPathObjectPtr
+xmlXPathNewNodeSet(xmlNodePtr val) {
+    xmlXPathObjectPtr ret;
+
+    ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
+    if (ret == NULL) {
+        xmlXPathErrMemory(NULL, "creating nodeset\n");
+	return(NULL);
+    }
+    memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
+    ret->type = XPATH_NODESET;
+    ret->boolval = 0;
+    ret->nodesetval = xmlXPathNodeSetCreate(val);
+    /* @@ with_ns to check whether namespace nodes should be looked at @@ */
+    return(ret);
+}
+
+/**
+ * xmlXPathNewValueTree:
+ * @val:  the NodePtr value
+ *
+ * Create a new xmlXPathObjectPtr of type Value Tree (XSLT) and initialize
+ * it with the tree root @val
+ *
+ * Returns the newly created object.
+ */
+xmlXPathObjectPtr
+xmlXPathNewValueTree(xmlNodePtr val) {
+    xmlXPathObjectPtr ret;
+
+    ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
+    if (ret == NULL) {
+        xmlXPathErrMemory(NULL, "creating result value tree\n");
+	return(NULL);
+    }
+    memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
+    ret->type = XPATH_XSLT_TREE;
+    ret->boolval = 1;
+    ret->user = (void *) val;
+    ret->nodesetval = xmlXPathNodeSetCreate(val);
+    return(ret);
+}
+
+/**
+ * xmlXPathNewNodeSetList:
+ * @val:  an existing NodeSet
+ *
+ * Create a new xmlXPathObjectPtr of type NodeSet and initialize
+ * it with the Nodeset @val
+ *
+ * Returns the newly created object.
+ */
+xmlXPathObjectPtr
+xmlXPathNewNodeSetList(xmlNodeSetPtr val)
+{
+    xmlXPathObjectPtr ret;
+    int i;
+
+    if (val == NULL)
+        ret = NULL;
+    else if (val->nodeTab == NULL)
+        ret = xmlXPathNewNodeSet(NULL);
+    else {
+        ret = xmlXPathNewNodeSet(val->nodeTab[0]);
+        for (i = 1; i < val->nodeNr; ++i)
+            xmlXPathNodeSetAddUnique(ret->nodesetval, val->nodeTab[i]);
+    }
+
+    return (ret);
+}
+
+/**
+ * xmlXPathWrapNodeSet:
+ * @val:  the NodePtr value
+ *
+ * Wrap the Nodeset @val in a new xmlXPathObjectPtr
+ *
+ * Returns the newly created object.
+ */
+xmlXPathObjectPtr
+xmlXPathWrapNodeSet(xmlNodeSetPtr val) {
+    xmlXPathObjectPtr ret;
+
+    ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
+    if (ret == NULL) {
+        xmlXPathErrMemory(NULL, "creating node set object\n");
+	return(NULL);
+    }
+    memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
+    ret->type = XPATH_NODESET;
+    ret->nodesetval = val;
+    return(ret);
+}
+
+/**
+ * xmlXPathFreeNodeSetList:
+ * @obj:  an existing NodeSetList object
+ *
+ * Free up the xmlXPathObjectPtr @obj but don't deallocate the objects in
+ * the list contrary to xmlXPathFreeObject().
+ */
+void
+xmlXPathFreeNodeSetList(xmlXPathObjectPtr obj) {
+    if (obj == NULL) return;
+    xmlFree(obj);
+}
+
+/**
+ * xmlXPathDifference:
+ * @nodes1:  a node-set
+ * @nodes2:  a node-set
+ *
+ * Implements the EXSLT - Sets difference() function:
+ *    node-set set:difference (node-set, node-set)
+ *
+ * Returns the difference between the two node sets, or nodes1 if
+ *         nodes2 is empty
+ */
+xmlNodeSetPtr
+xmlXPathDifference (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
+    xmlNodeSetPtr ret;
+    int i, l1;
+    xmlNodePtr cur;
+
+    if (xmlXPathNodeSetIsEmpty(nodes2))
+	return(nodes1);
+
+    ret = xmlXPathNodeSetCreate(NULL);
+    if (xmlXPathNodeSetIsEmpty(nodes1))
+	return(ret);
+
+    l1 = xmlXPathNodeSetGetLength(nodes1);
+
+    for (i = 0; i < l1; i++) {
+	cur = xmlXPathNodeSetItem(nodes1, i);
+	if (!xmlXPathNodeSetContains(nodes2, cur))
+	    xmlXPathNodeSetAddUnique(ret, cur);
+    }
+    return(ret);
+}
+
+/**
+ * xmlXPathIntersection:
+ * @nodes1:  a node-set
+ * @nodes2:  a node-set
+ *
+ * Implements the EXSLT - Sets intersection() function:
+ *    node-set set:intersection (node-set, node-set)
+ *
+ * Returns a node set comprising the nodes that are within both the
+ *         node sets passed as arguments
+ */
+xmlNodeSetPtr
+xmlXPathIntersection (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
+    xmlNodeSetPtr ret = xmlXPathNodeSetCreate(NULL);
+    int i, l1;
+    xmlNodePtr cur;
+
+    if (xmlXPathNodeSetIsEmpty(nodes1))
+	return(ret);
+    if (xmlXPathNodeSetIsEmpty(nodes2))
+	return(ret);
+
+    l1 = xmlXPathNodeSetGetLength(nodes1);
+
+    for (i = 0; i < l1; i++) {
+	cur = xmlXPathNodeSetItem(nodes1, i);
+	if (xmlXPathNodeSetContains(nodes2, cur))
+	    xmlXPathNodeSetAddUnique(ret, cur);
+    }
+    return(ret);
+}
+
+/**
+ * xmlXPathDistinctSorted:
+ * @nodes:  a node-set, sorted by document order
+ *
+ * Implements the EXSLT - Sets distinct() function:
+ *    node-set set:distinct (node-set)
+ * 
+ * Returns a subset of the nodes contained in @nodes, or @nodes if
+ *         it is empty
+ */
+xmlNodeSetPtr
+xmlXPathDistinctSorted (xmlNodeSetPtr nodes) {
+    xmlNodeSetPtr ret;
+    xmlHashTablePtr hash;
+    int i, l;
+    xmlChar * strval;
+    xmlNodePtr cur;
+
+    if (xmlXPathNodeSetIsEmpty(nodes))
+	return(nodes);
+
+    ret = xmlXPathNodeSetCreate(NULL);
+    l = xmlXPathNodeSetGetLength(nodes);
+    hash = xmlHashCreate (l);
+    for (i = 0; i < l; i++) {
+	cur = xmlXPathNodeSetItem(nodes, i);
+	strval = xmlXPathCastNodeToString(cur);
+	if (xmlHashLookup(hash, strval) == NULL) {
+	    xmlHashAddEntry(hash, strval, strval);
+	    xmlXPathNodeSetAddUnique(ret, cur);
+	} else {
+	    xmlFree(strval);
+	}
+    }
+    xmlHashFree(hash, (xmlHashDeallocator) xmlFree);
+    return(ret);
+}
+
+/**
+ * xmlXPathDistinct:
+ * @nodes:  a node-set
+ *
+ * Implements the EXSLT - Sets distinct() function:
+ *    node-set set:distinct (node-set)
+ * @nodes is sorted by document order, then #exslSetsDistinctSorted
+ * is called with the sorted node-set
+ *
+ * Returns a subset of the nodes contained in @nodes, or @nodes if
+ *         it is empty
+ */
+xmlNodeSetPtr
+xmlXPathDistinct (xmlNodeSetPtr nodes) {
+    if (xmlXPathNodeSetIsEmpty(nodes))
+	return(nodes);
+
+    xmlXPathNodeSetSort(nodes);
+    return(xmlXPathDistinctSorted(nodes));
+}
+
+/**
+ * xmlXPathHasSameNodes:
+ * @nodes1:  a node-set
+ * @nodes2:  a node-set
+ *
+ * Implements the EXSLT - Sets has-same-nodes function:
+ *    boolean set:has-same-node(node-set, node-set)
+ *
+ * Returns true (1) if @nodes1 shares any node with @nodes2, false (0)
+ *         otherwise
+ */
+int
+xmlXPathHasSameNodes (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
+    int i, l;
+    xmlNodePtr cur;
+
+    if (xmlXPathNodeSetIsEmpty(nodes1) ||
+	xmlXPathNodeSetIsEmpty(nodes2))
+	return(0);
+
+    l = xmlXPathNodeSetGetLength(nodes1);
+    for (i = 0; i < l; i++) {
+	cur = xmlXPathNodeSetItem(nodes1, i);
+	if (xmlXPathNodeSetContains(nodes2, cur))
+	    return(1);
+    }
+    return(0);
+}
+
+/**
+ * xmlXPathNodeLeadingSorted:
+ * @nodes: a node-set, sorted by document order
+ * @node: a node
+ *
+ * Implements the EXSLT - Sets leading() function:
+ *    node-set set:leading (node-set, node-set)
+ *
+ * Returns the nodes in @nodes that precede @node in document order,
+ *         @nodes if @node is NULL or an empty node-set if @nodes
+ *         doesn't contain @node
+ */
+xmlNodeSetPtr
+xmlXPathNodeLeadingSorted (xmlNodeSetPtr nodes, xmlNodePtr node) {
+    int i, l;
+    xmlNodePtr cur;
+    xmlNodeSetPtr ret;
+
+    if (node == NULL)
+	return(nodes);
+
+    ret = xmlXPathNodeSetCreate(NULL);
+    if (xmlXPathNodeSetIsEmpty(nodes) ||
+	(!xmlXPathNodeSetContains(nodes, node)))
+	return(ret);
+
+    l = xmlXPathNodeSetGetLength(nodes);
+    for (i = 0; i < l; i++) {
+	cur = xmlXPathNodeSetItem(nodes, i);
+	if (cur == node)
+	    break;
+	xmlXPathNodeSetAddUnique(ret, cur);
+    }
+    return(ret);
+}
+
+/**
+ * xmlXPathNodeLeading:
+ * @nodes:  a node-set
+ * @node:  a node
+ *
+ * Implements the EXSLT - Sets leading() function:
+ *    node-set set:leading (node-set, node-set)
+ * @nodes is sorted by document order, then #exslSetsNodeLeadingSorted
+ * is called.
+ *
+ * Returns the nodes in @nodes that precede @node in document order,
+ *         @nodes if @node is NULL or an empty node-set if @nodes
+ *         doesn't contain @node
+ */
+xmlNodeSetPtr
+xmlXPathNodeLeading (xmlNodeSetPtr nodes, xmlNodePtr node) {
+    xmlXPathNodeSetSort(nodes);
+    return(xmlXPathNodeLeadingSorted(nodes, node));
+}
+
+/**
+ * xmlXPathLeadingSorted:
+ * @nodes1:  a node-set, sorted by document order
+ * @nodes2:  a node-set, sorted by document order
+ *
+ * Implements the EXSLT - Sets leading() function:
+ *    node-set set:leading (node-set, node-set)
+ *
+ * Returns the nodes in @nodes1 that precede the first node in @nodes2
+ *         in document order, @nodes1 if @nodes2 is NULL or empty or
+ *         an empty node-set if @nodes1 doesn't contain @nodes2
+ */
+xmlNodeSetPtr
+xmlXPathLeadingSorted (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
+    if (xmlXPathNodeSetIsEmpty(nodes2))
+	return(nodes1);
+    return(xmlXPathNodeLeadingSorted(nodes1,
+				     xmlXPathNodeSetItem(nodes2, 1)));
+}
+
+/**
+ * xmlXPathLeading:
+ * @nodes1:  a node-set
+ * @nodes2:  a node-set
+ *
+ * Implements the EXSLT - Sets leading() function:
+ *    node-set set:leading (node-set, node-set)
+ * @nodes1 and @nodes2 are sorted by document order, then
+ * #exslSetsLeadingSorted is called.
+ *
+ * Returns the nodes in @nodes1 that precede the first node in @nodes2
+ *         in document order, @nodes1 if @nodes2 is NULL or empty or
+ *         an empty node-set if @nodes1 doesn't contain @nodes2
+ */
+xmlNodeSetPtr
+xmlXPathLeading (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
+    if (xmlXPathNodeSetIsEmpty(nodes2))
+	return(nodes1);
+    if (xmlXPathNodeSetIsEmpty(nodes1))
+	return(xmlXPathNodeSetCreate(NULL));
+    xmlXPathNodeSetSort(nodes1);
+    xmlXPathNodeSetSort(nodes2);
+    return(xmlXPathNodeLeadingSorted(nodes1,
+				     xmlXPathNodeSetItem(nodes2, 1)));
+}
+
+/**
+ * xmlXPathNodeTrailingSorted:
+ * @nodes: a node-set, sorted by document order
+ * @node: a node
+ *
+ * Implements the EXSLT - Sets trailing() function:
+ *    node-set set:trailing (node-set, node-set)
+ *
+ * Returns the nodes in @nodes that follow @node in document order,
+ *         @nodes if @node is NULL or an empty node-set if @nodes
+ *         doesn't contain @node
+ */
+xmlNodeSetPtr
+xmlXPathNodeTrailingSorted (xmlNodeSetPtr nodes, xmlNodePtr node) {
+    int i, l;
+    xmlNodePtr cur;
+    xmlNodeSetPtr ret;
+
+    if (node == NULL)
+	return(nodes);
+
+    ret = xmlXPathNodeSetCreate(NULL);
+    if (xmlXPathNodeSetIsEmpty(nodes) ||
+	(!xmlXPathNodeSetContains(nodes, node)))
+	return(ret);
+
+    l = xmlXPathNodeSetGetLength(nodes);
+    for (i = l; i > 0; i--) {
+	cur = xmlXPathNodeSetItem(nodes, i);
+	if (cur == node)
+	    break;
+	xmlXPathNodeSetAddUnique(ret, cur);
+    }
+    return(ret);
+}
+
+/**
+ * xmlXPathNodeTrailing:
+ * @nodes:  a node-set
+ * @node:  a node
+ *
+ * Implements the EXSLT - Sets trailing() function:
+ *    node-set set:trailing (node-set, node-set)
+ * @nodes is sorted by document order, then #xmlXPathNodeTrailingSorted
+ * is called.
+ *
+ * Returns the nodes in @nodes that follow @node in document order,
+ *         @nodes if @node is NULL or an empty node-set if @nodes
+ *         doesn't contain @node
+ */
+xmlNodeSetPtr
+xmlXPathNodeTrailing (xmlNodeSetPtr nodes, xmlNodePtr node) {
+    xmlXPathNodeSetSort(nodes);
+    return(xmlXPathNodeTrailingSorted(nodes, node));
+}
+
+/**
+ * xmlXPathTrailingSorted:
+ * @nodes1:  a node-set, sorted by document order
+ * @nodes2:  a node-set, sorted by document order
+ *
+ * Implements the EXSLT - Sets trailing() function:
+ *    node-set set:trailing (node-set, node-set)
+ *
+ * Returns the nodes in @nodes1 that follow the first node in @nodes2
+ *         in document order, @nodes1 if @nodes2 is NULL or empty or
+ *         an empty node-set if @nodes1 doesn't contain @nodes2
+ */
+xmlNodeSetPtr
+xmlXPathTrailingSorted (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
+    if (xmlXPathNodeSetIsEmpty(nodes2))
+	return(nodes1);
+    return(xmlXPathNodeTrailingSorted(nodes1,
+				      xmlXPathNodeSetItem(nodes2, 0)));
+}
+
+/**
+ * xmlXPathTrailing:
+ * @nodes1:  a node-set
+ * @nodes2:  a node-set
+ *
+ * Implements the EXSLT - Sets trailing() function:
+ *    node-set set:trailing (node-set, node-set)
+ * @nodes1 and @nodes2 are sorted by document order, then
+ * #xmlXPathTrailingSorted is called.
+ *
+ * Returns the nodes in @nodes1 that follow the first node in @nodes2
+ *         in document order, @nodes1 if @nodes2 is NULL or empty or
+ *         an empty node-set if @nodes1 doesn't contain @nodes2
+ */
+xmlNodeSetPtr
+xmlXPathTrailing (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
+    if (xmlXPathNodeSetIsEmpty(nodes2))
+	return(nodes1);
+    if (xmlXPathNodeSetIsEmpty(nodes1))
+	return(xmlXPathNodeSetCreate(NULL));
+    xmlXPathNodeSetSort(nodes1);
+    xmlXPathNodeSetSort(nodes2);
+    return(xmlXPathNodeTrailingSorted(nodes1,
+				      xmlXPathNodeSetItem(nodes2, 0)));
+}
+
+/************************************************************************
+ *									*
+ *		Routines to handle extra functions			*
+ *									*
+ ************************************************************************/
+
+/**
+ * xmlXPathRegisterFunc:
+ * @ctxt:  the XPath context
+ * @name:  the function name
+ * @f:  the function implementation or NULL
+ *
+ * Register a new function. If @f is NULL it unregisters the function
+ *
+ * Returns 0 in case of success, -1 in case of error
+ */
+int		  
+xmlXPathRegisterFunc(xmlXPathContextPtr ctxt, const xmlChar *name,
+		     xmlXPathFunction f) {
+    return(xmlXPathRegisterFuncNS(ctxt, name, NULL, f));
+}
+
+/**
+ * xmlXPathRegisterFuncNS:
+ * @ctxt:  the XPath context
+ * @name:  the function name
+ * @ns_uri:  the function namespace URI
+ * @f:  the function implementation or NULL
+ *
+ * Register a new function. If @f is NULL it unregisters the function
+ *
+ * Returns 0 in case of success, -1 in case of error
+ */
+int
+xmlXPathRegisterFuncNS(xmlXPathContextPtr ctxt, const xmlChar *name,
+		       const xmlChar *ns_uri, xmlXPathFunction f) {
+    if (ctxt == NULL)
+	return(-1);
+    if (name == NULL)
+	return(-1);
+
+    if (ctxt->funcHash == NULL)
+	ctxt->funcHash = xmlHashCreate(0);
+    if (ctxt->funcHash == NULL)
+	return(-1);
+    if (f == NULL)
+        return(xmlHashRemoveEntry2(ctxt->funcHash, name, ns_uri, NULL));
+    return(xmlHashAddEntry2(ctxt->funcHash, name, ns_uri, (void *) f));
+}
+
+/**
+ * xmlXPathRegisterFuncLookup:
+ * @ctxt:  the XPath context
+ * @f:  the lookup function
+ * @funcCtxt:  the lookup data
+ *
+ * Registers an external mechanism to do function lookup.
+ */
+void
+xmlXPathRegisterFuncLookup (xmlXPathContextPtr ctxt,
+			    xmlXPathFuncLookupFunc f,
+			    void *funcCtxt) {
+    if (ctxt == NULL)
+	return;
+    ctxt->funcLookupFunc = (void *) f;
+    ctxt->funcLookupData = funcCtxt;
+}
+
+/**
+ * xmlXPathFunctionLookup:
+ * @ctxt:  the XPath context
+ * @name:  the function name
+ *
+ * Search in the Function array of the context for the given
+ * function.
+ *
+ * Returns the xmlXPathFunction or NULL if not found
+ */
+xmlXPathFunction
+xmlXPathFunctionLookup(xmlXPathContextPtr ctxt, const xmlChar *name) {
+    if (ctxt == NULL)
+	return (NULL);
+
+    if (ctxt->funcLookupFunc != NULL) {
+	xmlXPathFunction ret;
+	xmlXPathFuncLookupFunc f;
+
+	f = (xmlXPathFuncLookupFunc) ctxt->funcLookupFunc;
+	ret = f(ctxt->funcLookupData, name, NULL);
+	if (ret != NULL)
+	    return(ret);
+    }
+    return(xmlXPathFunctionLookupNS(ctxt, name, NULL));
+}
+
+/**
+ * xmlXPathFunctionLookupNS:
+ * @ctxt:  the XPath context
+ * @name:  the function name
+ * @ns_uri:  the function namespace URI
+ *
+ * Search in the Function array of the context for the given
+ * function.
+ *
+ * Returns the xmlXPathFunction or NULL if not found
+ */
+xmlXPathFunction
+xmlXPathFunctionLookupNS(xmlXPathContextPtr ctxt, const xmlChar *name,
+			 const xmlChar *ns_uri) {
+    if (ctxt == NULL)
+	return(NULL);
+    if (name == NULL)
+	return(NULL);
+
+    if (ctxt->funcLookupFunc != NULL) {
+	xmlXPathFunction ret;
+	xmlXPathFuncLookupFunc f;
+
+	f = (xmlXPathFuncLookupFunc) ctxt->funcLookupFunc;
+	ret = f(ctxt->funcLookupData, name, ns_uri);
+	if (ret != NULL)
+	    return(ret);
+    }
+
+    if (ctxt->funcHash == NULL)
+	return(NULL);
+
+    return((xmlXPathFunction) xmlHashLookup2(ctxt->funcHash, name, ns_uri));
+}
+
+/**
+ * xmlXPathRegisteredFuncsCleanup:
+ * @ctxt:  the XPath context
+ *
+ * Cleanup the XPath context data associated to registered functions
+ */
+void
+xmlXPathRegisteredFuncsCleanup(xmlXPathContextPtr ctxt) {
+    if (ctxt == NULL)
+	return;
+
+    xmlHashFree(ctxt->funcHash, NULL);
+    ctxt->funcHash = NULL;
+}
+
+/************************************************************************
+ *									*
+ *			Routines to handle Variables			*
+ *									*
+ ************************************************************************/
+
+/**
+ * xmlXPathRegisterVariable:
+ * @ctxt:  the XPath context
+ * @name:  the variable name
+ * @value:  the variable value or NULL
+ *
+ * Register a new variable value. If @value is NULL it unregisters
+ * the variable
+ *
+ * Returns 0 in case of success, -1 in case of error
+ */
+int		  
+xmlXPathRegisterVariable(xmlXPathContextPtr ctxt, const xmlChar *name,
+			 xmlXPathObjectPtr value) {
+    return(xmlXPathRegisterVariableNS(ctxt, name, NULL, value));
+}
+
+/**
+ * xmlXPathRegisterVariableNS:
+ * @ctxt:  the XPath context
+ * @name:  the variable name
+ * @ns_uri:  the variable namespace URI
+ * @value:  the variable value or NULL
+ *
+ * Register a new variable value. If @value is NULL it unregisters
+ * the variable
+ *
+ * Returns 0 in case of success, -1 in case of error
+ */
+int
+xmlXPathRegisterVariableNS(xmlXPathContextPtr ctxt, const xmlChar *name,
+			   const xmlChar *ns_uri,
+			   xmlXPathObjectPtr value) {
+    if (ctxt == NULL)
+	return(-1);
+    if (name == NULL)
+	return(-1);
+
+    if (ctxt->varHash == NULL)
+	ctxt->varHash = xmlHashCreate(0);
+    if (ctxt->varHash == NULL)
+	return(-1);
+    if (value == NULL)
+        return(xmlHashRemoveEntry2(ctxt->varHash, name, ns_uri, 
+	                           (xmlHashDeallocator)xmlXPathFreeObject));
+    return(xmlHashUpdateEntry2(ctxt->varHash, name, ns_uri,
+			       (void *) value,
+			       (xmlHashDeallocator)xmlXPathFreeObject));
+}
+
+/**
+ * xmlXPathRegisterVariableLookup:
+ * @ctxt:  the XPath context
+ * @f:  the lookup function
+ * @data:  the lookup data
+ *
+ * register an external mechanism to do variable lookup
+ */
+void
+xmlXPathRegisterVariableLookup(xmlXPathContextPtr ctxt,
+	 xmlXPathVariableLookupFunc f, void *data) {
+    if (ctxt == NULL)
+	return;
+    ctxt->varLookupFunc = (void *) f;
+    ctxt->varLookupData = data;
+}
+
+/**
+ * xmlXPathVariableLookup:
+ * @ctxt:  the XPath context
+ * @name:  the variable name
+ *
+ * Search in the Variable array of the context for the given
+ * variable value.
+ *
+ * Returns a copy of the value or NULL if not found
+ */
+xmlXPathObjectPtr
+xmlXPathVariableLookup(xmlXPathContextPtr ctxt, const xmlChar *name) {
+    if (ctxt == NULL)
+	return(NULL);
+
+    if (ctxt->varLookupFunc != NULL) {
+	xmlXPathObjectPtr ret;
+
+	ret = ((xmlXPathVariableLookupFunc)ctxt->varLookupFunc)
+	        (ctxt->varLookupData, name, NULL);
+	return(ret);
+    }
+    return(xmlXPathVariableLookupNS(ctxt, name, NULL));
+}
+
+/**
+ * xmlXPathVariableLookupNS:
+ * @ctxt:  the XPath context
+ * @name:  the variable name
+ * @ns_uri:  the variable namespace URI
+ *
+ * Search in the Variable array of the context for the given
+ * variable value. 
+ *
+ * Returns the a copy of the value or NULL if not found
+ */
+xmlXPathObjectPtr
+xmlXPathVariableLookupNS(xmlXPathContextPtr ctxt, const xmlChar *name,
+			 const xmlChar *ns_uri) {
+    if (ctxt == NULL)
+	return(NULL);
+
+    if (ctxt->varLookupFunc != NULL) {
+	xmlXPathObjectPtr ret;
+
+	ret = ((xmlXPathVariableLookupFunc)ctxt->varLookupFunc)
+	        (ctxt->varLookupData, name, ns_uri);
+	if (ret != NULL) return(ret);
+    }
+
+    if (ctxt->varHash == NULL)
+	return(NULL);
+    if (name == NULL)
+	return(NULL);
+
+    return(xmlXPathObjectCopy((xmlXPathObjectPtr)
+		xmlHashLookup2(ctxt->varHash, name, ns_uri)));
+}
+
+/**
+ * xmlXPathRegisteredVariablesCleanup:
+ * @ctxt:  the XPath context
+ *
+ * Cleanup the XPath context data associated to registered variables
+ */
+void
+xmlXPathRegisteredVariablesCleanup(xmlXPathContextPtr ctxt) {
+    if (ctxt == NULL)
+	return;
+
+    xmlHashFree(ctxt->varHash, (xmlHashDeallocator)xmlXPathFreeObject);
+    ctxt->varHash = NULL;
+}
+
+/**
+ * xmlXPathRegisterNs:
+ * @ctxt:  the XPath context
+ * @prefix:  the namespace prefix
+ * @ns_uri:  the namespace name
+ *
+ * Register a new namespace. If @ns_uri is NULL it unregisters
+ * the namespace
+ *
+ * Returns 0 in case of success, -1 in case of error
+ */
+int
+xmlXPathRegisterNs(xmlXPathContextPtr ctxt, const xmlChar *prefix,
+			   const xmlChar *ns_uri) {
+    if (ctxt == NULL)
+	return(-1);
+    if (prefix == NULL)
+	return(-1);
+
+    if (ctxt->nsHash == NULL)
+	ctxt->nsHash = xmlHashCreate(10);
+    if (ctxt->nsHash == NULL)
+	return(-1);
+    if (ns_uri == NULL)
+        return(xmlHashRemoveEntry(ctxt->nsHash, prefix,
+	                          (xmlHashDeallocator)xmlFree));
+    return(xmlHashUpdateEntry(ctxt->nsHash, prefix, (void *) xmlStrdup(ns_uri),
+			      (xmlHashDeallocator)xmlFree));
+}
+
+/**
+ * xmlXPathNsLookup:
+ * @ctxt:  the XPath context
+ * @prefix:  the namespace prefix value
+ *
+ * Search in the namespace declaration array of the context for the given
+ * namespace name associated to the given prefix
+ *
+ * Returns the value or NULL if not found
+ */
+const xmlChar *
+xmlXPathNsLookup(xmlXPathContextPtr ctxt, const xmlChar *prefix) {
+    if (ctxt == NULL)
+	return(NULL);
+    if (prefix == NULL)
+	return(NULL);
+
+#ifdef XML_XML_NAMESPACE
+    if (xmlStrEqual(prefix, (const xmlChar *) "xml"))
+	return(XML_XML_NAMESPACE);
+#endif
+
+    if (ctxt->namespaces != NULL) {
+	int i;
+
+	for (i = 0;i < ctxt->nsNr;i++) {
+	    if ((ctxt->namespaces[i] != NULL) &&
+		(xmlStrEqual(ctxt->namespaces[i]->prefix, prefix)))
+		return(ctxt->namespaces[i]->href);
+	}
+    }
+
+    return((const xmlChar *) xmlHashLookup(ctxt->nsHash, prefix));
+}
+
+/**
+ * xmlXPathRegisteredNsCleanup:
+ * @ctxt:  the XPath context
+ *
+ * Cleanup the XPath context data associated to registered variables
+ */
+void
+xmlXPathRegisteredNsCleanup(xmlXPathContextPtr ctxt) {
+    if (ctxt == NULL)
+	return;
+
+    xmlHashFree(ctxt->nsHash, (xmlHashDeallocator)xmlFree);
+    ctxt->nsHash = NULL;
+}
+
+/************************************************************************
+ *									*
+ *			Routines to handle Values			*
+ *									*
+ ************************************************************************/
+
+/* Allocations are terrible, one needs to optimize all this !!! */
+
+/**
+ * xmlXPathNewFloat:
+ * @val:  the double value
+ *
+ * Create a new xmlXPathObjectPtr of type double and of value @val
+ *
+ * Returns the newly created object.
+ */
+xmlXPathObjectPtr
+xmlXPathNewFloat(double val) {
+    xmlXPathObjectPtr ret;
+
+    ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
+    if (ret == NULL) {
+        xmlXPathErrMemory(NULL, "creating float object\n");
+	return(NULL);
+    }
+    memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
+    ret->type = XPATH_NUMBER;
+    ret->floatval = val;
+    return(ret);
+}
+
+/**
+ * xmlXPathNewBoolean:
+ * @val:  the boolean value
+ *
+ * Create a new xmlXPathObjectPtr of type boolean and of value @val
+ *
+ * Returns the newly created object.
+ */
+xmlXPathObjectPtr
+xmlXPathNewBoolean(int val) {
+    xmlXPathObjectPtr ret;
+
+    ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
+    if (ret == NULL) {
+        xmlXPathErrMemory(NULL, "creating boolean object\n");
+	return(NULL);
+    }
+    memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
+    ret->type = XPATH_BOOLEAN;
+    ret->boolval = (val != 0);
+    return(ret);
+}
+
+/**
+ * xmlXPathNewString:
+ * @val:  the xmlChar * value
+ *
+ * Create a new xmlXPathObjectPtr of type string and of value @val
+ *
+ * Returns the newly created object.
+ */
+xmlXPathObjectPtr
+xmlXPathNewString(const xmlChar *val) {
+    xmlXPathObjectPtr ret;
+
+    ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
+    if (ret == NULL) {
+        xmlXPathErrMemory(NULL, "creating string object\n");
+	return(NULL);
+    }
+    memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
+    ret->type = XPATH_STRING;
+    if (val != NULL)
+	ret->stringval = xmlStrdup(val);
+    else
+	ret->stringval = xmlStrdup((const xmlChar *)"");
+    return(ret);
+}
+
+/**
+ * xmlXPathWrapString:
+ * @val:  the xmlChar * value
+ *
+ * Wraps the @val string into an XPath object.
+ *
+ * Returns the newly created object.
+ */
+xmlXPathObjectPtr
+xmlXPathWrapString (xmlChar *val) {
+    xmlXPathObjectPtr ret;
+
+    ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
+    if (ret == NULL) {
+        xmlXPathErrMemory(NULL, "creating string object\n");
+	return(NULL);
+    }
+    memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
+    ret->type = XPATH_STRING;
+    ret->stringval = val;
+    return(ret);
+}
+
+/**
+ * xmlXPathNewCString:
+ * @val:  the char * value
+ *
+ * Create a new xmlXPathObjectPtr of type string and of value @val
+ *
+ * Returns the newly created object.
+ */
+xmlXPathObjectPtr
+xmlXPathNewCString(const char *val) {
+    xmlXPathObjectPtr ret;
+
+    ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
+    if (ret == NULL) {
+        xmlXPathErrMemory(NULL, "creating string object\n");
+	return(NULL);
+    }
+    memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
+    ret->type = XPATH_STRING;
+    ret->stringval = xmlStrdup(BAD_CAST val);
+    return(ret);
+}
+
+/**
+ * xmlXPathWrapCString:
+ * @val:  the char * value
+ *
+ * Wraps a string into an XPath object.
+ *
+ * Returns the newly created object.
+ */
+xmlXPathObjectPtr
+xmlXPathWrapCString (char * val) {
+    return(xmlXPathWrapString((xmlChar *)(val)));
+}
+
+/**
+ * xmlXPathWrapExternal:
+ * @val:  the user data
+ *
+ * Wraps the @val data into an XPath object.
+ *
+ * Returns the newly created object.
+ */
+xmlXPathObjectPtr
+xmlXPathWrapExternal (void *val) {
+    xmlXPathObjectPtr ret;
+
+    ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
+    if (ret == NULL) {
+        xmlXPathErrMemory(NULL, "creating user object\n");
+	return(NULL);
+    }
+    memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
+    ret->type = XPATH_USERS;
+    ret->user = val;
+    return(ret);
+}
+
+/**
+ * xmlXPathObjectCopy:
+ * @val:  the original object
+ *
+ * allocate a new copy of a given object
+ *
+ * Returns the newly created object.
+ */
+xmlXPathObjectPtr
+xmlXPathObjectCopy(xmlXPathObjectPtr val) {
+    xmlXPathObjectPtr ret;
+
+    if (val == NULL)
+	return(NULL);
+
+    ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
+    if (ret == NULL) {
+        xmlXPathErrMemory(NULL, "copying object\n");
+	return(NULL);
+    }
+    memcpy(ret, val , (size_t) sizeof(xmlXPathObject));
+    switch (val->type) {
+	case XPATH_BOOLEAN:
+	case XPATH_NUMBER:
+	case XPATH_POINT:
+	case XPATH_RANGE:
+	    break;
+	case XPATH_STRING:
+	    ret->stringval = xmlStrdup(val->stringval);
+	    break;
+	case XPATH_XSLT_TREE:
+	    if ((val->nodesetval != NULL) &&
+		(val->nodesetval->nodeTab != NULL)) {
+		xmlNodePtr cur, tmp;
+		xmlDocPtr top;
+
+		ret->boolval = 1;
+		top =  xmlNewDoc(NULL);
+		top->name = (char *)
+		    xmlStrdup(val->nodesetval->nodeTab[0]->name);
+		ret->user = top;
+		if (top != NULL) {
+		    top->doc = top;
+		    cur = val->nodesetval->nodeTab[0]->children;
+		    while (cur != NULL) {
+			tmp = xmlDocCopyNode(cur, top, 1);
+			xmlAddChild((xmlNodePtr) top, tmp);
+			cur = cur->next;
+		    }
+		}
+		ret->nodesetval = xmlXPathNodeSetCreate((xmlNodePtr) top);
+	    } else
+		ret->nodesetval = xmlXPathNodeSetCreate(NULL);
+	    /* Deallocate the copied tree value */
+	    break;
+	case XPATH_NODESET:
+	    ret->nodesetval = xmlXPathNodeSetMerge(NULL, val->nodesetval);
+	    /* Do not deallocate the copied tree value */
+	    ret->boolval = 0;
+	    break;
+	case XPATH_LOCATIONSET:
+#ifdef LIBXML_XPTR_ENABLED
+	{
+	    xmlLocationSetPtr loc = val->user;
+	    ret->user = (void *) xmlXPtrLocationSetMerge(NULL, loc);
+	    break;
+	}
+#endif
+        case XPATH_USERS:
+	    ret->user = val->user;
+	    break; 
+        case XPATH_UNDEFINED:
+	    xmlGenericError(xmlGenericErrorContext,
+		    "xmlXPathObjectCopy: unsupported type %d\n",
+		    val->type);
+	    break;
+    }
+    return(ret);
+}
+
+/**
+ * xmlXPathFreeObject:
+ * @obj:  the object to free
+ *
+ * Free up an xmlXPathObjectPtr object.
+ */
+void
+xmlXPathFreeObject(xmlXPathObjectPtr obj) {
+    if (obj == NULL) return;
+    if ((obj->type == XPATH_NODESET) || (obj->type == XPATH_XSLT_TREE)) {
+	if (obj->boolval) {
+	    if (obj->user != NULL) {
+                xmlXPathFreeNodeSet(obj->nodesetval);
+		xmlFreeNodeList((xmlNodePtr) obj->user);
+	    } else if (obj->nodesetval != NULL)
+		xmlXPathFreeValueTree(obj->nodesetval);
+	} else {
+	    if (obj->nodesetval != NULL)
+		xmlXPathFreeNodeSet(obj->nodesetval);
+	}
+#ifdef LIBXML_XPTR_ENABLED
+    } else if (obj->type == XPATH_LOCATIONSET) {
+	if (obj->user != NULL)
+	    xmlXPtrFreeLocationSet(obj->user);
+#endif
+    } else if (obj->type == XPATH_STRING) {
+	if (obj->stringval != NULL)
+	    xmlFree(obj->stringval);
+    }
+
+    xmlFree(obj);
+}
+
+
+/************************************************************************
+ *									*
+ *			Type Casting Routines				*
+ *									*
+ ************************************************************************/
+
+/**
+ * xmlXPathCastBooleanToString:
+ * @val:  a boolean
+ *
+ * Converts a boolean to its string value.
+ *
+ * Returns a newly allocated string.
+ */
+xmlChar *
+xmlXPathCastBooleanToString (int val) {
+    xmlChar *ret;
+    if (val)
+	ret = xmlStrdup((const xmlChar *) "true");
+    else
+	ret = xmlStrdup((const xmlChar *) "false");
+    return(ret);
+}
+
+/**
+ * xmlXPathCastNumberToString:
+ * @val:  a number
+ *
+ * Converts a number to its string value.
+ *
+ * Returns a newly allocated string.
+ */
+xmlChar *
+xmlXPathCastNumberToString (double val) {
+    xmlChar *ret;
+    switch (xmlXPathIsInf(val)) {
+    case 1:
+	ret = xmlStrdup((const xmlChar *) "Infinity");
+	break;
+    case -1:
+	ret = xmlStrdup((const xmlChar *) "-Infinity");
+	break;
+    default:
+	if (xmlXPathIsNaN(val)) {
+	    ret = xmlStrdup((const xmlChar *) "NaN");
+	} else if (val == 0 && xmlXPathGetSign(val) != 0) {
+	    ret = xmlStrdup((const xmlChar *) "0");
+	} else {
+	    /* could be improved */
+	    char buf[100];
+	    xmlXPathFormatNumber(val, buf, 100);
+	    ret = xmlStrdup((const xmlChar *) buf);
+	}
+    }
+    return(ret);
+}
+
+/**
+ * xmlXPathCastNodeToString:
+ * @node:  a node
+ *
+ * Converts a node to its string value.
+ *
+ * Returns a newly allocated string.
+ */
+xmlChar *
+xmlXPathCastNodeToString (xmlNodePtr node) {
+    return(xmlNodeGetContent(node));
+}
+
+/**
+ * xmlXPathCastNodeSetToString:
+ * @ns:  a node-set
+ *
+ * Converts a node-set to its string value.
+ *
+ * Returns a newly allocated string.
+ */
+xmlChar *
+xmlXPathCastNodeSetToString (xmlNodeSetPtr ns) {
+    if ((ns == NULL) || (ns->nodeNr == 0) || (ns->nodeTab == NULL))
+	return(xmlStrdup((const xmlChar *) ""));
+
+    xmlXPathNodeSetSort(ns);
+    return(xmlXPathCastNodeToString(ns->nodeTab[0]));
+}
+
+/**
+ * xmlXPathCastToString:
+ * @val:  an XPath object
+ *
+ * Converts an existing object to its string() equivalent
+ *
+ * Returns the string value of the object, NULL in case of error.
+ *         A new string is allocated only if needed (@val isn't a
+ *         string object).
+ */
+xmlChar *
+xmlXPathCastToString(xmlXPathObjectPtr val) {
+    xmlChar *ret = NULL;
+
+    if (val == NULL)
+	return(xmlStrdup((const xmlChar *) ""));
+    switch (val->type) {
+	case XPATH_UNDEFINED:
+#ifdef DEBUG_EXPR
+	    xmlGenericError(xmlGenericErrorContext, "String: undefined\n");
+#endif
+	    ret = xmlStrdup((const xmlChar *) "");
+	    break;
+        case XPATH_NODESET:
+        case XPATH_XSLT_TREE:
+	    ret = xmlXPathCastNodeSetToString(val->nodesetval);
+	    break;
+	case XPATH_STRING:
+	    return(xmlStrdup(val->stringval));
+        case XPATH_BOOLEAN:
+	    ret = xmlXPathCastBooleanToString(val->boolval);
+	    break;
+	case XPATH_NUMBER: {
+	    ret = xmlXPathCastNumberToString(val->floatval);
+	    break;
+	}
+	case XPATH_USERS:
+	case XPATH_POINT:
+	case XPATH_RANGE:
+	case XPATH_LOCATIONSET:
+	    TODO
+	    ret = xmlStrdup((const xmlChar *) "");
+	    break;
+    }
+    return(ret);
+}
+
+/**
+ * xmlXPathConvertString:
+ * @val:  an XPath object
+ *
+ * Converts an existing object to its string() equivalent
+ *
+ * Returns the new object, the old one is freed (or the operation
+ *         is done directly on @val)
+ */
+xmlXPathObjectPtr
+xmlXPathConvertString(xmlXPathObjectPtr val) {
+    xmlChar *res = NULL;
+
+    if (val == NULL)
+	return(xmlXPathNewCString(""));
+
+    switch (val->type) {
+    case XPATH_UNDEFINED:
+#ifdef DEBUG_EXPR
+	xmlGenericError(xmlGenericErrorContext, "STRING: undefined\n");
+#endif
+	break;
+    case XPATH_NODESET:
+    case XPATH_XSLT_TREE:
+	res = xmlXPathCastNodeSetToString(val->nodesetval);
+	break;
+    case XPATH_STRING:
+	return(val);
+    case XPATH_BOOLEAN:
+	res = xmlXPathCastBooleanToString(val->boolval);
+	break;
+    case XPATH_NUMBER:
+	res = xmlXPathCastNumberToString(val->floatval);
+	break;
+    case XPATH_USERS:
+    case XPATH_POINT:
+    case XPATH_RANGE:
+    case XPATH_LOCATIONSET:
+	TODO;
+	break;
+    }
+    xmlXPathFreeObject(val);
+    if (res == NULL)
+	return(xmlXPathNewCString(""));
+    return(xmlXPathWrapString(res));
+}
+
+/**
+ * xmlXPathCastBooleanToNumber:
+ * @val:  a boolean
+ *
+ * Converts a boolean to its number value
+ *
+ * Returns the number value
+ */
+double
+xmlXPathCastBooleanToNumber(int val) {
+    if (val)
+	return(1.0);
+    return(0.0);
+}
+
+/**
+ * xmlXPathCastStringToNumber:
+ * @val:  a string
+ *
+ * Converts a string to its number value
+ *
+ * Returns the number value
+ */
+double
+xmlXPathCastStringToNumber(const xmlChar * val) {
+    return(xmlXPathStringEvalNumber(val));
+}
+
+/**
+ * xmlXPathCastNodeToNumber:
+ * @node:  a node
+ *
+ * Converts a node to its number value
+ *
+ * Returns the number value
+ */
+double
+xmlXPathCastNodeToNumber (xmlNodePtr node) {
+    xmlChar *strval;
+    double ret;
+
+    if (node == NULL)
+	return(xmlXPathNAN);
+    strval = xmlXPathCastNodeToString(node);
+    if (strval == NULL)
+	return(xmlXPathNAN);
+    ret = xmlXPathCastStringToNumber(strval);
+    xmlFree(strval);
+
+    return(ret);
+}
+
+/**
+ * xmlXPathCastNodeSetToNumber:
+ * @ns:  a node-set
+ *
+ * Converts a node-set to its number value
+ *
+ * Returns the number value
+ */
+double
+xmlXPathCastNodeSetToNumber (xmlNodeSetPtr ns) {
+    xmlChar *str;
+    double ret;
+
+    if (ns == NULL)
+	return(xmlXPathNAN);
+    str = xmlXPathCastNodeSetToString(ns);
+    ret = xmlXPathCastStringToNumber(str);
+    xmlFree(str);
+    return(ret);
+}
+
+/**
+ * xmlXPathCastToNumber:
+ * @val:  an XPath object
+ *
+ * Converts an XPath object to its number value
+ *
+ * Returns the number value
+ */
+double
+xmlXPathCastToNumber(xmlXPathObjectPtr val) {
+    double ret = 0.0;
+
+    if (val == NULL)
+	return(xmlXPathNAN);
+    switch (val->type) {
+    case XPATH_UNDEFINED:
+#ifdef DEGUB_EXPR
+	xmlGenericError(xmlGenericErrorContext, "NUMBER: undefined\n");
+#endif
+	ret = xmlXPathNAN;
+	break;
+    case XPATH_NODESET:
+    case XPATH_XSLT_TREE:
+	ret = xmlXPathCastNodeSetToNumber(val->nodesetval);
+	break;
+    case XPATH_STRING:
+	ret = xmlXPathCastStringToNumber(val->stringval);
+	break;
+    case XPATH_NUMBER:
+	ret = val->floatval;
+	break;
+    case XPATH_BOOLEAN:
+	ret = xmlXPathCastBooleanToNumber(val->boolval);
+	break;
+    case XPATH_USERS:
+    case XPATH_POINT:
+    case XPATH_RANGE:
+    case XPATH_LOCATIONSET:
+	TODO;
+	ret = xmlXPathNAN;
+	break;
+    }
+    return(ret);
+}
+
+/**
+ * xmlXPathConvertNumber:
+ * @val:  an XPath object
+ *
+ * Converts an existing object to its number() equivalent
+ *
+ * Returns the new object, the old one is freed (or the operation
+ *         is done directly on @val)
+ */
+xmlXPathObjectPtr
+xmlXPathConvertNumber(xmlXPathObjectPtr val) {
+    xmlXPathObjectPtr ret;
+
+    if (val == NULL)
+	return(xmlXPathNewFloat(0.0));
+    if (val->type == XPATH_NUMBER)
+	return(val);
+    ret = xmlXPathNewFloat(xmlXPathCastToNumber(val));
+    xmlXPathFreeObject(val);
+    return(ret);
+}
+
+/**
+ * xmlXPathCastNumberToBoolean:
+ * @val:  a number
+ *
+ * Converts a number to its boolean value
+ *
+ * Returns the boolean value
+ */
+int
+xmlXPathCastNumberToBoolean (double val) {
+     if (xmlXPathIsNaN(val) || (val == 0.0))
+	 return(0);
+     return(1);
+}
+
+/**
+ * xmlXPathCastStringToBoolean:
+ * @val:  a string
+ *
+ * Converts a string to its boolean value
+ *
+ * Returns the boolean value
+ */
+int
+xmlXPathCastStringToBoolean (const xmlChar *val) {
+    if ((val == NULL) || (xmlStrlen(val) == 0))
+	return(0);
+    return(1);
+}
+
+/**
+ * xmlXPathCastNodeSetToBoolean:
+ * @ns:  a node-set
+ *
+ * Converts a node-set to its boolean value
+ *
+ * Returns the boolean value
+ */
+int
+xmlXPathCastNodeSetToBoolean (xmlNodeSetPtr ns) {
+    if ((ns == NULL) || (ns->nodeNr == 0))
+	return(0);
+    return(1);
+}
+
+/**
+ * xmlXPathCastToBoolean:
+ * @val:  an XPath object
+ *
+ * Converts an XPath object to its boolean value
+ *
+ * Returns the boolean value
+ */
+int
+xmlXPathCastToBoolean (xmlXPathObjectPtr val) {
+    int ret = 0;
+
+    if (val == NULL)
+	return(0);
+    switch (val->type) {
+    case XPATH_UNDEFINED:
+#ifdef DEBUG_EXPR
+	xmlGenericError(xmlGenericErrorContext, "BOOLEAN: undefined\n");
+#endif
+	ret = 0;
+	break;
+    case XPATH_NODESET:
+    case XPATH_XSLT_TREE:
+	ret = xmlXPathCastNodeSetToBoolean(val->nodesetval);
+	break;
+    case XPATH_STRING:
+	ret = xmlXPathCastStringToBoolean(val->stringval);
+	break;
+    case XPATH_NUMBER:
+	ret = xmlXPathCastNumberToBoolean(val->floatval);
+	break;
+    case XPATH_BOOLEAN:
+	ret = val->boolval;
+	break;
+    case XPATH_USERS:
+    case XPATH_POINT:
+    case XPATH_RANGE:
+    case XPATH_LOCATIONSET:
+	TODO;
+	ret = 0;
+	break;
+    }
+    return(ret);
+}
+
+
+/**
+ * xmlXPathConvertBoolean:
+ * @val:  an XPath object
+ *
+ * Converts an existing object to its boolean() equivalent
+ *
+ * Returns the new object, the old one is freed (or the operation
+ *         is done directly on @val)
+ */
+xmlXPathObjectPtr
+xmlXPathConvertBoolean(xmlXPathObjectPtr val) {
+    xmlXPathObjectPtr ret;
+
+    if (val == NULL)
+	return(xmlXPathNewBoolean(0));
+    if (val->type == XPATH_BOOLEAN)
+	return(val);
+    ret = xmlXPathNewBoolean(xmlXPathCastToBoolean(val));
+    xmlXPathFreeObject(val);
+    return(ret);
+}
+
+/************************************************************************
+ *									*
+ *		Routines to handle XPath contexts			*
+ *									*
+ ************************************************************************/
+
+/**
+ * xmlXPathNewContext:
+ * @doc:  the XML document
+ *
+ * Create a new xmlXPathContext
+ *
+ * Returns the xmlXPathContext just allocated. The caller will need to free it.
+ */
+xmlXPathContextPtr
+xmlXPathNewContext(xmlDocPtr doc) {
+    xmlXPathContextPtr ret;
+
+    ret = (xmlXPathContextPtr) xmlMalloc(sizeof(xmlXPathContext));
+    if (ret == NULL) {
+        xmlXPathErrMemory(NULL, "creating context\n");
+	return(NULL);
+    }
+    memset(ret, 0 , (size_t) sizeof(xmlXPathContext));
+    ret->doc = doc;
+    ret->node = NULL;
+
+    ret->varHash = NULL;
+
+    ret->nb_types = 0;
+    ret->max_types = 0;
+    ret->types = NULL;
+
+    ret->funcHash = xmlHashCreate(0);
+
+    ret->nb_axis = 0;
+    ret->max_axis = 0;
+    ret->axis = NULL;
+
+    ret->nsHash = NULL;
+    ret->user = NULL;
+
+    ret->contextSize = -1;
+    ret->proximityPosition = -1;
+
+    xmlXPathRegisterAllFunctions(ret);
+    
+    return(ret);
+}
+
+/**
+ * xmlXPathFreeContext:
+ * @ctxt:  the context to free
+ *
+ * Free up an xmlXPathContext
+ */
+void
+xmlXPathFreeContext(xmlXPathContextPtr ctxt) {
+    xmlXPathRegisteredNsCleanup(ctxt);
+    xmlXPathRegisteredFuncsCleanup(ctxt);
+    xmlXPathRegisteredVariablesCleanup(ctxt);
+    xmlFree(ctxt);
+}
+
+/************************************************************************
+ *									*
+ *		Routines to handle XPath parser contexts		*
+ *									*
+ ************************************************************************/
+
+#define CHECK_CTXT(ctxt)						\
+    if (ctxt == NULL) { 						\
+        xmlGenericError(xmlGenericErrorContext,				\
+		"%s:%d Internal error: ctxt == NULL\n",			\
+	        __FILE__, __LINE__);					\
+    }									\
+
+
+#define CHECK_CONTEXT(ctxt)						\
+    if (ctxt == NULL) { 						\
+        xmlGenericError(xmlGenericErrorContext,				\
+		"%s:%d Internal error: no context\n",			\
+	        __FILE__, __LINE__);					\
+    }									\
+    else if (ctxt->doc == NULL) { 					\
+        xmlGenericError(xmlGenericErrorContext,				\
+		"%s:%d Internal error: no document\n",			\
+	        __FILE__, __LINE__);					\
+    }									\
+    else if (ctxt->doc->children == NULL) { 				\
+        xmlGenericError(xmlGenericErrorContext,				\
+	        "%s:%d Internal error: document without root\n",	\
+	        __FILE__, __LINE__);					\
+    }									\
+
+
+/**
+ * xmlXPathNewParserContext:
+ * @str:  the XPath expression
+ * @ctxt:  the XPath context
+ *
+ * Create a new xmlXPathParserContext
+ *
+ * Returns the xmlXPathParserContext just allocated.
+ */
+xmlXPathParserContextPtr
+xmlXPathNewParserContext(const xmlChar *str, xmlXPathContextPtr ctxt) {
+    xmlXPathParserContextPtr ret;
+
+    ret = (xmlXPathParserContextPtr) xmlMalloc(sizeof(xmlXPathParserContext));
+    if (ret == NULL) {
+        xmlXPathErrMemory(ctxt, "creating parser context\n");
+	return(NULL);
+    }
+    memset(ret, 0 , (size_t) sizeof(xmlXPathParserContext));
+    ret->cur = ret->base = str;
+    ret->context = ctxt;
+
+    ret->comp = xmlXPathNewCompExpr();
+    if (ret->comp == NULL) {
+	xmlFree(ret->valueTab);
+	xmlFree(ret);
+	return(NULL);
+    }
+    if ((ctxt != NULL) && (ctxt->dict != NULL)) {
+        ret->comp->dict = ctxt->dict;
+	xmlDictReference(ret->comp->dict);
+    }
+
+    return(ret);
+}
+
+/**
+ * xmlXPathCompParserContext:
+ * @comp:  the XPath compiled expression
+ * @ctxt:  the XPath context
+ *
+ * Create a new xmlXPathParserContext when processing a compiled expression
+ *
+ * Returns the xmlXPathParserContext just allocated.
+ */
+static xmlXPathParserContextPtr
+xmlXPathCompParserContext(xmlXPathCompExprPtr comp, xmlXPathContextPtr ctxt) {
+    xmlXPathParserContextPtr ret;
+
+    ret = (xmlXPathParserContextPtr) xmlMalloc(sizeof(xmlXPathParserContext));
+    if (ret == NULL) {
+        xmlXPathErrMemory(ctxt, "creating evaluation context\n");
+	return(NULL);
+    }
+    memset(ret, 0 , (size_t) sizeof(xmlXPathParserContext));
+
+    /* Allocate the value stack */
+    ret->valueTab = (xmlXPathObjectPtr *) 
+                     xmlMalloc(10 * sizeof(xmlXPathObjectPtr));
+    if (ret->valueTab == NULL) {
+	xmlFree(ret);
+	xmlXPathErrMemory(ctxt, "creating evaluation context\n");
+	return(NULL);
+    }
+    ret->valueNr = 0;
+    ret->valueMax = 10;
+    ret->value = NULL;
+
+    ret->context = ctxt;
+    ret->comp = comp;
+
+    return(ret);
+}
+
+/**
+ * xmlXPathFreeParserContext:
+ * @ctxt:  the context to free
+ *
+ * Free up an xmlXPathParserContext
+ */
+void
+xmlXPathFreeParserContext(xmlXPathParserContextPtr ctxt) {
+    if (ctxt->valueTab != NULL) {
+        xmlFree(ctxt->valueTab);
+    }
+    if (ctxt->comp)
+	xmlXPathFreeCompExpr(ctxt->comp);
+    xmlFree(ctxt);
+}
+
+/************************************************************************
+ *									*
+ *		The implicit core function library			*
+ *									*
+ ************************************************************************/
+
+/**
+ * xmlXPathNodeValHash:
+ * @node:  a node pointer
+ *
+ * Function computing the beginning of the string value of the node,
+ * used to speed up comparisons
+ *
+ * Returns an int usable as a hash
+ */
+static unsigned int
+xmlXPathNodeValHash(xmlNodePtr node) {
+    int len = 2;
+    const xmlChar * string = NULL;
+    xmlNodePtr tmp = NULL;
+    unsigned int ret = 0;
+
+    if (node == NULL)
+	return(0);
+
+    if (node->type == XML_DOCUMENT_NODE) {
+	tmp = xmlDocGetRootElement((xmlDocPtr) node);
+	if (tmp == NULL)
+	    node = node->children;
+	else
+	    node = tmp;
+
+	if (node == NULL)
+	    return(0);
+    }
+
+    switch (node->type) {
+	case XML_COMMENT_NODE:
+	case XML_PI_NODE:
+	case XML_CDATA_SECTION_NODE:
+	case XML_TEXT_NODE:
+	    string = node->content;
+	    if (string == NULL)
+		return(0);
+	    if (string[0] == 0)
+		return(0);
+	    return(((unsigned int) string[0]) +
+		   (((unsigned int) string[1]) << 8));
+	case XML_NAMESPACE_DECL:
+	    string = ((xmlNsPtr)node)->href;
+	    if (string == NULL)
+		return(0);
+	    if (string[0] == 0)
+		return(0);
+	    return(((unsigned int) string[0]) +
+		   (((unsigned int) string[1]) << 8));
+	case XML_ATTRIBUTE_NODE:
+	    tmp = ((xmlAttrPtr) node)->children;
+	    break;
+	case XML_ELEMENT_NODE:
+	    tmp = node->children;
+	    break;
+	default:
+	    return(0);
+    }
+    while (tmp != NULL) {
+	switch (tmp->type) {
+	    case XML_COMMENT_NODE:
+	    case XML_PI_NODE:
+	    case XML_CDATA_SECTION_NODE:
+	    case XML_TEXT_NODE:
+		string = tmp->content;
+		break;
+	    case XML_NAMESPACE_DECL:
+		string = ((xmlNsPtr)tmp)->href;
+		break;
+	    default:
+		break;
+	}
+	if ((string != NULL) && (string[0] != 0)) {
+	    if (len == 1) {
+		return(ret + (((unsigned int) string[0]) << 8));
+	    }
+	    if (string[1] == 0) {
+		len = 1;
+		ret = (unsigned int) string[0];
+	    } else {
+		return(((unsigned int) string[0]) +
+		       (((unsigned int) string[1]) << 8));
+	    }
+	}
+	/*
+	 * Skip to next node
+	 */
+	if ((tmp->children != NULL) && (tmp->type != XML_DTD_NODE)) {
+	    if (tmp->children->type != XML_ENTITY_DECL) {
+		tmp = tmp->children;
+		continue;
+	    }
+	}
+	if (tmp == node)
+	    break;
+
+	if (tmp->next != NULL) {
+	    tmp = tmp->next;
+	    continue;
+	}
+	
+	do {
+	    tmp = tmp->parent;
+	    if (tmp == NULL)
+		break;
+	    if (tmp == node) {
+		tmp = NULL;
+		break;
+	    }
+	    if (tmp->next != NULL) {
+		tmp = tmp->next;
+		break;
+	    }
+	} while (tmp != NULL);
+    }
+    return(ret);
+}
+
+/**
+ * xmlXPathStringHash:
+ * @string:  a string
+ *
+ * Function computing the beginning of the string value of the node,
+ * used to speed up comparisons
+ *
+ * Returns an int usable as a hash
+ */
+static unsigned int
+xmlXPathStringHash(const xmlChar * string) {
+    if (string == NULL)
+	return((unsigned int) 0);
+    if (string[0] == 0)
+	return(0);
+    return(((unsigned int) string[0]) +
+	   (((unsigned int) string[1]) << 8));
+}
+
+/**
+ * xmlXPathCompareNodeSetFloat:
+ * @ctxt:  the XPath Parser context
+ * @inf:  less than (1) or greater than (0)
+ * @strict:  is the comparison strict
+ * @arg:  the node set
+ * @f:  the value
+ *
+ * Implement the compare operation between a nodeset and a number
+ *     @ns < @val    (1, 1, ...
+ *     @ns <= @val   (1, 0, ...
+ *     @ns > @val    (0, 1, ...
+ *     @ns >= @val   (0, 0, ...
+ *
+ * If one object to be compared is a node-set and the other is a number,
+ * then the comparison will be true if and only if there is a node in the
+ * node-set such that the result of performing the comparison on the number
+ * to be compared and on the result of converting the string-value of that
+ * node to a number using the number function is true.
+ *
+ * Returns 0 or 1 depending on the results of the test.
+ */
+static int
+xmlXPathCompareNodeSetFloat(xmlXPathParserContextPtr ctxt, int inf, int strict,
+	                    xmlXPathObjectPtr arg, xmlXPathObjectPtr f) {
+    int i, ret = 0;
+    xmlNodeSetPtr ns;
+    xmlChar *str2;
+
+    if ((f == NULL) || (arg == NULL) ||
+	((arg->type != XPATH_NODESET) && (arg->type != XPATH_XSLT_TREE))) {
+	xmlXPathFreeObject(arg);
+	xmlXPathFreeObject(f);
+        return(0);
+    }
+    ns = arg->nodesetval;
+    if (ns != NULL) {
+	for (i = 0;i < ns->nodeNr;i++) {
+	     str2 = xmlXPathCastNodeToString(ns->nodeTab[i]);
+	     if (str2 != NULL) {
+		 valuePush(ctxt,
+			   xmlXPathNewString(str2));
+		 xmlFree(str2);
+		 xmlXPathNumberFunction(ctxt, 1);
+		 valuePush(ctxt, xmlXPathObjectCopy(f));
+		 ret = xmlXPathCompareValues(ctxt, inf, strict);
+		 if (ret)
+		     break;
+	     }
+	}
+    }
+    xmlXPathFreeObject(arg);
+    xmlXPathFreeObject(f);
+    return(ret);
+}
+
+/**
+ * xmlXPathCompareNodeSetString:
+ * @ctxt:  the XPath Parser context
+ * @inf:  less than (1) or greater than (0)
+ * @strict:  is the comparison strict
+ * @arg:  the node set
+ * @s:  the value
+ *
+ * Implement the compare operation between a nodeset and a string
+ *     @ns < @val    (1, 1, ...
+ *     @ns <= @val   (1, 0, ...
+ *     @ns > @val    (0, 1, ...
+ *     @ns >= @val   (0, 0, ...
+ *
+ * If one object to be compared is a node-set and the other is a string,
+ * then the comparison will be true if and only if there is a node in
+ * the node-set such that the result of performing the comparison on the
+ * string-value of the node and the other string is true.
+ *
+ * Returns 0 or 1 depending on the results of the test.
+ */
+static int
+xmlXPathCompareNodeSetString(xmlXPathParserContextPtr ctxt, int inf, int strict,
+	                    xmlXPathObjectPtr arg, xmlXPathObjectPtr s) {
+    int i, ret = 0;
+    xmlNodeSetPtr ns;
+    xmlChar *str2;
+
+    if ((s == NULL) || (arg == NULL) ||
+	((arg->type != XPATH_NODESET) && (arg->type != XPATH_XSLT_TREE))) {
+	xmlXPathFreeObject(arg);
+	xmlXPathFreeObject(s);
+        return(0);
+    }
+    ns = arg->nodesetval;
+    if (ns != NULL) {
+	for (i = 0;i < ns->nodeNr;i++) {
+	     str2 = xmlXPathCastNodeToString(ns->nodeTab[i]);
+	     if (str2 != NULL) {
+		 valuePush(ctxt,
+			   xmlXPathNewString(str2));
+		 xmlFree(str2);
+		 valuePush(ctxt, xmlXPathObjectCopy(s));
+		 ret = xmlXPathCompareValues(ctxt, inf, strict);
+		 if (ret)
+		     break;
+	     }
+	}
+    }
+    xmlXPathFreeObject(arg);
+    xmlXPathFreeObject(s);
+    return(ret);
+}
+
+/**
+ * xmlXPathCompareNodeSets:
+ * @inf:  less than (1) or greater than (0)
+ * @strict:  is the comparison strict
+ * @arg1:  the first node set object
+ * @arg2:  the second node set object
+ *
+ * Implement the compare operation on nodesets:
+ *
+ * If both objects to be compared are node-sets, then the comparison
+ * will be true if and only if there is a node in the first node-set
+ * and a node in the second node-set such that the result of performing
+ * the comparison on the string-values of the two nodes is true. 
+ * ....
+ * When neither object to be compared is a node-set and the operator
+ * is <=, <, >= or >, then the objects are compared by converting both
+ * objects to numbers and comparing the numbers according to IEEE 754.
+ * ....
+ * The number function converts its argument to a number as follows:
+ *  - a string that consists of optional whitespace followed by an
+ *    optional minus sign followed by a Number followed by whitespace
+ *    is converted to the IEEE 754 number that is nearest (according
+ *    to the IEEE 754 round-to-nearest rule) to the mathematical value
+ *    represented by the string; any other string is converted to NaN
+ *
+ * Conclusion all nodes need to be converted first to their string value
+ * and then the comparison must be done when possible 
+ */
+static int
+xmlXPathCompareNodeSets(int inf, int strict,
+	                xmlXPathObjectPtr arg1, xmlXPathObjectPtr arg2) {
+    int i, j, init = 0;
+    double val1;
+    double *values2;
+    int ret = 0;
+    xmlNodeSetPtr ns1;
+    xmlNodeSetPtr ns2;
+
+    if ((arg1 == NULL) ||
+	((arg1->type != XPATH_NODESET) && (arg1->type != XPATH_XSLT_TREE))) {
+	xmlXPathFreeObject(arg2);
+        return(0);
+    }
+    if ((arg2 == NULL) ||
+	((arg2->type != XPATH_NODESET) && (arg2->type != XPATH_XSLT_TREE))) {
+	xmlXPathFreeObject(arg1);
+	xmlXPathFreeObject(arg2);
+        return(0);
+    }
+
+    ns1 = arg1->nodesetval;
+    ns2 = arg2->nodesetval;
+
+    if ((ns1 == NULL) || (ns1->nodeNr <= 0)) {
+	xmlXPathFreeObject(arg1);
+	xmlXPathFreeObject(arg2);
+	return(0);
+    }
+    if ((ns2 == NULL) || (ns2->nodeNr <= 0)) {
+	xmlXPathFreeObject(arg1);
+	xmlXPathFreeObject(arg2);
+	return(0);
+    }
+
+    values2 = (double *) xmlMalloc(ns2->nodeNr * sizeof(double));
+    if (values2 == NULL) {
+        xmlXPathErrMemory(NULL, "comparing nodesets\n");
+	xmlXPathFreeObject(arg1);
+	xmlXPathFreeObject(arg2);
+	return(0);
+    }
+    for (i = 0;i < ns1->nodeNr;i++) {
+	val1 = xmlXPathCastNodeToNumber(ns1->nodeTab[i]);
+	if (xmlXPathIsNaN(val1))
+	    continue;
+	for (j = 0;j < ns2->nodeNr;j++) {
+	    if (init == 0) {
+		values2[j] = xmlXPathCastNodeToNumber(ns2->nodeTab[j]);
+	    }
+	    if (xmlXPathIsNaN(values2[j]))
+		continue;
+	    if (inf && strict) 
+		ret = (val1 < values2[j]);
+	    else if (inf && !strict)
+		ret = (val1 <= values2[j]);
+	    else if (!inf && strict)
+		ret = (val1 > values2[j]);
+	    else if (!inf && !strict)
+		ret = (val1 >= values2[j]);
+	    if (ret)
+		break;
+	}
+	if (ret)
+	    break;
+	init = 1;
+    }
+    xmlFree(values2);
+    xmlXPathFreeObject(arg1);
+    xmlXPathFreeObject(arg2);
+    return(ret);
+}
+
+/**
+ * xmlXPathCompareNodeSetValue:
+ * @ctxt:  the XPath Parser context
+ * @inf:  less than (1) or greater than (0)
+ * @strict:  is the comparison strict
+ * @arg:  the node set
+ * @val:  the value
+ *
+ * Implement the compare operation between a nodeset and a value
+ *     @ns < @val    (1, 1, ...
+ *     @ns <= @val   (1, 0, ...
+ *     @ns > @val    (0, 1, ...
+ *     @ns >= @val   (0, 0, ...
+ *
+ * If one object to be compared is a node-set and the other is a boolean,
+ * then the comparison will be true if and only if the result of performing
+ * the comparison on the boolean and on the result of converting
+ * the node-set to a boolean using the boolean function is true.
+ *
+ * Returns 0 or 1 depending on the results of the test.
+ */
+static int
+xmlXPathCompareNodeSetValue(xmlXPathParserContextPtr ctxt, int inf, int strict,
+	                    xmlXPathObjectPtr arg, xmlXPathObjectPtr val) {
+    if ((val == NULL) || (arg == NULL) ||
+	((arg->type != XPATH_NODESET) && (arg->type != XPATH_XSLT_TREE)))
+        return(0);
+
+    switch(val->type) {
+        case XPATH_NUMBER:
+	    return(xmlXPathCompareNodeSetFloat(ctxt, inf, strict, arg, val));
+        case XPATH_NODESET:
+        case XPATH_XSLT_TREE:
+	    return(xmlXPathCompareNodeSets(inf, strict, arg, val));
+        case XPATH_STRING:
+	    return(xmlXPathCompareNodeSetString(ctxt, inf, strict, arg, val));
+        case XPATH_BOOLEAN:
+	    valuePush(ctxt, arg);
+	    xmlXPathBooleanFunction(ctxt, 1);
+	    valuePush(ctxt, val);
+	    return(xmlXPathCompareValues(ctxt, inf, strict));
+	default:
+	    TODO
+    }
+    return(0);
+}
+
+/**
+ * xmlXPathEqualNodeSetString:
+ * @arg:  the nodeset object argument
+ * @str:  the string to compare to.
+ * @neq:  flag to show whether for '=' (0) or '!=' (1)
+ *
+ * Implement the equal operation on XPath objects content: @arg1 == @arg2
+ * If one object to be compared is a node-set and the other is a string,
+ * then the comparison will be true if and only if there is a node in
+ * the node-set such that the result of performing the comparison on the
+ * string-value of the node and the other string is true.
+ *
+ * Returns 0 or 1 depending on the results of the test.
+ */
+static int
+xmlXPathEqualNodeSetString(xmlXPathObjectPtr arg, const xmlChar * str, int neq)
+{
+    int i;
+    xmlNodeSetPtr ns;
+    xmlChar *str2;
+    unsigned int hash;
+
+    if ((str == NULL) || (arg == NULL) ||
+        ((arg->type != XPATH_NODESET) && (arg->type != XPATH_XSLT_TREE)))
+        return (0);
+    ns = arg->nodesetval;
+    /*
+     * A NULL nodeset compared with a string is always false
+     * (since there is no node equal, and no node not equal)
+     */
+    if ((ns == NULL) || (ns->nodeNr <= 0) )
+        return (0);
+    hash = xmlXPathStringHash(str);
+    for (i = 0; i < ns->nodeNr; i++) {
+        if (xmlXPathNodeValHash(ns->nodeTab[i]) == hash) {
+            str2 = xmlNodeGetContent(ns->nodeTab[i]);
+            if ((str2 != NULL) && (xmlStrEqual(str, str2))) {
+                xmlFree(str2);
+		if (neq)
+		    continue;
+                return (1);
+	    } else if ((str2 == NULL) && (xmlStrEqual(str, BAD_CAST ""))) {
+		if (neq)
+		    continue;
+                return (1);
+            } else if (neq) {
+		if (str2 != NULL)
+		    xmlFree(str2);
+		return (1);
+	    }
+            if (str2 != NULL)
+                xmlFree(str2);
+        } else if (neq)
+	    return (1);
+    }
+    return (0);
+}
+
+/**
+ * xmlXPathEqualNodeSetFloat:
+ * @arg:  the nodeset object argument
+ * @f:  the float to compare to
+ * @neq:  flag to show whether to compare '=' (0) or '!=' (1)
+ *
+ * Implement the equal operation on XPath objects content: @arg1 == @arg2
+ * If one object to be compared is a node-set and the other is a number,
+ * then the comparison will be true if and only if there is a node in
+ * the node-set such that the result of performing the comparison on the
+ * number to be compared and on the result of converting the string-value
+ * of that node to a number using the number function is true.
+ *
+ * Returns 0 or 1 depending on the results of the test.
+ */
+static int
+xmlXPathEqualNodeSetFloat(xmlXPathParserContextPtr ctxt,
+    xmlXPathObjectPtr arg, double f, int neq) {
+  int i, ret=0;
+  xmlNodeSetPtr ns;
+  xmlChar *str2;
+  xmlXPathObjectPtr val;
+  double v;
+
+    if ((arg == NULL) ||
+	((arg->type != XPATH_NODESET) && (arg->type != XPATH_XSLT_TREE)))
+        return(0);
+
+    ns = arg->nodesetval;
+    if (ns != NULL) {
+	for (i=0;i<ns->nodeNr;i++) {
+	    str2 = xmlXPathCastNodeToString(ns->nodeTab[i]);
+	    if (str2 != NULL) {
+		valuePush(ctxt, xmlXPathNewString(str2));
+		xmlFree(str2);
+		xmlXPathNumberFunction(ctxt, 1);
+		val = valuePop(ctxt);
+		v = val->floatval;
+		xmlXPathFreeObject(val);
+		if (!xmlXPathIsNaN(v)) {
+		    if ((!neq) && (v==f)) {
+			ret = 1;
+			break;
+		    } else if ((neq) && (v!=f)) {
+			ret = 1;
+			break;
+		    }
+		}
+	    }
+	}
+    }
+
+    return(ret);
+}
+
+
+/**
+ * xmlXPathEqualNodeSets:
+ * @arg1:  first nodeset object argument
+ * @arg2:  second nodeset object argument
+ * @neq:   flag to show whether to test '=' (0) or '!=' (1)
+ *
+ * Implement the equal / not equal operation on XPath nodesets:
+ * @arg1 == @arg2  or  @arg1 != @arg2
+ * If both objects to be compared are node-sets, then the comparison
+ * will be true if and only if there is a node in the first node-set and
+ * a node in the second node-set such that the result of performing the
+ * comparison on the string-values of the two nodes is true.
+ *
+ * (needless to say, this is a costly operation)
+ *
+ * Returns 0 or 1 depending on the results of the test.
+ */
+static int
+xmlXPathEqualNodeSets(xmlXPathObjectPtr arg1, xmlXPathObjectPtr arg2, int neq) {
+    int i, j;
+    unsigned int *hashs1;
+    unsigned int *hashs2;
+    xmlChar **values1;
+    xmlChar **values2;
+    int ret = 0;
+    xmlNodeSetPtr ns1;
+    xmlNodeSetPtr ns2;
+
+    if ((arg1 == NULL) ||
+	((arg1->type != XPATH_NODESET) && (arg1->type != XPATH_XSLT_TREE)))
+        return(0);
+    if ((arg2 == NULL) ||
+	((arg2->type != XPATH_NODESET) && (arg2->type != XPATH_XSLT_TREE)))
+        return(0);
+
+    ns1 = arg1->nodesetval;
+    ns2 = arg2->nodesetval;
+
+    if ((ns1 == NULL) || (ns1->nodeNr <= 0))
+	return(0);
+    if ((ns2 == NULL) || (ns2->nodeNr <= 0))
+	return(0);
+
+    /*
+     * for equal, check if there is a node pertaining to both sets
+     */
+    if (neq == 0)
+	for (i = 0;i < ns1->nodeNr;i++)
+	    for (j = 0;j < ns2->nodeNr;j++)
+		if (ns1->nodeTab[i] == ns2->nodeTab[j])
+		    return(1);
+
+    values1 = (xmlChar **) xmlMalloc(ns1->nodeNr * sizeof(xmlChar *));
+    if (values1 == NULL) {
+        xmlXPathErrMemory(NULL, "comparing nodesets\n");
+	return(0);
+    }
+    hashs1 = (unsigned int *) xmlMalloc(ns1->nodeNr * sizeof(unsigned int));
+    if (hashs1 == NULL) {
+        xmlXPathErrMemory(NULL, "comparing nodesets\n");
+	xmlFree(values1);
+	return(0);
+    }
+    memset(values1, 0, ns1->nodeNr * sizeof(xmlChar *));
+    values2 = (xmlChar **) xmlMalloc(ns2->nodeNr * sizeof(xmlChar *));
+    if (values2 == NULL) {
+        xmlXPathErrMemory(NULL, "comparing nodesets\n");
+	xmlFree(hashs1);
+	xmlFree(values1);
+	return(0);
+    }
+    hashs2 = (unsigned int *) xmlMalloc(ns2->nodeNr * sizeof(unsigned int));
+    if (hashs2 == NULL) {
+        xmlXPathErrMemory(NULL, "comparing nodesets\n");
+	xmlFree(hashs1);
+	xmlFree(values1);
+	xmlFree(values2);
+	return(0);
+    }
+    memset(values2, 0, ns2->nodeNr * sizeof(xmlChar *));
+    for (i = 0;i < ns1->nodeNr;i++) {
+	hashs1[i] = xmlXPathNodeValHash(ns1->nodeTab[i]);
+	for (j = 0;j < ns2->nodeNr;j++) {
+	    if (i == 0)
+		hashs2[j] = xmlXPathNodeValHash(ns2->nodeTab[j]);
+	    if (hashs1[i] != hashs2[j]) {
+		if (neq) {
+		    ret = 1;
+		    break;
+		}
+	    }
+	    else {
+		if (values1[i] == NULL)
+		    values1[i] = xmlNodeGetContent(ns1->nodeTab[i]);
+		if (values2[j] == NULL)
+		    values2[j] = xmlNodeGetContent(ns2->nodeTab[j]);
+		ret = xmlStrEqual(values1[i], values2[j]) ^ neq;
+		if (ret)
+		    break;
+	    }
+	}
+	if (ret)
+	    break;
+    }
+    for (i = 0;i < ns1->nodeNr;i++)
+	if (values1[i] != NULL)
+	    xmlFree(values1[i]);
+    for (j = 0;j < ns2->nodeNr;j++)
+	if (values2[j] != NULL)
+	    xmlFree(values2[j]);
+    xmlFree(values1);
+    xmlFree(values2);
+    xmlFree(hashs1);
+    xmlFree(hashs2);
+    return(ret);
+}
+
+static int
+xmlXPathEqualValuesCommon(xmlXPathParserContextPtr ctxt,
+  xmlXPathObjectPtr arg1, xmlXPathObjectPtr arg2) {
+    int ret = 0;
+    /*
+     *At this point we are assured neither arg1 nor arg2
+     *is a nodeset, so we can just pick the appropriate routine.
+     */
+    switch (arg1->type) {
+        case XPATH_UNDEFINED:
+#ifdef DEBUG_EXPR
+	    xmlGenericError(xmlGenericErrorContext,
+		    "Equal: undefined\n");
+#endif
+	    break;
+        case XPATH_BOOLEAN:
+	    switch (arg2->type) {
+	        case XPATH_UNDEFINED:
+#ifdef DEBUG_EXPR
+		    xmlGenericError(xmlGenericErrorContext,
+			    "Equal: undefined\n");
+#endif
+		    break;
+		case XPATH_BOOLEAN:
+#ifdef DEBUG_EXPR
+		    xmlGenericError(xmlGenericErrorContext,
+			    "Equal: %d boolean %d \n",
+			    arg1->boolval, arg2->boolval);
+#endif
+		    ret = (arg1->boolval == arg2->boolval);
+		    break;
+		case XPATH_NUMBER:
+		    ret = (arg1->boolval ==
+			   xmlXPathCastNumberToBoolean(arg2->floatval));
+		    break;
+		case XPATH_STRING:
+		    if ((arg2->stringval == NULL) ||
+			(arg2->stringval[0] == 0)) ret = 0;
+		    else 
+			ret = 1;
+		    ret = (arg1->boolval == ret);
+		    break;
+		case XPATH_USERS:
+		case XPATH_POINT:
+		case XPATH_RANGE:
+		case XPATH_LOCATIONSET:
+		    TODO
+		    break;
+		case XPATH_NODESET:
+		case XPATH_XSLT_TREE:
+		    break;
+	    }
+	    break;
+        case XPATH_NUMBER:
+	    switch (arg2->type) {
+	        case XPATH_UNDEFINED:
+#ifdef DEBUG_EXPR
+		    xmlGenericError(xmlGenericErrorContext,
+			    "Equal: undefined\n");
+#endif
+		    break;
+		case XPATH_BOOLEAN:
+		    ret = (arg2->boolval==
+			   xmlXPathCastNumberToBoolean(arg1->floatval));
+		    break;
+		case XPATH_STRING:
+		    valuePush(ctxt, arg2);
+		    xmlXPathNumberFunction(ctxt, 1);
+		    arg2 = valuePop(ctxt);
+		    /* no break on purpose */
+		case XPATH_NUMBER:
+		    /* Hand check NaN and Infinity equalities */
+		    if (xmlXPathIsNaN(arg1->floatval) ||
+		    	    xmlXPathIsNaN(arg2->floatval)) {
+		        ret = 0;
+		    } else if (xmlXPathIsInf(arg1->floatval) == 1) {
+		        if (xmlXPathIsInf(arg2->floatval) == 1)
+			    ret = 1;
+			else
+			    ret = 0;
+		    } else if (xmlXPathIsInf(arg1->floatval) == -1) {
+			if (xmlXPathIsInf(arg2->floatval) == -1)
+			    ret = 1;
+			else
+			    ret = 0;
+		    } else if (xmlXPathIsInf(arg2->floatval) == 1) {
+			if (xmlXPathIsInf(arg1->floatval) == 1)
+			    ret = 1;
+			else
+			    ret = 0;
+		    } else if (xmlXPathIsInf(arg2->floatval) == -1) {
+			if (xmlXPathIsInf(arg1->floatval) == -1)
+			    ret = 1;
+			else
+			    ret = 0;
+		    } else {
+		        ret = (arg1->floatval == arg2->floatval);
+		    }
+		    break;
+		case XPATH_USERS:
+		case XPATH_POINT:
+		case XPATH_RANGE:
+		case XPATH_LOCATIONSET:
+		    TODO
+		    break;
+		case XPATH_NODESET:
+		case XPATH_XSLT_TREE:
+		    break;
+	    }
+	    break;
+        case XPATH_STRING:
+	    switch (arg2->type) {
+	        case XPATH_UNDEFINED:
+#ifdef DEBUG_EXPR
+		    xmlGenericError(xmlGenericErrorContext,
+			    "Equal: undefined\n");
+#endif
+		    break;
+		case XPATH_BOOLEAN:
+		    if ((arg1->stringval == NULL) ||
+			(arg1->stringval[0] == 0)) ret = 0;
+		    else 
+			ret = 1;
+		    ret = (arg2->boolval == ret);
+		    break;
+		case XPATH_STRING:
+		    ret = xmlStrEqual(arg1->stringval, arg2->stringval);
+		    break;
+		case XPATH_NUMBER:
+		    valuePush(ctxt, arg1);
+		    xmlXPathNumberFunction(ctxt, 1);
+		    arg1 = valuePop(ctxt);
+		    /* Hand check NaN and Infinity equalities */
+		    if (xmlXPathIsNaN(arg1->floatval) ||
+		    	    xmlXPathIsNaN(arg2->floatval)) {
+		        ret = 0;
+		    } else if (xmlXPathIsInf(arg1->floatval) == 1) {
+			if (xmlXPathIsInf(arg2->floatval) == 1)
+			    ret = 1;
+			else
+			    ret = 0;
+		    } else if (xmlXPathIsInf(arg1->floatval) == -1) {
+			if (xmlXPathIsInf(arg2->floatval) == -1)
+			    ret = 1;
+			else
+			    ret = 0;
+		    } else if (xmlXPathIsInf(arg2->floatval) == 1) {
+			if (xmlXPathIsInf(arg1->floatval) == 1)
+			    ret = 1;
+			else
+			    ret = 0;
+		    } else if (xmlXPathIsInf(arg2->floatval) == -1) {
+			if (xmlXPathIsInf(arg1->floatval) == -1)
+			    ret = 1;
+			else
+			    ret = 0;
+		    } else {
+		        ret = (arg1->floatval == arg2->floatval);
+		    }
+		    break;
+		case XPATH_USERS:
+		case XPATH_POINT:
+		case XPATH_RANGE:
+		case XPATH_LOCATIONSET:
+		    TODO
+		    break;
+		case XPATH_NODESET:
+		case XPATH_XSLT_TREE:
+		    break;
+	    }
+	    break;
+        case XPATH_USERS:
+	case XPATH_POINT:
+	case XPATH_RANGE:
+	case XPATH_LOCATIONSET:
+	    TODO
+	    break;
+	case XPATH_NODESET:
+	case XPATH_XSLT_TREE:
+	    break;
+    }
+    xmlXPathFreeObject(arg1);
+    xmlXPathFreeObject(arg2);
+    return(ret);
+}
+
+/**
+ * xmlXPathEqualValues:
+ * @ctxt:  the XPath Parser context
+ *
+ * Implement the equal operation on XPath objects content: @arg1 == @arg2
+ *
+ * Returns 0 or 1 depending on the results of the test.
+ */
+int
+xmlXPathEqualValues(xmlXPathParserContextPtr ctxt) {
+    xmlXPathObjectPtr arg1, arg2, argtmp;
+    int ret = 0;
+
+    arg2 = valuePop(ctxt); 
+    arg1 = valuePop(ctxt);
+    if ((arg1 == NULL) || (arg2 == NULL)) {
+	if (arg1 != NULL)
+	    xmlXPathFreeObject(arg1);
+	else
+	    xmlXPathFreeObject(arg2);
+	XP_ERROR0(XPATH_INVALID_OPERAND);
+    }
+
+    if (arg1 == arg2) {
+#ifdef DEBUG_EXPR
+        xmlGenericError(xmlGenericErrorContext,
+		"Equal: by pointer\n");
+#endif
+        return(1);
+    }
+
+    /*
+     *If either argument is a nodeset, it's a 'special case'
+     */
+    if ((arg2->type == XPATH_NODESET) || (arg2->type == XPATH_XSLT_TREE) ||
+      (arg1->type == XPATH_NODESET) || (arg1->type == XPATH_XSLT_TREE)) {
+	/*
+	 *Hack it to assure arg1 is the nodeset
+	 */
+	if ((arg1->type != XPATH_NODESET) && (arg1->type != XPATH_XSLT_TREE)) {
+		argtmp = arg2;
+		arg2 = arg1;
+		arg1 = argtmp;
+	}
+	switch (arg2->type) {
+	    case XPATH_UNDEFINED:
+#ifdef DEBUG_EXPR
+		xmlGenericError(xmlGenericErrorContext,
+			"Equal: undefined\n");
+#endif
+		break;
+	    case XPATH_NODESET:
+	    case XPATH_XSLT_TREE:
+		ret = xmlXPathEqualNodeSets(arg1, arg2, 0);
+		break;
+	    case XPATH_BOOLEAN:
+		if ((arg1->nodesetval == NULL) ||
+		  (arg1->nodesetval->nodeNr == 0)) ret = 0;
+		else 
+		    ret = 1;
+		ret = (ret == arg2->boolval);
+		break;
+	    case XPATH_NUMBER:
+		ret = xmlXPathEqualNodeSetFloat(ctxt, arg1, arg2->floatval, 0);
+		break;
+	    case XPATH_STRING:
+		ret = xmlXPathEqualNodeSetString(arg1, arg2->stringval, 0);
+		break;
+	    case XPATH_USERS:
+	    case XPATH_POINT:
+	    case XPATH_RANGE:
+	    case XPATH_LOCATIONSET:
+		TODO
+		break;
+	}
+	xmlXPathFreeObject(arg1);
+	xmlXPathFreeObject(arg2);
+	return(ret);
+    }
+
+    return (xmlXPathEqualValuesCommon(ctxt, arg1, arg2));
+}
+
+/**
+ * xmlXPathNotEqualValues:
+ * @ctxt:  the XPath Parser context
+ *
+ * Implement the equal operation on XPath objects content: @arg1 == @arg2
+ *
+ * Returns 0 or 1 depending on the results of the test.
+ */
+int
+xmlXPathNotEqualValues(xmlXPathParserContextPtr ctxt) {
+    xmlXPathObjectPtr arg1, arg2, argtmp;
+    int ret = 0;
+
+    arg2 = valuePop(ctxt); 
+    arg1 = valuePop(ctxt);
+    if ((arg1 == NULL) || (arg2 == NULL)) {
+	if (arg1 != NULL)
+	    xmlXPathFreeObject(arg1);
+	else
+	    xmlXPathFreeObject(arg2);
+	XP_ERROR0(XPATH_INVALID_OPERAND);
+    }
+
+    if (arg1 == arg2) {
+#ifdef DEBUG_EXPR
+        xmlGenericError(xmlGenericErrorContext,
+		"NotEqual: by pointer\n");
+#endif
+        return(0);
+    }
+
+    /*
+     *If either argument is a nodeset, it's a 'special case'
+     */
+    if ((arg2->type == XPATH_NODESET) || (arg2->type == XPATH_XSLT_TREE) ||
+      (arg1->type == XPATH_NODESET) || (arg1->type == XPATH_XSLT_TREE)) {
+	/*
+	 *Hack it to assure arg1 is the nodeset
+	 */
+	if ((arg1->type != XPATH_NODESET) && (arg1->type != XPATH_XSLT_TREE)) {
+		argtmp = arg2;
+		arg2 = arg1;
+		arg1 = argtmp;
+	}
+	switch (arg2->type) {
+	    case XPATH_UNDEFINED:
+#ifdef DEBUG_EXPR
+		xmlGenericError(xmlGenericErrorContext,
+			"NotEqual: undefined\n");
+#endif
+		break;
+	    case XPATH_NODESET:
+	    case XPATH_XSLT_TREE:
+		ret = xmlXPathEqualNodeSets(arg1, arg2, 1);
+		break;
+	    case XPATH_BOOLEAN:
+		if ((arg1->nodesetval == NULL) ||
+		  (arg1->nodesetval->nodeNr == 0)) ret = 0;
+		else 
+		    ret = 1;
+		ret = (ret != arg2->boolval);
+		break;
+	    case XPATH_NUMBER:
+		ret = xmlXPathEqualNodeSetFloat(ctxt, arg1, arg2->floatval, 1);
+		break;
+	    case XPATH_STRING:
+		ret = xmlXPathEqualNodeSetString(arg1, arg2->stringval,1);
+		break;
+	    case XPATH_USERS:
+	    case XPATH_POINT:
+	    case XPATH_RANGE:
+	    case XPATH_LOCATIONSET:
+		TODO
+		break;
+	}
+	xmlXPathFreeObject(arg1);
+	xmlXPathFreeObject(arg2);
+	return(ret);
+    }
+
+    return (!xmlXPathEqualValuesCommon(ctxt, arg1, arg2));
+}
+
+/**
+ * xmlXPathCompareValues:
+ * @ctxt:  the XPath Parser context
+ * @inf:  less than (1) or greater than (0)
+ * @strict:  is the comparison strict
+ *
+ * Implement the compare operation on XPath objects: 
+ *     @arg1 < @arg2    (1, 1, ...
+ *     @arg1 <= @arg2   (1, 0, ...
+ *     @arg1 > @arg2    (0, 1, ...
+ *     @arg1 >= @arg2   (0, 0, ...
+ *
+ * When neither object to be compared is a node-set and the operator is
+ * <=, <, >=, >, then the objects are compared by converted both objects
+ * to numbers and comparing the numbers according to IEEE 754. The <
+ * comparison will be true if and only if the first number is less than the
+ * second number. The <= comparison will be true if and only if the first
+ * number is less than or equal to the second number. The > comparison
+ * will be true if and only if the first number is greater than the second
+ * number. The >= comparison will be true if and only if the first number
+ * is greater than or equal to the second number.
+ *
+ * Returns 1 if the comparison succeeded, 0 if it failed
+ */
+int
+xmlXPathCompareValues(xmlXPathParserContextPtr ctxt, int inf, int strict) {
+    int ret = 0, arg1i = 0, arg2i = 0;
+    xmlXPathObjectPtr arg1, arg2;
+
+    arg2 = valuePop(ctxt); 
+    arg1 = valuePop(ctxt);
+    if ((arg1 == NULL) || (arg2 == NULL)) {
+	if (arg1 != NULL)
+	    xmlXPathFreeObject(arg1);
+	else
+	    xmlXPathFreeObject(arg2);
+	XP_ERROR0(XPATH_INVALID_OPERAND);
+    }
+
+    if ((arg2->type == XPATH_NODESET) || (arg2->type == XPATH_XSLT_TREE) ||
+      (arg1->type == XPATH_NODESET) || (arg1->type == XPATH_XSLT_TREE)) {
+	if (((arg2->type == XPATH_NODESET) || (arg2->type == XPATH_XSLT_TREE)) &&
+	  ((arg1->type == XPATH_NODESET) || (arg1->type == XPATH_XSLT_TREE))){
+	    ret = xmlXPathCompareNodeSets(inf, strict, arg1, arg2);
+	} else {
+	    if ((arg1->type == XPATH_NODESET) || (arg1->type == XPATH_XSLT_TREE)) {
+		ret = xmlXPathCompareNodeSetValue(ctxt, inf, strict,
+			                          arg1, arg2);
+	    } else {
+		ret = xmlXPathCompareNodeSetValue(ctxt, !inf, strict,
+			                          arg2, arg1);
+	    }
+	}
+	return(ret);
+    }
+
+    if (arg1->type != XPATH_NUMBER) {
+	valuePush(ctxt, arg1);
+	xmlXPathNumberFunction(ctxt, 1);
+	arg1 = valuePop(ctxt);
+    }
+    if (arg1->type != XPATH_NUMBER) {
+	xmlXPathFreeObject(arg1);
+	xmlXPathFreeObject(arg2);
+	XP_ERROR0(XPATH_INVALID_OPERAND);
+    }
+    if (arg2->type != XPATH_NUMBER) {
+	valuePush(ctxt, arg2);
+	xmlXPathNumberFunction(ctxt, 1);
+	arg2 = valuePop(ctxt);
+    }
+    if (arg2->type != XPATH_NUMBER) {
+	xmlXPathFreeObject(arg1);
+	xmlXPathFreeObject(arg2);
+	XP_ERROR0(XPATH_INVALID_OPERAND);
+    }
+    /*
+     * Add tests for infinity and nan
+     * => feedback on 3.4 for Inf and NaN
+     */
+    /* Hand check NaN and Infinity comparisons */
+    if (xmlXPathIsNaN(arg1->floatval) || xmlXPathIsNaN(arg2->floatval)) {
+	ret=0;
+    } else {
+	arg1i=xmlXPathIsInf(arg1->floatval);
+	arg2i=xmlXPathIsInf(arg2->floatval);
+	if (inf && strict) {
+	    if ((arg1i == -1 && arg2i != -1) ||
+		(arg2i == 1 && arg1i != 1)) {
+		ret = 1;
+	    } else if (arg1i == 0 && arg2i == 0) {
+		ret = (arg1->floatval < arg2->floatval);
+	    } else {
+		ret = 0;
+	    }
+	}
+	else if (inf && !strict) {
+	    if (arg1i == -1 || arg2i == 1) {
+		ret = 1;
+	    } else if (arg1i == 0 && arg2i == 0) {
+		ret = (arg1->floatval <= arg2->floatval);
+	    } else {
+		ret = 0;
+	    }
+	}
+	else if (!inf && strict) {
+	    if ((arg1i == 1 && arg2i != 1) ||
+		(arg2i == -1 && arg1i != -1)) {
+		ret = 1;
+	    } else if (arg1i == 0 && arg2i == 0) {
+		ret = (arg1->floatval > arg2->floatval);
+	    } else {
+		ret = 0;
+	    }
+	}
+	else if (!inf && !strict) {
+	    if (arg1i == 1 || arg2i == -1) {
+		ret = 1;
+	    } else if (arg1i == 0 && arg2i == 0) {
+		ret = (arg1->floatval >= arg2->floatval);
+	    } else {
+		ret = 0;
+	    }
+	}
+    }
+    xmlXPathFreeObject(arg1);
+    xmlXPathFreeObject(arg2);
+    return(ret);
+}
+
+/**
+ * xmlXPathValueFlipSign:
+ * @ctxt:  the XPath Parser context
+ *
+ * Implement the unary - operation on an XPath object
+ * The numeric operators convert their operands to numbers as if
+ * by calling the number function.
+ */
+void
+xmlXPathValueFlipSign(xmlXPathParserContextPtr ctxt) {
+    CAST_TO_NUMBER;
+    CHECK_TYPE(XPATH_NUMBER);
+    if (xmlXPathIsNaN(ctxt->value->floatval))
+        ctxt->value->floatval=xmlXPathNAN;
+    else if (xmlXPathIsInf(ctxt->value->floatval) == 1)
+        ctxt->value->floatval=xmlXPathNINF;
+    else if (xmlXPathIsInf(ctxt->value->floatval) == -1)
+        ctxt->value->floatval=xmlXPathPINF;
+    else if (ctxt->value->floatval == 0) {
+        if (xmlXPathGetSign(ctxt->value->floatval) == 0)
+	    ctxt->value->floatval = xmlXPathNZERO;
+	else
+	    ctxt->value->floatval = 0;
+    }
+    else
+        ctxt->value->floatval = - ctxt->value->floatval;
+}
+
+/**
+ * xmlXPathAddValues:
+ * @ctxt:  the XPath Parser context
+ *
+ * Implement the add operation on XPath objects:
+ * The numeric operators convert their operands to numbers as if
+ * by calling the number function.
+ */
+void
+xmlXPathAddValues(xmlXPathParserContextPtr ctxt) {
+    xmlXPathObjectPtr arg;
+    double val;
+
+    arg = valuePop(ctxt);
+    if (arg == NULL)
+	XP_ERROR(XPATH_INVALID_OPERAND);
+    val = xmlXPathCastToNumber(arg);
+    xmlXPathFreeObject(arg);
+
+    CAST_TO_NUMBER;
+    CHECK_TYPE(XPATH_NUMBER);
+    ctxt->value->floatval += val;
+}
+
+/**
+ * xmlXPathSubValues:
+ * @ctxt:  the XPath Parser context
+ *
+ * Implement the subtraction operation on XPath objects:
+ * The numeric operators convert their operands to numbers as if
+ * by calling the number function.
+ */
+void
+xmlXPathSubValues(xmlXPathParserContextPtr ctxt) {
+    xmlXPathObjectPtr arg;
+    double val;
+
+    arg = valuePop(ctxt);
+    if (arg == NULL)
+	XP_ERROR(XPATH_INVALID_OPERAND);
+    val = xmlXPathCastToNumber(arg);
+    xmlXPathFreeObject(arg);
+
+    CAST_TO_NUMBER;
+    CHECK_TYPE(XPATH_NUMBER);
+    ctxt->value->floatval -= val;
+}
+
+/**
+ * xmlXPathMultValues:
+ * @ctxt:  the XPath Parser context
+ *
+ * Implement the multiply operation on XPath objects:
+ * The numeric operators convert their operands to numbers as if
+ * by calling the number function.
+ */
+void
+xmlXPathMultValues(xmlXPathParserContextPtr ctxt) {
+    xmlXPathObjectPtr arg;
+    double val;
+
+    arg = valuePop(ctxt);
+    if (arg == NULL)
+	XP_ERROR(XPATH_INVALID_OPERAND);
+    val = xmlXPathCastToNumber(arg);
+    xmlXPathFreeObject(arg);
+
+    CAST_TO_NUMBER;
+    CHECK_TYPE(XPATH_NUMBER);
+    ctxt->value->floatval *= val;
+}
+
+/**
+ * xmlXPathDivValues:
+ * @ctxt:  the XPath Parser context
+ *
+ * Implement the div operation on XPath objects @arg1 / @arg2:
+ * The numeric operators convert their operands to numbers as if
+ * by calling the number function.
+ */
+void
+xmlXPathDivValues(xmlXPathParserContextPtr ctxt) {
+    xmlXPathObjectPtr arg;
+    double val;
+
+    arg = valuePop(ctxt);
+    if (arg == NULL)
+	XP_ERROR(XPATH_INVALID_OPERAND);
+    val = xmlXPathCastToNumber(arg);
+    xmlXPathFreeObject(arg);
+
+    CAST_TO_NUMBER;
+    CHECK_TYPE(XPATH_NUMBER);
+    if (xmlXPathIsNaN(val) || xmlXPathIsNaN(ctxt->value->floatval))
+	ctxt->value->floatval = xmlXPathNAN;
+    else if (val == 0 && xmlXPathGetSign(val) != 0) {
+	if (ctxt->value->floatval == 0)
+	    ctxt->value->floatval = xmlXPathNAN;
+	else if (ctxt->value->floatval > 0)
+	    ctxt->value->floatval = xmlXPathNINF;
+	else if (ctxt->value->floatval < 0)
+	    ctxt->value->floatval = xmlXPathPINF;
+    }
+    else if (val == 0) {
+	if (ctxt->value->floatval == 0)
+	    ctxt->value->floatval = xmlXPathNAN;
+	else if (ctxt->value->floatval > 0)
+	    ctxt->value->floatval = xmlXPathPINF;
+	else if (ctxt->value->floatval < 0)
+	    ctxt->value->floatval = xmlXPathNINF;
+    } else 
+	ctxt->value->floatval /= val;
+}
+
+/**
+ * xmlXPathModValues:
+ * @ctxt:  the XPath Parser context
+ *
+ * Implement the mod operation on XPath objects: @arg1 / @arg2
+ * The numeric operators convert their operands to numbers as if
+ * by calling the number function.
+ */
+void
+xmlXPathModValues(xmlXPathParserContextPtr ctxt) {
+    xmlXPathObjectPtr arg;
+    double arg1, arg2;
+
+    arg = valuePop(ctxt);
+    if (arg == NULL)
+	XP_ERROR(XPATH_INVALID_OPERAND);
+    arg2 = xmlXPathCastToNumber(arg);
+    xmlXPathFreeObject(arg);
+
+    CAST_TO_NUMBER;
+    CHECK_TYPE(XPATH_NUMBER);
+    arg1 = ctxt->value->floatval;
+    if (arg2 == 0)
+	ctxt->value->floatval = xmlXPathNAN;
+    else {
+	ctxt->value->floatval = fmod(arg1, arg2);
+    }
+}
+
+/************************************************************************
+ *									*
+ *		The traversal functions					*
+ *									*
+ ************************************************************************/
+
+/*
+ * A traversal function enumerates nodes along an axis.
+ * Initially it must be called with NULL, and it indicates
+ * termination on the axis by returning NULL.
+ */
+typedef xmlNodePtr (*xmlXPathTraversalFunction)
+                    (xmlXPathParserContextPtr ctxt, xmlNodePtr cur);
+
+/**
+ * xmlXPathNextSelf:
+ * @ctxt:  the XPath Parser context
+ * @cur:  the current node in the traversal
+ *
+ * Traversal function for the "self" direction
+ * The self axis contains just the context node itself
+ *
+ * Returns the next element following that axis
+ */
+xmlNodePtr
+xmlXPathNextSelf(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
+    if (cur == NULL)
+        return(ctxt->context->node);
+    return(NULL);
+}
+
+/**
+ * xmlXPathNextChild:
+ * @ctxt:  the XPath Parser context
+ * @cur:  the current node in the traversal
+ *
+ * Traversal function for the "child" direction
+ * The child axis contains the children of the context node in document order.
+ *
+ * Returns the next element following that axis
+ */
+xmlNodePtr
+xmlXPathNextChild(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
+    if (cur == NULL) {
+	if (ctxt->context->node == NULL) return(NULL);
+	switch (ctxt->context->node->type) {
+            case XML_ELEMENT_NODE:
+            case XML_TEXT_NODE:
+            case XML_CDATA_SECTION_NODE:
+            case XML_ENTITY_REF_NODE:
+            case XML_ENTITY_NODE:
+            case XML_PI_NODE:
+            case XML_COMMENT_NODE:
+            case XML_NOTATION_NODE:
+            case XML_DTD_NODE:
+		return(ctxt->context->node->children);
+            case XML_DOCUMENT_NODE:
+            case XML_DOCUMENT_TYPE_NODE:
+            case XML_DOCUMENT_FRAG_NODE:
+            case XML_HTML_DOCUMENT_NODE:
+#ifdef LIBXML_DOCB_ENABLED
+	    case XML_DOCB_DOCUMENT_NODE:
+#endif
+		return(((xmlDocPtr) ctxt->context->node)->children);
+	    case XML_ELEMENT_DECL:
+	    case XML_ATTRIBUTE_DECL:
+	    case XML_ENTITY_DECL:
+            case XML_ATTRIBUTE_NODE:
+	    case XML_NAMESPACE_DECL:
+	    case XML_XINCLUDE_START:
+	    case XML_XINCLUDE_END:
+		return(NULL);
+	}
+	return(NULL);
+    }
+    if ((cur->type == XML_DOCUMENT_NODE) ||
+        (cur->type == XML_HTML_DOCUMENT_NODE))
+	return(NULL);
+    return(cur->next);
+}
+
+/**
+ * xmlXPathNextDescendant:
+ * @ctxt:  the XPath Parser context
+ * @cur:  the current node in the traversal
+ *
+ * Traversal function for the "descendant" direction
+ * the descendant axis contains the descendants of the context node in document
+ * order; a descendant is a child or a child of a child and so on.
+ *
+ * Returns the next element following that axis
+ */
+xmlNodePtr
+xmlXPathNextDescendant(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
+    if (cur == NULL) {
+	if (ctxt->context->node == NULL)
+	    return(NULL);
+	if ((ctxt->context->node->type == XML_ATTRIBUTE_NODE) ||
+	    (ctxt->context->node->type == XML_NAMESPACE_DECL))
+	    return(NULL);
+
+        if (ctxt->context->node == (xmlNodePtr) ctxt->context->doc)
+	    return(ctxt->context->doc->children);
+        return(ctxt->context->node->children);
+    }
+
+    if (cur->children != NULL) {
+	/*
+	 * Do not descend on entities declarations
+	 */
+    	if (cur->children->type != XML_ENTITY_DECL) {
+	    cur = cur->children;
+	    /*
+	     * Skip DTDs
+	     */
+	    if (cur->type != XML_DTD_NODE)
+		return(cur);
+	}
+    }
+
+    if (cur == ctxt->context->node) return(NULL);
+
+    while (cur->next != NULL) {
+	cur = cur->next;
+	if ((cur->type != XML_ENTITY_DECL) &&
+	    (cur->type != XML_DTD_NODE))
+	    return(cur);
+    }
+    
+    do {
+        cur = cur->parent;
+	if (cur == NULL) return(NULL);
+	if (cur == ctxt->context->node) return(NULL);
+	if (cur->next != NULL) {
+	    cur = cur->next;
+	    return(cur);
+	}
+    } while (cur != NULL);
+    return(cur);
+}
+
+/**
+ * xmlXPathNextDescendantOrSelf:
+ * @ctxt:  the XPath Parser context
+ * @cur:  the current node in the traversal
+ *
+ * Traversal function for the "descendant-or-self" direction
+ * the descendant-or-self axis contains the context node and the descendants
+ * of the context node in document order; thus the context node is the first
+ * node on the axis, and the first child of the context node is the second node
+ * on the axis
+ *
+ * Returns the next element following that axis
+ */
+xmlNodePtr
+xmlXPathNextDescendantOrSelf(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
+    if (cur == NULL) {
+	if (ctxt->context->node == NULL)
+	    return(NULL);
+	if ((ctxt->context->node->type == XML_ATTRIBUTE_NODE) ||
+	    (ctxt->context->node->type == XML_NAMESPACE_DECL))
+	    return(NULL);
+        return(ctxt->context->node);
+    }
+
+    return(xmlXPathNextDescendant(ctxt, cur));
+}
+
+/**
+ * xmlXPathNextParent:
+ * @ctxt:  the XPath Parser context
+ * @cur:  the current node in the traversal
+ *
+ * Traversal function for the "parent" direction
+ * The parent axis contains the parent of the context node, if there is one.
+ *
+ * Returns the next element following that axis
+ */
+xmlNodePtr
+xmlXPathNextParent(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
+    /*
+     * the parent of an attribute or namespace node is the element
+     * to which the attribute or namespace node is attached
+     * Namespace handling !!!
+     */
+    if (cur == NULL) {
+	if (ctxt->context->node == NULL) return(NULL);
+	switch (ctxt->context->node->type) {
+            case XML_ELEMENT_NODE:
+            case XML_TEXT_NODE:
+            case XML_CDATA_SECTION_NODE:
+            case XML_ENTITY_REF_NODE:
+            case XML_ENTITY_NODE:
+            case XML_PI_NODE:
+            case XML_COMMENT_NODE:
+            case XML_NOTATION_NODE:
+            case XML_DTD_NODE:
+	    case XML_ELEMENT_DECL:
+	    case XML_ATTRIBUTE_DECL:
+	    case XML_XINCLUDE_START:
+	    case XML_XINCLUDE_END:
+	    case XML_ENTITY_DECL:
+		if (ctxt->context->node->parent == NULL)
+		    return((xmlNodePtr) ctxt->context->doc);
+		if ((ctxt->context->node->parent->type == XML_ELEMENT_NODE) &&
+		    ((ctxt->context->node->parent->name[0] == ' ') ||
+		     (xmlStrEqual(ctxt->context->node->parent->name,
+				 BAD_CAST "fake node libxslt"))))
+		    return(NULL);
+		return(ctxt->context->node->parent);
+            case XML_ATTRIBUTE_NODE: {
+		xmlAttrPtr att = (xmlAttrPtr) ctxt->context->node;
+
+		return(att->parent);
+	    }
+            case XML_DOCUMENT_NODE:
+            case XML_DOCUMENT_TYPE_NODE:
+            case XML_DOCUMENT_FRAG_NODE:
+            case XML_HTML_DOCUMENT_NODE:
+#ifdef LIBXML_DOCB_ENABLED
+	    case XML_DOCB_DOCUMENT_NODE:
+#endif
+                return(NULL);
+	    case XML_NAMESPACE_DECL: {
+		xmlNsPtr ns = (xmlNsPtr) ctxt->context->node;
+		
+		if ((ns->next != NULL) &&
+		    (ns->next->type != XML_NAMESPACE_DECL))
+		    return((xmlNodePtr) ns->next);
+                return(NULL);
+	    }
+	}
+    }
+    return(NULL);
+}
+
+/**
+ * xmlXPathNextAncestor:
+ * @ctxt:  the XPath Parser context
+ * @cur:  the current node in the traversal
+ *
+ * Traversal function for the "ancestor" direction
+ * the ancestor axis contains the ancestors of the context node; the ancestors
+ * of the context node consist of the parent of context node and the parent's
+ * parent and so on; the nodes are ordered in reverse document order; thus the
+ * parent is the first node on the axis, and the parent's parent is the second
+ * node on the axis
+ *
+ * Returns the next element following that axis
+ */
+xmlNodePtr
+xmlXPathNextAncestor(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
+    /*
+     * the parent of an attribute or namespace node is the element
+     * to which the attribute or namespace node is attached
+     * !!!!!!!!!!!!!
+     */
+    if (cur == NULL) {
+	if (ctxt->context->node == NULL) return(NULL);
+	switch (ctxt->context->node->type) {
+            case XML_ELEMENT_NODE:
+            case XML_TEXT_NODE:
+            case XML_CDATA_SECTION_NODE:
+            case XML_ENTITY_REF_NODE:
+            case XML_ENTITY_NODE:
+            case XML_PI_NODE:
+            case XML_COMMENT_NODE:
+	    case XML_DTD_NODE:
+	    case XML_ELEMENT_DECL:
+	    case XML_ATTRIBUTE_DECL:
+	    case XML_ENTITY_DECL:
+            case XML_NOTATION_NODE:
+	    case XML_XINCLUDE_START:
+	    case XML_XINCLUDE_END:
+		if (ctxt->context->node->parent == NULL)
+		    return((xmlNodePtr) ctxt->context->doc);
+		if ((ctxt->context->node->parent->type == XML_ELEMENT_NODE) &&
+		    ((ctxt->context->node->parent->name[0] == ' ') ||
+		     (xmlStrEqual(ctxt->context->node->parent->name,
+				 BAD_CAST "fake node libxslt"))))
+		    return(NULL);
+		return(ctxt->context->node->parent);
+            case XML_ATTRIBUTE_NODE: {
+		xmlAttrPtr tmp = (xmlAttrPtr) ctxt->context->node;
+
+		return(tmp->parent);
+	    }
+            case XML_DOCUMENT_NODE:
+            case XML_DOCUMENT_TYPE_NODE:
+            case XML_DOCUMENT_FRAG_NODE:
+            case XML_HTML_DOCUMENT_NODE:
+#ifdef LIBXML_DOCB_ENABLED
+	    case XML_DOCB_DOCUMENT_NODE:
+#endif
+                return(NULL);
+	    case XML_NAMESPACE_DECL: {
+		xmlNsPtr ns = (xmlNsPtr) ctxt->context->node;
+		
+		if ((ns->next != NULL) &&
+		    (ns->next->type != XML_NAMESPACE_DECL))
+		    return((xmlNodePtr) ns->next);
+		/* Bad, how did that namespace end up here ? */
+                return(NULL);
+	    }
+	}
+	return(NULL);
+    }
+    if (cur == ctxt->context->doc->children)
+	return((xmlNodePtr) ctxt->context->doc);
+    if (cur == (xmlNodePtr) ctxt->context->doc)
+	return(NULL);
+    switch (cur->type) {
+	case XML_ELEMENT_NODE:
+	case XML_TEXT_NODE:
+	case XML_CDATA_SECTION_NODE:
+	case XML_ENTITY_REF_NODE:
+	case XML_ENTITY_NODE:
+	case XML_PI_NODE:
+	case XML_COMMENT_NODE:
+	case XML_NOTATION_NODE:
+	case XML_DTD_NODE:
+        case XML_ELEMENT_DECL:
+        case XML_ATTRIBUTE_DECL:
+        case XML_ENTITY_DECL:
+	case XML_XINCLUDE_START:
+	case XML_XINCLUDE_END:
+	    if (cur->parent == NULL)
+		return(NULL);
+	    if ((cur->parent->type == XML_ELEMENT_NODE) &&
+		((cur->parent->name[0] == ' ') ||
+		 (xmlStrEqual(cur->parent->name,
+			      BAD_CAST "fake node libxslt"))))
+		return(NULL);
+	    return(cur->parent);
+	case XML_ATTRIBUTE_NODE: {
+	    xmlAttrPtr att = (xmlAttrPtr) ctxt->context->node;
+
+	    return(att->parent);
+	}
+	case XML_NAMESPACE_DECL: {
+	    xmlNsPtr ns = (xmlNsPtr) ctxt->context->node;
+		
+	    if ((ns->next != NULL) &&
+	        (ns->next->type != XML_NAMESPACE_DECL))
+	        return((xmlNodePtr) ns->next);
+	    /* Bad, how did that namespace end up here ? */
+            return(NULL);
+	}
+	case XML_DOCUMENT_NODE:
+	case XML_DOCUMENT_TYPE_NODE:
+	case XML_DOCUMENT_FRAG_NODE:
+	case XML_HTML_DOCUMENT_NODE:
+#ifdef LIBXML_DOCB_ENABLED
+	case XML_DOCB_DOCUMENT_NODE:
+#endif
+	    return(NULL);
+    }
+    return(NULL);
+}
+
+/**
+ * xmlXPathNextAncestorOrSelf:
+ * @ctxt:  the XPath Parser context
+ * @cur:  the current node in the traversal
+ *
+ * Traversal function for the "ancestor-or-self" direction
+ * he ancestor-or-self axis contains the context node and ancestors of
+ * the context node in reverse document order; thus the context node is
+ * the first node on the axis, and the context node's parent the second;
+ * parent here is defined the same as with the parent axis.
+ *
+ * Returns the next element following that axis
+ */
+xmlNodePtr
+xmlXPathNextAncestorOrSelf(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
+    if (cur == NULL)
+        return(ctxt->context->node);
+    return(xmlXPathNextAncestor(ctxt, cur));
+}
+
+/**
+ * xmlXPathNextFollowingSibling:
+ * @ctxt:  the XPath Parser context
+ * @cur:  the current node in the traversal
+ *
+ * Traversal function for the "following-sibling" direction
+ * The following-sibling axis contains the following siblings of the context
+ * node in document order.
+ *
+ * Returns the next element following that axis
+ */
+xmlNodePtr
+xmlXPathNextFollowingSibling(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
+    if ((ctxt->context->node->type == XML_ATTRIBUTE_NODE) ||
+	(ctxt->context->node->type == XML_NAMESPACE_DECL))
+	return(NULL);
+    if (cur == (xmlNodePtr) ctxt->context->doc)
+        return(NULL);
+    if (cur == NULL)
+        return(ctxt->context->node->next);
+    return(cur->next);
+}
+
+/**
+ * xmlXPathNextPrecedingSibling:
+ * @ctxt:  the XPath Parser context
+ * @cur:  the current node in the traversal
+ *
+ * Traversal function for the "preceding-sibling" direction
+ * The preceding-sibling axis contains the preceding siblings of the context
+ * node in reverse document order; the first preceding sibling is first on the
+ * axis; the sibling preceding that node is the second on the axis and so on.
+ *
+ * Returns the next element following that axis
+ */
+xmlNodePtr
+xmlXPathNextPrecedingSibling(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
+    if ((ctxt->context->node->type == XML_ATTRIBUTE_NODE) ||
+	(ctxt->context->node->type == XML_NAMESPACE_DECL))
+	return(NULL);
+    if (cur == (xmlNodePtr) ctxt->context->doc)
+        return(NULL);
+    if (cur == NULL)
+        return(ctxt->context->node->prev);
+    if ((cur->prev != NULL) && (cur->prev->type == XML_DTD_NODE)) {
+	cur = cur->prev;
+	if (cur == NULL)
+	    return(ctxt->context->node->prev);
+    }
+    return(cur->prev);
+}
+
+/**
+ * xmlXPathNextFollowing:
+ * @ctxt:  the XPath Parser context
+ * @cur:  the current node in the traversal
+ *
+ * Traversal function for the "following" direction
+ * The following axis contains all nodes in the same document as the context
+ * node that are after the context node in document order, excluding any
+ * descendants and excluding attribute nodes and namespace nodes; the nodes
+ * are ordered in document order
+ *
+ * Returns the next element following that axis
+ */
+xmlNodePtr
+xmlXPathNextFollowing(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
+    if (cur != NULL && cur->children != NULL)
+        return cur->children ;
+    if (cur == NULL) cur = ctxt->context->node;
+    if (cur == NULL) return(NULL) ; /* ERROR */
+    if (cur->next != NULL) return(cur->next) ;
+    do {
+        cur = cur->parent;
+        if (cur == NULL) return(NULL);
+        if (cur == (xmlNodePtr) ctxt->context->doc) return(NULL);
+        if (cur->next != NULL) return(cur->next);
+    } while (cur != NULL);
+    return(cur);
+}
+
+/*
+ * xmlXPathIsAncestor:
+ * @ancestor:  the ancestor node
+ * @node:  the current node
+ *
+ * Check that @ancestor is a @node's ancestor
+ *
+ * returns 1 if @ancestor is a @node's ancestor, 0 otherwise.
+ */
+static int
+xmlXPathIsAncestor(xmlNodePtr ancestor, xmlNodePtr node) {
+    if ((ancestor == NULL) || (node == NULL)) return(0);
+    /* nodes need to be in the same document */
+    if (ancestor->doc != node->doc) return(0);
+    /* avoid searching if ancestor or node is the root node */
+    if (ancestor == (xmlNodePtr) node->doc) return(1);
+    if (node == (xmlNodePtr) ancestor->doc) return(0);
+    while (node->parent != NULL) {
+        if (node->parent == ancestor)
+            return(1);
+	node = node->parent;
+    }
+    return(0);
+}
+
+/**
+ * xmlXPathNextPreceding:
+ * @ctxt:  the XPath Parser context
+ * @cur:  the current node in the traversal
+ *
+ * Traversal function for the "preceding" direction
+ * the preceding axis contains all nodes in the same document as the context
+ * node that are before the context node in document order, excluding any
+ * ancestors and excluding attribute nodes and namespace nodes; the nodes are
+ * ordered in reverse document order
+ *
+ * Returns the next element following that axis
+ */
+xmlNodePtr
+xmlXPathNextPreceding(xmlXPathParserContextPtr ctxt, xmlNodePtr cur)
+{
+    if (cur == NULL)
+        cur = ctxt->context->node;
+    if (cur == NULL)
+	return (NULL);
+    if ((cur->prev != NULL) && (cur->prev->type == XML_DTD_NODE))
+	cur = cur->prev;
+    do {
+        if (cur->prev != NULL) {
+            for (cur = cur->prev; cur->last != NULL; cur = cur->last) ;
+            return (cur);
+        }
+
+        cur = cur->parent;
+        if (cur == NULL)
+            return (NULL);
+        if (cur == ctxt->context->doc->children)
+            return (NULL);
+    } while (xmlXPathIsAncestor(cur, ctxt->context->node));
+    return (cur);
+}
+
+/**
+ * xmlXPathNextPrecedingInternal:
+ * @ctxt:  the XPath Parser context
+ * @cur:  the current node in the traversal
+ *
+ * Traversal function for the "preceding" direction
+ * the preceding axis contains all nodes in the same document as the context
+ * node that are before the context node in document order, excluding any
+ * ancestors and excluding attribute nodes and namespace nodes; the nodes are
+ * ordered in reverse document order
+ * This is a faster implementation but internal only since it requires a 
+ * state kept in the parser context: ctxt->ancestor.
+ *
+ * Returns the next element following that axis
+ */
+static xmlNodePtr
+xmlXPathNextPrecedingInternal(xmlXPathParserContextPtr ctxt,
+                              xmlNodePtr cur)
+{
+    if (cur == NULL) {
+        cur = ctxt->context->node;
+        if (cur == NULL)
+            return (NULL);
+	if (cur->type == XML_NAMESPACE_DECL)
+	    cur = (xmlNodePtr)((xmlNsPtr)cur)->next;
+        ctxt->ancestor = cur->parent;
+    }
+    if ((cur->prev != NULL) && (cur->prev->type == XML_DTD_NODE))
+	cur = cur->prev;
+    while (cur->prev == NULL) {
+        cur = cur->parent;
+        if (cur == NULL)
+            return (NULL);
+        if (cur == ctxt->context->doc->children)
+            return (NULL);
+        if (cur != ctxt->ancestor)
+            return (cur);
+        ctxt->ancestor = cur->parent;
+    }
+    cur = cur->prev;
+    while (cur->last != NULL)
+        cur = cur->last;
+    return (cur);
+}
+
+/**
+ * xmlXPathNextNamespace:
+ * @ctxt:  the XPath Parser context
+ * @cur:  the current attribute in the traversal
+ *
+ * Traversal function for the "namespace" direction
+ * the namespace axis contains the namespace nodes of the context node;
+ * the order of nodes on this axis is implementation-defined; the axis will
+ * be empty unless the context node is an element
+ *
+ * We keep the XML namespace node at the end of the list.
+ *
+ * Returns the next element following that axis
+ */
+xmlNodePtr
+xmlXPathNextNamespace(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
+    if (ctxt->context->node->type != XML_ELEMENT_NODE) return(NULL);
+    if (ctxt->context->tmpNsList == NULL && cur != (xmlNodePtr) xmlXPathXMLNamespace) {
+        if (ctxt->context->tmpNsList != NULL)
+	    xmlFree(ctxt->context->tmpNsList);
+	ctxt->context->tmpNsList = 
+	    xmlGetNsList(ctxt->context->doc, ctxt->context->node);
+	ctxt->context->tmpNsNr = 0;
+	if (ctxt->context->tmpNsList != NULL) {
+	    while (ctxt->context->tmpNsList[ctxt->context->tmpNsNr] != NULL) {
+		ctxt->context->tmpNsNr++;
+	    }
+	}
+	return((xmlNodePtr) xmlXPathXMLNamespace);
+    }
+    if (ctxt->context->tmpNsNr > 0) {
+	return (xmlNodePtr)ctxt->context->tmpNsList[--ctxt->context->tmpNsNr];
+    } else {
+	if (ctxt->context->tmpNsList != NULL)
+	    xmlFree(ctxt->context->tmpNsList);
+	ctxt->context->tmpNsList = NULL;
+	return(NULL);
+    }
+}
+
+/**
+ * xmlXPathNextAttribute:
+ * @ctxt:  the XPath Parser context
+ * @cur:  the current attribute in the traversal
+ *
+ * Traversal function for the "attribute" direction
+ * TODO: support DTD inherited default attributes
+ *
+ * Returns the next element following that axis
+ */
+xmlNodePtr
+xmlXPathNextAttribute(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
+    if (ctxt->context->node == NULL)
+	return(NULL);
+    if (ctxt->context->node->type != XML_ELEMENT_NODE)
+	return(NULL);
+    if (cur == NULL) {
+        if (ctxt->context->node == (xmlNodePtr) ctxt->context->doc)
+	    return(NULL);
+        return((xmlNodePtr)ctxt->context->node->properties);
+    }
+    return((xmlNodePtr)cur->next);
+}
+
+/************************************************************************
+ *									*
+ *		NodeTest Functions					*
+ *									*
+ ************************************************************************/
+
+#define IS_FUNCTION			200
+
+
+/************************************************************************
+ *									*
+ *		Implicit tree core function library			*
+ *									*
+ ************************************************************************/
+
+/**
+ * xmlXPathRoot:
+ * @ctxt:  the XPath Parser context
+ *
+ * Initialize the context to the root of the document
+ */
+void
+xmlXPathRoot(xmlXPathParserContextPtr ctxt) {
+    ctxt->context->node = (xmlNodePtr) ctxt->context->doc;
+    valuePush(ctxt, xmlXPathNewNodeSet(ctxt->context->node));
+}
+
+/************************************************************************
+ *									*
+ *		The explicit core function library			*
+ *http://www.w3.org/Style/XSL/Group/1999/07/xpath-19990705.html#corelib	*
+ *									*
+ ************************************************************************/
+
+
+/**
+ * xmlXPathLastFunction:
+ * @ctxt:  the XPath Parser context
+ * @nargs:  the number of arguments
+ *
+ * Implement the last() XPath function
+ *    number last()
+ * The last function returns the number of nodes in the context node list.
+ */
+void
+xmlXPathLastFunction(xmlXPathParserContextPtr ctxt, int nargs) {
+    CHECK_ARITY(0);
+    if (ctxt->context->contextSize >= 0) {
+	valuePush(ctxt, xmlXPathNewFloat((double) ctxt->context->contextSize));
+#ifdef DEBUG_EXPR
+	xmlGenericError(xmlGenericErrorContext,
+		"last() : %d\n", ctxt->context->contextSize);
+#endif
+    } else {
+	XP_ERROR(XPATH_INVALID_CTXT_SIZE);
+    }
+}
+
+/**
+ * xmlXPathPositionFunction:
+ * @ctxt:  the XPath Parser context
+ * @nargs:  the number of arguments
+ *
+ * Implement the position() XPath function
+ *    number position()
+ * The position function returns the position of the context node in the
+ * context node list. The first position is 1, and so the last position
+ * will be equal to last().
+ */
+void
+xmlXPathPositionFunction(xmlXPathParserContextPtr ctxt, int nargs) {
+    CHECK_ARITY(0);
+    if (ctxt->context->proximityPosition >= 0) {
+	valuePush(ctxt,
+	      xmlXPathNewFloat((double) ctxt->context->proximityPosition));
+#ifdef DEBUG_EXPR
+	xmlGenericError(xmlGenericErrorContext, "position() : %d\n",
+		ctxt->context->proximityPosition);
+#endif
+    } else {
+	XP_ERROR(XPATH_INVALID_CTXT_POSITION);
+    }
+}
+
+/**
+ * xmlXPathCountFunction:
+ * @ctxt:  the XPath Parser context
+ * @nargs:  the number of arguments
+ *
+ * Implement the count() XPath function
+ *    number count(node-set)
+ */
+void
+xmlXPathCountFunction(xmlXPathParserContextPtr ctxt, int nargs) {
+    xmlXPathObjectPtr cur;
+
+    CHECK_ARITY(1);
+    if ((ctxt->value == NULL) || 
+	((ctxt->value->type != XPATH_NODESET) &&
+	 (ctxt->value->type != XPATH_XSLT_TREE)))
+	XP_ERROR(XPATH_INVALID_TYPE);
+    cur = valuePop(ctxt);
+
+    if ((cur == NULL) || (cur->nodesetval == NULL))
+	valuePush(ctxt, xmlXPathNewFloat((double) 0));
+    else if ((cur->type == XPATH_NODESET) || (cur->type == XPATH_XSLT_TREE)) {
+	valuePush(ctxt, xmlXPathNewFloat((double) cur->nodesetval->nodeNr));
+    } else {
+	if ((cur->nodesetval->nodeNr != 1) ||
+	    (cur->nodesetval->nodeTab == NULL)) {
+	    valuePush(ctxt, xmlXPathNewFloat((double) 0));
+	} else {
+	    xmlNodePtr tmp;
+	    int i = 0;
+
+	    tmp = cur->nodesetval->nodeTab[0];
+	    if (tmp != NULL) {
+		tmp = tmp->children;
+		while (tmp != NULL) {
+		    tmp = tmp->next;
+		    i++;
+		}
+	    }
+	    valuePush(ctxt, xmlXPathNewFloat((double) i));
+	}
+    }
+    xmlXPathFreeObject(cur);
+}
+
+/**
+ * xmlXPathGetElementsByIds:
+ * @doc:  the document
+ * @ids:  a whitespace separated list of IDs
+ *
+ * Selects elements by their unique ID.
+ *
+ * Returns a node-set of selected elements.
+ */
+static xmlNodeSetPtr
+xmlXPathGetElementsByIds (xmlDocPtr doc, const xmlChar *ids) {
+    xmlNodeSetPtr ret;
+    const xmlChar *cur = ids;
+    xmlChar *ID;
+    xmlAttrPtr attr;
+    xmlNodePtr elem = NULL;
+
+    if (ids == NULL) return(NULL);
+
+    ret = xmlXPathNodeSetCreate(NULL);
+
+    while (IS_BLANK_CH(*cur)) cur++;
+    while (*cur != 0) {
+	while ((!IS_BLANK_CH(*cur)) && (*cur != 0))
+	    cur++;
+
+        ID = xmlStrndup(ids, cur - ids);
+	if (ID != NULL) {
+	    /*
+	     * We used to check the fact that the value passed
+	     * was an NCName, but this generated much troubles for
+	     * me and Aleksey Sanin, people blatantly violated that
+	     * constaint, like Visa3D spec.
+	     * if (xmlValidateNCName(ID, 1) == 0)
+	     */
+	    attr = xmlGetID(doc, ID);
+	    if (attr != NULL) {
+		if (attr->type == XML_ATTRIBUTE_NODE)
+		    elem = attr->parent;
+		else if (attr->type == XML_ELEMENT_NODE)
+		    elem = (xmlNodePtr) attr;
+		else
+		    elem = NULL;
+		if (elem != NULL)
+		    xmlXPathNodeSetAdd(ret, elem);
+	    }
+	    xmlFree(ID);
+	}
+
+	while (IS_BLANK_CH(*cur)) cur++;
+	ids = cur;
+    }
+    return(ret);
+}
+
+/**
+ * xmlXPathIdFunction:
+ * @ctxt:  the XPath Parser context
+ * @nargs:  the number of arguments
+ *
+ * Implement the id() XPath function
+ *    node-set id(object)
+ * The id function selects elements by their unique ID
+ * (see [5.2.1 Unique IDs]). When the argument to id is of type node-set,
+ * then the result is the union of the result of applying id to the
+ * string value of each of the nodes in the argument node-set. When the
+ * argument to id is of any other type, the argument is converted to a
+ * string as if by a call to the string function; the string is split
+ * into a whitespace-separated list of tokens (whitespace is any sequence
+ * of characters matching the production S); the result is a node-set
+ * containing the elements in the same document as the context node that
+ * have a unique ID equal to any of the tokens in the list.
+ */
+void
+xmlXPathIdFunction(xmlXPathParserContextPtr ctxt, int nargs) {
+    xmlChar *tokens;
+    xmlNodeSetPtr ret;
+    xmlXPathObjectPtr obj;
+
+    CHECK_ARITY(1);
+    obj = valuePop(ctxt);
+    if (obj == NULL) XP_ERROR(XPATH_INVALID_OPERAND);
+    if ((obj->type == XPATH_NODESET) || (obj->type == XPATH_XSLT_TREE)) {
+	xmlNodeSetPtr ns;
+	int i;
+
+	ret = xmlXPathNodeSetCreate(NULL);
+
+	if (obj->nodesetval != NULL) {
+	    for (i = 0; i < obj->nodesetval->nodeNr; i++) {
+		tokens =
+		    xmlXPathCastNodeToString(obj->nodesetval->nodeTab[i]);
+		ns = xmlXPathGetElementsByIds(ctxt->context->doc, tokens);
+		ret = xmlXPathNodeSetMerge(ret, ns);
+		xmlXPathFreeNodeSet(ns);
+		if (tokens != NULL)
+		    xmlFree(tokens);
+	    }
+	}
+
+	xmlXPathFreeObject(obj);
+	valuePush(ctxt, xmlXPathWrapNodeSet(ret));
+	return;
+    }
+    obj = xmlXPathConvertString(obj);
+
+    ret = xmlXPathGetElementsByIds(ctxt->context->doc, obj->stringval);
+    valuePush(ctxt, xmlXPathWrapNodeSet(ret));
+
+    xmlXPathFreeObject(obj);
+    return;
+}
+
+/**
+ * xmlXPathLocalNameFunction:
+ * @ctxt:  the XPath Parser context
+ * @nargs:  the number of arguments
+ *
+ * Implement the local-name() XPath function
+ *    string local-name(node-set?)
+ * The local-name function returns a string containing the local part
+ * of the name of the node in the argument node-set that is first in
+ * document order. If the node-set is empty or the first node has no
+ * name, an empty string is returned. If the argument is omitted it
+ * defaults to the context node.
+ */
+void
+xmlXPathLocalNameFunction(xmlXPathParserContextPtr ctxt, int nargs) {
+    xmlXPathObjectPtr cur;
+
+    if (nargs == 0) {
+	valuePush(ctxt, xmlXPathNewNodeSet(ctxt->context->node));
+	nargs = 1;
+    }
+
+    CHECK_ARITY(1);
+    if ((ctxt->value == NULL) || 
+	((ctxt->value->type != XPATH_NODESET) &&
+	 (ctxt->value->type != XPATH_XSLT_TREE)))
+	XP_ERROR(XPATH_INVALID_TYPE);
+    cur = valuePop(ctxt);
+
+    if ((cur->nodesetval == NULL) || (cur->nodesetval->nodeNr == 0)) {
+	valuePush(ctxt, xmlXPathNewCString(""));
+    } else {
+	int i = 0; /* Should be first in document order !!!!! */
+	switch (cur->nodesetval->nodeTab[i]->type) {
+	case XML_ELEMENT_NODE:
+	case XML_ATTRIBUTE_NODE:
+	case XML_PI_NODE:
+	    if (cur->nodesetval->nodeTab[i]->name[0] == ' ')
+		valuePush(ctxt, xmlXPathNewCString(""));
+	    else
+		valuePush(ctxt,
+		      xmlXPathNewString(cur->nodesetval->nodeTab[i]->name));
+	    break;
+	case XML_NAMESPACE_DECL:
+	    valuePush(ctxt, xmlXPathNewString(
+			((xmlNsPtr)cur->nodesetval->nodeTab[i])->prefix));
+	    break;
+	default:
+	    valuePush(ctxt, xmlXPathNewCString(""));
+	}
+    }
+    xmlXPathFreeObject(cur);
+}
+
+/**
+ * xmlXPathNamespaceURIFunction:
+ * @ctxt:  the XPath Parser context
+ * @nargs:  the number of arguments
+ *
+ * Implement the namespace-uri() XPath function
+ *    string namespace-uri(node-set?)
+ * The namespace-uri function returns a string containing the
+ * namespace URI of the expanded name of the node in the argument
+ * node-set that is first in document order. If the node-set is empty,
+ * the first node has no name, or the expanded name has no namespace
+ * URI, an empty string is returned. If the argument is omitted it
+ * defaults to the context node.
+ */
+void
+xmlXPathNamespaceURIFunction(xmlXPathParserContextPtr ctxt, int nargs) {
+    xmlXPathObjectPtr cur;
+
+    if (nargs == 0) {
+        valuePush(ctxt, xmlXPathNewNodeSet(ctxt->context->node));
+	nargs = 1;
+    }
+    CHECK_ARITY(1);
+    if ((ctxt->value == NULL) || 
+	((ctxt->value->type != XPATH_NODESET) &&
+	 (ctxt->value->type != XPATH_XSLT_TREE)))
+	XP_ERROR(XPATH_INVALID_TYPE);
+    cur = valuePop(ctxt);
+
+    if ((cur->nodesetval == NULL) || (cur->nodesetval->nodeNr == 0)) {
+	valuePush(ctxt, xmlXPathNewCString(""));
+    } else {
+	int i = 0; /* Should be first in document order !!!!! */
+	switch (cur->nodesetval->nodeTab[i]->type) {
+	case XML_ELEMENT_NODE:
+	case XML_ATTRIBUTE_NODE:
+	    if (cur->nodesetval->nodeTab[i]->ns == NULL)
+		valuePush(ctxt, xmlXPathNewCString(""));
+	    else
+		valuePush(ctxt, xmlXPathNewString(
+			  cur->nodesetval->nodeTab[i]->ns->href));
+	    break;
+	default:
+	    valuePush(ctxt, xmlXPathNewCString(""));
+	}
+    }
+    xmlXPathFreeObject(cur);
+}
+
+/**
+ * xmlXPathNameFunction:
+ * @ctxt:  the XPath Parser context
+ * @nargs:  the number of arguments
+ *
+ * Implement the name() XPath function
+ *    string name(node-set?)
+ * The name function returns a string containing a QName representing
+ * the name of the node in the argument node-set that is first in document
+ * order. The QName must represent the name with respect to the namespace
+ * declarations in effect on the node whose name is being represented.
+ * Typically, this will be the form in which the name occurred in the XML
+ * source. This need not be the case if there are namespace declarations
+ * in effect on the node that associate multiple prefixes with the same
+ * namespace. However, an implementation may include information about
+ * the original prefix in its representation of nodes; in this case, an
+ * implementation can ensure that the returned string is always the same
+ * as the QName used in the XML source. If the argument it omitted it
+ * defaults to the context node.
+ * Libxml keep the original prefix so the "real qualified name" used is
+ * returned.
+ */
+static void
+xmlXPathNameFunction(xmlXPathParserContextPtr ctxt, int nargs)
+{
+    xmlXPathObjectPtr cur;
+
+    if (nargs == 0) {
+        valuePush(ctxt, xmlXPathNewNodeSet(ctxt->context->node));
+        nargs = 1;
+    }
+
+    CHECK_ARITY(1);
+    if ((ctxt->value == NULL) ||
+        ((ctxt->value->type != XPATH_NODESET) &&
+         (ctxt->value->type != XPATH_XSLT_TREE)))
+        XP_ERROR(XPATH_INVALID_TYPE);
+    cur = valuePop(ctxt);
+
+    if ((cur->nodesetval == NULL) || (cur->nodesetval->nodeNr == 0)) {
+        valuePush(ctxt, xmlXPathNewCString(""));
+    } else {
+        int i = 0;              /* Should be first in document order !!!!! */
+
+        switch (cur->nodesetval->nodeTab[i]->type) {
+            case XML_ELEMENT_NODE:
+            case XML_ATTRIBUTE_NODE:
+		if (cur->nodesetval->nodeTab[i]->name[0] == ' ')
+		    valuePush(ctxt, xmlXPathNewCString(""));
+		else if ((cur->nodesetval->nodeTab[i]->ns == NULL) ||
+                         (cur->nodesetval->nodeTab[i]->ns->prefix == NULL)) {
+                    valuePush(ctxt,
+		        xmlXPathNewString(cur->nodesetval->nodeTab[i]->name));
+
+		} else {
+		    xmlChar *fullname;
+		    
+		    fullname = xmlBuildQName(cur->nodesetval->nodeTab[i]->name,
+				     cur->nodesetval->nodeTab[i]->ns->prefix,
+				     NULL, 0);
+		    if (fullname == cur->nodesetval->nodeTab[i]->name)
+			fullname = xmlStrdup(cur->nodesetval->nodeTab[i]->name);
+		    if (fullname == NULL) {
+			XP_ERROR(XPATH_MEMORY_ERROR);
+		    }
+                    valuePush(ctxt, xmlXPathWrapString(fullname));
+                }
+                break;
+            default:
+                valuePush(ctxt,
+                          xmlXPathNewNodeSet(cur->nodesetval->nodeTab[i]));
+                xmlXPathLocalNameFunction(ctxt, 1);
+        }
+    }
+    xmlXPathFreeObject(cur);
+}
+
+
+/**
+ * xmlXPathStringFunction:
+ * @ctxt:  the XPath Parser context
+ * @nargs:  the number of arguments
+ *
+ * Implement the string() XPath function
+ *    string string(object?)
+ * The string function converts an object to a string as follows:
+ *    - A node-set is converted to a string by returning the value of
+ *      the node in the node-set that is first in document order.
+ *      If the node-set is empty, an empty string is returned.
+ *    - A number is converted to a string as follows
+ *      + NaN is converted to the string NaN 
+ *      + positive zero is converted to the string 0 
+ *      + negative zero is converted to the string 0 
+ *      + positive infinity is converted to the string Infinity 
+ *      + negative infinity is converted to the string -Infinity 
+ *      + if the number is an integer, the number is represented in
+ *        decimal form as a Number with no decimal point and no leading
+ *        zeros, preceded by a minus sign (-) if the number is negative
+ *      + otherwise, the number is represented in decimal form as a
+ *        Number including a decimal point with at least one digit
+ *        before the decimal point and at least one digit after the
+ *        decimal point, preceded by a minus sign (-) if the number
+ *        is negative; there must be no leading zeros before the decimal
+ *        point apart possibly from the one required digit immediately
+ *        before the decimal point; beyond the one required digit
+ *        after the decimal point there must be as many, but only as
+ *        many, more digits as are needed to uniquely distinguish the
+ *        number from all other IEEE 754 numeric values.
+ *    - The boolean false value is converted to the string false.
+ *      The boolean true value is converted to the string true.
+ *
+ * If the argument is omitted, it defaults to a node-set with the
+ * context node as its only member.
+ */
+void
+xmlXPathStringFunction(xmlXPathParserContextPtr ctxt, int nargs) {
+    xmlXPathObjectPtr cur;
+
+    if (nargs == 0) {
+	valuePush(ctxt,
+		  xmlXPathWrapString(
+			xmlXPathCastNodeToString(ctxt->context->node)));
+	return;
+    }
+
+    CHECK_ARITY(1);
+    cur = valuePop(ctxt);
+    if (cur == NULL) XP_ERROR(XPATH_INVALID_OPERAND);
+    cur = xmlXPathConvertString(cur);
+    valuePush(ctxt, cur);
+}
+
+/**
+ * xmlXPathStringLengthFunction:
+ * @ctxt:  the XPath Parser context
+ * @nargs:  the number of arguments
+ *
+ * Implement the string-length() XPath function
+ *    number string-length(string?)
+ * The string-length returns the number of characters in the string
+ * (see [3.6 Strings]). If the argument is omitted, it defaults to
+ * the context node converted to a string, in other words the value
+ * of the context node.
+ */
+void
+xmlXPathStringLengthFunction(xmlXPathParserContextPtr ctxt, int nargs) {
+    xmlXPathObjectPtr cur;
+
+    if (nargs == 0) {
+	if (ctxt->context->node == NULL) {
+	    valuePush(ctxt, xmlXPathNewFloat(0));
+	} else {
+	    xmlChar *content;
+
+	    content = xmlXPathCastNodeToString(ctxt->context->node);
+	    valuePush(ctxt, xmlXPathNewFloat(xmlUTF8Strlen(content)));
+	    xmlFree(content);
+	}
+	return;
+    }
+    CHECK_ARITY(1);
+    CAST_TO_STRING;
+    CHECK_TYPE(XPATH_STRING);
+    cur = valuePop(ctxt);
+    valuePush(ctxt, xmlXPathNewFloat(xmlUTF8Strlen(cur->stringval)));
+    xmlXPathFreeObject(cur);
+}
+
+/**
+ * xmlXPathConcatFunction:
+ * @ctxt:  the XPath Parser context
+ * @nargs:  the number of arguments
+ *
+ * Implement the concat() XPath function
+ *    string concat(string, string, string*)
+ * The concat function returns the concatenation of its arguments.
+ */
+void
+xmlXPathConcatFunction(xmlXPathParserContextPtr ctxt, int nargs) {
+    xmlXPathObjectPtr cur, newobj;
+    xmlChar *tmp;
+
+    if (nargs < 2) {
+	CHECK_ARITY(2);
+    }
+
+    CAST_TO_STRING;
+    cur = valuePop(ctxt);
+    if ((cur == NULL) || (cur->type != XPATH_STRING)) {
+        xmlXPathFreeObject(cur);
+	return;
+    }
+    nargs--;
+
+    while (nargs > 0) {
+	CAST_TO_STRING;
+	newobj = valuePop(ctxt);
+	if ((newobj == NULL) || (newobj->type != XPATH_STRING)) {
+	    xmlXPathFreeObject(newobj);
+	    xmlXPathFreeObject(cur);
+	    XP_ERROR(XPATH_INVALID_TYPE);
+	}
+	tmp = xmlStrcat(newobj->stringval, cur->stringval);
+	newobj->stringval = cur->stringval;
+	cur->stringval = tmp;
+
+	xmlXPathFreeObject(newobj);
+	nargs--;
+    }
+    valuePush(ctxt, cur);
+}
+
+/**
+ * xmlXPathContainsFunction:
+ * @ctxt:  the XPath Parser context
+ * @nargs:  the number of arguments
+ *
+ * Implement the contains() XPath function
+ *    boolean contains(string, string)
+ * The contains function returns true if the first argument string
+ * contains the second argument string, and otherwise returns false.
+ */
+void
+xmlXPathContainsFunction(xmlXPathParserContextPtr ctxt, int nargs) {
+    xmlXPathObjectPtr hay, needle;
+
+    CHECK_ARITY(2);
+    CAST_TO_STRING;
+    CHECK_TYPE(XPATH_STRING);
+    needle = valuePop(ctxt);
+    CAST_TO_STRING;
+    hay = valuePop(ctxt);
+    if ((hay == NULL) || (hay->type != XPATH_STRING)) {
+        xmlXPathFreeObject(hay);
+        xmlXPathFreeObject(needle);
+	XP_ERROR(XPATH_INVALID_TYPE);
+    }
+    if (xmlStrstr(hay->stringval, needle->stringval))
+        valuePush(ctxt, xmlXPathNewBoolean(1));
+    else
+        valuePush(ctxt, xmlXPathNewBoolean(0));
+    xmlXPathFreeObject(hay);
+    xmlXPathFreeObject(needle);
+}
+
+/**
+ * xmlXPathStartsWithFunction:
+ * @ctxt:  the XPath Parser context
+ * @nargs:  the number of arguments
+ *
+ * Implement the starts-with() XPath function
+ *    boolean starts-with(string, string)
+ * The starts-with function returns true if the first argument string
+ * starts with the second argument string, and otherwise returns false.
+ */
+void
+xmlXPathStartsWithFunction(xmlXPathParserContextPtr ctxt, int nargs) {
+    xmlXPathObjectPtr hay, needle;
+    int n;
+
+    CHECK_ARITY(2);
+    CAST_TO_STRING;
+    CHECK_TYPE(XPATH_STRING);
+    needle = valuePop(ctxt);
+    CAST_TO_STRING;
+    hay = valuePop(ctxt);
+    if ((hay == NULL) || (hay->type != XPATH_STRING)) {
+        xmlXPathFreeObject(hay);
+        xmlXPathFreeObject(needle);
+	XP_ERROR(XPATH_INVALID_TYPE);
+    }
+    n = xmlStrlen(needle->stringval);
+    if (xmlStrncmp(hay->stringval, needle->stringval, n))
+        valuePush(ctxt, xmlXPathNewBoolean(0));
+    else
+        valuePush(ctxt, xmlXPathNewBoolean(1));
+    xmlXPathFreeObject(hay);
+    xmlXPathFreeObject(needle);
+}
+
+/**
+ * xmlXPathSubstringFunction:
+ * @ctxt:  the XPath Parser context
+ * @nargs:  the number of arguments
+ *
+ * Implement the substring() XPath function
+ *    string substring(string, number, number?)
+ * The substring function returns the substring of the first argument
+ * starting at the position specified in the second argument with
+ * length specified in the third argument. For example,
+ * substring("12345",2,3) returns "234". If the third argument is not
+ * specified, it returns the substring starting at the position specified
+ * in the second argument and continuing to the end of the string. For
+ * example, substring("12345",2) returns "2345".  More precisely, each
+ * character in the string (see [3.6 Strings]) is considered to have a
+ * numeric position: the position of the first character is 1, the position
+ * of the second character is 2 and so on. The returned substring contains
+ * those characters for which the position of the character is greater than
+ * or equal to the second argument and, if the third argument is specified,
+ * less than the sum of the second and third arguments; the comparisons
+ * and addition used for the above follow the standard IEEE 754 rules. Thus:
+ *  - substring("12345", 1.5, 2.6) returns "234" 
+ *  - substring("12345", 0, 3) returns "12" 
+ *  - substring("12345", 0 div 0, 3) returns "" 
+ *  - substring("12345", 1, 0 div 0) returns "" 
+ *  - substring("12345", -42, 1 div 0) returns "12345" 
+ *  - substring("12345", -1 div 0, 1 div 0) returns "" 
+ */
+void
+xmlXPathSubstringFunction(xmlXPathParserContextPtr ctxt, int nargs) {
+    xmlXPathObjectPtr str, start, len;
+    double le=0, in;
+    int i, l, m;
+    xmlChar *ret;
+
+    if (nargs < 2) {
+	CHECK_ARITY(2);
+    }
+    if (nargs > 3) {
+	CHECK_ARITY(3);
+    }
+    /*
+     * take care of possible last (position) argument
+    */
+    if (nargs == 3) {
+	CAST_TO_NUMBER;
+	CHECK_TYPE(XPATH_NUMBER);
+	len = valuePop(ctxt);
+	le = len->floatval;
+        xmlXPathFreeObject(len);
+    }
+
+    CAST_TO_NUMBER;
+    CHECK_TYPE(XPATH_NUMBER);
+    start = valuePop(ctxt);
+    in = start->floatval;
+    xmlXPathFreeObject(start);
+    CAST_TO_STRING;
+    CHECK_TYPE(XPATH_STRING);
+    str = valuePop(ctxt);
+    m = xmlUTF8Strlen((const unsigned char *)str->stringval);
+
+    /*
+     * If last pos not present, calculate last position
+    */
+    if (nargs != 3) {
+	le = (double)m;
+	if (in < 1.0) 
+	    in = 1.0;
+    }
+
+    /* Need to check for the special cases where either 
+     * the index is NaN, the length is NaN, or both
+     * arguments are infinity (relying on Inf + -Inf = NaN)
+     */
+    if (!xmlXPathIsNaN(in + le) && !xmlXPathIsInf(in)) {
+        /*
+         * To meet the requirements of the spec, the arguments
+	 * must be converted to integer format before 
+	 * initial index calculations are done
+         *
+         * First we go to integer form, rounding up
+	 * and checking for special cases
+         */
+        i = (int) in;
+        if (((double)i)+0.5 <= in) i++;
+
+	if (xmlXPathIsInf(le) == 1) {
+	    l = m;
+	    if (i < 1)
+		i = 1;
+	}
+	else if (xmlXPathIsInf(le) == -1 || le < 0.0)
+	    l = 0;
+	else {
+	    l = (int) le;
+	    if (((double)l)+0.5 <= le) l++;
+	}
+
+	/* Now we normalize inidices */
+        i -= 1;
+        l += i;
+        if (i < 0)
+            i = 0;
+        if (l > m)
+            l = m;
+
+        /* number of chars to copy */
+        l -= i;
+
+        ret = xmlUTF8Strsub(str->stringval, i, l);
+    }
+    else {
+        ret = NULL;
+    }
+
+    if (ret == NULL)
+	valuePush(ctxt, xmlXPathNewCString(""));
+    else {
+	valuePush(ctxt, xmlXPathNewString(ret));
+	xmlFree(ret);
+    }
+
+    xmlXPathFreeObject(str);
+}
+
+/**
+ * xmlXPathSubstringBeforeFunction:
+ * @ctxt:  the XPath Parser context
+ * @nargs:  the number of arguments
+ *
+ * Implement the substring-before() XPath function
+ *    string substring-before(string, string)
+ * The substring-before function returns the substring of the first
+ * argument string that precedes the first occurrence of the second
+ * argument string in the first argument string, or the empty string
+ * if the first argument string does not contain the second argument
+ * string. For example, substring-before("1999/04/01","/") returns 1999.
+ */
+void
+xmlXPathSubstringBeforeFunction(xmlXPathParserContextPtr ctxt, int nargs) {
+  xmlXPathObjectPtr str;
+  xmlXPathObjectPtr find;
+  xmlBufferPtr target;
+  const xmlChar *point;
+  int offset;
+  
+  CHECK_ARITY(2);
+  CAST_TO_STRING;
+  find = valuePop(ctxt);
+  CAST_TO_STRING;
+  str = valuePop(ctxt);
+  
+  target = xmlBufferCreate();
+  if (target) {
+    point = xmlStrstr(str->stringval, find->stringval);
+    if (point) {
+      offset = (int)(point - str->stringval);
+      xmlBufferAdd(target, str->stringval, offset);
+    }
+    valuePush(ctxt, xmlXPathNewString(xmlBufferContent(target)));
+    xmlBufferFree(target);
+  }
+  
+  xmlXPathFreeObject(str);
+  xmlXPathFreeObject(find);
+}
+
+/**
+ * xmlXPathSubstringAfterFunction:
+ * @ctxt:  the XPath Parser context
+ * @nargs:  the number of arguments
+ *
+ * Implement the substring-after() XPath function
+ *    string substring-after(string, string)
+ * The substring-after function returns the substring of the first
+ * argument string that follows the first occurrence of the second
+ * argument string in the first argument string, or the empty stringi
+ * if the first argument string does not contain the second argument
+ * string. For example, substring-after("1999/04/01","/") returns 04/01,
+ * and substring-after("1999/04/01","19") returns 99/04/01.
+ */
+void
+xmlXPathSubstringAfterFunction(xmlXPathParserContextPtr ctxt, int nargs) {
+  xmlXPathObjectPtr str;
+  xmlXPathObjectPtr find;
+  xmlBufferPtr target;
+  const xmlChar *point;
+  int offset;
+  
+  CHECK_ARITY(2);
+  CAST_TO_STRING;
+  find = valuePop(ctxt);
+  CAST_TO_STRING;
+  str = valuePop(ctxt);
+  
+  target = xmlBufferCreate();
+  if (target) {
+    point = xmlStrstr(str->stringval, find->stringval);
+    if (point) {
+      offset = (int)(point - str->stringval) + xmlStrlen(find->stringval);
+      xmlBufferAdd(target, &str->stringval[offset],
+		   xmlStrlen(str->stringval) - offset);
+    }
+    valuePush(ctxt, xmlXPathNewString(xmlBufferContent(target)));
+    xmlBufferFree(target);
+  }
+  
+  xmlXPathFreeObject(str);
+  xmlXPathFreeObject(find);
+}
+
+/**
+ * xmlXPathNormalizeFunction:
+ * @ctxt:  the XPath Parser context
+ * @nargs:  the number of arguments
+ *
+ * Implement the normalize-space() XPath function
+ *    string normalize-space(string?)
+ * The normalize-space function returns the argument string with white
+ * space normalized by stripping leading and trailing whitespace
+ * and replacing sequences of whitespace characters by a single
+ * space. Whitespace characters are the same allowed by the S production
+ * in XML. If the argument is omitted, it defaults to the context
+ * node converted to a string, in other words the value of the context node.
+ */
+void
+xmlXPathNormalizeFunction(xmlXPathParserContextPtr ctxt, int nargs) {
+  xmlXPathObjectPtr obj = NULL;
+  xmlChar *source = NULL;
+  xmlBufferPtr target;
+  xmlChar blank;
+  
+  if (nargs == 0) {
+    /* Use current context node */
+    valuePush(ctxt,
+	      xmlXPathWrapString(
+		  xmlXPathCastNodeToString(ctxt->context->node)));
+    nargs = 1;
+  }
+
+  CHECK_ARITY(1);
+  CAST_TO_STRING;
+  CHECK_TYPE(XPATH_STRING);
+  obj = valuePop(ctxt);
+  source = obj->stringval;
+
+  target = xmlBufferCreate();
+  if (target && source) {
+    
+    /* Skip leading whitespaces */
+    while (IS_BLANK_CH(*source))
+      source++;
+  
+    /* Collapse intermediate whitespaces, and skip trailing whitespaces */
+    blank = 0;
+    while (*source) {
+      if (IS_BLANK_CH(*source)) {
+	blank = 0x20;
+      } else {
+	if (blank) {
+	  xmlBufferAdd(target, &blank, 1);
+	  blank = 0;
+	}
+	xmlBufferAdd(target, source, 1);
+      }
+      source++;
+    }
+  
+    valuePush(ctxt, xmlXPathNewString(xmlBufferContent(target)));
+    xmlBufferFree(target);
+  }
+  xmlXPathFreeObject(obj);
+}
+
+/**
+ * xmlXPathTranslateFunction:
+ * @ctxt:  the XPath Parser context
+ * @nargs:  the number of arguments
+ *
+ * Implement the translate() XPath function
+ *    string translate(string, string, string)
+ * The translate function returns the first argument string with
+ * occurrences of characters in the second argument string replaced
+ * by the character at the corresponding position in the third argument
+ * string. For example, translate("bar","abc","ABC") returns the string
+ * BAr. If there is a character in the second argument string with no
+ * character at a corresponding position in the third argument string
+ * (because the second argument string is longer than the third argument
+ * string), then occurrences of that character in the first argument
+ * string are removed. For example, translate("--aaa--","abc-","ABC")
+ * returns "AAA". If a character occurs more than once in second
+ * argument string, then the first occurrence determines the replacement
+ * character. If the third argument string is longer than the second
+ * argument string, then excess characters are ignored.
+ */
+void
+xmlXPathTranslateFunction(xmlXPathParserContextPtr ctxt, int nargs) {
+    xmlXPathObjectPtr str;
+    xmlXPathObjectPtr from;
+    xmlXPathObjectPtr to;
+    xmlBufferPtr target;
+    int offset, max;
+    xmlChar ch;
+    xmlChar *point;
+    xmlChar *cptr;
+
+    CHECK_ARITY(3);
+
+    CAST_TO_STRING;
+    to = valuePop(ctxt);
+    CAST_TO_STRING;
+    from = valuePop(ctxt);
+    CAST_TO_STRING;
+    str = valuePop(ctxt);
+
+    target = xmlBufferCreate();
+    if (target) {
+	max = xmlUTF8Strlen(to->stringval);
+	for (cptr = str->stringval; (ch=*cptr); ) {
+	    offset = xmlUTF8Strloc(from->stringval, cptr);
+	    if (offset >= 0) {
+		if (offset < max) {
+		    point = xmlUTF8Strpos(to->stringval, offset);
+		    if (point)
+			xmlBufferAdd(target, point, xmlUTF8Strsize(point, 1));
+		}
+	    } else
+		xmlBufferAdd(target, cptr, xmlUTF8Strsize(cptr, 1));
+
+	    /* Step to next character in input */
+	    cptr++;
+	    if ( ch & 0x80 ) {
+		/* if not simple ascii, verify proper format */
+		if ( (ch & 0xc0) != 0xc0 ) {
+		    xmlGenericError(xmlGenericErrorContext,
+			"xmlXPathTranslateFunction: Invalid UTF8 string\n");
+		    break;
+		}
+		/* then skip over remaining bytes for this char */
+		while ( (ch <<= 1) & 0x80 )
+		    if ( (*cptr++ & 0xc0) != 0x80 ) {
+			xmlGenericError(xmlGenericErrorContext,
+			    "xmlXPathTranslateFunction: Invalid UTF8 string\n");
+			break;
+		    }
+		if (ch & 0x80) /* must have had error encountered */
+		    break;
+	    }
+	}
+    }
+    valuePush(ctxt, xmlXPathNewString(xmlBufferContent(target)));
+    xmlBufferFree(target);
+    xmlXPathFreeObject(str);
+    xmlXPathFreeObject(from);
+    xmlXPathFreeObject(to);
+}
+
+/**
+ * xmlXPathBooleanFunction:
+ * @ctxt:  the XPath Parser context
+ * @nargs:  the number of arguments
+ *
+ * Implement the boolean() XPath function
+ *    boolean boolean(object)
+ * The boolean function converts its argument to a boolean as follows:
+ *    - a number is true if and only if it is neither positive or
+ *      negative zero nor NaN
+ *    - a node-set is true if and only if it is non-empty
+ *    - a string is true if and only if its length is non-zero
+ */
+void
+xmlXPathBooleanFunction(xmlXPathParserContextPtr ctxt, int nargs) {
+    xmlXPathObjectPtr cur;
+
+    CHECK_ARITY(1);
+    cur = valuePop(ctxt);
+    if (cur == NULL) XP_ERROR(XPATH_INVALID_OPERAND);
+    cur = xmlXPathConvertBoolean(cur);
+    valuePush(ctxt, cur);
+}
+
+/**
+ * xmlXPathNotFunction:
+ * @ctxt:  the XPath Parser context
+ * @nargs:  the number of arguments
+ *
+ * Implement the not() XPath function
+ *    boolean not(boolean)
+ * The not function returns true if its argument is false,
+ * and false otherwise.
+ */
+void
+xmlXPathNotFunction(xmlXPathParserContextPtr ctxt, int nargs) {
+    CHECK_ARITY(1);
+    CAST_TO_BOOLEAN;
+    CHECK_TYPE(XPATH_BOOLEAN);
+    ctxt->value->boolval = ! ctxt->value->boolval;
+}
+
+/**
+ * xmlXPathTrueFunction:
+ * @ctxt:  the XPath Parser context
+ * @nargs:  the number of arguments
+ *
+ * Implement the true() XPath function
+ *    boolean true()
+ */
+void
+xmlXPathTrueFunction(xmlXPathParserContextPtr ctxt, int nargs) {
+    CHECK_ARITY(0);
+    valuePush(ctxt, xmlXPathNewBoolean(1));
+}
+
+/**
+ * xmlXPathFalseFunction:
+ * @ctxt:  the XPath Parser context
+ * @nargs:  the number of arguments
+ *
+ * Implement the false() XPath function
+ *    boolean false()
+ */
+void
+xmlXPathFalseFunction(xmlXPathParserContextPtr ctxt, int nargs) {
+    CHECK_ARITY(0);
+    valuePush(ctxt, xmlXPathNewBoolean(0));
+}
+
+/**
+ * xmlXPathLangFunction:
+ * @ctxt:  the XPath Parser context
+ * @nargs:  the number of arguments
+ *
+ * Implement the lang() XPath function
+ *    boolean lang(string)
+ * The lang function returns true or false depending on whether the
+ * language of the context node as specified by xml:lang attributes
+ * is the same as or is a sublanguage of the language specified by
+ * the argument string. The language of the context node is determined
+ * by the value of the xml:lang attribute on the context node, or, if
+ * the context node has no xml:lang attribute, by the value of the
+ * xml:lang attribute on the nearest ancestor of the context node that
+ * has an xml:lang attribute. If there is no such attribute, then lang
+ * returns false. If there is such an attribute, then lang returns
+ * true if the attribute value is equal to the argument ignoring case,
+ * or if there is some suffix starting with - such that the attribute
+ * value is equal to the argument ignoring that suffix of the attribute
+ * value and ignoring case.
+ */
+void
+xmlXPathLangFunction(xmlXPathParserContextPtr ctxt, int nargs) {
+    xmlXPathObjectPtr val;
+    const xmlChar *theLang;
+    const xmlChar *lang;
+    int ret = 0;
+    int i;
+
+    CHECK_ARITY(1);
+    CAST_TO_STRING;
+    CHECK_TYPE(XPATH_STRING);
+    val = valuePop(ctxt);
+    lang = val->stringval;
+    theLang = xmlNodeGetLang(ctxt->context->node);
+    if ((theLang != NULL) && (lang != NULL)) {
+        for (i = 0;lang[i] != 0;i++)
+	    if (toupper(lang[i]) != toupper(theLang[i]))
+	        goto not_equal;
+        ret = 1;
+    }
+not_equal:
+    xmlFree((void *)theLang);
+    xmlXPathFreeObject(val);
+    valuePush(ctxt, xmlXPathNewBoolean(ret));
+}
+
+/**
+ * xmlXPathNumberFunction:
+ * @ctxt:  the XPath Parser context
+ * @nargs:  the number of arguments
+ *
+ * Implement the number() XPath function
+ *    number number(object?)
+ */
+void
+xmlXPathNumberFunction(xmlXPathParserContextPtr ctxt, int nargs) {
+    xmlXPathObjectPtr cur;
+    double res;
+
+    if (nargs == 0) {
+	if (ctxt->context->node == NULL) {
+	    valuePush(ctxt, xmlXPathNewFloat(0.0));
+	} else {
+	    xmlChar* content = xmlNodeGetContent(ctxt->context->node);
+
+	    res = xmlXPathStringEvalNumber(content);
+	    valuePush(ctxt, xmlXPathNewFloat(res));
+	    xmlFree(content);
+	}
+	return;
+    }
+
+    CHECK_ARITY(1);
+    cur = valuePop(ctxt);
+    cur = xmlXPathConvertNumber(cur);
+    valuePush(ctxt, cur);
+}
+
+/**
+ * xmlXPathSumFunction:
+ * @ctxt:  the XPath Parser context
+ * @nargs:  the number of arguments
+ *
+ * Implement the sum() XPath function
+ *    number sum(node-set)
+ * The sum function returns the sum of the values of the nodes in
+ * the argument node-set.
+ */
+void
+xmlXPathSumFunction(xmlXPathParserContextPtr ctxt, int nargs) {
+    xmlXPathObjectPtr cur;
+    int i;
+    double res = 0.0;
+
+    CHECK_ARITY(1);
+    if ((ctxt->value == NULL) || 
+	((ctxt->value->type != XPATH_NODESET) &&
+	 (ctxt->value->type != XPATH_XSLT_TREE)))
+	XP_ERROR(XPATH_INVALID_TYPE);
+    cur = valuePop(ctxt);
+
+    if ((cur->nodesetval != NULL) && (cur->nodesetval->nodeNr != 0)) {
+	for (i = 0; i < cur->nodesetval->nodeNr; i++) {
+	    res += xmlXPathCastNodeToNumber(cur->nodesetval->nodeTab[i]);
+	}
+    }
+    valuePush(ctxt, xmlXPathNewFloat(res));
+    xmlXPathFreeObject(cur);
+}
+
+/**
+ * xmlXPathFloorFunction:
+ * @ctxt:  the XPath Parser context
+ * @nargs:  the number of arguments
+ *
+ * Implement the floor() XPath function
+ *    number floor(number)
+ * The floor function returns the largest (closest to positive infinity)
+ * number that is not greater than the argument and that is an integer.
+ */
+void
+xmlXPathFloorFunction(xmlXPathParserContextPtr ctxt, int nargs) {
+    double f;
+
+    CHECK_ARITY(1);
+    CAST_TO_NUMBER;
+    CHECK_TYPE(XPATH_NUMBER);
+
+    f = (double)((int) ctxt->value->floatval);
+    if (f != ctxt->value->floatval) {
+	if (ctxt->value->floatval > 0)
+	    ctxt->value->floatval = f;
+	else
+	    ctxt->value->floatval = f - 1;
+    }
+}
+
+/**
+ * xmlXPathCeilingFunction:
+ * @ctxt:  the XPath Parser context
+ * @nargs:  the number of arguments
+ *
+ * Implement the ceiling() XPath function
+ *    number ceiling(number)
+ * The ceiling function returns the smallest (closest to negative infinity)
+ * number that is not less than the argument and that is an integer.
+ */
+void
+xmlXPathCeilingFunction(xmlXPathParserContextPtr ctxt, int nargs) {
+    double f;
+
+    CHECK_ARITY(1);
+    CAST_TO_NUMBER;
+    CHECK_TYPE(XPATH_NUMBER);
+
+#if 0
+    ctxt->value->floatval = ceil(ctxt->value->floatval);
+#else
+    f = (double)((int) ctxt->value->floatval);
+    if (f != ctxt->value->floatval) {
+	if (ctxt->value->floatval > 0)
+	    ctxt->value->floatval = f + 1;
+	else {
+	    if (ctxt->value->floatval < 0 && f == 0)
+	        ctxt->value->floatval = xmlXPathNZERO;
+	    else
+	        ctxt->value->floatval = f;
+	}
+
+    }
+#endif
+}
+
+/**
+ * xmlXPathRoundFunction:
+ * @ctxt:  the XPath Parser context
+ * @nargs:  the number of arguments
+ *
+ * Implement the round() XPath function
+ *    number round(number)
+ * The round function returns the number that is closest to the
+ * argument and that is an integer. If there are two such numbers,
+ * then the one that is even is returned.
+ */
+void
+xmlXPathRoundFunction(xmlXPathParserContextPtr ctxt, int nargs) {
+    double f;
+
+    CHECK_ARITY(1);
+    CAST_TO_NUMBER;
+    CHECK_TYPE(XPATH_NUMBER);
+
+    if ((xmlXPathIsNaN(ctxt->value->floatval)) ||
+	(xmlXPathIsInf(ctxt->value->floatval) == 1) ||
+	(xmlXPathIsInf(ctxt->value->floatval) == -1) ||
+	(ctxt->value->floatval == 0.0))
+	return;
+
+    f = (double)((int) ctxt->value->floatval);
+    if (ctxt->value->floatval < 0) {
+	if (ctxt->value->floatval < f - 0.5)
+	    ctxt->value->floatval = f - 1;
+	else 
+	    ctxt->value->floatval = f;
+	if (ctxt->value->floatval == 0)
+	    ctxt->value->floatval = xmlXPathNZERO;
+    } else {
+	if (ctxt->value->floatval < f + 0.5)
+	    ctxt->value->floatval = f;
+	else 
+	    ctxt->value->floatval = f + 1;
+    }
+}
+
+/************************************************************************
+ *									*
+ *			The Parser					*
+ *									*
+ ************************************************************************/
+
+/*
+ * a few forward declarations since we use a recursive call based
+ * implementation.
+ */
+static void xmlXPathCompileExpr(xmlXPathParserContextPtr ctxt);
+static void xmlXPathCompPredicate(xmlXPathParserContextPtr ctxt, int filter);
+static void xmlXPathCompLocationPath(xmlXPathParserContextPtr ctxt);
+static void xmlXPathCompRelativeLocationPath(xmlXPathParserContextPtr ctxt);
+static xmlChar * xmlXPathParseNameComplex(xmlXPathParserContextPtr ctxt,
+	                                  int qualified);
+
+/**
+ * xmlXPathCurrentChar:
+ * @ctxt:  the XPath parser context
+ * @cur:  pointer to the beginning of the char
+ * @len:  pointer to the length of the char read
+ *
+ * The current char value, if using UTF-8 this may actually span multiple
+ * bytes in the input buffer.
+ *
+ * Returns the current char value and its length
+ */
+
+static int
+xmlXPathCurrentChar(xmlXPathParserContextPtr ctxt, int *len) {
+    unsigned char c;
+    unsigned int val;
+    const xmlChar *cur;
+
+    if (ctxt == NULL)
+	return(0);
+    cur = ctxt->cur;
+
+    /*
+     * We are supposed to handle UTF8, check it's valid
+     * From rfc2044: encoding of the Unicode values on UTF-8:
+     *
+     * UCS-4 range (hex.)           UTF-8 octet sequence (binary)
+     * 0000 0000-0000 007F   0xxxxxxx
+     * 0000 0080-0000 07FF   110xxxxx 10xxxxxx
+     * 0000 0800-0000 FFFF   1110xxxx 10xxxxxx 10xxxxxx 
+     *
+     * Check for the 0x110000 limit too
+     */
+    c = *cur;
+    if (c & 0x80) {
+	if ((cur[1] & 0xc0) != 0x80)
+	    goto encoding_error;
+	if ((c & 0xe0) == 0xe0) {
+
+	    if ((cur[2] & 0xc0) != 0x80)
+		goto encoding_error;
+	    if ((c & 0xf0) == 0xf0) {
+		if (((c & 0xf8) != 0xf0) ||
+		    ((cur[3] & 0xc0) != 0x80))
+		    goto encoding_error;
+		/* 4-byte code */
+		*len = 4;
+		val = (cur[0] & 0x7) << 18;
+		val |= (cur[1] & 0x3f) << 12;
+		val |= (cur[2] & 0x3f) << 6;
+		val |= cur[3] & 0x3f;
+	    } else {
+	      /* 3-byte code */
+		*len = 3;
+		val = (cur[0] & 0xf) << 12;
+		val |= (cur[1] & 0x3f) << 6;
+		val |= cur[2] & 0x3f;
+	    }
+	} else {
+	  /* 2-byte code */
+	    *len = 2;
+	    val = (cur[0] & 0x1f) << 6;
+	    val |= cur[1] & 0x3f;
+	}
+	if (!IS_CHAR(val)) {
+	    XP_ERROR0(XPATH_INVALID_CHAR_ERROR);
+	}    
+	return(val);
+    } else {
+	/* 1-byte code */
+	*len = 1;
+	return((int) *cur);
+    }
+encoding_error:
+    /*
+     * If we detect an UTF8 error that probably means that the
+     * input encoding didn't get properly advertised in the
+     * declaration header. Report the error and switch the encoding
+     * to ISO-Latin-1 (if you don't like this policy, just declare the
+     * encoding !)
+     */
+    *len = 0;
+    XP_ERROR0(XPATH_ENCODING_ERROR);
+}
+
+/**
+ * xmlXPathParseNCName:
+ * @ctxt:  the XPath Parser context
+ *
+ * parse an XML namespace non qualified name.
+ *
+ * [NS 3] NCName ::= (Letter | '_') (NCNameChar)*
+ *
+ * [NS 4] NCNameChar ::= Letter | Digit | '.' | '-' | '_' |
+ *                       CombiningChar | Extender
+ *
+ * Returns the namespace name or NULL
+ */
+
+xmlChar *
+xmlXPathParseNCName(xmlXPathParserContextPtr ctxt) {
+    const xmlChar *in;
+    xmlChar *ret;
+    int count = 0;
+
+    /*
+     * Accelerator for simple ASCII names
+     */
+    in = ctxt->cur;
+    if (((*in >= 0x61) && (*in <= 0x7A)) ||
+	((*in >= 0x41) && (*in <= 0x5A)) ||
+	(*in == '_')) {
+	in++;
+	while (((*in >= 0x61) && (*in <= 0x7A)) ||
+	       ((*in >= 0x41) && (*in <= 0x5A)) ||
+	       ((*in >= 0x30) && (*in <= 0x39)) ||
+	       (*in == '_') || (*in == '.') ||
+	       (*in == '-'))
+	    in++;
+	if ((*in == ' ') || (*in == '>') || (*in == '/') ||
+            (*in == '[') || (*in == ']') || (*in == ':') ||
+            (*in == '@') || (*in == '*')) {
+	    count = in - ctxt->cur;
+	    if (count == 0)
+		return(NULL);
+	    ret = xmlStrndup(ctxt->cur, count);
+	    ctxt->cur = in;
+	    return(ret);
+	}
+    }
+    return(xmlXPathParseNameComplex(ctxt, 0));
+}
+
+
+/**
+ * xmlXPathParseQName:
+ * @ctxt:  the XPath Parser context
+ * @prefix:  a xmlChar ** 
+ *
+ * parse an XML qualified name
+ *
+ * [NS 5] QName ::= (Prefix ':')? LocalPart
+ *
+ * [NS 6] Prefix ::= NCName
+ *
+ * [NS 7] LocalPart ::= NCName
+ *
+ * Returns the function returns the local part, and prefix is updated
+ *   to get the Prefix if any.
+ */
+
+static xmlChar *
+xmlXPathParseQName(xmlXPathParserContextPtr ctxt, xmlChar **prefix) {
+    xmlChar *ret = NULL;
+
+    *prefix = NULL;
+    ret = xmlXPathParseNCName(ctxt);
+    if (CUR == ':') {
+        *prefix = ret;
+	NEXT;
+	ret = xmlXPathParseNCName(ctxt);
+    }
+    return(ret);
+}
+
+/**
+ * xmlXPathParseName:
+ * @ctxt:  the XPath Parser context
+ *
+ * parse an XML name
+ *
+ * [4] NameChar ::= Letter | Digit | '.' | '-' | '_' | ':' |
+ *                  CombiningChar | Extender
+ *
+ * [5] Name ::= (Letter | '_' | ':') (NameChar)*
+ *
+ * Returns the namespace name or NULL
+ */
+
+xmlChar *
+xmlXPathParseName(xmlXPathParserContextPtr ctxt) {
+    const xmlChar *in;
+    xmlChar *ret;
+    int count = 0;
+
+    /*
+     * Accelerator for simple ASCII names
+     */
+    in = ctxt->cur;
+    if (((*in >= 0x61) && (*in <= 0x7A)) ||
+	((*in >= 0x41) && (*in <= 0x5A)) ||
+	(*in == '_') || (*in == ':')) {
+	in++;
+	while (((*in >= 0x61) && (*in <= 0x7A)) ||
+	       ((*in >= 0x41) && (*in <= 0x5A)) ||
+	       ((*in >= 0x30) && (*in <= 0x39)) ||
+	       (*in == '_') || (*in == '-') ||
+	       (*in == ':') || (*in == '.'))
+	    in++;
+	if ((*in > 0) && (*in < 0x80)) {
+	    count = in - ctxt->cur;
+	    ret = xmlStrndup(ctxt->cur, count);
+	    ctxt->cur = in;
+	    return(ret);
+	}
+    }
+    return(xmlXPathParseNameComplex(ctxt, 1));
+}
+
+static xmlChar *
+xmlXPathParseNameComplex(xmlXPathParserContextPtr ctxt, int qualified) {
+    xmlChar buf[XML_MAX_NAMELEN + 5];
+    int len = 0, l;
+    int c;
+
+    /*
+     * Handler for more complex cases
+     */
+    c = CUR_CHAR(l);
+    if ((c == ' ') || (c == '>') || (c == '/') || /* accelerators */
+        (c == '[') || (c == ']') || (c == '@') || /* accelerators */
+        (c == '*') || /* accelerators */
+	(!IS_LETTER(c) && (c != '_') &&
+         ((qualified) && (c != ':')))) {
+	return(NULL);
+    }
+
+    while ((c != ' ') && (c != '>') && (c != '/') && /* test bigname.xml */
+	   ((IS_LETTER(c)) || (IS_DIGIT(c)) ||
+            (c == '.') || (c == '-') ||
+	    (c == '_') || ((qualified) && (c == ':')) || 
+	    (IS_COMBINING(c)) ||
+	    (IS_EXTENDER(c)))) {
+	COPY_BUF(l,buf,len,c);
+	NEXTL(l);
+	c = CUR_CHAR(l);
+	if (len >= XML_MAX_NAMELEN) {
+	    /*
+	     * Okay someone managed to make a huge name, so he's ready to pay
+	     * for the processing speed.
+	     */
+	    xmlChar *buffer;
+	    int max = len * 2;
+	    
+	    buffer = (xmlChar *) xmlMallocAtomic(max * sizeof(xmlChar));
+	    if (buffer == NULL) {
+		XP_ERROR0(XPATH_MEMORY_ERROR);
+	    }
+	    memcpy(buffer, buf, len);
+	    while ((IS_LETTER(c)) || (IS_DIGIT(c)) || /* test bigname.xml */
+		   (c == '.') || (c == '-') ||
+		   (c == '_') || ((qualified) && (c == ':')) || 
+		   (IS_COMBINING(c)) ||
+		   (IS_EXTENDER(c))) {
+		if (len + 10 > max) {
+		    max *= 2;
+		    buffer = (xmlChar *) xmlRealloc(buffer,
+			                            max * sizeof(xmlChar));
+		    if (buffer == NULL) {
+			XP_ERROR0(XPATH_MEMORY_ERROR);
+		    }
+		}
+		COPY_BUF(l,buffer,len,c);
+		NEXTL(l);
+		c = CUR_CHAR(l);
+	    }
+	    buffer[len] = 0;
+	    return(buffer);
+	}
+    }
+    if (len == 0)
+	return(NULL);
+    return(xmlStrndup(buf, len));
+}
+
+#define MAX_FRAC 20
+
+/*
+ * These are used as divisors for the fractional part of a number.
+ * Since the table includes 1.0 (representing '0' fractional digits),
+ * it must be dimensioned at MAX_FRAC+1 (bug 133921)
+ */
+static double my_pow10[MAX_FRAC+1] = {
+    1.0, 10.0, 100.0, 1000.0, 10000.0,
+    100000.0, 1000000.0, 10000000.0, 100000000.0, 1000000000.0,
+    10000000000.0, 100000000000.0, 1000000000000.0, 10000000000000.0,
+    100000000000000.0,
+    1000000000000000.0, 10000000000000000.0, 100000000000000000.0,
+    1000000000000000000.0, 10000000000000000000.0, 100000000000000000000.0
+};
+
+/**
+ * xmlXPathStringEvalNumber:
+ * @str:  A string to scan
+ *
+ *  [30a]  Float  ::= Number ('e' Digits?)?
+ *
+ *  [30]   Number ::=   Digits ('.' Digits?)?
+ *                    | '.' Digits 
+ *  [31]   Digits ::=   [0-9]+
+ *
+ * Compile a Number in the string
+ * In complement of the Number expression, this function also handles
+ * negative values : '-' Number.
+ *
+ * Returns the double value.
+ */
+double
+xmlXPathStringEvalNumber(const xmlChar *str) {
+    const xmlChar *cur = str;
+    double ret;
+    int ok = 0;
+    int isneg = 0;
+    int exponent = 0;
+    int is_exponent_negative = 0;
+#ifdef __GNUC__
+    unsigned long tmp = 0;
+    double temp;
+#endif
+    if (cur == NULL) return(0);
+    while (IS_BLANK_CH(*cur)) cur++;
+    if ((*cur != '.') && ((*cur < '0') || (*cur > '9')) && (*cur != '-')) {
+        return(xmlXPathNAN);
+    }
+    if (*cur == '-') {
+	isneg = 1;
+	cur++;
+    }
+
+#ifdef __GNUC__
+    /*
+     * tmp/temp is a workaround against a gcc compiler bug
+     * http://veillard.com/gcc.bug
+     */
+    ret = 0;
+    while ((*cur >= '0') && (*cur <= '9')) {
+	ret = ret * 10;
+	tmp = (*cur - '0');
+	ok = 1;
+	cur++;
+	temp = (double) tmp;
+	ret = ret + temp;
+    }
+#else
+    ret = 0;
+    while ((*cur >= '0') && (*cur <= '9')) {
+	ret = ret * 10 + (*cur - '0');
+	ok = 1;
+	cur++;
+    }
+#endif
+
+    if (*cur == '.') {
+	int v, frac = 0;
+	double fraction = 0;
+
+        cur++;
+	if (((*cur < '0') || (*cur > '9')) && (!ok)) {
+	    return(xmlXPathNAN);
+	}
+	while (((*cur >= '0') && (*cur <= '9')) && (frac < MAX_FRAC)) {
+	    v = (*cur - '0');
+	    fraction = fraction * 10 + v;
+	    frac = frac + 1;
+	    cur++;
+	}
+	fraction /= my_pow10[frac];
+	ret = ret + fraction;
+	while ((*cur >= '0') && (*cur <= '9'))
+	    cur++;
+    }
+    if ((*cur == 'e') || (*cur == 'E')) {
+      cur++;
+      if (*cur == '-') {
+	is_exponent_negative = 1;
+	cur++;
+      }
+      while ((*cur >= '0') && (*cur <= '9')) {
+	exponent = exponent * 10 + (*cur - '0');
+	cur++;
+      }
+    }
+    while (IS_BLANK_CH(*cur)) cur++;
+    if (*cur != 0) return(xmlXPathNAN);
+    if (isneg) ret = -ret;
+    if (is_exponent_negative) exponent = -exponent;
+    ret *= pow(10.0, (double)exponent);
+    return(ret);
+}
+
+/**
+ * xmlXPathCompNumber:
+ * @ctxt:  the XPath Parser context
+ *
+ *  [30]   Number ::=   Digits ('.' Digits?)?
+ *                    | '.' Digits 
+ *  [31]   Digits ::=   [0-9]+
+ *
+ * Compile a Number, then push it on the stack
+ *
+ */
+static void
+xmlXPathCompNumber(xmlXPathParserContextPtr ctxt)
+{
+    double ret = 0.0;
+    double mult = 1;
+    int ok = 0;
+    int exponent = 0;
+    int is_exponent_negative = 0;
+#ifdef __GNUC__
+    unsigned long tmp = 0;
+    double temp;
+#endif
+
+    CHECK_ERROR;
+    if ((CUR != '.') && ((CUR < '0') || (CUR > '9'))) {
+        XP_ERROR(XPATH_NUMBER_ERROR);
+    }
+#ifdef __GNUC__
+    /*
+     * tmp/temp is a workaround against a gcc compiler bug
+     * http://veillard.com/gcc.bug
+     */
+    ret = 0;
+    while ((CUR >= '0') && (CUR <= '9')) {
+	ret = ret * 10;
+	tmp = (CUR - '0');
+        ok = 1;
+        NEXT;
+	temp = (double) tmp;
+	ret = ret + temp;
+    }
+#else
+    ret = 0;
+    while ((CUR >= '0') && (CUR <= '9')) {
+	ret = ret * 10 + (CUR - '0');
+	ok = 1;
+	NEXT;
+    }
+#endif
+    if (CUR == '.') {
+        NEXT;
+        if (((CUR < '0') || (CUR > '9')) && (!ok)) {
+            XP_ERROR(XPATH_NUMBER_ERROR);
+        }
+        while ((CUR >= '0') && (CUR <= '9')) {
+            mult /= 10;
+            ret = ret + (CUR - '0') * mult;
+            NEXT;
+        }
+    }
+    if ((CUR == 'e') || (CUR == 'E')) {
+        NEXT;
+        if (CUR == '-') {
+            is_exponent_negative = 1;
+            NEXT;
+        }
+        while ((CUR >= '0') && (CUR <= '9')) {
+            exponent = exponent * 10 + (CUR - '0');
+            NEXT;
+        }
+        if (is_exponent_negative)
+            exponent = -exponent;
+        ret *= pow(10.0, (double) exponent);
+    }
+    PUSH_LONG_EXPR(XPATH_OP_VALUE, XPATH_NUMBER, 0, 0,
+                   xmlXPathNewFloat(ret), NULL);
+}
+
+/**
+ * xmlXPathParseLiteral:
+ * @ctxt:  the XPath Parser context
+ *
+ * Parse a Literal
+ *
+ *  [29]   Literal ::=   '"' [^"]* '"'
+ *                    | "'" [^']* "'"
+ *
+ * Returns the value found or NULL in case of error
+ */
+static xmlChar *
+xmlXPathParseLiteral(xmlXPathParserContextPtr ctxt) {
+    const xmlChar *q;
+    xmlChar *ret = NULL;
+
+    if (CUR == '"') {
+        NEXT;
+	q = CUR_PTR;
+	while ((IS_CHAR_CH(CUR)) && (CUR != '"'))
+	    NEXT;
+	if (!IS_CHAR_CH(CUR)) {
+	    XP_ERROR0(XPATH_UNFINISHED_LITERAL_ERROR);
+	} else {
+	    ret = xmlStrndup(q, CUR_PTR - q);
+	    NEXT;
+        }
+    } else if (CUR == '\'') {
+        NEXT;
+	q = CUR_PTR;
+	while ((IS_CHAR_CH(CUR)) && (CUR != '\''))
+	    NEXT;
+	if (!IS_CHAR_CH(CUR)) {
+	    XP_ERROR0(XPATH_UNFINISHED_LITERAL_ERROR);
+	} else {
+	    ret = xmlStrndup(q, CUR_PTR - q);
+	    NEXT;
+        }
+    } else {
+	XP_ERROR0(XPATH_START_LITERAL_ERROR);
+    }
+    return(ret);
+}
+
+/**
+ * xmlXPathCompLiteral:
+ * @ctxt:  the XPath Parser context
+ *
+ * Parse a Literal and push it on the stack.
+ *
+ *  [29]   Literal ::=   '"' [^"]* '"'
+ *                    | "'" [^']* "'"
+ *
+ * TODO: xmlXPathCompLiteral memory allocation could be improved.
+ */
+static void
+xmlXPathCompLiteral(xmlXPathParserContextPtr ctxt) {
+    const xmlChar *q;
+    xmlChar *ret = NULL;
+
+    if (CUR == '"') {
+        NEXT;
+	q = CUR_PTR;
+	while ((IS_CHAR_CH(CUR)) && (CUR != '"'))
+	    NEXT;
+	if (!IS_CHAR_CH(CUR)) {
+	    XP_ERROR(XPATH_UNFINISHED_LITERAL_ERROR);
+	} else {
+	    ret = xmlStrndup(q, CUR_PTR - q);
+	    NEXT;
+        }
+    } else if (CUR == '\'') {
+        NEXT;
+	q = CUR_PTR;
+	while ((IS_CHAR_CH(CUR)) && (CUR != '\''))
+	    NEXT;
+	if (!IS_CHAR_CH(CUR)) {
+	    XP_ERROR(XPATH_UNFINISHED_LITERAL_ERROR);
+	} else {
+	    ret = xmlStrndup(q, CUR_PTR - q);
+	    NEXT;
+        }
+    } else {
+	XP_ERROR(XPATH_START_LITERAL_ERROR);
+    }
+    if (ret == NULL) return;
+    PUSH_LONG_EXPR(XPATH_OP_VALUE, XPATH_STRING, 0, 0,
+	           xmlXPathNewString(ret), NULL);
+    xmlFree(ret);
+}
+
+/**
+ * xmlXPathCompVariableReference:
+ * @ctxt:  the XPath Parser context
+ *
+ * Parse a VariableReference, evaluate it and push it on the stack.
+ *
+ * The variable bindings consist of a mapping from variable names
+ * to variable values. The value of a variable is an object, which can be
+ * of any of the types that are possible for the value of an expression,
+ * and may also be of additional types not specified here.
+ *
+ * Early evaluation is possible since:
+ * The variable bindings [...] used to evaluate a subexpression are
+ * always the same as those used to evaluate the containing expression. 
+ *
+ *  [36]   VariableReference ::=   '$' QName 
+ */
+static void
+xmlXPathCompVariableReference(xmlXPathParserContextPtr ctxt) {
+    xmlChar *name;
+    xmlChar *prefix;
+
+    SKIP_BLANKS;
+    if (CUR != '$') {
+	XP_ERROR(XPATH_VARIABLE_REF_ERROR);
+    }
+    NEXT;
+    name = xmlXPathParseQName(ctxt, &prefix);
+    if (name == NULL) {
+	XP_ERROR(XPATH_VARIABLE_REF_ERROR);
+    }
+    ctxt->comp->last = -1;
+    PUSH_LONG_EXPR(XPATH_OP_VARIABLE, 0, 0, 0,
+	           name, prefix);
+    SKIP_BLANKS;
+}
+
+/**
+ * xmlXPathIsNodeType:
+ * @name:  a name string
+ *
+ * Is the name given a NodeType one.
+ *
+ *  [38]   NodeType ::=   'comment'
+ *                    | 'text'
+ *                    | 'processing-instruction'
+ *                    | 'node'
+ *
+ * Returns 1 if true 0 otherwise
+ */
+int
+xmlXPathIsNodeType(const xmlChar *name) {
+    if (name == NULL)
+	return(0);
+
+    if (xmlStrEqual(name, BAD_CAST "node"))
+	return(1);
+    if (xmlStrEqual(name, BAD_CAST "text"))
+	return(1);
+    if (xmlStrEqual(name, BAD_CAST "comment"))
+	return(1);
+    if (xmlStrEqual(name, BAD_CAST "processing-instruction"))
+	return(1);
+    return(0);
+}
+
+/**
+ * xmlXPathCompFunctionCall:
+ * @ctxt:  the XPath Parser context
+ *
+ *  [16]   FunctionCall ::=   FunctionName '(' ( Argument ( ',' Argument)*)? ')'
+ *  [17]   Argument ::=   Expr 
+ *
+ * Compile a function call, the evaluation of all arguments are
+ * pushed on the stack
+ */
+static void
+xmlXPathCompFunctionCall(xmlXPathParserContextPtr ctxt) {
+    xmlChar *name;
+    xmlChar *prefix;
+    int nbargs = 0;
+
+    name = xmlXPathParseQName(ctxt, &prefix);
+    if (name == NULL) {
+	XP_ERROR(XPATH_EXPR_ERROR);
+    }
+    SKIP_BLANKS;
+#ifdef DEBUG_EXPR
+    if (prefix == NULL)
+	xmlGenericError(xmlGenericErrorContext, "Calling function %s\n",
+			name);
+    else
+	xmlGenericError(xmlGenericErrorContext, "Calling function %s:%s\n",
+			prefix, name);
+#endif
+
+    if (CUR != '(') {
+	XP_ERROR(XPATH_EXPR_ERROR);
+    }
+    NEXT;
+    SKIP_BLANKS;
+
+    ctxt->comp->last = -1;
+    if (CUR != ')') {
+	while (CUR != 0) {
+	    int op1 = ctxt->comp->last;
+	    ctxt->comp->last = -1;
+	    xmlXPathCompileExpr(ctxt);
+	    CHECK_ERROR;
+	    PUSH_BINARY_EXPR(XPATH_OP_ARG, op1, ctxt->comp->last, 0, 0);
+	    nbargs++;
+	    if (CUR == ')') break;
+	    if (CUR != ',') {
+		XP_ERROR(XPATH_EXPR_ERROR);
+	    }
+	    NEXT;
+	    SKIP_BLANKS;
+	}
+    }
+    PUSH_LONG_EXPR(XPATH_OP_FUNCTION, nbargs, 0, 0,
+	           name, prefix);
+    NEXT;
+    SKIP_BLANKS;
+}
+
+/**
+ * xmlXPathCompPrimaryExpr:
+ * @ctxt:  the XPath Parser context
+ *
+ *  [15]   PrimaryExpr ::=   VariableReference 
+ *                | '(' Expr ')'
+ *                | Literal 
+ *                | Number 
+ *                | FunctionCall 
+ *
+ * Compile a primary expression.
+ */
+static void
+xmlXPathCompPrimaryExpr(xmlXPathParserContextPtr ctxt) {
+    SKIP_BLANKS;
+    if (CUR == '$') xmlXPathCompVariableReference(ctxt);
+    else if (CUR == '(') {
+	NEXT;
+	SKIP_BLANKS;
+	xmlXPathCompileExpr(ctxt);
+	CHECK_ERROR;
+	if (CUR != ')') {
+	    XP_ERROR(XPATH_EXPR_ERROR);
+	}
+	NEXT;
+	SKIP_BLANKS;
+    } else if (IS_DIGIT_CH(CUR) || (CUR == '.' && IS_DIGIT_CH(NXT(1)))) {
+	xmlXPathCompNumber(ctxt);
+    } else if ((CUR == '\'') || (CUR == '"')) {
+	xmlXPathCompLiteral(ctxt);
+    } else {
+	xmlXPathCompFunctionCall(ctxt);
+    }
+    SKIP_BLANKS;
+}
+
+/**
+ * xmlXPathCompFilterExpr:
+ * @ctxt:  the XPath Parser context
+ *
+ *  [20]   FilterExpr ::=   PrimaryExpr 
+ *               | FilterExpr Predicate 
+ *
+ * Compile a filter expression.
+ * Square brackets are used to filter expressions in the same way that
+ * they are used in location paths. It is an error if the expression to
+ * be filtered does not evaluate to a node-set. The context node list
+ * used for evaluating the expression in square brackets is the node-set
+ * to be filtered listed in document order.
+ */
+
+static void
+xmlXPathCompFilterExpr(xmlXPathParserContextPtr ctxt) {
+    xmlXPathCompPrimaryExpr(ctxt);
+    CHECK_ERROR;
+    SKIP_BLANKS;
+    
+    while (CUR == '[') {
+	xmlXPathCompPredicate(ctxt, 1);
+	SKIP_BLANKS;
+    }
+
+    
+}
+
+/**
+ * xmlXPathScanName:
+ * @ctxt:  the XPath Parser context
+ *
+ * Trickery: parse an XML name but without consuming the input flow
+ * Needed to avoid insanity in the parser state.
+ *
+ * [4] NameChar ::= Letter | Digit | '.' | '-' | '_' | ':' |
+ *                  CombiningChar | Extender
+ *
+ * [5] Name ::= (Letter | '_' | ':') (NameChar)*
+ *
+ * [6] Names ::= Name (S Name)*
+ *
+ * Returns the Name parsed or NULL
+ */
+
+static xmlChar *
+xmlXPathScanName(xmlXPathParserContextPtr ctxt) {
+    xmlChar buf[XML_MAX_NAMELEN];
+    int len = 0;
+
+    SKIP_BLANKS;
+    if (!IS_LETTER_CH(CUR) && (CUR != '_') &&
+        (CUR != ':')) {
+	return(NULL);
+    }
+
+    while ((IS_LETTER_CH(NXT(len))) || (IS_DIGIT_CH(NXT(len))) ||
+           (NXT(len) == '.') || (NXT(len) == '-') ||
+	   (NXT(len) == '_') || (NXT(len) == ':') || 
+	   (IS_COMBINING_CH(NXT(len))) ||
+	   (IS_EXTENDER_CH(NXT(len)))) {
+	buf[len] = NXT(len);
+	len++;
+	if (len >= XML_MAX_NAMELEN) {
+	    xmlGenericError(xmlGenericErrorContext, 
+	       "xmlScanName: reached XML_MAX_NAMELEN limit\n");
+	    while ((IS_LETTER_CH(NXT(len))) || (IS_DIGIT_CH(NXT(len))) ||
+		   (NXT(len) == '.') || (NXT(len) == '-') ||
+		   (NXT(len) == '_') || (NXT(len) == ':') || 
+		   (IS_COMBINING_CH(NXT(len))) ||
+		   (IS_EXTENDER_CH(NXT(len))))
+		 len++;
+	    break;
+	}
+    }
+    return(xmlStrndup(buf, len));
+}
+
+/**
+ * xmlXPathCompPathExpr:
+ * @ctxt:  the XPath Parser context
+ *
+ *  [19]   PathExpr ::=   LocationPath 
+ *               | FilterExpr 
+ *               | FilterExpr '/' RelativeLocationPath 
+ *               | FilterExpr '//' RelativeLocationPath 
+ *
+ * Compile a path expression.
+ * The / operator and // operators combine an arbitrary expression
+ * and a relative location path. It is an error if the expression
+ * does not evaluate to a node-set.
+ * The / operator does composition in the same way as when / is
+ * used in a location path. As in location paths, // is short for
+ * /descendant-or-self::node()/.
+ */
+
+static void
+xmlXPathCompPathExpr(xmlXPathParserContextPtr ctxt) {
+    int lc = 1;           /* Should we branch to LocationPath ?         */
+    xmlChar *name = NULL; /* we may have to preparse a name to find out */
+
+    SKIP_BLANKS;
+    if ((CUR == '$') || (CUR == '(') || (IS_DIGIT_CH(CUR)) ||
+        (CUR == '\'') || (CUR == '"') || (CUR == '.' && IS_DIGIT_CH(NXT(1)))) {
+	lc = 0;
+    } else if (CUR == '*') {
+	/* relative or absolute location path */
+	lc = 1;
+    } else if (CUR == '/') {
+	/* relative or absolute location path */
+	lc = 1;
+    } else if (CUR == '@') {
+	/* relative abbreviated attribute location path */
+	lc = 1;
+    } else if (CUR == '.') {
+	/* relative abbreviated attribute location path */
+	lc = 1;
+    } else {
+	/*
+	 * Problem is finding if we have a name here whether it's:
+	 *   - a nodetype
+	 *   - a function call in which case it's followed by '('
+	 *   - an axis in which case it's followed by ':'
+	 *   - a element name
+	 * We do an a priori analysis here rather than having to
+	 * maintain parsed token content through the recursive function
+	 * calls. This looks uglier but makes the code easier to
+	 * read/write/debug.
+	 */
+	SKIP_BLANKS;
+	name = xmlXPathScanName(ctxt);
+	if ((name != NULL) && (xmlStrstr(name, (xmlChar *) "::") != NULL)) {
+#ifdef DEBUG_STEP
+	    xmlGenericError(xmlGenericErrorContext,
+		    "PathExpr: Axis\n");
+#endif
+	    lc = 1;
+	    xmlFree(name);
+	} else if (name != NULL) {
+	    int len =xmlStrlen(name);
+
+	    
+	    while (NXT(len) != 0) {
+		if (NXT(len) == '/') {
+		    /* element name */
+#ifdef DEBUG_STEP
+		    xmlGenericError(xmlGenericErrorContext,
+			    "PathExpr: AbbrRelLocation\n");
+#endif
+		    lc = 1;
+		    break;
+		} else if (IS_BLANK_CH(NXT(len))) {
+		    /* ignore blanks */
+		    ;
+		} else if (NXT(len) == ':') {
+#ifdef DEBUG_STEP
+		    xmlGenericError(xmlGenericErrorContext,
+			    "PathExpr: AbbrRelLocation\n");
+#endif
+		    lc = 1;
+		    break;
+		} else if ((NXT(len) == '(')) {
+		    /* Note Type or Function */
+		    if (xmlXPathIsNodeType(name)) {
+#ifdef DEBUG_STEP
+		        xmlGenericError(xmlGenericErrorContext,
+				"PathExpr: Type search\n");
+#endif
+			lc = 1;
+		    } else {
+#ifdef DEBUG_STEP
+		        xmlGenericError(xmlGenericErrorContext,
+				"PathExpr: function call\n");
+#endif
+			lc = 0;
+		    }
+                    break;
+		} else if ((NXT(len) == '[')) {
+		    /* element name */
+#ifdef DEBUG_STEP
+		    xmlGenericError(xmlGenericErrorContext,
+			    "PathExpr: AbbrRelLocation\n");
+#endif
+		    lc = 1;
+		    break;
+		} else if ((NXT(len) == '<') || (NXT(len) == '>') ||
+			   (NXT(len) == '=')) {
+		    lc = 1;
+		    break;
+		} else {
+		    lc = 1;
+		    break;
+		}
+		len++;
+	    }
+	    if (NXT(len) == 0) {
+#ifdef DEBUG_STEP
+		xmlGenericError(xmlGenericErrorContext,
+			"PathExpr: AbbrRelLocation\n");
+#endif
+		/* element name */
+		lc = 1;
+	    }
+	    xmlFree(name);
+	} else {
+	    /* make sure all cases are covered explicitly */
+	    XP_ERROR(XPATH_EXPR_ERROR);
+	}
+    } 
+
+    if (lc) {
+	if (CUR == '/') {
+	    PUSH_LEAVE_EXPR(XPATH_OP_ROOT, 0, 0);
+	} else {
+	    PUSH_LEAVE_EXPR(XPATH_OP_NODE, 0, 0);
+	}
+	xmlXPathCompLocationPath(ctxt);
+    } else {
+	xmlXPathCompFilterExpr(ctxt);
+	CHECK_ERROR;
+	if ((CUR == '/') && (NXT(1) == '/')) {
+	    SKIP(2);
+	    SKIP_BLANKS;
+
+	    PUSH_LONG_EXPR(XPATH_OP_COLLECT, AXIS_DESCENDANT_OR_SELF,
+		    NODE_TEST_TYPE, NODE_TYPE_NODE, NULL, NULL);
+	    PUSH_UNARY_EXPR(XPATH_OP_RESET, ctxt->comp->last, 1, 0);
+
+	    xmlXPathCompRelativeLocationPath(ctxt);
+	} else if (CUR == '/') {
+	    xmlXPathCompRelativeLocationPath(ctxt);
+	}
+    }
+    SKIP_BLANKS;
+}
+
+/**
+ * xmlXPathCompUnionExpr:
+ * @ctxt:  the XPath Parser context
+ *
+ *  [18]   UnionExpr ::=   PathExpr 
+ *               | UnionExpr '|' PathExpr 
+ *
+ * Compile an union expression.
+ */
+
+static void
+xmlXPathCompUnionExpr(xmlXPathParserContextPtr ctxt) {
+    xmlXPathCompPathExpr(ctxt);
+    CHECK_ERROR;
+    SKIP_BLANKS;
+    while (CUR == '|') {
+	int op1 = ctxt->comp->last;
+	PUSH_LEAVE_EXPR(XPATH_OP_NODE, 0, 0);
+
+	NEXT;
+	SKIP_BLANKS;
+	xmlXPathCompPathExpr(ctxt);
+
+	PUSH_BINARY_EXPR(XPATH_OP_UNION, op1, ctxt->comp->last, 0, 0);
+
+	SKIP_BLANKS;
+    }
+}
+
+/**
+ * xmlXPathCompUnaryExpr:
+ * @ctxt:  the XPath Parser context
+ *
+ *  [27]   UnaryExpr ::=   UnionExpr 
+ *                   | '-' UnaryExpr 
+ *
+ * Compile an unary expression.
+ */
+
+static void
+xmlXPathCompUnaryExpr(xmlXPathParserContextPtr ctxt) {
+    int minus = 0;
+    int found = 0;
+
+    SKIP_BLANKS;
+    while (CUR == '-') {
+        minus = 1 - minus;
+	found = 1;
+	NEXT;
+	SKIP_BLANKS;
+    }
+
+    xmlXPathCompUnionExpr(ctxt);
+    CHECK_ERROR;
+    if (found) {
+	if (minus)
+	    PUSH_UNARY_EXPR(XPATH_OP_PLUS, ctxt->comp->last, 2, 0);
+	else
+	    PUSH_UNARY_EXPR(XPATH_OP_PLUS, ctxt->comp->last, 3, 0);
+    }
+}
+
+/**
+ * xmlXPathCompMultiplicativeExpr:
+ * @ctxt:  the XPath Parser context
+ *
+ *  [26]   MultiplicativeExpr ::=   UnaryExpr 
+ *                   | MultiplicativeExpr MultiplyOperator UnaryExpr 
+ *                   | MultiplicativeExpr 'div' UnaryExpr 
+ *                   | MultiplicativeExpr 'mod' UnaryExpr 
+ *  [34]   MultiplyOperator ::=   '*'
+ *
+ * Compile an Additive expression.
+ */
+
+static void
+xmlXPathCompMultiplicativeExpr(xmlXPathParserContextPtr ctxt) {
+    xmlXPathCompUnaryExpr(ctxt);
+    CHECK_ERROR;
+    SKIP_BLANKS;
+    while ((CUR == '*') || 
+           ((CUR == 'd') && (NXT(1) == 'i') && (NXT(2) == 'v')) ||
+           ((CUR == 'm') && (NXT(1) == 'o') && (NXT(2) == 'd'))) {
+	int op = -1;
+	int op1 = ctxt->comp->last;
+
+        if (CUR == '*') {
+	    op = 0;
+	    NEXT;
+	} else if (CUR == 'd') {
+	    op = 1;
+	    SKIP(3);
+	} else if (CUR == 'm') {
+	    op = 2;
+	    SKIP(3);
+	}
+	SKIP_BLANKS;
+        xmlXPathCompUnaryExpr(ctxt);
+	CHECK_ERROR;
+	PUSH_BINARY_EXPR(XPATH_OP_MULT, op1, ctxt->comp->last, op, 0);
+	SKIP_BLANKS;
+    }
+}
+
+/**
+ * xmlXPathCompAdditiveExpr:
+ * @ctxt:  the XPath Parser context
+ *
+ *  [25]   AdditiveExpr ::=   MultiplicativeExpr 
+ *                   | AdditiveExpr '+' MultiplicativeExpr 
+ *                   | AdditiveExpr '-' MultiplicativeExpr 
+ *
+ * Compile an Additive expression.
+ */
+
+static void
+xmlXPathCompAdditiveExpr(xmlXPathParserContextPtr ctxt) {
+
+    xmlXPathCompMultiplicativeExpr(ctxt);
+    CHECK_ERROR;
+    SKIP_BLANKS;
+    while ((CUR == '+') || (CUR == '-')) {
+	int plus;
+	int op1 = ctxt->comp->last;
+
+        if (CUR == '+') plus = 1;
+	else plus = 0;
+	NEXT;
+	SKIP_BLANKS;
+        xmlXPathCompMultiplicativeExpr(ctxt);
+	CHECK_ERROR;
+	PUSH_BINARY_EXPR(XPATH_OP_PLUS, op1, ctxt->comp->last, plus, 0);
+	SKIP_BLANKS;
+    }
+}
+
+/**
+ * xmlXPathCompRelationalExpr:
+ * @ctxt:  the XPath Parser context
+ *
+ *  [24]   RelationalExpr ::=   AdditiveExpr 
+ *                 | RelationalExpr '<' AdditiveExpr 
+ *                 | RelationalExpr '>' AdditiveExpr 
+ *                 | RelationalExpr '<=' AdditiveExpr 
+ *                 | RelationalExpr '>=' AdditiveExpr 
+ *
+ *  A <= B > C is allowed ? Answer from James, yes with
+ *  (AdditiveExpr <= AdditiveExpr) > AdditiveExpr
+ *  which is basically what got implemented.
+ *
+ * Compile a Relational expression, then push the result
+ * on the stack
+ */
+
+static void
+xmlXPathCompRelationalExpr(xmlXPathParserContextPtr ctxt) {
+    xmlXPathCompAdditiveExpr(ctxt);
+    CHECK_ERROR;
+    SKIP_BLANKS;
+    while ((CUR == '<') ||
+           (CUR == '>') ||
+           ((CUR == '<') && (NXT(1) == '=')) ||
+           ((CUR == '>') && (NXT(1) == '='))) {
+	int inf, strict;
+	int op1 = ctxt->comp->last;
+
+        if (CUR == '<') inf = 1;
+	else inf = 0;
+	if (NXT(1) == '=') strict = 0;
+	else strict = 1;
+	NEXT;
+	if (!strict) NEXT;
+	SKIP_BLANKS;
+        xmlXPathCompAdditiveExpr(ctxt);
+	CHECK_ERROR;
+	PUSH_BINARY_EXPR(XPATH_OP_CMP, op1, ctxt->comp->last, inf, strict);
+	SKIP_BLANKS;
+    }
+}
+
+/**
+ * xmlXPathCompEqualityExpr:
+ * @ctxt:  the XPath Parser context
+ *
+ *  [23]   EqualityExpr ::=   RelationalExpr 
+ *                 | EqualityExpr '=' RelationalExpr 
+ *                 | EqualityExpr '!=' RelationalExpr 
+ *
+ *  A != B != C is allowed ? Answer from James, yes with
+ *  (RelationalExpr = RelationalExpr) = RelationalExpr
+ *  (RelationalExpr != RelationalExpr) != RelationalExpr
+ *  which is basically what got implemented.
+ *
+ * Compile an Equality expression.
+ *
+ */
+static void
+xmlXPathCompEqualityExpr(xmlXPathParserContextPtr ctxt) {
+    xmlXPathCompRelationalExpr(ctxt);
+    CHECK_ERROR;
+    SKIP_BLANKS;
+    while ((CUR == '=') || ((CUR == '!') && (NXT(1) == '='))) {
+	int eq;
+	int op1 = ctxt->comp->last;
+
+        if (CUR == '=') eq = 1;
+	else eq = 0;
+	NEXT;
+	if (!eq) NEXT;
+	SKIP_BLANKS;
+        xmlXPathCompRelationalExpr(ctxt);
+	CHECK_ERROR;
+	PUSH_BINARY_EXPR(XPATH_OP_EQUAL, op1, ctxt->comp->last, eq, 0);
+	SKIP_BLANKS;
+    }
+}
+
+/**
+ * xmlXPathCompAndExpr:
+ * @ctxt:  the XPath Parser context
+ *
+ *  [22]   AndExpr ::=   EqualityExpr 
+ *                 | AndExpr 'and' EqualityExpr 
+ *
+ * Compile an AND expression.
+ *
+ */
+static void
+xmlXPathCompAndExpr(xmlXPathParserContextPtr ctxt) {
+    xmlXPathCompEqualityExpr(ctxt);
+    CHECK_ERROR;
+    SKIP_BLANKS;
+    while ((CUR == 'a') && (NXT(1) == 'n') && (NXT(2) == 'd')) {
+	int op1 = ctxt->comp->last;
+        SKIP(3);
+	SKIP_BLANKS;
+        xmlXPathCompEqualityExpr(ctxt);
+	CHECK_ERROR;
+	PUSH_BINARY_EXPR(XPATH_OP_AND, op1, ctxt->comp->last, 0, 0);
+	SKIP_BLANKS;
+    }
+}
+
+/**
+ * xmlXPathCompileExpr:
+ * @ctxt:  the XPath Parser context
+ *
+ *  [14]   Expr ::=   OrExpr 
+ *  [21]   OrExpr ::=   AndExpr 
+ *                 | OrExpr 'or' AndExpr 
+ *
+ * Parse and compile an expression
+ */
+static void
+xmlXPathCompileExpr(xmlXPathParserContextPtr ctxt) {
+    xmlXPathCompAndExpr(ctxt);
+    CHECK_ERROR;
+    SKIP_BLANKS;
+    while ((CUR == 'o') && (NXT(1) == 'r')) {
+	int op1 = ctxt->comp->last;
+        SKIP(2);
+	SKIP_BLANKS;
+        xmlXPathCompAndExpr(ctxt);
+	CHECK_ERROR;
+	PUSH_BINARY_EXPR(XPATH_OP_OR, op1, ctxt->comp->last, 0, 0);
+	op1 = ctxt->comp->nbStep;
+	SKIP_BLANKS;
+    }
+    if (ctxt->comp->steps[ctxt->comp->last].op != XPATH_OP_VALUE) {
+	/* more ops could be optimized too */
+	PUSH_UNARY_EXPR(XPATH_OP_SORT, ctxt->comp->last , 0, 0);
+    }
+}
+
+/**
+ * xmlXPathCompPredicate:
+ * @ctxt:  the XPath Parser context
+ * @filter:  act as a filter
+ *
+ *  [8]   Predicate ::=   '[' PredicateExpr ']'
+ *  [9]   PredicateExpr ::=   Expr 
+ *
+ * Compile a predicate expression
+ */
+static void
+xmlXPathCompPredicate(xmlXPathParserContextPtr ctxt, int filter) {
+    int op1 = ctxt->comp->last;
+
+    SKIP_BLANKS;
+    if (CUR != '[') {
+	XP_ERROR(XPATH_INVALID_PREDICATE_ERROR);
+    }
+    NEXT;
+    SKIP_BLANKS;
+
+    ctxt->comp->last = -1;
+    xmlXPathCompileExpr(ctxt);
+    CHECK_ERROR;
+
+    if (CUR != ']') {
+	XP_ERROR(XPATH_INVALID_PREDICATE_ERROR);
+    }
+
+    if (filter)
+	PUSH_BINARY_EXPR(XPATH_OP_FILTER, op1, ctxt->comp->last, 0, 0);
+    else
+	PUSH_BINARY_EXPR(XPATH_OP_PREDICATE, op1, ctxt->comp->last, 0, 0);
+
+    NEXT;
+    SKIP_BLANKS;
+}
+
+/**
+ * xmlXPathCompNodeTest:
+ * @ctxt:  the XPath Parser context
+ * @test:  pointer to a xmlXPathTestVal
+ * @type:  pointer to a xmlXPathTypeVal
+ * @prefix:  placeholder for a possible name prefix
+ *
+ * [7] NodeTest ::=   NameTest
+ *		    | NodeType '(' ')'
+ *		    | 'processing-instruction' '(' Literal ')'
+ *
+ * [37] NameTest ::=  '*'
+ *		    | NCName ':' '*'
+ *		    | QName
+ * [38] NodeType ::= 'comment'
+ *		   | 'text'
+ *		   | 'processing-instruction'
+ *		   | 'node'
+ *
+ * Returns the name found and updates @test, @type and @prefix appropriately
+ */
+static xmlChar *
+xmlXPathCompNodeTest(xmlXPathParserContextPtr ctxt, xmlXPathTestVal *test,
+	             xmlXPathTypeVal *type, const xmlChar **prefix,
+		     xmlChar *name) {
+    int blanks;
+
+    if ((test == NULL) || (type == NULL) || (prefix == NULL)) {
+	STRANGE;
+	return(NULL);
+    }
+    *type = (xmlXPathTypeVal) 0;
+    *test = (xmlXPathTestVal) 0;
+    *prefix = NULL;
+    SKIP_BLANKS;
+
+    if ((name == NULL) && (CUR == '*')) {
+	/*
+	 * All elements
+	 */
+	NEXT;
+	*test = NODE_TEST_ALL;
+	return(NULL);
+    }
+
+    if (name == NULL)
+	name = xmlXPathParseNCName(ctxt);
+    if (name == NULL) {
+	XP_ERROR0(XPATH_EXPR_ERROR);
+    }
+
+    blanks = IS_BLANK_CH(CUR);
+    SKIP_BLANKS;
+    if (CUR == '(') {
+	NEXT;
+	/*
+	 * NodeType or PI search
+	 */
+	if (xmlStrEqual(name, BAD_CAST "comment"))
+	    *type = NODE_TYPE_COMMENT;
+	else if (xmlStrEqual(name, BAD_CAST "node"))
+	    *type = NODE_TYPE_NODE;
+	else if (xmlStrEqual(name, BAD_CAST "processing-instruction"))
+	    *type = NODE_TYPE_PI;
+	else if (xmlStrEqual(name, BAD_CAST "text"))
+	    *type = NODE_TYPE_TEXT;
+	else {
+	    if (name != NULL)
+		xmlFree(name);
+	    XP_ERROR0(XPATH_EXPR_ERROR);
+	}
+
+	*test = NODE_TEST_TYPE;
+	
+	SKIP_BLANKS;
+	if (*type == NODE_TYPE_PI) {
+	    /*
+	     * Specific case: search a PI by name.
+	     */
+	    if (name != NULL)
+		xmlFree(name);
+	    name = NULL;
+	    if (CUR != ')') {
+		name = xmlXPathParseLiteral(ctxt);
+		CHECK_ERROR 0;
+		*test = NODE_TEST_PI;
+		SKIP_BLANKS;
+	    }
+	}
+	if (CUR != ')') {
+	    if (name != NULL)
+		xmlFree(name);
+	    XP_ERROR0(XPATH_UNCLOSED_ERROR);
+	}
+	NEXT;
+	return(name);
+    }
+    *test = NODE_TEST_NAME;
+    if ((!blanks) && (CUR == ':')) {
+	NEXT;
+
+	/*
+	 * Since currently the parser context don't have a
+	 * namespace list associated:
+	 * The namespace name for this prefix can be computed
+	 * only at evaluation time. The compilation is done
+	 * outside of any context.
+	 */
+#if 0
+	*prefix = xmlXPathNsLookup(ctxt->context, name);
+	if (name != NULL)
+	    xmlFree(name);
+	if (*prefix == NULL) {
+	    XP_ERROR0(XPATH_UNDEF_PREFIX_ERROR);
+	}
+#else
+	*prefix = name;
+#endif
+
+	if (CUR == '*') {
+	    /*
+	     * All elements
+	     */
+	    NEXT;
+	    *test = NODE_TEST_ALL;
+	    return(NULL);
+	}
+
+	name = xmlXPathParseNCName(ctxt);
+	if (name == NULL) {
+	    XP_ERROR0(XPATH_EXPR_ERROR);
+	}
+    }
+    return(name);
+}
+
+/**
+ * xmlXPathIsAxisName:
+ * @name:  a preparsed name token
+ *
+ * [6] AxisName ::=   'ancestor'
+ *                  | 'ancestor-or-self'
+ *                  | 'attribute'
+ *                  | 'child'
+ *                  | 'descendant'
+ *                  | 'descendant-or-self'
+ *                  | 'following'
+ *                  | 'following-sibling'
+ *                  | 'namespace'
+ *                  | 'parent'
+ *                  | 'preceding'
+ *                  | 'preceding-sibling'
+ *                  | 'self'
+ *
+ * Returns the axis or 0
+ */
+static xmlXPathAxisVal
+xmlXPathIsAxisName(const xmlChar *name) {
+    xmlXPathAxisVal ret = (xmlXPathAxisVal) 0;
+    switch (name[0]) {
+	case 'a':
+	    if (xmlStrEqual(name, BAD_CAST "ancestor"))
+		ret = AXIS_ANCESTOR;
+	    if (xmlStrEqual(name, BAD_CAST "ancestor-or-self"))
+		ret = AXIS_ANCESTOR_OR_SELF;
+	    if (xmlStrEqual(name, BAD_CAST "attribute"))
+		ret = AXIS_ATTRIBUTE;
+	    break;
+	case 'c':
+	    if (xmlStrEqual(name, BAD_CAST "child"))
+		ret = AXIS_CHILD;
+	    break;
+	case 'd':
+	    if (xmlStrEqual(name, BAD_CAST "descendant"))
+		ret = AXIS_DESCENDANT;
+	    if (xmlStrEqual(name, BAD_CAST "descendant-or-self"))
+		ret = AXIS_DESCENDANT_OR_SELF;
+	    break;
+	case 'f':
+	    if (xmlStrEqual(name, BAD_CAST "following"))
+		ret = AXIS_FOLLOWING;
+	    if (xmlStrEqual(name, BAD_CAST "following-sibling"))
+		ret = AXIS_FOLLOWING_SIBLING;
+	    break;
+	case 'n':
+	    if (xmlStrEqual(name, BAD_CAST "namespace"))
+		ret = AXIS_NAMESPACE;
+	    break;
+	case 'p':
+	    if (xmlStrEqual(name, BAD_CAST "parent"))
+		ret = AXIS_PARENT;
+	    if (xmlStrEqual(name, BAD_CAST "preceding"))
+		ret = AXIS_PRECEDING;
+	    if (xmlStrEqual(name, BAD_CAST "preceding-sibling"))
+		ret = AXIS_PRECEDING_SIBLING;
+	    break;
+	case 's':
+	    if (xmlStrEqual(name, BAD_CAST "self"))
+		ret = AXIS_SELF;
+	    break;
+    }
+    return(ret);
+}
+
+/**
+ * xmlXPathCompStep:
+ * @ctxt:  the XPath Parser context
+ *
+ * [4] Step ::=   AxisSpecifier NodeTest Predicate*
+ *                  | AbbreviatedStep 
+ *
+ * [12] AbbreviatedStep ::=   '.' | '..'
+ *
+ * [5] AxisSpecifier ::= AxisName '::'
+ *                  | AbbreviatedAxisSpecifier
+ *
+ * [13] AbbreviatedAxisSpecifier ::= '@'?
+ *
+ * Modified for XPtr range support as:
+ *
+ *  [4xptr] Step ::= AxisSpecifier NodeTest Predicate*
+ *                     | AbbreviatedStep
+ *                     | 'range-to' '(' Expr ')' Predicate*
+ *
+ * Compile one step in a Location Path
+ * A location step of . is short for self::node(). This is
+ * particularly useful in conjunction with //. For example, the
+ * location path .//para is short for
+ * self::node()/descendant-or-self::node()/child::para
+ * and so will select all para descendant elements of the context
+ * node.
+ * Similarly, a location step of .. is short for parent::node().
+ * For example, ../title is short for parent::node()/child::title
+ * and so will select the title children of the parent of the context
+ * node.
+ */
+static void
+xmlXPathCompStep(xmlXPathParserContextPtr ctxt) {
+#ifdef LIBXML_XPTR_ENABLED
+    int rangeto = 0;
+    int op2 = -1;
+#endif
+
+    SKIP_BLANKS;
+    if ((CUR == '.') && (NXT(1) == '.')) {
+	SKIP(2);
+	SKIP_BLANKS;
+	PUSH_LONG_EXPR(XPATH_OP_COLLECT, AXIS_PARENT,
+		    NODE_TEST_TYPE, NODE_TYPE_NODE, NULL, NULL);
+    } else if (CUR == '.') {
+	NEXT;
+	SKIP_BLANKS;
+    } else {
+	xmlChar *name = NULL;
+	const xmlChar *prefix = NULL;
+	xmlXPathTestVal test;
+	xmlXPathAxisVal axis = (xmlXPathAxisVal) 0;
+	xmlXPathTypeVal type;
+	int op1;
+
+	/*
+	 * The modification needed for XPointer change to the production
+	 */
+#ifdef LIBXML_XPTR_ENABLED
+	if (ctxt->xptr) {
+	    name = xmlXPathParseNCName(ctxt);
+	    if ((name != NULL) && (xmlStrEqual(name, BAD_CAST "range-to"))) {
+                op2 = ctxt->comp->last;
+		xmlFree(name);
+		SKIP_BLANKS;
+		if (CUR != '(') {
+		    XP_ERROR(XPATH_EXPR_ERROR);
+		}
+		NEXT;
+		SKIP_BLANKS;
+
+		xmlXPathCompileExpr(ctxt);
+		/* PUSH_BINARY_EXPR(XPATH_OP_RANGETO, op2, ctxt->comp->last, 0, 0); */
+		CHECK_ERROR;
+
+		SKIP_BLANKS;
+		if (CUR != ')') {
+		    XP_ERROR(XPATH_EXPR_ERROR);
+		}
+		NEXT;
+		rangeto = 1;
+		goto eval_predicates;
+	    }
+	}
+#endif
+	if (CUR == '*') {
+	    axis = AXIS_CHILD;
+	} else {
+	    if (name == NULL)
+		name = xmlXPathParseNCName(ctxt);
+	    if (name != NULL) {
+		axis = xmlXPathIsAxisName(name);
+		if (axis != 0) {
+		    SKIP_BLANKS;
+		    if ((CUR == ':') && (NXT(1) == ':')) {
+			SKIP(2);
+			xmlFree(name);
+			name = NULL;
+		    } else {
+			/* an element name can conflict with an axis one :-\ */
+			axis = AXIS_CHILD;
+		    }
+		} else {
+		    axis = AXIS_CHILD;
+		}
+	    } else if (CUR == '@') {
+		NEXT;
+		axis = AXIS_ATTRIBUTE;
+	    } else {
+		axis = AXIS_CHILD;
+	    }
+	}
+
+	CHECK_ERROR;
+
+	name = xmlXPathCompNodeTest(ctxt, &test, &type, &prefix, name);
+	if (test == 0)
+	    return;
+
+#ifdef DEBUG_STEP
+	xmlGenericError(xmlGenericErrorContext,
+		"Basis : computing new set\n");
+#endif
+
+#ifdef DEBUG_STEP
+	xmlGenericError(xmlGenericErrorContext, "Basis : ");
+	if (ctxt->value == NULL)
+	    xmlGenericError(xmlGenericErrorContext, "no value\n");
+	else if (ctxt->value->nodesetval == NULL)
+	    xmlGenericError(xmlGenericErrorContext, "Empty\n");
+	else
+	    xmlGenericErrorContextNodeSet(stdout, ctxt->value->nodesetval);
+#endif
+
+#ifdef LIBXML_XPTR_ENABLED
+eval_predicates:
+#endif
+	op1 = ctxt->comp->last;
+	ctxt->comp->last = -1;
+
+	SKIP_BLANKS;
+	while (CUR == '[') {
+	    xmlXPathCompPredicate(ctxt, 0);
+	}
+
+#ifdef LIBXML_XPTR_ENABLED
+	if (rangeto) {
+	    PUSH_BINARY_EXPR(XPATH_OP_RANGETO, op2, op1, 0, 0);
+	} else
+#endif
+	    PUSH_FULL_EXPR(XPATH_OP_COLLECT, op1, ctxt->comp->last, axis,
+			   test, type, (void *)prefix, (void *)name);
+
+    }
+#ifdef DEBUG_STEP
+    xmlGenericError(xmlGenericErrorContext, "Step : ");
+    if (ctxt->value == NULL)
+	xmlGenericError(xmlGenericErrorContext, "no value\n");
+    else if (ctxt->value->nodesetval == NULL)
+	xmlGenericError(xmlGenericErrorContext, "Empty\n");
+    else
+	xmlGenericErrorContextNodeSet(xmlGenericErrorContext,
+		ctxt->value->nodesetval);
+#endif
+}
+
+/**
+ * xmlXPathCompRelativeLocationPath:
+ * @ctxt:  the XPath Parser context
+ *
+ *  [3]   RelativeLocationPath ::=   Step 
+ *                     | RelativeLocationPath '/' Step 
+ *                     | AbbreviatedRelativeLocationPath 
+ *  [11]  AbbreviatedRelativeLocationPath ::=   RelativeLocationPath '//' Step 
+ *
+ * Compile a relative location path.
+ */
+static void
+xmlXPathCompRelativeLocationPath
+(xmlXPathParserContextPtr ctxt) {
+    SKIP_BLANKS;
+    if ((CUR == '/') && (NXT(1) == '/')) {
+	SKIP(2);
+	SKIP_BLANKS;
+	PUSH_LONG_EXPR(XPATH_OP_COLLECT, AXIS_DESCENDANT_OR_SELF,
+		         NODE_TEST_TYPE, NODE_TYPE_NODE, NULL, NULL);
+    } else if (CUR == '/') {
+	    NEXT;
+	SKIP_BLANKS;
+    }
+    xmlXPathCompStep(ctxt);
+    SKIP_BLANKS;
+    while (CUR == '/') {
+	if ((CUR == '/') && (NXT(1) == '/')) {
+	    SKIP(2);
+	    SKIP_BLANKS;
+	    PUSH_LONG_EXPR(XPATH_OP_COLLECT, AXIS_DESCENDANT_OR_SELF,
+			     NODE_TEST_TYPE, NODE_TYPE_NODE, NULL, NULL);
+	    xmlXPathCompStep(ctxt);
+	} else if (CUR == '/') {
+	    NEXT;
+	    SKIP_BLANKS;
+	    xmlXPathCompStep(ctxt);
+	}
+	SKIP_BLANKS;
+    }
+}
+
+/**
+ * xmlXPathCompLocationPath:
+ * @ctxt:  the XPath Parser context
+ *
+ *  [1]   LocationPath ::=   RelativeLocationPath 
+ *                     | AbsoluteLocationPath 
+ *  [2]   AbsoluteLocationPath ::=   '/' RelativeLocationPath?
+ *                     | AbbreviatedAbsoluteLocationPath 
+ *  [10]   AbbreviatedAbsoluteLocationPath ::=   
+ *                           '//' RelativeLocationPath 
+ *
+ * Compile a location path
+ *
+ * // is short for /descendant-or-self::node()/. For example,
+ * //para is short for /descendant-or-self::node()/child::para and
+ * so will select any para element in the document (even a para element
+ * that is a document element will be selected by //para since the
+ * document element node is a child of the root node); div//para is
+ * short for div/descendant-or-self::node()/child::para and so will
+ * select all para descendants of div children.
+ */
+static void
+xmlXPathCompLocationPath(xmlXPathParserContextPtr ctxt) {
+    SKIP_BLANKS;
+    if (CUR != '/') {
+        xmlXPathCompRelativeLocationPath(ctxt);
+    } else {
+	while (CUR == '/') {
+	    if ((CUR == '/') && (NXT(1) == '/')) {
+		SKIP(2);
+		SKIP_BLANKS;
+		PUSH_LONG_EXPR(XPATH_OP_COLLECT, AXIS_DESCENDANT_OR_SELF,
+			     NODE_TEST_TYPE, NODE_TYPE_NODE, NULL, NULL);
+		xmlXPathCompRelativeLocationPath(ctxt);
+	    } else if (CUR == '/') {
+		NEXT;
+		SKIP_BLANKS;
+		if ((CUR != 0 ) &&
+		    ((IS_LETTER_CH(CUR)) || (CUR == '_') || (CUR == '.') ||
+		     (CUR == '@') || (CUR == '*')))
+		    xmlXPathCompRelativeLocationPath(ctxt);
+	    }
+	}
+    }
+}
+
+/************************************************************************
+ *									*
+ * 		XPath precompiled expression evaluation			*
+ *									*
+ ************************************************************************/
+
+static int
+xmlXPathCompOpEval(xmlXPathParserContextPtr ctxt, xmlXPathStepOpPtr op);
+
+/**
+ * xmlXPathNodeCollectAndTest:
+ * @ctxt:  the XPath Parser context
+ * @op:  the XPath precompiled step operation
+ * @first:  pointer to the first element in document order
+ * @last:  pointer to the last element in document order
+ *
+ * This is the function implementing a step: based on the current list
+ * of nodes, it builds up a new list, looking at all nodes under that
+ * axis and selecting them. It also does the predicate filtering
+ *
+ * Pushes the new NodeSet resulting from the search.
+ *
+ * Returns the number of nodes traversed
+ */
+static int
+xmlXPathNodeCollectAndTest(xmlXPathParserContextPtr ctxt,
+                           xmlXPathStepOpPtr op,
+			   xmlNodePtr * first, xmlNodePtr * last)
+{
+    xmlXPathAxisVal axis = (xmlXPathAxisVal) op->value;
+    xmlXPathTestVal test = (xmlXPathTestVal) op->value2;
+    xmlXPathTypeVal type = (xmlXPathTypeVal) op->value3;
+    const xmlChar *prefix = op->value4;
+    const xmlChar *name = op->value5;
+    const xmlChar *URI = NULL;
+
+#ifdef DEBUG_STEP
+    int n = 0;
+#endif
+    int i, t = 0;
+    xmlNodeSetPtr ret, list;
+    xmlXPathTraversalFunction next = NULL;
+    void (*addNode) (xmlNodeSetPtr, xmlNodePtr);
+    xmlNodeSetPtr (*mergeNodeSet) (xmlNodeSetPtr, xmlNodeSetPtr);
+    xmlNodePtr cur = NULL;
+    xmlXPathObjectPtr obj;
+    xmlNodeSetPtr nodelist;
+    xmlNodePtr tmp;
+
+    CHECK_TYPE0(XPATH_NODESET);
+    obj = valuePop(ctxt);
+    addNode = xmlXPathNodeSetAdd;
+    mergeNodeSet = xmlXPathNodeSetMerge;
+    if (prefix != NULL) {
+        URI = xmlXPathNsLookup(ctxt->context, prefix);
+        if (URI == NULL)
+            XP_ERROR0(XPATH_UNDEF_PREFIX_ERROR);
+    }
+#ifdef DEBUG_STEP
+    xmlGenericError(xmlGenericErrorContext, "new step : ");
+#endif
+    switch (axis) {
+        case AXIS_ANCESTOR:
+#ifdef DEBUG_STEP
+            xmlGenericError(xmlGenericErrorContext, "axis 'ancestors' ");
+#endif
+            first = NULL;
+            next = xmlXPathNextAncestor;
+            break;
+        case AXIS_ANCESTOR_OR_SELF:
+#ifdef DEBUG_STEP
+            xmlGenericError(xmlGenericErrorContext,
+                            "axis 'ancestors-or-self' ");
+#endif
+            first = NULL;
+            next = xmlXPathNextAncestorOrSelf;
+            break;
+        case AXIS_ATTRIBUTE:
+#ifdef DEBUG_STEP
+            xmlGenericError(xmlGenericErrorContext, "axis 'attributes' ");
+#endif
+            first = NULL;
+	    last = NULL;
+            next = xmlXPathNextAttribute;
+	    mergeNodeSet = xmlXPathNodeSetMergeUnique;
+            break;
+        case AXIS_CHILD:
+#ifdef DEBUG_STEP
+            xmlGenericError(xmlGenericErrorContext, "axis 'child' ");
+#endif
+	    last = NULL;
+            next = xmlXPathNextChild;
+	    mergeNodeSet = xmlXPathNodeSetMergeUnique;
+            break;
+        case AXIS_DESCENDANT:
+#ifdef DEBUG_STEP
+            xmlGenericError(xmlGenericErrorContext, "axis 'descendant' ");
+#endif
+	    last = NULL;
+            next = xmlXPathNextDescendant;
+            break;
+        case AXIS_DESCENDANT_OR_SELF:
+#ifdef DEBUG_STEP
+            xmlGenericError(xmlGenericErrorContext,
+                            "axis 'descendant-or-self' ");
+#endif
+	    last = NULL;
+            next = xmlXPathNextDescendantOrSelf;
+            break;
+        case AXIS_FOLLOWING:
+#ifdef DEBUG_STEP
+            xmlGenericError(xmlGenericErrorContext, "axis 'following' ");
+#endif
+	    last = NULL;
+            next = xmlXPathNextFollowing;
+            break;
+        case AXIS_FOLLOWING_SIBLING:
+#ifdef DEBUG_STEP
+            xmlGenericError(xmlGenericErrorContext,
+                            "axis 'following-siblings' ");
+#endif
+	    last = NULL;
+            next = xmlXPathNextFollowingSibling;
+            break;
+        case AXIS_NAMESPACE:
+#ifdef DEBUG_STEP
+            xmlGenericError(xmlGenericErrorContext, "axis 'namespace' ");
+#endif
+            first = NULL;
+	    last = NULL;
+            next = (xmlXPathTraversalFunction) xmlXPathNextNamespace;
+	    mergeNodeSet = xmlXPathNodeSetMergeUnique;
+            break;
+        case AXIS_PARENT:
+#ifdef DEBUG_STEP
+            xmlGenericError(xmlGenericErrorContext, "axis 'parent' ");
+#endif
+            first = NULL;
+            next = xmlXPathNextParent;
+            break;
+        case AXIS_PRECEDING:
+#ifdef DEBUG_STEP
+            xmlGenericError(xmlGenericErrorContext, "axis 'preceding' ");
+#endif
+            first = NULL;
+            next = xmlXPathNextPrecedingInternal;
+            break;
+        case AXIS_PRECEDING_SIBLING:
+#ifdef DEBUG_STEP
+            xmlGenericError(xmlGenericErrorContext,
+                            "axis 'preceding-sibling' ");
+#endif
+            first = NULL;
+            next = xmlXPathNextPrecedingSibling;
+            break;
+        case AXIS_SELF:
+#ifdef DEBUG_STEP
+            xmlGenericError(xmlGenericErrorContext, "axis 'self' ");
+#endif
+            first = NULL;
+	    last = NULL;
+            next = xmlXPathNextSelf;
+	    mergeNodeSet = xmlXPathNodeSetMergeUnique;
+            break;
+    }
+    if (next == NULL)
+        return(0);
+
+    nodelist = obj->nodesetval;
+    if (nodelist == NULL) {
+        xmlXPathFreeObject(obj);
+        valuePush(ctxt, xmlXPathWrapNodeSet(NULL));
+        return(0);
+    }
+    addNode = xmlXPathNodeSetAddUnique;
+    ret = NULL;
+#ifdef DEBUG_STEP
+    xmlGenericError(xmlGenericErrorContext,
+                    " context contains %d nodes\n", nodelist->nodeNr);
+    switch (test) {
+        case NODE_TEST_NONE:
+            xmlGenericError(xmlGenericErrorContext,
+                            "           searching for none !!!\n");
+            break;
+        case NODE_TEST_TYPE:
+            xmlGenericError(xmlGenericErrorContext,
+                            "           searching for type %d\n", type);
+            break;
+        case NODE_TEST_PI:
+            xmlGenericError(xmlGenericErrorContext,
+                            "           searching for PI !!!\n");
+            break;
+        case NODE_TEST_ALL:
+            xmlGenericError(xmlGenericErrorContext,
+                            "           searching for *\n");
+            break;
+        case NODE_TEST_NS:
+            xmlGenericError(xmlGenericErrorContext,
+                            "           searching for namespace %s\n",
+                            prefix);
+            break;
+        case NODE_TEST_NAME:
+            xmlGenericError(xmlGenericErrorContext,
+                            "           searching for name %s\n", name);
+            if (prefix != NULL)
+                xmlGenericError(xmlGenericErrorContext,
+                                "           with namespace %s\n", prefix);
+            break;
+    }
+    xmlGenericError(xmlGenericErrorContext, "Testing : ");
+#endif
+    /*
+     * 2.3 Node Tests
+     *  - For the attribute axis, the principal node type is attribute. 
+     *  - For the namespace axis, the principal node type is namespace. 
+     *  - For other axes, the principal node type is element. 
+     *
+     * A node test * is true for any node of the
+     * principal node type. For example, child::* will
+     * select all element children of the context node
+     */
+    tmp = ctxt->context->node;
+    for (i = 0; i < nodelist->nodeNr; i++) {
+        ctxt->context->node = nodelist->nodeTab[i];
+
+        cur = NULL;
+        list = xmlXPathNodeSetCreate(NULL);
+        do {
+            cur = next(ctxt, cur);
+            if (cur == NULL)
+                break;
+            if ((first != NULL) && (*first == cur))
+                break;
+	    if (((t % 256) == 0) &&
+	        (first != NULL) && (*first != NULL) &&
+		(xmlXPathCmpNodes(*first, cur) >= 0))
+		break;
+	    if ((last != NULL) && (*last == cur))
+		break;
+	    if (((t % 256) == 0) &&
+		(last != NULL) && (*last != NULL) &&
+		(xmlXPathCmpNodes(cur, *last) >= 0))
+		break;
+            t++;
+#ifdef DEBUG_STEP
+            xmlGenericError(xmlGenericErrorContext, " %s", cur->name);
+#endif
+            switch (test) {
+                case NODE_TEST_NONE:
+                    ctxt->context->node = tmp;
+                    STRANGE return(t);
+                case NODE_TEST_TYPE:
+                    if ((cur->type == type) ||
+                        ((type == NODE_TYPE_NODE) &&
+                         ((cur->type == XML_DOCUMENT_NODE) ||
+                          (cur->type == XML_HTML_DOCUMENT_NODE) ||
+                          (cur->type == XML_ELEMENT_NODE) ||
+                          (cur->type == XML_NAMESPACE_DECL) ||
+                          (cur->type == XML_ATTRIBUTE_NODE) ||
+                          (cur->type == XML_PI_NODE) ||
+                          (cur->type == XML_COMMENT_NODE) ||
+                          (cur->type == XML_CDATA_SECTION_NODE) ||
+                          (cur->type == XML_TEXT_NODE))) ||
+			((type == NODE_TYPE_TEXT) &&
+			 (cur->type == XML_CDATA_SECTION_NODE))) {
+#ifdef DEBUG_STEP
+                        n++;
+#endif
+                        addNode(list, cur);
+                    }
+                    break;
+                case NODE_TEST_PI:
+                    if (cur->type == XML_PI_NODE) {
+                        if ((name != NULL) &&
+                            (!xmlStrEqual(name, cur->name)))
+                            break;
+#ifdef DEBUG_STEP
+                        n++;
+#endif
+                        addNode(list, cur);
+                    }
+                    break;
+                case NODE_TEST_ALL:
+                    if (axis == AXIS_ATTRIBUTE) {
+                        if (cur->type == XML_ATTRIBUTE_NODE) {
+#ifdef DEBUG_STEP
+                            n++;
+#endif
+                            addNode(list, cur);
+                        }
+                    } else if (axis == AXIS_NAMESPACE) {
+                        if (cur->type == XML_NAMESPACE_DECL) {
+#ifdef DEBUG_STEP
+                            n++;
+#endif
+                            xmlXPathNodeSetAddNs(list, ctxt->context->node, 
+				                 (xmlNsPtr) cur);
+                        }
+                    } else {
+                        if (cur->type == XML_ELEMENT_NODE) {
+                            if (prefix == NULL) {
+#ifdef DEBUG_STEP
+                                n++;
+#endif
+                                addNode(list, cur);
+                            } else if ((cur->ns != NULL) &&
+                                       (xmlStrEqual(URI, cur->ns->href))) {
+#ifdef DEBUG_STEP
+                                n++;
+#endif
+                                addNode(list, cur);
+                            }
+                        }
+                    }
+                    break;
+                case NODE_TEST_NS:{
+                        TODO;
+                        break;
+                    }
+                case NODE_TEST_NAME:
+                    switch (cur->type) {
+                        case XML_ELEMENT_NODE:
+                            if (xmlStrEqual(name, cur->name)) {
+                                if (prefix == NULL) {
+                                    if (cur->ns == NULL) {
+#ifdef DEBUG_STEP
+                                        n++;
+#endif
+                                        addNode(list, cur);
+                                    }
+                                } else {
+                                    if ((cur->ns != NULL) &&
+                                        (xmlStrEqual(URI,
+                                                     cur->ns->href))) {
+#ifdef DEBUG_STEP
+                                        n++;
+#endif
+                                        addNode(list, cur);
+                                    }
+                                }
+                            }
+                            break;
+                        case XML_ATTRIBUTE_NODE:{
+                                xmlAttrPtr attr = (xmlAttrPtr) cur;
+
+                                if (xmlStrEqual(name, attr->name)) {
+                                    if (prefix == NULL) {
+                                        if ((attr->ns == NULL) ||
+                                            (attr->ns->prefix == NULL)) {
+#ifdef DEBUG_STEP
+                                            n++;
+#endif
+                                            addNode(list,
+                                                    (xmlNodePtr) attr);
+                                        }
+                                    } else {
+                                        if ((attr->ns != NULL) &&
+                                            (xmlStrEqual(URI,
+                                                         attr->ns->
+                                                         href))) {
+#ifdef DEBUG_STEP
+                                            n++;
+#endif
+                                            addNode(list,
+                                                    (xmlNodePtr) attr);
+                                        }
+                                    }
+                                }
+                                break;
+                            }
+                        case XML_NAMESPACE_DECL:
+                            if (cur->type == XML_NAMESPACE_DECL) {
+                                xmlNsPtr ns = (xmlNsPtr) cur;
+
+                                if ((ns->prefix != NULL) && (name != NULL)
+                                    && (xmlStrEqual(ns->prefix, name))) {
+#ifdef DEBUG_STEP
+                                    n++;
+#endif
+				    xmlXPathNodeSetAddNs(list,
+					ctxt->context->node, (xmlNsPtr) cur);
+                                }
+                            }
+                            break;
+                        default:
+                            break;
+                    }
+                    break;
+                    break;
+            }
+        } while (cur != NULL);
+
+        /*
+         * If there is some predicate filtering do it now
+         */
+        if ((op->ch2 != -1) && (list != NULL) && (list->nodeNr > 0)) {
+            xmlXPathObjectPtr obj2;
+
+            valuePush(ctxt, xmlXPathWrapNodeSet(list));
+            xmlXPathCompOpEval(ctxt, &ctxt->comp->steps[op->ch2]);
+            CHECK_TYPE0(XPATH_NODESET);
+            obj2 = valuePop(ctxt);
+            list = obj2->nodesetval;
+            obj2->nodesetval = NULL;
+            xmlXPathFreeObject(obj2);
+        }
+        if (ret == NULL) {
+            ret = list;
+        } else {
+            ret = mergeNodeSet(ret, list);
+            xmlXPathFreeNodeSet(list);
+        }
+    }
+    ctxt->context->node = tmp;
+#ifdef DEBUG_STEP
+    xmlGenericError(xmlGenericErrorContext,
+                    "\nExamined %d nodes, found %d nodes at that step\n",
+                    t, n);
+#endif
+    valuePush(ctxt, xmlXPathWrapNodeSet(ret));
+    if ((obj->boolval) && (obj->user != NULL)) {
+	ctxt->value->boolval = 1;
+	ctxt->value->user = obj->user;
+	obj->user = NULL;
+	obj->boolval = 0;
+    }
+    xmlXPathFreeObject(obj);
+    return(t);
+}
+
+/**
+ * xmlXPathNodeCollectAndTestNth:
+ * @ctxt:  the XPath Parser context
+ * @op:  the XPath precompiled step operation
+ * @indx:  the index to collect
+ * @first:  pointer to the first element in document order
+ * @last:  pointer to the last element in document order
+ *
+ * This is the function implementing a step: based on the current list
+ * of nodes, it builds up a new list, looking at all nodes under that
+ * axis and selecting them. It also does the predicate filtering
+ *
+ * Pushes the new NodeSet resulting from the search.
+ * Returns the number of node traversed
+ */
+static int
+xmlXPathNodeCollectAndTestNth(xmlXPathParserContextPtr ctxt,
+                              xmlXPathStepOpPtr op, int indx,
+                              xmlNodePtr * first, xmlNodePtr * last)
+{
+    xmlXPathAxisVal axis = (xmlXPathAxisVal) op->value;
+    xmlXPathTestVal test = (xmlXPathTestVal) op->value2;
+    xmlXPathTypeVal type = (xmlXPathTypeVal) op->value3;
+    const xmlChar *prefix = op->value4;
+    const xmlChar *name = op->value5;
+    const xmlChar *URI = NULL;
+    int n = 0, t = 0;
+
+    int i;
+    xmlNodeSetPtr list;
+    xmlXPathTraversalFunction next = NULL;
+    void (*addNode) (xmlNodeSetPtr, xmlNodePtr);
+    xmlNodePtr cur = NULL;
+    xmlXPathObjectPtr obj;
+    xmlNodeSetPtr nodelist;
+    xmlNodePtr tmp;
+
+    CHECK_TYPE0(XPATH_NODESET);
+    obj = valuePop(ctxt);
+    addNode = xmlXPathNodeSetAdd;
+    if (prefix != NULL) {
+        URI = xmlXPathNsLookup(ctxt->context, prefix);
+        if (URI == NULL)
+            XP_ERROR0(XPATH_UNDEF_PREFIX_ERROR);
+    }
+#ifdef DEBUG_STEP_NTH
+    xmlGenericError(xmlGenericErrorContext, "new step : ");
+    if (first != NULL) {
+	if (*first != NULL)
+	    xmlGenericError(xmlGenericErrorContext, "first = %s ",
+		    (*first)->name);
+	else
+	    xmlGenericError(xmlGenericErrorContext, "first = NULL ");
+    }
+    if (last != NULL) {
+	if (*last != NULL)
+	    xmlGenericError(xmlGenericErrorContext, "last = %s ",
+		    (*last)->name);
+	else
+	    xmlGenericError(xmlGenericErrorContext, "last = NULL ");
+    }
+#endif
+    switch (axis) {
+        case AXIS_ANCESTOR:
+#ifdef DEBUG_STEP_NTH
+            xmlGenericError(xmlGenericErrorContext, "axis 'ancestors' ");
+#endif
+            first = NULL;
+            next = xmlXPathNextAncestor;
+            break;
+        case AXIS_ANCESTOR_OR_SELF:
+#ifdef DEBUG_STEP_NTH
+            xmlGenericError(xmlGenericErrorContext,
+                            "axis 'ancestors-or-self' ");
+#endif
+            first = NULL;
+            next = xmlXPathNextAncestorOrSelf;
+            break;
+        case AXIS_ATTRIBUTE:
+#ifdef DEBUG_STEP_NTH
+            xmlGenericError(xmlGenericErrorContext, "axis 'attributes' ");
+#endif
+            first = NULL;
+	    last = NULL;
+            next = xmlXPathNextAttribute;
+            break;
+        case AXIS_CHILD:
+#ifdef DEBUG_STEP_NTH
+            xmlGenericError(xmlGenericErrorContext, "axis 'child' ");
+#endif
+	    last = NULL;
+            next = xmlXPathNextChild;
+            break;
+        case AXIS_DESCENDANT:
+#ifdef DEBUG_STEP_NTH
+            xmlGenericError(xmlGenericErrorContext, "axis 'descendant' ");
+#endif
+	    last = NULL;
+            next = xmlXPathNextDescendant;
+            break;
+        case AXIS_DESCENDANT_OR_SELF:
+#ifdef DEBUG_STEP_NTH
+            xmlGenericError(xmlGenericErrorContext,
+                            "axis 'descendant-or-self' ");
+#endif
+	    last = NULL;
+            next = xmlXPathNextDescendantOrSelf;
+            break;
+        case AXIS_FOLLOWING:
+#ifdef DEBUG_STEP_NTH
+            xmlGenericError(xmlGenericErrorContext, "axis 'following' ");
+#endif
+	    last = NULL;
+            next = xmlXPathNextFollowing;
+            break;
+        case AXIS_FOLLOWING_SIBLING:
+#ifdef DEBUG_STEP_NTH
+            xmlGenericError(xmlGenericErrorContext,
+                            "axis 'following-siblings' ");
+#endif
+	    last = NULL;
+            next = xmlXPathNextFollowingSibling;
+            break;
+        case AXIS_NAMESPACE:
+#ifdef DEBUG_STEP_NTH
+            xmlGenericError(xmlGenericErrorContext, "axis 'namespace' ");
+#endif
+	    last = NULL;
+            first = NULL;
+            next = (xmlXPathTraversalFunction) xmlXPathNextNamespace;
+            break;
+        case AXIS_PARENT:
+#ifdef DEBUG_STEP_NTH
+            xmlGenericError(xmlGenericErrorContext, "axis 'parent' ");
+#endif
+            first = NULL;
+            next = xmlXPathNextParent;
+            break;
+        case AXIS_PRECEDING:
+#ifdef DEBUG_STEP_NTH
+            xmlGenericError(xmlGenericErrorContext, "axis 'preceding' ");
+#endif
+            first = NULL;
+            next = xmlXPathNextPrecedingInternal;
+            break;
+        case AXIS_PRECEDING_SIBLING:
+#ifdef DEBUG_STEP_NTH
+            xmlGenericError(xmlGenericErrorContext,
+                            "axis 'preceding-sibling' ");
+#endif
+            first = NULL;
+            next = xmlXPathNextPrecedingSibling;
+            break;
+        case AXIS_SELF:
+#ifdef DEBUG_STEP_NTH
+            xmlGenericError(xmlGenericErrorContext, "axis 'self' ");
+#endif
+            first = NULL;
+	    last = NULL;
+            next = xmlXPathNextSelf;
+            break;
+    }
+    if (next == NULL)
+        return(0);
+
+    nodelist = obj->nodesetval;
+    if (nodelist == NULL) {
+        xmlXPathFreeObject(obj);
+        valuePush(ctxt, xmlXPathWrapNodeSet(NULL));
+        return(0);
+    }
+    addNode = xmlXPathNodeSetAddUnique;
+#ifdef DEBUG_STEP_NTH
+    xmlGenericError(xmlGenericErrorContext,
+                    " context contains %d nodes\n", nodelist->nodeNr);
+    switch (test) {
+        case NODE_TEST_NONE:
+            xmlGenericError(xmlGenericErrorContext,
+                            "           searching for none !!!\n");
+            break;
+        case NODE_TEST_TYPE:
+            xmlGenericError(xmlGenericErrorContext,
+                            "           searching for type %d\n", type);
+            break;
+        case NODE_TEST_PI:
+            xmlGenericError(xmlGenericErrorContext,
+                            "           searching for PI !!!\n");
+            break;
+        case NODE_TEST_ALL:
+            xmlGenericError(xmlGenericErrorContext,
+                            "           searching for *\n");
+            break;
+        case NODE_TEST_NS:
+            xmlGenericError(xmlGenericErrorContext,
+                            "           searching for namespace %s\n",
+                            prefix);
+            break;
+        case NODE_TEST_NAME:
+            xmlGenericError(xmlGenericErrorContext,
+                            "           searching for name %s\n", name);
+            if (prefix != NULL)
+                xmlGenericError(xmlGenericErrorContext,
+                                "           with namespace %s\n", prefix);
+            break;
+    }
+    xmlGenericError(xmlGenericErrorContext, "Testing : ");
+#endif
+    /*
+     * 2.3 Node Tests
+     *  - For the attribute axis, the principal node type is attribute. 
+     *  - For the namespace axis, the principal node type is namespace. 
+     *  - For other axes, the principal node type is element. 
+     *
+     * A node test * is true for any node of the
+     * principal node type. For example, child::* will
+     * select all element children of the context node
+     */
+    tmp = ctxt->context->node;
+    list = xmlXPathNodeSetCreate(NULL);
+    for (i = 0; i < nodelist->nodeNr; i++) {
+        ctxt->context->node = nodelist->nodeTab[i];
+
+        cur = NULL;
+        n = 0;
+        do {
+            cur = next(ctxt, cur);
+            if (cur == NULL)
+                break;
+	    if ((first != NULL) && (*first == cur))
+		break;
+	    if (((t % 256) == 0) &&
+	        (first != NULL) && (*first != NULL) &&
+		(xmlXPathCmpNodes(*first, cur) >= 0))
+		break;
+	    if ((last != NULL) && (*last == cur))
+		break;
+	    if (((t % 256) == 0) &&
+	        (last != NULL) && (*last != NULL) &&
+		(xmlXPathCmpNodes(cur, *last) >= 0))
+		break;
+            t++;
+            switch (test) {
+                case NODE_TEST_NONE:
+                    ctxt->context->node = tmp;
+                    STRANGE return(0);
+                case NODE_TEST_TYPE:
+                    if ((cur->type == type) ||
+                        ((type == NODE_TYPE_NODE) &&
+                         ((cur->type == XML_DOCUMENT_NODE) ||
+                          (cur->type == XML_HTML_DOCUMENT_NODE) ||
+                          (cur->type == XML_ELEMENT_NODE) ||
+                          (cur->type == XML_PI_NODE) ||
+                          (cur->type == XML_COMMENT_NODE) ||
+                          (cur->type == XML_CDATA_SECTION_NODE) ||
+                          (cur->type == XML_TEXT_NODE))) ||
+			((type == NODE_TYPE_TEXT) &&
+			 (cur->type == XML_CDATA_SECTION_NODE))) {
+                        n++;
+                        if (n == indx)
+                            addNode(list, cur);
+                    }
+                    break;
+                case NODE_TEST_PI:
+                    if (cur->type == XML_PI_NODE) {
+                        if ((name != NULL) &&
+                            (!xmlStrEqual(name, cur->name)))
+                            break;
+                        n++;
+                        if (n == indx)
+                            addNode(list, cur);
+                    }
+                    break;
+                case NODE_TEST_ALL:
+                    if (axis == AXIS_ATTRIBUTE) {
+                        if (cur->type == XML_ATTRIBUTE_NODE) {
+                            n++;
+                            if (n == indx)
+                                addNode(list, cur);
+                        }
+                    } else if (axis == AXIS_NAMESPACE) {
+                        if (cur->type == XML_NAMESPACE_DECL) {
+                            n++;
+                            if (n == indx)
+				xmlXPathNodeSetAddNs(list, ctxt->context->node, 
+						     (xmlNsPtr) cur);
+                        }
+                    } else {
+                        if (cur->type == XML_ELEMENT_NODE) {
+                            if (prefix == NULL) {
+                                n++;
+                                if (n == indx)
+                                    addNode(list, cur);
+                            } else if ((cur->ns != NULL) &&
+                                       (xmlStrEqual(URI, cur->ns->href))) {
+                                n++;
+                                if (n == indx)
+                                    addNode(list, cur);
+                            }
+                        }
+                    }
+                    break;
+                case NODE_TEST_NS:{
+                        TODO;
+                        break;
+                    }
+                case NODE_TEST_NAME:
+                    switch (cur->type) {
+                        case XML_ELEMENT_NODE:
+                            if (xmlStrEqual(name, cur->name)) {
+                                if (prefix == NULL) {
+                                    if (cur->ns == NULL) {
+                                        n++;
+                                        if (n == indx)
+                                            addNode(list, cur);
+                                    }
+                                } else {
+                                    if ((cur->ns != NULL) &&
+                                        (xmlStrEqual(URI,
+                                                     cur->ns->href))) {
+                                        n++;
+                                        if (n == indx)
+                                            addNode(list, cur);
+                                    }
+                                }
+                            }
+                            break;
+                        case XML_ATTRIBUTE_NODE:{
+                                xmlAttrPtr attr = (xmlAttrPtr) cur;
+
+                                if (xmlStrEqual(name, attr->name)) {
+                                    if (prefix == NULL) {
+                                        if ((attr->ns == NULL) ||
+                                            (attr->ns->prefix == NULL)) {
+                                            n++;
+                                            if (n == indx)
+                                                addNode(list, cur);
+                                        }
+                                    } else {
+                                        if ((attr->ns != NULL) &&
+                                            (xmlStrEqual(URI,
+                                                         attr->ns->
+                                                         href))) {
+                                            n++;
+                                            if (n == indx)
+                                                addNode(list, cur);
+                                        }
+                                    }
+                                }
+                                break;
+                            }
+                        case XML_NAMESPACE_DECL:
+                            if (cur->type == XML_NAMESPACE_DECL) {
+                                xmlNsPtr ns = (xmlNsPtr) cur;
+
+                                if ((ns->prefix != NULL) && (name != NULL)
+                                    && (xmlStrEqual(ns->prefix, name))) {
+                                    n++;
+                                    if (n == indx)
+					xmlXPathNodeSetAddNs(list,
+					   ctxt->context->node, (xmlNsPtr) cur);
+                                }
+                            }
+                            break;
+                        default:
+                            break;
+                    }
+                    break;
+                    break;
+            }
+        } while (n < indx);
+    }
+    ctxt->context->node = tmp;
+#ifdef DEBUG_STEP_NTH
+    xmlGenericError(xmlGenericErrorContext,
+                    "\nExamined %d nodes, found %d nodes at that step\n",
+                    t, list->nodeNr);
+#endif
+    valuePush(ctxt, xmlXPathWrapNodeSet(list));
+    if ((obj->boolval) && (obj->user != NULL)) {
+	ctxt->value->boolval = 1;
+	ctxt->value->user = obj->user;
+	obj->user = NULL;
+	obj->boolval = 0;
+    }
+    xmlXPathFreeObject(obj);
+    return(t);
+}
+
+/**
+ * xmlXPathCompOpEvalFirst:
+ * @ctxt:  the XPath parser context with the compiled expression
+ * @op:  an XPath compiled operation
+ * @first:  the first elem found so far
+ *
+ * Evaluate the Precompiled XPath operation searching only the first
+ * element in document order
+ *
+ * Returns the number of examined objects.
+ */
+static int
+xmlXPathCompOpEvalFirst(xmlXPathParserContextPtr ctxt,
+                        xmlXPathStepOpPtr op, xmlNodePtr * first)
+{
+    int total = 0, cur;
+    xmlXPathCompExprPtr comp;
+    xmlXPathObjectPtr arg1, arg2;
+
+    CHECK_ERROR0;
+    comp = ctxt->comp;
+    switch (op->op) {
+        case XPATH_OP_END:
+            return (0);
+        case XPATH_OP_UNION:
+            total =
+                xmlXPathCompOpEvalFirst(ctxt, &comp->steps[op->ch1],
+                                        first);
+	    CHECK_ERROR0;
+            if ((ctxt->value != NULL)
+                && (ctxt->value->type == XPATH_NODESET)
+                && (ctxt->value->nodesetval != NULL)
+                && (ctxt->value->nodesetval->nodeNr >= 1)) {
+                /*
+                 * limit tree traversing to first node in the result
+                 */
+                xmlXPathNodeSetSort(ctxt->value->nodesetval);
+                *first = ctxt->value->nodesetval->nodeTab[0];
+            }
+            cur =
+                xmlXPathCompOpEvalFirst(ctxt, &comp->steps[op->ch2],
+                                        first);
+	    CHECK_ERROR0;
+            CHECK_TYPE0(XPATH_NODESET);
+            arg2 = valuePop(ctxt);
+
+            CHECK_TYPE0(XPATH_NODESET);
+            arg1 = valuePop(ctxt);
+
+            arg1->nodesetval = xmlXPathNodeSetMerge(arg1->nodesetval,
+                                                    arg2->nodesetval);
+            valuePush(ctxt, arg1);
+            xmlXPathFreeObject(arg2);
+            /* optimizer */
+	    if (total > cur)
+		xmlXPathCompSwap(op);
+            return (total + cur);
+        case XPATH_OP_ROOT:
+            xmlXPathRoot(ctxt);
+            return (0);
+        case XPATH_OP_NODE:
+            if (op->ch1 != -1)
+                total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
+	    CHECK_ERROR0;
+            if (op->ch2 != -1)
+                total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
+	    CHECK_ERROR0;
+            valuePush(ctxt, xmlXPathNewNodeSet(ctxt->context->node));
+            return (total);
+        case XPATH_OP_RESET:
+            if (op->ch1 != -1)
+                total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
+	    CHECK_ERROR0;
+            if (op->ch2 != -1)
+                total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
+	    CHECK_ERROR0;
+            ctxt->context->node = NULL;
+            return (total);
+        case XPATH_OP_COLLECT:{
+                if (op->ch1 == -1)
+                    return (total);
+
+                total = xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
+		CHECK_ERROR0;
+
+                /*
+                 * Optimization for [n] selection where n is a number
+                 */
+                if ((op->ch2 != -1) &&
+                    (comp->steps[op->ch2].op == XPATH_OP_PREDICATE) &&
+                    (comp->steps[op->ch2].ch1 == -1) &&
+                    (comp->steps[op->ch2].ch2 != -1) &&
+                    (comp->steps[comp->steps[op->ch2].ch2].op ==
+                     XPATH_OP_VALUE)) {
+                    xmlXPathObjectPtr val;
+
+                    val = comp->steps[comp->steps[op->ch2].ch2].value4;
+                    if ((val != NULL) && (val->type == XPATH_NUMBER)) {
+                        int indx = (int) val->floatval;
+
+                        if (val->floatval == (float) indx) {
+                            xmlXPathNodeCollectAndTestNth(ctxt, op, indx,
+                                                          first, NULL);
+                            return (total);
+                        }
+                    }
+                }
+                total += xmlXPathNodeCollectAndTest(ctxt, op, first, NULL);
+                return (total);
+            }
+        case XPATH_OP_VALUE:
+            valuePush(ctxt,
+                      xmlXPathObjectCopy((xmlXPathObjectPtr) op->value4));
+            return (0);
+        case XPATH_OP_SORT:
+            if (op->ch1 != -1)
+                total +=
+                    xmlXPathCompOpEvalFirst(ctxt, &comp->steps[op->ch1],
+                                            first);
+	    CHECK_ERROR0;
+            if ((ctxt->value != NULL)
+                && (ctxt->value->type == XPATH_NODESET)
+                && (ctxt->value->nodesetval != NULL))
+                xmlXPathNodeSetSort(ctxt->value->nodesetval);
+            return (total);
+        default:
+            return (xmlXPathCompOpEval(ctxt, op));
+    }
+}
+
+/**
+ * xmlXPathCompOpEvalLast:
+ * @ctxt:  the XPath parser context with the compiled expression
+ * @op:  an XPath compiled operation
+ * @last:  the last elem found so far
+ *
+ * Evaluate the Precompiled XPath operation searching only the last
+ * element in document order
+ *
+ * Returns the number of nodes traversed
+ */
+static int
+xmlXPathCompOpEvalLast(xmlXPathParserContextPtr ctxt, xmlXPathStepOpPtr op,
+                       xmlNodePtr * last)
+{
+    int total = 0, cur;
+    xmlXPathCompExprPtr comp;
+    xmlXPathObjectPtr arg1, arg2;
+    xmlNodePtr bak;
+    xmlDocPtr bakd;
+    int pp;
+    int cs;
+
+    CHECK_ERROR0;
+    comp = ctxt->comp;
+    switch (op->op) {
+        case XPATH_OP_END:
+            return (0);
+        case XPATH_OP_UNION:
+	    bakd = ctxt->context->doc;
+	    bak = ctxt->context->node;
+	    pp = ctxt->context->proximityPosition;
+	    cs = ctxt->context->contextSize;
+            total =
+                xmlXPathCompOpEvalLast(ctxt, &comp->steps[op->ch1], last);
+	    CHECK_ERROR0;
+            if ((ctxt->value != NULL)
+                && (ctxt->value->type == XPATH_NODESET)
+                && (ctxt->value->nodesetval != NULL)
+                && (ctxt->value->nodesetval->nodeNr >= 1)) {
+                /*
+                 * limit tree traversing to first node in the result
+                 */
+                xmlXPathNodeSetSort(ctxt->value->nodesetval);
+                *last =
+                    ctxt->value->nodesetval->nodeTab[ctxt->value->
+                                                     nodesetval->nodeNr -
+                                                     1];
+            }
+	    ctxt->context->doc = bakd;
+	    ctxt->context->node = bak;
+	    ctxt->context->proximityPosition = pp;
+	    ctxt->context->contextSize = cs;
+            cur =
+                xmlXPathCompOpEvalLast(ctxt, &comp->steps[op->ch2], last);
+	    CHECK_ERROR0;
+            if ((ctxt->value != NULL)
+                && (ctxt->value->type == XPATH_NODESET)
+                && (ctxt->value->nodesetval != NULL)
+                && (ctxt->value->nodesetval->nodeNr >= 1)) {
+            }
+            CHECK_TYPE0(XPATH_NODESET);
+            arg2 = valuePop(ctxt);
+
+            CHECK_TYPE0(XPATH_NODESET);
+            arg1 = valuePop(ctxt);
+
+            arg1->nodesetval = xmlXPathNodeSetMerge(arg1->nodesetval,
+                                                    arg2->nodesetval);
+            valuePush(ctxt, arg1);
+            xmlXPathFreeObject(arg2);
+            /* optimizer */
+	    if (total > cur)
+		xmlXPathCompSwap(op);
+            return (total + cur);
+        case XPATH_OP_ROOT:
+            xmlXPathRoot(ctxt);
+            return (0);
+        case XPATH_OP_NODE:
+            if (op->ch1 != -1)
+                total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
+	    CHECK_ERROR0;
+            if (op->ch2 != -1)
+                total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
+	    CHECK_ERROR0;
+            valuePush(ctxt, xmlXPathNewNodeSet(ctxt->context->node));
+            return (total);
+        case XPATH_OP_RESET:
+            if (op->ch1 != -1)
+                total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
+	    CHECK_ERROR0;
+            if (op->ch2 != -1)
+                total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
+	    CHECK_ERROR0;
+            ctxt->context->node = NULL;
+            return (total);
+        case XPATH_OP_COLLECT:{
+                if (op->ch1 == -1)
+                    return (0);
+
+                total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
+		CHECK_ERROR0;
+
+                /*
+                 * Optimization for [n] selection where n is a number
+                 */
+                if ((op->ch2 != -1) &&
+                    (comp->steps[op->ch2].op == XPATH_OP_PREDICATE) &&
+                    (comp->steps[op->ch2].ch1 == -1) &&
+                    (comp->steps[op->ch2].ch2 != -1) &&
+                    (comp->steps[comp->steps[op->ch2].ch2].op ==
+                     XPATH_OP_VALUE)) {
+                    xmlXPathObjectPtr val;
+
+                    val = comp->steps[comp->steps[op->ch2].ch2].value4;
+                    if ((val != NULL) && (val->type == XPATH_NUMBER)) {
+                        int indx = (int) val->floatval;
+
+                        if (val->floatval == (float) indx) {
+                            total +=
+                                xmlXPathNodeCollectAndTestNth(ctxt, op,
+                                                              indx, NULL,
+                                                              last);
+                            return (total);
+                        }
+                    }
+                }
+                total += xmlXPathNodeCollectAndTest(ctxt, op, NULL, last);
+                return (total);
+            }
+        case XPATH_OP_VALUE:
+            valuePush(ctxt,
+                      xmlXPathObjectCopy((xmlXPathObjectPtr) op->value4));
+            return (0);
+        case XPATH_OP_SORT:
+            if (op->ch1 != -1)
+                total +=
+                    xmlXPathCompOpEvalLast(ctxt, &comp->steps[op->ch1],
+                                           last);
+	    CHECK_ERROR0;
+            if ((ctxt->value != NULL)
+                && (ctxt->value->type == XPATH_NODESET)
+                && (ctxt->value->nodesetval != NULL))
+                xmlXPathNodeSetSort(ctxt->value->nodesetval);
+            return (total);
+        default:
+            return (xmlXPathCompOpEval(ctxt, op));
+    }
+}
+
+/**
+ * xmlXPathCompOpEval:
+ * @ctxt:  the XPath parser context with the compiled expression
+ * @op:  an XPath compiled operation
+ *
+ * Evaluate the Precompiled XPath operation
+ * Returns the number of nodes traversed
+ */
+static int
+xmlXPathCompOpEval(xmlXPathParserContextPtr ctxt, xmlXPathStepOpPtr op)
+{
+    int total = 0;
+    int equal, ret;
+    xmlXPathCompExprPtr comp;
+    xmlXPathObjectPtr arg1, arg2;
+    xmlNodePtr bak;
+    xmlDocPtr bakd;
+    int pp;
+    int cs;
+
+    CHECK_ERROR0;
+    comp = ctxt->comp;
+    switch (op->op) {
+        case XPATH_OP_END:
+            return (0);
+        case XPATH_OP_AND:
+	    bakd = ctxt->context->doc;
+	    bak = ctxt->context->node;
+	    pp = ctxt->context->proximityPosition;
+	    cs = ctxt->context->contextSize;
+            total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
+	    CHECK_ERROR0;
+            xmlXPathBooleanFunction(ctxt, 1);
+            if ((ctxt->value == NULL) || (ctxt->value->boolval == 0))
+                return (total);
+            arg2 = valuePop(ctxt);
+	    ctxt->context->doc = bakd;
+	    ctxt->context->node = bak;
+	    ctxt->context->proximityPosition = pp;
+	    ctxt->context->contextSize = cs;
+            total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
+	    if (ctxt->error) {
+		xmlXPathFreeObject(arg2);
+		return(0);
+	    }
+            xmlXPathBooleanFunction(ctxt, 1);
+            arg1 = valuePop(ctxt);
+            arg1->boolval &= arg2->boolval;
+            valuePush(ctxt, arg1);
+            xmlXPathFreeObject(arg2);
+            return (total);
+        case XPATH_OP_OR:
+	    bakd = ctxt->context->doc;
+	    bak = ctxt->context->node;
+	    pp = ctxt->context->proximityPosition;
+	    cs = ctxt->context->contextSize;
+            total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
+	    CHECK_ERROR0;
+            xmlXPathBooleanFunction(ctxt, 1);
+            if ((ctxt->value == NULL) || (ctxt->value->boolval == 1))
+                return (total);
+            arg2 = valuePop(ctxt);
+	    ctxt->context->doc = bakd;
+	    ctxt->context->node = bak;
+	    ctxt->context->proximityPosition = pp;
+	    ctxt->context->contextSize = cs;
+            total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
+	    if (ctxt->error) {
+		xmlXPathFreeObject(arg2);
+		return(0);
+	    }
+            xmlXPathBooleanFunction(ctxt, 1);
+            arg1 = valuePop(ctxt);
+            arg1->boolval |= arg2->boolval;
+            valuePush(ctxt, arg1);
+            xmlXPathFreeObject(arg2);
+            return (total);
+        case XPATH_OP_EQUAL:
+	    bakd = ctxt->context->doc;
+	    bak = ctxt->context->node;
+	    pp = ctxt->context->proximityPosition;
+	    cs = ctxt->context->contextSize;
+            total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
+	    CHECK_ERROR0;
+	    ctxt->context->doc = bakd;
+	    ctxt->context->node = bak;
+	    ctxt->context->proximityPosition = pp;
+	    ctxt->context->contextSize = cs;
+            total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
+	    CHECK_ERROR0;
+	    if (op->value)
+        	equal = xmlXPathEqualValues(ctxt);
+	    else
+		equal = xmlXPathNotEqualValues(ctxt);
+	    valuePush(ctxt, xmlXPathNewBoolean(equal));
+            return (total);
+        case XPATH_OP_CMP:
+	    bakd = ctxt->context->doc;
+	    bak = ctxt->context->node;
+	    pp = ctxt->context->proximityPosition;
+	    cs = ctxt->context->contextSize;
+            total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
+	    CHECK_ERROR0;
+	    ctxt->context->doc = bakd;
+	    ctxt->context->node = bak;
+	    ctxt->context->proximityPosition = pp;
+	    ctxt->context->contextSize = cs;
+            total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
+	    CHECK_ERROR0;
+            ret = xmlXPathCompareValues(ctxt, op->value, op->value2);
+            valuePush(ctxt, xmlXPathNewBoolean(ret));
+            return (total);
+        case XPATH_OP_PLUS:
+	    bakd = ctxt->context->doc;
+	    bak = ctxt->context->node;
+	    pp = ctxt->context->proximityPosition;
+	    cs = ctxt->context->contextSize;
+            total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
+	    CHECK_ERROR0;
+            if (op->ch2 != -1) {
+		ctxt->context->doc = bakd;
+		ctxt->context->node = bak;
+		ctxt->context->proximityPosition = pp;
+		ctxt->context->contextSize = cs;
+                total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
+	    }
+	    CHECK_ERROR0;
+            if (op->value == 0)
+                xmlXPathSubValues(ctxt);
+            else if (op->value == 1)
+                xmlXPathAddValues(ctxt);
+            else if (op->value == 2)
+                xmlXPathValueFlipSign(ctxt);
+            else if (op->value == 3) {
+                CAST_TO_NUMBER;
+                CHECK_TYPE0(XPATH_NUMBER);
+            }
+            return (total);
+        case XPATH_OP_MULT:
+	    bakd = ctxt->context->doc;
+	    bak = ctxt->context->node;
+	    pp = ctxt->context->proximityPosition;
+	    cs = ctxt->context->contextSize;
+            total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
+	    CHECK_ERROR0;
+	    ctxt->context->doc = bakd;
+	    ctxt->context->node = bak;
+	    ctxt->context->proximityPosition = pp;
+	    ctxt->context->contextSize = cs;
+            total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
+	    CHECK_ERROR0;
+            if (op->value == 0)
+                xmlXPathMultValues(ctxt);
+            else if (op->value == 1)
+                xmlXPathDivValues(ctxt);
+            else if (op->value == 2)
+                xmlXPathModValues(ctxt);
+            return (total);
+        case XPATH_OP_UNION:
+	    bakd = ctxt->context->doc;
+	    bak = ctxt->context->node;
+	    pp = ctxt->context->proximityPosition;
+	    cs = ctxt->context->contextSize;
+            total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
+	    CHECK_ERROR0;
+	    ctxt->context->doc = bakd;
+	    ctxt->context->node = bak;
+	    ctxt->context->proximityPosition = pp;
+	    ctxt->context->contextSize = cs;
+            total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
+	    CHECK_ERROR0;
+            CHECK_TYPE0(XPATH_NODESET);
+            arg2 = valuePop(ctxt);
+
+            CHECK_TYPE0(XPATH_NODESET);
+            arg1 = valuePop(ctxt);
+
+            arg1->nodesetval = xmlXPathNodeSetMerge(arg1->nodesetval,
+                                                    arg2->nodesetval);
+            valuePush(ctxt, arg1);
+            xmlXPathFreeObject(arg2);
+            return (total);
+        case XPATH_OP_ROOT:
+            xmlXPathRoot(ctxt);
+            return (total);
+        case XPATH_OP_NODE:
+            if (op->ch1 != -1)
+                total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
+	    CHECK_ERROR0;
+            if (op->ch2 != -1)
+                total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
+	    CHECK_ERROR0;
+            valuePush(ctxt, xmlXPathNewNodeSet(ctxt->context->node));
+            return (total);
+        case XPATH_OP_RESET:
+            if (op->ch1 != -1)
+                total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
+	    CHECK_ERROR0;
+            if (op->ch2 != -1)
+                total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
+	    CHECK_ERROR0;
+            ctxt->context->node = NULL;
+            return (total);
+        case XPATH_OP_COLLECT:{
+                if (op->ch1 == -1)
+                    return (total);
+
+                total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
+		CHECK_ERROR0;
+
+                /*
+                 * Optimization for [n] selection where n is a number
+                 */
+                if ((op->ch2 != -1) &&
+                    (comp->steps[op->ch2].op == XPATH_OP_PREDICATE) &&
+                    (comp->steps[op->ch2].ch1 == -1) &&
+                    (comp->steps[op->ch2].ch2 != -1) &&
+                    (comp->steps[comp->steps[op->ch2].ch2].op ==
+                     XPATH_OP_VALUE)) {
+                    xmlXPathObjectPtr val;
+
+                    val = comp->steps[comp->steps[op->ch2].ch2].value4;
+                    if ((val != NULL) && (val->type == XPATH_NUMBER)) {
+                        int indx = (int) val->floatval;
+
+                        if (val->floatval == (float) indx) {
+                            total +=
+                                xmlXPathNodeCollectAndTestNth(ctxt, op,
+                                                              indx, NULL,
+                                                              NULL);
+                            return (total);
+                        }
+                    }
+                }
+                total += xmlXPathNodeCollectAndTest(ctxt, op, NULL, NULL);
+                return (total);
+            }
+        case XPATH_OP_VALUE:
+            valuePush(ctxt,
+                      xmlXPathObjectCopy((xmlXPathObjectPtr) op->value4));
+            return (total);
+        case XPATH_OP_VARIABLE:{
+		xmlXPathObjectPtr val;
+
+                if (op->ch1 != -1)
+                    total +=
+                        xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
+                if (op->value5 == NULL) {
+		    val = xmlXPathVariableLookup(ctxt->context, op->value4);
+		    if (val == NULL) {
+			ctxt->error = XPATH_UNDEF_VARIABLE_ERROR;
+			return(0);
+		    }
+                    valuePush(ctxt, val);
+		} else {
+                    const xmlChar *URI;
+
+                    URI = xmlXPathNsLookup(ctxt->context, op->value5);
+                    if (URI == NULL) {
+                        xmlGenericError(xmlGenericErrorContext,
+                                        "xmlXPathCompOpEval: variable %s bound to undefined prefix %s\n",
+                                        op->value4, op->value5);
+                        return (total);
+                    }
+		    val = xmlXPathVariableLookupNS(ctxt->context,
+                                                       op->value4, URI);
+		    if (val == NULL) {
+			ctxt->error = XPATH_UNDEF_VARIABLE_ERROR;
+			return(0);
+		    }
+                    valuePush(ctxt, val);
+                }
+                return (total);
+            }
+        case XPATH_OP_FUNCTION:{
+                xmlXPathFunction func;
+                const xmlChar *oldFunc, *oldFuncURI;
+		int i;
+
+                if (op->ch1 != -1)
+                    total +=
+                        xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
+		if (ctxt->valueNr < op->value) {
+		    xmlGenericError(xmlGenericErrorContext,
+			    "xmlXPathCompOpEval: parameter error\n");
+		    ctxt->error = XPATH_INVALID_OPERAND;
+		    return (total);
+		}
+		for (i = 0; i < op->value; i++)
+		    if (ctxt->valueTab[(ctxt->valueNr - 1) - i] == NULL) {
+			xmlGenericError(xmlGenericErrorContext,
+				"xmlXPathCompOpEval: parameter error\n");
+			ctxt->error = XPATH_INVALID_OPERAND;
+			return (total);
+		    }
+                if (op->cache != NULL)
+                    func = (xmlXPathFunction) op->cache;
+                else {
+                    const xmlChar *URI = NULL;
+
+                    if (op->value5 == NULL)
+                        func =
+                            xmlXPathFunctionLookup(ctxt->context,
+                                                   op->value4);
+                    else {
+                        URI = xmlXPathNsLookup(ctxt->context, op->value5);
+                        if (URI == NULL) {
+                            xmlGenericError(xmlGenericErrorContext,
+                                            "xmlXPathCompOpEval: function %s bound to undefined prefix %s\n",
+                                            op->value4, op->value5);
+                            return (total);
+                        }
+                        func = xmlXPathFunctionLookupNS(ctxt->context,
+                                                        op->value4, URI);
+                    }
+                    if (func == NULL) {
+                        xmlGenericError(xmlGenericErrorContext,
+                                        "xmlXPathCompOpEval: function %s not found\n",
+                                        op->value4);
+                        XP_ERROR0(XPATH_UNKNOWN_FUNC_ERROR);
+                    }
+                    op->cache = (void *) func;
+                    op->cacheURI = (void *) URI;
+                }
+                oldFunc = ctxt->context->function;
+                oldFuncURI = ctxt->context->functionURI;
+                ctxt->context->function = op->value4;
+                ctxt->context->functionURI = op->cacheURI;
+                func(ctxt, op->value);
+                ctxt->context->function = oldFunc;
+                ctxt->context->functionURI = oldFuncURI;
+                return (total);
+            }
+        case XPATH_OP_ARG:
+	    bakd = ctxt->context->doc;
+	    bak = ctxt->context->node;
+            if (op->ch1 != -1)
+                total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
+	    ctxt->context->doc = bakd;
+	    ctxt->context->node = bak;
+	    CHECK_ERROR0;
+            if (op->ch2 != -1) {
+                total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
+	        ctxt->context->doc = bakd;
+	        ctxt->context->node = bak;
+	        CHECK_ERROR0;
+	    }
+            return (total);
+        case XPATH_OP_PREDICATE:
+        case XPATH_OP_FILTER:{
+                xmlXPathObjectPtr res;
+                xmlXPathObjectPtr obj, tmp;
+                xmlNodeSetPtr newset = NULL;
+                xmlNodeSetPtr oldset;
+                xmlNodePtr oldnode;
+                int i;
+
+                /*
+                 * Optimization for ()[1] selection i.e. the first elem
+                 */
+                if ((op->ch1 != -1) && (op->ch2 != -1) &&
+                    (comp->steps[op->ch1].op == XPATH_OP_SORT) &&
+                    (comp->steps[op->ch2].op == XPATH_OP_VALUE)) {
+                    xmlXPathObjectPtr val;
+
+                    val = comp->steps[op->ch2].value4;
+                    if ((val != NULL) && (val->type == XPATH_NUMBER) &&
+                        (val->floatval == 1.0)) {
+                        xmlNodePtr first = NULL;
+
+                        total +=
+                            xmlXPathCompOpEvalFirst(ctxt,
+                                                    &comp->steps[op->ch1],
+                                                    &first);
+			CHECK_ERROR0;
+                        /*
+                         * The nodeset should be in document order,
+                         * Keep only the first value
+                         */
+                        if ((ctxt->value != NULL) &&
+                            (ctxt->value->type == XPATH_NODESET) &&
+                            (ctxt->value->nodesetval != NULL) &&
+                            (ctxt->value->nodesetval->nodeNr > 1))
+                            ctxt->value->nodesetval->nodeNr = 1;
+                        return (total);
+                    }
+                }
+                /*
+                 * Optimization for ()[last()] selection i.e. the last elem
+                 */
+                if ((op->ch1 != -1) && (op->ch2 != -1) &&
+                    (comp->steps[op->ch1].op == XPATH_OP_SORT) &&
+                    (comp->steps[op->ch2].op == XPATH_OP_SORT)) {
+                    int f = comp->steps[op->ch2].ch1;
+
+                    if ((f != -1) &&
+                        (comp->steps[f].op == XPATH_OP_FUNCTION) &&
+                        (comp->steps[f].value5 == NULL) &&
+                        (comp->steps[f].value == 0) &&
+                        (comp->steps[f].value4 != NULL) &&
+                        (xmlStrEqual
+                         (comp->steps[f].value4, BAD_CAST "last"))) {
+                        xmlNodePtr last = NULL;
+
+                        total +=
+                            xmlXPathCompOpEvalLast(ctxt,
+                                                   &comp->steps[op->ch1],
+                                                   &last);
+			CHECK_ERROR0;
+                        /*
+                         * The nodeset should be in document order,
+                         * Keep only the last value
+                         */
+                        if ((ctxt->value != NULL) &&
+                            (ctxt->value->type == XPATH_NODESET) &&
+                            (ctxt->value->nodesetval != NULL) &&
+                            (ctxt->value->nodesetval->nodeTab != NULL) &&
+                            (ctxt->value->nodesetval->nodeNr > 1)) {
+                            ctxt->value->nodesetval->nodeTab[0] =
+                                ctxt->value->nodesetval->nodeTab[ctxt->
+                                                                 value->
+                                                                 nodesetval->
+                                                                 nodeNr -
+                                                                 1];
+                            ctxt->value->nodesetval->nodeNr = 1;
+                        }
+                        return (total);
+                    }
+                }
+
+                if (op->ch1 != -1)
+                    total +=
+                        xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
+		CHECK_ERROR0;
+                if (op->ch2 == -1)
+                    return (total);
+                if (ctxt->value == NULL)
+                    return (total);
+
+                oldnode = ctxt->context->node;
+
+#ifdef LIBXML_XPTR_ENABLED
+                /*
+                 * Hum are we filtering the result of an XPointer expression
+                 */
+                if (ctxt->value->type == XPATH_LOCATIONSET) {
+                    xmlLocationSetPtr newlocset = NULL;
+                    xmlLocationSetPtr oldlocset;
+
+                    /*
+                     * Extract the old locset, and then evaluate the result of the
+                     * expression for all the element in the locset. use it to grow
+                     * up a new locset.
+                     */
+                    CHECK_TYPE0(XPATH_LOCATIONSET);
+                    obj = valuePop(ctxt);
+                    oldlocset = obj->user;
+                    ctxt->context->node = NULL;
+
+                    if ((oldlocset == NULL) || (oldlocset->locNr == 0)) {
+                        ctxt->context->contextSize = 0;
+                        ctxt->context->proximityPosition = 0;
+                        if (op->ch2 != -1)
+                            total +=
+                                xmlXPathCompOpEval(ctxt,
+                                                   &comp->steps[op->ch2]);
+                        res = valuePop(ctxt);
+                        if (res != NULL)
+                            xmlXPathFreeObject(res);
+                        valuePush(ctxt, obj);
+                        CHECK_ERROR0;
+                        return (total);
+                    }
+                    newlocset = xmlXPtrLocationSetCreate(NULL);
+
+                    for (i = 0; i < oldlocset->locNr; i++) {
+                        /*
+                         * Run the evaluation with a node list made of a
+                         * single item in the nodelocset.
+                         */
+                        ctxt->context->node = oldlocset->locTab[i]->user;
+                        ctxt->context->contextSize = oldlocset->locNr;
+                        ctxt->context->proximityPosition = i + 1;
+                        tmp = xmlXPathNewNodeSet(ctxt->context->node);
+                        valuePush(ctxt, tmp);
+
+                        if (op->ch2 != -1)
+                            total +=
+                                xmlXPathCompOpEval(ctxt,
+                                                   &comp->steps[op->ch2]);
+                        CHECK_ERROR0;
+
+                        /*
+                         * The result of the evaluation need to be tested to
+                         * decided whether the filter succeeded or not
+                         */
+                        res = valuePop(ctxt);
+                        if (xmlXPathEvaluatePredicateResult(ctxt, res)) {
+                            xmlXPtrLocationSetAdd(newlocset,
+                                                  xmlXPathObjectCopy
+                                                  (oldlocset->locTab[i]));
+                        }
+
+                        /*
+                         * Cleanup
+                         */
+                        if (res != NULL)
+                            xmlXPathFreeObject(res);
+                        if (ctxt->value == tmp) {
+                            res = valuePop(ctxt);
+                            xmlXPathFreeObject(res);
+                        }
+
+                        ctxt->context->node = NULL;
+                    }
+
+                    /*
+                     * The result is used as the new evaluation locset.
+                     */
+                    xmlXPathFreeObject(obj);
+                    ctxt->context->node = NULL;
+                    ctxt->context->contextSize = -1;
+                    ctxt->context->proximityPosition = -1;
+                    valuePush(ctxt, xmlXPtrWrapLocationSet(newlocset));
+                    ctxt->context->node = oldnode;
+                    return (total);
+                }
+#endif /* LIBXML_XPTR_ENABLED */
+
+                /*
+                 * Extract the old set, and then evaluate the result of the
+                 * expression for all the element in the set. use it to grow
+                 * up a new set.
+                 */
+                CHECK_TYPE0(XPATH_NODESET);
+                obj = valuePop(ctxt);
+                oldset = obj->nodesetval;
+
+                oldnode = ctxt->context->node;
+                ctxt->context->node = NULL;
+
+                if ((oldset == NULL) || (oldset->nodeNr == 0)) {
+                    ctxt->context->contextSize = 0;
+                    ctxt->context->proximityPosition = 0;
+                    if (op->ch2 != -1)
+                        total +=
+                            xmlXPathCompOpEval(ctxt,
+                                               &comp->steps[op->ch2]);
+		    CHECK_ERROR0;
+                    res = valuePop(ctxt);
+                    if (res != NULL)
+                        xmlXPathFreeObject(res);
+                    valuePush(ctxt, obj);
+                    ctxt->context->node = oldnode;
+                    CHECK_ERROR0;
+                } else {
+                    /*
+                     * Initialize the new set.
+                     */
+                    newset = xmlXPathNodeSetCreate(NULL);
+
+                    for (i = 0; i < oldset->nodeNr; i++) {
+                        /*
+                         * Run the evaluation with a node list made of
+                         * a single item in the nodeset.
+                         */
+                        ctxt->context->node = oldset->nodeTab[i];
+                        tmp = xmlXPathNewNodeSet(ctxt->context->node);
+                        valuePush(ctxt, tmp);
+                        ctxt->context->contextSize = oldset->nodeNr;
+                        ctxt->context->proximityPosition = i + 1;
+
+                        if (op->ch2 != -1)
+                            total +=
+                                xmlXPathCompOpEval(ctxt,
+                                                   &comp->steps[op->ch2]);
+                        CHECK_ERROR0;
+
+                        /*
+                         * The result of the evaluation needs to be tested to
+                         * decide whether the filter succeeded or not
+                         */
+                        res = valuePop(ctxt);
+                        if (xmlXPathEvaluatePredicateResult(ctxt, res)) {
+                            xmlXPathNodeSetAdd(newset, oldset->nodeTab[i]);
+                        }
+
+                        /*
+                         * Cleanup
+                         */
+                        if (res != NULL)
+                            xmlXPathFreeObject(res);
+                        if (ctxt->value == tmp) {
+                            res = valuePop(ctxt);
+                            xmlXPathFreeObject(res);
+                        }
+
+                        ctxt->context->node = NULL;
+                    }
+
+                    /*
+                     * The result is used as the new evaluation set.
+                     */
+                    xmlXPathFreeObject(obj);
+                    ctxt->context->node = NULL;
+                    ctxt->context->contextSize = -1;
+                    ctxt->context->proximityPosition = -1;
+                    valuePush(ctxt, xmlXPathWrapNodeSet(newset));
+                }
+                ctxt->context->node = oldnode;
+                return (total);
+            }
+        case XPATH_OP_SORT:
+            if (op->ch1 != -1)
+                total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
+	    CHECK_ERROR0;
+            if ((ctxt->value != NULL) &&
+                (ctxt->value->type == XPATH_NODESET) &&
+                (ctxt->value->nodesetval != NULL))
+                xmlXPathNodeSetSort(ctxt->value->nodesetval);
+            return (total);
+#ifdef LIBXML_XPTR_ENABLED
+        case XPATH_OP_RANGETO:{
+                xmlXPathObjectPtr range;
+                xmlXPathObjectPtr res, obj;
+                xmlXPathObjectPtr tmp;
+                xmlLocationSetPtr newlocset = NULL;
+		    xmlLocationSetPtr oldlocset;
+                xmlNodeSetPtr oldset;
+                int i, j;
+
+                if (op->ch1 != -1)
+                    total +=
+                        xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
+                if (op->ch2 == -1)
+                    return (total);
+
+                if (ctxt->value->type == XPATH_LOCATIONSET) {
+                    /*
+                     * Extract the old locset, and then evaluate the result of the
+                     * expression for all the element in the locset. use it to grow
+                     * up a new locset.
+                     */
+                    CHECK_TYPE0(XPATH_LOCATIONSET);
+                    obj = valuePop(ctxt);
+                    oldlocset = obj->user;
+
+                    if ((oldlocset == NULL) || (oldlocset->locNr == 0)) {
+		        ctxt->context->node = NULL;
+                        ctxt->context->contextSize = 0;
+                        ctxt->context->proximityPosition = 0;
+                        total += xmlXPathCompOpEval(ctxt,&comp->steps[op->ch2]);
+                        res = valuePop(ctxt);
+                        if (res != NULL)
+                            xmlXPathFreeObject(res);
+                        valuePush(ctxt, obj);
+                        CHECK_ERROR0;
+                        return (total);
+                    }
+                    newlocset = xmlXPtrLocationSetCreate(NULL);
+
+                    for (i = 0; i < oldlocset->locNr; i++) {
+                        /*
+                         * Run the evaluation with a node list made of a
+                         * single item in the nodelocset.
+                         */
+                        ctxt->context->node = oldlocset->locTab[i]->user;
+                        ctxt->context->contextSize = oldlocset->locNr;
+                        ctxt->context->proximityPosition = i + 1;
+                        tmp = xmlXPathNewNodeSet(ctxt->context->node);
+                        valuePush(ctxt, tmp);
+
+                        if (op->ch2 != -1)
+                            total +=
+                                xmlXPathCompOpEval(ctxt,
+                                                   &comp->steps[op->ch2]);
+                        CHECK_ERROR0;
+
+                        res = valuePop(ctxt);
+			if (res->type == XPATH_LOCATIONSET) {
+			    xmlLocationSetPtr rloc = 
+			        (xmlLocationSetPtr)res->user;
+			    for (j=0; j<rloc->locNr; j++) {
+			        range = xmlXPtrNewRange(
+				  oldlocset->locTab[i]->user,
+				  oldlocset->locTab[i]->index,
+				  rloc->locTab[j]->user2,
+				  rloc->locTab[j]->index2);
+				if (range != NULL) {
+				    xmlXPtrLocationSetAdd(newlocset, range);
+				}
+			    }
+			} else {
+			    range = xmlXPtrNewRangeNodeObject(
+				(xmlNodePtr)oldlocset->locTab[i]->user, res);
+                            if (range != NULL) {
+                                xmlXPtrLocationSetAdd(newlocset,range);
+			    }
+                        }
+
+                        /*
+                         * Cleanup
+                         */
+                        if (res != NULL)
+                            xmlXPathFreeObject(res);
+                        if (ctxt->value == tmp) {
+                            res = valuePop(ctxt);
+                            xmlXPathFreeObject(res);
+                        }
+
+                        ctxt->context->node = NULL;
+                    }
+		} else {	/* Not a location set */
+                    CHECK_TYPE0(XPATH_NODESET);
+                    obj = valuePop(ctxt);
+                    oldset = obj->nodesetval;
+                    ctxt->context->node = NULL;
+
+                    newlocset = xmlXPtrLocationSetCreate(NULL);
+
+                    if (oldset != NULL) {
+                        for (i = 0; i < oldset->nodeNr; i++) {
+                            /*
+                             * Run the evaluation with a node list made of a single item
+                             * in the nodeset.
+                             */
+                            ctxt->context->node = oldset->nodeTab[i];
+                            tmp = xmlXPathNewNodeSet(ctxt->context->node);
+                            valuePush(ctxt, tmp);
+
+                            if (op->ch2 != -1)
+                                total +=
+                                    xmlXPathCompOpEval(ctxt,
+                                                   &comp->steps[op->ch2]);
+                            CHECK_ERROR0;
+
+                            res = valuePop(ctxt);
+                            range =
+                                xmlXPtrNewRangeNodeObject(oldset->nodeTab[i],
+                                                      res);
+                            if (range != NULL) {
+                                xmlXPtrLocationSetAdd(newlocset, range);
+                            }
+
+                            /*
+                             * Cleanup
+                             */
+                            if (res != NULL)
+                                xmlXPathFreeObject(res);
+                            if (ctxt->value == tmp) {
+                                res = valuePop(ctxt);
+                                xmlXPathFreeObject(res);
+                            }
+
+                            ctxt->context->node = NULL;
+                        }
+                    }
+                }
+
+                /*
+                 * The result is used as the new evaluation set.
+                 */
+                xmlXPathFreeObject(obj);
+                ctxt->context->node = NULL;
+                ctxt->context->contextSize = -1;
+                ctxt->context->proximityPosition = -1;
+                valuePush(ctxt, xmlXPtrWrapLocationSet(newlocset));
+                return (total);
+            }
+#endif /* LIBXML_XPTR_ENABLED */
+    }
+    xmlGenericError(xmlGenericErrorContext,
+                    "XPath: unknown precompiled operation %d\n", op->op);
+    return (total);
+}
+
+/**
+ * xmlXPathRunEval:
+ * @ctxt:  the XPath parser context with the compiled expression
+ *
+ * Evaluate the Precompiled XPath expression in the given context.
+ */
+static void
+xmlXPathRunEval(xmlXPathParserContextPtr ctxt) {
+    xmlXPathCompExprPtr comp;
+
+    if ((ctxt == NULL) || (ctxt->comp == NULL))
+	return;
+
+    if (ctxt->valueTab == NULL) {
+	/* Allocate the value stack */
+	ctxt->valueTab = (xmlXPathObjectPtr *) 
+			 xmlMalloc(10 * sizeof(xmlXPathObjectPtr));
+	if (ctxt->valueTab == NULL) {
+	    xmlXPathPErrMemory(ctxt, "creating evaluation context\n");
+	    xmlFree(ctxt);
+	}
+	ctxt->valueNr = 0;
+	ctxt->valueMax = 10;
+	ctxt->value = NULL;
+    }
+    comp = ctxt->comp;
+    if(comp->last < 0) {
+	xmlGenericError(xmlGenericErrorContext,
+	    "xmlXPathRunEval: last is less than zero\n");
+	return;
+    }
+    xmlXPathCompOpEval(ctxt, &comp->steps[comp->last]);
+}
+
+/************************************************************************
+ *									*
+ * 			Public interfaces				*
+ *									*
+ ************************************************************************/
+
+/**
+ * xmlXPathEvalPredicate:
+ * @ctxt:  the XPath context
+ * @res:  the Predicate Expression evaluation result
+ *
+ * Evaluate a predicate result for the current node.
+ * A PredicateExpr is evaluated by evaluating the Expr and converting
+ * the result to a boolean. If the result is a number, the result will
+ * be converted to true if the number is equal to the position of the
+ * context node in the context node list (as returned by the position
+ * function) and will be converted to false otherwise; if the result
+ * is not a number, then the result will be converted as if by a call
+ * to the boolean function. 
+ *
+ * Returns 1 if predicate is true, 0 otherwise
+ */
+int
+xmlXPathEvalPredicate(xmlXPathContextPtr ctxt, xmlXPathObjectPtr res) {
+    if (res == NULL) return(0);
+    switch (res->type) {
+        case XPATH_BOOLEAN:
+	    return(res->boolval);
+        case XPATH_NUMBER:
+	    return(res->floatval == ctxt->proximityPosition);
+        case XPATH_NODESET:
+        case XPATH_XSLT_TREE:
+	    if (res->nodesetval == NULL)
+		return(0);
+	    return(res->nodesetval->nodeNr != 0);
+        case XPATH_STRING:
+	    return((res->stringval != NULL) &&
+	           (xmlStrlen(res->stringval) != 0));
+        default:
+	    STRANGE
+    }
+    return(0);
+}
+
+/**
+ * xmlXPathEvaluatePredicateResult:
+ * @ctxt:  the XPath Parser context
+ * @res:  the Predicate Expression evaluation result
+ *
+ * Evaluate a predicate result for the current node.
+ * A PredicateExpr is evaluated by evaluating the Expr and converting
+ * the result to a boolean. If the result is a number, the result will
+ * be converted to true if the number is equal to the position of the
+ * context node in the context node list (as returned by the position
+ * function) and will be converted to false otherwise; if the result
+ * is not a number, then the result will be converted as if by a call
+ * to the boolean function. 
+ *
+ * Returns 1 if predicate is true, 0 otherwise
+ */
+int
+xmlXPathEvaluatePredicateResult(xmlXPathParserContextPtr ctxt, 
+                                xmlXPathObjectPtr res) {
+    if (res == NULL) return(0);
+    switch (res->type) {
+        case XPATH_BOOLEAN:
+	    return(res->boolval);
+        case XPATH_NUMBER:
+#ifdef WIN32
+	    return(((res->floatval == ctxt->context->proximityPosition) &&
+	           (!xmlXPathIsNaN(res->floatval)) /* MSC pbm Mark Vadoc !*/);
+#else
+	    return(res->floatval == ctxt->context->proximityPosition);
+#endif
+        case XPATH_NODESET:
+        case XPATH_XSLT_TREE:
+	    if (res->nodesetval == NULL)
+		return(0);
+	    return(res->nodesetval->nodeNr != 0);
+        case XPATH_STRING:
+	    return((res->stringval != NULL) &&
+	           (xmlStrlen(res->stringval) != 0));
+#ifdef LIBXML_XPTR_ENABLED
+	case XPATH_LOCATIONSET:{
+	    xmlLocationSetPtr ptr = res->user;
+	    if (ptr == NULL)
+	        return(0);
+	    return (ptr->locNr != 0);
+	    }
+#endif
+        default:
+	    STRANGE
+    }
+    return(0);
+}
+
+/**
+ * xmlXPathCtxtCompile:
+ * @ctxt: an XPath context
+ * @str:  the XPath expression
+ *
+ * Compile an XPath expression
+ *
+ * Returns the xmlXPathCompExprPtr resulting from the compilation or NULL.
+ *         the caller has to free the object.
+ */
+xmlXPathCompExprPtr
+xmlXPathCtxtCompile(xmlXPathContextPtr ctxt, const xmlChar *str) {
+    xmlXPathParserContextPtr pctxt;
+    xmlXPathCompExprPtr comp;
+
+    xmlXPathInit();
+
+    pctxt = xmlXPathNewParserContext(str, ctxt);
+    xmlXPathCompileExpr(pctxt);
+
+    if( pctxt->error != XPATH_EXPRESSION_OK )
+    {
+        xmlXPathFreeParserContext(pctxt);
+        return (0);
+    }
+
+    if (*pctxt->cur != 0) {
+	/* 
+	 * aleksey: in some cases this line prints *second* error message
+	 * (see bug #78858) and probably this should be fixed.
+	 * However, we are not sure that all error messages are printed
+	 * out in other places. It's not critical so we leave it as-is for now
+	 */
+	xmlXPatherror(pctxt, __FILE__, __LINE__, XPATH_EXPR_ERROR);
+	comp = NULL;
+    } else {
+	comp = pctxt->comp;
+	pctxt->comp = NULL;
+    }
+    xmlXPathFreeParserContext(pctxt);
+    if (comp != NULL) {
+	comp->expr = xmlStrdup(str);
+#ifdef DEBUG_EVAL_COUNTS
+	comp->string = xmlStrdup(str);
+	comp->nb = 0;
+#endif
+    }
+    return(comp);
+}
+
+/**
+ * xmlXPathCompile:
+ * @str:  the XPath expression
+ *
+ * Compile an XPath expression
+ *
+ * Returns the xmlXPathCompExprPtr resulting from the compilation or NULL.
+ *         the caller has to free the object.
+ */
+xmlXPathCompExprPtr
+xmlXPathCompile(const xmlChar *str) {
+    return(xmlXPathCtxtCompile(NULL, str));
+}
+
+/**
+ * xmlXPathCompiledEval:
+ * @comp:  the compiled XPath expression
+ * @ctx:  the XPath context
+ *
+ * Evaluate the Precompiled XPath expression in the given context.
+ *
+ * Returns the xmlXPathObjectPtr resulting from the evaluation or NULL.
+ *         the caller has to free the object.
+ */
+xmlXPathObjectPtr
+xmlXPathCompiledEval(xmlXPathCompExprPtr comp, xmlXPathContextPtr ctx) {
+    xmlXPathParserContextPtr ctxt;
+    xmlXPathObjectPtr res, tmp, init = NULL;
+    int stack = 0;
+#ifndef LIBXML_THREAD_ENABLED
+    static int reentance = 0;
+#endif
+
+    if ((comp == NULL) || (ctx == NULL))
+	return(NULL);
+    xmlXPathInit();
+
+    CHECK_CONTEXT(ctx)
+
+#ifndef LIBXML_THREAD_ENABLED
+    reentance++;
+    if (reentance > 1)
+	xmlXPathDisableOptimizer = 1;
+#endif
+
+#ifdef DEBUG_EVAL_COUNTS
+    comp->nb++;
+    if ((comp->string != NULL) && (comp->nb > 100)) {
+	fprintf(stderr, "100 x %s\n", comp->string);
+	comp->nb = 0;
+    }
+#endif
+    ctxt = xmlXPathCompParserContext(comp, ctx);
+    xmlXPathRunEval(ctxt);
+
+    if (ctxt->value == NULL) {
+	xmlGenericError(xmlGenericErrorContext,
+		"xmlXPathCompiledEval: evaluation failed\n");
+	res = NULL;
+    } else {
+	res = valuePop(ctxt);
+    }
+
+    
+    do {
+        tmp = valuePop(ctxt);
+	if (tmp != NULL) {
+	    if (tmp != init)
+		stack++;    
+	    xmlXPathFreeObject(tmp);
+        }
+    } while (tmp != NULL);
+    if ((stack != 0) && (res != NULL)) {
+	xmlGenericError(xmlGenericErrorContext,
+		"xmlXPathCompiledEval: %d object left on the stack\n",
+	        stack);
+    }
+    if (ctxt->error != XPATH_EXPRESSION_OK) {
+	xmlXPathFreeObject(res);
+	res = NULL;
+    }
+        
+
+    ctxt->comp = NULL;
+    xmlXPathFreeParserContext(ctxt);
+#ifndef LIBXML_THREAD_ENABLED
+    reentance--;
+#endif
+    return(res);
+}
+
+/**
+ * xmlXPathEvalExpr:
+ * @ctxt:  the XPath Parser context
+ *
+ * Parse and evaluate an XPath expression in the given context,
+ * then push the result on the context stack
+ */
+void
+xmlXPathEvalExpr(xmlXPathParserContextPtr ctxt) {
+    xmlXPathCompileExpr(ctxt);
+    CHECK_ERROR;
+    xmlXPathRunEval(ctxt);
+}
+
+/**
+ * xmlXPathEval:
+ * @str:  the XPath expression
+ * @ctx:  the XPath context
+ *
+ * Evaluate the XPath Location Path in the given context.
+ *
+ * Returns the xmlXPathObjectPtr resulting from the evaluation or NULL.
+ *         the caller has to free the object.
+ */
+xmlXPathObjectPtr
+xmlXPathEval(const xmlChar *str, xmlXPathContextPtr ctx) {
+    xmlXPathParserContextPtr ctxt;
+    xmlXPathObjectPtr res, tmp, init = NULL;
+    int stack = 0;
+
+    xmlXPathInit();
+
+    CHECK_CONTEXT(ctx)
+
+    ctxt = xmlXPathNewParserContext(str, ctx);
+    xmlXPathEvalExpr(ctxt);
+
+    if (ctxt->value == NULL) {
+	xmlGenericError(xmlGenericErrorContext,
+		"xmlXPathEval: evaluation failed\n");
+	res = NULL;
+    } else if (*ctxt->cur != 0) {
+	xmlXPatherror(ctxt, __FILE__, __LINE__, XPATH_EXPR_ERROR);
+	res = NULL;
+    } else {
+	res = valuePop(ctxt);
+    }
+
+    do {
+        tmp = valuePop(ctxt);
+	if (tmp != NULL) {
+	    if (tmp != init)
+		stack++;    
+	    xmlXPathFreeObject(tmp);
+        }
+    } while (tmp != NULL);
+    if ((stack != 0) && (res != NULL)) {
+	xmlGenericError(xmlGenericErrorContext,
+		"xmlXPathEval: %d object left on the stack\n",
+	        stack);
+    }
+    if (ctxt->error != XPATH_EXPRESSION_OK) {
+	xmlXPathFreeObject(res);
+	res = NULL;
+    }
+
+    xmlXPathFreeParserContext(ctxt);
+    return(res);
+}
+
+/**
+ * xmlXPathEvalExpression:
+ * @str:  the XPath expression
+ * @ctxt:  the XPath context
+ *
+ * Evaluate the XPath expression in the given context.
+ *
+ * Returns the xmlXPathObjectPtr resulting from the evaluation or NULL.
+ *         the caller has to free the object.
+ */
+xmlXPathObjectPtr
+xmlXPathEvalExpression(const xmlChar *str, xmlXPathContextPtr ctxt) {
+    xmlXPathParserContextPtr pctxt;
+    xmlXPathObjectPtr res, tmp;
+    int stack = 0;
+
+    xmlXPathInit();
+
+    CHECK_CONTEXT(ctxt)
+
+    pctxt = xmlXPathNewParserContext(str, ctxt);
+    xmlXPathEvalExpr(pctxt);
+
+    if (*pctxt->cur != 0) {
+	xmlXPatherror(pctxt, __FILE__, __LINE__, XPATH_EXPR_ERROR);
+	res = NULL;
+    } else {
+	res = valuePop(pctxt);
+    }
+    do {
+        tmp = valuePop(pctxt);
+	if (tmp != NULL) {
+	    xmlXPathFreeObject(tmp);
+	    stack++;
+	}
+    } while (tmp != NULL);
+    if ((stack != 0) && (res != NULL)) {
+	xmlGenericError(xmlGenericErrorContext,
+		"xmlXPathEvalExpression: %d object left on the stack\n",
+	        stack);
+    }
+    xmlXPathFreeParserContext(pctxt);
+    return(res);
+}
+
+/************************************************************************
+ *									*
+ *	Extra functions not pertaining to the XPath spec		*
+ *									*
+ ************************************************************************/
+/**
+ * xmlXPathEscapeUriFunction:
+ * @ctxt:  the XPath Parser context
+ * @nargs:  the number of arguments
+ *
+ * Implement the escape-uri() XPath function
+ *    string escape-uri(string $str, bool $escape-reserved)
+ *
+ * This function applies the URI escaping rules defined in section 2 of [RFC
+ * 2396] to the string supplied as $uri-part, which typically represents all
+ * or part of a URI. The effect of the function is to replace any special
+ * character in the string by an escape sequence of the form %xx%yy...,
+ * where xxyy... is the hexadecimal representation of the octets used to
+ * represent the character in UTF-8.
+ *
+ * The set of characters that are escaped depends on the setting of the
+ * boolean argument $escape-reserved.
+ *
+ * If $escape-reserved is true, all characters are escaped other than lower
+ * case letters a-z, upper case letters A-Z, digits 0-9, and the characters
+ * referred to in [RFC 2396] as "marks": specifically, "-" | "_" | "." | "!"
+ * | "~" | "*" | "'" | "(" | ")". The "%" character itself is escaped only
+ * if it is not followed by two hexadecimal digits (that is, 0-9, a-f, and
+ * A-F).
+ *
+ * If $escape-reserved is false, the behavior differs in that characters
+ * referred to in [RFC 2396] as reserved characters are not escaped. These
+ * characters are ";" | "/" | "?" | ":" | "@" | "&" | "=" | "+" | "$" | ",".
+ * 
+ * [RFC 2396] does not define whether escaped URIs should use lower case or
+ * upper case for hexadecimal digits. To ensure that escaped URIs can be
+ * compared using string comparison functions, this function must always use
+ * the upper-case letters A-F.
+ * 
+ * Generally, $escape-reserved should be set to true when escaping a string
+ * that is to form a single part of a URI, and to false when escaping an
+ * entire URI or URI reference.
+ * 
+ * In the case of non-ascii characters, the string is encoded according to 
+ * utf-8 and then converted according to RFC 2396.
+ *
+ * Examples
+ *  xf:escape-uri ("gopher://spinaltap.micro.umn.edu/00/Weather/California/Los%20Angeles#ocean"), true()) 
+ *  returns "gopher%3A%2F%2Fspinaltap.micro.umn.edu%2F00%2FWeather%2FCalifornia%2FLos%20Angeles%23ocean"
+ *  xf:escape-uri ("gopher://spinaltap.micro.umn.edu/00/Weather/California/Los%20Angeles#ocean"), false())
+ *  returns "gopher://spinaltap.micro.umn.edu/00/Weather/California/Los%20Angeles%23ocean"
+ *
+ */
+static void
+xmlXPathEscapeUriFunction(xmlXPathParserContextPtr ctxt, int nargs) {
+    xmlXPathObjectPtr str;
+    int escape_reserved;
+    xmlBufferPtr target;
+    xmlChar *cptr;
+    xmlChar escape[4];
+    
+    CHECK_ARITY(2);
+    
+    escape_reserved = xmlXPathPopBoolean(ctxt);
+    
+    CAST_TO_STRING;
+    str = valuePop(ctxt);
+    
+    target = xmlBufferCreate();
+    
+    escape[0] = '%';
+    escape[3] = 0;
+    
+    if (target) {
+	for (cptr = str->stringval; *cptr; cptr++) {
+	    if ((*cptr >= 'A' && *cptr <= 'Z') ||
+		(*cptr >= 'a' && *cptr <= 'z') ||
+		(*cptr >= '0' && *cptr <= '9') ||
+		*cptr == '-' || *cptr == '_' || *cptr == '.' || 
+		*cptr == '!' || *cptr == '~' || *cptr == '*' ||
+		*cptr == '\''|| *cptr == '(' || *cptr == ')' ||
+		(*cptr == '%' && 
+		 ((cptr[1] >= 'A' && cptr[1] <= 'F') ||
+		  (cptr[1] >= 'a' && cptr[1] <= 'f') ||
+		  (cptr[1] >= '0' && cptr[1] <= '9')) &&
+		 ((cptr[2] >= 'A' && cptr[2] <= 'F') ||
+		  (cptr[2] >= 'a' && cptr[2] <= 'f') ||
+		  (cptr[2] >= '0' && cptr[2] <= '9'))) ||
+		(!escape_reserved &&
+		 (*cptr == ';' || *cptr == '/' || *cptr == '?' ||
+		  *cptr == ':' || *cptr == '@' || *cptr == '&' ||
+		  *cptr == '=' || *cptr == '+' || *cptr == '$' ||
+		  *cptr == ','))) {
+		xmlBufferAdd(target, cptr, 1);
+	    } else {
+		if ((*cptr >> 4) < 10)
+		    escape[1] = '0' + (*cptr >> 4);
+		else
+		    escape[1] = 'A' - 10 + (*cptr >> 4);
+		if ((*cptr & 0xF) < 10)
+		    escape[2] = '0' + (*cptr & 0xF);
+		else
+		    escape[2] = 'A' - 10 + (*cptr & 0xF);
+		
+		xmlBufferAdd(target, &escape[0], 3);
+	    }
+	}
+    }
+    valuePush(ctxt, xmlXPathNewString(xmlBufferContent(target)));
+    xmlBufferFree(target);
+    xmlXPathFreeObject(str);
+}
+
+/**
+ * xmlXPathRegisterAllFunctions:
+ * @ctxt:  the XPath context
+ *
+ * Registers all default XPath functions in this context
+ */
+void
+xmlXPathRegisterAllFunctions(xmlXPathContextPtr ctxt)
+{
+    xmlXPathRegisterFunc(ctxt, (const xmlChar *)"boolean",
+                         xmlXPathBooleanFunction);
+    xmlXPathRegisterFunc(ctxt, (const xmlChar *)"ceiling",
+                         xmlXPathCeilingFunction);
+    xmlXPathRegisterFunc(ctxt, (const xmlChar *)"count",
+                         xmlXPathCountFunction);
+    xmlXPathRegisterFunc(ctxt, (const xmlChar *)"concat",
+                         xmlXPathConcatFunction);
+    xmlXPathRegisterFunc(ctxt, (const xmlChar *)"contains",
+                         xmlXPathContainsFunction);
+    xmlXPathRegisterFunc(ctxt, (const xmlChar *)"id",
+                         xmlXPathIdFunction);
+    xmlXPathRegisterFunc(ctxt, (const xmlChar *)"false",
+                         xmlXPathFalseFunction);
+    xmlXPathRegisterFunc(ctxt, (const xmlChar *)"floor",
+                         xmlXPathFloorFunction);
+    xmlXPathRegisterFunc(ctxt, (const xmlChar *)"last",
+                         xmlXPathLastFunction);
+    xmlXPathRegisterFunc(ctxt, (const xmlChar *)"lang",
+                         xmlXPathLangFunction);
+    xmlXPathRegisterFunc(ctxt, (const xmlChar *)"local-name",
+                         xmlXPathLocalNameFunction);
+    xmlXPathRegisterFunc(ctxt, (const xmlChar *)"not",
+                         xmlXPathNotFunction);
+    xmlXPathRegisterFunc(ctxt, (const xmlChar *)"name",
+                         xmlXPathNameFunction);
+    xmlXPathRegisterFunc(ctxt, (const xmlChar *)"namespace-uri",
+                         xmlXPathNamespaceURIFunction);
+    xmlXPathRegisterFunc(ctxt, (const xmlChar *)"normalize-space",
+                         xmlXPathNormalizeFunction);
+    xmlXPathRegisterFunc(ctxt, (const xmlChar *)"number",
+                         xmlXPathNumberFunction);
+    xmlXPathRegisterFunc(ctxt, (const xmlChar *)"position",
+                         xmlXPathPositionFunction);
+    xmlXPathRegisterFunc(ctxt, (const xmlChar *)"round",
+                         xmlXPathRoundFunction);
+    xmlXPathRegisterFunc(ctxt, (const xmlChar *)"string",
+                         xmlXPathStringFunction);
+    xmlXPathRegisterFunc(ctxt, (const xmlChar *)"string-length",
+                         xmlXPathStringLengthFunction);
+    xmlXPathRegisterFunc(ctxt, (const xmlChar *)"starts-with",
+                         xmlXPathStartsWithFunction);
+    xmlXPathRegisterFunc(ctxt, (const xmlChar *)"substring",
+                         xmlXPathSubstringFunction);
+    xmlXPathRegisterFunc(ctxt, (const xmlChar *)"substring-before",
+                         xmlXPathSubstringBeforeFunction);
+    xmlXPathRegisterFunc(ctxt, (const xmlChar *)"substring-after",
+                         xmlXPathSubstringAfterFunction);
+    xmlXPathRegisterFunc(ctxt, (const xmlChar *)"sum",
+                         xmlXPathSumFunction);
+    xmlXPathRegisterFunc(ctxt, (const xmlChar *)"true",
+                         xmlXPathTrueFunction);
+    xmlXPathRegisterFunc(ctxt, (const xmlChar *)"translate",
+                         xmlXPathTranslateFunction);
+
+    xmlXPathRegisterFuncNS(ctxt, (const xmlChar *)"escape-uri",
+	 (const xmlChar *)"http://www.w3.org/2002/08/xquery-functions",
+                         xmlXPathEscapeUriFunction);
+}
+
+#endif /* LIBXML_XPATH_ENABLED */
diff --git a/src/libxml/src/xpointer.c b/src/libxml/src/xpointer.c
new file mode 100644
index 0000000..7f014de
--- /dev/null
+++ b/src/libxml/src/xpointer.c
@@ -0,0 +1,2999 @@
+/*
+ * xpointer.c : Code to handle XML Pointer
+ *
+ * Base implementation was made accordingly to
+ * W3C Candidate Recommendation 7 June 2000
+ * http://www.w3.org/TR/2000/CR-xptr-20000607
+ *
+ * Added support for the element() scheme described in:
+ * W3C Proposed Recommendation 13 November 2002
+ * http://www.w3.org/TR/2002/PR-xptr-element-20021113/  
+ *
+ * See Copyright for the status of this software.
+ *
+ * daniel@veillard.com
+ */
+
+#define IN_LIBXML
+#include "libxml.h"
+
+/*
+ * TODO: better handling of error cases, the full expression should
+ *       be parsed beforehand instead of a progressive evaluation
+ * TODO: Access into entities references are not supported now ...
+ *       need a start to be able to pop out of entities refs since
+ *       parent is the endity declaration, not the ref.
+ */
+
+#include <string.h>
+#include <libxml/xpointer.h>
+#include <libxml/xmlmemory.h>
+#include <libxml/parserInternals.h>
+#include <libxml/uri.h>
+#include <libxml/xpath.h>
+#include <libxml/xpathInternals.h>
+#include <libxml/xmlerror.h>
+#include <libxml/globals.h>
+
+#ifdef LIBXML_XPTR_ENABLED
+
+/* Add support of the xmlns() xpointer scheme to initialize the namespaces */
+#define XPTR_XMLNS_SCHEME
+
+/* #define DEBUG_RANGES */
+#ifdef DEBUG_RANGES
+#ifdef LIBXML_DEBUG_ENABLED
+#include <libxml/debugXML.h>
+#endif
+#endif
+
+#define TODO 								\
+    xmlGenericError(xmlGenericErrorContext,				\
+	    "Unimplemented block at %s:%d\n",				\
+            __FILE__, __LINE__);
+
+#define STRANGE 							\
+    xmlGenericError(xmlGenericErrorContext,				\
+	    "Internal error at %s:%d\n",				\
+            __FILE__, __LINE__);
+
+/************************************************************************
+ *									*
+ * 		Some factorized error routines				*
+ *									*
+ ************************************************************************/
+
+/**
+ * xmlXPtrErrMemory:
+ * @extra:  extra informations
+ *
+ * Handle a redefinition of attribute error
+ */
+static void
+xmlXPtrErrMemory(const char *extra)
+{
+    __xmlRaiseError(NULL, NULL, NULL, NULL, NULL, XML_FROM_XPOINTER,
+		    XML_ERR_NO_MEMORY, XML_ERR_ERROR, NULL, 0, extra,
+		    NULL, NULL, 0, 0,
+		    "Memory allocation failed : %s\n", extra);
+}
+
+/**
+ * xmlXPtrErr:
+ * @ctxt:  an XPTR evaluation context
+ * @extra:  extra informations
+ *
+ * Handle a redefinition of attribute error
+ */
+static void
+xmlXPtrErr(xmlXPathParserContextPtr ctxt, int error,
+           const char * msg, const xmlChar *extra)
+{
+    if (ctxt != NULL)
+        ctxt->error = error;
+    if ((ctxt == NULL) || (ctxt->context == NULL)) {
+	__xmlRaiseError(NULL, NULL, NULL,
+			NULL, NULL, XML_FROM_XPOINTER, error,
+			XML_ERR_ERROR, NULL, 0,
+			(const char *) extra, NULL, NULL, 0, 0,
+			msg, extra);
+	return;
+    }
+    ctxt->context->lastError.domain = XML_FROM_XPOINTER;
+    ctxt->context->lastError.code = error;
+    ctxt->context->lastError.level = XML_ERR_ERROR;
+    ctxt->context->lastError.str1 = (char *) xmlStrdup(ctxt->base);
+    ctxt->context->lastError.int1 = ctxt->cur - ctxt->base;
+    ctxt->context->lastError.node = ctxt->context->debugNode;
+    if (ctxt->context->error != NULL) {
+	ctxt->context->error(ctxt->context->userData,
+	                     &ctxt->context->lastError);
+    } else {
+	__xmlRaiseError(NULL, NULL, NULL,
+			NULL, ctxt->context->debugNode, XML_FROM_XPOINTER,
+			error, XML_ERR_ERROR, NULL, 0,
+			(const char *) extra, (const char *) ctxt->base, NULL,
+			ctxt->cur - ctxt->base, 0,
+			msg, extra);
+    }
+}
+
+/************************************************************************
+ *									*
+ *		A few helper functions for child sequences		*
+ *									*
+ ************************************************************************/
+/* xmlXPtrAdvanceNode is a private function, but used by xinclude.c */
+xmlNodePtr xmlXPtrAdvanceNode(xmlNodePtr cur, int *level);
+/**
+ * xmlXPtrGetArity:
+ * @cur:  the node
+ *
+ * Returns the number of child for an element, -1 in case of error
+ */
+static int
+xmlXPtrGetArity(xmlNodePtr cur) {
+    int i;
+    if (cur == NULL) 
+	return(-1);
+    cur = cur->children;
+    for (i = 0;cur != NULL;cur = cur->next) {
+	if ((cur->type == XML_ELEMENT_NODE) ||
+	    (cur->type == XML_DOCUMENT_NODE) ||
+	    (cur->type == XML_HTML_DOCUMENT_NODE)) {
+	    i++;
+	}
+    }
+    return(i);
+}
+
+/**
+ * xmlXPtrGetIndex:
+ * @cur:  the node
+ *
+ * Returns the index of the node in its parent children list, -1
+ *         in case of error
+ */
+static int
+xmlXPtrGetIndex(xmlNodePtr cur) {
+    int i;
+    if (cur == NULL) 
+	return(-1);
+    for (i = 1;cur != NULL;cur = cur->prev) {
+	if ((cur->type == XML_ELEMENT_NODE) ||
+	    (cur->type == XML_DOCUMENT_NODE) ||
+	    (cur->type == XML_HTML_DOCUMENT_NODE)) {
+	    i++;
+	}
+    }
+    return(i);
+}
+
+/**
+ * xmlXPtrGetNthChild:
+ * @cur:  the node
+ * @no:  the child number
+ *
+ * Returns the @no'th element child of @cur or NULL
+ */
+static xmlNodePtr
+xmlXPtrGetNthChild(xmlNodePtr cur, int no) {
+    int i;
+    if (cur == NULL) 
+	return(cur);
+    cur = cur->children;
+    for (i = 0;i <= no;cur = cur->next) {
+	if (cur == NULL) 
+	    return(cur);
+	if ((cur->type == XML_ELEMENT_NODE) ||
+	    (cur->type == XML_DOCUMENT_NODE) ||
+	    (cur->type == XML_HTML_DOCUMENT_NODE)) {
+	    i++;
+	    if (i == no)
+		break;
+	}
+    }
+    return(cur);
+}
+
+/************************************************************************
+ *									*
+ *		Handling of XPointer specific types			*
+ *									*
+ ************************************************************************/
+
+/**
+ * xmlXPtrCmpPoints:
+ * @node1:  the first node
+ * @index1:  the first index
+ * @node2:  the second node
+ * @index2:  the second index
+ *
+ * Compare two points w.r.t document order
+ *
+ * Returns -2 in case of error 1 if first point < second point, 0 if
+ *         that's the same point, -1 otherwise
+ */
+static int
+xmlXPtrCmpPoints(xmlNodePtr node1, int index1, xmlNodePtr node2, int index2) {
+    if ((node1 == NULL) || (node2 == NULL))
+	return(-2);
+    /*
+     * a couple of optimizations which will avoid computations in most cases
+     */
+    if (node1 == node2) {
+	if (index1 < index2)
+	    return(1);
+	if (index1 > index2)
+	    return(-1);
+	return(0);
+    }
+    return(xmlXPathCmpNodes(node1, node2));
+}
+
+/**
+ * xmlXPtrNewPoint:
+ * @node:  the xmlNodePtr
+ * @indx:  the indx within the node
+ *
+ * Create a new xmlXPathObjectPtr of type point
+ *
+ * Returns the newly created object.
+ */
+static xmlXPathObjectPtr
+xmlXPtrNewPoint(xmlNodePtr node, int indx) {
+    xmlXPathObjectPtr ret;
+
+    if (node == NULL)
+	return(NULL);
+    if (indx < 0)
+	return(NULL);
+
+    ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
+    if (ret == NULL) {
+        xmlXPtrErrMemory("allocating point");
+	return(NULL);
+    }
+    memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
+    ret->type = XPATH_POINT;
+    ret->user = (void *) node;
+    ret->index = indx;
+    return(ret);
+}
+
+/**
+ * xmlXPtrRangeCheckOrder:
+ * @range:  an object range
+ *
+ * Make sure the points in the range are in the right order
+ */
+static void
+xmlXPtrRangeCheckOrder(xmlXPathObjectPtr range) {
+    int tmp;
+    xmlNodePtr tmp2;
+    if (range == NULL)
+	return;
+    if (range->type != XPATH_RANGE)
+	return;
+    if (range->user2 == NULL)
+	return;
+    tmp = xmlXPtrCmpPoints(range->user, range->index,
+	                     range->user2, range->index2);
+    if (tmp == -1) {
+	tmp2 = range->user;
+	range->user = range->user2;
+	range->user2 = tmp2;
+	tmp = range->index;
+	range->index = range->index2;
+	range->index2 = tmp;
+    }
+}
+
+/**
+ * xmlXPtrRangesEqual:
+ * @range1:  the first range
+ * @range2:  the second range
+ *
+ * Compare two ranges
+ *
+ * Returns 1 if equal, 0 otherwise
+ */
+static int
+xmlXPtrRangesEqual(xmlXPathObjectPtr range1, xmlXPathObjectPtr range2) {
+    if (range1 == range2)
+	return(1);
+    if ((range1 == NULL) || (range2 == NULL))
+	return(0);
+    if (range1->type != range2->type)
+	return(0);
+    if (range1->type != XPATH_RANGE)
+	return(0);
+    if (range1->user != range2->user)
+	return(0);
+    if (range1->index != range2->index)
+	return(0);
+    if (range1->user2 != range2->user2)
+	return(0);
+    if (range1->index2 != range2->index2)
+	return(0);
+    return(1);
+}
+
+/**
+ * xmlXPtrNewRange:
+ * @start:  the starting node
+ * @startindex:  the start index
+ * @end:  the ending point
+ * @endindex:  the ending index
+ *
+ * Create a new xmlXPathObjectPtr of type range
+ *
+ * Returns the newly created object.
+ */
+xmlXPathObjectPtr
+xmlXPtrNewRange(xmlNodePtr start, int startindex,
+	        xmlNodePtr end, int endindex) {
+    xmlXPathObjectPtr ret;
+
+    if (start == NULL)
+	return(NULL);
+    if (end == NULL)
+	return(NULL);
+    if (startindex < 0)
+	return(NULL);
+    if (endindex < 0)
+	return(NULL);
+
+    ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
+    if (ret == NULL) {
+        xmlXPtrErrMemory("allocating range");
+	return(NULL);
+    }
+    memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
+    ret->type = XPATH_RANGE;
+    ret->user = start;
+    ret->index = startindex;
+    ret->user2 = end;
+    ret->index2 = endindex;
+    xmlXPtrRangeCheckOrder(ret);
+    return(ret);
+}
+
+/**
+ * xmlXPtrNewRangePoints:
+ * @start:  the starting point
+ * @end:  the ending point
+ *
+ * Create a new xmlXPathObjectPtr of type range using 2 Points
+ *
+ * Returns the newly created object.
+ */
+xmlXPathObjectPtr
+xmlXPtrNewRangePoints(xmlXPathObjectPtr start, xmlXPathObjectPtr end) {
+    xmlXPathObjectPtr ret;
+
+    if (start == NULL)
+	return(NULL);
+    if (end == NULL)
+	return(NULL);
+    if (start->type != XPATH_POINT)
+	return(NULL);
+    if (end->type != XPATH_POINT)
+	return(NULL);
+
+    ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
+    if (ret == NULL) {
+        xmlXPtrErrMemory("allocating range");
+	return(NULL);
+    }
+    memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
+    ret->type = XPATH_RANGE;
+    ret->user = start->user;
+    ret->index = start->index;
+    ret->user2 = end->user;
+    ret->index2 = end->index;
+    xmlXPtrRangeCheckOrder(ret);
+    return(ret);
+}
+
+/**
+ * xmlXPtrNewRangePointNode:
+ * @start:  the starting point
+ * @end:  the ending node
+ *
+ * Create a new xmlXPathObjectPtr of type range from a point to a node
+ *
+ * Returns the newly created object.
+ */
+xmlXPathObjectPtr
+xmlXPtrNewRangePointNode(xmlXPathObjectPtr start, xmlNodePtr end) {
+    xmlXPathObjectPtr ret;
+
+    if (start == NULL)
+	return(NULL);
+    if (end == NULL)
+	return(NULL);
+    if (start->type != XPATH_POINT)
+	return(NULL);
+
+    ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
+    if (ret == NULL) {
+        xmlXPtrErrMemory("allocating range");
+	return(NULL);
+    }
+    memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
+    ret->type = XPATH_RANGE;
+    ret->user = start->user;
+    ret->index = start->index;
+    ret->user2 = end;
+    ret->index2 = -1;
+    xmlXPtrRangeCheckOrder(ret);
+    return(ret);
+}
+
+/**
+ * xmlXPtrNewRangeNodePoint:
+ * @start:  the starting node
+ * @end:  the ending point
+ *
+ * Create a new xmlXPathObjectPtr of type range from a node to a point
+ *
+ * Returns the newly created object.
+ */
+xmlXPathObjectPtr
+xmlXPtrNewRangeNodePoint(xmlNodePtr start, xmlXPathObjectPtr end) {
+    xmlXPathObjectPtr ret;
+
+    if (start == NULL)
+	return(NULL);
+    if (end == NULL)
+	return(NULL);
+    if (start->type != XPATH_POINT)
+	return(NULL);
+    if (end->type != XPATH_POINT)
+	return(NULL);
+
+    ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
+    if (ret == NULL) {
+        xmlXPtrErrMemory("allocating range");
+	return(NULL);
+    }
+    memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
+    ret->type = XPATH_RANGE;
+    ret->user = start;
+    ret->index = -1;
+    ret->user2 = end->user;
+    ret->index2 = end->index;
+    xmlXPtrRangeCheckOrder(ret);
+    return(ret);
+}
+
+/**
+ * xmlXPtrNewRangeNodes:
+ * @start:  the starting node
+ * @end:  the ending node
+ *
+ * Create a new xmlXPathObjectPtr of type range using 2 nodes
+ *
+ * Returns the newly created object.
+ */
+xmlXPathObjectPtr
+xmlXPtrNewRangeNodes(xmlNodePtr start, xmlNodePtr end) {
+    xmlXPathObjectPtr ret;
+
+    if (start == NULL)
+	return(NULL);
+    if (end == NULL)
+	return(NULL);
+
+    ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
+    if (ret == NULL) {
+        xmlXPtrErrMemory("allocating range");
+	return(NULL);
+    }
+    memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
+    ret->type = XPATH_RANGE;
+    ret->user = start;
+    ret->index = -1;
+    ret->user2 = end;
+    ret->index2 = -1;
+    xmlXPtrRangeCheckOrder(ret);
+    return(ret);
+}
+
+/**
+ * xmlXPtrNewCollapsedRange:
+ * @start:  the starting and ending node
+ *
+ * Create a new xmlXPathObjectPtr of type range using a single nodes
+ *
+ * Returns the newly created object.
+ */
+xmlXPathObjectPtr
+xmlXPtrNewCollapsedRange(xmlNodePtr start) {
+    xmlXPathObjectPtr ret;
+
+    if (start == NULL)
+	return(NULL);
+
+    ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
+    if (ret == NULL) {
+        xmlXPtrErrMemory("allocating range");
+	return(NULL);
+    }
+    memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
+    ret->type = XPATH_RANGE;
+    ret->user = start;
+    ret->index = -1;
+    ret->user2 = NULL;
+    ret->index2 = -1;
+    return(ret);
+}
+
+/**
+ * xmlXPtrNewRangeNodeObject:
+ * @start:  the starting node
+ * @end:  the ending object
+ *
+ * Create a new xmlXPathObjectPtr of type range from a not to an object
+ *
+ * Returns the newly created object.
+ */
+xmlXPathObjectPtr
+xmlXPtrNewRangeNodeObject(xmlNodePtr start, xmlXPathObjectPtr end) {
+    xmlXPathObjectPtr ret;
+
+    if (start == NULL)
+	return(NULL);
+    if (end == NULL)
+	return(NULL);
+    switch (end->type) {
+	case XPATH_POINT:
+	case XPATH_RANGE:
+	    break;
+	case XPATH_NODESET:
+	    /*
+	     * Empty set ... 
+	     */
+	    if (end->nodesetval->nodeNr <= 0)
+		return(NULL);
+	    break;
+	default:
+	    TODO
+	    return(NULL);
+    }
+
+    ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
+    if (ret == NULL) {
+        xmlXPtrErrMemory("allocating range");
+	return(NULL);
+    }
+    memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
+    ret->type = XPATH_RANGE;
+    ret->user = start;
+    ret->index = -1;
+    switch (end->type) {
+	case XPATH_POINT:
+	    ret->user2 = end->user;
+	    ret->index2 = end->index;
+	    break;
+	case XPATH_RANGE:
+	    ret->user2 = end->user2;
+	    ret->index2 = end->index2;
+	    break;
+	case XPATH_NODESET: {
+	    ret->user2 = end->nodesetval->nodeTab[end->nodesetval->nodeNr - 1];
+	    ret->index2 = -1;
+	    break;
+	}
+	default:
+	    STRANGE
+	    return(NULL);
+    }
+    xmlXPtrRangeCheckOrder(ret);
+    return(ret);
+}
+
+#define XML_RANGESET_DEFAULT	10
+
+/**
+ * xmlXPtrLocationSetCreate:
+ * @val:  an initial xmlXPathObjectPtr, or NULL
+ *
+ * Create a new xmlLocationSetPtr of type double and of value @val
+ *
+ * Returns the newly created object.
+ */
+xmlLocationSetPtr
+xmlXPtrLocationSetCreate(xmlXPathObjectPtr val) {
+    xmlLocationSetPtr ret;
+
+    ret = (xmlLocationSetPtr) xmlMalloc(sizeof(xmlLocationSet));
+    if (ret == NULL) {
+        xmlXPtrErrMemory("allocating locationset");
+	return(NULL);
+    }
+    memset(ret, 0 , (size_t) sizeof(xmlLocationSet));
+    if (val != NULL) {
+        ret->locTab = (xmlXPathObjectPtr *) xmlMalloc(XML_RANGESET_DEFAULT *
+					     sizeof(xmlXPathObjectPtr));
+	if (ret->locTab == NULL) {
+	    xmlXPtrErrMemory("allocating locationset");
+	    xmlFree(ret);
+	    return(NULL);
+	}
+	memset(ret->locTab, 0 ,
+	       XML_RANGESET_DEFAULT * (size_t) sizeof(xmlXPathObjectPtr));
+        ret->locMax = XML_RANGESET_DEFAULT;
+	ret->locTab[ret->locNr++] = val;
+    }
+    return(ret);
+}
+
+/**
+ * xmlXPtrLocationSetAdd:
+ * @cur:  the initial range set
+ * @val:  a new xmlXPathObjectPtr
+ *
+ * add a new xmlXPathObjectPtr to an existing LocationSet
+ * If the location already exist in the set @val is freed.
+ */
+void
+xmlXPtrLocationSetAdd(xmlLocationSetPtr cur, xmlXPathObjectPtr val) {
+    int i;
+
+    if (val == NULL) return;
+
+    /*
+     * check against doublons
+     */
+    for (i = 0;i < cur->locNr;i++) {
+	if (xmlXPtrRangesEqual(cur->locTab[i], val)) {
+	    xmlXPathFreeObject(val);
+	    return;
+	}
+    }
+
+    /*
+     * grow the locTab if needed
+     */
+    if (cur->locMax == 0) {
+        cur->locTab = (xmlXPathObjectPtr *) xmlMalloc(XML_RANGESET_DEFAULT *
+					     sizeof(xmlXPathObjectPtr));
+	if (cur->locTab == NULL) {
+	    xmlXPtrErrMemory("adding location to set");
+	    return;
+	}
+	memset(cur->locTab, 0 ,
+	       XML_RANGESET_DEFAULT * (size_t) sizeof(xmlXPathObjectPtr));
+        cur->locMax = XML_RANGESET_DEFAULT;
+    } else if (cur->locNr == cur->locMax) {
+        xmlXPathObjectPtr *temp;
+
+        cur->locMax *= 2;
+	temp = (xmlXPathObjectPtr *) xmlRealloc(cur->locTab, cur->locMax *
+				      sizeof(xmlXPathObjectPtr));
+	if (temp == NULL) {
+	    xmlXPtrErrMemory("adding location to set");
+	    return;
+	}
+	cur->locTab = temp;
+    }
+    cur->locTab[cur->locNr++] = val;
+}
+
+/**
+ * xmlXPtrLocationSetMerge:
+ * @val1:  the first LocationSet
+ * @val2:  the second LocationSet
+ *
+ * Merges two rangesets, all ranges from @val2 are added to @val1
+ *
+ * Returns val1 once extended or NULL in case of error.
+ */
+xmlLocationSetPtr
+xmlXPtrLocationSetMerge(xmlLocationSetPtr val1, xmlLocationSetPtr val2) {
+    int i;
+
+    if (val1 == NULL) return(NULL);
+    if (val2 == NULL) return(val1);
+
+    /*
+     * !!!!! this can be optimized a lot, knowing that both
+     *       val1 and val2 already have unicity of their values.
+     */
+
+    for (i = 0;i < val2->locNr;i++)
+        xmlXPtrLocationSetAdd(val1, val2->locTab[i]);
+
+    return(val1);
+}
+
+/**
+ * xmlXPtrLocationSetDel:
+ * @cur:  the initial range set
+ * @val:  an xmlXPathObjectPtr
+ *
+ * Removes an xmlXPathObjectPtr from an existing LocationSet
+ */
+void
+xmlXPtrLocationSetDel(xmlLocationSetPtr cur, xmlXPathObjectPtr val) {
+    int i;
+
+    if (cur == NULL) return;
+    if (val == NULL) return;
+
+    /*
+     * check against doublons
+     */
+    for (i = 0;i < cur->locNr;i++)
+        if (cur->locTab[i] == val) break;
+
+    if (i >= cur->locNr) {
+#ifdef DEBUG
+        xmlGenericError(xmlGenericErrorContext, 
+	        "xmlXPtrLocationSetDel: Range wasn't found in RangeList\n");
+#endif
+        return;
+    }
+    cur->locNr--;
+    for (;i < cur->locNr;i++)
+        cur->locTab[i] = cur->locTab[i + 1];
+    cur->locTab[cur->locNr] = NULL;
+}
+
+/**
+ * xmlXPtrLocationSetRemove:
+ * @cur:  the initial range set
+ * @val:  the index to remove
+ *
+ * Removes an entry from an existing LocationSet list.
+ */
+void
+xmlXPtrLocationSetRemove(xmlLocationSetPtr cur, int val) {
+    if (cur == NULL) return;
+    if (val >= cur->locNr) return;
+    cur->locNr--;
+    for (;val < cur->locNr;val++)
+        cur->locTab[val] = cur->locTab[val + 1];
+    cur->locTab[cur->locNr] = NULL;
+}
+
+/**
+ * xmlXPtrFreeLocationSet:
+ * @obj:  the xmlLocationSetPtr to free
+ *
+ * Free the LocationSet compound (not the actual ranges !).
+ */
+void
+xmlXPtrFreeLocationSet(xmlLocationSetPtr obj) {
+    int i;
+
+    if (obj == NULL) return;
+    if (obj->locTab != NULL) {
+	for (i = 0;i < obj->locNr; i++) {
+            xmlXPathFreeObject(obj->locTab[i]);
+	}
+	xmlFree(obj->locTab);
+    }
+    xmlFree(obj);
+}
+
+/**
+ * xmlXPtrNewLocationSetNodes:
+ * @start:  the start NodePtr value
+ * @end:  the end NodePtr value or NULL
+ *
+ * Create a new xmlXPathObjectPtr of type LocationSet and initialize
+ * it with the single range made of the two nodes @start and @end
+ *
+ * Returns the newly created object.
+ */
+xmlXPathObjectPtr
+xmlXPtrNewLocationSetNodes(xmlNodePtr start, xmlNodePtr end) {
+    xmlXPathObjectPtr ret;
+
+    ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
+    if (ret == NULL) {
+        xmlXPtrErrMemory("allocating locationset");
+	return(NULL);
+    }
+    memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
+    ret->type = XPATH_LOCATIONSET;
+    if (end == NULL)
+	ret->user = xmlXPtrLocationSetCreate(xmlXPtrNewCollapsedRange(start));
+    else
+	ret->user = xmlXPtrLocationSetCreate(xmlXPtrNewRangeNodes(start,end));
+    return(ret);
+}
+
+/**
+ * xmlXPtrNewLocationSetNodeSet:
+ * @set:  a node set
+ *
+ * Create a new xmlXPathObjectPtr of type LocationSet and initialize
+ * it with all the nodes from @set
+ *
+ * Returns the newly created object.
+ */
+xmlXPathObjectPtr
+xmlXPtrNewLocationSetNodeSet(xmlNodeSetPtr set) {
+    xmlXPathObjectPtr ret;
+
+    ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
+    if (ret == NULL) {
+        xmlXPtrErrMemory("allocating locationset");
+	return(NULL);
+    }
+    memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
+    ret->type = XPATH_LOCATIONSET;
+    if (set != NULL) {
+	int i;
+	xmlLocationSetPtr newset;
+
+	newset = xmlXPtrLocationSetCreate(NULL);
+	if (newset == NULL)
+	    return(ret);
+
+	for (i = 0;i < set->nodeNr;i++)
+	    xmlXPtrLocationSetAdd(newset,
+		        xmlXPtrNewCollapsedRange(set->nodeTab[i]));
+
+	ret->user = (void *) newset;
+    }
+    return(ret);
+}
+
+/**
+ * xmlXPtrWrapLocationSet:
+ * @val:  the LocationSet value
+ *
+ * Wrap the LocationSet @val in a new xmlXPathObjectPtr
+ *
+ * Returns the newly created object.
+ */
+xmlXPathObjectPtr
+xmlXPtrWrapLocationSet(xmlLocationSetPtr val) {
+    xmlXPathObjectPtr ret;
+
+    ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
+    if (ret == NULL) {
+        xmlXPtrErrMemory("allocating locationset");
+	return(NULL);
+    }
+    memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
+    ret->type = XPATH_LOCATIONSET;
+    ret->user = (void *) val;
+    return(ret);
+}
+
+/************************************************************************
+ *									*
+ *			The parser					*
+ *									*
+ ************************************************************************/
+
+static void xmlXPtrEvalChildSeq(xmlXPathParserContextPtr ctxt, xmlChar *name);
+
+/*
+ * Macros for accessing the content. Those should be used only by the parser,
+ * and not exported.
+ *
+ * Dirty macros, i.e. one need to make assumption on the context to use them
+ *
+ *   CUR_PTR return the current pointer to the xmlChar to be parsed.
+ *   CUR     returns the current xmlChar value, i.e. a 8 bit value
+ *           in ISO-Latin or UTF-8.
+ *           This should be used internally by the parser
+ *           only to compare to ASCII values otherwise it would break when
+ *           running with UTF-8 encoding.
+ *   NXT(n)  returns the n'th next xmlChar. Same as CUR is should be used only
+ *           to compare on ASCII based substring.
+ *   SKIP(n) Skip n xmlChar, and must also be used only to skip ASCII defined
+ *           strings within the parser.
+ *   CURRENT Returns the current char value, with the full decoding of
+ *           UTF-8 if we are using this mode. It returns an int.
+ *   NEXT    Skip to the next character, this does the proper decoding
+ *           in UTF-8 mode. It also pop-up unfinished entities on the fly.
+ *           It returns the pointer to the current xmlChar.
+ */
+
+#define CUR (*ctxt->cur)
+#define SKIP(val) ctxt->cur += (val)
+#define NXT(val) ctxt->cur[(val)]
+#define CUR_PTR ctxt->cur
+
+#define SKIP_BLANKS 							\
+    while (IS_BLANK_CH(*(ctxt->cur))) NEXT
+
+#define CURRENT (*ctxt->cur)
+#define NEXT ((*ctxt->cur) ?  ctxt->cur++: ctxt->cur)
+
+/*
+ * xmlXPtrGetChildNo:
+ * @ctxt:  the XPointer Parser context
+ * @index:  the child number
+ *
+ * Move the current node of the nodeset on the stack to the
+ * given child if found
+ */
+static void
+xmlXPtrGetChildNo(xmlXPathParserContextPtr ctxt, int indx) {
+    xmlNodePtr cur = NULL;
+    xmlXPathObjectPtr obj;
+    xmlNodeSetPtr oldset;
+
+    CHECK_TYPE(XPATH_NODESET);
+    obj = valuePop(ctxt);
+    oldset = obj->nodesetval;
+    if ((indx <= 0) || (oldset == NULL) || (oldset->nodeNr != 1)) {
+	xmlXPathFreeObject(obj);
+	valuePush(ctxt, xmlXPathNewNodeSet(NULL));
+	return;
+    }
+    cur = xmlXPtrGetNthChild(oldset->nodeTab[0], indx);
+    if (cur == NULL) {
+	xmlXPathFreeObject(obj);
+	valuePush(ctxt, xmlXPathNewNodeSet(NULL));
+	return;
+    }
+    oldset->nodeTab[0] = cur;
+    valuePush(ctxt, obj);
+}
+
+/**
+ * xmlXPtrEvalXPtrPart:
+ * @ctxt:  the XPointer Parser context
+ * @name:  the preparsed Scheme for the XPtrPart
+ * 
+ * XPtrPart ::= 'xpointer' '(' XPtrExpr ')'
+ *            | Scheme '(' SchemeSpecificExpr ')'
+ *
+ * Scheme   ::=  NCName - 'xpointer' [VC: Non-XPointer schemes]
+ *
+ * SchemeSpecificExpr ::= StringWithBalancedParens
+ *
+ * StringWithBalancedParens ::=  
+ *              [^()]* ('(' StringWithBalancedParens ')' [^()]*)*
+ *              [VC: Parenthesis escaping]
+ *
+ * XPtrExpr ::= Expr [VC: Parenthesis escaping]
+ *
+ * VC: Parenthesis escaping:
+ *   The end of an XPointer part is signaled by the right parenthesis ")"
+ *   character that is balanced with the left parenthesis "(" character
+ *   that began the part. Any unbalanced parenthesis character inside the
+ *   expression, even within literals, must be escaped with a circumflex (^)
+ *   character preceding it. If the expression contains any literal
+ *   occurrences of the circumflex, each must be escaped with an additional
+ *   circumflex (that is, ^^). If the unescaped parentheses in the expression
+ *   are not balanced, a syntax error results.
+ *
+ * Parse and evaluate an XPtrPart. Basically it generates the unescaped
+ * string and if the scheme is 'xpointer' it will call the XPath interpreter.
+ * 
+ * TODO: there is no new scheme registration mechanism
+ */
+
+static void
+xmlXPtrEvalXPtrPart(xmlXPathParserContextPtr ctxt, xmlChar *name) {
+    xmlChar *buffer, *cur;
+    int len;
+    int level;
+
+    if (name == NULL)
+    name = xmlXPathParseName(ctxt);
+    if (name == NULL)
+	XP_ERROR(XPATH_EXPR_ERROR);
+
+    if (CUR != '(')
+	XP_ERROR(XPATH_EXPR_ERROR);
+    NEXT;
+    level = 1;
+
+    len = xmlStrlen(ctxt->cur);
+    len++;
+    buffer = (xmlChar *) xmlMallocAtomic(len * sizeof (xmlChar));
+    if (buffer == NULL) {
+        xmlXPtrErrMemory("allocating buffer");
+	return;
+    }
+
+    cur = buffer;
+    while (CUR != 0) {
+	if (CUR == ')') {
+	    level--;
+	    if (level == 0) {
+		NEXT;
+		break;
+	    }
+	    *cur++ = CUR;
+	} else if (CUR == '(') {
+	    level++;
+	    *cur++ = CUR;
+	} else if (CUR == '^') {
+	    NEXT;
+	    if ((CUR == ')') || (CUR == '(') || (CUR == '^')) {
+		*cur++ = CUR;
+	    } else {
+		*cur++ = '^';
+		*cur++ = CUR;
+	    }
+	} else {
+	    *cur++ = CUR;
+	}
+	NEXT;
+    }
+    *cur = 0;
+
+    if ((level != 0) && (CUR == 0)) {
+	xmlFree(buffer);
+	XP_ERROR(XPTR_SYNTAX_ERROR);
+    }
+
+    if (xmlStrEqual(name, (xmlChar *) "xpointer")) {
+	const xmlChar *left = CUR_PTR;
+
+	CUR_PTR = buffer;
+	/*
+	 * To evaluate an xpointer scheme element (4.3) we need:
+	 *   context initialized to the root
+	 *   context position initalized to 1
+	 *   context size initialized to 1
+	 */
+	ctxt->context->node = (xmlNodePtr)ctxt->context->doc;
+	ctxt->context->proximityPosition = 1;
+	ctxt->context->contextSize = 1;
+	xmlXPathEvalExpr(ctxt);
+	CUR_PTR=left;
+    } else if (xmlStrEqual(name, (xmlChar *) "element")) {
+	const xmlChar *left = CUR_PTR;
+	xmlChar *name2;
+
+	CUR_PTR = buffer;
+	if (buffer[0] == '/') {
+	    xmlXPathRoot(ctxt);
+	    xmlXPtrEvalChildSeq(ctxt, NULL);
+	} else {
+	    name2 = xmlXPathParseName(ctxt);
+	    if (name2 == NULL) {
+		CUR_PTR = left;
+		xmlFree(buffer);
+		XP_ERROR(XPATH_EXPR_ERROR);
+	    }
+	    xmlXPtrEvalChildSeq(ctxt, name2);
+	}
+	CUR_PTR = left;
+#ifdef XPTR_XMLNS_SCHEME
+    } else if (xmlStrEqual(name, (xmlChar *) "xmlns")) {
+	const xmlChar *left = CUR_PTR;
+	xmlChar *prefix;
+	xmlChar *URI;
+	xmlURIPtr value;
+
+	CUR_PTR = buffer;
+        prefix = xmlXPathParseNCName(ctxt);
+	if (prefix == NULL) {
+	    xmlFree(buffer);
+	    xmlFree(name);
+	    XP_ERROR(XPTR_SYNTAX_ERROR);
+	}
+	SKIP_BLANKS;
+	if (CUR != '=') {
+	    xmlFree(prefix);
+	    xmlFree(buffer);
+	    xmlFree(name);
+	    XP_ERROR(XPTR_SYNTAX_ERROR);
+	}
+	NEXT;
+	SKIP_BLANKS;
+	/* @@ check escaping in the XPointer WD */
+
+	value = xmlParseURI((const char *)ctxt->cur);
+	if (value == NULL) {
+	    xmlFree(prefix);
+	    xmlFree(buffer);
+	    xmlFree(name);
+	    XP_ERROR(XPTR_SYNTAX_ERROR);
+	}
+	URI = xmlSaveUri(value);
+	xmlFreeURI(value);
+	if (URI == NULL) {
+	    xmlFree(prefix);
+	    xmlFree(buffer);
+	    xmlFree(name);
+	    XP_ERROR(XPATH_MEMORY_ERROR);
+	}
+	
+	xmlXPathRegisterNs(ctxt->context, prefix, URI);
+	CUR_PTR = left;
+	xmlFree(URI);
+	xmlFree(prefix);
+#endif /* XPTR_XMLNS_SCHEME */
+    } else {
+        xmlXPtrErr(ctxt, XML_XPTR_UNKNOWN_SCHEME,
+		   "unsupported scheme '%s'\n", name);
+    }
+    xmlFree(buffer);
+    xmlFree(name);
+}
+
+/**
+ * xmlXPtrEvalFullXPtr:
+ * @ctxt:  the XPointer Parser context
+ * @name:  the preparsed Scheme for the first XPtrPart
+ *
+ * FullXPtr ::= XPtrPart (S? XPtrPart)*
+ *
+ * As the specs says:
+ * -----------
+ * When multiple XPtrParts are provided, they must be evaluated in
+ * left-to-right order. If evaluation of one part fails, the nexti
+ * is evaluated. The following conditions cause XPointer part failure:
+ *
+ * - An unknown scheme
+ * - A scheme that does not locate any sub-resource present in the resource
+ * - A scheme that is not applicable to the media type of the resource
+ *
+ * The XPointer application must consume a failed XPointer part and
+ * attempt to evaluate the next one, if any. The result of the first
+ * XPointer part whose evaluation succeeds is taken to be the fragment
+ * located by the XPointer as a whole. If all the parts fail, the result
+ * for the XPointer as a whole is a sub-resource error.
+ * -----------
+ *
+ * Parse and evaluate a Full XPtr i.e. possibly a cascade of XPath based
+ * expressions or other schemes.
+ */
+static void
+xmlXPtrEvalFullXPtr(xmlXPathParserContextPtr ctxt, xmlChar *name) {
+    if (name == NULL)
+    name = xmlXPathParseName(ctxt);
+    if (name == NULL)
+	XP_ERROR(XPATH_EXPR_ERROR);
+    while (name != NULL) {
+	xmlXPtrEvalXPtrPart(ctxt, name);
+
+	/* in case of syntax error, break here */
+	if (ctxt->error != XPATH_EXPRESSION_OK)
+	    return;
+
+	/*
+	 * If the returned value is a non-empty nodeset
+	 * or location set, return here.
+	 */
+	if (ctxt->value != NULL) {
+	    xmlXPathObjectPtr obj = ctxt->value;
+
+	    switch (obj->type) {
+		case XPATH_LOCATIONSET: {
+		    xmlLocationSetPtr loc = ctxt->value->user;
+		    if ((loc != NULL) && (loc->locNr > 0))
+			return;
+		    break;
+		}
+		case XPATH_NODESET: {
+		    xmlNodeSetPtr loc = ctxt->value->nodesetval;
+		    if ((loc != NULL) && (loc->nodeNr > 0))
+			return;
+		    break;
+		}
+		default:
+		    break;
+	    }
+
+	    /*
+	     * Evaluating to improper values is equivalent to
+	     * a sub-resource error, clean-up the stack
+	     */
+	    do {
+		obj = valuePop(ctxt);
+		if (obj != NULL) {
+		    xmlXPathFreeObject(obj);
+		}
+	    } while (obj != NULL);
+	}
+
+	/*
+	 * Is there another XPointer part.
+	 */
+	SKIP_BLANKS;
+	name = xmlXPathParseName(ctxt);
+    }
+}
+
+/**
+ * xmlXPtrEvalChildSeq:
+ * @ctxt:  the XPointer Parser context
+ * @name:  a possible ID name of the child sequence
+ *
+ *  ChildSeq ::= '/1' ('/' [0-9]*)*
+ *             | Name ('/' [0-9]*)+
+ *
+ * Parse and evaluate a Child Sequence. This routine also handle the
+ * case of a Bare Name used to get a document ID.
+ */
+static void
+xmlXPtrEvalChildSeq(xmlXPathParserContextPtr ctxt, xmlChar *name) {
+    /*
+     * XPointer don't allow by syntax to address in mutirooted trees
+     * this might prove useful in some cases, warn about it.
+     */
+    if ((name == NULL) && (CUR == '/') && (NXT(1) != '1')) {
+        xmlXPtrErr(ctxt, XML_XPTR_CHILDSEQ_START,
+		   "warning: ChildSeq not starting by /1\n", NULL);
+    }
+
+    if (name != NULL) {
+	valuePush(ctxt, xmlXPathNewString(name));
+	xmlFree(name);
+	xmlXPathIdFunction(ctxt, 1);
+	CHECK_ERROR;
+    }
+
+    while (CUR == '/') {
+	int child = 0;
+	NEXT;
+        
+	while ((CUR >= '0') && (CUR <= '9')) {
+	    child = child * 10 + (CUR - '0');
+	    NEXT;
+	}
+	xmlXPtrGetChildNo(ctxt, child);
+    }
+}
+
+
+/**
+ * xmlXPtrEvalXPointer:
+ * @ctxt:  the XPointer Parser context
+ *
+ *  XPointer ::= Name
+ *             | ChildSeq
+ *             | FullXPtr
+ *
+ * Parse and evaluate an XPointer
+ */
+static void
+xmlXPtrEvalXPointer(xmlXPathParserContextPtr ctxt) {
+    if (ctxt->valueTab == NULL) {
+	/* Allocate the value stack */
+	ctxt->valueTab = (xmlXPathObjectPtr *) 
+			 xmlMalloc(10 * sizeof(xmlXPathObjectPtr));
+	if (ctxt->valueTab == NULL) {
+	    xmlXPtrErrMemory("allocating evaluation context");
+	    return;
+	}
+	ctxt->valueNr = 0;
+	ctxt->valueMax = 10;
+	ctxt->value = NULL;
+    }
+    SKIP_BLANKS;
+    if (CUR == '/') {
+	xmlXPathRoot(ctxt);
+        xmlXPtrEvalChildSeq(ctxt, NULL);
+    } else {
+	xmlChar *name;
+
+	name = xmlXPathParseName(ctxt);
+	if (name == NULL)
+	    XP_ERROR(XPATH_EXPR_ERROR);
+	if (CUR == '(') {
+	    xmlXPtrEvalFullXPtr(ctxt, name);
+	    /* Short evaluation */
+	    return;
+	} else {
+	    /* this handle both Bare Names and Child Sequences */
+	    xmlXPtrEvalChildSeq(ctxt, name);
+	}
+    }
+    SKIP_BLANKS;
+    if (CUR != 0)
+	XP_ERROR(XPATH_EXPR_ERROR);
+}
+
+
+/************************************************************************
+ *									*
+ *			General routines				*
+ *									*
+ ************************************************************************/
+
+void xmlXPtrStringRangeFunction(xmlXPathParserContextPtr ctxt, int nargs);
+void xmlXPtrStartPointFunction(xmlXPathParserContextPtr ctxt, int nargs);
+void xmlXPtrEndPointFunction(xmlXPathParserContextPtr ctxt, int nargs);
+void xmlXPtrHereFunction(xmlXPathParserContextPtr ctxt, int nargs);
+void xmlXPtrOriginFunction(xmlXPathParserContextPtr ctxt, int nargs);
+void xmlXPtrRangeInsideFunction(xmlXPathParserContextPtr ctxt, int nargs);
+void xmlXPtrRangeFunction(xmlXPathParserContextPtr ctxt, int nargs);
+
+/**
+ * xmlXPtrNewContext:
+ * @doc:  the XML document
+ * @here:  the node that directly contains the XPointer being evaluated or NULL
+ * @origin:  the element from which a user or program initiated traversal of
+ *           the link, or NULL.
+ *
+ * Create a new XPointer context
+ *
+ * Returns the xmlXPathContext just allocated.
+ */
+xmlXPathContextPtr
+xmlXPtrNewContext(xmlDocPtr doc, xmlNodePtr here, xmlNodePtr origin) {
+    xmlXPathContextPtr ret;
+
+    ret = xmlXPathNewContext(doc);
+    if (ret == NULL)
+	return(ret);
+    ret->xptr = 1;
+    ret->here = here;
+    ret->origin = origin;
+
+    xmlXPathRegisterFunc(ret, (xmlChar *)"range-to",
+	                 xmlXPtrRangeToFunction);
+    xmlXPathRegisterFunc(ret, (xmlChar *)"range",
+	                 xmlXPtrRangeFunction);
+    xmlXPathRegisterFunc(ret, (xmlChar *)"range-inside",
+	                 xmlXPtrRangeInsideFunction);
+    xmlXPathRegisterFunc(ret, (xmlChar *)"string-range",
+	                 xmlXPtrStringRangeFunction);
+    xmlXPathRegisterFunc(ret, (xmlChar *)"start-point",
+	                 xmlXPtrStartPointFunction);
+    xmlXPathRegisterFunc(ret, (xmlChar *)"end-point",
+	                 xmlXPtrEndPointFunction);
+    xmlXPathRegisterFunc(ret, (xmlChar *)"here",
+	                 xmlXPtrHereFunction);
+    xmlXPathRegisterFunc(ret, (xmlChar *)" origin",
+	                 xmlXPtrOriginFunction);
+
+    return(ret);
+}
+
+/**
+ * xmlXPtrEval:
+ * @str:  the XPointer expression
+ * @ctx:  the XPointer context
+ *
+ * Evaluate the XPath Location Path in the given context.
+ *
+ * Returns the xmlXPathObjectPtr resulting from the evaluation or NULL.
+ *         the caller has to free the object.
+ */
+xmlXPathObjectPtr
+xmlXPtrEval(const xmlChar *str, xmlXPathContextPtr ctx) {
+    xmlXPathParserContextPtr ctxt;
+    xmlXPathObjectPtr res = NULL, tmp;
+    xmlXPathObjectPtr init = NULL;
+    int stack = 0;
+
+    xmlXPathInit();
+
+    if ((ctx == NULL) || (str == NULL))
+	return(NULL);
+
+    ctxt = xmlXPathNewParserContext(str, ctx);
+    ctxt->xptr = 1;
+    xmlXPtrEvalXPointer(ctxt);
+
+    if ((ctxt->value != NULL) &&
+	(ctxt->value->type != XPATH_NODESET) &&
+	(ctxt->value->type != XPATH_LOCATIONSET)) {
+        xmlXPtrErr(ctxt, XML_XPTR_EVAL_FAILED,
+		"xmlXPtrEval: evaluation failed to return a node set\n",
+		   NULL);
+    } else {
+	res = valuePop(ctxt);
+    }
+
+    do {
+        tmp = valuePop(ctxt);
+	if (tmp != NULL) {
+	    if (tmp != init) {
+		if (tmp->type == XPATH_NODESET) {
+		    /*
+		     * Evaluation may push a root nodeset which is unused
+		     */
+		    xmlNodeSetPtr set; 
+		    set = tmp->nodesetval;
+		    if ((set->nodeNr != 1) ||
+			(set->nodeTab[0] != (xmlNodePtr) ctx->doc))
+			stack++;
+		} else
+		    stack++;    
+	    }
+	    xmlXPathFreeObject(tmp);
+        }
+    } while (tmp != NULL);
+    if (stack != 0) {
+        xmlXPtrErr(ctxt, XML_XPTR_EXTRA_OBJECTS,
+		   "xmlXPtrEval: object(s) left on the eval stack\n",
+		   NULL);
+    }
+    if (ctxt->error != XPATH_EXPRESSION_OK) {
+	xmlXPathFreeObject(res);
+	res = NULL;
+    }
+        
+    xmlXPathFreeParserContext(ctxt);
+    return(res);
+}
+
+/**
+ * xmlXPtrBuildRangeNodeList:
+ * @range:  a range object
+ *
+ * Build a node list tree copy of the range
+ *
+ * Returns an xmlNodePtr list or NULL.
+ *         the caller has to free the node tree.
+ */
+static xmlNodePtr
+xmlXPtrBuildRangeNodeList(xmlXPathObjectPtr range) {
+    /* pointers to generated nodes */
+    xmlNodePtr list = NULL, last = NULL, parent = NULL, tmp;
+    /* pointers to traversal nodes */
+    xmlNodePtr start, cur, end;
+    int index1, index2;
+
+    if (range == NULL)
+	return(NULL);
+    if (range->type != XPATH_RANGE)
+	return(NULL);
+    start = (xmlNodePtr) range->user;
+
+    if (start == NULL)
+	return(NULL);
+    end = range->user2;
+    if (end == NULL)
+	return(xmlCopyNode(start, 1));
+
+    cur = start;
+    index1 = range->index;
+    index2 = range->index2;
+    while (cur != NULL) {
+	if (cur == end) {
+	    if (cur->type == XML_TEXT_NODE) {
+		const xmlChar *content = cur->content;
+		int len;
+
+		if (content == NULL) {
+		    tmp = xmlNewTextLen(NULL, 0);
+		} else {
+		    len = index2;
+		    if ((cur == start) && (index1 > 1)) {
+			content += (index1 - 1);
+			len -= (index1 - 1);
+			index1 = 0;
+		    } else {
+			len = index2;
+		    }
+		    tmp = xmlNewTextLen(content, len);
+		}
+		/* single sub text node selection */
+		if (list == NULL)
+		    return(tmp);
+		/* prune and return full set */
+		if (last != NULL)
+		    xmlAddNextSibling(last, tmp);
+		else 
+		    xmlAddChild(parent, tmp);
+		return(list);
+	    } else {
+		tmp = xmlCopyNode(cur, 0);
+		if (list == NULL)
+		    list = tmp;
+		else {
+		    if (last != NULL)
+			xmlAddNextSibling(last, tmp);
+		    else
+			xmlAddChild(parent, tmp);
+		}
+		last = NULL;
+		parent = tmp;
+
+		if (index2 > 1) {
+		    end = xmlXPtrGetNthChild(cur, index2 - 1);
+		    index2 = 0;
+		}
+		if ((cur == start) && (index1 > 1)) {
+		    cur = xmlXPtrGetNthChild(cur, index1 - 1);
+		    index1 = 0;
+		} else {
+		    cur = cur->children;
+		}
+		/*
+		 * Now gather the remaining nodes from cur to end
+		 */
+		continue; /* while */
+	    }
+	} else if ((cur == start) &&
+		   (list == NULL) /* looks superfluous but ... */ ) {
+	    if ((cur->type == XML_TEXT_NODE) ||
+		(cur->type == XML_CDATA_SECTION_NODE)) {
+		const xmlChar *content = cur->content;
+
+		if (content == NULL) {
+		    tmp = xmlNewTextLen(NULL, 0);
+		} else {
+		    if (index1 > 1) {
+			content += (index1 - 1);
+		    }
+		    tmp = xmlNewText(content);
+		}
+		last = list = tmp;
+	    } else {
+		if ((cur == start) && (index1 > 1)) {
+		    tmp = xmlCopyNode(cur, 0);
+		    list = tmp;
+		    parent = tmp;
+		    last = NULL;
+		    cur = xmlXPtrGetNthChild(cur, index1 - 1);
+		    index1 = 0;
+		    /*
+		     * Now gather the remaining nodes from cur to end
+		     */
+		    continue; /* while */
+		}
+		tmp = xmlCopyNode(cur, 1);
+		list = tmp;
+		parent = NULL;
+		last = tmp;
+	    }
+	} else {
+	    tmp = NULL;
+	    switch (cur->type) {
+		case XML_DTD_NODE:
+		case XML_ELEMENT_DECL:
+		case XML_ATTRIBUTE_DECL:
+		case XML_ENTITY_NODE:
+		    /* Do not copy DTD informations */
+		    break;
+		case XML_ENTITY_DECL:
+		    TODO /* handle crossing entities -> stack needed */
+		    break;
+		case XML_XINCLUDE_START:
+		case XML_XINCLUDE_END:
+		    /* don't consider it part of the tree content */
+		    break;
+		case XML_ATTRIBUTE_NODE:
+		    /* Humm, should not happen ! */
+		    STRANGE
+		    break;
+		default:
+		    tmp = xmlCopyNode(cur, 1);
+		    break;
+	    }
+	    if (tmp != NULL) {
+		if ((list == NULL) || ((last == NULL) && (parent == NULL)))  {
+		    STRANGE
+		    return(NULL);
+		}
+		if (last != NULL)
+		    xmlAddNextSibling(last, tmp);
+		else {
+		    xmlAddChild(parent, tmp);
+		    last = tmp;
+		}
+	    }
+	}
+	/*
+	 * Skip to next node in document order
+	 */
+	if ((list == NULL) || ((last == NULL) && (parent == NULL)))  {
+	    STRANGE
+	    return(NULL);
+	}
+	cur = xmlXPtrAdvanceNode(cur, NULL);
+    }
+    return(list);
+}
+
+/**
+ * xmlXPtrBuildNodeList:
+ * @obj:  the XPointer result from the evaluation.
+ *
+ * Build a node list tree copy of the XPointer result.
+ * This will drop Attributes and Namespace declarations.
+ *
+ * Returns an xmlNodePtr list or NULL.
+ *         the caller has to free the node tree.
+ */
+xmlNodePtr
+xmlXPtrBuildNodeList(xmlXPathObjectPtr obj) {
+    xmlNodePtr list = NULL, last = NULL;
+    int i;
+
+    if (obj == NULL)
+	return(NULL);
+    switch (obj->type) {
+        case XPATH_NODESET: {
+	    xmlNodeSetPtr set = obj->nodesetval;
+	    if (set == NULL)
+		return(NULL);
+	    for (i = 0;i < set->nodeNr;i++) {
+		if (set->nodeTab[i] == NULL)
+		    continue;
+		switch (set->nodeTab[i]->type) {
+		    case XML_TEXT_NODE:
+		    case XML_CDATA_SECTION_NODE:
+		    case XML_ELEMENT_NODE:
+		    case XML_ENTITY_REF_NODE:
+		    case XML_ENTITY_NODE:
+		    case XML_PI_NODE:
+		    case XML_COMMENT_NODE:
+		    case XML_DOCUMENT_NODE:
+		    case XML_HTML_DOCUMENT_NODE:
+#ifdef LIBXML_DOCB_ENABLED
+		    case XML_DOCB_DOCUMENT_NODE:
+#endif
+		    case XML_XINCLUDE_START:
+		    case XML_XINCLUDE_END:
+			break;
+		    case XML_ATTRIBUTE_NODE:
+		    case XML_NAMESPACE_DECL:
+		    case XML_DOCUMENT_TYPE_NODE:
+		    case XML_DOCUMENT_FRAG_NODE:
+		    case XML_NOTATION_NODE:
+		    case XML_DTD_NODE:
+		    case XML_ELEMENT_DECL:
+		    case XML_ATTRIBUTE_DECL:
+		    case XML_ENTITY_DECL:
+			continue; /* for */
+		}
+		if (last == NULL)
+		    list = last = xmlCopyNode(set->nodeTab[i], 1);
+		else {
+		    xmlAddNextSibling(last, xmlCopyNode(set->nodeTab[i], 1));
+		    if (last->next != NULL)
+			last = last->next;
+		}
+	    }
+	    break;
+	}
+	case XPATH_LOCATIONSET: {
+	    xmlLocationSetPtr set = (xmlLocationSetPtr) obj->user;
+	    if (set == NULL)
+		return(NULL);
+	    for (i = 0;i < set->locNr;i++) {
+		if (last == NULL)
+		    list = last = xmlXPtrBuildNodeList(set->locTab[i]);
+		else
+		    xmlAddNextSibling(last,
+			    xmlXPtrBuildNodeList(set->locTab[i]));
+		if (last != NULL) {
+		    while (last->next != NULL)
+			last = last->next;
+		}
+	    }
+	    break;
+	}
+	case XPATH_RANGE:
+	    return(xmlXPtrBuildRangeNodeList(obj));
+	case XPATH_POINT:
+	    return(xmlCopyNode(obj->user, 0));
+	default:
+	    break;
+    }
+    return(list);
+}
+
+/************************************************************************
+ *									*
+ *			XPointer functions				*
+ *									*
+ ************************************************************************/
+
+/**
+ * xmlXPtrNbLocChildren:
+ * @node:  an xmlNodePtr
+ *
+ * Count the number of location children of @node or the length of the
+ * string value in case of text/PI/Comments nodes
+ *
+ * Returns the number of location children
+ */
+static int
+xmlXPtrNbLocChildren(xmlNodePtr node) {
+    int ret = 0;
+    if (node == NULL)
+	return(-1);
+    switch (node->type) {
+        case XML_HTML_DOCUMENT_NODE:
+        case XML_DOCUMENT_NODE:
+        case XML_ELEMENT_NODE:
+	    node = node->children;
+	    while (node != NULL) {
+		if (node->type == XML_ELEMENT_NODE)
+		    ret++;
+		node = node->next;
+	    }
+	    break;
+        case XML_ATTRIBUTE_NODE:
+	    return(-1);
+
+        case XML_PI_NODE:
+        case XML_COMMENT_NODE:
+        case XML_TEXT_NODE:
+        case XML_CDATA_SECTION_NODE:
+        case XML_ENTITY_REF_NODE:
+	    ret = xmlStrlen(node->content);
+	    break;
+	default:
+	    return(-1);
+    }
+    return(ret);
+}
+
+/**
+ * xmlXPtrHereFunction:
+ * @ctxt:  the XPointer Parser context
+ * @nargs:  the number of args
+ *
+ * Function implementing here() operation 
+ * as described in 5.4.3
+ */
+void
+xmlXPtrHereFunction(xmlXPathParserContextPtr ctxt, int nargs) {
+    CHECK_ARITY(0);
+
+    if (ctxt->context->here == NULL)
+	XP_ERROR(XPTR_SYNTAX_ERROR);
+    
+    valuePush(ctxt, xmlXPtrNewLocationSetNodes(ctxt->context->here, NULL));
+}
+
+/**
+ * xmlXPtrOriginFunction:
+ * @ctxt:  the XPointer Parser context
+ * @nargs:  the number of args
+ *
+ * Function implementing origin() operation 
+ * as described in 5.4.3
+ */
+void
+xmlXPtrOriginFunction(xmlXPathParserContextPtr ctxt, int nargs) {
+    CHECK_ARITY(0);
+
+    if (ctxt->context->origin == NULL)
+	XP_ERROR(XPTR_SYNTAX_ERROR);
+    
+    valuePush(ctxt, xmlXPtrNewLocationSetNodes(ctxt->context->origin, NULL));
+}
+
+/**
+ * xmlXPtrStartPointFunction:
+ * @ctxt:  the XPointer Parser context
+ * @nargs:  the number of args
+ *
+ * Function implementing start-point() operation 
+ * as described in 5.4.3
+ * ----------------
+ * location-set start-point(location-set)
+ *
+ * For each location x in the argument location-set, start-point adds a
+ * location of type point to the result location-set. That point represents
+ * the start point of location x and is determined by the following rules:
+ *
+ * - If x is of type point, the start point is x.
+ * - If x is of type range, the start point is the start point of x.
+ * - If x is of type root, element, text, comment, or processing instruction,
+ * - the container node of the start point is x and the index is 0.
+ * - If x is of type attribute or namespace, the function must signal a
+ *   syntax error.
+ * ----------------
+ *
+ */
+void
+xmlXPtrStartPointFunction(xmlXPathParserContextPtr ctxt, int nargs) {
+    xmlXPathObjectPtr tmp, obj, point;
+    xmlLocationSetPtr newset = NULL;
+    xmlLocationSetPtr oldset = NULL;
+
+    CHECK_ARITY(1);
+    if ((ctxt->value == NULL) ||
+	((ctxt->value->type != XPATH_LOCATIONSET) &&
+	 (ctxt->value->type != XPATH_NODESET)))
+        XP_ERROR(XPATH_INVALID_TYPE)
+
+    obj = valuePop(ctxt);
+    if (obj->type == XPATH_NODESET) {
+	/*
+	 * First convert to a location set
+	 */
+	tmp = xmlXPtrNewLocationSetNodeSet(obj->nodesetval);
+	xmlXPathFreeObject(obj);
+	obj = tmp;
+    }
+
+    newset = xmlXPtrLocationSetCreate(NULL);
+    if (newset == NULL) {
+	xmlXPathFreeObject(obj);
+        XP_ERROR(XPATH_MEMORY_ERROR);
+    }
+    oldset = (xmlLocationSetPtr) obj->user;
+    if (oldset != NULL) {
+	int i;
+
+	for (i = 0; i < oldset->locNr; i++) {
+	    tmp = oldset->locTab[i];
+	    if (tmp == NULL)
+		continue;
+	    point = NULL;
+	    switch (tmp->type) {
+		case XPATH_POINT:
+		    point = xmlXPtrNewPoint(tmp->user, tmp->index);
+		    break;
+		case XPATH_RANGE: {
+		    xmlNodePtr node = tmp->user;
+		    if (node != NULL) {
+			if (node->type == XML_ATTRIBUTE_NODE) {
+			    /* TODO: Namespace Nodes ??? */
+			    xmlXPathFreeObject(obj);
+			    xmlXPtrFreeLocationSet(newset);
+			    XP_ERROR(XPTR_SYNTAX_ERROR);
+			}
+			point = xmlXPtrNewPoint(node, tmp->index);
+		    }
+		    break;
+	        }
+		default:
+		    /*** Should we raise an error ?
+		    xmlXPathFreeObject(obj);
+		    xmlXPathFreeObject(newset);
+		    XP_ERROR(XPATH_INVALID_TYPE)
+		    ***/
+		    break;
+	    }
+            if (point != NULL)
+		xmlXPtrLocationSetAdd(newset, point);
+	}
+    }
+    xmlXPathFreeObject(obj);
+    valuePush(ctxt, xmlXPtrWrapLocationSet(newset));
+}
+
+/**
+ * xmlXPtrEndPointFunction:
+ * @ctxt:  the XPointer Parser context
+ * @nargs:  the number of args
+ *
+ * Function implementing end-point() operation 
+ * as described in 5.4.3
+ * ----------------------------
+ * location-set end-point(location-set)
+ *
+ * For each location x in the argument location-set, end-point adds a
+ * location of type point to the result location-set. That point represents
+ * the end point of location x and is determined by the following rules:
+ *
+ * - If x is of type point, the resulting point is x.
+ * - If x is of type range, the resulting point is the end point of x.
+ * - If x is of type root or element, the container node of the resulting
+ *   point is x and the index is the number of location children of x.
+ * - If x is of type text, comment, or processing instruction, the container
+ *   node of the resulting point is x and the index is the length of the
+ *   string-value of x.
+ * - If x is of type attribute or namespace, the function must signal a
+ *   syntax error.
+ * ----------------------------
+ */
+void
+xmlXPtrEndPointFunction(xmlXPathParserContextPtr ctxt, int nargs) {
+    xmlXPathObjectPtr tmp, obj, point;
+    xmlLocationSetPtr newset = NULL;
+    xmlLocationSetPtr oldset = NULL;
+
+    CHECK_ARITY(1);
+    if ((ctxt->value == NULL) ||
+	((ctxt->value->type != XPATH_LOCATIONSET) &&
+	 (ctxt->value->type != XPATH_NODESET)))
+        XP_ERROR(XPATH_INVALID_TYPE)
+
+    obj = valuePop(ctxt);
+    if (obj->type == XPATH_NODESET) {
+	/*
+	 * First convert to a location set
+	 */
+	tmp = xmlXPtrNewLocationSetNodeSet(obj->nodesetval);
+	xmlXPathFreeObject(obj);
+	obj = tmp;
+    }
+
+    newset = xmlXPtrLocationSetCreate(NULL);
+    oldset = (xmlLocationSetPtr) obj->user;
+    if (oldset != NULL) {
+	int i;
+
+	for (i = 0; i < oldset->locNr; i++) {
+	    tmp = oldset->locTab[i];
+	    if (tmp == NULL)
+		continue;
+	    point = NULL;
+	    switch (tmp->type) {
+		case XPATH_POINT:
+		    point = xmlXPtrNewPoint(tmp->user, tmp->index);
+		    break;
+		case XPATH_RANGE: {
+		    xmlNodePtr node = tmp->user2;
+		    if (node != NULL) {
+			if (node->type == XML_ATTRIBUTE_NODE) {
+			    /* TODO: Namespace Nodes ??? */
+			    xmlXPathFreeObject(obj);
+			    xmlXPtrFreeLocationSet(newset);
+			    XP_ERROR(XPTR_SYNTAX_ERROR);
+			}
+			point = xmlXPtrNewPoint(node, tmp->index2);
+		    } else if (tmp->user == NULL) {
+			point = xmlXPtrNewPoint(node,
+				       xmlXPtrNbLocChildren(node));
+		    }
+		    break;
+	        }
+		default:
+		    /*** Should we raise an error ?
+		    xmlXPathFreeObject(obj);
+		    xmlXPathFreeObject(newset);
+		    XP_ERROR(XPATH_INVALID_TYPE)
+		    ***/
+		    break;
+	    }
+            if (point != NULL)
+		xmlXPtrLocationSetAdd(newset, point);
+	}
+    }
+    xmlXPathFreeObject(obj);
+    valuePush(ctxt, xmlXPtrWrapLocationSet(newset));
+}
+
+
+/**
+ * xmlXPtrCoveringRange:
+ * @ctxt:  the XPointer Parser context
+ * @loc:  the location for which the covering range must be computed
+ *
+ * A covering range is a range that wholly encompasses a location
+ * Section 5.3.3. Covering Ranges for All Location Types
+ *        http://www.w3.org/TR/xptr#N2267
+ *
+ * Returns a new location or NULL in case of error
+ */
+static xmlXPathObjectPtr
+xmlXPtrCoveringRange(xmlXPathParserContextPtr ctxt, xmlXPathObjectPtr loc) {
+    if (loc == NULL)
+	return(NULL);
+    if ((ctxt == NULL) || (ctxt->context == NULL) ||
+	(ctxt->context->doc == NULL))
+	return(NULL);
+    switch (loc->type) {
+        case XPATH_POINT:
+	    return(xmlXPtrNewRange(loc->user, loc->index,
+			           loc->user, loc->index));
+        case XPATH_RANGE:
+	    if (loc->user2 != NULL) {
+		return(xmlXPtrNewRange(loc->user, loc->index,
+			              loc->user2, loc->index2));
+	    } else {
+		xmlNodePtr node = (xmlNodePtr) loc->user;
+		if (node == (xmlNodePtr) ctxt->context->doc) {
+		    return(xmlXPtrNewRange(node, 0, node,
+					   xmlXPtrGetArity(node)));
+		} else {
+		    switch (node->type) {
+			case XML_ATTRIBUTE_NODE:
+			/* !!! our model is slightly different than XPath */
+			    return(xmlXPtrNewRange(node, 0, node,
+					           xmlXPtrGetArity(node)));
+			case XML_ELEMENT_NODE:
+			case XML_TEXT_NODE:
+			case XML_CDATA_SECTION_NODE:
+			case XML_ENTITY_REF_NODE:
+			case XML_PI_NODE:
+			case XML_COMMENT_NODE:
+			case XML_DOCUMENT_NODE:
+			case XML_NOTATION_NODE:
+			case XML_HTML_DOCUMENT_NODE: {
+			    int indx = xmlXPtrGetIndex(node);
+			     
+			    node = node->parent;
+			    return(xmlXPtrNewRange(node, indx - 1,
+					           node, indx + 1));
+			}
+			default:
+			    return(NULL);
+		    }
+		}
+	    }
+	default:
+	    TODO /* missed one case ??? */
+    }
+    return(NULL);
+}
+
+/**
+ * xmlXPtrRangeFunction:
+ * @ctxt:  the XPointer Parser context
+ * @nargs:  the number of args
+ *
+ * Function implementing the range() function 5.4.3
+ *  location-set range(location-set )
+ *
+ *  The range function returns ranges covering the locations in
+ *  the argument location-set. For each location x in the argument
+ *  location-set, a range location representing the covering range of
+ *  x is added to the result location-set.
+ */
+void
+xmlXPtrRangeFunction(xmlXPathParserContextPtr ctxt, int nargs) {
+    int i;
+    xmlXPathObjectPtr set;
+    xmlLocationSetPtr oldset;
+    xmlLocationSetPtr newset;
+
+    CHECK_ARITY(1);
+    if ((ctxt->value == NULL) ||
+	((ctxt->value->type != XPATH_LOCATIONSET) &&
+	 (ctxt->value->type != XPATH_NODESET)))
+        XP_ERROR(XPATH_INVALID_TYPE)
+
+    set = valuePop(ctxt);
+    if (set->type == XPATH_NODESET) {
+	xmlXPathObjectPtr tmp;
+
+	/*
+	 * First convert to a location set
+	 */
+	tmp = xmlXPtrNewLocationSetNodeSet(set->nodesetval);
+	xmlXPathFreeObject(set);
+	set = tmp;
+    }
+    oldset = (xmlLocationSetPtr) set->user;
+
+    /*
+     * The loop is to compute the covering range for each item and add it
+     */
+    newset = xmlXPtrLocationSetCreate(NULL);
+    for (i = 0;i < oldset->locNr;i++) {
+	xmlXPtrLocationSetAdd(newset,
+		xmlXPtrCoveringRange(ctxt, oldset->locTab[i]));
+    }
+
+    /*
+     * Save the new value and cleanup
+     */
+    valuePush(ctxt, xmlXPtrWrapLocationSet(newset));
+    xmlXPathFreeObject(set);
+}
+
+/**
+ * xmlXPtrInsideRange:
+ * @ctxt:  the XPointer Parser context
+ * @loc:  the location for which the inside range must be computed
+ *
+ * A inside range is a range described in the range-inside() description
+ *
+ * Returns a new location or NULL in case of error
+ */
+static xmlXPathObjectPtr
+xmlXPtrInsideRange(xmlXPathParserContextPtr ctxt, xmlXPathObjectPtr loc) {
+    if (loc == NULL)
+	return(NULL);
+    if ((ctxt == NULL) || (ctxt->context == NULL) ||
+	(ctxt->context->doc == NULL))
+	return(NULL);
+    switch (loc->type) {
+        case XPATH_POINT: {
+	    xmlNodePtr node = (xmlNodePtr) loc->user;
+	    switch (node->type) {
+		case XML_PI_NODE:
+		case XML_COMMENT_NODE:
+		case XML_TEXT_NODE:
+		case XML_CDATA_SECTION_NODE: {
+		    if (node->content == NULL) {
+			return(xmlXPtrNewRange(node, 0, node, 0));
+		    } else {
+			return(xmlXPtrNewRange(node, 0, node,
+					       xmlStrlen(node->content)));
+		    }
+		}
+		case XML_ATTRIBUTE_NODE:
+		case XML_ELEMENT_NODE:
+		case XML_ENTITY_REF_NODE:
+		case XML_DOCUMENT_NODE:
+		case XML_NOTATION_NODE:
+		case XML_HTML_DOCUMENT_NODE: {
+		    return(xmlXPtrNewRange(node, 0, node,
+					   xmlXPtrGetArity(node)));
+		}
+		default:
+		    break;
+	    }
+	    return(NULL);
+	}
+        case XPATH_RANGE: {
+	    xmlNodePtr node = (xmlNodePtr) loc->user;
+	    if (loc->user2 != NULL) {
+		return(xmlXPtrNewRange(node, loc->index,
+			               loc->user2, loc->index2));
+	    } else {
+		switch (node->type) {
+		    case XML_PI_NODE:
+		    case XML_COMMENT_NODE:
+		    case XML_TEXT_NODE:
+		    case XML_CDATA_SECTION_NODE: {
+			if (node->content == NULL) {
+			    return(xmlXPtrNewRange(node, 0, node, 0));
+			} else {
+			    return(xmlXPtrNewRange(node, 0, node,
+						   xmlStrlen(node->content)));
+			}
+		    }
+		    case XML_ATTRIBUTE_NODE:
+		    case XML_ELEMENT_NODE:
+		    case XML_ENTITY_REF_NODE:
+		    case XML_DOCUMENT_NODE:
+		    case XML_NOTATION_NODE:
+		    case XML_HTML_DOCUMENT_NODE: {
+			return(xmlXPtrNewRange(node, 0, node,
+					       xmlXPtrGetArity(node)));
+		    }
+		    default:
+			break;
+		}
+		return(NULL);
+	    }
+        }
+	default:
+	    TODO /* missed one case ??? */
+    }
+    return(NULL);
+}
+
+/**
+ * xmlXPtrRangeInsideFunction:
+ * @ctxt:  the XPointer Parser context
+ * @nargs:  the number of args
+ *
+ * Function implementing the range-inside() function 5.4.3
+ *  location-set range-inside(location-set )
+ *
+ *  The range-inside function returns ranges covering the contents of
+ *  the locations in the argument location-set. For each location x in
+ *  the argument location-set, a range location is added to the result
+ *  location-set. If x is a range location, then x is added to the
+ *  result location-set. If x is not a range location, then x is used
+ *  as the container location of the start and end points of the range
+ *  location to be added; the index of the start point of the range is
+ *  zero; if the end point is a character point then its index is the
+ *  length of the string-value of x, and otherwise is the number of
+ *  location children of x.
+ *
+ */
+void
+xmlXPtrRangeInsideFunction(xmlXPathParserContextPtr ctxt, int nargs) {
+    int i;
+    xmlXPathObjectPtr set;
+    xmlLocationSetPtr oldset;
+    xmlLocationSetPtr newset;
+
+    CHECK_ARITY(1);
+    if ((ctxt->value == NULL) ||
+	((ctxt->value->type != XPATH_LOCATIONSET) &&
+	 (ctxt->value->type != XPATH_NODESET)))
+        XP_ERROR(XPATH_INVALID_TYPE)
+
+    set = valuePop(ctxt);
+    if (set->type == XPATH_NODESET) {
+	xmlXPathObjectPtr tmp;
+
+	/*
+	 * First convert to a location set
+	 */
+	tmp = xmlXPtrNewLocationSetNodeSet(set->nodesetval);
+	xmlXPathFreeObject(set);
+	set = tmp;
+    }
+    oldset = (xmlLocationSetPtr) set->user;
+
+    /*
+     * The loop is to compute the covering range for each item and add it
+     */
+    newset = xmlXPtrLocationSetCreate(NULL);
+    for (i = 0;i < oldset->locNr;i++) {
+	xmlXPtrLocationSetAdd(newset,
+		xmlXPtrInsideRange(ctxt, oldset->locTab[i]));
+    }
+
+    /*
+     * Save the new value and cleanup
+     */
+    valuePush(ctxt, xmlXPtrWrapLocationSet(newset));
+    xmlXPathFreeObject(set);
+}
+
+/**
+ * xmlXPtrRangeToFunction:
+ * @ctxt:  the XPointer Parser context
+ * @nargs:  the number of args
+ *
+ * Implement the range-to() XPointer function
+ */
+void
+xmlXPtrRangeToFunction(xmlXPathParserContextPtr ctxt, int nargs) {
+    xmlXPathObjectPtr range;
+    const xmlChar *cur;
+    xmlXPathObjectPtr res, obj;
+    xmlXPathObjectPtr tmp;
+    xmlLocationSetPtr newset = NULL;
+    xmlNodeSetPtr oldset;
+    int i;
+
+    CHECK_ARITY(1);
+    /*
+     * Save the expression pointer since we will have to evaluate
+     * it multiple times. Initialize the new set.
+     */
+    CHECK_TYPE(XPATH_NODESET);
+    obj = valuePop(ctxt);
+    oldset = obj->nodesetval;
+    ctxt->context->node = NULL;
+
+    cur = ctxt->cur;
+    newset = xmlXPtrLocationSetCreate(NULL);
+    
+    for (i = 0; i < oldset->nodeNr; i++) {
+	ctxt->cur = cur;
+
+	/*
+	 * Run the evaluation with a node list made of a single item
+	 * in the nodeset.
+	 */
+	ctxt->context->node = oldset->nodeTab[i];
+	tmp = xmlXPathNewNodeSet(ctxt->context->node);
+	valuePush(ctxt, tmp);
+
+	xmlXPathEvalExpr(ctxt);
+	CHECK_ERROR;
+
+	/*
+	 * The result of the evaluation need to be tested to
+	 * decided whether the filter succeeded or not
+	 */
+	res = valuePop(ctxt);
+	range = xmlXPtrNewRangeNodeObject(oldset->nodeTab[i], res);
+	if (range != NULL) {
+	    xmlXPtrLocationSetAdd(newset, range);
+	}
+
+	/*
+	 * Cleanup
+	 */
+	if (res != NULL)
+	    xmlXPathFreeObject(res);
+	if (ctxt->value == tmp) {
+	    res = valuePop(ctxt);
+	    xmlXPathFreeObject(res);
+	}
+	
+	ctxt->context->node = NULL;
+    }
+
+    /*
+     * The result is used as the new evaluation set.
+     */
+    xmlXPathFreeObject(obj);
+    ctxt->context->node = NULL;
+    ctxt->context->contextSize = -1;
+    ctxt->context->proximityPosition = -1;
+    valuePush(ctxt, xmlXPtrWrapLocationSet(newset));
+}
+
+/**
+ * xmlXPtrAdvanceNode:
+ * @cur:  the node
+ * @level: incremented/decremented to show level in tree
+ *
+ * Advance to the next element or text node in document order
+ * TODO: add a stack for entering/exiting entities 
+ *
+ * Returns -1 in case of failure, 0 otherwise
+ */
+xmlNodePtr
+xmlXPtrAdvanceNode(xmlNodePtr cur, int *level) {
+next:
+    if (cur == NULL)
+	return(NULL);
+    if (cur->children != NULL) {
+        cur = cur->children ;
+	if (level != NULL)
+	    (*level)++;
+	goto found;
+    }
+skip:		/* This label should only be needed if something is wrong! */
+    if (cur->next != NULL) {
+	cur = cur->next;
+	goto found;
+    }
+    do {
+        cur = cur->parent;
+	if (level != NULL)
+	    (*level)--;
+        if (cur == NULL) return(NULL);
+        if (cur->next != NULL) {
+	    cur = cur->next;
+	    goto found;
+	}
+    } while (cur != NULL);
+
+found:
+    if ((cur->type != XML_ELEMENT_NODE) &&
+	(cur->type != XML_TEXT_NODE) &&
+	(cur->type != XML_DOCUMENT_NODE) &&
+	(cur->type != XML_HTML_DOCUMENT_NODE) &&
+	(cur->type != XML_CDATA_SECTION_NODE)) {
+	    if (cur->type == XML_ENTITY_REF_NODE) {	/* Shouldn't happen */
+		TODO
+		goto skip;
+	    }
+	    goto next;
+	}
+    return(cur);
+}
+
+/**
+ * xmlXPtrAdvanceChar:
+ * @node:  the node
+ * @indx:  the indx
+ * @bytes:  the number of bytes
+ *
+ * Advance a point of the associated number of bytes (not UTF8 chars)
+ *
+ * Returns -1 in case of failure, 0 otherwise
+ */
+static int
+xmlXPtrAdvanceChar(xmlNodePtr *node, int *indx, int bytes) {
+    xmlNodePtr cur;
+    int pos;
+    int len;
+
+    if ((node == NULL) || (indx == NULL))
+	return(-1);
+    cur = *node;
+    if (cur == NULL)
+	return(-1);
+    pos = *indx;
+
+    while (bytes >= 0) {
+	/*
+	 * First position to the beginning of the first text node
+	 * corresponding to this point
+	 */
+	while ((cur != NULL) &&
+	       ((cur->type == XML_ELEMENT_NODE) ||
+	        (cur->type == XML_DOCUMENT_NODE) ||
+	        (cur->type == XML_HTML_DOCUMENT_NODE))) {
+	    if (pos > 0) {
+		cur = xmlXPtrGetNthChild(cur, pos);
+		pos = 0;
+	    } else {
+		cur = xmlXPtrAdvanceNode(cur, NULL);
+		pos = 0;
+	    }
+	}
+
+	if (cur == NULL) {
+	    *node = NULL;
+	    *indx = 0;
+	    return(-1);
+	}
+
+	/*
+	 * if there is no move needed return the current value.
+	 */
+	if (pos == 0) pos = 1;
+	if (bytes == 0) {
+	    *node = cur;
+	    *indx = pos;
+	    return(0);
+	}
+	/*
+	 * We should have a text (or cdata) node ... 
+	 */
+	len = 0;
+	if ((cur->type != XML_ELEMENT_NODE) &&
+            (cur->content != NULL)) {
+	    len = xmlStrlen(cur->content);
+	}
+	if (pos > len) {
+	    /* Strange, the indx in the text node is greater than it's len */
+	    STRANGE
+	    pos = len;
+	}
+	if (pos + bytes >= len) {
+	    bytes -= (len - pos);
+	    cur = xmlXPtrAdvanceNode(cur, NULL);
+	    cur = 0;
+	} else if (pos + bytes < len) {
+	    pos += bytes;
+	    *node = cur;
+	    *indx = pos;
+	    return(0);
+	}
+    }
+    return(-1);
+}
+
+/**
+ * xmlXPtrMatchString:
+ * @string:  the string to search
+ * @start:  the start textnode
+ * @startindex:  the start index
+ * @end:  the end textnode IN/OUT
+ * @endindex:  the end index IN/OUT
+ *
+ * Check whether the document contains @string at the position
+ * (@start, @startindex) and limited by the (@end, @endindex) point
+ *
+ * Returns -1 in case of failure, 0 if not found, 1 if found in which case
+ *            (@start, @startindex) will indicate the position of the beginning
+ *            of the range and (@end, @endindex) will indicate the end
+ *            of the range
+ */
+static int
+xmlXPtrMatchString(const xmlChar *string, xmlNodePtr start, int startindex,
+	            xmlNodePtr *end, int *endindex) {
+    xmlNodePtr cur;
+    int pos; /* 0 based */
+    int len; /* in bytes */
+    int stringlen; /* in bytes */
+    int match;
+
+    if (string == NULL)
+	return(-1);
+    if (start == NULL)
+	return(-1);
+    if ((end == NULL) || (endindex == NULL))
+	return(-1);
+    cur = start;
+    if (cur == NULL)
+	return(-1);
+    pos = startindex - 1;
+    stringlen = xmlStrlen(string);
+
+    while (stringlen > 0) {
+	if ((cur == *end) && (pos + stringlen > *endindex))
+	    return(0);
+
+	if ((cur->type != XML_ELEMENT_NODE) && (cur->content != NULL)) {
+	    len = xmlStrlen(cur->content);
+	    if (len >= pos + stringlen) {
+		match = (!xmlStrncmp(&cur->content[pos], string, stringlen));
+		if (match) {
+#ifdef DEBUG_RANGES
+		    xmlGenericError(xmlGenericErrorContext,
+			    "found range %d bytes at index %d of ->",
+			    stringlen, pos + 1);
+		    xmlDebugDumpString(stdout, cur->content);
+		    xmlGenericError(xmlGenericErrorContext, "\n");
+#endif
+		    *end = cur;
+		    *endindex = pos + stringlen;
+		    return(1);
+		} else {
+		    return(0);
+		}
+	    } else {
+                int sub = len - pos;
+		match = (!xmlStrncmp(&cur->content[pos], string, sub));
+		if (match) {
+#ifdef DEBUG_RANGES
+		    xmlGenericError(xmlGenericErrorContext,
+			    "found subrange %d bytes at index %d of ->",
+			    sub, pos + 1);
+		    xmlDebugDumpString(stdout, cur->content);
+		    xmlGenericError(xmlGenericErrorContext, "\n");
+#endif
+                    string = &string[sub];
+		    stringlen -= sub;
+		} else {
+		    return(0);
+		}
+	    }
+	}
+	cur = xmlXPtrAdvanceNode(cur, NULL);
+	if (cur == NULL)
+	    return(0);
+	pos = 0;
+    }
+    return(1);
+}
+
+/**
+ * xmlXPtrSearchString:
+ * @string:  the string to search
+ * @start:  the start textnode IN/OUT
+ * @startindex:  the start index IN/OUT
+ * @end:  the end textnode
+ * @endindex:  the end index
+ *
+ * Search the next occurrence of @string within the document content
+ * until the (@end, @endindex) point is reached
+ *
+ * Returns -1 in case of failure, 0 if not found, 1 if found in which case
+ *            (@start, @startindex) will indicate the position of the beginning
+ *            of the range and (@end, @endindex) will indicate the end
+ *            of the range
+ */
+static int
+xmlXPtrSearchString(const xmlChar *string, xmlNodePtr *start, int *startindex,
+	            xmlNodePtr *end, int *endindex) {
+    xmlNodePtr cur;
+    const xmlChar *str;
+    int pos; /* 0 based */
+    int len; /* in bytes */
+    xmlChar first;
+
+    if (string == NULL)
+	return(-1);
+    if ((start == NULL) || (startindex == NULL))
+	return(-1);
+    if ((end == NULL) || (endindex == NULL))
+	return(-1);
+    cur = *start;
+    if (cur == NULL)
+	return(-1);
+    pos = *startindex - 1;
+    first = string[0];
+
+    while (cur != NULL) {
+	if ((cur->type != XML_ELEMENT_NODE) && (cur->content != NULL)) {
+	    len = xmlStrlen(cur->content);
+	    while (pos <= len) {
+		if (first != 0) {
+		    str = xmlStrchr(&cur->content[pos], first);
+		    if (str != NULL) {
+			pos = (str - (xmlChar *)(cur->content));
+#ifdef DEBUG_RANGES
+			xmlGenericError(xmlGenericErrorContext,
+				"found '%c' at index %d of ->",
+				first, pos + 1);
+			xmlDebugDumpString(stdout, cur->content);
+			xmlGenericError(xmlGenericErrorContext, "\n");
+#endif
+			if (xmlXPtrMatchString(string, cur, pos + 1,
+					       end, endindex)) {
+			    *start = cur;
+			    *startindex = pos + 1;
+			    return(1);
+			}
+			pos++;
+		    } else {
+			pos = len + 1;
+		    }
+		} else {
+		    /*
+		     * An empty string is considered to match before each
+		     * character of the string-value and after the final
+		     * character. 
+		     */
+#ifdef DEBUG_RANGES
+		    xmlGenericError(xmlGenericErrorContext,
+			    "found '' at index %d of ->",
+			    pos + 1);
+		    xmlDebugDumpString(stdout, cur->content);
+		    xmlGenericError(xmlGenericErrorContext, "\n");
+#endif
+		    *start = cur;
+		    *startindex = pos + 1;
+		    *end = cur;
+		    *endindex = pos + 1;
+		    return(1);
+		}
+	    }
+	}
+	if ((cur == *end) && (pos >= *endindex))
+	    return(0);
+	cur = xmlXPtrAdvanceNode(cur, NULL);
+	if (cur == NULL)
+	    return(0);
+	pos = 1;
+    }
+    return(0);
+}
+
+/**
+ * xmlXPtrGetLastChar:
+ * @node:  the node
+ * @index:  the index
+ *
+ * Computes the point coordinates of the last char of this point
+ *
+ * Returns -1 in case of failure, 0 otherwise
+ */
+static int
+xmlXPtrGetLastChar(xmlNodePtr *node, int *indx) {
+    xmlNodePtr cur;
+    int pos, len = 0;
+
+    if ((node == NULL) || (indx == NULL))
+	return(-1);
+    cur = *node;
+    pos = *indx;
+
+    if (cur == NULL)
+	return(-1);
+    
+    if ((cur->type == XML_ELEMENT_NODE) ||
+	(cur->type == XML_DOCUMENT_NODE) ||
+	(cur->type == XML_HTML_DOCUMENT_NODE)) {
+	if (pos > 0) {
+	    cur = xmlXPtrGetNthChild(cur, pos);
+	    pos = 0;
+	}
+    }
+    while (cur != NULL) {
+	if (cur->last != NULL)
+	    cur = cur->last;
+	else if ((cur->type != XML_ELEMENT_NODE) &&
+	         (cur->content != NULL)) {
+	    len = xmlStrlen(cur->content);
+	    break;
+	} else {
+	    return(-1);
+	}
+    }
+    if (cur == NULL)
+	return(-1);
+    *node = cur;
+    *indx = len;
+    return(0);
+}
+
+/**
+ * xmlXPtrGetStartPoint:
+ * @obj:  an range
+ * @node:  the resulting node
+ * @indx:  the resulting index
+ *
+ * read the object and return the start point coordinates.
+ *
+ * Returns -1 in case of failure, 0 otherwise
+ */
+static int
+xmlXPtrGetStartPoint(xmlXPathObjectPtr obj, xmlNodePtr *node, int *indx) {
+    if ((obj == NULL) || (node == NULL) || (indx == NULL))
+	return(-1);
+
+    switch (obj->type) {
+        case XPATH_POINT:
+	    *node = obj->user;
+	    if (obj->index <= 0)
+		*indx = 0;
+	    else
+		*indx = obj->index;
+	    return(0);
+        case XPATH_RANGE:
+	    *node = obj->user;
+	    if (obj->index <= 0)
+		*indx = 0;
+	    else
+		*indx = obj->index;
+	    return(0);
+	default:
+	    break;
+    }
+    return(-1);
+}
+
+/**
+ * xmlXPtrGetEndPoint:
+ * @obj:  an range
+ * @node:  the resulting node
+ * @indx:  the resulting indx
+ *
+ * read the object and return the end point coordinates.
+ *
+ * Returns -1 in case of failure, 0 otherwise
+ */
+static int
+xmlXPtrGetEndPoint(xmlXPathObjectPtr obj, xmlNodePtr *node, int *indx) {
+    if ((obj == NULL) || (node == NULL) || (indx == NULL))
+	return(-1);
+
+    switch (obj->type) {
+        case XPATH_POINT:
+	    *node = obj->user;
+	    if (obj->index <= 0)
+		*indx = 0;
+	    else
+		*indx = obj->index;
+	    return(0);
+        case XPATH_RANGE:
+	    *node = obj->user;
+	    if (obj->index <= 0)
+		*indx = 0;
+	    else
+		*indx = obj->index;
+	    return(0);
+	default:
+	    break;
+    }
+    return(-1);
+}
+
+/**
+ * xmlXPtrStringRangeFunction:
+ * @ctxt:  the XPointer Parser context
+ * @nargs:  the number of args
+ *
+ * Function implementing the string-range() function
+ * range as described in 5.4.2 
+ *
+ * ------------------------------
+ * [Definition: For each location in the location-set argument,
+ * string-range returns a set of string ranges, a set of substrings in a
+ * string. Specifically, the string-value of the location is searched for
+ * substrings that match the string argument, and the resulting location-set
+ * will contain a range location for each non-overlapping match.]
+ * An empty string is considered to match before each character of the
+ * string-value and after the final character. Whitespace in a string
+ * is matched literally, with no normalization except that provided by
+ * XML for line ends. The third argument gives the position of the first
+ * character to be in the resulting range, relative to the start of the
+ * match. The default value is 1, which makes the range start immediately
+ * before the first character of the matched string. The fourth argument
+ * gives the number of characters in the range; the default is that the
+ * range extends to the end of the matched string.
+ *
+ * Element boundaries, as well as entire embedded nodes such as processing
+ * instructions and comments, are ignored as defined in [XPath].
+ *
+ * If the string in the second argument is not found in the string-value
+ * of the location, or if a value in the third or fourth argument indicates
+ * a string that is beyond the beginning or end of the document, the
+ * expression fails.
+ *
+ * The points of the range-locations in the returned location-set will
+ * all be character points.
+ * ------------------------------
+ */
+void
+xmlXPtrStringRangeFunction(xmlXPathParserContextPtr ctxt, int nargs) {
+    int i, startindex, endindex, fendindex;
+    xmlNodePtr start, end, fend;
+    xmlXPathObjectPtr set;
+    xmlLocationSetPtr oldset;
+    xmlLocationSetPtr newset;
+    xmlXPathObjectPtr string;
+    xmlXPathObjectPtr position = NULL;
+    xmlXPathObjectPtr number = NULL;
+    int found, pos = 0, num = 0;
+
+    /*
+     * Grab the arguments
+     */
+    if ((nargs < 2) || (nargs > 4))
+	XP_ERROR(XPATH_INVALID_ARITY);
+
+    if (nargs >= 4) {
+	CHECK_TYPE(XPATH_NUMBER);
+	number = valuePop(ctxt);
+	if (number != NULL)
+	    num = (int) number->floatval;
+    }
+    if (nargs >= 3) {
+	CHECK_TYPE(XPATH_NUMBER);
+	position = valuePop(ctxt);
+	if (position != NULL)
+	    pos = (int) position->floatval;
+    }
+    CHECK_TYPE(XPATH_STRING);
+    string = valuePop(ctxt);
+    if ((ctxt->value == NULL) ||
+	((ctxt->value->type != XPATH_LOCATIONSET) &&
+	 (ctxt->value->type != XPATH_NODESET)))
+        XP_ERROR(XPATH_INVALID_TYPE)
+
+    set = valuePop(ctxt);
+    newset = xmlXPtrLocationSetCreate(NULL);
+    if (set->nodesetval == NULL) {
+        goto error;
+    }
+    if (set->type == XPATH_NODESET) {
+	xmlXPathObjectPtr tmp;
+
+	/*
+	 * First convert to a location set
+	 */
+	tmp = xmlXPtrNewLocationSetNodeSet(set->nodesetval);
+	xmlXPathFreeObject(set);
+	set = tmp;
+    }
+    oldset = (xmlLocationSetPtr) set->user;
+
+    /*
+     * The loop is to search for each element in the location set
+     * the list of location set corresponding to that search
+     */
+    for (i = 0;i < oldset->locNr;i++) {
+#ifdef DEBUG_RANGES
+	xmlXPathDebugDumpObject(stdout, oldset->locTab[i], 0);
+#endif
+
+	xmlXPtrGetStartPoint(oldset->locTab[i], &start, &startindex);
+	xmlXPtrGetEndPoint(oldset->locTab[i], &end, &endindex);
+	xmlXPtrAdvanceChar(&start, &startindex, 0);
+	xmlXPtrGetLastChar(&end, &endindex);
+
+#ifdef DEBUG_RANGES
+	xmlGenericError(xmlGenericErrorContext,
+		"from index %d of ->", startindex);
+	xmlDebugDumpString(stdout, start->content);
+	xmlGenericError(xmlGenericErrorContext, "\n");
+	xmlGenericError(xmlGenericErrorContext,
+		"to index %d of ->", endindex);
+	xmlDebugDumpString(stdout, end->content);
+	xmlGenericError(xmlGenericErrorContext, "\n");
+#endif
+	do {
+            fend = end;
+            fendindex = endindex;
+	    found = xmlXPtrSearchString(string->stringval, &start, &startindex,
+		                        &fend, &fendindex);
+	    if (found == 1) {
+		if (position == NULL) {
+		    xmlXPtrLocationSetAdd(newset,
+			 xmlXPtrNewRange(start, startindex, fend, fendindex));
+		} else if (xmlXPtrAdvanceChar(&start, &startindex,
+			                      pos - 1) == 0) {
+		    if ((number != NULL) && (num > 0)) {
+			int rindx;
+			xmlNodePtr rend;
+			rend = start;
+			rindx = startindex - 1;
+			if (xmlXPtrAdvanceChar(&rend, &rindx,
+				               num) == 0) {
+			    xmlXPtrLocationSetAdd(newset,
+					xmlXPtrNewRange(start, startindex,
+							rend, rindx));
+			}
+		    } else if ((number != NULL) && (num <= 0)) {
+			xmlXPtrLocationSetAdd(newset,
+				    xmlXPtrNewRange(start, startindex,
+						    start, startindex));
+		    } else {
+			xmlXPtrLocationSetAdd(newset,
+				    xmlXPtrNewRange(start, startindex,
+						    fend, fendindex));
+		    }
+		}
+		start = fend;
+		startindex = fendindex;
+		if (string->stringval[0] == 0)
+		    startindex++;
+	    }
+	} while (found == 1);
+    }
+
+    /*
+     * Save the new value and cleanup
+     */
+error:
+    valuePush(ctxt, xmlXPtrWrapLocationSet(newset));
+    xmlXPathFreeObject(set);
+    xmlXPathFreeObject(string);
+    if (position) xmlXPathFreeObject(position);
+    if (number) xmlXPathFreeObject(number);
+}
+
+/**
+ * xmlXPtrEvalRangePredicate:
+ * @ctxt:  the XPointer Parser context
+ *
+ *  [8]   Predicate ::=   '[' PredicateExpr ']'
+ *  [9]   PredicateExpr ::=   Expr 
+ *
+ * Evaluate a predicate as in xmlXPathEvalPredicate() but for
+ * a Location Set instead of a node set
+ */
+void
+xmlXPtrEvalRangePredicate(xmlXPathParserContextPtr ctxt) {
+    const xmlChar *cur;
+    xmlXPathObjectPtr res;
+    xmlXPathObjectPtr obj, tmp;
+    xmlLocationSetPtr newset = NULL;
+    xmlLocationSetPtr oldset;
+    int i;
+
+    SKIP_BLANKS;
+    if (CUR != '[') {
+	XP_ERROR(XPATH_INVALID_PREDICATE_ERROR);
+    }
+    NEXT;
+    SKIP_BLANKS;
+
+    /*
+     * Extract the old set, and then evaluate the result of the
+     * expression for all the element in the set. use it to grow
+     * up a new set.
+     */
+    CHECK_TYPE(XPATH_LOCATIONSET);
+    obj = valuePop(ctxt);
+    oldset = obj->user;
+    ctxt->context->node = NULL;
+
+    if ((oldset == NULL) || (oldset->locNr == 0)) {
+	ctxt->context->contextSize = 0;
+	ctxt->context->proximityPosition = 0;
+	xmlXPathEvalExpr(ctxt);
+	res = valuePop(ctxt);
+	if (res != NULL)
+	    xmlXPathFreeObject(res);
+	valuePush(ctxt, obj);
+	CHECK_ERROR;
+    } else {
+	/*
+	 * Save the expression pointer since we will have to evaluate
+	 * it multiple times. Initialize the new set.
+	 */
+        cur = ctxt->cur;
+	newset = xmlXPtrLocationSetCreate(NULL);
+	
+        for (i = 0; i < oldset->locNr; i++) {
+	    ctxt->cur = cur;
+
+	    /*
+	     * Run the evaluation with a node list made of a single item
+	     * in the nodeset.
+	     */
+	    ctxt->context->node = oldset->locTab[i]->user;
+	    tmp = xmlXPathNewNodeSet(ctxt->context->node);
+	    valuePush(ctxt, tmp);
+	    ctxt->context->contextSize = oldset->locNr;
+	    ctxt->context->proximityPosition = i + 1;
+
+	    xmlXPathEvalExpr(ctxt);
+	    CHECK_ERROR;
+
+	    /*
+	     * The result of the evaluation need to be tested to
+	     * decided whether the filter succeeded or not
+	     */
+	    res = valuePop(ctxt);
+	    if (xmlXPathEvaluatePredicateResult(ctxt, res)) {
+	        xmlXPtrLocationSetAdd(newset,
+			xmlXPathObjectCopy(oldset->locTab[i]));
+	    }
+
+	    /*
+	     * Cleanup
+	     */
+	    if (res != NULL)
+		xmlXPathFreeObject(res);
+	    if (ctxt->value == tmp) {
+		res = valuePop(ctxt);
+		xmlXPathFreeObject(res);
+	    }
+	    
+	    ctxt->context->node = NULL;
+	}
+
+	/*
+	 * The result is used as the new evaluation set.
+	 */
+	xmlXPathFreeObject(obj);
+	ctxt->context->node = NULL;
+	ctxt->context->contextSize = -1;
+	ctxt->context->proximityPosition = -1;
+	valuePush(ctxt, xmlXPtrWrapLocationSet(newset));
+    }
+    if (CUR != ']') {
+	XP_ERROR(XPATH_INVALID_PREDICATE_ERROR);
+    }
+
+    NEXT;
+    SKIP_BLANKS;
+}
+
+#else
+#endif
+
diff --git a/src/libz/include/zconf.h b/src/libz/include/zconf.h
new file mode 100644
index 0000000..97f6f10
--- /dev/null
+++ b/src/libz/include/zconf.h
@@ -0,0 +1,279 @@
+/* zconf.h -- configuration of the zlib compression library
+ * Copyright (C) 1995-2002 Jean-loup Gailly.
+ * For conditions of distribution and use, see copyright notice in zlib.h 
+ */
+
+/* @(#) $Id: zconf.h,v 1.1 2008/11/12 02:25:24 agibert Exp $ */
+
+#ifndef _ZCONF_H
+#define _ZCONF_H
+
+/*
+ * If you *really* need a unique prefix for all types and library functions,
+ * compile with -DZ_PREFIX. The "standard" zlib should be compiled without it.
+ */
+#ifdef Z_PREFIX
+#  define deflateInit_	z_deflateInit_
+#  define deflate	z_deflate
+#  define deflateEnd	z_deflateEnd
+#  define inflateInit_ 	z_inflateInit_
+#  define inflate	z_inflate
+#  define inflateEnd	z_inflateEnd
+#  define deflateInit2_	z_deflateInit2_
+#  define deflateSetDictionary z_deflateSetDictionary
+#  define deflateCopy	z_deflateCopy
+#  define deflateReset	z_deflateReset
+#  define deflateParams	z_deflateParams
+#  define inflateInit2_	z_inflateInit2_
+#  define inflateSetDictionary z_inflateSetDictionary
+#  define inflateSync	z_inflateSync
+#  define inflateSyncPoint z_inflateSyncPoint
+#  define inflateReset	z_inflateReset
+#  define compress	z_compress
+#  define compress2	z_compress2
+#  define uncompress	z_uncompress
+#  define adler32	z_adler32
+#  define crc32		z_crc32
+#  define get_crc_table z_get_crc_table
+
+#  define Byte		z_Byte
+#  define uInt		z_uInt
+#  define uLong		z_uLong
+#  define Bytef	        z_Bytef
+#  define charf		z_charf
+#  define intf		z_intf
+#  define uIntf		z_uIntf
+#  define uLongf	z_uLongf
+#  define voidpf	z_voidpf
+#  define voidp		z_voidp
+#endif
+
+#if (defined(_WIN32) || defined(__WIN32__)) && !defined(WIN32)
+#  define WIN32
+#endif
+#if defined(__GNUC__) || defined(WIN32) || defined(__386__) || defined(i386)
+#  ifndef __32BIT__
+#    define __32BIT__
+#  endif
+#endif
+#if defined(__MSDOS__) && !defined(MSDOS)
+#  define MSDOS
+#endif
+
+/*
+ * Compile with -DMAXSEG_64K if the alloc function cannot allocate more
+ * than 64k bytes at a time (needed on systems with 16-bit int).
+ */
+#if defined(MSDOS) && !defined(__32BIT__)
+#  define MAXSEG_64K
+#endif
+#ifdef MSDOS
+#  define UNALIGNED_OK
+#endif
+
+#if (defined(MSDOS) || defined(_WINDOWS) || defined(WIN32))  && !defined(STDC)
+#  define STDC
+#endif
+#if defined(__STDC__) || defined(__cplusplus) || defined(__OS2__)
+#  ifndef STDC
+#    define STDC
+#  endif
+#endif
+
+#ifndef STDC
+#  ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */
+#    define const
+#  endif
+#endif
+
+/* Some Mac compilers merge all .h files incorrectly: */
+#if defined(__MWERKS__) || defined(applec) ||defined(THINK_C) ||defined(__SC__)
+#  define NO_DUMMY_DECL
+#endif
+
+/* Old Borland C incorrectly complains about missing returns: */
+#if defined(__BORLANDC__) && (__BORLANDC__ < 0x500)
+#  define NEED_DUMMY_RETURN
+#endif
+
+
+/* Maximum value for memLevel in deflateInit2 */
+#ifndef MAX_MEM_LEVEL
+#  ifdef MAXSEG_64K
+#    define MAX_MEM_LEVEL 8
+#  else
+#    define MAX_MEM_LEVEL 9
+#  endif
+#endif
+
+/* Maximum value for windowBits in deflateInit2 and inflateInit2.
+ * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files
+ * created by gzip. (Files created by minigzip can still be extracted by
+ * gzip.)
+ */
+#ifndef MAX_WBITS
+#  define MAX_WBITS   15 /* 32K LZ77 window */
+#endif
+
+/* The memory requirements for deflate are (in bytes):
+            (1 << (windowBits+2)) +  (1 << (memLevel+9))
+ that is: 128K for windowBits=15  +  128K for memLevel = 8  (default values)
+ plus a few kilobytes for small objects. For example, if you want to reduce
+ the default memory requirements from 256K to 128K, compile with
+     make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7"
+ Of course this will generally degrade compression (there's no free lunch).
+
+   The memory requirements for inflate are (in bytes) 1 << windowBits
+ that is, 32K for windowBits=15 (default value) plus a few kilobytes
+ for small objects.
+*/
+
+                        /* Type declarations */
+
+#ifndef OF /* function prototypes */
+#  ifdef STDC
+#    define OF(args)  args
+#  else
+#    define OF(args)  ()
+#  endif
+#endif
+
+/* The following definitions for FAR are needed only for MSDOS mixed
+ * model programming (small or medium model with some far allocations).
+ * This was tested only with MSC; for other MSDOS compilers you may have
+ * to define NO_MEMCPY in zutil.h.  If you don't need the mixed model,
+ * just define FAR to be empty.
+ */
+#if (defined(M_I86SM) || defined(M_I86MM)) && !defined(__32BIT__)
+   /* MSC small or medium model */
+#  define SMALL_MEDIUM
+#  ifdef _MSC_VER
+#    define FAR _far
+#  else
+#    define FAR far
+#  endif
+#endif
+#if defined(__BORLANDC__) && (defined(__SMALL__) || defined(__MEDIUM__))
+#  ifndef __32BIT__
+#    define SMALL_MEDIUM
+#    define FAR _far
+#  endif
+#endif
+
+/* Compile with -DZLIB_DLL for Windows DLL support */
+#if defined(ZLIB_DLL)
+#  if defined(_WINDOWS) || defined(WINDOWS)
+#    ifdef FAR
+#      undef FAR
+#    endif
+#    include <windows.h>
+#    define ZEXPORT  WINAPI
+#    ifdef WIN32
+#      define ZEXPORTVA  WINAPIV
+#    else
+#      define ZEXPORTVA  FAR _cdecl _export
+#    endif
+#  endif
+#  if defined (__BORLANDC__)
+#    if (__BORLANDC__ >= 0x0500) && defined (WIN32)
+#      include <windows.h>
+#      define ZEXPORT __declspec(dllexport) WINAPI
+#      define ZEXPORTRVA __declspec(dllexport) WINAPIV
+#    else
+#      if defined (_Windows) && defined (__DLL__)
+#        define ZEXPORT _export
+#        define ZEXPORTVA _export
+#      endif
+#    endif
+#  endif
+#endif
+
+#if defined (__BEOS__)
+#  if defined (ZLIB_DLL)
+#    define ZEXTERN extern __declspec(dllexport)
+#  else
+#    define ZEXTERN extern __declspec(dllimport)
+#  endif
+#endif
+
+#ifndef ZEXPORT
+#  define ZEXPORT
+#endif
+#ifndef ZEXPORTVA
+#  define ZEXPORTVA
+#endif
+#ifndef ZEXTERN
+#  define ZEXTERN extern
+#endif
+
+#ifndef FAR
+#   define FAR
+#endif
+
+#if !defined(MACOS) && !defined(TARGET_OS_MAC)
+typedef unsigned char  Byte;  /* 8 bits */
+#endif
+typedef unsigned int   uInt;  /* 16 bits or more */
+typedef unsigned long  uLong; /* 32 bits or more */
+
+#ifdef SMALL_MEDIUM
+   /* Borland C/C++ and some old MSC versions ignore FAR inside typedef */
+#  define Bytef Byte FAR
+#else
+   typedef Byte  FAR Bytef;
+#endif
+typedef char  FAR charf;
+typedef int   FAR intf;
+typedef uInt  FAR uIntf;
+typedef uLong FAR uLongf;
+
+#ifdef STDC
+   typedef void FAR *voidpf;
+   typedef void     *voidp;
+#else
+   typedef Byte FAR *voidpf;
+   typedef Byte     *voidp;
+#endif
+
+#ifdef HAVE_UNISTD_H
+#  include <sys/types.h> /* for off_t */
+#  include <unistd.h>    /* for SEEK_* and off_t */
+#  define z_off_t  off_t
+#endif
+#ifndef SEEK_SET
+#  define SEEK_SET        0       /* Seek from beginning of file.  */
+#  define SEEK_CUR        1       /* Seek from current position.  */
+#  define SEEK_END        2       /* Set file pointer to EOF plus "offset" */
+#endif
+#ifndef z_off_t
+#  define  z_off_t long
+#endif
+
+/* MVS linker does not support external names larger than 8 bytes */
+#if defined(__MVS__)
+#   pragma map(deflateInit_,"DEIN")
+#   pragma map(deflateInit2_,"DEIN2")
+#   pragma map(deflateEnd,"DEEND")
+#   pragma map(inflateInit_,"ININ")
+#   pragma map(inflateInit2_,"ININ2")
+#   pragma map(inflateEnd,"INEND")
+#   pragma map(inflateSync,"INSY")
+#   pragma map(inflateSetDictionary,"INSEDI")
+#   pragma map(inflate_blocks,"INBL")
+#   pragma map(inflate_blocks_new,"INBLNE")
+#   pragma map(inflate_blocks_free,"INBLFR")
+#   pragma map(inflate_blocks_reset,"INBLRE")
+#   pragma map(inflate_codes_free,"INCOFR")
+#   pragma map(inflate_codes,"INCO")
+#   pragma map(inflate_fast,"INFA")
+#   pragma map(inflate_flush,"INFLU")
+#   pragma map(inflate_mask,"INMA")
+#   pragma map(inflate_set_dictionary,"INSEDI2")
+#   pragma map(inflate_copyright,"INCOPY")
+#   pragma map(inflate_trees_bits,"INTRBI")
+#   pragma map(inflate_trees_dynamic,"INTRDY")
+#   pragma map(inflate_trees_fixed,"INTRFI")
+#   pragma map(inflate_trees_free,"INTRFR")
+#endif
+
+#endif /* _ZCONF_H */
diff --git a/src/libz/include/zlib.h b/src/libz/include/zlib.h
new file mode 100644
index 0000000..52cb529
--- /dev/null
+++ b/src/libz/include/zlib.h
@@ -0,0 +1,893 @@
+/* zlib.h -- interface of the 'zlib' general purpose compression library
+  version 1.1.4, March 11th, 2002
+
+  Copyright (C) 1995-2002 Jean-loup Gailly and Mark Adler
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
+  Jean-loup Gailly        Mark Adler
+  jloup@gzip.org          madler@alumni.caltech.edu
+
+
+  The data format used by the zlib library is described by RFCs (Request for
+  Comments) 1950 to 1952 in the files ftp://ds.internic.net/rfc/rfc1950.txt
+  (zlib format), rfc1951.txt (deflate format) and rfc1952.txt (gzip format).
+*/
+
+#ifndef _ZLIB_H
+#define _ZLIB_H
+
+#include "zconf.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define ZLIB_VERSION "1.1.4"
+
+/* 
+     The 'zlib' compression library provides in-memory compression and
+  decompression functions, including integrity checks of the uncompressed
+  data.  This version of the library supports only one compression method
+  (deflation) but other algorithms will be added later and will have the same
+  stream interface.
+
+     Compression can be done in a single step if the buffers are large
+  enough (for example if an input file is mmap'ed), or can be done by
+  repeated calls of the compression function.  In the latter case, the
+  application must provide more input and/or consume the output
+  (providing more output space) before each call.
+
+     The library also supports reading and writing files in gzip (.gz) format
+  with an interface similar to that of stdio.
+
+     The library does not install any signal handler. The decoder checks
+  the consistency of the compressed data, so the library should never
+  crash even in case of corrupted input.
+*/
+
+typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size));
+typedef void   (*free_func)  OF((voidpf opaque, voidpf address));
+
+struct internal_state;
+
+typedef struct z_stream_s {
+    Bytef    *next_in;  /* next input byte */
+    uInt     avail_in;  /* number of bytes available at next_in */
+    uLong    total_in;  /* total nb of input bytes read so far */
+
+    Bytef    *next_out; /* next output byte should be put there */
+    uInt     avail_out; /* remaining free space at next_out */
+    uLong    total_out; /* total nb of bytes output so far */
+
+    char     *msg;      /* last error message, NULL if no error */
+    struct internal_state FAR *state; /* not visible by applications */
+
+    alloc_func zalloc;  /* used to allocate the internal state */
+    free_func  zfree;   /* used to free the internal state */
+    voidpf     opaque;  /* private data object passed to zalloc and zfree */
+
+    int     data_type;  /* best guess about the data type: ascii or binary */
+    uLong   adler;      /* adler32 value of the uncompressed data */
+    uLong   reserved;   /* reserved for future use */
+} z_stream;
+
+typedef z_stream FAR *z_streamp;
+
+/*
+   The application must update next_in and avail_in when avail_in has
+   dropped to zero. It must update next_out and avail_out when avail_out
+   has dropped to zero. The application must initialize zalloc, zfree and
+   opaque before calling the init function. All other fields are set by the
+   compression library and must not be updated by the application.
+
+   The opaque value provided by the application will be passed as the first
+   parameter for calls of zalloc and zfree. This can be useful for custom
+   memory management. The compression library attaches no meaning to the
+   opaque value.
+
+   zalloc must return Z_NULL if there is not enough memory for the object.
+   If zlib is used in a multi-threaded application, zalloc and zfree must be
+   thread safe.
+
+   On 16-bit systems, the functions zalloc and zfree must be able to allocate
+   exactly 65536 bytes, but will not be required to allocate more than this
+   if the symbol MAXSEG_64K is defined (see zconf.h). WARNING: On MSDOS,
+   pointers returned by zalloc for objects of exactly 65536 bytes *must*
+   have their offset normalized to zero. The default allocation function
+   provided by this library ensures this (see zutil.c). To reduce memory
+   requirements and avoid any allocation of 64K objects, at the expense of
+   compression ratio, compile the library with -DMAX_WBITS=14 (see zconf.h).
+
+   The fields total_in and total_out can be used for statistics or
+   progress reports. After compression, total_in holds the total size of
+   the uncompressed data and may be saved for use in the decompressor
+   (particularly if the decompressor wants to decompress everything in
+   a single step).
+*/
+
+                        /* constants */
+
+#define Z_NO_FLUSH      0
+#define Z_PARTIAL_FLUSH 1 /* will be removed, use Z_SYNC_FLUSH instead */
+#define Z_SYNC_FLUSH    2
+#define Z_FULL_FLUSH    3
+#define Z_FINISH        4
+/* Allowed flush values; see deflate() below for details */
+
+#define Z_OK            0
+#define Z_STREAM_END    1
+#define Z_NEED_DICT     2
+#define Z_ERRNO        (-1)
+#define Z_STREAM_ERROR (-2)
+#define Z_DATA_ERROR   (-3)
+#define Z_MEM_ERROR    (-4)
+#define Z_BUF_ERROR    (-5)
+#define Z_VERSION_ERROR (-6)
+/* Return codes for the compression/decompression functions. Negative
+ * values are errors, positive values are used for special but normal events.
+ */
+
+#define Z_NO_COMPRESSION         0
+#define Z_BEST_SPEED             1
+#define Z_BEST_COMPRESSION       9
+#define Z_DEFAULT_COMPRESSION  (-1)
+/* compression levels */
+
+#define Z_FILTERED            1
+#define Z_HUFFMAN_ONLY        2
+#define Z_DEFAULT_STRATEGY    0
+/* compression strategy; see deflateInit2() below for details */
+
+#define Z_BINARY   0
+#define Z_ASCII    1
+#define Z_UNKNOWN  2
+/* Possible values of the data_type field */
+
+#define Z_DEFLATED   8
+/* The deflate compression method (the only one supported in this version) */
+
+#define Z_NULL  0  /* for initializing zalloc, zfree, opaque */
+
+#define zlib_version zlibVersion()
+/* for compatibility with versions < 1.0.2 */
+
+                        /* basic functions */
+
+ZEXTERN const char * ZEXPORT zlibVersion OF((void));
+/* The application can compare zlibVersion and ZLIB_VERSION for consistency.
+   If the first character differs, the library code actually used is
+   not compatible with the zlib.h header file used by the application.
+   This check is automatically made by deflateInit and inflateInit.
+ */
+
+/* 
+ZEXTERN int ZEXPORT deflateInit OF((z_streamp strm, int level));
+
+     Initializes the internal stream state for compression. The fields
+   zalloc, zfree and opaque must be initialized before by the caller.
+   If zalloc and zfree are set to Z_NULL, deflateInit updates them to
+   use default allocation functions.
+
+     The compression level must be Z_DEFAULT_COMPRESSION, or between 0 and 9:
+   1 gives best speed, 9 gives best compression, 0 gives no compression at
+   all (the input data is simply copied a block at a time).
+   Z_DEFAULT_COMPRESSION requests a default compromise between speed and
+   compression (currently equivalent to level 6).
+
+     deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not
+   enough memory, Z_STREAM_ERROR if level is not a valid compression level,
+   Z_VERSION_ERROR if the zlib library version (zlib_version) is incompatible
+   with the version assumed by the caller (ZLIB_VERSION).
+   msg is set to null if there is no error message.  deflateInit does not
+   perform any compression: this will be done by deflate().
+*/
+
+
+ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush));
+/*
+    deflate compresses as much data as possible, and stops when the input
+  buffer becomes empty or the output buffer becomes full. It may introduce some
+  output latency (reading input without producing any output) except when
+  forced to flush.
+
+    The detailed semantics are as follows. deflate performs one or both of the
+  following actions:
+
+  - Compress more input starting at next_in and update next_in and avail_in
+    accordingly. If not all input can be processed (because there is not
+    enough room in the output buffer), next_in and avail_in are updated and
+    processing will resume at this point for the next call of deflate().
+
+  - Provide more output starting at next_out and update next_out and avail_out
+    accordingly. This action is forced if the parameter flush is non zero.
+    Forcing flush frequently degrades the compression ratio, so this parameter
+    should be set only when necessary (in interactive applications).
+    Some output may be provided even if flush is not set.
+
+  Before the call of deflate(), the application should ensure that at least
+  one of the actions is possible, by providing more input and/or consuming
+  more output, and updating avail_in or avail_out accordingly; avail_out
+  should never be zero before the call. The application can consume the
+  compressed output when it wants, for example when the output buffer is full
+  (avail_out == 0), or after each call of deflate(). If deflate returns Z_OK
+  and with zero avail_out, it must be called again after making room in the
+  output buffer because there might be more output pending.
+
+    If the parameter flush is set to Z_SYNC_FLUSH, all pending output is
+  flushed to the output buffer and the output is aligned on a byte boundary, so
+  that the decompressor can get all input data available so far. (In particular
+  avail_in is zero after the call if enough output space has been provided
+  before the call.)  Flushing may degrade compression for some compression
+  algorithms and so it should be used only when necessary.
+
+    If flush is set to Z_FULL_FLUSH, all output is flushed as with
+  Z_SYNC_FLUSH, and the compression state is reset so that decompression can
+  restart from this point if previous compressed data has been damaged or if
+  random access is desired. Using Z_FULL_FLUSH too often can seriously degrade
+  the compression.
+
+    If deflate returns with avail_out == 0, this function must be called again
+  with the same value of the flush parameter and more output space (updated
+  avail_out), until the flush is complete (deflate returns with non-zero
+  avail_out).
+
+    If the parameter flush is set to Z_FINISH, pending input is processed,
+  pending output is flushed and deflate returns with Z_STREAM_END if there
+  was enough output space; if deflate returns with Z_OK, this function must be
+  called again with Z_FINISH and more output space (updated avail_out) but no
+  more input data, until it returns with Z_STREAM_END or an error. After
+  deflate has returned Z_STREAM_END, the only possible operations on the
+  stream are deflateReset or deflateEnd.
+  
+    Z_FINISH can be used immediately after deflateInit if all the compression
+  is to be done in a single step. In this case, avail_out must be at least
+  0.1% larger than avail_in plus 12 bytes.  If deflate does not return
+  Z_STREAM_END, then it must be called again as described above.
+
+    deflate() sets strm->adler to the adler32 checksum of all input read
+  so far (that is, total_in bytes).
+
+    deflate() may update data_type if it can make a good guess about
+  the input data type (Z_ASCII or Z_BINARY). In doubt, the data is considered
+  binary. This field is only for information purposes and does not affect
+  the compression algorithm in any manner.
+
+    deflate() returns Z_OK if some progress has been made (more input
+  processed or more output produced), Z_STREAM_END if all input has been
+  consumed and all output has been produced (only when flush is set to
+  Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example
+  if next_in or next_out was NULL), Z_BUF_ERROR if no progress is possible
+  (for example avail_in or avail_out was zero).
+*/
+
+
+ZEXTERN int ZEXPORT deflateEnd OF((z_streamp strm));
+/*
+     All dynamically allocated data structures for this stream are freed.
+   This function discards any unprocessed input and does not flush any
+   pending output.
+
+     deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the
+   stream state was inconsistent, Z_DATA_ERROR if the stream was freed
+   prematurely (some input or output was discarded). In the error case,
+   msg may be set but then points to a static string (which must not be
+   deallocated).
+*/
+
+
+/* 
+ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm));
+
+     Initializes the internal stream state for decompression. The fields
+   next_in, avail_in, zalloc, zfree and opaque must be initialized before by
+   the caller. If next_in is not Z_NULL and avail_in is large enough (the exact
+   value depends on the compression method), inflateInit determines the
+   compression method from the zlib header and allocates all data structures
+   accordingly; otherwise the allocation will be deferred to the first call of
+   inflate.  If zalloc and zfree are set to Z_NULL, inflateInit updates them to
+   use default allocation functions.
+
+     inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_VERSION_ERROR if the zlib library version is incompatible with the
+   version assumed by the caller.  msg is set to null if there is no error
+   message. inflateInit does not perform any decompression apart from reading
+   the zlib header if present: this will be done by inflate().  (So next_in and
+   avail_in may be modified, but next_out and avail_out are unchanged.)
+*/
+
+
+ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush));
+/*
+    inflate decompresses as much data as possible, and stops when the input
+  buffer becomes empty or the output buffer becomes full. It may some
+  introduce some output latency (reading input without producing any output)
+  except when forced to flush.
+
+  The detailed semantics are as follows. inflate performs one or both of the
+  following actions:
+
+  - Decompress more input starting at next_in and update next_in and avail_in
+    accordingly. If not all input can be processed (because there is not
+    enough room in the output buffer), next_in is updated and processing
+    will resume at this point for the next call of inflate().
+
+  - Provide more output starting at next_out and update next_out and avail_out
+    accordingly.  inflate() provides as much output as possible, until there
+    is no more input data or no more space in the output buffer (see below
+    about the flush parameter).
+
+  Before the call of inflate(), the application should ensure that at least
+  one of the actions is possible, by providing more input and/or consuming
+  more output, and updating the next_* and avail_* values accordingly.
+  The application can consume the uncompressed output when it wants, for
+  example when the output buffer is full (avail_out == 0), or after each
+  call of inflate(). If inflate returns Z_OK and with zero avail_out, it
+  must be called again after making room in the output buffer because there
+  might be more output pending.
+
+    If the parameter flush is set to Z_SYNC_FLUSH, inflate flushes as much
+  output as possible to the output buffer. The flushing behavior of inflate is
+  not specified for values of the flush parameter other than Z_SYNC_FLUSH
+  and Z_FINISH, but the current implementation actually flushes as much output
+  as possible anyway.
+
+    inflate() should normally be called until it returns Z_STREAM_END or an
+  error. However if all decompression is to be performed in a single step
+  (a single call of inflate), the parameter flush should be set to
+  Z_FINISH. In this case all pending input is processed and all pending
+  output is flushed; avail_out must be large enough to hold all the
+  uncompressed data. (The size of the uncompressed data may have been saved
+  by the compressor for this purpose.) The next operation on this stream must
+  be inflateEnd to deallocate the decompression state. The use of Z_FINISH
+  is never required, but can be used to inform inflate that a faster routine
+  may be used for the single inflate() call.
+
+     If a preset dictionary is needed at this point (see inflateSetDictionary
+  below), inflate sets strm-adler to the adler32 checksum of the
+  dictionary chosen by the compressor and returns Z_NEED_DICT; otherwise 
+  it sets strm->adler to the adler32 checksum of all output produced
+  so far (that is, total_out bytes) and returns Z_OK, Z_STREAM_END or
+  an error code as described below. At the end of the stream, inflate()
+  checks that its computed adler32 checksum is equal to that saved by the
+  compressor and returns Z_STREAM_END only if the checksum is correct.
+
+    inflate() returns Z_OK if some progress has been made (more input processed
+  or more output produced), Z_STREAM_END if the end of the compressed data has
+  been reached and all uncompressed output has been produced, Z_NEED_DICT if a
+  preset dictionary is needed at this point, Z_DATA_ERROR if the input data was
+  corrupted (input stream not conforming to the zlib format or incorrect
+  adler32 checksum), Z_STREAM_ERROR if the stream structure was inconsistent
+  (for example if next_in or next_out was NULL), Z_MEM_ERROR if there was not
+  enough memory, Z_BUF_ERROR if no progress is possible or if there was not
+  enough room in the output buffer when Z_FINISH is used. In the Z_DATA_ERROR
+  case, the application may then call inflateSync to look for a good
+  compression block.
+*/
+
+
+ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm));
+/*
+     All dynamically allocated data structures for this stream are freed.
+   This function discards any unprocessed input and does not flush any
+   pending output.
+
+     inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state
+   was inconsistent. In the error case, msg may be set but then points to a
+   static string (which must not be deallocated).
+*/
+
+                        /* Advanced functions */
+
+/*
+    The following functions are needed only in some special applications.
+*/
+
+/*   
+ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp strm,
+                                     int  level,
+                                     int  method,
+                                     int  windowBits,
+                                     int  memLevel,
+                                     int  strategy));
+
+     This is another version of deflateInit with more compression options. The
+   fields next_in, zalloc, zfree and opaque must be initialized before by
+   the caller.
+
+     The method parameter is the compression method. It must be Z_DEFLATED in
+   this version of the library.
+
+     The windowBits parameter is the base two logarithm of the window size
+   (the size of the history buffer).  It should be in the range 8..15 for this
+   version of the library. Larger values of this parameter result in better
+   compression at the expense of memory usage. The default value is 15 if
+   deflateInit is used instead.
+
+     The memLevel parameter specifies how much memory should be allocated
+   for the internal compression state. memLevel=1 uses minimum memory but
+   is slow and reduces compression ratio; memLevel=9 uses maximum memory
+   for optimal speed. The default value is 8. See zconf.h for total memory
+   usage as a function of windowBits and memLevel.
+
+     The strategy parameter is used to tune the compression algorithm. Use the
+   value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data produced by a
+   filter (or predictor), or Z_HUFFMAN_ONLY to force Huffman encoding only (no
+   string match).  Filtered data consists mostly of small values with a
+   somewhat random distribution. In this case, the compression algorithm is
+   tuned to compress them better. The effect of Z_FILTERED is to force more
+   Huffman coding and less string matching; it is somewhat intermediate
+   between Z_DEFAULT and Z_HUFFMAN_ONLY. The strategy parameter only affects
+   the compression ratio but not the correctness of the compressed output even
+   if it is not set appropriately.
+
+      deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_STREAM_ERROR if a parameter is invalid (such as an invalid
+   method). msg is set to null if there is no error message.  deflateInit2 does
+   not perform any compression: this will be done by deflate().
+*/
+                            
+ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm,
+                                             const Bytef *dictionary,
+                                             uInt  dictLength));
+/*
+     Initializes the compression dictionary from the given byte sequence
+   without producing any compressed output. This function must be called
+   immediately after deflateInit, deflateInit2 or deflateReset, before any
+   call of deflate. The compressor and decompressor must use exactly the same
+   dictionary (see inflateSetDictionary).
+
+     The dictionary should consist of strings (byte sequences) that are likely
+   to be encountered later in the data to be compressed, with the most commonly
+   used strings preferably put towards the end of the dictionary. Using a
+   dictionary is most useful when the data to be compressed is short and can be
+   predicted with good accuracy; the data can then be compressed better than
+   with the default empty dictionary.
+
+     Depending on the size of the compression data structures selected by
+   deflateInit or deflateInit2, a part of the dictionary may in effect be
+   discarded, for example if the dictionary is larger than the window size in
+   deflate or deflate2. Thus the strings most likely to be useful should be
+   put at the end of the dictionary, not at the front.
+
+     Upon return of this function, strm->adler is set to the Adler32 value
+   of the dictionary; the decompressor may later use this value to determine
+   which dictionary has been used by the compressor. (The Adler32 value
+   applies to the whole dictionary even if only a subset of the dictionary is
+   actually used by the compressor.)
+
+     deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a
+   parameter is invalid (such as NULL dictionary) or the stream state is
+   inconsistent (for example if deflate has already been called for this stream
+   or if the compression method is bsort). deflateSetDictionary does not
+   perform any compression: this will be done by deflate().
+*/
+
+ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest,
+                                    z_streamp source));
+/*
+     Sets the destination stream as a complete copy of the source stream.
+
+     This function can be useful when several compression strategies will be
+   tried, for example when there are several ways of pre-processing the input
+   data with a filter. The streams that will be discarded should then be freed
+   by calling deflateEnd.  Note that deflateCopy duplicates the internal
+   compression state which can be quite large, so this strategy is slow and
+   can consume lots of memory.
+
+     deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not
+   enough memory, Z_STREAM_ERROR if the source stream state was inconsistent
+   (such as zalloc being NULL). msg is left unchanged in both source and
+   destination.
+*/
+
+ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm));
+/*
+     This function is equivalent to deflateEnd followed by deflateInit,
+   but does not free and reallocate all the internal compression state.
+   The stream will keep the same compression level and any other attributes
+   that may have been set by deflateInit2.
+
+      deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent (such as zalloc or state being NULL).
+*/
+
+ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm,
+				      int level,
+				      int strategy));
+/*
+     Dynamically update the compression level and compression strategy.  The
+   interpretation of level and strategy is as in deflateInit2.  This can be
+   used to switch between compression and straight copy of the input data, or
+   to switch to a different kind of input data requiring a different
+   strategy. If the compression level is changed, the input available so far
+   is compressed with the old level (and may be flushed); the new level will
+   take effect only at the next call of deflate().
+
+     Before the call of deflateParams, the stream state must be set as for
+   a call of deflate(), since the currently available input may have to
+   be compressed and flushed. In particular, strm->avail_out must be non-zero.
+
+     deflateParams returns Z_OK if success, Z_STREAM_ERROR if the source
+   stream state was inconsistent or if a parameter was invalid, Z_BUF_ERROR
+   if strm->avail_out was zero.
+*/
+
+/*   
+ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm,
+                                     int  windowBits));
+
+     This is another version of inflateInit with an extra parameter. The
+   fields next_in, avail_in, zalloc, zfree and opaque must be initialized
+   before by the caller.
+
+     The windowBits parameter is the base two logarithm of the maximum window
+   size (the size of the history buffer).  It should be in the range 8..15 for
+   this version of the library. The default value is 15 if inflateInit is used
+   instead. If a compressed stream with a larger window size is given as
+   input, inflate() will return with the error code Z_DATA_ERROR instead of
+   trying to allocate a larger window.
+
+      inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_STREAM_ERROR if a parameter is invalid (such as a negative
+   memLevel). msg is set to null if there is no error message.  inflateInit2
+   does not perform any decompression apart from reading the zlib header if
+   present: this will be done by inflate(). (So next_in and avail_in may be
+   modified, but next_out and avail_out are unchanged.)
+*/
+
+ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm,
+                                             const Bytef *dictionary,
+                                             uInt  dictLength));
+/*
+     Initializes the decompression dictionary from the given uncompressed byte
+   sequence. This function must be called immediately after a call of inflate
+   if this call returned Z_NEED_DICT. The dictionary chosen by the compressor
+   can be determined from the Adler32 value returned by this call of
+   inflate. The compressor and decompressor must use exactly the same
+   dictionary (see deflateSetDictionary).
+
+     inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a
+   parameter is invalid (such as NULL dictionary) or the stream state is
+   inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the
+   expected one (incorrect Adler32 value). inflateSetDictionary does not
+   perform any decompression: this will be done by subsequent calls of
+   inflate().
+*/
+
+ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm));
+/* 
+    Skips invalid compressed data until a full flush point (see above the
+  description of deflate with Z_FULL_FLUSH) can be found, or until all
+  available input is skipped. No output is provided.
+
+    inflateSync returns Z_OK if a full flush point has been found, Z_BUF_ERROR
+  if no more input was provided, Z_DATA_ERROR if no flush point has been found,
+  or Z_STREAM_ERROR if the stream structure was inconsistent. In the success
+  case, the application may save the current current value of total_in which
+  indicates where valid compressed data was found. In the error case, the
+  application may repeatedly call inflateSync, providing more input each time,
+  until success or end of the input data.
+*/
+
+ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm));
+/*
+     This function is equivalent to inflateEnd followed by inflateInit,
+   but does not free and reallocate all the internal decompression state.
+   The stream will keep attributes that may have been set by inflateInit2.
+
+      inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent (such as zalloc or state being NULL).
+*/
+
+
+                        /* utility functions */
+
+/*
+     The following utility functions are implemented on top of the
+   basic stream-oriented functions. To simplify the interface, some
+   default options are assumed (compression level and memory usage,
+   standard memory allocation functions). The source code of these
+   utility functions can easily be modified if you need special options.
+*/
+
+ZEXTERN int ZEXPORT compress OF((Bytef *dest,   uLongf *destLen,
+                                 const Bytef *source, uLong sourceLen));
+/*
+     Compresses the source buffer into the destination buffer.  sourceLen is
+   the byte length of the source buffer. Upon entry, destLen is the total
+   size of the destination buffer, which must be at least 0.1% larger than
+   sourceLen plus 12 bytes. Upon exit, destLen is the actual size of the
+   compressed buffer.
+     This function can be used to compress a whole file at once if the
+   input file is mmap'ed.
+     compress returns Z_OK if success, Z_MEM_ERROR if there was not
+   enough memory, Z_BUF_ERROR if there was not enough room in the output
+   buffer.
+*/
+
+ZEXTERN int ZEXPORT compress2 OF((Bytef *dest,   uLongf *destLen,
+                                  const Bytef *source, uLong sourceLen,
+                                  int level));
+/*
+     Compresses the source buffer into the destination buffer. The level
+   parameter has the same meaning as in deflateInit.  sourceLen is the byte
+   length of the source buffer. Upon entry, destLen is the total size of the
+   destination buffer, which must be at least 0.1% larger than sourceLen plus
+   12 bytes. Upon exit, destLen is the actual size of the compressed buffer.
+
+     compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_BUF_ERROR if there was not enough room in the output buffer,
+   Z_STREAM_ERROR if the level parameter is invalid.
+*/
+
+ZEXTERN int ZEXPORT uncompress OF((Bytef *dest,   uLongf *destLen,
+                                   const Bytef *source, uLong sourceLen));
+/*
+     Decompresses the source buffer into the destination buffer.  sourceLen is
+   the byte length of the source buffer. Upon entry, destLen is the total
+   size of the destination buffer, which must be large enough to hold the
+   entire uncompressed data. (The size of the uncompressed data must have
+   been saved previously by the compressor and transmitted to the decompressor
+   by some mechanism outside the scope of this compression library.)
+   Upon exit, destLen is the actual size of the compressed buffer.
+     This function can be used to decompress a whole file at once if the
+   input file is mmap'ed.
+
+     uncompress returns Z_OK if success, Z_MEM_ERROR if there was not
+   enough memory, Z_BUF_ERROR if there was not enough room in the output
+   buffer, or Z_DATA_ERROR if the input data was corrupted.
+*/
+
+
+typedef voidp gzFile;
+
+ZEXTERN gzFile ZEXPORT gzopen  OF((const char *path, const char *mode));
+/*
+     Opens a gzip (.gz) file for reading or writing. The mode parameter
+   is as in fopen ("rb" or "wb") but can also include a compression level
+   ("wb9") or a strategy: 'f' for filtered data as in "wb6f", 'h' for
+   Huffman only compression as in "wb1h". (See the description
+   of deflateInit2 for more information about the strategy parameter.)
+
+     gzopen can be used to read a file which is not in gzip format; in this
+   case gzread will directly read from the file without decompression.
+
+     gzopen returns NULL if the file could not be opened or if there was
+   insufficient memory to allocate the (de)compression state; errno
+   can be checked to distinguish the two cases (if errno is zero, the
+   zlib error is Z_MEM_ERROR).  */
+
+ZEXTERN gzFile ZEXPORT gzdopen  OF((int fd, const char *mode));
+/*
+     gzdopen() associates a gzFile with the file descriptor fd.  File
+   descriptors are obtained from calls like open, dup, creat, pipe or
+   fileno (in the file has been previously opened with fopen).
+   The mode parameter is as in gzopen.
+     The next call of gzclose on the returned gzFile will also close the
+   file descriptor fd, just like fclose(fdopen(fd), mode) closes the file
+   descriptor fd. If you want to keep fd open, use gzdopen(dup(fd), mode).
+     gzdopen returns NULL if there was insufficient memory to allocate
+   the (de)compression state.
+*/
+
+ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy));
+/*
+     Dynamically update the compression level or strategy. See the description
+   of deflateInit2 for the meaning of these parameters.
+     gzsetparams returns Z_OK if success, or Z_STREAM_ERROR if the file was not
+   opened for writing.
+*/
+
+ZEXTERN int ZEXPORT    gzread  OF((gzFile file, voidp buf, unsigned len));
+/*
+     Reads the given number of uncompressed bytes from the compressed file.
+   If the input file was not in gzip format, gzread copies the given number
+   of bytes into the buffer.
+     gzread returns the number of uncompressed bytes actually read (0 for
+   end of file, -1 for error). */
+
+ZEXTERN int ZEXPORT    gzwrite OF((gzFile file, 
+				   const voidp buf, unsigned len));
+/*
+     Writes the given number of uncompressed bytes into the compressed file.
+   gzwrite returns the number of uncompressed bytes actually written
+   (0 in case of error).
+*/
+
+ZEXTERN int ZEXPORTVA   gzprintf OF((gzFile file, const char *format, ...));
+/*
+     Converts, formats, and writes the args to the compressed file under
+   control of the format string, as in fprintf. gzprintf returns the number of
+   uncompressed bytes actually written (0 in case of error).
+*/
+
+ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s));
+/*
+      Writes the given null-terminated string to the compressed file, excluding
+   the terminating null character.
+      gzputs returns the number of characters written, or -1 in case of error.
+*/
+
+ZEXTERN char * ZEXPORT gzgets OF((gzFile file, char *buf, int len));
+/*
+      Reads bytes from the compressed file until len-1 characters are read, or
+   a newline character is read and transferred to buf, or an end-of-file
+   condition is encountered.  The string is then terminated with a null
+   character.
+      gzgets returns buf, or Z_NULL in case of error.
+*/
+
+ZEXTERN int ZEXPORT    gzputc OF((gzFile file, int c));
+/*
+      Writes c, converted to an unsigned char, into the compressed file.
+   gzputc returns the value that was written, or -1 in case of error.
+*/
+
+ZEXTERN int ZEXPORT    gzgetc OF((gzFile file));
+/*
+      Reads one byte from the compressed file. gzgetc returns this byte
+   or -1 in case of end of file or error.
+*/
+
+ZEXTERN int ZEXPORT    gzflush OF((gzFile file, int flush));
+/*
+     Flushes all pending output into the compressed file. The parameter
+   flush is as in the deflate() function. The return value is the zlib
+   error number (see function gzerror below). gzflush returns Z_OK if
+   the flush parameter is Z_FINISH and all output could be flushed.
+     gzflush should be called only when strictly necessary because it can
+   degrade compression.
+*/
+
+ZEXTERN z_off_t ZEXPORT    gzseek OF((gzFile file,
+				      z_off_t offset, int whence));
+/* 
+      Sets the starting position for the next gzread or gzwrite on the
+   given compressed file. The offset represents a number of bytes in the
+   uncompressed data stream. The whence parameter is defined as in lseek(2);
+   the value SEEK_END is not supported.
+     If the file is opened for reading, this function is emulated but can be
+   extremely slow. If the file is opened for writing, only forward seeks are
+   supported; gzseek then compresses a sequence of zeroes up to the new
+   starting position.
+
+      gzseek returns the resulting offset location as measured in bytes from
+   the beginning of the uncompressed stream, or -1 in case of error, in
+   particular if the file is opened for writing and the new starting position
+   would be before the current position.
+*/
+
+ZEXTERN int ZEXPORT    gzrewind OF((gzFile file));
+/*
+     Rewinds the given file. This function is supported only for reading.
+
+   gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET)
+*/
+
+ZEXTERN z_off_t ZEXPORT    gztell OF((gzFile file));
+/*
+     Returns the starting position for the next gzread or gzwrite on the
+   given compressed file. This position represents a number of bytes in the
+   uncompressed data stream.
+
+   gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR)
+*/
+
+ZEXTERN int ZEXPORT gzeof OF((gzFile file));
+/*
+     Returns 1 when EOF has previously been detected reading the given
+   input stream, otherwise zero.
+*/
+
+ZEXTERN int ZEXPORT    gzclose OF((gzFile file));
+/*
+     Flushes all pending output if necessary, closes the compressed file
+   and deallocates all the (de)compression state. The return value is the zlib
+   error number (see function gzerror below).
+*/
+
+ZEXTERN const char * ZEXPORT gzerror OF((gzFile file, int *errnum));
+/*
+     Returns the error message for the last error which occurred on the
+   given compressed file. errnum is set to zlib error number. If an
+   error occurred in the file system and not in the compression library,
+   errnum is set to Z_ERRNO and the application may consult errno
+   to get the exact error code.
+*/
+
+                        /* checksum functions */
+
+/*
+     These functions are not related to compression but are exported
+   anyway because they might be useful in applications using the
+   compression library.
+*/
+
+ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len));
+
+/*
+     Update a running Adler-32 checksum with the bytes buf[0..len-1] and
+   return the updated checksum. If buf is NULL, this function returns
+   the required initial value for the checksum.
+   An Adler-32 checksum is almost as reliable as a CRC32 but can be computed
+   much faster. Usage example:
+
+     uLong adler = adler32(0L, Z_NULL, 0);
+
+     while (read_buffer(buffer, length) != EOF) {
+       adler = adler32(adler, buffer, length);
+     }
+     if (adler != original_adler) error();
+*/
+
+ZEXTERN uLong ZEXPORT crc32   OF((uLong crc, const Bytef *buf, uInt len));
+/*
+     Update a running crc with the bytes buf[0..len-1] and return the updated
+   crc. If buf is NULL, this function returns the required initial value
+   for the crc. Pre- and post-conditioning (one's complement) is performed
+   within this function so it shouldn't be done by the application.
+   Usage example:
+
+     uLong crc = crc32(0L, Z_NULL, 0);
+
+     while (read_buffer(buffer, length) != EOF) {
+       crc = crc32(crc, buffer, length);
+     }
+     if (crc != original_crc) error();
+*/
+
+
+                        /* various hacks, don't look :) */
+
+/* deflateInit and inflateInit are macros to allow checking the zlib version
+ * and the compiler's view of z_stream:
+ */
+ZEXTERN int ZEXPORT deflateInit_ OF((z_streamp strm, int level,
+                                     const char *version, int stream_size));
+ZEXTERN int ZEXPORT inflateInit_ OF((z_streamp strm,
+                                     const char *version, int stream_size));
+ZEXTERN int ZEXPORT deflateInit2_ OF((z_streamp strm, int  level, int  method,
+                                      int windowBits, int memLevel,
+                                      int strategy, const char *version,
+                                      int stream_size));
+ZEXTERN int ZEXPORT inflateInit2_ OF((z_streamp strm, int  windowBits,
+                                      const char *version, int stream_size));
+#define deflateInit(strm, level) \
+        deflateInit_((strm), (level),       ZLIB_VERSION, sizeof(z_stream))
+#define inflateInit(strm) \
+        inflateInit_((strm),                ZLIB_VERSION, sizeof(z_stream))
+#define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
+        deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\
+                      (strategy),           ZLIB_VERSION, sizeof(z_stream))
+#define inflateInit2(strm, windowBits) \
+        inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream))
+
+
+#if !defined(_Z_UTIL_H) && !defined(NO_DUMMY_DECL)
+    struct internal_state {int dummy;}; /* hack for buggy compilers */
+#endif
+
+ZEXTERN const char   * ZEXPORT zError           OF((int err));
+ZEXTERN int            ZEXPORT inflateSyncPoint OF((z_streamp z));
+ZEXTERN const uLongf * ZEXPORT get_crc_table    OF((void));
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _ZLIB_H */
diff --git a/src/libz/src/Makefile b/src/libz/src/Makefile
new file mode 100644
index 0000000..7780f38
--- /dev/null
+++ b/src/libz/src/Makefile
@@ -0,0 +1,54 @@
+#------------------------------------------------------------------------------
+# Local Makefile
+#------------------------------------------------------------------------------
+# $Workfile:   Makefile  $                                                     
+#------------------------------------------------------------------------------
+# $Author: agibert $                                                        
+# $Date: 2008/11/12 02:25:24 $                                             
+# $Revision: 1.1 $                                                         
+# $Label:  $                                                           
+#------------------------------------------------------------------------------
+
+
+
+#------------------------------------------------------------------------------
+# Var include
+#------------------------------------------------------------------------------
+
+include ../../Makefile_var.mk
+
+
+
+#------------------------------------------------------------------------------
+# Variables
+#------------------------------------------------------------------------------
+
+TARGET=		libz$(SHLIB_SUFFIX)
+
+OBJ=		libz.o                                                  \
+                adler32.o						\
+		compress.o						\
+		crc32.o							\
+		deflate.o						\
+		gzio.o							\
+		infblock.o						\
+		infcodes.o						\
+		inffast.o						\
+		inflate.o						\
+		inftrees.o						\
+		infutil.o						\
+		trees.o							\
+		uncompr.o						\
+		zutil.o
+
+EXTRA_INC=	
+
+EXTRA_LIB=	
+
+
+
+#------------------------------------------------------------------------------
+# Rule include
+#------------------------------------------------------------------------------
+
+include ../../Makefile_rule.mk
diff --git a/src/libz/src/adler32.c b/src/libz/src/adler32.c
new file mode 100644
index 0000000..781e365
--- /dev/null
+++ b/src/libz/src/adler32.c
@@ -0,0 +1,48 @@
+/* adler32.c -- compute the Adler-32 checksum of a data stream
+ * Copyright (C) 1995-2002 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h 
+ */
+
+/* @(#) $Id: adler32.c,v 1.1 2008/11/12 02:25:24 agibert Exp $ */
+
+#include "zlib.h"
+
+#define BASE 65521L /* largest prime smaller than 65536 */
+#define NMAX 5552
+/* NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */
+
+#define DO1(buf,i)  {s1 += buf[i]; s2 += s1;}
+#define DO2(buf,i)  DO1(buf,i); DO1(buf,i+1);
+#define DO4(buf,i)  DO2(buf,i); DO2(buf,i+2);
+#define DO8(buf,i)  DO4(buf,i); DO4(buf,i+4);
+#define DO16(buf)   DO8(buf,0); DO8(buf,8);
+
+/* ========================================================================= */
+uLong ZEXPORT adler32(adler, buf, len)
+    uLong adler;
+    const Bytef *buf;
+    uInt len;
+{
+    unsigned long s1 = adler & 0xffff;
+    unsigned long s2 = (adler >> 16) & 0xffff;
+    int k;
+
+    if (buf == Z_NULL) return 1L;
+
+    while (len > 0) {
+        k = len < NMAX ? len : NMAX;
+        len -= k;
+        while (k >= 16) {
+            DO16(buf);
+	    buf += 16;
+            k -= 16;
+        }
+        if (k != 0) do {
+            s1 += *buf++;
+	    s2 += s1;
+        } while (--k);
+        s1 %= BASE;
+        s2 %= BASE;
+    }
+    return (s2 << 16) | s1;
+}
diff --git a/src/libz/src/compress.c b/src/libz/src/compress.c
new file mode 100644
index 0000000..c47e1ce
--- /dev/null
+++ b/src/libz/src/compress.c
@@ -0,0 +1,68 @@
+/* compress.c -- compress a memory buffer
+ * Copyright (C) 1995-2002 Jean-loup Gailly.
+ * For conditions of distribution and use, see copyright notice in zlib.h 
+ */
+
+/* @(#) $Id: compress.c,v 1.1 2008/11/12 02:25:24 agibert Exp $ */
+
+#include "zlib.h"
+
+/* ===========================================================================
+     Compresses the source buffer into the destination buffer. The level
+   parameter has the same meaning as in deflateInit.  sourceLen is the byte
+   length of the source buffer. Upon entry, destLen is the total size of the
+   destination buffer, which must be at least 0.1% larger than sourceLen plus
+   12 bytes. Upon exit, destLen is the actual size of the compressed buffer.
+
+     compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_BUF_ERROR if there was not enough room in the output buffer,
+   Z_STREAM_ERROR if the level parameter is invalid.
+*/
+int ZEXPORT compress2 (dest, destLen, source, sourceLen, level)
+    Bytef *dest;
+    uLongf *destLen;
+    const Bytef *source;
+    uLong sourceLen;
+    int level;
+{
+    z_stream stream;
+    int err;
+
+    stream.next_in = (Bytef*)source;
+    stream.avail_in = (uInt)sourceLen;
+#ifdef MAXSEG_64K
+    /* Check for source > 64K on 16-bit machine: */
+    if ((uLong)stream.avail_in != sourceLen) return Z_BUF_ERROR;
+#endif
+    stream.next_out = dest;
+    stream.avail_out = (uInt)*destLen;
+    if ((uLong)stream.avail_out != *destLen) return Z_BUF_ERROR;
+
+    stream.zalloc = (alloc_func)0;
+    stream.zfree = (free_func)0;
+    stream.opaque = (voidpf)0;
+
+    err = deflateInit(&stream, level);
+    if (err != Z_OK) return err;
+
+    err = deflate(&stream, Z_FINISH);
+    if (err != Z_STREAM_END) {
+        deflateEnd(&stream);
+        return err == Z_OK ? Z_BUF_ERROR : err;
+    }
+    *destLen = stream.total_out;
+
+    err = deflateEnd(&stream);
+    return err;
+}
+
+/* ===========================================================================
+ */
+int ZEXPORT compress (dest, destLen, source, sourceLen)
+    Bytef *dest;
+    uLongf *destLen;
+    const Bytef *source;
+    uLong sourceLen;
+{
+    return compress2(dest, destLen, source, sourceLen, Z_DEFAULT_COMPRESSION);
+}
diff --git a/src/libz/src/crc32.c b/src/libz/src/crc32.c
new file mode 100644
index 0000000..70cafa2
--- /dev/null
+++ b/src/libz/src/crc32.c
@@ -0,0 +1,162 @@
+/* crc32.c -- compute the CRC-32 of a data stream
+ * Copyright (C) 1995-2002 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h 
+ */
+
+/* @(#) $Id: crc32.c,v 1.1 2008/11/12 02:25:24 agibert Exp $ */
+
+#include "zlib.h"
+
+#define local static
+
+#ifdef DYNAMIC_CRC_TABLE
+
+local int crc_table_empty = 1;
+local uLongf crc_table[256];
+local void make_crc_table OF((void));
+
+/*
+  Generate a table for a byte-wise 32-bit CRC calculation on the polynomial:
+  x^32+x^26+x^23+x^22+x^16+x^12+x^11+x^10+x^8+x^7+x^5+x^4+x^2+x+1.
+
+  Polynomials over GF(2) are represented in binary, one bit per coefficient,
+  with the lowest powers in the most significant bit.  Then adding polynomials
+  is just exclusive-or, and multiplying a polynomial by x is a right shift by
+  one.  If we call the above polynomial p, and represent a byte as the
+  polynomial q, also with the lowest power in the most significant bit (so the
+  byte 0xb1 is the polynomial x^7+x^3+x+1), then the CRC is (q*x^32) mod p,
+  where a mod b means the remainder after dividing a by b.
+
+  This calculation is done using the shift-register method of multiplying and
+  taking the remainder.  The register is initialized to zero, and for each
+  incoming bit, x^32 is added mod p to the register if the bit is a one (where
+  x^32 mod p is p+x^32 = x^26+...+1), and the register is multiplied mod p by
+  x (which is shifting right by one and adding x^32 mod p if the bit shifted
+  out is a one).  We start with the highest power (least significant bit) of
+  q and repeat for all eight bits of q.
+
+  The table is simply the CRC of all possible eight bit values.  This is all
+  the information needed to generate CRC's on data a byte at a time for all
+  combinations of CRC register values and incoming bytes.
+*/
+local void make_crc_table()
+{
+  uLong c;
+  int n, k;
+  uLong poly;            /* polynomial exclusive-or pattern */
+  /* terms of polynomial defining this crc (except x^32): */
+  static const Byte p[] = {0,1,2,4,5,7,8,10,11,12,16,22,23,26};
+
+  /* make exclusive-or pattern from polynomial (0xedb88320L) */
+  poly = 0L;
+  for (n = 0; n < sizeof(p)/sizeof(Byte); n++)
+    poly |= 1L << (31 - p[n]);
+ 
+  for (n = 0; n < 256; n++)
+  {
+    c = (uLong)n;
+    for (k = 0; k < 8; k++)
+      c = c & 1 ? poly ^ (c >> 1) : c >> 1;
+    crc_table[n] = c;
+  }
+  crc_table_empty = 0;
+}
+#else
+/* ========================================================================
+ * Table of CRC-32's of all single-byte values (made by make_crc_table)
+ */
+local const uLongf crc_table[256] = {
+  0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L,
+  0x706af48fL, 0xe963a535L, 0x9e6495a3L, 0x0edb8832L, 0x79dcb8a4L,
+  0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L,
+  0x90bf1d91L, 0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL,
+  0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L, 0x136c9856L,
+  0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL, 0x14015c4fL, 0x63066cd9L,
+  0xfa0f3d63L, 0x8d080df5L, 0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L,
+  0xa2677172L, 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL,
+  0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L, 0x32d86ce3L,
+  0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L, 0x26d930acL, 0x51de003aL,
+  0xc8d75180L, 0xbfd06116L, 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L,
+  0xb8bda50fL, 0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L,
+  0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL, 0x76dc4190L,
+  0x01db7106L, 0x98d220bcL, 0xefd5102aL, 0x71b18589L, 0x06b6b51fL,
+  0x9fbfe4a5L, 0xe8b8d433L, 0x7807c9a2L, 0x0f00f934L, 0x9609a88eL,
+  0xe10e9818L, 0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L,
+  0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL, 0x6c0695edL,
+  0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L, 0x65b0d9c6L, 0x12b7e950L,
+  0x8bbeb8eaL, 0xfcb9887cL, 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L,
+  0xfbd44c65L, 0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L,
+  0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL, 0x4369e96aL,
+  0x346ed9fcL, 0xad678846L, 0xda60b8d0L, 0x44042d73L, 0x33031de5L,
+  0xaa0a4c5fL, 0xdd0d7cc9L, 0x5005713cL, 0x270241aaL, 0xbe0b1010L,
+  0xc90c2086L, 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL,
+  0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L, 0x59b33d17L,
+  0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL, 0xedb88320L, 0x9abfb3b6L,
+  0x03b6e20cL, 0x74b1d29aL, 0xead54739L, 0x9dd277afL, 0x04db2615L,
+  0x73dc1683L, 0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L,
+  0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L, 0xf00f9344L,
+  0x8708a3d2L, 0x1e01f268L, 0x6906c2feL, 0xf762575dL, 0x806567cbL,
+  0x196c3671L, 0x6e6b06e7L, 0xfed41b76L, 0x89d32be0L, 0x10da7a5aL,
+  0x67dd4accL, 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L,
+  0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L, 0xd1bb67f1L,
+  0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL, 0xd80d2bdaL, 0xaf0a1b4cL,
+  0x36034af6L, 0x41047a60L, 0xdf60efc3L, 0xa867df55L, 0x316e8eefL,
+  0x4669be79L, 0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L,
+  0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL, 0xc5ba3bbeL,
+  0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L, 0xc2d7ffa7L, 0xb5d0cf31L,
+  0x2cd99e8bL, 0x5bdeae1dL, 0x9b64c2b0L, 0xec63f226L, 0x756aa39cL,
+  0x026d930aL, 0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L,
+  0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L, 0x92d28e9bL,
+  0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L, 0x86d3d2d4L, 0xf1d4e242L,
+  0x68ddb3f8L, 0x1fda836eL, 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L,
+  0x18b74777L, 0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL,
+  0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L, 0xa00ae278L,
+  0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L, 0xa7672661L, 0xd06016f7L,
+  0x4969474dL, 0x3e6e77dbL, 0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L,
+  0x37d83bf0L, 0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L,
+  0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L, 0xbad03605L,
+  0xcdd70693L, 0x54de5729L, 0x23d967bfL, 0xb3667a2eL, 0xc4614ab8L,
+  0x5d681b02L, 0x2a6f2b94L, 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL,
+  0x2d02ef8dL
+};
+#endif
+
+/* =========================================================================
+ * This function can be used by asm versions of crc32()
+ */
+const uLongf * ZEXPORT get_crc_table()
+{
+#ifdef DYNAMIC_CRC_TABLE
+  if (crc_table_empty) make_crc_table();
+#endif
+  return (const uLongf *)crc_table;
+}
+
+/* ========================================================================= */
+#define DO1(buf) crc = crc_table[((int)crc ^ (*buf++)) & 0xff] ^ (crc >> 8);
+#define DO2(buf)  DO1(buf); DO1(buf);
+#define DO4(buf)  DO2(buf); DO2(buf);
+#define DO8(buf)  DO4(buf); DO4(buf);
+
+/* ========================================================================= */
+uLong ZEXPORT crc32(crc, buf, len)
+    uLong crc;
+    const Bytef *buf;
+    uInt len;
+{
+    if (buf == Z_NULL) return 0L;
+#ifdef DYNAMIC_CRC_TABLE
+    if (crc_table_empty)
+      make_crc_table();
+#endif
+    crc = crc ^ 0xffffffffL;
+    while (len >= 8)
+    {
+      DO8(buf);
+      len -= 8;
+    }
+    if (len) do {
+      DO1(buf);
+    } while (--len);
+    return crc ^ 0xffffffffL;
+}
diff --git a/src/libz/src/deflate.c b/src/libz/src/deflate.c
new file mode 100644
index 0000000..bde2063
--- /dev/null
+++ b/src/libz/src/deflate.c
@@ -0,0 +1,1350 @@
+/* deflate.c -- compress data using the deflation algorithm
+ * Copyright (C) 1995-2002 Jean-loup Gailly.
+ * For conditions of distribution and use, see copyright notice in zlib.h 
+ */
+
+/*
+ *  ALGORITHM
+ *
+ *      The "deflation" process depends on being able to identify portions
+ *      of the input text which are identical to earlier input (within a
+ *      sliding window trailing behind the input currently being processed).
+ *
+ *      The most straightforward technique turns out to be the fastest for
+ *      most input files: try all possible matches and select the longest.
+ *      The key feature of this algorithm is that insertions into the string
+ *      dictionary are very simple and thus fast, and deletions are avoided
+ *      completely. Insertions are performed at each input character, whereas
+ *      string matches are performed only when the previous match ends. So it
+ *      is preferable to spend more time in matches to allow very fast string
+ *      insertions and avoid deletions. The matching algorithm for small
+ *      strings is inspired from that of Rabin & Karp. A brute force approach
+ *      is used to find longer strings when a small match has been found.
+ *      A similar algorithm is used in comic (by Jan-Mark Wams) and freeze
+ *      (by Leonid Broukhis).
+ *         A previous version of this file used a more sophisticated algorithm
+ *      (by Fiala and Greene) which is guaranteed to run in linear amortized
+ *      time, but has a larger average cost, uses more memory and is patented.
+ *      However the F&G algorithm may be faster for some highly redundant
+ *      files if the parameter max_chain_length (described below) is too large.
+ *
+ *  ACKNOWLEDGEMENTS
+ *
+ *      The idea of lazy evaluation of matches is due to Jan-Mark Wams, and
+ *      I found it in 'freeze' written by Leonid Broukhis.
+ *      Thanks to many people for bug reports and testing.
+ *
+ *  REFERENCES
+ *
+ *      Deutsch, L.P.,"DEFLATE Compressed Data Format Specification".
+ *      Available in ftp://ds.internic.net/rfc/rfc1951.txt
+ *
+ *      A description of the Rabin and Karp algorithm is given in the book
+ *         "Algorithms" by R. Sedgewick, Addison-Wesley, p252.
+ *
+ *      Fiala,E.R., and Greene,D.H.
+ *         Data Compression with Finite Windows, Comm.ACM, 32,4 (1989) 490-595
+ *
+ */
+
+/* @(#) $Id: deflate.c,v 1.1 2008/11/12 02:25:24 agibert Exp $ */
+
+#include "deflate.h"
+
+const char deflate_copyright[] =
+   " deflate 1.1.4 Copyright 1995-2002 Jean-loup Gailly ";
+/*
+  If you use the zlib library in a product, an acknowledgment is welcome
+  in the documentation of your product. If for some reason you cannot
+  include such an acknowledgment, I would appreciate that you keep this
+  copyright string in the executable of your product.
+ */
+
+/* ===========================================================================
+ *  Function prototypes.
+ */
+typedef enum {
+    need_more,      /* block not completed, need more input or more output */
+    block_done,     /* block flush performed */
+    finish_started, /* finish started, need only more output at next deflate */
+    finish_done     /* finish done, accept no more input or output */
+} block_state;
+
+typedef block_state (*compress_func) OF((deflate_state *s, int flush));
+/* Compression function. Returns the block state after the call. */
+
+local void fill_window    OF((deflate_state *s));
+local block_state deflate_stored OF((deflate_state *s, int flush));
+local block_state deflate_fast   OF((deflate_state *s, int flush));
+local block_state deflate_slow   OF((deflate_state *s, int flush));
+local void lm_init        OF((deflate_state *s));
+local void putShortMSB    OF((deflate_state *s, uInt b));
+local void flush_pending  OF((z_streamp strm));
+local int read_buf        OF((z_streamp strm, Bytef *buf, unsigned size));
+#ifdef ASMV
+      void match_init OF((void)); /* asm code initialization */
+      uInt longest_match  OF((deflate_state *s, IPos cur_match));
+#else
+local uInt longest_match  OF((deflate_state *s, IPos cur_match));
+#endif
+
+#ifdef DEBUG
+local  void check_match OF((deflate_state *s, IPos start, IPos match,
+                            int length));
+#endif
+
+/* ===========================================================================
+ * Local data
+ */
+
+#define NIL 0
+/* Tail of hash chains */
+
+#ifndef TOO_FAR
+#  define TOO_FAR 4096
+#endif
+/* Matches of length 3 are discarded if their distance exceeds TOO_FAR */
+
+#define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1)
+/* Minimum amount of lookahead, except at the end of the input file.
+ * See deflate.c for comments about the MIN_MATCH+1.
+ */
+
+/* Values for max_lazy_match, good_match and max_chain_length, depending on
+ * the desired pack level (0..9). The values given below have been tuned to
+ * exclude worst case performance for pathological files. Better values may be
+ * found for specific files.
+ */
+typedef struct config_s {
+   ush good_length; /* reduce lazy search above this match length */
+   ush max_lazy;    /* do not perform lazy search above this match length */
+   ush nice_length; /* quit search above this match length */
+   ush max_chain;
+   compress_func func;
+} config;
+
+local const config configuration_table[10] = {
+/*      good lazy nice chain */
+/* 0 */ {0,    0,  0,    0, deflate_stored},  /* store only */
+/* 1 */ {4,    4,  8,    4, deflate_fast}, /* maximum speed, no lazy matches */
+/* 2 */ {4,    5, 16,    8, deflate_fast},
+/* 3 */ {4,    6, 32,   32, deflate_fast},
+
+/* 4 */ {4,    4, 16,   16, deflate_slow},  /* lazy matches */
+/* 5 */ {8,   16, 32,   32, deflate_slow},
+/* 6 */ {8,   16, 128, 128, deflate_slow},
+/* 7 */ {8,   32, 128, 256, deflate_slow},
+/* 8 */ {32, 128, 258, 1024, deflate_slow},
+/* 9 */ {32, 258, 258, 4096, deflate_slow}}; /* maximum compression */
+
+/* Note: the deflate() code requires max_lazy >= MIN_MATCH and max_chain >= 4
+ * For deflate_fast() (levels <= 3) good is ignored and lazy has a different
+ * meaning.
+ */
+
+#define EQUAL 0
+/* result of memcmp for equal strings */
+
+struct static_tree_desc_s {int dummy;}; /* for buggy compilers */
+
+/* ===========================================================================
+ * Update a hash value with the given input byte
+ * IN  assertion: all calls to to UPDATE_HASH are made with consecutive
+ *    input characters, so that a running hash key can be computed from the
+ *    previous key instead of complete recalculation each time.
+ */
+#define UPDATE_HASH(s,h,c) (h = (((h)<<s->hash_shift) ^ (c)) & s->hash_mask)
+
+
+/* ===========================================================================
+ * Insert string str in the dictionary and set match_head to the previous head
+ * of the hash chain (the most recent string with same hash key). Return
+ * the previous length of the hash chain.
+ * If this file is compiled with -DFASTEST, the compression level is forced
+ * to 1, and no hash chains are maintained.
+ * IN  assertion: all calls to to INSERT_STRING are made with consecutive
+ *    input characters and the first MIN_MATCH bytes of str are valid
+ *    (except for the last MIN_MATCH-1 bytes of the input file).
+ */
+#ifdef FASTEST
+#define INSERT_STRING(s, str, match_head) \
+   (UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH-1)]), \
+    match_head = s->head[s->ins_h], \
+    s->head[s->ins_h] = (Pos)(str))
+#else
+#define INSERT_STRING(s, str, match_head) \
+   (UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH-1)]), \
+    s->prev[(str) & s->w_mask] = match_head = s->head[s->ins_h], \
+    s->head[s->ins_h] = (Pos)(str))
+#endif
+
+/* ===========================================================================
+ * Initialize the hash table (avoiding 64K overflow for 16 bit systems).
+ * prev[] will be initialized on the fly.
+ */
+#define CLEAR_HASH(s) \
+    s->head[s->hash_size-1] = NIL; \
+    zmemzero((Bytef *)s->head, (unsigned)(s->hash_size-1)*sizeof(*s->head));
+
+/* ========================================================================= */
+int ZEXPORT deflateInit_(strm, level, version, stream_size)
+    z_streamp strm;
+    int level;
+    const char *version;
+    int stream_size;
+{
+    return deflateInit2_(strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL,
+			 Z_DEFAULT_STRATEGY, version, stream_size);
+    /* To do: ignore strm->next_in if we use it as window */
+}
+
+/* ========================================================================= */
+int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy,
+		  version, stream_size)
+    z_streamp strm;
+    int  level;
+    int  method;
+    int  windowBits;
+    int  memLevel;
+    int  strategy;
+    const char *version;
+    int stream_size;
+{
+    deflate_state *s;
+    int noheader = 0;
+    static const char* my_version = ZLIB_VERSION;
+
+    ushf *overlay;
+    /* We overlay pending_buf and d_buf+l_buf. This works since the average
+     * output size for (length,distance) codes is <= 24 bits.
+     */
+
+    if (version == Z_NULL || version[0] != my_version[0] ||
+        stream_size != sizeof(z_stream)) {
+	return Z_VERSION_ERROR;
+    }
+    if (strm == Z_NULL) return Z_STREAM_ERROR;
+
+    strm->msg = Z_NULL;
+    if (strm->zalloc == Z_NULL) {
+	strm->zalloc = zcalloc;
+	strm->opaque = (voidpf)0;
+    }
+    if (strm->zfree == Z_NULL) strm->zfree = zcfree;
+
+    if (level == Z_DEFAULT_COMPRESSION) level = 6;
+#ifdef FASTEST
+    level = 1;
+#endif
+
+    if (windowBits < 0) { /* undocumented feature: suppress zlib header */
+        noheader = 1;
+        windowBits = -windowBits;
+    }
+    if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || method != Z_DEFLATED ||
+        windowBits < 9 || windowBits > 15 || level < 0 || level > 9 ||
+	strategy < 0 || strategy > Z_HUFFMAN_ONLY) {
+        return Z_STREAM_ERROR;
+    }
+    s = (deflate_state *) ZALLOC(strm, 1, sizeof(deflate_state));
+    if (s == Z_NULL) return Z_MEM_ERROR;
+    strm->state = (struct internal_state FAR *)s;
+    s->strm = strm;
+
+    s->noheader = noheader;
+    s->w_bits = windowBits;
+    s->w_size = 1 << s->w_bits;
+    s->w_mask = s->w_size - 1;
+
+    s->hash_bits = memLevel + 7;
+    s->hash_size = 1 << s->hash_bits;
+    s->hash_mask = s->hash_size - 1;
+    s->hash_shift =  ((s->hash_bits+MIN_MATCH-1)/MIN_MATCH);
+
+    s->window = (Bytef *) ZALLOC(strm, s->w_size, 2*sizeof(Byte));
+    s->prev   = (Posf *)  ZALLOC(strm, s->w_size, sizeof(Pos));
+    s->head   = (Posf *)  ZALLOC(strm, s->hash_size, sizeof(Pos));
+
+    s->lit_bufsize = 1 << (memLevel + 6); /* 16K elements by default */
+
+    overlay = (ushf *) ZALLOC(strm, s->lit_bufsize, sizeof(ush)+2);
+    s->pending_buf = (uchf *) overlay;
+    s->pending_buf_size = (ulg)s->lit_bufsize * (sizeof(ush)+2L);
+
+    if (s->window == Z_NULL || s->prev == Z_NULL || s->head == Z_NULL ||
+        s->pending_buf == Z_NULL) {
+        strm->msg = (char*)ERR_MSG(Z_MEM_ERROR);
+        deflateEnd (strm);
+        return Z_MEM_ERROR;
+    }
+    s->d_buf = overlay + s->lit_bufsize/sizeof(ush);
+    s->l_buf = s->pending_buf + (1+sizeof(ush))*s->lit_bufsize;
+
+    s->level = level;
+    s->strategy = strategy;
+    s->method = (Byte)method;
+
+    return deflateReset(strm);
+}
+
+/* ========================================================================= */
+int ZEXPORT deflateSetDictionary (strm, dictionary, dictLength)
+    z_streamp strm;
+    const Bytef *dictionary;
+    uInt  dictLength;
+{
+    deflate_state *s;
+    uInt length = dictLength;
+    uInt n;
+    IPos hash_head = 0;
+
+    if (strm == Z_NULL || strm->state == Z_NULL || dictionary == Z_NULL ||
+        strm->state->status != INIT_STATE) return Z_STREAM_ERROR;
+
+    s = strm->state;
+    strm->adler = adler32(strm->adler, dictionary, dictLength);
+
+    if (length < MIN_MATCH) return Z_OK;
+    if (length > MAX_DIST(s)) {
+	length = MAX_DIST(s);
+#ifndef USE_DICT_HEAD
+	dictionary += dictLength - length; /* use the tail of the dictionary */
+#endif
+    }
+    zmemcpy(s->window, dictionary, length);
+    s->strstart = length;
+    s->block_start = (long)length;
+
+    /* Insert all strings in the hash table (except for the last two bytes).
+     * s->lookahead stays null, so s->ins_h will be recomputed at the next
+     * call of fill_window.
+     */
+    s->ins_h = s->window[0];
+    UPDATE_HASH(s, s->ins_h, s->window[1]);
+    for (n = 0; n <= length - MIN_MATCH; n++) {
+	INSERT_STRING(s, n, hash_head);
+    }
+    if (hash_head) hash_head = 0;  /* to make compiler happy */
+    return Z_OK;
+}
+
+/* ========================================================================= */
+int ZEXPORT deflateReset (strm)
+    z_streamp strm;
+{
+    deflate_state *s;
+    
+    if (strm == Z_NULL || strm->state == Z_NULL ||
+        strm->zalloc == Z_NULL || strm->zfree == Z_NULL) return Z_STREAM_ERROR;
+
+    strm->total_in = strm->total_out = 0;
+    strm->msg = Z_NULL; /* use zfree if we ever allocate msg dynamically */
+    strm->data_type = Z_UNKNOWN;
+
+    s = (deflate_state *)strm->state;
+    s->pending = 0;
+    s->pending_out = s->pending_buf;
+
+    if (s->noheader < 0) {
+        s->noheader = 0; /* was set to -1 by deflate(..., Z_FINISH); */
+    }
+    s->status = s->noheader ? BUSY_STATE : INIT_STATE;
+    strm->adler = 1;
+    s->last_flush = Z_NO_FLUSH;
+
+    _tr_init(s);
+    lm_init(s);
+
+    return Z_OK;
+}
+
+/* ========================================================================= */
+int ZEXPORT deflateParams(strm, level, strategy)
+    z_streamp strm;
+    int level;
+    int strategy;
+{
+    deflate_state *s;
+    compress_func func;
+    int err = Z_OK;
+
+    if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+    s = strm->state;
+
+    if (level == Z_DEFAULT_COMPRESSION) {
+	level = 6;
+    }
+    if (level < 0 || level > 9 || strategy < 0 || strategy > Z_HUFFMAN_ONLY) {
+	return Z_STREAM_ERROR;
+    }
+    func = configuration_table[s->level].func;
+
+    if (func != configuration_table[level].func && strm->total_in != 0) {
+	/* Flush the last buffer: */
+	err = deflate(strm, Z_PARTIAL_FLUSH);
+    }
+    if (s->level != level) {
+	s->level = level;
+	s->max_lazy_match   = configuration_table[level].max_lazy;
+	s->good_match       = configuration_table[level].good_length;
+	s->nice_match       = configuration_table[level].nice_length;
+	s->max_chain_length = configuration_table[level].max_chain;
+    }
+    s->strategy = strategy;
+    return err;
+}
+
+/* =========================================================================
+ * Put a short in the pending buffer. The 16-bit value is put in MSB order.
+ * IN assertion: the stream state is correct and there is enough room in
+ * pending_buf.
+ */
+local void putShortMSB (s, b)
+    deflate_state *s;
+    uInt b;
+{
+    put_byte(s, (Byte)(b >> 8));
+    put_byte(s, (Byte)(b & 0xff));
+}   
+
+/* =========================================================================
+ * Flush as much pending output as possible. All deflate() output goes
+ * through this function so some applications may wish to modify it
+ * to avoid allocating a large strm->next_out buffer and copying into it.
+ * (See also read_buf()).
+ */
+local void flush_pending(strm)
+    z_streamp strm;
+{
+    unsigned len = strm->state->pending;
+
+    if (len > strm->avail_out) len = strm->avail_out;
+    if (len == 0) return;
+
+    zmemcpy(strm->next_out, strm->state->pending_out, len);
+    strm->next_out  += len;
+    strm->state->pending_out  += len;
+    strm->total_out += len;
+    strm->avail_out  -= len;
+    strm->state->pending -= len;
+    if (strm->state->pending == 0) {
+        strm->state->pending_out = strm->state->pending_buf;
+    }
+}
+
+/* ========================================================================= */
+int ZEXPORT deflate (strm, flush)
+    z_streamp strm;
+    int flush;
+{
+    int old_flush; /* value of flush param for previous deflate call */
+    deflate_state *s;
+
+    if (strm == Z_NULL || strm->state == Z_NULL ||
+	flush > Z_FINISH || flush < 0) {
+        return Z_STREAM_ERROR;
+    }
+    s = strm->state;
+
+    if (strm->next_out == Z_NULL ||
+        (strm->next_in == Z_NULL && strm->avail_in != 0) ||
+	(s->status == FINISH_STATE && flush != Z_FINISH)) {
+        ERR_RETURN(strm, Z_STREAM_ERROR);
+    }
+    if (strm->avail_out == 0) ERR_RETURN(strm, Z_BUF_ERROR);
+
+    s->strm = strm; /* just in case */
+    old_flush = s->last_flush;
+    s->last_flush = flush;
+
+    /* Write the zlib header */
+    if (s->status == INIT_STATE) {
+
+        uInt header = (Z_DEFLATED + ((s->w_bits-8)<<4)) << 8;
+        uInt level_flags = (s->level-1) >> 1;
+
+        if (level_flags > 3) level_flags = 3;
+        header |= (level_flags << 6);
+	if (s->strstart != 0) header |= PRESET_DICT;
+        header += 31 - (header % 31);
+
+        s->status = BUSY_STATE;
+        putShortMSB(s, header);
+
+	/* Save the adler32 of the preset dictionary: */
+	if (s->strstart != 0) {
+	    putShortMSB(s, (uInt)(strm->adler >> 16));
+	    putShortMSB(s, (uInt)(strm->adler & 0xffff));
+	}
+	strm->adler = 1L;
+    }
+
+    /* Flush as much pending output as possible */
+    if (s->pending != 0) {
+        flush_pending(strm);
+        if (strm->avail_out == 0) {
+	    /* Since avail_out is 0, deflate will be called again with
+	     * more output space, but possibly with both pending and
+	     * avail_in equal to zero. There won't be anything to do,
+	     * but this is not an error situation so make sure we
+	     * return OK instead of BUF_ERROR at next call of deflate:
+             */
+	    s->last_flush = -1;
+	    return Z_OK;
+	}
+
+    /* Make sure there is something to do and avoid duplicate consecutive
+     * flushes. For repeated and useless calls with Z_FINISH, we keep
+     * returning Z_STREAM_END instead of Z_BUFF_ERROR.
+     */
+    } else if (strm->avail_in == 0 && flush <= old_flush &&
+	       flush != Z_FINISH) {
+        ERR_RETURN(strm, Z_BUF_ERROR);
+    }
+
+    /* User must not provide more input after the first FINISH: */
+    if (s->status == FINISH_STATE && strm->avail_in != 0) {
+        ERR_RETURN(strm, Z_BUF_ERROR);
+    }
+
+    /* Start a new block or continue the current one.
+     */
+    if (strm->avail_in != 0 || s->lookahead != 0 ||
+        (flush != Z_NO_FLUSH && s->status != FINISH_STATE)) {
+        block_state bstate;
+
+	bstate = (*(configuration_table[s->level].func))(s, flush);
+
+        if (bstate == finish_started || bstate == finish_done) {
+            s->status = FINISH_STATE;
+        }
+        if (bstate == need_more || bstate == finish_started) {
+	    if (strm->avail_out == 0) {
+	        s->last_flush = -1; /* avoid BUF_ERROR next call, see above */
+	    }
+	    return Z_OK;
+	    /* If flush != Z_NO_FLUSH && avail_out == 0, the next call
+	     * of deflate should use the same flush parameter to make sure
+	     * that the flush is complete. So we don't have to output an
+	     * empty block here, this will be done at next call. This also
+	     * ensures that for a very small output buffer, we emit at most
+	     * one empty block.
+	     */
+	}
+        if (bstate == block_done) {
+            if (flush == Z_PARTIAL_FLUSH) {
+                _tr_align(s);
+            } else { /* FULL_FLUSH or SYNC_FLUSH */
+                _tr_stored_block(s, (char*)0, 0L, 0);
+                /* For a full flush, this empty block will be recognized
+                 * as a special marker by inflate_sync().
+                 */
+                if (flush == Z_FULL_FLUSH) {
+                    CLEAR_HASH(s);             /* forget history */
+                }
+            }
+            flush_pending(strm);
+	    if (strm->avail_out == 0) {
+	      s->last_flush = -1; /* avoid BUF_ERROR at next call, see above */
+	      return Z_OK;
+	    }
+        }
+    }
+    Assert(strm->avail_out > 0, "bug2");
+
+    if (flush != Z_FINISH) return Z_OK;
+    if (s->noheader) return Z_STREAM_END;
+
+    /* Write the zlib trailer (adler32) */
+    putShortMSB(s, (uInt)(strm->adler >> 16));
+    putShortMSB(s, (uInt)(strm->adler & 0xffff));
+    flush_pending(strm);
+    /* If avail_out is zero, the application will call deflate again
+     * to flush the rest.
+     */
+    s->noheader = -1; /* write the trailer only once! */
+    return s->pending != 0 ? Z_OK : Z_STREAM_END;
+}
+
+/* ========================================================================= */
+int ZEXPORT deflateEnd (strm)
+    z_streamp strm;
+{
+    int status;
+
+    if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+
+    status = strm->state->status;
+    if (status != INIT_STATE && status != BUSY_STATE &&
+	status != FINISH_STATE) {
+      return Z_STREAM_ERROR;
+    }
+
+    /* Deallocate in reverse order of allocations: */
+    TRY_FREE(strm, strm->state->pending_buf);
+    TRY_FREE(strm, strm->state->head);
+    TRY_FREE(strm, strm->state->prev);
+    TRY_FREE(strm, strm->state->window);
+
+    ZFREE(strm, strm->state);
+    strm->state = Z_NULL;
+
+    return status == BUSY_STATE ? Z_DATA_ERROR : Z_OK;
+}
+
+/* =========================================================================
+ * Copy the source state to the destination state.
+ * To simplify the source, this is not supported for 16-bit MSDOS (which
+ * doesn't have enough memory anyway to duplicate compression states).
+ */
+int ZEXPORT deflateCopy (dest, source)
+    z_streamp dest;
+    z_streamp source;
+{
+#ifdef MAXSEG_64K
+    return Z_STREAM_ERROR;
+#else
+    deflate_state *ds;
+    deflate_state *ss;
+    ushf *overlay;
+
+
+    if (source == Z_NULL || dest == Z_NULL || source->state == Z_NULL) {
+        return Z_STREAM_ERROR;
+    }
+
+    ss = source->state;
+
+    *dest = *source;
+
+    ds = (deflate_state *) ZALLOC(dest, 1, sizeof(deflate_state));
+    if (ds == Z_NULL) return Z_MEM_ERROR;
+    dest->state = (struct internal_state FAR *) ds;
+    *ds = *ss;
+    ds->strm = dest;
+
+    ds->window = (Bytef *) ZALLOC(dest, ds->w_size, 2*sizeof(Byte));
+    ds->prev   = (Posf *)  ZALLOC(dest, ds->w_size, sizeof(Pos));
+    ds->head   = (Posf *)  ZALLOC(dest, ds->hash_size, sizeof(Pos));
+    overlay = (ushf *) ZALLOC(dest, ds->lit_bufsize, sizeof(ush)+2);
+    ds->pending_buf = (uchf *) overlay;
+
+    if (ds->window == Z_NULL || ds->prev == Z_NULL || ds->head == Z_NULL ||
+        ds->pending_buf == Z_NULL) {
+        deflateEnd (dest);
+        return Z_MEM_ERROR;
+    }
+    /* following zmemcpy do not work for 16-bit MSDOS */
+    zmemcpy(ds->window, ss->window, ds->w_size * 2 * sizeof(Byte));
+    zmemcpy(ds->prev, ss->prev, ds->w_size * sizeof(Pos));
+    zmemcpy(ds->head, ss->head, ds->hash_size * sizeof(Pos));
+    zmemcpy(ds->pending_buf, ss->pending_buf, (uInt)ds->pending_buf_size);
+
+    ds->pending_out = ds->pending_buf + (ss->pending_out - ss->pending_buf);
+    ds->d_buf = overlay + ds->lit_bufsize/sizeof(ush);
+    ds->l_buf = ds->pending_buf + (1+sizeof(ush))*ds->lit_bufsize;
+
+    ds->l_desc.dyn_tree = ds->dyn_ltree;
+    ds->d_desc.dyn_tree = ds->dyn_dtree;
+    ds->bl_desc.dyn_tree = ds->bl_tree;
+
+    return Z_OK;
+#endif
+}
+
+/* ===========================================================================
+ * Read a new buffer from the current input stream, update the adler32
+ * and total number of bytes read.  All deflate() input goes through
+ * this function so some applications may wish to modify it to avoid
+ * allocating a large strm->next_in buffer and copying from it.
+ * (See also flush_pending()).
+ */
+local int read_buf(strm, buf, size)
+    z_streamp strm;
+    Bytef *buf;
+    unsigned size;
+{
+    unsigned len = strm->avail_in;
+
+    if (len > size) len = size;
+    if (len == 0) return 0;
+
+    strm->avail_in  -= len;
+
+    if (!strm->state->noheader) {
+        strm->adler = adler32(strm->adler, strm->next_in, len);
+    }
+    zmemcpy(buf, strm->next_in, len);
+    strm->next_in  += len;
+    strm->total_in += len;
+
+    return (int)len;
+}
+
+/* ===========================================================================
+ * Initialize the "longest match" routines for a new zlib stream
+ */
+local void lm_init (s)
+    deflate_state *s;
+{
+    s->window_size = (ulg)2L*s->w_size;
+
+    CLEAR_HASH(s);
+
+    /* Set the default configuration parameters:
+     */
+    s->max_lazy_match   = configuration_table[s->level].max_lazy;
+    s->good_match       = configuration_table[s->level].good_length;
+    s->nice_match       = configuration_table[s->level].nice_length;
+    s->max_chain_length = configuration_table[s->level].max_chain;
+
+    s->strstart = 0;
+    s->block_start = 0L;
+    s->lookahead = 0;
+    s->match_length = s->prev_length = MIN_MATCH-1;
+    s->match_available = 0;
+    s->ins_h = 0;
+#ifdef ASMV
+    match_init(); /* initialize the asm code */
+#endif
+}
+
+/* ===========================================================================
+ * Set match_start to the longest match starting at the given string and
+ * return its length. Matches shorter or equal to prev_length are discarded,
+ * in which case the result is equal to prev_length and match_start is
+ * garbage.
+ * IN assertions: cur_match is the head of the hash chain for the current
+ *   string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1
+ * OUT assertion: the match length is not greater than s->lookahead.
+ */
+#ifndef ASMV
+/* For 80x86 and 680x0, an optimized version will be provided in match.asm or
+ * match.S. The code will be functionally equivalent.
+ */
+#ifndef FASTEST
+local uInt longest_match(s, cur_match)
+    deflate_state *s;
+    IPos cur_match;                             /* current match */
+{
+    unsigned chain_length = s->max_chain_length;/* max hash chain length */
+    register Bytef *scan = s->window + s->strstart; /* current string */
+    register Bytef *match;                       /* matched string */
+    register int len;                           /* length of current match */
+    int best_len = s->prev_length;              /* best match length so far */
+    int nice_match = s->nice_match;             /* stop if match long enough */
+    IPos limit = s->strstart > (IPos)MAX_DIST(s) ?
+        s->strstart - (IPos)MAX_DIST(s) : NIL;
+    /* Stop when cur_match becomes <= limit. To simplify the code,
+     * we prevent matches with the string of window index 0.
+     */
+    Posf *prev = s->prev;
+    uInt wmask = s->w_mask;
+
+#ifdef UNALIGNED_OK
+    /* Compare two bytes at a time. Note: this is not always beneficial.
+     * Try with and without -DUNALIGNED_OK to check.
+     */
+    register Bytef *strend = s->window + s->strstart + MAX_MATCH - 1;
+    register ush scan_start = *(ushf*)scan;
+    register ush scan_end   = *(ushf*)(scan+best_len-1);
+#else
+    register Bytef *strend = s->window + s->strstart + MAX_MATCH;
+    register Byte scan_end1  = scan[best_len-1];
+    register Byte scan_end   = scan[best_len];
+#endif
+
+    /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.
+     * It is easy to get rid of this optimization if necessary.
+     */
+    Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever");
+
+    /* Do not waste too much time if we already have a good match: */
+    if (s->prev_length >= s->good_match) {
+        chain_length >>= 2;
+    }
+    /* Do not look for matches beyond the end of the input. This is necessary
+     * to make deflate deterministic.
+     */
+    if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead;
+
+    Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead");
+
+    do {
+        Assert(cur_match < s->strstart, "no future");
+        match = s->window + cur_match;
+
+        /* Skip to next match if the match length cannot increase
+         * or if the match length is less than 2:
+         */
+#if (defined(UNALIGNED_OK) && MAX_MATCH == 258)
+        /* This code assumes sizeof(unsigned short) == 2. Do not use
+         * UNALIGNED_OK if your compiler uses a different size.
+         */
+        if (*(ushf*)(match+best_len-1) != scan_end ||
+            *(ushf*)match != scan_start) continue;
+
+        /* It is not necessary to compare scan[2] and match[2] since they are
+         * always equal when the other bytes match, given that the hash keys
+         * are equal and that HASH_BITS >= 8. Compare 2 bytes at a time at
+         * strstart+3, +5, ... up to strstart+257. We check for insufficient
+         * lookahead only every 4th comparison; the 128th check will be made
+         * at strstart+257. If MAX_MATCH-2 is not a multiple of 8, it is
+         * necessary to put more guard bytes at the end of the window, or
+         * to check more often for insufficient lookahead.
+         */
+        Assert(scan[2] == match[2], "scan[2]?");
+        scan++, match++;
+        do {
+        } while (*(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
+                 *(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
+                 *(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
+                 *(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
+                 scan < strend);
+        /* The funny "do {}" generates better code on most compilers */
+
+        /* Here, scan <= window+strstart+257 */
+        Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");
+        if (*scan == *match) scan++;
+
+        len = (MAX_MATCH - 1) - (int)(strend-scan);
+        scan = strend - (MAX_MATCH-1);
+
+#else /* UNALIGNED_OK */
+
+        if (match[best_len]   != scan_end  ||
+            match[best_len-1] != scan_end1 ||
+            *match            != *scan     ||
+            *++match          != scan[1])      continue;
+
+        /* The check at best_len-1 can be removed because it will be made
+         * again later. (This heuristic is not always a win.)
+         * It is not necessary to compare scan[2] and match[2] since they
+         * are always equal when the other bytes match, given that
+         * the hash keys are equal and that HASH_BITS >= 8.
+         */
+        scan += 2, match++;
+        Assert(*scan == *match, "match[2]?");
+
+        /* We check for insufficient lookahead only every 8th comparison;
+         * the 256th check will be made at strstart+258.
+         */
+        do {
+        } while (*++scan == *++match && *++scan == *++match &&
+                 *++scan == *++match && *++scan == *++match &&
+                 *++scan == *++match && *++scan == *++match &&
+                 *++scan == *++match && *++scan == *++match &&
+                 scan < strend);
+
+        Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");
+
+        len = MAX_MATCH - (int)(strend - scan);
+        scan = strend - MAX_MATCH;
+
+#endif /* UNALIGNED_OK */
+
+        if (len > best_len) {
+            s->match_start = cur_match;
+            best_len = len;
+            if (len >= nice_match) break;
+#ifdef UNALIGNED_OK
+            scan_end = *(ushf*)(scan+best_len-1);
+#else
+            scan_end1  = scan[best_len-1];
+            scan_end   = scan[best_len];
+#endif
+        }
+    } while ((cur_match = prev[cur_match & wmask]) > limit
+             && --chain_length != 0);
+
+    if ((uInt)best_len <= s->lookahead) return (uInt)best_len;
+    return s->lookahead;
+}
+
+#else /* FASTEST */
+/* ---------------------------------------------------------------------------
+ * Optimized version for level == 1 only
+ */
+local uInt longest_match(s, cur_match)
+    deflate_state *s;
+    IPos cur_match;                             /* current match */
+{
+    register Bytef *scan = s->window + s->strstart; /* current string */
+    register Bytef *match;                       /* matched string */
+    register int len;                           /* length of current match */
+    register Bytef *strend = s->window + s->strstart + MAX_MATCH;
+
+    /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.
+     * It is easy to get rid of this optimization if necessary.
+     */
+    Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever");
+
+    Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead");
+
+    Assert(cur_match < s->strstart, "no future");
+
+    match = s->window + cur_match;
+
+    /* Return failure if the match length is less than 2:
+     */
+    if (match[0] != scan[0] || match[1] != scan[1]) return MIN_MATCH-1;
+
+    /* The check at best_len-1 can be removed because it will be made
+     * again later. (This heuristic is not always a win.)
+     * It is not necessary to compare scan[2] and match[2] since they
+     * are always equal when the other bytes match, given that
+     * the hash keys are equal and that HASH_BITS >= 8.
+     */
+    scan += 2, match += 2;
+    Assert(*scan == *match, "match[2]?");
+
+    /* We check for insufficient lookahead only every 8th comparison;
+     * the 256th check will be made at strstart+258.
+     */
+    do {
+    } while (*++scan == *++match && *++scan == *++match &&
+	     *++scan == *++match && *++scan == *++match &&
+	     *++scan == *++match && *++scan == *++match &&
+	     *++scan == *++match && *++scan == *++match &&
+	     scan < strend);
+
+    Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");
+
+    len = MAX_MATCH - (int)(strend - scan);
+
+    if (len < MIN_MATCH) return MIN_MATCH - 1;
+
+    s->match_start = cur_match;
+    return len <= s->lookahead ? len : s->lookahead;
+}
+#endif /* FASTEST */
+#endif /* ASMV */
+
+#ifdef DEBUG
+/* ===========================================================================
+ * Check that the match at match_start is indeed a match.
+ */
+local void check_match(s, start, match, length)
+    deflate_state *s;
+    IPos start, match;
+    int length;
+{
+    /* check that the match is indeed a match */
+    if (zmemcmp(s->window + match,
+                s->window + start, length) != EQUAL) {
+        fprintf(stderr, " start %u, match %u, length %d\n",
+		start, match, length);
+        do {
+	    fprintf(stderr, "%c%c", s->window[match++], s->window[start++]);
+	} while (--length != 0);
+        z_error("invalid match");
+    }
+    if (z_verbose > 1) {
+        fprintf(stderr,"\\[%d,%d]", start-match, length);
+        do { putc(s->window[start++], stderr); } while (--length != 0);
+    }
+}
+#else
+#  define check_match(s, start, match, length)
+#endif
+
+/* ===========================================================================
+ * Fill the window when the lookahead becomes insufficient.
+ * Updates strstart and lookahead.
+ *
+ * IN assertion: lookahead < MIN_LOOKAHEAD
+ * OUT assertions: strstart <= window_size-MIN_LOOKAHEAD
+ *    At least one byte has been read, or avail_in == 0; reads are
+ *    performed for at least two bytes (required for the zip translate_eol
+ *    option -- not supported here).
+ */
+local void fill_window(s)
+    deflate_state *s;
+{
+    register unsigned n, m;
+    register Posf *p;
+    unsigned more;    /* Amount of free space at the end of the window. */
+    uInt wsize = s->w_size;
+
+    do {
+        more = (unsigned)(s->window_size -(ulg)s->lookahead -(ulg)s->strstart);
+
+        /* Deal with !@#$% 64K limit: */
+        if (more == 0 && s->strstart == 0 && s->lookahead == 0) {
+            more = wsize;
+
+        } else if (more == (unsigned)(-1)) {
+            /* Very unlikely, but possible on 16 bit machine if strstart == 0
+             * and lookahead == 1 (input done one byte at time)
+             */
+            more--;
+
+        /* If the window is almost full and there is insufficient lookahead,
+         * move the upper half to the lower one to make room in the upper half.
+         */
+        } else if (s->strstart >= wsize+MAX_DIST(s)) {
+
+            zmemcpy(s->window, s->window+wsize, (unsigned)wsize);
+            s->match_start -= wsize;
+            s->strstart    -= wsize; /* we now have strstart >= MAX_DIST */
+            s->block_start -= (long) wsize;
+
+            /* Slide the hash table (could be avoided with 32 bit values
+               at the expense of memory usage). We slide even when level == 0
+               to keep the hash table consistent if we switch back to level > 0
+               later. (Using level 0 permanently is not an optimal usage of
+               zlib, so we don't care about this pathological case.)
+             */
+	    n = s->hash_size;
+	    p = &s->head[n];
+	    do {
+		m = *--p;
+		*p = (Pos)(m >= wsize ? m-wsize : NIL);
+	    } while (--n);
+
+	    n = wsize;
+#ifndef FASTEST
+	    p = &s->prev[n];
+	    do {
+		m = *--p;
+		*p = (Pos)(m >= wsize ? m-wsize : NIL);
+		/* If n is not on any hash chain, prev[n] is garbage but
+		 * its value will never be used.
+		 */
+	    } while (--n);
+#endif
+            more += wsize;
+        }
+        if (s->strm->avail_in == 0) return;
+
+        /* If there was no sliding:
+         *    strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 &&
+         *    more == window_size - lookahead - strstart
+         * => more >= window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1)
+         * => more >= window_size - 2*WSIZE + 2
+         * In the BIG_MEM or MMAP case (not yet supported),
+         *   window_size == input_size + MIN_LOOKAHEAD  &&
+         *   strstart + s->lookahead <= input_size => more >= MIN_LOOKAHEAD.
+         * Otherwise, window_size == 2*WSIZE so more >= 2.
+         * If there was sliding, more >= WSIZE. So in all cases, more >= 2.
+         */
+        Assert(more >= 2, "more < 2");
+
+        n = read_buf(s->strm, s->window + s->strstart + s->lookahead, more);
+        s->lookahead += n;
+
+        /* Initialize the hash value now that we have some input: */
+        if (s->lookahead >= MIN_MATCH) {
+            s->ins_h = s->window[s->strstart];
+            UPDATE_HASH(s, s->ins_h, s->window[s->strstart+1]);
+#if MIN_MATCH != 3
+            Call UPDATE_HASH() MIN_MATCH-3 more times
+#endif
+        }
+        /* If the whole input has less than MIN_MATCH bytes, ins_h is garbage,
+         * but this is not important since only literal bytes will be emitted.
+         */
+
+    } while (s->lookahead < MIN_LOOKAHEAD && s->strm->avail_in != 0);
+}
+
+/* ===========================================================================
+ * Flush the current block, with given end-of-file flag.
+ * IN assertion: strstart is set to the end of the current match.
+ */
+#define FLUSH_BLOCK_ONLY(s, eof) { \
+   _tr_flush_block(s, (s->block_start >= 0L ? \
+                   (charf *)&s->window[(unsigned)s->block_start] : \
+                   (charf *)Z_NULL), \
+		(ulg)((long)s->strstart - s->block_start), \
+		(eof)); \
+   s->block_start = s->strstart; \
+   flush_pending(s->strm); \
+   Tracev((stderr,"[FLUSH]")); \
+}
+
+/* Same but force premature exit if necessary. */
+#define FLUSH_BLOCK(s, eof) { \
+   FLUSH_BLOCK_ONLY(s, eof); \
+   if (s->strm->avail_out == 0) return (eof) ? finish_started : need_more; \
+}
+
+/* ===========================================================================
+ * Copy without compression as much as possible from the input stream, return
+ * the current block state.
+ * This function does not insert new strings in the dictionary since
+ * uncompressible data is probably not useful. This function is used
+ * only for the level=0 compression option.
+ * NOTE: this function should be optimized to avoid extra copying from
+ * window to pending_buf.
+ */
+local block_state deflate_stored(s, flush)
+    deflate_state *s;
+    int flush;
+{
+    /* Stored blocks are limited to 0xffff bytes, pending_buf is limited
+     * to pending_buf_size, and each stored block has a 5 byte header:
+     */
+    ulg max_block_size = 0xffff;
+    ulg max_start;
+
+    if (max_block_size > s->pending_buf_size - 5) {
+        max_block_size = s->pending_buf_size - 5;
+    }
+
+    /* Copy as much as possible from input to output: */
+    for (;;) {
+        /* Fill the window as much as possible: */
+        if (s->lookahead <= 1) {
+
+            Assert(s->strstart < s->w_size+MAX_DIST(s) ||
+		   s->block_start >= (long)s->w_size, "slide too late");
+
+            fill_window(s);
+            if (s->lookahead == 0 && flush == Z_NO_FLUSH) return need_more;
+
+            if (s->lookahead == 0) break; /* flush the current block */
+        }
+	Assert(s->block_start >= 0L, "block gone");
+
+	s->strstart += s->lookahead;
+	s->lookahead = 0;
+
+	/* Emit a stored block if pending_buf will be full: */
+ 	max_start = s->block_start + max_block_size;
+        if (s->strstart == 0 || (ulg)s->strstart >= max_start) {
+	    /* strstart == 0 is possible when wraparound on 16-bit machine */
+	    s->lookahead = (uInt)(s->strstart - max_start);
+	    s->strstart = (uInt)max_start;
+            FLUSH_BLOCK(s, 0);
+	}
+	/* Flush if we may have to slide, otherwise block_start may become
+         * negative and the data will be gone:
+         */
+        if (s->strstart - (uInt)s->block_start >= MAX_DIST(s)) {
+            FLUSH_BLOCK(s, 0);
+	}
+    }
+    FLUSH_BLOCK(s, flush == Z_FINISH);
+    return flush == Z_FINISH ? finish_done : block_done;
+}
+
+/* ===========================================================================
+ * Compress as much as possible from the input stream, return the current
+ * block state.
+ * This function does not perform lazy evaluation of matches and inserts
+ * new strings in the dictionary only for unmatched strings or for short
+ * matches. It is used only for the fast compression options.
+ */
+local block_state deflate_fast(s, flush)
+    deflate_state *s;
+    int flush;
+{
+    IPos hash_head = NIL; /* head of the hash chain */
+    int bflush;           /* set if current block must be flushed */
+
+    for (;;) {
+        /* Make sure that we always have enough lookahead, except
+         * at the end of the input file. We need MAX_MATCH bytes
+         * for the next match, plus MIN_MATCH bytes to insert the
+         * string following the next match.
+         */
+        if (s->lookahead < MIN_LOOKAHEAD) {
+            fill_window(s);
+            if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) {
+	        return need_more;
+	    }
+            if (s->lookahead == 0) break; /* flush the current block */
+        }
+
+        /* Insert the string window[strstart .. strstart+2] in the
+         * dictionary, and set hash_head to the head of the hash chain:
+         */
+        if (s->lookahead >= MIN_MATCH) {
+            INSERT_STRING(s, s->strstart, hash_head);
+        }
+
+        /* Find the longest match, discarding those <= prev_length.
+         * At this point we have always match_length < MIN_MATCH
+         */
+        if (hash_head != NIL && s->strstart - hash_head <= MAX_DIST(s)) {
+            /* To simplify the code, we prevent matches with the string
+             * of window index 0 (in particular we have to avoid a match
+             * of the string with itself at the start of the input file).
+             */
+            if (s->strategy != Z_HUFFMAN_ONLY) {
+                s->match_length = longest_match (s, hash_head);
+            }
+            /* longest_match() sets match_start */
+        }
+        if (s->match_length >= MIN_MATCH) {
+            check_match(s, s->strstart, s->match_start, s->match_length);
+
+            _tr_tally_dist(s, s->strstart - s->match_start,
+                           s->match_length - MIN_MATCH, bflush);
+
+            s->lookahead -= s->match_length;
+
+            /* Insert new strings in the hash table only if the match length
+             * is not too large. This saves time but degrades compression.
+             */
+#ifndef FASTEST
+            if (s->match_length <= s->max_insert_length &&
+                s->lookahead >= MIN_MATCH) {
+                s->match_length--; /* string at strstart already in hash table */
+                do {
+                    s->strstart++;
+                    INSERT_STRING(s, s->strstart, hash_head);
+                    /* strstart never exceeds WSIZE-MAX_MATCH, so there are
+                     * always MIN_MATCH bytes ahead.
+                     */
+                } while (--s->match_length != 0);
+                s->strstart++; 
+            } else
+#endif
+	    {
+                s->strstart += s->match_length;
+                s->match_length = 0;
+                s->ins_h = s->window[s->strstart];
+                UPDATE_HASH(s, s->ins_h, s->window[s->strstart+1]);
+#if MIN_MATCH != 3
+                Call UPDATE_HASH() MIN_MATCH-3 more times
+#endif
+                /* If lookahead < MIN_MATCH, ins_h is garbage, but it does not
+                 * matter since it will be recomputed at next deflate call.
+                 */
+            }
+        } else {
+            /* No match, output a literal byte */
+            Tracevv((stderr,"%c", s->window[s->strstart]));
+            _tr_tally_lit (s, s->window[s->strstart], bflush);
+            s->lookahead--;
+            s->strstart++; 
+        }
+        if (bflush) FLUSH_BLOCK(s, 0);
+    }
+    FLUSH_BLOCK(s, flush == Z_FINISH);
+    return flush == Z_FINISH ? finish_done : block_done;
+}
+
+/* ===========================================================================
+ * Same as above, but achieves better compression. We use a lazy
+ * evaluation for matches: a match is finally adopted only if there is
+ * no better match at the next window position.
+ */
+local block_state deflate_slow(s, flush)
+    deflate_state *s;
+    int flush;
+{
+    IPos hash_head = NIL;    /* head of hash chain */
+    int bflush;              /* set if current block must be flushed */
+
+    /* Process the input block. */
+    for (;;) {
+        /* Make sure that we always have enough lookahead, except
+         * at the end of the input file. We need MAX_MATCH bytes
+         * for the next match, plus MIN_MATCH bytes to insert the
+         * string following the next match.
+         */
+        if (s->lookahead < MIN_LOOKAHEAD) {
+            fill_window(s);
+            if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) {
+	        return need_more;
+	    }
+            if (s->lookahead == 0) break; /* flush the current block */
+        }
+
+        /* Insert the string window[strstart .. strstart+2] in the
+         * dictionary, and set hash_head to the head of the hash chain:
+         */
+        if (s->lookahead >= MIN_MATCH) {
+            INSERT_STRING(s, s->strstart, hash_head);
+        }
+
+        /* Find the longest match, discarding those <= prev_length.
+         */
+        s->prev_length = s->match_length, s->prev_match = s->match_start;
+        s->match_length = MIN_MATCH-1;
+
+        if (hash_head != NIL && s->prev_length < s->max_lazy_match &&
+            s->strstart - hash_head <= MAX_DIST(s)) {
+            /* To simplify the code, we prevent matches with the string
+             * of window index 0 (in particular we have to avoid a match
+             * of the string with itself at the start of the input file).
+             */
+            if (s->strategy != Z_HUFFMAN_ONLY) {
+                s->match_length = longest_match (s, hash_head);
+            }
+            /* longest_match() sets match_start */
+
+            if (s->match_length <= 5 && (s->strategy == Z_FILTERED ||
+                 (s->match_length == MIN_MATCH &&
+                  s->strstart - s->match_start > TOO_FAR))) {
+
+                /* If prev_match is also MIN_MATCH, match_start is garbage
+                 * but we will ignore the current match anyway.
+                 */
+                s->match_length = MIN_MATCH-1;
+            }
+        }
+        /* If there was a match at the previous step and the current
+         * match is not better, output the previous match:
+         */
+        if (s->prev_length >= MIN_MATCH && s->match_length <= s->prev_length) {
+            uInt max_insert = s->strstart + s->lookahead - MIN_MATCH;
+            /* Do not insert strings in hash table beyond this. */
+
+            check_match(s, s->strstart-1, s->prev_match, s->prev_length);
+
+            _tr_tally_dist(s, s->strstart -1 - s->prev_match,
+			   s->prev_length - MIN_MATCH, bflush);
+
+            /* Insert in hash table all strings up to the end of the match.
+             * strstart-1 and strstart are already inserted. If there is not
+             * enough lookahead, the last two strings are not inserted in
+             * the hash table.
+             */
+            s->lookahead -= s->prev_length-1;
+            s->prev_length -= 2;
+            do {
+                if (++s->strstart <= max_insert) {
+                    INSERT_STRING(s, s->strstart, hash_head);
+                }
+            } while (--s->prev_length != 0);
+            s->match_available = 0;
+            s->match_length = MIN_MATCH-1;
+            s->strstart++;
+
+            if (bflush) FLUSH_BLOCK(s, 0);
+
+        } else if (s->match_available) {
+            /* If there was no match at the previous position, output a
+             * single literal. If there was a match but the current match
+             * is longer, truncate the previous match to a single literal.
+             */
+            Tracevv((stderr,"%c", s->window[s->strstart-1]));
+	    _tr_tally_lit(s, s->window[s->strstart-1], bflush);
+	    if (bflush) {
+                FLUSH_BLOCK_ONLY(s, 0);
+            }
+            s->strstart++;
+            s->lookahead--;
+            if (s->strm->avail_out == 0) return need_more;
+        } else {
+            /* There is no previous match to compare with, wait for
+             * the next step to decide.
+             */
+            s->match_available = 1;
+            s->strstart++;
+            s->lookahead--;
+        }
+    }
+    Assert (flush != Z_NO_FLUSH, "no flush?");
+    if (s->match_available) {
+        Tracevv((stderr,"%c", s->window[s->strstart-1]));
+        _tr_tally_lit(s, s->window[s->strstart-1], bflush);
+        s->match_available = 0;
+    }
+    FLUSH_BLOCK(s, flush == Z_FINISH);
+    return flush == Z_FINISH ? finish_done : block_done;
+}
diff --git a/src/libz/src/deflate.h b/src/libz/src/deflate.h
new file mode 100644
index 0000000..f969d6f
--- /dev/null
+++ b/src/libz/src/deflate.h
@@ -0,0 +1,318 @@
+/* deflate.h -- internal compression state
+ * Copyright (C) 1995-2002 Jean-loup Gailly
+ * For conditions of distribution and use, see copyright notice in zlib.h 
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+   part of the implementation of the compression library and is
+   subject to change. Applications should only use zlib.h.
+ */
+
+/* @(#) $Id: deflate.h,v 1.1 2008/11/12 02:25:24 agibert Exp $ */
+
+#ifndef _DEFLATE_H
+#define _DEFLATE_H
+
+#include "zutil.h"
+
+/* ===========================================================================
+ * Internal compression state.
+ */
+
+#define LENGTH_CODES 29
+/* number of length codes, not counting the special END_BLOCK code */
+
+#define LITERALS  256
+/* number of literal bytes 0..255 */
+
+#define L_CODES (LITERALS+1+LENGTH_CODES)
+/* number of Literal or Length codes, including the END_BLOCK code */
+
+#define D_CODES   30
+/* number of distance codes */
+
+#define BL_CODES  19
+/* number of codes used to transfer the bit lengths */
+
+#define HEAP_SIZE (2*L_CODES+1)
+/* maximum heap size */
+
+#define MAX_BITS 15
+/* All codes must not exceed MAX_BITS bits */
+
+#define INIT_STATE    42
+#define BUSY_STATE   113
+#define FINISH_STATE 666
+/* Stream status */
+
+
+/* Data structure describing a single value and its code string. */
+typedef struct ct_data_s {
+    union {
+        ush  freq;       /* frequency count */
+        ush  code;       /* bit string */
+    } fc;
+    union {
+        ush  dad;        /* father node in Huffman tree */
+        ush  len;        /* length of bit string */
+    } dl;
+} FAR ct_data;
+
+#define Freq fc.freq
+#define Code fc.code
+#define Dad  dl.dad
+#define Len  dl.len
+
+typedef struct static_tree_desc_s  static_tree_desc;
+
+typedef struct tree_desc_s {
+    ct_data *dyn_tree;           /* the dynamic tree */
+    int     max_code;            /* largest code with non zero frequency */
+    static_tree_desc *stat_desc; /* the corresponding static tree */
+} FAR tree_desc;
+
+typedef ush Pos;
+typedef Pos FAR Posf;
+typedef unsigned IPos;
+
+/* A Pos is an index in the character window. We use short instead of int to
+ * save space in the various tables. IPos is used only for parameter passing.
+ */
+
+typedef struct internal_state {
+    z_streamp strm;      /* pointer back to this zlib stream */
+    int   status;        /* as the name implies */
+    Bytef *pending_buf;  /* output still pending */
+    ulg   pending_buf_size; /* size of pending_buf */
+    Bytef *pending_out;  /* next pending byte to output to the stream */
+    int   pending;       /* nb of bytes in the pending buffer */
+    int   noheader;      /* suppress zlib header and adler32 */
+    Byte  data_type;     /* UNKNOWN, BINARY or ASCII */
+    Byte  method;        /* STORED (for zip only) or DEFLATED */
+    int   last_flush;    /* value of flush param for previous deflate call */
+
+                /* used by deflate.c: */
+
+    uInt  w_size;        /* LZ77 window size (32K by default) */
+    uInt  w_bits;        /* log2(w_size)  (8..16) */
+    uInt  w_mask;        /* w_size - 1 */
+
+    Bytef *window;
+    /* Sliding window. Input bytes are read into the second half of the window,
+     * and move to the first half later to keep a dictionary of at least wSize
+     * bytes. With this organization, matches are limited to a distance of
+     * wSize-MAX_MATCH bytes, but this ensures that IO is always
+     * performed with a length multiple of the block size. Also, it limits
+     * the window size to 64K, which is quite useful on MSDOS.
+     * To do: use the user input buffer as sliding window.
+     */
+
+    ulg window_size;
+    /* Actual size of window: 2*wSize, except when the user input buffer
+     * is directly used as sliding window.
+     */
+
+    Posf *prev;
+    /* Link to older string with same hash index. To limit the size of this
+     * array to 64K, this link is maintained only for the last 32K strings.
+     * An index in this array is thus a window index modulo 32K.
+     */
+
+    Posf *head; /* Heads of the hash chains or NIL. */
+
+    uInt  ins_h;          /* hash index of string to be inserted */
+    uInt  hash_size;      /* number of elements in hash table */
+    uInt  hash_bits;      /* log2(hash_size) */
+    uInt  hash_mask;      /* hash_size-1 */
+
+    uInt  hash_shift;
+    /* Number of bits by which ins_h must be shifted at each input
+     * step. It must be such that after MIN_MATCH steps, the oldest
+     * byte no longer takes part in the hash key, that is:
+     *   hash_shift * MIN_MATCH >= hash_bits
+     */
+
+    long block_start;
+    /* Window position at the beginning of the current output block. Gets
+     * negative when the window is moved backwards.
+     */
+
+    uInt match_length;           /* length of best match */
+    IPos prev_match;             /* previous match */
+    int match_available;         /* set if previous match exists */
+    uInt strstart;               /* start of string to insert */
+    uInt match_start;            /* start of matching string */
+    uInt lookahead;              /* number of valid bytes ahead in window */
+
+    uInt prev_length;
+    /* Length of the best match at previous step. Matches not greater than this
+     * are discarded. This is used in the lazy match evaluation.
+     */
+
+    uInt max_chain_length;
+    /* To speed up deflation, hash chains are never searched beyond this
+     * length.  A higher limit improves compression ratio but degrades the
+     * speed.
+     */
+
+    uInt max_lazy_match;
+    /* Attempt to find a better match only when the current match is strictly
+     * smaller than this value. This mechanism is used only for compression
+     * levels >= 4.
+     */
+#   define max_insert_length  max_lazy_match
+    /* Insert new strings in the hash table only if the match length is not
+     * greater than this length. This saves time but degrades compression.
+     * max_insert_length is used only for compression levels <= 3.
+     */
+
+    int level;    /* compression level (1..9) */
+    int strategy; /* favor or force Huffman coding*/
+
+    uInt good_match;
+    /* Use a faster search when the previous match is longer than this */
+
+    int nice_match; /* Stop searching when current match exceeds this */
+
+                /* used by trees.c: */
+    /* Didn't use ct_data typedef below to supress compiler warning */
+    struct ct_data_s dyn_ltree[HEAP_SIZE];   /* literal and length tree */
+    struct ct_data_s dyn_dtree[2*D_CODES+1]; /* distance tree */
+    struct ct_data_s bl_tree[2*BL_CODES+1];  /* Huffman tree for bit lengths */
+
+    struct tree_desc_s l_desc;               /* desc. for literal tree */
+    struct tree_desc_s d_desc;               /* desc. for distance tree */
+    struct tree_desc_s bl_desc;              /* desc. for bit length tree */
+
+    ush bl_count[MAX_BITS+1];
+    /* number of codes at each bit length for an optimal tree */
+
+    int heap[2*L_CODES+1];      /* heap used to build the Huffman trees */
+    int heap_len;               /* number of elements in the heap */
+    int heap_max;               /* element of largest frequency */
+    /* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used.
+     * The same heap array is used to build all trees.
+     */
+
+    uch depth[2*L_CODES+1];
+    /* Depth of each subtree used as tie breaker for trees of equal frequency
+     */
+
+    uchf *l_buf;          /* buffer for literals or lengths */
+
+    uInt  lit_bufsize;
+    /* Size of match buffer for literals/lengths.  There are 4 reasons for
+     * limiting lit_bufsize to 64K:
+     *   - frequencies can be kept in 16 bit counters
+     *   - if compression is not successful for the first block, all input
+     *     data is still in the window so we can still emit a stored block even
+     *     when input comes from standard input.  (This can also be done for
+     *     all blocks if lit_bufsize is not greater than 32K.)
+     *   - if compression is not successful for a file smaller than 64K, we can
+     *     even emit a stored file instead of a stored block (saving 5 bytes).
+     *     This is applicable only for zip (not gzip or zlib).
+     *   - creating new Huffman trees less frequently may not provide fast
+     *     adaptation to changes in the input data statistics. (Take for
+     *     example a binary file with poorly compressible code followed by
+     *     a highly compressible string table.) Smaller buffer sizes give
+     *     fast adaptation but have of course the overhead of transmitting
+     *     trees more frequently.
+     *   - I can't count above 4
+     */
+
+    uInt last_lit;      /* running index in l_buf */
+
+    ushf *d_buf;
+    /* Buffer for distances. To simplify the code, d_buf and l_buf have
+     * the same number of elements. To use different lengths, an extra flag
+     * array would be necessary.
+     */
+
+    ulg opt_len;        /* bit length of current block with optimal trees */
+    ulg static_len;     /* bit length of current block with static trees */
+    uInt matches;       /* number of string matches in current block */
+    int last_eob_len;   /* bit length of EOB code for last block */
+
+#ifdef DEBUG
+    ulg compressed_len; /* total bit length of compressed file mod 2^32 */
+    ulg bits_sent;      /* bit length of compressed data sent mod 2^32 */
+#endif
+
+    ush bi_buf;
+    /* Output buffer. bits are inserted starting at the bottom (least
+     * significant bits).
+     */
+    int bi_valid;
+    /* Number of valid bits in bi_buf.  All bits above the last valid bit
+     * are always zero.
+     */
+
+} FAR deflate_state;
+
+/* Output a byte on the stream.
+ * IN assertion: there is enough room in pending_buf.
+ */
+#define put_byte(s, c) {s->pending_buf[s->pending++] = (c);}
+
+
+#define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1)
+/* Minimum amount of lookahead, except at the end of the input file.
+ * See deflate.c for comments about the MIN_MATCH+1.
+ */
+
+#define MAX_DIST(s)  ((s)->w_size-MIN_LOOKAHEAD)
+/* In order to simplify the code, particularly on 16 bit machines, match
+ * distances are limited to MAX_DIST instead of WSIZE.
+ */
+
+        /* in trees.c */
+void _tr_init         OF((deflate_state *s));
+int  _tr_tally        OF((deflate_state *s, unsigned dist, unsigned lc));
+void _tr_flush_block  OF((deflate_state *s, charf *buf, ulg stored_len,
+			  int eof));
+void _tr_align        OF((deflate_state *s));
+void _tr_stored_block OF((deflate_state *s, charf *buf, ulg stored_len,
+                          int eof));
+
+#define d_code(dist) \
+   ((dist) < 256 ? _dist_code[dist] : _dist_code[256+((dist)>>7)])
+/* Mapping from a distance to a distance code. dist is the distance - 1 and
+ * must not have side effects. _dist_code[256] and _dist_code[257] are never
+ * used.
+ */
+
+#ifndef DEBUG
+/* Inline versions of _tr_tally for speed: */
+
+#if defined(GEN_TREES_H) || !defined(STDC)
+  extern uch _length_code[];
+  extern uch _dist_code[];
+#else
+  extern const uch _length_code[];
+  extern const uch _dist_code[];
+#endif
+
+# define _tr_tally_lit(s, c, flush) \
+  { uch cc = (c); \
+    s->d_buf[s->last_lit] = 0; \
+    s->l_buf[s->last_lit++] = cc; \
+    s->dyn_ltree[cc].Freq++; \
+    flush = (s->last_lit == s->lit_bufsize-1); \
+   }
+# define _tr_tally_dist(s, distance, length, flush) \
+  { uch len = (length); \
+    ush dist = (distance); \
+    s->d_buf[s->last_lit] = dist; \
+    s->l_buf[s->last_lit++] = len; \
+    dist--; \
+    s->dyn_ltree[_length_code[len]+LITERALS+1].Freq++; \
+    s->dyn_dtree[d_code(dist)].Freq++; \
+    flush = (s->last_lit == s->lit_bufsize-1); \
+  }
+#else
+# define _tr_tally_lit(s, c, flush) flush = _tr_tally(s, 0, c)
+# define _tr_tally_dist(s, distance, length, flush) \
+              flush = _tr_tally(s, distance, length) 
+#endif
+
+#endif
diff --git a/src/libz/src/example.c b/src/libz/src/example.c
new file mode 100644
index 0000000..9208ca6
--- /dev/null
+++ b/src/libz/src/example.c
@@ -0,0 +1,556 @@
+/* example.c -- usage example of the zlib compression library
+ * Copyright (C) 1995-2002 Jean-loup Gailly.
+ * For conditions of distribution and use, see copyright notice in zlib.h 
+ */
+
+/* @(#) $Id: example.c,v 1.1 2008/11/12 02:25:24 agibert Exp $ */
+
+#include <stdio.h>
+#include "zlib.h"
+
+#ifdef STDC
+#  include <string.h>
+#  include <stdlib.h>
+#else
+   extern void exit  OF((int));
+#endif
+
+#if defined(VMS) || defined(RISCOS)
+#  define TESTFILE "foo-gz"
+#else
+#  define TESTFILE "foo.gz"
+#endif
+
+#define CHECK_ERR(err, msg) { \
+    if (err != Z_OK) { \
+        fprintf(stderr, "%s error: %d\n", msg, err); \
+        exit(1); \
+    } \
+}
+
+const char hello[] = "hello, hello!";
+/* "hello world" would be more standard, but the repeated "hello"
+ * stresses the compression code better, sorry...
+ */
+
+const char dictionary[] = "hello";
+uLong dictId; /* Adler32 value of the dictionary */
+
+void test_compress      OF((Byte *compr, uLong comprLen,
+		            Byte *uncompr, uLong uncomprLen));
+void test_gzio          OF((const char *out, const char *in, 
+		            Byte *uncompr, int uncomprLen));
+void test_deflate       OF((Byte *compr, uLong comprLen));
+void test_inflate       OF((Byte *compr, uLong comprLen,
+		            Byte *uncompr, uLong uncomprLen));
+void test_large_deflate OF((Byte *compr, uLong comprLen,
+		            Byte *uncompr, uLong uncomprLen));
+void test_large_inflate OF((Byte *compr, uLong comprLen,
+		            Byte *uncompr, uLong uncomprLen));
+void test_flush         OF((Byte *compr, uLong *comprLen));
+void test_sync          OF((Byte *compr, uLong comprLen,
+		            Byte *uncompr, uLong uncomprLen));
+void test_dict_deflate  OF((Byte *compr, uLong comprLen));
+void test_dict_inflate  OF((Byte *compr, uLong comprLen,
+		            Byte *uncompr, uLong uncomprLen));
+int  main               OF((int argc, char *argv[]));
+
+/* ===========================================================================
+ * Test compress() and uncompress()
+ */
+void test_compress(compr, comprLen, uncompr, uncomprLen)
+    Byte *compr, *uncompr;
+    uLong comprLen, uncomprLen;
+{
+    int err;
+    uLong len = strlen(hello)+1;
+
+    err = compress(compr, &comprLen, (const Bytef*)hello, len);
+    CHECK_ERR(err, "compress");
+
+    strcpy((char*)uncompr, "garbage");
+
+    err = uncompress(uncompr, &uncomprLen, compr, comprLen);
+    CHECK_ERR(err, "uncompress");
+
+    if (strcmp((char*)uncompr, hello)) {
+        fprintf(stderr, "bad uncompress\n");
+	exit(1);
+    } else {
+        printf("uncompress(): %s\n", (char *)uncompr);
+    }
+}
+
+/* ===========================================================================
+ * Test read/write of .gz files
+ */
+void test_gzio(out, in, uncompr, uncomprLen)
+    const char *out; /* compressed output file */
+    const char *in;  /* compressed input file */
+    Byte *uncompr;
+    int  uncomprLen;
+{
+    int err;
+    int len = strlen(hello)+1;
+    gzFile file;
+    z_off_t pos;
+
+    file = gzopen(out, "wb");
+    if (file == NULL) {
+        fprintf(stderr, "gzopen error\n");
+        exit(1);
+    }
+    gzputc(file, 'h');
+    if (gzputs(file, "ello") != 4) {
+        fprintf(stderr, "gzputs err: %s\n", gzerror(file, &err));
+	exit(1);
+    }
+    if (gzprintf(file, ", %s!", "hello") != 8) {
+        fprintf(stderr, "gzprintf err: %s\n", gzerror(file, &err));
+	exit(1);
+    }
+    gzseek(file, 1L, SEEK_CUR); /* add one zero byte */
+    gzclose(file);
+
+    file = gzopen(in, "rb");
+    if (file == NULL) {
+        fprintf(stderr, "gzopen error\n");
+    }
+    strcpy((char*)uncompr, "garbage");
+
+    uncomprLen = gzread(file, uncompr, (unsigned)uncomprLen);
+    if (uncomprLen != len) {
+        fprintf(stderr, "gzread err: %s\n", gzerror(file, &err));
+	exit(1);
+    }
+    if (strcmp((char*)uncompr, hello)) {
+        fprintf(stderr, "bad gzread: %s\n", (char*)uncompr);
+	exit(1);
+    } else {
+        printf("gzread(): %s\n", (char *)uncompr);
+    }
+
+    pos = gzseek(file, -8L, SEEK_CUR);
+    if (pos != 6 || gztell(file) != pos) {
+	fprintf(stderr, "gzseek error, pos=%ld, gztell=%ld\n",
+		(long)pos, (long)gztell(file));
+	exit(1);
+    }
+
+    if (gzgetc(file) != ' ') {
+	fprintf(stderr, "gzgetc error\n");
+	exit(1);
+    }
+
+    gzgets(file, (char*)uncompr, uncomprLen);
+    uncomprLen = strlen((char*)uncompr);
+    if (uncomprLen != 6) { /* "hello!" */
+        fprintf(stderr, "gzgets err after gzseek: %s\n", gzerror(file, &err));
+	exit(1);
+    }
+    if (strcmp((char*)uncompr, hello+7)) {
+        fprintf(stderr, "bad gzgets after gzseek\n");
+	exit(1);
+    } else {
+        printf("gzgets() after gzseek: %s\n", (char *)uncompr);
+    }
+
+    gzclose(file);
+}
+
+/* ===========================================================================
+ * Test deflate() with small buffers
+ */
+void test_deflate(compr, comprLen)
+    Byte *compr;
+    uLong comprLen;
+{
+    z_stream c_stream; /* compression stream */
+    int err;
+    int len = strlen(hello)+1;
+
+    c_stream.zalloc = (alloc_func)0;
+    c_stream.zfree = (free_func)0;
+    c_stream.opaque = (voidpf)0;
+
+    err = deflateInit(&c_stream, Z_DEFAULT_COMPRESSION);
+    CHECK_ERR(err, "deflateInit");
+
+    c_stream.next_in  = (Bytef*)hello;
+    c_stream.next_out = compr;
+
+    while (c_stream.total_in != (uLong)len && c_stream.total_out < comprLen) {
+        c_stream.avail_in = c_stream.avail_out = 1; /* force small buffers */
+        err = deflate(&c_stream, Z_NO_FLUSH);
+        CHECK_ERR(err, "deflate");
+    }
+    /* Finish the stream, still forcing small buffers: */
+    for (;;) {
+        c_stream.avail_out = 1;
+        err = deflate(&c_stream, Z_FINISH);
+        if (err == Z_STREAM_END) break;
+        CHECK_ERR(err, "deflate");
+    }
+
+    err = deflateEnd(&c_stream);
+    CHECK_ERR(err, "deflateEnd");
+}
+
+/* ===========================================================================
+ * Test inflate() with small buffers
+ */
+void test_inflate(compr, comprLen, uncompr, uncomprLen)
+    Byte *compr, *uncompr;
+    uLong comprLen, uncomprLen;
+{
+    int err;
+    z_stream d_stream; /* decompression stream */
+
+    strcpy((char*)uncompr, "garbage");
+
+    d_stream.zalloc = (alloc_func)0;
+    d_stream.zfree = (free_func)0;
+    d_stream.opaque = (voidpf)0;
+
+    d_stream.next_in  = compr;
+    d_stream.avail_in = 0;
+    d_stream.next_out = uncompr;
+
+    err = inflateInit(&d_stream);
+    CHECK_ERR(err, "inflateInit");
+
+    while (d_stream.total_out < uncomprLen && d_stream.total_in < comprLen) {
+        d_stream.avail_in = d_stream.avail_out = 1; /* force small buffers */
+        err = inflate(&d_stream, Z_NO_FLUSH);
+        if (err == Z_STREAM_END) break;
+        CHECK_ERR(err, "inflate");
+    }
+
+    err = inflateEnd(&d_stream);
+    CHECK_ERR(err, "inflateEnd");
+
+    if (strcmp((char*)uncompr, hello)) {
+        fprintf(stderr, "bad inflate\n");
+	exit(1);
+    } else {
+        printf("inflate(): %s\n", (char *)uncompr);
+    }
+}
+
+/* ===========================================================================
+ * Test deflate() with large buffers and dynamic change of compression level
+ */
+void test_large_deflate(compr, comprLen, uncompr, uncomprLen)
+    Byte *compr, *uncompr;
+    uLong comprLen, uncomprLen;
+{
+    z_stream c_stream; /* compression stream */
+    int err;
+
+    c_stream.zalloc = (alloc_func)0;
+    c_stream.zfree = (free_func)0;
+    c_stream.opaque = (voidpf)0;
+
+    err = deflateInit(&c_stream, Z_BEST_SPEED);
+    CHECK_ERR(err, "deflateInit");
+
+    c_stream.next_out = compr;
+    c_stream.avail_out = (uInt)comprLen;
+
+    /* At this point, uncompr is still mostly zeroes, so it should compress
+     * very well:
+     */
+    c_stream.next_in = uncompr;
+    c_stream.avail_in = (uInt)uncomprLen;
+    err = deflate(&c_stream, Z_NO_FLUSH);
+    CHECK_ERR(err, "deflate");
+    if (c_stream.avail_in != 0) {
+        fprintf(stderr, "deflate not greedy\n");
+	exit(1);
+    }
+
+    /* Feed in already compressed data and switch to no compression: */
+    deflateParams(&c_stream, Z_NO_COMPRESSION, Z_DEFAULT_STRATEGY);
+    c_stream.next_in = compr;
+    c_stream.avail_in = (uInt)comprLen/2;
+    err = deflate(&c_stream, Z_NO_FLUSH);
+    CHECK_ERR(err, "deflate");
+
+    /* Switch back to compressing mode: */
+    deflateParams(&c_stream, Z_BEST_COMPRESSION, Z_FILTERED);
+    c_stream.next_in = uncompr;
+    c_stream.avail_in = (uInt)uncomprLen;
+    err = deflate(&c_stream, Z_NO_FLUSH);
+    CHECK_ERR(err, "deflate");
+
+    err = deflate(&c_stream, Z_FINISH);
+    if (err != Z_STREAM_END) {
+        fprintf(stderr, "deflate should report Z_STREAM_END\n");
+	exit(1);
+    }
+    err = deflateEnd(&c_stream);
+    CHECK_ERR(err, "deflateEnd");
+}
+
+/* ===========================================================================
+ * Test inflate() with large buffers
+ */
+void test_large_inflate(compr, comprLen, uncompr, uncomprLen)
+    Byte *compr, *uncompr;
+    uLong comprLen, uncomprLen;
+{
+    int err;
+    z_stream d_stream; /* decompression stream */
+
+    strcpy((char*)uncompr, "garbage");
+
+    d_stream.zalloc = (alloc_func)0;
+    d_stream.zfree = (free_func)0;
+    d_stream.opaque = (voidpf)0;
+
+    d_stream.next_in  = compr;
+    d_stream.avail_in = (uInt)comprLen;
+
+    err = inflateInit(&d_stream);
+    CHECK_ERR(err, "inflateInit");
+
+    for (;;) {
+        d_stream.next_out = uncompr;            /* discard the output */
+	d_stream.avail_out = (uInt)uncomprLen;
+        err = inflate(&d_stream, Z_NO_FLUSH);
+        if (err == Z_STREAM_END) break;
+        CHECK_ERR(err, "large inflate");
+    }
+
+    err = inflateEnd(&d_stream);
+    CHECK_ERR(err, "inflateEnd");
+
+    if (d_stream.total_out != 2*uncomprLen + comprLen/2) {
+        fprintf(stderr, "bad large inflate: %ld\n", d_stream.total_out);
+	exit(1);
+    } else {
+        printf("large_inflate(): OK\n");
+    }
+}
+
+/* ===========================================================================
+ * Test deflate() with full flush
+ */
+void test_flush(compr, comprLen)
+    Byte *compr;
+    uLong *comprLen;
+{
+    z_stream c_stream; /* compression stream */
+    int err;
+    int len = strlen(hello)+1;
+
+    c_stream.zalloc = (alloc_func)0;
+    c_stream.zfree = (free_func)0;
+    c_stream.opaque = (voidpf)0;
+
+    err = deflateInit(&c_stream, Z_DEFAULT_COMPRESSION);
+    CHECK_ERR(err, "deflateInit");
+
+    c_stream.next_in  = (Bytef*)hello;
+    c_stream.next_out = compr;
+    c_stream.avail_in = 3;
+    c_stream.avail_out = (uInt)*comprLen;
+    err = deflate(&c_stream, Z_FULL_FLUSH);
+    CHECK_ERR(err, "deflate");
+
+    compr[3]++; /* force an error in first compressed block */
+    c_stream.avail_in = len - 3;
+
+    err = deflate(&c_stream, Z_FINISH);
+    if (err != Z_STREAM_END) {
+        CHECK_ERR(err, "deflate");
+    }
+    err = deflateEnd(&c_stream);
+    CHECK_ERR(err, "deflateEnd");
+
+    *comprLen = c_stream.total_out;
+}
+
+/* ===========================================================================
+ * Test inflateSync()
+ */
+void test_sync(compr, comprLen, uncompr, uncomprLen)
+    Byte *compr, *uncompr;
+    uLong comprLen, uncomprLen;
+{
+    int err;
+    z_stream d_stream; /* decompression stream */
+
+    strcpy((char*)uncompr, "garbage");
+
+    d_stream.zalloc = (alloc_func)0;
+    d_stream.zfree = (free_func)0;
+    d_stream.opaque = (voidpf)0;
+
+    d_stream.next_in  = compr;
+    d_stream.avail_in = 2; /* just read the zlib header */
+
+    err = inflateInit(&d_stream);
+    CHECK_ERR(err, "inflateInit");
+
+    d_stream.next_out = uncompr;
+    d_stream.avail_out = (uInt)uncomprLen;
+
+    inflate(&d_stream, Z_NO_FLUSH);
+    CHECK_ERR(err, "inflate");
+
+    d_stream.avail_in = (uInt)comprLen-2;   /* read all compressed data */
+    err = inflateSync(&d_stream);           /* but skip the damaged part */
+    CHECK_ERR(err, "inflateSync");
+
+    err = inflate(&d_stream, Z_FINISH);
+    if (err != Z_DATA_ERROR) {
+        fprintf(stderr, "inflate should report DATA_ERROR\n");
+        /* Because of incorrect adler32 */
+	exit(1);
+    }
+    err = inflateEnd(&d_stream);
+    CHECK_ERR(err, "inflateEnd");
+
+    printf("after inflateSync(): hel%s\n", (char *)uncompr);
+}
+
+/* ===========================================================================
+ * Test deflate() with preset dictionary
+ */
+void test_dict_deflate(compr, comprLen)
+    Byte *compr;
+    uLong comprLen;
+{
+    z_stream c_stream; /* compression stream */
+    int err;
+
+    c_stream.zalloc = (alloc_func)0;
+    c_stream.zfree = (free_func)0;
+    c_stream.opaque = (voidpf)0;
+
+    err = deflateInit(&c_stream, Z_BEST_COMPRESSION);
+    CHECK_ERR(err, "deflateInit");
+
+    err = deflateSetDictionary(&c_stream,
+			       (const Bytef*)dictionary, sizeof(dictionary));
+    CHECK_ERR(err, "deflateSetDictionary");
+
+    dictId = c_stream.adler;
+    c_stream.next_out = compr;
+    c_stream.avail_out = (uInt)comprLen;
+
+    c_stream.next_in = (Bytef*)hello;
+    c_stream.avail_in = (uInt)strlen(hello)+1;
+
+    err = deflate(&c_stream, Z_FINISH);
+    if (err != Z_STREAM_END) {
+        fprintf(stderr, "deflate should report Z_STREAM_END\n");
+	exit(1);
+    }
+    err = deflateEnd(&c_stream);
+    CHECK_ERR(err, "deflateEnd");
+}
+
+/* ===========================================================================
+ * Test inflate() with a preset dictionary
+ */
+void test_dict_inflate(compr, comprLen, uncompr, uncomprLen)
+    Byte *compr, *uncompr;
+    uLong comprLen, uncomprLen;
+{
+    int err;
+    z_stream d_stream; /* decompression stream */
+
+    strcpy((char*)uncompr, "garbage");
+
+    d_stream.zalloc = (alloc_func)0;
+    d_stream.zfree = (free_func)0;
+    d_stream.opaque = (voidpf)0;
+
+    d_stream.next_in  = compr;
+    d_stream.avail_in = (uInt)comprLen;
+
+    err = inflateInit(&d_stream);
+    CHECK_ERR(err, "inflateInit");
+
+    d_stream.next_out = uncompr;
+    d_stream.avail_out = (uInt)uncomprLen;
+
+    for (;;) {
+        err = inflate(&d_stream, Z_NO_FLUSH);
+        if (err == Z_STREAM_END) break;
+	if (err == Z_NEED_DICT) {
+	    if (d_stream.adler != dictId) {
+		fprintf(stderr, "unexpected dictionary");
+		exit(1);
+	    }
+	    err = inflateSetDictionary(&d_stream, (const Bytef*)dictionary,
+				       sizeof(dictionary));
+	}
+        CHECK_ERR(err, "inflate with dict");
+    }
+
+    err = inflateEnd(&d_stream);
+    CHECK_ERR(err, "inflateEnd");
+
+    if (strcmp((char*)uncompr, hello)) {
+        fprintf(stderr, "bad inflate with dict\n");
+	exit(1);
+    } else {
+        printf("inflate with dictionary: %s\n", (char *)uncompr);
+    }
+}
+
+/* ===========================================================================
+ * Usage:  example [output.gz  [input.gz]]
+ */
+
+int main(argc, argv)
+    int argc;
+    char *argv[];
+{
+    Byte *compr, *uncompr;
+    uLong comprLen = 10000*sizeof(int); /* don't overflow on MSDOS */
+    uLong uncomprLen = comprLen;
+    static const char* myVersion = ZLIB_VERSION;
+
+    if (zlibVersion()[0] != myVersion[0]) {
+        fprintf(stderr, "incompatible zlib version\n");
+        exit(1);
+
+    } else if (strcmp(zlibVersion(), ZLIB_VERSION) != 0) {
+        fprintf(stderr, "warning: different zlib version\n");
+    }
+
+    compr    = (Byte*)calloc((uInt)comprLen, 1);
+    uncompr  = (Byte*)calloc((uInt)uncomprLen, 1);
+    /* compr and uncompr are cleared to avoid reading uninitialized
+     * data and to ensure that uncompr compresses well.
+     */
+    if (compr == Z_NULL || uncompr == Z_NULL) {
+        printf("out of memory\n");
+	exit(1);
+    }
+    test_compress(compr, comprLen, uncompr, uncomprLen);
+
+    test_gzio((argc > 1 ? argv[1] : TESTFILE),
+              (argc > 2 ? argv[2] : TESTFILE),
+	      uncompr, (int)uncomprLen);
+
+    test_deflate(compr, comprLen);
+    test_inflate(compr, comprLen, uncompr, uncomprLen);
+
+    test_large_deflate(compr, comprLen, uncompr, uncomprLen);
+    test_large_inflate(compr, comprLen, uncompr, uncomprLen);
+
+    test_flush(compr, &comprLen);
+    test_sync(compr, comprLen, uncompr, uncomprLen);
+    comprLen = uncomprLen;
+
+    test_dict_deflate(compr, comprLen);
+    test_dict_inflate(compr, comprLen, uncompr, uncomprLen);
+
+    exit(0);
+    return 0; /* to avoid warning */
+}
diff --git a/src/libz/src/gzio.c b/src/libz/src/gzio.c
new file mode 100644
index 0000000..fcff309
--- /dev/null
+++ b/src/libz/src/gzio.c
@@ -0,0 +1,875 @@
+/* gzio.c -- IO on .gz files
+ * Copyright (C) 1995-2002 Jean-loup Gailly.
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ *
+ * Compile this file with -DNO_DEFLATE to avoid the compression code.
+ */
+
+/* @(#) $Id: gzio.c,v 1.1 2008/11/12 02:25:24 agibert Exp $ */
+
+#include <stdio.h>
+
+#include "zutil.h"
+
+struct internal_state {int dummy;}; /* for buggy compilers */
+
+#ifndef Z_BUFSIZE
+#  ifdef MAXSEG_64K
+#    define Z_BUFSIZE 4096 /* minimize memory usage for 16-bit DOS */
+#  else
+#    define Z_BUFSIZE 16384
+#  endif
+#endif
+#ifndef Z_PRINTF_BUFSIZE
+#  define Z_PRINTF_BUFSIZE 4096
+#endif
+
+#define ALLOC(size) malloc(size)
+#define TRYFREE(p) {if (p) free(p);}
+
+static int gz_magic[2] = {0x1f, 0x8b}; /* gzip magic header */
+
+/* gzip flag byte */
+#define ASCII_FLAG   0x01 /* bit 0 set: file probably ascii text */
+#define HEAD_CRC     0x02 /* bit 1 set: header CRC present */
+#define EXTRA_FIELD  0x04 /* bit 2 set: extra field present */
+#define ORIG_NAME    0x08 /* bit 3 set: original file name present */
+#define COMMENT      0x10 /* bit 4 set: file comment present */
+#define RESERVED     0xE0 /* bits 5..7: reserved */
+
+typedef struct gz_stream {
+    z_stream stream;
+    int      z_err;   /* error code for last stream operation */
+    int      z_eof;   /* set if end of input file */
+    FILE     *file;   /* .gz file */
+    Byte     *inbuf;  /* input buffer */
+    Byte     *outbuf; /* output buffer */
+    uLong    crc;     /* crc32 of uncompressed data */
+    char     *msg;    /* error message */
+    char     *path;   /* path name for debugging only */
+    int      transparent; /* 1 if input file is not a .gz file */
+    char     mode;    /* 'w' or 'r' */
+    long     startpos; /* start of compressed data in file (header skipped) */
+} gz_stream;
+
+
+local gzFile gz_open      OF((const char *path, const char *mode, int  fd));
+local int do_flush        OF((gzFile file, int flush));
+local int    get_byte     OF((gz_stream *s));
+local void   check_header OF((gz_stream *s));
+local int    destroy      OF((gz_stream *s));
+local void   putLong      OF((FILE *file, uLong x));
+local uLong  getLong      OF((gz_stream *s));
+
+/* ===========================================================================
+     Opens a gzip (.gz) file for reading or writing. The mode parameter
+   is as in fopen ("rb" or "wb"). The file is given either by file descriptor
+   or path name (if fd == -1).
+     gz_open return NULL if the file could not be opened or if there was
+   insufficient memory to allocate the (de)compression state; errno
+   can be checked to distinguish the two cases (if errno is zero, the
+   zlib error is Z_MEM_ERROR).
+*/
+local gzFile gz_open (path, mode, fd)
+    const char *path;
+    const char *mode;
+    int  fd;
+{
+    int err;
+    int level = Z_DEFAULT_COMPRESSION; /* compression level */
+    int strategy = Z_DEFAULT_STRATEGY; /* compression strategy */
+    char *p = (char*)mode;
+    gz_stream *s;
+    char fmode[80]; /* copy of mode, without the compression level */
+    char *m = fmode;
+
+    if (!path || !mode) return Z_NULL;
+
+    s = (gz_stream *)ALLOC(sizeof(gz_stream));
+    if (!s) return Z_NULL;
+
+    s->stream.zalloc = (alloc_func)0;
+    s->stream.zfree = (free_func)0;
+    s->stream.opaque = (voidpf)0;
+    s->stream.next_in = s->inbuf = Z_NULL;
+    s->stream.next_out = s->outbuf = Z_NULL;
+    s->stream.avail_in = s->stream.avail_out = 0;
+    s->file = NULL;
+    s->z_err = Z_OK;
+    s->z_eof = 0;
+    s->crc = crc32(0L, Z_NULL, 0);
+    s->msg = NULL;
+    s->transparent = 0;
+
+    s->path = (char*)ALLOC(strlen(path)+1);
+    if (s->path == NULL) {
+        return destroy(s), (gzFile)Z_NULL;
+    }
+    strcpy(s->path, path); /* do this early for debugging */
+
+    s->mode = '\0';
+    do {
+        if (*p == 'r') s->mode = 'r';
+        if (*p == 'w' || *p == 'a') s->mode = 'w';
+        if (*p >= '0' && *p <= '9') {
+	    level = *p - '0';
+	} else if (*p == 'f') {
+	  strategy = Z_FILTERED;
+	} else if (*p == 'h') {
+	  strategy = Z_HUFFMAN_ONLY;
+	} else {
+	    *m++ = *p; /* copy the mode */
+	}
+    } while (*p++ && m != fmode + sizeof(fmode));
+    if (s->mode == '\0') return destroy(s), (gzFile)Z_NULL;
+    
+    if (s->mode == 'w') {
+#ifdef NO_DEFLATE
+        err = Z_STREAM_ERROR;
+#else
+        err = deflateInit2(&(s->stream), level,
+                           Z_DEFLATED, -MAX_WBITS, DEF_MEM_LEVEL, strategy);
+        /* windowBits is passed < 0 to suppress zlib header */
+
+        s->stream.next_out = s->outbuf = (Byte*)ALLOC(Z_BUFSIZE);
+#endif
+        if (err != Z_OK || s->outbuf == Z_NULL) {
+            return destroy(s), (gzFile)Z_NULL;
+        }
+    } else {
+        s->stream.next_in  = s->inbuf = (Byte*)ALLOC(Z_BUFSIZE);
+
+        err = inflateInit2(&(s->stream), -MAX_WBITS);
+        /* windowBits is passed < 0 to tell that there is no zlib header.
+         * Note that in this case inflate *requires* an extra "dummy" byte
+         * after the compressed stream in order to complete decompression and
+         * return Z_STREAM_END. Here the gzip CRC32 ensures that 4 bytes are
+         * present after the compressed stream.
+         */
+        if (err != Z_OK || s->inbuf == Z_NULL) {
+            return destroy(s), (gzFile)Z_NULL;
+        }
+    }
+    s->stream.avail_out = Z_BUFSIZE;
+
+    errno = 0;
+    s->file = fd < 0 ? F_OPEN(path, fmode) : (FILE*)fdopen(fd, fmode);
+
+    if (s->file == NULL) {
+        return destroy(s), (gzFile)Z_NULL;
+    }
+    if (s->mode == 'w') {
+        /* Write a very simple .gz header:
+         */
+        fprintf(s->file, "%c%c%c%c%c%c%c%c%c%c", gz_magic[0], gz_magic[1],
+             Z_DEFLATED, 0 /*flags*/, 0,0,0,0 /*time*/, 0 /*xflags*/, OS_CODE);
+	s->startpos = 10L;
+	/* We use 10L instead of ftell(s->file) to because ftell causes an
+         * fflush on some systems. This version of the library doesn't use
+         * startpos anyway in write mode, so this initialization is not
+         * necessary.
+         */
+    } else {
+	check_header(s); /* skip the .gz header */
+	s->startpos = (ftell(s->file) - s->stream.avail_in);
+    }
+    
+    return (gzFile)s;
+}
+
+/* ===========================================================================
+     Opens a gzip (.gz) file for reading or writing.
+*/
+gzFile ZEXPORT gzopen (path, mode)
+    const char *path;
+    const char *mode;
+{
+    return gz_open (path, mode, -1);
+}
+
+/* ===========================================================================
+     Associate a gzFile with the file descriptor fd. fd is not dup'ed here
+   to mimic the behavio(u)r of fdopen.
+*/
+gzFile ZEXPORT gzdopen (fd, mode)
+    int fd;
+    const char *mode;
+{
+    char name[20];
+
+    if (fd < 0) return (gzFile)Z_NULL;
+    sprintf(name, "<fd:%d>", fd); /* for debugging */
+
+    return gz_open (name, mode, fd);
+}
+
+/* ===========================================================================
+ * Update the compression level and strategy
+ */
+int ZEXPORT gzsetparams (file, level, strategy)
+    gzFile file;
+    int level;
+    int strategy;
+{
+    gz_stream *s = (gz_stream*)file;
+
+    if (s == NULL || s->mode != 'w') return Z_STREAM_ERROR;
+
+    /* Make room to allow flushing */
+    if (s->stream.avail_out == 0) {
+
+	s->stream.next_out = s->outbuf;
+	if (fwrite(s->outbuf, 1, Z_BUFSIZE, s->file) != Z_BUFSIZE) {
+	    s->z_err = Z_ERRNO;
+	}
+	s->stream.avail_out = Z_BUFSIZE;
+    }
+
+    return deflateParams (&(s->stream), level, strategy);
+}
+
+/* ===========================================================================
+     Read a byte from a gz_stream; update next_in and avail_in. Return EOF
+   for end of file.
+   IN assertion: the stream s has been sucessfully opened for reading.
+*/
+local int get_byte(s)
+    gz_stream *s;
+{
+    if (s->z_eof) return EOF;
+    if (s->stream.avail_in == 0) {
+	errno = 0;
+	s->stream.avail_in = fread(s->inbuf, 1, Z_BUFSIZE, s->file);
+	if (s->stream.avail_in == 0) {
+	    s->z_eof = 1;
+	    if (ferror(s->file)) s->z_err = Z_ERRNO;
+	    return EOF;
+	}
+	s->stream.next_in = s->inbuf;
+    }
+    s->stream.avail_in--;
+    return *(s->stream.next_in)++;
+}
+
+/* ===========================================================================
+      Check the gzip header of a gz_stream opened for reading. Set the stream
+    mode to transparent if the gzip magic header is not present; set s->err
+    to Z_DATA_ERROR if the magic header is present but the rest of the header
+    is incorrect.
+    IN assertion: the stream s has already been created sucessfully;
+       s->stream.avail_in is zero for the first time, but may be non-zero
+       for concatenated .gz files.
+*/
+local void check_header(s)
+    gz_stream *s;
+{
+    int method; /* method byte */
+    int flags;  /* flags byte */
+    uInt len;
+    int c;
+
+    /* Check the gzip magic header */
+    for (len = 0; len < 2; len++) {
+	c = get_byte(s);
+	if (c != gz_magic[len]) {
+	    if (len != 0) s->stream.avail_in++, s->stream.next_in--;
+	    if (c != EOF) {
+		s->stream.avail_in++, s->stream.next_in--;
+		s->transparent = 1;
+	    }
+	    s->z_err = s->stream.avail_in != 0 ? Z_OK : Z_STREAM_END;
+	    return;
+	}
+    }
+    method = get_byte(s);
+    flags = get_byte(s);
+    if (method != Z_DEFLATED || (flags & RESERVED) != 0) {
+	s->z_err = Z_DATA_ERROR;
+	return;
+    }
+
+    /* Discard time, xflags and OS code: */
+    for (len = 0; len < 6; len++) (void)get_byte(s);
+
+    if ((flags & EXTRA_FIELD) != 0) { /* skip the extra field */
+	len  =  (uInt)get_byte(s);
+	len += ((uInt)get_byte(s))<<8;
+	/* len is garbage if EOF but the loop below will quit anyway */
+	while (len-- != 0 && get_byte(s) != EOF) ;
+    }
+    if ((flags & ORIG_NAME) != 0) { /* skip the original file name */
+	while ((c = get_byte(s)) != 0 && c != EOF) ;
+    }
+    if ((flags & COMMENT) != 0) {   /* skip the .gz file comment */
+	while ((c = get_byte(s)) != 0 && c != EOF) ;
+    }
+    if ((flags & HEAD_CRC) != 0) {  /* skip the header crc */
+	for (len = 0; len < 2; len++) (void)get_byte(s);
+    }
+    s->z_err = s->z_eof ? Z_DATA_ERROR : Z_OK;
+}
+
+ /* ===========================================================================
+ * Cleanup then free the given gz_stream. Return a zlib error code.
+   Try freeing in the reverse order of allocations.
+ */
+local int destroy (s)
+    gz_stream *s;
+{
+    int err = Z_OK;
+
+    if (!s) return Z_STREAM_ERROR;
+
+    TRYFREE(s->msg);
+
+    if (s->stream.state != NULL) {
+	if (s->mode == 'w') {
+#ifdef NO_DEFLATE
+	    err = Z_STREAM_ERROR;
+#else
+	    err = deflateEnd(&(s->stream));
+#endif
+	} else if (s->mode == 'r') {
+	    err = inflateEnd(&(s->stream));
+	}
+    }
+    if (s->file != NULL && fclose(s->file)) {
+#ifdef ESPIPE
+	if (errno != ESPIPE) /* fclose is broken for pipes in HP/UX */
+#endif
+	    err = Z_ERRNO;
+    }
+    if (s->z_err < 0) err = s->z_err;
+
+    TRYFREE(s->inbuf);
+    TRYFREE(s->outbuf);
+    TRYFREE(s->path);
+    TRYFREE(s);
+    return err;
+}
+
+/* ===========================================================================
+     Reads the given number of uncompressed bytes from the compressed file.
+   gzread returns the number of bytes actually read (0 for end of file).
+*/
+int ZEXPORT gzread (file, buf, len)
+    gzFile file;
+    voidp buf;
+    unsigned len;
+{
+    gz_stream *s = (gz_stream*)file;
+    Bytef *start = (Bytef*)buf; /* starting point for crc computation */
+    Byte  *next_out; /* == stream.next_out but not forced far (for MSDOS) */
+
+    if (s == NULL || s->mode != 'r') return Z_STREAM_ERROR;
+
+    if (s->z_err == Z_DATA_ERROR || s->z_err == Z_ERRNO) return -1;
+    if (s->z_err == Z_STREAM_END) return 0;  /* EOF */
+
+    next_out = (Byte*)buf;
+    s->stream.next_out = (Bytef*)buf;
+    s->stream.avail_out = len;
+
+    while (s->stream.avail_out != 0) {
+
+	if (s->transparent) {
+	    /* Copy first the lookahead bytes: */
+	    uInt n = s->stream.avail_in;
+	    if (n > s->stream.avail_out) n = s->stream.avail_out;
+	    if (n > 0) {
+		zmemcpy(s->stream.next_out, s->stream.next_in, n);
+		next_out += n;
+		s->stream.next_out = next_out;
+		s->stream.next_in   += n;
+		s->stream.avail_out -= n;
+		s->stream.avail_in  -= n;
+	    }
+	    if (s->stream.avail_out > 0) {
+		s->stream.avail_out -= fread(next_out, 1, s->stream.avail_out,
+					     s->file);
+	    }
+	    len -= s->stream.avail_out;
+	    s->stream.total_in  += (uLong)len;
+	    s->stream.total_out += (uLong)len;
+            if (len == 0) s->z_eof = 1;
+	    return (int)len;
+	}
+        if (s->stream.avail_in == 0 && !s->z_eof) {
+
+            errno = 0;
+            s->stream.avail_in = fread(s->inbuf, 1, Z_BUFSIZE, s->file);
+            if (s->stream.avail_in == 0) {
+                s->z_eof = 1;
+		if (ferror(s->file)) {
+		    s->z_err = Z_ERRNO;
+		    break;
+		}
+            }
+            s->stream.next_in = s->inbuf;
+        }
+        s->z_err = inflate(&(s->stream), Z_NO_FLUSH);
+
+	if (s->z_err == Z_STREAM_END) {
+	    /* Check CRC and original size */
+	    s->crc = crc32(s->crc, start, (uInt)(s->stream.next_out - start));
+	    start = s->stream.next_out;
+
+	    if (getLong(s) != s->crc) {
+		s->z_err = Z_DATA_ERROR;
+	    } else {
+	        (void)getLong(s);
+                /* The uncompressed length returned by above getlong() may
+                 * be different from s->stream.total_out) in case of
+		 * concatenated .gz files. Check for such files:
+		 */
+		check_header(s);
+		if (s->z_err == Z_OK) {
+		    uLong total_in = s->stream.total_in;
+		    uLong total_out = s->stream.total_out;
+
+		    inflateReset(&(s->stream));
+		    s->stream.total_in = total_in;
+		    s->stream.total_out = total_out;
+		    s->crc = crc32(0L, Z_NULL, 0);
+		}
+	    }
+	}
+	if (s->z_err != Z_OK || s->z_eof) break;
+    }
+    s->crc = crc32(s->crc, start, (uInt)(s->stream.next_out - start));
+
+    return (int)(len - s->stream.avail_out);
+}
+
+
+/* ===========================================================================
+      Reads one byte from the compressed file. gzgetc returns this byte
+   or -1 in case of end of file or error.
+*/
+int ZEXPORT gzgetc(file)
+    gzFile file;
+{
+    unsigned char c;
+
+    return gzread(file, &c, 1) == 1 ? c : -1;
+}
+
+
+/* ===========================================================================
+      Reads bytes from the compressed file until len-1 characters are
+   read, or a newline character is read and transferred to buf, or an
+   end-of-file condition is encountered.  The string is then terminated
+   with a null character.
+      gzgets returns buf, or Z_NULL in case of error.
+
+      The current implementation is not optimized at all.
+*/
+char * ZEXPORT gzgets(file, buf, len)
+    gzFile file;
+    char *buf;
+    int len;
+{
+    char *b = buf;
+    if (buf == Z_NULL || len <= 0) return Z_NULL;
+
+    while (--len > 0 && gzread(file, buf, 1) == 1 && *buf++ != '\n') ;
+    *buf = '\0';
+    return b == buf && len > 0 ? Z_NULL : b;
+}
+
+
+#ifndef NO_DEFLATE
+/* ===========================================================================
+     Writes the given number of uncompressed bytes into the compressed file.
+   gzwrite returns the number of bytes actually written (0 in case of error).
+*/
+int ZEXPORT gzwrite (file, buf, len)
+    gzFile file;
+    const voidp buf;
+    unsigned len;
+{
+    gz_stream *s = (gz_stream*)file;
+
+    if (s == NULL || s->mode != 'w') return Z_STREAM_ERROR;
+
+    s->stream.next_in = (Bytef*)buf;
+    s->stream.avail_in = len;
+
+    while (s->stream.avail_in != 0) {
+
+        if (s->stream.avail_out == 0) {
+
+            s->stream.next_out = s->outbuf;
+            if (fwrite(s->outbuf, 1, Z_BUFSIZE, s->file) != Z_BUFSIZE) {
+                s->z_err = Z_ERRNO;
+                break;
+            }
+            s->stream.avail_out = Z_BUFSIZE;
+        }
+        s->z_err = deflate(&(s->stream), Z_NO_FLUSH);
+        if (s->z_err != Z_OK) break;
+    }
+    s->crc = crc32(s->crc, (const Bytef *)buf, len);
+
+    return (int)(len - s->stream.avail_in);
+}
+
+/* ===========================================================================
+     Converts, formats, and writes the args to the compressed file under
+   control of the format string, as in fprintf. gzprintf returns the number of
+   uncompressed bytes actually written (0 in case of error).
+*/
+#ifdef STDC
+#include <stdarg.h>
+
+int ZEXPORTVA gzprintf (gzFile file, const char *format, /* args */ ...)
+{
+    char buf[Z_PRINTF_BUFSIZE];
+    va_list va;
+    int len;
+
+    va_start(va, format);
+#ifdef HAS_vsnprintf
+    (void)vsnprintf(buf, sizeof(buf), format, va);
+#else
+    (void)vsprintf(buf, format, va);
+#endif
+    va_end(va);
+    len = strlen(buf); /* some *sprintf don't return the nb of bytes written */
+    if (len <= 0) return 0;
+
+    return gzwrite(file, buf, (unsigned)len);
+}
+#else /* not ANSI C */
+
+int ZEXPORTVA gzprintf (file, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
+	               a11, a12, a13, a14, a15, a16, a17, a18, a19, a20)
+    gzFile file;
+    const char *format;
+    int a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
+	a11, a12, a13, a14, a15, a16, a17, a18, a19, a20;
+{
+    char buf[Z_PRINTF_BUFSIZE];
+    int len;
+
+#ifdef HAS_snprintf
+    snprintf(buf, sizeof(buf), format, a1, a2, a3, a4, a5, a6, a7, a8,
+	     a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
+#else
+    sprintf(buf, format, a1, a2, a3, a4, a5, a6, a7, a8,
+	    a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
+#endif
+    len = strlen(buf); /* old sprintf doesn't return the nb of bytes written */
+    if (len <= 0) return 0;
+
+    return gzwrite(file, buf, len);
+}
+#endif
+
+/* ===========================================================================
+      Writes c, converted to an unsigned char, into the compressed file.
+   gzputc returns the value that was written, or -1 in case of error.
+*/
+int ZEXPORT gzputc(file, c)
+    gzFile file;
+    int c;
+{
+    unsigned char cc = (unsigned char) c; /* required for big endian systems */
+
+    return gzwrite(file, &cc, 1) == 1 ? (int)cc : -1;
+}
+
+
+/* ===========================================================================
+      Writes the given null-terminated string to the compressed file, excluding
+   the terminating null character.
+      gzputs returns the number of characters written, or -1 in case of error.
+*/
+int ZEXPORT gzputs(file, s)
+    gzFile file;
+    const char *s;
+{
+    return gzwrite(file, (char*)s, (unsigned)strlen(s));
+}
+
+
+/* ===========================================================================
+     Flushes all pending output into the compressed file. The parameter
+   flush is as in the deflate() function.
+*/
+local int do_flush (file, flush)
+    gzFile file;
+    int flush;
+{
+    uInt len;
+    int done = 0;
+    gz_stream *s = (gz_stream*)file;
+
+    if (s == NULL || s->mode != 'w') return Z_STREAM_ERROR;
+
+    s->stream.avail_in = 0; /* should be zero already anyway */
+
+    for (;;) {
+        len = Z_BUFSIZE - s->stream.avail_out;
+
+        if (len != 0) {
+            if ((uInt)fwrite(s->outbuf, 1, len, s->file) != len) {
+                s->z_err = Z_ERRNO;
+                return Z_ERRNO;
+            }
+            s->stream.next_out = s->outbuf;
+            s->stream.avail_out = Z_BUFSIZE;
+        }
+        if (done) break;
+        s->z_err = deflate(&(s->stream), flush);
+
+	/* Ignore the second of two consecutive flushes: */
+	if (len == 0 && s->z_err == Z_BUF_ERROR) s->z_err = Z_OK;
+
+        /* deflate has finished flushing only when it hasn't used up
+         * all the available space in the output buffer: 
+         */
+        done = (s->stream.avail_out != 0 || s->z_err == Z_STREAM_END);
+ 
+        if (s->z_err != Z_OK && s->z_err != Z_STREAM_END) break;
+    }
+    return  s->z_err == Z_STREAM_END ? Z_OK : s->z_err;
+}
+
+int ZEXPORT gzflush (file, flush)
+     gzFile file;
+     int flush;
+{
+    gz_stream *s = (gz_stream*)file;
+    int err = do_flush (file, flush);
+
+    if (err) return err;
+    fflush(s->file);
+    return  s->z_err == Z_STREAM_END ? Z_OK : s->z_err;
+}
+#endif /* NO_DEFLATE */
+
+/* ===========================================================================
+      Sets the starting position for the next gzread or gzwrite on the given
+   compressed file. The offset represents a number of bytes in the
+      gzseek returns the resulting offset location as measured in bytes from
+   the beginning of the uncompressed stream, or -1 in case of error.
+      SEEK_END is not implemented, returns error.
+      In this version of the library, gzseek can be extremely slow.
+*/
+z_off_t ZEXPORT gzseek (file, offset, whence)
+    gzFile file;
+    z_off_t offset;
+    int whence;
+{
+    gz_stream *s = (gz_stream*)file;
+
+    if (s == NULL || whence == SEEK_END ||
+	s->z_err == Z_ERRNO || s->z_err == Z_DATA_ERROR) {
+	return -1L;
+    }
+    
+    if (s->mode == 'w') {
+#ifdef NO_DEFLATE
+	return -1L;
+#else
+	if (whence == SEEK_SET) {
+	    offset -= s->stream.total_in;
+	}
+	if (offset < 0) return -1L;
+
+	/* At this point, offset is the number of zero bytes to write. */
+	if (s->inbuf == Z_NULL) {
+	    s->inbuf = (Byte*)ALLOC(Z_BUFSIZE); /* for seeking */
+	    zmemzero(s->inbuf, Z_BUFSIZE);
+	}
+	while (offset > 0)  {
+	    uInt size = Z_BUFSIZE;
+	    if (offset < Z_BUFSIZE) size = (uInt)offset;
+
+	    size = gzwrite(file, s->inbuf, size);
+	    if (size == 0) return -1L;
+
+	    offset -= size;
+	}
+	return (z_off_t)s->stream.total_in;
+#endif
+    }
+    /* Rest of function is for reading only */
+
+    /* compute absolute position */
+    if (whence == SEEK_CUR) {
+	offset += s->stream.total_out;
+    }
+    if (offset < 0) return -1L;
+
+    if (s->transparent) {
+	/* map to fseek */
+	s->stream.avail_in = 0;
+	s->stream.next_in = s->inbuf;
+        if (fseek(s->file, offset, SEEK_SET) < 0) return -1L;
+
+	s->stream.total_in = s->stream.total_out = (uLong)offset;
+	return offset;
+    }
+
+    /* For a negative seek, rewind and use positive seek */
+    if ((uLong)offset >= s->stream.total_out) {
+	offset -= s->stream.total_out;
+    } else if (gzrewind(file) < 0) {
+	return -1L;
+    }
+    /* offset is now the number of bytes to skip. */
+
+    if (offset != 0 && s->outbuf == Z_NULL) {
+	s->outbuf = (Byte*)ALLOC(Z_BUFSIZE);
+    }
+    while (offset > 0)  {
+	int size = Z_BUFSIZE;
+	if (offset < Z_BUFSIZE) size = (int)offset;
+
+	size = gzread(file, s->outbuf, (uInt)size);
+	if (size <= 0) return -1L;
+	offset -= size;
+    }
+    return (z_off_t)s->stream.total_out;
+}
+
+/* ===========================================================================
+     Rewinds input file. 
+*/
+int ZEXPORT gzrewind (file)
+    gzFile file;
+{
+    gz_stream *s = (gz_stream*)file;
+    
+    if (s == NULL || s->mode != 'r') return -1;
+
+    s->z_err = Z_OK;
+    s->z_eof = 0;
+    s->stream.avail_in = 0;
+    s->stream.next_in = s->inbuf;
+    s->crc = crc32(0L, Z_NULL, 0);
+	
+    if (s->startpos == 0) { /* not a compressed file */
+	rewind(s->file);
+	return 0;
+    }
+
+    (void) inflateReset(&s->stream);
+    return fseek(s->file, s->startpos, SEEK_SET);
+}
+
+/* ===========================================================================
+     Returns the starting position for the next gzread or gzwrite on the
+   given compressed file. This position represents a number of bytes in the
+   uncompressed data stream.
+*/
+z_off_t ZEXPORT gztell (file)
+    gzFile file;
+{
+    return gzseek(file, 0L, SEEK_CUR);
+}
+
+/* ===========================================================================
+     Returns 1 when EOF has previously been detected reading the given
+   input stream, otherwise zero.
+*/
+int ZEXPORT gzeof (file)
+    gzFile file;
+{
+    gz_stream *s = (gz_stream*)file;
+    
+    return (s == NULL || s->mode != 'r') ? 0 : s->z_eof;
+}
+
+/* ===========================================================================
+   Outputs a long in LSB order to the given file
+*/
+local void putLong (file, x)
+    FILE *file;
+    uLong x;
+{
+    int n;
+    for (n = 0; n < 4; n++) {
+        fputc((int)(x & 0xff), file);
+        x >>= 8;
+    }
+}
+
+/* ===========================================================================
+   Reads a long in LSB order from the given gz_stream. Sets z_err in case
+   of error.
+*/
+local uLong getLong (s)
+    gz_stream *s;
+{
+    uLong x = (uLong)get_byte(s);
+    int c;
+
+    x += ((uLong)get_byte(s))<<8;
+    x += ((uLong)get_byte(s))<<16;
+    c = get_byte(s);
+    if (c == EOF) s->z_err = Z_DATA_ERROR;
+    x += ((uLong)c)<<24;
+    return x;
+}
+
+/* ===========================================================================
+     Flushes all pending output if necessary, closes the compressed file
+   and deallocates all the (de)compression state.
+*/
+int ZEXPORT gzclose (file)
+    gzFile file;
+{
+    int err;
+    gz_stream *s = (gz_stream*)file;
+
+    if (s == NULL) return Z_STREAM_ERROR;
+
+    if (s->mode == 'w') {
+#ifdef NO_DEFLATE
+	return Z_STREAM_ERROR;
+#else
+        err = do_flush (file, Z_FINISH);
+        if (err != Z_OK) return destroy((gz_stream*)file);
+
+        putLong (s->file, s->crc);
+        putLong (s->file, s->stream.total_in);
+#endif
+    }
+    return destroy((gz_stream*)file);
+}
+
+/* ===========================================================================
+     Returns the error message for the last error which occured on the
+   given compressed file. errnum is set to zlib error number. If an
+   error occured in the file system and not in the compression library,
+   errnum is set to Z_ERRNO and the application may consult errno
+   to get the exact error code.
+*/
+const char*  ZEXPORT gzerror (file, errnum)
+    gzFile file;
+    int *errnum;
+{
+    char *m;
+    gz_stream *s = (gz_stream*)file;
+
+    if (s == NULL) {
+        *errnum = Z_STREAM_ERROR;
+        return (const char*)ERR_MSG(Z_STREAM_ERROR);
+    }
+    *errnum = s->z_err;
+    if (*errnum == Z_OK) return (const char*)"";
+
+    m =  (char*)(*errnum == Z_ERRNO ? zstrerror(errno) : s->stream.msg);
+
+    if (m == NULL || *m == '\0') m = (char*)ERR_MSG(s->z_err);
+
+    TRYFREE(s->msg);
+    s->msg = (char*)ALLOC(strlen(s->path) + strlen(m) + 3);
+    strcpy(s->msg, s->path);
+    strcat(s->msg, ": ");
+    strcat(s->msg, m);
+    return (const char*)s->msg;
+}
diff --git a/src/libz/src/infblock.c b/src/libz/src/infblock.c
new file mode 100644
index 0000000..dd7a6d4
--- /dev/null
+++ b/src/libz/src/infblock.c
@@ -0,0 +1,403 @@
+/* infblock.c -- interpret and process block types to last block
+ * Copyright (C) 1995-2002 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h 
+ */
+
+#include "zutil.h"
+#include "infblock.h"
+#include "inftrees.h"
+#include "infcodes.h"
+#include "infutil.h"
+
+struct inflate_codes_state {int dummy;}; /* for buggy compilers */
+
+/* simplify the use of the inflate_huft type with some defines */
+#define exop word.what.Exop
+#define bits word.what.Bits
+
+/* Table for deflate from PKZIP's appnote.txt. */
+local const uInt border[] = { /* Order of the bit length code lengths */
+        16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
+
+/*
+   Notes beyond the 1.93a appnote.txt:
+
+   1. Distance pointers never point before the beginning of the output
+      stream.
+   2. Distance pointers can point back across blocks, up to 32k away.
+   3. There is an implied maximum of 7 bits for the bit length table and
+      15 bits for the actual data.
+   4. If only one code exists, then it is encoded using one bit.  (Zero
+      would be more efficient, but perhaps a little confusing.)  If two
+      codes exist, they are coded using one bit each (0 and 1).
+   5. There is no way of sending zero distance codes--a dummy must be
+      sent if there are none.  (History: a pre 2.0 version of PKZIP would
+      store blocks with no distance codes, but this was discovered to be
+      too harsh a criterion.)  Valid only for 1.93a.  2.04c does allow
+      zero distance codes, which is sent as one code of zero bits in
+      length.
+   6. There are up to 286 literal/length codes.  Code 256 represents the
+      end-of-block.  Note however that the static length tree defines
+      288 codes just to fill out the Huffman codes.  Codes 286 and 287
+      cannot be used though, since there is no length base or extra bits
+      defined for them.  Similarily, there are up to 30 distance codes.
+      However, static trees define 32 codes (all 5 bits) to fill out the
+      Huffman codes, but the last two had better not show up in the data.
+   7. Unzip can check dynamic Huffman blocks for complete code sets.
+      The exception is that a single code would not be complete (see #4).
+   8. The five bits following the block type is really the number of
+      literal codes sent minus 257.
+   9. Length codes 8,16,16 are interpreted as 13 length codes of 8 bits
+      (1+6+6).  Therefore, to output three times the length, you output
+      three codes (1+1+1), whereas to output four times the same length,
+      you only need two codes (1+3).  Hmm.
+  10. In the tree reconstruction algorithm, Code = Code + Increment
+      only if BitLength(i) is not zero.  (Pretty obvious.)
+  11. Correction: 4 Bits: # of Bit Length codes - 4     (4 - 19)
+  12. Note: length code 284 can represent 227-258, but length code 285
+      really is 258.  The last length deserves its own, short code
+      since it gets used a lot in very redundant files.  The length
+      258 is special since 258 - 3 (the min match length) is 255.
+  13. The literal/length and distance code bit lengths are read as a
+      single stream of lengths.  It is possible (and advantageous) for
+      a repeat code (16, 17, or 18) to go across the boundary between
+      the two sets of lengths.
+ */
+
+
+void inflate_blocks_reset(s, z, c)
+inflate_blocks_statef *s;
+z_streamp z;
+uLongf *c;
+{
+  if (c != Z_NULL)
+    *c = s->check;
+  if (s->mode == BTREE || s->mode == DTREE)
+    ZFREE(z, s->sub.trees.blens);
+  if (s->mode == CODES)
+    inflate_codes_free(s->sub.decode.codes, z);
+  s->mode = TYPE;
+  s->bitk = 0;
+  s->bitb = 0;
+  s->read = s->write = s->window;
+  if (s->checkfn != Z_NULL)
+    z->adler = s->check = (*s->checkfn)(0L, (const Bytef *)Z_NULL, 0);
+  Tracev((stderr, "inflate:   blocks reset\n"));
+}
+
+
+inflate_blocks_statef *inflate_blocks_new(z, c, w)
+z_streamp z;
+check_func c;
+uInt w;
+{
+  inflate_blocks_statef *s;
+
+  if ((s = (inflate_blocks_statef *)ZALLOC
+       (z,1,sizeof(struct inflate_blocks_state))) == Z_NULL)
+    return s;
+  if ((s->hufts =
+       (inflate_huft *)ZALLOC(z, sizeof(inflate_huft), MANY)) == Z_NULL)
+  {
+    ZFREE(z, s);
+    return Z_NULL;
+  }
+  if ((s->window = (Bytef *)ZALLOC(z, 1, w)) == Z_NULL)
+  {
+    ZFREE(z, s->hufts);
+    ZFREE(z, s);
+    return Z_NULL;
+  }
+  s->end = s->window + w;
+  s->checkfn = c;
+  s->mode = TYPE;
+  Tracev((stderr, "inflate:   blocks allocated\n"));
+  inflate_blocks_reset(s, z, Z_NULL);
+  return s;
+}
+
+
+int inflate_blocks(s, z, r)
+inflate_blocks_statef *s;
+z_streamp z;
+int r;
+{
+  uInt t;               /* temporary storage */
+  uLong b;              /* bit buffer */
+  uInt k;               /* bits in bit buffer */
+  Bytef *p;             /* input data pointer */
+  uInt n;               /* bytes available there */
+  Bytef *q;             /* output window write pointer */
+  uInt m;               /* bytes to end of window or read pointer */
+
+  /* copy input/output information to locals (UPDATE macro restores) */
+  LOAD
+
+  /* process input based on current state */
+  while (1) switch (s->mode)
+  {
+    case TYPE:
+      NEEDBITS(3)
+      t = (uInt)b & 7;
+      s->last = t & 1;
+      switch (t >> 1)
+      {
+        case 0:                         /* stored */
+          Tracev((stderr, "inflate:     stored block%s\n",
+                 s->last ? " (last)" : ""));
+          DUMPBITS(3)
+          t = k & 7;                    /* go to byte boundary */
+          DUMPBITS(t)
+          s->mode = LENS;               /* get length of stored block */
+          break;
+        case 1:                         /* fixed */
+          Tracev((stderr, "inflate:     fixed codes block%s\n",
+                 s->last ? " (last)" : ""));
+          {
+            uInt bl, bd;
+            inflate_huft *tl, *td;
+
+            inflate_trees_fixed(&bl, &bd, &tl, &td, z);
+            s->sub.decode.codes = inflate_codes_new(bl, bd, tl, td, z);
+            if (s->sub.decode.codes == Z_NULL)
+            {
+              r = Z_MEM_ERROR;
+              LEAVE
+            }
+          }
+          DUMPBITS(3)
+          s->mode = CODES;
+          break;
+        case 2:                         /* dynamic */
+          Tracev((stderr, "inflate:     dynamic codes block%s\n",
+                 s->last ? " (last)" : ""));
+          DUMPBITS(3)
+          s->mode = TABLE;
+          break;
+        case 3:                         /* illegal */
+          DUMPBITS(3)
+          s->mode = BAD;
+          z->msg = (char*)"invalid block type";
+          r = Z_DATA_ERROR;
+          LEAVE
+      }
+      break;
+    case LENS:
+      NEEDBITS(32)
+      if ((((~b) >> 16) & 0xffff) != (b & 0xffff))
+      {
+        s->mode = BAD;
+        z->msg = (char*)"invalid stored block lengths";
+        r = Z_DATA_ERROR;
+        LEAVE
+      }
+      s->sub.left = (uInt)b & 0xffff;
+      b = k = 0;                      /* dump bits */
+      Tracev((stderr, "inflate:       stored length %u\n", s->sub.left));
+      s->mode = s->sub.left ? STORED : (s->last ? DRY : TYPE);
+      break;
+    case STORED:
+      if (n == 0)
+        LEAVE
+      NEEDOUT
+      t = s->sub.left;
+      if (t > n) t = n;
+      if (t > m) t = m;
+      zmemcpy(q, p, t);
+      p += t;  n -= t;
+      q += t;  m -= t;
+      if ((s->sub.left -= t) != 0)
+        break;
+      Tracev((stderr, "inflate:       stored end, %lu total out\n",
+              z->total_out + (q >= s->read ? q - s->read :
+              (s->end - s->read) + (q - s->window))));
+      s->mode = s->last ? DRY : TYPE;
+      break;
+    case TABLE:
+      NEEDBITS(14)
+      s->sub.trees.table = t = (uInt)b & 0x3fff;
+#ifndef PKZIP_BUG_WORKAROUND
+      if ((t & 0x1f) > 29 || ((t >> 5) & 0x1f) > 29)
+      {
+        s->mode = BAD;
+        z->msg = (char*)"too many length or distance symbols";
+        r = Z_DATA_ERROR;
+        LEAVE
+      }
+#endif
+      t = 258 + (t & 0x1f) + ((t >> 5) & 0x1f);
+      if ((s->sub.trees.blens = (uIntf*)ZALLOC(z, t, sizeof(uInt))) == Z_NULL)
+      {
+        r = Z_MEM_ERROR;
+        LEAVE
+      }
+      DUMPBITS(14)
+      s->sub.trees.index = 0;
+      Tracev((stderr, "inflate:       table sizes ok\n"));
+      s->mode = BTREE;
+    case BTREE:
+      while (s->sub.trees.index < 4 + (s->sub.trees.table >> 10))
+      {
+        NEEDBITS(3)
+        s->sub.trees.blens[border[s->sub.trees.index++]] = (uInt)b & 7;
+        DUMPBITS(3)
+      }
+      while (s->sub.trees.index < 19)
+        s->sub.trees.blens[border[s->sub.trees.index++]] = 0;
+      s->sub.trees.bb = 7;
+      t = inflate_trees_bits(s->sub.trees.blens, &s->sub.trees.bb,
+                             &s->sub.trees.tb, s->hufts, z);
+      if (t != Z_OK)
+      {
+        r = t;
+        if (r == Z_DATA_ERROR)
+        {
+          ZFREE(z, s->sub.trees.blens);
+          s->mode = BAD;
+        }
+        LEAVE
+      }
+      s->sub.trees.index = 0;
+      Tracev((stderr, "inflate:       bits tree ok\n"));
+      s->mode = DTREE;
+    case DTREE:
+      while (t = s->sub.trees.table,
+             s->sub.trees.index < 258 + (t & 0x1f) + ((t >> 5) & 0x1f))
+      {
+        inflate_huft *h;
+        uInt i, j, c;
+
+        t = s->sub.trees.bb;
+        NEEDBITS(t)
+        h = s->sub.trees.tb + ((uInt)b & inflate_mask[t]);
+        t = h->bits;
+        c = h->base;
+        if (c < 16)
+        {
+          DUMPBITS(t)
+          s->sub.trees.blens[s->sub.trees.index++] = c;
+        }
+        else /* c == 16..18 */
+        {
+          i = c == 18 ? 7 : c - 14;
+          j = c == 18 ? 11 : 3;
+          NEEDBITS(t + i)
+          DUMPBITS(t)
+          j += (uInt)b & inflate_mask[i];
+          DUMPBITS(i)
+          i = s->sub.trees.index;
+          t = s->sub.trees.table;
+          if (i + j > 258 + (t & 0x1f) + ((t >> 5) & 0x1f) ||
+              (c == 16 && i < 1))
+          {
+            ZFREE(z, s->sub.trees.blens);
+            s->mode = BAD;
+            z->msg = (char*)"invalid bit length repeat";
+            r = Z_DATA_ERROR;
+            LEAVE
+          }
+          c = c == 16 ? s->sub.trees.blens[i - 1] : 0;
+          do {
+            s->sub.trees.blens[i++] = c;
+          } while (--j);
+          s->sub.trees.index = i;
+        }
+      }
+      s->sub.trees.tb = Z_NULL;
+      {
+        uInt bl, bd;
+        inflate_huft *tl, *td;
+        inflate_codes_statef *c;
+
+        bl = 9;         /* must be <= 9 for lookahead assumptions */
+        bd = 6;         /* must be <= 9 for lookahead assumptions */
+        t = s->sub.trees.table;
+        t = inflate_trees_dynamic(257 + (t & 0x1f), 1 + ((t >> 5) & 0x1f),
+                                  s->sub.trees.blens, &bl, &bd, &tl, &td,
+                                  s->hufts, z);
+        if (t != Z_OK)
+        {
+          if (t == (uInt)Z_DATA_ERROR)
+          {
+            ZFREE(z, s->sub.trees.blens);
+            s->mode = BAD;
+          }
+          r = t;
+          LEAVE
+        }
+        Tracev((stderr, "inflate:       trees ok\n"));
+        if ((c = inflate_codes_new(bl, bd, tl, td, z)) == Z_NULL)
+        {
+          r = Z_MEM_ERROR;
+          LEAVE
+        }
+        s->sub.decode.codes = c;
+      }
+      ZFREE(z, s->sub.trees.blens);
+      s->mode = CODES;
+    case CODES:
+      UPDATE
+      if ((r = inflate_codes(s, z, r)) != Z_STREAM_END)
+        return inflate_flush(s, z, r);
+      r = Z_OK;
+      inflate_codes_free(s->sub.decode.codes, z);
+      LOAD
+      Tracev((stderr, "inflate:       codes end, %lu total out\n",
+              z->total_out + (q >= s->read ? q - s->read :
+              (s->end - s->read) + (q - s->window))));
+      if (!s->last)
+      {
+        s->mode = TYPE;
+        break;
+      }
+      s->mode = DRY;
+    case DRY:
+      FLUSH
+      if (s->read != s->write)
+        LEAVE
+      s->mode = DONE;
+    case DONE:
+      r = Z_STREAM_END;
+      LEAVE
+    case BAD:
+      r = Z_DATA_ERROR;
+      LEAVE
+    default:
+      r = Z_STREAM_ERROR;
+      LEAVE
+  }
+}
+
+
+int inflate_blocks_free(s, z)
+inflate_blocks_statef *s;
+z_streamp z;
+{
+  inflate_blocks_reset(s, z, Z_NULL);
+  ZFREE(z, s->window);
+  ZFREE(z, s->hufts);
+  ZFREE(z, s);
+  Tracev((stderr, "inflate:   blocks freed\n"));
+  return Z_OK;
+}
+
+
+void inflate_set_dictionary(s, d, n)
+inflate_blocks_statef *s;
+const Bytef *d;
+uInt  n;
+{
+  zmemcpy(s->window, d, n);
+  s->read = s->write = s->window + n;
+}
+
+
+/* Returns true if inflate is currently at the end of a block generated
+ * by Z_SYNC_FLUSH or Z_FULL_FLUSH. 
+ * IN assertion: s != Z_NULL
+ */
+int inflate_blocks_sync_point(s)
+inflate_blocks_statef *s;
+{
+  return s->mode == LENS;
+}
diff --git a/src/libz/src/infblock.h b/src/libz/src/infblock.h
new file mode 100644
index 0000000..173b226
--- /dev/null
+++ b/src/libz/src/infblock.h
@@ -0,0 +1,39 @@
+/* infblock.h -- header to use infblock.c
+ * Copyright (C) 1995-2002 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h 
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+   part of the implementation of the compression library and is
+   subject to change. Applications should only use zlib.h.
+ */
+
+struct inflate_blocks_state;
+typedef struct inflate_blocks_state FAR inflate_blocks_statef;
+
+extern inflate_blocks_statef * inflate_blocks_new OF((
+    z_streamp z,
+    check_func c,               /* check function */
+    uInt w));                   /* window size */
+
+extern int inflate_blocks OF((
+    inflate_blocks_statef *,
+    z_streamp ,
+    int));                      /* initial return code */
+
+extern void inflate_blocks_reset OF((
+    inflate_blocks_statef *,
+    z_streamp ,
+    uLongf *));                  /* check value on output */
+
+extern int inflate_blocks_free OF((
+    inflate_blocks_statef *,
+    z_streamp));
+
+extern void inflate_set_dictionary OF((
+    inflate_blocks_statef *s,
+    const Bytef *d,  /* dictionary */
+    uInt  n));       /* dictionary length */
+
+extern int inflate_blocks_sync_point OF((
+    inflate_blocks_statef *s));
diff --git a/src/libz/src/infcodes.c b/src/libz/src/infcodes.c
new file mode 100644
index 0000000..9abe541
--- /dev/null
+++ b/src/libz/src/infcodes.c
@@ -0,0 +1,251 @@
+/* infcodes.c -- process literals and length/distance pairs
+ * Copyright (C) 1995-2002 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h 
+ */
+
+#include "zutil.h"
+#include "inftrees.h"
+#include "infblock.h"
+#include "infcodes.h"
+#include "infutil.h"
+#include "inffast.h"
+
+/* simplify the use of the inflate_huft type with some defines */
+#define exop word.what.Exop
+#define bits word.what.Bits
+
+typedef enum {        /* waiting for "i:"=input, "o:"=output, "x:"=nothing */
+      START,    /* x: set up for LEN */
+      LEN,      /* i: get length/literal/eob next */
+      LENEXT,   /* i: getting length extra (have base) */
+      DIST,     /* i: get distance next */
+      DISTEXT,  /* i: getting distance extra */
+      COPY,     /* o: copying bytes in window, waiting for space */
+      LIT,      /* o: got literal, waiting for output space */
+      WASH,     /* o: got eob, possibly still output waiting */
+      END,      /* x: got eob and all data flushed */
+      BADCODE}  /* x: got error */
+inflate_codes_mode;
+
+/* inflate codes private state */
+struct inflate_codes_state {
+
+  /* mode */
+  inflate_codes_mode mode;      /* current inflate_codes mode */
+
+  /* mode dependent information */
+  uInt len;
+  union {
+    struct {
+      inflate_huft *tree;       /* pointer into tree */
+      uInt need;                /* bits needed */
+    } code;             /* if LEN or DIST, where in tree */
+    uInt lit;           /* if LIT, literal */
+    struct {
+      uInt get;                 /* bits to get for extra */
+      uInt dist;                /* distance back to copy from */
+    } copy;             /* if EXT or COPY, where and how much */
+  } sub;                /* submode */
+
+  /* mode independent information */
+  Byte lbits;           /* ltree bits decoded per branch */
+  Byte dbits;           /* dtree bits decoder per branch */
+  inflate_huft *ltree;          /* literal/length/eob tree */
+  inflate_huft *dtree;          /* distance tree */
+
+};
+
+
+inflate_codes_statef *inflate_codes_new(bl, bd, tl, td, z)
+uInt bl, bd;
+inflate_huft *tl;
+inflate_huft *td; /* need separate declaration for Borland C++ */
+z_streamp z;
+{
+  inflate_codes_statef *c;
+
+  if ((c = (inflate_codes_statef *)
+       ZALLOC(z,1,sizeof(struct inflate_codes_state))) != Z_NULL)
+  {
+    c->mode = START;
+    c->lbits = (Byte)bl;
+    c->dbits = (Byte)bd;
+    c->ltree = tl;
+    c->dtree = td;
+    Tracev((stderr, "inflate:       codes new\n"));
+  }
+  return c;
+}
+
+
+int inflate_codes(s, z, r)
+inflate_blocks_statef *s;
+z_streamp z;
+int r;
+{
+  uInt j;               /* temporary storage */
+  inflate_huft *t;      /* temporary pointer */
+  uInt e;               /* extra bits or operation */
+  uLong b;              /* bit buffer */
+  uInt k;               /* bits in bit buffer */
+  Bytef *p;             /* input data pointer */
+  uInt n;               /* bytes available there */
+  Bytef *q;             /* output window write pointer */
+  uInt m;               /* bytes to end of window or read pointer */
+  Bytef *f;             /* pointer to copy strings from */
+  inflate_codes_statef *c = s->sub.decode.codes;  /* codes state */
+
+  /* copy input/output information to locals (UPDATE macro restores) */
+  LOAD
+
+  /* process input and output based on current state */
+  while (1) switch (c->mode)
+  {             /* waiting for "i:"=input, "o:"=output, "x:"=nothing */
+    case START:         /* x: set up for LEN */
+#ifndef SLOW
+      if (m >= 258 && n >= 10)
+      {
+        UPDATE
+        r = inflate_fast(c->lbits, c->dbits, c->ltree, c->dtree, s, z);
+        LOAD
+        if (r != Z_OK)
+        {
+          c->mode = r == Z_STREAM_END ? WASH : BADCODE;
+          break;
+        }
+      }
+#endif /* !SLOW */
+      c->sub.code.need = c->lbits;
+      c->sub.code.tree = c->ltree;
+      c->mode = LEN;
+    case LEN:           /* i: get length/literal/eob next */
+      j = c->sub.code.need;
+      NEEDBITS(j)
+      t = c->sub.code.tree + ((uInt)b & inflate_mask[j]);
+      DUMPBITS(t->bits)
+      e = (uInt)(t->exop);
+      if (e == 0)               /* literal */
+      {
+        c->sub.lit = t->base;
+        Tracevv((stderr, t->base >= 0x20 && t->base < 0x7f ?
+                 "inflate:         literal '%c'\n" :
+                 "inflate:         literal 0x%02x\n", t->base));
+        c->mode = LIT;
+        break;
+      }
+      if (e & 16)               /* length */
+      {
+        c->sub.copy.get = e & 15;
+        c->len = t->base;
+        c->mode = LENEXT;
+        break;
+      }
+      if ((e & 64) == 0)        /* next table */
+      {
+        c->sub.code.need = e;
+        c->sub.code.tree = t + t->base;
+        break;
+      }
+      if (e & 32)               /* end of block */
+      {
+        Tracevv((stderr, "inflate:         end of block\n"));
+        c->mode = WASH;
+        break;
+      }
+      c->mode = BADCODE;        /* invalid code */
+      z->msg = (char*)"invalid literal/length code";
+      r = Z_DATA_ERROR;
+      LEAVE
+    case LENEXT:        /* i: getting length extra (have base) */
+      j = c->sub.copy.get;
+      NEEDBITS(j)
+      c->len += (uInt)b & inflate_mask[j];
+      DUMPBITS(j)
+      c->sub.code.need = c->dbits;
+      c->sub.code.tree = c->dtree;
+      Tracevv((stderr, "inflate:         length %u\n", c->len));
+      c->mode = DIST;
+    case DIST:          /* i: get distance next */
+      j = c->sub.code.need;
+      NEEDBITS(j)
+      t = c->sub.code.tree + ((uInt)b & inflate_mask[j]);
+      DUMPBITS(t->bits)
+      e = (uInt)(t->exop);
+      if (e & 16)               /* distance */
+      {
+        c->sub.copy.get = e & 15;
+        c->sub.copy.dist = t->base;
+        c->mode = DISTEXT;
+        break;
+      }
+      if ((e & 64) == 0)        /* next table */
+      {
+        c->sub.code.need = e;
+        c->sub.code.tree = t + t->base;
+        break;
+      }
+      c->mode = BADCODE;        /* invalid code */
+      z->msg = (char*)"invalid distance code";
+      r = Z_DATA_ERROR;
+      LEAVE
+    case DISTEXT:       /* i: getting distance extra */
+      j = c->sub.copy.get;
+      NEEDBITS(j)
+      c->sub.copy.dist += (uInt)b & inflate_mask[j];
+      DUMPBITS(j)
+      Tracevv((stderr, "inflate:         distance %u\n", c->sub.copy.dist));
+      c->mode = COPY;
+    case COPY:          /* o: copying bytes in window, waiting for space */
+      f = q - c->sub.copy.dist;
+      while (f < s->window)             /* modulo window size-"while" instead */
+        f += s->end - s->window;        /* of "if" handles invalid distances */
+      while (c->len)
+      {
+        NEEDOUT
+        OUTBYTE(*f++)
+        if (f == s->end)
+          f = s->window;
+        c->len--;
+      }
+      c->mode = START;
+      break;
+    case LIT:           /* o: got literal, waiting for output space */
+      NEEDOUT
+      OUTBYTE(c->sub.lit)
+      c->mode = START;
+      break;
+    case WASH:          /* o: got eob, possibly more output */
+      if (k > 7)        /* return unused byte, if any */
+      {
+        Assert(k < 16, "inflate_codes grabbed too many bytes")
+        k -= 8;
+        n++;
+        p--;            /* can always return one */
+      }
+      FLUSH
+      if (s->read != s->write)
+        LEAVE
+      c->mode = END;
+    case END:
+      r = Z_STREAM_END;
+      LEAVE
+    case BADCODE:       /* x: got error */
+      r = Z_DATA_ERROR;
+      LEAVE
+    default:
+      r = Z_STREAM_ERROR;
+      LEAVE
+  }
+#ifdef NEED_DUMMY_RETURN
+  return Z_STREAM_ERROR;  /* Some dumb compilers complain without this */
+#endif
+}
+
+
+void inflate_codes_free(c, z)
+inflate_codes_statef *c;
+z_streamp z;
+{
+  ZFREE(z, c);
+  Tracev((stderr, "inflate:       codes free\n"));
+}
diff --git a/src/libz/src/infcodes.h b/src/libz/src/infcodes.h
new file mode 100644
index 0000000..46821a0
--- /dev/null
+++ b/src/libz/src/infcodes.h
@@ -0,0 +1,27 @@
+/* infcodes.h -- header to use infcodes.c
+ * Copyright (C) 1995-2002 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h 
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+   part of the implementation of the compression library and is
+   subject to change. Applications should only use zlib.h.
+ */
+
+struct inflate_codes_state;
+typedef struct inflate_codes_state FAR inflate_codes_statef;
+
+extern inflate_codes_statef *inflate_codes_new OF((
+    uInt, uInt,
+    inflate_huft *, inflate_huft *,
+    z_streamp ));
+
+extern int inflate_codes OF((
+    inflate_blocks_statef *,
+    z_streamp ,
+    int));
+
+extern void inflate_codes_free OF((
+    inflate_codes_statef *,
+    z_streamp ));
+
diff --git a/src/libz/src/inffast.c b/src/libz/src/inffast.c
new file mode 100644
index 0000000..aa7f1d4
--- /dev/null
+++ b/src/libz/src/inffast.c
@@ -0,0 +1,183 @@
+/* inffast.c -- process literals and length/distance pairs fast
+ * Copyright (C) 1995-2002 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h 
+ */
+
+#include "zutil.h"
+#include "inftrees.h"
+#include "infblock.h"
+#include "infcodes.h"
+#include "infutil.h"
+#include "inffast.h"
+
+struct inflate_codes_state {int dummy;}; /* for buggy compilers */
+
+/* simplify the use of the inflate_huft type with some defines */
+#define exop word.what.Exop
+#define bits word.what.Bits
+
+/* macros for bit input with no checking and for returning unused bytes */
+#define GRABBITS(j) {while(k<(j)){b|=((uLong)NEXTBYTE)<<k;k+=8;}}
+#define UNGRAB {c=z->avail_in-n;c=(k>>3)<c?k>>3:c;n+=c;p-=c;k-=c<<3;}
+
+/* Called with number of bytes left to write in window at least 258
+   (the maximum string length) and number of input bytes available
+   at least ten.  The ten bytes are six bytes for the longest length/
+   distance pair plus four bytes for overloading the bit buffer. */
+
+int inflate_fast(bl, bd, tl, td, s, z)
+uInt bl, bd;
+inflate_huft *tl;
+inflate_huft *td; /* need separate declaration for Borland C++ */
+inflate_blocks_statef *s;
+z_streamp z;
+{
+  inflate_huft *t;      /* temporary pointer */
+  uInt e;               /* extra bits or operation */
+  uLong b;              /* bit buffer */
+  uInt k;               /* bits in bit buffer */
+  Bytef *p;             /* input data pointer */
+  uInt n;               /* bytes available there */
+  Bytef *q;             /* output window write pointer */
+  uInt m;               /* bytes to end of window or read pointer */
+  uInt ml;              /* mask for literal/length tree */
+  uInt md;              /* mask for distance tree */
+  uInt c;               /* bytes to copy */
+  uInt d;               /* distance back to copy from */
+  Bytef *r;             /* copy source pointer */
+
+  /* load input, output, bit values */
+  LOAD
+
+  /* initialize masks */
+  ml = inflate_mask[bl];
+  md = inflate_mask[bd];
+
+  /* do until not enough input or output space for fast loop */
+  do {                          /* assume called with m >= 258 && n >= 10 */
+    /* get literal/length code */
+    GRABBITS(20)                /* max bits for literal/length code */
+    if ((e = (t = tl + ((uInt)b & ml))->exop) == 0)
+    {
+      DUMPBITS(t->bits)
+      Tracevv((stderr, t->base >= 0x20 && t->base < 0x7f ?
+                "inflate:         * literal '%c'\n" :
+                "inflate:         * literal 0x%02x\n", t->base));
+      *q++ = (Byte)t->base;
+      m--;
+      continue;
+    }
+    do {
+      DUMPBITS(t->bits)
+      if (e & 16)
+      {
+        /* get extra bits for length */
+        e &= 15;
+        c = t->base + ((uInt)b & inflate_mask[e]);
+        DUMPBITS(e)
+        Tracevv((stderr, "inflate:         * length %u\n", c));
+
+        /* decode distance base of block to copy */
+        GRABBITS(15);           /* max bits for distance code */
+        e = (t = td + ((uInt)b & md))->exop;
+        do {
+          DUMPBITS(t->bits)
+          if (e & 16)
+          {
+            /* get extra bits to add to distance base */
+            e &= 15;
+            GRABBITS(e)         /* get extra bits (up to 13) */
+            d = t->base + ((uInt)b & inflate_mask[e]);
+            DUMPBITS(e)
+            Tracevv((stderr, "inflate:         * distance %u\n", d));
+
+            /* do the copy */
+            m -= c;
+            r = q - d;
+            if (r < s->window)                  /* wrap if needed */
+            {
+              do {
+                r += s->end - s->window;        /* force pointer in window */
+              } while (r < s->window);          /* covers invalid distances */
+              e = s->end - r;
+              if (c > e)
+              {
+                c -= e;                         /* wrapped copy */
+                do {
+                    *q++ = *r++;
+                } while (--e);
+                r = s->window;
+                do {
+                    *q++ = *r++;
+                } while (--c);
+              }
+              else                              /* normal copy */
+              {
+                *q++ = *r++;  c--;
+                *q++ = *r++;  c--;
+                do {
+                    *q++ = *r++;
+                } while (--c);
+              }
+            }
+            else                                /* normal copy */
+            {
+              *q++ = *r++;  c--;
+              *q++ = *r++;  c--;
+              do {
+                *q++ = *r++;
+              } while (--c);
+            }
+            break;
+          }
+          else if ((e & 64) == 0)
+          {
+            t += t->base;
+            e = (t += ((uInt)b & inflate_mask[e]))->exop;
+          }
+          else
+          {
+            z->msg = (char*)"invalid distance code";
+            UNGRAB
+            UPDATE
+            return Z_DATA_ERROR;
+          }
+        } while (1);
+        break;
+      }
+      if ((e & 64) == 0)
+      {
+        t += t->base;
+        if ((e = (t += ((uInt)b & inflate_mask[e]))->exop) == 0)
+        {
+          DUMPBITS(t->bits)
+          Tracevv((stderr, t->base >= 0x20 && t->base < 0x7f ?
+                    "inflate:         * literal '%c'\n" :
+                    "inflate:         * literal 0x%02x\n", t->base));
+          *q++ = (Byte)t->base;
+          m--;
+          break;
+        }
+      }
+      else if (e & 32)
+      {
+        Tracevv((stderr, "inflate:         * end of block\n"));
+        UNGRAB
+        UPDATE
+        return Z_STREAM_END;
+      }
+      else
+      {
+        z->msg = (char*)"invalid literal/length code";
+        UNGRAB
+        UPDATE
+        return Z_DATA_ERROR;
+      }
+    } while (1);
+  } while (m >= 258 && n >= 10);
+
+  /* not enough input or output--restore pointers and return */
+  UNGRAB
+  UPDATE
+  return Z_OK;
+}
diff --git a/src/libz/src/inffast.h b/src/libz/src/inffast.h
new file mode 100644
index 0000000..a31a4bb
--- /dev/null
+++ b/src/libz/src/inffast.h
@@ -0,0 +1,17 @@
+/* inffast.h -- header to use inffast.c
+ * Copyright (C) 1995-2002 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h 
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+   part of the implementation of the compression library and is
+   subject to change. Applications should only use zlib.h.
+ */
+
+extern int inflate_fast OF((
+    uInt,
+    uInt,
+    inflate_huft *,
+    inflate_huft *,
+    inflate_blocks_statef *,
+    z_streamp ));
diff --git a/src/libz/src/inffixed.h b/src/libz/src/inffixed.h
new file mode 100644
index 0000000..77f7e76
--- /dev/null
+++ b/src/libz/src/inffixed.h
@@ -0,0 +1,151 @@
+/* inffixed.h -- table for decoding fixed codes
+ * Generated automatically by the maketree.c program
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+   part of the implementation of the compression library and is
+   subject to change. Applications should only use zlib.h.
+ */
+
+local uInt fixed_bl = 9;
+local uInt fixed_bd = 5;
+local inflate_huft fixed_tl[] = {
+    {{{96,7}},256}, {{{0,8}},80}, {{{0,8}},16}, {{{84,8}},115},
+    {{{82,7}},31}, {{{0,8}},112}, {{{0,8}},48}, {{{0,9}},192},
+    {{{80,7}},10}, {{{0,8}},96}, {{{0,8}},32}, {{{0,9}},160},
+    {{{0,8}},0}, {{{0,8}},128}, {{{0,8}},64}, {{{0,9}},224},
+    {{{80,7}},6}, {{{0,8}},88}, {{{0,8}},24}, {{{0,9}},144},
+    {{{83,7}},59}, {{{0,8}},120}, {{{0,8}},56}, {{{0,9}},208},
+    {{{81,7}},17}, {{{0,8}},104}, {{{0,8}},40}, {{{0,9}},176},
+    {{{0,8}},8}, {{{0,8}},136}, {{{0,8}},72}, {{{0,9}},240},
+    {{{80,7}},4}, {{{0,8}},84}, {{{0,8}},20}, {{{85,8}},227},
+    {{{83,7}},43}, {{{0,8}},116}, {{{0,8}},52}, {{{0,9}},200},
+    {{{81,7}},13}, {{{0,8}},100}, {{{0,8}},36}, {{{0,9}},168},
+    {{{0,8}},4}, {{{0,8}},132}, {{{0,8}},68}, {{{0,9}},232},
+    {{{80,7}},8}, {{{0,8}},92}, {{{0,8}},28}, {{{0,9}},152},
+    {{{84,7}},83}, {{{0,8}},124}, {{{0,8}},60}, {{{0,9}},216},
+    {{{82,7}},23}, {{{0,8}},108}, {{{0,8}},44}, {{{0,9}},184},
+    {{{0,8}},12}, {{{0,8}},140}, {{{0,8}},76}, {{{0,9}},248},
+    {{{80,7}},3}, {{{0,8}},82}, {{{0,8}},18}, {{{85,8}},163},
+    {{{83,7}},35}, {{{0,8}},114}, {{{0,8}},50}, {{{0,9}},196},
+    {{{81,7}},11}, {{{0,8}},98}, {{{0,8}},34}, {{{0,9}},164},
+    {{{0,8}},2}, {{{0,8}},130}, {{{0,8}},66}, {{{0,9}},228},
+    {{{80,7}},7}, {{{0,8}},90}, {{{0,8}},26}, {{{0,9}},148},
+    {{{84,7}},67}, {{{0,8}},122}, {{{0,8}},58}, {{{0,9}},212},
+    {{{82,7}},19}, {{{0,8}},106}, {{{0,8}},42}, {{{0,9}},180},
+    {{{0,8}},10}, {{{0,8}},138}, {{{0,8}},74}, {{{0,9}},244},
+    {{{80,7}},5}, {{{0,8}},86}, {{{0,8}},22}, {{{192,8}},0},
+    {{{83,7}},51}, {{{0,8}},118}, {{{0,8}},54}, {{{0,9}},204},
+    {{{81,7}},15}, {{{0,8}},102}, {{{0,8}},38}, {{{0,9}},172},
+    {{{0,8}},6}, {{{0,8}},134}, {{{0,8}},70}, {{{0,9}},236},
+    {{{80,7}},9}, {{{0,8}},94}, {{{0,8}},30}, {{{0,9}},156},
+    {{{84,7}},99}, {{{0,8}},126}, {{{0,8}},62}, {{{0,9}},220},
+    {{{82,7}},27}, {{{0,8}},110}, {{{0,8}},46}, {{{0,9}},188},
+    {{{0,8}},14}, {{{0,8}},142}, {{{0,8}},78}, {{{0,9}},252},
+    {{{96,7}},256}, {{{0,8}},81}, {{{0,8}},17}, {{{85,8}},131},
+    {{{82,7}},31}, {{{0,8}},113}, {{{0,8}},49}, {{{0,9}},194},
+    {{{80,7}},10}, {{{0,8}},97}, {{{0,8}},33}, {{{0,9}},162},
+    {{{0,8}},1}, {{{0,8}},129}, {{{0,8}},65}, {{{0,9}},226},
+    {{{80,7}},6}, {{{0,8}},89}, {{{0,8}},25}, {{{0,9}},146},
+    {{{83,7}},59}, {{{0,8}},121}, {{{0,8}},57}, {{{0,9}},210},
+    {{{81,7}},17}, {{{0,8}},105}, {{{0,8}},41}, {{{0,9}},178},
+    {{{0,8}},9}, {{{0,8}},137}, {{{0,8}},73}, {{{0,9}},242},
+    {{{80,7}},4}, {{{0,8}},85}, {{{0,8}},21}, {{{80,8}},258},
+    {{{83,7}},43}, {{{0,8}},117}, {{{0,8}},53}, {{{0,9}},202},
+    {{{81,7}},13}, {{{0,8}},101}, {{{0,8}},37}, {{{0,9}},170},
+    {{{0,8}},5}, {{{0,8}},133}, {{{0,8}},69}, {{{0,9}},234},
+    {{{80,7}},8}, {{{0,8}},93}, {{{0,8}},29}, {{{0,9}},154},
+    {{{84,7}},83}, {{{0,8}},125}, {{{0,8}},61}, {{{0,9}},218},
+    {{{82,7}},23}, {{{0,8}},109}, {{{0,8}},45}, {{{0,9}},186},
+    {{{0,8}},13}, {{{0,8}},141}, {{{0,8}},77}, {{{0,9}},250},
+    {{{80,7}},3}, {{{0,8}},83}, {{{0,8}},19}, {{{85,8}},195},
+    {{{83,7}},35}, {{{0,8}},115}, {{{0,8}},51}, {{{0,9}},198},
+    {{{81,7}},11}, {{{0,8}},99}, {{{0,8}},35}, {{{0,9}},166},
+    {{{0,8}},3}, {{{0,8}},131}, {{{0,8}},67}, {{{0,9}},230},
+    {{{80,7}},7}, {{{0,8}},91}, {{{0,8}},27}, {{{0,9}},150},
+    {{{84,7}},67}, {{{0,8}},123}, {{{0,8}},59}, {{{0,9}},214},
+    {{{82,7}},19}, {{{0,8}},107}, {{{0,8}},43}, {{{0,9}},182},
+    {{{0,8}},11}, {{{0,8}},139}, {{{0,8}},75}, {{{0,9}},246},
+    {{{80,7}},5}, {{{0,8}},87}, {{{0,8}},23}, {{{192,8}},0},
+    {{{83,7}},51}, {{{0,8}},119}, {{{0,8}},55}, {{{0,9}},206},
+    {{{81,7}},15}, {{{0,8}},103}, {{{0,8}},39}, {{{0,9}},174},
+    {{{0,8}},7}, {{{0,8}},135}, {{{0,8}},71}, {{{0,9}},238},
+    {{{80,7}},9}, {{{0,8}},95}, {{{0,8}},31}, {{{0,9}},158},
+    {{{84,7}},99}, {{{0,8}},127}, {{{0,8}},63}, {{{0,9}},222},
+    {{{82,7}},27}, {{{0,8}},111}, {{{0,8}},47}, {{{0,9}},190},
+    {{{0,8}},15}, {{{0,8}},143}, {{{0,8}},79}, {{{0,9}},254},
+    {{{96,7}},256}, {{{0,8}},80}, {{{0,8}},16}, {{{84,8}},115},
+    {{{82,7}},31}, {{{0,8}},112}, {{{0,8}},48}, {{{0,9}},193},
+    {{{80,7}},10}, {{{0,8}},96}, {{{0,8}},32}, {{{0,9}},161},
+    {{{0,8}},0}, {{{0,8}},128}, {{{0,8}},64}, {{{0,9}},225},
+    {{{80,7}},6}, {{{0,8}},88}, {{{0,8}},24}, {{{0,9}},145},
+    {{{83,7}},59}, {{{0,8}},120}, {{{0,8}},56}, {{{0,9}},209},
+    {{{81,7}},17}, {{{0,8}},104}, {{{0,8}},40}, {{{0,9}},177},
+    {{{0,8}},8}, {{{0,8}},136}, {{{0,8}},72}, {{{0,9}},241},
+    {{{80,7}},4}, {{{0,8}},84}, {{{0,8}},20}, {{{85,8}},227},
+    {{{83,7}},43}, {{{0,8}},116}, {{{0,8}},52}, {{{0,9}},201},
+    {{{81,7}},13}, {{{0,8}},100}, {{{0,8}},36}, {{{0,9}},169},
+    {{{0,8}},4}, {{{0,8}},132}, {{{0,8}},68}, {{{0,9}},233},
+    {{{80,7}},8}, {{{0,8}},92}, {{{0,8}},28}, {{{0,9}},153},
+    {{{84,7}},83}, {{{0,8}},124}, {{{0,8}},60}, {{{0,9}},217},
+    {{{82,7}},23}, {{{0,8}},108}, {{{0,8}},44}, {{{0,9}},185},
+    {{{0,8}},12}, {{{0,8}},140}, {{{0,8}},76}, {{{0,9}},249},
+    {{{80,7}},3}, {{{0,8}},82}, {{{0,8}},18}, {{{85,8}},163},
+    {{{83,7}},35}, {{{0,8}},114}, {{{0,8}},50}, {{{0,9}},197},
+    {{{81,7}},11}, {{{0,8}},98}, {{{0,8}},34}, {{{0,9}},165},
+    {{{0,8}},2}, {{{0,8}},130}, {{{0,8}},66}, {{{0,9}},229},
+    {{{80,7}},7}, {{{0,8}},90}, {{{0,8}},26}, {{{0,9}},149},
+    {{{84,7}},67}, {{{0,8}},122}, {{{0,8}},58}, {{{0,9}},213},
+    {{{82,7}},19}, {{{0,8}},106}, {{{0,8}},42}, {{{0,9}},181},
+    {{{0,8}},10}, {{{0,8}},138}, {{{0,8}},74}, {{{0,9}},245},
+    {{{80,7}},5}, {{{0,8}},86}, {{{0,8}},22}, {{{192,8}},0},
+    {{{83,7}},51}, {{{0,8}},118}, {{{0,8}},54}, {{{0,9}},205},
+    {{{81,7}},15}, {{{0,8}},102}, {{{0,8}},38}, {{{0,9}},173},
+    {{{0,8}},6}, {{{0,8}},134}, {{{0,8}},70}, {{{0,9}},237},
+    {{{80,7}},9}, {{{0,8}},94}, {{{0,8}},30}, {{{0,9}},157},
+    {{{84,7}},99}, {{{0,8}},126}, {{{0,8}},62}, {{{0,9}},221},
+    {{{82,7}},27}, {{{0,8}},110}, {{{0,8}},46}, {{{0,9}},189},
+    {{{0,8}},14}, {{{0,8}},142}, {{{0,8}},78}, {{{0,9}},253},
+    {{{96,7}},256}, {{{0,8}},81}, {{{0,8}},17}, {{{85,8}},131},
+    {{{82,7}},31}, {{{0,8}},113}, {{{0,8}},49}, {{{0,9}},195},
+    {{{80,7}},10}, {{{0,8}},97}, {{{0,8}},33}, {{{0,9}},163},
+    {{{0,8}},1}, {{{0,8}},129}, {{{0,8}},65}, {{{0,9}},227},
+    {{{80,7}},6}, {{{0,8}},89}, {{{0,8}},25}, {{{0,9}},147},
+    {{{83,7}},59}, {{{0,8}},121}, {{{0,8}},57}, {{{0,9}},211},
+    {{{81,7}},17}, {{{0,8}},105}, {{{0,8}},41}, {{{0,9}},179},
+    {{{0,8}},9}, {{{0,8}},137}, {{{0,8}},73}, {{{0,9}},243},
+    {{{80,7}},4}, {{{0,8}},85}, {{{0,8}},21}, {{{80,8}},258},
+    {{{83,7}},43}, {{{0,8}},117}, {{{0,8}},53}, {{{0,9}},203},
+    {{{81,7}},13}, {{{0,8}},101}, {{{0,8}},37}, {{{0,9}},171},
+    {{{0,8}},5}, {{{0,8}},133}, {{{0,8}},69}, {{{0,9}},235},
+    {{{80,7}},8}, {{{0,8}},93}, {{{0,8}},29}, {{{0,9}},155},
+    {{{84,7}},83}, {{{0,8}},125}, {{{0,8}},61}, {{{0,9}},219},
+    {{{82,7}},23}, {{{0,8}},109}, {{{0,8}},45}, {{{0,9}},187},
+    {{{0,8}},13}, {{{0,8}},141}, {{{0,8}},77}, {{{0,9}},251},
+    {{{80,7}},3}, {{{0,8}},83}, {{{0,8}},19}, {{{85,8}},195},
+    {{{83,7}},35}, {{{0,8}},115}, {{{0,8}},51}, {{{0,9}},199},
+    {{{81,7}},11}, {{{0,8}},99}, {{{0,8}},35}, {{{0,9}},167},
+    {{{0,8}},3}, {{{0,8}},131}, {{{0,8}},67}, {{{0,9}},231},
+    {{{80,7}},7}, {{{0,8}},91}, {{{0,8}},27}, {{{0,9}},151},
+    {{{84,7}},67}, {{{0,8}},123}, {{{0,8}},59}, {{{0,9}},215},
+    {{{82,7}},19}, {{{0,8}},107}, {{{0,8}},43}, {{{0,9}},183},
+    {{{0,8}},11}, {{{0,8}},139}, {{{0,8}},75}, {{{0,9}},247},
+    {{{80,7}},5}, {{{0,8}},87}, {{{0,8}},23}, {{{192,8}},0},
+    {{{83,7}},51}, {{{0,8}},119}, {{{0,8}},55}, {{{0,9}},207},
+    {{{81,7}},15}, {{{0,8}},103}, {{{0,8}},39}, {{{0,9}},175},
+    {{{0,8}},7}, {{{0,8}},135}, {{{0,8}},71}, {{{0,9}},239},
+    {{{80,7}},9}, {{{0,8}},95}, {{{0,8}},31}, {{{0,9}},159},
+    {{{84,7}},99}, {{{0,8}},127}, {{{0,8}},63}, {{{0,9}},223},
+    {{{82,7}},27}, {{{0,8}},111}, {{{0,8}},47}, {{{0,9}},191},
+    {{{0,8}},15}, {{{0,8}},143}, {{{0,8}},79}, {{{0,9}},255}
+  };
+local inflate_huft fixed_td[] = {
+    {{{80,5}},1}, {{{87,5}},257}, {{{83,5}},17}, {{{91,5}},4097},
+    {{{81,5}},5}, {{{89,5}},1025}, {{{85,5}},65}, {{{93,5}},16385},
+    {{{80,5}},3}, {{{88,5}},513}, {{{84,5}},33}, {{{92,5}},8193},
+    {{{82,5}},9}, {{{90,5}},2049}, {{{86,5}},129}, {{{192,5}},24577},
+    {{{80,5}},2}, {{{87,5}},385}, {{{83,5}},25}, {{{91,5}},6145},
+    {{{81,5}},7}, {{{89,5}},1537}, {{{85,5}},97}, {{{93,5}},24577},
+    {{{80,5}},4}, {{{88,5}},769}, {{{84,5}},49}, {{{92,5}},12289},
+    {{{82,5}},13}, {{{90,5}},3073}, {{{86,5}},193}, {{{192,5}},24577}
+  };
diff --git a/src/libz/src/inflate.c b/src/libz/src/inflate.c
new file mode 100644
index 0000000..dfb2e86
--- /dev/null
+++ b/src/libz/src/inflate.c
@@ -0,0 +1,366 @@
+/* inflate.c -- zlib interface to inflate modules
+ * Copyright (C) 1995-2002 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h 
+ */
+
+#include "zutil.h"
+#include "infblock.h"
+
+struct inflate_blocks_state {int dummy;}; /* for buggy compilers */
+
+typedef enum {
+      METHOD,   /* waiting for method byte */
+      FLAG,     /* waiting for flag byte */
+      DICT4,    /* four dictionary check bytes to go */
+      DICT3,    /* three dictionary check bytes to go */
+      DICT2,    /* two dictionary check bytes to go */
+      DICT1,    /* one dictionary check byte to go */
+      DICT0,    /* waiting for inflateSetDictionary */
+      BLOCKS,   /* decompressing blocks */
+      CHECK4,   /* four check bytes to go */
+      CHECK3,   /* three check bytes to go */
+      CHECK2,   /* two check bytes to go */
+      CHECK1,   /* one check byte to go */
+      DONE,     /* finished check, done */
+      BAD}      /* got an error--stay here */
+inflate_mode;
+
+/* inflate private state */
+struct internal_state {
+
+  /* mode */
+  inflate_mode  mode;   /* current inflate mode */
+
+  /* mode dependent information */
+  union {
+    uInt method;        /* if FLAGS, method byte */
+    struct {
+      uLong was;                /* computed check value */
+      uLong need;               /* stream check value */
+    } check;            /* if CHECK, check values to compare */
+    uInt marker;        /* if BAD, inflateSync's marker bytes count */
+  } sub;        /* submode */
+
+  /* mode independent information */
+  int  nowrap;          /* flag for no wrapper */
+  uInt wbits;           /* log2(window size)  (8..15, defaults to 15) */
+  inflate_blocks_statef 
+    *blocks;            /* current inflate_blocks state */
+
+};
+
+
+int ZEXPORT inflateReset(z)
+z_streamp z;
+{
+  if (z == Z_NULL || z->state == Z_NULL)
+    return Z_STREAM_ERROR;
+  z->total_in = z->total_out = 0;
+  z->msg = Z_NULL;
+  z->state->mode = z->state->nowrap ? BLOCKS : METHOD;
+  inflate_blocks_reset(z->state->blocks, z, Z_NULL);
+  Tracev((stderr, "inflate: reset\n"));
+  return Z_OK;
+}
+
+
+int ZEXPORT inflateEnd(z)
+z_streamp z;
+{
+  if (z == Z_NULL || z->state == Z_NULL || z->zfree == Z_NULL)
+    return Z_STREAM_ERROR;
+  if (z->state->blocks != Z_NULL)
+    inflate_blocks_free(z->state->blocks, z);
+  ZFREE(z, z->state);
+  z->state = Z_NULL;
+  Tracev((stderr, "inflate: end\n"));
+  return Z_OK;
+}
+
+
+int ZEXPORT inflateInit2_(z, w, version, stream_size)
+z_streamp z;
+int w;
+const char *version;
+int stream_size;
+{
+  if (version == Z_NULL || version[0] != ZLIB_VERSION[0] ||
+      stream_size != sizeof(z_stream))
+      return Z_VERSION_ERROR;
+
+  /* initialize state */
+  if (z == Z_NULL)
+    return Z_STREAM_ERROR;
+  z->msg = Z_NULL;
+  if (z->zalloc == Z_NULL)
+  {
+    z->zalloc = zcalloc;
+    z->opaque = (voidpf)0;
+  }
+  if (z->zfree == Z_NULL) z->zfree = zcfree;
+  if ((z->state = (struct internal_state FAR *)
+       ZALLOC(z,1,sizeof(struct internal_state))) == Z_NULL)
+    return Z_MEM_ERROR;
+  z->state->blocks = Z_NULL;
+
+  /* handle undocumented nowrap option (no zlib header or check) */
+  z->state->nowrap = 0;
+  if (w < 0)
+  {
+    w = - w;
+    z->state->nowrap = 1;
+  }
+
+  /* set window size */
+  if (w < 8 || w > 15)
+  {
+    inflateEnd(z);
+    return Z_STREAM_ERROR;
+  }
+  z->state->wbits = (uInt)w;
+
+  /* create inflate_blocks state */
+  if ((z->state->blocks =
+      inflate_blocks_new(z, z->state->nowrap ? Z_NULL : adler32, (uInt)1 << w))
+      == Z_NULL)
+  {
+    inflateEnd(z);
+    return Z_MEM_ERROR;
+  }
+  Tracev((stderr, "inflate: allocated\n"));
+
+  /* reset state */
+  inflateReset(z);
+  return Z_OK;
+}
+
+
+int ZEXPORT inflateInit_(z, version, stream_size)
+z_streamp z;
+const char *version;
+int stream_size;
+{
+  return inflateInit2_(z, DEF_WBITS, version, stream_size);
+}
+
+
+#define NEEDBYTE {if(z->avail_in==0)return r;r=f;}
+#define NEXTBYTE (z->avail_in--,z->total_in++,*z->next_in++)
+
+int ZEXPORT inflate(z, f)
+z_streamp z;
+int f;
+{
+  int r;
+  uInt b;
+
+  if (z == Z_NULL || z->state == Z_NULL || z->next_in == Z_NULL)
+    return Z_STREAM_ERROR;
+  f = f == Z_FINISH ? Z_BUF_ERROR : Z_OK;
+  r = Z_BUF_ERROR;
+  while (1) switch (z->state->mode)
+  {
+    case METHOD:
+      NEEDBYTE
+      if (((z->state->sub.method = NEXTBYTE) & 0xf) != Z_DEFLATED)
+      {
+        z->state->mode = BAD;
+        z->msg = (char*)"unknown compression method";
+        z->state->sub.marker = 5;       /* can't try inflateSync */
+        break;
+      }
+      if ((z->state->sub.method >> 4) + 8 > z->state->wbits)
+      {
+        z->state->mode = BAD;
+        z->msg = (char*)"invalid window size";
+        z->state->sub.marker = 5;       /* can't try inflateSync */
+        break;
+      }
+      z->state->mode = FLAG;
+    case FLAG:
+      NEEDBYTE
+      b = NEXTBYTE;
+      if (((z->state->sub.method << 8) + b) % 31)
+      {
+        z->state->mode = BAD;
+        z->msg = (char*)"incorrect header check";
+        z->state->sub.marker = 5;       /* can't try inflateSync */
+        break;
+      }
+      Tracev((stderr, "inflate: zlib header ok\n"));
+      if (!(b & PRESET_DICT))
+      {
+        z->state->mode = BLOCKS;
+        break;
+      }
+      z->state->mode = DICT4;
+    case DICT4:
+      NEEDBYTE
+      z->state->sub.check.need = (uLong)NEXTBYTE << 24;
+      z->state->mode = DICT3;
+    case DICT3:
+      NEEDBYTE
+      z->state->sub.check.need += (uLong)NEXTBYTE << 16;
+      z->state->mode = DICT2;
+    case DICT2:
+      NEEDBYTE
+      z->state->sub.check.need += (uLong)NEXTBYTE << 8;
+      z->state->mode = DICT1;
+    case DICT1:
+      NEEDBYTE
+      z->state->sub.check.need += (uLong)NEXTBYTE;
+      z->adler = z->state->sub.check.need;
+      z->state->mode = DICT0;
+      return Z_NEED_DICT;
+    case DICT0:
+      z->state->mode = BAD;
+      z->msg = (char*)"need dictionary";
+      z->state->sub.marker = 0;       /* can try inflateSync */
+      return Z_STREAM_ERROR;
+    case BLOCKS:
+      r = inflate_blocks(z->state->blocks, z, r);
+      if (r == Z_DATA_ERROR)
+      {
+        z->state->mode = BAD;
+        z->state->sub.marker = 0;       /* can try inflateSync */
+        break;
+      }
+      if (r == Z_OK)
+        r = f;
+      if (r != Z_STREAM_END)
+        return r;
+      r = f;
+      inflate_blocks_reset(z->state->blocks, z, &z->state->sub.check.was);
+      if (z->state->nowrap)
+      {
+        z->state->mode = DONE;
+        break;
+      }
+      z->state->mode = CHECK4;
+    case CHECK4:
+      NEEDBYTE
+      z->state->sub.check.need = (uLong)NEXTBYTE << 24;
+      z->state->mode = CHECK3;
+    case CHECK3:
+      NEEDBYTE
+      z->state->sub.check.need += (uLong)NEXTBYTE << 16;
+      z->state->mode = CHECK2;
+    case CHECK2:
+      NEEDBYTE
+      z->state->sub.check.need += (uLong)NEXTBYTE << 8;
+      z->state->mode = CHECK1;
+    case CHECK1:
+      NEEDBYTE
+      z->state->sub.check.need += (uLong)NEXTBYTE;
+
+      if (z->state->sub.check.was != z->state->sub.check.need)
+      {
+        z->state->mode = BAD;
+        z->msg = (char*)"incorrect data check";
+        z->state->sub.marker = 5;       /* can't try inflateSync */
+        break;
+      }
+      Tracev((stderr, "inflate: zlib check ok\n"));
+      z->state->mode = DONE;
+    case DONE:
+      return Z_STREAM_END;
+    case BAD:
+      return Z_DATA_ERROR;
+    default:
+      return Z_STREAM_ERROR;
+  }
+#ifdef NEED_DUMMY_RETURN
+  return Z_STREAM_ERROR;  /* Some dumb compilers complain without this */
+#endif
+}
+
+
+int ZEXPORT inflateSetDictionary(z, dictionary, dictLength)
+z_streamp z;
+const Bytef *dictionary;
+uInt  dictLength;
+{
+  uInt length = dictLength;
+
+  if (z == Z_NULL || z->state == Z_NULL || z->state->mode != DICT0)
+    return Z_STREAM_ERROR;
+
+  if (adler32(1L, dictionary, dictLength) != z->adler) return Z_DATA_ERROR;
+  z->adler = 1L;
+
+  if (length >= ((uInt)1<<z->state->wbits))
+  {
+    length = (1<<z->state->wbits)-1;
+    dictionary += dictLength - length;
+  }
+  inflate_set_dictionary(z->state->blocks, dictionary, length);
+  z->state->mode = BLOCKS;
+  return Z_OK;
+}
+
+
+int ZEXPORT inflateSync(z)
+z_streamp z;
+{
+  uInt n;       /* number of bytes to look at */
+  Bytef *p;     /* pointer to bytes */
+  uInt m;       /* number of marker bytes found in a row */
+  uLong r, w;   /* temporaries to save total_in and total_out */
+
+  /* set up */
+  if (z == Z_NULL || z->state == Z_NULL)
+    return Z_STREAM_ERROR;
+  if (z->state->mode != BAD)
+  {
+    z->state->mode = BAD;
+    z->state->sub.marker = 0;
+  }
+  if ((n = z->avail_in) == 0)
+    return Z_BUF_ERROR;
+  p = z->next_in;
+  m = z->state->sub.marker;
+
+  /* search */
+  while (n && m < 4)
+  {
+    static const Byte mark[4] = {0, 0, 0xff, 0xff};
+    if (*p == mark[m])
+      m++;
+    else if (*p)
+      m = 0;
+    else
+      m = 4 - m;
+    p++, n--;
+  }
+
+  /* restore */
+  z->total_in += p - z->next_in;
+  z->next_in = p;
+  z->avail_in = n;
+  z->state->sub.marker = m;
+
+  /* return no joy or set up to restart on a new block */
+  if (m != 4)
+    return Z_DATA_ERROR;
+  r = z->total_in;  w = z->total_out;
+  inflateReset(z);
+  z->total_in = r;  z->total_out = w;
+  z->state->mode = BLOCKS;
+  return Z_OK;
+}
+
+
+/* Returns true if inflate is currently at the end of a block generated
+ * by Z_SYNC_FLUSH or Z_FULL_FLUSH. This function is used by one PPP
+ * implementation to provide an additional safety check. PPP uses Z_SYNC_FLUSH
+ * but removes the length bytes of the resulting empty stored block. When
+ * decompressing, PPP checks that at the end of input packet, inflate is
+ * waiting for these length bytes.
+ */
+int ZEXPORT inflateSyncPoint(z)
+z_streamp z;
+{
+  if (z == Z_NULL || z->state == Z_NULL || z->state->blocks == Z_NULL)
+    return Z_STREAM_ERROR;
+  return inflate_blocks_sync_point(z->state->blocks);
+}
diff --git a/src/libz/src/inftrees.c b/src/libz/src/inftrees.c
new file mode 100644
index 0000000..4c32ca3
--- /dev/null
+++ b/src/libz/src/inftrees.c
@@ -0,0 +1,454 @@
+/* inftrees.c -- generate Huffman trees for efficient decoding
+ * Copyright (C) 1995-2002 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h 
+ */
+
+#include "zutil.h"
+#include "inftrees.h"
+
+#if !defined(BUILDFIXED) && !defined(STDC)
+#  define BUILDFIXED   /* non ANSI compilers may not accept inffixed.h */
+#endif
+
+const char inflate_copyright[] =
+   " inflate 1.1.4 Copyright 1995-2002 Mark Adler ";
+/*
+  If you use the zlib library in a product, an acknowledgment is welcome
+  in the documentation of your product. If for some reason you cannot
+  include such an acknowledgment, I would appreciate that you keep this
+  copyright string in the executable of your product.
+ */
+struct internal_state  {int dummy;}; /* for buggy compilers */
+
+/* simplify the use of the inflate_huft type with some defines */
+#define exop word.what.Exop
+#define bits word.what.Bits
+
+
+local int huft_build OF((
+    uIntf *,            /* code lengths in bits */
+    uInt,               /* number of codes */
+    uInt,               /* number of "simple" codes */
+    const uIntf *,      /* list of base values for non-simple codes */
+    const uIntf *,      /* list of extra bits for non-simple codes */
+    inflate_huft * FAR*,/* result: starting table */
+    uIntf *,            /* maximum lookup bits (returns actual) */
+    inflate_huft *,     /* space for trees */
+    uInt *,             /* hufts used in space */
+    uIntf * ));         /* space for values */
+
+/* Tables for deflate from PKZIP's appnote.txt. */
+local const uInt cplens[31] = { /* Copy lengths for literal codes 257..285 */
+        3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
+        35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0};
+        /* see note #13 above about 258 */
+local const uInt cplext[31] = { /* Extra bits for literal codes 257..285 */
+        0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2,
+        3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 112, 112}; /* 112==invalid */
+local const uInt cpdist[30] = { /* Copy offsets for distance codes 0..29 */
+        1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
+        257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
+        8193, 12289, 16385, 24577};
+local const uInt cpdext[30] = { /* Extra bits for distance codes */
+        0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6,
+        7, 7, 8, 8, 9, 9, 10, 10, 11, 11,
+        12, 12, 13, 13};
+
+/*
+   Huffman code decoding is performed using a multi-level table lookup.
+   The fastest way to decode is to simply build a lookup table whose
+   size is determined by the longest code.  However, the time it takes
+   to build this table can also be a factor if the data being decoded
+   is not very long.  The most common codes are necessarily the
+   shortest codes, so those codes dominate the decoding time, and hence
+   the speed.  The idea is you can have a shorter table that decodes the
+   shorter, more probable codes, and then point to subsidiary tables for
+   the longer codes.  The time it costs to decode the longer codes is
+   then traded against the time it takes to make longer tables.
+
+   This results of this trade are in the variables lbits and dbits
+   below.  lbits is the number of bits the first level table for literal/
+   length codes can decode in one step, and dbits is the same thing for
+   the distance codes.  Subsequent tables are also less than or equal to
+   those sizes.  These values may be adjusted either when all of the
+   codes are shorter than that, in which case the longest code length in
+   bits is used, or when the shortest code is *longer* than the requested
+   table size, in which case the length of the shortest code in bits is
+   used.
+
+   There are two different values for the two tables, since they code a
+   different number of possibilities each.  The literal/length table
+   codes 286 possible values, or in a flat code, a little over eight
+   bits.  The distance table codes 30 possible values, or a little less
+   than five bits, flat.  The optimum values for speed end up being
+   about one bit more than those, so lbits is 8+1 and dbits is 5+1.
+   The optimum values may differ though from machine to machine, and
+   possibly even between compilers.  Your mileage may vary.
+ */
+
+
+/* If BMAX needs to be larger than 16, then h and x[] should be uLong. */
+#define BMAX 15         /* maximum bit length of any code */
+
+local int huft_build(b, n, s, d, e, t, m, hp, hn, v)
+uIntf *b;               /* code lengths in bits (all assumed <= BMAX) */
+uInt n;                 /* number of codes (assumed <= 288) */
+uInt s;                 /* number of simple-valued codes (0..s-1) */
+const uIntf *d;         /* list of base values for non-simple codes */
+const uIntf *e;         /* list of extra bits for non-simple codes */
+inflate_huft * FAR *t;  /* result: starting table */
+uIntf *m;               /* maximum lookup bits, returns actual */
+inflate_huft *hp;       /* space for trees */
+uInt *hn;               /* hufts used in space */
+uIntf *v;               /* working area: values in order of bit length */
+/* Given a list of code lengths and a maximum table size, make a set of
+   tables to decode that set of codes.  Return Z_OK on success, Z_BUF_ERROR
+   if the given code set is incomplete (the tables are still built in this
+   case), or Z_DATA_ERROR if the input is invalid. */
+{
+
+  uInt a;                       /* counter for codes of length k */
+  uInt c[BMAX+1];               /* bit length count table */
+  uInt f;                       /* i repeats in table every f entries */
+  int g;                        /* maximum code length */
+  int h;                        /* table level */
+  register uInt i;              /* counter, current code */
+  register uInt j;              /* counter */
+  register int k;               /* number of bits in current code */
+  int l;                        /* bits per table (returned in m) */
+  uInt mask;                    /* (1 << w) - 1, to avoid cc -O bug on HP */
+  register uIntf *p;            /* pointer into c[], b[], or v[] */
+  inflate_huft *q;              /* points to current table */
+  struct inflate_huft_s r;      /* table entry for structure assignment */
+  inflate_huft *u[BMAX];        /* table stack */
+  register int w;               /* bits before this table == (l * h) */
+  uInt x[BMAX+1];               /* bit offsets, then code stack */
+  uIntf *xp;                    /* pointer into x */
+  int y;                        /* number of dummy codes added */
+  uInt z;                       /* number of entries in current table */
+
+
+  /* Generate counts for each bit length */
+  p = c;
+#define C0 *p++ = 0;
+#define C2 C0 C0 C0 C0
+#define C4 C2 C2 C2 C2
+  C4                            /* clear c[]--assume BMAX+1 is 16 */
+  p = b;  i = n;
+  do {
+    c[*p++]++;                  /* assume all entries <= BMAX */
+  } while (--i);
+  if (c[0] == n)                /* null input--all zero length codes */
+  {
+    *t = (inflate_huft *)Z_NULL;
+    *m = 0;
+    return Z_OK;
+  }
+
+
+  /* Find minimum and maximum length, bound *m by those */
+  l = *m;
+  for (j = 1; j <= BMAX; j++)
+    if (c[j])
+      break;
+  k = j;                        /* minimum code length */
+  if ((uInt)l < j)
+    l = j;
+  for (i = BMAX; i; i--)
+    if (c[i])
+      break;
+  g = i;                        /* maximum code length */
+  if ((uInt)l > i)
+    l = i;
+  *m = l;
+
+
+  /* Adjust last length count to fill out codes, if needed */
+  for (y = 1 << j; j < i; j++, y <<= 1)
+    if ((y -= c[j]) < 0)
+      return Z_DATA_ERROR;
+  if ((y -= c[i]) < 0)
+    return Z_DATA_ERROR;
+  c[i] += y;
+
+
+  /* Generate starting offsets into the value table for each length */
+  x[1] = j = 0;
+  p = c + 1;  xp = x + 2;
+  while (--i) {                 /* note that i == g from above */
+    *xp++ = (j += *p++);
+  }
+
+
+  /* Make a table of values in order of bit lengths */
+  p = b;  i = 0;
+  do {
+    if ((j = *p++) != 0)
+      v[x[j]++] = i;
+  } while (++i < n);
+  n = x[g];                     /* set n to length of v */
+
+
+  /* Generate the Huffman codes and for each, make the table entries */
+  x[0] = i = 0;                 /* first Huffman code is zero */
+  p = v;                        /* grab values in bit order */
+  h = -1;                       /* no tables yet--level -1 */
+  w = -l;                       /* bits decoded == (l * h) */
+  u[0] = (inflate_huft *)Z_NULL;        /* just to keep compilers happy */
+  q = (inflate_huft *)Z_NULL;   /* ditto */
+  z = 0;                        /* ditto */
+
+  /* go through the bit lengths (k already is bits in shortest code) */
+  for (; k <= g; k++)
+  {
+    a = c[k];
+    while (a--)
+    {
+      /* here i is the Huffman code of length k bits for value *p */
+      /* make tables up to required level */
+      while (k > w + l)
+      {
+        h++;
+        w += l;                 /* previous table always l bits */
+
+        /* compute minimum size table less than or equal to l bits */
+        z = g - w;
+        z = z > (uInt)l ? l : z;        /* table size upper limit */
+        if ((f = 1 << (j = k - w)) > a + 1)     /* try a k-w bit table */
+        {                       /* too few codes for k-w bit table */
+          f -= a + 1;           /* deduct codes from patterns left */
+          xp = c + k;
+          if (j < z)
+            while (++j < z)     /* try smaller tables up to z bits */
+            {
+              if ((f <<= 1) <= *++xp)
+                break;          /* enough codes to use up j bits */
+              f -= *xp;         /* else deduct codes from patterns */
+            }
+        }
+        z = 1 << j;             /* table entries for j-bit table */
+
+        /* allocate new table */
+        if (*hn + z > MANY)     /* (note: doesn't matter for fixed) */
+          return Z_DATA_ERROR;  /* overflow of MANY */
+        u[h] = q = hp + *hn;
+        *hn += z;
+
+        /* connect to last table, if there is one */
+        if (h)
+        {
+          x[h] = i;             /* save pattern for backing up */
+          r.bits = (Byte)l;     /* bits to dump before this table */
+          r.exop = (Byte)j;     /* bits in this table */
+          j = i >> (w - l);
+          r.base = (uInt)(q - u[h-1] - j);   /* offset to this table */
+          u[h-1][j] = r;        /* connect to last table */
+        }
+        else
+          *t = q;               /* first table is returned result */
+      }
+
+      /* set up table entry in r */
+      r.bits = (Byte)(k - w);
+      if (p >= v + n)
+        r.exop = 128 + 64;      /* out of values--invalid code */
+      else if (*p < s)
+      {
+        r.exop = (Byte)(*p < 256 ? 0 : 32 + 64);     /* 256 is end-of-block */
+        r.base = *p++;          /* simple code is just the value */
+      }
+      else
+      {
+        r.exop = (Byte)(e[*p - s] + 16 + 64);/* non-simple--look up in lists */
+        r.base = d[*p++ - s];
+      }
+
+      /* fill code-like entries with r */
+      f = 1 << (k - w);
+      for (j = i >> w; j < z; j += f)
+        q[j] = r;
+
+      /* backwards increment the k-bit code i */
+      for (j = 1 << (k - 1); i & j; j >>= 1)
+        i ^= j;
+      i ^= j;
+
+      /* backup over finished tables */
+      mask = (1 << w) - 1;      /* needed on HP, cc -O bug */
+      while ((i & mask) != x[h])
+      {
+        h--;                    /* don't need to update q */
+        w -= l;
+        mask = (1 << w) - 1;
+      }
+    }
+  }
+
+
+  /* Return Z_BUF_ERROR if we were given an incomplete table */
+  return y != 0 && g != 1 ? Z_BUF_ERROR : Z_OK;
+}
+
+
+int inflate_trees_bits(c, bb, tb, hp, z)
+uIntf *c;               /* 19 code lengths */
+uIntf *bb;              /* bits tree desired/actual depth */
+inflate_huft * FAR *tb; /* bits tree result */
+inflate_huft *hp;       /* space for trees */
+z_streamp z;            /* for messages */
+{
+  int r;
+  uInt hn = 0;          /* hufts used in space */
+  uIntf *v;             /* work area for huft_build */
+
+  if ((v = (uIntf*)ZALLOC(z, 19, sizeof(uInt))) == Z_NULL)
+    return Z_MEM_ERROR;
+  r = huft_build(c, 19, 19, (uIntf*)Z_NULL, (uIntf*)Z_NULL,
+                 tb, bb, hp, &hn, v);
+  if (r == Z_DATA_ERROR)
+    z->msg = (char*)"oversubscribed dynamic bit lengths tree";
+  else if (r == Z_BUF_ERROR || *bb == 0)
+  {
+    z->msg = (char*)"incomplete dynamic bit lengths tree";
+    r = Z_DATA_ERROR;
+  }
+  ZFREE(z, v);
+  return r;
+}
+
+
+int inflate_trees_dynamic(nl, nd, c, bl, bd, tl, td, hp, z)
+uInt nl;                /* number of literal/length codes */
+uInt nd;                /* number of distance codes */
+uIntf *c;               /* that many (total) code lengths */
+uIntf *bl;              /* literal desired/actual bit depth */
+uIntf *bd;              /* distance desired/actual bit depth */
+inflate_huft * FAR *tl; /* literal/length tree result */
+inflate_huft * FAR *td; /* distance tree result */
+inflate_huft *hp;       /* space for trees */
+z_streamp z;            /* for messages */
+{
+  int r;
+  uInt hn = 0;          /* hufts used in space */
+  uIntf *v;             /* work area for huft_build */
+
+  /* allocate work area */
+  if ((v = (uIntf*)ZALLOC(z, 288, sizeof(uInt))) == Z_NULL)
+    return Z_MEM_ERROR;
+
+  /* build literal/length tree */
+  r = huft_build(c, nl, 257, cplens, cplext, tl, bl, hp, &hn, v);
+  if (r != Z_OK || *bl == 0)
+  {
+    if (r == Z_DATA_ERROR)
+      z->msg = (char*)"oversubscribed literal/length tree";
+    else if (r != Z_MEM_ERROR)
+    {
+      z->msg = (char*)"incomplete literal/length tree";
+      r = Z_DATA_ERROR;
+    }
+    ZFREE(z, v);
+    return r;
+  }
+
+  /* build distance tree */
+  r = huft_build(c + nl, nd, 0, cpdist, cpdext, td, bd, hp, &hn, v);
+  if (r != Z_OK || (*bd == 0 && nl > 257))
+  {
+    if (r == Z_DATA_ERROR)
+      z->msg = (char*)"oversubscribed distance tree";
+    else if (r == Z_BUF_ERROR) {
+#ifdef PKZIP_BUG_WORKAROUND
+      r = Z_OK;
+    }
+#else
+      z->msg = (char*)"incomplete distance tree";
+      r = Z_DATA_ERROR;
+    }
+    else if (r != Z_MEM_ERROR)
+    {
+      z->msg = (char*)"empty distance tree with lengths";
+      r = Z_DATA_ERROR;
+    }
+    ZFREE(z, v);
+    return r;
+#endif
+  }
+
+  /* done */
+  ZFREE(z, v);
+  return Z_OK;
+}
+
+
+/* build fixed tables only once--keep them here */
+#ifdef BUILDFIXED
+local int fixed_built = 0;
+#define FIXEDH 544      /* number of hufts used by fixed tables */
+local inflate_huft fixed_mem[FIXEDH];
+local uInt fixed_bl;
+local uInt fixed_bd;
+local inflate_huft *fixed_tl;
+local inflate_huft *fixed_td;
+#else
+#include "inffixed.h"
+#endif
+
+
+int inflate_trees_fixed(bl, bd, tl, td, z)
+uIntf *bl;               /* literal desired/actual bit depth */
+uIntf *bd;               /* distance desired/actual bit depth */
+inflate_huft * FAR *tl;  /* literal/length tree result */
+inflate_huft * FAR *td;  /* distance tree result */
+z_streamp z;             /* for memory allocation */
+{
+#ifdef BUILDFIXED
+  /* build fixed tables if not already */
+  if (!fixed_built)
+  {
+    int k;              /* temporary variable */
+    uInt f = 0;         /* number of hufts used in fixed_mem */
+    uIntf *c;           /* length list for huft_build */
+    uIntf *v;           /* work area for huft_build */
+
+    /* allocate memory */
+    if ((c = (uIntf*)ZALLOC(z, 288, sizeof(uInt))) == Z_NULL)
+      return Z_MEM_ERROR;
+    if ((v = (uIntf*)ZALLOC(z, 288, sizeof(uInt))) == Z_NULL)
+    {
+      ZFREE(z, c);
+      return Z_MEM_ERROR;
+    }
+
+    /* literal table */
+    for (k = 0; k < 144; k++)
+      c[k] = 8;
+    for (; k < 256; k++)
+      c[k] = 9;
+    for (; k < 280; k++)
+      c[k] = 7;
+    for (; k < 288; k++)
+      c[k] = 8;
+    fixed_bl = 9;
+    huft_build(c, 288, 257, cplens, cplext, &fixed_tl, &fixed_bl,
+               fixed_mem, &f, v);
+
+    /* distance table */
+    for (k = 0; k < 30; k++)
+      c[k] = 5;
+    fixed_bd = 5;
+    huft_build(c, 30, 0, cpdist, cpdext, &fixed_td, &fixed_bd,
+               fixed_mem, &f, v);
+
+    /* done */
+    ZFREE(z, v);
+    ZFREE(z, c);
+    fixed_built = 1;
+  }
+#endif
+  *bl = fixed_bl;
+  *bd = fixed_bd;
+  *tl = fixed_tl;
+  *td = fixed_td;
+  return Z_OK;
+}
diff --git a/src/libz/src/inftrees.h b/src/libz/src/inftrees.h
new file mode 100644
index 0000000..04b73b7
--- /dev/null
+++ b/src/libz/src/inftrees.h
@@ -0,0 +1,58 @@
+/* inftrees.h -- header to use inftrees.c
+ * Copyright (C) 1995-2002 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h 
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+   part of the implementation of the compression library and is
+   subject to change. Applications should only use zlib.h.
+ */
+
+/* Huffman code lookup table entry--this entry is four bytes for machines
+   that have 16-bit pointers (e.g. PC's in the small or medium model). */
+
+typedef struct inflate_huft_s FAR inflate_huft;
+
+struct inflate_huft_s {
+  union {
+    struct {
+      Byte Exop;        /* number of extra bits or operation */
+      Byte Bits;        /* number of bits in this code or subcode */
+    } what;
+    uInt pad;           /* pad structure to a power of 2 (4 bytes for */
+  } word;               /*  16-bit, 8 bytes for 32-bit int's) */
+  uInt base;            /* literal, length base, distance base,
+                           or table offset */
+};
+
+/* Maximum size of dynamic tree.  The maximum found in a long but non-
+   exhaustive search was 1004 huft structures (850 for length/literals
+   and 154 for distances, the latter actually the result of an
+   exhaustive search).  The actual maximum is not known, but the
+   value below is more than safe. */
+#define MANY 1440
+
+extern int inflate_trees_bits OF((
+    uIntf *,                    /* 19 code lengths */
+    uIntf *,                    /* bits tree desired/actual depth */
+    inflate_huft * FAR *,       /* bits tree result */
+    inflate_huft *,             /* space for trees */
+    z_streamp));                /* for messages */
+
+extern int inflate_trees_dynamic OF((
+    uInt,                       /* number of literal/length codes */
+    uInt,                       /* number of distance codes */
+    uIntf *,                    /* that many (total) code lengths */
+    uIntf *,                    /* literal desired/actual bit depth */
+    uIntf *,                    /* distance desired/actual bit depth */
+    inflate_huft * FAR *,       /* literal/length tree result */
+    inflate_huft * FAR *,       /* distance tree result */
+    inflate_huft *,             /* space for trees */
+    z_streamp));                /* for messages */
+
+extern int inflate_trees_fixed OF((
+    uIntf *,                    /* literal desired/actual bit depth */
+    uIntf *,                    /* distance desired/actual bit depth */
+    inflate_huft * FAR *,       /* literal/length tree result */
+    inflate_huft * FAR *,       /* distance tree result */
+    z_streamp));                /* for memory allocation */
diff --git a/src/libz/src/infutil.c b/src/libz/src/infutil.c
new file mode 100644
index 0000000..9a07622
--- /dev/null
+++ b/src/libz/src/infutil.c
@@ -0,0 +1,87 @@
+/* inflate_util.c -- data and routines common to blocks and codes
+ * Copyright (C) 1995-2002 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h 
+ */
+
+#include "zutil.h"
+#include "infblock.h"
+#include "inftrees.h"
+#include "infcodes.h"
+#include "infutil.h"
+
+struct inflate_codes_state {int dummy;}; /* for buggy compilers */
+
+/* And'ing with mask[n] masks the lower n bits */
+uInt inflate_mask[17] = {
+    0x0000,
+    0x0001, 0x0003, 0x0007, 0x000f, 0x001f, 0x003f, 0x007f, 0x00ff,
+    0x01ff, 0x03ff, 0x07ff, 0x0fff, 0x1fff, 0x3fff, 0x7fff, 0xffff
+};
+
+
+/* copy as much as possible from the sliding window to the output area */
+int inflate_flush(s, z, r)
+inflate_blocks_statef *s;
+z_streamp z;
+int r;
+{
+  uInt n;
+  Bytef *p;
+  Bytef *q;
+
+  /* local copies of source and destination pointers */
+  p = z->next_out;
+  q = s->read;
+
+  /* compute number of bytes to copy as far as end of window */
+  n = (uInt)((q <= s->write ? s->write : s->end) - q);
+  if (n > z->avail_out) n = z->avail_out;
+  if (n && r == Z_BUF_ERROR) r = Z_OK;
+
+  /* update counters */
+  z->avail_out -= n;
+  z->total_out += n;
+
+  /* update check information */
+  if (s->checkfn != Z_NULL)
+    z->adler = s->check = (*s->checkfn)(s->check, q, n);
+
+  /* copy as far as end of window */
+  zmemcpy(p, q, n);
+  p += n;
+  q += n;
+
+  /* see if more to copy at beginning of window */
+  if (q == s->end)
+  {
+    /* wrap pointers */
+    q = s->window;
+    if (s->write == s->end)
+      s->write = s->window;
+
+    /* compute bytes to copy */
+    n = (uInt)(s->write - q);
+    if (n > z->avail_out) n = z->avail_out;
+    if (n && r == Z_BUF_ERROR) r = Z_OK;
+
+    /* update counters */
+    z->avail_out -= n;
+    z->total_out += n;
+
+    /* update check information */
+    if (s->checkfn != Z_NULL)
+      z->adler = s->check = (*s->checkfn)(s->check, q, n);
+
+    /* copy */
+    zmemcpy(p, q, n);
+    p += n;
+    q += n;
+  }
+
+  /* update pointers */
+  z->next_out = p;
+  s->read = q;
+
+  /* done */
+  return r;
+}
diff --git a/src/libz/src/infutil.h b/src/libz/src/infutil.h
new file mode 100644
index 0000000..4401df8
--- /dev/null
+++ b/src/libz/src/infutil.h
@@ -0,0 +1,98 @@
+/* infutil.h -- types and macros common to blocks and codes
+ * Copyright (C) 1995-2002 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h 
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+   part of the implementation of the compression library and is
+   subject to change. Applications should only use zlib.h.
+ */
+
+#ifndef _INFUTIL_H
+#define _INFUTIL_H
+
+typedef enum {
+      TYPE,     /* get type bits (3, including end bit) */
+      LENS,     /* get lengths for stored */
+      STORED,   /* processing stored block */
+      TABLE,    /* get table lengths */
+      BTREE,    /* get bit lengths tree for a dynamic block */
+      DTREE,    /* get length, distance trees for a dynamic block */
+      CODES,    /* processing fixed or dynamic block */
+      DRY,      /* output remaining window bytes */
+      DONE,     /* finished last block, done */
+      BAD}      /* got a data error--stuck here */
+inflate_block_mode;
+
+/* inflate blocks semi-private state */
+struct inflate_blocks_state {
+
+  /* mode */
+  inflate_block_mode  mode;     /* current inflate_block mode */
+
+  /* mode dependent information */
+  union {
+    uInt left;          /* if STORED, bytes left to copy */
+    struct {
+      uInt table;               /* table lengths (14 bits) */
+      uInt index;               /* index into blens (or border) */
+      uIntf *blens;             /* bit lengths of codes */
+      uInt bb;                  /* bit length tree depth */
+      inflate_huft *tb;         /* bit length decoding tree */
+    } trees;            /* if DTREE, decoding info for trees */
+    struct {
+      inflate_codes_statef 
+         *codes;
+    } decode;           /* if CODES, current state */
+  } sub;                /* submode */
+  uInt last;            /* true if this block is the last block */
+
+  /* mode independent information */
+  uInt bitk;            /* bits in bit buffer */
+  uLong bitb;           /* bit buffer */
+  inflate_huft *hufts;  /* single malloc for tree space */
+  Bytef *window;        /* sliding window */
+  Bytef *end;           /* one byte after sliding window */
+  Bytef *read;          /* window read pointer */
+  Bytef *write;         /* window write pointer */
+  check_func checkfn;   /* check function */
+  uLong check;          /* check on output */
+
+};
+
+
+/* defines for inflate input/output */
+/*   update pointers and return */
+#define UPDBITS {s->bitb=b;s->bitk=k;}
+#define UPDIN {z->avail_in=n;z->total_in+=p-z->next_in;z->next_in=p;}
+#define UPDOUT {s->write=q;}
+#define UPDATE {UPDBITS UPDIN UPDOUT}
+#define LEAVE {UPDATE return inflate_flush(s,z,r);}
+/*   get bytes and bits */
+#define LOADIN {p=z->next_in;n=z->avail_in;b=s->bitb;k=s->bitk;}
+#define NEEDBYTE {if(n)r=Z_OK;else LEAVE}
+#define NEXTBYTE (n--,*p++)
+#define NEEDBITS(j) {while(k<(j)){NEEDBYTE;b|=((uLong)NEXTBYTE)<<k;k+=8;}}
+#define DUMPBITS(j) {b>>=(j);k-=(j);}
+/*   output bytes */
+#define WAVAIL (uInt)(q<s->read?s->read-q-1:s->end-q)
+#define LOADOUT {q=s->write;m=(uInt)WAVAIL;}
+#define WRAP {if(q==s->end&&s->read!=s->window){q=s->window;m=(uInt)WAVAIL;}}
+#define FLUSH {UPDOUT r=inflate_flush(s,z,r); LOADOUT}
+#define NEEDOUT {if(m==0){WRAP if(m==0){FLUSH WRAP if(m==0) LEAVE}}r=Z_OK;}
+#define OUTBYTE(a) {*q++=(Byte)(a);m--;}
+/*   load local pointers */
+#define LOAD {LOADIN LOADOUT}
+
+/* masks for lower bits (size given to avoid silly warnings with Visual C++) */
+extern uInt inflate_mask[17];
+
+/* copy as much as possible from the sliding window to the output area */
+extern int inflate_flush OF((
+    inflate_blocks_statef *,
+    z_streamp ,
+    int));
+
+struct internal_state      {int dummy;}; /* for buggy compilers */
+
+#endif
diff --git a/src/libz/src/libz.c b/src/libz/src/libz.c
new file mode 100644
index 0000000..a09db9a
--- /dev/null
+++ b/src/libz/src/libz.c
@@ -0,0 +1,19 @@
+/*----------------------------------------------------------------------------*/
+/* $Workfile:   libz.c  $                                                     */
+/*----------------------------------------------------------------------------*/
+/* $Author: agibert $                                                      */
+/* $Date: 2008/11/12 02:25:24 $                                           */
+/* $Revision: 1.1 $                                                       */
+/* $Label:  $                                                         */
+/*----------------------------------------------------------------------------*/
+
+
+
+char IMRG_Z_WHAT_IDENT[] = "@(#) VERSIONIMR: $Label:  $   $Date: 2008/11/12 02:25:24 $   $Workfile:   libz.c  $";
+
+
+
+void libz_dummy(void)
+{
+    int i=0;
+}
diff --git a/src/libz/src/maketree.c b/src/libz/src/maketree.c
new file mode 100644
index 0000000..a16d4b1
--- /dev/null
+++ b/src/libz/src/maketree.c
@@ -0,0 +1,85 @@
+/* maketree.c -- make inffixed.h table for decoding fixed codes
+ * Copyright (C) 1995-2002 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h 
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+   part of the implementation of the compression library and is
+   subject to change. Applications should only use zlib.h.
+ */
+
+/* This program is included in the distribution for completeness.
+   You do not need to compile or run this program since inffixed.h
+   is already included in the distribution.  To use this program
+   you need to compile zlib with BUILDFIXED defined and then compile
+   and link this program with the zlib library.  Then the output of
+   this program can be piped to inffixed.h. */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include "zutil.h"
+#include "inftrees.h"
+
+/* simplify the use of the inflate_huft type with some defines */
+#define exop word.what.Exop
+#define bits word.what.Bits
+
+/* generate initialization table for an inflate_huft structure array */
+void maketree(uInt b, inflate_huft *t)
+{
+  int i, e;
+
+  i = 0;
+  while (1)
+  {
+    e = t[i].exop;
+    if (e && (e & (16+64)) == 0)        /* table pointer */
+    {
+      fprintf(stderr, "maketree: cannot initialize sub-tables!\n");
+      exit(1);
+    }
+    if (i % 4 == 0)
+      printf("\n   ");
+    printf(" {{{%u,%u}},%u}", t[i].exop, t[i].bits, t[i].base);
+    if (++i == (1<<b))
+      break;
+    putchar(',');
+  }
+  puts("");
+}
+
+/* create the fixed tables in C initialization syntax */
+void main(void)
+{
+  int r;
+  uInt bl, bd;
+  inflate_huft *tl, *td;
+  z_stream z;
+
+  z.zalloc = zcalloc;
+  z.opaque = (voidpf)0;
+  z.zfree = zcfree;
+  r = inflate_trees_fixed(&bl, &bd, &tl, &td, &z);
+  if (r)
+  {
+    fprintf(stderr, "inflate_trees_fixed error %d\n", r);
+    return;
+  }
+  puts("/* inffixed.h -- table for decoding fixed codes");
+  puts(" * Generated automatically by the maketree.c program");
+  puts(" */");
+  puts("");
+  puts("/* WARNING: this file should *not* be used by applications. It is");
+  puts("   part of the implementation of the compression library and is");
+  puts("   subject to change. Applications should only use zlib.h.");
+  puts(" */");
+  puts("");
+  printf("local uInt fixed_bl = %d;\n", bl);
+  printf("local uInt fixed_bd = %d;\n", bd);
+  printf("local inflate_huft fixed_tl[] = {");
+  maketree(bl, tl);
+  puts("  };");
+  printf("local inflate_huft fixed_td[] = {");
+  maketree(bd, td);
+  puts("  };");
+}
diff --git a/src/libz/src/minigzip.c b/src/libz/src/minigzip.c
new file mode 100644
index 0000000..5c8b066
--- /dev/null
+++ b/src/libz/src/minigzip.c
@@ -0,0 +1,320 @@
+/* minigzip.c -- simulate gzip using the zlib compression library
+ * Copyright (C) 1995-2002 Jean-loup Gailly.
+ * For conditions of distribution and use, see copyright notice in zlib.h 
+ */
+
+/*
+ * minigzip is a minimal implementation of the gzip utility. This is
+ * only an example of using zlib and isn't meant to replace the
+ * full-featured gzip. No attempt is made to deal with file systems
+ * limiting names to 14 or 8+3 characters, etc... Error checking is
+ * very limited. So use minigzip only for testing; use gzip for the
+ * real thing. On MSDOS, use only on file names without extension
+ * or in pipe mode.
+ */
+
+/* @(#) $Id: minigzip.c,v 1.1 2008/11/12 02:25:24 agibert Exp $ */
+
+#include <stdio.h>
+#include "zlib.h"
+
+#ifdef STDC
+#  include <string.h>
+#  include <stdlib.h>
+#else
+   extern void exit  OF((int));
+#endif
+
+#ifdef USE_MMAP
+#  include <sys/types.h>
+#  include <sys/mman.h>
+#  include <sys/stat.h>
+#endif
+
+#if defined(MSDOS) || defined(OS2) || defined(WIN32)
+#  include <fcntl.h>
+#  include <io.h>
+#  define SET_BINARY_MODE(file) setmode(fileno(file), O_BINARY)
+#else
+#  define SET_BINARY_MODE(file)
+#endif
+
+#ifdef VMS
+#  define unlink delete
+#  define GZ_SUFFIX "-gz"
+#endif
+#ifdef RISCOS
+#  define unlink remove
+#  define GZ_SUFFIX "-gz"
+#  define fileno(file) file->__file
+#endif
+#if defined(__MWERKS__) && __dest_os != __be_os && __dest_os != __win32_os
+#  include <unix.h> /* for fileno */
+#endif
+
+#ifndef WIN32 /* unlink already in stdio.h for WIN32 */
+  extern int unlink OF((const char *));
+#endif
+
+#ifndef GZ_SUFFIX
+#  define GZ_SUFFIX ".gz"
+#endif
+#define SUFFIX_LEN (sizeof(GZ_SUFFIX)-1)
+
+#define BUFLEN      16384
+#define MAX_NAME_LEN 1024
+
+#ifdef MAXSEG_64K
+#  define local static
+   /* Needed for systems with limitation on stack size. */
+#else
+#  define local
+#endif
+
+char *prog;
+
+void error            OF((const char *msg));
+void gz_compress      OF((FILE   *in, gzFile out));
+#ifdef USE_MMAP
+int  gz_compress_mmap OF((FILE   *in, gzFile out));
+#endif
+void gz_uncompress    OF((gzFile in, FILE   *out));
+void file_compress    OF((char  *file, char *mode));
+void file_uncompress  OF((char  *file));
+int  main             OF((int argc, char *argv[]));
+
+/* ===========================================================================
+ * Display error message and exit
+ */
+void error(msg)
+    const char *msg;
+{
+    fprintf(stderr, "%s: %s\n", prog, msg);
+    exit(1);
+}
+
+/* ===========================================================================
+ * Compress input to output then close both files.
+ */
+
+void gz_compress(in, out)
+    FILE   *in;
+    gzFile out;
+{
+    local char buf[BUFLEN];
+    int len;
+    int err;
+
+#ifdef USE_MMAP
+    /* Try first compressing with mmap. If mmap fails (minigzip used in a
+     * pipe), use the normal fread loop.
+     */
+    if (gz_compress_mmap(in, out) == Z_OK) return;
+#endif
+    for (;;) {
+        len = fread(buf, 1, sizeof(buf), in);
+        if (ferror(in)) {
+            perror("fread");
+            exit(1);
+        }
+        if (len == 0) break;
+
+        if (gzwrite(out, buf, (unsigned)len) != len) error(gzerror(out, &err));
+    }
+    fclose(in);
+    if (gzclose(out) != Z_OK) error("failed gzclose");
+}
+
+#ifdef USE_MMAP /* MMAP version, Miguel Albrecht <malbrech@eso.org> */
+
+/* Try compressing the input file at once using mmap. Return Z_OK if
+ * if success, Z_ERRNO otherwise.
+ */
+int gz_compress_mmap(in, out)
+    FILE   *in;
+    gzFile out;
+{
+    int len;
+    int err;
+    int ifd = fileno(in);
+    caddr_t buf;    /* mmap'ed buffer for the entire input file */
+    off_t buf_len;  /* length of the input file */
+    struct stat sb;
+
+    /* Determine the size of the file, needed for mmap: */
+    if (fstat(ifd, &sb) < 0) return Z_ERRNO;
+    buf_len = sb.st_size;
+    if (buf_len <= 0) return Z_ERRNO;
+
+    /* Now do the actual mmap: */
+    buf = mmap((caddr_t) 0, buf_len, PROT_READ, MAP_SHARED, ifd, (off_t)0); 
+    if (buf == (caddr_t)(-1)) return Z_ERRNO;
+
+    /* Compress the whole file at once: */
+    len = gzwrite(out, (char *)buf, (unsigned)buf_len);
+
+    if (len != (int)buf_len) error(gzerror(out, &err));
+
+    munmap(buf, buf_len);
+    fclose(in);
+    if (gzclose(out) != Z_OK) error("failed gzclose");
+    return Z_OK;
+}
+#endif /* USE_MMAP */
+
+/* ===========================================================================
+ * Uncompress input to output then close both files.
+ */
+void gz_uncompress(in, out)
+    gzFile in;
+    FILE   *out;
+{
+    local char buf[BUFLEN];
+    int len;
+    int err;
+
+    for (;;) {
+        len = gzread(in, buf, sizeof(buf));
+        if (len < 0) error (gzerror(in, &err));
+        if (len == 0) break;
+
+        if ((int)fwrite(buf, 1, (unsigned)len, out) != len) {
+	    error("failed fwrite");
+	}
+    }
+    if (fclose(out)) error("failed fclose");
+
+    if (gzclose(in) != Z_OK) error("failed gzclose");
+}
+
+
+/* ===========================================================================
+ * Compress the given file: create a corresponding .gz file and remove the
+ * original.
+ */
+void file_compress(file, mode)
+    char  *file;
+    char  *mode;
+{
+    local char outfile[MAX_NAME_LEN];
+    FILE  *in;
+    gzFile out;
+
+    strcpy(outfile, file);
+    strcat(outfile, GZ_SUFFIX);
+
+    in = fopen(file, "rb");
+    if (in == NULL) {
+        perror(file);
+        exit(1);
+    }
+    out = gzopen(outfile, mode);
+    if (out == NULL) {
+        fprintf(stderr, "%s: can't gzopen %s\n", prog, outfile);
+        exit(1);
+    }
+    gz_compress(in, out);
+
+    unlink(file);
+}
+
+
+/* ===========================================================================
+ * Uncompress the given file and remove the original.
+ */
+void file_uncompress(file)
+    char  *file;
+{
+    local char buf[MAX_NAME_LEN];
+    char *infile, *outfile;
+    FILE  *out;
+    gzFile in;
+    int len = strlen(file);
+
+    strcpy(buf, file);
+
+    if (len > SUFFIX_LEN && strcmp(file+len-SUFFIX_LEN, GZ_SUFFIX) == 0) {
+        infile = file;
+        outfile = buf;
+        outfile[len-3] = '\0';
+    } else {
+        outfile = file;
+        infile = buf;
+        strcat(infile, GZ_SUFFIX);
+    }
+    in = gzopen(infile, "rb");
+    if (in == NULL) {
+        fprintf(stderr, "%s: can't gzopen %s\n", prog, infile);
+        exit(1);
+    }
+    out = fopen(outfile, "wb");
+    if (out == NULL) {
+        perror(file);
+        exit(1);
+    }
+
+    gz_uncompress(in, out);
+
+    unlink(infile);
+}
+
+
+/* ===========================================================================
+ * Usage:  minigzip [-d] [-f] [-h] [-1 to -9] [files...]
+ *   -d : decompress
+ *   -f : compress with Z_FILTERED
+ *   -h : compress with Z_HUFFMAN_ONLY
+ *   -1 to -9 : compression level
+ */
+
+int main(argc, argv)
+    int argc;
+    char *argv[];
+{
+    int uncompr = 0;
+    gzFile file;
+    char outmode[20];
+
+    strcpy(outmode, "wb6 ");
+
+    prog = argv[0];
+    argc--, argv++;
+
+    while (argc > 0) {
+      if (strcmp(*argv, "-d") == 0)
+	uncompr = 1;
+      else if (strcmp(*argv, "-f") == 0)
+	outmode[3] = 'f';
+      else if (strcmp(*argv, "-h") == 0)
+	outmode[3] = 'h';
+      else if ((*argv)[0] == '-' && (*argv)[1] >= '1' && (*argv)[1] <= '9' &&
+	       (*argv)[2] == 0)
+	outmode[2] = (*argv)[1];
+      else
+	break;
+      argc--, argv++;
+    }
+    if (argc == 0) {
+        SET_BINARY_MODE(stdin);
+        SET_BINARY_MODE(stdout);
+        if (uncompr) {
+            file = gzdopen(fileno(stdin), "rb");
+            if (file == NULL) error("can't gzdopen stdin");
+            gz_uncompress(file, stdout);
+        } else {
+            file = gzdopen(fileno(stdout), outmode);
+            if (file == NULL) error("can't gzdopen stdout");
+            gz_compress(stdin, file);
+        }
+    } else {
+        do {
+            if (uncompr) {
+                file_uncompress(*argv);
+            } else {
+                file_compress(*argv, outmode);
+            }
+        } while (argv++, --argc);
+    }
+    exit(0);
+    return 0; /* to avoid warning */
+}
diff --git a/src/libz/src/trees.c b/src/libz/src/trees.c
new file mode 100644
index 0000000..aec2f3f
--- /dev/null
+++ b/src/libz/src/trees.c
@@ -0,0 +1,1214 @@
+/* trees.c -- output deflated data using Huffman coding
+ * Copyright (C) 1995-2002 Jean-loup Gailly
+ * For conditions of distribution and use, see copyright notice in zlib.h 
+ */
+
+/*
+ *  ALGORITHM
+ *
+ *      The "deflation" process uses several Huffman trees. The more
+ *      common source values are represented by shorter bit sequences.
+ *
+ *      Each code tree is stored in a compressed form which is itself
+ * a Huffman encoding of the lengths of all the code strings (in
+ * ascending order by source values).  The actual code strings are
+ * reconstructed from the lengths in the inflate process, as described
+ * in the deflate specification.
+ *
+ *  REFERENCES
+ *
+ *      Deutsch, L.P.,"'Deflate' Compressed Data Format Specification".
+ *      Available in ftp.uu.net:/pub/archiving/zip/doc/deflate-1.1.doc
+ *
+ *      Storer, James A.
+ *          Data Compression:  Methods and Theory, pp. 49-50.
+ *          Computer Science Press, 1988.  ISBN 0-7167-8156-5.
+ *
+ *      Sedgewick, R.
+ *          Algorithms, p290.
+ *          Addison-Wesley, 1983. ISBN 0-201-06672-6.
+ */
+
+/* @(#) $Id: trees.c,v 1.1 2008/11/12 02:25:24 agibert Exp $ */
+
+/* #define GEN_TREES_H */
+
+#include "deflate.h"
+
+#ifdef DEBUG
+#  include <ctype.h>
+#endif
+
+/* ===========================================================================
+ * Constants
+ */
+
+#define MAX_BL_BITS 7
+/* Bit length codes must not exceed MAX_BL_BITS bits */
+
+#define END_BLOCK 256
+/* end of block literal code */
+
+#define REP_3_6      16
+/* repeat previous bit length 3-6 times (2 bits of repeat count) */
+
+#define REPZ_3_10    17
+/* repeat a zero length 3-10 times  (3 bits of repeat count) */
+
+#define REPZ_11_138  18
+/* repeat a zero length 11-138 times  (7 bits of repeat count) */
+
+local const int extra_lbits[LENGTH_CODES] /* extra bits for each length code */
+   = {0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0};
+
+local const int extra_dbits[D_CODES] /* extra bits for each distance code */
+   = {0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13};
+
+local const int extra_blbits[BL_CODES]/* extra bits for each bit length code */
+   = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7};
+
+local const uch bl_order[BL_CODES]
+   = {16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15};
+/* The lengths of the bit length codes are sent in order of decreasing
+ * probability, to avoid transmitting the lengths for unused bit length codes.
+ */
+
+#define Buf_size (8 * 2*sizeof(char))
+/* Number of bits used within bi_buf. (bi_buf might be implemented on
+ * more than 16 bits on some systems.)
+ */
+
+/* ===========================================================================
+ * Local data. These are initialized only once.
+ */
+
+#define DIST_CODE_LEN  512 /* see definition of array dist_code below */
+
+#if defined(GEN_TREES_H) || !defined(STDC)
+/* non ANSI compilers may not accept trees.h */
+
+local ct_data static_ltree[L_CODES+2];
+/* The static literal tree. Since the bit lengths are imposed, there is no
+ * need for the L_CODES extra codes used during heap construction. However
+ * The codes 286 and 287 are needed to build a canonical tree (see _tr_init
+ * below).
+ */
+
+local ct_data static_dtree[D_CODES];
+/* The static distance tree. (Actually a trivial tree since all codes use
+ * 5 bits.)
+ */
+
+uch _dist_code[DIST_CODE_LEN];
+/* Distance codes. The first 256 values correspond to the distances
+ * 3 .. 258, the last 256 values correspond to the top 8 bits of
+ * the 15 bit distances.
+ */
+
+uch _length_code[MAX_MATCH-MIN_MATCH+1];
+/* length code for each normalized match length (0 == MIN_MATCH) */
+
+local int base_length[LENGTH_CODES];
+/* First normalized length for each code (0 = MIN_MATCH) */
+
+local int base_dist[D_CODES];
+/* First normalized distance for each code (0 = distance of 1) */
+
+#else
+#  include "trees.h"
+#endif /* GEN_TREES_H */
+
+struct static_tree_desc_s {
+    const ct_data *static_tree;  /* static tree or NULL */
+    const intf *extra_bits;      /* extra bits for each code or NULL */
+    int     extra_base;          /* base index for extra_bits */
+    int     elems;               /* max number of elements in the tree */
+    int     max_length;          /* max bit length for the codes */
+};
+
+local static_tree_desc  static_l_desc =
+{static_ltree, extra_lbits, LITERALS+1, L_CODES, MAX_BITS};
+
+local static_tree_desc  static_d_desc =
+{static_dtree, extra_dbits, 0,          D_CODES, MAX_BITS};
+
+local static_tree_desc  static_bl_desc =
+{(const ct_data *)0, extra_blbits, 0,   BL_CODES, MAX_BL_BITS};
+
+/* ===========================================================================
+ * Local (static) routines in this file.
+ */
+
+local void tr_static_init OF((void));
+local void init_block     OF((deflate_state *s));
+local void pqdownheap     OF((deflate_state *s, ct_data *tree, int k));
+local void gen_bitlen     OF((deflate_state *s, tree_desc *desc));
+local void gen_codes      OF((ct_data *tree, int max_code, ushf *bl_count));
+local void build_tree     OF((deflate_state *s, tree_desc *desc));
+local void scan_tree      OF((deflate_state *s, ct_data *tree, int max_code));
+local void send_tree      OF((deflate_state *s, ct_data *tree, int max_code));
+local int  build_bl_tree  OF((deflate_state *s));
+local void send_all_trees OF((deflate_state *s, int lcodes, int dcodes,
+                              int blcodes));
+local void compress_block OF((deflate_state *s, ct_data *ltree,
+                              ct_data *dtree));
+local void set_data_type  OF((deflate_state *s));
+local unsigned bi_reverse OF((unsigned value, int length));
+local void bi_windup      OF((deflate_state *s));
+local void bi_flush       OF((deflate_state *s));
+local void copy_block     OF((deflate_state *s, charf *buf, unsigned len,
+                              int header));
+
+#ifdef GEN_TREES_H
+local void gen_trees_header OF((void));
+#endif
+
+#ifndef DEBUG
+#  define send_code(s, c, tree) send_bits(s, tree[c].Code, tree[c].Len)
+   /* Send a code of the given tree. c and tree must not have side effects */
+
+#else /* DEBUG */
+#  define send_code(s, c, tree) \
+     { if (z_verbose>2) fprintf(stderr,"\ncd %3d ",(c)); \
+       send_bits(s, tree[c].Code, tree[c].Len); }
+#endif
+
+/* ===========================================================================
+ * Output a short LSB first on the stream.
+ * IN assertion: there is enough room in pendingBuf.
+ */
+#define put_short(s, w) { \
+    put_byte(s, (uch)((w) & 0xff)); \
+    put_byte(s, (uch)((ush)(w) >> 8)); \
+}
+
+/* ===========================================================================
+ * Send a value on a given number of bits.
+ * IN assertion: length <= 16 and value fits in length bits.
+ */
+#ifdef DEBUG
+local void send_bits      OF((deflate_state *s, int value, int length));
+
+local void send_bits(s, value, length)
+    deflate_state *s;
+    int value;  /* value to send */
+    int length; /* number of bits */
+{
+    Tracevv((stderr," l %2d v %4x ", length, value));
+    Assert(length > 0 && length <= 15, "invalid length");
+    s->bits_sent += (ulg)length;
+
+    /* If not enough room in bi_buf, use (valid) bits from bi_buf and
+     * (16 - bi_valid) bits from value, leaving (width - (16-bi_valid))
+     * unused bits in value.
+     */
+    if (s->bi_valid > (int)Buf_size - length) {
+        s->bi_buf |= (value << s->bi_valid);
+        put_short(s, s->bi_buf);
+        s->bi_buf = (ush)value >> (Buf_size - s->bi_valid);
+        s->bi_valid += length - Buf_size;
+    } else {
+        s->bi_buf |= value << s->bi_valid;
+        s->bi_valid += length;
+    }
+}
+#else /* !DEBUG */
+
+#define send_bits(s, value, length) \
+{ int len = length;\
+  if (s->bi_valid > (int)Buf_size - len) {\
+    int val = value;\
+    s->bi_buf |= (val << s->bi_valid);\
+    put_short(s, s->bi_buf);\
+    s->bi_buf = (ush)val >> (Buf_size - s->bi_valid);\
+    s->bi_valid += len - Buf_size;\
+  } else {\
+    s->bi_buf |= (value) << s->bi_valid;\
+    s->bi_valid += len;\
+  }\
+}
+#endif /* DEBUG */
+
+
+#define MAX(a,b) (a >= b ? a : b)
+/* the arguments must not have side effects */
+
+/* ===========================================================================
+ * Initialize the various 'constant' tables.
+ */
+local void tr_static_init()
+{
+#if defined(GEN_TREES_H) || !defined(STDC)
+    static int static_init_done = 0;
+    int n;        /* iterates over tree elements */
+    int bits;     /* bit counter */
+    int length;   /* length value */
+    int code;     /* code value */
+    int dist;     /* distance index */
+    ush bl_count[MAX_BITS+1];
+    /* number of codes at each bit length for an optimal tree */
+
+    if (static_init_done) return;
+
+    /* For some embedded targets, global variables are not initialized: */
+    static_l_desc.static_tree = static_ltree;
+    static_l_desc.extra_bits = extra_lbits;
+    static_d_desc.static_tree = static_dtree;
+    static_d_desc.extra_bits = extra_dbits;
+    static_bl_desc.extra_bits = extra_blbits;
+
+    /* Initialize the mapping length (0..255) -> length code (0..28) */
+    length = 0;
+    for (code = 0; code < LENGTH_CODES-1; code++) {
+        base_length[code] = length;
+        for (n = 0; n < (1<<extra_lbits[code]); n++) {
+            _length_code[length++] = (uch)code;
+        }
+    }
+    Assert (length == 256, "tr_static_init: length != 256");
+    /* Note that the length 255 (match length 258) can be represented
+     * in two different ways: code 284 + 5 bits or code 285, so we
+     * overwrite length_code[255] to use the best encoding:
+     */
+    _length_code[length-1] = (uch)code;
+
+    /* Initialize the mapping dist (0..32K) -> dist code (0..29) */
+    dist = 0;
+    for (code = 0 ; code < 16; code++) {
+        base_dist[code] = dist;
+        for (n = 0; n < (1<<extra_dbits[code]); n++) {
+            _dist_code[dist++] = (uch)code;
+        }
+    }
+    Assert (dist == 256, "tr_static_init: dist != 256");
+    dist >>= 7; /* from now on, all distances are divided by 128 */
+    for ( ; code < D_CODES; code++) {
+        base_dist[code] = dist << 7;
+        for (n = 0; n < (1<<(extra_dbits[code]-7)); n++) {
+            _dist_code[256 + dist++] = (uch)code;
+        }
+    }
+    Assert (dist == 256, "tr_static_init: 256+dist != 512");
+
+    /* Construct the codes of the static literal tree */
+    for (bits = 0; bits <= MAX_BITS; bits++) bl_count[bits] = 0;
+    n = 0;
+    while (n <= 143) static_ltree[n++].Len = 8, bl_count[8]++;
+    while (n <= 255) static_ltree[n++].Len = 9, bl_count[9]++;
+    while (n <= 279) static_ltree[n++].Len = 7, bl_count[7]++;
+    while (n <= 287) static_ltree[n++].Len = 8, bl_count[8]++;
+    /* Codes 286 and 287 do not exist, but we must include them in the
+     * tree construction to get a canonical Huffman tree (longest code
+     * all ones)
+     */
+    gen_codes((ct_data *)static_ltree, L_CODES+1, bl_count);
+
+    /* The static distance tree is trivial: */
+    for (n = 0; n < D_CODES; n++) {
+        static_dtree[n].Len = 5;
+        static_dtree[n].Code = bi_reverse((unsigned)n, 5);
+    }
+    static_init_done = 1;
+
+#  ifdef GEN_TREES_H
+    gen_trees_header();
+#  endif
+#endif /* defined(GEN_TREES_H) || !defined(STDC) */
+}
+
+/* ===========================================================================
+ * Genererate the file trees.h describing the static trees.
+ */
+#ifdef GEN_TREES_H
+#  ifndef DEBUG
+#    include <stdio.h>
+#  endif
+
+#  define SEPARATOR(i, last, width) \
+      ((i) == (last)? "\n};\n\n" :    \
+       ((i) % (width) == (width)-1 ? ",\n" : ", "))
+
+void gen_trees_header()
+{
+    FILE *header = fopen("trees.h", "w");
+    int i;
+
+    Assert (header != NULL, "Can't open trees.h");
+    fprintf(header,
+	    "/* header created automatically with -DGEN_TREES_H */\n\n");
+
+    fprintf(header, "local const ct_data static_ltree[L_CODES+2] = {\n");
+    for (i = 0; i < L_CODES+2; i++) {
+	fprintf(header, "{{%3u},{%3u}}%s", static_ltree[i].Code,
+		static_ltree[i].Len, SEPARATOR(i, L_CODES+1, 5));
+    }
+
+    fprintf(header, "local const ct_data static_dtree[D_CODES] = {\n");
+    for (i = 0; i < D_CODES; i++) {
+	fprintf(header, "{{%2u},{%2u}}%s", static_dtree[i].Code,
+		static_dtree[i].Len, SEPARATOR(i, D_CODES-1, 5));
+    }
+
+    fprintf(header, "const uch _dist_code[DIST_CODE_LEN] = {\n");
+    for (i = 0; i < DIST_CODE_LEN; i++) {
+	fprintf(header, "%2u%s", _dist_code[i],
+		SEPARATOR(i, DIST_CODE_LEN-1, 20));
+    }
+
+    fprintf(header, "const uch _length_code[MAX_MATCH-MIN_MATCH+1]= {\n");
+    for (i = 0; i < MAX_MATCH-MIN_MATCH+1; i++) {
+	fprintf(header, "%2u%s", _length_code[i],
+		SEPARATOR(i, MAX_MATCH-MIN_MATCH, 20));
+    }
+
+    fprintf(header, "local const int base_length[LENGTH_CODES] = {\n");
+    for (i = 0; i < LENGTH_CODES; i++) {
+	fprintf(header, "%1u%s", base_length[i],
+		SEPARATOR(i, LENGTH_CODES-1, 20));
+    }
+
+    fprintf(header, "local const int base_dist[D_CODES] = {\n");
+    for (i = 0; i < D_CODES; i++) {
+	fprintf(header, "%5u%s", base_dist[i],
+		SEPARATOR(i, D_CODES-1, 10));
+    }
+
+    fclose(header);
+}
+#endif /* GEN_TREES_H */
+
+/* ===========================================================================
+ * Initialize the tree data structures for a new zlib stream.
+ */
+void _tr_init(s)
+    deflate_state *s;
+{
+    tr_static_init();
+
+    s->l_desc.dyn_tree = s->dyn_ltree;
+    s->l_desc.stat_desc = &static_l_desc;
+
+    s->d_desc.dyn_tree = s->dyn_dtree;
+    s->d_desc.stat_desc = &static_d_desc;
+
+    s->bl_desc.dyn_tree = s->bl_tree;
+    s->bl_desc.stat_desc = &static_bl_desc;
+
+    s->bi_buf = 0;
+    s->bi_valid = 0;
+    s->last_eob_len = 8; /* enough lookahead for inflate */
+#ifdef DEBUG
+    s->compressed_len = 0L;
+    s->bits_sent = 0L;
+#endif
+
+    /* Initialize the first block of the first file: */
+    init_block(s);
+}
+
+/* ===========================================================================
+ * Initialize a new block.
+ */
+local void init_block(s)
+    deflate_state *s;
+{
+    int n; /* iterates over tree elements */
+
+    /* Initialize the trees. */
+    for (n = 0; n < L_CODES;  n++) s->dyn_ltree[n].Freq = 0;
+    for (n = 0; n < D_CODES;  n++) s->dyn_dtree[n].Freq = 0;
+    for (n = 0; n < BL_CODES; n++) s->bl_tree[n].Freq = 0;
+
+    s->dyn_ltree[END_BLOCK].Freq = 1;
+    s->opt_len = s->static_len = 0L;
+    s->last_lit = s->matches = 0;
+}
+
+#define SMALLEST 1
+/* Index within the heap array of least frequent node in the Huffman tree */
+
+
+/* ===========================================================================
+ * Remove the smallest element from the heap and recreate the heap with
+ * one less element. Updates heap and heap_len.
+ */
+#define pqremove(s, tree, top) \
+{\
+    top = s->heap[SMALLEST]; \
+    s->heap[SMALLEST] = s->heap[s->heap_len--]; \
+    pqdownheap(s, tree, SMALLEST); \
+}
+
+/* ===========================================================================
+ * Compares to subtrees, using the tree depth as tie breaker when
+ * the subtrees have equal frequency. This minimizes the worst case length.
+ */
+#define smaller(tree, n, m, depth) \
+   (tree[n].Freq < tree[m].Freq || \
+   (tree[n].Freq == tree[m].Freq && depth[n] <= depth[m]))
+
+/* ===========================================================================
+ * Restore the heap property by moving down the tree starting at node k,
+ * exchanging a node with the smallest of its two sons if necessary, stopping
+ * when the heap property is re-established (each father smaller than its
+ * two sons).
+ */
+local void pqdownheap(s, tree, k)
+    deflate_state *s;
+    ct_data *tree;  /* the tree to restore */
+    int k;               /* node to move down */
+{
+    int v = s->heap[k];
+    int j = k << 1;  /* left son of k */
+    while (j <= s->heap_len) {
+        /* Set j to the smallest of the two sons: */
+        if (j < s->heap_len &&
+            smaller(tree, s->heap[j+1], s->heap[j], s->depth)) {
+            j++;
+        }
+        /* Exit if v is smaller than both sons */
+        if (smaller(tree, v, s->heap[j], s->depth)) break;
+
+        /* Exchange v with the smallest son */
+        s->heap[k] = s->heap[j];  k = j;
+
+        /* And continue down the tree, setting j to the left son of k */
+        j <<= 1;
+    }
+    s->heap[k] = v;
+}
+
+/* ===========================================================================
+ * Compute the optimal bit lengths for a tree and update the total bit length
+ * for the current block.
+ * IN assertion: the fields freq and dad are set, heap[heap_max] and
+ *    above are the tree nodes sorted by increasing frequency.
+ * OUT assertions: the field len is set to the optimal bit length, the
+ *     array bl_count contains the frequencies for each bit length.
+ *     The length opt_len is updated; static_len is also updated if stree is
+ *     not null.
+ */
+local void gen_bitlen(s, desc)
+    deflate_state *s;
+    tree_desc *desc;    /* the tree descriptor */
+{
+    ct_data *tree        = desc->dyn_tree;
+    int max_code         = desc->max_code;
+    const ct_data *stree = desc->stat_desc->static_tree;
+    const intf *extra    = desc->stat_desc->extra_bits;
+    int base             = desc->stat_desc->extra_base;
+    int max_length       = desc->stat_desc->max_length;
+    int h;              /* heap index */
+    int n, m;           /* iterate over the tree elements */
+    int bits;           /* bit length */
+    int xbits;          /* extra bits */
+    ush f;              /* frequency */
+    int overflow = 0;   /* number of elements with bit length too large */
+
+    for (bits = 0; bits <= MAX_BITS; bits++) s->bl_count[bits] = 0;
+
+    /* In a first pass, compute the optimal bit lengths (which may
+     * overflow in the case of the bit length tree).
+     */
+    tree[s->heap[s->heap_max]].Len = 0; /* root of the heap */
+
+    for (h = s->heap_max+1; h < HEAP_SIZE; h++) {
+        n = s->heap[h];
+        bits = tree[tree[n].Dad].Len + 1;
+        if (bits > max_length) bits = max_length, overflow++;
+        tree[n].Len = (ush)bits;
+        /* We overwrite tree[n].Dad which is no longer needed */
+
+        if (n > max_code) continue; /* not a leaf node */
+
+        s->bl_count[bits]++;
+        xbits = 0;
+        if (n >= base) xbits = extra[n-base];
+        f = tree[n].Freq;
+        s->opt_len += (ulg)f * (bits + xbits);
+        if (stree) s->static_len += (ulg)f * (stree[n].Len + xbits);
+    }
+    if (overflow == 0) return;
+
+    Trace((stderr,"\nbit length overflow\n"));
+    /* This happens for example on obj2 and pic of the Calgary corpus */
+
+    /* Find the first bit length which could increase: */
+    do {
+        bits = max_length-1;
+        while (s->bl_count[bits] == 0) bits--;
+        s->bl_count[bits]--;      /* move one leaf down the tree */
+        s->bl_count[bits+1] += 2; /* move one overflow item as its brother */
+        s->bl_count[max_length]--;
+        /* The brother of the overflow item also moves one step up,
+         * but this does not affect bl_count[max_length]
+         */
+        overflow -= 2;
+    } while (overflow > 0);
+
+    /* Now recompute all bit lengths, scanning in increasing frequency.
+     * h is still equal to HEAP_SIZE. (It is simpler to reconstruct all
+     * lengths instead of fixing only the wrong ones. This idea is taken
+     * from 'ar' written by Haruhiko Okumura.)
+     */
+    for (bits = max_length; bits != 0; bits--) {
+        n = s->bl_count[bits];
+        while (n != 0) {
+            m = s->heap[--h];
+            if (m > max_code) continue;
+            if (tree[m].Len != (unsigned) bits) {
+                Trace((stderr,"code %d bits %d->%d\n", m, tree[m].Len, bits));
+                s->opt_len += ((long)bits - (long)tree[m].Len)
+                              *(long)tree[m].Freq;
+                tree[m].Len = (ush)bits;
+            }
+            n--;
+        }
+    }
+}
+
+/* ===========================================================================
+ * Generate the codes for a given tree and bit counts (which need not be
+ * optimal).
+ * IN assertion: the array bl_count contains the bit length statistics for
+ * the given tree and the field len is set for all tree elements.
+ * OUT assertion: the field code is set for all tree elements of non
+ *     zero code length.
+ */
+local void gen_codes (tree, max_code, bl_count)
+    ct_data *tree;             /* the tree to decorate */
+    int max_code;              /* largest code with non zero frequency */
+    ushf *bl_count;            /* number of codes at each bit length */
+{
+    ush next_code[MAX_BITS+1]; /* next code value for each bit length */
+    ush code = 0;              /* running code value */
+    int bits;                  /* bit index */
+    int n;                     /* code index */
+
+    /* The distribution counts are first used to generate the code values
+     * without bit reversal.
+     */
+    for (bits = 1; bits <= MAX_BITS; bits++) {
+        next_code[bits] = code = (code + bl_count[bits-1]) << 1;
+    }
+    /* Check that the bit counts in bl_count are consistent. The last code
+     * must be all ones.
+     */
+    Assert (code + bl_count[MAX_BITS]-1 == (1<<MAX_BITS)-1,
+            "inconsistent bit counts");
+    Tracev((stderr,"\ngen_codes: max_code %d ", max_code));
+
+    for (n = 0;  n <= max_code; n++) {
+        int len = tree[n].Len;
+        if (len == 0) continue;
+        /* Now reverse the bits */
+        tree[n].Code = bi_reverse(next_code[len]++, len);
+
+        Tracecv(tree != static_ltree, (stderr,"\nn %3d %c l %2d c %4x (%x) ",
+             n, (isgraph(n) ? n : ' '), len, tree[n].Code, next_code[len]-1));
+    }
+}
+
+/* ===========================================================================
+ * Construct one Huffman tree and assigns the code bit strings and lengths.
+ * Update the total bit length for the current block.
+ * IN assertion: the field freq is set for all tree elements.
+ * OUT assertions: the fields len and code are set to the optimal bit length
+ *     and corresponding code. The length opt_len is updated; static_len is
+ *     also updated if stree is not null. The field max_code is set.
+ */
+local void build_tree(s, desc)
+    deflate_state *s;
+    tree_desc *desc; /* the tree descriptor */
+{
+    ct_data *tree         = desc->dyn_tree;
+    const ct_data *stree  = desc->stat_desc->static_tree;
+    int elems             = desc->stat_desc->elems;
+    int n, m;          /* iterate over heap elements */
+    int max_code = -1; /* largest code with non zero frequency */
+    int node;          /* new node being created */
+
+    /* Construct the initial heap, with least frequent element in
+     * heap[SMALLEST]. The sons of heap[n] are heap[2*n] and heap[2*n+1].
+     * heap[0] is not used.
+     */
+    s->heap_len = 0, s->heap_max = HEAP_SIZE;
+
+    for (n = 0; n < elems; n++) {
+        if (tree[n].Freq != 0) {
+            s->heap[++(s->heap_len)] = max_code = n;
+            s->depth[n] = 0;
+        } else {
+            tree[n].Len = 0;
+        }
+    }
+
+    /* The pkzip format requires that at least one distance code exists,
+     * and that at least one bit should be sent even if there is only one
+     * possible code. So to avoid special checks later on we force at least
+     * two codes of non zero frequency.
+     */
+    while (s->heap_len < 2) {
+        node = s->heap[++(s->heap_len)] = (max_code < 2 ? ++max_code : 0);
+        tree[node].Freq = 1;
+        s->depth[node] = 0;
+        s->opt_len--; if (stree) s->static_len -= stree[node].Len;
+        /* node is 0 or 1 so it does not have extra bits */
+    }
+    desc->max_code = max_code;
+
+    /* The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree,
+     * establish sub-heaps of increasing lengths:
+     */
+    for (n = s->heap_len/2; n >= 1; n--) pqdownheap(s, tree, n);
+
+    /* Construct the Huffman tree by repeatedly combining the least two
+     * frequent nodes.
+     */
+    node = elems;              /* next internal node of the tree */
+    do {
+        pqremove(s, tree, n);  /* n = node of least frequency */
+        m = s->heap[SMALLEST]; /* m = node of next least frequency */
+
+        s->heap[--(s->heap_max)] = n; /* keep the nodes sorted by frequency */
+        s->heap[--(s->heap_max)] = m;
+
+        /* Create a new node father of n and m */
+        tree[node].Freq = tree[n].Freq + tree[m].Freq;
+        s->depth[node] = (uch) (MAX(s->depth[n], s->depth[m]) + 1);
+        tree[n].Dad = tree[m].Dad = (ush)node;
+#ifdef DUMP_BL_TREE
+        if (tree == s->bl_tree) {
+            fprintf(stderr,"\nnode %d(%d), sons %d(%d) %d(%d)",
+                    node, tree[node].Freq, n, tree[n].Freq, m, tree[m].Freq);
+        }
+#endif
+        /* and insert the new node in the heap */
+        s->heap[SMALLEST] = node++;
+        pqdownheap(s, tree, SMALLEST);
+
+    } while (s->heap_len >= 2);
+
+    s->heap[--(s->heap_max)] = s->heap[SMALLEST];
+
+    /* At this point, the fields freq and dad are set. We can now
+     * generate the bit lengths.
+     */
+    gen_bitlen(s, (tree_desc *)desc);
+
+    /* The field len is now set, we can generate the bit codes */
+    gen_codes ((ct_data *)tree, max_code, s->bl_count);
+}
+
+/* ===========================================================================
+ * Scan a literal or distance tree to determine the frequencies of the codes
+ * in the bit length tree.
+ */
+local void scan_tree (s, tree, max_code)
+    deflate_state *s;
+    ct_data *tree;   /* the tree to be scanned */
+    int max_code;    /* and its largest code of non zero frequency */
+{
+    int n;                     /* iterates over all tree elements */
+    int prevlen = -1;          /* last emitted length */
+    int curlen;                /* length of current code */
+    int nextlen = tree[0].Len; /* length of next code */
+    int count = 0;             /* repeat count of the current code */
+    int max_count = 7;         /* max repeat count */
+    int min_count = 4;         /* min repeat count */
+
+    if (nextlen == 0) max_count = 138, min_count = 3;
+    tree[max_code+1].Len = (ush)0xffff; /* guard */
+
+    for (n = 0; n <= max_code; n++) {
+        curlen = nextlen; nextlen = tree[n+1].Len;
+        if (++count < max_count && curlen == nextlen) {
+            continue;
+        } else if (count < min_count) {
+            s->bl_tree[curlen].Freq += count;
+        } else if (curlen != 0) {
+            if (curlen != prevlen) s->bl_tree[curlen].Freq++;
+            s->bl_tree[REP_3_6].Freq++;
+        } else if (count <= 10) {
+            s->bl_tree[REPZ_3_10].Freq++;
+        } else {
+            s->bl_tree[REPZ_11_138].Freq++;
+        }
+        count = 0; prevlen = curlen;
+        if (nextlen == 0) {
+            max_count = 138, min_count = 3;
+        } else if (curlen == nextlen) {
+            max_count = 6, min_count = 3;
+        } else {
+            max_count = 7, min_count = 4;
+        }
+    }
+}
+
+/* ===========================================================================
+ * Send a literal or distance tree in compressed form, using the codes in
+ * bl_tree.
+ */
+local void send_tree (s, tree, max_code)
+    deflate_state *s;
+    ct_data *tree; /* the tree to be scanned */
+    int max_code;       /* and its largest code of non zero frequency */
+{
+    int n;                     /* iterates over all tree elements */
+    int prevlen = -1;          /* last emitted length */
+    int curlen;                /* length of current code */
+    int nextlen = tree[0].Len; /* length of next code */
+    int count = 0;             /* repeat count of the current code */
+    int max_count = 7;         /* max repeat count */
+    int min_count = 4;         /* min repeat count */
+
+    /* tree[max_code+1].Len = -1; */  /* guard already set */
+    if (nextlen == 0) max_count = 138, min_count = 3;
+
+    for (n = 0; n <= max_code; n++) {
+        curlen = nextlen; nextlen = tree[n+1].Len;
+        if (++count < max_count && curlen == nextlen) {
+            continue;
+        } else if (count < min_count) {
+            do { send_code(s, curlen, s->bl_tree); } while (--count != 0);
+
+        } else if (curlen != 0) {
+            if (curlen != prevlen) {
+                send_code(s, curlen, s->bl_tree); count--;
+            }
+            Assert(count >= 3 && count <= 6, " 3_6?");
+            send_code(s, REP_3_6, s->bl_tree); send_bits(s, count-3, 2);
+
+        } else if (count <= 10) {
+            send_code(s, REPZ_3_10, s->bl_tree); send_bits(s, count-3, 3);
+
+        } else {
+            send_code(s, REPZ_11_138, s->bl_tree); send_bits(s, count-11, 7);
+        }
+        count = 0; prevlen = curlen;
+        if (nextlen == 0) {
+            max_count = 138, min_count = 3;
+        } else if (curlen == nextlen) {
+            max_count = 6, min_count = 3;
+        } else {
+            max_count = 7, min_count = 4;
+        }
+    }
+}
+
+/* ===========================================================================
+ * Construct the Huffman tree for the bit lengths and return the index in
+ * bl_order of the last bit length code to send.
+ */
+local int build_bl_tree(s)
+    deflate_state *s;
+{
+    int max_blindex;  /* index of last bit length code of non zero freq */
+
+    /* Determine the bit length frequencies for literal and distance trees */
+    scan_tree(s, (ct_data *)s->dyn_ltree, s->l_desc.max_code);
+    scan_tree(s, (ct_data *)s->dyn_dtree, s->d_desc.max_code);
+
+    /* Build the bit length tree: */
+    build_tree(s, (tree_desc *)(&(s->bl_desc)));
+    /* opt_len now includes the length of the tree representations, except
+     * the lengths of the bit lengths codes and the 5+5+4 bits for the counts.
+     */
+
+    /* Determine the number of bit length codes to send. The pkzip format
+     * requires that at least 4 bit length codes be sent. (appnote.txt says
+     * 3 but the actual value used is 4.)
+     */
+    for (max_blindex = BL_CODES-1; max_blindex >= 3; max_blindex--) {
+        if (s->bl_tree[bl_order[max_blindex]].Len != 0) break;
+    }
+    /* Update opt_len to include the bit length tree and counts */
+    s->opt_len += 3*(max_blindex+1) + 5+5+4;
+    Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld",
+            s->opt_len, s->static_len));
+
+    return max_blindex;
+}
+
+/* ===========================================================================
+ * Send the header for a block using dynamic Huffman trees: the counts, the
+ * lengths of the bit length codes, the literal tree and the distance tree.
+ * IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4.
+ */
+local void send_all_trees(s, lcodes, dcodes, blcodes)
+    deflate_state *s;
+    int lcodes, dcodes, blcodes; /* number of codes for each tree */
+{
+    int rank;                    /* index in bl_order */
+
+    Assert (lcodes >= 257 && dcodes >= 1 && blcodes >= 4, "not enough codes");
+    Assert (lcodes <= L_CODES && dcodes <= D_CODES && blcodes <= BL_CODES,
+            "too many codes");
+    Tracev((stderr, "\nbl counts: "));
+    send_bits(s, lcodes-257, 5); /* not +255 as stated in appnote.txt */
+    send_bits(s, dcodes-1,   5);
+    send_bits(s, blcodes-4,  4); /* not -3 as stated in appnote.txt */
+    for (rank = 0; rank < blcodes; rank++) {
+        Tracev((stderr, "\nbl code %2d ", bl_order[rank]));
+        send_bits(s, s->bl_tree[bl_order[rank]].Len, 3);
+    }
+    Tracev((stderr, "\nbl tree: sent %ld", s->bits_sent));
+
+    send_tree(s, (ct_data *)s->dyn_ltree, lcodes-1); /* literal tree */
+    Tracev((stderr, "\nlit tree: sent %ld", s->bits_sent));
+
+    send_tree(s, (ct_data *)s->dyn_dtree, dcodes-1); /* distance tree */
+    Tracev((stderr, "\ndist tree: sent %ld", s->bits_sent));
+}
+
+/* ===========================================================================
+ * Send a stored block
+ */
+void _tr_stored_block(s, buf, stored_len, eof)
+    deflate_state *s;
+    charf *buf;       /* input block */
+    ulg stored_len;   /* length of input block */
+    int eof;          /* true if this is the last block for a file */
+{
+    send_bits(s, (STORED_BLOCK<<1)+eof, 3);  /* send block type */
+#ifdef DEBUG
+    s->compressed_len = (s->compressed_len + 3 + 7) & (ulg)~7L;
+    s->compressed_len += (stored_len + 4) << 3;
+#endif
+    copy_block(s, buf, (unsigned)stored_len, 1); /* with header */
+}
+
+/* ===========================================================================
+ * Send one empty static block to give enough lookahead for inflate.
+ * This takes 10 bits, of which 7 may remain in the bit buffer.
+ * The current inflate code requires 9 bits of lookahead. If the
+ * last two codes for the previous block (real code plus EOB) were coded
+ * on 5 bits or less, inflate may have only 5+3 bits of lookahead to decode
+ * the last real code. In this case we send two empty static blocks instead
+ * of one. (There are no problems if the previous block is stored or fixed.)
+ * To simplify the code, we assume the worst case of last real code encoded
+ * on one bit only.
+ */
+void _tr_align(s)
+    deflate_state *s;
+{
+    send_bits(s, STATIC_TREES<<1, 3);
+    send_code(s, END_BLOCK, static_ltree);
+#ifdef DEBUG
+    s->compressed_len += 10L; /* 3 for block type, 7 for EOB */
+#endif
+    bi_flush(s);
+    /* Of the 10 bits for the empty block, we have already sent
+     * (10 - bi_valid) bits. The lookahead for the last real code (before
+     * the EOB of the previous block) was thus at least one plus the length
+     * of the EOB plus what we have just sent of the empty static block.
+     */
+    if (1 + s->last_eob_len + 10 - s->bi_valid < 9) {
+        send_bits(s, STATIC_TREES<<1, 3);
+        send_code(s, END_BLOCK, static_ltree);
+#ifdef DEBUG
+        s->compressed_len += 10L;
+#endif
+        bi_flush(s);
+    }
+    s->last_eob_len = 7;
+}
+
+/* ===========================================================================
+ * Determine the best encoding for the current block: dynamic trees, static
+ * trees or store, and output the encoded block to the zip file.
+ */
+void _tr_flush_block(s, buf, stored_len, eof)
+    deflate_state *s;
+    charf *buf;       /* input block, or NULL if too old */
+    ulg stored_len;   /* length of input block */
+    int eof;          /* true if this is the last block for a file */
+{
+    ulg opt_lenb, static_lenb; /* opt_len and static_len in bytes */
+    int max_blindex = 0;  /* index of last bit length code of non zero freq */
+
+    /* Build the Huffman trees unless a stored block is forced */
+    if (s->level > 0) {
+
+	 /* Check if the file is ascii or binary */
+	if (s->data_type == Z_UNKNOWN) set_data_type(s);
+
+	/* Construct the literal and distance trees */
+	build_tree(s, (tree_desc *)(&(s->l_desc)));
+	Tracev((stderr, "\nlit data: dyn %ld, stat %ld", s->opt_len,
+		s->static_len));
+
+	build_tree(s, (tree_desc *)(&(s->d_desc)));
+	Tracev((stderr, "\ndist data: dyn %ld, stat %ld", s->opt_len,
+		s->static_len));
+	/* At this point, opt_len and static_len are the total bit lengths of
+	 * the compressed block data, excluding the tree representations.
+	 */
+
+	/* Build the bit length tree for the above two trees, and get the index
+	 * in bl_order of the last bit length code to send.
+	 */
+	max_blindex = build_bl_tree(s);
+
+	/* Determine the best encoding. Compute first the block length in bytes*/
+	opt_lenb = (s->opt_len+3+7)>>3;
+	static_lenb = (s->static_len+3+7)>>3;
+
+	Tracev((stderr, "\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u ",
+		opt_lenb, s->opt_len, static_lenb, s->static_len, stored_len,
+		s->last_lit));
+
+	if (static_lenb <= opt_lenb) opt_lenb = static_lenb;
+
+    } else {
+        Assert(buf != (char*)0, "lost buf");
+	opt_lenb = static_lenb = stored_len + 5; /* force a stored block */
+    }
+
+#ifdef FORCE_STORED
+    if (buf != (char*)0) { /* force stored block */
+#else
+    if (stored_len+4 <= opt_lenb && buf != (char*)0) {
+                       /* 4: two words for the lengths */
+#endif
+        /* The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE.
+         * Otherwise we can't have processed more than WSIZE input bytes since
+         * the last block flush, because compression would have been
+         * successful. If LIT_BUFSIZE <= WSIZE, it is never too late to
+         * transform a block into a stored block.
+         */
+        _tr_stored_block(s, buf, stored_len, eof);
+
+#ifdef FORCE_STATIC
+    } else if (static_lenb >= 0) { /* force static trees */
+#else
+    } else if (static_lenb == opt_lenb) {
+#endif
+        send_bits(s, (STATIC_TREES<<1)+eof, 3);
+        compress_block(s, (ct_data *)static_ltree, (ct_data *)static_dtree);
+#ifdef DEBUG
+        s->compressed_len += 3 + s->static_len;
+#endif
+    } else {
+        send_bits(s, (DYN_TREES<<1)+eof, 3);
+        send_all_trees(s, s->l_desc.max_code+1, s->d_desc.max_code+1,
+                       max_blindex+1);
+        compress_block(s, (ct_data *)s->dyn_ltree, (ct_data *)s->dyn_dtree);
+#ifdef DEBUG
+        s->compressed_len += 3 + s->opt_len;
+#endif
+    }
+    Assert (s->compressed_len == s->bits_sent, "bad compressed size");
+    /* The above check is made mod 2^32, for files larger than 512 MB
+     * and uLong implemented on 32 bits.
+     */
+    init_block(s);
+
+    if (eof) {
+        bi_windup(s);
+#ifdef DEBUG
+        s->compressed_len += 7;  /* align on byte boundary */
+#endif
+    }
+    Tracev((stderr,"\ncomprlen %lu(%lu) ", s->compressed_len>>3,
+           s->compressed_len-7*eof));
+}
+
+/* ===========================================================================
+ * Save the match info and tally the frequency counts. Return true if
+ * the current block must be flushed.
+ */
+int _tr_tally (s, dist, lc)
+    deflate_state *s;
+    unsigned dist;  /* distance of matched string */
+    unsigned lc;    /* match length-MIN_MATCH or unmatched char (if dist==0) */
+{
+    s->d_buf[s->last_lit] = (ush)dist;
+    s->l_buf[s->last_lit++] = (uch)lc;
+    if (dist == 0) {
+        /* lc is the unmatched char */
+        s->dyn_ltree[lc].Freq++;
+    } else {
+        s->matches++;
+        /* Here, lc is the match length - MIN_MATCH */
+        dist--;             /* dist = match distance - 1 */
+        Assert((ush)dist < (ush)MAX_DIST(s) &&
+               (ush)lc <= (ush)(MAX_MATCH-MIN_MATCH) &&
+               (ush)d_code(dist) < (ush)D_CODES,  "_tr_tally: bad match");
+
+        s->dyn_ltree[_length_code[lc]+LITERALS+1].Freq++;
+        s->dyn_dtree[d_code(dist)].Freq++;
+    }
+
+#ifdef TRUNCATE_BLOCK
+    /* Try to guess if it is profitable to stop the current block here */
+    if ((s->last_lit & 0x1fff) == 0 && s->level > 2) {
+        /* Compute an upper bound for the compressed length */
+        ulg out_length = (ulg)s->last_lit*8L;
+        ulg in_length = (ulg)((long)s->strstart - s->block_start);
+        int dcode;
+        for (dcode = 0; dcode < D_CODES; dcode++) {
+            out_length += (ulg)s->dyn_dtree[dcode].Freq *
+                (5L+extra_dbits[dcode]);
+        }
+        out_length >>= 3;
+        Tracev((stderr,"\nlast_lit %u, in %ld, out ~%ld(%ld%%) ",
+               s->last_lit, in_length, out_length,
+               100L - out_length*100L/in_length));
+        if (s->matches < s->last_lit/2 && out_length < in_length/2) return 1;
+    }
+#endif
+    return (s->last_lit == s->lit_bufsize-1);
+    /* We avoid equality with lit_bufsize because of wraparound at 64K
+     * on 16 bit machines and because stored blocks are restricted to
+     * 64K-1 bytes.
+     */
+}
+
+/* ===========================================================================
+ * Send the block data compressed using the given Huffman trees
+ */
+local void compress_block(s, ltree, dtree)
+    deflate_state *s;
+    ct_data *ltree; /* literal tree */
+    ct_data *dtree; /* distance tree */
+{
+    unsigned dist;      /* distance of matched string */
+    int lc;             /* match length or unmatched char (if dist == 0) */
+    unsigned lx = 0;    /* running index in l_buf */
+    unsigned code;      /* the code to send */
+    int extra;          /* number of extra bits to send */
+
+    if (s->last_lit != 0) do {
+        dist = s->d_buf[lx];
+        lc = s->l_buf[lx++];
+        if (dist == 0) {
+            send_code(s, lc, ltree); /* send a literal byte */
+            Tracecv(isgraph(lc), (stderr," '%c' ", lc));
+        } else {
+            /* Here, lc is the match length - MIN_MATCH */
+            code = _length_code[lc];
+            send_code(s, code+LITERALS+1, ltree); /* send the length code */
+            extra = extra_lbits[code];
+            if (extra != 0) {
+                lc -= base_length[code];
+                send_bits(s, lc, extra);       /* send the extra length bits */
+            }
+            dist--; /* dist is now the match distance - 1 */
+            code = d_code(dist);
+            Assert (code < D_CODES, "bad d_code");
+
+            send_code(s, code, dtree);       /* send the distance code */
+            extra = extra_dbits[code];
+            if (extra != 0) {
+                dist -= base_dist[code];
+                send_bits(s, dist, extra);   /* send the extra distance bits */
+            }
+        } /* literal or match pair ? */
+
+        /* Check that the overlay between pending_buf and d_buf+l_buf is ok: */
+        Assert(s->pending < s->lit_bufsize + 2*lx, "pendingBuf overflow");
+
+    } while (lx < s->last_lit);
+
+    send_code(s, END_BLOCK, ltree);
+    s->last_eob_len = ltree[END_BLOCK].Len;
+}
+
+/* ===========================================================================
+ * Set the data type to ASCII or BINARY, using a crude approximation:
+ * binary if more than 20% of the bytes are <= 6 or >= 128, ascii otherwise.
+ * IN assertion: the fields freq of dyn_ltree are set and the total of all
+ * frequencies does not exceed 64K (to fit in an int on 16 bit machines).
+ */
+local void set_data_type(s)
+    deflate_state *s;
+{
+    int n = 0;
+    unsigned ascii_freq = 0;
+    unsigned bin_freq = 0;
+    while (n < 7)        bin_freq += s->dyn_ltree[n++].Freq;
+    while (n < 128)    ascii_freq += s->dyn_ltree[n++].Freq;
+    while (n < LITERALS) bin_freq += s->dyn_ltree[n++].Freq;
+    s->data_type = (Byte)(bin_freq > (ascii_freq >> 2) ? Z_BINARY : Z_ASCII);
+}
+
+/* ===========================================================================
+ * Reverse the first len bits of a code, using straightforward code (a faster
+ * method would use a table)
+ * IN assertion: 1 <= len <= 15
+ */
+local unsigned bi_reverse(code, len)
+    unsigned code; /* the value to invert */
+    int len;       /* its bit length */
+{
+    register unsigned res = 0;
+    do {
+        res |= code & 1;
+        code >>= 1, res <<= 1;
+    } while (--len > 0);
+    return res >> 1;
+}
+
+/* ===========================================================================
+ * Flush the bit buffer, keeping at most 7 bits in it.
+ */
+local void bi_flush(s)
+    deflate_state *s;
+{
+    if (s->bi_valid == 16) {
+        put_short(s, s->bi_buf);
+        s->bi_buf = 0;
+        s->bi_valid = 0;
+    } else if (s->bi_valid >= 8) {
+        put_byte(s, (Byte)s->bi_buf);
+        s->bi_buf >>= 8;
+        s->bi_valid -= 8;
+    }
+}
+
+/* ===========================================================================
+ * Flush the bit buffer and align the output on a byte boundary
+ */
+local void bi_windup(s)
+    deflate_state *s;
+{
+    if (s->bi_valid > 8) {
+        put_short(s, s->bi_buf);
+    } else if (s->bi_valid > 0) {
+        put_byte(s, (Byte)s->bi_buf);
+    }
+    s->bi_buf = 0;
+    s->bi_valid = 0;
+#ifdef DEBUG
+    s->bits_sent = (s->bits_sent+7) & ~7;
+#endif
+}
+
+/* ===========================================================================
+ * Copy a stored block, storing first the length and its
+ * one's complement if requested.
+ */
+local void copy_block(s, buf, len, header)
+    deflate_state *s;
+    charf    *buf;    /* the input data */
+    unsigned len;     /* its length */
+    int      header;  /* true if block header must be written */
+{
+    bi_windup(s);        /* align on byte boundary */
+    s->last_eob_len = 8; /* enough lookahead for inflate */
+
+    if (header) {
+        put_short(s, (ush)len);   
+        put_short(s, (ush)~len);
+#ifdef DEBUG
+        s->bits_sent += 2*16;
+#endif
+    }
+#ifdef DEBUG
+    s->bits_sent += (ulg)len<<3;
+#endif
+    while (len--) {
+        put_byte(s, *buf++);
+    }
+}
diff --git a/src/libz/src/trees.h b/src/libz/src/trees.h
new file mode 100644
index 0000000..72facf9
--- /dev/null
+++ b/src/libz/src/trees.h
@@ -0,0 +1,128 @@
+/* header created automatically with -DGEN_TREES_H */
+
+local const ct_data static_ltree[L_CODES+2] = {
+{{ 12},{  8}}, {{140},{  8}}, {{ 76},{  8}}, {{204},{  8}}, {{ 44},{  8}},
+{{172},{  8}}, {{108},{  8}}, {{236},{  8}}, {{ 28},{  8}}, {{156},{  8}},
+{{ 92},{  8}}, {{220},{  8}}, {{ 60},{  8}}, {{188},{  8}}, {{124},{  8}},
+{{252},{  8}}, {{  2},{  8}}, {{130},{  8}}, {{ 66},{  8}}, {{194},{  8}},
+{{ 34},{  8}}, {{162},{  8}}, {{ 98},{  8}}, {{226},{  8}}, {{ 18},{  8}},
+{{146},{  8}}, {{ 82},{  8}}, {{210},{  8}}, {{ 50},{  8}}, {{178},{  8}},
+{{114},{  8}}, {{242},{  8}}, {{ 10},{  8}}, {{138},{  8}}, {{ 74},{  8}},
+{{202},{  8}}, {{ 42},{  8}}, {{170},{  8}}, {{106},{  8}}, {{234},{  8}},
+{{ 26},{  8}}, {{154},{  8}}, {{ 90},{  8}}, {{218},{  8}}, {{ 58},{  8}},
+{{186},{  8}}, {{122},{  8}}, {{250},{  8}}, {{  6},{  8}}, {{134},{  8}},
+{{ 70},{  8}}, {{198},{  8}}, {{ 38},{  8}}, {{166},{  8}}, {{102},{  8}},
+{{230},{  8}}, {{ 22},{  8}}, {{150},{  8}}, {{ 86},{  8}}, {{214},{  8}},
+{{ 54},{  8}}, {{182},{  8}}, {{118},{  8}}, {{246},{  8}}, {{ 14},{  8}},
+{{142},{  8}}, {{ 78},{  8}}, {{206},{  8}}, {{ 46},{  8}}, {{174},{  8}},
+{{110},{  8}}, {{238},{  8}}, {{ 30},{  8}}, {{158},{  8}}, {{ 94},{  8}},
+{{222},{  8}}, {{ 62},{  8}}, {{190},{  8}}, {{126},{  8}}, {{254},{  8}},
+{{  1},{  8}}, {{129},{  8}}, {{ 65},{  8}}, {{193},{  8}}, {{ 33},{  8}},
+{{161},{  8}}, {{ 97},{  8}}, {{225},{  8}}, {{ 17},{  8}}, {{145},{  8}},
+{{ 81},{  8}}, {{209},{  8}}, {{ 49},{  8}}, {{177},{  8}}, {{113},{  8}},
+{{241},{  8}}, {{  9},{  8}}, {{137},{  8}}, {{ 73},{  8}}, {{201},{  8}},
+{{ 41},{  8}}, {{169},{  8}}, {{105},{  8}}, {{233},{  8}}, {{ 25},{  8}},
+{{153},{  8}}, {{ 89},{  8}}, {{217},{  8}}, {{ 57},{  8}}, {{185},{  8}},
+{{121},{  8}}, {{249},{  8}}, {{  5},{  8}}, {{133},{  8}}, {{ 69},{  8}},
+{{197},{  8}}, {{ 37},{  8}}, {{165},{  8}}, {{101},{  8}}, {{229},{  8}},
+{{ 21},{  8}}, {{149},{  8}}, {{ 85},{  8}}, {{213},{  8}}, {{ 53},{  8}},
+{{181},{  8}}, {{117},{  8}}, {{245},{  8}}, {{ 13},{  8}}, {{141},{  8}},
+{{ 77},{  8}}, {{205},{  8}}, {{ 45},{  8}}, {{173},{  8}}, {{109},{  8}},
+{{237},{  8}}, {{ 29},{  8}}, {{157},{  8}}, {{ 93},{  8}}, {{221},{  8}},
+{{ 61},{  8}}, {{189},{  8}}, {{125},{  8}}, {{253},{  8}}, {{ 19},{  9}},
+{{275},{  9}}, {{147},{  9}}, {{403},{  9}}, {{ 83},{  9}}, {{339},{  9}},
+{{211},{  9}}, {{467},{  9}}, {{ 51},{  9}}, {{307},{  9}}, {{179},{  9}},
+{{435},{  9}}, {{115},{  9}}, {{371},{  9}}, {{243},{  9}}, {{499},{  9}},
+{{ 11},{  9}}, {{267},{  9}}, {{139},{  9}}, {{395},{  9}}, {{ 75},{  9}},
+{{331},{  9}}, {{203},{  9}}, {{459},{  9}}, {{ 43},{  9}}, {{299},{  9}},
+{{171},{  9}}, {{427},{  9}}, {{107},{  9}}, {{363},{  9}}, {{235},{  9}},
+{{491},{  9}}, {{ 27},{  9}}, {{283},{  9}}, {{155},{  9}}, {{411},{  9}},
+{{ 91},{  9}}, {{347},{  9}}, {{219},{  9}}, {{475},{  9}}, {{ 59},{  9}},
+{{315},{  9}}, {{187},{  9}}, {{443},{  9}}, {{123},{  9}}, {{379},{  9}},
+{{251},{  9}}, {{507},{  9}}, {{  7},{  9}}, {{263},{  9}}, {{135},{  9}},
+{{391},{  9}}, {{ 71},{  9}}, {{327},{  9}}, {{199},{  9}}, {{455},{  9}},
+{{ 39},{  9}}, {{295},{  9}}, {{167},{  9}}, {{423},{  9}}, {{103},{  9}},
+{{359},{  9}}, {{231},{  9}}, {{487},{  9}}, {{ 23},{  9}}, {{279},{  9}},
+{{151},{  9}}, {{407},{  9}}, {{ 87},{  9}}, {{343},{  9}}, {{215},{  9}},
+{{471},{  9}}, {{ 55},{  9}}, {{311},{  9}}, {{183},{  9}}, {{439},{  9}},
+{{119},{  9}}, {{375},{  9}}, {{247},{  9}}, {{503},{  9}}, {{ 15},{  9}},
+{{271},{  9}}, {{143},{  9}}, {{399},{  9}}, {{ 79},{  9}}, {{335},{  9}},
+{{207},{  9}}, {{463},{  9}}, {{ 47},{  9}}, {{303},{  9}}, {{175},{  9}},
+{{431},{  9}}, {{111},{  9}}, {{367},{  9}}, {{239},{  9}}, {{495},{  9}},
+{{ 31},{  9}}, {{287},{  9}}, {{159},{  9}}, {{415},{  9}}, {{ 95},{  9}},
+{{351},{  9}}, {{223},{  9}}, {{479},{  9}}, {{ 63},{  9}}, {{319},{  9}},
+{{191},{  9}}, {{447},{  9}}, {{127},{  9}}, {{383},{  9}}, {{255},{  9}},
+{{511},{  9}}, {{  0},{  7}}, {{ 64},{  7}}, {{ 32},{  7}}, {{ 96},{  7}},
+{{ 16},{  7}}, {{ 80},{  7}}, {{ 48},{  7}}, {{112},{  7}}, {{  8},{  7}},
+{{ 72},{  7}}, {{ 40},{  7}}, {{104},{  7}}, {{ 24},{  7}}, {{ 88},{  7}},
+{{ 56},{  7}}, {{120},{  7}}, {{  4},{  7}}, {{ 68},{  7}}, {{ 36},{  7}},
+{{100},{  7}}, {{ 20},{  7}}, {{ 84},{  7}}, {{ 52},{  7}}, {{116},{  7}},
+{{  3},{  8}}, {{131},{  8}}, {{ 67},{  8}}, {{195},{  8}}, {{ 35},{  8}},
+{{163},{  8}}, {{ 99},{  8}}, {{227},{  8}}
+};
+
+local const ct_data static_dtree[D_CODES] = {
+{{ 0},{ 5}}, {{16},{ 5}}, {{ 8},{ 5}}, {{24},{ 5}}, {{ 4},{ 5}},
+{{20},{ 5}}, {{12},{ 5}}, {{28},{ 5}}, {{ 2},{ 5}}, {{18},{ 5}},
+{{10},{ 5}}, {{26},{ 5}}, {{ 6},{ 5}}, {{22},{ 5}}, {{14},{ 5}},
+{{30},{ 5}}, {{ 1},{ 5}}, {{17},{ 5}}, {{ 9},{ 5}}, {{25},{ 5}},
+{{ 5},{ 5}}, {{21},{ 5}}, {{13},{ 5}}, {{29},{ 5}}, {{ 3},{ 5}},
+{{19},{ 5}}, {{11},{ 5}}, {{27},{ 5}}, {{ 7},{ 5}}, {{23},{ 5}}
+};
+
+const uch _dist_code[DIST_CODE_LEN] = {
+ 0,  1,  2,  3,  4,  4,  5,  5,  6,  6,  6,  6,  7,  7,  7,  7,  8,  8,  8,  8,
+ 8,  8,  8,  8,  9,  9,  9,  9,  9,  9,  9,  9, 10, 10, 10, 10, 10, 10, 10, 10,
+10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 13, 13, 13, 13,
+13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+13, 13, 13, 13, 13, 13, 13, 13, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 15,
+15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,  0,  0, 16, 17,
+18, 18, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 22,
+23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
+26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
+26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27,
+27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+27, 27, 27, 27, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+28, 28, 28, 28, 28, 28, 28, 28, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29
+};
+
+const uch _length_code[MAX_MATCH-MIN_MATCH+1]= {
+ 0,  1,  2,  3,  4,  5,  6,  7,  8,  8,  9,  9, 10, 10, 11, 11, 12, 12, 12, 12,
+13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16,
+17, 17, 17, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19,
+19, 19, 19, 19, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
+21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 22, 22, 22, 22,
+22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 23, 23, 23,
+23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
+25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 26, 26, 26, 26, 26, 26, 26, 26,
+26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
+26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 28
+};
+
+local const int base_length[LENGTH_CODES] = {
+0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16, 20, 24, 28, 32, 40, 48, 56,
+64, 80, 96, 112, 128, 160, 192, 224, 0
+};
+
+local const int base_dist[D_CODES] = {
+    0,     1,     2,     3,     4,     6,     8,    12,    16,    24,
+   32,    48,    64,    96,   128,   192,   256,   384,   512,   768,
+ 1024,  1536,  2048,  3072,  4096,  6144,  8192, 12288, 16384, 24576
+};
+
diff --git a/src/libz/src/uncompr.c b/src/libz/src/uncompr.c
new file mode 100644
index 0000000..834d7f4
--- /dev/null
+++ b/src/libz/src/uncompr.c
@@ -0,0 +1,58 @@
+/* uncompr.c -- decompress a memory buffer
+ * Copyright (C) 1995-2002 Jean-loup Gailly.
+ * For conditions of distribution and use, see copyright notice in zlib.h 
+ */
+
+/* @(#) $Id: uncompr.c,v 1.1 2008/11/12 02:25:24 agibert Exp $ */
+
+#include "zlib.h"
+
+/* ===========================================================================
+     Decompresses the source buffer into the destination buffer.  sourceLen is
+   the byte length of the source buffer. Upon entry, destLen is the total
+   size of the destination buffer, which must be large enough to hold the
+   entire uncompressed data. (The size of the uncompressed data must have
+   been saved previously by the compressor and transmitted to the decompressor
+   by some mechanism outside the scope of this compression library.)
+   Upon exit, destLen is the actual size of the compressed buffer.
+     This function can be used to decompress a whole file at once if the
+   input file is mmap'ed.
+
+     uncompress returns Z_OK if success, Z_MEM_ERROR if there was not
+   enough memory, Z_BUF_ERROR if there was not enough room in the output
+   buffer, or Z_DATA_ERROR if the input data was corrupted.
+*/
+int ZEXPORT uncompress (dest, destLen, source, sourceLen)
+    Bytef *dest;
+    uLongf *destLen;
+    const Bytef *source;
+    uLong sourceLen;
+{
+    z_stream stream;
+    int err;
+
+    stream.next_in = (Bytef*)source;
+    stream.avail_in = (uInt)sourceLen;
+    /* Check for source > 64K on 16-bit machine: */
+    if ((uLong)stream.avail_in != sourceLen) return Z_BUF_ERROR;
+
+    stream.next_out = dest;
+    stream.avail_out = (uInt)*destLen;
+    if ((uLong)stream.avail_out != *destLen) return Z_BUF_ERROR;
+
+    stream.zalloc = (alloc_func)0;
+    stream.zfree = (free_func)0;
+
+    err = inflateInit(&stream);
+    if (err != Z_OK) return err;
+
+    err = inflate(&stream, Z_FINISH);
+    if (err != Z_STREAM_END) {
+        inflateEnd(&stream);
+        return err == Z_OK ? Z_BUF_ERROR : err;
+    }
+    *destLen = stream.total_out;
+
+    err = inflateEnd(&stream);
+    return err;
+}
diff --git a/src/libz/src/zlib.h b/src/libz/src/zlib.h
new file mode 100644
index 0000000..52cb529
--- /dev/null
+++ b/src/libz/src/zlib.h
@@ -0,0 +1,893 @@
+/* zlib.h -- interface of the 'zlib' general purpose compression library
+  version 1.1.4, March 11th, 2002
+
+  Copyright (C) 1995-2002 Jean-loup Gailly and Mark Adler
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
+  Jean-loup Gailly        Mark Adler
+  jloup@gzip.org          madler@alumni.caltech.edu
+
+
+  The data format used by the zlib library is described by RFCs (Request for
+  Comments) 1950 to 1952 in the files ftp://ds.internic.net/rfc/rfc1950.txt
+  (zlib format), rfc1951.txt (deflate format) and rfc1952.txt (gzip format).
+*/
+
+#ifndef _ZLIB_H
+#define _ZLIB_H
+
+#include "zconf.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define ZLIB_VERSION "1.1.4"
+
+/* 
+     The 'zlib' compression library provides in-memory compression and
+  decompression functions, including integrity checks of the uncompressed
+  data.  This version of the library supports only one compression method
+  (deflation) but other algorithms will be added later and will have the same
+  stream interface.
+
+     Compression can be done in a single step if the buffers are large
+  enough (for example if an input file is mmap'ed), or can be done by
+  repeated calls of the compression function.  In the latter case, the
+  application must provide more input and/or consume the output
+  (providing more output space) before each call.
+
+     The library also supports reading and writing files in gzip (.gz) format
+  with an interface similar to that of stdio.
+
+     The library does not install any signal handler. The decoder checks
+  the consistency of the compressed data, so the library should never
+  crash even in case of corrupted input.
+*/
+
+typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size));
+typedef void   (*free_func)  OF((voidpf opaque, voidpf address));
+
+struct internal_state;
+
+typedef struct z_stream_s {
+    Bytef    *next_in;  /* next input byte */
+    uInt     avail_in;  /* number of bytes available at next_in */
+    uLong    total_in;  /* total nb of input bytes read so far */
+
+    Bytef    *next_out; /* next output byte should be put there */
+    uInt     avail_out; /* remaining free space at next_out */
+    uLong    total_out; /* total nb of bytes output so far */
+
+    char     *msg;      /* last error message, NULL if no error */
+    struct internal_state FAR *state; /* not visible by applications */
+
+    alloc_func zalloc;  /* used to allocate the internal state */
+    free_func  zfree;   /* used to free the internal state */
+    voidpf     opaque;  /* private data object passed to zalloc and zfree */
+
+    int     data_type;  /* best guess about the data type: ascii or binary */
+    uLong   adler;      /* adler32 value of the uncompressed data */
+    uLong   reserved;   /* reserved for future use */
+} z_stream;
+
+typedef z_stream FAR *z_streamp;
+
+/*
+   The application must update next_in and avail_in when avail_in has
+   dropped to zero. It must update next_out and avail_out when avail_out
+   has dropped to zero. The application must initialize zalloc, zfree and
+   opaque before calling the init function. All other fields are set by the
+   compression library and must not be updated by the application.
+
+   The opaque value provided by the application will be passed as the first
+   parameter for calls of zalloc and zfree. This can be useful for custom
+   memory management. The compression library attaches no meaning to the
+   opaque value.
+
+   zalloc must return Z_NULL if there is not enough memory for the object.
+   If zlib is used in a multi-threaded application, zalloc and zfree must be
+   thread safe.
+
+   On 16-bit systems, the functions zalloc and zfree must be able to allocate
+   exactly 65536 bytes, but will not be required to allocate more than this
+   if the symbol MAXSEG_64K is defined (see zconf.h). WARNING: On MSDOS,
+   pointers returned by zalloc for objects of exactly 65536 bytes *must*
+   have their offset normalized to zero. The default allocation function
+   provided by this library ensures this (see zutil.c). To reduce memory
+   requirements and avoid any allocation of 64K objects, at the expense of
+   compression ratio, compile the library with -DMAX_WBITS=14 (see zconf.h).
+
+   The fields total_in and total_out can be used for statistics or
+   progress reports. After compression, total_in holds the total size of
+   the uncompressed data and may be saved for use in the decompressor
+   (particularly if the decompressor wants to decompress everything in
+   a single step).
+*/
+
+                        /* constants */
+
+#define Z_NO_FLUSH      0
+#define Z_PARTIAL_FLUSH 1 /* will be removed, use Z_SYNC_FLUSH instead */
+#define Z_SYNC_FLUSH    2
+#define Z_FULL_FLUSH    3
+#define Z_FINISH        4
+/* Allowed flush values; see deflate() below for details */
+
+#define Z_OK            0
+#define Z_STREAM_END    1
+#define Z_NEED_DICT     2
+#define Z_ERRNO        (-1)
+#define Z_STREAM_ERROR (-2)
+#define Z_DATA_ERROR   (-3)
+#define Z_MEM_ERROR    (-4)
+#define Z_BUF_ERROR    (-5)
+#define Z_VERSION_ERROR (-6)
+/* Return codes for the compression/decompression functions. Negative
+ * values are errors, positive values are used for special but normal events.
+ */
+
+#define Z_NO_COMPRESSION         0
+#define Z_BEST_SPEED             1
+#define Z_BEST_COMPRESSION       9
+#define Z_DEFAULT_COMPRESSION  (-1)
+/* compression levels */
+
+#define Z_FILTERED            1
+#define Z_HUFFMAN_ONLY        2
+#define Z_DEFAULT_STRATEGY    0
+/* compression strategy; see deflateInit2() below for details */
+
+#define Z_BINARY   0
+#define Z_ASCII    1
+#define Z_UNKNOWN  2
+/* Possible values of the data_type field */
+
+#define Z_DEFLATED   8
+/* The deflate compression method (the only one supported in this version) */
+
+#define Z_NULL  0  /* for initializing zalloc, zfree, opaque */
+
+#define zlib_version zlibVersion()
+/* for compatibility with versions < 1.0.2 */
+
+                        /* basic functions */
+
+ZEXTERN const char * ZEXPORT zlibVersion OF((void));
+/* The application can compare zlibVersion and ZLIB_VERSION for consistency.
+   If the first character differs, the library code actually used is
+   not compatible with the zlib.h header file used by the application.
+   This check is automatically made by deflateInit and inflateInit.
+ */
+
+/* 
+ZEXTERN int ZEXPORT deflateInit OF((z_streamp strm, int level));
+
+     Initializes the internal stream state for compression. The fields
+   zalloc, zfree and opaque must be initialized before by the caller.
+   If zalloc and zfree are set to Z_NULL, deflateInit updates them to
+   use default allocation functions.
+
+     The compression level must be Z_DEFAULT_COMPRESSION, or between 0 and 9:
+   1 gives best speed, 9 gives best compression, 0 gives no compression at
+   all (the input data is simply copied a block at a time).
+   Z_DEFAULT_COMPRESSION requests a default compromise between speed and
+   compression (currently equivalent to level 6).
+
+     deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not
+   enough memory, Z_STREAM_ERROR if level is not a valid compression level,
+   Z_VERSION_ERROR if the zlib library version (zlib_version) is incompatible
+   with the version assumed by the caller (ZLIB_VERSION).
+   msg is set to null if there is no error message.  deflateInit does not
+   perform any compression: this will be done by deflate().
+*/
+
+
+ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush));
+/*
+    deflate compresses as much data as possible, and stops when the input
+  buffer becomes empty or the output buffer becomes full. It may introduce some
+  output latency (reading input without producing any output) except when
+  forced to flush.
+
+    The detailed semantics are as follows. deflate performs one or both of the
+  following actions:
+
+  - Compress more input starting at next_in and update next_in and avail_in
+    accordingly. If not all input can be processed (because there is not
+    enough room in the output buffer), next_in and avail_in are updated and
+    processing will resume at this point for the next call of deflate().
+
+  - Provide more output starting at next_out and update next_out and avail_out
+    accordingly. This action is forced if the parameter flush is non zero.
+    Forcing flush frequently degrades the compression ratio, so this parameter
+    should be set only when necessary (in interactive applications).
+    Some output may be provided even if flush is not set.
+
+  Before the call of deflate(), the application should ensure that at least
+  one of the actions is possible, by providing more input and/or consuming
+  more output, and updating avail_in or avail_out accordingly; avail_out
+  should never be zero before the call. The application can consume the
+  compressed output when it wants, for example when the output buffer is full
+  (avail_out == 0), or after each call of deflate(). If deflate returns Z_OK
+  and with zero avail_out, it must be called again after making room in the
+  output buffer because there might be more output pending.
+
+    If the parameter flush is set to Z_SYNC_FLUSH, all pending output is
+  flushed to the output buffer and the output is aligned on a byte boundary, so
+  that the decompressor can get all input data available so far. (In particular
+  avail_in is zero after the call if enough output space has been provided
+  before the call.)  Flushing may degrade compression for some compression
+  algorithms and so it should be used only when necessary.
+
+    If flush is set to Z_FULL_FLUSH, all output is flushed as with
+  Z_SYNC_FLUSH, and the compression state is reset so that decompression can
+  restart from this point if previous compressed data has been damaged or if
+  random access is desired. Using Z_FULL_FLUSH too often can seriously degrade
+  the compression.
+
+    If deflate returns with avail_out == 0, this function must be called again
+  with the same value of the flush parameter and more output space (updated
+  avail_out), until the flush is complete (deflate returns with non-zero
+  avail_out).
+
+    If the parameter flush is set to Z_FINISH, pending input is processed,
+  pending output is flushed and deflate returns with Z_STREAM_END if there
+  was enough output space; if deflate returns with Z_OK, this function must be
+  called again with Z_FINISH and more output space (updated avail_out) but no
+  more input data, until it returns with Z_STREAM_END or an error. After
+  deflate has returned Z_STREAM_END, the only possible operations on the
+  stream are deflateReset or deflateEnd.
+  
+    Z_FINISH can be used immediately after deflateInit if all the compression
+  is to be done in a single step. In this case, avail_out must be at least
+  0.1% larger than avail_in plus 12 bytes.  If deflate does not return
+  Z_STREAM_END, then it must be called again as described above.
+
+    deflate() sets strm->adler to the adler32 checksum of all input read
+  so far (that is, total_in bytes).
+
+    deflate() may update data_type if it can make a good guess about
+  the input data type (Z_ASCII or Z_BINARY). In doubt, the data is considered
+  binary. This field is only for information purposes and does not affect
+  the compression algorithm in any manner.
+
+    deflate() returns Z_OK if some progress has been made (more input
+  processed or more output produced), Z_STREAM_END if all input has been
+  consumed and all output has been produced (only when flush is set to
+  Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example
+  if next_in or next_out was NULL), Z_BUF_ERROR if no progress is possible
+  (for example avail_in or avail_out was zero).
+*/
+
+
+ZEXTERN int ZEXPORT deflateEnd OF((z_streamp strm));
+/*
+     All dynamically allocated data structures for this stream are freed.
+   This function discards any unprocessed input and does not flush any
+   pending output.
+
+     deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the
+   stream state was inconsistent, Z_DATA_ERROR if the stream was freed
+   prematurely (some input or output was discarded). In the error case,
+   msg may be set but then points to a static string (which must not be
+   deallocated).
+*/
+
+
+/* 
+ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm));
+
+     Initializes the internal stream state for decompression. The fields
+   next_in, avail_in, zalloc, zfree and opaque must be initialized before by
+   the caller. If next_in is not Z_NULL and avail_in is large enough (the exact
+   value depends on the compression method), inflateInit determines the
+   compression method from the zlib header and allocates all data structures
+   accordingly; otherwise the allocation will be deferred to the first call of
+   inflate.  If zalloc and zfree are set to Z_NULL, inflateInit updates them to
+   use default allocation functions.
+
+     inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_VERSION_ERROR if the zlib library version is incompatible with the
+   version assumed by the caller.  msg is set to null if there is no error
+   message. inflateInit does not perform any decompression apart from reading
+   the zlib header if present: this will be done by inflate().  (So next_in and
+   avail_in may be modified, but next_out and avail_out are unchanged.)
+*/
+
+
+ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush));
+/*
+    inflate decompresses as much data as possible, and stops when the input
+  buffer becomes empty or the output buffer becomes full. It may some
+  introduce some output latency (reading input without producing any output)
+  except when forced to flush.
+
+  The detailed semantics are as follows. inflate performs one or both of the
+  following actions:
+
+  - Decompress more input starting at next_in and update next_in and avail_in
+    accordingly. If not all input can be processed (because there is not
+    enough room in the output buffer), next_in is updated and processing
+    will resume at this point for the next call of inflate().
+
+  - Provide more output starting at next_out and update next_out and avail_out
+    accordingly.  inflate() provides as much output as possible, until there
+    is no more input data or no more space in the output buffer (see below
+    about the flush parameter).
+
+  Before the call of inflate(), the application should ensure that at least
+  one of the actions is possible, by providing more input and/or consuming
+  more output, and updating the next_* and avail_* values accordingly.
+  The application can consume the uncompressed output when it wants, for
+  example when the output buffer is full (avail_out == 0), or after each
+  call of inflate(). If inflate returns Z_OK and with zero avail_out, it
+  must be called again after making room in the output buffer because there
+  might be more output pending.
+
+    If the parameter flush is set to Z_SYNC_FLUSH, inflate flushes as much
+  output as possible to the output buffer. The flushing behavior of inflate is
+  not specified for values of the flush parameter other than Z_SYNC_FLUSH
+  and Z_FINISH, but the current implementation actually flushes as much output
+  as possible anyway.
+
+    inflate() should normally be called until it returns Z_STREAM_END or an
+  error. However if all decompression is to be performed in a single step
+  (a single call of inflate), the parameter flush should be set to
+  Z_FINISH. In this case all pending input is processed and all pending
+  output is flushed; avail_out must be large enough to hold all the
+  uncompressed data. (The size of the uncompressed data may have been saved
+  by the compressor for this purpose.) The next operation on this stream must
+  be inflateEnd to deallocate the decompression state. The use of Z_FINISH
+  is never required, but can be used to inform inflate that a faster routine
+  may be used for the single inflate() call.
+
+     If a preset dictionary is needed at this point (see inflateSetDictionary
+  below), inflate sets strm-adler to the adler32 checksum of the
+  dictionary chosen by the compressor and returns Z_NEED_DICT; otherwise 
+  it sets strm->adler to the adler32 checksum of all output produced
+  so far (that is, total_out bytes) and returns Z_OK, Z_STREAM_END or
+  an error code as described below. At the end of the stream, inflate()
+  checks that its computed adler32 checksum is equal to that saved by the
+  compressor and returns Z_STREAM_END only if the checksum is correct.
+
+    inflate() returns Z_OK if some progress has been made (more input processed
+  or more output produced), Z_STREAM_END if the end of the compressed data has
+  been reached and all uncompressed output has been produced, Z_NEED_DICT if a
+  preset dictionary is needed at this point, Z_DATA_ERROR if the input data was
+  corrupted (input stream not conforming to the zlib format or incorrect
+  adler32 checksum), Z_STREAM_ERROR if the stream structure was inconsistent
+  (for example if next_in or next_out was NULL), Z_MEM_ERROR if there was not
+  enough memory, Z_BUF_ERROR if no progress is possible or if there was not
+  enough room in the output buffer when Z_FINISH is used. In the Z_DATA_ERROR
+  case, the application may then call inflateSync to look for a good
+  compression block.
+*/
+
+
+ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm));
+/*
+     All dynamically allocated data structures for this stream are freed.
+   This function discards any unprocessed input and does not flush any
+   pending output.
+
+     inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state
+   was inconsistent. In the error case, msg may be set but then points to a
+   static string (which must not be deallocated).
+*/
+
+                        /* Advanced functions */
+
+/*
+    The following functions are needed only in some special applications.
+*/
+
+/*   
+ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp strm,
+                                     int  level,
+                                     int  method,
+                                     int  windowBits,
+                                     int  memLevel,
+                                     int  strategy));
+
+     This is another version of deflateInit with more compression options. The
+   fields next_in, zalloc, zfree and opaque must be initialized before by
+   the caller.
+
+     The method parameter is the compression method. It must be Z_DEFLATED in
+   this version of the library.
+
+     The windowBits parameter is the base two logarithm of the window size
+   (the size of the history buffer).  It should be in the range 8..15 for this
+   version of the library. Larger values of this parameter result in better
+   compression at the expense of memory usage. The default value is 15 if
+   deflateInit is used instead.
+
+     The memLevel parameter specifies how much memory should be allocated
+   for the internal compression state. memLevel=1 uses minimum memory but
+   is slow and reduces compression ratio; memLevel=9 uses maximum memory
+   for optimal speed. The default value is 8. See zconf.h for total memory
+   usage as a function of windowBits and memLevel.
+
+     The strategy parameter is used to tune the compression algorithm. Use the
+   value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data produced by a
+   filter (or predictor), or Z_HUFFMAN_ONLY to force Huffman encoding only (no
+   string match).  Filtered data consists mostly of small values with a
+   somewhat random distribution. In this case, the compression algorithm is
+   tuned to compress them better. The effect of Z_FILTERED is to force more
+   Huffman coding and less string matching; it is somewhat intermediate
+   between Z_DEFAULT and Z_HUFFMAN_ONLY. The strategy parameter only affects
+   the compression ratio but not the correctness of the compressed output even
+   if it is not set appropriately.
+
+      deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_STREAM_ERROR if a parameter is invalid (such as an invalid
+   method). msg is set to null if there is no error message.  deflateInit2 does
+   not perform any compression: this will be done by deflate().
+*/
+                            
+ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm,
+                                             const Bytef *dictionary,
+                                             uInt  dictLength));
+/*
+     Initializes the compression dictionary from the given byte sequence
+   without producing any compressed output. This function must be called
+   immediately after deflateInit, deflateInit2 or deflateReset, before any
+   call of deflate. The compressor and decompressor must use exactly the same
+   dictionary (see inflateSetDictionary).
+
+     The dictionary should consist of strings (byte sequences) that are likely
+   to be encountered later in the data to be compressed, with the most commonly
+   used strings preferably put towards the end of the dictionary. Using a
+   dictionary is most useful when the data to be compressed is short and can be
+   predicted with good accuracy; the data can then be compressed better than
+   with the default empty dictionary.
+
+     Depending on the size of the compression data structures selected by
+   deflateInit or deflateInit2, a part of the dictionary may in effect be
+   discarded, for example if the dictionary is larger than the window size in
+   deflate or deflate2. Thus the strings most likely to be useful should be
+   put at the end of the dictionary, not at the front.
+
+     Upon return of this function, strm->adler is set to the Adler32 value
+   of the dictionary; the decompressor may later use this value to determine
+   which dictionary has been used by the compressor. (The Adler32 value
+   applies to the whole dictionary even if only a subset of the dictionary is
+   actually used by the compressor.)
+
+     deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a
+   parameter is invalid (such as NULL dictionary) or the stream state is
+   inconsistent (for example if deflate has already been called for this stream
+   or if the compression method is bsort). deflateSetDictionary does not
+   perform any compression: this will be done by deflate().
+*/
+
+ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest,
+                                    z_streamp source));
+/*
+     Sets the destination stream as a complete copy of the source stream.
+
+     This function can be useful when several compression strategies will be
+   tried, for example when there are several ways of pre-processing the input
+   data with a filter. The streams that will be discarded should then be freed
+   by calling deflateEnd.  Note that deflateCopy duplicates the internal
+   compression state which can be quite large, so this strategy is slow and
+   can consume lots of memory.
+
+     deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not
+   enough memory, Z_STREAM_ERROR if the source stream state was inconsistent
+   (such as zalloc being NULL). msg is left unchanged in both source and
+   destination.
+*/
+
+ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm));
+/*
+     This function is equivalent to deflateEnd followed by deflateInit,
+   but does not free and reallocate all the internal compression state.
+   The stream will keep the same compression level and any other attributes
+   that may have been set by deflateInit2.
+
+      deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent (such as zalloc or state being NULL).
+*/
+
+ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm,
+				      int level,
+				      int strategy));
+/*
+     Dynamically update the compression level and compression strategy.  The
+   interpretation of level and strategy is as in deflateInit2.  This can be
+   used to switch between compression and straight copy of the input data, or
+   to switch to a different kind of input data requiring a different
+   strategy. If the compression level is changed, the input available so far
+   is compressed with the old level (and may be flushed); the new level will
+   take effect only at the next call of deflate().
+
+     Before the call of deflateParams, the stream state must be set as for
+   a call of deflate(), since the currently available input may have to
+   be compressed and flushed. In particular, strm->avail_out must be non-zero.
+
+     deflateParams returns Z_OK if success, Z_STREAM_ERROR if the source
+   stream state was inconsistent or if a parameter was invalid, Z_BUF_ERROR
+   if strm->avail_out was zero.
+*/
+
+/*   
+ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm,
+                                     int  windowBits));
+
+     This is another version of inflateInit with an extra parameter. The
+   fields next_in, avail_in, zalloc, zfree and opaque must be initialized
+   before by the caller.
+
+     The windowBits parameter is the base two logarithm of the maximum window
+   size (the size of the history buffer).  It should be in the range 8..15 for
+   this version of the library. The default value is 15 if inflateInit is used
+   instead. If a compressed stream with a larger window size is given as
+   input, inflate() will return with the error code Z_DATA_ERROR instead of
+   trying to allocate a larger window.
+
+      inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_STREAM_ERROR if a parameter is invalid (such as a negative
+   memLevel). msg is set to null if there is no error message.  inflateInit2
+   does not perform any decompression apart from reading the zlib header if
+   present: this will be done by inflate(). (So next_in and avail_in may be
+   modified, but next_out and avail_out are unchanged.)
+*/
+
+ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm,
+                                             const Bytef *dictionary,
+                                             uInt  dictLength));
+/*
+     Initializes the decompression dictionary from the given uncompressed byte
+   sequence. This function must be called immediately after a call of inflate
+   if this call returned Z_NEED_DICT. The dictionary chosen by the compressor
+   can be determined from the Adler32 value returned by this call of
+   inflate. The compressor and decompressor must use exactly the same
+   dictionary (see deflateSetDictionary).
+
+     inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a
+   parameter is invalid (such as NULL dictionary) or the stream state is
+   inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the
+   expected one (incorrect Adler32 value). inflateSetDictionary does not
+   perform any decompression: this will be done by subsequent calls of
+   inflate().
+*/
+
+ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm));
+/* 
+    Skips invalid compressed data until a full flush point (see above the
+  description of deflate with Z_FULL_FLUSH) can be found, or until all
+  available input is skipped. No output is provided.
+
+    inflateSync returns Z_OK if a full flush point has been found, Z_BUF_ERROR
+  if no more input was provided, Z_DATA_ERROR if no flush point has been found,
+  or Z_STREAM_ERROR if the stream structure was inconsistent. In the success
+  case, the application may save the current current value of total_in which
+  indicates where valid compressed data was found. In the error case, the
+  application may repeatedly call inflateSync, providing more input each time,
+  until success or end of the input data.
+*/
+
+ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm));
+/*
+     This function is equivalent to inflateEnd followed by inflateInit,
+   but does not free and reallocate all the internal decompression state.
+   The stream will keep attributes that may have been set by inflateInit2.
+
+      inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent (such as zalloc or state being NULL).
+*/
+
+
+                        /* utility functions */
+
+/*
+     The following utility functions are implemented on top of the
+   basic stream-oriented functions. To simplify the interface, some
+   default options are assumed (compression level and memory usage,
+   standard memory allocation functions). The source code of these
+   utility functions can easily be modified if you need special options.
+*/
+
+ZEXTERN int ZEXPORT compress OF((Bytef *dest,   uLongf *destLen,
+                                 const Bytef *source, uLong sourceLen));
+/*
+     Compresses the source buffer into the destination buffer.  sourceLen is
+   the byte length of the source buffer. Upon entry, destLen is the total
+   size of the destination buffer, which must be at least 0.1% larger than
+   sourceLen plus 12 bytes. Upon exit, destLen is the actual size of the
+   compressed buffer.
+     This function can be used to compress a whole file at once if the
+   input file is mmap'ed.
+     compress returns Z_OK if success, Z_MEM_ERROR if there was not
+   enough memory, Z_BUF_ERROR if there was not enough room in the output
+   buffer.
+*/
+
+ZEXTERN int ZEXPORT compress2 OF((Bytef *dest,   uLongf *destLen,
+                                  const Bytef *source, uLong sourceLen,
+                                  int level));
+/*
+     Compresses the source buffer into the destination buffer. The level
+   parameter has the same meaning as in deflateInit.  sourceLen is the byte
+   length of the source buffer. Upon entry, destLen is the total size of the
+   destination buffer, which must be at least 0.1% larger than sourceLen plus
+   12 bytes. Upon exit, destLen is the actual size of the compressed buffer.
+
+     compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_BUF_ERROR if there was not enough room in the output buffer,
+   Z_STREAM_ERROR if the level parameter is invalid.
+*/
+
+ZEXTERN int ZEXPORT uncompress OF((Bytef *dest,   uLongf *destLen,
+                                   const Bytef *source, uLong sourceLen));
+/*
+     Decompresses the source buffer into the destination buffer.  sourceLen is
+   the byte length of the source buffer. Upon entry, destLen is the total
+   size of the destination buffer, which must be large enough to hold the
+   entire uncompressed data. (The size of the uncompressed data must have
+   been saved previously by the compressor and transmitted to the decompressor
+   by some mechanism outside the scope of this compression library.)
+   Upon exit, destLen is the actual size of the compressed buffer.
+     This function can be used to decompress a whole file at once if the
+   input file is mmap'ed.
+
+     uncompress returns Z_OK if success, Z_MEM_ERROR if there was not
+   enough memory, Z_BUF_ERROR if there was not enough room in the output
+   buffer, or Z_DATA_ERROR if the input data was corrupted.
+*/
+
+
+typedef voidp gzFile;
+
+ZEXTERN gzFile ZEXPORT gzopen  OF((const char *path, const char *mode));
+/*
+     Opens a gzip (.gz) file for reading or writing. The mode parameter
+   is as in fopen ("rb" or "wb") but can also include a compression level
+   ("wb9") or a strategy: 'f' for filtered data as in "wb6f", 'h' for
+   Huffman only compression as in "wb1h". (See the description
+   of deflateInit2 for more information about the strategy parameter.)
+
+     gzopen can be used to read a file which is not in gzip format; in this
+   case gzread will directly read from the file without decompression.
+
+     gzopen returns NULL if the file could not be opened or if there was
+   insufficient memory to allocate the (de)compression state; errno
+   can be checked to distinguish the two cases (if errno is zero, the
+   zlib error is Z_MEM_ERROR).  */
+
+ZEXTERN gzFile ZEXPORT gzdopen  OF((int fd, const char *mode));
+/*
+     gzdopen() associates a gzFile with the file descriptor fd.  File
+   descriptors are obtained from calls like open, dup, creat, pipe or
+   fileno (in the file has been previously opened with fopen).
+   The mode parameter is as in gzopen.
+     The next call of gzclose on the returned gzFile will also close the
+   file descriptor fd, just like fclose(fdopen(fd), mode) closes the file
+   descriptor fd. If you want to keep fd open, use gzdopen(dup(fd), mode).
+     gzdopen returns NULL if there was insufficient memory to allocate
+   the (de)compression state.
+*/
+
+ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy));
+/*
+     Dynamically update the compression level or strategy. See the description
+   of deflateInit2 for the meaning of these parameters.
+     gzsetparams returns Z_OK if success, or Z_STREAM_ERROR if the file was not
+   opened for writing.
+*/
+
+ZEXTERN int ZEXPORT    gzread  OF((gzFile file, voidp buf, unsigned len));
+/*
+     Reads the given number of uncompressed bytes from the compressed file.
+   If the input file was not in gzip format, gzread copies the given number
+   of bytes into the buffer.
+     gzread returns the number of uncompressed bytes actually read (0 for
+   end of file, -1 for error). */
+
+ZEXTERN int ZEXPORT    gzwrite OF((gzFile file, 
+				   const voidp buf, unsigned len));
+/*
+     Writes the given number of uncompressed bytes into the compressed file.
+   gzwrite returns the number of uncompressed bytes actually written
+   (0 in case of error).
+*/
+
+ZEXTERN int ZEXPORTVA   gzprintf OF((gzFile file, const char *format, ...));
+/*
+     Converts, formats, and writes the args to the compressed file under
+   control of the format string, as in fprintf. gzprintf returns the number of
+   uncompressed bytes actually written (0 in case of error).
+*/
+
+ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s));
+/*
+      Writes the given null-terminated string to the compressed file, excluding
+   the terminating null character.
+      gzputs returns the number of characters written, or -1 in case of error.
+*/
+
+ZEXTERN char * ZEXPORT gzgets OF((gzFile file, char *buf, int len));
+/*
+      Reads bytes from the compressed file until len-1 characters are read, or
+   a newline character is read and transferred to buf, or an end-of-file
+   condition is encountered.  The string is then terminated with a null
+   character.
+      gzgets returns buf, or Z_NULL in case of error.
+*/
+
+ZEXTERN int ZEXPORT    gzputc OF((gzFile file, int c));
+/*
+      Writes c, converted to an unsigned char, into the compressed file.
+   gzputc returns the value that was written, or -1 in case of error.
+*/
+
+ZEXTERN int ZEXPORT    gzgetc OF((gzFile file));
+/*
+      Reads one byte from the compressed file. gzgetc returns this byte
+   or -1 in case of end of file or error.
+*/
+
+ZEXTERN int ZEXPORT    gzflush OF((gzFile file, int flush));
+/*
+     Flushes all pending output into the compressed file. The parameter
+   flush is as in the deflate() function. The return value is the zlib
+   error number (see function gzerror below). gzflush returns Z_OK if
+   the flush parameter is Z_FINISH and all output could be flushed.
+     gzflush should be called only when strictly necessary because it can
+   degrade compression.
+*/
+
+ZEXTERN z_off_t ZEXPORT    gzseek OF((gzFile file,
+				      z_off_t offset, int whence));
+/* 
+      Sets the starting position for the next gzread or gzwrite on the
+   given compressed file. The offset represents a number of bytes in the
+   uncompressed data stream. The whence parameter is defined as in lseek(2);
+   the value SEEK_END is not supported.
+     If the file is opened for reading, this function is emulated but can be
+   extremely slow. If the file is opened for writing, only forward seeks are
+   supported; gzseek then compresses a sequence of zeroes up to the new
+   starting position.
+
+      gzseek returns the resulting offset location as measured in bytes from
+   the beginning of the uncompressed stream, or -1 in case of error, in
+   particular if the file is opened for writing and the new starting position
+   would be before the current position.
+*/
+
+ZEXTERN int ZEXPORT    gzrewind OF((gzFile file));
+/*
+     Rewinds the given file. This function is supported only for reading.
+
+   gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET)
+*/
+
+ZEXTERN z_off_t ZEXPORT    gztell OF((gzFile file));
+/*
+     Returns the starting position for the next gzread or gzwrite on the
+   given compressed file. This position represents a number of bytes in the
+   uncompressed data stream.
+
+   gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR)
+*/
+
+ZEXTERN int ZEXPORT gzeof OF((gzFile file));
+/*
+     Returns 1 when EOF has previously been detected reading the given
+   input stream, otherwise zero.
+*/
+
+ZEXTERN int ZEXPORT    gzclose OF((gzFile file));
+/*
+     Flushes all pending output if necessary, closes the compressed file
+   and deallocates all the (de)compression state. The return value is the zlib
+   error number (see function gzerror below).
+*/
+
+ZEXTERN const char * ZEXPORT gzerror OF((gzFile file, int *errnum));
+/*
+     Returns the error message for the last error which occurred on the
+   given compressed file. errnum is set to zlib error number. If an
+   error occurred in the file system and not in the compression library,
+   errnum is set to Z_ERRNO and the application may consult errno
+   to get the exact error code.
+*/
+
+                        /* checksum functions */
+
+/*
+     These functions are not related to compression but are exported
+   anyway because they might be useful in applications using the
+   compression library.
+*/
+
+ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len));
+
+/*
+     Update a running Adler-32 checksum with the bytes buf[0..len-1] and
+   return the updated checksum. If buf is NULL, this function returns
+   the required initial value for the checksum.
+   An Adler-32 checksum is almost as reliable as a CRC32 but can be computed
+   much faster. Usage example:
+
+     uLong adler = adler32(0L, Z_NULL, 0);
+
+     while (read_buffer(buffer, length) != EOF) {
+       adler = adler32(adler, buffer, length);
+     }
+     if (adler != original_adler) error();
+*/
+
+ZEXTERN uLong ZEXPORT crc32   OF((uLong crc, const Bytef *buf, uInt len));
+/*
+     Update a running crc with the bytes buf[0..len-1] and return the updated
+   crc. If buf is NULL, this function returns the required initial value
+   for the crc. Pre- and post-conditioning (one's complement) is performed
+   within this function so it shouldn't be done by the application.
+   Usage example:
+
+     uLong crc = crc32(0L, Z_NULL, 0);
+
+     while (read_buffer(buffer, length) != EOF) {
+       crc = crc32(crc, buffer, length);
+     }
+     if (crc != original_crc) error();
+*/
+
+
+                        /* various hacks, don't look :) */
+
+/* deflateInit and inflateInit are macros to allow checking the zlib version
+ * and the compiler's view of z_stream:
+ */
+ZEXTERN int ZEXPORT deflateInit_ OF((z_streamp strm, int level,
+                                     const char *version, int stream_size));
+ZEXTERN int ZEXPORT inflateInit_ OF((z_streamp strm,
+                                     const char *version, int stream_size));
+ZEXTERN int ZEXPORT deflateInit2_ OF((z_streamp strm, int  level, int  method,
+                                      int windowBits, int memLevel,
+                                      int strategy, const char *version,
+                                      int stream_size));
+ZEXTERN int ZEXPORT inflateInit2_ OF((z_streamp strm, int  windowBits,
+                                      const char *version, int stream_size));
+#define deflateInit(strm, level) \
+        deflateInit_((strm), (level),       ZLIB_VERSION, sizeof(z_stream))
+#define inflateInit(strm) \
+        inflateInit_((strm),                ZLIB_VERSION, sizeof(z_stream))
+#define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
+        deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\
+                      (strategy),           ZLIB_VERSION, sizeof(z_stream))
+#define inflateInit2(strm, windowBits) \
+        inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream))
+
+
+#if !defined(_Z_UTIL_H) && !defined(NO_DUMMY_DECL)
+    struct internal_state {int dummy;}; /* hack for buggy compilers */
+#endif
+
+ZEXTERN const char   * ZEXPORT zError           OF((int err));
+ZEXTERN int            ZEXPORT inflateSyncPoint OF((z_streamp z));
+ZEXTERN const uLongf * ZEXPORT get_crc_table    OF((void));
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _ZLIB_H */
diff --git a/src/libz/src/zutil.c b/src/libz/src/zutil.c
new file mode 100644
index 0000000..f98749c
--- /dev/null
+++ b/src/libz/src/zutil.c
@@ -0,0 +1,225 @@
+/* zutil.c -- target dependent utility functions for the compression library
+ * Copyright (C) 1995-2002 Jean-loup Gailly.
+ * For conditions of distribution and use, see copyright notice in zlib.h 
+ */
+
+/* @(#) $Id: zutil.c,v 1.1 2008/11/12 02:25:24 agibert Exp $ */
+
+#include "zutil.h"
+
+struct internal_state      {int dummy;}; /* for buggy compilers */
+
+#ifndef STDC
+extern void exit OF((int));
+#endif
+
+const char *z_errmsg[10] = {
+"need dictionary",     /* Z_NEED_DICT       2  */
+"stream end",          /* Z_STREAM_END      1  */
+"",                    /* Z_OK              0  */
+"file error",          /* Z_ERRNO         (-1) */
+"stream error",        /* Z_STREAM_ERROR  (-2) */
+"data error",          /* Z_DATA_ERROR    (-3) */
+"insufficient memory", /* Z_MEM_ERROR     (-4) */
+"buffer error",        /* Z_BUF_ERROR     (-5) */
+"incompatible version",/* Z_VERSION_ERROR (-6) */
+""};
+
+
+const char * ZEXPORT zlibVersion()
+{
+    return ZLIB_VERSION;
+}
+
+#ifdef DEBUG
+
+#  ifndef verbose
+#    define verbose 0
+#  endif
+int z_verbose = verbose;
+
+void z_error (m)
+    char *m;
+{
+    fprintf(stderr, "%s\n", m);
+    exit(1);
+}
+#endif
+
+/* exported to allow conversion of error code to string for compress() and
+ * uncompress()
+ */
+const char * ZEXPORT zError(err)
+    int err;
+{
+    return ERR_MSG(err);
+}
+
+
+#ifndef HAVE_MEMCPY
+
+void zmemcpy(dest, source, len)
+    Bytef* dest;
+    const Bytef* source;
+    uInt  len;
+{
+    if (len == 0) return;
+    do {
+        *dest++ = *source++; /* ??? to be unrolled */
+    } while (--len != 0);
+}
+
+int zmemcmp(s1, s2, len)
+    const Bytef* s1;
+    const Bytef* s2;
+    uInt  len;
+{
+    uInt j;
+
+    for (j = 0; j < len; j++) {
+        if (s1[j] != s2[j]) return 2*(s1[j] > s2[j])-1;
+    }
+    return 0;
+}
+
+void zmemzero(dest, len)
+    Bytef* dest;
+    uInt  len;
+{
+    if (len == 0) return;
+    do {
+        *dest++ = 0;  /* ??? to be unrolled */
+    } while (--len != 0);
+}
+#endif
+
+#ifdef __TURBOC__
+#if (defined( __BORLANDC__) || !defined(SMALL_MEDIUM)) && !defined(__32BIT__)
+/* Small and medium model in Turbo C are for now limited to near allocation
+ * with reduced MAX_WBITS and MAX_MEM_LEVEL
+ */
+#  define MY_ZCALLOC
+
+/* Turbo C malloc() does not allow dynamic allocation of 64K bytes
+ * and farmalloc(64K) returns a pointer with an offset of 8, so we
+ * must fix the pointer. Warning: the pointer must be put back to its
+ * original form in order to free it, use zcfree().
+ */
+
+#define MAX_PTR 10
+/* 10*64K = 640K */
+
+local int next_ptr = 0;
+
+typedef struct ptr_table_s {
+    voidpf org_ptr;
+    voidpf new_ptr;
+} ptr_table;
+
+local ptr_table table[MAX_PTR];
+/* This table is used to remember the original form of pointers
+ * to large buffers (64K). Such pointers are normalized with a zero offset.
+ * Since MSDOS is not a preemptive multitasking OS, this table is not
+ * protected from concurrent access. This hack doesn't work anyway on
+ * a protected system like OS/2. Use Microsoft C instead.
+ */
+
+voidpf zcalloc (voidpf opaque, unsigned items, unsigned size)
+{
+    voidpf buf = opaque; /* just to make some compilers happy */
+    ulg bsize = (ulg)items*size;
+
+    /* If we allocate less than 65520 bytes, we assume that farmalloc
+     * will return a usable pointer which doesn't have to be normalized.
+     */
+    if (bsize < 65520L) {
+        buf = farmalloc(bsize);
+        if (*(ush*)&buf != 0) return buf;
+    } else {
+        buf = farmalloc(bsize + 16L);
+    }
+    if (buf == NULL || next_ptr >= MAX_PTR) return NULL;
+    table[next_ptr].org_ptr = buf;
+
+    /* Normalize the pointer to seg:0 */
+    *((ush*)&buf+1) += ((ush)((uch*)buf-0) + 15) >> 4;
+    *(ush*)&buf = 0;
+    table[next_ptr++].new_ptr = buf;
+    return buf;
+}
+
+void  zcfree (voidpf opaque, voidpf ptr)
+{
+    int n;
+    if (*(ush*)&ptr != 0) { /* object < 64K */
+        farfree(ptr);
+        return;
+    }
+    /* Find the original pointer */
+    for (n = 0; n < next_ptr; n++) {
+        if (ptr != table[n].new_ptr) continue;
+
+        farfree(table[n].org_ptr);
+        while (++n < next_ptr) {
+            table[n-1] = table[n];
+        }
+        next_ptr--;
+        return;
+    }
+    ptr = opaque; /* just to make some compilers happy */
+    Assert(0, "zcfree: ptr not found");
+}
+#endif
+#endif /* __TURBOC__ */
+
+
+#if defined(M_I86) && !defined(__32BIT__)
+/* Microsoft C in 16-bit mode */
+
+#  define MY_ZCALLOC
+
+#if (!defined(_MSC_VER) || (_MSC_VER <= 600))
+#  define _halloc  halloc
+#  define _hfree   hfree
+#endif
+
+voidpf zcalloc (voidpf opaque, unsigned items, unsigned size)
+{
+    if (opaque) opaque = 0; /* to make compiler happy */
+    return _halloc((long)items, size);
+}
+
+void  zcfree (voidpf opaque, voidpf ptr)
+{
+    if (opaque) opaque = 0; /* to make compiler happy */
+    _hfree(ptr);
+}
+
+#endif /* MSC */
+
+
+#ifndef MY_ZCALLOC /* Any system without a special alloc function */
+
+#ifndef STDC
+extern voidp  calloc OF((uInt items, uInt size));
+extern void   free   OF((voidpf ptr));
+#endif
+
+voidpf zcalloc (opaque, items, size)
+    voidpf opaque;
+    unsigned items;
+    unsigned size;
+{
+    if (opaque) items += size - size; /* make compiler happy */
+    return (voidpf)calloc(items, size);
+}
+
+void  zcfree (opaque, ptr)
+    voidpf opaque;
+    voidpf ptr;
+{
+    free(ptr);
+    if (opaque) return; /* make compiler happy */
+}
+
+#endif /* MY_ZCALLOC */
diff --git a/src/libz/src/zutil.h b/src/libz/src/zutil.h
new file mode 100644
index 0000000..7d30d2d
--- /dev/null
+++ b/src/libz/src/zutil.h
@@ -0,0 +1,220 @@
+/* zutil.h -- internal interface and configuration of the compression library
+ * Copyright (C) 1995-2002 Jean-loup Gailly.
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+   part of the implementation of the compression library and is
+   subject to change. Applications should only use zlib.h.
+ */
+
+/* @(#) $Id: zutil.h,v 1.1 2008/11/12 02:25:24 agibert Exp $ */
+
+#ifndef _Z_UTIL_H
+#define _Z_UTIL_H
+
+#include "zlib.h"
+
+#ifdef STDC
+#  include <stddef.h>
+#  include <string.h>
+#  include <stdlib.h>
+#endif
+#ifdef NO_ERRNO_H
+    extern int errno;
+#else
+#   include <errno.h>
+#endif
+
+#ifndef local
+#  define local static
+#endif
+/* compile with -Dlocal if your debugger can't find static symbols */
+
+typedef unsigned char  uch;
+typedef uch FAR uchf;
+typedef unsigned short ush;
+typedef ush FAR ushf;
+typedef unsigned long  ulg;
+
+extern const char *z_errmsg[10]; /* indexed by 2-zlib_error */
+/* (size given to avoid silly warnings with Visual C++) */
+
+#define ERR_MSG(err) z_errmsg[Z_NEED_DICT-(err)]
+
+#define ERR_RETURN(strm,err) \
+  return (strm->msg = (char*)ERR_MSG(err), (err))
+/* To be used only when the state is known to be valid */
+
+        /* common constants */
+
+#ifndef DEF_WBITS
+#  define DEF_WBITS MAX_WBITS
+#endif
+/* default windowBits for decompression. MAX_WBITS is for compression only */
+
+#if MAX_MEM_LEVEL >= 8
+#  define DEF_MEM_LEVEL 8
+#else
+#  define DEF_MEM_LEVEL  MAX_MEM_LEVEL
+#endif
+/* default memLevel */
+
+#define STORED_BLOCK 0
+#define STATIC_TREES 1
+#define DYN_TREES    2
+/* The three kinds of block type */
+
+#define MIN_MATCH  3
+#define MAX_MATCH  258
+/* The minimum and maximum match lengths */
+
+#define PRESET_DICT 0x20 /* preset dictionary flag in zlib header */
+
+        /* target dependencies */
+
+#ifdef MSDOS
+#  define OS_CODE  0x00
+#  if defined(__TURBOC__) || defined(__BORLANDC__)
+#    if(__STDC__ == 1) && (defined(__LARGE__) || defined(__COMPACT__))
+       /* Allow compilation with ANSI keywords only enabled */
+       void _Cdecl farfree( void *block );
+       void *_Cdecl farmalloc( unsigned long nbytes );
+#    else
+#     include <alloc.h>
+#    endif
+#  else /* MSC or DJGPP */
+#    include <malloc.h>
+#  endif
+#endif
+
+#ifdef OS2
+#  define OS_CODE  0x06
+#endif
+
+#ifdef WIN32 /* Window 95 & Windows NT */
+#  define OS_CODE  0x0b
+#endif
+
+#if defined(VAXC) || defined(VMS)
+#  define OS_CODE  0x02
+#  define F_OPEN(name, mode) \
+     fopen((name), (mode), "mbc=60", "ctx=stm", "rfm=fix", "mrs=512")
+#endif
+
+#ifdef AMIGA
+#  define OS_CODE  0x01
+#endif
+
+#if defined(ATARI) || defined(atarist)
+#  define OS_CODE  0x05
+#endif
+
+#if defined(MACOS) || defined(TARGET_OS_MAC)
+#  define OS_CODE  0x07
+#  if defined(__MWERKS__) && __dest_os != __be_os && __dest_os != __win32_os
+#    include <unix.h> /* for fdopen */
+#  else
+#    ifndef fdopen
+#      define fdopen(fd,mode) NULL /* No fdopen() */
+#    endif
+#  endif
+#endif
+
+#ifdef __50SERIES /* Prime/PRIMOS */
+#  define OS_CODE  0x0F
+#endif
+
+#ifdef TOPS20
+#  define OS_CODE  0x0a
+#endif
+
+#if defined(_BEOS_) || defined(RISCOS)
+#  define fdopen(fd,mode) NULL /* No fdopen() */
+#endif
+
+#if (defined(_MSC_VER) && (_MSC_VER > 600))
+#  define fdopen(fd,type)  _fdopen(fd,type)
+#endif
+
+
+        /* Common defaults */
+
+#ifndef OS_CODE
+#  define OS_CODE  0x03  /* assume Unix */
+#endif
+
+#ifndef F_OPEN
+#  define F_OPEN(name, mode) fopen((name), (mode))
+#endif
+
+         /* functions */
+
+#ifdef HAVE_STRERROR
+   extern char *strerror OF((int));
+#  define zstrerror(errnum) strerror(errnum)
+#else
+#  define zstrerror(errnum) ""
+#endif
+
+#if defined(pyr)
+#  define NO_MEMCPY
+#endif
+#if defined(SMALL_MEDIUM) && !defined(_MSC_VER) && !defined(__SC__)
+ /* Use our own functions for small and medium model with MSC <= 5.0.
+  * You may have to use the same strategy for Borland C (untested).
+  * The __SC__ check is for Symantec.
+  */
+#  define NO_MEMCPY
+#endif
+#if defined(STDC) && !defined(HAVE_MEMCPY) && !defined(NO_MEMCPY)
+#  define HAVE_MEMCPY
+#endif
+#ifdef HAVE_MEMCPY
+#  ifdef SMALL_MEDIUM /* MSDOS small or medium model */
+#    define zmemcpy _fmemcpy
+#    define zmemcmp _fmemcmp
+#    define zmemzero(dest, len) _fmemset(dest, 0, len)
+#  else
+#    define zmemcpy memcpy
+#    define zmemcmp memcmp
+#    define zmemzero(dest, len) memset(dest, 0, len)
+#  endif
+#else
+   extern void zmemcpy  OF((Bytef* dest, const Bytef* source, uInt len));
+   extern int  zmemcmp  OF((const Bytef* s1, const Bytef* s2, uInt len));
+   extern void zmemzero OF((Bytef* dest, uInt len));
+#endif
+
+/* Diagnostic functions */
+#ifdef DEBUG
+#  include <stdio.h>
+   extern int z_verbose;
+   extern void z_error    OF((char *m));
+#  define Assert(cond,msg) {if(!(cond)) z_error(msg);}
+#  define Trace(x) {if (z_verbose>=0) fprintf x ;}
+#  define Tracev(x) {if (z_verbose>0) fprintf x ;}
+#  define Tracevv(x) {if (z_verbose>1) fprintf x ;}
+#  define Tracec(c,x) {if (z_verbose>0 && (c)) fprintf x ;}
+#  define Tracecv(c,x) {if (z_verbose>1 && (c)) fprintf x ;}
+#else
+#  define Assert(cond,msg)
+#  define Trace(x)
+#  define Tracev(x)
+#  define Tracevv(x)
+#  define Tracec(c,x)
+#  define Tracecv(c,x)
+#endif
+
+
+typedef uLong (ZEXPORT *check_func) OF((uLong check, const Bytef *buf,
+				       uInt len));
+voidpf zcalloc OF((voidpf opaque, unsigned items, unsigned size));
+void   zcfree  OF((voidpf opaque, voidpf ptr));
+
+#define ZALLOC(strm, items, size) \
+           (*((strm)->zalloc))((strm)->opaque, (items), (size))
+#define ZFREE(strm, addr)  (*((strm)->zfree))((strm)->opaque, (voidpf)(addr))
+#define TRY_FREE(s, p) {if (p) ZFREE(s, p);}
+
+#endif /* _Z_UTIL_H */
diff --git a/src/sd_appl_struct/src/Makefile b/src/sd_appl_struct/src/Makefile
new file mode 100644
index 0000000..bc25763
--- /dev/null
+++ b/src/sd_appl_struct/src/Makefile
@@ -0,0 +1,65 @@
+#------------------------------------------------------------------------------
+# Local Makefile
+#------------------------------------------------------------------------------
+# $Workfile:   Makefile  $                                                     
+#------------------------------------------------------------------------------
+# $Author: agibert $                                                        
+# $Date: 2008/11/12 02:25:24 $                                             
+# $Revision: 1.1 $                                                         
+# $Label:  $                                                           
+#------------------------------------------------------------------------------
+
+#------------------------------------------------------------------------------
+# IMR - Interlinking Message Router                                            
+# Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)                
+# mailto:arnaud@rx3.net                                                        
+# http://www.rx3.org/dvp/?dvp=imr                                              
+#------------------------------------------------------------------------------
+# This file is part of IMR                                                     
+#                                                                              
+# This program is free software; you can redistribute it and/or                
+# modify it under the terms of the GNU General Public License                  
+# as published by the Free Software Foundation; either version 2               
+# of the License, or (at your option) any later version.                       
+#                                                                              
+# This program is distributed in the hope that it will be useful,              
+# but WITHOUT ANY WARRANTY; without even the implied warranty of               
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                
+# GNU General Public License for more details.                                 
+#                                                                              
+# You should have received a copy of the GNU General Public License            
+# along with this program; if not, write to the Free Software Foundation,      
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.          
+#------------------------------------------------------------------------------
+
+
+
+
+
+#------------------------------------------------------------------------------
+# Var include
+#------------------------------------------------------------------------------
+
+include ../../Makefile_var.mk
+
+
+
+#------------------------------------------------------------------------------
+# Variables
+#------------------------------------------------------------------------------
+
+TARGET=		sd_appl_struct.xml
+
+OBJ_RAW=	sd_appl_struct.xml.m4
+
+EXTRA_INC=	
+
+EXTRA_LIB=	
+
+
+
+#------------------------------------------------------------------------------
+# Rule include
+#------------------------------------------------------------------------------
+
+include ../../Makefile_rule.mk
diff --git a/src/sd_appl_struct/src/appl_commun.xml.m4 b/src/sd_appl_struct/src/appl_commun.xml.m4
new file mode 100644
index 0000000..e8fc6f5
--- /dev/null
+++ b/src/sd_appl_struct/src/appl_commun.xml.m4
@@ -0,0 +1,58 @@
+changecom(`<!--', `-->')dnl
+dnl
+dnl+---------------------------------------------------------------------------+
+dnl|    Begin header_appl Macro                                                |
+dnl+---------------------------------------------------------------------------+
+dnl
+define(`header_appl',
+`<?xml version="1.0" ?>
+`<!-- Appl Struct definitions -->'
+`<appl_struct>'')
+dnl
+dnl+---------------------------------------------------------------------------+
+dnl|     End header_appl Macro                                                 |
+dnl+---------------------------------------------------------------------------+
+dnl
+dnl
+dnl+---------------------------------------------------------------------------+
+dnl|    Begin footer_appl Macro                                                |
+dnl+---------------------------------------------------------------------------+
+dnl
+define(`footer_appl',
+`<!-- Appl Struct definitions footer -->
+`</appl_struct>'')
+dnl
+dnl+---------------------------------------------------------------------------+
+dnl|     End footer_appl Macro                                                 |
+dnl+---------------------------------------------------------------------------+
+dnl
+dnl
+dnl+---------------------------------------------------------------------------+
+dnl|    Begin insert_version Macro                                             |
+dnl|                                                                           |
+dnl| $1 : la chaine VERSION                                                    |
+dnl+---------------------------------------------------------------------------+
+dnl
+define(`insert_version',
+`<version>$1</version>')
+dnl
+dnl+----------------------------------------------------------------------------+
+dnl|     End insert_version Macro                                               |
+dnl+----------------------------------------------------------------------------+
+dnl
+dnl
+dnl+---------------------------------------------------------------------------+
+dnl|    Begin appli Macro                                                      |
+dnl|                                                                           |
+dnl| $1 : Appli Name                                                           |
+dnl+---------------------------------------------------------------------------+
+dnl
+define(`appli_object',
+`	<appli>
+`		<name>$1</name>'
+`	</appli>'')
+dnl
+dnl+---------------------------------------------------------------------------+
+dnl|     End appli Macro                                                       |
+dnl+---------------------------------------------------------------------------+
+dnl
diff --git a/src/sd_appl_struct/src/sd_appl_struct.xml.m4 b/src/sd_appl_struct/src/sd_appl_struct.xml.m4
new file mode 100644
index 0000000..6cbd610
--- /dev/null
+++ b/src/sd_appl_struct/src/sd_appl_struct.xml.m4
@@ -0,0 +1,20 @@
+dnl
+divert(-1)
+include(`appl_commun.xml.m4')
+divert(0)dnl
+dnl
+changecom(`<!--', `-->')dnl
+dnl
+dnl
+header_appl()
+insert_version(@(#) VERSIONIMR: $Label:  $   $Date: 2008/11/12 02:25:24 $   $Workfile:   sd_appl_struct.xml.m4  $)
+appli_object(unknown)
+appli_object(cristal_fml)
+appli_object(bo_fml)
+appli_object(bo_raw)
+appli_object(cristal_raw)
+appli_object(fml)
+appli_object(raw)
+appli_object(bo.trunc_fml)
+appli_object(bo.trunc_raw)
+footer_appl()
diff --git a/src/sd_cnv_struct/src/Makefile b/src/sd_cnv_struct/src/Makefile
new file mode 100644
index 0000000..a245a39
--- /dev/null
+++ b/src/sd_cnv_struct/src/Makefile
@@ -0,0 +1,65 @@
+#------------------------------------------------------------------------------
+# Local Makefile
+#------------------------------------------------------------------------------
+# $Workfile:   Makefile  $                                                     
+#------------------------------------------------------------------------------
+# $Author: agibert $                                                        
+# $Date: 2008/11/12 02:25:24 $                                             
+# $Revision: 1.1 $                                                         
+# $Label:  $                                                           
+#------------------------------------------------------------------------------
+
+#------------------------------------------------------------------------------
+# IMR - Interlinking Message Router                                            
+# Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)                
+# mailto:arnaud@rx3.net                                                        
+# http://www.rx3.org/dvp/?dvp=imr                                              
+#------------------------------------------------------------------------------
+# This file is part of IMR                                                     
+#                                                                              
+# This program is free software; you can redistribute it and/or                
+# modify it under the terms of the GNU General Public License                  
+# as published by the Free Software Foundation; either version 2               
+# of the License, or (at your option) any later version.                       
+#                                                                              
+# This program is distributed in the hope that it will be useful,              
+# but WITHOUT ANY WARRANTY; without even the implied warranty of               
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                
+# GNU General Public License for more details.                                 
+#                                                                              
+# You should have received a copy of the GNU General Public License            
+# along with this program; if not, write to the Free Software Foundation,      
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.          
+#------------------------------------------------------------------------------
+
+
+
+
+
+#------------------------------------------------------------------------------
+# Var include
+#------------------------------------------------------------------------------
+
+include ../../Makefile_var.mk
+
+
+
+#------------------------------------------------------------------------------
+# Variables
+#------------------------------------------------------------------------------
+
+TARGET=		sd_cnv_struct.xml
+
+OBJ_RAW=	sd_cnv_struct.xml.m4
+
+EXTRA_INC=	
+
+EXTRA_LIB=	
+
+
+
+#------------------------------------------------------------------------------
+# Rule include
+#------------------------------------------------------------------------------
+
+include ../../Makefile_rule.mk
diff --git a/src/sd_cnv_struct/src/cnv_commun.xml.m4 b/src/sd_cnv_struct/src/cnv_commun.xml.m4
new file mode 100644
index 0000000..ce37944
--- /dev/null
+++ b/src/sd_cnv_struct/src/cnv_commun.xml.m4
@@ -0,0 +1,58 @@
+changecom(`<!--', `-->')dnl
+dnl
+dnl+---------------------------------------------------------------------------+
+dnl|    Begin header_cnv Macro                                                 |
+dnl+---------------------------------------------------------------------------+
+dnl
+define(`header_cnv',
+`<?xml version="1.0" ?>
+`<!-- Cnv Struct definitions -->'
+`<cnv_struct>'')
+dnl
+dnl+---------------------------------------------------------------------------+
+dnl|     End header_cnv Macro                                                  |
+dnl+---------------------------------------------------------------------------+
+dnl
+dnl
+dnl+---------------------------------------------------------------------------+
+dnl|    Begin footer_cnv Macro                                                 |
+dnl+---------------------------------------------------------------------------+
+dnl
+define(`footer_cnv',
+`<!-- Cnv Struct definitions footer -->
+`</cnv_struct>'')
+dnl
+dnl+---------------------------------------------------------------------------+
+dnl|     End footer_cnv Macro                                                  |
+dnl+---------------------------------------------------------------------------+
+dnl
+dnl
+dnl+---------------------------------------------------------------------------+
+dnl|    Begin insert_version Macro                                             |
+dnl|                                                                           |
+dnl| $1 : la chaine VERSION                                                    |
+dnl+---------------------------------------------------------------------------+
+dnl
+define(`insert_version',
+`<version>$1</version>')
+dnl
+dnl+----------------------------------------------------------------------------+
+dnl|     End insert_version Macro                                               |
+dnl+----------------------------------------------------------------------------+
+dnl
+dnl
+dnl+---------------------------------------------------------------------------+
+dnl|    Begin convert_fct Macro                                                |
+dnl|                                                                           |
+dnl| $1 : Convert Function Name                                                |
+dnl+---------------------------------------------------------------------------+
+dnl
+define(`convert_fct',
+`	<cnv>
+`		<name>$1</name>'
+`	</cnv>'')
+dnl
+dnl+---------------------------------------------------------------------------+
+dnl|     End convert_fct Macro                                                       |
+dnl+---------------------------------------------------------------------------+
+dnl
diff --git a/src/sd_cnv_struct/src/sd_cnv_struct.xml.m4 b/src/sd_cnv_struct/src/sd_cnv_struct.xml.m4
new file mode 100644
index 0000000..571e4c7
--- /dev/null
+++ b/src/sd_cnv_struct/src/sd_cnv_struct.xml.m4
@@ -0,0 +1,19 @@
+dnl
+divert(-1)
+include(`cnv_commun.xml.m4')
+divert(0)dnl
+dnl
+changecom(`<!--', `-->')dnl
+dnl
+dnl
+header_cnv()
+insert_version(@(#) VERSIONIMR: $Label:  $   $Date: 2008/11/12 02:25:24 $   $Workfile:   sd_cnv_struct.xml.m4  $)
+convert_fct(Unknown)
+convert_fct(Pad_Right)
+convert_fct(Pad_Left)
+convert_fct(Strip_Right)
+convert_fct(Strip_Left)
+convert_fct(Strip_Num)
+convert_fct(Pad_Num)
+convert_fct(Cut_Right)
+footer_cnv()
diff --git a/src/sd_fmt_struct/src/Makefile b/src/sd_fmt_struct/src/Makefile
new file mode 100644
index 0000000..c82d2f6
--- /dev/null
+++ b/src/sd_fmt_struct/src/Makefile
@@ -0,0 +1,65 @@
+#------------------------------------------------------------------------------
+# Local Makefile
+#------------------------------------------------------------------------------
+# $Workfile:   Makefile  $                                                     
+#------------------------------------------------------------------------------
+# $Author: agibert $                                                        
+# $Date: 2008/11/12 02:25:24 $                                             
+# $Revision: 1.1 $                                                         
+# $Label:  $                                                           
+#------------------------------------------------------------------------------
+
+#------------------------------------------------------------------------------
+# IMR - Interlinking Message Router                                            
+# Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)                
+# mailto:arnaud@rx3.net                                                        
+# http://www.rx3.org/dvp/?dvp=imr                                              
+#------------------------------------------------------------------------------
+# This file is part of IMR                                                     
+#                                                                              
+# This program is free software; you can redistribute it and/or                
+# modify it under the terms of the GNU General Public License                  
+# as published by the Free Software Foundation; either version 2               
+# of the License, or (at your option) any later version.                       
+#                                                                              
+# This program is distributed in the hope that it will be useful,              
+# but WITHOUT ANY WARRANTY; without even the implied warranty of               
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                
+# GNU General Public License for more details.                                 
+#                                                                              
+# You should have received a copy of the GNU General Public License            
+# along with this program; if not, write to the Free Software Foundation,      
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.          
+#------------------------------------------------------------------------------
+
+
+
+
+
+#------------------------------------------------------------------------------
+# Var include
+#------------------------------------------------------------------------------
+
+include ../../Makefile_var.mk
+
+
+
+#------------------------------------------------------------------------------
+# Variables
+#------------------------------------------------------------------------------
+
+TARGET=		sd_fmt_struct.xml
+
+OBJ_RAW=	sd_fmt_struct.xml.m4
+
+EXTRA_INC=	
+
+EXTRA_LIB=	
+
+
+
+#------------------------------------------------------------------------------
+# Rule include
+#------------------------------------------------------------------------------
+
+include ../../Makefile_rule.mk
diff --git a/src/sd_fmt_struct/src/fmt_commun.xml.m4 b/src/sd_fmt_struct/src/fmt_commun.xml.m4
new file mode 100644
index 0000000..b2cae17
--- /dev/null
+++ b/src/sd_fmt_struct/src/fmt_commun.xml.m4
@@ -0,0 +1,142 @@
+changecom(`<!--', `-->')dnl
+dnl
+dnl+---------------------------------------------------------------------------+
+dnl|    Begin header_fmt Macro                                                 |
+dnl+---------------------------------------------------------------------------+
+dnl
+define(`header_fmt',
+`<?xml version="1.0" ?>
+`<!-- Fmt Struct definitions -->'
+`<fmt_struct>'')
+dnl
+dnl+---------------------------------------------------------------------------+
+dnl|     End header_fmt Macro                                                  |
+dnl+---------------------------------------------------------------------------+
+dnl
+dnl
+dnl+---------------------------------------------------------------------------+
+dnl|    Begin footer_fmt Macro                                                 |
+dnl+---------------------------------------------------------------------------+
+dnl
+define(`footer_fmt',
+`<!-- Fmt Struct definitions footer -->
+`</fmt_struct>'')
+dnl
+dnl+---------------------------------------------------------------------------+
+dnl|     End footer_fmt Macro                                                  |
+dnl+---------------------------------------------------------------------------+
+dnl
+dnl
+dnl+---------------------------------------------------------------------------+
+dnl|    Begin insert_version Macro                                             |
+dnl|                                                                           |
+dnl| $1 : la chaine VERSION                                                    |
+dnl+---------------------------------------------------------------------------+
+dnl
+define(`insert_version',
+`<version>$1</version>')
+dnl
+dnl+----------------------------------------------------------------------------+
+dnl|     End insert_version Macro                                               |
+dnl+----------------------------------------------------------------------------+
+dnl
+dnl
+dnl+---------------------------------------------------------------------------+
+dnl|    Begin fmtmsg_object Macro                                              |
+dnl|                                                                           |
+dnl| $1 : Message Name                                                         |
+dnl| $2 : branche_id                                                           |
+dnl| $3 : fmtattr_name                                                         |
+dnl+---------------------------------------------------------------------------+
+dnl
+define(`fmtmsg_object',
+`		<fmtmsg>
+`			<name>$1</name>'
+`			<branche_id>$2</branche_id>'
+ifelse($3,,`dnl',`			<fmtattr_name>$3</fmtattr_name>')
+`		</fmtmsg>'')
+dnl
+dnl+----------------------------------------------------------------------------+
+dnl|     End fmtmsg_object Macro                                                |
+dnl+----------------------------------------------------------------------------+
+dnl
+dnl
+dnl+---------------------------------------------------------------------------+
+dnl|    Begin list_fmtmsg_object Macro        Arg. variadique                  |
+dnl|                                                                           |
+dnl| $1 : Message Name                                                         |
+dnl| $2 : branche_id                                                           |
+dnl| $3 : fmtattr_name                                                         |
+dnl+---------------------------------------------------------------------------+
+dnl
+define(`list_fmtmsg_object',
+`ifelse($#,1,`dnl',`fmtmsg_object($1,$2,$3)'
+`list_fmtmsg_object(shift(shift(shift($@))))')')
+dnl
+dnl+----------------------------------------------------------------------------+
+dnl|     End list_fmtmsg_object Macro                                           |
+dnl+----------------------------------------------------------------------------+
+dnl
+dnl
+dnl+---------------------------------------------------------------------------+
+dnl|    Begin format_object Macro             Arg. variadique                  |
+dnl|                                                                           |
+dnl| $1 : Format Name                                                          |
+dnl+---------------------------------------------------------------------------+
+dnl
+define(`format_object',
+`	<format>
+`		<name>$1</name>'
+list_fmtmsg_object(shift($@))
+`	</format>'')
+dnl
+dnl+---------------------------------------------------------------------------+
+dnl|     End format_object Macro                                               |
+dnl+---------------------------------------------------------------------------+
+dnl
+dnl
+dnl+---------------------------------------------------------------------------+
+dnl|     Begin branch definition                                               |
+dnl+---------------------------------------------------------------------------+
+dnl
+define(`branchFluxVersCrt',`2')
+define(`branchFluxDeCrt',`3')
+define(`branchFluxDeCreSurFluxEmis',`4')
+define(`branchFluxDeCreSurFluxRecus',`5')
+define(`branchFluxDeCreRejet',`6')
+define(`branch13CStlm',`7')
+define(`branch13CStlmBank',`8')
+define(`branch13C55StlmCus',`9')
+define(`branchVirtDeBo',`10')
+define(`branchFld50',`11')
+define(`branchFld52',`12')
+define(`branchFld55',`13')
+define(`branchFld56',`14')
+define(`branchFld57',`15')
+define(`branchFld58',`16')
+define(`branchFld59',`17')
+define(`branchFld50Cre',`21')
+define(`branchFld52Cre',`22')
+define(`branchFld55Cre',`23')
+define(`branchFld56Cre',`24')
+define(`branchFld57Cre',`25')
+define(`branchFld58Cre',`26')
+define(`branchFld59Cre',`27')
+define(`branchCreIdent',`30')
+define(`branch13CStlmCre',`37')
+define(`branch13C55StlmCusCre',`39')
+define(`branchDltdIdent',`50')
+define(`branch13CIdentCre',`500')
+define(`branch13COcc6Cre',`501')
+define(`branch13COcc5Cre',`502')
+define(`branch13COcc4Cre',`503')
+define(`branch13COcc3Cre',`504')
+define(`branch13COcc2Cre',`505')
+define(`branch13COcc1Cre',`506')
+define(`branchHeaderCre',`888')
+define(`branchIdentBreak',`999')
+dnl
+dnl+---------------------------------------------------------------------------+
+dnl|     End branch definition                                                 |
+dnl+---------------------------------------------------------------------------+
+dnl
diff --git a/src/sd_fmt_struct/src/sd_fmt_struct.xml.m4 b/src/sd_fmt_struct/src/sd_fmt_struct.xml.m4
new file mode 100644
index 0000000..93cad49
--- /dev/null
+++ b/src/sd_fmt_struct/src/sd_fmt_struct.xml.m4
@@ -0,0 +1,534 @@
+dnl
+divert(-1)
+include(`fmt_commun.xml.m4')
+divert(0)dnl
+dnl
+changecom(`<!--', `-->')dnl
+dnl
+dnl
+header_fmt()
+insert_version(@(#) VERSIONIMR: $Label:  $   $Date: 2008/11/12 02:25:24 $   $Workfile:   sd_fmt_struct.xml.m4  $)
+changecom(`<', `>')dnl
+format_object(Unknown,
+              msg_fixed_fml, branchIdentBreak, )
+ifdef(`TUX_SUPPORT', `format_object(FML,
+              msg_fixed_fml, branchIdentBreak, )')
+changecom(`<!--', `-->')dnl
+<!-- branche BB2 messages d'identification des flux destines a cristal -->
+<!-- branche BB3 messages d'identification des cre en provenance de cristal -->
+<!-- branche BB4 messages d'identification des flux pour cre sur flux emis -->
+<!-- branche BB5 messages d'identification des flux pour cre sur flux recus -->
+<!-- branche BB6 messages d'identification des flux pour cre de rejet -->
+<!-- branche BB8 messages d'identification des virements bancaires -->
+<!-- branche BB9 messages d'identification des virements de clientele -->
+<!-- branche BB11 messages d'identification du format du champ 50 -->
+<!-- branche BB12 messages d'identification du format du champ 52 -->
+<!-- branche BB13 messages d'identification du format du champ 55 -->
+<!-- branche BB14 messages d'identification du format du champ 56 -->
+<!-- branche BB15 messages d'identification du format du champ 57 -->
+<!-- branche BB16 messages d'identification du format du champ 58 -->
+<!-- branche BB17 messages d'identification du format du champ 59 -->
+<!-- Les branches suivantes sont reserves aux cre -->
+<!-- branche BB18 messages d'identification des virements bancaires -->
+<!-- branche BB19 messages d'identification des virements de clientele -->
+<!-- branche BB21 messages d'identification du format du champ 50 -->
+<!-- branche BB22 messages d'identification du format du champ 52 -->
+<!-- branche BB23 messages d'identification du format du champ 55 -->
+<!-- branche BB24 messages d'identification du format du champ 56 -->
+<!-- branche BB25 messages d'identification du format du champ 57 -->
+<!-- branche BB26 messages d'identification du format du champ 58 -->
+<!-- branche BB27 messages d'identification du format du champ 59 -->
+<!-- branche BB2 messages d'identification des flux destines a cristal -->
+<!-- branche BB3 messages d'identification des cre en provenance de cristal -->
+<!-- branche BB4 messages d'identification des flux pour cre sur flux emis -->
+<!-- branche BB5 messages d'identification des flux pour cre sur flux recus -->
+<!-- branche BB6 messages d'identification des flux pour cre de rejet -->
+<!-- message des cre -->
+<!-- flux destines a cristal -->
+<!-- branche BB8 messages d'identification des virements avec bloc 13C -->
+<!-- branche BB9 messages d'identification des virements de clientele avec bloc 55 -->
+<!-- branche BB11 messages d'identification du format du champ 50 -->
+<!-- branche BB12 messages d'identification du format du champ 52 -->
+<!-- branche BB13 messages d'identification du format du champ 55 -->
+<!-- branche BB14 messages d'identification du format du champ 56 -->
+<!-- branche BB15 messages d'identification du format du champ 57 -->
+<!-- branche BB16 messages d'identification du format du champ 58 -->
+<!-- branche BB17 messages d'identification du format du champ 59 -->
+<!-- messages de mapping des champ 70 72 et 77 -->
+<!-- debut des modifications -->		
+<!-- branche BB18 messages d'identification des virements avec bloc 13C -->
+<!--  DEBUT Traitement du bloc 13C -->
+<!--  FIN Traitement du bloc 13C -->
+<!-- branche BB19 messages d'identification des virements de clientele avec bloc 55 -->
+<!-- branche BB21 messages d'identification du format du champ 50 -->
+<!-- branche BB22 messages d'identification du format du champ 52 -->
+<!-- branche BB23 messages d'identification du format du champ 55 -->
+<!-- branche BB24 messages d'identification du format du champ 56 -->
+<!-- branche BB25 messages d'identification du format du champ 57 -->
+<!-- branche BB26 messages d'identification du format du champ 58 -->
+<!-- branche BB27 messages d'identification du format du champ 59 -->
+<!-- messages de mapping des champ 70 72 et 77 -->
+<!-- branche BB30 messages d'identification des flux pour cre  -->
+<!-- fin des modifications -->		
+changecom(`<', `>')dnl
+format_object(XML,
+              swf_cre_field_occ13x, branchIdentBreak, ,
+              crt_flux_ident, branchFluxVersCrt, ,
+              crt_flux_vs02, branchFluxVersCrt, ,
+              crt_flux_vs07, branchFluxVersCrt, ,
+              crt_flux_vs08, branchFluxVersCrt, ,
+              crt_flux_os01, branchFluxVersCrt, ,
+              crt_flux_vs03, branchFluxVersCrt, ,
+              crt_flux_vs04, branchFluxVersCrt, ,
+              crt_cre_ident, branchFluxDeCrt, ,
+              crt_cre_cr01, branchFluxDeCrt, ,
+              crt_cre_cr02, branchFluxDeCrt, ,
+              crt_cre_cr03, branchFluxDeCrt, ,
+              crt_cre_cr04, branchFluxDeCrt, ,
+              crt_cre_cr05, branchFluxDeCrt, ,
+              crt_cre_cr06, branchFluxDeCrt, ,
+              crt_cre_cr07, branchFluxDeCrt, ,
+              crt_cre_cr08, branchFluxDeCrt, ,
+              crt_cre_cr09, branchFluxDeCrt, ,
+              crt_cre_cr10, branchFluxDeCrt, ,
+              crt_cre_cr11, branchFluxDeCrt, ,
+              crt_cre_cr12, branchFluxDeCrt, ,
+              crt_cre_cr13, branchFluxDeCrt, ,
+              crt_cre_cr14, branchFluxDeCrt, ,
+              crt_cre_cr15, branchFluxDeCrt, ,
+              crt_cre_cr16, branchFluxDeCrt, ,
+              crt_cre_cr17, branchFluxDeCrt, ,
+              crt_cre_cr18, branchFluxDeCrt, ,
+              crt_cre_cr20, branchFluxDeCrt, ,
+              crt_cre_cr21, branchFluxDeCrt, ,
+              crt_cre_cr22, branchFluxDeCrt, ,
+              crt_cre_cr23, branchFluxDeCrt, ,
+              crt_cre_cr24, branchFluxDeCrt, ,
+              crt_cre_cr25, branchFluxDeCrt, ,
+              crt_cre_cr30, branchFluxDeCrt, ,
+              crt_cre_cr31, branchFluxDeCrt, ,
+              crt_cre_cr40, branchFluxDeCrt, ,
+              crt_cre_cr41, branchFluxDeCrt, ,
+              crt_cre_cr42, branchFluxDeCrt, ,
+              crt_cre_cr44, branchFluxDeCrt, ,
+              crt_cre_cr45, branchFluxDeCrt, ,
+              crt_cre_cr50, branchFluxDeCrt, ,
+              crt_cre_emis_ident, branchFluxDeCreSurFluxEmis, ,
+              crt_cre_emis_vs02, branchFluxDeCreSurFluxEmis, ,
+              crt_cre_emis_vs07, branchFluxDeCreSurFluxEmis, ,
+              crt_cre_emis_vs08, branchFluxDeCreSurFluxEmis, ,
+              crt_cre_emis_os01, branchFluxDeCreSurFluxEmis, ,
+              crt_cre_emis_vs03, branchFluxDeCreSurFluxEmis, ,
+              crt_cre_emis_vs04, branchFluxDeCreSurFluxEmis, ,
+              crt_cre_recu_ident, branchFluxDeCreSurFluxRecus, ,
+              crt_cre_recu_vs02, branchFluxDeCreSurFluxRecus, ,
+              crt_cre_recu_vs07, branchFluxDeCreSurFluxRecus, ,
+              crt_cre_recu_vs08, branchFluxDeCreSurFluxRecus, ,
+              crt_cre_recu_os01, branchFluxDeCreSurFluxRecus, ,
+              crt_cre_recu_vs03, branchFluxDeCreSurFluxRecus, ,
+              crt_cre_recu_vs04, branchFluxDeCreSurFluxRecus, ,
+              crt_cre_rejet_ident, branchFluxDeCreRejet, ,
+              crt_cre_rejet_vs02, branchFluxDeCreRejet, ,
+              crt_cre_rejet_vs07, branchFluxDeCreRejet, ,
+              crt_cre_rejet_vs08, branchFluxDeCreRejet, ,
+              crt_cre_rejet_os01, branchFluxDeCreRejet, ,
+              crt_cre_rejet_vs03, branchFluxDeCreRejet, ,
+              crt_cre_rejet_vs04, branchFluxDeCreRejet, ,
+              crt_cre_header, branchHeaderCre, ,
+              crt_cre_flux_emis_header, branchHeaderCre, ,
+              crt_cre_flux_recu_header, branchHeaderCre, ,
+              crt_cre_rejet_header, branchHeaderCre, ,
+              crt_flux_header, branchIdentBreak, ,
+              crt_flux_or_header, branchIdentBreak, ,
+              crt_flux_or, branchIdentBreak, ,
+              crt_flux_stlm_header, branchIdentBreak, ,
+              crt_flux_stlm_bk, branchIdentBreak, ,
+              crt_flux_stlm_cus, branchIdentBreak, ,
+              crt_flux_stlm_cus_end, branchIdentBreak, ,
+              swf_field_13c, branchIdentBreak, ,
+              crt_flux_stlm_sans13c, branch13CStlm, ,
+              crt_flux_stlm_avec13c, branch13CStlm, ,
+              crt_flux_stlm_cus_sans55, branch13C55StlmCus, ,
+              crt_flux_stlm_cus_avec55, branch13C55StlmCus, ,
+              swf_field_50x, branchFld50, ,
+              swf_field_50k_fmt, branchFld50, ,
+              swf_field_50a_fmt, branchFld50, ,
+              swf_field_50k_comp, branchIdentBreak, ,
+              swf_field_52x, branchFld52, ,
+              swf_field_52d_fmt, branchFld52, ,
+              swf_field_52a_fmt, branchFld52, ,
+              swf_field_52d_comp, branchIdentBreak, ,
+              swf_field_55x, branchFld55, ,
+              swf_field_55d_fmt, branchFld55, ,
+              swf_field_55a_fmt, branchFld55, ,
+              swf_field_55b_fmt, branchFld55, ,
+              swf_field_55d_comp, branchIdentBreak, ,
+              swf_field_56x, branchFld56, ,
+              swf_field_56d_fmt, branchFld56, ,
+              swf_field_56a_fmt, branchFld56, ,
+              swf_field_56d_comp, branchIdentBreak, ,
+              swf_field_57x, branchFld57, ,
+              swf_field_57d_fmt, branchFld57, ,
+              swf_field_57a_fmt, branchFld57, ,
+              swf_field_57b_fmt, branchFld57, ,
+              swf_field_57d_comp, branchIdentBreak, ,
+              swf_field_58x, branchFld58, ,
+              swf_field_58d_fmt, branchFld58, ,
+              swf_field_58a_fmt, branchFld58, ,
+              swf_field_58b_fmt, branchFld58, ,
+              swf_field_58d_comp, branchIdentBreak, ,
+              swf_field_59x, branchFld59, ,
+              swf_field_59blanc_fmt, branchFld59, ,
+              swf_field_59a_fmt, branchFld59, ,
+              swf_field_59blanc_comp, branchIdentBreak, ,
+              swf_field_70, branchIdentBreak, ,
+              swf_field_72, branchIdentBreak, ,
+              swf_field_72_autres_lignes, branchIdentBreak, ,
+              swf_field_77, branchIdentBreak, ,
+              crt_cre_flux_stlm_sans13c, branch13CStlmCre, ,
+              crt_cre_flux_stlm_avec13c, branch13CStlmCre, ,
+              crt_cre_flux_13c_occ6, branch13COcc6Cre, ,
+              crt_cre_flux_stlm_avec13c_occ6, branch13COcc6Cre, ,
+              crt_cre_flux_13c_occ5, branch13COcc5Cre, ,
+              crt_cre_flux_stlm_avec13c_occ5, branch13COcc5Cre, ,
+              crt_cre_flux_13c_occ4, branch13COcc4Cre, ,
+              crt_cre_flux_stlm_avec13c_occ4, branch13COcc4Cre, ,
+              crt_cre_flux_13c_occ3, branch13COcc3Cre, ,
+              crt_cre_flux_stlm_avec13c_occ3, branch13COcc3Cre, ,
+              crt_cre_flux_13c_occ2, branch13COcc2Cre, ,
+              crt_cre_flux_stlm_avec13c_occ2, branch13COcc2Cre, ,
+              crt_cre_flux_13c_occ1, branch13COcc1Cre, ,
+              crt_cre_flux_stlm_avec13c, branch13COcc1Cre, ,
+              crt_cre_flux_stlm_cus_sans55, branch13C55StlmCusCre, ,
+              crt_cre_flux_stlm_cus_avec55, branch13C55StlmCusCre, ,
+              swf_cre_field_50x, branchFld50Cre, ,
+              swf_cre_field_50k_fmt, branchFld50Cre, ,
+              swf_cre_field_50a_fmt, branchFld50Cre, ,
+              swf_cre_field_50k_comp, branchIdentBreak, ,
+              swf_cre_field_52x, branchFld52Cre, ,
+              swf_cre_field_52d_fmt, branchFld52Cre, ,
+              swf_cre_field_52a_fmt, branchFld52Cre, ,
+              swf_cre_field_52d_comp, branchIdentBreak, ,
+              swf_cre_field_55x, branchFld55Cre, ,
+              swf_cre_field_55d_fmt, branchFld55Cre, ,
+              swf_cre_field_55a_fmt, branchFld55Cre, ,
+              swf_cre_field_55b_fmt, branchFld55Cre, ,
+              swf_cre_field_55d_comp, branchIdentBreak, ,
+              swf_cre_field_56x, branchFld56Cre, ,
+              swf_cre_field_56d_fmt, branchFld56Cre, ,
+              swf_cre_field_56a_fmt, branchFld56Cre, ,
+              swf_cre_field_56d_comp, branchIdentBreak, ,
+              swf_cre_field_57x, branchFld57Cre, ,
+              swf_cre_field_57d_fmt, branchFld57Cre, ,
+              swf_cre_field_57a_fmt, branchFld57Cre, ,
+              swf_cre_field_57b_fmt, branchFld57Cre, ,
+              swf_cre_field_57d_comp, branchIdentBreak, ,
+              swf_cre_field_58x, branchFld58Cre, ,
+              swf_cre_field_58d_fmt, branchFld58Cre, ,
+              swf_cre_field_58a_fmt, branchFld58Cre, ,
+              swf_cre_field_58b_fmt, branchFld58Cre, ,
+              swf_cre_field_58d_comp, branchIdentBreak, ,
+              swf_cre_field_59x, branchFld59Cre, ,
+              swf_cre_field_59blanc_fmt, branchFld59Cre, ,
+              swf_cre_field_59a_fmt, branchFld59Cre, ,
+              swf_cre_field_59blanc_comp, branchIdentBreak, ,
+              swf_cre_field_70, branchIdentBreak, ,
+              swf_cre_field_72, branchIdentBreak, ,
+              swf_cre_field_72_autres_lignes, branchIdentBreak, ,
+              swf_cre_field_77, branchIdentBreak, ,
+              crt_cre_flux_ident, branchCreIdent, ,
+              crt_cre_flux_vs02, branchCreIdent, ,
+              crt_cre_flux_vs07, branchCreIdent, ,
+              crt_cre_flux_vs08, branchCreIdent, ,
+              crt_cre_flux_os01, branchCreIdent, ,
+              crt_cre_flux_vs03, branchCreIdent, ,
+              crt_cre_flux_vs04, branchCreIdent, ,
+              crt_cre_flux_header, branchIdentBreak, ,
+              crt_cre_flux_stlm_header, branchIdentBreak, ,
+              crt_cre_flux_or_header, branchIdentBreak, ,
+              crt_cre_flux_or, branchIdentBreak, ,
+              swf_cre_field_13c, branchIdentBreak, ,
+              crt_cre_flux_stlm_bk, branchIdentBreak, ,
+              crt_cre_flux_stlm_cus, branchIdentBreak, ,
+              crt_cre_flux_stlm_cus_end, branchIdentBreak, )
+changecom(`<!--', `-->')dnl
+<!--  DEBUT Traitement du bloc 13C -->
+<!--  FIN Traitement du bloc 13C -->
+<!-- messages extraction insertion de donnees d'un flux complet (concerne le CRE40) -->
+<!-- messages extraction insertion de donnees relatives aux ordres de restitution -->
+<!-- messages extraction insertion de donnees relatives aux virements -->
+<!-- branche BB2 messages d'identification des flux destines a cristal -->
+<!-- branche BB3 messages d'identification des cre en provenance de cristal -->
+<!-- branche BB4 messages d'identification des flux pour cre sur flux emis -->
+<!-- branche BB5 messages d'identification des flux pour cre sur flux recus -->
+<!-- branche BB6 messages d'identification des flux pour cre de rejet -->
+<!-- message des cre -->
+<!-- flux destines a cristal -->
+<!-- branche BB8 messages d'identification des virements bancaires -->
+<!-- branche BB9 messages d'identification des virements de clientele -->
+<!-- branche BB10 messages d'identification des virements emanant des titres ou de matcc -->
+<!-- branche BB11 messages d'identification du format du champ 50 -->
+<!-- branche BB12 messages d'identification du format du champ 52 -->
+<!-- branche BB13 messages d'identification du format du champ 55 -->
+<!-- branche BB14 messages d'identification du format du champ 56 -->
+<!-- branche BB15 messages d'identification du format du champ 57 -->
+<!-- branche BB16 messages d'identification du format du champ 58 -->
+<!-- branche BB17 messages d'identification du format du champ 59 -->
+<!-- messages de mapping des champ 70 72 et 77 -->
+changecom(`<', `>')dnl
+format_object(Fixed,
+              swf_cre_field_occ13x, branch13CIdentCre, ,
+              swf_cre_field_occ13c_sndtime, branch13CIdentCre, ,
+              swf_cre_field_occ13c_clstime, branch13CIdentCre, ,
+              msg_fixed_fml, branchIdentBreak, ,
+              crt_flux_cre, branchIdentBreak, ,
+              crt_flux_ordre_rest, branchIdentBreak, ,
+              crt_flux_stlm, branchIdentBreak, ,
+              crt_flux_stlm_cus_56_a_77, branchIdentBreak, ,
+              crt_flux_stlm_avec13c, branchIdentBreak, ,
+              crt_flux_ident, branchFluxVersCrt, ,
+              crt_flux_vs02, branchFluxVersCrt, ,
+              crt_flux_vs07, branchFluxVersCrt, ,
+              crt_flux_vs08, branchFluxVersCrt, ,
+              crt_flux_os01, branchFluxVersCrt, ,
+              crt_flux_vs03, branchFluxVersCrt, ,
+              crt_flux_vs04, branchFluxVersCrt, ,
+              crt_cre_ident, branchFluxDeCrt, ,
+              crt_cre_cr01, branchFluxDeCrt, ,
+              crt_cre_cr02, branchFluxDeCrt, ,
+              crt_cre_cr03, branchFluxDeCrt, ,
+              crt_cre_cr04, branchFluxDeCrt, ,
+              crt_cre_cr05, branchFluxDeCrt, ,
+              crt_cre_cr06, branchFluxDeCrt, ,
+              crt_cre_cr07, branchFluxDeCrt, ,
+              crt_cre_cr08, branchFluxDeCrt, ,
+              crt_cre_cr09, branchFluxDeCrt, ,
+              crt_cre_cr10, branchFluxDeCrt, ,
+              crt_cre_cr11, branchFluxDeCrt, ,
+              crt_cre_cr12, branchFluxDeCrt, ,
+              crt_cre_cr13, branchFluxDeCrt, ,
+              crt_cre_cr14, branchFluxDeCrt, ,
+              crt_cre_cr15, branchFluxDeCrt, ,
+              crt_cre_cr16, branchFluxDeCrt, ,
+              crt_cre_cr17, branchFluxDeCrt, ,
+              crt_cre_cr18, branchFluxDeCrt, ,
+              crt_cre_cr20, branchFluxDeCrt, ,
+              crt_cre_cr21, branchFluxDeCrt, ,
+              crt_cre_cr22, branchFluxDeCrt, ,
+              crt_cre_cr23, branchFluxDeCrt, ,
+              crt_cre_cr24, branchFluxDeCrt, ,
+              crt_cre_cr25, branchFluxDeCrt, ,
+              crt_cre_cr30, branchFluxDeCrt, ,
+              crt_cre_cr31, branchFluxDeCrt, ,
+              crt_cre_cr40, branchFluxDeCrt, ,
+              crt_cre_cr41, branchFluxDeCrt, ,
+              crt_cre_cr42, branchFluxDeCrt, ,
+              crt_cre_cr44, branchFluxDeCrt, ,
+              crt_cre_cr45, branchFluxDeCrt, ,
+              crt_cre_cr50, branchFluxDeCrt, ,
+              crt_cre_emis_ident, branchFluxDeCreSurFluxEmis, ,
+              crt_cre_emis_vs02, branchFluxDeCreSurFluxEmis, ,
+              crt_cre_emis_vs07, branchFluxDeCreSurFluxEmis, ,
+              crt_cre_emis_vs08, branchFluxDeCreSurFluxEmis, ,
+              crt_cre_emis_os01, branchFluxDeCreSurFluxEmis, ,
+              crt_cre_emis_vs03, branchFluxDeCreSurFluxEmis, ,
+              crt_cre_emis_vs04, branchFluxDeCreSurFluxEmis, ,
+              crt_cre_recu_ident, branchFluxDeCreSurFluxRecus, ,
+              crt_cre_recu_vs02, branchFluxDeCreSurFluxRecus, ,
+              crt_cre_recu_vs07, branchFluxDeCreSurFluxRecus, ,
+              crt_cre_recu_vs08, branchFluxDeCreSurFluxRecus, ,
+              crt_cre_recu_os01, branchFluxDeCreSurFluxRecus, ,
+              crt_cre_recu_vs03, branchFluxDeCreSurFluxRecus, ,
+              crt_cre_recu_vs04, branchFluxDeCreSurFluxRecus, ,
+              crt_cre_rejet_ident, branchFluxDeCreRejet, ,
+              crt_cre_rejet_vs02, branchFluxDeCreRejet, ,
+              crt_cre_rejet_vs07, branchFluxDeCreRejet, ,
+              crt_cre_rejet_vs08, branchFluxDeCreRejet, ,
+              crt_cre_rejet_os01, branchFluxDeCreRejet, ,
+              crt_cre_rejet_vs03, branchFluxDeCreRejet, ,
+              crt_cre_rejet_vs04, branchFluxDeCreRejet, ,
+              crt_cre_header, branchHeaderCre, ,
+              crt_cre_flux_emis_header, branchHeaderCre, ,
+              crt_cre_flux_recu_header, branchHeaderCre, ,
+              crt_cre_rejet_header, branchHeaderCre, ,
+              crt_flux_header, branchIdentBreak, ,
+              crt_flux_or_header, branchIdentBreak, ,
+              crt_flux_or, branchIdentBreak, ,
+              crt_flux_stlm_header, branchIdentBreak, ,
+              crt_flux_stlm_bk, branchIdentBreak, ,
+              crt_flux_stlm_cus, branchIdentBreak, ,
+              crt_flux_stlm_cus_end, branchIdentBreak, ,
+              swf_field_13c, branchIdentBreak, ,
+              crt_flux_stlm_sans13c, branch13CStlmBank, ,
+              crt_flux_stlm_bk_sans13c, branch13CStlmBank, ,
+              crt_flux_stlm_bk_avec13c, branch13CStlmBank, ,
+              crt_flux_stlm_cus_sans55, branch13C55StlmCus, ,
+              crt_flux_stlm_cus_sans55_sans13c, branch13C55StlmCus, ,
+              crt_flux_stlm_cus_sans55_avec13c, branch13C55StlmCus, ,
+              crt_flux_stlm_cus_avec55_sans13c, branch13C55StlmCus, ,
+              crt_flux_stlm_cus_avec55_avec13c, branch13C55StlmCus, ,
+              crt_msg_bo_ident, branchVirtDeBo, ,
+              crt_msg_titres, branchVirtDeBo, ,
+              crt_msg_matcc, branchVirtDeBo, ,
+              swf_field_50x, branchFld50, ,
+              swf_field_50k_fmt, branchFld50, ,
+              swf_field_50a_fmt, branchFld50, ,
+              swf_field_50vide_fmt, branchFld50, ,
+              swf_field_50k_comp, branchIdentBreak, ,
+              swf_cre_field_50x, branchFld50Cre, ,
+              swf_cre_field_50k_fmt, branchFld50Cre, ,
+              swf_cre_field_50a_fmt, branchFld50Cre, ,
+              swf_cre_field_50k_comp, branchIdentBreak, ,
+              swf_field_52x, branchFld52, ,
+              swf_field_52d_fmt, branchFld52, ,
+              swf_field_52a_fmt, branchFld52, ,
+              swf_field_52vide_fmt, branchFld52, ,
+              swf_field_52d_comp, branchIdentBreak, ,
+              swf_cre_field_52x, branchFld52Cre, ,
+              swf_cre_field_52d_fmt, branchFld52Cre, ,
+              swf_cre_field_52a_fmt, branchFld52Cre, ,
+              swf_cre_field_52d_comp, branchIdentBreak, ,
+              swf_field_55x, branchFld55, ,
+              swf_field_55d_fmt, branchFld55, ,
+              swf_field_55a_fmt, branchFld55, ,
+              swf_field_55b_fmt, branchFld55, ,
+              swf_field_55vide_fmt, branchFld55, ,
+              swf_field_55d_comp, branchIdentBreak, ,
+              swf_field_56x, branchFld56, ,
+              swf_field_56d_fmt, branchFld56, ,
+              swf_field_56a_fmt, branchFld56, ,
+              swf_field_56vide_fmt, branchFld56, ,
+              swf_field_56d_comp, branchIdentBreak, ,
+              swf_field_57x, branchFld57, ,
+              swf_field_57d_fmt, branchFld57, ,
+              swf_field_57a_fmt, branchFld57, ,
+              swf_field_57b_fmt, branchFld57, ,
+              swf_field_57vide_fmt, branchFld57, ,
+              swf_field_57d_comp, branchIdentBreak, ,
+              swf_field_58x, branchFld58, ,
+              swf_field_58d_fmt, branchFld58, ,
+              swf_field_58a_fmt, branchFld58, ,
+              swf_field_58b_fmt, branchFld58, ,
+              swf_field_58vide_fmt, branchFld58, ,
+              swf_field_58d_comp, branchIdentBreak, ,
+              swf_field_59x, branchFld59, ,
+              swf_field_59blanc_fmt, branchFld59, ,
+              swf_field_59a_fmt, branchFld59, ,
+              swf_field_59blanc_comp, branchIdentBreak, ,
+              swf_cre_field_56x, branchFld56Cre, ,
+              swf_cre_field_56d_fmt, branchFld56Cre, ,
+              swf_cre_field_56a_fmt, branchFld56Cre, ,
+              swf_cre_field_56d_comp, branchIdentBreak, ,
+              swf_cre_field_57x, branchFld57Cre, ,
+              swf_cre_field_57d_fmt, branchFld57Cre, ,
+              swf_cre_field_57a_fmt, branchFld57Cre, ,
+              swf_cre_field_57b_fmt, branchFld57Cre, ,
+              swf_cre_field_57d_comp, branchIdentBreak, ,
+              swf_cre_field_58x, branchFld58Cre, ,
+              swf_cre_field_58d_fmt, branchFld58Cre, ,
+              swf_cre_field_58a_fmt, branchFld58Cre, ,
+              swf_cre_field_58b_fmt, branchFld58Cre, ,
+              swf_cre_field_58d_comp, branchIdentBreak, ,
+              swf_cre_field_59x, branchFld59Cre, ,
+              swf_cre_field_59blanc_fmt, branchFld59Cre, ,
+              swf_cre_field_59a_fmt, branchFld59Cre, ,
+              swf_cre_field_59blanc_comp, branchIdentBreak, ,
+              swf_cre_field_55x, branchFld55Cre, ,
+              swf_cre_field_55d_fmt, branchFld55Cre, ,
+              swf_cre_field_55a_fmt, branchFld55Cre, ,
+              swf_cre_field_55b_fmt, branchFld55Cre, ,
+              swf_cre_field_55d_comp, branchIdentBreak, ,
+              swf_field_70, branchIdentBreak, ,
+              swf_field_72, branchIdentBreak, ,
+              swf_cre_field_72, branchIdentBreak, ,
+              swf_field_72_autres_lignes, branchIdentBreak, ,
+              swf_cre_field_72_autres_lignes, branchIdentBreak, ,
+              swf_field_77, branchIdentBreak, ,
+              cus_champ_13c_sans55, branchIdentBreak, ,
+              cus_champ_13c_avec55, branchIdentBreak, ,
+              crt_cre_flux_header, branchIdentBreak, ,
+              crt_cre_flux_stlm_header, branchIdentBreak, ,
+              crt_cre_flux_or_header, branchIdentBreak, ,
+              crt_cre_flux_or, branchIdentBreak, ,
+              swf_cre_field_13c, branchIdentBreak, ,
+              crt_cre_flux_stlm_bk, branchIdentBreak, ,
+              crt_cre_flux_stlm_cus, branchIdentBreak, ,
+              crt_cre_flux_stlm_cus_end, branchIdentBreak, ,
+              swf_cre_field_70, branchIdentBreak, ,
+              swf_cre_field_77, branchIdentBreak, ,
+              crt_cre_flux_stlm_cus_56_a_77, branchIdentBreak, ,
+              cre_cus_champ_13c_sans55, branchIdentBreak, ,
+              cre_cus_champ_13c_avec55, branchIdentBreak, ,
+              cut_end_msg, branchIdentBreak, )
+changecom(`<!--', `-->')dnl
+<!-- messages d'identification des delimiteurs utilise -->
+changecom(`<', `>')dnl
+format_object(Delimited,
+              delimited_ident,branchDltdIdent, crlf_t,
+              delimited_test, branchDltdIdent, ffff_t,
+              delimited_test, branchDltdIdent, zzzz_t,
+              delimited_test, branchDltdIdent, crlf_t,
+              msg_delimited_fixed, branchIdentBreak, crlf_t,
+              msg_delimited_fixed, branchIdentBreak, ffff_t,
+              msg_delimited_fixed, branchIdentBreak, zzzz_t,
+              swf_field_50k_comp, branchIdentBreak, crlf_t,
+              swf_field_50k_comp, branchIdentBreak, ffff_t,
+              swf_field_50k_comp, branchIdentBreak, zzzz_t,
+              swf_cre_field_50k_comp, branchIdentBreak, crlf_t,
+              swf_cre_field_50k_comp, branchIdentBreak, ffff_t,
+              swf_cre_field_50k_comp, branchIdentBreak, zzzz_t,
+              swf_field_52d_comp, branchIdentBreak, crlf_t,
+              swf_field_52d_comp, branchIdentBreak, ffff_t,
+              swf_field_52d_comp, branchIdentBreak, zzzz_t,
+              swf_cre_field_52d_comp, branchIdentBreak, crlf_t,
+              swf_cre_field_52d_comp, branchIdentBreak, ffff_t,
+              swf_cre_field_52d_comp, branchIdentBreak, zzzz_t,
+              swf_field_55d_comp, branchIdentBreak, crlf_t,
+              swf_field_55d_comp, branchIdentBreak, ffff_t,
+              swf_field_55d_comp, branchIdentBreak, zzzz_t,
+              swf_cre_field_55d_comp, branchIdentBreak, crlf_t,
+              swf_cre_field_55d_comp, branchIdentBreak, ffff_t,
+              swf_cre_field_55d_comp, branchIdentBreak, zzzz_t,
+              swf_field_56d_comp, branchIdentBreak, crlf_t,
+              swf_field_56d_comp, branchIdentBreak, ffff_t,
+              swf_field_56d_comp, branchIdentBreak, zzzz_t,
+              swf_cre_field_56d_comp, branchIdentBreak, crlf_t,
+              swf_cre_field_56d_comp, branchIdentBreak, ffff_t,
+              swf_cre_field_56d_comp, branchIdentBreak, zzzz_t,
+              swf_field_57d_comp, branchIdentBreak, crlf_t,
+              swf_field_57d_comp, branchIdentBreak, ffff_t,
+              swf_field_57d_comp, branchIdentBreak, zzzz_t,
+              swf_cre_field_57d_comp, branchIdentBreak, crlf_t,
+              swf_cre_field_57d_comp, branchIdentBreak, ffff_t,
+              swf_cre_field_57d_comp, branchIdentBreak, zzzz_t,
+              swf_field_58d_comp, branchIdentBreak, crlf_t,
+              swf_field_58d_comp, branchIdentBreak, ffff_t,
+              swf_field_58d_comp, branchIdentBreak, zzzz_t,
+              swf_cre_field_58d_comp, branchIdentBreak, crlf_t,
+              swf_cre_field_58d_comp, branchIdentBreak, ffff_t,
+              swf_cre_field_58d_comp, branchIdentBreak, zzzz_t,
+              swf_field_59blanc_comp, branchIdentBreak, crlf_t,
+              swf_field_59blanc_comp, branchIdentBreak, ffff_t,
+              swf_field_59blanc_comp, branchIdentBreak, zzzz_t,
+              swf_cre_field_59blanc_comp, branchIdentBreak, crlf_t,
+              swf_cre_field_59blanc_comp, branchIdentBreak, ffff_t,
+              swf_cre_field_59blanc_comp, branchIdentBreak, zzzz_t,
+              swf_field_70, branchIdentBreak, crlf_t,
+              swf_field_70, branchIdentBreak, ffff_t,
+              swf_field_70, branchIdentBreak, zzzz_t,
+              swf_cre_field_70, branchIdentBreak, crlf_t,
+              swf_cre_field_70, branchIdentBreak, ffff_t,
+              swf_cre_field_70, branchIdentBreak, zzzz_t,
+              swf_field_72_autres_lignes, branchIdentBreak, crlf_t,
+              swf_field_72_autres_lignes, branchIdentBreak, ffff_t,
+              swf_field_72_autres_lignes, branchIdentBreak, zzzz_t,
+              swf_cre_field_72_autres_lignes, branchIdentBreak, crlf_t,
+              swf_cre_field_72_autres_lignes, branchIdentBreak, ffff_t,
+              swf_cre_field_72_autres_lignes, branchIdentBreak, zzzz_t,
+              swf_field_77, branchIdentBreak, crlf_t,
+              swf_field_77, branchIdentBreak, ffff_t,
+              swf_field_77, branchIdentBreak, zzzz_t,
+              swf_cre_field_77, branchIdentBreak, crlf_t,
+              swf_cre_field_77, branchIdentBreak, ffff_t,
+              swf_cre_field_77, branchIdentBreak, zzzz_t)
+footer_fmt()
diff --git a/src/sd_fmtattr_struct/src/Makefile b/src/sd_fmtattr_struct/src/Makefile
new file mode 100644
index 0000000..6882bf7
--- /dev/null
+++ b/src/sd_fmtattr_struct/src/Makefile
@@ -0,0 +1,65 @@
+#------------------------------------------------------------------------------
+# Local Makefile
+#------------------------------------------------------------------------------
+# $Workfile:   Makefile  $                                                     
+#------------------------------------------------------------------------------
+# $Author: agibert $                                                        
+# $Date: 2008/11/12 02:25:24 $                                             
+# $Revision: 1.1 $                                                         
+# $Label:  $                                                           
+#------------------------------------------------------------------------------
+
+#------------------------------------------------------------------------------
+# IMR - Interlinking Message Router                                            
+# Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)                
+# mailto:arnaud@rx3.net                                                        
+# http://www.rx3.org/dvp/?dvp=imr                                              
+#------------------------------------------------------------------------------
+# This file is part of IMR                                                     
+#                                                                              
+# This program is free software; you can redistribute it and/or                
+# modify it under the terms of the GNU General Public License                  
+# as published by the Free Software Foundation; either version 2               
+# of the License, or (at your option) any later version.                       
+#                                                                              
+# This program is distributed in the hope that it will be useful,              
+# but WITHOUT ANY WARRANTY; without even the implied warranty of               
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                
+# GNU General Public License for more details.                                 
+#                                                                              
+# You should have received a copy of the GNU General Public License            
+# along with this program; if not, write to the Free Software Foundation,      
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.          
+#------------------------------------------------------------------------------
+
+
+
+
+
+#------------------------------------------------------------------------------
+# Var include
+#------------------------------------------------------------------------------
+
+include ../../Makefile_var.mk
+
+
+
+#------------------------------------------------------------------------------
+# Variables
+#------------------------------------------------------------------------------
+
+TARGET=		sd_fmtattr_struct.xml
+
+OBJ_RAW=	sd_fmtattr_struct.xml.m4
+
+EXTRA_INC=	
+
+EXTRA_LIB=	
+
+
+
+#------------------------------------------------------------------------------
+# Rule include
+#------------------------------------------------------------------------------
+
+include ../../Makefile_rule.mk
diff --git a/src/sd_fmtattr_struct/src/fmtattr_commun.xml.m4 b/src/sd_fmtattr_struct/src/fmtattr_commun.xml.m4
new file mode 100644
index 0000000..13567c0
--- /dev/null
+++ b/src/sd_fmtattr_struct/src/fmtattr_commun.xml.m4
@@ -0,0 +1,60 @@
+changecom(`<!--', `-->')dnl
+dnl
+dnl+---------------------------------------------------------------------------+
+dnl|    Begin header_fmtattr Macro                                             |
+dnl+---------------------------------------------------------------------------+
+dnl
+define(`header_fmtattr',
+`<?xml version="1.0" ?>
+`<!-- FmtAttr Struct definitions -->'
+`<fmtattr_struct>'')
+dnl
+dnl+---------------------------------------------------------------------------+
+dnl|     End header_cnv Macro                                                  |
+dnl+---------------------------------------------------------------------------+
+dnl
+dnl
+dnl+---------------------------------------------------------------------------+
+dnl|    Begin footer_fmtattr Macro                                             |
+dnl+---------------------------------------------------------------------------+
+dnl
+define(`footer_fmtattr',
+`<!-- FmtAttr Struct definitions footer -->
+`</fmtattr_struct>'')
+dnl
+dnl+---------------------------------------------------------------------------+
+dnl|     End footer_fmtattr Macro                                              |
+dnl+---------------------------------------------------------------------------+
+dnl
+dnl
+dnl+---------------------------------------------------------------------------+
+dnl|    Begin insert_version Macro                                             |
+dnl|                                                                           |
+dnl| $1 : la chaine VERSION                                                    |
+dnl+---------------------------------------------------------------------------+
+dnl
+define(`insert_version',
+`<version>$1</version>')
+dnl
+dnl+----------------------------------------------------------------------------+
+dnl|     End insert_version Macro                                               |
+dnl+----------------------------------------------------------------------------+
+dnl
+dnl
+dnl+---------------------------------------------------------------------------+
+dnl|    Begin format_attribut Macro                                            |
+dnl|                                                                           |
+dnl| $1 : Format Attribut Name                                                 |
+dnl| $2 : Format Attribut Value                                                |
+dnl+---------------------------------------------------------------------------+
+dnl
+define(`format_attribut',
+`	<fmtattr>
+`		<name>$1</name>'
+`		<value>$2</value>'
+`	</fmtattr>'')
+dnl
+dnl+---------------------------------------------------------------------------+
+dnl|     End format_attribut Macro                                             |
+dnl+---------------------------------------------------------------------------+
+dnl
diff --git a/src/sd_fmtattr_struct/src/sd_fmtattr_struct.xml.m4 b/src/sd_fmtattr_struct/src/sd_fmtattr_struct.xml.m4
new file mode 100644
index 0000000..4ab4c29
--- /dev/null
+++ b/src/sd_fmtattr_struct/src/sd_fmtattr_struct.xml.m4
@@ -0,0 +1,18 @@
+dnl
+divert(-1)
+include(`fmtattr_commun.xml.m4')
+divert(0)dnl
+dnl
+changecom(`<!--', `-->')dnl
+dnl
+dnl
+header_fmtattr()
+insert_version(@(#) VERSIONIMR: $Label:  $   $Date: 2008/11/12 02:25:24 $   $Workfile:   sd_fmtattr_struct.xml.m4  $)
+format_attribut(unknown,)
+format_attribut(crlf_t,T%0D%0A)
+format_attribut(lf_t,T%0A)
+format_attribut(crlf_s,S%0D%0A)
+format_attribut(lf_s,S%0A)
+format_attribut(ffff_t,T%0C%0C)
+format_attribut(zzzz_t,T%FF%FF)
+footer_fmtattr()
diff --git a/src/sd_mappath_struct/src/Makefile b/src/sd_mappath_struct/src/Makefile
new file mode 100644
index 0000000..016b02e
--- /dev/null
+++ b/src/sd_mappath_struct/src/Makefile
@@ -0,0 +1,66 @@
+#------------------------------------------------------------------------------
+# Local Makefile
+#------------------------------------------------------------------------------
+# $Workfile:   Makefile  $                                                     
+#------------------------------------------------------------------------------
+# $Author: agibert $                                                        
+# $Date: 2008/11/12 02:25:24 $                                             
+# $Revision: 1.1 $                                                         
+# $Label:  $                                                           
+#------------------------------------------------------------------------------
+
+#------------------------------------------------------------------------------
+# IMR - Interlinking Message Router                                            
+# Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)                
+# mailto:arnaud@rx3.net                                                        
+# http://www.rx3.org/dvp/?dvp=imr                                              
+#------------------------------------------------------------------------------
+# This file is part of IMR                                                     
+#                                                                              
+# This program is free software; you can redistribute it and/or                
+# modify it under the terms of the GNU General Public License                  
+# as published by the Free Software Foundation; either version 2               
+# of the License, or (at your option) any later version.                       
+#                                                                              
+# This program is distributed in the hope that it will be useful,              
+# but WITHOUT ANY WARRANTY; without even the implied warranty of               
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                
+# GNU General Public License for more details.                                 
+#                                                                              
+# You should have received a copy of the GNU General Public License            
+# along with this program; if not, write to the Free Software Foundation,      
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.          
+#------------------------------------------------------------------------------
+
+
+
+
+
+#------------------------------------------------------------------------------
+# Var include
+#------------------------------------------------------------------------------
+
+include ../../Makefile_var.mk
+
+
+
+#------------------------------------------------------------------------------
+# Variables
+#------------------------------------------------------------------------------
+
+TARGET=		sd_mappath_struct.xml
+
+OBJ_RAW=	sd_mappath_struct.xml.m4
+
+
+EXTRA_INC=	
+
+EXTRA_LIB=	
+
+
+
+#------------------------------------------------------------------------------
+# Rule include
+#------------------------------------------------------------------------------
+
+include ../../Makefile_rule.mk
diff --git a/src/sd_mappath_struct/src/fixed_xml.xml.m4 b/src/sd_mappath_struct/src/fixed_xml.xml.m4
new file mode 100644
index 0000000..8f1969b
--- /dev/null
+++ b/src/sd_mappath_struct/src/fixed_xml.xml.m4
@@ -0,0 +1,290 @@
+changecom(`<!--', `-->')dnl
+dnl
+dnl+--------------------------------------+
+dnl|    Begin Macro Section               |
+dnl+--------------------------------------+
+dnl
+define(`fixed_xml',
+<!-- branche BB2 mapping des donnees communes au virement bancaire et au virement de clientele -->
+<!-- branche BB3 mapping des donnees specifiques au virement bancaire -->
+<!-- branche BB4 mapping des donnees specifiques au virement de clientele -->
+<!-- branche BB5 mapping des donnees specifiques aux ordres de restitutuion (y compris entete) -->
+<!-- branche BB6 mapping des blocs communs (52 56 57 72 ) au virement bancaire et au virement de clientele -->
+<!-- branche BB10 mapping des blocs au format A B ou blanc -->
+<!-- branche BB11 mapping des blocs au format D ou K -->
+<!-- branche BB13 mapping du bloc 13C -->
+<!-- branche BB55 et BB5513 mapping du bloc 55 -->
+<!-- branche 1900 :  mapping specifique des msg des titres -->
+<!-- branche 2500 :  mapping specifique des msg de matcc -->
+<!-- branche BB55 et BB5513 mapping du bloc 55 -->
+<!-- Buffer BUF2 (fixed) pour donnees du virement -->
+<!-- Buffer BUF3 (fixed) pour donnees du virement de clientele (du bloc 56 au bloc 77) -->
+<!-- Buffer BUF10 (fixed) pour mapping du bloc 13C -->
+<!-- Buffer BUF11 (fixed) pour bloc 50 -->
+<!-- Buffer BUF12 (fixed) pour bloc 52 -->
+<!-- Buffer BUF13 (fixed) pour bloc 55 -->
+<!-- Buffer BUF14 (fixed) pour bloc 56 -->
+<!-- Buffer BUF15 (fixed) pour bloc 57 -->
+<!-- Buffer BUF16 (fixed) pour bloc 58 -->
+<!-- Buffer BUF17 (fixed) pour bloc 59 -->
+<!-- Buffer BUF18 (fixed) pour bloc 72 -->
+<!-- Buffer BUF20 (fixed ou delimited) pour mapping des blocs "delimited"  il est reutilise -->
+<!-- Buffer BUF30 (fixed) pour msg de matcc et titres : buffer intermediaire -->
+<!-- identification de la provenance des messages en fonction des tailles -->
+`cmd_identifier(branchCommuneVirtBankCus,bufferWork,y,crt_msg_bo_ident,'
+`				Fixed,crt_msg_titres,branchTitres,'
+`				Fixed,crt_msg_matcc,branchMatcc,'
+`				Fixed,unknown,branchCommuneVirtBankCus)'
+<!-- suppression des caracteres supperflus en fin des messages des titres -->
+`cmd_mapper(branchTitres,Fixed,,Fixed,,bufferWork,bufferTempMatccTitres,,strip_end_msg-strip_end_msg)'
+`cmd_mapper(branchTitres,Fixed,,Fixed,,bufferTempMatccTitres,bufferWork,activeClearFlag,cut_end_msg-cut_end_msg1)'
+`cmd_go_to(branchTitres,branchCommuneVirtBankCus)'
+<!-- suppression des caracteres supperflus en fin des messages de matcc -->
+`cmd_mapper(branchMatcc,Fixed,,Fixed,,bufferWork,bufferTempMatccTitres,,strip_end_msg-strip_end_msg)'
+`cmd_mapper(branchMatcc,Fixed,,Fixed,,bufferTempMatccTitres,bufferWork,activeClearFlag,cut_end_msg-cut_end_msg2)'
+`cmd_go_to(branchMatcc,branchCommuneVirtBankCus)'
+
+`cmd_identifier(branchCommuneVirtBankCus,bufferWork,y,crt_flux_ident,'
+`				Fixed,crt_flux_vs02,branchCommuneVirtBankCus,'
+`				Fixed,crt_flux_vs03,branchCommuneVirtBankCus,'
+`				Fixed,crt_flux_vs04,branchCommuneVirtBankCus,'
+`				Fixed,crt_flux_vs07,branchCommuneVirtBankCus,'
+`				Fixed,crt_flux_vs08,branchCommuneVirtBankCus,'
+`				Fixed,crt_flux_os01,branchVirtOr)'
+		<!-- mapping des entete_commun et entete_vgm -->
+`cmd_mapper(branchCommuneVirtBankCus,Fixed,,XML,,bufferWork,bufferTemp,activeClearFlag,crt_flux_header-crt_flux_header)'
+`cmd_mapper(branchCommuneVirtBankCus,Fixed,,XML,,bufferWork,bufferTemp,,crt_flux_stlm_header-crt_flux_stlm_header)'
+		<!-- extraction des donnees du virement -->
+`cmd_mapper(branchCommuneVirtBankCus,Fixed,,Fixed,,bufferWork,bufferDataMsg,,crt_flux_stlm-crt_flux_stlm-extract_stlm_from_flux)'
+		<!-- identification complete a partir de la branche 0 -->
+`cmd_identifier(branchCommuneVirtBankCus,bufferWork,y,crt_flux_ident,'
+`				Fixed,crt_flux_vs02,branchVirtBank,'
+`				Fixed,crt_flux_vs03,branchVirtBank,'
+`				Fixed,crt_flux_vs04,branchVirtBank,'
+`				Fixed,crt_flux_vs07,branchVirtCus,'
+`				Fixed,crt_flux_vs08,branchVirtCus)'
+<!-- partie commune aux flux destines a cristal et aux cre -->
+<!-- branche BB3 mapping des donnees du virement bancaire -->
+		<!-- mapping des donnees du virement bancaire hors 13c 52 56 57 58 et 72 -->
+`cmd_mapper(branchVirtBank,Fixed,,XML,,bufferDataMsg,bufferTemp,,crt_flux_stlm_bk-crt_flux_stlm_bk)'
+	<!-- bloc 13C -->
+		<!-- recherche existence du bloc 13C -->
+`cmd_identifier(branchVirtBank,bufferDataMsg,n,crt_flux_stlm_sans13c,'
+`				Fixed,crt_flux_stlm_bk_sans13c,branchVirtBank,'
+`				Fixed,crt_flux_stlm_bk_avec13c,branchFld13)'
+		<!-- extraction du bloc 13c -->
+`cmd_mapper(branchFld13,Fixed,,Fixed,,bufferDataMsg,bufferMapping13C,,crt_flux_stlm_bk-swf_field_13c)'
+		<!-- mapping du bloc 13c -->
+`cmd_mapper(branchFld13,Fixed,,XML,,bufferMapping13C,bufferTemp,,swf_field_13c-swf_field_13c)'
+`cmd_go_to(branchFld13,branchVirtBank)'
+	<!-- fin bloc 13C -->
+		<!-- extraction du bloc 52 du virement bancaire -->
+`cmd_mapper(branchVirtBank,Fixed,,Fixed,,bufferDataMsg,bufferMapping52,,crt_flux_stlm_bk-swf_field_52x)'
+		<!-- extraction du bloc 56 du virement bancaire -->
+`cmd_mapper(branchVirtBank,Fixed,,Fixed,,bufferDataMsg,bufferMapping56,,crt_flux_stlm_bk-swf_field_56x)'
+		<!-- extraction du bloc 57 du virement bancaire -->
+`cmd_mapper(branchVirtBank,Fixed,,Fixed,,bufferDataMsg,bufferMapping57,,crt_flux_stlm_bk-swf_field_57x)'
+		<!-- extraction du bloc 58 du virement bancaire -->
+`cmd_mapper(branchVirtBank,Fixed,,Fixed,,bufferDataMsg,bufferMapping58,,crt_flux_stlm_bk-swf_field_58x)'
+		<!-- extraction du bloc 72 du virement bancaire -->
+`cmd_mapper(branchVirtBank,Fixed,,Fixed,,bufferDataMsg,bufferMapping72,,crt_flux_stlm_bk-swf_field_72)'
+	<!-- traitement du bloc 58 specifique au virement bancaire -->
+		<!-- identifier format du bloc 58 -->
+`cmd_identifier(branchVirtBank,bufferMapping58,n,swf_field_58x,'
+`				Fixed,swf_field_58d_fmt,branchFld_D_K,'
+`				Fixed,swf_field_58a_fmt,branchFld_A_B_Blanc,'
+`				Fixed,swf_field_58b_fmt,branchFld_A_B_Blanc,'
+`				Fixed,swf_field_58vide_fmt,branchVirtBank)'
+		<!-- mapping du bloc 58A  -->
+`cmd_mapper(branchFld_A_B_Blanc,Fixed,,XML,,bufferMapping58,bufferTemp,,swf_field_58x-swf_field_58x-format_a)'
+`cmd_go_to(branchFld_A_B_Blanc,branchVirtBank)'
+		<!-- mapping du bloc 58D (hors complements) -->
+`cmd_mapper(branchFld_D_K,Fixed,,XML,,bufferMapping58,bufferTemp,,swf_field_58x-swf_field_58x-format_d)'
+		<!-- extraction de complements du bloc58D -->
+`cmd_mapper(branchFld_D_K,Fixed,,Fixed,,bufferMapping58,bufferWorkMultiligne,activeClearFlag,swf_field_58x-swf_field_58d_comp)'
+		<!-- mapping de complements du bloc58D -->
+`champ_multiligne(branchFld_D_K,bufferWorkMultiligne,bufferTemp,branchVirtBank,bufferTempMultiligne,swf_field_58d_comp-swf_field_58d_comp)'
+	<!-- fin bloc 58 -->
+`cmd_go_to(branchVirtBank,branchMappingCommunBankCus)'
+<!-- fin branche BB3 -->
+<!-- branche BB4 mapping des donnees du virement de clientele -->
+		<!-- identification du virement de clientele -->
+`cmd_identifier(branchVirtCus,bufferDataMsg,n,crt_flux_stlm_cus_sans55,'
+`				Fixed,crt_flux_stlm_cus_sans55_sans13c,branchVirtCus,'
+`				Fixed,crt_flux_stlm_cus_sans55_avec13c,branchFld13,'
+`				Fixed,crt_flux_stlm_cus_avec55_sans13c,branchFld55,'
+`				Fixed,crt_flux_stlm_cus_avec55_avec13c,branchFld55avec13C)'
+<!-- traitement sans bloc 55 et avec bloc 13C -->
+		<!-- extraction du bloc 13c -->
+`cmd_mapper(branchFld13,Fixed,,Fixed,,bufferDataMsg,bufferMapping13C,,cus_champ_13c_sans55-swf_field_13c)'
+		<!-- mapping du bloc 13c -->
+`cmd_mapper(branchFld13,Fixed,,XML,,bufferMapping13C,bufferTemp,,swf_field_13c-swf_field_13c)'
+`cmd_go_to(branchFld13,branchVirtCus)'
+<!-- traitement sans bloc 55 -->
+		<!-- extraction de la fin du virement (du bloc 56 au bloc 77) -->
+`cmd_mapper(branchVirtCus,Fixed,,Fixed,,bufferDataMsg,bufferDataVirtCus,,crt_flux_stlm_cus_56_a_77-crt_flux_stlm_cus_56_a_77-sans55-extract)'
+<!-- fin traitement sans bloc 55 -->
+<!-- traitement avec bloc 55 et bloc 13C -->
+		<!-- extraction du bloc 13c -->
+`cmd_mapper(branchFld55avec13C,Fixed,,Fixed,,bufferDataMsg,bufferMapping13C,,cus_champ_13c_avec55-swf_field_13c)'
+		<!-- mapping du bloc 13c -->
+`cmd_mapper(branchFld55avec13C,Fixed,,Fixed,,bufferMapping13C,bufferTemp,,swf_field_13c-swf_field_13c)'
+`cmd_go_to(branchFld55avec13C,branchFld55)'
+<!-- traitement avec bloc 55 -->
+		<!-- extraction de la fin du virement (du bloc 56 au bloc 77) -->
+`cmd_mapper(branchFld55,Fixed,,Fixed,,bufferDataMsg,bufferDataVirtCus,,crt_flux_stlm_cus_56_a_77-crt_flux_stlm_cus_56_a_77-avec55-extract)'
+		<!-- extraction du bloc 55 du virement bancaire -->
+`cmd_mapper(branchFld55,Fixed,,Fixed,,bufferDataMsg,bufferMapping55,,crt_flux_stlm_cus-swf_field_55x)'
+		<!-- identifier format du bloc 55 -->
+`cmd_identifier(branchFld55,bufferMapping55,n,swf_field_55x,'
+`				Fixed,swf_field_55d_fmt,branchFld_D_K,'
+`				Fixed,swf_field_55a_fmt,branchFld_A_B_Blanc,'
+`				Fixed,swf_field_55b_fmt,branchFld_A_B_Blanc,'
+`				Fixed,swf_field_55vide_fmt,branchFld_A_B_Blanc)'
+		<!-- mapping du bloc 55A  -->
+`cmd_mapper(branchFld_A_B_Blanc,Fixed,,XML,,bufferMapping55,bufferTemp,,swf_field_55x-swf_field_55x-format_a)'
+`cmd_go_to(branchFld_A_B_Blanc,branchVirtCus)'
+		<!-- mapping du bloc 55D (hors complements) -->
+`cmd_mapper(branchFld_D_K,Fixed,,XML,,bufferMapping55,bufferTemp,,swf_field_55x-swf_field_55x-format_d)'
+		<!-- extraction de complements du bloc55D -->
+`cmd_mapper(branchFld_D_K,Fixed,,Fixed,,bufferMapping55,bufferWorkMultiligne,activeClearFlag,swf_field_55x-swf_field_55d_comp)'
+		<!-- mapping de complements du bloc55D -->
+`champ_multiligne(branchFld_D_K,bufferWorkMultiligne,bufferTemp,branchVirtCus,bufferTempMultiligne,swf_field_55d_comp-swf_field_55d_comp)'
+<!-- fin traitement avec bloc 55 -->
+<!-- mapping des donnees du virement de clientele hors 13c 50 52 55 56 57 59 70 72 et 77 -->
+`cmd_mapper(branchVirtCus,Fixed,,XML,,bufferDataMsg,bufferTemp,,crt_flux_stlm_cus-crt_flux_stlm_cus)'
+`cmd_mapper(branchVirtCus,Fixed,,XML,,bufferDataVirtCus,bufferTemp,,crt_flux_stlm_cus_end-crt_flux_stlm_cus_end)'
+<!-- fin mapping des donnees du virement de clientele hors 13c 50 52 55 56 57 59 70 72 et 77 -->
+<!-- extraction des blocs 50 52 56 57 59 et 72 -->
+		<!-- extraction du bloc 50 du virement de clientele -->
+`cmd_mapper(branchVirtCus,Fixed,,Fixed,,bufferDataMsg,bufferMapping50,,crt_flux_stlm_cus-swf_field_50x)'
+		<!-- extraction du bloc 52 du virement de clientele -->
+`cmd_mapper(branchVirtCus,Fixed,,Fixed,,bufferDataMsg,bufferMapping52,,crt_flux_stlm_cus-swf_field_52x)'
+		<!-- extraction du bloc 56 du virement de clientele -->
+`cmd_mapper(branchVirtCus,Fixed,,Fixed,,bufferDataVirtCus,bufferMapping56,,crt_flux_stlm_cus_end-swf_field_56x)'
+		<!-- extraction du bloc 57 du virement de clientele -->
+`cmd_mapper(branchVirtCus,Fixed,,Fixed,,bufferDataVirtCus,bufferMapping57,,crt_flux_stlm_cus_end-swf_field_57x)'
+		<!-- extraction du bloc 59 du virement de clientele -->
+`cmd_mapper(branchVirtCus,Fixed,,Fixed,,bufferDataVirtCus,bufferMapping59,,crt_flux_stlm_cus_end-swf_field_59x)'
+		<!-- extraction du bloc 72 du virement de clientele -->
+`cmd_mapper(branchVirtCus,Fixed,,Fixed,,bufferDataVirtCus,bufferMapping72,,crt_flux_stlm_cus_end-swf_field_72)'
+<!-- fin extraction des blocs 50 52 56 57 59 et 72 -->
+<!-- mapping des blocs specifiques au virement de clientele 50 59 70 77 -->
+	<!-- traitement du bloc 50 -->
+		<!-- identifier format du bloc 50 -->
+`cmd_identifier(branchVirtCus,bufferMapping50,n,swf_field_50x,'
+`				Fixed,swf_field_50k_fmt,branchFld_D_K,'
+`				Fixed,swf_field_50a_fmt,branchFld_A_B_Blanc,'
+`				Fixed,swf_field_50vide_fmt,branchVirtCus)'
+		<!-- mapping du bloc 50A  -->
+`cmd_mapper(branchFld_A_B_Blanc,Fixed,,XML,,bufferMapping50,bufferTemp,,swf_field_50x-swf_field_50x-format_a)'
+`cmd_go_to(branchFld_A_B_Blanc,branchVirtCus)'
+		<!-- mapping du bloc 50k (hors complements) -->
+`cmd_mapper(branchFld_D_K,Fixed,,XML,,bufferMapping50,bufferTemp,,swf_field_50x-swf_field_50x-format_k)'
+		<!-- extraction de complements du bloc50k -->
+`cmd_mapper(branchFld_D_K,Fixed,,Fixed,,bufferMapping50,bufferWorkMultiligne,activeClearFlag,swf_field_50x-swf_field_50k_comp)'
+		<!-- mapping de complements du bloc50k -->
+`champ_multiligne(branchFld_D_K,bufferWorkMultiligne,bufferTemp,branchVirtCus,bufferTempMultiligne,swf_field_50k_comp-swf_field_50k_comp)'
+	<!-- fin bloc 50 -->
+	<!-- traitement du bloc 59 -->
+		<!-- identifier format du bloc 59 -->
+`cmd_identifier(branchVirtCus,bufferMapping59,n,swf_field_59x,'
+`				Fixed,swf_field_59blanc_fmt,branchFld_D_K,'
+`				Fixed,swf_field_59a_fmt,branchFld_A_B_Blanc)'
+		<!-- mapping du bloc 59A  -->
+`cmd_mapper(branchFld_A_B_Blanc,Fixed,,XML,,bufferMapping59,bufferTemp,,swf_field_59x-swf_field_59x-format_a)'
+`cmd_go_to(branchFld_A_B_Blanc,branchVirtCus)'
+		<!-- mapping du bloc 59blanc (hors complements) -->
+`cmd_mapper(branchFld_D_K,Fixed,,XML,,bufferMapping59,bufferTemp,,swf_field_59x-swf_field_59x-format_blanc)'
+		<!-- extraction de complements du bloc 59blanc -->
+`cmd_mapper(branchFld_D_K,Fixed,,Fixed,,bufferMapping59,bufferWorkMultiligne,activeClearFlag,swf_field_59x-swf_field_59blanc_comp)'
+		<!-- mapping de complements du bloc59blanc -->
+`champ_multiligne(branchFld_D_K,bufferWorkMultiligne,bufferTemp,branchVirtCus,bufferTempMultiligne,swf_field_59blanc_comp-swf_field_59blanc_comp)'
+	<!-- fin bloc 59 -->
+	<!-- traitement du bloc 70 -->
+		<!-- extraction du bloc 70 -->
+`cmd_mapper(branchVirtCus,Fixed,,Fixed,,bufferDataVirtCus,bufferWorkMultiligne,activeClearFlag,crt_flux_stlm_cus_end-swf_field_70)'
+		<!-- mapping du bloc 70 -->
+`champ_multiligne(branchVirtCus,bufferWorkMultiligne,bufferTemp,branchVirtCus,bufferTempMultiligne,swf_field_70-swf_field_70)'
+	<!-- fin bloc 70 -->
+	<!-- traitement du bloc 77 -->
+		<!-- extraction du bloc 77 -->
+`cmd_mapper(branchVirtCus,Fixed,,Fixed,,bufferDataVirtCus,bufferWorkMultiligne,activeClearFlag,crt_flux_stlm_cus_end-swf_field_77)'
+		<!-- mapping du bloc 77 -->
+`champ_multiligne(branchVirtCus,bufferWorkMultiligne,bufferTemp,branchMappingCommunBankCus,bufferTempMultiligne,swf_field_77-swf_field_77)'
+	<!-- fin bloc 77 -->
+<!-- fin mapping des blocs specifiques au virement de clientele 50 59 70 77 -->
+<!-- fin branche BB4 -->
+<!-- branche BB6 mapping des blocs communs (52 56 57 72 ) au virement bancaire et au virement de clientele -->
+<!-- bloc 52 -->		
+		<!-- identifier format du bloc 52 -->
+`cmd_identifier(branchMappingCommunBankCus,bufferMapping52,n,swf_field_52x,'
+`				Fixed,swf_field_52d_fmt,branchFld_D_K,'
+`				Fixed,swf_field_52a_fmt,branchFld_A_B_Blanc,'
+`				Fixed,swf_field_52vide_fmt,branchMappingCommunBankCus)'
+		<!-- mapping du bloc 52A  -->
+`cmd_mapper(branchFld_A_B_Blanc,Fixed,,XML,,bufferMapping52,bufferTemp,,swf_field_52x-swf_field_52x-format_a)'
+`cmd_go_to(branchFld_A_B_Blanc,branchMappingCommunBankCus)'
+		<!-- mapping du bloc 52D (hors complements) -->
+`cmd_mapper(branchFld_D_K,Fixed,,XML,,bufferMapping52,bufferTemp,,swf_field_52x-swf_field_52x-format_d)'
+		<!-- extraction de complements du bloc52D -->
+`cmd_mapper(branchFld_D_K,Fixed,,Fixed,,bufferMapping52,bufferWorkMultiligne,activeClearFlag,swf_field_52x-swf_field_52d_comp)'
+		<!-- mapping de complements du bloc52D -->
+`champ_multiligne(branchFld_D_K,bufferWorkMultiligne,bufferTemp,branchMappingCommunBankCus,bufferTempMultiligne,swf_field_52d_comp-swf_field_52d_comp)'
+<!-- fin bloc 52 -->
+<!-- bloc 56 -->		
+		<!-- identifier format du bloc 56 -->
+`cmd_identifier(branchMappingCommunBankCus,bufferMapping56,n,swf_field_56x,'
+`				Fixed,swf_field_56d_fmt,branchFld_D_K,'
+`				Fixed,swf_field_56a_fmt,branchFld_A_B_Blanc,'
+`				Fixed,swf_field_56vide_fmt,branchMappingCommunBankCus)'
+		<!-- mapping du bloc 56A  -->
+`cmd_mapper(branchFld_A_B_Blanc,Fixed,,XML,,bufferMapping56,bufferTemp,,swf_field_56x-swf_field_56x-format_a)'
+`cmd_go_to(branchFld_A_B_Blanc,branchMappingCommunBankCus)'
+		<!-- mapping du bloc 56D (hors complements) -->
+`cmd_mapper(branchFld_D_K,Fixed,,XML,,bufferMapping56,bufferTemp,,swf_field_56x-swf_field_56x-format_d)'
+		<!-- extraction de complements du bloc56D -->
+`cmd_mapper(branchFld_D_K,Fixed,,Fixed,,bufferMapping56,bufferWorkMultiligne,activeClearFlag,swf_field_56x-swf_field_56d_comp)'
+		<!-- mapping de complements du bloc56D -->
+`champ_multiligne(branchFld_D_K,bufferWorkMultiligne,bufferTemp,branchMappingCommunBankCus,bufferTempMultiligne,swf_field_56d_comp-swf_field_56d_comp)'
+<!-- fin bloc 56 -->
+<!-- bloc 57 -->		
+		<!-- identifier format du bloc 57 -->
+`cmd_identifier(branchMappingCommunBankCus,bufferMapping57,n,swf_field_57x,'
+`				Fixed,swf_field_57d_fmt,branchFld_D_K,'
+`				Fixed,swf_field_57a_fmt,branchFld_A_B_Blanc,'
+`				Fixed,swf_field_57b_fmt,branchFld_A_B_Blanc,'
+`				Fixed,swf_field_57vide_fmt,branchMappingCommunBankCus)'
+		<!-- mapping du bloc 57A  -->
+`cmd_mapper(branchFld_A_B_Blanc,Fixed,,XML,,bufferMapping57,bufferTemp,,swf_field_57x-swf_field_57x-format_a)'
+`cmd_go_to(branchFld_A_B_Blanc,branchMappingCommunBankCus)'
+		<!-- mapping du bloc 57D (hors complements) -->
+`cmd_mapper(branchFld_D_K,Fixed,,XML,,bufferMapping57,bufferTemp,,swf_field_57x-swf_field_57x-format_d)'
+		<!-- extraction de complements du bloc57D -->
+`cmd_mapper(branchFld_D_K,Fixed,,Fixed,,bufferMapping57,bufferWorkMultiligne,activeClearFlag,swf_field_57x-swf_field_57d_comp)'
+		<!-- mapping de complements du bloc57D -->
+`champ_multiligne(branchFld_D_K,bufferWorkMultiligne,bufferTemp,branchMappingCommunBankCus,bufferTempMultiligne,swf_field_57d_comp-swf_field_57d_comp)'
+<!-- fin bloc 57 -->
+<!-- bloc 72 -->
+		<!-- mapping du bloc 72 (hors autres lignes)  -->
+`cmd_mapper(branchMappingCommunBankCus,Fixed,,XML,,bufferMapping72,bufferTemp,,swf_field_72-swf_field_72)'
+		<!-- extraction de autres lignes du bloc 72 -->
+`cmd_mapper(branchMappingCommunBankCus,Fixed,,Fixed,,bufferMapping72,bufferWorkMultiligne,,swf_field_72-swf_field_72_autres_lignes)'
+		<!-- mapping de autres lignes du bloc 72 -->
+`champ_multiligne(branchMappingCommunBankCus,bufferWorkMultiligne,bufferTemp,branchTraitSelonFormat,bufferTempMultiligne,swf_field_72_autres_lignes-swf_field_72_autres_lignes)'
+<!-- fin bloc 72 -->
+<!-- fin partie commune aux flux destines a cristal et aux cre -->
+<!-- branche BB5 traitement specifiques aux ordres de restitution -->
+		<!-- mapping des entete_commun et entete_or -->
+`cmd_mapper(branchVirtOr,Fixed,,XML,,bufferWork,bufferTemp,activeClearFlag,crt_flux_header-crt_flux_header)'
+`cmd_mapper(branchVirtOr,Fixed,,XML,,bufferWork,bufferTemp,,crt_flux_or_header-crt_flux_or_header)'
+		<!-- extraction des donnees de or -->
+`cmd_mapper(branchVirtOr,Fixed,,Fixed,,bufferWork,bufferDataMsg,,crt_flux_ordre_rest-crt_flux_ordre_rest-extract_or_from_flux)'
+		<!-- mapping des ordres de restitution -->
+`cmd_mapper(branchVirtOr,Fixed,,XML,,bufferDataMsg,bufferTemp,,crt_flux_or-crt_flux_or)'
+`cmd_go_to(branchVirtOr,branchTraitSelonFormat)')
+dnl
+dnl+--------------------------------------+
+dnl|    End Macro Section                 |
+dnl+--------------------------------------+
+dnl
diff --git a/src/sd_mappath_struct/src/fixed_xml_cre.xml.m4 b/src/sd_mappath_struct/src/fixed_xml_cre.xml.m4
new file mode 100644
index 0000000..3d2e554
--- /dev/null
+++ b/src/sd_mappath_struct/src/fixed_xml_cre.xml.m4
@@ -0,0 +1,357 @@
+changecom(`<!--', `-->')dnl
+dnl
+dnl+--------------------------------------+
+dnl|    Begin Macro Section               |
+dnl+--------------------------------------+
+dnl
+define(`fixed_xml_cre',
+<!-- branche BB1030 mapping des donnees des cre sur vgm/or emis -->
+<!-- branche BB1031 mapping des donnees des cre sur vgm/or recus -->
+<!-- branche BB1032 mapping des donnees des cre de rejet -->
+<!-- branche BB1033 mapping des entete d'or pour les CRE40 -->
+<!-- branche BB1034 mapping des donnees d'or -->
+<!-- branche BB1003 mapping des donnees specifiques au virement bancaire -->
+<!-- branche BB1004 mapping des donnees specifiques au virement de clientele -->
+<!-- branche BB1005 mapping des donnees specifiques aux ordres de restitutuion (y compris entete) -->
+<!-- branche BB1006 mapping des blocs communs (52 56 57 72 ) au virement bancaire et au virement de clientele -->
+<!-- branche BB1010 mapping des blocs au format A B ou blanc -->
+<!-- branche BB1011 mapping des blocs au format D ou K -->
+<!-- branche BB1013 mapping du bloc 13C -->
+<!-- branche BB1055 et BB5513 mapping du bloc 55 -->
+<!-- Buffer BUF2 (fixed) pour donnees du virement -->
+<!-- Buffer BUF3 (fixed) pour donnees du virement de clientele (du bloc 56 au bloc 77) -->
+<!-- Buffer BUF10 (fixed) pour mapping du bloc 13C -->
+<!-- Buffer BUF11 (fixed) pour bloc 50 -->
+<!-- Buffer BUF12 (fixed) pour bloc 52 -->
+<!-- Buffer BUF13 (fixed) pour bloc 55 -->
+<!-- Buffer BUF14 (fixed) pour bloc 56 -->
+<!-- Buffer BUF15 (fixed) pour bloc 57 -->
+<!-- Buffer BUF16 (fixed) pour bloc 58 -->
+<!-- Buffer BUF17 (fixed) pour bloc 59 -->
+<!-- Buffer BUF18 (fixed) pour bloc 72 -->
+<!-- Buffer BUF20 (fixed ou delimited) pour mapping des blocs "delimited"  il est reutilise -->
+<!-- Buffer BUF21 fixed pour flux complet extrait du CRE40 -->
+		<!-- identification complete a partir de la branche BB2 -->
+`cmd_go_to(branchCommuneVirtBankCusTest,branchCreVgmEmisTest)'
+`cmd_mapper(branchCreVgmEmisTest,Fixed,,Fixed,,bufferWork,bufferCreFixed,,cut_end_msg-cut_end_msg1)'
+`cmd_identifier(branchCreVgmEmisTest,bufferCreFixed,y,crt_cre_ident,'
+`				Fixed,crt_cre_cr01,branchCreVgmEmisTest,'
+`				Fixed,crt_cre_cr02,branchCreVgmEmisTest,'
+`				Fixed,crt_cre_cr03,branchCreVgmEmisTest,'
+`				Fixed,crt_cre_cr04,branchCreVgmEmisTest,'
+`				Fixed,crt_cre_cr05,branchCreVgmEmisTest,'
+`				Fixed,crt_cre_cr06,branchCreVgmEmisTest,'
+`				Fixed,crt_cre_cr07,branchCreVgmEmisTest,'
+`				Fixed,crt_cre_cr08,branchCreVgmEmisTest,'
+`				Fixed,crt_cre_cr09,branchCreVgmEmisTest,'
+`				Fixed,crt_cre_cr10,branchCreVgmEmisTest,'
+`				Fixed,crt_cre_cr11,branchCreVgmEmisTest,'
+`				Fixed,crt_cre_cr12,branchCreVgmEmisTest,'
+`				Fixed,crt_cre_cr13,branchCreVgmEmisTest,'
+`				Fixed,crt_cre_cr14,branchCreVgmEmisTest,'
+`				Fixed,crt_cre_cr15,branchCreVgmEmisTest,'
+`				Fixed,crt_cre_cr16,branchCreVgmEmisTest,'
+`				Fixed,crt_cre_cr17,branchCreVgmEmisTest,'
+`				Fixed,crt_cre_cr18,branchCreVgmEmisTest,'
+`				Fixed,crt_cre_cr20,branchCreVgmRecuTest,'
+`				Fixed,crt_cre_cr21,branchCreVgmRecuTest,'
+`				Fixed,crt_cre_cr22,branchCreVgmRecuTest,'
+`				Fixed,crt_cre_cr23,branchCreVgmRecuTest,'
+`				Fixed,crt_cre_cr24,branchCreVgmRecuTest,'
+`				Fixed,crt_cre_cr25,branchCreVgmRecuTest,'
+`				Fixed,crt_cre_cr30,branchCreVgmRecuTest,'
+`				Fixed,crt_cre_cr31,branchCreVgmRecuTest,'
+`				Fixed,crt_cre_cr40,branchCreRejetTest)'
+<!-- branche BB1030 mapping des donnees des cre sur vgm/or emis -->
+		<!-- mapping des entete_commun et entete_cre sur vgm/or emis -->
+`cmd_mapper(branchCreVgmEmisTest,Fixed,,XML,,bufferCreFixed,bufferTemp,activeClearFlag,crt_cre_header-crt_cre_header)'
+`cmd_mapper(branchCreVgmEmisTest,Fixed,,XML,,bufferCreFixed,bufferTemp,,crt_cre_flux_emis_header-crt_cre_flux_emis_header)'
+		<!-- extraction du virement ou de l'or -->
+`cmd_mapper(branchCreVgmEmisTest,Fixed,,Fixed,,bufferCreFixed,bufferDataMsg,,crt_flux_stlm-crt_flux_stlm-extract_stlm_emis_from_cre)'
+		<!-- identification du flux -->
+`cmd_identifier(branchCreVgmEmisTest,bufferCreFixed,n,crt_cre_emis_ident,'
+`				Fixed,crt_cre_emis_vs02,branchVirtBankTest,'
+`				Fixed,crt_cre_emis_vs03,branchVirtBankTest,'
+`				Fixed,crt_cre_emis_vs04,branchVirtBankTest,'
+`				Fixed,crt_cre_emis_vs07,branchVirtCusTest,'
+`				Fixed,crt_cre_emis_vs08,branchVirtCusTest,'
+`				Fixed,crt_cre_emis_os01,branchCreRejetDataOrTest)'
+<!-- branche BB1003 mapping des donnees des cre sur vgm/or recus -->
+		<!-- mapping des entete_commun et entete_cre sur vgm/or recus -->
+`cmd_mapper(branchCreVgmRecuTest,Fixed,,XML,,bufferCreFixed,bufferTemp,activeClearFlag,crt_cre_header-crt_cre_header)'
+`cmd_mapper(branchCreVgmRecuTest,Fixed,,XML,,bufferCreFixed,bufferTemp,,crt_cre_flux_recu_header-crt_cre_flux_recu_header)'
+		<!-- extraction du virement ou de l'or -->
+`cmd_mapper(branchCreVgmRecuTest,Fixed,,Fixed,,bufferCreFixed,bufferDataMsg,,crt_flux_stlm-crt_flux_stlm-extract_stlm_recu_from_cre)'
+		<!-- identification du flux -->
+`cmd_identifier(branchCreVgmRecuTest,bufferCreFixed,n,crt_cre_recu_ident,'
+`				Fixed,crt_cre_recu_vs02,branchVirtBankTest,'
+`				Fixed,crt_cre_recu_vs03,branchVirtBankTest,'
+`				Fixed,crt_cre_recu_vs04,branchVirtBankTest,'
+`				Fixed,crt_cre_recu_vs07,branchVirtCusTest,'
+`				Fixed,crt_cre_recu_vs08,branchVirtCusTest,'
+`				Fixed,crt_cre_recu_os01,branchCreRejetDataOrTest)'
+<!-- branche BB1032 mapping des donnees des cre de rejet -->
+		<!-- mapping des entete_commun et entete_cre de rejet -->
+`cmd_mapper(branchCreRejetTest,Fixed,,XML,,bufferCreFixed,bufferTemp,activeClearFlag,crt_cre_header-crt_cre_header)'
+`cmd_mapper(branchCreRejetTest,Fixed,,XML,,bufferCreFixed,bufferTemp,,crt_cre_rejet_header-crt_cre_rejet_header)'
+		<!-- extraction du flux complet -->
+`cmd_mapper(branchCreRejetTest,Fixed,,Fixed,,bufferCreFixed,bufferFluxFromCre,,crt_flux_cre-crt_flux_cre-extract_flux_from_cre)'
+		<!-- identification complete a partir de la branche BB1032 -->
+`cmd_identifier(branchCreRejetTest,bufferFluxFromCre,n,crt_flux_ident,'
+`				Fixed,crt_flux_vs02,branchCreRejetTest,'
+`				Fixed,crt_flux_vs03,branchCreRejetTest,'
+`				Fixed,crt_flux_vs04,branchCreRejetTest,'
+`				Fixed,crt_flux_vs07,branchCreRejetTest,'
+`				Fixed,crt_flux_vs08,branchCreRejetTest,'
+`				Fixed,crt_flux_os01,branchCreRejetEnTeteOrTest)'
+<!-- CRE40 virements -->
+		<!-- mapping des entete_commun et entete_vgm -->
+`cmd_mapper(branchCreRejetTest,Fixed,,XML,,bufferFluxFromCre,bufferTemp,,crt_cre_flux_header-crt_cre_flux_header)'
+`cmd_mapper(branchCreRejetTest,Fixed,,XML,,bufferFluxFromCre,bufferTemp,,crt_cre_flux_stlm_header-crt_cre_flux_stlm_header)'
+		<!-- extraction des donnees du virement -->
+`cmd_mapper(branchCreRejetTest,Fixed,,Fixed,,bufferFluxFromCre,bufferDataMsg,,crt_flux_stlm-crt_flux_stlm-extract_stlm_from_flux)'
+		<!-- identification complete a partir de la branche BB1032 -->
+`cmd_identifier(branchCreRejetTest,bufferFluxFromCre,n,crt_flux_ident,'
+`				Fixed,crt_flux_vs02,branchVirtBankTest,'
+`				Fixed,crt_flux_vs03,branchVirtBankTest,'
+`				Fixed,crt_flux_vs04,branchVirtBankTest,'
+`				Fixed,crt_flux_vs07,branchVirtCusTest,'
+`				Fixed,crt_flux_vs08,branchVirtCusTest)'
+<!-- CRE40 fin virements -->
+<!-- CRE40 OR -->
+		<!-- mapping des entete_commun et entete_or -->
+`cmd_mapper(branchCreRejetEnTeteOrTest,Fixed,,XML,,bufferFluxFromCre,bufferTemp,,crt_cre_flux_header-crt_cre_flux_header)'
+`cmd_mapper(branchCreRejetEnTeteOrTest,Fixed,,XML,,bufferFluxFromCre,bufferTemp,,crt_cre_flux_or_header-crt_cre_flux_or_header)'
+		<!-- extraction des donnees de or -->
+`cmd_mapper(branchCreRejetEnTeteOrTest,Fixed,,Fixed,,bufferFluxFromCre,bufferDataMsg,,crt_flux_ordre_rest-crt_flux_ordre_rest-extract_or_from_flux)'
+`cmd_go_to(branchCreRejetEnTeteOrTest,branchCreRejetDataOrTest)'
+<!-- CRE40 fin OR -->
+<!-- fin branche BB1032 mapping des donnees des cre de rejet -->
+<!-- partie commune aux flux destines a cristal et aux cre -->
+<!-- branche BB1003 mapping des donnees du virement bancaire -->
+		<!-- mapping des donnees du virement bancaire hors 13c 52 56 57 58 et 72 -->
+`cmd_mapper(branchVirtBankTest,Fixed,,XML,,bufferDataMsg,bufferTemp,,crt_cre_flux_stlm_bk-crt_cre_flux_stlm_bk)'
+	<!-- bloc 13C -->
+		<!-- recherche existence du bloc 13C -->
+`cmd_identifier(branchVirtBankTest,bufferDataMsg,n,crt_flux_stlm_sans13c,'
+`				Fixed,crt_flux_stlm_bk_sans13c,branchVirtBankTest,'
+`				Fixed,crt_flux_stlm_bk_avec13c,branchFld13Test)'
+		<!-- extraction du bloc 13c -->
+`cmd_mapper(branchFld13Test,Fixed,,Fixed,,bufferDataMsg,bufferMapping13C,,crt_flux_stlm_bk-swf_field_13c)'
+		<!-- mapping du bloc 13c -->
+`cmd_mapper(branchFld13Test,Fixed,,XML,,bufferMapping13C,bufferTemp,,swf_cre_field_13c-swf_cre_field_13c)'
+`cmd_go_to(branchFld13Test,branchVirtBankTest)'
+	<!-- fin bloc 13C -->
+		<!-- extraction du bloc 52 du virement bancaire -->
+`cmd_mapper(branchVirtBankTest,Fixed,,Fixed,,bufferDataMsg,bufferMapping52,,crt_flux_stlm_bk-swf_field_52x)'
+		<!-- extraction du bloc 56 du virement bancaire -->
+`cmd_mapper(branchVirtBankTest,Fixed,,Fixed,,bufferDataMsg,bufferMapping56,,crt_flux_stlm_bk-swf_field_56x)'
+		<!-- extraction du bloc 57 du virement bancaire -->
+`cmd_mapper(branchVirtBankTest,Fixed,,Fixed,,bufferDataMsg,bufferMapping57,,crt_flux_stlm_bk-swf_field_57x)'
+		<!-- extraction du bloc 58 du virement bancaire -->
+`cmd_mapper(branchVirtBankTest,Fixed,,Fixed,,bufferDataMsg,bufferMapping58,,crt_flux_stlm_bk-swf_field_58x)'
+		<!-- extraction du bloc 72 du virement bancaire -->
+`cmd_mapper(branchVirtBankTest,Fixed,,Fixed,,bufferDataMsg,bufferMapping72,,crt_flux_stlm_bk-swf_field_72)'
+	<!-- traitement du bloc 58 specifique au virement bancaire -->
+		<!-- identifier format du bloc 58 -->
+`cmd_identifier(branchVirtBankTest,bufferMapping58,n,swf_field_58x,'
+`				Fixed,swf_field_58d_fmt,branchFld_D_KTest,'
+`				Fixed,swf_field_58a_fmt,branchFld_A_B_BlancTest,'
+`				Fixed,swf_field_58b_fmt,branchFld_A_B_BlancTest,'
+`				Fixed,swf_field_58vide_fmt,branchVirtBankTest)'
+		<!-- mapping du bloc 58A  -->
+`cmd_mapper(branchFld_A_B_BlancTest,Fixed,,XML,,bufferMapping58,bufferTemp,,swf_cre_field_58x-swf_cre_field_58x-format_a)'
+`cmd_go_to(branchFld_A_B_BlancTest,branchVirtBankTest)'
+		<!-- mapping du bloc 58D (hors complements) -->
+`cmd_mapper(branchFld_D_KTest,Fixed,,XML,,bufferMapping58,bufferTemp,,swf_cre_field_58x-swf_cre_field_58x-format_d)'
+		<!-- extraction de complements du bloc58D -->
+`cmd_mapper(branchFld_D_KTest,Fixed,,Fixed,,bufferMapping58,bufferWorkMultiligne,activeClearFlag,swf_field_58x-swf_field_58d_comp)'
+		<!-- mapping de complements du bloc58D -->
+`cmd_mapper(branchFld_D_KTest,Delimited,crlf_t,XML,,bufferWorkMultiligne,bufferTemp,,swf_cre_field_58d_comp-swf_cre_field_58d_comp)'
+`cmd_go_to(branchFld_D_KTest,branchVirtBankTest)'
+	<!-- fin bloc 58 -->
+`cmd_go_to(branchVirtBankTest,branchMappingCommunBankCusTest)'
+<!-- fin branche BB1003 -->
+<!-- branche BB1004 mapping des donnees du virement de clientele -->
+		<!-- identification du virement de clientele -->
+`cmd_identifier(branchVirtCusTest,bufferDataMsg,n,crt_flux_stlm_cus_sans55,'
+`				Fixed,crt_flux_stlm_cus_sans55_sans13c,branchVirtCusTest,'
+`				Fixed,crt_flux_stlm_cus_sans55_avec13c,branchFld13Test,'
+`				Fixed,crt_flux_stlm_cus_avec55_sans13c,branchFld55Test,'
+`				Fixed,crt_flux_stlm_cus_avec55_avec13c,branchFld55avec13CTest)'
+<!-- traitement sans bloc 55 et avec bloc 13C -->
+		<!-- extraction du bloc 13c -->
+`cmd_mapper(branchFld13Test,Fixed,,Fixed,,bufferDataMsg,bufferMapping13C,,cus_champ_13c_sans55-swf_field_13c)'
+		<!-- mapping du bloc 13c -->
+`cmd_mapper(branchFld13Test,Fixed,,Fixed,,bufferMapping13C,bufferTemp,,swf_field_13c-swf_field_13c)'
+`cmd_go_to(branchFld13Test,branchVirtCusTest)'
+<!-- traitement sans bloc 55 -->
+		<!-- extraction de la fin du virement (du bloc 56 au bloc 77) -->
+`cmd_mapper(branchVirtCusTest,Fixed,,Fixed,,bufferDataMsg,bufferDataVirtCus,,crt_flux_stlm_cus_56_a_77-crt_flux_stlm_cus_56_a_77-sans55-extract)'
+<!-- fin traitement sans bloc 55 -->
+<!-- traitement avec bloc 55 et bloc 13C -->
+		<!-- extraction du bloc 13c -->
+`cmd_mapper(branchFld55avec13CTest,Fixed,,Fixed,,bufferDataMsg,bufferMapping13C,,cus_champ_13c_avec55-swf_field_13c)'
+		<!-- mapping du bloc 13c -->
+`cmd_mapper(branchFld55avec13CTest,Fixed,,Fixed,,bufferMapping13C,bufferTemp,,swf_field_13c-swf_field_13c)'
+`cmd_go_to(branchFld55avec13CTest,branchFld55Test)'
+<!-- traitement avec bloc 55 -->
+		<!-- extraction de la fin du virement (du bloc 56 au bloc 77) -->
+`cmd_mapper(branchFld55Test,Fixed,,Fixed,,bufferDataMsg,bufferDataVirtCus,,crt_flux_stlm_cus_56_a_77-crt_flux_stlm_cus_56_a_77-avec55-extract)'
+		<!-- extraction du bloc 55 du virement bancaire -->
+`cmd_mapper(branchFld55Test,Fixed,,Fixed,,bufferDataMsg,bufferMapping55,,crt_flux_stlm_cus-swf_field_55x)'
+		<!-- identifier format du bloc 55 -->
+`cmd_identifier(branchFld55Test,bufferMapping55,n,swf_field_55x,'
+`				Fixed,swf_field_55d_fmt,branchFld_D_KTest,'
+`				Fixed,swf_field_55a_fmt,branchFld_A_B_BlancTest,'
+`				Fixed,swf_field_55b_fmt,branchFld_A_B_BlancTest,'
+`				Fixed,swf_field_55vide_fmt,branchFld_A_B_BlancTest)'
+		<!-- mapping du bloc 55A  -->
+`cmd_mapper(branchFld_A_B_BlancTest,Fixed,,XML,,bufferMapping55,bufferTemp,,swf_cre_field_55x-swf_cre_field_55x-format_a)'
+`cmd_go_to(branchFld_A_B_BlancTest,branchVirtCusTest)'
+		<!-- mapping du bloc 55D (hors complements) -->
+`cmd_mapper(branchFld_D_KTest,Fixed,,XML,,bufferMapping55,bufferTemp,,swf_cre_field_55x-swf_cre_field_55x-format_d)'
+		<!-- extraction de complements du bloc55D -->
+`cmd_mapper(branchFld_D_KTest,Fixed,,Fixed,,bufferMapping55,bufferWorkMultiligne,activeClearFlag,swf_field_55x-swf_field_55d_comp)'
+		<!-- mapping de complements du bloc55D -->
+`cmd_mapper(branchFld_D_KTest,Delimited,crlf_t,XML,,bufferWorkMultiligne,bufferTemp,,swf_cre_field_55d_comp-swf_cre_field_55d_comp)'
+`cmd_go_to(branchFld_D_KTest,branchVirtCusTest)'
+<!-- fin traitement avec bloc 55 -->
+<!-- mapping des donnees du virement de clientele hors 13c 50 52 55 56 57 59 70 72 et 77 -->
+`cmd_mapper(branchVirtCusTest,Fixed,,XML,,bufferDataMsg,bufferTemp,,crt_cre_flux_stlm_cus-crt_cre_flux_stlm_cus)'
+`cmd_mapper(branchVirtCusTest,Fixed,,XML,,bufferDataVirtCus,bufferTemp,,crt_cre_flux_stlm_cus_end-crt_cre_flux_stlm_cus_end)'
+<!-- fin mapping des donnees du virement de clientele hors 13c 50 52 55 56 57 59 70 72 et 77 -->
+<!-- extraction des blocs 50 52 56 57 59 et 72 -->
+		<!-- extraction du bloc 50 du virement de clientele -->
+`cmd_mapper(branchVirtCusTest,Fixed,,Fixed,,bufferDataMsg,bufferMapping50,,crt_flux_stlm_cus-swf_field_50x)'
+		<!-- extraction du bloc 52 du virement de clientele -->
+`cmd_mapper(branchVirtCusTest,Fixed,,Fixed,,bufferDataMsg,bufferMapping52,,crt_flux_stlm_cus-swf_field_52x)'
+		<!-- extraction du bloc 56 du virement de clientele -->
+`cmd_mapper(branchVirtCusTest,Fixed,,Fixed,,bufferDataVirtCus,bufferMapping56,,crt_flux_stlm_cus_end-swf_field_56x)'
+		<!-- extraction du bloc 57 du virement de clientele -->
+`cmd_mapper(branchVirtCusTest,Fixed,,Fixed,,bufferDataVirtCus,bufferMapping57,,crt_flux_stlm_cus_end-swf_field_57x)'
+		<!-- extraction du bloc 59 du virement de clientele -->
+`cmd_mapper(branchVirtCusTest,Fixed,,Fixed,,bufferDataVirtCus,bufferMapping59,,crt_flux_stlm_cus_end-swf_field_59x)'
+		<!-- extraction du bloc 72 du virement de clientele -->
+`cmd_mapper(branchVirtCusTest,Fixed,,Fixed,,bufferDataVirtCus,bufferMapping72,,crt_flux_stlm_cus_end-swf_field_72)'
+<!-- fin extraction des blocs 50 52 56 57 59 et 72 -->
+<!-- mapping des blocs specifiques au virement de clientele 50 59 70 77 -->
+	<!-- traitement du bloc 50 -->
+		<!-- identifier format du bloc 50 -->
+`cmd_identifier(branchVirtCusTest,bufferMapping50,n,swf_field_50x,'
+`				Fixed,swf_field_50k_fmt,branchFld_D_KTest,'
+`				Fixed,swf_field_50a_fmt,branchFld_A_B_BlancTest,'
+`				Fixed,swf_field_50vide_fmt,branchVirtCusTest)'
+		<!-- mapping du bloc 50A  -->
+`cmd_mapper(branchFld_A_B_BlancTest,Fixed,,XML,,bufferMapping50,bufferTemp,,swf_cre_field_50x-swf_cre_field_50x-format_a)'
+`cmd_go_to(branchFld_A_B_BlancTest,branchVirtCusTest)'
+		<!-- mapping du bloc 50k (hors complements) -->
+`cmd_mapper(branchFld_D_KTest,Fixed,,XML,,bufferMapping50,bufferTemp,,swf_cre_field_50x-swf_cre_field_50x-format_k)'
+		<!-- extraction de complements du bloc50k -->
+`cmd_mapper(branchFld_D_KTest,Fixed,,Fixed,,bufferMapping50,bufferWorkMultiligne,activeClearFlag,swf_field_50x-swf_field_50k_comp)'
+		<!-- mapping de complements du bloc50k -->
+`cmd_mapper(branchFld_D_KTest,Delimited,crlf_t,XML,,bufferWorkMultiligne,bufferTemp,,swf_cre_field_50k_comp-swf_cre_field_50k_comp)'
+`cmd_go_to(branchFld_D_KTest,branchVirtCusTest)'
+	<!-- fin bloc 50 -->
+	<!-- traitement du bloc 59 -->
+		<!-- identifier format du bloc 59 -->
+`cmd_identifier(branchVirtCusTest,bufferMapping59,n,swf_field_59x,'
+`				Fixed,swf_field_59blanc_fmt,branchFld_D_KTest,'
+`				Fixed,swf_field_59a_fmt,branchFld_A_B_BlancTest)'
+		<!-- mapping du bloc 59A  -->
+`cmd_mapper(branchFld_A_B_BlancTest,Fixed,,XML,,bufferMapping59,bufferTemp,,swf_cre_field_59x-swf_cre_field_59x-format_a)'
+`cmd_go_to(branchFld_A_B_BlancTest,branchVirtCusTest)'
+		<!-- mapping du bloc 59blanc (hors complements) -->
+`cmd_mapper(branchFld_D_KTest,Fixed,,XML,,bufferMapping59,bufferTemp,,swf_cre_field_59x-swf_cre_field_59x-format_blanc)'
+		<!-- extraction de complements du bloc 59blanc -->
+`cmd_mapper(branchFld_D_KTest,Fixed,,Fixed,,bufferMapping59,bufferWorkMultiligne,activeClearFlag,swf_field_59x-swf_field_59blanc_comp)'
+		<!-- mapping de complements du bloc59blanc -->
+`cmd_mapper(branchFld_D_KTest,Delimited,crlf_t,XML,,bufferWorkMultiligne,bufferTemp,,swf_cre_field_59blanc_comp-swf_cre_field_59blanc_comp)'
+`cmd_go_to(branchFld_D_KTest,branchVirtCusTest)'
+	<!-- fin bloc 59 -->
+	<!-- traitement du bloc 70 -->
+		<!-- extraction du bloc 70 -->
+`cmd_mapper(branchVirtCusTest,Fixed,,Fixed,,bufferDataVirtCus,bufferWorkMultiligne,activeClearFlag,crt_flux_stlm_cus_end-swf_field_70)'
+		<!-- mapping du bloc 70 -->
+`cmd_mapper(branchVirtCusTest,Delimited,crlf_t,XML,,bufferWorkMultiligne,bufferTemp,,swf_cre_field_70-swf_cre_field_70)'
+	<!-- fin bloc 70 -->
+	<!-- traitement du bloc 77 -->
+		<!-- extraction du bloc 77 -->
+`cmd_mapper(branchVirtCusTest,Fixed,,Fixed,,bufferDataVirtCus,bufferWorkMultiligne,activeClearFlag,crt_flux_stlm_cus_end-swf_field_77)'
+		<!-- mapping du bloc 77 -->
+`cmd_mapper(branchVirtCusTest,Delimited,crlf_t,XML,,bufferWorkMultiligne,bufferTemp,,swf_cre_field_77-swf_cre_field_77)'
+	<!-- fin bloc 77 -->
+<!-- fin mapping des blocs specifiques au virement de clientele 50 59 70 77 -->
+`cmd_go_to(branchVirtCusTest,branchMappingCommunBankCusTest)'
+<!-- fin branche BB1004 -->
+<!-- branche BB1006 mapping des blocs communs (52 56 57 72 ) au virement bancaire et au virement de clientele -->
+<!-- bloc 52 -->		
+		<!-- identifier format du bloc 52 -->
+`cmd_identifier(branchMappingCommunBankCusTest,bufferMapping52,n,swf_field_52x,'
+`				Fixed,swf_field_52d_fmt,branchFld_D_KTest,'
+`				Fixed,swf_field_52a_fmt,branchFld_A_B_BlancTest,'
+`				Fixed,swf_field_52vide_fmt,branchMappingCommunBankCusTest)'
+		<!-- mapping du bloc 52A  -->
+`cmd_mapper(branchFld_A_B_BlancTest,Fixed,,XML,,bufferMapping52,bufferTemp,,swf_cre_field_52x-swf_cre_field_52x-format_a)'
+`cmd_go_to(branchFld_A_B_BlancTest,branchMappingCommunBankCusTest)'
+		<!-- mapping du bloc 52D (hors complements) -->
+`cmd_mapper(branchFld_D_KTest,Fixed,,XML,,bufferMapping52,bufferTemp,,swf_cre_field_52x-swf_cre_field_52x-format_d)'
+		<!-- extraction de complements du bloc52D -->
+`cmd_mapper(branchFld_D_KTest,Fixed,,Fixed,,bufferMapping52,bufferWorkMultiligne,activeClearFlag,swf_field_52x-swf_field_52d_comp)'
+		<!-- mapping de complements du bloc52D -->
+`cmd_mapper(branchFld_D_KTest,Delimited,crlf_t,XML,,bufferWorkMultiligne,bufferTemp,,swf_cre_field_52d_comp-swf_cre_field_52d_comp)'
+`cmd_go_to(branchFld_D_KTest,branchMappingCommunBankCusTest)'
+<!-- fin bloc 52 -->
+<!-- bloc 56 -->		
+		<!-- identifier format du bloc 56 -->
+`cmd_identifier(branchMappingCommunBankCusTest,bufferMapping56,n,swf_field_56x,'
+`				Fixed,swf_field_56d_fmt,branchFld_D_KTest,'
+`				Fixed,swf_field_56a_fmt,branchFld_A_B_BlancTest,'
+`				Fixed,swf_field_56vide_fmt,branchMappingCommunBankCusTest)'
+		<!-- mapping du bloc 56A  -->
+`cmd_mapper(branchFld_A_B_BlancTest,Fixed,,XML,,bufferMapping56,bufferTemp,,swf_cre_field_56x-swf_cre_field_56x-format_a)'
+`cmd_go_to(branchFld_A_B_BlancTest,branchMappingCommunBankCusTest)'
+		<!-- mapping du bloc 56D (hors complements) -->
+`cmd_mapper(branchFld_D_KTest,Fixed,,XML,,bufferMapping56,bufferTemp,,swf_cre_field_56x-swf_cre_field_56x-format_d)'
+		<!-- extraction de complements du bloc56D -->
+`cmd_mapper(branchFld_D_KTest,Fixed,,Fixed,,bufferMapping56,bufferWorkMultiligne,activeClearFlag,swf_field_56x-swf_field_56d_comp)'
+		<!-- mapping de complements du bloc56D -->
+`cmd_mapper(branchFld_D_KTest,Delimited,crlf_t,XML,,bufferWorkMultiligne,bufferTemp,,swf_cre_field_56d_comp-swf_cre_field_56d_comp)'
+`cmd_go_to(branchFld_D_KTest,branchMappingCommunBankCusTest)'
+<!-- fin bloc 56 -->
+<!-- bloc 57 -->		
+		<!-- identifier format du bloc 57 -->
+`cmd_identifier(branchMappingCommunBankCusTest,bufferMapping57,n,swf_field_57x,'
+`				Fixed,swf_field_57d_fmt,branchFld_D_KTest,'
+`				Fixed,swf_field_57a_fmt,branchFld_A_B_BlancTest,'
+`				Fixed,swf_field_57b_fmt,branchFld_A_B_BlancTest,'
+`				Fixed,swf_field_57vide_fmt,branchMappingCommunBankCusTest)'
+		<!-- mapping du bloc 57A  -->
+`cmd_mapper(branchFld_A_B_BlancTest,Fixed,,XML,,bufferMapping57,bufferTemp,,swf_cre_field_57x-swf_cre_field_57x-format_a)'
+`cmd_go_to(branchFld_A_B_BlancTest,branchMappingCommunBankCusTest)'
+		<!-- mapping du bloc 57D (hors complements) -->
+`cmd_mapper(branchFld_D_KTest,Fixed,,XML,,bufferMapping57,bufferTemp,,swf_cre_field_57x-swf_cre_field_57x-format_d)'
+		<!-- extraction de complements du bloc57D -->
+`cmd_mapper(branchFld_D_KTest,Fixed,,Fixed,,bufferMapping57,bufferWorkMultiligne,activeClearFlag,swf_field_57x-swf_field_57d_comp)'
+		<!-- mapping de complements du bloc57D -->
+`cmd_mapper(branchFld_D_KTest,Delimited,crlf_t,XML,,bufferWorkMultiligne,bufferTemp,,swf_cre_field_57d_comp-swf_cre_field_57d_comp)'
+`cmd_go_to(branchFld_D_KTest,branchMappingCommunBankCusTest)'
+<!-- fin bloc 57 -->
+<!-- bloc 72 -->
+		<!-- mapping du bloc 72 (hors autres lignes)  -->
+`cmd_mapper(branchMappingCommunBankCusTest,Fixed,,XML,,bufferMapping72,bufferTemp,,swf_cre_field_72-swf_cre_field_72)'
+		<!-- extraction de autres lignes du bloc 72 -->
+`cmd_mapper(branchMappingCommunBankCusTest,Fixed,,Fixed,,bufferMapping72,bufferWorkMultiligne,,swf_field_72-swf_field_72_autres_lignes)'
+		<!-- mapping de autres lignes du bloc 72 -->
+`cmd_mapper(branchMappingCommunBankCusTest,Delimited,crlf_t,XML,,bufferWorkMultiligne,bufferTemp,,swf_cre_field_72_autres_lignes-swf_cre_field_72_autres_lignes)'
+`cmd_go_to(branchMappingCommunBankCusTest,branchTraitSelonFormat)'
+<!-- fin bloc 72 -->
+<!-- fin partie commune aux flux destines a cristal et aux cre -->
+		<!-- mapping des ordres de restitution -->
+`cmd_mapper(branchCreRejetDataOrTest,Fixed,,XML,,bufferDataMsg,bufferTemp,,crt_cre_flux_or-crt_cre_flux_or)'
+`cmd_go_to(branchCreRejetDataOrTest,branchTraitSelonFormat)')
+dnl
+dnl+--------------------------------------+
+dnl|    End Macro Section                 |
+dnl+--------------------------------------+
+dnl
diff --git a/src/sd_mappath_struct/src/mappath_cmd.xml.m4 b/src/sd_mappath_struct/src/mappath_cmd.xml.m4
new file mode 100644
index 0000000..61a275c
--- /dev/null
+++ b/src/sd_mappath_struct/src/mappath_cmd.xml.m4
@@ -0,0 +1,200 @@
+changecom(`<!--', `-->')dnl
+dnl
+dnl+-----------------------------+
+dnl|    Begin Macro Section      |
+dnl|                             |
+dnl| $1 : branche_id from        |
+dnl| $2 : branche_id to          |
+dnl+-----------------------------+
+dnl
+define(`cmd_go_to',
+`		<mapcmd>
+`			<branche_id>$1</branche_id>'
+`			<go_to>'
+`				<branche_id>$2</branche_id>'
+`			</go_to>'
+`		</mapcmd>'')
+dnl
+dnl+-----------------------------+
+dnl|     End Macro Section       |
+dnl+-----------------------------+
+dnl
+dnl
+dnl+-----------------------------+
+dnl|    Begin Macro Section      |
+dnl|                             |
+dnl| $1 : branche_id             |
+dnl| $2 : inputbuffer            |
+dnl| $3 : outputbuffer           |
+dnl+-----------------------------+
+dnl
+define(`cmd_copie',
+`		<mapcmd>
+`			<branche_id>$1</branche_id>'
+`			<copie>'
+`				<inputbuffer>$2</inputbuffer>'
+`				<outputbuffer>$3</outputbuffer>'
+`			</copie>'
+`		</mapcmd>'')
+dnl
+dnl+-----------------------------+
+dnl|     End Macro Section       |
+dnl+-----------------------------+
+dnl
+dnl
+dnl+-----------------------------+
+dnl|    Begin Macro Section      |
+dnl|                             |
+dnl| $1 : branche_id             |
+dnl| $2 : inputformat            |
+dnl| $3 : inputformat_attr       |
+dnl| $4 : outputformat           |
+dnl| $5 : outputformat_attr      |
+dnl| $6 : inputbuffer            |
+dnl| $7 : outputbuffer           |
+dnl| $8 : clearflag              |
+dnl| $9 : msgmap                 |
+dnl+-----------------------------+
+dnl
+define(`cmd_mapper',
+`		<mapcmd>
+`			<branche_id>$1</branche_id>'
+`			<mapper>'
+`				<inputformat>$2</inputformat>'
+ifelse($3,,`dnl',`				<inputformat_attr>$3</inputformat_attr>')
+`				<outputformat>$4</outputformat>'
+ifelse($5,,`dnl',`				<outputformat_attr>$5</outputformat_attr>')
+`				<inputbuffer>$6</inputbuffer>'
+`				<outputbuffer>$7</outputbuffer>'
+ifelse($8,,`dnl',`				<clearflag>$8</clearflag>')
+`				<msgmap>$9</msgmap>'
+`			</mapper>'
+`		</mapcmd>'')
+dnl
+dnl+-----------------------------+
+dnl|     End Macro Section       |
+dnl+-----------------------------+
+dnl
+dnl
+dnl+-----------------------------+
+dnl|    Begin Macro Section      |
+dnl|                             |
+dnl| $1 : branche_id             |
+dnl| $2 : numbuffer              |
+dnl| $3 : identtotal             |
+dnl| $4 : type                   |
+dnl+-----------------------------+
+dnl
+define(`begin_cmd_identifier',
+`		<mapcmd>
+`			<branche_id>$1</branche_id>'
+`			<identifier>'
+`				<numbuffer>$2</numbuffer>'
+`				<identtotal>$3</identtotal>'
+`				<type>$4</type>'')
+dnl
+dnl+-----------------------------+
+dnl|     End Macro Section       |
+dnl+-----------------------------+
+dnl
+dnl
+dnl+-----------------------------+
+dnl|    Begin Macro Section      |
+dnl+-----------------------------+
+dnl
+define(`end_cmd_identifier',
+`			</identifier>
+`		</mapcmd>'')
+dnl
+dnl+-----------------------------+
+dnl|     End Macro Section       |
+dnl+-----------------------------+
+dnl
+dnl
+dnl+-----------------------------+
+dnl|    Begin Macro Section      |
+dnl|                             |
+dnl| $1 : format                 |
+dnl| $2 : type                   |
+dnl| $3 : branche_id             |
+dnl+-----------------------------+
+dnl
+define(`cmd_jump',
+`				<go_to>
+`					<format>$1</format>'
+`					<type>$2</type>'
+`					<branche_id>$3</branche_id>'
+`				</go_to>'')
+dnl
+dnl+-----------------------------+
+dnl|     End Macro Section       |
+dnl+-----------------------------+
+dnl
+dnl
+dnl+-----------------------------+
+dnl|    Begin Macro Section      |
+dnl+-----------------------------+
+dnl
+define(`list_cmd_jump',
+`ifelse($@,,,`cmd_jump($1,$2,$3)'
+`list_cmd_jump(shift(shift(shift($@))))')')
+dnl `cmd_jump($1,$2,$3)list_cmd_jump(shift(shift(shift($@))))')')
+dnl
+dnl+-----------------------------+
+dnl|     End Macro Section       |
+dnl+-----------------------------+
+dnl
+dnl
+dnl+-----------------------------+
+dnl|    Begin Macro Section      |
+dnl|                             |
+dnl| $1 : branche_id             |
+dnl| $2 : numbuffer              |
+dnl| $3 : identtotal             |
+dnl| $4 : type                   |
+dnl| $i+5 : format               |
+dnl| $i+6 : type                 |
+dnl| $i+7 : branche_id           |
+dnl+-----------------------------+
+dnl
+define(`cmd_identifier',
+`begin_cmd_identifier($1,$2,$3,$4)'
+`list_cmd_jump(shift(shift(shift(shift($@)))))'dnl
+`end_cmd_identifier')
+dnl
+dnl+-----------------------------+
+dnl|     End Macro Section       |
+dnl+-----------------------------+
+dnl
+dnl
+dnl+-----------------------------+
+dnl|    Begin Macro Section      |
+dnl|                             |
+dnl| $1 : branche_id             |
+dnl| $2 : inputbuffer            |
+dnl| $3 : outputbuffer           |
+dnl| $4 : branche_id goto        |
+dnl| $5 : tempbuffer             |
+dnl| $6 : msgmap                 |
+dnl+-----------------------------+
+dnl
+define(`champ_multiligne',
+
+`cmd_mapper($1,Delimited,ffff_t,Fixed,,$2,$5,activeClearFlag,msgmap_delimited_fixed)'
+`cmd_identifier($1,$2,n,delimited_ident,'
+`				Delimited,delimited_test,branchDelimitedFfffT,'
+`				Delimited,unknown,$1)'
+`cmd_mapper($1,Delimited,zzzz_t,Fixed,,$2,$5,activeClearFlag,msgmap_delimited_fixed)'
+`cmd_identifier($1,$2,n,delimited_ident,'
+`				Delimited,delimited_test,branchDelimitedZzzzT,'
+`				Delimited,unknown,branchDelimitedCrlfT)'
+`cmd_mapper(branchDelimitedFfffT,Delimited,ffff_t,XML,,$2,$3,,$6)'
+`cmd_go_to(branchDelimitedFfffT,$4)'
+`cmd_mapper(branchDelimitedZzzzT,Delimited,zzzz_t,XML,,$2,$3,,$6)'
+`cmd_go_to(branchDelimitedZzzzT,$4)'
+`cmd_mapper(branchDelimitedCrlfT,Delimited,crlf_t,XML,,$2,$3,,$6)'
+`cmd_go_to(branchDelimitedCrlfT,$4)')
+dnl
+dnl+-----------------------------+
+dnl|     End Macro Section       |
+dnl+-----------------------------+
diff --git a/src/sd_mappath_struct/src/mappath_commun.xml.m4 b/src/sd_mappath_struct/src/mappath_commun.xml.m4
new file mode 100644
index 0000000..290a301
--- /dev/null
+++ b/src/sd_mappath_struct/src/mappath_commun.xml.m4
@@ -0,0 +1,212 @@
+changecom(`<!--', `-->')dnl
+dnl
+dnl+-----------------------------+
+dnl|    Begin Macro Section      |
+dnl+-----------------------------+
+dnl
+define(`header_mappath',
+`<?xml version="1.0" ?>
+`<!-- MapPath Struct definitions -->'
+`<mappath_struct>'')
+dnl
+dnl+-----------------------------+
+dnl|     End Macro Section       |
+dnl+-----------------------------+
+dnl
+dnl
+dnl+-----------------------------+
+dnl|    Begin Macro Section      |
+dnl+-----------------------------+
+dnl
+define(`footer_mappath',
+`<!-- MapPath Struct definitions footer -->
+`</mappath_struct>'')
+dnl
+dnl+-----------------------------+
+dnl|     End Macro Section       |
+dnl+-----------------------------+
+dnl
+dnl
+dnl+-----------------------------+
+dnl|    Begin Macro Section      |
+dnl|                             |
+dnl| $1 : la chaine VERSION      |
+dnl+-----------------------------+
+dnl
+define(`insert_version',
+`<version>$1</version>')
+dnl
+dnl+-----------------------------+
+dnl|     End Macro Section       |
+dnl+-----------------------------+
+dnl
+dnl
+dnl+-----------------------------+
+dnl|    Begin Macro Section      |
+dnl|                             |
+dnl| $1 : inputappli             |
+dnl| $2 : outputappli            |
+dnl| $3 : inputformat            |
+dnl| $4 : outputformat           |
+dnl+-----------------------------+
+dnl
+define(`begin_mappath',
+`	<mappath>
+`		<inputappli>$1</inputappli>'
+`		<outputappli>$2</outputappli>'
+`		<inputformat>$3</inputformat>'
+`		<outputformat>$4</outputformat>'')
+dnl
+dnl+-----------------------------+
+dnl|     End Macro Section       |
+dnl+-----------------------------+
+dnl
+dnl
+dnl+-----------------------------+
+dnl|    Begin Macro Section      |
+dnl+-----------------------------+
+dnl
+define(`end_mappath',
+`	</mappath>')
+dnl
+dnl+-----------------------------+
+dnl|     End Macro Section       |
+dnl+-----------------------------+
+dnl
+dnl
+dnl+-----------------------------+
+dnl|    Begin Macro Section      |
+dnl+-----------------------------+
+dnl
+define(`ident_raw',
+`begin_cmd_identifier($1,$2,y,unknown)'
+`cmd_jump($3,unknown,$4)'
+`cmd_jump($5,unknown,$6)'
+`end_cmd_identifier()')
+dnl
+dnl+-----------------------------+
+dnl|     End Macro Section       |
+dnl+-----------------------------+
+dnl
+dnl
+dnl+-----------------------------+
+dnl|    Begin Macro Section      |
+dnl+-----------------------------+
+dnl
+define(`stripping_fml',
+`cmd_mapper($1,FML,,Fixed,,$2,$3,,msgmap_fixed_fml)')
+dnl
+dnl+-----------------------------+
+dnl|     End Macro Section       |
+dnl+-----------------------------+
+dnl
+dnl
+dnl+-----------------------------+
+dnl|    Begin Macro Section      |
+dnl+-----------------------------+
+dnl
+define(`dressing_fml',
+`cmd_mapper($1,Fixed,,FML,,$2,$3,,msgmap_fixed_fml)')
+dnl
+dnl+-----------------------------+
+dnl|     End Macro Section       |
+dnl+-----------------------------+
+dnl
+dnl
+dnl+---------------------------------------------------------------------------+
+dnl|     Begin buffer definition                                               |
+dnl+---------------------------------------------------------------------------+
+dnl
+define(`bufferMainInput',`0')
+define(`bufferMainOutput',`1')
+define(`bufferWork',`48')
+define(`bufferTemp',`49')
+define(`bufferCreFixed',`46')
+define(`bufferFluxFromCre',`21')
+define(`bufferDataMsg',`2')
+define(`bufferDataVirtCus',`3')
+define(`bufferOcc13C',`19')
+define(`bufferMapping13C',`10')
+define(`bufferMapping50',`11')
+define(`bufferMapping52',`12')
+define(`bufferMapping55',`13')
+define(`bufferMapping56',`14')
+define(`bufferMapping57',`15')
+define(`bufferMapping58',`16')
+define(`bufferMapping59',`17')
+define(`bufferMapping72',`18')
+define(`bufferWorkMultiligne',`20')
+define(`bufferTempMultiligne',`22')
+define(`bufferTempMatccTitres',`30')
+dnl
+dnl+---------------------------------------------------------------------------+
+dnl|       End buffer definition                                               |
+dnl+---------------------------------------------------------------------------+
+dnl
+dnl
+dnl+---------------------------------------------------------------------------+
+dnl|     Begin branch id definition                                            |
+dnl+---------------------------------------------------------------------------+
+dnl
+define(`branchInitiale',`0')
+define(`branchIdentFormat',`1')
+define(`branchTraitSelonFormat',`100')
+define(`branchCommuneVirtBankCus',`2')
+define(`branchCommuneVirtBankCusTest',`1002')
+define(`branchVirtBank',`3')
+define(`branchVirtBankTest',`1003')
+define(`branchVirtCus',`4')
+define(`branchVirtCusTest',`1004')
+define(`branchVirtOr',`5')
+define(`branchVirtOrTest',`1005')
+define(`branchMappingCommunBankCus',`6')
+define(`branchMappingCommunBankCusTest',`1006')
+define(`branchFld_A_B_Blanc',`10')
+define(`branchFld_A_B_BlancTest',`1010')
+define(`branchFld_D_K',`11')
+define(`branchFld_D_KTest',`1011')
+define(`branchFld13',`13')
+define(`branchFld13Test',`1013')
+define(`branchFld55',`55')
+define(`branchFld55Test',`1055')
+define(`branchFld55avec13C',`5513')
+define(`branchFld55avec13CTest',`5513')
+define(`branchTitres',`1900')
+define(`branchMatcc',`2500')
+define(`branchCreVgmEmis',`30')
+define(`branchCreVgmEmisTest',`1030')
+define(`branchCreVgmRecu',`31')
+define(`branchCreVgmRecuTest',`1031')
+define(`branchCreRejet',`32')
+define(`branchCreRejetTest',`1032')
+define(`branchCreRejetOr',`35')
+define(`branchCreRejetEnTeteOrTest',`1033')
+define(`branchCreRejetDataOrTest',`1034')
+define(`branchDelimitedFfffT',`111')
+define(`branchDelimitedZzzzT',`211')
+define(`branchDelimitedCrlfT',`311')
+define(`branchOcc13cClstime',`7')
+define(`branchOcc13cTrunc',`8')
+define(`branchInsertStlmEmisInCre',`302')
+define(`branchInsertOrEmisInCre',`305')
+define(`branchInsertStlmRecuInCre',`312')
+define(`branchInsertOrRecuInCre',`315')
+define(`branchInsertStlmInCreRejet',`322')
+define(`branchInsertOrRecuInCreRejet',`325')
+define(`branchBreakMappingBoCrt',`99')
+dnl
+dnl+---------------------------------------------------------------------------+
+dnl|       End branch id definition                                            |
+dnl+---------------------------------------------------------------------------+
+dnl
+dnl
+dnl+-------------------------------------+
+dnl|    Begin clear flag definition      |
+dnl+-------------------------------------+
+dnl
+define(`activeClearFlag',`1')
+dnl
+dnl+-------------------------------------+
+dnl|     End clear flag definition       |
+dnl+-------------------------------------+
+dnl
diff --git a/src/sd_mappath_struct/src/sd_mappath_struct.xml.m4 b/src/sd_mappath_struct/src/sd_mappath_struct.xml.m4
new file mode 100644
index 0000000..9609500
--- /dev/null
+++ b/src/sd_mappath_struct/src/sd_mappath_struct.xml.m4
@@ -0,0 +1,289 @@
+dnl
+divert(-1)
+include(`mappath_cmd.xml.m4')
+include(`mappath_commun.xml.m4')
+include(`fixed_xml.xml.m4')
+include(`fixed_xml_cre.xml.m4')
+include(`xml_fixed.xml.m4')
+include(`xml_fixed_cre.xml.m4')
+divert(0)dnl
+dnl
+changecom(`<!--', `-->')dnl
+dnl
+dnl
+header_mappath()
+insert_version(@(#) VERSIONIMR: $Label:  $   $Date: 2008/11/12 02:25:24 $   $Workfile:   sd_mappath_struct.xml.m4  $)
+ifdef(`TUX_SUPPORT', `dnl
+dnl+------------------------------------------+
+dnl|     Begin MAPPATH  FML--> RAW            |
+dnl+------------------------------------------+
+dnl
+begin_mappath(fml,raw,FML,Fixed)
+cmd_copie(branchInitiale,bufferMainInput,bufferTemp)
+cmd_go_to(branchInitiale,branchTraitSelonFormat)
+stripping_fml(branchTraitSelonFormat,bufferTemp,bufferMainOutput)
+end_mappath()
+dnl
+dnl+------------------------------------------+
+dnl|     End MAPPATH  FML--> RAW              |
+dnl+------------------------------------------+
+dnl
+dnl
+dnl+------------------------------------------+
+dnl|     Begin MAPPATH  RAW --> FML           |
+dnl+------------------------------------------+
+dnl
+begin_mappath(raw,fml,Unknown,FML)
+cmd_copie(branchInitiale,bufferMainInput,bufferTemp)
+cmd_go_to(branchInitiale,branchTraitSelonFormat)
+dressing_fml(branchTraitSelonFormat,bufferTemp,bufferMainOutput)
+end_mappath()
+dnl
+dnl+------------------------------------------+
+dnl|     End MAPPATH  RAW --> FML             |
+dnl+------------------------------------------+
+dnl
+dnl')
+dnl+------------------------------------------+
+dnl|     Begin MAPPATH  RAW --> RAW           |
+dnl+------------------------------------------+
+dnl
+begin_mappath(raw,raw,Unknown,Unknown)
+cmd_copie(branchInitiale,bufferMainInput,bufferTemp)
+cmd_go_to(branchInitiale,branchTraitSelonFormat)
+cmd_copie(branchTraitSelonFormat,bufferTemp,bufferMainOutput)
+end_mappath()
+dnl
+dnl+------------------------------------------+
+dnl|     End MAPPATH  RAW --> RAW             |
+dnl+------------------------------------------+
+ifdef(`TUX_SUPPORT', `dnl
+dnl
+dnl+---------------------------------------------+
+dnl|     Begin MAPPATH  cristal_fml --> bo_raw   |
+dnl+---------------------------------------------+
+dnl
+begin_mappath(cristal_fml,bo_raw,FML,Unknown)
+cmd_copie(branchInitiale,bufferMainInput,bufferTemp)
+stripping_fml(branchInitiale,bufferMainInput,bufferWork)
+cmd_go_to(branchInitiale,branchIdentFormat)
+ident_raw(branchIdentFormat,bufferWork,XML,branchCommuneVirtBankCus,Fixed,branchCommuneVirtBankCusTest)
+xml_fixed_cre(MODE_NO_TRUNC)
+fixed_xml_cre()
+cmd_copie(branchTraitSelonFormat,bufferTemp,bufferMainOutput)
+end_mappath()
+dnl
+dnl+---------------------------------------------+
+dnl|     End MAPPATH  cristal_fml --> bo_raw     |
+dnl+---------------------------------------------+
+dnl
+dnl
+dnl+---------------------------------------------------+
+dnl|     Begin MAPPATH  cristal_fml --> bo.trunc_raw   |
+dnl+---------------------------------------------------+
+dnl
+begin_mappath(cristal_fml,bo.trunc_raw,FML,Unknown)
+cmd_copie(branchInitiale,bufferMainInput,bufferTemp)
+stripping_fml(branchInitiale,bufferMainInput,bufferWork)
+cmd_go_to(branchInitiale,branchIdentFormat)
+ident_raw(branchIdentFormat,bufferWork,XML,branchCommuneVirtBankCus,Fixed,branchCommuneVirtBankCusTest)
+xml_fixed_cre(MODE_TRUNC)
+fixed_xml_cre()
+cmd_copie(branchTraitSelonFormat,bufferTemp,bufferMainOutput)
+end_mappath()
+dnl
+dnl+---------------------------------------------------+
+dnl|     End MAPPATH  cristal_fml --> bo.trunc_raw     |
+dnl+---------------------------------------------------+
+dnl
+dnl
+dnl+---------------------------------------------+
+dnl|     Begin MAPPATH  cristal_raw --> bo_fml   |
+dnl+---------------------------------------------+
+dnl
+begin_mappath(cristal_raw,bo_fml,Unknown,FML)
+cmd_copie(branchInitiale,bufferMainInput,bufferTemp)
+cmd_copie(branchInitiale,bufferMainInput,bufferWork)
+cmd_go_to(branchInitiale,branchIdentFormat)
+ident_raw(branchIdentFormat,bufferWork,XML,branchCommuneVirtBankCus,Fixed,branchCommuneVirtBankCusTest)
+xml_fixed_cre(MODE_NO_TRUNC)
+fixed_xml_cre()
+dressing_fml(branchTraitSelonFormat,bufferTemp,bufferMainOutput)
+end_mappath()
+dnl
+dnl+---------------------------------------------+
+dnl|     End MAPPATH  cristal_raw --> bo_fml     |
+dnl+---------------------------------------------+
+dnl
+dnl
+dnl+---------------------------------------------------+
+dnl|     Begin MAPPATH  cristal_raw --> bo.trunc_fml   |
+dnl+---------------------------------------------------+
+dnl
+begin_mappath(cristal_raw,bo.trunc_fml,Unknown,FML)
+cmd_copie(branchInitiale,bufferMainInput,bufferTemp)
+cmd_copie(branchInitiale,bufferMainInput,bufferWork)
+cmd_go_to(branchInitiale,branchIdentFormat)
+ident_raw(branchIdentFormat,bufferWork,XML,branchCommuneVirtBankCus,Fixed,branchCommuneVirtBankCusTest)
+xml_fixed_cre(MODE_TRUNC)
+fixed_xml_cre()
+dressing_fml(branchTraitSelonFormat,bufferTemp,bufferMainOutput)
+end_mappath()
+dnl
+dnl+---------------------------------------------------+
+dnl|     End MAPPATH  cristal_raw --> bo.trunc_fml     |
+dnl+---------------------------------------------------+
+dnl
+dnl
+dnl+---------------------------------------------+
+dnl|     Begin MAPPATH  bo_raw --> cristal_fml   |
+dnl+---------------------------------------------+
+dnl
+begin_mappath(bo_raw,cristal_fml,Unknown,FML)
+cmd_copie(branchInitiale,bufferMainInput,bufferTemp)
+cmd_copie(branchInitiale,bufferMainInput,bufferWork)
+cmd_go_to(branchInitiale,branchIdentFormat)
+ident_raw(branchIdentFormat,bufferWork,Fixed,branchCommuneVirtBankCus,XML,branchCommuneVirtBankCusTest)
+fixed_xml()
+xml_fixed()
+dressing_fml(branchTraitSelonFormat,bufferTemp,bufferMainOutput)
+end_mappath()
+dnl
+dnl+---------------------------------------------+
+dnl|     End MAPPATH  bo_raw --> cristal_fml     |
+dnl+---------------------------------------------+
+dnl
+dnl
+dnl+---------------------------------------------+
+dnl|     Begin MAPPATH  bo_fml --> cristal_raw   |
+dnl+---------------------------------------------+
+dnl
+begin_mappath(bo_fml,cristal_raw,FML,Unknown)
+cmd_copie(branchInitiale,bufferMainInput,bufferTemp)
+stripping_fml(branchInitiale,bufferMainInput,bufferWork)
+cmd_go_to(branchInitiale,branchIdentFormat)
+ident_raw(branchIdentFormat,bufferWork,XML,branchCommuneVirtBankCusTest,Fixed,branchCommuneVirtBankCus)
+fixed_xml()
+xml_fixed()
+cmd_copie(branchTraitSelonFormat,bufferTemp,bufferMainOutput)
+end_mappath()
+dnl
+dnl+---------------------------------------------+
+dnl|     End MAPPATH  bo_fml --> cristal_raw     |
+dnl+---------------------------------------------+')
+dnl
+dnl
+dnl+---------------------------------------------+
+dnl|     Begin MAPPATH  bo_raw --> cristal_raw   |
+dnl+---------------------------------------------+
+dnl
+begin_mappath(bo_raw,cristal_raw,Unknown,Unknown)
+cmd_copie(branchInitiale,bufferMainInput,bufferTemp)
+cmd_copie(branchInitiale,bufferMainInput,bufferWork)
+cmd_go_to(branchInitiale,branchIdentFormat)
+ident_raw(branchIdentFormat,bufferWork,Fixed,branchCommuneVirtBankCus,XML,branchCommuneVirtBankCusTest)
+fixed_xml()
+xml_fixed()
+cmd_copie(branchTraitSelonFormat,bufferTemp,bufferMainOutput)
+end_mappath()
+dnl
+dnl+---------------------------------------------+
+dnl|     End MAPPATH  bo_raw --> cristal_raw     |
+dnl+---------------------------------------------+
+dnl
+dnl
+dnl+---------------------------------------------+
+dnl|     Begin MAPPATH  cristal_raw --> bo_raw   |
+dnl+---------------------------------------------+
+dnl
+begin_mappath(cristal_raw,bo_raw,Unknown,Unknown)
+cmd_copie(branchInitiale,bufferMainInput,bufferTemp)
+cmd_copie(branchInitiale,bufferMainInput,bufferWork)
+cmd_go_to(branchInitiale,branchIdentFormat)
+ident_raw(branchIdentFormat,bufferWork,XML,branchCommuneVirtBankCus,Fixed,branchCommuneVirtBankCusTest)
+xml_fixed_cre(MODE_NO_TRUNC)
+fixed_xml_cre()
+cmd_copie(branchTraitSelonFormat,bufferTemp,bufferMainOutput)
+end_mappath()
+dnl
+dnl+---------------------------------------------+
+dnl|     End MAPPATH  cristal_raw --> bo_raw     |
+dnl+---------------------------------------------+
+dnl
+dnl
+dnl+---------------------------------------------------+
+dnl|     Begin MAPPATH  cristal_raw --> bo.trunc_raw   |
+dnl+---------------------------------------------------+
+dnl
+begin_mappath(cristal_raw,bo.trunc_raw,Unknown,Unknown)
+cmd_copie(branchInitiale,bufferMainInput,bufferTemp)
+cmd_copie(branchInitiale,bufferMainInput,bufferWork)
+cmd_go_to(branchInitiale,branchIdentFormat)
+ident_raw(branchIdentFormat,bufferWork,XML,branchCommuneVirtBankCus,Fixed,branchCommuneVirtBankCusTest)
+xml_fixed_cre(MODE_TRUNC)
+fixed_xml_cre()
+cmd_copie(branchTraitSelonFormat,bufferTemp,bufferMainOutput)
+end_mappath()
+dnl
+dnl+---------------------------------------------------+
+dnl|     End MAPPATH  cristal_raw --> bo.trunc_raw     |
+dnl+---------------------------------------------------+
+ifdef(`TUX_SUPPORT', `dnl
+dnl
+dnl+---------------------------------------------+
+dnl|     Begin MAPPATH  bo_fml --> cristal_fml   |
+dnl+---------------------------------------------+
+dnl
+begin_mappath(bo_fml,cristal_fml,FML,FML)
+cmd_copie(branchInitiale,bufferMainInput,bufferTemp)
+stripping_fml(branchInitiale,bufferMainInput,bufferWork)
+cmd_go_to(branchInitiale,branchIdentFormat)
+ident_raw(branchIdentFormat,bufferWork,Fixed,branchCommuneVirtBankCus,XML,branchCommuneVirtBankCusTest)
+fixed_xml()
+xml_fixed()
+dressing_fml(branchTraitSelonFormat,bufferTemp,bufferMainOutput)
+end_mappath()
+dnl
+dnl+---------------------------------------------+
+dnl|     End MAPPATH  bo_fml --> cristal_fml     |
+dnl+---------------------------------------------+
+dnl
+dnl
+dnl+---------------------------------------------+
+dnl|     Begin MAPPATH  cristal_fml --> bo_fml   |
+dnl+---------------------------------------------+
+dnl
+begin_mappath(cristal_fml,bo_fml,FML,FML)
+cmd_copie(branchInitiale,bufferMainInput,bufferTemp)
+stripping_fml(branchInitiale,bufferMainInput,bufferWork)
+cmd_go_to(branchInitiale,branchIdentFormat)
+ident_raw(branchIdentFormat,bufferWork,XML,branchCommuneVirtBankCus,Fixed,branchCommuneVirtBankCusTest)
+xml_fixed_cre(MODE_NO_TRUNC)
+fixed_xml_cre()
+dressing_fml(branchTraitSelonFormat,bufferTemp,bufferMainOutput)
+end_mappath()
+dnl
+dnl+---------------------------------------------+
+dnl|     End MAPPATH  cristal_fml --> bo_fml     |
+dnl+---------------------------------------------+
+dnl
+dnl
+dnl+---------------------------------------------------+
+dnl|     Begin MAPPATH  cristal_fml --> bo.trunc_fml   |
+dnl+---------------------------------------------------+
+dnl
+begin_mappath(cristal_fml,bo.trunc_fml,FML,FML)
+cmd_copie(branchInitiale,bufferMainInput,bufferTemp)
+stripping_fml(branchInitiale,bufferMainInput,bufferWork)
+cmd_go_to(branchInitiale,branchIdentFormat)
+ident_raw(branchIdentFormat,bufferWork,XML,branchCommuneVirtBankCus,Fixed,branchCommuneVirtBankCusTest)
+xml_fixed_cre(MODE_TRUNC)
+fixed_xml_cre()
+dressing_fml(branchTraitSelonFormat,bufferTemp,bufferMainOutput)
+end_mappath()
+dnl
+dnl+---------------------------------------------------+
+dnl|     End MAPPATH  cristal_fml --> bo.trunc_fml     |
+dnl+---------------------------------------------------+
+dnl')
+footer_mappath()
diff --git a/src/sd_mappath_struct/src/xml_fixed.xml.m4 b/src/sd_mappath_struct/src/xml_fixed.xml.m4
new file mode 100644
index 0000000..f34e403
--- /dev/null
+++ b/src/sd_mappath_struct/src/xml_fixed.xml.m4
@@ -0,0 +1,293 @@
+changecom(`<!--', `-->')dnl
+dnl
+dnl+--------------------------------------+
+dnl|    Begin Macro Section               |
+dnl+--------------------------------------+
+dnl
+define(`xml_fixed',
+<!-- branche BB2 mapping des donnees communes au virement bancaire et au virement de clientele -->
+<!-- branche BB3 mapping des donnees specifiques au virement bancaire -->
+<!-- branche BB4 mapping des donnees specifiques au virement de clientele -->
+<!-- branche BB5 mapping des donnees specifiques aux ordres de restitutuion -->
+<!-- branche BB10 mapping des blocs au format A B ou blanc -->
+<!-- branche BB11 mapping des blocs au format D ou K -->
+<!-- branche BB13 mapping du bloc 13C -->
+<!-- branche BB55 traitement specifique au bloc 55 -->
+<!-- Buffer BUF2 (fixed) pour donnees du virement -->
+<!-- Buffer BUF3 (fixed) pour donnees du virement de clientele (du bloc 56 au bloc 77) -->
+<!-- Buffer BUF10 (fixed) pour mapping du bloc 13C -->
+<!-- Buffer BUF11 (fixed) pour bloc 50 -->
+<!-- Buffer BUF12 (fixed) pour bloc 52 -->
+<!-- Buffer BUF13 (fixed) pour bloc 55 -->
+<!-- Buffer BUF14 (fixed) pour bloc 56 -->
+<!-- Buffer BUF15 (fixed) pour bloc 57 -->
+<!-- Buffer BUF16 (fixed) pour bloc 58 -->
+<!-- Buffer BUF17 (fixed) pour bloc 59 -->
+<!-- Buffer BUF18 (fixed) pour bloc 72 -->
+<!-- Buffer BUF20 (fixed ou delimited) pour mapping des blocs "delimited"  il est reutilise -->
+`cmd_identifier(branchCommuneVirtBankCusTest,bufferWork,y,crt_flux_ident,'
+`				XML,crt_flux_vs02,branchCommuneVirtBankCusTest,'
+`				XML,crt_flux_vs03,branchCommuneVirtBankCusTest,'
+`				XML,crt_flux_vs04,branchCommuneVirtBankCusTest,'
+`				XML,crt_flux_vs07,branchCommuneVirtBankCusTest,'
+`				XML,crt_flux_vs08,branchCommuneVirtBankCusTest,'
+`				XML,crt_flux_os01,branchVirtOrTest)'
+		<!-- mapping des entete_commun et entete_vgm -->
+`cmd_mapper(branchCommuneVirtBankCusTest,XML,,Fixed,,bufferWork,bufferTemp,activeClearFlag,crt_flux_header-crt_flux_header)'
+`cmd_mapper(branchCommuneVirtBankCusTest,XML,,Fixed,,bufferWork,bufferTemp,,crt_flux_header-crt_flux_header-special_fixed)'
+`cmd_mapper(branchCommuneVirtBankCusTest,XML,,Fixed,,bufferWork,bufferTemp,,crt_flux_stlm_header-crt_flux_stlm_header)'
+<!-- traitement des blocs communs aux virements bancaires et de clientele 13c 52 56 57 72 -->
+<!-- bloc 13c -->
+		<!-- recherche existence du bloc 13C -->
+`cmd_identifier(branchCommuneVirtBankCusTest,bufferWork,n,crt_flux_stlm_sans13c,'
+`				XML,crt_flux_stlm_avec13c,branchFld13Test,'
+`				XML,unknown,branchCommuneVirtBankCusTest)'
+		<!-- mapping du bloc 13c -->
+`cmd_mapper(branchFld13Test,XML,,Fixed,,bufferWork,bufferMapping13C,,swf_field_13c-swf_field_13c)'
+`cmd_go_to(branchFld13Test,branchCommuneVirtBankCusTest)'
+<!-- fin bloc 13c -->
+<!-- bloc 52 -->
+		<!-- identifier format du bloc 52 -->
+`cmd_identifier(branchCommuneVirtBankCusTest,bufferWork,n,swf_field_52x,'
+`				XML,swf_field_52d_fmt,branchFld_D_KTest,'
+`				XML,swf_field_52a_fmt,branchFld_A_B_BlancTest,'
+`				XML,unknown,branchFld_A_B_BlancTest)'
+		<!-- mapping du bloc 52A  -->
+`cmd_mapper(branchFld_A_B_BlancTest,XML,,Fixed,,bufferWork,bufferMapping52,,swf_field_52x-swf_field_52x-format_a)'
+`cmd_go_to(branchFld_A_B_BlancTest,branchCommuneVirtBankCusTest)'
+		<!-- mapping du bloc 52D (hors complements) -->
+`cmd_mapper(branchFld_D_KTest,XML,,Fixed,,bufferWork,bufferMapping52,,swf_field_52x-swf_field_52x-format_d)'
+		<!-- mapping de complements du bloc52D -->
+`cmd_mapper(branchFld_D_KTest,XML,,Delimited,crlf_t,bufferWork,bufferWorkMultiligne,activeClearFlag,swf_field_52d_comp-swf_field_52d_comp)'
+		<!-- insertion de complements du bloc52D -->
+`cmd_mapper(branchFld_D_KTest,Fixed,,Fixed,,bufferWorkMultiligne,bufferMapping52,,swf_field_52d_comp-swf_field_52x)'
+`cmd_go_to(branchFld_D_KTest,branchCommuneVirtBankCusTest)'
+<!-- fin bloc 52 -->
+<!-- bloc 56 -->
+		<!-- identifier format du bloc 56 -->
+`cmd_identifier(branchCommuneVirtBankCusTest,bufferWork,n,swf_field_56x,'
+`				XML,swf_field_56d_fmt,branchFld_D_KTest,'
+`				XML,swf_field_56a_fmt,branchFld_A_B_BlancTest,'
+`				XML,unknown,branchFld_A_B_BlancTest)'
+		<!-- mapping du bloc 56A  -->
+`cmd_mapper(branchFld_A_B_BlancTest,XML,,Fixed,,bufferWork,bufferMapping56,,swf_field_56x-swf_field_56x-format_a)'
+`cmd_go_to(branchFld_A_B_BlancTest,branchCommuneVirtBankCusTest)'
+		<!-- mapping du bloc 56D (hors complements) -->
+`cmd_mapper(branchFld_D_KTest,XML,,Fixed,,bufferWork,bufferMapping56,,swf_field_56x-swf_field_56x-format_d)'
+		<!-- mapping de complements du bloc56D -->
+`cmd_mapper(branchFld_D_KTest,XML,,Delimited,crlf_t,bufferWork,bufferWorkMultiligne,activeClearFlag,swf_field_56d_comp-swf_field_56d_comp)'
+		<!-- insertion de complements du bloc56D -->
+`cmd_mapper(branchFld_D_KTest,Fixed,,Fixed,,bufferWorkMultiligne,bufferMapping56,,swf_field_56d_comp-swf_field_56x)'
+`cmd_go_to(branchFld_D_KTest,branchCommuneVirtBankCusTest)'
+<!-- fin bloc 56 -->
+<!-- bloc 57 -->
+		<!-- identifier format du bloc 57 -->
+`cmd_identifier(branchCommuneVirtBankCusTest,bufferWork,n,swf_field_57x,'
+`				XML,swf_field_57d_fmt,branchFld_D_KTest,'
+`				XML,swf_field_57a_fmt,branchFld_A_B_BlancTest,'
+`				XML,swf_field_57b_fmt,branchFld_A_B_BlancTest,'
+`				XML,unknown,branchFld_A_B_BlancTest)'
+		<!-- mapping du bloc 57A  -->
+`cmd_mapper(branchFld_A_B_BlancTest,XML,,Fixed,,bufferWork,bufferMapping57,,swf_field_57x-swf_field_57x-format_a)'
+`cmd_go_to(branchFld_A_B_BlancTest,branchCommuneVirtBankCusTest)'
+		<!-- mapping du bloc 57D (hors complements) -->
+`cmd_mapper(branchFld_D_KTest,XML,,Fixed,,bufferWork,bufferMapping57,,swf_field_57x-swf_field_57x-format_d)'
+		<!-- mapping de complements du bloc57D -->
+`cmd_mapper(branchFld_D_KTest,XML,,Delimited,crlf_t,bufferWork,bufferWorkMultiligne,activeClearFlag,swf_field_57d_comp-swf_field_57d_comp)'
+		<!-- insertion de complements du bloc57D -->
+`cmd_mapper(branchFld_D_KTest,Fixed,,Fixed,,bufferWorkMultiligne,bufferMapping57,,swf_field_57d_comp-swf_field_57x)'
+`cmd_go_to(branchFld_D_KTest,branchCommuneVirtBankCusTest)'
+<!-- fin bloc 57 -->
+<!-- bloc 72 -->
+		<!-- mapping du bloc 72 (hors autres lignes)  -->
+`cmd_mapper(branchCommuneVirtBankCusTest,XML,,Fixed,,bufferWork,bufferMapping72,,swf_field_72-swf_field_72)'
+		<!-- mapping de autres lignes du bloc 72 -->
+`cmd_mapper(branchCommuneVirtBankCusTest,XML,,Delimited,crlf_t,bufferWork,bufferWorkMultiligne,activeClearFlag,swf_field_72_autres_lignes-swf_field_72_autres_lignes)'
+		<!-- insertion de autres lignes du bloc 72 -->
+`cmd_mapper(branchCommuneVirtBankCusTest,Fixed,,Fixed,,bufferWorkMultiligne,bufferMapping72,,swf_field_72_autres_lignes-swf_field_72)'
+<!-- fin bloc 72 -->
+<!-- fin de traitement des blocs communs aux virements bancaires et de clientele -->
+		<!-- identification complete a partir de la branche 0 -->
+`cmd_identifier(branchCommuneVirtBankCusTest,bufferWork,y,crt_flux_ident,'
+`				XML,crt_flux_vs02,branchVirtBankTest,'
+`				XML,crt_flux_vs03,branchVirtBankTest,'
+`				XML,crt_flux_vs04,branchVirtBankTest,'
+`				XML,crt_flux_vs07,branchVirtCusTest,'
+`				XML,crt_flux_vs08,branchVirtCusTest)'
+<!-- traitement specifiques aux virements bancaires -->
+<!-- bloc 58 -->
+		<!-- identifier format du bloc 58 -->
+`cmd_identifier(branchVirtBankTest,bufferWork,n,swf_field_58x,'
+`				XML,swf_field_58d_fmt,branchFld_D_KTest,'
+`				XML,swf_field_58a_fmt,branchFld_A_B_BlancTest,'
+`				XML,swf_field_58b_fmt,branchFld_A_B_BlancTest,'
+`				XML,unknown,branchFld_A_B_BlancTest)'
+		<!-- mapping du bloc 58A  -->
+`cmd_mapper(branchFld_A_B_BlancTest,XML,,Fixed,,bufferWork,bufferMapping58,,swf_field_58x-swf_field_58x-format_a)'
+`cmd_go_to(branchFld_A_B_BlancTest,branchVirtBankTest)'
+		<!-- mapping du bloc 58D (hors complements)  -->
+`cmd_mapper(branchFld_D_KTest,XML,,Fixed,,bufferWork,bufferMapping58,,swf_field_58x-swf_field_58x-format_d)'
+		<!-- mapping de complements du bloc58D -->
+`cmd_mapper(branchFld_D_KTest,XML,,Delimited,crlf_t,bufferWork,bufferWorkMultiligne,activeClearFlag,swf_field_58d_comp-swf_field_58d_comp)'
+		<!-- insertion de complements du bloc58D -->
+`cmd_mapper(branchFld_D_KTest,Fixed,,Fixed,,bufferWorkMultiligne,bufferMapping58,,swf_field_58d_comp-swf_field_58x)'
+`cmd_go_to(branchFld_D_KTest,branchVirtBankTest)'
+<!-- fin bloc 58 -->
+<!-- mapping du virement bancaire hors blocs 13c 52 56 57 58 72 -->
+`cmd_mapper(branchVirtBankTest,XML,,Fixed,,bufferWork,bufferDataMsg,,crt_flux_stlm_bk-crt_flux_stlm_bk)'
+<!-- fin mapping du virement bancaire hors blocs 13c 52 56 57 58 72 -->
+<!-- insertion des blocs 52 56 57 58 72 -->
+`cmd_mapper(branchVirtBankTest,Fixed,,Fixed,,bufferMapping52,bufferDataMsg,,swf_field_52x-crt_flux_stlm_bk)'
+`cmd_mapper(branchVirtBankTest,Fixed,,Fixed,,bufferMapping56,bufferDataMsg,,swf_field_56x-crt_flux_stlm_bk)'
+`cmd_mapper(branchVirtBankTest,Fixed,,Fixed,,bufferMapping57,bufferDataMsg,,swf_field_57x-crt_flux_stlm_bk)'
+`cmd_mapper(branchVirtBankTest,Fixed,,Fixed,,bufferMapping58,bufferDataMsg,,swf_field_58x-crt_flux_stlm_bk)'
+`cmd_mapper(branchVirtBankTest,Fixed,,Fixed,,bufferMapping72,bufferDataMsg,,swf_field_72-crt_flux_stlm_bk)'
+<!-- fin insertion des blocs 52 56 57 58 72 -->
+<!-- insertion du bloc 13c -->
+		<!-- recherche existence du bloc 13C -->
+`cmd_identifier(branchVirtBankTest,bufferWork,n,crt_flux_stlm_sans13c,'
+`				XML,crt_flux_stlm_avec13c,branchFld13Test,'
+`				XML,unknown,branchVirtBankTest)'
+		<!-- insertion du bloc 13c -->
+`cmd_mapper(branchFld13Test,Fixed,,Fixed,,bufferMapping13C,bufferDataMsg,,swf_field_13c-crt_flux_stlm_bk)'
+`cmd_go_to(branchFld13Test,branchVirtBankTest)'
+<!-- fin insertion du bloc 13c -->
+<!-- fin de traitement specifiques aux virements bancaires -->
+<!-- retour a la branche commune -->
+`cmd_go_to(branchVirtBankTest,branchCommuneVirtBankCusTest)'
+<!-- branche BB4 traitement specifiques aux virements de clientele -->
+<!-- mapping du virement de clientele hors blocs 13c 50 52 55 56 57 59 70 72 77 -->
+		<!-- mapping jusqu'au bloc 56 -->
+`cmd_mapper(branchVirtCusTest,XML,,Fixed,,bufferWork,bufferDataMsg,,crt_flux_stlm_cus-crt_flux_stlm_cus)'
+		<!-- mapping a partir du bloc 56 jusqu'au bloc 77 -->
+`cmd_mapper(branchVirtCusTest,XML,,Fixed,,bufferWork,bufferDataVirtCus,,crt_flux_stlm_cus_end-crt_flux_stlm_cus_end)'
+<!-- fin mapping du virement de clientele hors blocs 13c 50 52 55 56 57 59 70 72 77 -->
+<!-- insertion des blocs 52 56 57 72 deja mappes -->
+`cmd_mapper(branchVirtCusTest,Fixed,,Fixed,,bufferMapping52,bufferDataMsg,,swf_field_52x-crt_flux_stlm_cus)'
+`cmd_mapper(branchVirtCusTest,Fixed,,Fixed,,bufferMapping56,bufferDataVirtCus,,swf_field_56x-crt_flux_stlm_cus_end)'
+`cmd_mapper(branchVirtCusTest,Fixed,,Fixed,,bufferMapping57,bufferDataVirtCus,,swf_field_57x-crt_flux_stlm_cus_end)'
+`cmd_mapper(branchVirtCusTest,Fixed,,Fixed,,bufferMapping72,bufferDataVirtCus,,swf_field_72-crt_flux_stlm_cus_end)'
+<!-- fin insertion des blocs 52 56 57 72 -->
+<!-- mapping et insertion des blocs specifiques au virement de clientele hors 55 -->
+<!-- bloc 50 -->
+		<!-- identifier format du bloc 50 -->
+`cmd_identifier(branchVirtCusTest,bufferWork,n,swf_field_50x,'
+`				XML,swf_field_50k_fmt,branchFld_D_KTest,'
+`				XML,swf_field_50a_fmt,branchFld_A_B_BlancTest,'
+`				XML,unknown,branchFld_A_B_BlancTest)'
+		<!-- mapping du bloc 50A  -->
+`cmd_mapper(branchFld_A_B_BlancTest,XML,,Fixed,,bufferWork,bufferMapping50,,swf_field_50x-swf_field_50x-format_a)'
+`cmd_go_to(branchFld_A_B_BlancTest,branchVirtCusTest)'
+		<!-- mapping du bloc 50K (hors complements)  -->
+`cmd_mapper(branchFld_D_KTest,XML,,Fixed,,bufferWork,bufferMapping50,,swf_field_50x-swf_field_50x-format_k)'
+		<!-- mapping de complements du bloc50k -->
+`cmd_mapper(branchFld_D_KTest,XML,,Delimited,crlf_t,bufferWork,bufferWorkMultiligne,activeClearFlag,swf_field_50k_comp-swf_field_50k_comp)'
+		<!-- insertion de complements du bloc50k -->
+`cmd_mapper(branchFld_D_KTest,Fixed,,Fixed,,bufferWorkMultiligne,bufferMapping50,,swf_field_50k_comp-swf_field_50x)'
+`cmd_go_to(branchFld_D_KTest,branchVirtCusTest)'
+		<!-- insertion du bloc 50 -->
+`cmd_mapper(branchVirtCusTest,Fixed,,Fixed,,bufferMapping50,bufferDataMsg,,swf_field_50x-crt_flux_stlm_cus)'
+<!-- fin bloc 50 -->
+<!-- bloc 59 -->
+		<!-- identifier format du bloc 59 -->
+`cmd_identifier(branchVirtCusTest,bufferWork,n,swf_field_59x,'
+`				XML,swf_field_59blanc_fmt,branchFld_D_KTest,'
+`				XML,swf_field_59a_fmt,branchFld_A_B_BlancTest,'
+`				XML,unknown,branchFld_A_B_BlancTest)'
+		<!-- mapping du bloc 59A  -->
+`cmd_mapper(branchFld_A_B_BlancTest,XML,,Fixed,,bufferWork,bufferMapping59,,swf_field_59x-swf_field_59x-format_a)'
+`cmd_go_to(branchFld_A_B_BlancTest,branchVirtCusTest)'
+		<!-- mapping du bloc 59blanc (hors complements)  -->
+`cmd_mapper(branchFld_D_KTest,XML,,Fixed,,bufferWork,bufferMapping59,,swf_field_59x-swf_field_59x-format_blanc)'
+		<!-- mapping de complements du bloc 59blanc -->
+`cmd_mapper(branchFld_D_KTest,XML,,Delimited,crlf_t,bufferWork,bufferWorkMultiligne,activeClearFlag,swf_field_59blanc_comp-swf_field_59blanc_comp)'
+		<!-- insertion de complements du bloc 59blanc -->
+`cmd_mapper(branchFld_D_KTest,Fixed,,Fixed,,bufferWorkMultiligne,bufferMapping59,,swf_field_59blanc_comp-swf_field_59x)'
+`cmd_go_to(branchFld_D_KTest,branchVirtCusTest)'
+		<!-- insertion du bloc 59 -->
+`cmd_mapper(branchVirtCusTest,Fixed,,Fixed,,bufferMapping59,bufferDataVirtCus,,swf_field_59x-crt_flux_stlm_cus_end)'
+<!-- fin bloc 59 -->
+<!-- bloc 70 -->
+		<!-- mapping du bloc 70 -->
+`cmd_mapper(branchVirtCusTest,XML,,Delimited,crlf_t,bufferWork,bufferWorkMultiligne,activeClearFlag,swf_field_70-swf_field_70)'
+		<!-- insertion du bloc 70 -->
+`cmd_mapper(branchVirtCusTest,Fixed,,Fixed,,bufferWorkMultiligne,bufferDataVirtCus,,swf_field_70-crt_flux_stlm_cus_end)'
+<!-- fin bloc 70 -->
+<!-- bloc 77 -->
+		<!-- mapping du bloc 77 -->
+`cmd_mapper(branchVirtCusTest,XML,,Delimited,crlf_t,bufferWork,bufferWorkMultiligne,activeClearFlag,swf_field_77-swf_field_77)'
+		<!-- insertion du bloc 77 -->
+`cmd_mapper(branchVirtCusTest,Fixed,,Fixed,,bufferWorkMultiligne,bufferDataVirtCus,,swf_field_77-crt_flux_stlm_cus_end)'
+<!-- fin bloc 77 -->
+<!-- mapping et insertion des blocs specifiques au virement de clientele hors 55 -->
+<!-- traitement du bloc 55 -->
+<!-- bloc 55 -->
+		<!-- recherche existence du bloc 55 -->
+`cmd_identifier(branchVirtCusTest,bufferWork,n,crt_flux_stlm_cus_sans55,'
+`				XML,crt_flux_stlm_cus_avec55,branchFld55Test,'
+`				XML,unknown,branchVirtCusTest)'
+<!-- sans bloc 55 -->
+		<!-- insertion de la fin du virement (bloc 56 a bloc 77) -->
+`cmd_mapper(branchVirtCusTest,Fixed,,Fixed,,bufferDataVirtCus,bufferDataMsg,,crt_flux_stlm_cus_56_a_77-crt_flux_stlm_cus_56_a_77-sans55-insert)'
+		<!-- insertion du bloc 13C -->
+		<!-- recherche existence du bloc 13C -->
+`cmd_identifier(branchVirtCusTest,bufferWork,n,crt_flux_stlm_sans13c,'
+`				XML,crt_flux_stlm_avec13c,branchFld13Test,'
+`				XML,unknown,branchVirtCusTest)'
+		<!-- insertion du bloc 13c -->
+`cmd_mapper(branchFld13Test,Fixed,,Fixed,,bufferMapping13C,bufferDataMsg,,swf_field_13c-cus_champ_13c_sans55)'
+`cmd_go_to(branchFld13Test,branchVirtCusTest)'
+		<!-- fin insertion du bloc 13c -->		
+<!-- fin sans bloc 55 -->
+<!-- avec bloc 55 -->
+		<!-- identifier format du bloc 55 -->
+`cmd_identifier(branchFld55Test,bufferWork,n,swf_field_55x,'
+`				XML,swf_field_55d_fmt,branchFld_D_KTest,'
+`				XML,swf_field_55a_fmt,branchFld_A_B_BlancTest,'
+`				XML,swf_field_55b_fmt,branchFld_A_B_BlancTest,'
+`				XML,unknown,branchFld_A_B_BlancTest)'
+		<!-- mapping du bloc 55A  -->
+`cmd_mapper(branchFld_A_B_BlancTest,XML,,Fixed,,bufferWork,bufferMapping55,,swf_field_55x-swf_field_55x-format_a)'
+`cmd_go_to(branchFld_A_B_BlancTest,branchFld55Test)'
+		<!-- mapping du bloc 55D (hors complements)  -->
+`cmd_mapper(branchFld_D_KTest,XML,,Fixed,,bufferWork,bufferMapping55,,swf_field_55x-swf_field_55x-format_d)'
+		<!-- mapping de complements du bloc55D -->
+`cmd_mapper(branchFld_D_KTest,XML,,Delimited,crlf_t,bufferWork,bufferWorkMultiligne,activeClearFlag,swf_field_55d_comp-swf_field_55d_comp)'
+		<!-- insertion de complements du bloc55D -->
+`cmd_mapper(branchFld_D_KTest,Fixed,,Fixed,,bufferWorkMultiligne,bufferMapping55,,swf_field_55d_comp-swf_field_55x)'
+`cmd_go_to(branchFld_D_KTest,branchFld55Test)'
+		<!-- insertion du bloc 55 -->
+`cmd_mapper(branchFld55Test,Fixed,,Fixed,,bufferMapping55,bufferDataMsg,,swf_field_55x-crt_flux_stlm_cus)'
+		<!-- insertion de la fin du virement (bloc 56 a bloc 77) -->
+`cmd_mapper(branchFld55Test,Fixed,,Fixed,,bufferDataVirtCus,bufferDataMsg,,crt_flux_stlm_cus_56_a_77-crt_flux_stlm_cus_56_a_77-avec55-insert)'
+		<!-- insertion du bloc 13C -->
+		<!-- recherche existence du bloc 13C -->
+`cmd_identifier(branchFld55Test,bufferWork,n,crt_flux_stlm_sans13c,'
+`				XML,crt_flux_stlm_avec13c,branchFld13Test,'
+`				XML,unknown,branchFld55Test)'
+		<!-- insertion du bloc 13c -->
+`cmd_mapper(branchFld13Test,Fixed,,Fixed,,bufferMapping13C,bufferDataMsg,,swf_field_13c-cus_champ_13c_avec55)'
+`cmd_go_to(branchFld13Test,branchFld55Test)'
+`cmd_go_to(branchFld55Test,branchVirtCusTest)'
+		<!-- fin insertion du bloc 13c -->		
+<!-- fin avec bloc 55 -->
+<!-- fin de traitement specifiques aux virements de clientele -->
+<!-- retour a la branche commune -->
+`cmd_go_to(branchVirtCusTest,branchCommuneVirtBankCusTest)'
+<!-- insertion des donnees du virement dans le flux destine a cristal -->
+`cmd_mapper(branchCommuneVirtBankCusTest,Fixed,,Fixed,,bufferDataMsg,bufferTemp,,crt_flux_stlm-crt_flux_stlm-insert_stlm_in_flux)'
+`cmd_go_to(branchCommuneVirtBankCusTest,branchBreakMappingBoCrt)'
+<!-- branche BB5 traitement specifiques aux ordres de restitution -->
+		<!-- mapping des entete_commun et entete_or -->
+`cmd_mapper(branchVirtOrTest,XML,,Fixed,,bufferWork,bufferTemp,activeClearFlag,crt_flux_header-crt_flux_header)'
+`cmd_mapper(branchVirtOrTest,XML,,Fixed,,bufferWork,bufferTemp,,crt_flux_or_header-crt_flux_or_header)'
+		<!-- mapping des ordres de restitution -->
+`cmd_mapper(branchVirtOrTest,XML,,Fixed,,bufferWork,bufferDataMsg,,crt_flux_or-crt_flux_or)'
+		<!-- insertion des donnees de or -->
+`cmd_mapper(branchVirtOrTest,Fixed,,Fixed,,bufferDataMsg,bufferTemp,,crt_flux_ordre_rest-crt_flux_ordre_rest-insert_or_in_flux)'
+`cmd_go_to(branchBreakMappingBoCrt,branchTraitSelonFormat)')
+dnl
+dnl+--------------------------------------+
+dnl|    End Macro Section                 |
+dnl+--------------------------------------+
+dnl
diff --git a/src/sd_mappath_struct/src/xml_fixed_cre.xml.m4 b/src/sd_mappath_struct/src/xml_fixed_cre.xml.m4
new file mode 100644
index 0000000..29b910e
--- /dev/null
+++ b/src/sd_mappath_struct/src/xml_fixed_cre.xml.m4
@@ -0,0 +1,517 @@
+changecom(`<!--', `-->')dnl
+dnl
+dnl+--------------------------------------+
+dnl|    Begin Macro Section               |
+dnl|                                      |
+dnl| $1 : MODE_TRUNC ou MODE_NO_TRUNC     |
+dnl+--------------------------------------+
+dnl
+define(`xml_fixed_cre',
+<!-- branche BB30 mapping des donnees des cre sur vgm/or emis -->
+<!-- branche BB31 mapping des donnees des cre sur vgm/or recus -->
+<!-- branche BB32 mapping des donnees des cre de rejet et des en tetes de flux -->
+<!-- branche BB3 mapping des donnees specifiques au virement bancaire -->
+<!-- branche BB4 mapping des donnees specifiques au virement de clientele -->
+<!-- branche BB5 mapping des donnees specifiques aux ordres de restitutuion  -->
+<!-- branche BB6 mapping des blocs communs (52 56 57 72 ) au virement bancaire et au virement de clientele -->
+<!-- branche BB10 mapping des blocs au format A B ou blanc -->
+<!-- branche BB11 mapping des blocs au format D ou K -->
+<!-- branche BB13 mapping du bloc 13C -->
+<!-- branche BB55 mapping du bloc 55 -->
+<!-- Buffer BUF2 (fixed) pour donnees du virement -->
+<!-- Buffer BUF3 (fixed) pour donnees du virement de clientele (du bloc 56 au bloc 77) -->
+<!-- Buffer BUF10 (fixed) pour mapping du bloc 13C -->
+<!-- Buffer BUF11 (fixed) pour bloc 50 -->
+<!-- Buffer BUF12 (fixed) pour bloc 52 -->
+<!-- Buffer BUF13 (fixed) pour bloc 55 -->
+<!-- Buffer BUF14 (fixed) pour bloc 56 -->
+<!-- Buffer BUF15 (fixed) pour bloc 57 -->
+<!-- Buffer BUF16 (fixed) pour bloc 58 -->
+<!-- Buffer BUF17 (fixed) pour bloc 59 -->
+<!-- Buffer BUF18 (fixed) pour bloc 72 -->
+<!-- Buffer BUF20 (fixed ou delimited) pour mapping des blocs "delimited"  il est reutilise -->
+		<!-- identification complete a partir de la branche BB30 -->
+`cmd_go_to(branchCommuneVirtBankCus,branchCreVgmEmis)'
+`cmd_identifier(branchCreVgmEmis,bufferWork,y,crt_cre_ident,'
+`				XML,crt_cre_cr01,branchCreVgmEmis,'
+`				XML,crt_cre_cr02,branchCreVgmEmis,'
+`				XML,crt_cre_cr03,branchCreVgmEmis,'
+`				XML,crt_cre_cr04,branchCreVgmEmis,'
+`				XML,crt_cre_cr05,branchCreVgmEmis,'
+`				XML,crt_cre_cr06,branchCreVgmEmis,'
+`				XML,crt_cre_cr07,branchCreVgmEmis,'
+`				XML,crt_cre_cr08,branchCreVgmEmis,'
+`				XML,crt_cre_cr09,branchCreVgmEmis,'
+`				XML,crt_cre_cr10,branchCreVgmEmis,'
+`				XML,crt_cre_cr11,branchCreVgmEmis,'
+`				XML,crt_cre_cr12,branchCreVgmEmis,'
+`				XML,crt_cre_cr13,branchCreVgmEmis,'
+`				XML,crt_cre_cr14,branchCreVgmEmis,'
+`				XML,crt_cre_cr15,branchCreVgmEmis,'
+`				XML,crt_cre_cr16,branchCreVgmEmis,'
+`				XML,crt_cre_cr17,branchCreVgmEmis,'
+`				XML,crt_cre_cr18,branchCreVgmEmis,'
+`				XML,crt_cre_cr20,branchCreVgmRecu,'
+`				XML,crt_cre_cr21,branchCreVgmRecu,'
+`				XML,crt_cre_cr22,branchCreVgmRecu,'
+`				XML,crt_cre_cr23,branchCreVgmRecu,'
+`				XML,crt_cre_cr24,branchCreVgmRecu,'
+`				XML,crt_cre_cr25,branchCreVgmRecu,'
+`				XML,crt_cre_cr30,branchCreVgmRecu,'
+`				XML,crt_cre_cr31,branchCreVgmRecu,'
+`				XML,crt_cre_cr40,branchCreRejet)'
+<!-- branche BB30 mapping des donnees des cre sur vgm/or emis -->
+		<!-- mapping des entete_commun et entete_cre sur vgm/or emis -->
+`cmd_mapper(branchCreVgmEmis,XML,,Fixed,,bufferWork,bufferTemp,activeClearFlag,crt_cre_header-crt_cre_header)'
+`cmd_mapper(branchCreVgmEmis,XML,,Fixed,,bufferWork,bufferTemp,,crt_cre_header-crt_cre_header_special_fixed)'
+`cmd_mapper(branchCreVgmEmis,XML,,Fixed,,bufferWork,bufferTemp,,crt_cre_flux_emis_header-crt_cre_flux_emis_header)'
+		<!-- identification du flux -->
+`cmd_identifier(branchCreVgmEmis,bufferWork,n,crt_cre_emis_ident,'
+`				XML,crt_cre_emis_vs02,branchCommuneVirtBankCus,'
+`				XML,crt_cre_emis_vs03,branchCommuneVirtBankCus,'
+`				XML,crt_cre_emis_vs04,branchCommuneVirtBankCus,'
+`				XML,crt_cre_emis_vs07,branchCommuneVirtBankCus,'
+`				XML,crt_cre_emis_vs08,branchCommuneVirtBankCus,'
+`				XML,crt_cre_emis_os01,branchVirtOr)'
+<!-- branche BB31 mapping des donnees des cre sur vgm/or recus -->
+		<!-- mapping des entete_commun et entete_cre sur vgm/or recus -->
+`cmd_mapper(branchCreVgmRecu,XML,,Fixed,,bufferWork,bufferTemp,activeClearFlag,crt_cre_header-crt_cre_header)'
+`cmd_mapper(branchCreVgmRecu,XML,,Fixed,,bufferWork,bufferTemp,,crt_cre_header-crt_cre_header_special_fixed)'
+`cmd_mapper(branchCreVgmRecu,XML,,Fixed,,bufferWork,bufferTemp,,crt_cre_flux_recu_header-crt_cre_flux_recu_header)'
+		<!-- identification du flux -->
+`cmd_identifier(branchCreVgmRecu,bufferWork,n,crt_cre_recu_ident,'
+`				XML,crt_cre_recu_vs02,branchCommuneVirtBankCus,'
+`				XML,crt_cre_recu_vs03,branchCommuneVirtBankCus,'
+`				XML,crt_cre_recu_vs04,branchCommuneVirtBankCus,'
+`				XML,crt_cre_recu_vs07,branchCommuneVirtBankCus,'
+`				XML,crt_cre_recu_vs08,branchCommuneVirtBankCus,'
+`				XML,crt_cre_recu_os01,branchVirtOr)'
+<!-- branche BB32 mapping des donnees des cre de rejet -->
+		<!-- mapping des entete_commun et entete_cre de rejet -->
+`cmd_mapper(branchCreRejet,XML,,Fixed,,bufferWork,bufferTemp,activeClearFlag,crt_cre_header-crt_cre_header)'
+`cmd_mapper(branchCreRejet,XML,,Fixed,,bufferWork,bufferTemp,,crt_cre_header-crt_cre_header_special_fixed)'
+`cmd_mapper(branchCreRejet,XML,,Fixed,,bufferWork,bufferTemp,,crt_cre_rejet_header-crt_cre_rejet_header)'
+<!-- Extraction de l'en tete commun du flux contenu dans le cre de rejet -->
+`cmd_mapper(branchCreRejet,XML,,Fixed,,bufferWork,bufferTemp,,crt_cre_flux_header-crt_cre_flux_header)'
+		<!-- identification du flux -->
+`cmd_identifier(branchCreRejet,bufferWork,n,crt_cre_rejet_ident,'
+`				XML,crt_cre_rejet_vs02,branchCreRejet,'
+`				XML,crt_cre_rejet_vs03,branchCreRejet,'
+`				XML,crt_cre_rejet_vs04,branchCreRejet,'
+`				XML,crt_cre_rejet_vs07,branchCreRejet,'
+`				XML,crt_cre_rejet_vs08,branchCreRejet,'
+`				XML,crt_cre_rejet_os01,branchCreRejetOr)'
+<!-- Extraction de l'en tete specifique du VS contenu dans le cre de rejet -->
+`cmd_mapper(branchCreRejet,XML,,Fixed,,bufferWork,bufferTemp,,crt_cre_flux_stlm_header-crt_cre_flux_stlm_header)'
+<!-- retour a la branche commune -->
+`cmd_go_to(branchCreRejet,branchCommuneVirtBankCus)'
+<!-- Extraction de l'en tete specifique de l'OR contenu dans le cre de rejet -->
+`cmd_mapper(branchCreRejetOr,XML,,Fixed,,bufferWork,bufferTemp,,crt_cre_flux_or_header-crt_cre_flux_or_header)'
+<!-- retour a la branche specifique or -->
+`cmd_go_to(branchCreRejetOr,branchVirtOr)'
+<!-- branche BB2 traitement des blocs communs aux virements bancaires et de clientele 13c 52 56 57 72 -->
+<!-- bloc 13c -->
+		<!-- mapping du bloc 13c -->
+`cmd_mapper(branchCommuneVirtBankCus,XML,,Fixed,,bufferWork,bufferMapping13C,,swf_cre_field_13c-swf_cre_field_13c)'
+`ifelse($1,MODE_TRUNC,
+`<!--  Traitement du bloc 13C -->'
+<!--  6eme Occ 13C  -->
+`cmd_identifier(branchCommuneVirtBankCus,bufferWork,n,crt_cre_flux_13c_occ6,'
+`				XML,crt_cre_flux_stlm_avec13c_occ6,branchVirtBank,'
+`				XML,unknown,branchCommuneVirtBankCus)'
+`cmd_mapper(branchVirtBank,XML,,Fixed,,bufferWork,bufferOcc13C,activeClearFlag,swf_cre_field_13c-swf_cre_field_13c_occ6)'
+`cmd_identifier(branchVirtBank,bufferOcc13C,n,swf_cre_field_occ13x,'
+`				Fixed,swf_cre_field_occ13c_sndtime,branchMappingCommunBankCus,'
+`				Fixed,swf_cre_field_occ13c_clstime,branchOcc13cClstime,'
+`				Fixed,unknown,branchOcc13cTrunc)'
+`cmd_go_to(branchVirtBank,branchCommuneVirtBankCus)'
+`cmd_mapper(branchMappingCommunBankCus,Fixed,,Fixed,,bufferOcc13C,bufferTemp,,swf_cre_field_occ13c_sndtime-crt_cre_header)'
+`cmd_go_to(branchMappingCommunBankCus,branchCommuneVirtBankCus)'
+`cmd_mapper(branchOcc13cClstime,Fixed,,Fixed,,bufferOcc13C,bufferTemp,,swf_cre_field_occ13c_clstime-crt_cre_header)'
+`cmd_go_to(branchOcc13cClstime,branchCommuneVirtBankCus)'
+`cmd_mapper(branchOcc13cTrunc,XML,,Fixed,,bufferWork,bufferTemp,,swf_cre_field_occ13c_tronc-crt_cre_header)'
+`cmd_go_to(branchOcc13cTrunc,branchCommuneVirtBankCus)'
+<!--  5eme Occ 13C  -->
+`cmd_identifier(branchCommuneVirtBankCus,bufferWork,n,crt_cre_flux_13c_occ5,'
+`				XML,crt_cre_flux_stlm_avec13c_occ5,branchVirtBank,'
+`				XML,unknown,branchCommuneVirtBankCus)'
+`cmd_mapper(branchVirtBank,XML,,Fixed,,bufferWork,bufferOcc13C,activeClearFlag,swf_cre_field_13c-swf_cre_field_13c_occ5)'
+`cmd_identifier(branchVirtBank,bufferOcc13C,n,swf_cre_field_occ13x,'
+`				Fixed,swf_cre_field_occ13c_sndtime,branchMappingCommunBankCus,'
+`				Fixed,swf_cre_field_occ13c_clstime,branchOcc13cClstime,'
+`				Fixed,unknown,branchOcc13cTrunc)'
+`cmd_go_to(branchVirtBank,branchCommuneVirtBankCus)'
+`cmd_mapper(branchMappingCommunBankCus,Fixed,,Fixed,,bufferOcc13C,bufferTemp,,swf_cre_field_occ13c_sndtime-crt_cre_header)'
+`cmd_go_to(branchMappingCommunBankCus,branchCommuneVirtBankCus)'
+`cmd_mapper(branchOcc13cClstime,Fixed,,Fixed,,bufferOcc13C,bufferTemp,,swf_cre_field_occ13c_clstime-crt_cre_header)'
+`cmd_go_to(branchOcc13cClstime,branchCommuneVirtBankCus)'
+`cmd_mapper(branchOcc13cTrunc,XML,,Fixed,,bufferWork,bufferTemp,,swf_cre_field_occ13c_tronc-crt_cre_header)'
+`cmd_go_to(branchOcc13cTrunc,branchCommuneVirtBankCus)'
+<!--  4eme Occ 13C  -->
+`cmd_identifier(branchCommuneVirtBankCus,bufferWork,n,crt_cre_flux_13c_occ4,'
+`				XML,crt_cre_flux_stlm_avec13c_occ4,branchVirtBank,'
+`				XML,unknown,branchCommuneVirtBankCus)'
+`cmd_mapper(branchVirtBank,XML,,Fixed,,bufferWork,bufferOcc13C,activeClearFlag,swf_cre_field_13c-swf_cre_field_13c_occ4)'
+`cmd_identifier(branchVirtBank,bufferOcc13C,n,swf_cre_field_occ13x,'
+`				Fixed,swf_cre_field_occ13c_sndtime,branchMappingCommunBankCus,'
+`				Fixed,swf_cre_field_occ13c_clstime,branchOcc13cClstime,'
+`				Fixed,unknown,branchOcc13cTrunc)'
+`cmd_go_to(branchVirtBank,branchCommuneVirtBankCus)'
+`cmd_mapper(branchMappingCommunBankCus,Fixed,,Fixed,,bufferOcc13C,bufferTemp,,swf_cre_field_occ13c_sndtime-crt_cre_header)'
+`cmd_go_to(branchMappingCommunBankCus,branchCommuneVirtBankCus)'
+`cmd_mapper(branchOcc13cClstime,Fixed,,Fixed,,bufferOcc13C,bufferTemp,,swf_cre_field_occ13c_clstime-crt_cre_header)'
+`cmd_go_to(branchOcc13cClstime,branchCommuneVirtBankCus)'
+`cmd_mapper(branchOcc13cTrunc,XML,,Fixed,,bufferWork,bufferTemp,,swf_cre_field_occ13c_tronc-crt_cre_header)'
+`cmd_go_to(branchOcc13cTrunc,branchCommuneVirtBankCus)'
+<!--  3eme Occ 13C  -->
+`cmd_identifier(branchCommuneVirtBankCus,bufferWork,n,crt_cre_flux_13c_occ3,'
+`				XML,crt_cre_flux_stlm_avec13c_occ3,branchVirtBank,'
+`				XML,unknown,branchCommuneVirtBankCus)'
+`cmd_mapper(branchVirtBank,XML,,Fixed,,bufferWork,bufferOcc13C,activeClearFlag,swf_cre_field_13c-swf_cre_field_13c_occ3)'
+`cmd_identifier(branchVirtBank,bufferOcc13C,n,swf_cre_field_occ13x,'
+`				Fixed,swf_cre_field_occ13c_sndtime,branchMappingCommunBankCus,'
+`				Fixed,swf_cre_field_occ13c_clstime,branchOcc13cClstime,'
+`				Fixed,unknown,branchOcc13cTrunc)'
+`cmd_go_to(branchVirtBank,branchCommuneVirtBankCus)'
+`cmd_mapper(branchMappingCommunBankCus,Fixed,,Fixed,,bufferOcc13C,bufferTemp,,swf_cre_field_occ13c_sndtime-crt_cre_header)'
+`cmd_go_to(branchMappingCommunBankCus,branchCommuneVirtBankCus)'
+`cmd_mapper(branchOcc13cClstime,Fixed,,Fixed,,bufferOcc13C,bufferTemp,,swf_cre_field_occ13c_clstime-crt_cre_header)'
+`cmd_go_to(branchOcc13cClstime,branchCommuneVirtBankCus)'
+`cmd_mapper(branchOcc13cTrunc,XML,,Fixed,,bufferWork,bufferTemp,,swf_cre_field_occ13c_tronc-crt_cre_header)'
+`cmd_go_to(branchOcc13cTrunc,branchCommuneVirtBankCus)'
+<!--  2eme Occ 13C  -->
+`cmd_identifier(branchCommuneVirtBankCus,bufferWork,n,crt_cre_flux_13c_occ2,'
+`				XML,crt_cre_flux_stlm_avec13c_occ2,branchVirtBank,'
+`				XML,unknown,branchCommuneVirtBankCus)'
+`cmd_mapper(branchVirtBank,XML,,Fixed,,bufferWork,bufferOcc13C,activeClearFlag,swf_cre_field_13c-swf_cre_field_13c_occ2)'
+`cmd_identifier(branchVirtBank,bufferOcc13C,n,swf_cre_field_occ13x,'
+`				Fixed,swf_cre_field_occ13c_sndtime,branchMappingCommunBankCus,'
+`				Fixed,swf_cre_field_occ13c_clstime,branchOcc13cClstime,'
+`				Fixed,unknown,branchOcc13cTrunc)'
+`cmd_go_to(branchVirtBank,branchCommuneVirtBankCus)'
+`cmd_mapper(branchMappingCommunBankCus,Fixed,,Fixed,,bufferOcc13C,bufferTemp,,swf_cre_field_occ13c_sndtime-crt_cre_header)'
+`cmd_go_to(branchMappingCommunBankCus,branchCommuneVirtBankCus)'
+`cmd_mapper(branchOcc13cClstime,Fixed,,Fixed,,bufferOcc13C,bufferTemp,,swf_cre_field_occ13c_clstime-crt_cre_header)'
+`cmd_go_to(branchOcc13cClstime,branchCommuneVirtBankCus)'
+`cmd_mapper(branchOcc13cTrunc,XML,,Fixed,,bufferWork,bufferTemp,,swf_cre_field_occ13c_tronc-crt_cre_header)'
+`cmd_go_to(branchOcc13cTrunc,branchCommuneVirtBankCus)'
+<!--  1eme Occ 13C  -->
+`cmd_identifier(branchCommuneVirtBankCus,bufferWork,n,crt_cre_flux_13c_occ1,'
+`				XML,crt_cre_flux_stlm_avec13c,branchVirtBank,'
+`				XML,unknown,branchCommuneVirtBankCus)'
+`cmd_mapper(branchVirtBank,XML,,Fixed,,bufferWork,bufferOcc13C,activeClearFlag,swf_cre_field_13c-crt_cre_flux_stlm_avec13c)'
+`cmd_identifier(branchVirtBank,bufferOcc13C,n,swf_cre_field_occ13x,'
+`				Fixed,swf_cre_field_occ13c_sndtime,branchMappingCommunBankCus,'
+`				Fixed,swf_cre_field_occ13c_clstime,branchOcc13cClstime,'
+`				Fixed,unknown,branchOcc13cTrunc)'
+`cmd_go_to(branchVirtBank,branchCommuneVirtBankCus)'
+`cmd_mapper(branchMappingCommunBankCus,Fixed,,Fixed,,bufferOcc13C,bufferTemp,,swf_cre_field_occ13c_sndtime-crt_cre_header)'
+`cmd_go_to(branchMappingCommunBankCus,branchCommuneVirtBankCus)'
+`cmd_mapper(branchOcc13cClstime,Fixed,,Fixed,,bufferOcc13C,bufferTemp,,swf_cre_field_occ13c_clstime-crt_cre_header)'
+`cmd_go_to(branchOcc13cClstime,branchCommuneVirtBankCus)'
+`cmd_mapper(branchOcc13cTrunc,XML,,Fixed,,bufferWork,bufferTemp,,swf_cre_field_occ13c_tronc-crt_cre_header)'
+`cmd_go_to(branchOcc13cTrunc,branchCommuneVirtBankCus)'
+<!--  Traitement du bloc 13C FIN -->)dnl`else')'
+`ifelse($1,MODE_TRUNC,
+`
+<!-- fin bloc 13c -->',`<!-- fin bloc 13c -->')'
+<!-- bloc 52 -->
+		<!-- identifier format du bloc 52 -->
+`cmd_identifier(branchCommuneVirtBankCus,bufferWork,n,swf_cre_field_52x,'
+`				XML,swf_cre_field_52d_fmt,branchFld_D_K,'
+`				XML,swf_cre_field_52a_fmt,branchFld_A_B_Blanc,'
+`				XML,unknown,branchFld_A_B_Blanc)'
+		<!-- mapping du bloc 52A  -->
+`cmd_mapper(branchFld_A_B_Blanc,XML,,Fixed,,bufferWork,bufferMapping52,,swf_cre_field_52x-swf_cre_field_52x-format_a)'
+`cmd_go_to(branchFld_A_B_Blanc,branchCommuneVirtBankCus)'
+		<!-- mapping du bloc 52D (hors complements) -->
+`cmd_mapper(branchFld_D_K,XML,,Fixed,,bufferWork,bufferMapping52,,swf_cre_field_52x-swf_cre_field_52x-format_d)'
+		<!-- mapping de complements du bloc52D -->
+`cmd_mapper(branchFld_D_K,XML,,Delimited,crlf_t,bufferWork,bufferWorkMultiligne,activeClearFlag,swf_cre_field_52d_comp-swf_cre_field_52d_comp)'
+		<!-- insertion de complements du bloc52D -->
+`cmd_mapper(branchFld_D_K,Fixed,,Fixed,,bufferWorkMultiligne,bufferMapping52,,swf_cre_field_52d_comp-swf_cre_field_52x)'
+`cmd_go_to(branchFld_D_K,branchCommuneVirtBankCus)'
+<!-- fin bloc 52 -->
+<!-- bloc 56 -->
+		<!-- identifier format du bloc 56 -->
+`cmd_identifier(branchCommuneVirtBankCus,bufferWork,n,swf_cre_field_56x,'
+`				XML,swf_cre_field_56d_fmt,branchFld_D_K,'
+`				XML,swf_cre_field_56a_fmt,branchFld_A_B_Blanc,'
+`				XML,unknown,branchFld_A_B_Blanc)'
+		<!-- mapping du bloc 56A  -->
+`cmd_mapper(branchFld_A_B_Blanc,XML,,Fixed,,bufferWork,bufferMapping56,,swf_cre_field_56x-swf_cre_field_56x-format_a)'
+`cmd_go_to(branchFld_A_B_Blanc,branchCommuneVirtBankCus)'
+		<!-- mapping du bloc 56D (hors complements) -->
+`cmd_mapper(branchFld_D_K,XML,,Fixed,,bufferWork,bufferMapping56,,swf_cre_field_56x-swf_cre_field_56x-format_d)'
+		<!-- mapping de complements du bloc56D -->
+`cmd_mapper(branchFld_D_K,XML,,Delimited,crlf_t,bufferWork,bufferWorkMultiligne,activeClearFlag,swf_cre_field_56d_comp-swf_cre_field_56d_comp)'
+		<!-- insertion de complements du bloc56D -->
+`cmd_mapper(branchFld_D_K,Fixed,,Fixed,,bufferWorkMultiligne,bufferMapping56,,swf_cre_field_56d_comp-swf_cre_field_56x)'
+`cmd_go_to(branchFld_D_K,branchCommuneVirtBankCus)'
+<!-- fin bloc 56 -->
+<!-- bloc 57 -->
+		<!-- identifier format du bloc 57 -->
+`cmd_identifier(branchCommuneVirtBankCus,bufferWork,n,swf_cre_field_57x,'
+`				XML,swf_cre_field_57d_fmt,branchFld_D_K,'
+`				XML,swf_cre_field_57a_fmt,branchFld_A_B_Blanc,'
+`				XML,swf_cre_field_57b_fmt,branchFld_A_B_Blanc,'
+`				XML,unknown,branchFld_A_B_Blanc)'
+		<!-- mapping du bloc 57A  -->
+`cmd_mapper(branchFld_A_B_Blanc,XML,,Fixed,,bufferWork,bufferMapping57,,swf_cre_field_57x-swf_cre_field_57x-format_a)'
+`cmd_go_to(branchFld_A_B_Blanc,branchCommuneVirtBankCus)'
+		<!-- mapping du bloc 57D (hors complements) -->
+`cmd_mapper(branchFld_D_K,XML,,Fixed,,bufferWork,bufferMapping57,,swf_cre_field_57x-swf_cre_field_57x-format_d)'
+		<!-- mapping de complements du bloc57D -->
+`cmd_mapper(branchFld_D_K,XML,,Delimited,crlf_t,bufferWork,bufferWorkMultiligne,activeClearFlag,swf_cre_field_57d_comp-swf_cre_field_57d_comp)'
+		<!-- insertion de complements du bloc57D -->
+`cmd_mapper(branchFld_D_K,Fixed,,Fixed,,bufferWorkMultiligne,bufferMapping57,,swf_cre_field_57d_comp-swf_cre_field_57x)'
+`cmd_go_to(branchFld_D_K,branchCommuneVirtBankCus)'
+<!-- fin bloc 57 -->
+<!-- bloc 72 -->
+		<!-- mapping du bloc 72 (hors autres lignes)  -->
+`cmd_mapper(branchCommuneVirtBankCus,XML,,Fixed,,bufferWork,bufferMapping72,,swf_cre_field_72-swf_cre_field_72)'
+		<!-- mapping de autres lignes du bloc 72 -->
+`cmd_mapper(branchCommuneVirtBankCus,XML,,Delimited,crlf_t,bufferWork,bufferWorkMultiligne,activeClearFlag,swf_cre_field_72_autres_lignes-swf_cre_field_72_autres_lignes)'
+		<!-- insertion de autres lignes du bloc 72 -->
+`cmd_mapper(branchCommuneVirtBankCus,Fixed,,Fixed,,bufferWorkMultiligne,bufferMapping72,,swf_cre_field_72_autres_lignes-swf_cre_field_72)'
+<!-- fin bloc 72 -->
+<!-- fin de traitement des blocs communs aux virements bancaires et de clientele -->
+		<!-- identification complete a partir de la branche 0 -->
+`cmd_identifier(branchCommuneVirtBankCus,bufferWork,y,crt_cre_flux_ident,'
+`				XML,crt_cre_flux_vs02,branchVirtBank,'
+`				XML,crt_cre_flux_vs03,branchVirtBank,'
+`				XML,crt_cre_flux_vs04,branchVirtBank,'
+`				XML,crt_cre_flux_vs07,branchVirtCus,'
+`				XML,crt_cre_flux_vs08,branchVirtCus)'
+<!-- branche BB3 mapping des donnees specifiques au virement bancaire -->
+<!-- bloc 58 -->
+		<!-- identifier format du bloc 58 -->
+`cmd_identifier(branchVirtBank,bufferWork,n,swf_cre_field_58x,'
+`				XML,swf_cre_field_58d_fmt,branchFld_D_K,'
+`				XML,swf_cre_field_58a_fmt,branchFld_A_B_Blanc,'
+`				XML,swf_cre_field_58b_fmt,branchFld_A_B_Blanc,'
+`				XML,unknown,branchFld_A_B_Blanc)'
+		<!-- mapping du bloc 58A  -->
+`cmd_mapper(branchFld_A_B_Blanc,XML,,Fixed,,bufferWork,bufferMapping58,,swf_cre_field_58x-swf_cre_field_58x-format_a)'
+`cmd_go_to(branchFld_A_B_Blanc,branchVirtBank)'
+		<!-- mapping du bloc 58D (hors complements)  -->
+`cmd_mapper(branchFld_D_K,XML,,Fixed,,bufferWork,bufferMapping58,,swf_cre_field_58x-swf_cre_field_58x-format_d)'
+		<!-- mapping de complements du bloc58D -->
+`cmd_mapper(branchFld_D_K,XML,,Delimited,crlf_t,bufferWork,bufferWorkMultiligne,activeClearFlag,swf_cre_field_58d_comp-swf_cre_field_58d_comp)'
+		<!-- insertion de complements du bloc58D -->
+`cmd_mapper(branchFld_D_K,Fixed,,Fixed,,bufferWorkMultiligne,bufferMapping58,,swf_cre_field_58d_comp-swf_cre_field_58x)'
+`cmd_go_to(branchFld_D_K,branchVirtBank)'
+<!-- fin bloc 58 -->
+<!-- mapping du virement bancaire hors blocs 13c 52 56 57 58 72 -->
+`cmd_mapper(branchVirtBank,XML,,Fixed,,bufferWork,bufferDataMsg,,crt_cre_flux_stlm_bk-crt_cre_flux_stlm_bk)'
+<!-- fin mapping du virement bancaire hors blocs 13c 52 56 57 58 72 -->
+<!-- insertion des blocs 52 56 57 58 72 -->
+`cmd_mapper(branchVirtBank,Fixed,,Fixed,,bufferMapping52,bufferDataMsg,,swf_cre_field_52x-crt_cre_flux_stlm_bk)'
+`cmd_mapper(branchVirtBank,Fixed,,Fixed,,bufferMapping56,bufferDataMsg,,swf_cre_field_56x-crt_cre_flux_stlm_bk)'
+`cmd_mapper(branchVirtBank,Fixed,,Fixed,,bufferMapping57,bufferDataMsg,,swf_cre_field_57x-crt_cre_flux_stlm_bk)'
+`cmd_mapper(branchVirtBank,Fixed,,Fixed,,bufferMapping58,bufferDataMsg,,swf_cre_field_58x-crt_cre_flux_stlm_bk)'
+`cmd_mapper(branchVirtBank,Fixed,,Fixed,,bufferMapping72,bufferDataMsg,,swf_cre_field_72-crt_cre_flux_stlm_bk)'
+<!-- fin insertion des blocs 52 56 57 58 72 -->
+`ifelse($1,MODE_NO_TRUNC,<!-- insertion du bloc 13c -->
+`cmd_mapper(branchVirtBank,Fixed,,Fixed,,bufferMapping13C,bufferDataMsg,,swf_cre_field_13c-crt_cre_flux_stlm_bk)'
+<!-- fin insertion du bloc 13c -->,`dnl')'
+<!-- fin de traitement specifiques aux virements bancaires -->
+<!-- retour a la branche commune -->
+`cmd_go_to(branchVirtBank,branchCommuneVirtBankCus)'
+<!-- branche BB4 mapping des donnees specifiques au virement de clientele -->
+<!-- mapping du virement de clientele hors blocs 13c 50 52 55 56 57 59 70 72 77 -->
+		<!-- mapping jusqu'au bloc 56 -->
+`cmd_mapper(branchVirtCus,XML,,Fixed,,bufferWork,bufferDataMsg,,crt_cre_flux_stlm_cus-crt_cre_flux_stlm_cus)'
+		<!-- mapping a partir du bloc 56 jusqu'au bloc 77 -->
+`cmd_mapper(branchVirtCus,XML,,Fixed,,bufferWork,bufferDataVirtCus,,crt_cre_flux_stlm_cus_end-crt_cre_flux_stlm_cus_end)'
+<!-- fin mapping du virement de clientele hors blocs 13c 50 52 55 56 57 59 70 72 77 -->
+<!-- insertion des blocs 52 56 57 72 deja mappes -->
+`cmd_mapper(branchVirtCus,Fixed,,Fixed,,bufferMapping52,bufferDataMsg,,swf_cre_field_52x-crt_cre_flux_stlm_cus)'
+`cmd_mapper(branchVirtCus,Fixed,,Fixed,,bufferMapping56,bufferDataVirtCus,,swf_cre_field_56x-crt_cre_flux_stlm_cus_end)'
+`cmd_mapper(branchVirtCus,Fixed,,Fixed,,bufferMapping57,bufferDataVirtCus,,swf_cre_field_57x-crt_cre_flux_stlm_cus_end)'
+`cmd_mapper(branchVirtCus,Fixed,,Fixed,,bufferMapping72,bufferDataVirtCus,,swf_cre_field_72-crt_cre_flux_stlm_cus_end)'
+<!-- fin insertion des blocs 52 56 57 72 -->
+<!-- mapping et insertion des blocs specifiques au virement de clientele hors 55 -->
+<!-- bloc 50 -->
+		<!-- identifier format du bloc 50 -->
+`cmd_identifier(branchVirtCus,bufferWork,n,swf_cre_field_50x,'
+`				XML,swf_cre_field_50k_fmt,branchFld_D_K,'
+`				XML,swf_cre_field_50a_fmt,branchFld_A_B_Blanc,'
+`				XML,unknown,branchFld_A_B_Blanc)'
+		<!-- mapping du bloc 50A  -->
+`cmd_mapper(branchFld_A_B_Blanc,XML,,Fixed,,bufferWork,bufferMapping50,,swf_cre_field_50x-swf_cre_field_50x-format_a)'
+`cmd_go_to(branchFld_A_B_Blanc,branchVirtCus)'
+		<!-- mapping du bloc 50K (hors complements)  -->
+`cmd_mapper(branchFld_D_K,XML,,Fixed,,bufferWork,bufferMapping50,,swf_cre_field_50x-swf_cre_field_50x-format_k)'
+		<!-- mapping de complements du bloc50k -->
+`cmd_mapper(branchFld_D_K,XML,,Delimited,crlf_t,bufferWork,bufferWorkMultiligne,activeClearFlag,swf_cre_field_50k_comp-swf_cre_field_50k_comp)'
+		<!-- insertion de complements du bloc50k -->
+`cmd_mapper(branchFld_D_K,Fixed,,Fixed,,bufferWorkMultiligne,bufferMapping50,,swf_cre_field_50k_comp-swf_cre_field_50x)'
+`cmd_go_to(branchFld_D_K,branchVirtCus)'
+		<!-- insertion du bloc 50 -->
+`cmd_mapper(branchVirtCus,Fixed,,Fixed,,bufferMapping50,bufferDataMsg,,swf_cre_field_50x-crt_cre_flux_stlm_cus)'
+<!-- fin bloc 50 -->
+<!-- bloc 59 -->
+		<!-- identifier format du bloc 59 -->
+`cmd_identifier(branchVirtCus,bufferWork,n,swf_cre_field_59x,'
+`				XML,swf_cre_field_59blanc_fmt,branchFld_D_K,'
+`				XML,swf_cre_field_59a_fmt,branchFld_A_B_Blanc,'
+`				XML,unknown,branchFld_A_B_Blanc)'
+		<!-- mapping du bloc 59A  -->
+`cmd_mapper(branchFld_A_B_Blanc,XML,,Fixed,,bufferWork,bufferMapping59,,swf_cre_field_59x-swf_cre_field_59x-format_a)'
+`cmd_go_to(branchFld_A_B_Blanc,branchVirtCus)'
+		<!-- mapping du bloc 59blanc (hors complements)  -->
+`cmd_mapper(branchFld_D_K,XML,,Fixed,,bufferWork,bufferMapping59,,swf_cre_field_59x-swf_cre_field_59x-format_blanc)'
+		<!-- mapping de complements du bloc 59blanc -->
+`cmd_mapper(branchFld_D_K,XML,,Delimited,crlf_t,bufferWork,bufferWorkMultiligne,activeClearFlag,swf_cre_field_59blanc_comp-swf_cre_field_59blanc_comp)'
+		<!-- insertion de complements du bloc 59blanc -->
+`cmd_mapper(branchFld_D_K,Fixed,,Fixed,,bufferWorkMultiligne,bufferMapping59,,swf_cre_field_59blanc_comp-swf_cre_field_59x)'
+`cmd_go_to(branchFld_D_K,branchVirtCus)'
+		<!-- insertion du bloc 59 -->
+`cmd_mapper(branchVirtCus,Fixed,,Fixed,,bufferMapping59,bufferDataVirtCus,,swf_cre_field_59x-crt_cre_flux_stlm_cus_end)'
+<!-- fin bloc 59 -->
+<!-- bloc 70 -->
+		<!-- mapping du bloc 70 -->
+`cmd_mapper(branchVirtCus,XML,,Delimited,crlf_t,bufferWork,bufferWorkMultiligne,activeClearFlag,swf_cre_field_70-swf_cre_field_70)'
+		<!-- insertion du bloc 70 -->
+`cmd_mapper(branchVirtCus,Fixed,,Fixed,,bufferWorkMultiligne,bufferDataVirtCus,,swf_cre_field_70-crt_cre_flux_stlm_cus_end)'
+<!-- fin bloc 70 -->
+<!-- bloc 77 -->
+		<!-- mapping du bloc 77 -->
+`cmd_mapper(branchVirtCus,XML,,Delimited,crlf_t,bufferWork,bufferWorkMultiligne,activeClearFlag,swf_cre_field_77-swf_cre_field_77)'
+		<!-- insertion du bloc 77 -->
+`cmd_mapper(branchVirtCus,Fixed,,Fixed,,bufferWorkMultiligne,bufferDataVirtCus,,swf_cre_field_77-crt_cre_flux_stlm_cus_end)'
+<!-- fin bloc 77 -->
+<!-- mapping et insertion des blocs specifiques au virement de clientele hors 55 -->
+<!-- traitement du bloc 55 -->
+<!-- bloc 55 -->
+		<!-- recherche existence du bloc 55 -->
+`cmd_identifier(branchVirtCus,bufferWork,n,crt_cre_flux_stlm_cus_sans55,'
+`				XML,crt_cre_flux_stlm_cus_avec55,branchFld55,'
+`				XML,unknown,branchVirtCus)'
+<!-- sans bloc 55 -->
+		<!-- insertion de la fin du virement (bloc 56 a bloc 77) -->
+`cmd_mapper(branchVirtCus,Fixed,,Fixed,,bufferDataVirtCus,bufferDataMsg,,crt_cre_flux_stlm_cus_56_a_77-crt_cre_flux_stlm_cus_56_a_77-sans55-insert)'
+`ifelse($1,MODE_NO_TRUNC,		<!-- insertion du bloc 13c -->
+`cmd_mapper(branchVirtCus,Fixed,,Fixed,,bufferMapping13C,bufferDataMsg,,swf_cre_field_13c-cre_cus_champ_13c_sans55)'
+		<!-- fin insertion du bloc 13c -->		,`dnl')'
+<!-- fin sans bloc 55 -->
+<!-- avec bloc 55 -->
+		<!-- identifier format du bloc 55 -->
+`cmd_identifier(branchFld55,bufferWork,n,swf_cre_field_55x,'
+`				XML,swf_cre_field_55d_fmt,branchFld_D_K,'
+`				XML,swf_cre_field_55a_fmt,branchFld_A_B_Blanc,'
+`				XML,swf_cre_field_55b_fmt,branchFld_A_B_Blanc,'
+`				XML,unknown,branchFld_A_B_Blanc)'
+		<!-- mapping du bloc 55A  -->
+`cmd_mapper(branchFld_A_B_Blanc,XML,,Fixed,,bufferWork,bufferMapping55,,swf_cre_field_55x-swf_cre_field_55x-format_a)'
+`cmd_go_to(branchFld_A_B_Blanc,branchFld55)'
+		<!-- mapping du bloc 55D (hors complements)  -->
+`cmd_mapper(branchFld_D_K,XML,,Fixed,,bufferWork,bufferMapping55,,swf_cre_field_55x-swf_cre_field_55x-format_d)'
+		<!-- mapping de complements du bloc55D -->
+`cmd_mapper(branchFld_D_K,XML,,Delimited,crlf_t,bufferWork,bufferWorkMultiligne,activeClearFlag,swf_cre_field_55d_comp-swf_cre_field_55d_comp)'
+		<!-- insertion de complements du bloc55D -->
+`cmd_mapper(branchFld_D_K,Fixed,,Fixed,,bufferWorkMultiligne,bufferMapping55,,swf_cre_field_55d_comp-swf_cre_field_55x)'
+`cmd_go_to(branchFld_D_K,branchFld55)'
+		<!-- insertion du bloc 55 -->
+`cmd_mapper(branchFld55,Fixed,,Fixed,,bufferMapping55,bufferDataMsg,,swf_cre_field_55x-crt_cre_flux_stlm_cus)'
+		<!-- insertion de la fin du virement (bloc 56 a bloc 77) -->
+`cmd_mapper(branchFld55,Fixed,,Fixed,,bufferDataVirtCus,bufferDataMsg,,crt_cre_flux_stlm_cus_56_a_77-crt_cre_flux_stlm_cus_56_a_77-avec55-insert)'
+`ifelse($1,MODE_NO_TRUNC,		<!-- insertion du bloc 13C -->
+`cmd_mapper(branchFld55,Fixed,,Fixed,,bufferMapping13C,bufferDataMsg,,swf_cre_field_13c-cre_cus_champ_13c_avec55)'
+		<!-- fin insertion du bloc 13c -->		,`dnl')'
+`cmd_go_to(branchFld55,branchVirtCus)'
+<!-- fin avec bloc 55 -->
+<!-- fin de traitement specifiques aux virements de clientele -->
+<!-- retour a la branche commune -->
+`cmd_go_to(branchVirtCus,branchCommuneVirtBankCus)'
+<!-- branche BB5 mapping des donnees specifiques aux ordres de restitutuion  -->
+<!-- Extraction des donnees de l'OR contenu dans le cre  -->
+`cmd_mapper(branchVirtOr,XML,,Fixed,,bufferWork,bufferDataMsg,,crt_cre_flux_or-crt_cre_flux_or)'
+<!-- retour a la branche commune -->
+`cmd_go_to(branchVirtOr,branchCommuneVirtBankCus)'
+<!-- insertion des donnees du virement dans le flux destine a l'ic -->
+`cmd_identifier(branchCommuneVirtBankCus,bufferWork,y,crt_cre_ident,'
+`				XML,crt_cre_cr01,branchCreVgmEmis,'
+`				XML,crt_cre_cr02,branchCreVgmEmis,'
+`				XML,crt_cre_cr03,branchCreVgmEmis,'
+`				XML,crt_cre_cr04,branchCreVgmEmis,'
+`				XML,crt_cre_cr05,branchCreVgmEmis,'
+`				XML,crt_cre_cr06,branchCreVgmEmis,'
+`				XML,crt_cre_cr07,branchCreVgmEmis,'
+`				XML,crt_cre_cr08,branchCreVgmEmis,'
+`				XML,crt_cre_cr09,branchCreVgmEmis,'
+`				XML,crt_cre_cr10,branchCreVgmEmis,'
+`				XML,crt_cre_cr11,branchCreVgmEmis,'
+`				XML,crt_cre_cr12,branchCreVgmEmis,'
+`				XML,crt_cre_cr13,branchCreVgmEmis,'
+`				XML,crt_cre_cr14,branchCreVgmEmis,'
+`				XML,crt_cre_cr15,branchCreVgmEmis,'
+`				XML,crt_cre_cr16,branchCreVgmEmis,'
+`				XML,crt_cre_cr17,branchCreVgmEmis,'
+`				XML,crt_cre_cr18,branchCreVgmEmis,'
+`				XML,crt_cre_cr20,branchCreVgmRecu,'
+`				XML,crt_cre_cr21,branchCreVgmRecu,'
+`				XML,crt_cre_cr22,branchCreVgmRecu,'
+`				XML,crt_cre_cr23,branchCreVgmRecu,'
+`				XML,crt_cre_cr24,branchCreVgmRecu,'
+`				XML,crt_cre_cr25,branchCreVgmRecu,'
+`				XML,crt_cre_cr30,branchCreVgmRecu,'
+`				XML,crt_cre_cr31,branchCreVgmRecu,'
+`				XML,crt_cre_cr40,branchCreRejet)'
+<!-- branche BB30 mapping des donnees des cre sur vgm/or emis -->
+		<!-- identification du flux -->
+`cmd_identifier(branchCreVgmEmis,bufferWork,n,crt_cre_emis_ident,'
+`				XML,crt_cre_emis_vs02,branchInsertStlmEmisInCre,'
+`				XML,crt_cre_emis_vs03,branchInsertStlmEmisInCre,'
+`				XML,crt_cre_emis_vs04,branchInsertStlmEmisInCre,'
+`				XML,crt_cre_emis_vs07,branchInsertStlmEmisInCre,'
+`				XML,crt_cre_emis_vs08,branchInsertStlmEmisInCre,'
+`				XML,crt_cre_emis_os01,branchInsertOrEmisInCre)'
+<!-- Insertion des donnees du virement contenu dans le cre  -->
+`cmd_mapper(branchInsertStlmEmisInCre,Fixed,,Fixed,,bufferDataMsg,bufferTemp,,crt_flux_stlm-crt_flux_stlm-insert_stlm_emis_in_cre)'
+<!-- fin de traitement des cre sur vgm emis -->
+`cmd_go_to(branchInsertStlmEmisInCre,branchTraitSelonFormat)'
+<!-- Insertion des donnees de l'OR contenu dans le cre  -->
+`cmd_mapper(branchInsertOrEmisInCre,Fixed,,Fixed,,bufferDataMsg,bufferTemp,,crt_flux_ordre_rest-crt_flux_ordre_rest-insert_or_emis_in_cre)'
+<!-- fin de traitement des cre sur or emis -->
+`cmd_go_to(branchInsertOrEmisInCre,branchTraitSelonFormat)'
+<!-- branche BB31 mapping des donnees des cre sur vgm/or recus -->
+		<!-- identification du flux -->
+`cmd_identifier(branchCreVgmRecu,bufferWork,n,crt_cre_recu_ident,'
+`				XML,crt_cre_recu_vs02,branchInsertStlmRecuInCre,'
+`				XML,crt_cre_recu_vs03,branchInsertStlmRecuInCre,'
+`				XML,crt_cre_recu_vs04,branchInsertStlmRecuInCre,'
+`				XML,crt_cre_recu_vs07,branchInsertStlmRecuInCre,'
+`				XML,crt_cre_recu_vs08,branchInsertStlmRecuInCre,'
+`				XML,crt_cre_recu_os01,branchInsertOrRecuInCre)'
+<!-- Insertion des donnees du virement contenu dans le cre  -->
+`cmd_mapper(branchInsertStlmRecuInCre,Fixed,,Fixed,,bufferDataMsg,bufferTemp,,crt_flux_stlm-crt_flux_stlm-insert_stlm_recu_in_cre)'
+<!-- fin de traitement des cre sur vgm recu -->
+`cmd_go_to(branchInsertStlmRecuInCre,branchTraitSelonFormat)'
+<!-- Insertion des donnees de l'OR contenu dans le cre  -->
+`cmd_mapper(branchInsertOrRecuInCre,Fixed,,Fixed,,bufferDataMsg,bufferTemp,,crt_flux_ordre_rest-crt_flux_ordre_rest-insert_or_recu_in_cre)'
+<!-- fin de traitement des cre sur or recu -->
+`cmd_go_to(branchInsertOrRecuInCre,branchTraitSelonFormat)'
+<!-- branche BB32 mapping des donnees des cre de rejet  -->
+		<!-- identification du flux -->
+`cmd_identifier(branchCreRejet,bufferWork,n,crt_cre_rejet_ident,'
+`				XML,crt_cre_rejet_vs02,branchInsertStlmInCreRejet,'
+`				XML,crt_cre_rejet_vs03,branchInsertStlmInCreRejet,'
+`				XML,crt_cre_rejet_vs04,branchInsertStlmInCreRejet,'
+`				XML,crt_cre_rejet_vs07,branchInsertStlmInCreRejet,'
+`				XML,crt_cre_rejet_vs08,branchInsertStlmInCreRejet,'
+`				XML,crt_cre_rejet_os01,branchInsertOrRecuInCreRejet)'
+<!-- Insertion des donnees du virement contenu dans le cre  -->
+`cmd_mapper(branchInsertStlmInCreRejet,Fixed,,Fixed,,bufferDataMsg,bufferTemp,,crt_flux_stlm-crt_flux_stlm-insert_stlm_in_cre_rejet)'
+<!-- fin de traitement des vgm en cre de rejet -->
+`cmd_go_to(branchInsertStlmInCreRejet,branchTraitSelonFormat)'
+<!-- Insertion des donnees de l'OR contenu dans le cre  -->
+`cmd_mapper(branchInsertOrRecuInCreRejet,Fixed,,Fixed,,bufferDataMsg,bufferTemp,,crt_flux_ordre_rest-crt_flux_ordre_rest-insert_or_recu_in_cre_rejet)'
+<!-- fin de traitement des or en cre de rejet -->
+`cmd_go_to(branchInsertOrRecuInCreRejet,branchTraitSelonFormat)')
+dnl
+dnl+--------------------------------------+
+dnl|    End Macro Section                 |
+dnl+--------------------------------------+
+dnl
diff --git a/src/sd_msg_struct/src/Makefile b/src/sd_msg_struct/src/Makefile
new file mode 100644
index 0000000..3b03694
--- /dev/null
+++ b/src/sd_msg_struct/src/Makefile
@@ -0,0 +1,66 @@
+#------------------------------------------------------------------------------
+# Local Makefile
+#------------------------------------------------------------------------------
+# $Workfile:   Makefile  $                                                     
+#------------------------------------------------------------------------------
+# $Author: agibert $                                                        
+# $Date: 2008/11/12 02:25:24 $                                             
+# $Revision: 1.1 $                                                         
+# $Label:  $                                                           
+#------------------------------------------------------------------------------
+
+#------------------------------------------------------------------------------
+# IMR - Interlinking Message Router                                            
+# Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)                
+# mailto:arnaud@rx3.net                                                        
+# http://www.rx3.org/dvp/?dvp=imr                                              
+#------------------------------------------------------------------------------
+# This file is part of IMR                                                     
+#                                                                              
+# This program is free software; you can redistribute it and/or                
+# modify it under the terms of the GNU General Public License                  
+# as published by the Free Software Foundation; either version 2               
+# of the License, or (at your option) any later version.                       
+#                                                                              
+# This program is distributed in the hope that it will be useful,              
+# but WITHOUT ANY WARRANTY; without even the implied warranty of               
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                
+# GNU General Public License for more details.                                 
+#                                                                              
+# You should have received a copy of the GNU General Public License            
+# along with this program; if not, write to the Free Software Foundation,      
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.          
+#------------------------------------------------------------------------------
+
+
+
+
+
+#------------------------------------------------------------------------------
+# Var include
+#------------------------------------------------------------------------------
+
+include ../../Makefile_var.mk
+
+
+
+#------------------------------------------------------------------------------
+# Variables
+#------------------------------------------------------------------------------
+
+TARGET=		sd_msg_struct.xml
+
+OBJ_RAW=	sd_msg_struct.xml.m4
+
+
+EXTRA_INC=	
+
+EXTRA_LIB=	
+
+
+
+#------------------------------------------------------------------------------
+# Rule include
+#------------------------------------------------------------------------------
+
+include ../../Makefile_rule.mk
diff --git a/src/sd_msg_struct/src/crt_cre_flux_ident.xml.m4 b/src/sd_msg_struct/src/crt_cre_flux_ident.xml.m4
new file mode 100644
index 0000000..762b865
--- /dev/null
+++ b/src/sd_msg_struct/src/crt_cre_flux_ident.xml.m4
@@ -0,0 +1,182 @@
+<!-- messages d'identification des flux destines a cristal -->
+<!-- branche BB2 point d'entree -->
+msg_object(crt_cre_flux_ident,,
+           ,,,
+               ,,,,,
+               ,,,,
+               ,,,,
+               )
+msg_object(crt_cre_flux_vs02,,
+           type_flux,`VS02',,
+               5,4,,,,
+               /cristal/cre/donnees_cre/flux/en_tete_commun/type_flux,,,,
+               ,,,,
+               )
+msg_object(crt_cre_flux_vs03,,
+           type_flux,`VS03',,
+               5,4,,,,
+               /cristal/cre/donnees_cre/flux/en_tete_commun/type_flux,,,,
+               ,,,,
+               )
+msg_object(crt_cre_flux_vs04,,
+           type_flux,`VS04',,
+               5,4,,,,
+               /cristal/cre/donnees_cre/flux/en_tete_commun/type_flux,,,,
+               ,,,,
+               )
+msg_object(crt_cre_flux_vs07,,
+           type_flux,`VS07',,
+               5,4,,,,
+               /cristal/cre/donnees_cre/flux/en_tete_commun/type_flux,,,,
+               ,,,,
+               )
+msg_object(crt_cre_flux_vs08,,
+           type_flux,`VS08',,
+               5,4,,,,
+               /cristal/cre/donnees_cre/flux/en_tete_commun/type_flux,,,,
+               ,,,,
+               )
+msg_object(crt_cre_flux_os01,,
+           type_flux,`OS01',,
+               5,4,,,,
+               /cristal/cre/donnees_cre/flux/en_tete_commun/type_flux,,,,
+               ,,,,
+               )
+<!-- messages d'identification des virements destines a cristal -->
+<!-- branche BB8 point d'entree -->
+msg_object(crt_cre_flux_stlm_sans13c,,
+           ,,,
+               ,,,,,
+               ,,,,
+               ,,,,
+               )
+<!-- branche BB8 specifique au xml -->
+<!-- DAHBI DEBUT -->
+msg_object(crt_cre_flux_13c_occ6,,
+           ,,,
+               ,,,,,
+               ,,,,
+               ,,,,
+               )
+msg_object(crt_cre_flux_13c_occ5,,
+           ,,,
+               ,,,,,
+               ,,,,
+               ,,,,
+               )
+msg_object(crt_cre_flux_13c_occ4,,
+           ,,,
+               ,,,,,
+               ,,,,
+               ,,,,
+               )
+msg_object(crt_cre_flux_13c_occ3,,
+           ,,,
+               ,,,,,
+               ,,,,
+               ,,,,
+               )
+msg_object(crt_cre_flux_13c_occ2,,
+           ,,,
+               ,,,,,
+               ,,,,
+               ,,,,
+               )
+msg_object(crt_cre_flux_13c_occ1,,
+           ,,,
+               ,,,,,
+               ,,,,
+               ,,,,
+               )
+msg_object(crt_cre_flux_stlm_avec13c_occ6,,
+           champ_13c_6,,y,
+               ,,,,,
+               /cristal/cre/donnees_cre/flux/donnees/champ13c[@occ="6"],,,,
+               ,,,,
+               )
+msg_object(crt_cre_flux_stlm_avec13c_occ5,,
+           champ_13c_5,,y,
+               ,,,,,
+               /cristal/cre/donnees_cre/flux/donnees/champ13c[@occ="5"],,,,
+               ,,,,
+               )
+msg_object(crt_cre_flux_stlm_avec13c_occ4,,
+           champ_13c_4,,y,
+               ,,,,,
+               /cristal/cre/donnees_cre/flux/donnees/champ13c[@occ="4"],,,,
+               ,,,,
+               )
+msg_object(crt_cre_flux_stlm_avec13c_occ3,,
+           champ_13c_3,,y,
+               ,,,,,
+               /cristal/cre/donnees_cre/flux/donnees/champ13c[@occ="3"],,,,
+               ,,,,
+               )
+msg_object(crt_cre_flux_stlm_avec13c_occ2,,
+           champ_13c_2,,y,
+               ,,,,,
+               /cristal/cre/donnees_cre/flux/donnees/champ13c[@occ="2"],,,,
+               ,,,,
+               )
+<!-- DAHBI FIN  -->
+msg_object(crt_cre_flux_stlm_avec13c,,
+           champ_13c_1,,y,
+               ,,,,,
+               /cristal/cre/donnees_cre/flux/donnees/champ13c[@occ="1"],,,,
+               ,,,,
+               )
+<!-- messages d'identification des virements de clientele avec ou sans bloc 55 -->	
+<!-- branche BB9 point d'entree -->
+msg_object(crt_cre_flux_stlm_cus_sans55,,
+           ,,,
+               ,,,,,
+               ,,,,
+               ,,,,
+               )
+<!-- branche BB9 specifique au xml -->
+msg_object(crt_cre_flux_stlm_cus_avec55,,
+           bq_de_refin_format,,y,
+               ,,,,,
+               /cristal/cre/donnees_cre/flux/donnees/bq_du_refin/format_champ,,,,
+               ,,,,
+               )
+<!-- messages d'identification des virements bancaires destines a cristal -->
+<!-- branche BB8 specifique au fixed -->
+msg_object(crt_cre_flux_stlm_bk_sans13c,1102,
+           ,,,
+               ,,,,,
+               ,,,,
+               ,,,,
+               )
+msg_object(crt_cre_flux_stlm_bk_avec13c,1216,
+           ,,,
+               ,,,,,
+               ,,,,
+               ,,,,
+               )
+<!-- messages d'identification des virements de clientele destines a cristal -->
+<!-- branche BB9 specifique au fixed -->
+msg_object(crt_cre_flux_stlm_cus_sans55_sans13c,2058,
+           ,,,
+               ,,,,,
+               ,,,,
+               ,,,,
+               )
+msg_object(crt_cre_flux_stlm_cus_sans55_avec13c,2172,
+           ,,,
+               ,,,,,
+               ,,,,
+               ,,,,
+               )
+msg_object(crt_cre_flux_stlm_cus_avec55_sans13c,2242,
+           ,,,
+               ,,,,,
+               ,,,,
+               ,,,,
+               )
+msg_object(crt_cre_flux_stlm_cus_avec55_avec13c,2356,
+           ,,,
+               ,,,,,
+               ,,,,
+               ,,,,
+               )
diff --git a/src/sd_msg_struct/src/crt_cre_flux_or.xml.m4 b/src/sd_msg_struct/src/crt_cre_flux_or.xml.m4
new file mode 100644
index 0000000..1e3b950
--- /dev/null
+++ b/src/sd_msg_struct/src/crt_cre_flux_or.xml.m4
@@ -0,0 +1,87 @@
+<!-- messages de mapping des entetes des ordres de restitution destines a ic -->
+<!-- taille 51 ( a partir de 302 entete commun) -->
+msg_object(crt_cre_flux_or_header,,
+           ref_util,,,
+               854,16,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/specific_or/ref_util,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           bic_emetteur,,,
+               870,11,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/specific_or/bic_emet,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           bic_recepteur,,,
+               881,11,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/specific_or/bic_recep,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           priorite_reseau,,,
+               892,1,,,` ',
+               /cristal/cre/donnees_cre/flux/specific_or/priorite_reseau,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           type_or,,,
+               893,4,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/specific_or/type_or,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           heure_emission_tot,,,
+               897,4,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/specific_or/h_emis_tot,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           heure_emission_tard,,,
+               901,4,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/specific_or/h_emis_tard,Strip_Right,` ',` ',
+               ,,,,
+               )
+<!-- messages de mapping des ordres de restitution virements bancaires (hors blocs 52 56 57 58 72) -->
+<!-- taille 83 -->
+      <!-- A VOIR xml sans fixed -->
+msg_object(crt_cre_flux_or,,
+           reference_emetteur_flux,,,
+               ,,,,,
+               /cristal/cre/donnees_cre/flux/donnees/ref_emet,,,,
+               ,,,,
+               ,
+           reference_d_origine,,,
+               0,16,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/ref_orig,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           date_de_reglement,,,
+               16,8,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/date_regl,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           devise,,,
+               24,3,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/devise,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           montant,,,
+               27,18,Pad_Left,`0',`0',
+               /cristal/cre/donnees_cre/flux/donnees/montant,Strip_Left,`0',`0',
+               ,,,,
+               ,
+           identification_du_sous_champ_errone,,,
+               45,3,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/champ_errone,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           code_motif_de_restitution,,,
+               48,4,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/code_motif_rest,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           code_commission_interbancaire,,,
+               52,2,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/code_commi,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           motif_de_la_restitution,,,
+               54,29,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/motif_rest,Strip_Right,` ',` ',
+               ,,,,
+               )
diff --git a/src/sd_msg_struct/src/crt_cre_flux_stlm.xml.m4 b/src/sd_msg_struct/src/crt_cre_flux_stlm.xml.m4
new file mode 100644
index 0000000..7a048e7
--- /dev/null
+++ b/src/sd_msg_struct/src/crt_cre_flux_stlm.xml.m4
@@ -0,0 +1,52 @@
+<!-- message permettant l'extraction et l'insertion des donnees d'un flux complet de ou dans un CRE40 -->
+<!-- 2771 = taille maxi des data (avec bloc 13c et champ 55) -->
+<!-- ne concernent que le format fixed -->
+msg_object(crt_flux_cre,,
+           flux_complet,,,
+               0,2771,,,,
+               ,,,,
+               ,,,,
+               ,
+           flux_complet_in_cre,,,
+               552,2771,,,,
+               ,,,,
+               ,,,,
+               )
+<!-- les messages de clientele sont decoupes en 3 parties -->
+<!-- du debut   jusqu'au bloc 55 inclus -->
+<!-- du bloc 56 jusqu'au bloc 77 inclus -->
+<!-- le bloc 13c -->
+<!-- message permettant l'extraction et l'insertion des donnees du bloc 56 jusqu'au bloc 77 inclus -->
+<!-- taille des donnees = 1200 -->
+<!-- ne concernent que le format fixed -->
+msg_object(crt_cre_flux_stlm_cus_56_a_77,,
+           cus_block2,,,
+               0,1200,,,,
+               ,,,,
+               ,,,,
+               ,
+           cus_block2_sans55,,,
+               858,1200,,,,
+               ,,,,
+               ,,,,
+               ,
+           cus_block2_avec55,,,
+               1042,1200,,,,
+               ,,,,
+               ,,,,
+               )
+<!-- message permettant l'extraction et l'insertion des donnees du bloc 13c -->
+<!-- taille des donnees = 114 -->
+<!-- ne concernent que le format fixed -->
+msg_object(cre_cus_champ_13c_sans55,,
+           champ_13c,,,
+               2058,114,Pad_Right,` ',` ',
+               ,,,,
+               ,,,,
+               )
+msg_object(cre_cus_champ_13c_avec55,,
+           champ_13c,,,
+               2242,114,Pad_Right,` ',` ',
+               ,,,,
+               ,,,,
+               )
diff --git a/src/sd_msg_struct/src/crt_cre_flux_stlm_bk.xml.m4 b/src/sd_msg_struct/src/crt_cre_flux_stlm_bk.xml.m4
new file mode 100644
index 0000000..6b96849
--- /dev/null
+++ b/src/sd_msg_struct/src/crt_cre_flux_stlm_bk.xml.m4
@@ -0,0 +1,70 @@
+<!-- messages de mapping des virements bancaires (hors blocs 52 56 57 58 72) -->
+<!-- contenus dans un cre de rejet (cr40) -->
+<!-- taille 1102 ou 1216 si bloc 13C -->
+		<!-- A VOIR xml sans fixed -->
+msg_object(crt_cre_flux_stlm_bk,,
+           reference_emetteur_flux,,,
+               ,,,,,
+               /cristal/cre/donnees_cre/flux/donnees/ref_emet,,,,
+               ,,,,
+               ,
+           reference_d_origine,,,
+               0,16,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/ref_orig,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           date_de_reglement,,,
+               16,8,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/date_regl,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           devise,,,
+               24,3,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/devise,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           montant,,,
+               27,18,Pad_Left,`0',`0',
+               /cristal/cre/donnees_cre/flux/donnees/montant,Strip_Left,`0',`0',
+               ,,,,
+               ,
+           champ_52,,,
+               45,184,Pad_Right,` ',` ',
+               ,,,,
+               ,,,,
+               ,
+           no_ccr_emet_rib_emet_ou_compte_cor,,,
+               229,34,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/compte_emet,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           ccr_recepteur,,,
+               263,11,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/compte_recep,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           champ_56,,,
+               274,184,Pad_Right,` ',` ',
+               ,,,,
+               ,,,,
+               ,
+           champ_57,,,
+               458,184,Pad_Right,` ',` ',
+               ,,,,
+               ,,,,
+               ,
+           champ_58,,,
+               642,184,Pad_Right,` ',` ',
+               ,,,,
+               ,,,,
+               ,
+           champ_72,,,
+               826,276,Pad_Right,` ',` ',
+               ,,,,
+               ,,,,
+               ,
+           champ_13c,,,
+               1102,114,Pad_Right,` ',` ',
+               ,,,,
+               ,,,,
+               )
diff --git a/src/sd_msg_struct/src/crt_cre_flux_stlm_cus.xml.m4 b/src/sd_msg_struct/src/crt_cre_flux_stlm_cus.xml.m4
new file mode 100644
index 0000000..66cb776
--- /dev/null
+++ b/src/sd_msg_struct/src/crt_cre_flux_stlm_cus.xml.m4
@@ -0,0 +1,145 @@
+<!-- messages de mapping des virements clientele jusqu'au bloc 55 (hors blocs 50 52) -->
+<!-- contenus dans un cre de rejet (cr40)	-->
+<!-- taille : 2058, 2172 (avec 13C), 2242 (avec 55), 2356 (avec 55 et 13C) -->
+      <!-- A VOIR xml sans fixed -->
+msg_object(crt_cre_flux_stlm_cus,,
+           reference_emetteur_flux,,,
+               ,,,,,
+               /cristal/cre/donnees_cre/flux/donnees/ref_emet,,,,
+               ,,,,
+               ,
+           23b_code_operation,,,
+               0,4,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/code_operation,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           23e_code_instruction01,,,
+               4,35,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/instruction[@occ="1"],Strip_Right,` ',` ',
+               ,,,,
+               ,
+           23e_code_instruction02,,,
+               39,35,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/instruction[@occ="2"],Strip_Right,` ',` ',
+               ,,,,
+               ,
+           23e_code_instruction03,,,
+               74,35,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/instruction[@occ="3"],Strip_Right,` ',` ',
+               ,,,,
+               ,
+           23e_code_instruction04,,,
+               109,35,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/instruction[@occ="4"],Strip_Right,` ',` ',
+               ,,,,
+               ,
+           23e_code_instruction05,,,
+               144,35,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/instruction[@occ="5"],Strip_Right,` ',` ',
+               ,,,,
+               ,
+           23e_code_instruction06,,,
+               179,35,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/instruction[@occ="6"],Strip_Right,` ',` ',
+               ,,,,
+               ,
+           23e_code_instruction07,,,
+               214,35,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/instruction[@occ="7"],Strip_Right,` ',` ',
+               ,,,,
+               ,
+           23e_code_instruction08,,,
+               249,35,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/instruction[@occ="8"],Strip_Right,` ',` ',
+               ,,,,
+               ,
+           23e_code_instruction09,,,
+               284,35,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/instruction[@occ="9"],Strip_Right,` ',` ',
+               ,,,,
+               ,
+           23e_code_instruction10,,,
+               319,35,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/instruction[@occ="10"],Strip_Right,` ',` ',
+               ,,,,
+               ,
+           26t_code_type_de_transaction,,,
+               354,3,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/code_trans,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           date_de_reglement,,,
+               357,8,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/date_regl,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           devise,,,
+               365,3,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/devise,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           montant,,,
+               368,18,Pad_Num,`0',`0',
+               /cristal/cre/donnees_cre/flux/donnees/montant,Strip_Left,`0',`0',
+               ,,,,
+               ,
+           33b_devise_de_instruction,,,
+               386,3,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/devise_inst,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           33b_montant_de_instruction,,,
+               389,18,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/montant_inst,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           36_taux_de_conversion,,,
+               407,12,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/tx_conversion,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           champ_50,,,
+               419,186,Pad_Right,` ',` ',
+               ,,,,
+               ,,,,
+               ,
+           champ_52,,,
+               605,184,Pad_Right,` ',` ',
+               ,,,,
+               ,,,,
+               ,
+           53a_compte,,,
+               789,34,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/compte_emet_cp/compte,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           53a_complements,,,
+               823,11,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/compte_emet_cp/complements,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           53a_format,,,
+               834,1,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/compte_emet_cp/format_champ,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           54a_compte,,,
+               835,11,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/compte_recep_cp/compte,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           54a_complements,,,
+               846,11,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/compte_recep_cp/complements,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           54a_format,,,
+               857,1,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/compte_recep_cp/format_champ,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           champ_55,,,
+               858,184,Pad_Right,` ',` ',
+               ,,,,
+               ,,,,
+               )
diff --git a/src/sd_msg_struct/src/crt_cre_flux_stlm_cus_end.xml.m4 b/src/sd_msg_struct/src/crt_cre_flux_stlm_cus_end.xml.m4
new file mode 100644
index 0000000..6e256f7
--- /dev/null
+++ b/src/sd_msg_struct/src/crt_cre_flux_stlm_cus_end.xml.m4
@@ -0,0 +1,99 @@
+<!-- messages de mapping des virements clientele a partir du bloc 55 (hors blocs 56 57 59 70 72 77) -->
+<!-- flux contenu dans un cre de rejet (cr40)	-->
+<!-- taille = 1200 -->
+msg_object(crt_cre_flux_stlm_cus_end,,
+           champ_56,,,
+               0,184,Pad_Right,` ',` ',
+               ,,,,
+               ,,,,
+               ,
+           champ_57,,,
+               184,184,Pad_Right,` ',` ',
+               ,,,,
+               ,,,,
+               ,
+           champ_59,,,
+               368,186,Pad_Right,` ',` ',
+               ,,,,
+               ,,,,
+               ,
+           champ_70,,,
+               554,148,Pad_Right,` ',` ',
+               ,,,,
+               ,,,,
+               ,
+           71a_repartition_des_frais,,,
+               702,3,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/repart_frais,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           71f_frais_emet01_devise,,,
+               705,3,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/dev_frais_emet[@occ="1"],Strip_Right,` ',` ',
+               ,,,,
+               ,
+           71f_frais_emet01_montant,,,
+               708,15,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/mnt_frais_emet[@occ="1"],Strip_Right,` ',` ',
+               ,,,,
+               ,
+           71f_frais_emet02_devise,,,
+               723,3,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/dev_frais_emet[@occ="2"],Strip_Right,` ',` ',
+               ,,,,
+               ,
+           71f_frais_emet02_montant,,,
+               726,15,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/mnt_frais_emet[@occ="2"],Strip_Right,` ',` ',
+               ,,,,
+               ,
+           71f_frais_emet03_devise,,,
+               741,3,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/dev_frais_emet[@occ="3"],Strip_Right,` ',` ',
+               ,,,,
+               ,
+           71f_frais_emet03_montant,,,
+               744,15,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/mnt_frais_emet[@occ="3"],Strip_Right,` ',` ',
+               ,,,,
+               ,
+           71f_frais_emet04_devise,,,
+               759,3,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/dev_frais_emet[@occ="4"],Strip_Right,` ',` ',
+               ,,,,
+               ,
+           71f_frais_emet04_montant,,,
+               762,15,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/mnt_frais_emet[@occ="4"],Strip_Right,` ',` ',
+               ,,,,
+               ,
+           71f_frais_emet05_devise,,,
+               777,3,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/dev_frais_emet[@occ="5"],Strip_Right,` ',` ',
+               ,,,,
+               ,
+           71f_frais_emet05_montant,,,
+               780,15,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/mnt_frais_emet[@occ="5"],Strip_Right,` ',` ',
+               ,,,,
+               ,
+           71g_frais_recept_devise,,,
+               795,3,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/dev_frais_recep,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           71g_frais_recept_montant,,,
+               798,15,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/mnt_frais_recep,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           champ_72,,,
+               813,276,Pad_Right,` ',` ',
+               ,,,,
+               ,,,,
+               ,
+           champ_77,,,
+               1089,111,Pad_Right,` ',` ',
+               ,,,,
+               ,,,,
+               )
diff --git a/src/sd_msg_struct/src/crt_cre_flux_stlm_header.xml.m4 b/src/sd_msg_struct/src/crt_cre_flux_stlm_header.xml.m4
new file mode 100644
index 0000000..3aae159
--- /dev/null
+++ b/src/sd_msg_struct/src/crt_cre_flux_stlm_header.xml.m4
@@ -0,0 +1,226 @@
+<!-- messages de mapping des entetes communs des flux contenus dans les -->
+<!-- cre de rejet (cr40)	-->
+<!-- taille 302 a partir de 552 -->
+	   <!-- A VOIR fixed sans xml -->
+	   <!-- A VOIR fixed sans xml -->
+	   <!-- A VOIR fixed sans xml -->
+msg_object(crt_cre_flux_header,,
+           code_banque_ctrl,,,
+               552,5,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/en_tete_commun/code_bq_ctrl,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           type_flux,,,
+               557,4,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/en_tete_commun/type_flux,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           code_util,,,
+               561,20,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/en_tete_commun/code_util,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           code_guichet_pf_p,,,
+               581,8,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/en_tete_commun/code_guichet,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           authentification,,,
+               589,10,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/en_tete_commun/authentification,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           num_fichier,,,
+               599,10,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/en_tete_commun/num_fichier,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           responsable,,,
+               609,10,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/en_tete_commun/responsable,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           commentaire,,,
+               619,35,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/en_tete_commun/commentaire,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           r1,,,
+               654,16,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/zone_reservee/ref_interne,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           r2,,,
+               670,16,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/zone_reservee/ref_emet,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           r3,,,
+               686,16,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/zone_reservee/ref_dossier,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           r4,,,
+               702,12,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/zone_reservee/ref_comptable,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           service_desti,,,
+               714,5,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/zone_reservee/svce_dest,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           service_desti_initial,,,
+               719,5,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/zone_reservee/svce_dest_init,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           canal_final,,,
+               724,3,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/zone_reservee/canal_final,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           bic_cri_recep,,,
+               727,11,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/zone_reservee/bic_cri_recep,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           code_pays_desti,,,
+               738,2,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/zone_reservee/code_pays_dest,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           ident_acteur,,,
+               740,18,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/zone_reservee/id_acteur,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           code_siege_emet,,,
+               758,5,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/zone_reservee/code_siege_emet,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           ref_denotage,,,
+               763,18,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/zone_reservee/ref_denotage,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           code_appli_routage,,,
+               781,3,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/zone_reservee/code_appli_rout,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           code_siege_routage,,,
+               784,5,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/zone_reservee/code_siege_rout,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           ref_unique_interne,,,
+               789,20,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/zone_reservee/ref_unique_int,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           heure_debit_rtgs_emet,,,
+               809,9,Pad_Right,` ',` ',
+               /imr/xml_missing,,,,
+               ,,,,
+               ,
+           ident_pdse,,,
+               818,12,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/zone_reservee/id_pdse,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           nature_operation,,,
+               830,8,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/zone_reservee/nat_op,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           heure_ech_cls,,,
+               838,9,Pad_Right,` ',` ',
+               /imr/xml_missing,,,,
+               ,,,,
+               ,
+           zone_reservee,,,
+               847,7,Pad_Right,` ',` ',
+               /imr/xml_missing,,,,
+               ,,,,
+               )
+<!-- messages de mapping des entetes specifique des flux  contenus  -->
+<!-- dans les cre de rejet (cr40)  -->
+<!-- taille 113 ( a partir de 854 taille de entete commun + offset en tetes CR40 )-->
+msg_object(crt_cre_flux_stlm_header,,
+           ref_util,,,
+               854,16,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/specific_vir/ref_util,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           ind_ann_gen,,,
+               870,1,,,` ',
+               /cristal/cre/donnees_cre/flux/specific_vir/ind_ann_gen,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           ref_ann,,,
+               871,16,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/specific_vir/ref_ann,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           type_ann,,,
+               887,1,,,` ',
+               /cristal/cre/donnees_cre/flux/specific_vir/type_ann,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           ref_ann_init,,,
+               888,16,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/specific_vir/ref_ann_init,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           code_acc_int,,,
+               904,4,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/specific_vir/code_acc_int,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           bic_emetteur,,,
+               908,11,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/specific_vir/bic_emet,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           bic_recepteur,,,
+               919,11,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/specific_vir/bic_recep,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           ident_bq_desti,,,
+               930,10,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/specific_vir/identifiant_bq_dest,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           bic_bq_desti,,,
+               940,11,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/specific_vir/code_bic_swift_dest,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           priorite_reseau,,,
+               951,1,,,` ',
+               /cristal/cre/donnees_cre/flux/specific_vir/priorite_reseau,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           canal_de_routage,,,
+               952,3,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/specific_vir/canal,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           heure_d_echeance_champ_113,,,
+               955,4,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/specific_vir/h_echeance,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           heure_emission_tot,,,
+               959,4,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/specific_vir/h_emis_tot,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           heure_emission_tard,,,
+               963,4,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/specific_vir/h_emis_tard,Strip_Right,` ',` ',
+               ,,,,
+               )
diff --git a/src/sd_msg_struct/src/crt_cre_header.xml.m4 b/src/sd_msg_struct/src/crt_cre_header.xml.m4
new file mode 100644
index 0000000..fb34a86
--- /dev/null
+++ b/src/sd_msg_struct/src/crt_cre_header.xml.m4
@@ -0,0 +1,379 @@
+<!-- message de mapping de entete commun des CRE (flux en provenance de cristal) -->
+<!-- taille 471 -->
+		<!-- A VOIR fixed sans xml -->
+		<!-- A VOIR fixed sans xml -->
+		<!-- A VOIR fixed sans xml -->
+		<!-- A VOIR fixed sans xml -->
+		<!-- A VOIR fixed sans xml -->
+msg_object(crt_cre_header,,
+           code_banque_ctrl,,,
+               0,5,Pad_Right,` ',` ',
+               /cristal/cre/en_tete_commun_cre/code_bq_ctrl,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           reference_du_flux,,,
+               5,16,Pad_Right,` ',` ',
+               /cristal/cre/en_tete_commun_cre/ref_pf_cre,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           type_cre,,,
+               21,4,Pad_Right,` ',` ',
+               /cristal/cre/en_tete_commun_cre/type_cre,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           horodatage_pf_p,,,
+               25,14,Pad_Right,` ',` ',
+               /cristal/cre/en_tete_commun_cre/horo_pf_cre,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           code_utilisateur_final,,,
+               39,20,Pad_Right,` ',` ',
+               /cristal/cre/en_tete_commun_cre/code_util_cre,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           code_utilisateur_back_office,,,
+               59,20,Pad_Right,` ',` ',
+               /cristal/cre/en_tete_commun_cre/code_bo_util_cre,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           code_guichet_pf_p,,,
+               79,8,Pad_Right,` ',` ',
+               /cristal/cre/en_tete_commun_cre/code_guichet_cre,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           commentaire,,,
+               87,35,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/commentaire,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           code_utilisateur_final_initial,,,
+               122,20,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/code_util_init,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           code_utilisateur_back_office_initial,,,
+               142,20,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/code_bo_util_init,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           code_guichet_pf_p_initial,,,
+               162,8,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/code_guichet_init,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           indicateur_doublon,,,
+               170,1,Pad_Right,` ',` ',
+               /cristal/cre/en_tete_commun_cre/ind_doublon_cre,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           zone_reservee,,,
+               171,218,Pad_Right,` ',` ',
+               /imr/xml_missing,,,,
+               ,,,,
+               ,
+           horodatage_13c,,,
+               389,9,Pad_Right,` ',` ',
+               /imr/xml_missing,,,,
+               ,,,,
+               ,
+           heure_d_echeance_cls,,,
+               398,9,Pad_Right,` ',` ',
+               /imr/xml_missing,,,,
+               ,,,,
+               ,
+           indic_troncature_13c,,,
+               407,1,Pad_Right,` ',` ',
+               /imr/xml_missing,,,`N',
+               ,,,,
+               ,
+           zone_reservee2,,,
+               408,63,Pad_Right,` ',` ',
+               /imr/xml_missing,,,,
+               ,,,,
+               )
+<!--  DEBUT Traitement du bloc 13C -->
+msg_object(swf_cre_field_occ13x,,
+           occ13,,,
+               0,19,Pad_Right,` ',` ',
+               ,,,,
+               ,,,,
+               ,
+           code_occ13,,,
+               0,9,Pad_Right,` ',` ',
+               ,,,,
+               ,,,,
+               ,
+           value_occ13,,,
+               9,9,Pad_Right,` ',` ',
+               ,,,,
+               ,,,,
+               ,
+           champ_bidon,,,
+               1,1,Pad_Right,` ',`O',
+               /imr/xml_missing,,,`O',
+               ,,,,
+               )
+<!-- messages d'identification des blocs occ13c -->
+msg_object(swf_cre_field_occ13c_sndtime,,
+           code_occ13,`/SNDTIME/',,
+               0,9,,,,
+               ,,,,
+               ,,,,
+               )
+msg_object(swf_cre_field_occ13c_clstime,,
+           code_occ13,`/CLSTIME/',,
+               0,9,,,,
+               ,,,,
+               ,,,,
+               )
+<!--  FIN Traitement du bloc 13C -->
+<!-- message de mapping de entete de CRE sur vgm/or emis (CR10 CR11 CR14 et CR15) -->
+<!-- taille 260 (a partir de 471 entete commun => 731) -->
+msg_object(crt_cre_flux_emis_header,,
+           reference_emetteur,,,
+               471,16,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/ref_emet,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           indicateur_provenance_flux,,,
+               487,3,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/provenance,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           code_operateur_saisie,,,
+               490,10,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/code_op,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           indicateur_de_synchronisation,,,
+               500,4,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/ind_synchro,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           code_statut_cri,,,
+               504,1,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/code_statut_cri,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           code_raison,,,
+               505,2,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/code_raison,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           heure_statut_cri,,,
+               507,6,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/h_statut_cri,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           num_sequence_fifo,,,
+               513,6,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/num_seq_fifo,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           libelle_cre,,,
+               519,30,Pad_Right,` ',` ',
+               /cristal/cre/en_tete_commun_cre/lib_cre,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           type_flux,,,
+               549,4,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/type_flux,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           libelle_motif,,,
+               553,30,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/lib_motif,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           code_responsable,,,
+               583,10,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/responsable,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           ref_util,,,
+               593,16,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/ref_util,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           code_util,,,
+               609,20,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/code_util,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           num_fic_origine,,,
+               629,10,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/num_fic_ori,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           horodatage_pf_p,,,
+               639,14,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/horo_pf_flux,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           ref_annonce,,,
+               653,16,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/ref_ann,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           bic_emetteur,,,
+               669,11,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/bic_emet,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           bic_recepteur,,,
+               680,11,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/bic_recep,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           bic_recepteur_initial,,,
+               691,11,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/bic_recep_init,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           canal_de_routage,,,
+               702,3,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/canal,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           canal_de_routage_initial,,,
+               705,3,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/canal_init,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           canal_de_routage_final,,,
+               708,3,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/canal_final,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           ref_emetteur_cri,,,
+               711,16,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/ref_emet_cri,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           heure_d_echeance_champ_113,,,
+               727,4,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/h_echeance,Strip_Right,` ',` ',
+               ,,,,
+               )
+<!-- message de mapping de entete de CRE sur vgm/or recu (CR22) -->
+<!-- taille 195 (a partir de 471 entete commun => 666) -->
+msg_object(crt_cre_flux_recu_header,,
+           reference_emetteur,,,
+               471,16,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/ref_emet,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           indicateur_de_synchronisation,,,
+               487,4,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/ind_synchro,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           code_statut_cri,,,
+               491,1,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/code_statut_cri,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           code_raison,,,
+               492,2,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/code_raison,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           heure_statut_cri,,,
+               494,6,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/h_statut_cri,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           num_sequence_fifo,,,
+               500,6,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/num_seq_fifo,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           libelle_cre,,,
+               506,30,Pad_Right,` ',` ',
+               /cristal/cre/en_tete_commun_cre/lib_cre,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           type_flux,,,
+               536,4,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/type_flux,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           libelle_motif,,,
+               540,30,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/lib_motif,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           horodatage_pf_p,,,
+               570,14,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/horo_pf_flux,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           ref_util_virement,,,
+               584,16,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/ref_util_vr,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           ref_annonce,,,
+               600,16,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/ref_ann,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           bic_emetteur,,,
+               616,11,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/bic_emet,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           bic_recepteur,,,
+               627,11,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/bic_recep,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           canal_de_routage,,,
+               638,3,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/canal,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           rib_recep,,,
+               641,21,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/rib_recep,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           heure_d_echeance_champ_113,,,
+               662,4,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/h_echeance,Strip_Right,` ',` ',
+               ,,,,
+               )
+<!-- message de mapping de CRE de rejet a acquisition (CR40) -->
+<!-- taille 81 (a partir de 471 entete commun => 552 ) -->
+		<!-- A VOIR xml sans fixed -->
+msg_object(crt_cre_rejet_header,,
+           libelle_cre,,,
+               471,30,Pad_Right,` ',` ',
+               /cristal/cre/en_tete_commun_cre/lib_cre,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           type_flux,,,
+               501,4,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/type_flux,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           code_rejet_motif,,,
+               505,3,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/code_rejet,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           libelle_motif,,,
+               508,30,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/lib_motif,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           horodatage_pf_p,,,
+               538,14,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/horo_pf_flux,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           detail_motif_rej,,,
+               ,,,,,
+               /cristal/cre/donnees_cre/detail_motif_rej,Strip_Right,` ',,
+               ,,,,
+               )
diff --git a/src/sd_msg_struct/src/crt_cre_ident.xml.m4 b/src/sd_msg_struct/src/crt_cre_ident.xml.m4
new file mode 100644
index 0000000..3f5a977
--- /dev/null
+++ b/src/sd_msg_struct/src/crt_cre_ident.xml.m4
@@ -0,0 +1,372 @@
+<!-- messages d'identification des flux en provenance de cristal -->
+<!-- branche BB3 point d'entree identification des cre -->
+msg_object(crt_cre_ident,,
+           ,,,
+               ,,,,,
+               ,,,,
+               ,,,,
+               )
+msg_object(crt_cre_cr01,,
+           type_cre,`CR01',,
+               21,4,,,,
+               /cristal/cre/en_tete_commun_cre/type_cre,,,,
+               ,,,,
+               )
+msg_object(crt_cre_cr02,,
+           type_cre,`CR02',,
+               21,4,,,,
+               /cristal/cre/en_tete_commun_cre/type_cre,,,,
+               ,,,,
+               )
+msg_object(crt_cre_cr03,,
+           type_cre,`CR03',,
+               21,4,,,,
+               /cristal/cre/en_tete_commun_cre/type_cre,,,,
+               ,,,,
+               )
+msg_object(crt_cre_cr04,,
+           type_cre,`CR04',,
+               21,4,,,,
+               /cristal/cre/en_tete_commun_cre/type_cre,,,,
+               ,,,,
+               )
+msg_object(crt_cre_cr05,,
+           type_cre,`CR05',,
+               21,4,,,,
+               /cristal/cre/en_tete_commun_cre/type_cre,,,,
+               ,,,,
+               )
+msg_object(crt_cre_cr06,,
+           type_cre,`CR06',,
+               21,4,,,,
+               /cristal/cre/en_tete_commun_cre/type_cre,,,,
+               ,,,,
+               )
+msg_object(crt_cre_cr07,,
+           type_cre,`CR07',,
+               21,4,,,,
+               /cristal/cre/en_tete_commun_cre/type_cre,,,,
+               ,,,,
+               )
+msg_object(crt_cre_cr08,,
+           type_cre,`CR08',,
+               21,4,,,,
+               /cristal/cre/en_tete_commun_cre/type_cre,,,,
+               ,,,,
+               )
+msg_object(crt_cre_cr09,,
+           type_cre,`CR09',,
+               21,4,,,,
+               /cristal/cre/en_tete_commun_cre/type_cre,,,,
+               ,,,,
+               )
+msg_object(crt_cre_cr10,,
+           type_cre,`CR10',,
+               21,4,,,,
+               /cristal/cre/en_tete_commun_cre/type_cre,,,,
+               ,,,,
+               )
+msg_object(crt_cre_cr11,,
+           type_cre,`CR11',,
+               21,4,,,,
+               /cristal/cre/en_tete_commun_cre/type_cre,,,,
+               ,,,,
+               )
+msg_object(crt_cre_cr12,,
+           type_cre,`CR12',,
+               21,4,,,,
+               /cristal/cre/en_tete_commun_cre/type_cre,,,,
+               ,,,,
+               )
+msg_object(crt_cre_cr13,,
+           type_cre,`CR13',,
+               21,4,,,,
+               /cristal/cre/en_tete_commun_cre/type_cre,,,,
+               ,,,,
+               )
+msg_object(crt_cre_cr14,,
+           type_cre,`CR14',,
+               21,4,,,,
+               /cristal/cre/en_tete_commun_cre/type_cre,,,,
+               ,,,,
+               )
+msg_object(crt_cre_cr15,,
+           type_cre,`CR15',,
+               21,4,,,,
+               /cristal/cre/en_tete_commun_cre/type_cre,,,,
+               ,,,,
+               )
+msg_object(crt_cre_cr16,,
+           type_cre,`CR16',,
+               21,4,,,,
+               /cristal/cre/en_tete_commun_cre/type_cre,,,,
+               ,,,,
+               )
+msg_object(crt_cre_cr17,,
+           type_cre,`CR17',,
+               21,4,,,,
+               /cristal/cre/en_tete_commun_cre/type_cre,,,,
+               ,,,,
+               )
+msg_object(crt_cre_cr18,,
+           type_cre,`CR18',,
+               21,4,,,,
+               /cristal/cre/en_tete_commun_cre/type_cre,,,,
+               ,,,,
+               )
+msg_object(crt_cre_cr20,,
+           type_cre,`CR20',,
+               21,4,,,,
+               /cristal/cre/en_tete_commun_cre/type_cre,,,,
+               ,,,,
+               )
+msg_object(crt_cre_cr21,,
+           type_cre,`CR21',,
+               21,4,,,,
+               /cristal/cre/en_tete_commun_cre/type_cre,,,,
+               ,,,,
+               )
+msg_object(crt_cre_cr22,,
+           type_cre,`CR22',,
+               21,4,,,,
+               /cristal/cre/en_tete_commun_cre/type_cre,,,,
+               ,,,,
+               )
+msg_object(crt_cre_cr23,,
+           type_cre,`CR23',,
+               21,4,,,,
+               /cristal/cre/en_tete_commun_cre/type_cre,,,,
+               ,,,,
+               )
+msg_object(crt_cre_cr24,,
+           type_cre,`CR24',,
+               21,4,,,,
+               /cristal/cre/en_tete_commun_cre/type_cre,,,,
+               ,,,,
+               )
+msg_object(crt_cre_cr25,,
+           type_cre,`CR25',,
+               21,4,,,,
+               /cristal/cre/en_tete_commun_cre/type_cre,,,,
+               ,,,,
+               )
+msg_object(crt_cre_cr30,,
+           type_cre,`CR30',,
+               21,4,,,,
+               /cristal/cre/en_tete_commun_cre/type_cre,,,,
+               ,,,,
+               )
+msg_object(crt_cre_cr31,,
+           type_cre,`CR31',,
+               21,4,,,,
+               /cristal/cre/en_tete_commun_cre/type_cre,,,,
+               ,,,,
+               )
+msg_object(crt_cre_cr40,,
+           type_cre,`CR40',,
+               21,4,,,,
+               /cristal/cre/en_tete_commun_cre/type_cre,,,,
+               ,,,,
+               )
+msg_object(crt_cre_cr41,,
+           type_cre,`CR41',,
+               21,4,,,,
+               /cristal/cre/en_tete_commun_cre/type_cre,,,,
+               ,,,,
+               )
+msg_object(crt_cre_cr42,,
+           type_cre,`CR42',,
+               21,4,,,,
+               /cristal/cre/en_tete_commun_cre/type_cre,,,,
+               ,,,,
+               )
+msg_object(crt_cre_cr44,,
+           type_cre,`CR44',,
+               21,4,,,,
+               /cristal/cre/en_tete_commun_cre/type_cre,,,,
+               ,,,,
+               )
+msg_object(crt_cre_cr45,,
+           type_cre,`CR45',,
+               21,4,,,,
+               /cristal/cre/en_tete_commun_cre/type_cre,,,,
+               ,,,,
+               )
+msg_object(crt_cre_cr50,,
+           type_cre,`CR50',,
+               21,4,,,,
+               /cristal/cre/en_tete_commun_cre/type_cre,,,,
+               ,,,,
+               )
+<!-- branche BB4 point d'entree identification des flux pour cre sur flux emis -->
+msg_object(crt_cre_emis_ident,,
+           ,,,
+               ,,,,,
+               ,,,,
+               ,,,,
+               )
+msg_object(crt_cre_emis_vs02,,
+           type_flux,`VS02',,
+               549,4,,,,
+               /cristal/cre/donnees_cre/type_flux,,,,
+               ,,,,
+               )
+msg_object(crt_cre_emis_vs03,,
+           type_flux,`VS03',,
+               549,4,,,,
+               /cristal/cre/donnees_cre/type_flux,,,,
+               ,,,,
+               )
+msg_object(crt_cre_emis_vs04,,
+           type_flux,`VS04',,
+               549,4,,,,
+               /cristal/cre/donnees_cre/type_flux,,,,
+               ,,,,
+               )
+msg_object(crt_cre_emis_vs07,,
+           type_flux,`VS07',,
+               549,4,,,,
+               /cristal/cre/donnees_cre/type_flux,,,,
+               ,,,,
+               )
+msg_object(crt_cre_emis_vs08,,
+           type_flux,`VS08',,
+               549,4,,,,
+               /cristal/cre/donnees_cre/type_flux,,,,
+               ,,,,
+               )
+msg_object(crt_cre_emis_os01,,
+           type_flux,`OS01',,
+               549,4,,,,
+               /cristal/cre/donnees_cre/type_flux,,,,
+               ,,,,
+               )
+<!-- branche BB5 point d'entree identification des flux pour cre sur flux recus -->
+msg_object(crt_cre_recu_ident,,
+           ,,,
+               ,,,,,
+               ,,,,
+               ,,,,
+               )
+msg_object(crt_cre_recu_vs02,,
+           type_flux,`VS02',,
+               536,4,,,,
+               /cristal/cre/donnees_cre/type_flux,,,,
+               ,,,,
+               )
+msg_object(crt_cre_recu_vs03,,
+           type_flux,`VS03',,
+               536,4,,,,
+               /cristal/cre/donnees_cre/type_flux,,,,
+               ,,,,
+               )
+msg_object(crt_cre_recu_vs04,,
+           type_flux,`VS04',,
+               536,4,,,,
+               /cristal/cre/donnees_cre/type_flux,,,,
+               ,,,,
+               )
+msg_object(crt_cre_recu_vs07,,
+           type_flux,`VS07',,
+               536,4,,,,
+               /cristal/cre/donnees_cre/type_flux,,,,
+               ,,,,
+               )
+msg_object(crt_cre_recu_vs08,,
+           type_flux,`VS08',,
+               536,4,,,,
+               /cristal/cre/donnees_cre/type_flux,,,,
+               ,,,,
+               )
+msg_object(crt_cre_recu_os01,,
+           type_flux,`OS01',,
+               536,4,,,,
+               /cristal/cre/donnees_cre/type_flux,,,,
+               ,,,,
+               )
+<!-- branche BB6 point d'entree identification des flux pour cre de rejet -->
+msg_object(crt_cre_rejet_ident,,
+           ,,,
+               ,,,,,
+               ,,,,
+               ,,,,
+               )
+msg_object(crt_cre_rejet_vs02,,
+           type_flux,`VS02',,
+               557,4,,,,
+               /cristal/cre/donnees_cre/type_flux,,,,
+               ,,,,
+               )
+msg_object(crt_cre_rejet_vs03,,
+           type_flux,`VS03',,
+               557,4,,,,
+               /cristal/cre/donnees_cre/type_flux,,,,
+               ,,,,
+               )
+msg_object(crt_cre_rejet_vs04,,
+           type_flux,`VS04',,
+               557,4,,,,
+               /cristal/cre/donnees_cre/type_flux,,,,
+               ,,,,
+               )
+msg_object(crt_cre_rejet_vs07,,
+           type_flux,`VS07',,
+               557,4,,,,
+               /cristal/cre/donnees_cre/type_flux,,,,
+               ,,,,
+               )
+msg_object(crt_cre_rejet_vs08,,
+           type_flux,`VS08',,
+               557,4,,,,
+               /cristal/cre/donnees_cre/type_flux,,,,
+               ,,,,
+               )
+msg_object(crt_cre_rejet_os01,,
+           type_flux,`OS01',,
+               557,4,,,,
+               /cristal/cre/donnees_cre/type_flux,,,,
+               ,,,,
+               )
+<!-- Point d'entree identification des flux pour cre en format XML uniquement -->
+msg_object(crt_cre_flux_ident,,
+           ,,,
+               ,,,,,
+               ,,,,
+               ,,,,
+               )
+msg_object(crt_cre_flux_vs02,,
+           type_flux,`VS02',,
+               ,,,,,
+               /cristal/cre/donnees_cre/type_flux,,,,
+               ,,,,
+               )
+msg_object(crt_cre_flux_vs03,,
+           type_flux,`VS03',,
+               ,,,,,
+               /cristal/cre/donnees_cre/type_flux,,,,
+               ,,,,
+               )
+msg_object(crt_cre_flux_vs04,,
+           type_flux,`VS04',,
+               ,,,,,
+               /cristal/cre/donnees_cre/type_flux,,,,
+               ,,,,
+               )
+msg_object(crt_cre_flux_vs07,,
+           type_flux,`VS07',,
+               ,,,,,
+               /cristal/cre/donnees_cre/type_flux,,,,
+               ,,,,
+               )
+msg_object(crt_cre_flux_vs08,,
+           type_flux,`VS08',,
+               ,,,,,
+               /cristal/cre/donnees_cre/type_flux,,,,
+               ,,,,
+               )
+msg_object(crt_cre_flux_os01,,
+           type_flux,`OS01',,
+               ,,,,,
+               /cristal/cre/donnees_cre/type_flux,,,,
+               ,,,,
+               )
diff --git a/src/sd_msg_struct/src/crt_flux_ident.xml.m4 b/src/sd_msg_struct/src/crt_flux_ident.xml.m4
new file mode 100644
index 0000000..da0b3c2
--- /dev/null
+++ b/src/sd_msg_struct/src/crt_flux_ident.xml.m4
@@ -0,0 +1,148 @@
+<!-- messages d'identification des flux destines a cristal -->
+<!-- branche BB2 point d'entree -->
+msg_object(crt_flux_ident,,
+           ,,,
+               ,,,,,
+               ,,,,
+               ,,,,
+               )
+msg_object(crt_flux_vs02,,
+           type_flux,`VS02',,
+               5,4,,,,
+               /cristal/flux/en_tete_commun/type_flux,,,,
+               ,,,,
+               )
+msg_object(crt_flux_vs03,,
+           type_flux,`VS03',,
+               5,4,,,,
+               /cristal/flux/en_tete_commun/type_flux,,,,
+               ,,,,
+               )
+msg_object(crt_flux_vs04,,
+           type_flux,`VS04',,
+               5,4,,,,
+               /cristal/flux/en_tete_commun/type_flux,,,,
+               ,,,,
+               )
+msg_object(crt_flux_vs07,,
+           type_flux,`VS07',,
+               5,4,,,,
+               /cristal/flux/en_tete_commun/type_flux,,,,
+               ,,,,
+               )
+msg_object(crt_flux_vs08,,
+           type_flux,`VS08',,
+               5,4,,,,
+               /cristal/flux/en_tete_commun/type_flux,,,,
+               ,,,,
+               )
+msg_object(crt_flux_os01,,
+           type_flux,`OS01',,
+               5,4,,,,
+               /cristal/flux/en_tete_commun/type_flux,,,,
+               ,,,,
+               )
+<!-- messages d'identification des virements destines a cristal -->
+<!-- branche BB8 point d'entree -->
+msg_object(crt_flux_stlm_sans13c,,
+           ,,,
+               ,,,,,
+               ,,,,
+               ,,,,
+               )
+<!-- branche BB8 specifique au xml -->
+msg_object(crt_flux_stlm_avec13c,,
+           champ_13c_1,,y,
+               ,,,,,
+               /cristal/flux/donnees/champ13c[@occ="1"],,,,
+               ,,,,
+               )
+<!-- messages d'identification des virements de clientele avec ou sans bloc 55 -->	
+<!-- branche BB9 point d'entree -->
+msg_object(crt_flux_stlm_cus_sans55,,
+           ,,,
+               ,,,,,
+               ,,,,
+               ,,,,
+               )
+<!-- branche BB9 specifique au xml -->
+msg_object(crt_flux_stlm_cus_avec55,,
+           bq_de_refin_format,,y,
+               ,,,,,
+               /cristal/flux/donnees/bq_du_refin/format_champ,,,,
+               ,,,,
+               )
+<!-- messages d'identification des virements bancaires destines a cristal -->
+<!-- branche BB8 specifique au fixed -->
+msg_object(crt_flux_stlm_bk_sans13c,1102,
+           ,,,
+               ,,,,,
+               ,,,,
+               ,,,,
+               )
+msg_object(crt_flux_stlm_bk_avec13c,1216,
+           ,,,
+               ,,,,,
+               ,,,,
+               ,,,,
+               )
+<!-- messages d'identification des virements de clientele destines a cristal -->
+<!-- branche BB9 specifique au fixed -->
+msg_object(crt_flux_stlm_cus_sans55_sans13c,2058,
+           ,,,
+               ,,,,,
+               ,,,,
+               ,,,,
+               )
+msg_object(crt_flux_stlm_cus_sans55_avec13c,2172,
+           ,,,
+               ,,,,,
+               ,,,,
+               ,,,,
+               )
+msg_object(crt_flux_stlm_cus_avec55_sans13c,2242,
+           ,,,
+               ,,,,,
+               ,,,,
+               ,,,,
+               )
+msg_object(crt_flux_stlm_cus_avec55_avec13c,2356,
+           ,,,
+               ,,,,,
+               ,,,,
+               ,,,,
+               )
+<!-- messages d'identification des virements de clientele destines a cristal -->
+<!-- branche BB10 specifique au fixed -->
+msg_object(crt_msg_bo_ident,,
+           ,,,
+               ,,,,,
+               ,,,,
+               ,,,,
+               )
+msg_object(crt_msg_titres,1900,
+           ,,,
+               ,,,,,
+               ,,,,
+               ,,,,
+               )
+msg_object(crt_msg_matcc,2500,
+           ,,,
+               ,,,,,
+               ,,,,
+               ,,,,
+               )
+<!-- messages d'identification des delimiteurs utilises dans les messages -->
+<!-- branche BB30 specifique au delimited -->
+msg_object(delimited_ident,,
+           ,,,
+               ,,,,,
+               ,,,,
+               ,,,,
+               )
+msg_object(delimited_test,,
+           dltd_occurence1,,y,
+               ,,,,,
+               ,,,,
+               1,,,,
+               )
diff --git a/src/sd_msg_struct/src/crt_flux_or.xml.m4 b/src/sd_msg_struct/src/crt_flux_or.xml.m4
new file mode 100644
index 0000000..d939caa
--- /dev/null
+++ b/src/sd_msg_struct/src/crt_flux_or.xml.m4
@@ -0,0 +1,115 @@
+<!-- message permettant l'extraction et l'insertion des donnees des ordres de restitution (taille 83) -->
+<!-- ne concernent que le format fixed -->
+msg_object(crt_flux_ordre_rest,,
+           or,,,
+               0,83,,,,
+               ,,,,
+               ,,,,
+               ,
+           or_emis_in_cre,,,
+               731,83,,,,
+               ,,,,
+               ,,,,
+               ,
+           or_recu_in_cre,,,
+               666,83,,,,
+               ,,,,
+               ,,,,
+               ,
+           or_in_flux,,,
+               353,83,,,,
+               ,,,,
+               ,,,,
+               ,
+           or_in_cre_rejet,,,
+               905,83,,,,
+               ,,,,
+               ,,,,
+               )
+<!-- messages de mapping des entetes des ordres de restitution destines a cristal -->
+<!-- taille 51 ( a partir de 302 entete commun) -->
+msg_object(crt_flux_or_header,,
+           ref_util,,,
+               302,16,Pad_Right,` ',,
+               /cristal/flux/specific_or/ref_util,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           bic_emetteur,,,
+               318,11,Pad_Right,` ',,
+               /cristal/flux/specific_or/bic_emet,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           bic_recepteur,,,
+               329,11,Pad_Right,` ',,
+               /cristal/flux/specific_or/bic_recep,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           priorite_reseau,,,
+               340,1,,,,
+               /cristal/flux/specific_or/priorite_reseau,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           type_or,,,
+               341,4,Pad_Right,` ',,
+               /cristal/flux/specific_or/type_or,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           heure_emission_tot,,,
+               345,4,Pad_Right,` ',,
+               /cristal/flux/specific_or/h_emis_tot,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           heure_emission_tard,,,
+               349,4,Pad_Right,` ',,
+               /cristal/flux/specific_or/h_emis_tard,Strip_Right,` ',` ',
+               ,,,,
+               )
+<!-- messages de mapping des ordres de restitution virements bancaires (hors blocs 52 56 57 58 72) -->
+<!-- taille 83 -->
+      <!-- A VOIR xml sans fixed -->
+msg_object(crt_flux_or,,
+           reference_emetteur_flux,,,
+               ,,,,,
+               /cristal/flux/donnees/ref_emet,,,,
+               ,,,,
+               ,
+           reference_d_origine,,,
+               0,16,Pad_Right,` ',,
+               /cristal/flux/donnees/ref_orig,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           date_de_reglement,,,
+               16,8,Pad_Right,` ',,
+               /cristal/flux/donnees/date_regl,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           devise,,,
+               24,3,Pad_Right,` ',,
+               /cristal/flux/donnees/devise,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           montant,,,
+               27,18,Pad_Left,`0',,
+               /cristal/flux/donnees/montant,Strip_Left,` ',`0',
+               ,,,,
+               ,
+           identification_du_sous_champ_errone,,,
+               45,3,Pad_Right,` ',,
+               /cristal/flux/donnees/champ_errone,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           code_motif_de_restitution,,,
+               48,4,Pad_Right,` ',,
+               /cristal/flux/donnees/code_motif_rest,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           code_commission_interbancaire,,,
+               52,2,Pad_Right,` ',,
+               /cristal/flux/donnees/code_commi,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           motif_de_la_restitution,,,
+               54,29,Pad_Right,` ',,
+               /cristal/flux/donnees/motif_rest,Strip_Right,` ',` ',
+               ,,,,
+               )
diff --git a/src/sd_msg_struct/src/crt_flux_stlm.xml.m4 b/src/sd_msg_struct/src/crt_flux_stlm.xml.m4
new file mode 100644
index 0000000..33b86fd
--- /dev/null
+++ b/src/sd_msg_struct/src/crt_flux_stlm.xml.m4
@@ -0,0 +1,81 @@
+<!-- message permettant l'extraction et l'insertion des donnees d'un flux complet de ou dans un CRE40 -->
+<!-- 2771 = taille maxi des data (avec bloc 13c et champ 55) -->
+<!-- ne concernent que le format fixed -->
+msg_object(crt_flux_cre,,
+           flux_complet,,,
+               0,2771,,,,
+               ,,,,
+               ,,,,
+               ,
+           flux_complet_in_cre,,,
+               552,2771,,,,
+               ,,,,
+               ,,,,
+               )
+<!-- message permettant l'extraction et l'insertion des donnees des virements (bancaires ou de clientele) -->
+<!-- 2356 = taille maxi des data (avec bloc 13c et champ 55) -->
+<!-- ne concernent que le format fixed -->
+msg_object(crt_flux_stlm,,
+           settlement,,,
+               0,2356,,,,
+               ,,,,
+               ,,,,
+               ,
+           settlement_emis_in_cre,,,
+               731,2356,,,,
+               ,,,,
+               ,,,,
+               ,
+           settlement_recu_in_cre,,,
+               666,2356,,,,
+               ,,,,
+               ,,,,
+               ,
+           settlement_in_flux,,,
+               415,2356,,,,
+               ,,,,
+               ,,,,
+               ,
+           settlement_in_cre_rejet,,,
+               967,2356,,,,
+               ,,,,
+               ,,,,
+               )
+<!-- les messages de clientele sont decoupes en 3 parties -->
+<!-- du debut   jusqu'au bloc 55 inclus -->
+<!-- du bloc 56 jusqu'au bloc 77 inclus -->
+<!-- le bloc 13c -->
+<!-- message permettant l'extraction et l'insertion des donnees du bloc 56 jusqu'au bloc 77 inclus -->
+<!-- taille des donnees = 1200 -->
+<!-- ne concernent que le format fixed -->
+msg_object(crt_flux_stlm_cus_56_a_77,,
+           cus_block2,,,
+               0,1200,,,,
+               ,,,,
+               ,,,,
+               ,
+           cus_block2_sans55,,,
+               858,1200,,,,
+               ,,,,
+               ,,,,
+               ,
+           cus_block2_avec55,,,
+               1042,1200,,,,
+               ,,,,
+               ,,,,
+               )
+<!-- message permettant l'extraction et l'insertion des donnees du bloc 13c -->
+<!-- taille des donnees = 114 -->
+<!-- ne concernent que le format fixed -->
+msg_object(cus_champ_13c_sans55,,
+           champ_13c,,,
+               2058,114,Pad_Right,` ',,
+               ,,,,
+               ,,,,
+               )
+msg_object(cus_champ_13c_avec55,,
+           champ_13c,,,
+               2242,114,Pad_Right,` ',,
+               ,,,,
+               ,,,,
+               )
diff --git a/src/sd_msg_struct/src/crt_flux_stlm_bk.xml.m4 b/src/sd_msg_struct/src/crt_flux_stlm_bk.xml.m4
new file mode 100644
index 0000000..99293a8
--- /dev/null
+++ b/src/sd_msg_struct/src/crt_flux_stlm_bk.xml.m4
@@ -0,0 +1,69 @@
+<!-- messages de mapping des virements bancaires (hors blocs 52 56 57 58 72) -->
+<!-- taille 1102 ou 1216 si bloc 13C -->
+		<!-- A VOIR xml sans fixed -->
+msg_object(crt_flux_stlm_bk,,
+           reference_emetteur_flux,,,
+               ,,,,,
+               /cristal/flux/donnees/ref_emet,,,,
+               ,,,,
+               ,
+           reference_d_origine,,,
+               0,16,Pad_Right,` ',,
+               /cristal/flux/donnees/ref_orig,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           date_de_reglement,,,
+               16,8,Pad_Right,` ',,
+               /cristal/flux/donnees/date_regl,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           devise,,,
+               24,3,Pad_Right,` ',,
+               /cristal/flux/donnees/devise,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           montant,,,
+               27,18,Pad_Left,`0',,
+               /cristal/flux/donnees/montant,Strip_Left,` ',`0',
+               ,,,,
+               ,
+           champ_52,,,
+               45,184,Pad_Right,` ',,
+               ,,,,
+               ,,,,
+               ,
+           no_ccr_emet_rib_emet_ou_compte_cor,,,
+               229,34,Pad_Right,` ',,
+               /cristal/flux/donnees/compte_emet,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           ccr_recepteur,,,
+               263,11,Pad_Right,` ',,
+               /cristal/flux/donnees/compte_recep,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           champ_56,,,
+               274,184,Pad_Right,` ',,
+               ,,,,
+               ,,,,
+               ,
+           champ_57,,,
+               458,184,Pad_Right,` ',,
+               ,,,,
+               ,,,,
+               ,
+           champ_58,,,
+               642,184,Pad_Right,` ',,
+               ,,,,
+               ,,,,
+               ,
+           champ_72,,,
+               826,276,Pad_Right,` ',,
+               ,,,,
+               ,,,,
+               ,
+           champ_13c,,,
+               1102,114,Pad_Right,` ',,
+               ,,,,
+               ,,,,
+               )
diff --git a/src/sd_msg_struct/src/crt_flux_stlm_cus.xml.m4 b/src/sd_msg_struct/src/crt_flux_stlm_cus.xml.m4
new file mode 100644
index 0000000..df8d1f1
--- /dev/null
+++ b/src/sd_msg_struct/src/crt_flux_stlm_cus.xml.m4
@@ -0,0 +1,144 @@
+<!-- messages de mapping des virements clientele jusqu'au bloc 55 (hors blocs 50 52) -->
+<!-- taille : 2058, 2172 (avec 13C), 2242 (avec 55), 2356 (avec 55 et 13C) -->
+      <!-- A VOIR xml sans fixed -->
+msg_object(crt_flux_stlm_cus,,
+           reference_emetteur_flux,,,
+               ,,,,,
+               /cristal/flux/donnees/ref_emet,,,,
+               ,,,,
+               ,
+           23b_code_operation,,,
+               0,4,Pad_Right,` ',,
+               /cristal/flux/donnees/code_operation,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           23e_code_instruction01,,,
+               4,35,Pad_Right,` ',,
+               /cristal/flux/donnees/instruction[@occ="1"],Strip_Right,` ',` ',
+               ,,,,
+               ,
+           23e_code_instruction02,,,
+               39,35,Pad_Right,` ',,
+               /cristal/flux/donnees/instruction[@occ="2"],Strip_Right,` ',` ',
+               ,,,,
+               ,
+           23e_code_instruction03,,,
+               74,35,Pad_Right,` ',,
+               /cristal/flux/donnees/instruction[@occ="3"],Strip_Right,` ',` ',
+               ,,,,
+               ,
+           23e_code_instruction04,,,
+               109,35,Pad_Right,` ',,
+               /cristal/flux/donnees/instruction[@occ="4"],Strip_Right,` ',` ',
+               ,,,,
+               ,
+           23e_code_instruction05,,,
+               144,35,Pad_Right,` ',,
+               /cristal/flux/donnees/instruction[@occ="5"],Strip_Right,` ',` ',
+               ,,,,
+               ,
+           23e_code_instruction06,,,
+               179,35,Pad_Right,` ',,
+               /cristal/flux/donnees/instruction[@occ="6"],Strip_Right,` ',` ',
+               ,,,,
+               ,
+           23e_code_instruction07,,,
+               214,35,Pad_Right,` ',,
+               /cristal/flux/donnees/instruction[@occ="7"],Strip_Right,` ',` ',
+               ,,,,
+               ,
+           23e_code_instruction08,,,
+               249,35,Pad_Right,` ',,
+               /cristal/flux/donnees/instruction[@occ="8"],Strip_Right,` ',` ',
+               ,,,,
+               ,
+           23e_code_instruction09,,,
+               284,35,Pad_Right,` ',,
+               /cristal/flux/donnees/instruction[@occ="9"],Strip_Right,` ',` ',
+               ,,,,
+               ,
+           23e_code_instruction10,,,
+               319,35,Pad_Right,` ',,
+               /cristal/flux/donnees/instruction[@occ="10"],Strip_Right,` ',` ',
+               ,,,,
+               ,
+           26t_code_type_de_transaction,,,
+               354,3,Pad_Right,` ',,
+               /cristal/flux/donnees/code_trans,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           date_de_reglement,,,
+               357,8,Pad_Right,` ',,
+               /cristal/flux/donnees/date_regl,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           devise,,,
+               365,3,Pad_Right,` ',,
+               /cristal/flux/donnees/devise,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           montant,,,
+               368,18,Pad_Left,`0',,
+               /cristal/flux/donnees/montant,Strip_Left,` ',`0',
+               ,,,,
+               ,
+           33b_devise_de_instruction,,,
+               386,3,Pad_Right,` ',,
+               /cristal/flux/donnees/devise_inst,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           33b_montant_de_instruction,,,
+               389,18,Pad_Right,` ',,
+               /cristal/flux/donnees/montant_inst,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           36_taux_de_conversion,,,
+               407,12,Pad_Right,` ',,
+               /cristal/flux/donnees/tx_conversion,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           champ_50,,,
+               419,186,Pad_Right,` ',,
+               ,,,,
+               ,,,,
+               ,
+           champ_52,,,
+               605,184,Pad_Right,` ',,
+               ,,,,
+               ,,,,
+               ,
+           53a_compte,,,
+               789,34,Pad_Right,` ',,
+               /cristal/flux/donnees/compte_emet_cp/compte,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           53a_complements,,,
+               823,11,Pad_Right,` ',,
+               /cristal/flux/donnees/compte_emet_cp/complements,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           53a_format,,,
+               834,1,Pad_Right,` ',,
+               /cristal/flux/donnees/compte_emet_cp/format_champ,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           54a_compte,,,
+               835,11,Pad_Right,` ',,
+               /cristal/flux/donnees/compte_recep_cp/compte,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           54a_complements,,,
+               846,11,Pad_Right,` ',,
+               /cristal/flux/donnees/compte_recep_cp/complements,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           54a_format,,,
+               857,1,Pad_Right,` ',,
+               /cristal/flux/donnees/compte_recep_cp/format_champ,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           champ_55,,,
+               858,184,Pad_Right,` ',,
+               ,,,,
+               ,,,,
+               )
diff --git a/src/sd_msg_struct/src/crt_flux_stlm_cus_end.xml.m4 b/src/sd_msg_struct/src/crt_flux_stlm_cus_end.xml.m4
new file mode 100644
index 0000000..7c51d32
--- /dev/null
+++ b/src/sd_msg_struct/src/crt_flux_stlm_cus_end.xml.m4
@@ -0,0 +1,98 @@
+<!-- messages de mapping des virements clientele a partir du bloc 55 (hors blocs 56 57 59 70 72 77) -->
+<!-- taille = 1200 -->
+msg_object(crt_flux_stlm_cus_end,,
+           champ_56,,,
+               0,184,Pad_Right,` ',,
+               ,,,,
+               ,,,,
+               ,
+           champ_57,,,
+               184,184,Pad_Right,` ',,
+               ,,,,
+               ,,,,
+               ,
+           champ_59,,,
+               368,186,Pad_Right,` ',,
+               ,,,,
+               ,,,,
+               ,
+           champ_70,,,
+               554,148,Pad_Right,` ',,
+               ,,,,
+               ,,,,
+               ,
+           71a_repartition_des_frais,,,
+               702,3,Pad_Right,` ',,
+               /cristal/flux/donnees/repart_frais,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           71f_frais_emet01_devise,,,
+               705,3,Pad_Right,` ',,
+               /cristal/flux/donnees/dev_frais_emet[@occ="1"],Strip_Right,` ',` ',
+               ,,,,
+               ,
+           71f_frais_emet01_montant,,,
+               708,15,Pad_Right,` ',,
+               /cristal/flux/donnees/mnt_frais_emet[@occ="1"],Strip_Right,` ',` ',
+               ,,,,
+               ,
+           71f_frais_emet02_devise,,,
+               723,3,Pad_Right,` ',,
+               /cristal/flux/donnees/dev_frais_emet[@occ="2"],Strip_Right,` ',` ',
+               ,,,,
+               ,
+           71f_frais_emet02_montant,,,
+               726,15,Pad_Right,` ',,
+               /cristal/flux/donnees/mnt_frais_emet[@occ="2"],Strip_Right,` ',` ',
+               ,,,,
+               ,
+           71f_frais_emet03_devise,,,
+               741,3,Pad_Right,` ',,
+               /cristal/flux/donnees/dev_frais_emet[@occ="3"],Strip_Right,` ',` ',
+               ,,,,
+               ,
+           71f_frais_emet03_montant,,,
+               744,15,Pad_Right,` ',,
+               /cristal/flux/donnees/mnt_frais_emet[@occ="3"],Strip_Right,` ',` ',
+               ,,,,
+               ,
+           71f_frais_emet04_devise,,,
+               759,3,Pad_Right,` ',,
+               /cristal/flux/donnees/dev_frais_emet[@occ="4"],Strip_Right,` ',` ',
+               ,,,,
+               ,
+           71f_frais_emet04_montant,,,
+               762,15,Pad_Right,` ',,
+               /cristal/flux/donnees/mnt_frais_emet[@occ="4"],Strip_Right,` ',` ',
+               ,,,,
+               ,
+           71f_frais_emet05_devise,,,
+               777,3,Pad_Right,` ',,
+               /cristal/flux/donnees/dev_frais_emet[@occ="5"],Strip_Right,` ',` ',
+               ,,,,
+               ,
+           71f_frais_emet05_montant,,,
+               780,15,Pad_Right,` ',,
+               /cristal/flux/donnees/mnt_frais_emet[@occ="5"],Strip_Right,` ',` ',
+               ,,,,
+               ,
+           71g_frais_recept_devise,,,
+               795,3,Pad_Right,` ',,
+               /cristal/flux/donnees/dev_frais_recep,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           71g_frais_recept_montant,,,
+               798,15,Pad_Right,` ',,
+               /cristal/flux/donnees/mnt_frais_recep,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           champ_72,,,
+               813,276,Pad_Right,` ',,
+               ,,,,
+               ,,,,
+               ,
+           champ_77,,,
+               1089,111,Pad_Right,` ',,
+               ,,,,
+               ,,,,
+               )
diff --git a/src/sd_msg_struct/src/crt_flux_stlm_header.xml.m4 b/src/sd_msg_struct/src/crt_flux_stlm_header.xml.m4
new file mode 100644
index 0000000..0112742
--- /dev/null
+++ b/src/sd_msg_struct/src/crt_flux_stlm_header.xml.m4
@@ -0,0 +1,224 @@
+<!-- messages de mapping des entetes communs des flux destines a cristal -->
+<!-- taille 302 -->
+	   <!-- A VOIR fixed sans xml -->
+	   <!-- A VOIR fixed sans xml -->
+	   <!-- A VOIR fixed sans xml -->
+msg_object(crt_flux_header,,
+           code_banque_ctrl,,,
+               0,5,Pad_Right,` ',,
+               /cristal/flux/en_tete_commun/code_bq_ctrl,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           type_flux,,,
+               5,4,Pad_Right,` ',,
+               /cristal/flux/en_tete_commun/type_flux,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           code_util,,,
+               9,20,Pad_Right,` ',,
+               /cristal/flux/en_tete_commun/code_util,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           code_guichet_pf_p,,,
+               29,8,Pad_Right,` ',,
+               /cristal/flux/en_tete_commun/code_guichet,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           authentification,,,
+               37,10,Pad_Right,` ',,
+               /cristal/flux/en_tete_commun/authentification,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           num_fichier,,,
+               47,10,Pad_Right,` ',,
+               /cristal/flux/en_tete_commun/num_fichier,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           responsable,,,
+               57,10,Pad_Right,` ',,
+               /cristal/flux/en_tete_commun/responsable,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           commentaire,,,
+               67,35,Pad_Right,` ',,
+               /cristal/flux/en_tete_commun/commentaire,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           r1,,,
+               102,16,Pad_Right,` ',,
+               /cristal/flux/zone_reservee/ref_interne,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           r2,,,
+               118,16,Pad_Right,` ',,
+               /cristal/flux/zone_reservee/ref_emet,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           r3,,,
+               134,16,Pad_Right,` ',,
+               /cristal/flux/zone_reservee/ref_dossier,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           r4,,,
+               150,12,Pad_Right,` ',,
+               /cristal/flux/zone_reservee/ref_comptable,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           service_desti,,,
+               162,5,Pad_Right,` ',,
+               /cristal/flux/zone_reservee/svce_dest,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           service_desti_initial,,,
+               167,5,Pad_Right,` ',,
+               /cristal/flux/zone_reservee/svce_dest_init,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           canal_final,,,
+               172,3,Pad_Right,` ',,
+               /cristal/flux/zone_reservee/canal_final,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           bic_cri_recep,,,
+               175,11,Pad_Right,` ',,
+               /cristal/flux/zone_reservee/bic_cri_recep,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           code_pays_desti,,,
+               186,2,Pad_Right,` ',,
+               /cristal/flux/zone_reservee/code_pays_dest,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           ident_acteur,,,
+               188,18,Pad_Right,` ',,
+               /cristal/flux/zone_reservee/id_acteur,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           code_siege_emet,,,
+               206,5,Pad_Right,` ',,
+               /cristal/flux/zone_reservee/code_siege_emet,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           ref_denotage,,,
+               211,18,Pad_Right,` ',,
+               /cristal/flux/zone_reservee/ref_denotage,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           code_appli_routage,,,
+               229,3,Pad_Right,` ',,
+               /cristal/flux/zone_reservee/code_appli_rout,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           code_siege_routage,,,
+               232,5,Pad_Right,` ',,
+               /cristal/flux/zone_reservee/code_siege_rout,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           ref_unique_interne,,,
+               237,20,Pad_Right,` ',,
+               /cristal/flux/zone_reservee/ref_unique_int,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           heure_debit_rtgs_emet,,,
+               257,9,Pad_Right,` ',,
+               /imr/xml_missing,,,` ',
+               ,,,,
+               ,
+           ident_pdse,,,
+               266,12,Pad_Right,` ',,
+               /cristal/flux/zone_reservee/id_pdse,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           nature_operation,,,
+               278,8,Pad_Right,` ',,
+               /cristal/flux/zone_reservee/nat_op,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           heure_ech_cls,,,
+               286,9,Pad_Right,` ',,
+               /imr/xml_missing,,,` ',
+               ,,,,
+               ,
+           zone_reservee,,,
+               295,7,Pad_Right,` ',,
+               /imr/xml_missing,,,` ',
+               ,,,,
+               )
+<!-- messages de mapping des entetes des virements destines a cristal -->
+<!-- taille 113 ( a partir de 302 taille de entete commun )-->
+msg_object(crt_flux_stlm_header,,
+           ref_util,,,
+               302,16,Pad_Right,` ',,
+               /cristal/flux/specific_vir/ref_util,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           ind_ann_gen,,,
+               318,1,,,,
+               /cristal/flux/specific_vir/ind_ann_gen,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           ref_ann,,,
+               319,16,Pad_Right,` ',,
+               /cristal/flux/specific_vir/ref_ann,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           type_ann,,,
+               335,1,,,,
+               /cristal/flux/specific_vir/type_ann,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           ref_ann_init,,,
+               336,16,Pad_Right,` ',,
+               /cristal/flux/specific_vir/ref_ann_init,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           code_acc_int,,,
+               352,4,Pad_Right,` ',,
+               /cristal/flux/specific_vir/code_acc_int,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           bic_emetteur,,,
+               356,11,Pad_Right,` ',,
+               /cristal/flux/specific_vir/bic_emet,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           bic_recepteur,,,
+               367,11,Pad_Right,` ',,
+               /cristal/flux/specific_vir/bic_recep,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           ident_bq_desti,,,
+               378,10,Pad_Right,` ',,
+               /cristal/flux/specific_vir/identifiant_bq_dest,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           bic_bq_desti,,,
+               388,11,Pad_Right,` ',,
+               /cristal/flux/specific_vir/code_bic_swift_dest,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           priorite_reseau,,,
+               399,1,,,,
+               /cristal/flux/specific_vir/priorite_reseau,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           canal_de_routage,,,
+               400,3,Pad_Right,` ',,
+               /cristal/flux/specific_vir/canal,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           heure_d_echeance_champ_113,,,
+               403,4,Pad_Right,` ',,
+               /cristal/flux/specific_vir/h_echeance,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           heure_emission_tot,,,
+               407,4,Pad_Right,` ',,
+               /cristal/flux/specific_vir/h_emis_tot,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           heure_emission_tard,,,
+               411,4,Pad_Right,` ',,
+               /cristal/flux/specific_vir/h_emis_tard,Strip_Right,` ',` ',
+               ,,,,
+               )
diff --git a/src/sd_msg_struct/src/cut_end_msg.xml.m4 b/src/sd_msg_struct/src/cut_end_msg.xml.m4
new file mode 100644
index 0000000..6e4e7cf
--- /dev/null
+++ b/src/sd_msg_struct/src/cut_end_msg.xml.m4
@@ -0,0 +1,12 @@
+<!-- message permettant de supprimer 1 caractere en fin de fichier -->
+msg_object(cut_end_msg,,
+           cut_end_fld1,,,
+               0,10000,Cut_Right,`1',` ',
+               ,,,,
+               ,,,,
+               ,
+           cut_end_fld2,,,
+               0,10000,Cut_Right,`2',` ',
+               ,,,,
+               ,,,,
+               )
diff --git a/src/sd_msg_struct/src/dltd_end_msg.xml.m4 b/src/sd_msg_struct/src/dltd_end_msg.xml.m4
new file mode 100644
index 0000000..485a013
--- /dev/null
+++ b/src/sd_msg_struct/src/dltd_end_msg.xml.m4
@@ -0,0 +1,7 @@
+<!-- message permettant d'ajouter un caractere de fin de fichier -->
+msg_object(dltd_end_msg,,
+           dltd_end_fld,,,
+               0,10000,,,,
+               /imr/xml_missing,,,,
+               0,,,,
+               )
diff --git a/src/sd_msg_struct/src/msg_commun.xml.m4 b/src/sd_msg_struct/src/msg_commun.xml.m4
new file mode 100644
index 0000000..9365eb1
--- /dev/null
+++ b/src/sd_msg_struct/src/msg_commun.xml.m4
@@ -0,0 +1,222 @@
+dnl
+dnl+---------------------------------------------------------------------------+
+dnl|    Begin header_msg Macro                                                 |
+dnl+---------------------------------------------------------------------------+
+dnl
+define(`header_msg',
+`<?xml version="1.0" ?>
+`<!-- Msg Struct definitions -->'
+`<msg_struct>'')
+dnl
+dnl+---------------------------------------------------------------------------+
+dnl|     End header_msg Macro                                                  |
+dnl+---------------------------------------------------------------------------+
+dnl
+dnl
+dnl+---------------------------------------------------------------------------+
+dnl|    Begin footer_msg Macro                                                 |
+dnl+---------------------------------------------------------------------------+
+dnl
+define(`footer_msg',
+`<!-- Msg Struct definitions footer -->
+`</msg_struct>'')
+dnl
+dnl+---------------------------------------------------------------------------+
+dnl|     End footer_msg Macro                                                  |
+dnl+---------------------------------------------------------------------------+
+dnl
+dnl
+dnl+---------------------------------------------------------------------------+
+dnl|    Begin insert_version Macro                                             |
+dnl|                                                                           |
+dnl| $1 : la chaine VERSION                                                    |
+dnl+---------------------------------------------------------------------------+
+dnl
+define(`insert_version',
+`<version>$1</version>')
+dnl
+dnl+----------------------------------------------------------------------------+
+dnl|     End insert_version Macro                                               |
+dnl+----------------------------------------------------------------------------+
+dnl
+dnl
+dnl+---------------------------------------------------------------------------+
+dnl|    Begin fixed_field Macro                                                |
+dnl|                                                                           |
+dnl| $1 : Fixed OffSet                                                         |
+dnl| $2 : Fixed Size                                                           |
+dnl| $3 : Fixed CNV Name                                                       |
+dnl| $4 : Fixed CNV Attribute                                                  |
+dnl| $5 : Fixed DefVal                                                         |
+dnl+---------------------------------------------------------------------------+
+dnl
+define(`fixed_field',
+`ifelse(`$2',,`dnl',`			<fixed>')'
+`ifelse(`$1',,`dnl',`				<offset>$1</offset>')'
+`ifelse(`$2',,`dnl',`				<size>$2</size>')'
+`ifelse(`$3',,`dnl',`				<cnv>')'
+`ifelse(`$3',,`dnl',`					<name>$3</name>')'
+`ifelse(`$4',,`dnl',`					<attribute>$4</attribute>')'
+`ifelse(`$3',,`dnl',`				</cnv>')'
+`ifelse(`$5',,`dnl',`				<defval>$5</defval>')'
+`ifelse(`$2',,`dnl',`			</fixed>')')
+dnl
+dnl+----------------------------------------------------------------------------+
+dnl|     End fixed_field Macro                                                  |
+dnl+----------------------------------------------------------------------------+
+dnl
+dnl
+dnl+---------------------------------------------------------------------------+
+dnl|    Begin xml_field Macro                                                  |
+dnl|                                                                           |
+dnl| $1 : XML Name                                                             |
+dnl| $2 : XML CNV Name                                                         |
+dnl| $3 : XML CNV Attribute                                                    |
+dnl| $4 : XML DefVal                                                           |
+dnl+---------------------------------------------------------------------------+
+dnl
+define(`xml_field',
+`ifelse(`$1',,`dnl',`			<xml>'
+`				<name>$1</name>')'
+`ifelse(`$2',,`dnl',`				<cnv>'
+`					<name>$2</name>')'
+`ifelse(`$3',,`dnl',`					<attribute>$3</attribute>')'
+`ifelse(`$2',,`dnl',`				</cnv>')'
+`ifelse(`$4',,`dnl',`				<defval>$4</defval>')'
+`ifelse(`$1',,`dnl',`			</xml>')')
+dnl
+dnl+----------------------------------------------------------------------------+
+dnl|     End xml_field Macro                                                    |
+dnl+----------------------------------------------------------------------------+
+dnl
+dnl
+dnl+---------------------------------------------------------------------------+
+dnl|    Begin delimited_field Macro                                            |
+dnl|                                                                           |
+dnl| $1 : Delimited Id                                                         |
+dnl| $2 : Delimited CNV Name                                                   |
+dnl| $3 : Delimited CNV Attribute                                              |
+dnl| $4 : Delimited CNV DefVal                                                 |
+dnl+---------------------------------------------------------------------------+
+dnl
+define(`delimited_field',
+`ifelse(`$1',,`dnl',`			<delimited>'
+`				<id>$1</id>')'
+`ifelse(`$2',,`dnl',`				<cnv>'
+`					<name>$2</name>')'
+`ifelse(`$3',,`dnl',`					<attribute>$3</attribute>')'
+`ifelse(`$2',,`dnl',`				</cnv>')'
+`ifelse(`$4',,`dnl',`				<defval>$4</defval>')'
+`ifelse(`$1',,`dnl',`			</delimited>')')
+dnl
+dnl+----------------------------------------------------------------------------+
+dnl|     End delimited_field Macro                                              |
+dnl+----------------------------------------------------------------------------+
+dnl
+dnl
+dnl+---------------------------------------------------------------------------+
+dnl|    Begin fml_field Macro                                                  |
+dnl|                                                                           |
+dnl| $1 : FML Name                                                             |
+dnl+---------------------------------------------------------------------------+
+dnl
+define(`fml_field',
+`ifelse(`$1',,`dnl',`			<fml>')'
+`ifelse(`$1',,`dnl',`				<name>$1</name>')'
+`ifelse(`$1',,`dnl',`			</fml>')')
+dnl
+dnl+----------------------------------------------------------------------------+
+dnl|     End fml_field Macro                                                    |
+dnl+----------------------------------------------------------------------------+
+dnl
+dnl
+dnl+---------------------------------------------------------------------------+
+dnl|    Begin fieldmsg_object Macro                                            |
+dnl|                                                                           |
+dnl| $1 : Field Name                                                           |
+dnl| $2 : ValueId                                                              |
+dnl| $3 : Field Exist                                                          |
+dnl| $4 : Fixed OffSet                                                         |
+dnl| $5 : Fixed Size                                                           |
+dnl| $6 : Fixed CNV Name                                                       |
+dnl| $7 : Fixed CNV Attribute                                                  |
+dnl| $8 : Fixed DefVal                                                         |
+dnl| $9 : XML Name                                                             |
+dnl| $10: XML CNV Name                                                         |
+dnl| $11: XML CNV Attribute                                                    |
+dnl| $12: XML DefVal                                                           |
+dnl| $13: Delimited Id                                                         |
+dnl| $14: Delimited CNV Name                                                   |
+dnl| $15: Delimited CNV Attribute                                              |
+dnl| $16: Delimited CNV DefVal                                                 |
+dnl| $17: FML Name                                                             |
+dnl+---------------------------------------------------------------------------+
+dnl
+define(`fieldmsg_object',
+`ifelse($1,,`dnl',`		<field>'
+`			<name>$1</name>')'
+dnl `		<field>
+dnl `			<name>$1</name>'
+`ifelse(`$2',,`dnl',`			<valueid>$2</valueid>')'
+`ifelse($3,,`dnl',`			<exist>$3</exist>')'
+`fixed_field(shift(shift(shift($@))))'
+`xml_field(shift(shift(shift(shift(shift(shift(shift(shift($@)))))))))'
+`delimited_field(shift(shift(shift(shift(shift(shift(shift(shift(shift(shift(shift(shift($@)))))))))))))'
+`fml_field(shift(shift(shift(shift(shift(shift(shift(shift(shift(shift(shift(shift(shift(shift(shift(shift($@)))))))))))))))))'
+`ifelse($1,,`dnl',`		</field>')')
+dnl `		</field>')
+dnl
+dnl+----------------------------------------------------------------------------+
+dnl|     End fieldmsg_object Macro                                              |
+dnl+----------------------------------------------------------------------------+
+dnl
+dnl
+dnl+---------------------------------------------------------------------------+
+dnl|    Begin list_fieldmsg_object Macro        Arg. variadique                |
+dnl|                                                                           |
+dnl| $1 : Field Name                                                           |
+dnl| $2 : ValueId                                                              |
+dnl| $3 : Field Exist                                                          |
+dnl| $4 : Fixed OffSet                                                         |
+dnl| $5 : Fixed Size                                                           |
+dnl| $6 : Fixed CNV Name                                                       |
+dnl| $7 : Fixed CNV Attribute                                                  |
+dnl| $8 : Fixed DefVal                                                         |
+dnl| $9 : XML Name                                                             |
+dnl| $10: XML CNV Name                                                         |
+dnl| $11: XML CNV Attribute                                                    |
+dnl| $12: XML DefVal                                                           |
+dnl| $13: Delimited Id                                                         |
+dnl| $14: Delimited CNV Name                                                   |
+dnl| $15: Delimited CNV Attribute                                              |
+dnl| $16: Delimited CNV DefVal                                                 |
+dnl| $fieldmsg_object($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16)  |
+dnl+---------------------------------------------------------------------------+
+dnl
+define(`list_fieldmsg_object',
+`ifelse($#,1,`dnl',`fieldmsg_object($@)'
+`list_fieldmsg_object(shift(shift(shift(shift(shift(shift(shift(shift(shift(shift(shift(shift(shift(shift(shift(shift(shift($@))))))))))))))))))')')
+dnl
+dnl+----------------------------------------------------------------------------+
+dnl|     End list_fieldmsg_object Macro                                         |
+dnl+----------------------------------------------------------------------------+
+dnl
+dnl
+dnl+---------------------------------------------------------------------------+
+dnl|    Begin msg_object Macro                                                 |
+dnl|                                                                           |
+dnl| $1 : message Name                                                         |
+dnl| $2 : message size                                                         |
+dnl+---------------------------------------------------------------------------+
+dnl
+define(`msg_object',
+`	<message>
+`		<name>$1</name>'
+ifelse($2,,`dnl',`		<size>$2</size>')
+list_fieldmsg_object(shift(shift($@)))
+`	</message>'')
+dnl
+dnl+---------------------------------------------------------------------------+
+dnl|     End msg_object Macro                                                  |
+dnl+---------------------------------------------------------------------------+
+dnl
diff --git a/src/sd_msg_struct/src/msg_delimited_fixed.xml.m4 b/src/sd_msg_struct/src/msg_delimited_fixed.xml.m4
new file mode 100644
index 0000000..f4486a5
--- /dev/null
+++ b/src/sd_msg_struct/src/msg_delimited_fixed.xml.m4
@@ -0,0 +1,6 @@
+msg_object(msg_delimited_fixed,,
+           complements,,,
+               0,148,,,,
+               ,,,,
+               0,,,,
+               )
diff --git a/src/sd_msg_struct/src/msg_fixed_fml.xml.m4 b/src/sd_msg_struct/src/msg_fixed_fml.xml.m4
new file mode 100644
index 0000000..3bbae1e
--- /dev/null
+++ b/src/sd_msg_struct/src/msg_fixed_fml.xml.m4
@@ -0,0 +1,6 @@
+msg_object(msg_fixed_fml,,
+           FML_MSG_TXT,,,
+               0,64000,,,,
+               ,,,,
+               ,,,,
+               FML_MSG_TXT)
diff --git a/src/sd_msg_struct/src/msg_unknown.xml.m4 b/src/sd_msg_struct/src/msg_unknown.xml.m4
new file mode 100644
index 0000000..d038a93
--- /dev/null
+++ b/src/sd_msg_struct/src/msg_unknown.xml.m4
@@ -0,0 +1,7 @@
+<!-- message unknown -->
+msg_object(unknown,,
+           ,,,
+               ,,,,,
+               ,,,,
+               ,,,,
+               )
diff --git a/src/sd_msg_struct/src/sd_msg_struct.xml.m4 b/src/sd_msg_struct/src/sd_msg_struct.xml.m4
new file mode 100644
index 0000000..8544ea1
--- /dev/null
+++ b/src/sd_msg_struct/src/sd_msg_struct.xml.m4
@@ -0,0 +1,84 @@
+dnl
+divert(-1)
+include(`msg_commun.xml.m4')
+divert(0)dnl
+dnl
+changecom(`<!--', `-->')dnl
+dnl
+dnl
+header_msg()
+insert_version(@(#) VERSIONIMR: $Label:  $   $Date: 2008/11/12 02:25:24 $   $Workfile:   sd_msg_struct.xml.m4  $)
+include(`msg_unknown.xml.m4')
+include(`cut_end_msg.xml.m4')
+include(`strip_end_msg.xml.m4')
+include(`msg_fixed_fml.xml.m4')
+include(`msg_delimited_fixed.xml.m4')
+include(`crt_cre_header.xml.m4')
+include(`crt_cre_ident.xml.m4')
+include(`crt_flux_ident.xml.m4')
+include(`crt_flux_stlm.xml.m4')
+include(`crt_flux_stlm_bk.xml.m4')
+include(`crt_flux_stlm_cus.xml.m4')
+include(`crt_flux_stlm_cus_end.xml.m4')
+include(`crt_flux_stlm_header.xml.m4')
+include(`crt_flux_or.xml.m4')
+include(`swf_field_13c.xml.m4')
+include(`swf_field_50_ident.xml.m4')
+include(`swf_field_50k_comp.xml.m4')
+include(`swf_field_50x.xml.m4')
+include(`swf_field_52_ident.xml.m4')
+include(`swf_field_52d_comp.xml.m4')
+include(`swf_field_52x.xml.m4')
+include(`swf_field_55_ident.xml.m4')
+include(`swf_field_55d_comp.xml.m4')
+include(`swf_field_55x.xml.m4')
+include(`swf_field_56_ident.xml.m4')
+include(`swf_field_56d_comp.xml.m4')
+include(`swf_field_56x.xml.m4')
+include(`swf_field_57_ident.xml.m4')
+include(`swf_field_57d_comp.xml.m4')
+include(`swf_field_57x.xml.m4')
+include(`swf_field_58_ident.xml.m4')
+include(`swf_field_58d_comp.xml.m4')
+include(`swf_field_58x.xml.m4')
+include(`swf_field_59_ident.xml.m4')
+include(`swf_field_59blanc_comp.xml.m4')
+include(`swf_field_59x.xml.m4')
+include(`swf_field_70.xml.m4')
+include(`swf_field_72.xml.m4')
+include(`swf_field_72_autres_lignes.xml.m4')
+include(`swf_field_77.xml.m4')
+include(`crt_cre_flux_ident.xml.m4')
+include(`crt_cre_flux_or.xml.m4')
+include(`crt_cre_flux_stlm.xml.m4')
+include(`crt_cre_flux_stlm_bk.xml.m4')
+include(`crt_cre_flux_stlm_cus.xml.m4')
+include(`crt_cre_flux_stlm_cus_end.xml.m4')
+include(`crt_cre_flux_stlm_header.xml.m4')
+include(`swf_cre_field_13c.xml.m4')
+include(`swf_cre_field_50_ident.xml.m4')
+include(`swf_cre_field_50k_comp.xml.m4')
+include(`swf_cre_field_50x.xml.m4')
+include(`swf_cre_field_52_ident.xml.m4')
+include(`swf_cre_field_52d_comp.xml.m4')
+include(`swf_cre_field_52x.xml.m4')
+include(`swf_cre_field_55_ident.xml.m4')
+include(`swf_cre_field_55d_comp.xml.m4')
+include(`swf_cre_field_55x.xml.m4')
+include(`swf_cre_field_56_ident.xml.m4')
+include(`swf_cre_field_56d_comp.xml.m4')
+include(`swf_cre_field_56x.xml.m4')
+include(`swf_cre_field_57_ident.xml.m4')
+include(`swf_cre_field_57d_comp.xml.m4')
+include(`swf_cre_field_57x.xml.m4')
+include(`swf_cre_field_58_ident.xml.m4')
+include(`swf_cre_field_58d_comp.xml.m4')
+include(`swf_cre_field_58x.xml.m4')
+include(`swf_cre_field_59_ident.xml.m4')
+include(`swf_cre_field_59blanc_comp.xml.m4')
+include(`swf_cre_field_59x.xml.m4')
+include(`swf_cre_field_70.xml.m4')
+include(`swf_cre_field_72.xml.m4')
+include(`swf_cre_field_72_autres_lignes.xml.m4')
+include(`swf_cre_field_77.xml.m4')
+footer_msg()
diff --git a/src/sd_msg_struct/src/strip_end_msg.xml.m4 b/src/sd_msg_struct/src/strip_end_msg.xml.m4
new file mode 100644
index 0000000..2ba04b5
--- /dev/null
+++ b/src/sd_msg_struct/src/strip_end_msg.xml.m4
@@ -0,0 +1,7 @@
+<!-- message permettant de stripper les espaces en fin de message -->
+msg_object(strip_end_msg,,
+           strip_end_fld,,,
+               0,10000,Strip_Right,` ',` ',
+               ,,,,
+               ,,,,
+               )
diff --git a/src/sd_msg_struct/src/swf_cre_field_13c.xml.m4 b/src/sd_msg_struct/src/swf_cre_field_13c.xml.m4
new file mode 100644
index 0000000..fb76dfd
--- /dev/null
+++ b/src/sd_msg_struct/src/swf_cre_field_13c.xml.m4
@@ -0,0 +1,37 @@
+<!-- message de mapping des champs 13c -->
+msg_object(swf_cre_field_13c,,
+           champ_13c,,,
+               0,114,Pad_Right,` ',` ',
+               ,,,,
+               ,,,,
+               ,
+           champ_13c_1,,,
+               0,19,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/champ13c[@occ="1"],Strip_Right,` ',,
+               ,,,,
+               ,
+           champ_13c_2,,,
+               19,19,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/champ13c[@occ="2"],Strip_Right,` ',,
+               ,,,,
+               ,
+           champ_13c_3,,,
+               38,19,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/champ13c[@occ="3"],Strip_Right,` ',,
+               ,,,,
+               ,
+           champ_13c_4,,,
+               57,19,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/champ13c[@occ="4"],Strip_Right,` ',,
+               ,,,,
+               ,
+           champ_13c_5,,,
+               76,19,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/champ13c[@occ="5"],Strip_Right,` ',,
+               ,,,,
+               ,
+           champ_13c_6,,,
+               95,19,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/champ13c[@occ="6"],Strip_Right,` ',,
+               ,,,,
+               )
diff --git a/src/sd_msg_struct/src/swf_cre_field_50_ident.xml.m4 b/src/sd_msg_struct/src/swf_cre_field_50_ident.xml.m4
new file mode 100644
index 0000000..08a9d70
--- /dev/null
+++ b/src/sd_msg_struct/src/swf_cre_field_50_ident.xml.m4
@@ -0,0 +1,20 @@
+<!-- messages d'identification des blocs 50 -->
+msg_object(swf_cre_field_50a_fmt,,
+           cli_donneur_ordre_format,`A',,
+               185,1,,,,
+               /cristal/cre/donnees_cre/flux/donnees/cli_don_ordre/format_champ,,,,
+               ,,,,
+               )
+msg_object(swf_cre_field_50k_fmt,,
+           cli_donneur_ordre_format,`K',,
+               185,1,,,,
+               /cristal/cre/donnees_cre/flux/donnees/cli_don_ordre/format_champ,,,,
+               ,,,,
+               )
+<!-- dans mappath	retour de identifier	= unknown pour	xml -->
+msg_object(swf_cre_field_50vide_fmt,,
+           cli_donneur_ordre_format,` ',,
+               185,1,,,,
+               ,,,,
+               ,,,,
+               )
diff --git a/src/sd_msg_struct/src/swf_cre_field_50k_comp.xml.m4 b/src/sd_msg_struct/src/swf_cre_field_50k_comp.xml.m4
new file mode 100644
index 0000000..64a84ed
--- /dev/null
+++ b/src/sd_msg_struct/src/swf_cre_field_50k_comp.xml.m4
@@ -0,0 +1,28 @@
+<!-- message permettant	l'extraction et l'insertion de identification des blocs 50K	(champ identification) -->
+<!-- message de mapping	de	identification	des blocs 5OK (autres champs)	-->
+msg_object(swf_cre_field_50k_comp,,
+           identification,,,
+               0,148,Pad_Right,` ',` ',
+               ,,,,
+               ,,,,
+               ,
+           cli_donneur_ordre_identification_ligne1,,,
+               ,35,,,,
+               /cristal/cre/donnees_cre/flux/donnees/cli_don_ordre/identification/ligne[1],Strip_Right,` ',,
+               0,Pad_Right,` ',` ',
+               ,
+           cli_donneur_ordre_identification_ligne2,,,
+               ,35,,,,
+               /cristal/cre/donnees_cre/flux/donnees/cli_don_ordre/identification/ligne[2],Strip_Right,` ',,
+               1,Pad_Right,` ',` ',
+               ,
+           cli_donneur_ordre_identification_ligne3,,,
+               ,35,,,,
+               /cristal/cre/donnees_cre/flux/donnees/cli_don_ordre/identification/ligne[3],Strip_Right,` ',,
+               2,Pad_Right,` ',` ',
+               ,
+           cli_donneur_ordre_identification_ligne4,,,
+               ,35,,,,
+               /cristal/cre/donnees_cre/flux/donnees/cli_don_ordre/identification/ligne[4],Strip_Right,` ',,
+               3,Pad_Right,` ',` ',
+               )
diff --git a/src/sd_msg_struct/src/swf_cre_field_50x.xml.m4 b/src/sd_msg_struct/src/swf_cre_field_50x.xml.m4
new file mode 100644
index 0000000..0667b5d
--- /dev/null
+++ b/src/sd_msg_struct/src/swf_cre_field_50x.xml.m4
@@ -0,0 +1,30 @@
+<!-- message permettant	l'extraction et l'insertion des blocs 50 (champ_50) -->
+<!-- message de mapping	des blocs 50 (autres	champs) -->
+<!-- le champ cli_donneur_ordre_identification est	utilise pour le mapping	du	50A -->
+<!-- il permet	l'extraction et l'insertion de identification pour	le	mapping du 50K	-->
+msg_object(swf_cre_field_50x,,
+           champ_50,,,
+               0,186,Pad_Right,` ',` ',
+               ,,,,
+               ,,,,
+               ,
+           cli_donneur_ordre_type,,,
+               0,3,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/cli_don_ordre/type,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           cli_donneur_ordre_coordonnees,,,
+               3,34,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/cli_don_ordre/coordonnees,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           cli_donneur_ordre_identification,,,
+               37,148,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/cli_don_ordre/identification/ligne[1],Strip_Right,` ',` ',
+               ,,,,
+               ,
+           cli_donneur_ordre_format,,,
+               185,1,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/cli_don_ordre/format_champ,Strip_Right,` ',` ',
+               ,,,,
+               )
diff --git a/src/sd_msg_struct/src/swf_cre_field_52_ident.xml.m4 b/src/sd_msg_struct/src/swf_cre_field_52_ident.xml.m4
new file mode 100644
index 0000000..6eca136
--- /dev/null
+++ b/src/sd_msg_struct/src/swf_cre_field_52_ident.xml.m4
@@ -0,0 +1,20 @@
+<!-- messages d'identification des blocs 52 -->
+msg_object(swf_cre_field_52a_fmt,,
+           bq_donneuse_ordre_format,`A',,
+               183,1,,,,
+               /cristal/cre/donnees_cre/flux/donnees/bq_don_ordre/format_champ,,,,
+               ,,,,
+               )
+msg_object(swf_cre_field_52d_fmt,,
+           bq_donneuse_ordre_format,`D',,
+               183,1,,,,
+               /cristal/cre/donnees_cre/flux/donnees/bq_don_ordre/format_champ,,,,
+               ,,,,
+               )
+<!-- dans mappath retour de identifier = unknown pour xml -->
+msg_object(swf_cre_field_52vide_fmt,,
+           bq_donneuse_ordre_format,` ',,
+               183,1,,,,
+               ,,,,
+               ,,,,
+               )
diff --git a/src/sd_msg_struct/src/swf_cre_field_52d_comp.xml.m4 b/src/sd_msg_struct/src/swf_cre_field_52d_comp.xml.m4
new file mode 100644
index 0000000..55634bb
--- /dev/null
+++ b/src/sd_msg_struct/src/swf_cre_field_52d_comp.xml.m4
@@ -0,0 +1,28 @@
+<!-- message permettant l'extraction et l'insertion de complements des blocs 52D (complements) -->
+<!-- message de mapping de complements des blocs 52D (autres champs) -->
+msg_object(swf_cre_field_52d_comp,,
+           complements,,,
+               0,148,Pad_Right,` ',` ',
+               ,,,,
+               ,,,,
+               ,
+           bq_donneuse_ordre_complements_ligne1,,,
+               ,35,,,,
+               /cristal/cre/donnees_cre/flux/donnees/bq_don_ordre/complements/ligne[1],Strip_Right,` ',,
+               0,Pad_Right,` ',` ',
+               ,
+           bq_donneuse_ordre_complements_ligne2,,,
+               ,35,,,,
+               /cristal/cre/donnees_cre/flux/donnees/bq_don_ordre/complements/ligne[2],Strip_Right,` ',,
+               1,Pad_Right,` ',` ',
+               ,
+           bq_donneuse_ordre_complements_ligne3,,,
+               ,35,,,,
+               /cristal/cre/donnees_cre/flux/donnees/bq_don_ordre/complements/ligne[3],Strip_Right,` ',,
+               2,Pad_Right,` ',` ',
+               ,
+           bq_donneuse_ordre_complements_ligne4,,,
+               ,35,,,,
+               /cristal/cre/donnees_cre/flux/donnees/bq_don_ordre/complements/ligne[4],Strip_Right,` ',,
+               3,Pad_Right,` ',` ',
+               )
diff --git a/src/sd_msg_struct/src/swf_cre_field_52x.xml.m4 b/src/sd_msg_struct/src/swf_cre_field_52x.xml.m4
new file mode 100644
index 0000000..1b94671
--- /dev/null
+++ b/src/sd_msg_struct/src/swf_cre_field_52x.xml.m4
@@ -0,0 +1,30 @@
+<!-- message permettant l'extraction et l'insertion des blocs 52 (champ_52) -->
+<!-- message de mapping des blocs 52 (autres champs) -->
+<!-- le champ bq_donneuse_ordre_complements est utilise pour le mapping du 52A -->
+<!-- il permet l'extraction et l'insertion de complements pour le mapping du 52D -->
+msg_object(swf_cre_field_52x,,
+           champ_52,,,
+               0,184,Pad_Right,` ',` ',
+               ,,,,
+               ,,,,
+               ,
+           bq_donneuse_ordre_no_de_compte,,,
+               0,34,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/bq_don_ordre/compte,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           bq_donneuse_ordre_sens_du_compte,,,
+               34,1,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/bq_don_ordre/sens,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           bq_donneuse_ordre_complements,,,
+               35,148,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/bq_don_ordre/complements/ligne[1],Strip_Right,` ',` ',
+               ,,,,
+               ,
+           bq_donneuse_ordre_format,,,
+               183,1,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/bq_don_ordre/format_champ,Strip_Right,` ',` ',
+               ,,,,
+               )
diff --git a/src/sd_msg_struct/src/swf_cre_field_55_ident.xml.m4 b/src/sd_msg_struct/src/swf_cre_field_55_ident.xml.m4
new file mode 100644
index 0000000..a3178bc
--- /dev/null
+++ b/src/sd_msg_struct/src/swf_cre_field_55_ident.xml.m4
@@ -0,0 +1,26 @@
+<!-- messages d'identification des blocs 55 -->
+msg_object(swf_cre_field_55a_fmt,,
+           bq_de_refin_format,`A',,
+               183,1,,,,
+               /cristal/cre/donnees_cre/flux/donnees/bq_du_refin/format_champ,,,,
+               ,,,,
+               )
+msg_object(swf_cre_field_55b_fmt,,
+           bq_de_refin_format,`B',,
+               183,1,,,,
+               /cristal/cre/donnees_cre/flux/donnees/bq_du_refin/format_champ,,,,
+               ,,,,
+               )
+msg_object(swf_cre_field_55d_fmt,,
+           bq_de_refin_format,`D',,
+               183,1,,,,
+               /cristal/cre/donnees_cre/flux/donnees/bq_du_refin/format_champ,,,,
+               ,,,,
+               )
+<!-- dans mappath	retour de identifier	= unknown pour	xml -->
+msg_object(swf_cre_field_55vide_fmt,,
+           bq_de_refin_format,` ',,
+               183,1,,,,
+               ,,,,
+               ,,,,
+               )
diff --git a/src/sd_msg_struct/src/swf_cre_field_55d_comp.xml.m4 b/src/sd_msg_struct/src/swf_cre_field_55d_comp.xml.m4
new file mode 100644
index 0000000..fcab91c
--- /dev/null
+++ b/src/sd_msg_struct/src/swf_cre_field_55d_comp.xml.m4
@@ -0,0 +1,28 @@
+<!-- message permettant l'extraction et l'insertion de complements des blocs 55D (complements) -->
+<!-- message de mapping de complements des blocs 55D (autres champs) -->
+msg_object(swf_cre_field_55d_comp,,
+           complements,,,
+               0,148,Pad_Right,` ',` ',
+               ,,,,
+               ,,,,
+               ,
+           bq_de_refin_complements_ligne1,,,
+               ,35,,,,
+               /cristal/cre/donnees_cre/flux/donnees/bq_du_refin/complements/ligne[1],Strip_Right,` ',,
+               0,Pad_Right,` ',` ',
+               ,
+           bq_de_refin_complements_ligne2,,,
+               ,35,,,,
+               /cristal/cre/donnees_cre/flux/donnees/bq_du_refin/complements/ligne[2],Strip_Right,` ',,
+               1,Pad_Right,` ',` ',
+               ,
+           bq_de_refin_complements_ligne3,,,
+               ,35,,,,
+               /cristal/cre/donnees_cre/flux/donnees/bq_du_refin/complements/ligne[3],Strip_Right,` ',,
+               2,Pad_Right,` ',` ',
+               ,
+           bq_de_refin_complements_ligne4,,,
+               ,35,,,,
+               /cristal/cre/donnees_cre/flux/donnees/bq_du_refin/complements/ligne[4],Strip_Right,` ',,
+               3,Pad_Right,` ',` ',
+               )
diff --git a/src/sd_msg_struct/src/swf_cre_field_55x.xml.m4 b/src/sd_msg_struct/src/swf_cre_field_55x.xml.m4
new file mode 100644
index 0000000..753e982
--- /dev/null
+++ b/src/sd_msg_struct/src/swf_cre_field_55x.xml.m4
@@ -0,0 +1,30 @@
+<!-- message permettant	l'extraction et l'insertion des blocs 55 (champ_55) -->
+<!-- message de mapping	des blocs 55 (autres champs) -->
+<!-- le champ bq_de_refin_complements est utilise pour le mapping du 55A -->
+<!-- il permet l'extraction et l'insertion de complements pour	le	mapping du 55D -->
+msg_object(swf_cre_field_55x,,
+           champ_55,,,
+               0,184,Pad_Right,` ',` ',
+               ,,,,
+               ,,,,
+               ,
+           bq_de_refin_no_de_compte,,,
+               0,34,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/bq_du_refin/compte,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           bq_de_refin_sens_du_compte,,,
+               34,1,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/bq_du_refin/sens,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           bq_de_refin_complements,,,
+               35,148,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/bq_du_refin/complements/ligne[1],Strip_Right,` ',` ',
+               ,,,,
+               ,
+           bq_de_refin_format,,,
+               183,1,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/bq_du_refin/format_champ,Strip_Right,` ',` ',
+               ,,,,
+               )
diff --git a/src/sd_msg_struct/src/swf_cre_field_56_ident.xml.m4 b/src/sd_msg_struct/src/swf_cre_field_56_ident.xml.m4
new file mode 100644
index 0000000..96db806
--- /dev/null
+++ b/src/sd_msg_struct/src/swf_cre_field_56_ident.xml.m4
@@ -0,0 +1,20 @@
+<!-- messages d'identification des blocs 56 -->
+msg_object(swf_cre_field_56a_fmt,,
+           bq_intermed_recep_format,`A',,
+               183,1,,,,
+               //cristal/cre/donnees_cre/flux/donnees/bq_inter_recep/format_champ,,,,
+               ,,,,
+               )
+msg_object(swf_cre_field_56d_fmt,,
+           bq_intermed_recep_format,`D',,
+               183,1,,,,
+               //cristal/cre/donnees_cre/flux/donnees/bq_inter_recep/format_champ,,,,
+               ,,,,
+               )
+<!-- dans mappath	retour de identifier	= unknown pour	xml -->
+msg_object(swf_cre_field_56vide_fmt,,
+           bq_intermed_recep_format,` ',,
+               183,1,,,,
+               ,,,,
+               ,,,,
+               )
diff --git a/src/sd_msg_struct/src/swf_cre_field_56d_comp.xml.m4 b/src/sd_msg_struct/src/swf_cre_field_56d_comp.xml.m4
new file mode 100644
index 0000000..e81750e
--- /dev/null
+++ b/src/sd_msg_struct/src/swf_cre_field_56d_comp.xml.m4
@@ -0,0 +1,28 @@
+<!-- message permettant l'extraction et l'insertion de complements des blocs 56D (complements) -->
+<!-- message de mapping de complements des blocs 56D (autres champs) -->
+msg_object(swf_cre_field_56d_comp,,
+           complements,,,
+               0,148,Pad_Right,` ',` ',
+               ,,,,
+               ,,,,
+               ,
+           bq_intermed_recep_complements_ligne1,,,
+               ,35,,,,
+               /cristal/cre/donnees_cre/flux/donnees/bq_inter_recep/complements/ligne[1],Strip_Right,` ',,
+               0,Pad_Right,` ',` ',
+               ,
+           bq_intermed_recep_complements_ligne2,,,
+               ,35,,,,
+               /cristal/cre/donnees_cre/flux/donnees/bq_inter_recep/complements/ligne[2],Strip_Right,` ',,
+               1,Pad_Right,` ',` ',
+               ,
+           bq_intermed_recep_complements_ligne3,,,
+               ,35,,,,
+               /cristal/cre/donnees_cre/flux/donnees/bq_inter_recep/complements/ligne[3],Strip_Right,` ',,
+               2,Pad_Right,` ',` ',
+               ,
+           bq_intermed_recep_complements_ligne4,,,
+               ,35,,,,
+               /cristal/cre/donnees_cre/flux/donnees/bq_inter_recep/complements/ligne[4],Strip_Right,` ',,
+               3,Pad_Right,` ',` ',
+               )
diff --git a/src/sd_msg_struct/src/swf_cre_field_56x.xml.m4 b/src/sd_msg_struct/src/swf_cre_field_56x.xml.m4
new file mode 100644
index 0000000..c7dd51c
--- /dev/null
+++ b/src/sd_msg_struct/src/swf_cre_field_56x.xml.m4
@@ -0,0 +1,30 @@
+<!-- message permettant l'extraction et l'insertion des blocs 56 (champ_56) -->
+<!-- message de mapping des blocs 56 (autres champs) -->
+<!-- le champ bq_intermed_recep_complements est utilise pour le mapping du 56A -->
+<!-- il permet l'extraction et l'insertion de complements pour le mapping du 56D -->
+msg_object(swf_cre_field_56x,,
+           champ_56,,,
+               0,184,Pad_Right,` ',` ',
+               ,,,,
+               ,,,,
+               ,
+           bq_intermed_recep_no_de_compte,,,
+               0,34,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/bq_inter_recep/compte,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           bq_intermed_recep_sens_du_compte,,,
+               34,1,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/bq_inter_recep/sens,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           bq_intermed_recep_complements,,,
+               35,148,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/bq_inter_recep/complements/ligne[1],Strip_Right,` ',` ',
+               ,,,,
+               ,
+           bq_intermed_recep_format,,,
+               183,1,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/bq_inter_recep/format_champ,Strip_Right,` ',` ',
+               ,,,,
+               )
diff --git a/src/sd_msg_struct/src/swf_cre_field_57_ident.xml.m4 b/src/sd_msg_struct/src/swf_cre_field_57_ident.xml.m4
new file mode 100644
index 0000000..87edd47
--- /dev/null
+++ b/src/sd_msg_struct/src/swf_cre_field_57_ident.xml.m4
@@ -0,0 +1,26 @@
+<!-- messages d'identification des blocs 57 -->
+msg_object(swf_cre_field_57a_fmt,,
+           bq_du_beneficiaire_format,`A',,
+               183,1,,,,
+               /cristal/cre/donnees_cre/flux/donnees/bq_du_benef/format_champ,,,,
+               ,,,,
+               )
+msg_object(swf_cre_field_57b_fmt,,
+           bq_du_beneficiaire_format,`B',,
+               183,1,,,,
+               /cristal/cre/donnees_cre/flux/donnees/bq_du_benef/format_champ,,,,
+               ,,,,
+               )
+msg_object(swf_cre_field_57d_fmt,,
+           bq_du_beneficiaire_format,`D',,
+               183,1,,,,
+               /cristal/cre/donnees_cre/flux/donnees/bq_du_benef/format_champ,,,,
+               ,,,,
+               )
+<!-- dans mappath	retour de identifier	= unknown pour	xml -->
+msg_object(swf_cre_field_57vide_fmt,,
+           bq_du_beneficiaire_format,` ',,
+               183,1,,,,
+               ,,,,
+               ,,,,
+               )
diff --git a/src/sd_msg_struct/src/swf_cre_field_57d_comp.xml.m4 b/src/sd_msg_struct/src/swf_cre_field_57d_comp.xml.m4
new file mode 100644
index 0000000..a8de0c9
--- /dev/null
+++ b/src/sd_msg_struct/src/swf_cre_field_57d_comp.xml.m4
@@ -0,0 +1,28 @@
+<!-- message permettant l'extraction et l'insertion de complements des blocs 57D (complements) -->
+<!-- message de mapping de complements des blocs 57D (autres champs) -->
+msg_object(swf_cre_field_57d_comp,,
+           complements,,,
+               0,148,Pad_Right,` ',` ',
+               ,,,,
+               ,,,,
+               ,
+           bq_du_beneficiaire_complements_ligne1,,,
+               ,35,,,,
+               /cristal/cre/donnees_cre/flux/donnees/bq_du_benef/complements/ligne[1],Strip_Right,` ',,
+               0,Pad_Right,` ',` ',
+               ,
+           bq_du_beneficiaire_complements_ligne2,,,
+               ,35,,,,
+               /cristal/cre/donnees_cre/flux/donnees/bq_du_benef/complements/ligne[2],Strip_Right,` ',,
+               1,Pad_Right,` ',` ',
+               ,
+           bq_du_beneficiaire_complements_ligne3,,,
+               ,35,,,,
+               /cristal/cre/donnees_cre/flux/donnees/bq_du_benef/complements/ligne[3],Strip_Right,` ',,
+               2,Pad_Right,` ',` ',
+               ,
+           bq_du_beneficiaire_complements_ligne4,,,
+               ,35,,,,
+               /cristal/cre/donnees_cre/flux/donnees/bq_du_benef/complements/ligne[4],Strip_Right,` ',,
+               3,Pad_Right,` ',` ',
+               )
diff --git a/src/sd_msg_struct/src/swf_cre_field_57x.xml.m4 b/src/sd_msg_struct/src/swf_cre_field_57x.xml.m4
new file mode 100644
index 0000000..91990c8
--- /dev/null
+++ b/src/sd_msg_struct/src/swf_cre_field_57x.xml.m4
@@ -0,0 +1,30 @@
+<!-- message permettant l'extraction et l'insertion des blocs 57 (champ_57) -->
+<!-- message de mapping des blocs 57 (autres champs) -->
+<!-- le champ bq_du_beneficiaire_complements est utilise pour le mapping du 57A -->
+<!-- il permet l'extraction et l'insertion de complements pour le mapping du 57D -->
+msg_object(swf_cre_field_57x,,
+           champ_57,,,
+               0,184,Pad_Right,` ',` ',
+               ,,,,
+               ,,,,
+               ,
+           bq_du_beneficiaire_no_de_compte,,,
+               0,34,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/bq_du_benef/compte,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           bq_du_beneficiaire_sens_du_compte,,,
+               34,1,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/bq_du_benef/sens,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           bq_du_beneficiaire_complements,,,
+               35,148,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/bq_du_benef/complements/ligne[1],Strip_Right,` ',` ',
+               ,,,,
+               ,
+           bq_du_beneficiaire_format,,,
+               183,1,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/bq_du_benef/format_champ,Strip_Right,` ',` ',
+               ,,,,
+               )
diff --git a/src/sd_msg_struct/src/swf_cre_field_58_ident.xml.m4 b/src/sd_msg_struct/src/swf_cre_field_58_ident.xml.m4
new file mode 100644
index 0000000..35934ae
--- /dev/null
+++ b/src/sd_msg_struct/src/swf_cre_field_58_ident.xml.m4
@@ -0,0 +1,26 @@
+<!-- messages d'identification des blocs 58 -->
+msg_object(swf_cre_field_58a_fmt,,
+           bq_beneficiaire_format,`A',,
+               183,1,,,,
+               /cristal/cre/donnees_cre/flux/donnees/bq_benef/format_champ,,,,
+               ,,,,
+               )
+msg_object(swf_cre_field_58b_fmt,,
+           bq_beneficiaire_format,`B',,
+               183,1,,,,
+               /cristal/cre/donnees_cre/flux/donnees/bq_benef/format_champ,,,,
+               ,,,,
+               )
+msg_object(swf_cre_field_58d_fmt,,
+           bq_beneficiaire_format,`D',,
+               183,1,,,,
+               /cristal/cre/donnees_cre/flux/donnees/bq_benef/format_champ,,,,
+               ,,,,
+               )
+<!-- dans mappath	retour de identifier	= unknown pour	xml -->
+msg_object(swf_cre_field_58vide_fmt,,
+           bq_beneficiaire_format,` ',,
+               183,1,,,,
+               ,,,,
+               ,,,,
+               )
diff --git a/src/sd_msg_struct/src/swf_cre_field_58d_comp.xml.m4 b/src/sd_msg_struct/src/swf_cre_field_58d_comp.xml.m4
new file mode 100644
index 0000000..5b7a7b4
--- /dev/null
+++ b/src/sd_msg_struct/src/swf_cre_field_58d_comp.xml.m4
@@ -0,0 +1,28 @@
+<!-- message permettant l'extraction et l'insertion de complements des blocs 58D (complements) -->
+<!-- message de mapping de complements des blocs 58D (autres champs) -->
+msg_object(swf_cre_field_58d_comp,,
+           complements,,,
+               0,148,Pad_Right,` ',` ',
+               ,,,,
+               ,,,,
+               ,
+           bq_beneficiaire_complements_ligne1,,,
+               ,35,,,,
+               /cristal/cre/donnees_cre/flux/donnees/bq_benef/complements/ligne[1],Strip_Right,` ',,
+               0,Pad_Right,` ',` ',
+               ,
+           bq_beneficiaire_complements_ligne2,,,
+               ,35,,,,
+               /cristal/cre/donnees_cre/flux/donnees/bq_benef/complements/ligne[2],Strip_Right,` ',,
+               1,Pad_Right,` ',` ',
+               ,
+           bq_beneficiaire_complements_ligne3,,,
+               ,35,,,,
+               /cristal/cre/donnees_cre/flux/donnees/bq_benef/complements/ligne[3],Strip_Right,` ',,
+               2,Pad_Right,` ',` ',
+               ,
+           bq_beneficiaire_complements_ligne4,,,
+               ,35,,,,
+               /cristal/cre/donnees_cre/flux/donnees/bq_benef/complements/ligne[4],Strip_Right,` ',,
+               3,Pad_Right,` ',` ',
+               )
diff --git a/src/sd_msg_struct/src/swf_cre_field_58x.xml.m4 b/src/sd_msg_struct/src/swf_cre_field_58x.xml.m4
new file mode 100644
index 0000000..d186aba
--- /dev/null
+++ b/src/sd_msg_struct/src/swf_cre_field_58x.xml.m4
@@ -0,0 +1,30 @@
+<!-- message permettant l'extraction et l'insertion des blocs 58 (champ_58) -->
+<!-- message de mapping des blocs 58 (autres champs) -->
+<!-- le champ bq_beneficiaire_complements est utilise pour le mapping du 58A -->
+<!-- il permet l'extraction et l'insertion de complements pour le mapping du 58D -->
+msg_object(swf_cre_field_58x,,
+           champ_58,,,
+               0,184,Pad_Right,` ',` ',
+               ,,,,
+               ,,,,
+               ,
+           bq_beneficiaire_no_de_compte,,,
+               0,34,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/bq_benef/compte,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           bq_beneficiaire_sens_du_compte,,,
+               34,1,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/bq_benef/sens,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           bq_beneficiaire_complements,,,
+               35,148,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/bq_benef/complements/ligne[1],Strip_Right,` ',` ',
+               ,,,,
+               ,
+           bq_beneficiaire_format,,,
+               183,1,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/bq_benef/format_champ,Strip_Right,` ',` ',
+               ,,,,
+               )
diff --git a/src/sd_msg_struct/src/swf_cre_field_59_ident.xml.m4 b/src/sd_msg_struct/src/swf_cre_field_59_ident.xml.m4
new file mode 100644
index 0000000..5a5c4b5
--- /dev/null
+++ b/src/sd_msg_struct/src/swf_cre_field_59_ident.xml.m4
@@ -0,0 +1,13 @@
+<!-- messages d'identification des blocs 59 -->
+msg_object(swf_cre_field_59a_fmt,,
+           cli_beneficiaire_format,`A',,
+               185,1,,,,
+               /cristal/cre/donnees_cre/flux/donnees/cli_benef/format_champ,,,,
+               ,,,,
+               )
+msg_object(swf_cre_field_59blanc_fmt,,
+           cli_beneficiaire_format,` ',,
+               185,1,,,,
+               /cristal/cre/donnees_cre/flux/donnees/cli_benef/format_champ,,,,
+               ,,,,
+               )
diff --git a/src/sd_msg_struct/src/swf_cre_field_59blanc_comp.xml.m4 b/src/sd_msg_struct/src/swf_cre_field_59blanc_comp.xml.m4
new file mode 100644
index 0000000..6940653
--- /dev/null
+++ b/src/sd_msg_struct/src/swf_cre_field_59blanc_comp.xml.m4
@@ -0,0 +1,28 @@
+<!-- message permettant l'extraction et l'insertion de identification des blocs 59blanc (champ identification)-->
+<!-- message de mapping de identification des blocs 59blanc(autres champs) -->
+msg_object(swf_cre_field_59blanc_comp,,
+           identification,,,
+               0,148,Pad_Right,` ',` ',
+               ,,,,
+               ,,,,
+               ,
+           cli_beneficiaire_identification_ligne1,,,
+               ,35,,,,
+               /cristal/cre/donnees_cre/flux/donnees/cli_benef/identification/ligne[1],Strip_Right,` ',,
+               0,Pad_Right,` ',` ',
+               ,
+           cli_beneficiaire_identification_ligne2,,,
+               ,35,,,,
+               /cristal/cre/donnees_cre/flux/donnees/cli_benef/identification/ligne[2],Strip_Right,` ',,
+               1,Pad_Right,` ',` ',
+               ,
+           cli_beneficiaire_identification_ligne3,,,
+               ,35,,,,
+               /cristal/cre/donnees_cre/flux/donnees/cli_benef/identification/ligne[3],Strip_Right,` ',,
+               2,Pad_Right,` ',` ',
+               ,
+           cli_beneficiaire_identification_ligne4,,,
+               ,35,,,,
+               /cristal/cre/donnees_cre/flux/donnees/cli_benef/identification/ligne[4],Strip_Right,` ',,
+               3,Pad_Right,` ',` ',
+               )
diff --git a/src/sd_msg_struct/src/swf_cre_field_59x.xml.m4 b/src/sd_msg_struct/src/swf_cre_field_59x.xml.m4
new file mode 100644
index 0000000..f2e63aa
--- /dev/null
+++ b/src/sd_msg_struct/src/swf_cre_field_59x.xml.m4
@@ -0,0 +1,30 @@
+<!-- message permettant l'extraction et l'insertion des blocs 59 (champ_59) -->
+<!-- message de mapping des blocs 59 (autres champs) -->
+<!-- le champ cli_beneficiaire_identification est utilise pour le mapping du 59A -->
+<!-- il permet l'extraction et l'insertion de identification pour le mapping du 59blanc -->
+msg_object(swf_cre_field_59x,,
+           champ_59,,,
+               0,186,Pad_Right,` ',` ',
+               ,,,,
+               ,,,,
+               ,
+           cli_beneficiaire_type,,,
+               0,3,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/cli_benef/type,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           cli_beneficiaire_coordonnees,,,
+               3,34,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/cli_benef/coordonnees,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           cli_beneficiaire_identification,,,
+               37,148,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/cli_benef/identification/ligne[1],Strip_Right,` ',` ',
+               ,,,,
+               ,
+           cli_beneficiaire_format,,,
+               185,1,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/cli_benef/format_champ,,,` ',
+               ,,,,
+               )
diff --git a/src/sd_msg_struct/src/swf_cre_field_70.xml.m4 b/src/sd_msg_struct/src/swf_cre_field_70.xml.m4
new file mode 100644
index 0000000..8870eaf
--- /dev/null
+++ b/src/sd_msg_struct/src/swf_cre_field_70.xml.m4
@@ -0,0 +1,28 @@
+<!-- message permettant l'extraction et l'insertion des blocs 70 (champ_70) -->
+<!-- message de mapping du bloc 70 (autres champs) -->
+msg_object(swf_cre_field_70,,
+           champ_70,,,
+               0,148,Pad_Right,` ',` ',
+               ,,,,
+               ,,,,
+               ,
+           motif_paiement_ligne1,,,
+               ,35,,,,
+               /cristal/cre/donnees_cre/flux/donnees/motif_paiement/ligne[1],Strip_Right,` ',,
+               0,Pad_Right,` ',` ',
+               ,
+           motif_paiement_ligne2,,,
+               ,35,,,,
+               /cristal/cre/donnees_cre/flux/donnees/motif_paiement/ligne[2],Strip_Right,` ',,
+               1,Pad_Right,` ',` ',
+               ,
+           motif_paiement_ligne3,,,
+               ,35,,,,
+               /cristal/cre/donnees_cre/flux/donnees/motif_paiement/ligne[3],Strip_Right,` ',,
+               2,Pad_Right,` ',` ',
+               ,
+           motif_paiement_ligne4,,,
+               ,35,,,,
+               /cristal/cre/donnees_cre/flux/donnees/motif_paiement/ligne[4],Strip_Right,` ',,
+               3,Pad_Right,` ',` ',
+               )
diff --git a/src/sd_msg_struct/src/swf_cre_field_72.xml.m4 b/src/sd_msg_struct/src/swf_cre_field_72.xml.m4
new file mode 100644
index 0000000..2479cab
--- /dev/null
+++ b/src/sd_msg_struct/src/swf_cre_field_72.xml.m4
@@ -0,0 +1,74 @@
+<!-- message permettant l'extraction et l'insertion des blocs 72 (champ_72) -->
+<!-- message de mapping du bloc 72 (autres champs) -->
+<!-- le champ champ_72_autres_lignes permet l'extraction et l'insertion globales des "autres lignes du champ 72" -->
+msg_object(swf_cre_field_72,,
+           champ_72,,,
+               0,276,Pad_Right,` ',` ',
+               ,,,,
+               ,,,,
+               ,
+           72_bq_interm_en_emission,,,
+               0,11,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/bic_inter_emet,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           72_code_routage,,,
+               11,1,,,` ',
+               /cristal/cre/donnees_cre/flux/donnees/code_rout,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           72_categorie,,,
+               12,1,,,` ',
+               /cristal/cre/donnees_cre/flux/donnees/categorie,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           72_qualite,,,
+               13,1,,,` ',
+               /cristal/cre/donnees_cre/flux/donnees/qualite,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           72_code_produit,,,
+               14,2,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/code_prod,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           72_identification_du_flux,,,
+               16,1,,,` ',
+               /cristal/cre/donnees_cre/flux/donnees/id_flux,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           72_code_commission_interbancaire,,,
+               17,2,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/code_commi,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           72_code_declaration_statistique,,,
+               19,1,,,` ',
+               /cristal/cre/donnees_cre/flux/donnees/code_stat,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           72_code_accord_bilateral,,,
+               20,4,Pad_Right,` ',` ',
+               /cristal/cre/donnees_cre/flux/donnees/code_acc_bi,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           72_taux_de_tva,,,
+               24,4,Pad_Left,`0',`0',
+               /cristal/cre/donnees_cre/flux/donnees/taux_tva,Strip_Num,`0',`0',
+               ,,,,
+               ,
+           72_montant_des_frais,,,
+               28,13,Pad_Left,`0',`0',
+               /cristal/cre/donnees_cre/flux/donnees/mnt_frais,Strip_Num,`0',`0',
+               ,,,,
+               ,
+           72_montant_de_tva_percu,,,
+               41,13,Pad_Left,`0',`0',
+               /cristal/cre/donnees_cre/flux/donnees/mnt_tva,Strip_Num,`0',`0',
+               ,,,,
+               ,
+           champ_72_autres_lignes,,,
+               54,222,Pad_Right,` ',` ',
+               ,,,,
+               ,,,,
+               )
diff --git a/src/sd_msg_struct/src/swf_cre_field_72_autres_lignes.xml.m4 b/src/sd_msg_struct/src/swf_cre_field_72_autres_lignes.xml.m4
new file mode 100644
index 0000000..0b0baef
--- /dev/null
+++ b/src/sd_msg_struct/src/swf_cre_field_72_autres_lignes.xml.m4
@@ -0,0 +1,38 @@
+<!-- message permettant l'extraction et l'insertion de autres_lignes des blocs 72 (champ champ_72_autres_lignes)-->
+<!-- message de mapping de autres_lignes des blocs 72(autres champs) -->
+msg_object(swf_cre_field_72_autres_lignes,,
+           champ_72_autres_lignes,,,
+               0,222,Pad_Right,` ',` ',
+               ,,,,
+               ,,,,
+               ,
+           lignes_72_ligne1,,,
+               ,35,,,,
+               /cristal/cre/donnees_cre/flux/donnees/lignes_72/ligne[1],Strip_Right,` ',,
+               0,Pad_Right,` ',` ',
+               ,
+           lignes_72_ligne2,,,
+               ,35,,,,
+               /cristal/cre/donnees_cre/flux/donnees/lignes_72/ligne[2],Strip_Right,` ',,
+               1,Pad_Right,` ',` ',
+               ,
+           lignes_72_ligne3,,,
+               ,35,,,,
+               /cristal/cre/donnees_cre/flux/donnees/lignes_72/ligne[3],Strip_Right,` ',,
+               2,Pad_Right,` ',` ',
+               ,
+           lignes_72_ligne4,,,
+               ,35,,,,
+               /cristal/cre/donnees_cre/flux/donnees/lignes_72/ligne[4],Strip_Right,` ',,
+               3,Pad_Right,` ',` ',
+               ,
+           lignes_72_ligne5,,,
+               ,35,,,,
+               /cristal/cre/donnees_cre/flux/donnees/lignes_72/ligne[5],Strip_Right,` ',,
+               4,Pad_Right,` ',` ',
+               ,
+           lignes_72_ligne6,,,
+               ,35,,,,
+               /cristal/cre/donnees_cre/flux/donnees/lignes_72/ligne[6],Strip_Right,` ',,
+               5,Pad_Right,` ',` ',
+               )
diff --git a/src/sd_msg_struct/src/swf_cre_field_77.xml.m4 b/src/sd_msg_struct/src/swf_cre_field_77.xml.m4
new file mode 100644
index 0000000..8f1be92
--- /dev/null
+++ b/src/sd_msg_struct/src/swf_cre_field_77.xml.m4
@@ -0,0 +1,23 @@
+<!-- message permettant l'extraction et l'insertion des blocs 77 (champ_77) -->
+<!-- message de mapping du bloc 77 (autres champs) -->
+msg_object(swf_cre_field_77,,
+           champ_77,,,
+               0,111,Pad_Right,` ',` ',
+               ,,,,
+               ,,,,
+               ,
+           77B_info_reglement_ligne1,,,
+               ,35,,,,
+               /cristal/cre/donnees_cre/flux/donnees/info_regl/ligne[1],Strip_Right,` ',,
+               0,Pad_Right,` ',` ',
+               ,
+           77B_info_reglement_ligne2,,,
+               ,35,,,,
+               /cristal/cre/donnees_cre/flux/donnees/info_regl/ligne[2],Strip_Right,` ',,
+               1,Pad_Right,` ',` ',
+               ,
+           77B_info_reglement_ligne3,,,
+               ,35,,,,
+               /cristal/cre/donnees_cre/flux/donnees/info_regl/ligne[3],Strip_Right,` ',,
+               2,Pad_Right,` ',` ',
+               )
diff --git a/src/sd_msg_struct/src/swf_field_13c.xml.m4 b/src/sd_msg_struct/src/swf_field_13c.xml.m4
new file mode 100644
index 0000000..2dc4293
--- /dev/null
+++ b/src/sd_msg_struct/src/swf_field_13c.xml.m4
@@ -0,0 +1,37 @@
+<!-- message de mapping des champs 13c -->
+msg_object(swf_field_13c,,
+           champ_13c,,,
+               0,114,Pad_Right,` ',,
+               ,,,,
+               ,,,,
+               ,
+           champ_13c_1,,,
+               0,19,Pad_Right,` ',,
+               /cristal/flux/donnees/champ13c[@occ="1"],Strip_Right,` ',` ',
+               ,,,,
+               ,
+           champ_13c_2,,,
+               19,19,Pad_Right,` ',,
+               /cristal/flux/donnees/champ13c[@occ="2"],Strip_Right,` ',` ',
+               ,,,,
+               ,
+           champ_13c_3,,,
+               38,19,Pad_Right,` ',,
+               /cristal/flux/donnees/champ13c[@occ="3"],Strip_Right,` ',` ',
+               ,,,,
+               ,
+           champ_13c_4,,,
+               57,19,Pad_Right,` ',,
+               /cristal/flux/donnees/champ13c[@occ="4"],Strip_Right,` ',` ',
+               ,,,,
+               ,
+           champ_13c_5,,,
+               76,19,Pad_Right,` ',,
+               /cristal/flux/donnees/champ13c[@occ="5"],Strip_Right,` ',` ',
+               ,,,,
+               ,
+           champ_13c_6,,,
+               95,19,Pad_Right,` ',,
+               /cristal/flux/donnees/champ13c[@occ="6"],Strip_Right,` ',` ',
+               ,,,,
+               )
diff --git a/src/sd_msg_struct/src/swf_field_50_ident.xml.m4 b/src/sd_msg_struct/src/swf_field_50_ident.xml.m4
new file mode 100644
index 0000000..fc81b85
--- /dev/null
+++ b/src/sd_msg_struct/src/swf_field_50_ident.xml.m4
@@ -0,0 +1,20 @@
+<!-- messages d'identification des blocs 50 -->
+msg_object(swf_field_50a_fmt,,
+           cli_donneur_ordre_format,`A',,
+               185,1,,,,
+               /cristal/flux/donnees/cli_don_ordre/format_champ,,,,
+               ,,,,
+               )
+msg_object(swf_field_50k_fmt,,
+           cli_donneur_ordre_format,`K',,
+               185,1,,,,
+               /cristal/flux/donnees/cli_don_ordre/format_champ,,,,
+               ,,,,
+               )
+<!-- dans mappath	retour de identifier	= unknown pour	xml -->
+msg_object(swf_field_50vide_fmt,,
+           cli_donneur_ordre_format,` ',,
+               185,1,,,,
+               ,,,,
+               ,,,,
+               )
diff --git a/src/sd_msg_struct/src/swf_field_50k_comp.xml.m4 b/src/sd_msg_struct/src/swf_field_50k_comp.xml.m4
new file mode 100644
index 0000000..31a7d40
--- /dev/null
+++ b/src/sd_msg_struct/src/swf_field_50k_comp.xml.m4
@@ -0,0 +1,28 @@
+<!-- message permettant	l'extraction et l'insertion de identification des blocs 50K	(champ identification) -->
+<!-- message de mapping	de	identification	des blocs 5OK (autres champs)	-->
+msg_object(swf_field_50k_comp,,
+           identification,,,
+               0,148,Pad_Right,` ',,
+               ,,,,
+               ,,,,
+               ,
+           cli_donneur_ordre_identification_ligne1,,,
+               ,35,,,,
+               /cristal/flux/donnees/cli_don_ordre/identification/ligne[1],Strip_Right,` ',` ',
+               0,Pad_Right,` ',,
+               ,
+           cli_donneur_ordre_identification_ligne2,,,
+               ,35,,,,
+               /cristal/flux/donnees/cli_don_ordre/identification/ligne[2],Strip_Right,` ',` ',
+               1,Pad_Right,` ',,
+               ,
+           cli_donneur_ordre_identification_ligne3,,,
+               ,35,,,,
+               /cristal/flux/donnees/cli_don_ordre/identification/ligne[3],Strip_Right,` ',` ',
+               2,Pad_Right,` ',,
+               ,
+           cli_donneur_ordre_identification_ligne4,,,
+               ,35,,,,
+               /cristal/flux/donnees/cli_don_ordre/identification/ligne[4],Strip_Right,` ',` ',
+               3,Pad_Right,` ',,
+               )
diff --git a/src/sd_msg_struct/src/swf_field_50x.xml.m4 b/src/sd_msg_struct/src/swf_field_50x.xml.m4
new file mode 100644
index 0000000..94a450e
--- /dev/null
+++ b/src/sd_msg_struct/src/swf_field_50x.xml.m4
@@ -0,0 +1,30 @@
+<!-- message permettant	l'extraction et l'insertion des blocs 50 (champ_50) -->
+<!-- message de mapping	des blocs 50 (autres	champs) -->
+<!-- le champ cli_donneur_ordre_identification est	utilise pour le mapping	du	50A -->
+<!-- il permet	l'extraction et l'insertion de identification pour	le	mapping du 50K	-->
+msg_object(swf_field_50x,,
+           champ_50,,,
+               0,186,Pad_Right,` ',,
+               ,,,,
+               ,,,,
+               ,
+           cli_donneur_ordre_type,,,
+               0,3,Pad_Right,` ',,
+               /cristal/flux/donnees/cli_don_ordre/type,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           cli_donneur_ordre_coordonnees,,,
+               3,34,Pad_Right,` ',,
+               /cristal/flux/donnees/cli_don_ordre/coordonnees,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           cli_donneur_ordre_identification,,,
+               37,148,Pad_Right,` ',,
+               /cristal/flux/donnees/cli_don_ordre/identification/ligne[1],Strip_Right,` ',` ',
+               ,,,,
+               ,
+           cli_donneur_ordre_format,,,
+               185,1,Pad_Right,` ',,
+               /cristal/flux/donnees/cli_don_ordre/format_champ,Strip_Right,` ',` ',
+               ,,,,
+               )
diff --git a/src/sd_msg_struct/src/swf_field_52_ident.xml.m4 b/src/sd_msg_struct/src/swf_field_52_ident.xml.m4
new file mode 100644
index 0000000..79ce738
--- /dev/null
+++ b/src/sd_msg_struct/src/swf_field_52_ident.xml.m4
@@ -0,0 +1,20 @@
+<!-- messages d'identification des blocs 52 -->
+msg_object(swf_field_52a_fmt,,
+           bq_donneuse_ordre_format,`A',,
+               183,1,,,,
+               /cristal/flux/donnees/bq_don_ordre/format_champ,,,,
+               ,,,,
+               )
+msg_object(swf_field_52d_fmt,,
+           bq_donneuse_ordre_format,`D',,
+               183,1,,,,
+               /cristal/flux/donnees/bq_don_ordre/format_champ,,,,
+               ,,,,
+               )
+<!-- dans mappath retour de identifier = unknown pour xml -->
+msg_object(swf_field_52vide_fmt,,
+           bq_donneuse_ordre_format,` ',,
+               183,1,,,,
+               ,,,,
+               ,,,,
+               )
diff --git a/src/sd_msg_struct/src/swf_field_52d_comp.xml.m4 b/src/sd_msg_struct/src/swf_field_52d_comp.xml.m4
new file mode 100644
index 0000000..fecbb44
--- /dev/null
+++ b/src/sd_msg_struct/src/swf_field_52d_comp.xml.m4
@@ -0,0 +1,28 @@
+<!-- message permettant l'extraction et l'insertion de complements des blocs 52D (complements) -->
+<!-- message de mapping de complements des blocs 52D (autres champs) -->
+msg_object(swf_field_52d_comp,,
+           complements,,,
+               0,148,Pad_Right,` ',,
+               ,,,,
+               ,,,,
+               ,
+           bq_donneuse_ordre_complements_ligne1,,,
+               ,35,,,,
+               /cristal/flux/donnees/bq_don_ordre/complements/ligne[1],Strip_Right,` ',` ',
+               0,Pad_Right,` ',,
+               ,
+           bq_donneuse_ordre_complements_ligne2,,,
+               ,35,,,,
+               /cristal/flux/donnees/bq_don_ordre/complements/ligne[2],Strip_Right,` ',` ',
+               1,Pad_Right,` ',,
+               ,
+           bq_donneuse_ordre_complements_ligne3,,,
+               ,35,,,,
+               /cristal/flux/donnees/bq_don_ordre/complements/ligne[3],Strip_Right,` ',` ',
+               2,Pad_Right,` ',,
+               ,
+           bq_donneuse_ordre_complements_ligne4,,,
+               ,35,,,,
+               /cristal/flux/donnees/bq_don_ordre/complements/ligne[4],Strip_Right,` ',` ',
+               3,Pad_Right,` ',,
+               )
diff --git a/src/sd_msg_struct/src/swf_field_52x.xml.m4 b/src/sd_msg_struct/src/swf_field_52x.xml.m4
new file mode 100644
index 0000000..5dff8a1
--- /dev/null
+++ b/src/sd_msg_struct/src/swf_field_52x.xml.m4
@@ -0,0 +1,30 @@
+<!-- message permettant l'extraction et l'insertion des blocs 52 (champ_52) -->
+<!-- message de mapping des blocs 52 (autres champs) -->
+<!-- le champ bq_donneuse_ordre_complements est utilise pour le mapping du 52A -->
+<!-- il permet l'extraction et l'insertion de complements pour le mapping du 52D -->
+msg_object(swf_field_52x,,
+           champ_52,,,
+               0,184,Pad_Right,` ',,
+               ,,,,
+               ,,,,
+               ,
+           bq_donneuse_ordre_no_de_compte,,,
+               0,34,Pad_Right,` ',,
+               /cristal/flux/donnees/bq_don_ordre/compte,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           bq_donneuse_ordre_sens_du_compte,,,
+               34,1,Pad_Right,` ',,
+               /cristal/flux/donnees/bq_don_ordre/sens,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           bq_donneuse_ordre_complements,,,
+               35,148,Pad_Right,` ',,
+               /cristal/flux/donnees/bq_don_ordre/complements/ligne[1],Strip_Right,` ',` ',
+               ,,,,
+               ,
+           bq_donneuse_ordre_format,,,
+               183,1,Pad_Right,` ',,
+               /cristal/flux/donnees/bq_don_ordre/format_champ,Strip_Right,` ',` ',
+               ,,,,
+               )
diff --git a/src/sd_msg_struct/src/swf_field_55_ident.xml.m4 b/src/sd_msg_struct/src/swf_field_55_ident.xml.m4
new file mode 100644
index 0000000..fd582f8
--- /dev/null
+++ b/src/sd_msg_struct/src/swf_field_55_ident.xml.m4
@@ -0,0 +1,26 @@
+<!-- messages d'identification des blocs 55 -->
+msg_object(swf_field_55a_fmt,,
+           bq_de_refin_format,`A',,
+               183,1,,,,
+               /cristal/flux/donnees/bq_du_refin/format_champ,,,,
+               ,,,,
+               )
+msg_object(swf_field_55b_fmt,,
+           bq_de_refin_format,`B',,
+               183,1,,,,
+               /cristal/flux/donnees/bq_du_refin/format_champ,,,,
+               ,,,,
+               )
+msg_object(swf_field_55d_fmt,,
+           bq_de_refin_format,`D',,
+               183,1,,,,
+               /cristal/flux/donnees/bq_du_refin/format_champ,,,,
+               ,,,,
+               )
+<!-- dans mappath	retour de identifier	= unknown pour	xml -->
+msg_object(swf_field_55vide_fmt,,
+           bq_de_refin_format,` ',,
+               183,1,,,,
+               ,,,,
+               ,,,,
+               )
diff --git a/src/sd_msg_struct/src/swf_field_55d_comp.xml.m4 b/src/sd_msg_struct/src/swf_field_55d_comp.xml.m4
new file mode 100644
index 0000000..f47141f
--- /dev/null
+++ b/src/sd_msg_struct/src/swf_field_55d_comp.xml.m4
@@ -0,0 +1,28 @@
+<!-- message permettant l'extraction et l'insertion de complements des blocs 55D (complements) -->
+<!-- message de mapping de complements des blocs 55D (autres champs) -->
+msg_object(swf_field_55d_comp,,
+           complements,,,
+               0,148,Pad_Right,` ',,
+               ,,,,
+               ,,,,
+               ,
+           bq_de_refin_complements_ligne1,,,
+               ,35,,,,
+               /cristal/flux/donnees/bq_du_refin/complements/ligne[1],Strip_Right,` ',` ',
+               0,Pad_Right,` ',,
+               ,
+           bq_de_refin_complements_ligne2,,,
+               ,35,,,,
+               /cristal/flux/donnees/bq_du_refin/complements/ligne[2],Strip_Right,` ',` ',
+               1,Pad_Right,` ',,
+               ,
+           bq_de_refin_complements_ligne3,,,
+               ,35,,,,
+               /cristal/flux/donnees/bq_du_refin/complements/ligne[3],Strip_Right,` ',` ',
+               2,Pad_Right,` ',,
+               ,
+           bq_de_refin_complements_ligne4,,,
+               ,35,,,,
+               /cristal/flux/donnees/bq_du_refin/complements/ligne[4],Strip_Right,` ',` ',
+               3,Pad_Right,` ',,
+               )
diff --git a/src/sd_msg_struct/src/swf_field_55x.xml.m4 b/src/sd_msg_struct/src/swf_field_55x.xml.m4
new file mode 100644
index 0000000..2d532ee
--- /dev/null
+++ b/src/sd_msg_struct/src/swf_field_55x.xml.m4
@@ -0,0 +1,30 @@
+<!-- message permettant	l'extraction et l'insertion des blocs 55 (champ_55) -->
+<!-- message de mapping	des blocs 55 (autres champs) -->
+<!-- le champ bq_de_refin_complements est utilise pour le mapping du 55A -->
+<!-- il permet l'extraction et l'insertion de complements pour	le	mapping du 55D -->
+msg_object(swf_field_55x,,
+           champ_55,,,
+               0,184,Pad_Right,` ',,
+               ,,,,
+               ,,,,
+               ,
+           bq_de_refin_no_de_compte,,,
+               0,34,Pad_Right,` ',,
+               /cristal/flux/donnees/bq_du_refin/compte,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           bq_de_refin_sens_du_compte,,,
+               34,1,Pad_Right,` ',,
+               /cristal/flux/donnees/bq_du_refin/sens,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           bq_de_refin_complements,,,
+               35,148,Pad_Right,` ',,
+               /cristal/flux/donnees/bq_du_refin/complements/ligne[1],Strip_Right,` ',` ',
+               ,,,,
+               ,
+           bq_de_refin_format,,,
+               183,1,Pad_Right,` ',,
+               /cristal/flux/donnees/bq_du_refin/format_champ,Strip_Right,` ',` ',
+               ,,,,
+               )
diff --git a/src/sd_msg_struct/src/swf_field_56_ident.xml.m4 b/src/sd_msg_struct/src/swf_field_56_ident.xml.m4
new file mode 100644
index 0000000..fb89e74
--- /dev/null
+++ b/src/sd_msg_struct/src/swf_field_56_ident.xml.m4
@@ -0,0 +1,20 @@
+<!-- messages d'identification des blocs 56 -->
+msg_object(swf_field_56a_fmt,,
+           bq_intermed_recep_format,`A',,
+               183,1,,,,
+               /cristal/flux/donnees/bq_inter_recep/format_champ,,,,
+               ,,,,
+               )
+msg_object(swf_field_56d_fmt,,
+           bq_intermed_recep_format,`D',,
+               183,1,,,,
+               /cristal/flux/donnees/bq_inter_recep/format_champ,,,,
+               ,,,,
+               )
+<!-- dans mappath	retour de identifier	= unknown pour	xml -->
+msg_object(swf_field_56vide_fmt,,
+           bq_intermed_recep_format,` ',,
+               183,1,,,,
+               ,,,,
+               ,,,,
+               )
diff --git a/src/sd_msg_struct/src/swf_field_56d_comp.xml.m4 b/src/sd_msg_struct/src/swf_field_56d_comp.xml.m4
new file mode 100644
index 0000000..0e6dc6a
--- /dev/null
+++ b/src/sd_msg_struct/src/swf_field_56d_comp.xml.m4
@@ -0,0 +1,28 @@
+<!-- message permettant l'extraction et l'insertion de complements des blocs 56D (complements) -->
+<!-- message de mapping de complements des blocs 56D (autres champs) -->
+msg_object(swf_field_56d_comp,,
+           complements,,,
+               0,148,Pad_Right,` ',,
+               ,,,,
+               ,,,,
+               ,
+           bq_intermed_recep_complements_ligne1,,,
+               ,35,,,,
+               /cristal/flux/donnees/bq_inter_recep/complements/ligne[1],Strip_Right,` ',` ',
+               0,Pad_Right,` ',,
+               ,
+           bq_intermed_recep_complements_ligne2,,,
+               ,35,,,,
+               /cristal/flux/donnees/bq_inter_recep/complements/ligne[2],Strip_Right,` ',` ',
+               1,Pad_Right,` ',,
+               ,
+           bq_intermed_recep_complements_ligne3,,,
+               ,35,,,,
+               /cristal/flux/donnees/bq_inter_recep/complements/ligne[3],Strip_Right,` ',` ',
+               2,Pad_Right,` ',,
+               ,
+           bq_intermed_recep_complements_ligne4,,,
+               ,35,,,,
+               /cristal/flux/donnees/bq_inter_recep/complements/ligne[4],Strip_Right,` ',` ',
+               3,Pad_Right,` ',,
+               )
diff --git a/src/sd_msg_struct/src/swf_field_56x.xml.m4 b/src/sd_msg_struct/src/swf_field_56x.xml.m4
new file mode 100644
index 0000000..18c6107
--- /dev/null
+++ b/src/sd_msg_struct/src/swf_field_56x.xml.m4
@@ -0,0 +1,30 @@
+<!-- message permettant l'extraction et l'insertion des blocs 56 (champ_56) -->
+<!-- message de mapping des blocs 56 (autres champs) -->
+<!-- le champ bq_intermed_recep_complements est utilise pour le mapping du 56A -->
+<!-- il permet l'extraction et l'insertion de complements pour le mapping du 56D -->
+msg_object(swf_field_56x,,
+           champ_56,,,
+               0,184,Pad_Right,` ',,
+               ,,,,
+               ,,,,
+               ,
+           bq_intermed_recep_no_de_compte,,,
+               0,34,Pad_Right,` ',,
+               /cristal/flux/donnees/bq_inter_recep/compte,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           bq_intermed_recep_sens_du_compte,,,
+               34,1,Pad_Right,` ',,
+               /cristal/flux/donnees/bq_inter_recep/sens,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           bq_intermed_recep_complements,,,
+               35,148,Pad_Right,` ',,
+               /cristal/flux/donnees/bq_inter_recep/complements/ligne[1],Strip_Right,` ',` ',
+               ,,,,
+               ,
+           bq_intermed_recep_format,,,
+               183,1,Pad_Right,` ',,
+               /cristal/flux/donnees/bq_inter_recep/format_champ,Strip_Right,` ',` ',
+               ,,,,
+               )
diff --git a/src/sd_msg_struct/src/swf_field_57_ident.xml.m4 b/src/sd_msg_struct/src/swf_field_57_ident.xml.m4
new file mode 100644
index 0000000..cc66aaf
--- /dev/null
+++ b/src/sd_msg_struct/src/swf_field_57_ident.xml.m4
@@ -0,0 +1,26 @@
+<!-- messages d'identification des blocs 57 -->
+msg_object(swf_field_57a_fmt,,
+           bq_du_beneficiaire_format,`A',,
+               183,1,,,,
+               /cristal/flux/donnees/bq_du_benef/format_champ,,,,
+               ,,,,
+               )
+msg_object(swf_field_57b_fmt,,
+           bq_du_beneficiaire_format,`B',,
+               183,1,,,,
+               /cristal/flux/donnees/bq_du_benef/format_champ,,,,
+               ,,,,
+               )
+msg_object(swf_field_57d_fmt,,
+           bq_du_beneficiaire_format,`D',,
+               183,1,,,,
+               /cristal/flux/donnees/bq_du_benef/format_champ,,,,
+               ,,,,
+               )
+<!-- dans mappath	retour de identifier	= unknown pour	xml -->
+msg_object(swf_field_57vide_fmt,,
+           bq_du_beneficiaire_format,` ',,
+               183,1,,,,
+               ,,,,
+               ,,,,
+               )
diff --git a/src/sd_msg_struct/src/swf_field_57d_comp.xml.m4 b/src/sd_msg_struct/src/swf_field_57d_comp.xml.m4
new file mode 100644
index 0000000..43977c9
--- /dev/null
+++ b/src/sd_msg_struct/src/swf_field_57d_comp.xml.m4
@@ -0,0 +1,28 @@
+<!-- message permettant l'extraction et l'insertion de complements des blocs 57D (complements) -->
+<!-- message de mapping de complements des blocs 57D (autres champs) -->
+msg_object(swf_field_57d_comp,,
+           complements,,,
+               0,148,Pad_Right,` ',,
+               ,,,,
+               ,,,,
+               ,
+           bq_du_beneficiaire_complements_ligne1,,,
+               ,35,,,,
+               /cristal/flux/donnees/bq_du_benef/complements/ligne[1],Strip_Right,` ',` ',
+               0,Pad_Right,` ',,
+               ,
+           bq_du_beneficiaire_complements_ligne2,,,
+               ,35,,,,
+               /cristal/flux/donnees/bq_du_benef/complements/ligne[2],Strip_Right,` ',` ',
+               1,Pad_Right,` ',,
+               ,
+           bq_du_beneficiaire_complements_ligne3,,,
+               ,35,,,,
+               /cristal/flux/donnees/bq_du_benef/complements/ligne[3],Strip_Right,` ',` ',
+               2,Pad_Right,` ',,
+               ,
+           bq_du_beneficiaire_complements_ligne4,,,
+               ,35,,,,
+               /cristal/flux/donnees/bq_du_benef/complements/ligne[4],Strip_Right,` ',` ',
+               3,Pad_Right,` ',,
+               )
diff --git a/src/sd_msg_struct/src/swf_field_57x.xml.m4 b/src/sd_msg_struct/src/swf_field_57x.xml.m4
new file mode 100644
index 0000000..74b2ea3
--- /dev/null
+++ b/src/sd_msg_struct/src/swf_field_57x.xml.m4
@@ -0,0 +1,30 @@
+<!-- message permettant l'extraction et l'insertion des blocs 57 (champ_57) -->
+<!-- message de mapping des blocs 57 (autres champs) -->
+<!-- le champ bq_du_beneficiaire_complements est utilise pour le mapping du 57A -->
+<!-- il permet l'extraction et l'insertion de complements pour le mapping du 57D -->
+msg_object(swf_field_57x,,
+           champ_57,,,
+               0,184,Pad_Right,` ',,
+               ,,,,
+               ,,,,
+               ,
+           bq_du_beneficiaire_no_de_compte,,,
+               0,34,Pad_Right,` ',,
+               /cristal/flux/donnees/bq_du_benef/compte,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           bq_du_beneficiaire_sens_du_compte,,,
+               34,1,Pad_Right,` ',,
+               /cristal/flux/donnees/bq_du_benef/sens,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           bq_du_beneficiaire_complements,,,
+               35,148,Pad_Right,` ',,
+               /cristal/flux/donnees/bq_du_benef/complements/ligne[1],Strip_Right,` ',` ',
+               ,,,,
+               ,
+           bq_du_beneficiaire_format,,,
+               183,1,Pad_Right,` ',,
+               /cristal/flux/donnees/bq_du_benef/format_champ,Strip_Right,` ',` ',
+               ,,,,
+               )
diff --git a/src/sd_msg_struct/src/swf_field_58_ident.xml.m4 b/src/sd_msg_struct/src/swf_field_58_ident.xml.m4
new file mode 100644
index 0000000..2da0e2c
--- /dev/null
+++ b/src/sd_msg_struct/src/swf_field_58_ident.xml.m4
@@ -0,0 +1,26 @@
+<!-- messages d'identification des blocs 58 -->
+msg_object(swf_field_58a_fmt,,
+           bq_beneficiaire_format,`A',,
+               183,1,,,,
+               /cristal/flux/donnees/bq_benef/format_champ,,,,
+               ,,,,
+               )
+msg_object(swf_field_58b_fmt,,
+           bq_beneficiaire_format,`B',,
+               183,1,,,,
+               /cristal/flux/donnees/bq_benef/format_champ,,,,
+               ,,,,
+               )
+msg_object(swf_field_58d_fmt,,
+           bq_beneficiaire_format,`D',,
+               183,1,,,,
+               /cristal/flux/donnees/bq_benef/format_champ,,,,
+               ,,,,
+               )
+<!-- dans mappath	retour de identifier	= unknown pour	xml -->
+msg_object(swf_field_58vide_fmt,,
+           bq_beneficiaire_format,` ',,
+               183,1,,,,
+               ,,,,
+               ,,,,
+               )
diff --git a/src/sd_msg_struct/src/swf_field_58d_comp.xml.m4 b/src/sd_msg_struct/src/swf_field_58d_comp.xml.m4
new file mode 100644
index 0000000..7bf1214
--- /dev/null
+++ b/src/sd_msg_struct/src/swf_field_58d_comp.xml.m4
@@ -0,0 +1,28 @@
+<!-- message permettant l'extraction et l'insertion de complements des blocs 58D (complements) -->
+<!-- message de mapping de complements des blocs 58D (autres champs) -->
+msg_object(swf_field_58d_comp,,
+           complements,,,
+               0,148,Pad_Right,` ',,
+               ,,,,
+               ,,,,
+               ,
+           bq_beneficiaire_complements_ligne1,,,
+               ,35,,,,
+               /cristal/flux/donnees/bq_benef/complements/ligne[1],Strip_Right,` ',` ',
+               0,Pad_Right,` ',,
+               ,
+           bq_beneficiaire_complements_ligne2,,,
+               ,35,,,,
+               /cristal/flux/donnees/bq_benef/complements/ligne[2],Strip_Right,` ',` ',
+               1,Pad_Right,` ',,
+               ,
+           bq_beneficiaire_complements_ligne3,,,
+               ,35,,,,
+               /cristal/flux/donnees/bq_benef/complements/ligne[3],Strip_Right,` ',` ',
+               2,Pad_Right,` ',,
+               ,
+           bq_beneficiaire_complements_ligne4,,,
+               ,35,,,,
+               /cristal/flux/donnees/bq_benef/complements/ligne[4],Strip_Right,` ',` ',
+               3,Pad_Right,` ',,
+               )
diff --git a/src/sd_msg_struct/src/swf_field_58x.xml.m4 b/src/sd_msg_struct/src/swf_field_58x.xml.m4
new file mode 100644
index 0000000..ec0d8b0
--- /dev/null
+++ b/src/sd_msg_struct/src/swf_field_58x.xml.m4
@@ -0,0 +1,30 @@
+<!-- message permettant l'extraction et l'insertion des blocs 58 (champ_58) -->
+<!-- message de mapping des blocs 58 (autres champs) -->
+<!-- le champ bq_beneficiaire_complements est utilise pour le mapping du 58A -->
+<!-- il permet l'extraction et l'insertion de complements pour le mapping du 58D -->
+msg_object(swf_field_58x,,
+           champ_58,,,
+               0,184,Pad_Right,` ',,
+               ,,,,
+               ,,,,
+               ,
+           bq_beneficiaire_no_de_compte,,,
+               0,34,Pad_Right,` ',,
+               /cristal/flux/donnees/bq_benef/compte,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           bq_beneficiaire_sens_du_compte,,,
+               34,1,Pad_Right,` ',,
+               /cristal/flux/donnees/bq_benef/sens,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           bq_beneficiaire_complements,,,
+               35,148,Pad_Right,` ',,
+               /cristal/flux/donnees/bq_benef/complements/ligne[1],Strip_Right,` ',` ',
+               ,,,,
+               ,
+           bq_beneficiaire_format,,,
+               183,1,Pad_Right,` ',,
+               /cristal/flux/donnees/bq_benef/format_champ,Strip_Right,` ',` ',
+               ,,,,
+               )
diff --git a/src/sd_msg_struct/src/swf_field_59_ident.xml.m4 b/src/sd_msg_struct/src/swf_field_59_ident.xml.m4
new file mode 100644
index 0000000..4074e79
--- /dev/null
+++ b/src/sd_msg_struct/src/swf_field_59_ident.xml.m4
@@ -0,0 +1,13 @@
+<!-- messages d'identification des blocs 59 -->
+msg_object(swf_field_59a_fmt,,
+           cli_beneficiaire_format,`A',,
+               185,1,,,,
+               /cristal/flux/donnees/cli_benef/format_champ,,,,
+               ,,,,
+               )
+msg_object(swf_field_59blanc_fmt,,
+           cli_beneficiaire_format,` ',,
+               185,1,,,,
+               /cristal/flux/donnees/cli_benef/format_champ,,,,
+               ,,,,
+               )
diff --git a/src/sd_msg_struct/src/swf_field_59blanc_comp.xml.m4 b/src/sd_msg_struct/src/swf_field_59blanc_comp.xml.m4
new file mode 100644
index 0000000..386e7b8
--- /dev/null
+++ b/src/sd_msg_struct/src/swf_field_59blanc_comp.xml.m4
@@ -0,0 +1,28 @@
+<!-- message permettant l'extraction et l'insertion de identification des blocs 59blanc (champ identification)-->
+<!-- message de mapping de identification des blocs 59blanc(autres champs) -->
+msg_object(swf_field_59blanc_comp,,
+           identification,,,
+               0,148,Pad_Right,` ',,
+               ,,,,
+               ,,,,
+               ,
+           cli_beneficiaire_identification_ligne1,,,
+               ,35,,,,
+               /cristal/flux/donnees/cli_benef/identification/ligne[1],Strip_Right,` ',` ',
+               0,Pad_Right,` ',,
+               ,
+           cli_beneficiaire_identification_ligne2,,,
+               ,35,,,,
+               /cristal/flux/donnees/cli_benef/identification/ligne[2],Strip_Right,` ',` ',
+               1,Pad_Right,` ',,
+               ,
+           cli_beneficiaire_identification_ligne3,,,
+               ,35,,,,
+               /cristal/flux/donnees/cli_benef/identification/ligne[3],Strip_Right,` ',` ',
+               2,Pad_Right,` ',,
+               ,
+           cli_beneficiaire_identification_ligne4,,,
+               ,35,,,,
+               /cristal/flux/donnees/cli_benef/identification/ligne[4],Strip_Right,` ',` ',
+               3,Pad_Right,` ',,
+               )
diff --git a/src/sd_msg_struct/src/swf_field_59x.xml.m4 b/src/sd_msg_struct/src/swf_field_59x.xml.m4
new file mode 100644
index 0000000..3f0e78a
--- /dev/null
+++ b/src/sd_msg_struct/src/swf_field_59x.xml.m4
@@ -0,0 +1,30 @@
+<!-- message permettant l'extraction et l'insertion des blocs 59 (champ_59) -->
+<!-- message de mapping des blocs 59 (autres champs) -->
+<!-- le champ cli_beneficiaire_identification est utilise pour le mapping du 59A -->
+<!-- il permet l'extraction et l'insertion de identification pour le mapping du 59blanc -->
+msg_object(swf_field_59x,,
+           champ_59,,,
+               0,186,Pad_Right,` ',,
+               ,,,,
+               ,,,,
+               ,
+           cli_beneficiaire_type,,,
+               0,3,Pad_Right,` ',,
+               /cristal/flux/donnees/cli_benef/type,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           cli_beneficiaire_coordonnees,,,
+               3,34,Pad_Right,` ',,
+               /cristal/flux/donnees/cli_benef/coordonnees,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           cli_beneficiaire_identification,,,
+               37,148,Pad_Right,` ',,
+               /cristal/flux/donnees/cli_benef/identification/ligne[1],Strip_Right,` ',` ',
+               ,,,,
+               ,
+           cli_beneficiaire_format,,,
+               185,1,Pad_Right,` ',,
+               /cristal/flux/donnees/cli_benef/format_champ,,,` ',
+               ,,,,
+               )
diff --git a/src/sd_msg_struct/src/swf_field_70.xml.m4 b/src/sd_msg_struct/src/swf_field_70.xml.m4
new file mode 100644
index 0000000..28dbf3f
--- /dev/null
+++ b/src/sd_msg_struct/src/swf_field_70.xml.m4
@@ -0,0 +1,28 @@
+<!-- message permettant l'extraction et l'insertion des blocs 70 (champ_70) -->
+<!-- message de mapping du bloc 70 (autres champs) -->
+msg_object(swf_field_70,,
+           champ_70,,,
+               0,148,Pad_Right,` ',,
+               ,,,,
+               ,,,,
+               ,
+           motif_paiement_ligne1,,,
+               ,35,,,,
+               /cristal/flux/donnees/motif_paiement/ligne[1],Strip_Right,` ',` ',
+               0,Pad_Right,` ',,
+               ,
+           motif_paiement_ligne2,,,
+               ,35,,,,
+               /cristal/flux/donnees/motif_paiement/ligne[2],Strip_Right,` ',` ',
+               1,Pad_Right,` ',,
+               ,
+           motif_paiement_ligne3,,,
+               ,35,,,,
+               /cristal/flux/donnees/motif_paiement/ligne[3],Strip_Right,` ',` ',
+               2,Pad_Right,` ',,
+               ,
+           motif_paiement_ligne4,,,
+               ,35,,,,
+               /cristal/flux/donnees/motif_paiement/ligne[4],Strip_Right,` ',` ',
+               3,Pad_Right,` ',,
+               )
diff --git a/src/sd_msg_struct/src/swf_field_72.xml.m4 b/src/sd_msg_struct/src/swf_field_72.xml.m4
new file mode 100644
index 0000000..736f6b7
--- /dev/null
+++ b/src/sd_msg_struct/src/swf_field_72.xml.m4
@@ -0,0 +1,74 @@
+<!-- message permettant l'extraction et l'insertion des blocs 72 (champ_72) -->
+<!-- message de mapping du bloc 72 (autres champs) -->
+<!-- le champ champ_72_autres_lignes permet l'extraction et l'insertion globales des "autres lignes du champ 72" -->
+msg_object(swf_field_72,,
+           champ_72,,,
+               0,276,Pad_Right,` ',,
+               ,,,,
+               ,,,,
+               ,
+           72_bq_interm_en_emission,,,
+               0,11,Pad_Right,` ',,
+               /cristal/flux/donnees/bic_inter_emet,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           72_code_routage,,,
+               11,1,,,,
+               /cristal/flux/donnees/code_rout,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           72_categorie,,,
+               12,1,,,,
+               /cristal/flux/donnees/categorie,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           72_qualite,,,
+               13,1,,,,
+               /cristal/flux/donnees/qualite,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           72_code_produit,,,
+               14,2,Pad_Right,` ',,
+               /cristal/flux/donnees/code_prod,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           72_identification_du_flux,,,
+               16,1,,,,
+               /cristal/flux/donnees/id_flux,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           72_code_commission_interbancaire,,,
+               17,2,Pad_Right,` ',,
+               /cristal/flux/donnees/code_commi,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           72_code_declaration_statistique,,,
+               19,1,,,,
+               /cristal/flux/donnees/code_stat,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           72_code_accord_bilateral,,,
+               20,4,Pad_Right,` ',,
+               /cristal/flux/donnees/code_acc_bi,Strip_Right,` ',` ',
+               ,,,,
+               ,
+           72_taux_de_tva,,,
+               24,4,Pad_Left,`0',,
+               /cristal/flux/donnees/taux_tva,Strip_Num,`0',`0',
+               ,,,,
+               ,
+           72_montant_des_frais,,,
+               28,13,Pad_Left,`0',,
+               /cristal/flux/donnees/mnt_frais,Strip_Num,`0',`0',
+               ,,,,
+               ,
+           72_montant_de_tva_percu,,,
+               41,13,Pad_Left,`0',,
+               /cristal/flux/donnees/mnt_tva,Strip_Num,`0',`0',
+               ,,,,
+               ,
+           champ_72_autres_lignes,,,
+               54,222,Pad_Right,` ',,
+               ,,,,
+               ,,,,
+               )
diff --git a/src/sd_msg_struct/src/swf_field_72_autres_lignes.xml.m4 b/src/sd_msg_struct/src/swf_field_72_autres_lignes.xml.m4
new file mode 100644
index 0000000..8657118
--- /dev/null
+++ b/src/sd_msg_struct/src/swf_field_72_autres_lignes.xml.m4
@@ -0,0 +1,38 @@
+<!-- message permettant l'extraction et l'insertion de autres_lignes des blocs 72 (champ champ_72_autres_lignes)-->
+<!-- message de mapping de autres_lignes des blocs 72(autres champs) -->
+msg_object(swf_field_72_autres_lignes,,
+           champ_72_autres_lignes,,,
+               0,222,Pad_Right,` ',,
+               ,,,,
+               ,,,,
+               ,
+           lignes_72_ligne1,,,
+               ,35,,,,
+               /cristal/flux/donnees/lignes_72/ligne[1],Strip_Right,` ',` ',
+               0,Pad_Right,` ',,
+               ,
+           lignes_72_ligne2,,,
+               ,35,,,,
+               /cristal/flux/donnees/lignes_72/ligne[2],Strip_Right,` ',` ',
+               1,Pad_Right,` ',,
+               ,
+           lignes_72_ligne3,,,
+               ,35,,,,
+               /cristal/flux/donnees/lignes_72/ligne[3],Strip_Right,` ',` ',
+               2,Pad_Right,` ',,
+               ,
+           lignes_72_ligne4,,,
+               ,35,,,,
+               /cristal/flux/donnees/lignes_72/ligne[4],Strip_Right,` ',` ',
+               3,Pad_Right,` ',,
+               ,
+           lignes_72_ligne5,,,
+               ,35,,,,
+               /cristal/flux/donnees/lignes_72/ligne[5],Strip_Right,` ',` ',
+               4,Pad_Right,` ',,
+               ,
+           lignes_72_ligne6,,,
+               ,35,,,,
+               /cristal/flux/donnees/lignes_72/ligne[6],Strip_Right,` ',` ',
+               5,Pad_Right,` ',,
+               )
diff --git a/src/sd_msg_struct/src/swf_field_77.xml.m4 b/src/sd_msg_struct/src/swf_field_77.xml.m4
new file mode 100644
index 0000000..7293a22
--- /dev/null
+++ b/src/sd_msg_struct/src/swf_field_77.xml.m4
@@ -0,0 +1,23 @@
+<!-- message permettant l'extraction et l'insertion des blocs 77 (champ_77) -->
+<!-- message de mapping du bloc 77 (autres champs) -->
+msg_object(swf_field_77,,
+           champ_77,,,
+               0,111,Pad_Right,` ',,
+               ,,,,
+               ,,,,
+               ,
+           77B_info_reglement_ligne1,,,
+               ,35,,,,
+               /cristal/flux/donnees/info_regl/ligne[1],Strip_Right,` ',` ',
+               0,Pad_Right,` ',,
+               ,
+           77B_info_reglement_ligne2,,,
+               ,35,,,,
+               /cristal/flux/donnees/info_regl/ligne[2],Strip_Right,` ',` ',
+               1,Pad_Right,` ',,
+               ,
+           77B_info_reglement_ligne3,,,
+               ,35,,,,
+               /cristal/flux/donnees/info_regl/ligne[3],Strip_Right,` ',` ',
+               2,Pad_Right,` ',,
+               )
diff --git a/src/sd_msgmap_struct/src/Makefile b/src/sd_msgmap_struct/src/Makefile
new file mode 100644
index 0000000..ad052dc
--- /dev/null
+++ b/src/sd_msgmap_struct/src/Makefile
@@ -0,0 +1,65 @@
+#------------------------------------------------------------------------------
+# Local Makefile
+#------------------------------------------------------------------------------
+# $Workfile:   Makefile  $                                                     
+#------------------------------------------------------------------------------
+# $Author: agibert $                                                        
+# $Date: 2008/11/12 02:25:24 $                                             
+# $Revision: 1.1 $                                                         
+# $Label:  $                                                           
+#------------------------------------------------------------------------------
+
+#------------------------------------------------------------------------------
+# IMR - Interlinking Message Router                                            
+# Copyright (C) 2005 Arnaud G. Gibert & Others (See ReadMe.txt)                
+# mailto:arnaud@rx3.net                                                        
+# http://www.rx3.org/dvp/?dvp=imr                                              
+#------------------------------------------------------------------------------
+# This file is part of IMR                                                     
+#                                                                              
+# This program is free software; you can redistribute it and/or                
+# modify it under the terms of the GNU General Public License                  
+# as published by the Free Software Foundation; either version 2               
+# of the License, or (at your option) any later version.                       
+#                                                                              
+# This program is distributed in the hope that it will be useful,              
+# but WITHOUT ANY WARRANTY; without even the implied warranty of               
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                
+# GNU General Public License for more details.                                 
+#                                                                              
+# You should have received a copy of the GNU General Public License            
+# along with this program; if not, write to the Free Software Foundation,      
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.          
+#------------------------------------------------------------------------------
+
+
+
+
+
+#------------------------------------------------------------------------------
+# Var include
+#------------------------------------------------------------------------------
+
+include ../../Makefile_var.mk
+
+
+
+#------------------------------------------------------------------------------
+# Variables
+#------------------------------------------------------------------------------
+
+TARGET=		sd_msgmap_struct.xml
+
+OBJ_RAW=	sd_msgmap_struct.xml.m4
+
+EXTRA_INC=	
+
+EXTRA_LIB=	
+
+
+
+#------------------------------------------------------------------------------
+# Rule include
+#------------------------------------------------------------------------------
+
+include ../../Makefile_rule.mk
diff --git a/src/sd_msgmap_struct/src/cre.xml.m4 b/src/sd_msgmap_struct/src/cre.xml.m4
new file mode 100644
index 0000000..f634abe
--- /dev/null
+++ b/src/sd_msgmap_struct/src/cre.xml.m4
@@ -0,0 +1,127 @@
+<!-- mapping de l'entete communs des cre fixed <-> xml -->
+msgmap_object(crt_cre_header-crt_cre_header,crt_cre_header,crt_cre_header,
+				code_banque_ctrl,code_banque_ctrl,
+				reference_du_flux,reference_du_flux,
+				type_cre,type_cre,
+				horodatage_pf_p,horodatage_pf_p,
+				code_utilisateur_final,code_utilisateur_final,
+				code_utilisateur_back_office,code_utilisateur_back_office,
+				code_guichet_pf_p,code_guichet_pf_p,
+				commentaire,commentaire,
+				code_utilisateur_final_initial,code_utilisateur_final_initial,
+				code_utilisateur_back_office_initial,code_utilisateur_back_office_initial,
+				code_guichet_pf_p_initial,code_guichet_pf_p_initial,
+				indicateur_doublon,indicateur_doublon)
+<!-- mapping de l'entete communs des cre xml->fixed -->
+<!-- concernent les champs definis en fixed et pas en xml -->
+msgmap_object(crt_cre_header-crt_cre_header_special_fixed,crt_cre_header,crt_cre_header,
+				zone_reservee,zone_reservee,
+				horodatage_13c,horodatage_13c,
+				heure_d_echeance_cls,heure_d_echeance_cls,
+				indic_troncature_13c,indic_troncature_13c,
+				zone_reservee2,zone_reservee2)
+<!-- mapping de l'entete des cre sur vgm/or emis fixed <-> xml -->
+msgmap_object(crt_cre_flux_emis_header-crt_cre_flux_emis_header,crt_cre_flux_emis_header,crt_cre_flux_emis_header,
+				reference_emetteur,reference_emetteur,
+				indicateur_provenance_flux,indicateur_provenance_flux,
+				code_operateur_saisie,code_operateur_saisie,
+				indicateur_de_synchronisation,indicateur_de_synchronisation,
+				code_statut_cri,code_statut_cri,
+				code_raison,code_raison,
+				heure_statut_cri,heure_statut_cri,
+				num_sequence_fifo,num_sequence_fifo,
+				libelle_cre,libelle_cre,
+				type_flux,type_flux,
+				libelle_motif,libelle_motif,
+				code_responsable,code_responsable,
+				ref_util,ref_util,
+				code_util,code_util,
+				num_fic_origine,num_fic_origine,
+				horodatage_pf_p,horodatage_pf_p,
+				ref_annonce,ref_annonce,
+				bic_emetteur,bic_emetteur,
+				bic_recepteur,bic_recepteur,
+				bic_recepteur_initial,bic_recepteur_initial,
+				canal_de_routage,canal_de_routage,
+				canal_de_routage_initial,canal_de_routage_initial,
+				canal_de_routage_final,canal_de_routage_final,
+				ref_emetteur_cri,ref_emetteur_cri,
+				heure_d_echeance_champ_113,heure_d_echeance_champ_113)
+<!-- mapping de l'entete des cre sur vgm/or recus fixed <-> xml -->
+msgmap_object(crt_cre_flux_recu_header-crt_cre_flux_recu_header,crt_cre_flux_recu_header,crt_cre_flux_recu_header,
+				reference_emetteur,reference_emetteur,
+				indicateur_de_synchronisation,indicateur_de_synchronisation,
+				code_statut_cri,code_statut_cri,
+				code_raison,code_raison,
+				heure_statut_cri,heure_statut_cri,
+				num_sequence_fifo,num_sequence_fifo,
+				libelle_cre,libelle_cre,
+				type_flux,type_flux,
+				libelle_motif,libelle_motif,
+				horodatage_pf_p,horodatage_pf_p,
+				ref_util_virement,ref_util_virement,
+				ref_annonce,ref_annonce,
+				bic_emetteur,bic_emetteur,
+				bic_recepteur,bic_recepteur,
+				canal_de_routage,canal_de_routage,
+				rib_recep,rib_recep,
+				heure_d_echeance_champ_113,heure_d_echeance_champ_113)
+<!-- mapping de l'entete des cre de rejet fixed <-> xml -->
+			<!-- A VOIR xml sans fixed -->
+			<!--<fieldmap>
+				<inputfield>detail_motif_rej</inputfield>
+				<outputfield>detail_motif_rej</outputfield>
+			</fieldmap>-->
+msgmap_object(crt_cre_rejet_header-crt_cre_rejet_header,crt_cre_rejet_header,crt_cre_rejet_header,
+				libelle_cre,libelle_cre,
+				type_flux,type_flux,
+				code_rejet_motif,code_rejet_motif,
+				libelle_motif,libelle_motif,
+				horodatage_pf_p,horodatage_pf_p)
+<!-- mapping de l'entete specifique des flux contenus dans les cre de rejet fixed <-> xml -->
+msgmap_object(crt_cre_flux_stlm_header-crt_cre_flux_stlm_header,crt_cre_flux_stlm_header,crt_cre_flux_stlm_header,
+				ref_util,ref_util,
+				ind_ann_gen,ind_ann_gen,
+				ref_ann,ref_ann,
+				type_ann,type_ann,
+				ref_ann_init,ref_ann_init,
+				code_acc_int,code_acc_int,
+				bic_emetteur,bic_emetteur,
+				bic_recepteur,bic_recepteur,
+				ident_bq_desti,ident_bq_desti,
+				bic_bq_desti,bic_bq_desti,
+				priorite_reseau,priorite_reseau,
+				canal_de_routage,canal_de_routage,
+				heure_d_echeance_champ_113,heure_d_echeance_champ_113,
+				heure_emission_tot,heure_emission_tot,
+				heure_emission_tard,heure_emission_tard)
+<!-- mapping de l'entete communs des cre fixed <-> xml -->
+msgmap_object(crt_cre_flux_header-crt_cre_flux_header,crt_cre_flux_header,crt_cre_flux_header,
+				code_banque_ctrl,code_banque_ctrl,
+				type_flux,type_flux,
+				code_util,code_util,
+				code_guichet_pf_p,code_guichet_pf_p,
+				authentification,authentification,
+				num_fichier,num_fichier,
+				responsable,responsable,
+				commentaire,commentaire,
+				r1,r1,
+				r2,r2,
+				r3,r3,
+				r4,r4,
+				service_desti,service_desti,
+				service_desti_initial,service_desti_initial,
+				canal_final,canal_final,
+				bic_cri_recep,bic_cri_recep,
+				code_pays_desti,code_pays_desti,
+				ident_acteur,ident_acteur,
+				code_siege_emet,code_siege_emet,
+				ref_denotage,ref_denotage,
+				code_appli_routage,code_appli_routage,
+				code_siege_routage,code_siege_routage,
+				ref_unique_interne,ref_unique_interne,
+				heure_debit_rtgs_emet,heure_debit_rtgs_emet,
+				ident_pdse,ident_pdse,
+				nature_operation,nature_operation,
+				heure_ech_cls,heure_ech_cls,
+				zone_reservee,zone_reservee)
diff --git a/src/sd_msgmap_struct/src/cre_field_13c.xml.m4 b/src/sd_msgmap_struct/src/cre_field_13c.xml.m4
new file mode 100644
index 0000000..f09372d
--- /dev/null
+++ b/src/sd_msgmap_struct/src/cre_field_13c.xml.m4
@@ -0,0 +1,37 @@
+<!-- mapping bloc 13c fixed <-> xml -->
+msgmap_object(swf_cre_field_13c-swf_cre_field_13c,swf_cre_field_13c,swf_cre_field_13c,
+				champ_13c_1,champ_13c_1,
+				champ_13c_2,champ_13c_2,
+				champ_13c_3,champ_13c_3,
+				champ_13c_4,champ_13c_4,
+				champ_13c_5,champ_13c_5,
+				champ_13c_6,champ_13c_6)
+<!--  DEBUT Traitement du bloc 13C -->
+msgmap_object(swf_cre_field_13c-swf_cre_field_13c_occ6,swf_cre_field_13c,swf_cre_field_occ13x,
+				champ_13c_6,occ13)
+msgmap_object(swf_cre_field_13c-swf_cre_field_13c_occ5,swf_cre_field_13c,swf_cre_field_occ13x,
+				champ_13c_5,occ13)
+msgmap_object(swf_cre_field_13c-swf_cre_field_13c_occ4,swf_cre_field_13c,swf_cre_field_occ13x,
+				champ_13c_4,occ13)
+msgmap_object(swf_cre_field_13c-swf_cre_field_13c_occ3,swf_cre_field_13c,swf_cre_field_occ13x,
+				champ_13c_3,occ13)
+msgmap_object(swf_cre_field_13c-swf_cre_field_13c_occ2,swf_cre_field_13c,swf_cre_field_occ13x,
+				champ_13c_2,occ13)
+msgmap_object(swf_cre_field_13c-crt_cre_flux_stlm_avec13c,swf_cre_field_13c,swf_cre_field_occ13x,
+				champ_13c_1,occ13)
+msgmap_object(swf_cre_field_occ13c_sndtime-crt_cre_header,swf_cre_field_occ13x,crt_cre_header,
+				value_occ13,horodatage_13c)
+msgmap_object(swf_cre_field_occ13c_clstime-crt_cre_header,swf_cre_field_occ13x,crt_cre_header,
+				value_occ13,heure_d_echeance_cls)
+msgmap_object(swf_cre_field_occ13c_tronc-crt_cre_header,swf_cre_field_occ13x,crt_cre_header,
+				champ_bidon,indic_troncature_13c)
+<!--  FIN Traitement du bloc 13C -->
+<!-- insertion du bloc 13c (dans un virement bancaire) fixed -> fixed -->
+msgmap_object(swf_cre_field_13c-crt_cre_flux_stlm_bk,swf_cre_field_13c,crt_cre_flux_stlm_bk,
+				champ_13c,champ_13c)
+<!-- insertion du bloc 13c (a partir d'un virement de clientele sans champ 55) fixed -> fixed -->
+msgmap_object(swf_cre_field_13c-cre_cus_champ_13c_sans55,swf_cre_field_13c,cre_cus_champ_13c_sans55,
+				champ_13c,champ_13c)
+<!-- insertion du bloc 13c (a partir d'un virement de clientele avec champ 55) fixed -> fixed -->
+msgmap_object(swf_cre_field_13c-cre_cus_champ_13c_avec55,swf_cre_field_13c,cre_cus_champ_13c_avec55,
+				champ_13c,champ_13c)
diff --git a/src/sd_msgmap_struct/src/cre_field_50.xml.m4 b/src/sd_msgmap_struct/src/cre_field_50.xml.m4
new file mode 100644
index 0000000..a6a1aa4
--- /dev/null
+++ b/src/sd_msgmap_struct/src/cre_field_50.xml.m4
@@ -0,0 +1,23 @@
+<!-- mapping bloc 50A fixed <-> xml -->
+msgmap_object(swf_cre_field_50x-swf_cre_field_50x-format_a,swf_cre_field_50x,swf_cre_field_50x,
+				cli_donneur_ordre_type,cli_donneur_ordre_type,
+				cli_donneur_ordre_coordonnees,cli_donneur_ordre_coordonnees,
+				cli_donneur_ordre_identification,cli_donneur_ordre_identification,
+				cli_donneur_ordre_format,cli_donneur_ordre_format)
+<!-- mapping bloc 50k (hors identification) fixed <-> xml -->
+msgmap_object(swf_cre_field_50x-swf_cre_field_50x-format_k,swf_cre_field_50x,swf_cre_field_50x,
+				cli_donneur_ordre_type,cli_donneur_ordre_type,
+				cli_donneur_ordre_coordonnees,cli_donneur_ordre_coordonnees,
+				cli_donneur_ordre_format,cli_donneur_ordre_format)
+<!-- mapping de identification du bloc 50k delimited <-> xml -->
+msgmap_object(swf_cre_field_50k_comp-swf_cre_field_50k_comp,swf_cre_field_50k_comp,swf_cre_field_50k_comp,
+				cli_donneur_ordre_identification_ligne1,cli_donneur_ordre_identification_ligne1,
+				cli_donneur_ordre_identification_ligne2,cli_donneur_ordre_identification_ligne2,
+				cli_donneur_ordre_identification_ligne3,cli_donneur_ordre_identification_ligne3,
+				cli_donneur_ordre_identification_ligne4,cli_donneur_ordre_identification_ligne4)
+<!-- insertion de identification dans bloc 50k fixed -> fixed -->
+msgmap_object(swf_cre_field_50k_comp-swf_cre_field_50x,swf_cre_field_50k_comp,swf_cre_field_50x,
+				identification,cli_donneur_ordre_identification)
+<!-- insertion du bloc 50 (dans un virement de clientele) fixed -> fixed -->
+msgmap_object(swf_cre_field_50x-crt_cre_flux_stlm_cus,swf_cre_field_50x,crt_cre_flux_stlm_cus,
+				champ_50,champ_50)
diff --git a/src/sd_msgmap_struct/src/cre_field_52.xml.m4 b/src/sd_msgmap_struct/src/cre_field_52.xml.m4
new file mode 100644
index 0000000..3ada35b
--- /dev/null
+++ b/src/sd_msgmap_struct/src/cre_field_52.xml.m4
@@ -0,0 +1,26 @@
+<!-- mapping bloc 52A fixed <-> xml	-->
+msgmap_object(swf_cre_field_52x-swf_cre_field_52x-format_a,swf_cre_field_52x,swf_cre_field_52x,
+				bq_donneuse_ordre_no_de_compte,bq_donneuse_ordre_no_de_compte,
+				bq_donneuse_ordre_sens_du_compte,bq_donneuse_ordre_sens_du_compte,
+				bq_donneuse_ordre_complements,bq_donneuse_ordre_complements,
+				bq_donneuse_ordre_format,bq_donneuse_ordre_format)
+<!-- mapping bloc 52D (hors complements) fixed <->	xml -->
+msgmap_object(swf_cre_field_52x-swf_cre_field_52x-format_d,swf_cre_field_52x,swf_cre_field_52x,
+				bq_donneuse_ordre_no_de_compte,bq_donneuse_ordre_no_de_compte,
+				bq_donneuse_ordre_sens_du_compte,bq_donneuse_ordre_sens_du_compte,
+				bq_donneuse_ordre_format,bq_donneuse_ordre_format)
+<!-- mapping de complements du bloc 52D delimited <->	xml -->
+msgmap_object(swf_cre_field_52d_comp-swf_cre_field_52d_comp,swf_cre_field_52d_comp,swf_cre_field_52d_comp,
+				bq_donneuse_ordre_complements_ligne1,bq_donneuse_ordre_complements_ligne1,
+				bq_donneuse_ordre_complements_ligne2,bq_donneuse_ordre_complements_ligne2,
+				bq_donneuse_ordre_complements_ligne3,bq_donneuse_ordre_complements_ligne3,
+				bq_donneuse_ordre_complements_ligne4,bq_donneuse_ordre_complements_ligne4)
+<!-- insertion de complements dans bloc 52D fixed -> fixed -->
+msgmap_object(swf_cre_field_52d_comp-swf_cre_field_52x,swf_cre_field_52d_comp,swf_cre_field_52x,
+				complements,bq_donneuse_ordre_complements)
+<!-- insertion du bloc 52 (dans un virement bancaire) fixed -> fixed -->
+msgmap_object(swf_cre_field_52x-crt_cre_flux_stlm_bk,swf_cre_field_52x,crt_cre_flux_stlm_bk,
+				champ_52,champ_52)
+<!-- insertion	du	bloc 52 (dans un virement de clientele) fixed -> fixed -->
+msgmap_object(swf_cre_field_52x-crt_cre_flux_stlm_cus,swf_cre_field_52x,crt_cre_flux_stlm_cus,
+				champ_52,champ_52)
diff --git a/src/sd_msgmap_struct/src/cre_field_55.xml.m4 b/src/sd_msgmap_struct/src/cre_field_55.xml.m4
new file mode 100644
index 0000000..85a572a
--- /dev/null
+++ b/src/sd_msgmap_struct/src/cre_field_55.xml.m4
@@ -0,0 +1,23 @@
+<!-- mapping bloc 55A fixed <-> xml -->
+msgmap_object(swf_cre_field_55x-swf_cre_field_55x-format_a,swf_cre_field_55x,swf_cre_field_55x,
+				bq_de_refin_no_de_compte,bq_de_refin_no_de_compte,
+				bq_de_refin_sens_du_compte,bq_de_refin_sens_du_compte,
+				bq_de_refin_complements,bq_de_refin_complements,
+				bq_de_refin_format,bq_de_refin_format)
+<!-- mapping bloc 55D (hors complements) fixed <-> xml -->
+msgmap_object(swf_cre_field_55x-swf_cre_field_55x-format_d,swf_cre_field_55x,swf_cre_field_55x,
+				bq_de_refin_no_de_compte,bq_de_refin_no_de_compte,
+				bq_de_refin_sens_du_compte,bq_de_refin_sens_du_compte,
+				bq_de_refin_format,bq_de_refin_format)
+<!-- mapping de complements du bloc	55D delimited <-> xml -->
+msgmap_object(swf_cre_field_55d_comp-swf_cre_field_55d_comp,swf_cre_field_55d_comp,swf_cre_field_55d_comp,
+				bq_de_refin_complements_ligne1,bq_de_refin_complements_ligne1,
+				bq_de_refin_complements_ligne2,bq_de_refin_complements_ligne2,
+				bq_de_refin_complements_ligne3,bq_de_refin_complements_ligne3,
+				bq_de_refin_complements_ligne4,bq_de_refin_complements_ligne4)
+<!-- insertion de complements dans bloc 55D fixed -> fixed -->
+msgmap_object(swf_cre_field_55d_comp-swf_cre_field_55x,swf_cre_field_55d_comp,swf_cre_field_55x,
+				complements,bq_de_refin_complements)
+<!-- insertion du bloc 55 (dans un virement de clientele) fixed -> fixed -->
+msgmap_object(swf_cre_field_55x-crt_cre_flux_stlm_cus,swf_cre_field_55x,crt_cre_flux_stlm_cus,
+				champ_55,champ_55)
diff --git a/src/sd_msgmap_struct/src/cre_field_56.xml.m4 b/src/sd_msgmap_struct/src/cre_field_56.xml.m4
new file mode 100644
index 0000000..b67334a
--- /dev/null
+++ b/src/sd_msgmap_struct/src/cre_field_56.xml.m4
@@ -0,0 +1,26 @@
+<!-- mapping bloc 56A fixed <-> xml	-->
+msgmap_object(swf_cre_field_56x-swf_cre_field_56x-format_a,swf_cre_field_56x,swf_cre_field_56x,
+				bq_intermed_recep_no_de_compte,bq_intermed_recep_no_de_compte,
+				bq_intermed_recep_sens_du_compte,bq_intermed_recep_sens_du_compte,
+				bq_intermed_recep_complements,bq_intermed_recep_complements,
+				bq_intermed_recep_format,bq_intermed_recep_format)
+<!-- mapping bloc 56D (hors complements) fixed <->	xml -->
+msgmap_object(swf_cre_field_56x-swf_cre_field_56x-format_d,swf_cre_field_56x,swf_cre_field_56x,
+				bq_intermed_recep_no_de_compte,bq_intermed_recep_no_de_compte,
+				bq_intermed_recep_sens_du_compte,bq_intermed_recep_sens_du_compte,
+				bq_intermed_recep_format,bq_intermed_recep_format)
+<!-- mapping de complements du bloc 56D delimited <->	xml -->
+msgmap_object(swf_cre_field_56d_comp-swf_cre_field_56d_comp,swf_cre_field_56d_comp,swf_cre_field_56d_comp,
+				bq_intermed_recep_complements_ligne1,bq_intermed_recep_complements_ligne1,
+				bq_intermed_recep_complements_ligne2,bq_intermed_recep_complements_ligne2,
+				bq_intermed_recep_complements_ligne3,bq_intermed_recep_complements_ligne3,
+				bq_intermed_recep_complements_ligne4,bq_intermed_recep_complements_ligne4)
+<!-- insertion de complements dans bloc 56D fixed -> fixed -->
+msgmap_object(swf_cre_field_56d_comp-swf_cre_field_56x,swf_cre_field_56d_comp,swf_cre_field_56x,
+				complements,bq_intermed_recep_complements)
+<!-- insertion du bloc 56 (dans un virement bancaire) fixed -> fixed -->
+msgmap_object(swf_cre_field_56x-crt_cre_flux_stlm_bk,swf_cre_field_56x,crt_cre_flux_stlm_bk,
+				champ_56,champ_56)
+<!-- insertion	du	bloc 56 (dans un virement de clientele) fixed -> fixed -->
+msgmap_object(swf_cre_field_56x-crt_cre_flux_stlm_cus_end,swf_cre_field_56x,crt_cre_flux_stlm_cus_end,
+				champ_56,champ_56)
diff --git a/src/sd_msgmap_struct/src/cre_field_57.xml.m4 b/src/sd_msgmap_struct/src/cre_field_57.xml.m4
new file mode 100644
index 0000000..eb0026a
--- /dev/null
+++ b/src/sd_msgmap_struct/src/cre_field_57.xml.m4
@@ -0,0 +1,26 @@
+<!-- mapping bloc 57A fixed <-> xml	-->
+msgmap_object(swf_cre_field_57x-swf_cre_field_57x-format_a,swf_cre_field_57x,swf_cre_field_57x,
+				bq_du_beneficiaire_no_de_compte,bq_du_beneficiaire_no_de_compte,
+				bq_du_beneficiaire_sens_du_compte,bq_du_beneficiaire_sens_du_compte,
+				bq_du_beneficiaire_complements,bq_du_beneficiaire_complements,
+				bq_du_beneficiaire_format,bq_du_beneficiaire_format)
+<!-- mapping bloc 57D (hors complements) fixed <->	xml -->
+msgmap_object(swf_cre_field_57x-swf_cre_field_57x-format_d,swf_cre_field_57x,swf_cre_field_57x,
+				bq_du_beneficiaire_no_de_compte,bq_du_beneficiaire_no_de_compte,
+				bq_du_beneficiaire_sens_du_compte,bq_du_beneficiaire_sens_du_compte,
+				bq_du_beneficiaire_format,bq_du_beneficiaire_format)
+<!-- mapping de complements du bloc 57D delimited <->	xml -->
+msgmap_object(swf_cre_field_57d_comp-swf_cre_field_57d_comp,swf_cre_field_57d_comp,swf_cre_field_57d_comp,
+				bq_du_beneficiaire_complements_ligne1,bq_du_beneficiaire_complements_ligne1,
+				bq_du_beneficiaire_complements_ligne2,bq_du_beneficiaire_complements_ligne2,
+				bq_du_beneficiaire_complements_ligne3,bq_du_beneficiaire_complements_ligne3,
+				bq_du_beneficiaire_complements_ligne4,bq_du_beneficiaire_complements_ligne4)
+<!-- insertion de complements dans bloc 57D fixed -> fixed -->
+msgmap_object(swf_cre_field_57d_comp-swf_cre_field_57x,swf_field_57d_comp,swf_field_57x,
+				complements,bq_du_beneficiaire_complements)
+<!-- insertion du bloc 57 (dans un virement bancaire) fixed -> fixed -->
+msgmap_object(swf_cre_field_57x-crt_cre_flux_stlm_bk,swf_cre_field_57x,crt_cre_flux_stlm_bk,
+				champ_57,champ_57)
+<!-- insertion	du	bloc 57 (dans un virement de clientele) fixed -> fixed -->
+msgmap_object(swf_cre_field_57x-crt_cre_flux_stlm_cus_end,swf_cre_field_57x,crt_cre_flux_stlm_cus_end,
+				champ_57,champ_57)
diff --git a/src/sd_msgmap_struct/src/cre_field_58.xml.m4 b/src/sd_msgmap_struct/src/cre_field_58.xml.m4
new file mode 100644
index 0000000..6c3ce0b
--- /dev/null
+++ b/src/sd_msgmap_struct/src/cre_field_58.xml.m4
@@ -0,0 +1,24 @@
+<!-- mapping bloc 58A fixed <-> xml	-->
+msgmap_object(swf_cre_field_58x-swf_cre_field_58x-format_a,swf_cre_field_58x,swf_cre_field_58x,
+				bq_beneficiaire_no_de_compte,bq_beneficiaire_no_de_compte,
+				bq_beneficiaire_sens_du_compte,bq_beneficiaire_sens_du_compte,
+				bq_beneficiaire_complements,bq_beneficiaire_complements,
+				bq_beneficiaire_format,bq_beneficiaire_format)
+<!-- mapping bloc 58D (hors complements) fixed <->	xml -->
+msgmap_object(swf_cre_field_58x-swf_cre_field_58x-format_d,swf_cre_field_58x,swf_cre_field_58x,
+				bq_beneficiaire_no_de_compte,bq_beneficiaire_no_de_compte,
+				bq_beneficiaire_sens_du_compte,bq_beneficiaire_sens_du_compte,
+				bq_beneficiaire_format,bq_beneficiaire_format)
+<!-- mapping de complements du bloc 58D delimited <->	xml -->
+msgmap_object(swf_cre_field_58d_comp-swf_cre_field_58d_comp,swf_cre_field_58d_comp,swf_cre_field_58d_comp,
+				bq_beneficiaire_complements_ligne1,bq_beneficiaire_complements_ligne1,
+				bq_beneficiaire_complements_ligne2,bq_beneficiaire_complements_ligne2,
+				bq_beneficiaire_complements_ligne3,bq_beneficiaire_complements_ligne3,
+				bq_beneficiaire_complements_ligne4,bq_beneficiaire_complements_ligne4)
+<!-- insertion de complements dans bloc 58D fixed -> fixed -->
+msgmap_object(swf_cre_field_58d_comp-swf_cre_field_58x,swf_cre_field_58d_comp,swf_cre_field_58x,
+				complements,bq_beneficiaire_complements)
+<!-- insertion du bloc 58 (dans un virement bancaire) fixed -> fixed -->
+msgmap_object(swf_cre_field_58x-crt_cre_flux_stlm_bk,swf_cre_field_58x,crt_cre_flux_stlm_bk,
+				champ_58,champ_58)
+<!-- le bloc 58 n'existe pas dans un virement de clientele -->
diff --git a/src/sd_msgmap_struct/src/cre_field_59.xml.m4 b/src/sd_msgmap_struct/src/cre_field_59.xml.m4
new file mode 100644
index 0000000..fa44051
--- /dev/null
+++ b/src/sd_msgmap_struct/src/cre_field_59.xml.m4
@@ -0,0 +1,23 @@
+<!-- mapping bloc 59A fixed <-> xml -->
+msgmap_object(swf_cre_field_59x-swf_cre_field_59x-format_a,swf_cre_field_59x,swf_cre_field_59x,
+				cli_beneficiaire_type,cli_beneficiaire_type,
+				cli_beneficiaire_coordonnees,cli_beneficiaire_coordonnees,
+				cli_beneficiaire_identification,cli_beneficiaire_identification,
+				cli_beneficiaire_format,cli_beneficiaire_format)
+<!-- mapping bloc 59blanc (hors identification) fixed <-> xml -->
+msgmap_object(swf_cre_field_59x-swf_cre_field_59x-format_blanc,swf_cre_field_59x,swf_cre_field_59x,
+				cli_beneficiaire_type,cli_beneficiaire_type,
+				cli_beneficiaire_coordonnees,cli_beneficiaire_coordonnees,
+				cli_beneficiaire_format,cli_beneficiaire_format)
+<!-- mapping de identification du bloc 59blanc delimited <-> xml -->
+msgmap_object(swf_cre_field_59blanc_comp-swf_cre_field_59blanc_comp,swf_cre_field_59blanc_comp,swf_cre_field_59blanc_comp,
+				cli_beneficiaire_identification_ligne1,cli_beneficiaire_identification_ligne1,
+				cli_beneficiaire_identification_ligne2,cli_beneficiaire_identification_ligne2,
+				cli_beneficiaire_identification_ligne3,cli_beneficiaire_identification_ligne3,
+				cli_beneficiaire_identification_ligne4,cli_beneficiaire_identification_ligne4)
+<!-- insertion de identification dans bloc 59blanc fixed -> fixed -->
+msgmap_object(swf_cre_field_59blanc_comp-swf_cre_field_59x,swf_cre_field_59blanc_comp,swf_cre_field_59x,
+				identification,cli_beneficiaire_identification)
+<!-- insertion du bloc 59 (dans un virement de clientele) fixed -> fixed -->
+msgmap_object(swf_cre_field_59x-crt_cre_flux_stlm_cus_end,swf_cre_field_59x,crt_cre_flux_stlm_cus_end,
+				champ_59,champ_59)
diff --git a/src/sd_msgmap_struct/src/cre_field_70.xml.m4 b/src/sd_msgmap_struct/src/cre_field_70.xml.m4
new file mode 100644
index 0000000..a21dae0
--- /dev/null
+++ b/src/sd_msgmap_struct/src/cre_field_70.xml.m4
@@ -0,0 +1,9 @@
+<!-- mapping du bloc 70 delimited <-> xml -->
+msgmap_object(swf_cre_field_70-swf_cre_field_70,swf_cre_field_70,swf_cre_field_70,
+				motif_paiement_ligne1,motif_paiement_ligne1,
+				motif_paiement_ligne2,motif_paiement_ligne2,
+				motif_paiement_ligne3,motif_paiement_ligne3,
+				motif_paiement_ligne4,motif_paiement_ligne4)
+<!-- insertion du bloc 70 (dans un virement de clientele) fixed -> fixed -->
+msgmap_object(swf_cre_field_70-crt_cre_flux_stlm_cus_end,swf_cre_field_70,crt_cre_flux_stlm_cus_end,
+				champ_70,champ_70)
diff --git a/src/sd_msgmap_struct/src/cre_field_72.xml.m4 b/src/sd_msgmap_struct/src/cre_field_72.xml.m4
new file mode 100644
index 0000000..04391d5
--- /dev/null
+++ b/src/sd_msgmap_struct/src/cre_field_72.xml.m4
@@ -0,0 +1,31 @@
+<!-- mapping bloc 72 (hors autres lignes) fixed <-> xml -->
+msgmap_object(swf_cre_field_72-swf_cre_field_72,swf_cre_field_72,swf_cre_field_72,
+				72_bq_interm_en_emission,72_bq_interm_en_emission,
+				72_code_routage,72_code_routage,
+				72_categorie,72_categorie,
+				72_qualite,72_qualite,
+				72_code_produit,72_code_produit,
+				72_identification_du_flux,72_identification_du_flux,
+				72_code_commission_interbancaire,72_code_commission_interbancaire,
+				72_code_declaration_statistique,72_code_declaration_statistique,
+				72_code_accord_bilateral,72_code_accord_bilateral,
+				72_taux_de_tva,72_taux_de_tva,
+				72_montant_des_frais,72_montant_des_frais,
+				72_montant_de_tva_percu,72_montant_de_tva_percu)
+<!-- mapping de autres_lignes du bloc 72 delimited <-> xml -->
+msgmap_object(swf_cre_field_72_autres_lignes-swf_cre_field_72_autres_lignes,swf_cre_field_72_autres_lignes,swf_cre_field_72_autres_lignes,
+				lignes_72_ligne1,lignes_72_ligne1,
+				lignes_72_ligne2,lignes_72_ligne2,
+				lignes_72_ligne3,lignes_72_ligne3,
+				lignes_72_ligne4,lignes_72_ligne4,
+				lignes_72_ligne5,lignes_72_ligne5,
+				lignes_72_ligne6,lignes_72_ligne6)
+<!-- insertion de autres_lignes du bloc 72 fixed -> fixed -->
+msgmap_object(swf_cre_field_72_autres_lignes-swf_cre_field_72,swf_cre_field_72_autres_lignes,swf_cre_field_72,
+				champ_72_autres_lignes,champ_72_autres_lignes)
+<!-- insertion du bloc 72 (dans un virement bancaire) fixed -> fixed -->
+msgmap_object(swf_cre_field_72-crt_cre_flux_stlm_bk,swf_cre_field_72,crt_cre_flux_stlm_bk,
+				champ_72,champ_72)
+<!-- insertion du bloc 72 (a partir d'un virement de clientele) fixed -> fixed -->
+msgmap_object(swf_cre_field_72-crt_cre_flux_stlm_cus_end,swf_cre_field_72,crt_cre_flux_stlm_cus_end,
+				champ_72,champ_72)
diff --git a/src/sd_msgmap_struct/src/cre_field_77.xml.m4 b/src/sd_msgmap_struct/src/cre_field_77.xml.m4
new file mode 100644
index 0000000..b7f024e
--- /dev/null
+++ b/src/sd_msgmap_struct/src/cre_field_77.xml.m4
@@ -0,0 +1,9 @@
+<!-- mapping du bloc 77 delimited <-> xml -->
+msgmap_object(swf_cre_field_77-swf_cre_field_77,swf_cre_field_77,swf_cre_field_77,
+				77B_info_reglement_ligne1,77B_info_reglement_ligne1,
+				77B_info_reglement_ligne2,77B_info_reglement_ligne2,
+				77B_info_reglement_ligne3,77B_info_reglement_ligne3)
+<!-- le bloc 77 n'existe pas dans le virement bancaire -->
+<!-- insertion du bloc 77 (dans un virement de clientele) fixed -> fixed -->
+msgmap_object(swf_cre_field_77-crt_cre_flux_stlm_cus_end,swf_cre_field_77,crt_cre_flux_stlm_cus_end,
+				champ_77,champ_77)
diff --git a/src/sd_msgmap_struct/src/cre_or.xml.m4 b/src/sd_msgmap_struct/src/cre_or.xml.m4
new file mode 100644
index 0000000..e7b9d7f
--- /dev/null
+++ b/src/sd_msgmap_struct/src/cre_or.xml.m4
@@ -0,0 +1,24 @@
+<!-- mapping de l'entete des ordres de restitution fixed <-> xml -->
+msgmap_object(crt_cre_flux_or_header-crt_cre_flux_or_header,crt_cre_flux_or_header,crt_cre_flux_or_header,
+				ref_util,ref_util,
+				bic_emetteur,bic_emetteur,
+				bic_recepteur,bic_recepteur,
+				priorite_reseau,priorite_reseau,
+				type_or,type_or,
+				heure_emission_tot,heure_emission_tot,
+				heure_emission_tard,heure_emission_tard)
+<!-- mapping des ordres de restitution fixed <-> xml -->
+			<!-- A VOIR xml sans fixed -->
+			<!--<fieldmap>
+				<inputfield>reference_emetteur_flux</inputfield>
+				<outputfield>reference_emetteur_flux</outputfield>
+			</fieldmap>-->
+msgmap_object(crt_cre_flux_or-crt_cre_flux_or,crt_cre_flux_or,crt_cre_flux_or,
+				reference_d_origine,reference_d_origine,
+				date_de_reglement,date_de_reglement,
+				devise,devise,
+				montant,montant,
+				identification_du_sous_champ_errone,identification_du_sous_champ_errone,
+				code_motif_de_restitution,code_motif_de_restitution,
+				code_commission_interbancaire,code_commission_interbancaire,
+				motif_de_la_restitution,motif_de_la_restitution)
diff --git a/src/sd_msgmap_struct/src/cre_stlm.xml.m4 b/src/sd_msgmap_struct/src/cre_stlm.xml.m4
new file mode 100644
index 0000000..ead5f3c
--- /dev/null
+++ b/src/sd_msgmap_struct/src/cre_stlm.xml.m4
@@ -0,0 +1,64 @@
+<!-- insertion de ces donnees dans le virement de clientele fixed -> fixed -->
+msgmap_object(crt_cre_flux_stlm_cus_56_a_77-crt_cre_flux_stlm_cus_56_a_77-sans55-insert,crt_cre_flux_stlm_cus_56_a_77,crt_cre_flux_stlm_cus_56_a_77,
+				cus_block2,cus_block2_sans55)
+msgmap_object(crt_cre_flux_stlm_cus_56_a_77-crt_cre_flux_stlm_cus_56_a_77-avec55-insert,crt_cre_flux_stlm_cus_56_a_77,crt_cre_flux_stlm_cus_56_a_77,
+				cus_block2,cus_block2_avec55)
+<!-- mapping virement bancaire (hors bloc 13c 52 56 57 58 72) fixed <-> xml -->
+			<!-- A VOIR xml sans fixed -->
+			<!--<fieldmap>
+				<inputfield>reference_emetteur_flux</inputfield>
+				<outputfield>reference_emetteur_flux</outputfield>
+			</fieldmap>-->
+msgmap_object(crt_cre_flux_stlm_bk-crt_cre_flux_stlm_bk,crt_cre_flux_stlm_bk,crt_cre_flux_stlm_bk,
+				reference_d_origine,reference_d_origine,
+				date_de_reglement,date_de_reglement,
+				devise,devise,
+				montant,montant,
+				no_ccr_emet_rib_emet_ou_compte_cor,no_ccr_emet_rib_emet_ou_compte_cor,
+				ccr_recepteur,ccr_recepteur)
+<!-- mapping virement de clientele jusqu'au bloc 56 (hors bloc 50 52 et 55) fixed <-> xml -->
+			<!-- A VOIR xml sans fixed -->
+			<!--<fieldmap>
+				<inputfield>reference_emetteur_flux</inputfield>
+				<outputfield>reference_emetteur_flux</outputfield>
+			</fieldmap>-->
+msgmap_object(crt_cre_flux_stlm_cus-crt_cre_flux_stlm_cus,crt_cre_flux_stlm_cus,crt_cre_flux_stlm_cus,
+				23b_code_operation,23b_code_operation,
+				23e_code_instruction01,23e_code_instruction01,
+				23e_code_instruction02,23e_code_instruction02,
+				23e_code_instruction03,23e_code_instruction03,
+				23e_code_instruction04,23e_code_instruction04,
+				23e_code_instruction05,23e_code_instruction05,
+				23e_code_instruction06,23e_code_instruction06,
+				23e_code_instruction07,23e_code_instruction07,
+				23e_code_instruction08,23e_code_instruction08,
+				23e_code_instruction09,23e_code_instruction09,
+				23e_code_instruction10,23e_code_instruction10,
+				26t_code_type_de_transaction,26t_code_type_de_transaction,
+				date_de_reglement,date_de_reglement,
+				devise,devise,
+				montant,montant,
+				33b_devise_de_instruction,33b_devise_de_instruction,
+				33b_montant_de_instruction,33b_montant_de_instruction,
+				36_taux_de_conversion,36_taux_de_conversion,
+				53a_compte,53a_compte,
+				53a_complements,53a_complements,
+				53a_format,53a_format,
+				54a_compte,54a_compte,
+				54a_complements,54a_complements,
+				54a_format,54a_format)
+<!-- mapping virement de clientele du bloc 56 au bloc 77 (hors bloc 56 57 59 70 72 77) fixed <-> xml -->
+msgmap_object(crt_cre_flux_stlm_cus_end-crt_cre_flux_stlm_cus_end,crt_cre_flux_stlm_cus_end,crt_cre_flux_stlm_cus_end,
+				71a_repartition_des_frais,71a_repartition_des_frais,
+				71f_frais_emet01_devise,71f_frais_emet01_devise,
+				71f_frais_emet01_montant,71f_frais_emet01_montant,
+				71f_frais_emet02_devise,71f_frais_emet02_devise,
+				71f_frais_emet02_montant,71f_frais_emet02_montant,
+				71f_frais_emet03_devise,71f_frais_emet03_devise,
+				71f_frais_emet03_montant,71f_frais_emet03_montant,
+				71f_frais_emet04_devise,71f_frais_emet04_devise,
+				71f_frais_emet04_montant,71f_frais_emet04_montant,
+				71f_frais_emet05_devise,71f_frais_emet05_devise,
+				71f_frais_emet05_montant,71f_frais_emet05_montant,
+				71g_frais_recept_devise,71g_frais_recept_devise,
+				71g_frais_recept_montant,71g_frais_recept_montant)
diff --git a/src/sd_msgmap_struct/src/cut_end_msg.xml.m4 b/src/sd_msgmap_struct/src/cut_end_msg.xml.m4
new file mode 100644
index 0000000..954d93c
--- /dev/null
+++ b/src/sd_msgmap_struct/src/cut_end_msg.xml.m4
@@ -0,0 +1,5 @@
+<!-- suppression du dernier caractere d'un virement   fixed -> fixed -->
+msgmap_object(cut_end_msg-cut_end_msg1,cut_end_msg,cut_end_msg,
+				cut_end_fld1,cut_end_fld1)
+msgmap_object(cut_end_msg-cut_end_msg2,cut_end_msg,cut_end_msg,
+				cut_end_fld2,cut_end_fld2)
diff --git a/src/sd_msgmap_struct/src/dltd_end_msg.xml.m4 b/src/sd_msgmap_struct/src/dltd_end_msg.xml.m4
new file mode 100644
index 0000000..8b980a9
--- /dev/null
+++ b/src/sd_msgmap_struct/src/dltd_end_msg.xml.m4
@@ -0,0 +1,3 @@
+<!-- extraction des donnees d'un virement (a partir d'un flux destine a cristal) fixed -> fixed -->
+msgmap_object(dltd_end_msg-dltd_end_msg,dltd_end_msg,dltd_end_msg,
+				dltd_end_fld,dltd_end_fld)
diff --git a/src/sd_msgmap_struct/src/field_13c.xml.m4 b/src/sd_msgmap_struct/src/field_13c.xml.m4
new file mode 100644
index 0000000..d15da75
--- /dev/null
+++ b/src/sd_msgmap_struct/src/field_13c.xml.m4
@@ -0,0 +1,26 @@
+<!-- mapping bloc 13c fixed <-> xml -->
+msgmap_object(swf_field_13c-swf_field_13c,swf_field_13c,swf_field_13c,
+				champ_13c_1,champ_13c_1,
+				champ_13c_2,champ_13c_2,
+				champ_13c_3,champ_13c_3,
+				champ_13c_4,champ_13c_4,
+				champ_13c_5,champ_13c_5,
+				champ_13c_6,champ_13c_6)
+<!-- extraction du bloc 13c (a partir d'un virement bancaire) fixed -> fixed -->
+msgmap_object(crt_flux_stlm_bk-swf_field_13c,crt_flux_stlm_bk,swf_field_13c,
+				champ_13c,champ_13c)
+<!-- insertion du bloc 13c (dans un virement bancaire) fixed -> fixed -->
+msgmap_object(swf_field_13c-crt_flux_stlm_bk,swf_field_13c,crt_flux_stlm_bk,
+				champ_13c,champ_13c)
+<!-- extraction du bloc 13c (a partir d'un virement de clientele sans champ 55) fixed -> fixed -->
+msgmap_object(cus_champ_13c_sans55-swf_field_13c,cus_champ_13c_sans55,swf_field_13c,
+				champ_13c,champ_13c)
+<!-- insertion du bloc 13c (a partir d'un virement de clientele sans champ 55) fixed -> fixed -->
+msgmap_object(swf_field_13c-cus_champ_13c_sans55,swf_field_13c,cus_champ_13c_sans55,
+				champ_13c,champ_13c)
+<!-- extraction du bloc 13c (a partir d'un virement de clientele avec champ 55) fixed -> fixed -->
+msgmap_object(cus_champ_13c_avec55-swf_field_13c,cus_champ_13c_avec55,swf_field_13c,
+				champ_13c,champ_13c)
+<!-- insertion du bloc 13c (a partir d'un virement de clientele avec champ 55) fixed -> fixed -->
+msgmap_object(swf_field_13c-cus_champ_13c_avec55,swf_field_13c,cus_champ_13c_avec55,
+				champ_13c,champ_13c)
diff --git a/src/sd_msgmap_struct/src/field_50.xml.m4 b/src/sd_msgmap_struct/src/field_50.xml.m4
new file mode 100644
index 0000000..a7ab6d4
--- /dev/null
+++ b/src/sd_msgmap_struct/src/field_50.xml.m4
@@ -0,0 +1,30 @@
+<!-- mapping bloc 50A fixed <-> xml -->
+msgmap_object(swf_field_50x-swf_field_50x-format_a,swf_field_50x,swf_field_50x,
+				cli_donneur_ordre_type,cli_donneur_ordre_type,
+				cli_donneur_ordre_coordonnees,cli_donneur_ordre_coordonnees,
+				cli_donneur_ordre_identification,cli_donneur_ordre_identification,
+				cli_donneur_ordre_format,cli_donneur_ordre_format)
+<!-- mapping bloc 50k (hors identification) fixed <-> xml -->
+msgmap_object(swf_field_50x-swf_field_50x-format_k,swf_field_50x,swf_field_50x,
+				cli_donneur_ordre_type,cli_donneur_ordre_type,
+				cli_donneur_ordre_coordonnees,cli_donneur_ordre_coordonnees,
+				cli_donneur_ordre_format,cli_donneur_ordre_format)
+<!-- mapping de identification du bloc 50k delimited <-> xml -->
+msgmap_object(swf_field_50k_comp-swf_field_50k_comp,swf_field_50k_comp,swf_field_50k_comp,
+				cli_donneur_ordre_identification_ligne1,cli_donneur_ordre_identification_ligne1,
+				cli_donneur_ordre_identification_ligne2,cli_donneur_ordre_identification_ligne2,
+				cli_donneur_ordre_identification_ligne3,cli_donneur_ordre_identification_ligne3,
+				cli_donneur_ordre_identification_ligne4,cli_donneur_ordre_identification_ligne4)
+<!-- insertion de identification dans bloc 50k fixed -> fixed -->
+msgmap_object(swf_field_50k_comp-swf_field_50x,swf_field_50k_comp,swf_field_50x,
+				identification,cli_donneur_ordre_identification)
+<!-- extraction de identification du bloc 50k fixed -> fixed -->
+msgmap_object(swf_field_50x-swf_field_50k_comp,swf_field_50x,swf_field_50k_comp,
+				cli_donneur_ordre_identification,identification)
+<!-- le bloc 50 n'existe pas dans le virement bancaire -->
+<!-- extraction du bloc 50 (a partir d'un virement de clientele) fixed -> fixed -->
+msgmap_object(crt_flux_stlm_cus-swf_field_50x,crt_flux_stlm_cus,swf_field_50x,
+				champ_50,champ_50)
+<!-- insertion du bloc 50 (dans un virement de clientele) fixed -> fixed -->
+msgmap_object(swf_field_50x-crt_flux_stlm_cus,swf_field_50x,crt_flux_stlm_cus,
+				champ_50,champ_50)
diff --git a/src/sd_msgmap_struct/src/field_52.xml.m4 b/src/sd_msgmap_struct/src/field_52.xml.m4
new file mode 100644
index 0000000..55882e8
--- /dev/null
+++ b/src/sd_msgmap_struct/src/field_52.xml.m4
@@ -0,0 +1,35 @@
+<!-- mapping bloc 52A fixed <-> xml	-->
+msgmap_object(swf_field_52x-swf_field_52x-format_a,swf_field_52x,swf_field_52x,
+				bq_donneuse_ordre_no_de_compte,bq_donneuse_ordre_no_de_compte,
+				bq_donneuse_ordre_sens_du_compte,bq_donneuse_ordre_sens_du_compte,
+				bq_donneuse_ordre_complements,bq_donneuse_ordre_complements,
+				bq_donneuse_ordre_format,bq_donneuse_ordre_format)
+<!-- mapping bloc 52D (hors complements) fixed <->	xml -->
+msgmap_object(swf_field_52x-swf_field_52x-format_d,swf_field_52x,swf_field_52x,
+				bq_donneuse_ordre_no_de_compte,bq_donneuse_ordre_no_de_compte,
+				bq_donneuse_ordre_sens_du_compte,bq_donneuse_ordre_sens_du_compte,
+				bq_donneuse_ordre_format,bq_donneuse_ordre_format)
+<!-- mapping de complements du bloc 52D delimited <->	xml -->
+msgmap_object(swf_field_52d_comp-swf_field_52d_comp,swf_field_52d_comp,swf_field_52d_comp,
+				bq_donneuse_ordre_complements_ligne1,bq_donneuse_ordre_complements_ligne1,
+				bq_donneuse_ordre_complements_ligne2,bq_donneuse_ordre_complements_ligne2,
+				bq_donneuse_ordre_complements_ligne3,bq_donneuse_ordre_complements_ligne3,
+				bq_donneuse_ordre_complements_ligne4,bq_donneuse_ordre_complements_ligne4)
+<!-- insertion de complements dans bloc 52D fixed -> fixed -->
+msgmap_object(swf_field_52d_comp-swf_field_52x,swf_field_52d_comp,swf_field_52x,
+				complements,bq_donneuse_ordre_complements)
+<!-- extraction de complements du bloc 52D fixed -> fixed -->
+msgmap_object(swf_field_52x-swf_field_52d_comp,swf_field_52x,swf_field_52d_comp,
+				bq_donneuse_ordre_complements,complements)
+<!-- extraction du bloc 52 (a partir d'un virement bancaire) fixed -> fixed -->
+msgmap_object(crt_flux_stlm_bk-swf_field_52x,crt_flux_stlm_bk,swf_field_52x,
+				champ_52,champ_52)
+<!-- insertion du bloc 52 (dans un virement bancaire) fixed -> fixed -->
+msgmap_object(swf_field_52x-crt_flux_stlm_bk,swf_field_52x,crt_flux_stlm_bk,
+				champ_52,champ_52)
+<!-- extraction du bloc 52 (a partir d'un virement de clientele) fixed -> fixed -->
+msgmap_object(crt_flux_stlm_cus-swf_field_52x,crt_flux_stlm_cus,swf_field_52x,
+				champ_52,champ_52)
+<!-- insertion	du	bloc 52 (dans un virement de clientele) fixed -> fixed -->
+msgmap_object(swf_field_52x-crt_flux_stlm_cus,swf_field_52x,crt_flux_stlm_cus,
+				champ_52,champ_52)
diff --git a/src/sd_msgmap_struct/src/field_55.xml.m4 b/src/sd_msgmap_struct/src/field_55.xml.m4
new file mode 100644
index 0000000..ac47c3a
--- /dev/null
+++ b/src/sd_msgmap_struct/src/field_55.xml.m4
@@ -0,0 +1,30 @@
+<!-- mapping bloc 55A fixed <-> xml -->
+msgmap_object(swf_field_55x-swf_field_55x-format_a,swf_field_55x,swf_field_55x,
+				bq_de_refin_no_de_compte,bq_de_refin_no_de_compte,
+				bq_de_refin_sens_du_compte,bq_de_refin_sens_du_compte,
+				bq_de_refin_complements,bq_de_refin_complements,
+				bq_de_refin_format,bq_de_refin_format)
+<!-- mapping bloc 55D (hors complements) fixed <-> xml -->
+msgmap_object(swf_field_55x-swf_field_55x-format_d,swf_field_55x,swf_field_55x,
+				bq_de_refin_no_de_compte,bq_de_refin_no_de_compte,
+				bq_de_refin_sens_du_compte,bq_de_refin_sens_du_compte,
+				bq_de_refin_format,bq_de_refin_format)
+<!-- mapping de complements du bloc	55D delimited <-> xml -->
+msgmap_object(swf_field_55d_comp-swf_field_55d_comp,swf_field_55d_comp,swf_field_55d_comp,
+				bq_de_refin_complements_ligne1,bq_de_refin_complements_ligne1,
+				bq_de_refin_complements_ligne2,bq_de_refin_complements_ligne2,
+				bq_de_refin_complements_ligne3,bq_de_refin_complements_ligne3,
+				bq_de_refin_complements_ligne4,bq_de_refin_complements_ligne4)
+<!-- insertion de complements dans bloc 55D fixed -> fixed -->
+msgmap_object(swf_field_55d_comp-swf_field_55x,swf_field_55d_comp,swf_field_55x,
+				complements,bq_de_refin_complements)
+<!-- extraction de complements du bloc 55D fixed -> fixed -->
+msgmap_object(swf_field_55x-swf_field_55d_comp,swf_field_55x,swf_field_55d_comp,
+				bq_de_refin_complements,complements)
+<!-- le bloc 55 n'existe pas dans le virement bancaire -->
+<!-- extraction du bloc 55 (a partir d'un	virement	de	clientele) fixed -> fixed -->
+msgmap_object(crt_flux_stlm_cus-swf_field_55x,crt_flux_stlm_cus,swf_field_55x,
+				champ_55,champ_55)
+<!-- insertion du bloc 55 (dans un virement de clientele) fixed -> fixed -->
+msgmap_object(swf_field_55x-crt_flux_stlm_cus,swf_field_55x,crt_flux_stlm_cus,
+				champ_55,champ_55)
diff --git a/src/sd_msgmap_struct/src/field_56.xml.m4 b/src/sd_msgmap_struct/src/field_56.xml.m4
new file mode 100644
index 0000000..8b3a662
--- /dev/null
+++ b/src/sd_msgmap_struct/src/field_56.xml.m4
@@ -0,0 +1,35 @@
+<!-- mapping bloc 56A fixed <-> xml	-->
+msgmap_object(swf_field_56x-swf_field_56x-format_a,swf_field_56x,swf_field_56x,
+				bq_intermed_recep_no_de_compte,bq_intermed_recep_no_de_compte,
+				bq_intermed_recep_sens_du_compte,bq_intermed_recep_sens_du_compte,
+				bq_intermed_recep_complements,bq_intermed_recep_complements,
+				bq_intermed_recep_format,bq_intermed_recep_format)
+<!-- mapping bloc 56D (hors complements) fixed <->	xml -->
+msgmap_object(swf_field_56x-swf_field_56x-format_d,swf_field_56x,swf_field_56x,
+				bq_intermed_recep_no_de_compte,bq_intermed_recep_no_de_compte,
+				bq_intermed_recep_sens_du_compte,bq_intermed_recep_sens_du_compte,
+				bq_intermed_recep_format,bq_intermed_recep_format)
+<!-- mapping de complements du bloc 56D delimited <->	xml -->
+msgmap_object(swf_field_56d_comp-swf_field_56d_comp,swf_field_56d_comp,swf_field_56d_comp,
+				bq_intermed_recep_complements_ligne1,bq_intermed_recep_complements_ligne1,
+				bq_intermed_recep_complements_ligne2,bq_intermed_recep_complements_ligne2,
+				bq_intermed_recep_complements_ligne3,bq_intermed_recep_complements_ligne3,
+				bq_intermed_recep_complements_ligne4,bq_intermed_recep_complements_ligne4)
+<!-- insertion de complements dans bloc 56D fixed -> fixed -->
+msgmap_object(swf_field_56d_comp-swf_field_56x,swf_field_56d_comp,swf_field_56x,
+				complements,bq_intermed_recep_complements)
+<!-- extraction de complements du bloc 56D fixed -> fixed -->
+msgmap_object(swf_field_56x-swf_field_56d_comp,swf_field_56x,swf_field_56d_comp,
+				bq_intermed_recep_complements,complements)
+<!-- extraction du bloc 56 (a partir d'un virement bancaire) fixed -> fixed -->
+msgmap_object(crt_flux_stlm_bk-swf_field_56x,crt_flux_stlm_bk,swf_field_56x,
+				champ_56,champ_56)
+<!-- insertion du bloc 56 (dans un virement bancaire) fixed -> fixed -->
+msgmap_object(swf_field_56x-crt_flux_stlm_bk,swf_field_56x,crt_flux_stlm_bk,
+				champ_56,champ_56)
+<!-- extraction du bloc 56 (a partir d'un virement de clientele) fixed -> fixed -->
+msgmap_object(crt_flux_stlm_cus_end-swf_field_56x,crt_flux_stlm_cus_end,swf_field_56x,
+				champ_56,champ_56)
+<!-- insertion	du	bloc 56 (dans un virement de clientele) fixed -> fixed -->
+msgmap_object(swf_field_56x-crt_flux_stlm_cus_end,swf_field_56x,crt_flux_stlm_cus_end,
+				champ_56,champ_56)
diff --git a/src/sd_msgmap_struct/src/field_57.xml.m4 b/src/sd_msgmap_struct/src/field_57.xml.m4
new file mode 100644
index 0000000..a6da468
--- /dev/null
+++ b/src/sd_msgmap_struct/src/field_57.xml.m4
@@ -0,0 +1,35 @@
+<!-- mapping bloc 57A fixed <-> xml	-->
+msgmap_object(swf_field_57x-swf_field_57x-format_a,swf_field_57x,swf_field_57x,
+				bq_du_beneficiaire_no_de_compte,bq_du_beneficiaire_no_de_compte,
+				bq_du_beneficiaire_sens_du_compte,bq_du_beneficiaire_sens_du_compte,
+				bq_du_beneficiaire_complements,bq_du_beneficiaire_complements,
+				bq_du_beneficiaire_format,bq_du_beneficiaire_format)
+<!-- mapping bloc 57D (hors complements) fixed <->	xml -->
+msgmap_object(swf_field_57x-swf_field_57x-format_d,swf_field_57x,swf_field_57x,
+				bq_du_beneficiaire_no_de_compte,bq_du_beneficiaire_no_de_compte,
+				bq_du_beneficiaire_sens_du_compte,bq_du_beneficiaire_sens_du_compte,
+				bq_du_beneficiaire_format,bq_du_beneficiaire_format)
+<!-- mapping de complements du bloc 57D delimited <->	xml -->
+msgmap_object(swf_field_57d_comp-swf_field_57d_comp,swf_field_57d_comp,swf_field_57d_comp,
+				bq_du_beneficiaire_complements_ligne1,bq_du_beneficiaire_complements_ligne1,
+				bq_du_beneficiaire_complements_ligne2,bq_du_beneficiaire_complements_ligne2,
+				bq_du_beneficiaire_complements_ligne3,bq_du_beneficiaire_complements_ligne3,
+				bq_du_beneficiaire_complements_ligne4,bq_du_beneficiaire_complements_ligne4)
+<!-- insertion de complements dans bloc 57D fixed -> fixed -->
+msgmap_object(swf_field_57d_comp-swf_field_57x,swf_field_57d_comp,swf_field_57x,
+				complements,bq_du_beneficiaire_complements)
+<!-- extraction de complements du bloc 57D fixed -> fixed -->
+msgmap_object(swf_field_57x-swf_field_57d_comp,swf_field_57x,swf_field_57d_comp,
+				bq_du_beneficiaire_complements,complements)
+<!-- extraction du bloc 57 (a partir d'un virement bancaire) fixed -> fixed -->
+msgmap_object(crt_flux_stlm_bk-swf_field_57x,crt_flux_stlm_bk,swf_field_57x,
+				champ_57,champ_57)
+<!-- insertion du bloc 57 (dans un virement bancaire) fixed -> fixed -->
+msgmap_object(swf_field_57x-crt_flux_stlm_bk,swf_field_57x,crt_flux_stlm_bk,
+				champ_57,champ_57)
+<!-- extraction du bloc 57 (a partir d'un virement de clientele) fixed -> fixed -->
+msgmap_object(crt_flux_stlm_cus_end-swf_field_57x,crt_flux_stlm_cus_end,swf_field_57x,
+				champ_57,champ_57)
+<!-- insertion	du	bloc 57 (dans un virement de clientele) fixed -> fixed -->
+msgmap_object(swf_field_57x-crt_flux_stlm_cus_end,swf_field_57x,crt_flux_stlm_cus_end,
+				champ_57,champ_57)
diff --git a/src/sd_msgmap_struct/src/field_58.xml.m4 b/src/sd_msgmap_struct/src/field_58.xml.m4
new file mode 100644
index 0000000..8fc4660
--- /dev/null
+++ b/src/sd_msgmap_struct/src/field_58.xml.m4
@@ -0,0 +1,30 @@
+<!-- mapping bloc 58A fixed <-> xml	-->
+msgmap_object(swf_field_58x-swf_field_58x-format_a,swf_field_58x,swf_field_58x,
+				bq_beneficiaire_no_de_compte,bq_beneficiaire_no_de_compte,
+				bq_beneficiaire_sens_du_compte,bq_beneficiaire_sens_du_compte,
+				bq_beneficiaire_complements,bq_beneficiaire_complements,
+				bq_beneficiaire_format,bq_beneficiaire_format)
+<!-- mapping bloc 58D (hors complements) fixed <->	xml -->
+msgmap_object(swf_field_58x-swf_field_58x-format_d,swf_field_58x,swf_field_58x,
+				bq_beneficiaire_no_de_compte,bq_beneficiaire_no_de_compte,
+				bq_beneficiaire_sens_du_compte,bq_beneficiaire_sens_du_compte,
+				bq_beneficiaire_format,bq_beneficiaire_format)
+<!-- mapping de complements du bloc 58D delimited <->	xml -->
+msgmap_object(swf_field_58d_comp-swf_field_58d_comp,swf_field_58d_comp,swf_field_58d_comp,
+				bq_beneficiaire_complements_ligne1,bq_beneficiaire_complements_ligne1,
+				bq_beneficiaire_complements_ligne2,bq_beneficiaire_complements_ligne2,
+				bq_beneficiaire_complements_ligne3,bq_beneficiaire_complements_ligne3,
+				bq_beneficiaire_complements_ligne4,bq_beneficiaire_complements_ligne4)
+<!-- insertion de complements dans bloc 58D fixed -> fixed -->
+msgmap_object(swf_field_58d_comp-swf_field_58x,swf_field_58d_comp,swf_field_58x,
+				complements,bq_beneficiaire_complements)
+<!-- extraction de complements du bloc 58D fixed -> fixed -->
+msgmap_object(swf_field_58x-swf_field_58d_comp,swf_field_58x,swf_field_58d_comp,
+				bq_beneficiaire_complements,complements)
+<!-- extraction du bloc 58 (a partir d'un virement bancaire) fixed -> fixed -->
+msgmap_object(crt_flux_stlm_bk-swf_field_58x,crt_flux_stlm_bk,swf_field_58x,
+				champ_58,champ_58)
+<!-- insertion du bloc 58 (dans un virement bancaire) fixed -> fixed -->
+msgmap_object(swf_field_58x-crt_flux_stlm_bk,swf_field_58x,crt_flux_stlm_bk,
+				champ_58,champ_58)
+<!-- le bloc 58 n'existe pas dans un virement de clientele -->
diff --git a/src/sd_msgmap_struct/src/field_59.xml.m4 b/src/sd_msgmap_struct/src/field_59.xml.m4
new file mode 100644
index 0000000..591b8b5
--- /dev/null
+++ b/src/sd_msgmap_struct/src/field_59.xml.m4
@@ -0,0 +1,30 @@
+<!-- mapping bloc 59A fixed <-> xml -->
+msgmap_object(swf_field_59x-swf_field_59x-format_a,swf_field_59x,swf_field_59x,
+				cli_beneficiaire_type,cli_beneficiaire_type,
+				cli_beneficiaire_coordonnees,cli_beneficiaire_coordonnees,
+				cli_beneficiaire_identification,cli_beneficiaire_identification,
+				cli_beneficiaire_format,cli_beneficiaire_format)
+<!-- mapping bloc 59blanc (hors identification) fixed <-> xml -->
+msgmap_object(swf_field_59x-swf_field_59x-format_blanc,swf_field_59x,swf_field_59x,
+				cli_beneficiaire_type,cli_beneficiaire_type,
+				cli_beneficiaire_coordonnees,cli_beneficiaire_coordonnees,
+				cli_beneficiaire_format,cli_beneficiaire_format)
+<!-- mapping de identification du bloc 59blanc delimited <-> xml -->
+msgmap_object(swf_field_59blanc_comp-swf_field_59blanc_comp,swf_field_59blanc_comp,swf_field_59blanc_comp,
+				cli_beneficiaire_identification_ligne1,cli_beneficiaire_identification_ligne1,
+				cli_beneficiaire_identification_ligne2,cli_beneficiaire_identification_ligne2,
+				cli_beneficiaire_identification_ligne3,cli_beneficiaire_identification_ligne3,
+				cli_beneficiaire_identification_ligne4,cli_beneficiaire_identification_ligne4)
+<!-- insertion de identification dans bloc 59blanc fixed -> fixed -->
+msgmap_object(swf_field_59blanc_comp-swf_field_59x,swf_field_59blanc_comp,swf_field_59x,
+				identification,cli_beneficiaire_identification)
+<!-- extraction de identification du bloc 59blanc fixed -> fixed -->
+msgmap_object(swf_field_59x-swf_field_59blanc_comp,swf_field_59x,swf_field_59blanc_comp,
+				cli_beneficiaire_identification,identification)
+<!-- le bloc 59 n'existe pas dans le virement bancaire -->
+<!-- extraction du bloc 59 (a partir d'un virement de clientele) fixed -> fixed -->
+msgmap_object(crt_flux_stlm_cus_end-swf_field_59x,crt_flux_stlm_cus_end,swf_field_59x,
+				champ_59,champ_59)
+<!-- insertion du bloc 59 (dans un virement de clientele) fixed -> fixed -->
+msgmap_object(swf_field_59x-crt_flux_stlm_cus_end,swf_field_59x,crt_flux_stlm_cus_end,
+				champ_59,champ_59)
diff --git a/src/sd_msgmap_struct/src/field_70.xml.m4 b/src/sd_msgmap_struct/src/field_70.xml.m4
new file mode 100644
index 0000000..f59ffb7
--- /dev/null
+++ b/src/sd_msgmap_struct/src/field_70.xml.m4
@@ -0,0 +1,13 @@
+<!-- mapping du bloc 70 delimited <-> xml -->
+msgmap_object(swf_field_70-swf_field_70,swf_field_70,swf_field_70,
+				motif_paiement_ligne1,motif_paiement_ligne1,
+				motif_paiement_ligne2,motif_paiement_ligne2,
+				motif_paiement_ligne3,motif_paiement_ligne3,
+				motif_paiement_ligne4,motif_paiement_ligne4)
+<!-- le bloc 70 n'existe pas dans le virement bancaire -->
+<!-- extraction du bloc 70 (a partir d'un virement de clientele) fixed -> fixed -->
+msgmap_object(crt_flux_stlm_cus_end-swf_field_70,crt_flux_stlm_cus_end,swf_field_70,
+				champ_70,champ_70)
+<!-- insertion du bloc 70 (dans un virement de clientele) fixed -> fixed -->
+msgmap_object(swf_field_70-crt_flux_stlm_cus_end,swf_field_70,crt_flux_stlm_cus_end,
+				champ_70,champ_70)
diff --git a/src/sd_msgmap_struct/src/field_72.xml.m4 b/src/sd_msgmap_struct/src/field_72.xml.m4
new file mode 100644
index 0000000..683e020
--- /dev/null
+++ b/src/sd_msgmap_struct/src/field_72.xml.m4
@@ -0,0 +1,40 @@
+<!-- mapping bloc 72 (hors autres lignes) fixed <-> xml -->
+msgmap_object(swf_field_72-swf_field_72,swf_field_72,swf_field_72,
+				72_bq_interm_en_emission,72_bq_interm_en_emission,
+				72_code_routage,72_code_routage,
+				72_categorie,72_categorie,
+				72_qualite,72_qualite,
+				72_code_produit,72_code_produit,
+				72_identification_du_flux,72_identification_du_flux,
+				72_code_commission_interbancaire,72_code_commission_interbancaire,
+				72_code_declaration_statistique,72_code_declaration_statistique,
+				72_code_accord_bilateral,72_code_accord_bilateral,
+				72_taux_de_tva,72_taux_de_tva,
+				72_montant_des_frais,72_montant_des_frais,
+				72_montant_de_tva_percu,72_montant_de_tva_percu)
+<!-- mapping de autres_lignes du bloc 72 delimited <-> xml -->
+msgmap_object(swf_field_72_autres_lignes-swf_field_72_autres_lignes,swf_field_72_autres_lignes,swf_field_72_autres_lignes,
+				lignes_72_ligne1,lignes_72_ligne1,
+				lignes_72_ligne2,lignes_72_ligne2,
+				lignes_72_ligne3,lignes_72_ligne3,
+				lignes_72_ligne4,lignes_72_ligne4,
+				lignes_72_ligne5,lignes_72_ligne5,
+				lignes_72_ligne6,lignes_72_ligne6)
+<!-- insertion de autres_lignes du bloc 72 fixed -> fixed -->
+msgmap_object(swf_field_72_autres_lignes-swf_field_72,swf_field_72_autres_lignes,swf_field_72,
+				champ_72_autres_lignes,champ_72_autres_lignes)
+<!-- extraction de autres_lignes du bloc 72 fixed -> fixed -->
+msgmap_object(swf_field_72-swf_field_72_autres_lignes,swf_field_72,swf_field_72_autres_lignes,
+				champ_72_autres_lignes,champ_72_autres_lignes)
+<!-- extraction du bloc 72 (a partir d'un virement bancaire) fixed -> fixed -->
+msgmap_object(crt_flux_stlm_bk-swf_field_72,crt_flux_stlm_bk,swf_field_72,
+				champ_72,champ_72)
+<!-- insertion du bloc 72 (dans un virement bancaire) fixed -> fixed -->
+msgmap_object(swf_field_72-crt_flux_stlm_bk,swf_field_72,crt_flux_stlm_bk,
+				champ_72,champ_72)
+<!-- extraction du bloc 72 (a partir d'un virement de clientele) fixed -> fixed -->
+msgmap_object(crt_flux_stlm_cus_end-swf_field_72,crt_flux_stlm_cus_end,swf_field_72,
+				champ_72,champ_72)
+<!-- insertion du bloc 72 (a partir d'un virement de clientele) fixed -> fixed -->
+msgmap_object(swf_field_72-crt_flux_stlm_cus_end,swf_field_72,crt_flux_stlm_cus_end,
+				champ_72,champ_72)
diff --git a/src/sd_msgmap_struct/src/field_77.xml.m4 b/src/sd_msgmap_struct/src/field_77.xml.m4
new file mode 100644
index 0000000..43b5143
--- /dev/null
+++ b/src/sd_msgmap_struct/src/field_77.xml.m4
@@ -0,0 +1,12 @@
+<!-- mapping du bloc 77 delimited <-> xml -->
+msgmap_object(swf_field_77-swf_field_77,swf_field_77,swf_field_77,
+				77B_info_reglement_ligne1,77B_info_reglement_ligne1,
+				77B_info_reglement_ligne2,77B_info_reglement_ligne2,
+				77B_info_reglement_ligne3,77B_info_reglement_ligne3)
+<!-- le bloc 77 n'existe pas dans le virement bancaire -->
+<!-- extraction du bloc 77 (a partir d'un virement de clientele) fixed -> fixed -->
+msgmap_object(crt_flux_stlm_cus_end-swf_field_77,crt_flux_stlm_cus_end,swf_field_77,
+				champ_77,champ_77)
+<!-- insertion du bloc 77 (dans un virement de clientele) fixed -> fixed -->
+msgmap_object(swf_field_77-crt_flux_stlm_cus_end,swf_field_77,crt_flux_stlm_cus_end,
+				champ_77,champ_77)
diff --git a/src/sd_msgmap_struct/src/msgmap_commun.xml.m4 b/src/sd_msgmap_struct/src/msgmap_commun.xml.m4
new file mode 100644
index 0000000..ed6edf8
--- /dev/null
+++ b/src/sd_msgmap_struct/src/msgmap_commun.xml.m4
@@ -0,0 +1,104 @@
+changecom(`<!--', `-->')dnl
+define(`forloop',
+`pushdef(`$1', `$2')_forloop(`$1', `$2', `$3', `$4')popdef(`$1')')
+define(`_forloop',
+`$4`'ifelse($1, `$3', ,
+`define(`$1', incr($1))_forloop(`$1', `$2', `$3', `$4')')')
+dnl
+dnl+---------------------------------------------------------------------------+
+dnl|    Begin header_msgmap Macro                                              |
+dnl+---------------------------------------------------------------------------+
+dnl
+define(`header_msgmap',
+`<?xml version="1.0" ?>
+`<!-- MsgMap Struct definitions -->'
+`<msgmap_struct>'')
+dnl
+dnl+---------------------------------------------------------------------------+
+dnl|     End header_msgmap Macro                                               |
+dnl+---------------------------------------------------------------------------+
+dnl
+dnl
+dnl+---------------------------------------------------------------------------+
+dnl|    Begin footer_msgmap Macro                                              |
+dnl+---------------------------------------------------------------------------+
+dnl
+define(`footer_msgmap',
+`<!-- MsgMap Struct definitions footer -->
+`</msgmap_struct>'')
+dnl
+dnl+---------------------------------------------------------------------------+
+dnl|     End footer_msgmap Macro                                               |
+dnl+---------------------------------------------------------------------------+
+dnl
+dnl
+dnl+---------------------------------------------------------------------------+
+dnl|    Begin insert_version Macro                                             |
+dnl|                                                                           |
+dnl| $1 : la chaine VERSION                                                    |
+dnl+---------------------------------------------------------------------------+
+dnl
+define(`insert_version',
+`<version>$1</version>')
+dnl
+dnl+----------------------------------------------------------------------------+
+dnl|     End insert_version Macro                                               |
+dnl+----------------------------------------------------------------------------+
+dnl
+dnl
+dnl+---------------------------------------------------------------------------+
+dnl|    Begin fieldmap_object Macro                                            |
+dnl|                                                                           |
+dnl| $1 : inputfield                                                           |
+dnl| $2 : outputfield                                                          |
+dnl+---------------------------------------------------------------------------+
+dnl
+define(`fieldmap_object',
+`			<fieldmap>
+`				<inputfield>$1</inputfield>'
+`				<outputfield>$2</outputfield>'
+`			</fieldmap>'')
+dnl
+dnl+----------------------------------------------------------------------------+
+dnl|     End fieldmap_object Macro                                              |
+dnl+----------------------------------------------------------------------------+
+dnl
+dnl
+dnl+---------------------------------------------------------------------------+
+dnl|    Begin list_fieldmap_object Macro        Arg. variadique                |
+dnl|                                                                           |
+dnl| $1 : inputfield                                                           |
+dnl| $2 : outputfield                                                          |
+dnl+---------------------------------------------------------------------------+
+dnl
+define(`list_fieldmap_object',
+`ifelse($#,1,`dnl',`fieldmap_object($1,$2)'
+`list_fieldmap_object(shift(shift($@)))')')
+dnl
+dnl+----------------------------------------------------------------------------+
+dnl|     End list_fieldmap_object Macro                                         |
+dnl+----------------------------------------------------------------------------+
+dnl
+dnl
+dnl+---------------------------------------------------------------------------+
+dnl|    Begin msgmap_object Macro                                              |
+dnl|                                                                           |
+dnl| $1 : msgmap Name                                                          |
+dnl| $2 : inputmessage                                                         |
+dnl| $3 : outputmessage                                                        |
+dnl+---------------------------------------------------------------------------+
+dnl
+define(`msgmap_object',
+`	<msgmap>
+`		<name>$1</name>'
+`		<inputmessage>$2</inputmessage>'
+`		<outputmessage>$3</outputmessage>'
+`		<fieldmapstruct>'
+list_fieldmap_object(shift(shift(shift($@))))
+`		</fieldmapstruct>'
+`	</msgmap>'')
+dnl
+dnl+---------------------------------------------------------------------------+
+dnl|     End msgmap_object Macro                                               |
+dnl+---------------------------------------------------------------------------+
+dnl
diff --git a/src/sd_msgmap_struct/src/msgmap_delimited_fixed.xml.m4 b/src/sd_msgmap_struct/src/msgmap_delimited_fixed.xml.m4
new file mode 100644
index 0000000..671dfe3
--- /dev/null
+++ b/src/sd_msgmap_struct/src/msgmap_delimited_fixed.xml.m4
@@ -0,0 +1,4 @@
+<!-- mapping permettant un changement de format du buffer input  Delimited -> fixed -->
+<!-- utilise pour les champs multi-lignes -->
+msgmap_object(msgmap_delimited_fixed,msg_delimited_fixed,msg_delimited_fixed,
+				complements,complements)
diff --git a/src/sd_msgmap_struct/src/msgmap_fixed_fml.xml.m4 b/src/sd_msgmap_struct/src/msgmap_fixed_fml.xml.m4
new file mode 100644
index 0000000..c64824b
--- /dev/null
+++ b/src/sd_msgmap_struct/src/msgmap_fixed_fml.xml.m4
@@ -0,0 +1,2 @@
+msgmap_object(msgmap_fixed_fml,msg_fixed_fml,msg_fixed_fml,
+				FML_MSG_TXT,FML_MSG_TXT)
diff --git a/src/sd_msgmap_struct/src/or.xml.m4 b/src/sd_msgmap_struct/src/or.xml.m4
new file mode 100644
index 0000000..124dd58
--- /dev/null
+++ b/src/sd_msgmap_struct/src/or.xml.m4
@@ -0,0 +1,46 @@
+<!-- extraction des donnees d'un ordre de restitution (a partir d'un flux destine a cristal) fixed -> fixed -->
+msgmap_object(crt_flux_ordre_rest-crt_flux_ordre_rest-extract_or_from_flux,crt_flux_ordre_rest,crt_flux_ordre_rest,
+				or_in_flux,or)
+<!-- insertion des donnees d'un ordre de restitution dans un flux destine a cristal fixed -> fixed -->
+msgmap_object(crt_flux_ordre_rest-crt_flux_ordre_rest-insert_or_in_flux,crt_flux_ordre_rest,crt_flux_ordre_rest,
+				or,or_in_flux)
+<!-- extraction des donnees d'un OR (a partir d'un CRE sur vgm/or emis) fixed -> fixed -->
+msgmap_object(crt_flux_ordre_rest-crt_flux_ordre_rest-extract_or_emis_from_cre,crt_flux_ordre_rest,crt_flux_ordre_rest,
+				or_emis_in_cre,or)
+<!-- insertion des donnees d'un OR dans un CRE sur vgm/or emis fixed -> fixed -->
+msgmap_object(crt_flux_ordre_rest-crt_flux_ordre_rest-insert_or_emis_in_cre,crt_flux_ordre_rest,crt_flux_ordre_rest,
+				or,or_emis_in_cre)
+<!-- extraction des donnees d'un OR (a partir d'un CRE sur vgm/or recu) fixed -> fixed -->
+msgmap_object(crt_flux_ordre_rest-crt_flux_ordre_rest-extract_or_recu_from_cre,crt_flux_ordre_rest,crt_flux_ordre_rest,
+				or_recu_in_cre,or)
+<!-- insertion des donnees d'un OR dans un CRE sur vgm/or recu fixed -> fixed -->
+msgmap_object(crt_flux_ordre_rest-crt_flux_ordre_rest-insert_or_recu_in_cre,crt_flux_ordre_rest,crt_flux_ordre_rest,
+				or,or_recu_in_cre)
+<!-- insertion des donnees d'un OR dans un CRE de rejet -> fixed -->
+msgmap_object(crt_flux_ordre_rest-crt_flux_ordre_rest-insert_or_recu_in_cre_rejet,crt_flux_ordre_rest,crt_flux_ordre_rest,
+				or,or_in_cre_rejet)
+<!-- mapping de l'entete des ordres de restitution fixed <-> xml -->
+msgmap_object(crt_flux_or_header-crt_flux_or_header,crt_flux_or_header,crt_flux_or_header,
+				ref_util,ref_util,
+				bic_emetteur,bic_emetteur,
+				bic_recepteur,bic_recepteur,
+				priorite_reseau,priorite_reseau,
+				type_or,type_or,
+				heure_emission_tot,heure_emission_tot,
+				heure_emission_tard,heure_emission_tard)
+<!-- mapping des ordres de restitution fixed <-> xml -->
+			<!-- A VOIR xml sans fixed
+			<fieldmap>
+				<inputfield>reference_emetteur_flux</inputfield>
+				<outputfield>reference_emetteur_flux</outputfield>
+			</fieldmap>
+			-->
+msgmap_object(crt_flux_or-crt_flux_or,crt_flux_or,crt_flux_or,
+				reference_d_origine,reference_d_origine,
+				date_de_reglement,date_de_reglement,
+				devise,devise,
+				montant,montant,
+				identification_du_sous_champ_errone,identification_du_sous_champ_errone,
+				code_motif_de_restitution,code_motif_de_restitution,
+				code_commission_interbancaire,code_commission_interbancaire,
+				motif_de_la_restitution,motif_de_la_restitution)
diff --git a/src/sd_msgmap_struct/src/sd_msgmap_struct.xml.m4 b/src/sd_msgmap_struct/src/sd_msgmap_struct.xml.m4
new file mode 100644
index 0000000..9a7ed38
--- /dev/null
+++ b/src/sd_msgmap_struct/src/sd_msgmap_struct.xml.m4
@@ -0,0 +1,42 @@
+dnl
+divert(-1)
+include(`msgmap_commun.xml.m4')
+divert(0)dnl
+dnl
+changecom(`<!--', `-->')dnl
+dnl
+dnl
+header_msgmap()
+insert_version(@(#) VERSIONIMR: $Label:  $   $Date: 2008/11/12 02:25:24 $   $Workfile:   sd_msgmap_struct.xml.m4  $)
+include(`msgmap_fixed_fml.xml.m4')
+include(`msgmap_delimited_fixed.xml.m4')
+include(`field_13c.xml.m4')
+include(`field_50.xml.m4')
+include(`field_52.xml.m4')
+include(`field_55.xml.m4')
+include(`field_56.xml.m4')
+include(`field_57.xml.m4')
+include(`field_58.xml.m4')
+include(`field_59.xml.m4')
+include(`field_70.xml.m4')
+include(`field_72.xml.m4')
+include(`field_77.xml.m4')
+include(`or.xml.m4')
+include(`cre.xml.m4')
+include(`stlm.xml.m4')
+include(`cut_end_msg.xml.m4')
+include(`strip_end_msg.xml.m4')
+include(`cre_field_13c.xml.m4')
+include(`cre_field_50.xml.m4')
+include(`cre_field_52.xml.m4')
+include(`cre_field_55.xml.m4')
+include(`cre_field_56.xml.m4')
+include(`cre_field_57.xml.m4')
+include(`cre_field_58.xml.m4')
+include(`cre_field_59.xml.m4')
+include(`cre_field_70.xml.m4')
+include(`cre_field_72.xml.m4')
+include(`cre_field_77.xml.m4')
+include(`cre_or.xml.m4')
+include(`cre_stlm.xml.m4')
+footer_msgmap()
diff --git a/src/sd_msgmap_struct/src/stlm.xml.m4 b/src/sd_msgmap_struct/src/stlm.xml.m4
new file mode 100644
index 0000000..64a8f57
--- /dev/null
+++ b/src/sd_msgmap_struct/src/stlm.xml.m4
@@ -0,0 +1,148 @@
+<!-- extraction des donnees d'un virement (a partir d'un flux destine a cristal) fixed -> fixed -->
+msgmap_object(crt_flux_stlm-crt_flux_stlm-extract_stlm_from_flux,crt_flux_stlm,crt_flux_stlm,
+				settlement_in_flux,settlement)
+<!-- insertion des donnees d'un virement dans un flux destine a cristal fixed -> fixed -->
+msgmap_object(crt_flux_stlm-crt_flux_stlm-insert_stlm_in_flux,crt_flux_stlm,crt_flux_stlm,
+				settlement,settlement_in_flux)
+<!-- extraction des donnees d'un virement (a partir d'un CRE sur vgm/or emis) fixed -> fixed -->
+msgmap_object(crt_flux_stlm-crt_flux_stlm-extract_stlm_emis_from_cre,crt_flux_stlm,crt_flux_stlm,
+				settlement_emis_in_cre,settlement)
+<!-- insertion des donnees d'un virement dans un CRE sur vgm/or emis fixed -> fixed -->
+msgmap_object(crt_flux_stlm-crt_flux_stlm-insert_stlm_emis_in_cre,crt_flux_stlm,crt_flux_stlm,
+				settlement,settlement_emis_in_cre)
+<!-- extraction des donnees d'un virement (a partir d'un CRE sur vgm/or recu) fixed -> fixed -->
+msgmap_object(crt_flux_stlm-crt_flux_stlm-extract_stlm_recu_from_cre,crt_flux_stlm,crt_flux_stlm,
+				settlement_recu_in_cre,settlement)
+<!-- insertion des donnees d'un virement dans un CRE sur vgm/or recu fixed -> fixed -->
+msgmap_object(crt_flux_stlm-crt_flux_stlm-insert_stlm_recu_in_cre,crt_flux_stlm,crt_flux_stlm,
+				settlement,settlement_recu_in_cre)
+<!-- insertion des donnees d'un virement dans un CRE de rejet -> fixed -->
+msgmap_object(crt_flux_stlm-crt_flux_stlm-insert_stlm_in_cre_rejet,crt_flux_stlm,crt_flux_stlm,
+				settlement,settlement_in_cre_rejet)
+<!-- extraction des donnees d'un flux complet a partir d'un cre de rejet CR40 fixed -> fixed -->
+msgmap_object(crt_flux_cre-crt_flux_cre-extract_flux_from_cre,crt_flux_cre,crt_flux_cre,
+				flux_complet_in_cre,flux_complet)
+<!-- insertion des donnees d'un flux complet dans un cre de rejet CR40 fixed -> fixed -->
+msgmap_object(crt_flux_cre-crt_flux_cre-insert_flux_in_cre,crt_flux_cre,crt_flux_cre,
+				flux_complet,flux_complet_in_cre)
+<!-- donnees du bloc56 au bloc 77 dans virement de clientele -->
+<!-- extraction de ces donnees du virement de clientele fixed -> fixed -->
+msgmap_object(crt_flux_stlm_cus_56_a_77-crt_flux_stlm_cus_56_a_77-sans55-extract,crt_flux_stlm_cus_56_a_77,crt_flux_stlm_cus_56_a_77,
+				cus_block2_sans55,cus_block2)
+msgmap_object(crt_flux_stlm_cus_56_a_77-crt_flux_stlm_cus_56_a_77-avec55-extract,crt_flux_stlm_cus_56_a_77,crt_flux_stlm_cus_56_a_77,
+				cus_block2_avec55,cus_block2)
+<!-- insertion de ces donnees dans le virement de clientele fixed -> fixed -->
+msgmap_object(crt_flux_stlm_cus_56_a_77-crt_flux_stlm_cus_56_a_77-sans55-insert,crt_flux_stlm_cus_56_a_77,crt_flux_stlm_cus_56_a_77,
+				cus_block2,cus_block2_sans55)
+msgmap_object(crt_flux_stlm_cus_56_a_77-crt_flux_stlm_cus_56_a_77-avec55-insert,crt_flux_stlm_cus_56_a_77,crt_flux_stlm_cus_56_a_77,
+				cus_block2,cus_block2_avec55)
+<!-- mapping de l'entete communs des flux destines a cristal fixed <-> xml -->
+msgmap_object(crt_flux_header-crt_flux_header,crt_flux_header,crt_flux_header,
+				code_banque_ctrl,code_banque_ctrl,
+				type_flux,type_flux,
+				code_util,code_util,
+				code_guichet_pf_p,code_guichet_pf_p,
+				authentification,authentification,
+				num_fichier,num_fichier,
+				responsable,responsable,
+				commentaire,commentaire,
+				r1,r1,
+				r2,r2,
+				r3,r3,
+				r4,r4,
+				service_desti,service_desti,
+				service_desti_initial,service_desti_initial,
+				canal_final,canal_final,
+				bic_cri_recep,bic_cri_recep,
+				code_pays_desti,code_pays_desti,
+				ident_acteur,ident_acteur,
+				code_siege_emet,code_siege_emet,
+				ref_denotage,ref_denotage,
+				code_appli_routage,code_appli_routage,
+				code_siege_routage,code_siege_routage,
+				ref_unique_interne,ref_unique_interne,
+				ident_pdse,ident_pdse,
+				nature_operation,nature_operation)
+<!-- mapping des champs (non definis en xml) de l'entete communs des flux destines a cristal -->
+msgmap_object(crt_flux_header-crt_flux_header-special_fixed,crt_flux_header,crt_flux_header,
+				heure_debit_rtgs_emet,heure_debit_rtgs_emet,
+				heure_ech_cls,heure_ech_cls,
+				zone_reservee,zone_reservee)
+<!-- mapping de l'entete des virements fixed <-> xml -->
+msgmap_object(crt_flux_stlm_header-crt_flux_stlm_header,crt_flux_stlm_header,crt_flux_stlm_header,
+				ref_util,ref_util,
+				ind_ann_gen,ind_ann_gen,
+				ref_ann,ref_ann,
+				type_ann,type_ann,
+				ref_ann_init,ref_ann_init,
+				code_acc_int,code_acc_int,
+				bic_emetteur,bic_emetteur,
+				bic_recepteur,bic_recepteur,
+				ident_bq_desti,ident_bq_desti,
+				bic_bq_desti,bic_bq_desti,
+				priorite_reseau,priorite_reseau,
+				canal_de_routage,canal_de_routage,
+				heure_d_echeance_champ_113,heure_d_echeance_champ_113,
+				heure_emission_tot,heure_emission_tot,
+				heure_emission_tard,heure_emission_tard)
+<!-- mapping virement bancaire (hors bloc 13c 52 56 57 58 72) fixed <-> xml -->
+			<!-- A VOIR xml sans fixed
+			<fieldmap>
+				<inputfield>reference_emetteur_flux</inputfield>
+				<outputfield>reference_emetteur_flux</outputfield>
+			</fieldmap>
+			-->
+msgmap_object(crt_flux_stlm_bk-crt_flux_stlm_bk,crt_flux_stlm_bk,crt_flux_stlm_bk,
+				reference_d_origine,reference_d_origine,
+				date_de_reglement,date_de_reglement,
+				devise,devise,
+				montant,montant,
+				no_ccr_emet_rib_emet_ou_compte_cor,no_ccr_emet_rib_emet_ou_compte_cor,
+				ccr_recepteur,ccr_recepteur)
+<!-- mapping virement de clientele jusqu'au bloc 56 (hors bloc 50 52 et 55) fixed <-> xml -->
+			<!-- A VOIR xml sans fixed
+			<fieldmap>
+				<inputfield>reference_emetteur_flux</inputfield>
+				<outputfield>reference_emetteur_flux</outputfield>
+			</fieldmap>
+			-->
+msgmap_object(crt_flux_stlm_cus-crt_flux_stlm_cus,crt_flux_stlm_cus,crt_flux_stlm_cus,
+				23b_code_operation,23b_code_operation,
+				23e_code_instruction01,23e_code_instruction01,
+				23e_code_instruction02,23e_code_instruction02,
+				23e_code_instruction03,23e_code_instruction03,
+				23e_code_instruction04,23e_code_instruction04,
+				23e_code_instruction05,23e_code_instruction05,
+				23e_code_instruction06,23e_code_instruction06,
+				23e_code_instruction07,23e_code_instruction07,
+				23e_code_instruction08,23e_code_instruction08,
+				23e_code_instruction09,23e_code_instruction09,
+				23e_code_instruction10,23e_code_instruction10,
+				26t_code_type_de_transaction,26t_code_type_de_transaction,
+				date_de_reglement,date_de_reglement,
+				devise,devise,
+				montant,montant,
+				33b_devise_de_instruction,33b_devise_de_instruction,
+				33b_montant_de_instruction,33b_montant_de_instruction,
+				36_taux_de_conversion,36_taux_de_conversion,
+				53a_compte,53a_compte,
+				53a_complements,53a_complements,
+				53a_format,53a_format,
+				54a_compte,54a_compte,
+				54a_complements,54a_complements,
+				54a_format,54a_format)
+<!-- mapping virement de clientele du bloc 56 au bloc 77 (hors bloc 56 57 59 70 72 77) fixed <-> xml -->
+msgmap_object(crt_flux_stlm_cus_end-crt_flux_stlm_cus_end,crt_flux_stlm_cus_end,crt_flux_stlm_cus_end,
+				71a_repartition_des_frais,71a_repartition_des_frais,
+				71f_frais_emet01_devise,71f_frais_emet01_devise,
+				71f_frais_emet01_montant,71f_frais_emet01_montant,
+				71f_frais_emet02_devise,71f_frais_emet02_devise,
+				71f_frais_emet02_montant,71f_frais_emet02_montant,
+				71f_frais_emet03_devise,71f_frais_emet03_devise,
+				71f_frais_emet03_montant,71f_frais_emet03_montant,
+				71f_frais_emet04_devise,71f_frais_emet04_devise,
+				71f_frais_emet04_montant,71f_frais_emet04_montant,
+				71f_frais_emet05_devise,71f_frais_emet05_devise,
+				71f_frais_emet05_montant,71f_frais_emet05_montant,
+				71g_frais_recept_devise,71g_frais_recept_devise,
+				71g_frais_recept_montant,71g_frais_recept_montant)
diff --git a/src/sd_msgmap_struct/src/strip_end_msg.xml.m4 b/src/sd_msgmap_struct/src/strip_end_msg.xml.m4
new file mode 100644
index 0000000..9c89e42
--- /dev/null
+++ b/src/sd_msgmap_struct/src/strip_end_msg.xml.m4
@@ -0,0 +1,3 @@
+<!-- suppression des dernier caracteres blancs d'un virement   fixed -> fixed -->
+msgmap_object(strip_end_msg-strip_end_msg,strip_end_msg,strip_end_msg,
+				strip_end_fld,strip_end_fld)
diff --git a/tst/in-1.txt.bz2 b/tst/in-1.txt.bz2
new file mode 100644
index 0000000..532ecad
Binary files /dev/null and b/tst/in-1.txt.bz2 differ
diff --git a/tst/in-10k.txt.bz2 b/tst/in-10k.txt.bz2
new file mode 100644
index 0000000..78cc02b
Binary files /dev/null and b/tst/in-10k.txt.bz2 differ
diff --git a/tst/in-1k.txt.bz2 b/tst/in-1k.txt.bz2
new file mode 100644
index 0000000..6a4676b
Binary files /dev/null and b/tst/in-1k.txt.bz2 differ
diff --git a/tst/in-50k.txt.bz2 b/tst/in-50k.txt.bz2
new file mode 100644
index 0000000..fd9a6dc
Binary files /dev/null and b/tst/in-50k.txt.bz2 differ